ffmpeg.c

   1 /*
   2  * FFmpeg main
   3  * Copyright (c) 2000-2003 Fabrice Bellard
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "config.h"
  23 #include <ctype.h>
  24 #include <string.h>
  25 #include <math.h>
  26 #include <stdlib.h>
  27 #include <errno.h>
  28 #include <signal.h>
  29 #include <limits.h>
  30 #include "libavformat/avformat.h"
  31 #include "libavdevice/avdevice.h"
  32 #include "libswscale/swscale.h"
  33 #include "libavformat/framehook.h"
  34 #include "libavcodec/opt.h"
  35 #include "libavcodec/audioconvert.h"
  36 #include "libavutil/fifo.h"
  37 #include "libavutil/avstring.h"
  38 #include "libavformat/os_support.h"
  39
  40 #ifdef HAVE_SYS_RESOURCE_H
  41 #include <sys/types.h>
  42 #include <sys/resource.h>
  43 #elif defined(HAVE_GETPROCESSTIMES)
  44 #include <windows.h>
  45 #endif
  46
  47 #if defined(HAVE_TERMIOS_H)
  48 #include <unistd.h>
  49 #include <fcntl.h>
  50 #include <sys/ioctl.h>
  51 #include <sys/time.h>
  52 #include <termios.h>
  53 #elif defined(HAVE_CONIO_H)
  54 #include <conio.h>
  55 #endif
  56 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
  57 #include <time.h>
  58
  59 #include "cmdutils.h"
  60
  61 #undef NDEBUG
  62 #include <assert.h>
  63
  64 #undef exit
  65
  66 const char program_name[] = "FFmpeg";
  67 const int program_birth_year = 2000;
  68
  69 /* select an input stream for an output stream */
  70 typedef struct AVStreamMap {
  71     int file_index;
  72     int stream_index;
  73     int sync_file_index;
  74     int sync_stream_index;
  75 } AVStreamMap;
  76
  77 /** select an input file for an output file */
  78 typedef struct AVMetaDataMap {
  79     int out_file;
  80     int in_file;
  81 } AVMetaDataMap;
  82
  83 static const OptionDef options[];
  84
  85 #define MAX_FILES 20
  86
  87 static AVFormatContext *input_files[MAX_FILES];
  88 static int64_t input_files_ts_offset[MAX_FILES];
  89 static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
  90 static int nb_input_files = 0;
  91
  92 static AVFormatContext *output_files[MAX_FILES];
  93 static int nb_output_files = 0;
  94
  95 static AVStreamMap stream_maps[MAX_FILES];
  96 static int nb_stream_maps;
  97
  98 static AVMetaDataMap meta_data_maps[MAX_FILES];
  99 static int nb_meta_data_maps;
 100
 101 static AVInputFormat *file_iformat;
 102 static AVOutputFormat *file_oformat;
 103 static int frame_width  = 0;
 104 static int frame_height = 0;
 105 static float frame_aspect_ratio = 0;
 106 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
 107 static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
 108 static int frame_padtop  = 0;
 109 static int frame_padbottom = 0;
 110 static int frame_padleft  = 0;
 111 static int frame_padright = 0;
 112 static int padcolor[3] = {16,128,128}; /* default to black */
 113 static int frame_topBand  = 0;
 114 static int frame_bottomBand = 0;
 115 static int frame_leftBand  = 0;
 116 static int frame_rightBand = 0;
 117 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
 118 static AVRational frame_rate;
 119 static float video_qscale = 0;
 120 static uint16_t *intra_matrix = NULL;
 121 static uint16_t *inter_matrix = NULL;
 122 #if 0 //experimental, (can be removed)
 123 static float video_rc_qsquish=1.0;
 124 static float video_rc_qmod_amp=0;
 125 static int video_rc_qmod_freq=0;
 126 #endif
 127 static const char *video_rc_override_string=NULL;
 128 static int video_disable = 0;
 129 static int video_discard = 0;
 130 static char *video_codec_name = NULL;
 131 static int video_codec_tag = 0;
 132 static int same_quality = 0;
 133 static int do_deinterlace = 0;
 134 static int top_field_first = -1;
 135 static int me_threshold = 0;
 136 static int intra_dc_precision = 8;
 137 static int loop_input = 0;
 138 static int loop_output = AVFMT_NOOUTPUTLOOP;
 139 static int qp_hist = 0;
 140
 141 static int intra_only = 0;
 142 static int audio_sample_rate = 44100;
 143 #define QSCALE_NONE -99999
 144 static float audio_qscale = QSCALE_NONE;
 145 static int audio_disable = 0;
 146 static int audio_channels = 1;
 147 static char  *audio_codec_name = NULL;
 148 static int audio_codec_tag = 0;
 149 static char *audio_language = NULL;
 150
 151 static int subtitle_disable = 0;
 152 static char *subtitle_codec_name = NULL;
 153 static char *subtitle_language = NULL;
 154
 155 static float mux_preload= 0.5;
 156 static float mux_max_delay= 0.7;
 157
 158 static int64_t recording_time = INT64_MAX;
 159 static int64_t start_time = 0;
 160 static int64_t rec_timestamp = 0;
 161 static int64_t input_ts_offset = 0;
 162 static int file_overwrite = 0;
 163 static char *str_title = NULL;
 164 static char *str_author = NULL;
 165 static char *str_copyright = NULL;
 166 static char *str_comment = NULL;
 167 static char *str_genre = NULL;
 168 static char *str_album = NULL;
 169 static int do_benchmark = 0;
 170 static int do_hex_dump = 0;
 171 static int do_pkt_dump = 0;
 172 static int do_psnr = 0;
 173 static int do_pass = 0;
 174 static char *pass_logfilename = NULL;
 175 static int audio_stream_copy = 0;
 176 static int video_stream_copy = 0;
 177 static int subtitle_stream_copy = 0;
 178 static int video_sync_method= -1;
 179 static int audio_sync_method= 0;
 180 static float audio_drift_threshold= 0.1;
 181 static int copy_ts= 0;
 182 static int opt_shortest = 0; //
 183 static int video_global_header = 0;
 184 static char *vstats_filename;
 185 static FILE *vstats_file;
 186 static int opt_programid = 0;
 187
 188 static int rate_emu = 0;
 189
 190 static int  video_channel = 0;
 191 static char *video_standard;
 192
 193 static int audio_volume = 256;
 194
 195 static int using_stdin = 0;
 196 static int using_vhook = 0;
 197 static int verbose = 1;
 198 static int thread_count= 1;
 199 static int q_pressed = 0;
 200 static int64_t video_size = 0;
 201 static int64_t audio_size = 0;
 202 static int64_t extra_size = 0;
 203 static int nb_frames_dup = 0;
 204 static int nb_frames_drop = 0;
 205 static int input_sync;
 206 static uint64_t limit_filesize = 0; //
 207
 208 static int pgmyuv_compatibility_hack=0;
 209 static float dts_delta_threshold = 10;
 210
 211 static unsigned int sws_flags = SWS_BICUBIC;
 212
 213 static const char **opt_names;
 214 static int opt_name_count;
 215 static AVCodecContext *avctx_opts[CODEC_TYPE_NB];
 216 static AVFormatContext *avformat_opts;
 217 static struct SwsContext *sws_opts;
 218 static int64_t timer_start;
 219
 220 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
 221 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
 222 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
 223 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
 224
 225 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
 226
 227 struct AVInputStream;
 228
 229 typedef struct AVOutputStream {
 230     int file_index;          /* file index */
 231     int index;               /* stream index in the output file */
 232     int source_index;        /* AVInputStream index */
 233     AVStream *st;            /* stream in the output file */
 234     int encoding_needed;     /* true if encoding needed for this stream */
 235     int frame_number;
 236     /* input pts and corresponding output pts
 237        for A/V sync */
 238     //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
 239     struct AVInputStream *sync_ist; /* input stream to sync against */
 240     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
 241     /* video only */
 242     int video_resample;
 243     AVFrame pict_tmp;      /* temporary image for resampling */
 244     struct SwsContext *img_resample_ctx; /* for image resampling */
 245     int resample_height;
 246
 247     int video_crop;
 248     int topBand;             /* cropping area sizes */
 249     int leftBand;
 250
 251     int video_pad;
 252     int padtop;              /* padding area sizes */
 253     int padbottom;
 254     int padleft;
 255     int padright;
 256
 257     /* audio only */
 258     int audio_resample;
 259     ReSampleContext *resample; /* for audio resampling */
 260     AVFifoBuffer fifo;     /* for compression: one audio fifo per codec */
 261     FILE *logfile;
 262 } AVOutputStream;
 263
 264 typedef struct AVInputStream {
 265     int file_index;
 266     int index;
 267     AVStream *st;
 268     int discard;             /* true if stream data should be discarded */
 269     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
 270     int64_t sample_index;      /* current sample */
 271
 272     int64_t       start;     /* time when read started */
 273     unsigned long frame;     /* current frame */
 274     int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
 275                                 is not defined */
 276     int64_t       pts;       /* current pts */
 277     int is_start;            /* is 1 at the start and after a discontinuity */
 278 } AVInputStream;
 279
 280 typedef struct AVInputFile {
 281     int eof_reached;      /* true if eof reached */
 282     int ist_index;        /* index of first stream in ist_table */
 283     int buffer_size;      /* current total buffer size */
 284     int nb_streams;       /* nb streams we are aware of */
 285 } AVInputFile;
 286
 287 #ifdef HAVE_TERMIOS_H
 288
 289 /* init terminal so that we can grab keys */
 290 static struct termios oldtty;
 291 #endif
 292
 293 static void term_exit(void)
 294 {
 295 #ifdef HAVE_TERMIOS_H
 296     tcsetattr (0, TCSANOW, &oldtty);
 297 #endif
 298 }
 299
 300 static volatile sig_atomic_t received_sigterm = 0;
 301
 302 static void
 303 sigterm_handler(int sig)
 304 {
 305     received_sigterm = sig;
 306     term_exit();
 307 }
 308
 309 static void term_init(void)
 310 {
 311 #ifdef HAVE_TERMIOS_H
 312     struct termios tty;
 313
 314     tcgetattr (0, &tty);
 315     oldtty = tty;
 316
 317     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 318                           |INLCR|IGNCR|ICRNL|IXON);
 319     tty.c_oflag |= OPOST;
 320     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
 321     tty.c_cflag &= ~(CSIZE|PARENB);
 322     tty.c_cflag |= CS8;
 323     tty.c_cc[VMIN] = 1;
 324     tty.c_cc[VTIME] = 0;
 325
 326     tcsetattr (0, TCSANOW, &tty);
 327     signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
 328 #endif
 329
 330     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
 331     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
 332     /*
 333     register a function to be called at normal program termination
 334     */
 335     atexit(term_exit);
 336 #ifdef CONFIG_BEOS_NETSERVER
 337     fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
 338 #endif
 339 }
 340
 341 /* read a key without blocking */
 342 static int read_key(void)
 343 {
 344 #if defined(HAVE_TERMIOS_H)
 345     int n = 1;
 346     unsigned char ch;
 347 #ifndef CONFIG_BEOS_NETSERVER
 348     struct timeval tv;
 349     fd_set rfds;
 350
 351     FD_ZERO(&rfds);
 352     FD_SET(0, &rfds);
 353     tv.tv_sec = 0;
 354     tv.tv_usec = 0;
 355     n = select(1, &rfds, NULL, NULL, &tv);
 356 #endif
 357     if (n > 0) {
 358         n = read(0, &ch, 1);
 359         if (n == 1)
 360             return ch;
 361
 362         return n;
 363     }
 364 #elif defined(HAVE_CONIO_H)
 365     if(kbhit())
 366         return(getch());
 367 #endif
 368     return -1;
 369 }
 370
 371 static int decode_interrupt_cb(void)
 372 {
 373     return q_pressed || (q_pressed = read_key() == 'q');
 374 }
 375
 376 static int av_exit(int ret)
 377 {
 378     int i;
 379
 380     /* close files */
 381     for(i=0;i<nb_output_files;i++) {
 382         /* maybe av_close_output_file ??? */
 383         AVFormatContext *s = output_files[i];
 384         int j;
 385         if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
 386             url_fclose(s->pb);
 387         for(j=0;j<s->nb_streams;j++) {
 388             av_free(s->streams[j]->codec);
 389             av_free(s->streams[j]);
 390         }
 391         av_free(s);
 392     }
 393     for(i=0;i<nb_input_files;i++)
 394         av_close_input_file(input_files[i]);
 395
 396     av_free(intra_matrix);
 397     av_free(inter_matrix);
 398
 399     if (vstats_file)
 400         fclose(vstats_file);
 401     av_free(vstats_filename);
 402
 403     av_free(opt_names);
 404
 405     av_free(video_codec_name);
 406     av_free(audio_codec_name);
 407     av_free(subtitle_codec_name);
 408
 409     av_free(video_standard);
 410
 411 #ifdef CONFIG_POWERPC_PERF
 412     extern void powerpc_display_perf_report(void);
 413     powerpc_display_perf_report();
 414 #endif /* CONFIG_POWERPC_PERF */
 415
 416     if (received_sigterm) {
 417         fprintf(stderr,
 418             "Received signal %d: terminating.\n",
 419             (int) received_sigterm);
 420         exit (255);
 421     }
 422
 423     exit(ret); /* not all OS-es handle main() return value */
 424     return ret;
 425 }
 426
 427 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
 428 {
 429     int i, err;
 430     AVFormatContext *ic;
 431     int nopts = 0;
 432
 433     err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
 434     if (err < 0)
 435         return err;
 436     /* copy stream format */
 437     s->nb_streams = ic->nb_streams;
 438     for(i=0;i<ic->nb_streams;i++) {
 439         AVStream *st;
 440
 441         // FIXME: a more elegant solution is needed
 442         st = av_mallocz(sizeof(AVStream));
 443         memcpy(st, ic->streams[i], sizeof(AVStream));
 444         st->codec = avcodec_alloc_context();
 445         memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
 446         s->streams[i] = st;
 447
 448         if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
 449             st->stream_copy = 1;
 450         else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
 451             st->stream_copy = 1;
 452
 453         if(!st->codec->thread_count)
 454             st->codec->thread_count = 1;
 455         if(st->codec->thread_count>1)
 456             avcodec_thread_init(st->codec, st->codec->thread_count);
 457
 458         if(st->codec->flags & CODEC_FLAG_BITEXACT)
 459             nopts = 1;
 460     }
 461
 462     if (!nopts)
 463         s->timestamp = av_gettime();
 464
 465     av_close_input_file(ic);
 466     return 0;
 467 }
 468
 469 static double
 470 get_sync_ipts(const AVOutputStream *ost)
 471 {
 472     const AVInputStream *ist = ost->sync_ist;
 473     return (double)(ist->pts - start_time)/AV_TIME_BASE;
 474 }
 475
 476 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
 477     int ret;
 478
 479     while(bsfc){
 480         AVPacket new_pkt= *pkt;
 481         int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
 482                                           &new_pkt.data, &new_pkt.size,
 483                                           pkt->data, pkt->size,
 484                                           pkt->flags & PKT_FLAG_KEY);
 485         if(a>0){
 486             av_free_packet(pkt);
 487             new_pkt.destruct= av_destruct_packet;
 488         } else if(a<0){
 489             fprintf(stderr, "%s failed for stream %d, codec %s",
 490                     bsfc->filter->name, pkt->stream_index,
 491                     avctx->codec ? avctx->codec->name : "copy");
 492             print_error("", a);
 493         }
 494         *pkt= new_pkt;
 495
 496         bsfc= bsfc->next;
 497     }
 498
 499     ret= av_interleaved_write_frame(s, pkt);
 500     if(ret < 0){
 501         print_error("av_interleaved_write_frame()", ret);
 502         av_exit(1);
 503     }
 504 }
 505
 506 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
 507
 508 static void do_audio_out(AVFormatContext *s,
 509                          AVOutputStream *ost,
 510                          AVInputStream *ist,
 511                          unsigned char *buf, int size)
 512 {
 513     uint8_t *buftmp;
 514     static uint8_t *audio_buf = NULL;
 515     static uint8_t *audio_out = NULL;
 516     const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
 517
 518     int size_out, frame_bytes, ret;
 519     AVCodecContext *enc= ost->st->codec;
 520     AVCodecContext *dec= ist->st->codec;
 521
 522     /* SC: dynamic allocation of buffers */
 523     if (!audio_buf)
 524         audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
 525     if (!audio_out)
 526         audio_out = av_malloc(audio_out_size);
 527     if (!audio_buf || !audio_out)
 528         return;               /* Should signal an error ! */
 529
 530     if (enc->channels != dec->channels)
 531         ost->audio_resample = 1;
 532
 533     if (ost->audio_resample && !ost->resample) {
 534         ost->resample = audio_resample_init(enc->channels,    dec->channels,
 535                                             enc->sample_rate, dec->sample_rate);
 536         if (!ost->resample) {
 537             fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
 538                     dec->channels, dec->sample_rate,
 539                     enc->channels, enc->sample_rate);
 540             av_exit(1);
 541         }
 542     }
 543
 544     if(audio_sync_method){
 545         double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
 546                 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
 547         double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
 548         int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
 549
 550         //FIXME resample delay
 551         if(fabs(delta) > 50){
 552             if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
 553                 if(byte_delta < 0){
 554                     byte_delta= FFMAX(byte_delta, -size);
 555                     size += byte_delta;
 556                     buf  -= byte_delta;
 557                     if(verbose > 2)
 558                         fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
 559                     if(!size)
 560                         return;
 561                     ist->is_start=0;
 562                 }else{
 563                     static uint8_t *input_tmp= NULL;
 564                     input_tmp= av_realloc(input_tmp, byte_delta + size);
 565
 566                     if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
 567                         ist->is_start=0;
 568                     else
 569                         byte_delta= MAX_AUDIO_PACKET_SIZE - size;
 570
 571                     memset(input_tmp, 0, byte_delta);
 572                     memcpy(input_tmp + byte_delta, buf, size);
 573                     buf= input_tmp;
 574                     size += byte_delta;
 575                     if(verbose > 2)
 576                         fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
 577                 }
 578             }else if(audio_sync_method>1){
 579                 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
 580                 assert(ost->audio_resample);
 581                 if(verbose > 2)
 582                     fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
 583 //                fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2));
 584                 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
 585             }
 586         }
 587     }else
 588         ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
 589                         - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
 590
 591     if (ost->audio_resample) {
 592         buftmp = audio_buf;
 593         size_out = audio_resample(ost->resample,
 594                                   (short *)buftmp, (short *)buf,
 595                                   size / (ist->st->codec->channels * 2));
 596         size_out = size_out * enc->channels * 2;
 597     } else {
 598         buftmp = buf;
 599         size_out = size;
 600     }
 601
 602     /* now encode as many frames as possible */
 603     if (enc->frame_size > 1) {
 604         /* output resampled raw samples */
 605         av_fifo_realloc(&ost->fifo, av_fifo_size(&ost->fifo) + size_out);
 606         av_fifo_generic_write(&ost->fifo, buftmp, size_out, NULL);
 607
 608         frame_bytes = enc->frame_size * 2 * enc->channels;
 609
 610         while (av_fifo_size(&ost->fifo) >= frame_bytes) {
 611             AVPacket pkt;
 612             av_init_packet(&pkt);
 613
 614             av_fifo_read(&ost->fifo, audio_buf, frame_bytes);
 615
 616             //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
 617
 618             ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
 619                                        (short *)audio_buf);
 620             audio_size += ret;
 621             pkt.stream_index= ost->index;
 622             pkt.data= audio_out;
 623             pkt.size= ret;
 624             if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
 625                 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
 626             pkt.flags |= PKT_FLAG_KEY;
 627             write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
 628
 629             ost->sync_opts += enc->frame_size;
 630         }
 631     } else {
 632         AVPacket pkt;
 633         av_init_packet(&pkt);
 634
 635         ost->sync_opts += size_out / (2 * enc->channels);
 636
 637         /* output a pcm frame */
 638         /* XXX: change encoding codec API to avoid this ? */
 639         switch(enc->codec->id) {
 640         case CODEC_ID_PCM_S32LE:
 641         case CODEC_ID_PCM_S32BE:
 642         case CODEC_ID_PCM_U32LE:
 643         case CODEC_ID_PCM_U32BE:
 644         case CODEC_ID_PCM_F32BE:
 645             size_out = size_out << 1;
 646             break;
 647         case CODEC_ID_PCM_S24LE:
 648         case CODEC_ID_PCM_S24BE:
 649         case CODEC_ID_PCM_U24LE:
 650         case CODEC_ID_PCM_U24BE:
 651         case CODEC_ID_PCM_S24DAUD:
 652             size_out = size_out / 2 * 3;
 653             break;
 654         case CODEC_ID_PCM_S16LE:
 655         case CODEC_ID_PCM_S16BE:
 656         case CODEC_ID_PCM_U16LE:
 657         case CODEC_ID_PCM_U16BE:
 658             break;
 659         default:
 660             size_out = size_out >> 1;
 661             break;
 662         }
 663         //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
 664         ret = avcodec_encode_audio(enc, audio_out, size_out,
 665                                    (short *)buftmp);
 666         audio_size += ret;
 667         pkt.stream_index= ost->index;
 668         pkt.data= audio_out;
 669         pkt.size= ret;
 670         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
 671             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
 672         pkt.flags |= PKT_FLAG_KEY;
 673         write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
 674     }
 675 }
 676
 677 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
 678 {
 679     AVCodecContext *dec;
 680     AVPicture *picture2;
 681     AVPicture picture_tmp;
 682     uint8_t *buf = 0;
 683
 684     dec = ist->st->codec;
 685
 686     /* deinterlace : must be done before any resize */
 687     if (do_deinterlace || using_vhook) {
 688         int size;
 689
 690         /* create temporary picture */
 691         size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
 692         buf = av_malloc(size);
 693         if (!buf)
 694             return;
 695
 696         picture2 = &picture_tmp;
 697         avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
 698
 699         if (do_deinterlace){
 700             if(avpicture_deinterlace(picture2, picture,
 701                                      dec->pix_fmt, dec->width, dec->height) < 0) {
 702                 /* if error, do not deinterlace */
 703                 av_free(buf);
 704                 buf = NULL;
 705                 picture2 = picture;
 706             }
 707         } else {
 708             av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
 709         }
 710     } else {
 711         picture2 = picture;
 712     }
 713
 714     if (ENABLE_VHOOK)
 715         frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
 716                            1000000 * ist->pts / AV_TIME_BASE);
 717
 718     if (picture != picture2)
 719         *picture = *picture2;
 720     *bufp = buf;
 721 }
 722
 723 /* we begin to correct av delay at this threshold */
 724 #define AV_DELAY_MAX 0.100
 725
 726 static void do_subtitle_out(AVFormatContext *s,
 727                             AVOutputStream *ost,
 728                             AVInputStream *ist,
 729                             AVSubtitle *sub,
 730                             int64_t pts)
 731 {
 732     static uint8_t *subtitle_out = NULL;
 733     int subtitle_out_max_size = 65536;
 734     int subtitle_out_size, nb, i;
 735     AVCodecContext *enc;
 736     AVPacket pkt;
 737
 738     if (pts == AV_NOPTS_VALUE) {
 739         fprintf(stderr, "Subtitle packets must have a pts\n");
 740         return;
 741     }
 742
 743     enc = ost->st->codec;
 744
 745     if (!subtitle_out) {
 746         subtitle_out = av_malloc(subtitle_out_max_size);
 747     }
 748
 749     /* Note: DVB subtitle need one packet to draw them and one other
 750        packet to clear them */
 751     /* XXX: signal it in the codec context ? */
 752     if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
 753         nb = 2;
 754     else
 755         nb = 1;
 756
 757     for(i = 0; i < nb; i++) {
 758         subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
 759                                                     subtitle_out_max_size, sub);
 760
 761         av_init_packet(&pkt);
 762         pkt.stream_index = ost->index;
 763         pkt.data = subtitle_out;
 764         pkt.size = subtitle_out_size;
 765         pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
 766         if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
 767             /* XXX: the pts correction is handled here. Maybe handling
 768                it in the codec would be better */
 769             if (i == 0)
 770                 pkt.pts += 90 * sub->start_display_time;
 771             else
 772                 pkt.pts += 90 * sub->end_display_time;
 773         }
 774         write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
 775     }
 776 }
 777
 778 static int bit_buffer_size= 1024*256;
 779 static uint8_t *bit_buffer= NULL;
 780
 781 static void do_video_out(AVFormatContext *s,
 782                          AVOutputStream *ost,
 783                          AVInputStream *ist,
 784                          AVFrame *in_picture,
 785                          int *frame_size)
 786 {
 787     int nb_frames, i, ret;
 788     AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
 789     AVFrame picture_crop_temp, picture_pad_temp;
 790     AVCodecContext *enc, *dec;
 791
 792     avcodec_get_frame_defaults(&picture_crop_temp);
 793     avcodec_get_frame_defaults(&picture_pad_temp);
 794
 795     enc = ost->st->codec;
 796     dec = ist->st->codec;
 797
 798     /* by default, we output a single frame */
 799     nb_frames = 1;
 800
 801     *frame_size = 0;
 802
 803     if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){
 804         double vdelta;
 805         vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
 806         //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
 807         if (vdelta < -1.1)
 808             nb_frames = 0;
 809         else if (video_sync_method == 2)
 810             ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
 811         else if (vdelta > 1.1)
 812             nb_frames = lrintf(vdelta);
 813 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
 814         if (nb_frames == 0){
 815             ++nb_frames_drop;
 816             if (verbose>2)
 817                 fprintf(stderr, "*** drop!\n");
 818         }else if (nb_frames > 1) {
 819             nb_frames_dup += nb_frames;
 820             if (verbose>2)
 821                 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
 822         }
 823     }else
 824         ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
 825
 826     nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
 827     if (nb_frames <= 0)
 828         return;
 829
 830     if (ost->video_crop) {
 831         if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
 832             av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
 833             return;
 834         }
 835         formatted_picture = &picture_crop_temp;
 836     } else {
 837         formatted_picture = in_picture;
 838     }
 839
 840     final_picture = formatted_picture;
 841     padding_src = formatted_picture;
 842     resampling_dst = &ost->pict_tmp;
 843     if (ost->video_pad) {
 844         final_picture = &ost->pict_tmp;
 845         if (ost->video_resample) {
 846             if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
 847                 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
 848                 return;
 849             }
 850             resampling_dst = &picture_pad_temp;
 851         }
 852     }
 853
 854     if (ost->video_resample) {
 855         padding_src = NULL;
 856         final_picture = &ost->pict_tmp;
 857         sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
 858               0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
 859     }
 860
 861     if (ost->video_pad) {
 862         av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
 863                 enc->height, enc->width, enc->pix_fmt,
 864                 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
 865     }
 866
 867     /* duplicates frame if needed */
 868     for(i=0;i<nb_frames;i++) {
 869         AVPacket pkt;
 870         av_init_packet(&pkt);
 871         pkt.stream_index= ost->index;
 872
 873         if (s->oformat->flags & AVFMT_RAWPICTURE) {
 874             /* raw pictures are written as AVPicture structure to
 875                avoid any copies. We support temorarily the older
 876                method. */
 877             AVFrame* old_frame = enc->coded_frame;
 878             enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
 879             pkt.data= (uint8_t *)final_picture;
 880             pkt.size=  sizeof(AVPicture);
 881             pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
 882             pkt.flags |= PKT_FLAG_KEY;
 883
 884             write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
 885             enc->coded_frame = old_frame;
 886         } else {
 887             AVFrame big_picture;
 888
 889             big_picture= *final_picture;
 890             /* better than nothing: use input picture interlaced
 891                settings */
 892             big_picture.interlaced_frame = in_picture->interlaced_frame;
 893             if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
 894                 if(top_field_first == -1)
 895                     big_picture.top_field_first = in_picture->top_field_first;
 896                 else
 897                     big_picture.top_field_first = top_field_first;
 898             }
 899
 900             /* handles sameq here. This is not correct because it may
 901                not be a global option */
 902             if (same_quality) {
 903                 big_picture.quality = ist->st->quality;
 904             }else
 905                 big_picture.quality = ost->st->quality;
 906             if(!me_threshold)
 907                 big_picture.pict_type = 0;
 908 //            big_picture.pts = AV_NOPTS_VALUE;
 909             big_picture.pts= ost->sync_opts;
 910 //            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
 911 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
 912             ret = avcodec_encode_video(enc,
 913                                        bit_buffer, bit_buffer_size,
 914                                        &big_picture);
 915             if (ret == -1) {
 916                 fprintf(stderr, "Video encoding failed\n");
 917                 av_exit(1);
 918             }
 919             //enc->frame_number = enc->real_pict_num;
 920             if(ret>0){
 921                 pkt.data= bit_buffer;
 922                 pkt.size= ret;
 923                 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
 924                     pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
 925 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
 926    pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
 927    pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
 928
 929                 if(enc->coded_frame->key_frame)
 930                     pkt.flags |= PKT_FLAG_KEY;
 931                 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
 932                 *frame_size = ret;
 933                 video_size += ret;
 934                 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
 935                 //        enc->frame_number-1, enc->real_pict_num, ret,
 936                 //        enc->pict_type);
 937                 /* if two pass, output log */
 938                 if (ost->logfile && enc->stats_out) {
 939                     fprintf(ost->logfile, "%s", enc->stats_out);
 940                 }
 941             }
 942         }
 943         ost->sync_opts++;
 944         ost->frame_number++;
 945     }
 946 }
 947
 948 static double psnr(double d){
 949     return -10.0*log(d)/log(10.0);
 950 }
 951
 952 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
 953                            int frame_size)
 954 {
 955     AVCodecContext *enc;
 956     int frame_number;
 957     double ti1, bitrate, avg_bitrate;
 958
 959     /* this is executed just the first time do_video_stats is called */
 960     if (!vstats_file) {
 961         vstats_file = fopen(vstats_filename, "w");
 962         if (!vstats_file) {
 963             perror("fopen");
 964             av_exit(1);
 965         }
 966     }
 967
 968     enc = ost->st->codec;
 969     if (enc->codec_type == CODEC_TYPE_VIDEO) {
 970         frame_number = ost->frame_number;
 971         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
 972         if (enc->flags&CODEC_FLAG_PSNR)
 973             fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
 974
 975         fprintf(vstats_file,"f_size= %6d ", frame_size);
 976         /* compute pts value */
 977         ti1 = ost->sync_opts * av_q2d(enc->time_base);
 978         if (ti1 < 0.01)
 979             ti1 = 0.01;
 980
 981         bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
 982         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
 983         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
 984             (double)video_size / 1024, ti1, bitrate, avg_bitrate);
 985         fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
 986     }
 987 }
 988
 989 static void print_report(AVFormatContext **output_files,
 990                          AVOutputStream **ost_table, int nb_ostreams,
 991                          int is_last_report)
 992 {
 993     char buf[1024];
 994     AVOutputStream *ost;
 995     AVFormatContext *oc, *os;
 996     int64_t total_size;
 997     AVCodecContext *enc;
 998     int frame_number, vid, i;
 999     double bitrate, ti1, pts;
1000     static int64_t last_time = -1;
1001     static int qp_histogram[52];
1002
1003     if (!is_last_report) {
1004         int64_t cur_time;
1005         /* display the report every 0.5 seconds */
1006         cur_time = av_gettime();
1007         if (last_time == -1) {
1008             last_time = cur_time;
1009             return;
1010         }
1011         if ((cur_time - last_time) < 500000)
1012             return;
1013         last_time = cur_time;
1014     }
1015
1016
1017     oc = output_files[0];
1018
1019     total_size = url_fsize(oc->pb);
1020     if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1021         total_size= url_ftell(oc->pb);
1022
1023     buf[0] = '\0';
1024     ti1 = 1e10;
1025     vid = 0;
1026     for(i=0;i<nb_ostreams;i++) {
1027         ost = ost_table[i];
1028         os = output_files[ost->file_index];
1029         enc = ost->st->codec;
1030         if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1031             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1032                      !ost->st->stream_copy ?
1033                      enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1034         }
1035         if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1036             float t = (av_gettime()-timer_start) / 1000000.0;
1037
1038             frame_number = ost->frame_number;
1039             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1040                      frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1041                      !ost->st->stream_copy ?
1042                      enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1043             if(is_last_report)
1044                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1045             if(qp_hist){
1046                 int j;
1047                 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1048                 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
1049                     qp_histogram[qp]++;
1050                 for(j=0; j<32; j++)
1051                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1052             }
1053             if (enc->flags&CODEC_FLAG_PSNR){
1054                 int j;
1055                 double error, error_sum=0;
1056                 double scale, scale_sum=0;
1057                 char type[3]= {'Y','U','V'};
1058                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1059                 for(j=0; j<3; j++){
1060                     if(is_last_report){
1061                         error= enc->error[j];
1062                         scale= enc->width*enc->height*255.0*255.0*frame_number;
1063                     }else{
1064                         error= enc->coded_frame->error[j];
1065                         scale= enc->width*enc->height*255.0*255.0;
1066                     }
1067                     if(j) scale/=4;
1068                     error_sum += error;
1069                     scale_sum += scale;
1070                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1071                 }
1072                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1073             }
1074             vid = 1;
1075         }
1076         /* compute min output value */
1077         pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1078         if ((pts < ti1) && (pts > 0))
1079             ti1 = pts;
1080     }
1081     if (ti1 < 0.01)
1082         ti1 = 0.01;
1083
1084     if (verbose || is_last_report) {
1085         bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1086
1087         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1088             "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1089             (double)total_size / 1024, ti1, bitrate);
1090
1091         if (verbose > 1)
1092           snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1093                   nb_frames_dup, nb_frames_drop);
1094
1095         if (verbose >= 0)
1096             fprintf(stderr, "%s    \r", buf);
1097
1098         fflush(stderr);
1099     }
1100
1101     if (is_last_report && verbose >= 0){
1102         int64_t raw= audio_size + video_size + extra_size;
1103         fprintf(stderr, "\n");
1104         fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1105                 video_size/1024.0,
1106                 audio_size/1024.0,
1107                 extra_size/1024.0,
1108                 100.0*(total_size - raw)/raw
1109         );
1110     }
1111 }
1112
1113 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1114 static int output_packet(AVInputStream *ist, int ist_index,
1115                          AVOutputStream **ost_table, int nb_ostreams,
1116                          const AVPacket *pkt)
1117 {
1118     AVFormatContext *os;
1119     AVOutputStream *ost;
1120     uint8_t *ptr;
1121     int len, ret, i;
1122     uint8_t *data_buf;
1123     int data_size, got_picture;
1124     AVFrame picture;
1125     void *buffer_to_free;
1126     static unsigned int samples_size= 0;
1127     static short *samples= NULL;
1128     AVSubtitle subtitle, *subtitle_to_free;
1129     int got_subtitle;
1130
1131     if(ist->next_pts == AV_NOPTS_VALUE)
1132         ist->next_pts= ist->pts;
1133
1134     if (pkt == NULL) {
1135         /* EOF handling */
1136         ptr = NULL;
1137         len = 0;
1138         goto handle_eof;
1139     }
1140
1141     if(pkt->dts != AV_NOPTS_VALUE)
1142         ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1143
1144     len = pkt->size;
1145     ptr = pkt->data;
1146
1147     //while we have more to decode or while the decoder did output something on EOF
1148     while (len > 0 || (!pkt && ist->next_pts != ist->pts)) {
1149     handle_eof:
1150         ist->pts= ist->next_pts;
1151
1152         if(len && len != pkt->size && verbose>0)
1153             fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1154
1155         /* decode the packet if needed */
1156         data_buf = NULL; /* fail safe */
1157         data_size = 0;
1158         subtitle_to_free = NULL;
1159         if (ist->decoding_needed) {
1160             switch(ist->st->codec->codec_type) {
1161             case CODEC_TYPE_AUDIO:{
1162                 if(pkt)
1163                     samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1164                 data_size= samples_size;
1165                     /* XXX: could avoid copy if PCM 16 bits with same
1166                        endianness as CPU */
1167                 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1168                                            ptr, len);
1169                 if (ret < 0)
1170                     goto fail_decode;
1171                 ptr += ret;
1172                 len -= ret;
1173                 /* Some bug in mpeg audio decoder gives */
1174                 /* data_size < 0, it seems they are overflows */
1175                 if (data_size <= 0) {
1176                     /* no audio frame */
1177                     continue;
1178                 }
1179                 data_buf = (uint8_t *)samples;
1180                 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1181                     (ist->st->codec->sample_rate * ist->st->codec->channels);
1182                 break;}
1183             case CODEC_TYPE_VIDEO:
1184                     data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1185                     /* XXX: allocate picture correctly */
1186                     avcodec_get_frame_defaults(&picture);
1187
1188                     ret = avcodec_decode_video(ist->st->codec,
1189                                                &picture, &got_picture, ptr, len);
1190                     ist->st->quality= picture.quality;
1191                     if (ret < 0)
1192                         goto fail_decode;
1193                     if (!got_picture) {
1194                         /* no picture yet */
1195                         goto discard_packet;
1196                     }
1197                     if (ist->st->codec->time_base.num != 0) {
1198                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1199                                           ist->st->codec->time_base.num) /
1200                             ist->st->codec->time_base.den;
1201                     }
1202                     len = 0;
1203                     break;
1204             case CODEC_TYPE_SUBTITLE:
1205                 ret = avcodec_decode_subtitle(ist->st->codec,
1206                                               &subtitle, &got_subtitle, ptr, len);
1207                 if (ret < 0)
1208                     goto fail_decode;
1209                 if (!got_subtitle) {
1210                     goto discard_packet;
1211                 }
1212                 subtitle_to_free = &subtitle;
1213                 len = 0;
1214                 break;
1215             default:
1216                 goto fail_decode;
1217             }
1218         } else {
1219             switch(ist->st->codec->codec_type) {
1220             case CODEC_TYPE_AUDIO:
1221                 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1222                     ist->st->codec->sample_rate;
1223                 break;
1224             case CODEC_TYPE_VIDEO:
1225                 if (ist->st->codec->time_base.num != 0) {
1226                     ist->next_pts += ((int64_t)AV_TIME_BASE *
1227                                       ist->st->codec->time_base.num) /
1228                         ist->st->codec->time_base.den;
1229                 }
1230                 break;
1231             }
1232             data_buf = ptr;
1233             data_size = len;
1234             ret = len;
1235             len = 0;
1236         }
1237
1238         buffer_to_free = NULL;
1239         if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1240             pre_process_video_frame(ist, (AVPicture *)&picture,
1241                                     &buffer_to_free);
1242         }
1243
1244         // preprocess audio (volume)
1245         if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1246             if (audio_volume != 256) {
1247                 short *volp;
1248                 volp = samples;
1249                 for(i=0;i<(data_size / sizeof(short));i++) {
1250                     int v = ((*volp) * audio_volume + 128) >> 8;
1251                     if (v < -32768) v = -32768;
1252                     if (v >  32767) v = 32767;
1253                     *volp++ = v;
1254                 }
1255             }
1256         }
1257
1258         /* frame rate emulation */
1259         if (ist->st->codec->rate_emu) {
1260             int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1261             int64_t now = av_gettime() - ist->start;
1262             if (pts > now)
1263                 usleep(pts - now);
1264
1265             ist->frame++;
1266         }
1267
1268 #if 0
1269         /* mpeg PTS deordering : if it is a P or I frame, the PTS
1270            is the one of the next displayed one */
1271         /* XXX: add mpeg4 too ? */
1272         if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1273             if (ist->st->codec->pict_type != B_TYPE) {
1274                 int64_t tmp;
1275                 tmp = ist->last_ip_pts;
1276                 ist->last_ip_pts  = ist->frac_pts.val;
1277                 ist->frac_pts.val = tmp;
1278             }
1279         }
1280 #endif
1281         /* if output time reached then transcode raw format,
1282            encode packets and output them */
1283         if (start_time == 0 || ist->pts >= start_time)
1284             for(i=0;i<nb_ostreams;i++) {
1285                 int frame_size;
1286
1287                 ost = ost_table[i];
1288                 if (ost->source_index == ist_index) {
1289                     os = output_files[ost->file_index];
1290
1291 #if 0
1292                     printf("%d: got pts=%0.3f %0.3f\n", i,
1293                            (double)pkt->pts / AV_TIME_BASE,
1294                            ((double)ist->pts / AV_TIME_BASE) -
1295                            ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1296 #endif
1297                     /* set the input output pts pairs */
1298                     //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1299
1300                     if (ost->encoding_needed) {
1301                         switch(ost->st->codec->codec_type) {
1302                         case CODEC_TYPE_AUDIO:
1303                             do_audio_out(os, ost, ist, data_buf, data_size);
1304                             break;
1305                         case CODEC_TYPE_VIDEO:
1306                             do_video_out(os, ost, ist, &picture, &frame_size);
1307                             if (vstats_filename && frame_size)
1308                                 do_video_stats(os, ost, frame_size);
1309                             break;
1310                         case CODEC_TYPE_SUBTITLE:
1311                             do_subtitle_out(os, ost, ist, &subtitle,
1312                                             pkt->pts);
1313                             break;
1314                         default:
1315                             abort();
1316                         }
1317                     } else {
1318                         AVFrame avframe; //FIXME/XXX remove this
1319                         AVPacket opkt;
1320                         av_init_packet(&opkt);
1321
1322                         if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1323                             continue;
1324
1325                         /* no reencoding needed : output the packet directly */
1326                         /* force the input stream PTS */
1327
1328                         avcodec_get_frame_defaults(&avframe);
1329                         ost->st->codec->coded_frame= &avframe;
1330                         avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1331
1332                         if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1333                             audio_size += data_size;
1334                         else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1335                             video_size += data_size;
1336                             ost->sync_opts++;
1337                         }
1338
1339                         opkt.stream_index= ost->index;
1340                         if(pkt->pts != AV_NOPTS_VALUE)
1341                             opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1342                         else
1343                             opkt.pts= AV_NOPTS_VALUE;
1344
1345                         if (pkt->dts == AV_NOPTS_VALUE)
1346                             opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1347                         else
1348                             opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1349
1350                         opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1351                         opkt.flags= pkt->flags;
1352
1353                         //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1354                         if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1355                             opkt.destruct= av_destruct_packet;
1356
1357                         write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1358                         ost->st->codec->frame_number++;
1359                         ost->frame_number++;
1360                         av_free_packet(&opkt);
1361                     }
1362                 }
1363             }
1364         av_free(buffer_to_free);
1365         /* XXX: allocate the subtitles in the codec ? */
1366         if (subtitle_to_free) {
1367             if (subtitle_to_free->rects != NULL) {
1368                 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1369                     av_free(subtitle_to_free->rects[i].bitmap);
1370                     av_free(subtitle_to_free->rects[i].rgba_palette);
1371                 }
1372                 av_freep(&subtitle_to_free->rects);
1373             }
1374             subtitle_to_free->num_rects = 0;
1375             subtitle_to_free = NULL;
1376         }
1377     }
1378  discard_packet:
1379     if (pkt == NULL) {
1380         /* EOF handling */
1381
1382         for(i=0;i<nb_ostreams;i++) {
1383             ost = ost_table[i];
1384             if (ost->source_index == ist_index) {
1385                 AVCodecContext *enc= ost->st->codec;
1386                 os = output_files[ost->file_index];
1387
1388                 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1389                     continue;
1390                 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1391                     continue;
1392
1393                 if (ost->encoding_needed) {
1394                     for(;;) {
1395                         AVPacket pkt;
1396                         int fifo_bytes;
1397                         av_init_packet(&pkt);
1398                         pkt.stream_index= ost->index;
1399
1400                         switch(ost->st->codec->codec_type) {
1401                         case CODEC_TYPE_AUDIO:
1402                             fifo_bytes = av_fifo_size(&ost->fifo);
1403                             ret = 0;
1404                             /* encode any samples remaining in fifo */
1405                             if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1406                                 int fs_tmp = enc->frame_size;
1407                                 enc->frame_size = fifo_bytes / (2 * enc->channels);
1408                                 av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes);
1409                                     ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1410                                 enc->frame_size = fs_tmp;
1411                             }
1412                             if(ret <= 0) {
1413                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1414                             }
1415                             audio_size += ret;
1416                             pkt.flags |= PKT_FLAG_KEY;
1417                             break;
1418                         case CODEC_TYPE_VIDEO:
1419                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1420                             video_size += ret;
1421                             if(enc->coded_frame && enc->coded_frame->key_frame)
1422                                 pkt.flags |= PKT_FLAG_KEY;
1423                             if (ost->logfile && enc->stats_out) {
1424                                 fprintf(ost->logfile, "%s", enc->stats_out);
1425                             }
1426                             break;
1427                         default:
1428                             ret=-1;
1429                         }
1430
1431                         if(ret<=0)
1432                             break;
1433                         pkt.data= bit_buffer;
1434                         pkt.size= ret;
1435                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1436                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1437                         write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1438                     }
1439                 }
1440             }
1441         }
1442     }
1443
1444     return 0;
1445  fail_decode:
1446     return -1;
1447 }
1448
1449 static void print_sdp(AVFormatContext **avc, int n)
1450 {
1451     char sdp[2048];
1452
1453     avf_sdp_create(avc, n, sdp, sizeof(sdp));
1454     printf("SDP:\n%s\n", sdp);
1455 }
1456
1457 static int stream_index_from_inputs(AVFormatContext **input_files,
1458                                     int nb_input_files,
1459                                     AVInputFile *file_table,
1460                                     AVInputStream **ist_table,
1461                                     enum CodecType type,
1462                                     int programid)
1463 {
1464     int p, q, z;
1465     for(z=0; z<nb_input_files; z++) {
1466         AVFormatContext *ic = input_files[z];
1467         for(p=0; p<ic->nb_programs; p++) {
1468             AVProgram *program = ic->programs[p];
1469             if(program->id != programid)
1470                 continue;
1471             for(q=0; q<program->nb_stream_indexes; q++) {
1472                 int sidx = program->stream_index[q];
1473                 int ris = file_table[z].ist_index + sidx;
1474                 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1475                     return ris;
1476             }
1477         }
1478     }
1479
1480     return -1;
1481 }
1482
1483 /*
1484  * The following code is the main loop of the file converter
1485  */
1486 static int av_encode(AVFormatContext **output_files,
1487                      int nb_output_files,
1488                      AVFormatContext **input_files,
1489                      int nb_input_files,
1490                      AVStreamMap *stream_maps, int nb_stream_maps)
1491 {
1492     int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1493     AVFormatContext *is, *os;
1494     AVCodecContext *codec, *icodec;
1495     AVOutputStream *ost, **ost_table = NULL;
1496     AVInputStream *ist, **ist_table = NULL;
1497     AVInputFile *file_table;
1498     int key;
1499     int want_sdp = 1;
1500
1501     file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1502     if (!file_table)
1503         goto fail;
1504
1505     /* input stream init */
1506     j = 0;
1507     for(i=0;i<nb_input_files;i++) {
1508         is = input_files[i];
1509         file_table[i].ist_index = j;
1510         file_table[i].nb_streams = is->nb_streams;
1511         j += is->nb_streams;
1512     }
1513     nb_istreams = j;
1514
1515     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1516     if (!ist_table)
1517         goto fail;
1518
1519     for(i=0;i<nb_istreams;i++) {
1520         ist = av_mallocz(sizeof(AVInputStream));
1521         if (!ist)
1522             goto fail;
1523         ist_table[i] = ist;
1524     }
1525     j = 0;
1526     for(i=0;i<nb_input_files;i++) {
1527         is = input_files[i];
1528         for(k=0;k<is->nb_streams;k++) {
1529             ist = ist_table[j++];
1530             ist->st = is->streams[k];
1531             ist->file_index = i;
1532             ist->index = k;
1533             ist->discard = 1; /* the stream is discarded by default
1534                                  (changed later) */
1535
1536             if (ist->st->codec->rate_emu) {
1537                 ist->start = av_gettime();
1538                 ist->frame = 0;
1539             }
1540         }
1541     }
1542
1543     /* output stream init */
1544     nb_ostreams = 0;
1545     for(i=0;i<nb_output_files;i++) {
1546         os = output_files[i];
1547         if (!os->nb_streams) {
1548             fprintf(stderr, "Output file does not contain any stream\n");
1549             av_exit(1);
1550         }
1551         nb_ostreams += os->nb_streams;
1552     }
1553     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1554         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1555         av_exit(1);
1556     }
1557
1558     /* Sanity check the mapping args -- do the input files & streams exist? */
1559     for(i=0;i<nb_stream_maps;i++) {
1560         int fi = stream_maps[i].file_index;
1561         int si = stream_maps[i].stream_index;
1562
1563         if (fi < 0 || fi > nb_input_files - 1 ||
1564             si < 0 || si > file_table[fi].nb_streams - 1) {
1565             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1566             av_exit(1);
1567         }
1568         fi = stream_maps[i].sync_file_index;
1569         si = stream_maps[i].sync_stream_index;
1570         if (fi < 0 || fi > nb_input_files - 1 ||
1571             si < 0 || si > file_table[fi].nb_streams - 1) {
1572             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1573             av_exit(1);
1574         }
1575     }
1576
1577     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1578     if (!ost_table)
1579         goto fail;
1580     for(i=0;i<nb_ostreams;i++) {
1581         ost = av_mallocz(sizeof(AVOutputStream));
1582         if (!ost)
1583             goto fail;
1584         ost_table[i] = ost;
1585     }
1586
1587     n = 0;
1588     for(k=0;k<nb_output_files;k++) {
1589         os = output_files[k];
1590         for(i=0;i<os->nb_streams;i++) {
1591             int found;
1592             ost = ost_table[n++];
1593             ost->file_index = k;
1594             ost->index = i;
1595             ost->st = os->streams[i];
1596             if (nb_stream_maps > 0) {
1597                 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1598                     stream_maps[n-1].stream_index;
1599
1600                 /* Sanity check that the stream types match */
1601                 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1602                     int i= ost->file_index;
1603                     dump_format(output_files[i], i, output_files[i]->filename, 1);
1604                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1605                         stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1606                         ost->file_index, ost->index);
1607                     av_exit(1);
1608                 }
1609
1610             } else {
1611                 if(opt_programid) {
1612                     found = 0;
1613                     j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1614                     if(j != -1) {
1615                         ost->source_index = j;
1616                         found = 1;
1617                     }
1618                 } else {
1619                     /* get corresponding input stream index : we select the first one with the right type */
1620                     found = 0;
1621                     for(j=0;j<nb_istreams;j++) {
1622                         ist = ist_table[j];
1623                         if (ist->discard &&
1624                             ist->st->codec->codec_type == ost->st->codec->codec_type) {
1625                             ost->source_index = j;
1626                             found = 1;
1627                             break;
1628                         }
1629                     }
1630                 }
1631
1632                 if (!found) {
1633                     if(! opt_programid) {
1634                         /* try again and reuse existing stream */
1635                         for(j=0;j<nb_istreams;j++) {
1636                             ist = ist_table[j];
1637                             if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1638                                 ost->source_index = j;
1639                                 found = 1;
1640                             }
1641                         }
1642                     }
1643                     if (!found) {
1644                         int i= ost->file_index;
1645                         dump_format(output_files[i], i, output_files[i]->filename, 1);
1646                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1647                                 ost->file_index, ost->index);
1648                         av_exit(1);
1649                     }
1650                 }
1651             }
1652             ist = ist_table[ost->source_index];
1653             ist->discard = 0;
1654             ost->sync_ist = (nb_stream_maps > 0) ?
1655                 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1656                          stream_maps[n-1].sync_stream_index] : ist;
1657         }
1658     }
1659
1660     /* for each output stream, we compute the right encoding parameters */
1661     for(i=0;i<nb_ostreams;i++) {
1662         ost = ost_table[i];
1663         os = output_files[ost->file_index];
1664         ist = ist_table[ost->source_index];
1665
1666         codec = ost->st->codec;
1667         icodec = ist->st->codec;
1668
1669         if (!ost->st->language[0])
1670             av_strlcpy(ost->st->language, ist->st->language,
1671                        sizeof(ost->st->language));
1672
1673         ost->st->disposition = ist->st->disposition;
1674
1675         if (ost->st->stream_copy) {
1676             /* if stream_copy is selected, no need to decode or encode */
1677             codec->codec_id = icodec->codec_id;
1678             codec->codec_type = icodec->codec_type;
1679
1680             if(!codec->codec_tag){
1681                 if(   !os->oformat->codec_tag
1682                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1683                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1684                     codec->codec_tag = icodec->codec_tag;
1685             }
1686
1687             codec->bit_rate = icodec->bit_rate;
1688             codec->extradata= icodec->extradata;
1689             codec->extradata_size= icodec->extradata_size;
1690             if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1691                 codec->time_base = icodec->time_base;
1692             else
1693                 codec->time_base = ist->st->time_base;
1694             switch(codec->codec_type) {
1695             case CODEC_TYPE_AUDIO:
1696                 if(audio_volume != 256) {
1697                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1698                     av_exit(1);
1699                 }
1700                 codec->sample_rate = icodec->sample_rate;
1701                 codec->channels = icodec->channels;
1702                 codec->frame_size = icodec->frame_size;
1703                 codec->block_align= icodec->block_align;
1704                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1705                     codec->block_align= 0;
1706                 if(codec->codec_id == CODEC_ID_AC3)
1707                     codec->block_align= 0;
1708                 break;
1709             case CODEC_TYPE_VIDEO:
1710                 if(using_vhook) {
1711                     fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1712                     av_exit(1);
1713                 }
1714                 codec->pix_fmt = icodec->pix_fmt;
1715                 codec->width = icodec->width;
1716                 codec->height = icodec->height;
1717                 codec->has_b_frames = icodec->has_b_frames;
1718                 break;
1719             case CODEC_TYPE_SUBTITLE:
1720                 break;
1721             default:
1722                 abort();
1723             }
1724         } else {
1725             switch(codec->codec_type) {
1726             case CODEC_TYPE_AUDIO:
1727                 if (av_fifo_init(&ost->fifo, 1024))
1728                     goto fail;
1729                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1730                 icodec->request_channels = codec->channels;
1731                 ist->decoding_needed = 1;
1732                 ost->encoding_needed = 1;
1733                 break;
1734             case CODEC_TYPE_VIDEO:
1735                 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1736                 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1737                 ost->video_resample = ((codec->width != icodec->width -
1738                                 (frame_leftBand + frame_rightBand) +
1739                                 (frame_padleft + frame_padright)) ||
1740                         (codec->height != icodec->height -
1741                                 (frame_topBand  + frame_bottomBand) +
1742                                 (frame_padtop + frame_padbottom)) ||
1743                         (codec->pix_fmt != icodec->pix_fmt));
1744                 if (ost->video_crop) {
1745                     ost->topBand = frame_topBand;
1746                     ost->leftBand = frame_leftBand;
1747                 }
1748                 if (ost->video_pad) {
1749                     ost->padtop = frame_padtop;
1750                     ost->padleft = frame_padleft;
1751                     ost->padbottom = frame_padbottom;
1752                     ost->padright = frame_padright;
1753                     if (!ost->video_resample) {
1754                         avcodec_get_frame_defaults(&ost->pict_tmp);
1755                         if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1756                                          codec->width, codec->height))
1757                             goto fail;
1758                     }
1759                 }
1760                 if (ost->video_resample) {
1761                     avcodec_get_frame_defaults(&ost->pict_tmp);
1762                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1763                                          codec->width, codec->height)) {
1764                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1765                         av_exit(1);
1766                     }
1767                     sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1768                     ost->img_resample_ctx = sws_getContext(
1769                             icodec->width - (frame_leftBand + frame_rightBand),
1770                             icodec->height - (frame_topBand + frame_bottomBand),
1771                             icodec->pix_fmt,
1772                             codec->width - (frame_padleft + frame_padright),
1773                             codec->height - (frame_padtop + frame_padbottom),
1774                             codec->pix_fmt,
1775                             sws_flags, NULL, NULL, NULL);
1776                     if (ost->img_resample_ctx == NULL) {
1777                         fprintf(stderr, "Cannot get resampling context\n");
1778                         av_exit(1);
1779                     }
1780                     ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1781                 }
1782                 ost->encoding_needed = 1;
1783                 ist->decoding_needed = 1;
1784                 break;
1785             case CODEC_TYPE_SUBTITLE:
1786                 ost->encoding_needed = 1;
1787                 ist->decoding_needed = 1;
1788                 break;
1789             default:
1790                 abort();
1791                 break;
1792             }
1793             /* two pass mode */
1794             if (ost->encoding_needed &&
1795                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1796                 char logfilename[1024];
1797                 FILE *f;
1798                 int size;
1799                 char *logbuffer;
1800
1801                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1802                          pass_logfilename ?
1803                          pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1804                 if (codec->flags & CODEC_FLAG_PASS1) {
1805                     f = fopen(logfilename, "w");
1806                     if (!f) {
1807                         perror(logfilename);
1808                         av_exit(1);
1809                     }
1810                     ost->logfile = f;
1811                 } else {
1812                     /* read the log file */
1813                     f = fopen(logfilename, "r");
1814                     if (!f) {
1815                         perror(logfilename);
1816                         av_exit(1);
1817                     }
1818                     fseek(f, 0, SEEK_END);
1819                     size = ftell(f);
1820                     fseek(f, 0, SEEK_SET);
1821                     logbuffer = av_malloc(size + 1);
1822                     if (!logbuffer) {
1823                         fprintf(stderr, "Could not allocate log buffer\n");
1824                         av_exit(1);
1825                     }
1826                     size = fread(logbuffer, 1, size, f);
1827                     fclose(f);
1828                     logbuffer[size] = '\0';
1829                     codec->stats_in = logbuffer;
1830                 }
1831             }
1832         }
1833         if(codec->codec_type == CODEC_TYPE_VIDEO){
1834             int size= codec->width * codec->height;
1835             bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1836         }
1837     }
1838
1839     if (!bit_buffer)
1840         bit_buffer = av_malloc(bit_buffer_size);
1841     if (!bit_buffer)
1842         goto fail;
1843
1844     /* dump the file output parameters - cannot be done before in case
1845        of stream copy */
1846     for(i=0;i<nb_output_files;i++) {
1847         dump_format(output_files[i], i, output_files[i]->filename, 1);
1848     }
1849
1850     /* dump the stream mapping */
1851     if (verbose >= 0) {
1852         fprintf(stderr, "Stream mapping:\n");
1853         for(i=0;i<nb_ostreams;i++) {
1854             ost = ost_table[i];
1855             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1856                     ist_table[ost->source_index]->file_index,
1857                     ist_table[ost->source_index]->index,
1858                     ost->file_index,
1859                     ost->index);
1860             if (ost->sync_ist != ist_table[ost->source_index])
1861                 fprintf(stderr, " [sync #%d.%d]",
1862                         ost->sync_ist->file_index,
1863                         ost->sync_ist->index);
1864             fprintf(stderr, "\n");
1865         }
1866     }
1867
1868     /* open each encoder */
1869     for(i=0;i<nb_ostreams;i++) {
1870         ost = ost_table[i];
1871         if (ost->encoding_needed) {
1872             AVCodec *codec;
1873             codec = avcodec_find_encoder(ost->st->codec->codec_id);
1874             if (!codec) {
1875                 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1876                         ost->file_index, ost->index);
1877                 av_exit(1);
1878             }
1879             if (avcodec_open(ost->st->codec, codec) < 0) {
1880                 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1881                         ost->file_index, ost->index);
1882                 av_exit(1);
1883             }
1884             extra_size += ost->st->codec->extradata_size;
1885         }
1886     }
1887
1888     /* open each decoder */
1889     for(i=0;i<nb_istreams;i++) {
1890         ist = ist_table[i];
1891         if (ist->decoding_needed) {
1892             AVCodec *codec;
1893             codec = avcodec_find_decoder(ist->st->codec->codec_id);
1894             if (!codec) {
1895                 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1896                         ist->st->codec->codec_id, ist->file_index, ist->index);
1897                 av_exit(1);
1898             }
1899             if (avcodec_open(ist->st->codec, codec) < 0) {
1900                 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1901                         ist->file_index, ist->index);
1902                 av_exit(1);
1903             }
1904             //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1905             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1906         }
1907     }
1908
1909     /* init pts */
1910     for(i=0;i<nb_istreams;i++) {
1911         ist = ist_table[i];
1912         is = input_files[ist->file_index];
1913         ist->pts = 0;
1914         ist->next_pts = AV_NOPTS_VALUE;
1915         ist->is_start = 1;
1916     }
1917
1918     /* set meta data information from input file if required */
1919     for (i=0;i<nb_meta_data_maps;i++) {
1920         AVFormatContext *out_file;
1921         AVFormatContext *in_file;
1922
1923         int out_file_index = meta_data_maps[i].out_file;
1924         int in_file_index = meta_data_maps[i].in_file;
1925         if (out_file_index < 0 || out_file_index >= nb_output_files) {
1926             fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1927             ret = AVERROR(EINVAL);
1928             goto fail;
1929         }
1930         if (in_file_index < 0 || in_file_index >= nb_input_files) {
1931             fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1932             ret = AVERROR(EINVAL);
1933             goto fail;
1934         }
1935
1936         out_file = output_files[out_file_index];
1937         in_file = input_files[in_file_index];
1938
1939         strcpy(out_file->title, in_file->title);
1940         strcpy(out_file->author, in_file->author);
1941         strcpy(out_file->copyright, in_file->copyright);
1942         strcpy(out_file->comment, in_file->comment);
1943         strcpy(out_file->album, in_file->album);
1944         out_file->year = in_file->year;
1945         out_file->track = in_file->track;
1946         strcpy(out_file->genre, in_file->genre);
1947     }
1948
1949     /* open files and write file headers */
1950     for(i=0;i<nb_output_files;i++) {
1951         os = output_files[i];
1952         if (av_write_header(os) < 0) {
1953             fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1954             ret = AVERROR(EINVAL);
1955             goto fail;
1956         }
1957         if (strcmp(output_files[i]->oformat->name, "rtp")) {
1958             want_sdp = 0;
1959         }
1960     }
1961     if (want_sdp) {
1962         print_sdp(output_files, nb_output_files);
1963     }
1964
1965     if (!using_stdin && verbose >= 0) {
1966         fprintf(stderr, "Press [q] to stop encoding\n");
1967         url_set_interrupt_cb(decode_interrupt_cb);
1968     }
1969     term_init();
1970
1971     key = -1;
1972     timer_start = av_gettime();
1973
1974     for(; received_sigterm == 0;) {
1975         int file_index, ist_index;
1976         AVPacket pkt;
1977         double ipts_min;
1978         double opts_min;
1979
1980     redo:
1981         ipts_min= 1e100;
1982         opts_min= 1e100;
1983         /* if 'q' pressed, exits */
1984         if (!using_stdin) {
1985             if (q_pressed)
1986                 break;
1987             /* read_key() returns 0 on EOF */
1988             key = read_key();
1989             if (key == 'q')
1990                 break;
1991         }
1992
1993         /* select the stream that we must read now by looking at the
1994            smallest output pts */
1995         file_index = -1;
1996         for(i=0;i<nb_ostreams;i++) {
1997             double ipts, opts;
1998             ost = ost_table[i];
1999             os = output_files[ost->file_index];
2000             ist = ist_table[ost->source_index];
2001             if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2002                 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2003             else
2004                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2005             ipts = (double)ist->pts;
2006             if (!file_table[ist->file_index].eof_reached){
2007                 if(ipts < ipts_min) {
2008                     ipts_min = ipts;
2009                     if(input_sync ) file_index = ist->file_index;
2010                 }
2011                 if(opts < opts_min) {
2012                     opts_min = opts;
2013                     if(!input_sync) file_index = ist->file_index;
2014                 }
2015             }
2016             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2017                 file_index= -1;
2018                 break;
2019             }
2020         }
2021         /* if none, if is finished */
2022         if (file_index < 0) {
2023             break;
2024         }
2025
2026         /* finish if recording time exhausted */
2027         if (opts_min >= (recording_time / 1000000.0))
2028             break;
2029
2030         /* finish if limit size exhausted */
2031         if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2032             break;
2033
2034         /* read a frame from it and output it in the fifo */
2035         is = input_files[file_index];
2036         if (av_read_frame(is, &pkt) < 0) {
2037             file_table[file_index].eof_reached = 1;
2038             if (opt_shortest)
2039                 break;
2040             else
2041                 continue;
2042         }
2043
2044         if (do_pkt_dump) {
2045             av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2046         }
2047         /* the following test is needed in case new streams appear
2048            dynamically in stream : we ignore them */
2049         if (pkt.stream_index >= file_table[file_index].nb_streams)
2050             goto discard_packet;
2051         ist_index = file_table[file_index].ist_index + pkt.stream_index;
2052         ist = ist_table[ist_index];
2053         if (ist->discard)
2054             goto discard_packet;
2055
2056         if (pkt.dts != AV_NOPTS_VALUE)
2057             pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2058         if (pkt.pts != AV_NOPTS_VALUE)
2059             pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2060
2061         if(input_files_ts_scale[file_index][pkt.stream_index]){
2062             if(pkt.pts != AV_NOPTS_VALUE)
2063                 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2064             if(pkt.dts != AV_NOPTS_VALUE)
2065                 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2066         }
2067
2068 //        fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
2069         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2070             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2071             int64_t delta= pkt_dts - ist->next_pts;
2072             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2073                 input_files_ts_offset[ist->file_index]-= delta;
2074                 if (verbose > 2)
2075                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2076                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2077                 if(pkt.pts != AV_NOPTS_VALUE)
2078                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2079             }
2080         }
2081
2082         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2083         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2084
2085             if (verbose >= 0)
2086                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2087                         ist->file_index, ist->index);
2088
2089             av_free_packet(&pkt);
2090             goto redo;
2091         }
2092
2093     discard_packet:
2094         av_free_packet(&pkt);
2095
2096         /* dump report by using the output first video and audio streams */
2097         print_report(output_files, ost_table, nb_ostreams, 0);
2098     }
2099
2100     /* at the end of stream, we must flush the decoder buffers */
2101     for(i=0;i<nb_istreams;i++) {
2102         ist = ist_table[i];
2103         if (ist->decoding_needed) {
2104             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2105         }
2106     }
2107
2108     term_exit();
2109
2110     /* write the trailer if needed and close file */
2111     for(i=0;i<nb_output_files;i++) {
2112         os = output_files[i];
2113         av_write_trailer(os);
2114     }
2115
2116     /* dump report by using the first video and audio streams */
2117     print_report(output_files, ost_table, nb_ostreams, 1);
2118
2119     /* close each encoder */
2120     for(i=0;i<nb_ostreams;i++) {
2121         ost = ost_table[i];
2122         if (ost->encoding_needed) {
2123             av_freep(&ost->st->codec->stats_in);
2124             avcodec_close(ost->st->codec);
2125         }
2126     }
2127
2128     /* close each decoder */
2129     for(i=0;i<nb_istreams;i++) {
2130         ist = ist_table[i];
2131         if (ist->decoding_needed) {
2132             avcodec_close(ist->st->codec);
2133         }
2134     }
2135
2136     /* finished ! */
2137
2138     ret = 0;
2139  fail1:
2140     av_freep(&bit_buffer);
2141     av_free(file_table);
2142
2143     if (ist_table) {
2144         for(i=0;i<nb_istreams;i++) {
2145             ist = ist_table[i];
2146             av_free(ist);
2147         }
2148         av_free(ist_table);
2149     }
2150     if (ost_table) {
2151         for(i=0;i<nb_ostreams;i++) {
2152             ost = ost_table[i];
2153             if (ost) {
2154                 if (ost->logfile) {
2155                     fclose(ost->logfile);
2156                     ost->logfile = NULL;
2157                 }
2158                 av_fifo_free(&ost->fifo); /* works even if fifo is not
2159                                              initialized but set to zero */
2160                 av_free(ost->pict_tmp.data[0]);
2161                 if (ost->video_resample)
2162                     sws_freeContext(ost->img_resample_ctx);
2163                 if (ost->resample)
2164                     audio_resample_close(ost->resample);
2165                 av_free(ost);
2166             }
2167         }
2168         av_free(ost_table);
2169     }
2170     return ret;
2171  fail:
2172     ret = AVERROR(ENOMEM);
2173     goto fail1;
2174 }
2175
2176 #if 0
2177 int file_read(const char *filename)
2178 {
2179     URLContext *h;
2180     unsigned char buffer[1024];
2181     int len, i;
2182
2183     if (url_open(&h, filename, O_RDONLY) < 0) {
2184         printf("could not open '%s'\n", filename);
2185         return -1;
2186     }
2187     for(;;) {
2188         len = url_read(h, buffer, sizeof(buffer));
2189         if (len <= 0)
2190             break;
2191         for(i=0;i<len;i++) putchar(buffer[i]);
2192     }
2193     url_close(h);
2194     return 0;
2195 }
2196 #endif
2197
2198 static void opt_format(const char *arg)
2199 {
2200     /* compatibility stuff for pgmyuv */
2201     if (!strcmp(arg, "pgmyuv")) {
2202         pgmyuv_compatibility_hack=1;
2203 //        opt_image_format(arg);
2204         arg = "image2";
2205         fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2206     }
2207
2208     file_iformat = av_find_input_format(arg);
2209     file_oformat = guess_format(arg, NULL, NULL);
2210     if (!file_iformat && !file_oformat) {
2211         fprintf(stderr, "Unknown input or output format: %s\n", arg);
2212         av_exit(1);
2213     }
2214 }
2215
2216 static int opt_default(const char *opt, const char *arg){
2217     int type;
2218     const AVOption *o= NULL;
2219     int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2220
2221     for(type=0; type<CODEC_TYPE_NB; type++){
2222         const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2223         if(o2)
2224             o = av_set_string2(avctx_opts[type], opt, arg, 1);
2225     }
2226     if(!o)
2227         o = av_set_string2(avformat_opts, opt, arg, 1);
2228     if(!o)
2229         o = av_set_string2(sws_opts, opt, arg, 1);
2230     if(!o){
2231         if(opt[0] == 'a')
2232             o = av_set_string2(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg, 1);
2233         else if(opt[0] == 'v')
2234             o = av_set_string2(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg, 1);
2235         else if(opt[0] == 's')
2236             o = av_set_string2(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg, 1);
2237     }
2238     if(!o)
2239         return -1;
2240
2241 //    av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avctx_opts, opt, NULL), (int)av_get_int(avctx_opts, opt, NULL));
2242
2243     //FIXME we should always use avctx_opts, ... for storing options so there will not be any need to keep track of what i set over this
2244     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
2245     opt_names[opt_name_count++]= o->name;
2246
2247     if(avctx_opts[0]->debug || avformat_opts->debug)
2248         av_log_set_level(AV_LOG_DEBUG);
2249     return 0;
2250 }
2251
2252 static void opt_video_rc_override_string(const char *arg)
2253 {
2254     video_rc_override_string = arg;
2255 }
2256
2257 static int opt_me_threshold(const char *opt, const char *arg)
2258 {
2259     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2260     return 0;
2261 }
2262
2263 static int opt_verbose(const char *opt, const char *arg)
2264 {
2265     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2266     av_log_set_level(verbose);
2267     return 0;
2268 }
2269
2270 static void opt_frame_rate(const char *arg)
2271 {
2272     if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2273         fprintf(stderr, "Incorrect frame rate\n");
2274         av_exit(1);
2275     }
2276 }
2277
2278 static int opt_bitrate(const char *opt, const char *arg)
2279 {
2280     int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2281
2282     opt_default(opt, arg);
2283
2284     if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2285         fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2286
2287     return 0;
2288 }
2289
2290 static void opt_frame_crop_top(const char *arg)
2291 {
2292     frame_topBand = atoi(arg);
2293     if (frame_topBand < 0) {
2294         fprintf(stderr, "Incorrect top crop size\n");
2295         av_exit(1);
2296     }
2297     if ((frame_topBand % 2) != 0) {
2298         fprintf(stderr, "Top crop size must be a multiple of 2\n");
2299         av_exit(1);
2300     }
2301     if ((frame_topBand) >= frame_height){
2302         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2303         av_exit(1);
2304     }
2305     frame_height -= frame_topBand;
2306 }
2307
2308 static void opt_frame_crop_bottom(const char *arg)
2309 {
2310     frame_bottomBand = atoi(arg);
2311     if (frame_bottomBand < 0) {
2312         fprintf(stderr, "Incorrect bottom crop size\n");
2313         av_exit(1);
2314     }
2315     if ((frame_bottomBand % 2) != 0) {
2316         fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2317         av_exit(1);
2318     }
2319     if ((frame_bottomBand) >= frame_height){
2320         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2321         av_exit(1);
2322     }
2323     frame_height -= frame_bottomBand;
2324 }
2325
2326 static void opt_frame_crop_left(const char *arg)
2327 {
2328     frame_leftBand = atoi(arg);
2329     if (frame_leftBand < 0) {
2330         fprintf(stderr, "Incorrect left crop size\n");
2331         av_exit(1);
2332     }
2333     if ((frame_leftBand % 2) != 0) {
2334         fprintf(stderr, "Left crop size must be a multiple of 2\n");
2335         av_exit(1);
2336     }
2337     if ((frame_leftBand) >= frame_width){
2338         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2339         av_exit(1);
2340     }
2341     frame_width -= frame_leftBand;
2342 }
2343
2344 static void opt_frame_crop_right(const char *arg)
2345 {
2346     frame_rightBand = atoi(arg);
2347     if (frame_rightBand < 0) {
2348         fprintf(stderr, "Incorrect right crop size\n");
2349         av_exit(1);
2350     }
2351     if ((frame_rightBand % 2) != 0) {
2352         fprintf(stderr, "Right crop size must be a multiple of 2\n");
2353         av_exit(1);
2354     }
2355     if ((frame_rightBand) >= frame_width){
2356         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2357         av_exit(1);
2358     }
2359     frame_width -= frame_rightBand;
2360 }
2361
2362 static void opt_frame_size(const char *arg)
2363 {
2364     if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2365         fprintf(stderr, "Incorrect frame size\n");
2366         av_exit(1);
2367     }
2368     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2369         fprintf(stderr, "Frame size must be a multiple of 2\n");
2370         av_exit(1);
2371     }
2372 }
2373
2374
2375 #define SCALEBITS 10
2376 #define ONE_HALF  (1 << (SCALEBITS - 1))
2377 #define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2378
2379 #define RGB_TO_Y(r, g, b) \
2380 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2381   FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2382
2383 #define RGB_TO_U(r1, g1, b1, shift)\
2384 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2385      FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2386
2387 #define RGB_TO_V(r1, g1, b1, shift)\
2388 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2389    FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2390
2391 static void opt_pad_color(const char *arg) {
2392     /* Input is expected to be six hex digits similar to
2393        how colors are expressed in html tags (but without the #) */
2394     int rgb = strtol(arg, NULL, 16);
2395     int r,g,b;
2396
2397     r = (rgb >> 16);
2398     g = ((rgb >> 8) & 255);
2399     b = (rgb & 255);
2400
2401     padcolor[0] = RGB_TO_Y(r,g,b);
2402     padcolor[1] = RGB_TO_U(r,g,b,0);
2403     padcolor[2] = RGB_TO_V(r,g,b,0);
2404 }
2405
2406 static void opt_frame_pad_top(const char *arg)
2407 {
2408     frame_padtop = atoi(arg);
2409     if (frame_padtop < 0) {
2410         fprintf(stderr, "Incorrect top pad size\n");
2411         av_exit(1);
2412     }
2413     if ((frame_padtop % 2) != 0) {
2414         fprintf(stderr, "Top pad size must be a multiple of 2\n");
2415         av_exit(1);
2416     }
2417 }
2418
2419 static void opt_frame_pad_bottom(const char *arg)
2420 {
2421     frame_padbottom = atoi(arg);
2422     if (frame_padbottom < 0) {
2423         fprintf(stderr, "Incorrect bottom pad size\n");
2424         av_exit(1);
2425     }
2426     if ((frame_padbottom % 2) != 0) {
2427         fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2428         av_exit(1);
2429     }
2430 }
2431
2432
2433 static void opt_frame_pad_left(const char *arg)
2434 {
2435     frame_padleft = atoi(arg);
2436     if (frame_padleft < 0) {
2437         fprintf(stderr, "Incorrect left pad size\n");
2438         av_exit(1);
2439     }
2440     if ((frame_padleft % 2) != 0) {
2441         fprintf(stderr, "Left pad size must be a multiple of 2\n");
2442         av_exit(1);
2443     }
2444 }
2445
2446
2447 static void opt_frame_pad_right(const char *arg)
2448 {
2449     frame_padright = atoi(arg);
2450     if (frame_padright < 0) {
2451         fprintf(stderr, "Incorrect right pad size\n");
2452         av_exit(1);
2453     }
2454     if ((frame_padright % 2) != 0) {
2455         fprintf(stderr, "Right pad size must be a multiple of 2\n");
2456         av_exit(1);
2457     }
2458 }
2459
2460 static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2461 {
2462     int i;
2463     char fmt_str[128];
2464     for (i=-1; i < nb_fmts; i++) {
2465         get_fmt_string (fmt_str, sizeof(fmt_str), i);
2466         fprintf(stdout, "%s\n", fmt_str);
2467     }
2468 }
2469
2470 static void opt_frame_pix_fmt(const char *arg)
2471 {
2472     if (strcmp(arg, "list"))
2473         frame_pix_fmt = avcodec_get_pix_fmt(arg);
2474     else {
2475         list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2476         av_exit(0);
2477     }
2478 }
2479
2480 static void opt_frame_aspect_ratio(const char *arg)
2481 {
2482     int x = 0, y = 0;
2483     double ar = 0;
2484     const char *p;
2485     char *end;
2486
2487     p = strchr(arg, ':');
2488     if (p) {
2489         x = strtol(arg, &end, 10);
2490         if (end == p)
2491             y = strtol(end+1, &end, 10);
2492         if (x > 0 && y > 0)
2493             ar = (double)x / (double)y;
2494     } else
2495         ar = strtod(arg, NULL);
2496
2497     if (!ar) {
2498         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2499         av_exit(1);
2500     }
2501     frame_aspect_ratio = ar;
2502 }
2503
2504 static void opt_qscale(const char *arg)
2505 {
2506     video_qscale = atof(arg);
2507     if (video_qscale <= 0 ||
2508         video_qscale > 255) {
2509         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2510         av_exit(1);
2511     }
2512 }
2513
2514 static void opt_top_field_first(const char *arg)
2515 {
2516     top_field_first= atoi(arg);
2517 }
2518
2519 static int opt_thread_count(const char *opt, const char *arg)
2520 {
2521     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2522 #if !defined(HAVE_THREADS)
2523     if (verbose >= 0)
2524         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2525 #endif
2526     return 0;
2527 }
2528
2529 static void opt_audio_sample_fmt(const char *arg)
2530 {
2531     if (strcmp(arg, "list"))
2532         audio_sample_fmt = avcodec_get_sample_fmt(arg);
2533     else {
2534         list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2535         av_exit(0);
2536     }
2537 }
2538
2539 static int opt_audio_rate(const char *opt, const char *arg)
2540 {
2541     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2542     return 0;
2543 }
2544
2545 static int opt_audio_channels(const char *opt, const char *arg)
2546 {
2547     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2548     return 0;
2549 }
2550
2551 static void opt_video_channel(const char *arg)
2552 {
2553     video_channel = strtol(arg, NULL, 0);
2554 }
2555
2556 static void opt_video_standard(const char *arg)
2557 {
2558     video_standard = av_strdup(arg);
2559 }
2560
2561 static void opt_codec(int *pstream_copy, char **pcodec_name,
2562                       int codec_type, const char *arg)
2563 {
2564     av_freep(pcodec_name);
2565     if (!strcmp(arg, "copy")) {
2566         *pstream_copy = 1;
2567     } else {
2568         *pcodec_name = av_strdup(arg);
2569     }
2570 }
2571
2572 static void opt_audio_codec(const char *arg)
2573 {
2574     opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2575 }
2576
2577 static void opt_audio_tag(const char *arg)
2578 {
2579     char *tail;
2580     audio_codec_tag= strtol(arg, &tail, 0);
2581
2582     if(!tail || *tail)
2583         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2584 }
2585
2586 static void opt_video_tag(const char *arg)
2587 {
2588     char *tail;
2589     video_codec_tag= strtol(arg, &tail, 0);
2590
2591     if(!tail || *tail)
2592         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2593 }
2594
2595 #ifdef CONFIG_VHOOK
2596 static void add_frame_hooker(const char *arg)
2597 {
2598     int argc = 0;
2599     char *argv[64];
2600     int i;
2601     char *args = av_strdup(arg);
2602
2603     using_vhook = 1;
2604
2605     argv[0] = strtok(args, " ");
2606     while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2607     }
2608
2609     i = frame_hook_add(argc, argv);
2610
2611     if (i != 0) {
2612         fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2613         av_exit(1);
2614     }
2615 }
2616 #endif
2617
2618 static void opt_video_codec(const char *arg)
2619 {
2620     opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2621 }
2622
2623 static void opt_subtitle_codec(const char *arg)
2624 {
2625     opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2626 }
2627
2628 static void opt_map(const char *arg)
2629 {
2630     AVStreamMap *m;
2631     char *p;
2632
2633     m = &stream_maps[nb_stream_maps++];
2634
2635     m->file_index = strtol(arg, &p, 0);
2636     if (*p)
2637         p++;
2638
2639     m->stream_index = strtol(p, &p, 0);
2640     if (*p) {
2641         p++;
2642         m->sync_file_index = strtol(p, &p, 0);
2643         if (*p)
2644             p++;
2645         m->sync_stream_index = strtol(p, &p, 0);
2646     } else {
2647         m->sync_file_index = m->file_index;
2648         m->sync_stream_index = m->stream_index;
2649     }
2650 }
2651
2652 static void opt_map_meta_data(const char *arg)
2653 {
2654     AVMetaDataMap *m;
2655     char *p;
2656
2657     m = &meta_data_maps[nb_meta_data_maps++];
2658
2659     m->out_file = strtol(arg, &p, 0);
2660     if (*p)
2661         p++;
2662
2663     m->in_file = strtol(p, &p, 0);
2664 }
2665
2666 static void opt_input_ts_scale(const char *arg)
2667 {
2668     unsigned int stream;
2669     double scale;
2670     char *p;
2671
2672     stream = strtol(arg, &p, 0);
2673     if (*p)
2674         p++;
2675     scale= strtod(p, &p);
2676
2677     if(stream >= MAX_STREAMS)
2678         av_exit(1);
2679
2680     input_files_ts_scale[nb_input_files][stream]= scale;
2681 }
2682
2683 static int opt_recording_time(const char *opt, const char *arg)
2684 {
2685     recording_time = parse_time_or_die(opt, arg, 1);
2686     return 0;
2687 }
2688
2689 static int opt_start_time(const char *opt, const char *arg)
2690 {
2691     start_time = parse_time_or_die(opt, arg, 1);
2692     return 0;
2693 }
2694
2695 static int opt_rec_timestamp(const char *opt, const char *arg)
2696 {
2697     rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2698     return 0;
2699 }
2700
2701 static int opt_input_ts_offset(const char *opt, const char *arg)
2702 {
2703     input_ts_offset = parse_time_or_die(opt, arg, 1);
2704     return 0;
2705 }
2706
2707 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2708 {
2709     const char *codec_string = encoder ? "encoder" : "decoder";
2710     AVCodec *codec;
2711
2712     if(!name)
2713         return CODEC_ID_NONE;
2714     codec = encoder ?
2715         avcodec_find_encoder_by_name(name) :
2716         avcodec_find_decoder_by_name(name);
2717     if(!codec) {
2718         av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2719         av_exit(1);
2720     }
2721     if(codec->type != type) {
2722         av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2723         av_exit(1);
2724     }
2725     return codec->id;
2726 }
2727
2728 static void set_context_opts(void *ctx, void *opts_ctx, int flags)
2729 {
2730     int i;
2731     for(i=0; i<opt_name_count; i++){
2732         char buf[256];
2733         const AVOption *opt;
2734         const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
2735         /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
2736         if(str && ((opt->flags & flags) == flags))
2737             av_set_string2(ctx, opt_names[i], str, 1);
2738     }
2739 }
2740
2741 static void opt_input_file(const char *filename)
2742 {
2743     AVFormatContext *ic;
2744     AVFormatParameters params, *ap = &params;
2745     int err, i, ret, rfps, rfps_base;
2746     int64_t timestamp;
2747
2748     if (!strcmp(filename, "-"))
2749         filename = "pipe:";
2750
2751     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2752                     !strcmp(filename, "/dev/stdin");
2753
2754     /* get default parameters from command line */
2755     ic = av_alloc_format_context();
2756
2757     memset(ap, 0, sizeof(*ap));
2758     ap->prealloced_context = 1;
2759     ap->sample_rate = audio_sample_rate;
2760     ap->channels = audio_channels;
2761     ap->time_base.den = frame_rate.num;
2762     ap->time_base.num = frame_rate.den;
2763     ap->width = frame_width + frame_padleft + frame_padright;
2764     ap->height = frame_height + frame_padtop + frame_padbottom;
2765     ap->pix_fmt = frame_pix_fmt;
2766     ap->channel = video_channel;
2767     ap->standard = video_standard;
2768     ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2769     ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2770     if(pgmyuv_compatibility_hack)
2771         ap->video_codec_id= CODEC_ID_PGMYUV;
2772
2773     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2774
2775     ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2776     ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2777     ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2778
2779     /* open the input file with generic libav function */
2780     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2781     if (err < 0) {
2782         print_error(filename, err);
2783         av_exit(1);
2784     }
2785     if(opt_programid) {
2786         int i;
2787         for(i=0; i<ic->nb_programs; i++)
2788             if(ic->programs[i]->id != opt_programid)
2789                 ic->programs[i]->discard = AVDISCARD_ALL;
2790     }
2791
2792     ic->loop_input = loop_input;
2793
2794     /* If not enough info to get the stream parameters, we decode the
2795        first frames to get it. (used in mpeg case for example) */
2796     ret = av_find_stream_info(ic);
2797     if (ret < 0 && verbose >= 0) {
2798         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2799         av_exit(1);
2800     }
2801
2802     timestamp = start_time;
2803     /* add the stream start time */
2804     if (ic->start_time != AV_NOPTS_VALUE)
2805         timestamp += ic->start_time;
2806
2807     /* if seeking requested, we execute it */
2808     if (start_time != 0) {
2809         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2810         if (ret < 0) {
2811             fprintf(stderr, "%s: could not seek to position %0.3f\n",
2812                     filename, (double)timestamp / AV_TIME_BASE);
2813         }
2814         /* reset seek info */
2815         start_time = 0;
2816     }
2817
2818     /* update the current parameters so that they match the one of the input stream */
2819     for(i=0;i<ic->nb_streams;i++) {
2820         AVCodecContext *enc = ic->streams[i]->codec;
2821         if(thread_count>1)
2822             avcodec_thread_init(enc, thread_count);
2823         enc->thread_count= thread_count;
2824         switch(enc->codec_type) {
2825         case CODEC_TYPE_AUDIO:
2826             set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2827             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2828             audio_channels = enc->channels;
2829             audio_sample_rate = enc->sample_rate;
2830             if(audio_disable)
2831                 ic->streams[i]->discard= AVDISCARD_ALL;
2832             break;
2833         case CODEC_TYPE_VIDEO:
2834             set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2835             frame_height = enc->height;
2836             frame_width = enc->width;
2837             frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2838             frame_pix_fmt = enc->pix_fmt;
2839             rfps      = ic->streams[i]->r_frame_rate.num;
2840             rfps_base = ic->streams[i]->r_frame_rate.den;
2841             if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2842             if(me_threshold)
2843                 enc->debug |= FF_DEBUG_MV;
2844
2845             if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2846
2847                 if (verbose >= 0)
2848                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2849                             i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2850
2851                     (float)rfps / rfps_base, rfps, rfps_base);
2852             }
2853             /* update the current frame rate to match the stream frame rate */
2854             frame_rate.num = rfps;
2855             frame_rate.den = rfps_base;
2856
2857             enc->rate_emu = rate_emu;
2858             if(video_disable)
2859                 ic->streams[i]->discard= AVDISCARD_ALL;
2860             else if(video_discard)
2861                 ic->streams[i]->discard= video_discard;
2862             break;
2863         case CODEC_TYPE_DATA:
2864             break;
2865         case CODEC_TYPE_SUBTITLE:
2866             if(subtitle_disable)
2867                 ic->streams[i]->discard = AVDISCARD_ALL;
2868             break;
2869         case CODEC_TYPE_ATTACHMENT:
2870         case CODEC_TYPE_UNKNOWN:
2871             break;
2872         default:
2873             abort();
2874         }
2875     }
2876
2877     input_files[nb_input_files] = ic;
2878     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2879     /* dump the file content */
2880     if (verbose >= 0)
2881         dump_format(ic, nb_input_files, filename, 0);
2882
2883     nb_input_files++;
2884     file_iformat = NULL;
2885     file_oformat = NULL;
2886
2887     video_channel = 0;
2888
2889     rate_emu = 0;
2890     av_freep(&video_codec_name);
2891     av_freep(&audio_codec_name);
2892     av_freep(&subtitle_codec_name);
2893 }
2894
2895 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2896                                          int *has_subtitle_ptr)
2897 {
2898     int has_video, has_audio, has_subtitle, i, j;
2899     AVFormatContext *ic;
2900
2901     has_video = 0;
2902     has_audio = 0;
2903     has_subtitle = 0;
2904     for(j=0;j<nb_input_files;j++) {
2905         ic = input_files[j];
2906         for(i=0;i<ic->nb_streams;i++) {
2907             AVCodecContext *enc = ic->streams[i]->codec;
2908             switch(enc->codec_type) {
2909             case CODEC_TYPE_AUDIO:
2910                 has_audio = 1;
2911                 break;
2912             case CODEC_TYPE_VIDEO:
2913                 has_video = 1;
2914                 break;
2915             case CODEC_TYPE_SUBTITLE:
2916                 has_subtitle = 1;
2917                 break;
2918             case CODEC_TYPE_DATA:
2919             case CODEC_TYPE_ATTACHMENT:
2920             case CODEC_TYPE_UNKNOWN:
2921                 break;
2922             default:
2923                 abort();
2924             }
2925         }
2926     }
2927     *has_video_ptr = has_video;
2928     *has_audio_ptr = has_audio;
2929     *has_subtitle_ptr = has_subtitle;
2930 }
2931
2932 static void new_video_stream(AVFormatContext *oc)
2933 {
2934     AVStream *st;
2935     AVCodecContext *video_enc;
2936     int codec_id;
2937
2938     st = av_new_stream(oc, oc->nb_streams);
2939     if (!st) {
2940         fprintf(stderr, "Could not alloc stream\n");
2941         av_exit(1);
2942     }
2943     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2944     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2945     video_bitstream_filters= NULL;
2946
2947     if(thread_count>1)
2948         avcodec_thread_init(st->codec, thread_count);
2949
2950     video_enc = st->codec;
2951
2952     if(video_codec_tag)
2953         video_enc->codec_tag= video_codec_tag;
2954
2955     if(   (video_global_header&1)
2956        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2957         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2958         avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2959     }
2960     if(video_global_header&2){
2961         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2962         avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2963     }
2964
2965     if (video_stream_copy) {
2966         st->stream_copy = 1;
2967         video_enc->codec_type = CODEC_TYPE_VIDEO;
2968     } else {
2969         const char *p;
2970         int i;
2971         AVCodec *codec;
2972         AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2973
2974         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2975         if (video_codec_name)
2976             codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2977
2978         video_enc->codec_id = codec_id;
2979         codec = avcodec_find_encoder(codec_id);
2980
2981         set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
2982
2983         video_enc->time_base.den = fps.num;
2984         video_enc->time_base.num = fps.den;
2985         if(codec && codec->supported_framerates){
2986             const AVRational *p= codec->supported_framerates;
2987             const AVRational *best=NULL;
2988             AVRational best_error= (AVRational){INT_MAX, 1};
2989             for(; p->den!=0; p++){
2990                 AVRational error= av_sub_q(fps, *p);
2991                 if(error.num <0) error.num *= -1;
2992                 if(av_cmp_q(error, best_error) < 0){
2993                     best_error= error;
2994                     best= p;
2995                 }
2996             }
2997             video_enc->time_base.den= best->num;
2998             video_enc->time_base.num= best->den;
2999         }
3000
3001         video_enc->width = frame_width + frame_padright + frame_padleft;
3002         video_enc->height = frame_height + frame_padtop + frame_padbottom;
3003         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3004         video_enc->pix_fmt = frame_pix_fmt;
3005
3006         if(codec && codec->pix_fmts){
3007             const enum PixelFormat *p= codec->pix_fmts;
3008             for(; *p!=-1; p++){
3009                 if(*p == video_enc->pix_fmt)
3010                     break;
3011             }
3012             if(*p == -1)
3013                 video_enc->pix_fmt = codec->pix_fmts[0];
3014         }
3015
3016         if (intra_only)
3017             video_enc->gop_size = 0;
3018         if (video_qscale || same_quality) {
3019             video_enc->flags |= CODEC_FLAG_QSCALE;
3020             video_enc->global_quality=
3021                 st->quality = FF_QP2LAMBDA * video_qscale;
3022         }
3023
3024         if(intra_matrix)
3025             video_enc->intra_matrix = intra_matrix;
3026         if(inter_matrix)
3027             video_enc->inter_matrix = inter_matrix;
3028
3029         video_enc->thread_count = thread_count;
3030         p= video_rc_override_string;
3031         for(i=0; p; i++){
3032             int start, end, q;
3033             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3034             if(e!=3){
3035                 fprintf(stderr, "error parsing rc_override\n");
3036                 av_exit(1);
3037             }
3038             video_enc->rc_override=
3039                 av_realloc(video_enc->rc_override,
3040                            sizeof(RcOverride)*(i+1));
3041             video_enc->rc_override[i].start_frame= start;
3042             video_enc->rc_override[i].end_frame  = end;
3043             if(q>0){
3044                 video_enc->rc_override[i].qscale= q;
3045                 video_enc->rc_override[i].quality_factor= 1.0;
3046             }
3047             else{
3048                 video_enc->rc_override[i].qscale= 0;
3049                 video_enc->rc_override[i].quality_factor= -q/100.0;
3050             }
3051             p= strchr(p, '/');
3052             if(p) p++;
3053         }
3054         video_enc->rc_override_count=i;
3055         if (!video_enc->rc_initial_buffer_occupancy)
3056             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3057         video_enc->me_threshold= me_threshold;
3058         video_enc->intra_dc_precision= intra_dc_precision - 8;
3059
3060         if (do_psnr)
3061             video_enc->flags|= CODEC_FLAG_PSNR;
3062
3063         /* two pass mode */
3064         if (do_pass) {
3065             if (do_pass == 1) {
3066                 video_enc->flags |= CODEC_FLAG_PASS1;
3067             } else {
3068                 video_enc->flags |= CODEC_FLAG_PASS2;
3069             }
3070         }
3071     }
3072
3073     /* reset some key parameters */
3074     video_disable = 0;
3075     av_freep(&video_codec_name);
3076     video_stream_copy = 0;
3077 }
3078
3079 static void new_audio_stream(AVFormatContext *oc)
3080 {
3081     AVStream *st;
3082     AVCodecContext *audio_enc;
3083     int codec_id;
3084
3085     st = av_new_stream(oc, oc->nb_streams);
3086     if (!st) {
3087         fprintf(stderr, "Could not alloc stream\n");
3088         av_exit(1);
3089     }
3090     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3091
3092     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3093     audio_bitstream_filters= NULL;
3094
3095     if(thread_count>1)
3096         avcodec_thread_init(st->codec, thread_count);
3097
3098     audio_enc = st->codec;
3099     audio_enc->codec_type = CODEC_TYPE_AUDIO;
3100
3101     if(audio_codec_tag)
3102         audio_enc->codec_tag= audio_codec_tag;
3103
3104     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3105         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3106         avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3107     }
3108     if (audio_stream_copy) {
3109         st->stream_copy = 1;
3110         audio_enc->channels = audio_channels;
3111     } else {
3112         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3113
3114         set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3115
3116         if (audio_codec_name)
3117             codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3118         audio_enc->codec_id = codec_id;
3119
3120         if (audio_qscale > QSCALE_NONE) {
3121             audio_enc->flags |= CODEC_FLAG_QSCALE;
3122             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3123         }
3124         audio_enc->thread_count = thread_count;
3125         audio_enc->channels = audio_channels;
3126     }
3127     audio_enc->sample_rate = audio_sample_rate;
3128     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3129     if (audio_language) {
3130         av_strlcpy(st->language, audio_language, sizeof(st->language));
3131         av_free(audio_language);
3132         audio_language = NULL;
3133     }
3134
3135     /* reset some key parameters */
3136     audio_disable = 0;
3137     av_freep(&audio_codec_name);
3138     audio_stream_copy = 0;
3139 }
3140
3141 static void new_subtitle_stream(AVFormatContext *oc)
3142 {
3143     AVStream *st;
3144     AVCodecContext *subtitle_enc;
3145
3146     st = av_new_stream(oc, oc->nb_streams);
3147     if (!st) {
3148         fprintf(stderr, "Could not alloc stream\n");
3149         av_exit(1);
3150     }
3151     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3152
3153     bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3154     subtitle_bitstream_filters= NULL;
3155
3156     subtitle_enc = st->codec;
3157     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3158     if (subtitle_stream_copy) {
3159         st->stream_copy = 1;
3160     } else {
3161         set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3162         subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3163     }
3164
3165     if (subtitle_language) {
3166         av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3167         av_free(subtitle_language);
3168         subtitle_language = NULL;
3169     }
3170
3171     subtitle_disable = 0;
3172     av_freep(&subtitle_codec_name);
3173     subtitle_stream_copy = 0;
3174 }
3175
3176 static void opt_new_audio_stream(void)
3177 {
3178     AVFormatContext *oc;
3179     if (nb_output_files <= 0) {
3180         fprintf(stderr, "At least one output file must be specified\n");
3181         av_exit(1);
3182     }
3183     oc = output_files[nb_output_files - 1];
3184     new_audio_stream(oc);
3185 }
3186
3187 static void opt_new_video_stream(void)
3188 {
3189     AVFormatContext *oc;
3190     if (nb_output_files <= 0) {
3191         fprintf(stderr, "At least one output file must be specified\n");
3192         av_exit(1);
3193     }
3194     oc = output_files[nb_output_files - 1];
3195     new_video_stream(oc);
3196 }
3197
3198 static void opt_new_subtitle_stream(void)
3199 {
3200     AVFormatContext *oc;
3201     if (nb_output_files <= 0) {
3202         fprintf(stderr, "At least one output file must be specified\n");
3203         av_exit(1);
3204     }
3205     oc = output_files[nb_output_files - 1];
3206     new_subtitle_stream(oc);
3207 }
3208
3209 static void opt_output_file(const char *filename)
3210 {
3211     AVFormatContext *oc;
3212     int use_video, use_audio, use_subtitle;
3213     int input_has_video, input_has_audio, input_has_subtitle;
3214     AVFormatParameters params, *ap = &params;
3215
3216     if (!strcmp(filename, "-"))
3217         filename = "pipe:";
3218
3219     oc = av_alloc_format_context();
3220
3221     if (!file_oformat) {
3222         file_oformat = guess_format(NULL, filename, NULL);
3223         if (!file_oformat) {
3224             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3225                     filename);
3226             av_exit(1);
3227         }
3228     }
3229
3230     oc->oformat = file_oformat;
3231     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3232
3233     if (!strcmp(file_oformat->name, "ffm") &&
3234         av_strstart(filename, "http:", NULL)) {
3235         /* special case for files sent to ffserver: we get the stream
3236            parameters from ffserver */
3237         int err = read_ffserver_streams(oc, filename);
3238         if (err < 0) {
3239             print_error(filename, err);
3240             av_exit(1);
3241         }
3242     } else {
3243         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3244         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3245         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3246
3247         /* disable if no corresponding type found and at least one
3248            input file */
3249         if (nb_input_files > 0) {
3250             check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3251                                          &input_has_subtitle);
3252             if (!input_has_video)
3253                 use_video = 0;
3254             if (!input_has_audio)
3255                 use_audio = 0;
3256             if (!input_has_subtitle)
3257                 use_subtitle = 0;
3258         }
3259
3260         /* manual disable */
3261         if (audio_disable) {
3262             use_audio = 0;
3263         }
3264         if (video_disable) {
3265             use_video = 0;
3266         }
3267         if (subtitle_disable) {
3268             use_subtitle = 0;
3269         }
3270
3271         if (use_video) {
3272             new_video_stream(oc);
3273         }
3274
3275         if (use_audio) {
3276             new_audio_stream(oc);
3277         }
3278
3279         if (use_subtitle) {
3280             new_subtitle_stream(oc);
3281         }
3282
3283         oc->timestamp = rec_timestamp;
3284
3285         if (str_title)
3286             av_strlcpy(oc->title, str_title, sizeof(oc->title));
3287         if (str_author)
3288             av_strlcpy(oc->author, str_author, sizeof(oc->author));
3289         if (str_copyright)
3290             av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3291         if (str_comment)
3292             av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3293         if (str_album)
3294             av_strlcpy(oc->album, str_album, sizeof(oc->album));
3295         if (str_genre)
3296             av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3297     }
3298
3299     output_files[nb_output_files++] = oc;
3300
3301     /* check filename in case of an image number is expected */
3302     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3303         if (!av_filename_number_test(oc->filename)) {
3304             print_error(oc->filename, AVERROR_NUMEXPECTED);
3305             av_exit(1);
3306         }
3307     }
3308
3309     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3310         /* test if it already exists to avoid loosing precious files */
3311         if (!file_overwrite &&
3312             (strchr(filename, ':') == NULL ||
3313              filename[1] == ':' ||
3314              av_strstart(filename, "file:", NULL))) {
3315             if (url_exist(filename)) {
3316                 int c;
3317
3318                 if (!using_stdin) {
3319                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3320                     fflush(stderr);
3321                     c = getchar();
3322                     if (toupper(c) != 'Y') {
3323                         fprintf(stderr, "Not overwriting - exiting\n");
3324                         av_exit(1);
3325                     }
3326                 }
3327                 else {
3328                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3329                     av_exit(1);
3330                 }
3331             }
3332         }
3333
3334         /* open the file */
3335         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3336             fprintf(stderr, "Could not open '%s'\n", filename);
3337             av_exit(1);
3338         }
3339     }
3340
3341     memset(ap, 0, sizeof(*ap));
3342     if (av_set_parameters(oc, ap) < 0) {
3343         fprintf(stderr, "%s: Invalid encoding parameters\n",
3344                 oc->filename);
3345         av_exit(1);
3346     }
3347
3348     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3349     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3350     oc->loop_output = loop_output;
3351
3352     set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3353
3354     /* reset some options */
3355     file_oformat = NULL;
3356     file_iformat = NULL;
3357 }
3358
3359 /* same option as mencoder */
3360 static void opt_pass(const char *pass_str)
3361 {
3362     int pass;
3363     pass = atoi(pass_str);
3364     if (pass != 1 && pass != 2) {
3365         fprintf(stderr, "pass number can be only 1 or 2\n");
3366         av_exit(1);
3367     }
3368     do_pass = pass;
3369 }
3370
3371 static int64_t getutime(void)
3372 {
3373 #ifdef HAVE_GETRUSAGE
3374     struct rusage rusage;
3375
3376     getrusage(RUSAGE_SELF, &rusage);
3377     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3378 #elif defined(HAVE_GETPROCESSTIMES)
3379     HANDLE proc;
3380     FILETIME c, e, k, u;
3381     proc = GetCurrentProcess();
3382     GetProcessTimes(proc, &c, &e, &k, &u);
3383     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3384 #else
3385     return av_gettime();
3386 #endif
3387 }
3388
3389 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3390 {
3391     int i;
3392     const char *p = str;
3393     for(i = 0;; i++) {
3394         dest[i] = atoi(p);
3395         if(i == 63)
3396             break;
3397         p = strchr(p, ',');
3398         if(!p) {
3399             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3400             av_exit(1);
3401         }
3402         p++;
3403     }
3404 }
3405
3406 static void opt_inter_matrix(const char *arg)
3407 {
3408     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3409     parse_matrix_coeffs(inter_matrix, arg);
3410 }
3411
3412 static void opt_intra_matrix(const char *arg)
3413 {
3414     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3415     parse_matrix_coeffs(intra_matrix, arg);
3416 }
3417
3418 /**
3419  * Trivial log callback.
3420  * Only suitable for show_help and similar since it lacks prefix handling.
3421  */
3422 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3423 {
3424     vfprintf(stdout, fmt, vl);
3425 }
3426
3427 static void show_help(void)
3428 {
3429     av_log_set_callback(log_callback_help);
3430     printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3431            "Hyper fast Audio and Video encoder\n");
3432     printf("\n");
3433     show_help_options(options, "Main options:\n",
3434                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3435     show_help_options(options, "\nAdvanced options:\n",
3436                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3437                       OPT_EXPERT);
3438     show_help_options(options, "\nVideo options:\n",
3439                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3440                       OPT_VIDEO);
3441     show_help_options(options, "\nAdvanced Video options:\n",
3442                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3443                       OPT_VIDEO | OPT_EXPERT);
3444     show_help_options(options, "\nAudio options:\n",
3445                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3446                       OPT_AUDIO);
3447     show_help_options(options, "\nAdvanced Audio options:\n",
3448                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3449                       OPT_AUDIO | OPT_EXPERT);
3450     show_help_options(options, "\nSubtitle options:\n",
3451                       OPT_SUBTITLE | OPT_GRAB,
3452                       OPT_SUBTITLE);
3453     show_help_options(options, "\nAudio/Video grab options:\n",
3454                       OPT_GRAB,
3455                       OPT_GRAB);
3456     printf("\n");
3457     av_opt_show(avctx_opts[0], NULL);
3458     printf("\n");
3459     av_opt_show(avformat_opts, NULL);
3460     printf("\n");
3461     av_opt_show(sws_opts, NULL);
3462 }
3463
3464 static void opt_target(const char *arg)
3465 {
3466     int norm = -1;
3467     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3468
3469     if(!strncmp(arg, "pal-", 4)) {
3470         norm = 0;
3471         arg += 4;
3472     } else if(!strncmp(arg, "ntsc-", 5)) {
3473         norm = 1;
3474         arg += 5;
3475     } else if(!strncmp(arg, "film-", 5)) {
3476         norm = 2;
3477         arg += 5;
3478     } else {
3479         int fr;
3480         /* Calculate FR via float to avoid int overflow */
3481         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3482         if(fr == 25000) {
3483             norm = 0;
3484         } else if((fr == 29970) || (fr == 23976)) {
3485             norm = 1;
3486         } else {
3487             /* Try to determine PAL/NTSC by peeking in the input files */
3488             if(nb_input_files) {
3489                 int i, j;
3490                 for(j = 0; j < nb_input_files; j++) {
3491                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3492                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3493                         if(c->codec_type != CODEC_TYPE_VIDEO)
3494                             continue;
3495                         fr = c->time_base.den * 1000 / c->time_base.num;
3496                         if(fr == 25000) {
3497                             norm = 0;
3498                             break;
3499                         } else if((fr == 29970) || (fr == 23976)) {
3500                             norm = 1;
3501                             break;
3502                         }
3503                     }
3504                     if(norm >= 0)
3505                         break;
3506                 }
3507             }
3508         }
3509         if(verbose && norm >= 0)
3510             fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3511     }
3512
3513     if(norm < 0) {
3514         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3515         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3516         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3517         av_exit(1);
3518     }
3519
3520     if(!strcmp(arg, "vcd")) {
3521
3522         opt_video_codec("mpeg1video");
3523         opt_audio_codec("mp2");
3524         opt_format("vcd");
3525
3526         opt_frame_size(norm ? "352x240" : "352x288");
3527         opt_frame_rate(frame_rates[norm]);
3528         opt_default("gop", norm ? "18" : "15");
3529
3530         opt_default("b", "1150000");
3531         opt_default("maxrate", "1150000");
3532         opt_default("minrate", "1150000");
3533         opt_default("bufsize", "327680"); // 40*1024*8;
3534
3535         opt_default("ab", "224000");
3536         audio_sample_rate = 44100;
3537         audio_channels = 2;
3538
3539         opt_default("packetsize", "2324");
3540         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3541
3542         /* We have to offset the PTS, so that it is consistent with the SCR.
3543            SCR starts at 36000, but the first two packs contain only padding
3544            and the first pack from the other stream, respectively, may also have
3545            been written before.
3546            So the real data starts at SCR 36000+3*1200. */
3547         mux_preload= (36000+3*1200) / 90000.0; //0.44
3548     } else if(!strcmp(arg, "svcd")) {
3549
3550         opt_video_codec("mpeg2video");
3551         opt_audio_codec("mp2");
3552         opt_format("svcd");
3553
3554         opt_frame_size(norm ? "480x480" : "480x576");
3555         opt_frame_rate(frame_rates[norm]);
3556         opt_default("gop", norm ? "18" : "15");
3557
3558         opt_default("b", "2040000");
3559         opt_default("maxrate", "2516000");
3560         opt_default("minrate", "0"); //1145000;
3561         opt_default("bufsize", "1835008"); //224*1024*8;
3562         opt_default("flags", "+SCAN_OFFSET");
3563
3564
3565         opt_default("ab", "224000");
3566         audio_sample_rate = 44100;
3567
3568         opt_default("packetsize", "2324");
3569
3570     } else if(!strcmp(arg, "dvd")) {
3571
3572         opt_video_codec("mpeg2video");
3573         opt_audio_codec("ac3");
3574         opt_format("dvd");
3575
3576         opt_frame_size(norm ? "720x480" : "720x576");
3577         opt_frame_rate(frame_rates[norm]);
3578         opt_default("gop", norm ? "18" : "15");
3579
3580         opt_default("b", "6000000");
3581         opt_default("maxrate", "9000000");
3582         opt_default("minrate", "0"); //1500000;
3583         opt_default("bufsize", "1835008"); //224*1024*8;
3584
3585         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3586         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3587
3588         opt_default("ab", "448000");
3589         audio_sample_rate = 48000;
3590
3591     } else if(!strncmp(arg, "dv", 2)) {
3592
3593         opt_format("dv");
3594
3595         opt_frame_size(norm ? "720x480" : "720x576");
3596         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3597                                              (norm ? "yuv411p" : "yuv420p"));
3598         opt_frame_rate(frame_rates[norm]);
3599
3600         audio_sample_rate = 48000;
3601         audio_channels = 2;
3602
3603     } else {
3604         fprintf(stderr, "Unknown target: %s\n", arg);
3605         av_exit(1);
3606     }
3607 }
3608
3609 static void opt_vstats_file (const char *arg)
3610 {
3611     av_free (vstats_filename);
3612     vstats_filename=av_strdup (arg);
3613 }
3614
3615 static void opt_vstats (void)
3616 {
3617     char filename[40];
3618     time_t today2 = time(NULL);
3619     struct tm *today = localtime(&today2);
3620
3621     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3622              today->tm_sec);
3623     opt_vstats_file(filename);
3624 }
3625
3626 static int opt_bsf(const char *opt, const char *arg)
3627 {
3628     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3629     AVBitStreamFilterContext **bsfp;
3630
3631     if(!bsfc){
3632         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3633         av_exit(1);
3634     }
3635
3636     bsfp= *opt == 'v' ? &video_bitstream_filters :
3637           *opt == 'a' ? &audio_bitstream_filters :
3638                         &subtitle_bitstream_filters;
3639     while(*bsfp)
3640         bsfp= &(*bsfp)->next;
3641
3642     *bsfp= bsfc;
3643
3644     return 0;
3645 }
3646
3647 static int opt_preset(const char *opt, const char *arg)
3648 {
3649     FILE *f=NULL;
3650     char tmp[1000], tmp2[1000];
3651     int i;
3652     const char *base[3]= { getenv("HOME"),
3653                            "/usr/local/share",
3654                            "/usr/share",
3655                          };
3656
3657     for(i=!base[0]; i<3 && !f; i++){
3658         snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3659         f= fopen(tmp, "r");
3660         if(!f){
3661             char *codec_name= *opt == 'v' ? video_codec_name :
3662                               *opt == 'a' ? audio_codec_name :
3663                                             subtitle_codec_name;
3664               snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s-%s.ffpreset", base[i],  i ? "" : ".", codec_name, arg);
3665             f= fopen(tmp, "r");
3666         }
3667     }
3668
3669     if(!f){
3670         fprintf(stderr, "Preset file not found\n");
3671         av_exit(1);
3672     }
3673
3674     while(!feof(f)){
3675         int e= fscanf(f, "%999[^=]=%999[^\n]\n", tmp, tmp2);
3676         if(e!=2){
3677             fprintf(stderr, "Preset file invalid\n");
3678             av_exit(1);
3679         }
3680         if(!strcmp(tmp, "acodec")){
3681             opt_audio_codec(tmp2);
3682         }else if(!strcmp(tmp, "vcodec")){
3683             opt_video_codec(tmp2);
3684         }else if(!strcmp(tmp, "scodec")){
3685             opt_subtitle_codec(tmp2);
3686         }else
3687             opt_default(tmp, tmp2);
3688     }
3689
3690     fclose(f);
3691
3692     return 0;
3693 }
3694
3695 static const OptionDef options[] = {
3696     /* main options */
3697     { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3698     { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3699     { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3700     { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3701     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3702     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3703     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3704     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3705     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3706     { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3707     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3708     { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3709     { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3710     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3711     { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3712     { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3713     { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3714     { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3715     { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3716     { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3717     { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3718     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3719     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3720       "add timings for benchmarking" },
3721     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3722       "dump each input packet" },
3723     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3724       "when dumping packets, also dump the payload" },
3725     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3726     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3727     { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
3728     { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3729     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3730     { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3731     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3732     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3733     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3734     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3735     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3736     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3737     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3738     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3739
3740     /* video options */
3741     { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3742     { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3743     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3744     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3745     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3746     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3747     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
3748     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3749     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3750     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3751     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3752     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3753     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3754     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3755     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3756     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3757     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3758     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3759     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3760     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3761     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3762     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3763     { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
3764     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3765       "use same video quality as source (implies VBR)" },
3766     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3767     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3768     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3769       "deinterlace pictures" },
3770     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3771     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3772     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3773 #ifdef CONFIG_VHOOK
3774     { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3775 #endif
3776     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3777     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3778     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3779     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3780     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3781     { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3782     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3783
3784     /* audio options */
3785     { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3786     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3787     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3788     { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3789     { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3790     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3791     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3792     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3793     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3794     { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3795     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3796
3797     /* subtitle options */
3798     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3799     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3800     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3801     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3802
3803     /* grab options */
3804     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3805     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3806     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3807
3808     /* muxer options */
3809     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3810     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3811
3812     { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3813     { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3814     { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3815
3816     { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3817     { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3818     { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3819
3820     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3821     { NULL, },
3822 };
3823
3824 int main(int argc, char **argv)
3825 {
3826     int i;
3827     int64_t ti;
3828
3829     avcodec_register_all();
3830     avdevice_register_all();
3831     av_register_all();
3832
3833     if(isatty(STDIN_FILENO))
3834         url_set_interrupt_cb(decode_interrupt_cb);
3835
3836     for(i=0; i<CODEC_TYPE_NB; i++){
3837         avctx_opts[i]= avcodec_alloc_context2(i);
3838     }
3839     avformat_opts = av_alloc_format_context();
3840     sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3841
3842     show_banner();
3843     if (argc <= 1) {
3844         show_help();
3845         av_exit(1);
3846     }
3847
3848     /* parse options */
3849     parse_options(argc, argv, options, opt_output_file);
3850
3851     /* file converter / grab */
3852     if (nb_output_files <= 0) {
3853         fprintf(stderr, "Must supply at least one output file\n");
3854         av_exit(1);
3855     }
3856
3857     if (nb_input_files == 0) {
3858         fprintf(stderr, "Must supply at least one input file\n");
3859         av_exit(1);
3860     }
3861
3862     ti = getutime();
3863     av_encode(output_files, nb_output_files, input_files, nb_input_files,
3864               stream_maps, nb_stream_maps);
3865     ti = getutime() - ti;
3866     if (do_benchmark) {
3867         printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3868     }
3869
3870     return av_exit(0);
3871 }