git.sesse.net Git - ffmpeg/blob - ffmpeg.c

   1 /*
   2  * FFmpeg main
   3  * Copyright (c) 2000-2003 Fabrice Bellard
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19 #define HAVE_AV_CONFIG_H
  20 #include <limits.h>
  21 #include "avformat.h"
  22 #include "framehook.h"
  23 #include "dsputil.h"
  24
  25 #ifndef CONFIG_WIN32
  26 #include <unistd.h>
  27 #include <fcntl.h>
  28 #include <sys/ioctl.h>
  29 #include <sys/time.h>
  30 #include <termios.h>
  31 #include <sys/resource.h>
  32 #include <signal.h>
  33 #endif
  34 #ifdef CONFIG_OS2
  35 #include <sys/types.h>
  36 #include <sys/select.h>
  37 #include <stdlib.h>
  38 #endif
  39 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
  40 #include <time.h>
  41
  42 #include "cmdutils.h"
  43
  44 #undef NDEBUG
  45 #include <assert.h>
  46
  47 #if !defined(INFINITY) && defined(HUGE_VAL)
  48 #define INFINITY HUGE_VAL
  49 #endif
  50
  51 /* select an input stream for an output stream */
  52 typedef struct AVStreamMap {
  53     int file_index;
  54     int stream_index;
  55 } AVStreamMap;
  56
  57 /** select an input file for an output file */
  58 typedef struct AVMetaDataMap {
  59     int out_file;
  60     int in_file;
  61 } AVMetaDataMap;
  62
  63 extern const OptionDef options[];
  64
  65 static void show_help(void);
  66 static void show_license(void);
  67
  68 #define MAX_FILES 20
  69
  70 static AVFormatContext *input_files[MAX_FILES];
  71 static int64_t input_files_ts_offset[MAX_FILES];
  72 static int nb_input_files = 0;
  73
  74 static AVFormatContext *output_files[MAX_FILES];
  75 static int nb_output_files = 0;
  76
  77 static AVStreamMap stream_maps[MAX_FILES];
  78 static int nb_stream_maps;
  79
  80 static AVMetaDataMap meta_data_maps[MAX_FILES];
  81 static int nb_meta_data_maps;
  82
  83 static AVInputFormat *file_iformat;
  84 static AVOutputFormat *file_oformat;
  85 static AVImageFormat *image_format;
  86 static int frame_width  = 0;
  87 static int frame_height = 0;
  88 static float frame_aspect_ratio = 0;
  89 static enum PixelFormat frame_pix_fmt = PIX_FMT_YUV420P;
  90 static int frame_padtop  = 0;
  91 static int frame_padbottom = 0;
  92 static int frame_padleft  = 0;
  93 static int frame_padright = 0;
  94 static int padcolor[3] = {16,128,128}; /* default to black */
  95 static int frame_topBand  = 0;
  96 static int frame_bottomBand = 0;
  97 static int frame_leftBand  = 0;
  98 static int frame_rightBand = 0;
  99 static int max_frames[3] = {INT_MAX, INT_MAX, INT_MAX};
 100 static int frame_rate = 25;
 101 static int frame_rate_base = 1;
 102 static int video_bit_rate = 200*1000;
 103 static int video_bit_rate_tolerance = 4000*1000;
 104 static float video_qscale = 0;
 105 static int video_qmin = 2;
 106 static int video_qmax = 31;
 107 static int video_lmin = 2*FF_QP2LAMBDA;
 108 static int video_lmax = 31*FF_QP2LAMBDA;
 109 static int video_mb_lmin = 2*FF_QP2LAMBDA;
 110 static int video_mb_lmax = 31*FF_QP2LAMBDA;
 111 static int video_qdiff = 3;
 112 static int video_lelim = 0;
 113 static int video_celim = 0;
 114 static float video_qblur = 0.5;
 115 static float video_qsquish = 0.0;
 116 static float video_qcomp = 0.5;
 117 static uint16_t *intra_matrix = NULL;
 118 static uint16_t *inter_matrix = NULL;
 119 #if 0 //experimental, (can be removed)
 120 static float video_rc_qsquish=1.0;
 121 static float video_rc_qmod_amp=0;
 122 static int video_rc_qmod_freq=0;
 123 #endif
 124 static char *video_rc_override_string=NULL;
 125 static char *video_rc_eq="tex^qComp";
 126 static int video_rc_buffer_size=0;
 127 static float video_rc_buffer_aggressivity=1.0;
 128 static int video_rc_max_rate=0;
 129 static int video_rc_min_rate=0;
 130 static float video_rc_initial_cplx=0;
 131 static float video_b_qfactor = 1.25;
 132 static float video_b_qoffset = 1.25;
 133 static float video_i_qfactor = -0.8;
 134 static float video_i_qoffset = 0.0;
 135 static int video_intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
 136 static int video_inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
 137 static int me_method = ME_EPZS;
 138 static int video_disable = 0;
 139 static int video_discard = 0;
 140 static int video_codec_id = CODEC_ID_NONE;
 141 static int video_codec_tag = 0;
 142 static int same_quality = 0;
 143 static int b_frames = 0;
 144 static int mb_decision = FF_MB_DECISION_SIMPLE;
 145 static int ildct_cmp = FF_CMP_VSAD;
 146 static int mb_cmp = FF_CMP_SAD;
 147 static int sub_cmp = FF_CMP_SAD;
 148 static int cmp = FF_CMP_SAD;
 149 static int pre_cmp = FF_CMP_SAD;
 150 static int pre_me = 0;
 151 static float lumi_mask = 0;
 152 static float dark_mask = 0;
 153 static float scplx_mask = 0;
 154 static float tcplx_mask = 0;
 155 static float p_mask = 0;
 156 static int use_4mv = 0;
 157 static int use_obmc = 0;
 158 static int use_loop = 0;
 159 static int use_aic = 0;
 160 static int use_aiv = 0;
 161 static int use_umv = 0;
 162 static int use_ss = 0;
 163 static int use_alt_scan = 0;
 164 static int use_trell = 0;
 165 static int use_scan_offset = 0;
 166 static int use_qpel = 0;
 167 static int use_qprd = 0;
 168 static int use_cbprd = 0;
 169 static int use_mv0 = 0;
 170 static int do_normalize_aqp = 0;
 171 static int qns = 0;
 172 static int closed_gop = 0;
 173 static int strict_gop = 0;
 174 static int no_output = 0;
 175 static int do_deinterlace = 0;
 176 static int do_interlace_dct = 0;
 177 static int do_interlace_me = 0;
 178 static int workaround_bugs = FF_BUG_AUTODETECT;
 179 static int error_resilience = 2;
 180 static int error_concealment = 3;
 181 static int dct_algo = 0;
 182 static int idct_algo = 0;
 183 static int use_part = 0;
 184 static int packet_size = 0;
 185 static int error_rate = 0;
 186 static int strict = 0;
 187 static int top_field_first = -1;
 188 static int noise_reduction = 0;
 189 static int sc_threshold = 0;
 190 static int debug = 0;
 191 static int debug_mv = 0;
 192 static int me_threshold = 0;
 193 static int mb_threshold = 0;
 194 static int intra_dc_precision = 8;
 195 static int coder = 0;
 196 static int context = 0;
 197 static int predictor = 0;
 198 static int video_profile = FF_PROFILE_UNKNOWN;
 199 static int video_level = FF_LEVEL_UNKNOWN;
 200 static int nsse_weight = 8;
 201 static int subpel_quality= 8;
 202 static int lowres= 0;
 203 static int frame_skip_threshold= 0;
 204 static int frame_skip_factor= 0;
 205 static int frame_skip_exp= 0;
 206 static int frame_skip_cmp= FF_CMP_DCTMAX;
 207 extern int loop_input; /* currently a hack */
 208
 209 static int gop_size = 12;
 210 static int intra_only = 0;
 211 static int audio_sample_rate = 44100;
 212 static int audio_bit_rate = 64000;
 213 static int audio_disable = 0;
 214 static int audio_channels = 1;
 215 static int audio_codec_id = CODEC_ID_NONE;
 216 static int audio_codec_tag = 0;
 217
 218 static int mux_rate= 0;
 219 static int mux_packet_size= 0;
 220 static float mux_preload= 0.5;
 221 static float mux_max_delay= 0.7;
 222
 223 static int64_t recording_time = 0;
 224 static int64_t start_time = 0;
 225 static int64_t rec_timestamp = 0;
 226 static int64_t input_ts_offset = 0;
 227 static int file_overwrite = 0;
 228 static char *str_title = NULL;
 229 static char *str_author = NULL;
 230 static char *str_copyright = NULL;
 231 static char *str_comment = NULL;
 232 static int do_benchmark = 0;
 233 static int do_hex_dump = 0;
 234 static int do_pkt_dump = 0;
 235 static int do_psnr = 0;
 236 static int do_vstats = 0;
 237 static int do_pass = 0;
 238 static int bitexact = 0;
 239 static char *pass_logfilename = NULL;
 240 static int audio_stream_copy = 0;
 241 static int video_stream_copy = 0;
 242 static int video_sync_method= 1;
 243 static int audio_sync_method= 0;
 244 static int copy_ts= 0;
 245 static int opt_shortest = 0; //
 246
 247 static int rate_emu = 0;
 248
 249 static char *video_grab_format = "video4linux";
 250 static char *video_device = NULL;
 251 static char *grab_device = NULL;
 252 static int  video_channel = 0;
 253 static char *video_standard = "ntsc";
 254
 255 static char *audio_grab_format = "audio_device";
 256 static char *audio_device = NULL;
 257
 258 static int using_stdin = 0;
 259 static int using_vhook = 0;
 260 static int verbose = 1;
 261 static int thread_count= 1;
 262 static int q_pressed = 0;
 263 static int me_range = 0;
 264 static int64_t video_size = 0;
 265 static int64_t audio_size = 0;
 266 static int64_t extra_size = 0;
 267 static int nb_frames_dup = 0;
 268 static int nb_frames_drop = 0;
 269 static int input_sync;
 270 static int limit_filesize = 0; //
 271
 272 static int pgmyuv_compatibility_hack=0;
 273
 274
 275 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
 276
 277 typedef struct AVOutputStream {
 278     int file_index;          /* file index */
 279     int index;               /* stream index in the output file */
 280     int source_index;        /* AVInputStream index */
 281     AVStream *st;            /* stream in the output file */
 282     int encoding_needed;     /* true if encoding needed for this stream */
 283     int frame_number;
 284     /* input pts and corresponding output pts
 285        for A/V sync */
 286     double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
 287     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
 288     /* video only */
 289     int video_resample;      /* video_resample and video_crop are mutually exclusive */
 290     AVFrame pict_tmp;      /* temporary image for resampling */
 291     ImgReSampleContext *img_resample_ctx; /* for image resampling */
 292
 293     int video_crop;          /* video_resample and video_crop are mutually exclusive */
 294     int topBand;             /* cropping area sizes */
 295     int leftBand;
 296
 297     int video_pad;           /* video_resample and video_pad are mutually exclusive */
 298     int padtop;              /* padding area sizes */
 299     int padbottom;
 300     int padleft;
 301     int padright;
 302
 303     /* audio only */
 304     int audio_resample;
 305     ReSampleContext *resample; /* for audio resampling */
 306     FifoBuffer fifo;     /* for compression: one audio fifo per codec */
 307     FILE *logfile;
 308 } AVOutputStream;
 309
 310 typedef struct AVInputStream {
 311     int file_index;
 312     int index;
 313     AVStream *st;
 314     int discard;             /* true if stream data should be discarded */
 315     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
 316     int64_t sample_index;      /* current sample */
 317
 318     int64_t       start;     /* time when read started */
 319     unsigned long frame;     /* current frame */
 320     int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
 321                                 is not defined */
 322     int64_t       pts;       /* current pts */
 323     int is_start;            /* is 1 at the start and after a discontinuity */
 324 } AVInputStream;
 325
 326 typedef struct AVInputFile {
 327     int eof_reached;      /* true if eof reached */
 328     int ist_index;        /* index of first stream in ist_table */
 329     int buffer_size;      /* current total buffer size */
 330     int buffer_size_max;  /* buffer size at which we consider we can stop
 331                              buffering */
 332     int nb_streams;       /* nb streams we are aware of */
 333 } AVInputFile;
 334
 335 #ifndef CONFIG_WIN32
 336
 337 /* init terminal so that we can grab keys */
 338 static struct termios oldtty;
 339
 340 static void term_exit(void)
 341 {
 342     tcsetattr (0, TCSANOW, &oldtty);
 343 }
 344
 345 static volatile sig_atomic_t received_sigterm = 0;
 346
 347 static void
 348 sigterm_handler(int sig)
 349 {
 350     received_sigterm = sig;
 351     term_exit();
 352 }
 353
 354 static void term_init(void)
 355 {
 356     struct termios tty;
 357
 358     tcgetattr (0, &tty);
 359     oldtty = tty;
 360
 361     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 362                           |INLCR|IGNCR|ICRNL|IXON);
 363     tty.c_oflag |= OPOST;
 364     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
 365     tty.c_cflag &= ~(CSIZE|PARENB);
 366     tty.c_cflag |= CS8;
 367     tty.c_cc[VMIN] = 1;
 368     tty.c_cc[VTIME] = 0;
 369
 370     tcsetattr (0, TCSANOW, &tty);
 371
 372     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
 373     signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
 374     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
 375     /*
 376     register a function to be called at normal program termination
 377     */
 378     atexit(term_exit);
 379 #ifdef CONFIG_BEOS_NETSERVER
 380     fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
 381 #endif
 382 }
 383
 384 /* read a key without blocking */
 385 static int read_key(void)
 386 {
 387     int n = 1;
 388     unsigned char ch;
 389 #ifndef CONFIG_BEOS_NETSERVER
 390     struct timeval tv;
 391     fd_set rfds;
 392
 393     FD_ZERO(&rfds);
 394     FD_SET(0, &rfds);
 395     tv.tv_sec = 0;
 396     tv.tv_usec = 0;
 397     n = select(1, &rfds, NULL, NULL, &tv);
 398 #endif
 399     if (n > 0) {
 400         n = read(0, &ch, 1);
 401         if (n == 1)
 402             return ch;
 403
 404         return n;
 405     }
 406     return -1;
 407 }
 408
 409 static int decode_interrupt_cb(void)
 410 {
 411     return q_pressed || (q_pressed = read_key() == 'q');
 412 }
 413
 414 #else
 415
 416 static volatile int received_sigterm = 0;
 417
 418 /* no interactive support */
 419 static void term_exit(void)
 420 {
 421 }
 422
 423 static void term_init(void)
 424 {
 425 }
 426
 427 static int read_key(void)
 428 {
 429     return 0;
 430 }
 431
 432 #endif
 433
 434 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
 435 {
 436     int i, err;
 437     AVFormatContext *ic;
 438
 439     err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
 440     if (err < 0)
 441         return err;
 442     /* copy stream format */
 443     s->nb_streams = ic->nb_streams;
 444     for(i=0;i<ic->nb_streams;i++) {
 445         AVStream *st;
 446
 447         st = av_mallocz(sizeof(AVStream));
 448         memcpy(st, ic->streams[i], sizeof(AVStream));
 449         s->streams[i] = st;
 450     }
 451
 452     av_close_input_file(ic);
 453     return 0;
 454 }
 455
 456 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
 457
 458 static void do_audio_out(AVFormatContext *s,
 459                          AVOutputStream *ost,
 460                          AVInputStream *ist,
 461                          unsigned char *buf, int size)
 462 {
 463     uint8_t *buftmp;
 464     static uint8_t *audio_buf = NULL;
 465     static uint8_t *audio_out = NULL;
 466     const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
 467
 468     int size_out, frame_bytes, ret;
 469     AVCodecContext *enc= &ost->st->codec;
 470
 471     /* SC: dynamic allocation of buffers */
 472     if (!audio_buf)
 473         audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
 474     if (!audio_out)
 475         audio_out = av_malloc(audio_out_size);
 476     if (!audio_buf || !audio_out)
 477         return;               /* Should signal an error ! */
 478
 479     if(audio_sync_method){
 480         double delta = ost->sync_ipts * enc->sample_rate - ost->sync_opts
 481                 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2);
 482         double idelta= delta*ist->st->codec.sample_rate / enc->sample_rate;
 483         int byte_delta= ((int)idelta)*2*ist->st->codec.channels;
 484
 485         //FIXME resample delay
 486         if(fabs(delta) > 50){
 487             if(ist->is_start){
 488                 if(byte_delta < 0){
 489                     byte_delta= FFMAX(byte_delta, -size);
 490                     size += byte_delta;
 491                     buf  -= byte_delta;
 492                     if(verbose > 2)
 493                         fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
 494                     if(!size)
 495                         return;
 496                     ist->is_start=0;
 497                 }else{
 498                     static uint8_t *input_tmp= NULL;
 499                     input_tmp= av_realloc(input_tmp, byte_delta + size);
 500
 501                     if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
 502                         ist->is_start=0;
 503                     else
 504                         byte_delta= MAX_AUDIO_PACKET_SIZE - size;
 505
 506                     memset(input_tmp, 0, byte_delta);
 507                     memcpy(input_tmp + byte_delta, buf, size);
 508                     buf= input_tmp;
 509                     size += byte_delta;
 510                     if(verbose > 2)
 511                         fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
 512                 }
 513             }else if(audio_sync_method>1){
 514                 int comp= clip(delta, -audio_sync_method, audio_sync_method);
 515                 assert(ost->audio_resample);
 516                 if(verbose > 2)
 517                     fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
 518 //                fprintf(stderr, "drift:%f len:%d opts:%lld ipts:%lld fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(ost->sync_ipts * enc->sample_rate), fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2));
 519                 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
 520             }
 521         }
 522     }else
 523         ost->sync_opts= lrintf(ost->sync_ipts * enc->sample_rate)
 524                         - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2); //FIXME wrong
 525
 526     if (ost->audio_resample) {
 527         buftmp = audio_buf;
 528         size_out = audio_resample(ost->resample,
 529                                   (short *)buftmp, (short *)buf,
 530                                   size / (ist->st->codec.channels * 2));
 531         size_out = size_out * enc->channels * 2;
 532     } else {
 533         buftmp = buf;
 534         size_out = size;
 535     }
 536
 537     /* now encode as many frames as possible */
 538     if (enc->frame_size > 1) {
 539         /* output resampled raw samples */
 540         fifo_write(&ost->fifo, buftmp, size_out,
 541                    &ost->fifo.wptr);
 542
 543         frame_bytes = enc->frame_size * 2 * enc->channels;
 544
 545         while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
 546                      &ost->fifo.rptr) == 0) {
 547             AVPacket pkt;
 548             av_init_packet(&pkt);
 549
 550             ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
 551                                        (short *)audio_buf);
 552             audio_size += ret;
 553             pkt.stream_index= ost->index;
 554             pkt.data= audio_out;
 555             pkt.size= ret;
 556             if(enc->coded_frame)
 557                 pkt.pts= enc->coded_frame->pts;
 558             pkt.flags |= PKT_FLAG_KEY;
 559             av_interleaved_write_frame(s, &pkt);
 560
 561             ost->sync_opts += enc->frame_size;
 562         }
 563     } else {
 564         AVPacket pkt;
 565         av_init_packet(&pkt);
 566
 567         ost->sync_opts += size_out / (2 * enc->channels);
 568
 569         /* output a pcm frame */
 570         /* XXX: change encoding codec API to avoid this ? */
 571         switch(enc->codec->id) {
 572         case CODEC_ID_PCM_S16LE:
 573         case CODEC_ID_PCM_S16BE:
 574         case CODEC_ID_PCM_U16LE:
 575         case CODEC_ID_PCM_U16BE:
 576             break;
 577         default:
 578             size_out = size_out >> 1;
 579             break;
 580         }
 581         ret = avcodec_encode_audio(enc, audio_out, size_out,
 582                                    (short *)buftmp);
 583         audio_size += ret;
 584         pkt.stream_index= ost->index;
 585         pkt.data= audio_out;
 586         pkt.size= ret;
 587         if(enc->coded_frame)
 588             pkt.pts= enc->coded_frame->pts;
 589         pkt.flags |= PKT_FLAG_KEY;
 590         av_interleaved_write_frame(s, &pkt);
 591     }
 592 }
 593
 594 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
 595 {
 596     AVCodecContext *dec;
 597     AVPicture *picture2;
 598     AVPicture picture_tmp;
 599     uint8_t *buf = 0;
 600
 601     dec = &ist->st->codec;
 602
 603     /* deinterlace : must be done before any resize */
 604     if (do_deinterlace || using_vhook) {
 605         int size;
 606
 607         /* create temporary picture */
 608         size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
 609         buf = av_malloc(size);
 610         if (!buf)
 611             return;
 612
 613         picture2 = &picture_tmp;
 614         avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
 615
 616         if (do_deinterlace){
 617             if(avpicture_deinterlace(picture2, picture,
 618                                      dec->pix_fmt, dec->width, dec->height) < 0) {
 619                 /* if error, do not deinterlace */
 620                 av_free(buf);
 621                 buf = NULL;
 622                 picture2 = picture;
 623             }
 624         } else {
 625             if (img_convert(picture2, dec->pix_fmt, picture,
 626                             dec->pix_fmt, dec->width, dec->height) < 0) {
 627                 /* if error, do not copy */
 628                 av_free(buf);
 629                 buf = NULL;
 630                 picture2 = picture;
 631             }
 632         }
 633     } else {
 634         picture2 = picture;
 635     }
 636
 637     frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
 638
 639     if (picture != picture2)
 640         *picture = *picture2;
 641     *bufp = buf;
 642 }
 643
 644 /* we begin to correct av delay at this threshold */
 645 #define AV_DELAY_MAX 0.100
 646
 647
 648 /* Expects img to be yuv420 */
 649 static void fill_pad_region(AVPicture* img, int height, int width,
 650         int padtop, int padbottom, int padleft, int padright, int *color) {
 651
 652     int i, y, shift;
 653     uint8_t *optr;
 654
 655     for (i = 0; i < 3; i++) {
 656         shift = (i == 0) ? 0 : 1;
 657
 658         if (padtop || padleft) {
 659             memset(img->data[i], color[i], (((img->linesize[i] * padtop) +
 660                             padleft) >> shift));
 661         }
 662
 663         if (padleft || padright) {
 664             optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
 665                 (img->linesize[i] - (padright >> shift));
 666
 667             for (y = 0; y < ((height - (padtop + padbottom) - 1) >> shift); y++) {
 668                 memset(optr, color[i], (padleft + padright) >> shift);
 669                 optr += img->linesize[i];
 670             }
 671         }
 672
 673         if (padbottom || padright) {
 674             optr = img->data[i] + (((img->linesize[i] * (height - padbottom)) - padright) >> shift);
 675             memset(optr, color[i], (((img->linesize[i] * padbottom) + padright) >> shift));
 676         }
 677     }
 678 }
 679
 680 static int bit_buffer_size= 1024*256;
 681 static uint8_t *bit_buffer= NULL;
 682
 683 static void do_video_out(AVFormatContext *s,
 684                          AVOutputStream *ost,
 685                          AVInputStream *ist,
 686                          AVFrame *in_picture,
 687                          int *frame_size)
 688 {
 689     int nb_frames, i, ret;
 690     AVFrame *final_picture, *formatted_picture;
 691     AVFrame picture_format_temp, picture_crop_temp;
 692     uint8_t *buf = NULL, *buf1 = NULL;
 693     AVCodecContext *enc, *dec;
 694     enum PixelFormat target_pixfmt;
 695
 696     avcodec_get_frame_defaults(&picture_format_temp);
 697     avcodec_get_frame_defaults(&picture_crop_temp);
 698
 699     enc = &ost->st->codec;
 700     dec = &ist->st->codec;
 701
 702     /* by default, we output a single frame */
 703     nb_frames = 1;
 704
 705     *frame_size = 0;
 706
 707     if(video_sync_method){
 708         double vdelta;
 709         vdelta = ost->sync_ipts * enc->frame_rate / enc->frame_rate_base - ost->sync_opts;
 710         //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
 711         if (vdelta < -1.1)
 712             nb_frames = 0;
 713         else if (vdelta > 1.1)
 714             nb_frames = lrintf(vdelta);
 715 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%lld, ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
 716         if (nb_frames == 0){
 717             ++nb_frames_drop;
 718             if (verbose>2)
 719                 fprintf(stderr, "*** drop!\n");
 720         }else if (nb_frames > 1) {
 721             nb_frames_dup += nb_frames;
 722             if (verbose>2)
 723                 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
 724         }
 725     }else
 726         ost->sync_opts= lrintf(ost->sync_ipts * enc->frame_rate / enc->frame_rate_base);
 727
 728     nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
 729     if (nb_frames <= 0)
 730         return;
 731
 732     /* convert pixel format if needed */
 733     target_pixfmt = ost->video_resample || ost->video_pad
 734         ? PIX_FMT_YUV420P : enc->pix_fmt;
 735     if (dec->pix_fmt != target_pixfmt) {
 736         int size;
 737
 738         /* create temporary picture */
 739         size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
 740         buf = av_malloc(size);
 741         if (!buf)
 742             return;
 743         formatted_picture = &picture_format_temp;
 744         avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
 745
 746         if (img_convert((AVPicture*)formatted_picture, target_pixfmt,
 747                         (AVPicture *)in_picture, dec->pix_fmt,
 748                         dec->width, dec->height) < 0) {
 749
 750             if (verbose >= 0)
 751                 fprintf(stderr, "pixel format conversion not handled\n");
 752
 753             goto the_end;
 754         }
 755     } else {
 756         formatted_picture = in_picture;
 757     }
 758
 759     /* XXX: resampling could be done before raw format conversion in
 760        some cases to go faster */
 761     /* XXX: only works for YUV420P */
 762     if (ost->video_resample) {
 763         final_picture = &ost->pict_tmp;
 764         img_resample(ost->img_resample_ctx, (AVPicture*)final_picture, (AVPicture*)formatted_picture);
 765
 766         if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
 767             fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
 768                     ost->padtop, ost->padbottom, ost->padleft, ost->padright,
 769                     padcolor);
 770         }
 771
 772         if (enc->pix_fmt != PIX_FMT_YUV420P) {
 773             int size;
 774
 775             av_free(buf);
 776             /* create temporary picture */
 777             size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
 778             buf = av_malloc(size);
 779             if (!buf)
 780                 return;
 781             final_picture = &picture_format_temp;
 782             avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
 783
 784             if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
 785                             (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
 786                             enc->width, enc->height) < 0) {
 787
 788                 if (verbose >= 0)
 789                     fprintf(stderr, "pixel format conversion not handled\n");
 790
 791                 goto the_end;
 792             }
 793         }
 794     } else if (ost->video_crop) {
 795         picture_crop_temp.data[0] = formatted_picture->data[0] +
 796                 (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
 797
 798         picture_crop_temp.data[1] = formatted_picture->data[1] +
 799                 ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
 800                 (ost->leftBand >> 1);
 801
 802         picture_crop_temp.data[2] = formatted_picture->data[2] +
 803                 ((ost->topBand >> 1) * formatted_picture->linesize[2]) +
 804                 (ost->leftBand >> 1);
 805
 806         picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
 807         picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
 808         picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
 809         final_picture = &picture_crop_temp;
 810     } else if (ost->video_pad) {
 811         final_picture = &ost->pict_tmp;
 812
 813         for (i = 0; i < 3; i++) {
 814             uint8_t *optr, *iptr;
 815             int shift = (i == 0) ? 0 : 1;
 816             int y, yheight;
 817
 818             /* set offset to start writing image into */
 819             optr = final_picture->data[i] + (((final_picture->linesize[i] *
 820                             ost->padtop) + ost->padleft) >> shift);
 821             iptr = formatted_picture->data[i];
 822
 823             yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
 824             for (y = 0; y < yheight; y++) {
 825                 /* copy unpadded image row into padded image row */
 826                 memcpy(optr, iptr, formatted_picture->linesize[i]);
 827                 optr += final_picture->linesize[i];
 828                 iptr += formatted_picture->linesize[i];
 829             }
 830         }
 831
 832         fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
 833                 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
 834                 padcolor);
 835
 836         if (enc->pix_fmt != PIX_FMT_YUV420P) {
 837             int size;
 838
 839             av_free(buf);
 840             /* create temporary picture */
 841             size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
 842             buf = av_malloc(size);
 843             if (!buf)
 844                 return;
 845             final_picture = &picture_format_temp;
 846             avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
 847
 848             if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
 849                         (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
 850                         enc->width, enc->height) < 0) {
 851
 852                 if (verbose >= 0)
 853                     fprintf(stderr, "pixel format conversion not handled\n");
 854
 855                 goto the_end;
 856             }
 857         }
 858     } else {
 859         final_picture = formatted_picture;
 860     }
 861     /* duplicates frame if needed */
 862     for(i=0;i<nb_frames;i++) {
 863         AVPacket pkt;
 864         av_init_packet(&pkt);
 865         pkt.stream_index= ost->index;
 866
 867         if (s->oformat->flags & AVFMT_RAWPICTURE) {
 868             /* raw pictures are written as AVPicture structure to
 869                avoid any copies. We support temorarily the older
 870                method. */
 871             AVFrame* old_frame = enc->coded_frame;
 872             enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
 873             pkt.data= (uint8_t *)final_picture;
 874             pkt.size=  sizeof(AVPicture);
 875             if(dec->coded_frame)
 876                 pkt.pts= dec->coded_frame->pts;
 877             if(dec->coded_frame && dec->coded_frame->key_frame)
 878                 pkt.flags |= PKT_FLAG_KEY;
 879
 880             av_interleaved_write_frame(s, &pkt);
 881             enc->coded_frame = old_frame;
 882         } else {
 883             AVFrame big_picture;
 884
 885             big_picture= *final_picture;
 886             /* better than nothing: use input picture interlaced
 887                settings */
 888             big_picture.interlaced_frame = in_picture->interlaced_frame;
 889             if(do_interlace_me || do_interlace_dct){
 890                 if(top_field_first == -1)
 891                     big_picture.top_field_first = in_picture->top_field_first;
 892                 else
 893                     big_picture.top_field_first = top_field_first;
 894             }
 895
 896             /* handles sameq here. This is not correct because it may
 897                not be a global option */
 898             if (same_quality) {
 899                 big_picture.quality = ist->st->quality;
 900             }else
 901                 big_picture.quality = ost->st->quality;
 902             if(!me_threshold)
 903                 big_picture.pict_type = 0;
 904 //            big_picture.pts = AV_NOPTS_VALUE;
 905             big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->frame_rate_base, enc->frame_rate);
 906 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
 907             ret = avcodec_encode_video(enc,
 908                                        bit_buffer, bit_buffer_size,
 909                                        &big_picture);
 910             //enc->frame_number = enc->real_pict_num;
 911             if(ret>0){
 912                 pkt.data= bit_buffer;
 913                 pkt.size= ret;
 914                 if(enc->coded_frame)
 915                     pkt.pts= enc->coded_frame->pts;
 916 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
 917    pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->frame_rate, AV_TIME_BASE*(int64_t)enc->frame_rate_base) : -1,
 918    pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->frame_rate, AV_TIME_BASE*(int64_t)enc->frame_rate_base) : -1);*/
 919
 920                 if(enc->coded_frame && enc->coded_frame->key_frame)
 921                     pkt.flags |= PKT_FLAG_KEY;
 922                 av_interleaved_write_frame(s, &pkt);
 923                 *frame_size = ret;
 924                 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
 925                 //        enc->frame_number-1, enc->real_pict_num, ret,
 926                 //        enc->pict_type);
 927                 /* if two pass, output log */
 928                 if (ost->logfile && enc->stats_out) {
 929                     fprintf(ost->logfile, "%s", enc->stats_out);
 930                 }
 931             }
 932         }
 933         ost->sync_opts++;
 934         ost->frame_number++;
 935     }
 936  the_end:
 937     av_free(buf);
 938     av_free(buf1);
 939 }
 940
 941 static double psnr(double d){
 942     if(d==0) return INFINITY;
 943     return -10.0*log(d)/log(10.0);
 944 }
 945
 946 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
 947                            int frame_size)
 948 {
 949     static FILE *fvstats=NULL;
 950     char filename[40];
 951     time_t today2;
 952     struct tm *today;
 953     AVCodecContext *enc;
 954     int frame_number;
 955     int64_t ti;
 956     double ti1, bitrate, avg_bitrate;
 957
 958     if (!fvstats) {
 959         today2 = time(NULL);
 960         today = localtime(&today2);
 961         snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
 962                                                today->tm_min,
 963                                                today->tm_sec);
 964         fvstats = fopen(filename,"w");
 965         if (!fvstats) {
 966             perror("fopen");
 967             exit(1);
 968         }
 969     }
 970
 971     ti = MAXINT64;
 972     enc = &ost->st->codec;
 973     if (enc->codec_type == CODEC_TYPE_VIDEO) {
 974         frame_number = ost->frame_number;
 975         fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
 976         if (enc->flags&CODEC_FLAG_PSNR)
 977             fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
 978
 979         fprintf(fvstats,"f_size= %6d ", frame_size);
 980         /* compute pts value */
 981         ti1 = (double)ost->sync_opts *enc->frame_rate_base / enc->frame_rate;
 982         if (ti1 < 0.01)
 983             ti1 = 0.01;
 984
 985         bitrate = (double)(frame_size * 8) * enc->frame_rate / enc->frame_rate_base / 1000.0;
 986         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
 987         fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
 988             (double)video_size / 1024, ti1, bitrate, avg_bitrate);
 989         fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
 990     }
 991 }
 992
 993 static void print_report(AVFormatContext **output_files,
 994                          AVOutputStream **ost_table, int nb_ostreams,
 995                          int is_last_report)
 996 {
 997     char buf[1024];
 998     AVOutputStream *ost;
 999     AVFormatContext *oc, *os;
1000     int64_t total_size;
1001     AVCodecContext *enc;
1002     int frame_number, vid, i;
1003     double bitrate, ti1, pts;
1004     static int64_t last_time = -1;
1005
1006     if (!is_last_report) {
1007         int64_t cur_time;
1008         /* display the report every 0.5 seconds */
1009         cur_time = av_gettime();
1010         if (last_time == -1) {
1011             last_time = cur_time;
1012             return;
1013         }
1014         if ((cur_time - last_time) < 500000)
1015             return;
1016         last_time = cur_time;
1017     }
1018
1019
1020     oc = output_files[0];
1021
1022     total_size = url_ftell(&oc->pb);
1023
1024     buf[0] = '\0';
1025     ti1 = 1e10;
1026     vid = 0;
1027     for(i=0;i<nb_ostreams;i++) {
1028         ost = ost_table[i];
1029         os = output_files[ost->file_index];
1030         enc = &ost->st->codec;
1031         if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1032             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1033                     enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1034         }
1035         if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1036             frame_number = ost->frame_number;
1037             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%2.1f ",
1038                     frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : 0);
1039             if(is_last_report)
1040                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1041             if (enc->flags&CODEC_FLAG_PSNR){
1042                 int j;
1043                 double error, error_sum=0;
1044                 double scale, scale_sum=0;
1045                 char type[3]= {'Y','U','V'};
1046                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1047                 for(j=0; j<3; j++){
1048                     if(is_last_report){
1049                         error= enc->error[j];
1050                         scale= enc->width*enc->height*255.0*255.0*frame_number;
1051                     }else{
1052                         error= enc->coded_frame->error[j];
1053                         scale= enc->width*enc->height*255.0*255.0;
1054                     }
1055                     if(j) scale/=4;
1056                     error_sum += error;
1057                     scale_sum += scale;
1058                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1059                 }
1060                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1061             }
1062             vid = 1;
1063         }
1064         /* compute min output value */
1065         pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1066         if ((pts < ti1) && (pts > 0))
1067             ti1 = pts;
1068     }
1069     if (ti1 < 0.01)
1070         ti1 = 0.01;
1071
1072     if (verbose || is_last_report) {
1073         bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1074
1075         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1076             "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1077             (double)total_size / 1024, ti1, bitrate);
1078
1079         if (verbose > 1)
1080           snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1081                   nb_frames_dup, nb_frames_drop);
1082
1083         if (verbose >= 0)
1084             fprintf(stderr, "%s    \r", buf);
1085
1086         fflush(stderr);
1087     }
1088
1089     if (is_last_report && verbose >= 0){
1090         int64_t raw= audio_size + video_size + extra_size;
1091         fprintf(stderr, "\n");
1092         fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1093                 video_size/1024.0,
1094                 audio_size/1024.0,
1095                 extra_size/1024.0,
1096                 100.0*(total_size - raw)/raw
1097         );
1098     }
1099 }
1100
1101 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1102 static int output_packet(AVInputStream *ist, int ist_index,
1103                          AVOutputStream **ost_table, int nb_ostreams,
1104                          const AVPacket *pkt)
1105 {
1106     AVFormatContext *os;
1107     AVOutputStream *ost;
1108     uint8_t *ptr;
1109     int len, ret, i;
1110     uint8_t *data_buf;
1111     int data_size, got_picture;
1112     AVFrame picture;
1113     void *buffer_to_free;
1114     static int samples_size= 0;
1115     static short *samples= NULL;
1116
1117     if(!pkt){
1118         ist->pts= ist->next_pts; // needed for last packet if vsync=0
1119     } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1120         ist->next_pts = ist->pts = pkt->dts;
1121     } else {
1122 //        assert(ist->pts == ist->next_pts);
1123     }
1124
1125     if (pkt == NULL) {
1126         /* EOF handling */
1127         ptr = NULL;
1128         len = 0;
1129         goto handle_eof;
1130     }
1131
1132     len = pkt->size;
1133     ptr = pkt->data;
1134     while (len > 0) {
1135     handle_eof:
1136         /* decode the packet if needed */
1137         data_buf = NULL; /* fail safe */
1138         data_size = 0;
1139         if (ist->decoding_needed) {
1140             switch(ist->st->codec.codec_type) {
1141             case CODEC_TYPE_AUDIO:{
1142                 if(pkt)
1143                     samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1144                     /* XXX: could avoid copy if PCM 16 bits with same
1145                        endianness as CPU */
1146                 ret = avcodec_decode_audio(&ist->st->codec, samples, &data_size,
1147                                            ptr, len);
1148                 if (ret < 0)
1149                     goto fail_decode;
1150                 ptr += ret;
1151                 len -= ret;
1152                 /* Some bug in mpeg audio decoder gives */
1153                 /* data_size < 0, it seems they are overflows */
1154                 if (data_size <= 0) {
1155                     /* no audio frame */
1156                     continue;
1157                 }
1158                 data_buf = (uint8_t *)samples;
1159                 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1160                     (ist->st->codec.sample_rate * ist->st->codec.channels);
1161                 break;}
1162             case CODEC_TYPE_VIDEO:
1163                     data_size = (ist->st->codec.width * ist->st->codec.height * 3) / 2;
1164                     /* XXX: allocate picture correctly */
1165                     avcodec_get_frame_defaults(&picture);
1166
1167                     ret = avcodec_decode_video(&ist->st->codec,
1168                                                &picture, &got_picture, ptr, len);
1169                     ist->st->quality= picture.quality;
1170                     if (ret < 0)
1171                         goto fail_decode;
1172                     if (!got_picture) {
1173                         /* no picture yet */
1174                         goto discard_packet;
1175                     }
1176                     if (ist->st->codec.frame_rate_base != 0) {
1177                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1178                                           ist->st->codec.frame_rate_base) /
1179                             ist->st->codec.frame_rate;
1180                     }
1181                     len = 0;
1182                     break;
1183                 default:
1184                     goto fail_decode;
1185                 }
1186             } else {
1187                 switch(ist->st->codec.codec_type) {
1188                 case CODEC_TYPE_AUDIO:
1189                     ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec.frame_size) /
1190                         (ist->st->codec.sample_rate * ist->st->codec.channels);
1191                     break;
1192                 case CODEC_TYPE_VIDEO:
1193                     if (ist->st->codec.frame_rate_base != 0) {
1194                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1195                                           ist->st->codec.frame_rate_base) /
1196                             ist->st->codec.frame_rate;
1197                     }
1198                     break;
1199                 }
1200                 data_buf = ptr;
1201                 data_size = len;
1202                 ret = len;
1203                 len = 0;
1204             }
1205
1206             buffer_to_free = NULL;
1207             if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1208                 pre_process_video_frame(ist, (AVPicture *)&picture,
1209                                         &buffer_to_free);
1210             }
1211
1212             /* frame rate emulation */
1213             if (ist->st->codec.rate_emu) {
1214                 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec.frame_rate_base, 1000000, ist->st->codec.frame_rate);
1215                 int64_t now = av_gettime() - ist->start;
1216                 if (pts > now)
1217                     usleep(pts - now);
1218
1219                 ist->frame++;
1220             }
1221
1222 #if 0
1223             /* mpeg PTS deordering : if it is a P or I frame, the PTS
1224                is the one of the next displayed one */
1225             /* XXX: add mpeg4 too ? */
1226             if (ist->st->codec.codec_id == CODEC_ID_MPEG1VIDEO) {
1227                 if (ist->st->codec.pict_type != B_TYPE) {
1228                     int64_t tmp;
1229                     tmp = ist->last_ip_pts;
1230                     ist->last_ip_pts  = ist->frac_pts.val;
1231                     ist->frac_pts.val = tmp;
1232                 }
1233             }
1234 #endif
1235             /* if output time reached then transcode raw format,
1236                encode packets and output them */
1237             if (start_time == 0 || ist->pts >= start_time)
1238                 for(i=0;i<nb_ostreams;i++) {
1239                     int frame_size;
1240
1241                     ost = ost_table[i];
1242                     if (ost->source_index == ist_index) {
1243                         os = output_files[ost->file_index];
1244
1245 #if 0
1246                         printf("%d: got pts=%0.3f %0.3f\n", i,
1247                                (double)pkt->pts / AV_TIME_BASE,
1248                                ((double)ist->pts / AV_TIME_BASE) -
1249                                ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1250 #endif
1251                         /* set the input output pts pairs */
1252                         ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index])/ AV_TIME_BASE;
1253
1254                         if (ost->encoding_needed) {
1255                             switch(ost->st->codec.codec_type) {
1256                             case CODEC_TYPE_AUDIO:
1257                                 do_audio_out(os, ost, ist, data_buf, data_size);
1258                                 break;
1259                             case CODEC_TYPE_VIDEO:
1260                                     do_video_out(os, ost, ist, &picture, &frame_size);
1261                                     video_size += frame_size;
1262                                     if (do_vstats && frame_size)
1263                                         do_video_stats(os, ost, frame_size);
1264                                 break;
1265                             default:
1266                                 av_abort();
1267                             }
1268                         } else {
1269                             AVFrame avframe; //FIXME/XXX remove this
1270                             AVPacket opkt;
1271                             av_init_packet(&opkt);
1272
1273                             /* no reencoding needed : output the packet directly */
1274                             /* force the input stream PTS */
1275
1276                             avcodec_get_frame_defaults(&avframe);
1277                             ost->st->codec.coded_frame= &avframe;
1278                             avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1279
1280                             if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO)
1281                                 audio_size += data_size;
1282                             else if (ost->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1283                                 video_size += data_size;
1284                                 ost->sync_opts++;
1285                             }
1286
1287                             opkt.stream_index= ost->index;
1288                             opkt.data= data_buf;
1289                             opkt.size= data_size;
1290                             if(pkt->pts != AV_NOPTS_VALUE)
1291                                 opkt.pts= pkt->pts + input_files_ts_offset[ist->file_index];
1292                             else
1293                                 opkt.pts= AV_NOPTS_VALUE;
1294                             opkt.dts= pkt->dts + input_files_ts_offset[ist->file_index];
1295                             opkt.flags= pkt->flags;
1296
1297                             av_interleaved_write_frame(os, &opkt);
1298                             ost->st->codec.frame_number++;
1299                             ost->frame_number++;
1300                         }
1301                     }
1302                 }
1303             av_free(buffer_to_free);
1304         }
1305  discard_packet:
1306     if (pkt == NULL) {
1307         /* EOF handling */
1308
1309         for(i=0;i<nb_ostreams;i++) {
1310             ost = ost_table[i];
1311             if (ost->source_index == ist_index) {
1312                 AVCodecContext *enc= &ost->st->codec;
1313                 os = output_files[ost->file_index];
1314
1315                 if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1316                     continue;
1317                 if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1318                     continue;
1319
1320                 if (ost->encoding_needed) {
1321                     for(;;) {
1322                         AVPacket pkt;
1323                         av_init_packet(&pkt);
1324                         pkt.stream_index= ost->index;
1325
1326                         switch(ost->st->codec.codec_type) {
1327                         case CODEC_TYPE_AUDIO:
1328                             ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1329                             audio_size += ret;
1330                             pkt.flags |= PKT_FLAG_KEY;
1331                             break;
1332                         case CODEC_TYPE_VIDEO:
1333                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1334                             video_size += ret;
1335                             if(enc->coded_frame && enc->coded_frame->key_frame)
1336                                 pkt.flags |= PKT_FLAG_KEY;
1337                             if (ost->logfile && enc->stats_out) {
1338                                 fprintf(ost->logfile, "%s", enc->stats_out);
1339                             }
1340                             break;
1341                         default:
1342                             ret=-1;
1343                         }
1344
1345                         if(ret<=0)
1346                             break;
1347                         pkt.data= bit_buffer;
1348                         pkt.size= ret;
1349                         if(enc->coded_frame)
1350                             pkt.pts= enc->coded_frame->pts;
1351                         av_interleaved_write_frame(os, &pkt);
1352                     }
1353                 }
1354             }
1355         }
1356     }
1357
1358     return 0;
1359  fail_decode:
1360     return -1;
1361 }
1362
1363
1364 /*
1365  * The following code is the main loop of the file converter
1366  */
1367 static int av_encode(AVFormatContext **output_files,
1368                      int nb_output_files,
1369                      AVFormatContext **input_files,
1370                      int nb_input_files,
1371                      AVStreamMap *stream_maps, int nb_stream_maps)
1372 {
1373     int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1374     AVFormatContext *is, *os;
1375     AVCodecContext *codec, *icodec;
1376     AVOutputStream *ost, **ost_table = NULL;
1377     AVInputStream *ist, **ist_table = NULL;
1378     AVInputFile *file_table;
1379     AVFormatContext *stream_no_data;
1380     int key;
1381
1382     file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1383     if (!file_table)
1384         goto fail;
1385
1386     /* input stream init */
1387     j = 0;
1388     for(i=0;i<nb_input_files;i++) {
1389         is = input_files[i];
1390         file_table[i].ist_index = j;
1391         file_table[i].nb_streams = is->nb_streams;
1392         j += is->nb_streams;
1393     }
1394     nb_istreams = j;
1395
1396     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1397     if (!ist_table)
1398         goto fail;
1399
1400     for(i=0;i<nb_istreams;i++) {
1401         ist = av_mallocz(sizeof(AVInputStream));
1402         if (!ist)
1403             goto fail;
1404         ist_table[i] = ist;
1405     }
1406     j = 0;
1407     for(i=0;i<nb_input_files;i++) {
1408         is = input_files[i];
1409         for(k=0;k<is->nb_streams;k++) {
1410             ist = ist_table[j++];
1411             ist->st = is->streams[k];
1412             ist->file_index = i;
1413             ist->index = k;
1414             ist->discard = 1; /* the stream is discarded by default
1415                                  (changed later) */
1416
1417             if (ist->st->codec.rate_emu) {
1418                 ist->start = av_gettime();
1419                 ist->frame = 0;
1420             }
1421         }
1422     }
1423
1424     /* output stream init */
1425     nb_ostreams = 0;
1426     for(i=0;i<nb_output_files;i++) {
1427         os = output_files[i];
1428         nb_ostreams += os->nb_streams;
1429     }
1430     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1431         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1432         exit(1);
1433     }
1434
1435     /* Sanity check the mapping args -- do the input files & streams exist? */
1436     for(i=0;i<nb_stream_maps;i++) {
1437         int fi = stream_maps[i].file_index;
1438         int si = stream_maps[i].stream_index;
1439
1440         if (fi < 0 || fi > nb_input_files - 1 ||
1441             si < 0 || si > file_table[fi].nb_streams - 1) {
1442             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1443             exit(1);
1444         }
1445     }
1446
1447     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1448     if (!ost_table)
1449         goto fail;
1450     for(i=0;i<nb_ostreams;i++) {
1451         ost = av_mallocz(sizeof(AVOutputStream));
1452         if (!ost)
1453             goto fail;
1454         ost_table[i] = ost;
1455     }
1456
1457     n = 0;
1458     for(k=0;k<nb_output_files;k++) {
1459         os = output_files[k];
1460         for(i=0;i<os->nb_streams;i++) {
1461             int found;
1462             ost = ost_table[n++];
1463             ost->file_index = k;
1464             ost->index = i;
1465             ost->st = os->streams[i];
1466             if (nb_stream_maps > 0) {
1467                 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1468                     stream_maps[n-1].stream_index;
1469
1470                 /* Sanity check that the stream types match */
1471                 if (ist_table[ost->source_index]->st->codec.codec_type != ost->st->codec.codec_type) {
1472                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1473                         stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1474                         ost->file_index, ost->index);
1475                     exit(1);
1476                 }
1477
1478             } else {
1479                 /* get corresponding input stream index : we select the first one with the right type */
1480                 found = 0;
1481                 for(j=0;j<nb_istreams;j++) {
1482                     ist = ist_table[j];
1483                     if (ist->discard &&
1484                         ist->st->codec.codec_type == ost->st->codec.codec_type) {
1485                         ost->source_index = j;
1486                         found = 1;
1487                         break;
1488                     }
1489                 }
1490
1491                 if (!found) {
1492                     /* try again and reuse existing stream */
1493                     for(j=0;j<nb_istreams;j++) {
1494                         ist = ist_table[j];
1495                         if (ist->st->codec.codec_type == ost->st->codec.codec_type) {
1496                             ost->source_index = j;
1497                             found = 1;
1498                         }
1499                     }
1500                     if (!found) {
1501                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1502                                 ost->file_index, ost->index);
1503                         exit(1);
1504                     }
1505                 }
1506             }
1507             ist = ist_table[ost->source_index];
1508             ist->discard = 0;
1509         }
1510     }
1511
1512     /* for each output stream, we compute the right encoding parameters */
1513     for(i=0;i<nb_ostreams;i++) {
1514         ost = ost_table[i];
1515         ist = ist_table[ost->source_index];
1516
1517         codec = &ost->st->codec;
1518         icodec = &ist->st->codec;
1519
1520         if (ost->st->stream_copy) {
1521             /* if stream_copy is selected, no need to decode or encode */
1522             codec->codec_id = icodec->codec_id;
1523             codec->codec_type = icodec->codec_type;
1524             if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1525             codec->bit_rate = icodec->bit_rate;
1526             switch(codec->codec_type) {
1527             case CODEC_TYPE_AUDIO:
1528                 codec->sample_rate = icodec->sample_rate;
1529                 codec->channels = icodec->channels;
1530                 codec->frame_size = icodec->frame_size;
1531                 codec->block_align= icodec->block_align;
1532                 break;
1533             case CODEC_TYPE_VIDEO:
1534                 codec->frame_rate = icodec->frame_rate;
1535                 codec->frame_rate_base = icodec->frame_rate_base;
1536                 codec->width = icodec->width;
1537                 codec->height = icodec->height;
1538                 codec->has_b_frames = icodec->has_b_frames;
1539                 break;
1540             default:
1541                 av_abort();
1542             }
1543         } else {
1544             switch(codec->codec_type) {
1545             case CODEC_TYPE_AUDIO:
1546                 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1547                     goto fail;
1548
1549                 if (codec->channels == icodec->channels &&
1550                     codec->sample_rate == icodec->sample_rate) {
1551                     ost->audio_resample = 0;
1552                 } else {
1553                     if (codec->channels != icodec->channels &&
1554                         (icodec->codec_id == CODEC_ID_AC3 ||
1555                          icodec->codec_id == CODEC_ID_DTS)) {
1556                         /* Special case for 5:1 AC3 and DTS input */
1557                         /* and mono or stereo output      */
1558                         /* Request specific number of channels */
1559                         icodec->channels = codec->channels;
1560                         if (codec->sample_rate == icodec->sample_rate)
1561                             ost->audio_resample = 0;
1562                         else {
1563                             ost->audio_resample = 1;
1564                         }
1565                     } else {
1566                         ost->audio_resample = 1;
1567                     }
1568                 }
1569                 if(audio_sync_method>1)
1570                     ost->audio_resample = 1;
1571
1572                 if(ost->audio_resample){
1573                     ost->resample = audio_resample_init(codec->channels, icodec->channels,
1574                                                     codec->sample_rate, icodec->sample_rate);
1575                     if(!ost->resample){
1576                         printf("Can't resample.  Aborting.\n");
1577                         av_abort();
1578                     }
1579                 }
1580                 ist->decoding_needed = 1;
1581                 ost->encoding_needed = 1;
1582                 break;
1583             case CODEC_TYPE_VIDEO:
1584                 if (codec->width == icodec->width &&
1585                     codec->height == icodec->height &&
1586                     frame_topBand == 0 &&
1587                     frame_bottomBand == 0 &&
1588                     frame_leftBand == 0 &&
1589                     frame_rightBand == 0 &&
1590                     frame_padtop == 0 &&
1591                     frame_padbottom == 0 &&
1592                     frame_padleft == 0 &&
1593                     frame_padright == 0)
1594                 {
1595                     ost->video_resample = 0;
1596                     ost->video_crop = 0;
1597                     ost->video_pad = 0;
1598                 } else if ((codec->width == icodec->width -
1599                                 (frame_leftBand + frame_rightBand)) &&
1600                         (codec->height == icodec->height -
1601                                 (frame_topBand  + frame_bottomBand)))
1602                 {
1603                     ost->video_resample = 0;
1604                     ost->video_crop = 1;
1605                     ost->topBand = frame_topBand;
1606                     ost->leftBand = frame_leftBand;
1607                 } else if ((codec->width == icodec->width +
1608                                 (frame_padleft + frame_padright)) &&
1609                         (codec->height == icodec->height +
1610                                 (frame_padtop + frame_padbottom))) {
1611                     ost->video_resample = 0;
1612                     ost->video_crop = 0;
1613                     ost->video_pad = 1;
1614                     ost->padtop = frame_padtop;
1615                     ost->padleft = frame_padleft;
1616                     ost->padbottom = frame_padbottom;
1617                     ost->padright = frame_padright;
1618                     avcodec_get_frame_defaults(&ost->pict_tmp);
1619                     if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1620                                 codec->width, codec->height ) )
1621                         goto fail;
1622                 } else {
1623                     ost->video_resample = 1;
1624                     ost->video_crop = 0; // cropping is handled as part of resample
1625                     avcodec_get_frame_defaults(&ost->pict_tmp);
1626                     if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1627                                          codec->width, codec->height ) )
1628                         goto fail;
1629
1630                     ost->img_resample_ctx = img_resample_full_init(
1631                                       ost->st->codec.width, ost->st->codec.height,
1632                                       ist->st->codec.width, ist->st->codec.height,
1633                                       frame_topBand, frame_bottomBand,
1634                             frame_leftBand, frame_rightBand,
1635                             frame_padtop, frame_padbottom,
1636                             frame_padleft, frame_padright);
1637
1638                     ost->padtop = frame_padtop;
1639                     ost->padleft = frame_padleft;
1640                     ost->padbottom = frame_padbottom;
1641                     ost->padright = frame_padright;
1642
1643                 }
1644                 ost->encoding_needed = 1;
1645                 ist->decoding_needed = 1;
1646                 break;
1647             default:
1648                 av_abort();
1649             }
1650             /* two pass mode */
1651             if (ost->encoding_needed &&
1652                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1653                 char logfilename[1024];
1654                 FILE *f;
1655                 int size;
1656                 char *logbuffer;
1657
1658                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1659                          pass_logfilename ?
1660                          pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1661                 if (codec->flags & CODEC_FLAG_PASS1) {
1662                     f = fopen(logfilename, "w");
1663                     if (!f) {
1664                         perror(logfilename);
1665                         exit(1);
1666                     }
1667                     ost->logfile = f;
1668                 } else {
1669                     /* read the log file */
1670                     f = fopen(logfilename, "r");
1671                     if (!f) {
1672                         perror(logfilename);
1673                         exit(1);
1674                     }
1675                     fseek(f, 0, SEEK_END);
1676                     size = ftell(f);
1677                     fseek(f, 0, SEEK_SET);
1678                     logbuffer = av_malloc(size + 1);
1679                     if (!logbuffer) {
1680                         fprintf(stderr, "Could not allocate log buffer\n");
1681                         exit(1);
1682                     }
1683                     size = fread(logbuffer, 1, size, f);
1684                     fclose(f);
1685                     logbuffer[size] = '\0';
1686                     codec->stats_in = logbuffer;
1687                 }
1688             }
1689         }
1690         if(codec->codec_type == CODEC_TYPE_VIDEO){
1691             int size= codec->width * codec->height;
1692             bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1693         }
1694     }
1695
1696     if (!bit_buffer)
1697         bit_buffer = av_malloc(bit_buffer_size);
1698     if (!bit_buffer)
1699         goto fail;
1700
1701     /* dump the file output parameters - cannot be done before in case
1702        of stream copy */
1703     for(i=0;i<nb_output_files;i++) {
1704         dump_format(output_files[i], i, output_files[i]->filename, 1);
1705     }
1706
1707     /* dump the stream mapping */
1708     if (verbose >= 0) {
1709         fprintf(stderr, "Stream mapping:\n");
1710         for(i=0;i<nb_ostreams;i++) {
1711             ost = ost_table[i];
1712             fprintf(stderr, "  Stream #%d.%d -> #%d.%d\n",
1713                     ist_table[ost->source_index]->file_index,
1714                     ist_table[ost->source_index]->index,
1715                     ost->file_index,
1716                     ost->index);
1717         }
1718     }
1719
1720     /* open each encoder */
1721     for(i=0;i<nb_ostreams;i++) {
1722         ost = ost_table[i];
1723         if (ost->encoding_needed) {
1724             AVCodec *codec;
1725             codec = avcodec_find_encoder(ost->st->codec.codec_id);
1726             if (!codec) {
1727                 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1728                         ost->file_index, ost->index);
1729                 exit(1);
1730             }
1731             if (avcodec_open(&ost->st->codec, codec) < 0) {
1732                 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1733                         ost->file_index, ost->index);
1734                 exit(1);
1735             }
1736             extra_size += ost->st->codec.extradata_size;
1737         }
1738     }
1739
1740     /* open each decoder */
1741     for(i=0;i<nb_istreams;i++) {
1742         ist = ist_table[i];
1743         if (ist->decoding_needed) {
1744             AVCodec *codec;
1745             codec = avcodec_find_decoder(ist->st->codec.codec_id);
1746             if (!codec) {
1747                 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1748                         ist->st->codec.codec_id, ist->file_index, ist->index);
1749                 exit(1);
1750             }
1751             if (avcodec_open(&ist->st->codec, codec) < 0) {
1752                 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1753                         ist->file_index, ist->index);
1754                 exit(1);
1755             }
1756             //if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO)
1757             //    ist->st->codec.flags |= CODEC_FLAG_REPEAT_FIELD;
1758         }
1759     }
1760
1761     /* init pts */
1762     for(i=0;i<nb_istreams;i++) {
1763         ist = ist_table[i];
1764         is = input_files[ist->file_index];
1765         ist->pts = 0;
1766         ist->next_pts = ist->st->start_time;
1767         if(ist->next_pts == AV_NOPTS_VALUE)
1768             ist->next_pts=0;
1769         if(input_files_ts_offset[ist->file_index])
1770             ist->next_pts= AV_NOPTS_VALUE;
1771         ist->is_start = 1;
1772     }
1773
1774     /* compute buffer size max (should use a complete heuristic) */
1775     for(i=0;i<nb_input_files;i++) {
1776         file_table[i].buffer_size_max = 2048;
1777     }
1778
1779     /* set meta data information from input file if required */
1780     for (i=0;i<nb_meta_data_maps;i++) {
1781         AVFormatContext *out_file;
1782         AVFormatContext *in_file;
1783
1784         int out_file_index = meta_data_maps[i].out_file;
1785         int in_file_index = meta_data_maps[i].in_file;
1786         if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1787             fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1788             ret = -EINVAL;
1789             goto fail;
1790         }
1791         if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1792             fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1793             ret = -EINVAL;
1794             goto fail;
1795         }
1796
1797         out_file = output_files[out_file_index];
1798         in_file = input_files[in_file_index];
1799
1800         strcpy(out_file->title, in_file->title);
1801         strcpy(out_file->author, in_file->author);
1802         strcpy(out_file->copyright, in_file->copyright);
1803         strcpy(out_file->comment, in_file->comment);
1804         strcpy(out_file->album, in_file->album);
1805         out_file->year = in_file->year;
1806         out_file->track = in_file->track;
1807         strcpy(out_file->genre, in_file->genre);
1808     }
1809
1810     /* open files and write file headers */
1811     for(i=0;i<nb_output_files;i++) {
1812         os = output_files[i];
1813         if (av_write_header(os) < 0) {
1814             fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1815             ret = -EINVAL;
1816             goto fail;
1817         }
1818     }
1819
1820 #ifndef CONFIG_WIN32
1821     if ( !using_stdin && verbose >= 0) {
1822         fprintf(stderr, "Press [q] to stop encoding\n");
1823         url_set_interrupt_cb(decode_interrupt_cb);
1824     }
1825 #endif
1826     term_init();
1827
1828     stream_no_data = 0;
1829     key = -1;
1830
1831     for(; received_sigterm == 0;) {
1832         int file_index, ist_index;
1833         AVPacket pkt;
1834         double ipts_min;
1835         double opts_min;
1836
1837     redo:
1838         ipts_min= 1e100;
1839         opts_min= 1e100;
1840         /* if 'q' pressed, exits */
1841         if (!using_stdin) {
1842             if (q_pressed)
1843                 break;
1844             /* read_key() returns 0 on EOF */
1845             key = read_key();
1846             if (key == 'q')
1847                 break;
1848         }
1849
1850         /* select the stream that we must read now by looking at the
1851            smallest output pts */
1852         file_index = -1;
1853         for(i=0;i<nb_ostreams;i++) {
1854             double ipts, opts;
1855             ost = ost_table[i];
1856             os = output_files[ost->file_index];
1857             ist = ist_table[ost->source_index];
1858             if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO)
1859                 opts = (double)ost->sync_opts * ost->st->codec.frame_rate_base / ost->st->codec.frame_rate;
1860             else
1861                 opts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1862             ipts = (double)ist->pts;
1863             if (!file_table[ist->file_index].eof_reached){
1864                 if(ipts < ipts_min) {
1865                     ipts_min = ipts;
1866                     if(input_sync ) file_index = ist->file_index;
1867                 }
1868                 if(opts < opts_min) {
1869                     opts_min = opts;
1870                     if(!input_sync) file_index = ist->file_index;
1871                 }
1872             }
1873             if(ost->frame_number >= max_frames[ost->st->codec.codec_type]){
1874                 file_index= -1;
1875                 break;
1876             }
1877         }
1878         /* if none, if is finished */
1879         if (file_index < 0) {
1880             break;
1881         }
1882
1883         /* finish if recording time exhausted */
1884         if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1885             break;
1886
1887         /* finish if limit size exhausted */
1888         if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1889             break;
1890
1891         /* read a frame from it and output it in the fifo */
1892         is = input_files[file_index];
1893         if (av_read_frame(is, &pkt) < 0) {
1894             file_table[file_index].eof_reached = 1;
1895             if (opt_shortest) break; else continue; //
1896         }
1897
1898         if (!pkt.size) {
1899             stream_no_data = is;
1900         } else {
1901             stream_no_data = 0;
1902         }
1903         if (do_pkt_dump) {
1904             av_pkt_dump(stdout, &pkt, do_hex_dump);
1905         }
1906         /* the following test is needed in case new streams appear
1907            dynamically in stream : we ignore them */
1908         if (pkt.stream_index >= file_table[file_index].nb_streams)
1909             goto discard_packet;
1910         ist_index = file_table[file_index].ist_index + pkt.stream_index;
1911         ist = ist_table[ist_index];
1912         if (ist->discard)
1913             goto discard_packet;
1914
1915 //        fprintf(stderr, "next:%lld dts:%lld off:%lld %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec.codec_type);
1916         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1917             int64_t delta= pkt.dts - ist->next_pts;
1918             if(ABS(delta) > 10LL*AV_TIME_BASE && !copy_ts){
1919                 input_files_ts_offset[ist->file_index]-= delta;
1920                 if (verbose > 2)
1921                     fprintf(stderr, "timestamp discontinuity %lld, new offset= %lld\n", delta, input_files_ts_offset[ist->file_index]);
1922                 for(i=0; i<file_table[file_index].nb_streams; i++){
1923                     int index= file_table[file_index].ist_index + i;
1924                     ist_table[index]->next_pts += delta;
1925                     ist_table[index]->is_start=1;
1926                 }
1927             }
1928         }
1929
1930         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1931         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1932
1933             if (verbose >= 0)
1934                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1935                         ist->file_index, ist->index);
1936
1937             av_free_packet(&pkt);
1938             goto redo;
1939         }
1940
1941     discard_packet:
1942         av_free_packet(&pkt);
1943
1944         /* dump report by using the output first video and audio streams */
1945         print_report(output_files, ost_table, nb_ostreams, 0);
1946     }
1947
1948     /* at the end of stream, we must flush the decoder buffers */
1949     for(i=0;i<nb_istreams;i++) {
1950         ist = ist_table[i];
1951         if (ist->decoding_needed) {
1952             output_packet(ist, i, ost_table, nb_ostreams, NULL);
1953         }
1954     }
1955
1956     term_exit();
1957
1958     /* write the trailer if needed and close file */
1959     for(i=0;i<nb_output_files;i++) {
1960         os = output_files[i];
1961         av_write_trailer(os);
1962     }
1963
1964     /* dump report by using the first video and audio streams */
1965     print_report(output_files, ost_table, nb_ostreams, 1);
1966
1967     /* close each encoder */
1968     for(i=0;i<nb_ostreams;i++) {
1969         ost = ost_table[i];
1970         if (ost->encoding_needed) {
1971             av_freep(&ost->st->codec.stats_in);
1972             avcodec_close(&ost->st->codec);
1973         }
1974     }
1975
1976     /* close each decoder */
1977     for(i=0;i<nb_istreams;i++) {
1978         ist = ist_table[i];
1979         if (ist->decoding_needed) {
1980             avcodec_close(&ist->st->codec);
1981         }
1982     }
1983
1984     /* finished ! */
1985
1986     ret = 0;
1987  fail1:
1988     av_freep(&bit_buffer);
1989     av_free(file_table);
1990
1991     if (ist_table) {
1992         for(i=0;i<nb_istreams;i++) {
1993             ist = ist_table[i];
1994             av_free(ist);
1995         }
1996         av_free(ist_table);
1997     }
1998     if (ost_table) {
1999         for(i=0;i<nb_ostreams;i++) {
2000             ost = ost_table[i];
2001             if (ost) {
2002                 if (ost->logfile) {
2003                     fclose(ost->logfile);
2004                     ost->logfile = NULL;
2005                 }
2006                 fifo_free(&ost->fifo); /* works even if fifo is not
2007                                           initialized but set to zero */
2008                 av_free(ost->pict_tmp.data[0]);
2009                 if (ost->video_resample)
2010                     img_resample_close(ost->img_resample_ctx);
2011                 if (ost->audio_resample)
2012                     audio_resample_close(ost->resample);
2013                 av_free(ost);
2014             }
2015         }
2016         av_free(ost_table);
2017     }
2018     return ret;
2019  fail:
2020     ret = -ENOMEM;
2021     goto fail1;
2022 }
2023
2024 #if 0
2025 int file_read(const char *filename)
2026 {
2027     URLContext *h;
2028     unsigned char buffer[1024];
2029     int len, i;
2030
2031     if (url_open(&h, filename, O_RDONLY) < 0) {
2032         printf("could not open '%s'\n", filename);
2033         return -1;
2034     }
2035     for(;;) {
2036         len = url_read(h, buffer, sizeof(buffer));
2037         if (len <= 0)
2038             break;
2039         for(i=0;i<len;i++) putchar(buffer[i]);
2040     }
2041     url_close(h);
2042     return 0;
2043 }
2044 #endif
2045
2046 static void opt_image_format(const char *arg)
2047 {
2048     AVImageFormat *f;
2049
2050     for(f = first_image_format; f != NULL; f = f->next) {
2051         if (!strcmp(arg, f->name))
2052             break;
2053     }
2054     if (!f) {
2055         fprintf(stderr, "Unknown image format: '%s'\n", arg);
2056         exit(1);
2057     }
2058     image_format = f;
2059 }
2060
2061 static void opt_format(const char *arg)
2062 {
2063     /* compatibility stuff for pgmyuv */
2064     if (!strcmp(arg, "pgmyuv")) {
2065         pgmyuv_compatibility_hack=1;
2066 //        opt_image_format(arg);
2067         arg = "image2";
2068     }
2069
2070     file_iformat = av_find_input_format(arg);
2071     file_oformat = guess_format(arg, NULL, NULL);
2072     if (!file_iformat && !file_oformat) {
2073         fprintf(stderr, "Unknown input or output format: %s\n", arg);
2074         exit(1);
2075     }
2076 }
2077
2078 static void opt_video_bitrate(const char *arg)
2079 {
2080     video_bit_rate = atoi(arg) * 1000;
2081 }
2082
2083 static void opt_video_bitrate_tolerance(const char *arg)
2084 {
2085     video_bit_rate_tolerance = atoi(arg) * 1000;
2086 }
2087
2088 static void opt_video_bitrate_max(const char *arg)
2089 {
2090     video_rc_max_rate = atoi(arg) * 1000;
2091 }
2092
2093 static void opt_video_bitrate_min(const char *arg)
2094 {
2095     video_rc_min_rate = atoi(arg) * 1000;
2096 }
2097
2098 static void opt_video_buffer_size(const char *arg)
2099 {
2100     video_rc_buffer_size = atoi(arg) * 8*1024;
2101 }
2102
2103 static void opt_video_rc_eq(char *arg)
2104 {
2105     video_rc_eq = arg;
2106 }
2107
2108 static void opt_video_rc_override_string(char *arg)
2109 {
2110     video_rc_override_string = arg;
2111 }
2112
2113
2114 static void opt_workaround_bugs(const char *arg)
2115 {
2116     workaround_bugs = atoi(arg);
2117 }
2118
2119 static void opt_dct_algo(const char *arg)
2120 {
2121     dct_algo = atoi(arg);
2122 }
2123
2124 static void opt_idct_algo(const char *arg)
2125 {
2126     idct_algo = atoi(arg);
2127 }
2128
2129 static void opt_me_threshold(const char *arg)
2130 {
2131     me_threshold = atoi(arg);
2132 }
2133
2134 static void opt_mb_threshold(const char *arg)
2135 {
2136     mb_threshold = atoi(arg);
2137 }
2138
2139 static void opt_error_resilience(const char *arg)
2140 {
2141     error_resilience = atoi(arg);
2142 }
2143
2144 static void opt_error_concealment(const char *arg)
2145 {
2146     error_concealment = atoi(arg);
2147 }
2148
2149 static void opt_debug(const char *arg)
2150 {
2151     debug = atoi(arg);
2152 }
2153
2154 static void opt_vismv(const char *arg)
2155 {
2156     debug_mv = atoi(arg);
2157 }
2158
2159 static void opt_verbose(const char *arg)
2160 {
2161     verbose = atoi(arg);
2162     av_log_set_level(atoi(arg));
2163 }
2164
2165 static void opt_frame_rate(const char *arg)
2166 {
2167     if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2168         fprintf(stderr, "Incorrect frame rate\n");
2169         exit(1);
2170     }
2171 }
2172
2173 static void opt_frame_crop_top(const char *arg)
2174 {
2175     frame_topBand = atoi(arg);
2176     if (frame_topBand < 0) {
2177         fprintf(stderr, "Incorrect top crop size\n");
2178         exit(1);
2179     }
2180     if ((frame_topBand % 2) != 0) {
2181         fprintf(stderr, "Top crop size must be a multiple of 2\n");
2182         exit(1);
2183     }
2184     if ((frame_topBand) >= frame_height){
2185         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2186         exit(1);
2187     }
2188     frame_height -= frame_topBand;
2189 }
2190
2191 static void opt_frame_crop_bottom(const char *arg)
2192 {
2193     frame_bottomBand = atoi(arg);
2194     if (frame_bottomBand < 0) {
2195         fprintf(stderr, "Incorrect bottom crop size\n");
2196         exit(1);
2197     }
2198     if ((frame_bottomBand % 2) != 0) {
2199         fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2200         exit(1);
2201     }
2202     if ((frame_bottomBand) >= frame_height){
2203         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2204         exit(1);
2205     }
2206     frame_height -= frame_bottomBand;
2207 }
2208
2209 static void opt_frame_crop_left(const char *arg)
2210 {
2211     frame_leftBand = atoi(arg);
2212     if (frame_leftBand < 0) {
2213         fprintf(stderr, "Incorrect left crop size\n");
2214         exit(1);
2215     }
2216     if ((frame_leftBand % 2) != 0) {
2217         fprintf(stderr, "Left crop size must be a multiple of 2\n");
2218         exit(1);
2219     }
2220     if ((frame_leftBand) >= frame_width){
2221         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2222         exit(1);
2223     }
2224     frame_width -= frame_leftBand;
2225 }
2226
2227 static void opt_frame_crop_right(const char *arg)
2228 {
2229     frame_rightBand = atoi(arg);
2230     if (frame_rightBand < 0) {
2231         fprintf(stderr, "Incorrect right crop size\n");
2232         exit(1);
2233     }
2234     if ((frame_rightBand % 2) != 0) {
2235         fprintf(stderr, "Right crop size must be a multiple of 2\n");
2236         exit(1);
2237     }
2238     if ((frame_rightBand) >= frame_width){
2239         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2240         exit(1);
2241     }
2242     frame_width -= frame_rightBand;
2243 }
2244
2245 static void opt_frame_size(const char *arg)
2246 {
2247     if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2248         fprintf(stderr, "Incorrect frame size\n");
2249         exit(1);
2250     }
2251     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2252         fprintf(stderr, "Frame size must be a multiple of 2\n");
2253         exit(1);
2254     }
2255 }
2256
2257
2258 #define SCALEBITS 10
2259 #define ONE_HALF  (1 << (SCALEBITS - 1))
2260 #define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2261
2262 #define RGB_TO_Y(r, g, b) \
2263 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2264   FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2265
2266 #define RGB_TO_U(r1, g1, b1, shift)\
2267 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2268      FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2269
2270 #define RGB_TO_V(r1, g1, b1, shift)\
2271 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2272    FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2273
2274 static void opt_pad_color(const char *arg) {
2275     /* Input is expected to be six hex digits similar to
2276        how colors are expressed in html tags (but without the #) */
2277     int rgb = strtol(arg, NULL, 16);
2278     int r,g,b;
2279
2280     r = (rgb >> 16);
2281     g = ((rgb >> 8) & 255);
2282     b = (rgb & 255);
2283
2284     padcolor[0] = RGB_TO_Y(r,g,b);
2285     padcolor[1] = RGB_TO_U(r,g,b,0);
2286     padcolor[2] = RGB_TO_V(r,g,b,0);
2287 }
2288
2289 static void opt_frame_pad_top(const char *arg)
2290 {
2291     frame_padtop = atoi(arg);
2292     if (frame_padtop < 0) {
2293         fprintf(stderr, "Incorrect top pad size\n");
2294         exit(1);
2295     }
2296     if ((frame_padtop % 2) != 0) {
2297         fprintf(stderr, "Top pad size must be a multiple of 2\n");
2298         exit(1);
2299     }
2300 }
2301
2302 static void opt_frame_pad_bottom(const char *arg)
2303 {
2304     frame_padbottom = atoi(arg);
2305     if (frame_padbottom < 0) {
2306         fprintf(stderr, "Incorrect bottom pad size\n");
2307         exit(1);
2308     }
2309     if ((frame_padbottom % 2) != 0) {
2310         fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2311         exit(1);
2312     }
2313 }
2314
2315
2316 static void opt_frame_pad_left(const char *arg)
2317 {
2318     frame_padleft = atoi(arg);
2319     if (frame_padleft < 0) {
2320         fprintf(stderr, "Incorrect left pad size\n");
2321         exit(1);
2322     }
2323     if ((frame_padleft % 2) != 0) {
2324         fprintf(stderr, "Left pad size must be a multiple of 2\n");
2325         exit(1);
2326     }
2327 }
2328
2329
2330 static void opt_frame_pad_right(const char *arg)
2331 {
2332     frame_padright = atoi(arg);
2333     if (frame_padright < 0) {
2334         fprintf(stderr, "Incorrect right pad size\n");
2335         exit(1);
2336     }
2337     if ((frame_padright % 2) != 0) {
2338         fprintf(stderr, "Right pad size must be a multiple of 2\n");
2339         exit(1);
2340     }
2341 }
2342
2343
2344 static void opt_frame_pix_fmt(const char *arg)
2345 {
2346     frame_pix_fmt = avcodec_get_pix_fmt(arg);
2347 }
2348
2349 static void opt_frame_aspect_ratio(const char *arg)
2350 {
2351     int x = 0, y = 0;
2352     double ar = 0;
2353     const char *p;
2354
2355     p = strchr(arg, ':');
2356     if (p) {
2357         x = strtol(arg, (char **)&arg, 10);
2358         if (arg == p)
2359             y = strtol(arg+1, (char **)&arg, 10);
2360         if (x > 0 && y > 0)
2361             ar = (double)x / (double)y;
2362     } else
2363         ar = strtod(arg, (char **)&arg);
2364
2365     if (!ar) {
2366         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2367         exit(1);
2368     }
2369     frame_aspect_ratio = ar;
2370 }
2371
2372 static void opt_gop_size(const char *arg)
2373 {
2374     gop_size = atoi(arg);
2375 }
2376
2377 static void opt_b_frames(const char *arg)
2378 {
2379     b_frames = atoi(arg);
2380     if (b_frames > FF_MAX_B_FRAMES) {
2381         fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2382         exit(1);
2383     } else if (b_frames < 1) {
2384         fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2385         exit(1);
2386     }
2387 }
2388
2389 static void opt_mb_decision(const char *arg)
2390 {
2391     mb_decision = atoi(arg);
2392 }
2393
2394 static void opt_mb_cmp(const char *arg)
2395 {
2396     mb_cmp = atoi(arg);
2397 }
2398
2399 static void opt_ildct_cmp(const char *arg)
2400 {
2401     ildct_cmp = atoi(arg);
2402 }
2403
2404 static void opt_sub_cmp(const char *arg)
2405 {
2406     sub_cmp = atoi(arg);
2407 }
2408
2409 static void opt_cmp(const char *arg)
2410 {
2411     cmp = atoi(arg);
2412 }
2413
2414 static void opt_pre_cmp(const char *arg)
2415 {
2416     pre_cmp = atoi(arg);
2417 }
2418
2419 static void opt_pre_me(const char *arg)
2420 {
2421     pre_me = atoi(arg);
2422 }
2423
2424 static void opt_lumi_mask(const char *arg)
2425 {
2426     lumi_mask = atof(arg);
2427 }
2428
2429 static void opt_dark_mask(const char *arg)
2430 {
2431     dark_mask = atof(arg);
2432 }
2433
2434 static void opt_scplx_mask(const char *arg)
2435 {
2436     scplx_mask = atof(arg);
2437 }
2438
2439 static void opt_tcplx_mask(const char *arg)
2440 {
2441     tcplx_mask = atof(arg);
2442 }
2443
2444 static void opt_p_mask(const char *arg)
2445 {
2446     p_mask = atof(arg);
2447 }
2448
2449 static void opt_qscale(const char *arg)
2450 {
2451     video_qscale = atof(arg);
2452     if (video_qscale < 0.01 ||
2453         video_qscale > 255) {
2454         fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2455         exit(1);
2456     }
2457 }
2458
2459 static void opt_qsquish(const char *arg)
2460 {
2461     video_qsquish = atof(arg);
2462     if (video_qsquish < 0.0 ||
2463         video_qsquish > 99.0) {
2464         fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
2465         exit(1);
2466     }
2467 }
2468
2469 static void opt_lelim(const char *arg)
2470 {
2471     video_lelim = atoi(arg);
2472     if (video_lelim < -99 ||
2473         video_lelim > 99) {
2474         fprintf(stderr, "lelim must be >= -99 and <= 99\n");
2475         exit(1);
2476     }
2477 }
2478
2479 static void opt_celim(const char *arg)
2480 {
2481     video_celim = atoi(arg);
2482     if (video_celim < -99 ||
2483         video_celim > 99) {
2484         fprintf(stderr, "celim must be >= -99 and <= 99\n");
2485         exit(1);
2486     }
2487 }
2488
2489 static void opt_lmax(const char *arg)
2490 {
2491     video_lmax = atof(arg)*FF_QP2LAMBDA;
2492 }
2493
2494 static void opt_lmin(const char *arg)
2495 {
2496     video_lmin = atof(arg)*FF_QP2LAMBDA;
2497 }
2498
2499 static void opt_qmin(const char *arg)
2500 {
2501     video_qmin = atoi(arg);
2502     if (video_qmin < 1 ||
2503         video_qmin > 31) {
2504         fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2505         exit(1);
2506     }
2507 }
2508
2509 static void opt_qmax(const char *arg)
2510 {
2511     video_qmax = atoi(arg);
2512     if (video_qmax < 1 ||
2513         video_qmax > 31) {
2514         fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2515         exit(1);
2516     }
2517 }
2518
2519 static void opt_mb_lmin(const char *arg)
2520 {
2521     video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2522     if (video_mb_lmin < 1 ||
2523         video_mb_lmin > FF_LAMBDA_MAX) {
2524         fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2525         exit(1);
2526     }
2527 }
2528
2529 static void opt_mb_lmax(const char *arg)
2530 {
2531     video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2532     if (video_mb_lmax < 1 ||
2533         video_mb_lmax > FF_LAMBDA_MAX) {
2534         fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2535         exit(1);
2536     }
2537 }
2538
2539 static void opt_qdiff(const char *arg)
2540 {
2541     video_qdiff = atoi(arg);
2542     if (video_qdiff < 0 ||
2543         video_qdiff > 31) {
2544         fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2545         exit(1);
2546     }
2547 }
2548
2549 static void opt_qblur(const char *arg)
2550 {
2551     video_qblur = atof(arg);
2552 }
2553
2554 static void opt_qcomp(const char *arg)
2555 {
2556     video_qcomp = atof(arg);
2557 }
2558
2559 static void opt_rc_initial_cplx(const char *arg)
2560 {
2561     video_rc_initial_cplx = atof(arg);
2562 }
2563 static void opt_b_qfactor(const char *arg)
2564 {
2565     video_b_qfactor = atof(arg);
2566 }
2567 static void opt_i_qfactor(const char *arg)
2568 {
2569     video_i_qfactor = atof(arg);
2570 }
2571 static void opt_b_qoffset(const char *arg)
2572 {
2573     video_b_qoffset = atof(arg);
2574 }
2575 static void opt_i_qoffset(const char *arg)
2576 {
2577     video_i_qoffset = atof(arg);
2578 }
2579
2580 static void opt_ibias(const char *arg)
2581 {
2582     video_intra_quant_bias = atoi(arg);
2583 }
2584 static void opt_pbias(const char *arg)
2585 {
2586     video_inter_quant_bias = atoi(arg);
2587 }
2588
2589 static void opt_packet_size(const char *arg)
2590 {
2591     packet_size= atoi(arg);
2592 }
2593
2594 static void opt_error_rate(const char *arg)
2595 {
2596     error_rate= atoi(arg);
2597 }
2598
2599 static void opt_strict(const char *arg)
2600 {
2601     strict= atoi(arg);
2602 }
2603
2604 static void opt_top_field_first(const char *arg)
2605 {
2606     top_field_first= atoi(arg);
2607 }
2608
2609 static void opt_noise_reduction(const char *arg)
2610 {
2611     noise_reduction= atoi(arg);
2612 }
2613
2614 static void opt_qns(const char *arg)
2615 {
2616     qns= atoi(arg);
2617 }
2618
2619 static void opt_sc_threshold(const char *arg)
2620 {
2621     sc_threshold= atoi(arg);
2622 }
2623
2624 static void opt_me_range(const char *arg)
2625 {
2626     me_range = atoi(arg);
2627 }
2628
2629 static void opt_thread_count(const char *arg)
2630 {
2631     thread_count= atoi(arg);
2632 #if !defined(HAVE_THREADS)
2633     if (verbose >= 0)
2634         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2635 #endif
2636 }
2637
2638 static void opt_audio_bitrate(const char *arg)
2639 {
2640     audio_bit_rate = atoi(arg) * 1000;
2641 }
2642
2643 static void opt_audio_rate(const char *arg)
2644 {
2645     audio_sample_rate = atoi(arg);
2646 }
2647
2648 static void opt_audio_channels(const char *arg)
2649 {
2650     audio_channels = atoi(arg);
2651 }
2652
2653 static void opt_video_device(const char *arg)
2654 {
2655     video_device = av_strdup(arg);
2656 }
2657
2658 static void opt_grab_device(const char *arg)
2659 {
2660     grab_device = av_strdup(arg);
2661 }
2662
2663 static void opt_video_channel(const char *arg)
2664 {
2665     video_channel = strtol(arg, NULL, 0);
2666 }
2667
2668 static void opt_video_standard(const char *arg)
2669 {
2670     video_standard = av_strdup(arg);
2671 }
2672
2673 static void opt_audio_device(const char *arg)
2674 {
2675     audio_device = av_strdup(arg);
2676 }
2677
2678 static void opt_audio_codec(const char *arg)
2679 {
2680     AVCodec *p;
2681
2682     if (!strcmp(arg, "copy")) {
2683         audio_stream_copy = 1;
2684     } else {
2685         p = first_avcodec;
2686         while (p) {
2687             if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
2688                 break;
2689             p = p->next;
2690         }
2691         if (p == NULL) {
2692             fprintf(stderr, "Unknown audio codec '%s'\n", arg);
2693             exit(1);
2694         } else {
2695             audio_codec_id = p->id;
2696         }
2697     }
2698 }
2699
2700 static void opt_audio_tag(const char *arg)
2701 {
2702     char *tail;
2703     audio_codec_tag= strtol(arg, &tail, 0);
2704
2705     if(!tail || *tail)
2706         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2707 }
2708
2709 static void opt_video_tag(const char *arg)
2710 {
2711     char *tail;
2712     video_codec_tag= strtol(arg, &tail, 0);
2713
2714     if(!tail || *tail)
2715         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2716 }
2717
2718 static void add_frame_hooker(const char *arg)
2719 {
2720     int argc = 0;
2721     char *argv[64];
2722     int i;
2723     char *args = av_strdup(arg);
2724
2725     using_vhook = 1;
2726
2727     argv[0] = strtok(args, " ");
2728     while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2729     }
2730
2731     i = frame_hook_add(argc, argv);
2732
2733     if (i != 0) {
2734         fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2735         exit(1);
2736     }
2737 }
2738
2739 const char *motion_str[] = {
2740     "zero",
2741     "full",
2742     "log",
2743     "phods",
2744     "epzs",
2745     "x1",
2746     NULL,
2747 };
2748
2749 static void opt_motion_estimation(const char *arg)
2750 {
2751     const char **p;
2752     p = motion_str;
2753     for(;;) {
2754         if (!*p) {
2755             fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2756             exit(1);
2757         }
2758         if (!strcmp(*p, arg))
2759             break;
2760         p++;
2761     }
2762     me_method = (p - motion_str) + 1;
2763 }
2764
2765 static void opt_video_codec(const char *arg)
2766 {
2767     AVCodec *p;
2768
2769     if (!strcmp(arg, "copy")) {
2770         video_stream_copy = 1;
2771     } else {
2772         p = first_avcodec;
2773         while (p) {
2774             if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
2775                 break;
2776             p = p->next;
2777         }
2778         if (p == NULL) {
2779             fprintf(stderr, "Unknown video codec '%s'\n", arg);
2780             exit(1);
2781         } else {
2782             video_codec_id = p->id;
2783         }
2784     }
2785 }
2786
2787 static void opt_map(const char *arg)
2788 {
2789     AVStreamMap *m;
2790     const char *p;
2791
2792     p = arg;
2793     m = &stream_maps[nb_stream_maps++];
2794
2795     m->file_index = strtol(arg, (char **)&p, 0);
2796     if (*p)
2797         p++;
2798
2799     m->stream_index = strtol(p, (char **)&p, 0);
2800 }
2801
2802 static void opt_map_meta_data(const char *arg)
2803 {
2804     AVMetaDataMap *m;
2805     const char *p;
2806
2807     p = arg;
2808     m = &meta_data_maps[nb_meta_data_maps++];
2809
2810     m->out_file = strtol(arg, (char **)&p, 0);
2811     if (*p)
2812         p++;
2813
2814     m->in_file = strtol(p, (char **)&p, 0);
2815 }
2816
2817 static void opt_recording_time(const char *arg)
2818 {
2819     recording_time = parse_date(arg, 1);
2820 }
2821
2822 static void opt_start_time(const char *arg)
2823 {
2824     start_time = parse_date(arg, 1);
2825 }
2826
2827 static void opt_rec_timestamp(const char *arg)
2828 {
2829     rec_timestamp = parse_date(arg, 0) / 1000000;
2830 }
2831
2832 static void opt_input_ts_offset(const char *arg)
2833 {
2834     input_ts_offset = parse_date(arg, 1);
2835 }
2836
2837 static void opt_input_file(const char *filename)
2838 {
2839     AVFormatContext *ic;
2840     AVFormatParameters params, *ap = &params;
2841     int err, i, ret, rfps, rfps_base;
2842     int64_t timestamp;
2843
2844     if (!strcmp(filename, "-"))
2845         filename = "pipe:";
2846
2847     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2848                    !strcmp( filename, "/dev/stdin" );
2849
2850     /* get default parameters from command line */
2851     memset(ap, 0, sizeof(*ap));
2852     ap->sample_rate = audio_sample_rate;
2853     ap->channels = audio_channels;
2854     ap->frame_rate = frame_rate;
2855     ap->frame_rate_base = frame_rate_base;
2856     ap->width = frame_width + frame_padleft + frame_padright;
2857     ap->height = frame_height + frame_padtop + frame_padbottom;
2858     ap->image_format = image_format;
2859     ap->pix_fmt = frame_pix_fmt;
2860     ap->device  = grab_device;
2861     ap->channel = video_channel;
2862     ap->standard = video_standard;
2863     ap->video_codec_id = video_codec_id;
2864     ap->audio_codec_id = audio_codec_id;
2865     if(pgmyuv_compatibility_hack)
2866         ap->video_codec_id= CODEC_ID_PGMYUV;
2867
2868     /* open the input file with generic libav function */
2869     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2870     if (err < 0) {
2871         print_error(filename, err);
2872         exit(1);
2873     }
2874
2875     /* If not enough info to get the stream parameters, we decode the
2876        first frames to get it. (used in mpeg case for example) */
2877     ret = av_find_stream_info(ic);
2878     if (ret < 0 && verbose >= 0) {
2879         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2880         exit(1);
2881     }
2882
2883     timestamp = start_time;
2884     /* add the stream start time */
2885     if (ic->start_time != AV_NOPTS_VALUE)
2886         timestamp += ic->start_time;
2887
2888     /* if seeking requested, we execute it */
2889     if (start_time != 0) {
2890         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2891         if (ret < 0) {
2892             fprintf(stderr, "%s: could not seek to position %0.3f\n",
2893                     filename, (double)timestamp / AV_TIME_BASE);
2894         }
2895         /* reset seek info */
2896         start_time = 0;
2897     }
2898
2899     /* update the current parameters so that they match the one of the input stream */
2900     for(i=0;i<ic->nb_streams;i++) {
2901         AVCodecContext *enc = &ic->streams[i]->codec;
2902 #if defined(HAVE_THREADS)
2903         if(thread_count>1)
2904             avcodec_thread_init(enc, thread_count);
2905 #endif
2906         enc->thread_count= thread_count;
2907         switch(enc->codec_type) {
2908         case CODEC_TYPE_AUDIO:
2909             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2910             audio_channels = enc->channels;
2911             audio_sample_rate = enc->sample_rate;
2912             if(audio_disable)
2913                 ic->streams[i]->discard= AVDISCARD_ALL;
2914             break;
2915         case CODEC_TYPE_VIDEO:
2916             frame_height = enc->height;
2917             frame_width = enc->width;
2918             frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2919             frame_pix_fmt = enc->pix_fmt;
2920             rfps      = ic->streams[i]->r_frame_rate;
2921             rfps_base = ic->streams[i]->r_frame_rate_base;
2922             enc->workaround_bugs = workaround_bugs;
2923             enc->error_resilience = error_resilience;
2924             enc->error_concealment = error_concealment;
2925             enc->idct_algo = idct_algo;
2926             enc->debug = debug;
2927             enc->debug_mv = debug_mv;
2928             enc->lowres= lowres;
2929             if(bitexact)
2930                 enc->flags|= CODEC_FLAG_BITEXACT;
2931             if(me_threshold)
2932                 enc->debug |= FF_DEBUG_MV;
2933
2934             if (enc->frame_rate != rfps || enc->frame_rate_base != rfps_base) {
2935
2936                 if (verbose >= 0)
2937                     fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2938                             i, (float)enc->frame_rate / enc->frame_rate_base, enc->frame_rate, enc->frame_rate_base,
2939
2940                     (float)rfps / rfps_base, rfps, rfps_base);
2941             }
2942             /* update the current frame rate to match the stream frame rate */
2943             frame_rate      = rfps;
2944             frame_rate_base = rfps_base;
2945
2946             enc->rate_emu = rate_emu;
2947             if(video_disable)
2948                 ic->streams[i]->discard= AVDISCARD_ALL;
2949             else if(video_discard)
2950                 ic->streams[i]->discard= video_discard;
2951             break;
2952         case CODEC_TYPE_DATA:
2953             break;
2954         default:
2955             av_abort();
2956         }
2957     }
2958
2959     input_files[nb_input_files] = ic;
2960     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2961     /* dump the file content */
2962     if (verbose >= 0)
2963         dump_format(ic, nb_input_files, filename, 0);
2964
2965     nb_input_files++;
2966     file_iformat = NULL;
2967     file_oformat = NULL;
2968     image_format = NULL;
2969
2970     grab_device = NULL;
2971     video_channel = 0;
2972
2973     rate_emu = 0;
2974 }
2975
2976 static void opt_grab(const char *arg)
2977 {
2978     file_iformat = av_find_input_format(arg);
2979     opt_input_file("");
2980 }
2981
2982 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2983 {
2984     int has_video, has_audio, i, j;
2985     AVFormatContext *ic;
2986
2987     has_video = 0;
2988     has_audio = 0;
2989     for(j=0;j<nb_input_files;j++) {
2990         ic = input_files[j];
2991         for(i=0;i<ic->nb_streams;i++) {
2992             AVCodecContext *enc = &ic->streams[i]->codec;
2993             switch(enc->codec_type) {
2994             case CODEC_TYPE_AUDIO:
2995                 has_audio = 1;
2996                 break;
2997             case CODEC_TYPE_VIDEO:
2998                 has_video = 1;
2999                 break;
3000             case CODEC_TYPE_DATA:
3001                 break;
3002             default:
3003                 av_abort();
3004             }
3005         }
3006     }
3007     *has_video_ptr = has_video;
3008     *has_audio_ptr = has_audio;
3009 }
3010
3011 static void opt_output_file(const char *filename)
3012 {
3013     AVStream *st;
3014     AVFormatContext *oc;
3015     int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
3016     int codec_id;
3017     AVFormatParameters params, *ap = &params;
3018
3019     if (!strcmp(filename, "-"))
3020         filename = "pipe:";
3021
3022     oc = av_alloc_format_context();
3023
3024     if (!file_oformat) {
3025         file_oformat = guess_format(NULL, filename, NULL);
3026         if (!file_oformat) {
3027             fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3028                     filename);
3029             exit(1);
3030         }
3031     }
3032
3033     oc->oformat = file_oformat;
3034
3035     if (!strcmp(file_oformat->name, "ffm") &&
3036         strstart(filename, "http:", NULL)) {
3037         /* special case for files sent to ffserver: we get the stream
3038            parameters from ffserver */
3039         if (read_ffserver_streams(oc, filename) < 0) {
3040             fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3041             exit(1);
3042         }
3043     } else {
3044         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy;
3045         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy;
3046
3047         /* disable if no corresponding type found and at least one
3048            input file */
3049         if (nb_input_files > 0) {
3050             check_audio_video_inputs(&input_has_video, &input_has_audio);
3051             if (!input_has_video)
3052                 use_video = 0;
3053             if (!input_has_audio)
3054                 use_audio = 0;
3055         }
3056
3057         /* manual disable */
3058         if (audio_disable) {
3059             use_audio = 0;
3060         }
3061         if (video_disable) {
3062             use_video = 0;
3063         }
3064
3065         nb_streams = 0;
3066         if (use_video) {
3067             AVCodecContext *video_enc;
3068
3069             st = av_new_stream(oc, nb_streams++);
3070             if (!st) {
3071                 fprintf(stderr, "Could not alloc stream\n");
3072                 exit(1);
3073             }
3074 #if defined(HAVE_THREADS)
3075             if(thread_count>1)
3076                 avcodec_thread_init(&st->codec, thread_count);
3077 #endif
3078
3079             video_enc = &st->codec;
3080
3081             if(video_codec_tag)
3082                 video_enc->codec_tag= video_codec_tag;
3083
3084             if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
3085                 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3086             if (video_stream_copy) {
3087                 st->stream_copy = 1;
3088                 video_enc->codec_type = CODEC_TYPE_VIDEO;
3089             } else {
3090                 char *p;
3091                 int i;
3092                 AVCodec *codec;
3093
3094                 codec_id = av_guess_codec(file_oformat, NULL, filename, NULL, CODEC_TYPE_VIDEO);
3095                 if (video_codec_id != CODEC_ID_NONE)
3096                     codec_id = video_codec_id;
3097
3098                 video_enc->codec_id = codec_id;
3099                 codec = avcodec_find_encoder(codec_id);
3100
3101                 video_enc->bit_rate = video_bit_rate;
3102                 video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
3103                 video_enc->frame_rate = frame_rate;
3104                 video_enc->frame_rate_base = frame_rate_base;
3105                 if(codec && codec->supported_framerates){
3106                     const AVRational *p= codec->supported_framerates;
3107                     AVRational req= (AVRational){frame_rate, frame_rate_base};
3108                     const AVRational *best=NULL;
3109                     AVRational best_error= (AVRational){INT_MAX, 1};
3110                     for(; p->den!=0; p++){
3111                         AVRational error= av_sub_q(req, *p);
3112                         if(error.num <0) error.num *= -1;
3113                         if(av_cmp_q(error, best_error) < 0){
3114                             best_error= error;
3115                             best= p;
3116                         }
3117                     }
3118                     video_enc->frame_rate     = best->num;
3119                     video_enc->frame_rate_base= best->den;
3120                 }
3121
3122                 video_enc->width = frame_width + frame_padright + frame_padleft;
3123                 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3124                 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3125                 video_enc->pix_fmt = frame_pix_fmt;
3126
3127                 if(codec && codec->pix_fmts){
3128                     const enum PixelFormat *p= codec->pix_fmts;
3129                     for(; *p!=-1; p++){
3130                         if(*p == video_enc->pix_fmt)
3131                             break;
3132                     }
3133                     if(*p == -1)
3134                         video_enc->pix_fmt = codec->pix_fmts[0];
3135                 }
3136
3137                 if (!intra_only)
3138                     video_enc->gop_size = gop_size;
3139                 else
3140                     video_enc->gop_size = 0;
3141                 if (video_qscale || same_quality) {
3142                     video_enc->flags |= CODEC_FLAG_QSCALE;
3143                     video_enc->global_quality=
3144                     st->quality = FF_QP2LAMBDA * video_qscale;
3145                 }
3146
3147                 if(intra_matrix)
3148                     video_enc->intra_matrix = intra_matrix;
3149                 if(inter_matrix)
3150                     video_enc->inter_matrix = inter_matrix;
3151
3152                 if(bitexact)
3153                     video_enc->flags |= CODEC_FLAG_BITEXACT;
3154
3155                 video_enc->mb_decision = mb_decision;
3156                 video_enc->mb_cmp = mb_cmp;
3157                 video_enc->ildct_cmp = ildct_cmp;
3158                 video_enc->me_sub_cmp = sub_cmp;
3159                 video_enc->me_cmp = cmp;
3160                 video_enc->me_pre_cmp = pre_cmp;
3161                 video_enc->pre_me = pre_me;
3162                 video_enc->lumi_masking = lumi_mask;
3163                 video_enc->dark_masking = dark_mask;
3164                 video_enc->spatial_cplx_masking = scplx_mask;
3165                 video_enc->temporal_cplx_masking = tcplx_mask;
3166                 video_enc->p_masking = p_mask;
3167                 video_enc->quantizer_noise_shaping= qns;
3168
3169                 if (use_umv) {
3170                     video_enc->flags |= CODEC_FLAG_H263P_UMV;
3171                 }
3172                 if (use_ss) {
3173                     video_enc->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
3174                 }
3175                 if (use_aic) {
3176                     video_enc->flags |= CODEC_FLAG_H263P_AIC;
3177                 }
3178                 if (use_aiv) {
3179                     video_enc->flags |= CODEC_FLAG_H263P_AIV;
3180                 }
3181                 if (use_4mv) {
3182                     video_enc->flags |= CODEC_FLAG_4MV;
3183                 }
3184                 if (use_obmc) {
3185                     video_enc->flags |= CODEC_FLAG_OBMC;
3186                 }
3187                 if (use_loop) {
3188                     video_enc->flags |= CODEC_FLAG_LOOP_FILTER;
3189                 }
3190
3191                 if(use_part) {
3192                     video_enc->flags |= CODEC_FLAG_PART;
3193                 }
3194                 if (use_alt_scan) {
3195                     video_enc->flags |= CODEC_FLAG_ALT_SCAN;
3196                 }
3197                 if (use_trell) {
3198                     video_enc->flags |= CODEC_FLAG_TRELLIS_QUANT;
3199                 }
3200                    if (use_mv0) {
3201                     video_enc->flags |= CODEC_FLAG_MV0;
3202                 }
3203                    if (do_normalize_aqp) {
3204                     video_enc->flags |= CODEC_FLAG_NORMALIZE_AQP;
3205                 }
3206                 if (use_scan_offset) {
3207                     video_enc->flags |= CODEC_FLAG_SVCD_SCAN_OFFSET;
3208                 }
3209                 if (closed_gop) {
3210                     video_enc->flags |= CODEC_FLAG_CLOSED_GOP;
3211                 }
3212                 if (strict_gop) {
3213                     video_enc->flags2 |= CODEC_FLAG2_STRICT_GOP;
3214                 }
3215                 if (use_qpel) {
3216                     video_enc->flags |= CODEC_FLAG_QPEL;
3217                 }
3218                 if (use_qprd) {
3219                     video_enc->flags |= CODEC_FLAG_QP_RD;
3220                 }
3221                 if (use_cbprd) {
3222                     video_enc->flags |= CODEC_FLAG_CBP_RD;
3223                 }
3224                 if (b_frames) {
3225                     video_enc->max_b_frames = b_frames;
3226                     video_enc->b_frame_strategy = 0;
3227                     video_enc->b_quant_factor = 2.0;
3228                 }
3229                 if (do_interlace_dct) {
3230                     video_enc->flags |= CODEC_FLAG_INTERLACED_DCT;
3231                 }
3232                 if (do_interlace_me) {
3233                     video_enc->flags |= CODEC_FLAG_INTERLACED_ME;
3234                 }
3235                 if (no_output) {
3236                     video_enc->flags2 |= CODEC_FLAG2_NO_OUTPUT;
3237                 }
3238                 video_enc->qmin = video_qmin;
3239                 video_enc->qmax = video_qmax;
3240                 video_enc->lmin = video_lmin;
3241                 video_enc->lmax = video_lmax;
3242                 video_enc->rc_qsquish = video_qsquish;
3243                 video_enc->luma_elim_threshold = video_lelim;
3244                 video_enc->chroma_elim_threshold = video_celim;
3245                 video_enc->mb_lmin = video_mb_lmin;
3246                 video_enc->mb_lmax = video_mb_lmax;
3247                 video_enc->max_qdiff = video_qdiff;
3248                 video_enc->qblur = video_qblur;
3249                 video_enc->qcompress = video_qcomp;
3250                 video_enc->rc_eq = video_rc_eq;
3251                 video_enc->debug = debug;
3252                 video_enc->debug_mv = debug_mv;
3253                 video_enc->thread_count = thread_count;
3254                 p= video_rc_override_string;
3255                 for(i=0; p; i++){
3256                     int start, end, q;
3257                     int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3258                     if(e!=3){
3259                         fprintf(stderr, "error parsing rc_override\n");
3260                         exit(1);
3261                     }
3262                     video_enc->rc_override=
3263                         av_realloc(video_enc->rc_override,
3264                                    sizeof(RcOverride)*(i+1));
3265                     video_enc->rc_override[i].start_frame= start;
3266                     video_enc->rc_override[i].end_frame  = end;
3267                     if(q>0){
3268                         video_enc->rc_override[i].qscale= q;
3269                         video_enc->rc_override[i].quality_factor= 1.0;
3270                     }
3271                     else{
3272                         video_enc->rc_override[i].qscale= 0;
3273                         video_enc->rc_override[i].quality_factor= -q/100.0;
3274                     }
3275                     p= strchr(p, '/');
3276                     if(p) p++;
3277                 }
3278                 video_enc->rc_override_count=i;
3279
3280                 video_enc->rc_max_rate = video_rc_max_rate;
3281                 video_enc->rc_min_rate = video_rc_min_rate;
3282                 video_enc->rc_buffer_size = video_rc_buffer_size;
3283                 video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3284                 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3285                 video_enc->rc_initial_cplx= video_rc_initial_cplx;
3286                 video_enc->i_quant_factor = video_i_qfactor;
3287                 video_enc->b_quant_factor = video_b_qfactor;
3288                 video_enc->i_quant_offset = video_i_qoffset;
3289                 video_enc->b_quant_offset = video_b_qoffset;
3290                 video_enc->intra_quant_bias = video_intra_quant_bias;
3291                 video_enc->inter_quant_bias = video_inter_quant_bias;
3292                 video_enc->dct_algo = dct_algo;
3293                 video_enc->idct_algo = idct_algo;
3294                 video_enc->me_threshold= me_threshold;
3295                 video_enc->mb_threshold= mb_threshold;
3296                 video_enc->intra_dc_precision= intra_dc_precision - 8;
3297                 video_enc->strict_std_compliance = strict;
3298                 video_enc->error_rate = error_rate;
3299                 video_enc->noise_reduction= noise_reduction;
3300                 video_enc->scenechange_threshold= sc_threshold;
3301                 video_enc->me_range = me_range;
3302                 video_enc->coder_type= coder;
3303                 video_enc->context_model= context;
3304                 video_enc->prediction_method= predictor;
3305                 video_enc->profile= video_profile;
3306                 video_enc->level= video_level;
3307                 video_enc->nsse_weight= nsse_weight;
3308                 video_enc->me_subpel_quality= subpel_quality;
3309                 video_enc->frame_skip_threshold= frame_skip_threshold;
3310                 video_enc->frame_skip_factor= frame_skip_factor;
3311                 video_enc->frame_skip_exp= frame_skip_exp;
3312                 video_enc->frame_skip_cmp= frame_skip_cmp;
3313
3314                 if(packet_size){
3315                     video_enc->rtp_mode= 1;
3316                     video_enc->rtp_payload_size= packet_size;
3317                 }
3318
3319                 if (do_psnr)
3320                     video_enc->flags|= CODEC_FLAG_PSNR;
3321
3322                 video_enc->me_method = me_method;
3323
3324                 /* two pass mode */
3325                 if (do_pass) {
3326                     if (do_pass == 1) {
3327                         video_enc->flags |= CODEC_FLAG_PASS1;
3328                     } else {
3329                         video_enc->flags |= CODEC_FLAG_PASS2;
3330                     }
3331                 }
3332             }
3333         }
3334
3335         if (use_audio) {
3336             AVCodecContext *audio_enc;
3337
3338             st = av_new_stream(oc, nb_streams++);
3339             if (!st) {
3340                 fprintf(stderr, "Could not alloc stream\n");
3341                 exit(1);
3342             }
3343 #if defined(HAVE_THREADS)
3344             if(thread_count>1)
3345                 avcodec_thread_init(&st->codec, thread_count);
3346 #endif
3347
3348             audio_enc = &st->codec;
3349             audio_enc->codec_type = CODEC_TYPE_AUDIO;
3350
3351             if(audio_codec_tag)
3352                 audio_enc->codec_tag= audio_codec_tag;
3353
3354             if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
3355                 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3356             if (audio_stream_copy) {
3357                 st->stream_copy = 1;
3358                 audio_enc->channels = audio_channels;
3359             } else {
3360                 codec_id = av_guess_codec(file_oformat, NULL, filename, NULL, CODEC_TYPE_AUDIO);
3361                 if (audio_codec_id != CODEC_ID_NONE)
3362                     codec_id = audio_codec_id;
3363                 audio_enc->codec_id = codec_id;
3364
3365                 audio_enc->bit_rate = audio_bit_rate;
3366                 audio_enc->strict_std_compliance = strict;
3367                 audio_enc->thread_count = thread_count;
3368                 /* For audio codecs other than AC3 or DTS we limit */
3369                 /* the number of coded channels to stereo   */
3370                 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3371                     && codec_id != CODEC_ID_DTS) {
3372                     audio_enc->channels = 2;
3373                 } else
3374                     audio_enc->channels = audio_channels;
3375             }
3376             audio_enc->sample_rate = audio_sample_rate;
3377         }
3378
3379         oc->nb_streams = nb_streams;
3380
3381         if (!nb_streams) {
3382             fprintf(stderr, "No audio or video streams available\n");
3383             exit(1);
3384         }
3385
3386         oc->timestamp = rec_timestamp;
3387
3388         if (str_title)
3389             pstrcpy(oc->title, sizeof(oc->title), str_title);
3390         if (str_author)
3391             pstrcpy(oc->author, sizeof(oc->author), str_author);
3392         if (str_copyright)
3393             pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3394         if (str_comment)
3395             pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3396     }
3397
3398     output_files[nb_output_files++] = oc;
3399
3400     pstrcpy(oc->filename, sizeof(oc->filename), filename);
3401
3402     /* check filename in case of an image number is expected */
3403     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3404         if (filename_number_test(oc->filename) < 0) {
3405             print_error(oc->filename, AVERROR_NUMEXPECTED);
3406             exit(1);
3407         }
3408     }
3409
3410     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3411         /* test if it already exists to avoid loosing precious files */
3412         if (!file_overwrite &&
3413             (strchr(filename, ':') == NULL ||
3414              strstart(filename, "file:", NULL))) {
3415             if (url_exist(filename)) {
3416                 int c;
3417
3418                 if ( !using_stdin ) {
3419                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3420                     fflush(stderr);
3421                     c = getchar();
3422                     if (toupper(c) != 'Y') {
3423                         fprintf(stderr, "Not overwriting - exiting\n");
3424                         exit(1);
3425                     }
3426                                 }
3427                                 else {
3428                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3429                     exit(1);
3430                                 }
3431             }
3432         }
3433
3434         /* open the file */
3435         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3436             fprintf(stderr, "Could not open '%s'\n", filename);
3437             exit(1);
3438         }
3439     }
3440
3441     memset(ap, 0, sizeof(*ap));
3442     ap->image_format = image_format;
3443     if (av_set_parameters(oc, ap) < 0) {
3444         fprintf(stderr, "%s: Invalid encoding parameters\n",
3445                 oc->filename);
3446         exit(1);
3447     }
3448
3449     oc->packet_size= mux_packet_size;
3450     oc->mux_rate= mux_rate;
3451     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3452     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3453
3454     /* reset some options */
3455     file_oformat = NULL;
3456     file_iformat = NULL;
3457     image_format = NULL;
3458     audio_disable = 0;
3459     video_disable = 0;
3460     audio_codec_id = CODEC_ID_NONE;
3461     video_codec_id = CODEC_ID_NONE;
3462     audio_stream_copy = 0;
3463     video_stream_copy = 0;
3464 }
3465
3466 /* prepare dummy protocols for grab */
3467 static void prepare_grab(void)
3468 {
3469     int has_video, has_audio, i, j;
3470     AVFormatContext *oc;
3471     AVFormatContext *ic;
3472     AVFormatParameters vp1, *vp = &vp1;
3473     AVFormatParameters ap1, *ap = &ap1;
3474
3475     /* see if audio/video inputs are needed */
3476     has_video = 0;
3477     has_audio = 0;
3478     memset(ap, 0, sizeof(*ap));
3479     memset(vp, 0, sizeof(*vp));
3480     vp->frame_rate_base= 1;
3481     for(j=0;j<nb_output_files;j++) {
3482         oc = output_files[j];
3483         for(i=0;i<oc->nb_streams;i++) {
3484             AVCodecContext *enc = &oc->streams[i]->codec;
3485             switch(enc->codec_type) {
3486             case CODEC_TYPE_AUDIO:
3487                 if (enc->sample_rate > ap->sample_rate)
3488                     ap->sample_rate = enc->sample_rate;
3489                 if (enc->channels > ap->channels)
3490                     ap->channels = enc->channels;
3491                 has_audio = 1;
3492                 break;
3493             case CODEC_TYPE_VIDEO:
3494                 if (enc->width > vp->width)
3495                     vp->width = enc->width;
3496                 if (enc->height > vp->height)
3497                     vp->height = enc->height;
3498
3499                 if (vp->frame_rate_base*(int64_t)enc->frame_rate > enc->frame_rate_base*(int64_t)vp->frame_rate){
3500                     vp->frame_rate      = enc->frame_rate;
3501                     vp->frame_rate_base = enc->frame_rate_base;
3502                 }
3503                 has_video = 1;
3504                 break;
3505             default:
3506                 av_abort();
3507             }
3508         }
3509     }
3510
3511     if (has_video == 0 && has_audio == 0) {
3512         fprintf(stderr, "Output file must have at least one audio or video stream\n");
3513         exit(1);
3514     }
3515
3516     if (has_video) {
3517         AVInputFormat *fmt1;
3518         fmt1 = av_find_input_format(video_grab_format);
3519         vp->device  = video_device;
3520         vp->channel = video_channel;
3521         vp->standard = video_standard;
3522         if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3523             fprintf(stderr, "Could not find video grab device\n");
3524             exit(1);
3525         }
3526         /* If not enough info to get the stream parameters, we decode the
3527            first frames to get it. */
3528         if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3529             fprintf(stderr, "Could not find video grab parameters\n");
3530             exit(1);
3531         }
3532         /* by now video grab has one stream */
3533         ic->streams[0]->r_frame_rate      = vp->frame_rate;
3534         ic->streams[0]->r_frame_rate_base = vp->frame_rate_base;
3535         input_files[nb_input_files] = ic;
3536
3537         if (verbose >= 0)
3538             dump_format(ic, nb_input_files, "", 0);
3539
3540         nb_input_files++;
3541     }
3542     if (has_audio && audio_grab_format) {
3543         AVInputFormat *fmt1;
3544         fmt1 = av_find_input_format(audio_grab_format);
3545         ap->device = audio_device;
3546         if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3547             fprintf(stderr, "Could not find audio grab device\n");
3548             exit(1);
3549         }
3550         input_files[nb_input_files] = ic;
3551
3552         if (verbose >= 0)
3553             dump_format(ic, nb_input_files, "", 0);
3554
3555         nb_input_files++;
3556     }
3557 }
3558
3559 /* same option as mencoder */
3560 static void opt_pass(const char *pass_str)
3561 {
3562     int pass;
3563     pass = atoi(pass_str);
3564     if (pass != 1 && pass != 2) {
3565         fprintf(stderr, "pass number can be only 1 or 2\n");
3566         exit(1);
3567     }
3568     do_pass = pass;
3569 }
3570
3571 #if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3572 static int64_t getutime(void)
3573 {
3574   return av_gettime();
3575 }
3576 #else
3577 static int64_t getutime(void)
3578 {
3579     struct rusage rusage;
3580
3581     getrusage(RUSAGE_SELF, &rusage);
3582     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3583 }
3584 #endif
3585
3586 extern int ffm_nopts;
3587
3588 static void opt_bitexact(void)
3589 {
3590     bitexact=1;
3591     /* disable generate of real time pts in ffm (need to be supressed anyway) */
3592     ffm_nopts = 1;
3593 }
3594
3595 static void show_formats(void)
3596 {
3597     AVInputFormat *ifmt;
3598     AVOutputFormat *ofmt;
3599     AVImageFormat *image_fmt;
3600     URLProtocol *up;
3601     AVCodec *p, *p2;
3602     const char **pp, *last_name;
3603
3604     printf("File formats:\n");
3605     last_name= "000";
3606     for(;;){
3607         int decode=0;
3608         int encode=0;
3609         const char *name=NULL;
3610         const char *long_name=NULL;
3611
3612         for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3613             if((name == NULL || strcmp(ofmt->name, name)<0) &&
3614                 strcmp(ofmt->name, last_name)>0){
3615                 name= ofmt->name;
3616                 long_name= ofmt->long_name;
3617                 encode=1;
3618             }
3619         }
3620         for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3621             if((name == NULL || strcmp(ifmt->name, name)<0) &&
3622                 strcmp(ifmt->name, last_name)>0){
3623                 name= ifmt->name;
3624                 long_name= ifmt->long_name;
3625                 encode=0;
3626             }
3627             if(name && strcmp(ifmt->name, name)==0)
3628                 decode=1;
3629         }
3630         if(name==NULL)
3631             break;
3632         last_name= name;
3633
3634         printf(
3635             " %s%s %-15s %s\n",
3636             decode ? "D":" ",
3637             encode ? "E":" ",
3638             name,
3639             long_name ? long_name:" ");
3640     }
3641     printf("\n");
3642
3643     printf("Image formats (filename extensions, if any, follow):\n");
3644     for(image_fmt = first_image_format; image_fmt != NULL;
3645         image_fmt = image_fmt->next) {
3646         printf(
3647             " %s%s %-6s %s\n",
3648             image_fmt->img_read  ? "D":" ",
3649             image_fmt->img_write ? "E":" ",
3650             image_fmt->name,
3651             image_fmt->extensions ? image_fmt->extensions:" ");
3652     }
3653     printf("\n");
3654
3655     printf("Codecs:\n");
3656     last_name= "000";
3657     for(;;){
3658         int decode=0;
3659         int encode=0;
3660         int cap=0;
3661
3662         p2=NULL;
3663         for(p = first_avcodec; p != NULL; p = p->next) {
3664             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3665                 strcmp(p->name, last_name)>0){
3666                 p2= p;
3667                 decode= encode= cap=0;
3668             }
3669             if(p2 && strcmp(p->name, p2->name)==0){
3670                 if(p->decode) decode=1;
3671                 if(p->encode) encode=1;
3672                 cap |= p->capabilities;
3673             }
3674         }
3675         if(p2==NULL)
3676             break;
3677         last_name= p2->name;
3678
3679         printf(
3680             " %s%s%s%s%s%s %s",
3681             decode ? "D": (/*p2->decoder ? "d":*/" "),
3682             encode ? "E":" ",
3683             p2->type == CODEC_TYPE_AUDIO ? "A":"V",
3684             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3685             cap & CODEC_CAP_DR1 ? "D":" ",
3686             cap & CODEC_CAP_TRUNCATED ? "T":" ",
3687             p2->name);
3688        /* if(p2->decoder && decode==0)
3689             printf(" use %s for decoding", p2->decoder->name);*/
3690         printf("\n");
3691     }
3692     printf("\n");
3693
3694     printf("Supported file protocols:\n");
3695     for(up = first_protocol; up != NULL; up = up->next)
3696         printf(" %s:", up->name);
3697     printf("\n");
3698
3699     printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3700     printf("Motion estimation methods:\n");
3701     pp = motion_str;
3702     while (*pp) {
3703         printf(" %s", *pp);
3704         if ((pp - motion_str + 1) == ME_ZERO)
3705             printf("(fastest)");
3706         else if ((pp - motion_str + 1) == ME_FULL)
3707             printf("(slowest)");
3708         else if ((pp - motion_str + 1) == ME_EPZS)
3709             printf("(default)");
3710         pp++;
3711     }
3712     printf("\n\n");
3713     printf(
3714 "Note, the names of encoders and decoders dont always match, so there are\n"
3715 "several cases where the above table shows encoder only or decoder only entries\n"
3716 "even though both encoding and decoding are supported for example, the h263\n"
3717 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3718 "worse\n");
3719     exit(1);
3720 }
3721
3722 void parse_matrix_coeffs(uint16_t *dest, const char *str)
3723 {
3724     int i;
3725     const char *p = str;
3726     for(i = 0;; i++) {
3727         dest[i] = atoi(p);
3728         if(i == 63)
3729             break;
3730         p = strchr(p, ',');
3731         if(!p) {
3732             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3733             exit(1);
3734         }
3735         p++;
3736     }
3737 }
3738
3739 void opt_inter_matrix(const char *arg)
3740 {
3741     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3742     parse_matrix_coeffs(inter_matrix, arg);
3743 }
3744
3745 void opt_intra_matrix(const char *arg)
3746 {
3747     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3748     parse_matrix_coeffs(intra_matrix, arg);
3749 }
3750
3751 static void opt_target(const char *arg)
3752 {
3753     int norm = -1;
3754     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3755
3756     if(!strncmp(arg, "pal-", 4)) {
3757         norm = 0;
3758         arg += 4;
3759     } else if(!strncmp(arg, "ntsc-", 5)) {
3760         norm = 1;
3761         arg += 5;
3762     } else if(!strncmp(arg, "film-", 5)) {
3763         norm = 2;
3764         arg += 5;
3765     } else {
3766         int fr;
3767         /* Calculate FR via float to avoid int overflow */
3768         fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3769         if(fr == 25000) {
3770             norm = 0;
3771         } else if((fr == 29970) || (fr == 23976)) {
3772             norm = 1;
3773         } else {
3774             /* Try to determine PAL/NTSC by peeking in the input files */
3775             if(nb_input_files) {
3776                 int i, j;
3777                 for(j = 0; j < nb_input_files; j++) {
3778                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3779                         AVCodecContext *c = &input_files[j]->streams[i]->codec;
3780                         if(c->codec_type != CODEC_TYPE_VIDEO)
3781                             continue;
3782                         fr = c->frame_rate * 1000 / c->frame_rate_base;
3783                         if(fr == 25000) {
3784                             norm = 0;
3785                             break;
3786                         } else if((fr == 29970) || (fr == 23976)) {
3787                             norm = 1;
3788                             break;
3789                         }
3790                     }
3791                     if(norm >= 0)
3792                         break;
3793                 }
3794             }
3795         }
3796         if(verbose && norm >= 0)
3797             fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3798     }
3799
3800     if(norm < 0) {
3801         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3802         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3803         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3804         exit(1);
3805     }
3806
3807     if(!strcmp(arg, "vcd")) {
3808
3809         opt_video_codec("mpeg1video");
3810         opt_audio_codec("mp2");
3811         opt_format("vcd");
3812
3813         opt_frame_size(norm ? "352x240" : "352x288");
3814         opt_frame_rate(frame_rates[norm]);
3815         opt_gop_size(norm ? "18" : "15");
3816
3817         video_bit_rate = 1150000;
3818         video_rc_max_rate = 1150000;
3819         video_rc_min_rate = 1150000;
3820         video_rc_buffer_size = 40*1024*8;
3821
3822         audio_bit_rate = 224000;
3823         audio_sample_rate = 44100;
3824
3825         mux_packet_size= 2324;
3826         mux_rate= 2352 * 75 * 8;
3827
3828         /* We have to offset the PTS, so that it is consistent with the SCR.
3829            SCR starts at 36000, but the first two packs contain only padding
3830            and the first pack from the other stream, respectively, may also have
3831            been written before.
3832            So the real data starts at SCR 36000+3*1200. */
3833         mux_preload= (36000+3*1200) / 90000.0; //0.44
3834     } else if(!strcmp(arg, "svcd")) {
3835
3836         opt_video_codec("mpeg2video");
3837         opt_audio_codec("mp2");
3838         opt_format("svcd");
3839
3840         opt_frame_size(norm ? "480x480" : "480x576");
3841         opt_frame_rate(frame_rates[norm]);
3842         opt_gop_size(norm ? "18" : "15");
3843
3844         video_bit_rate = 2040000;
3845         video_rc_max_rate = 2516000;
3846         video_rc_min_rate = 0; //1145000;
3847         video_rc_buffer_size = 224*1024*8;
3848         use_scan_offset = 1;
3849
3850         audio_bit_rate = 224000;
3851         audio_sample_rate = 44100;
3852
3853         mux_packet_size= 2324;
3854
3855     } else if(!strcmp(arg, "dvd")) {
3856
3857         opt_video_codec("mpeg2video");
3858         opt_audio_codec("ac3");
3859         opt_format("dvd");
3860
3861         opt_frame_size(norm ? "720x480" : "720x576");
3862         opt_frame_rate(frame_rates[norm]);
3863         opt_gop_size(norm ? "18" : "15");
3864
3865         video_bit_rate = 6000000;
3866         video_rc_max_rate = 9000000;
3867         video_rc_min_rate = 0; //1500000;
3868         video_rc_buffer_size = 224*1024*8;
3869
3870         mux_packet_size= 2048;  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3871         mux_rate = 10080000;    // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3872
3873         audio_bit_rate = 448000;
3874         audio_sample_rate = 48000;
3875
3876     } else if(!strcmp(arg, "dv")) {
3877
3878         opt_format("dv");
3879
3880         opt_frame_size(norm ? "720x480" : "720x576");
3881         opt_frame_rate(frame_rates[norm]);
3882
3883         audio_sample_rate = 48000;
3884         audio_channels = 2;
3885
3886     } else {
3887         fprintf(stderr, "Unknown target: %s\n", arg);
3888         exit(1);
3889     }
3890 }
3891
3892 static void show_version(void)
3893 {
3894     fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3895            "libavcodec  %d\n"
3896            "libavformat %d\n",
3897            avcodec_build(), LIBAVFORMAT_BUILD);
3898     exit(1);
3899 }
3900
3901 const OptionDef options[] = {
3902     /* main options */
3903     { "L", 0, {(void*)show_license}, "show license" },
3904     { "h", 0, {(void*)show_help}, "show help" },
3905     { "version", 0, {(void*)show_version}, "show version" },
3906     { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3907     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3908     { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3909     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3910     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3911     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream" },
3912     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3913     { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3914     { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3915     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3916     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3917     { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3918     { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3919     { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3920     { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3921     { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3922     { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
3923     { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
3924     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3925       "add timings for benchmarking" },
3926     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3927       "dump each input packet" },
3928     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3929       "when dumping packets, also dump the payload" },
3930     { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" },
3931     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3932     { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3933     { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3934     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3935     { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3936     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3937     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3938     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3939     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3940
3941     /* video options */
3942     { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
3943     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3944     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3945     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3946     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3947     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3948     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3949     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3950     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3951     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3952     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3953     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3954     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3955     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3956     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3957     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3958     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3959     { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
3960     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3961     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3962     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3963     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3964     { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
3965     { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
3966     { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
3967     { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
3968     { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
3969     { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "max macroblock quantiser scale (VBR)", "q" },
3970     { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3971     { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
3972     { "qsquish", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qsquish}, "how to keep quantiser between qmin and qmax (0 = clip, 1 = use differentiable function)", "squish" },
3973     { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
3974     { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
3975     { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
3976     { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
3977     { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
3978     { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
3979     { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
3980     { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
3981 //    { "b_strategy", HAS_ARG | OPT_EXPERT, {(void*)opt_b_strategy}, "dynamic b frame selection strategy", "strategy" },
3982     { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3983     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3984     { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
3985     { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
3986     { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
3987     { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
3988     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3989     { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3990       "method" },
3991     { "dct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dct_algo}, "set dct algo",  "algo" },
3992     { "idct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_idct_algo}, "set idct algo",  "algo" },
3993     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3994     { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold",  "" },
3995     { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience",  "n" },
3996     { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment",  "bit_mask" },
3997     { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
3998     { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
3999     { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
4000     { "mbcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_cmp}, "macroblock compare function", "cmp function" },
4001     { "ildctcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ildct_cmp}, "ildct compare function", "cmp function" },
4002     { "subcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sub_cmp}, "subpel compare function", "cmp function" },
4003     { "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
4004     { "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
4005     { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
4006     { "lelim", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lelim}, "single coefficient elimination threshold for luminance (negative values also consider DC coefficient)", "elim" },
4007     { "celim", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_celim}, "single coefficient elimination threshold for chrominance (negative values also consider DC coefficient)", "elim" },
4008     { "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
4009     { "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
4010     { "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
4011     { "tcplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_tcplx_mask}, "temporal complexity masking", "" },
4012     { "p_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_p_mask}, "inter masking", "" },
4013     { "4mv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_4mv}, "use four motion vector by macroblock (MPEG4)" },
4014     { "obmc", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_obmc}, "use overlapped block motion compensation (h263+)" },
4015     { "lf", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_loop}, "use loop filter (h263+)" },
4016     { "part", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_part}, "use data partitioning (MPEG4)" },
4017     { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
4018     { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
4019     { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
4020     { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
4021     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4022       "use same video quality as source (implies VBR)" },
4023     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4024     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
4025     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4026       "deinterlace pictures" },
4027     { "ildct", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_dct},
4028       "force interlaced dct support in encoder (MPEG2/MPEG4)" },
4029     { "ilme", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_me},
4030       "force interlaced me support in encoder (MPEG2/MPEG4)" },
4031     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4032     { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
4033     { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
4034     { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
4035     { "aiv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aiv}, "enable Alternative inter vlc (h263+)" },
4036     { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
4037     { "ssm", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_ss}, "enable Slice Structured mode (h263+)" },
4038     { "alt", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_alt_scan}, "enable alternate scantable (MPEG2/MPEG4)" },
4039     { "qprd", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qprd}, "" },
4040     { "cbp", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_cbprd}, "" },
4041     { "trell", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_trell}, "enable trellis quantization" },
4042     { "mv0", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_mv0}, "try to encode each MB with MV=<0,0> and choose the better one (has no effect if mbd=0)" },
4043     { "naq", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_normalize_aqp}, "normalize adaptive quantization" },
4044     { "cgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&closed_gop}, "closed gop" },
4045     { "sgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&strict_gop}, "strict gop" },
4046     { "noout", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&no_output}, "skip bitstream encoding" },
4047     { "scan_offset", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_scan_offset}, "enable SVCD Scan Offset placeholder" },
4048     { "qpel", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qpel}, "enable 1/4-pel" },
4049     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4050     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4051     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4052     { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },
4053     { "qns", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qns}, "quantization noise shaping", "" },
4054     { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
4055     { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
4056     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4057     { "coder", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&coder}, "coder type", "" },
4058     { "context", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&context}, "context model", "" },
4059     { "pred", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&predictor}, "prediction method", "" },
4060     { "vprofile", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_profile}, "profile", "" },
4061     { "vlevel", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_level}, "level", "" },
4062     { "nssew", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&nsse_weight}, "weight", "" },
4063     { "subq", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&subpel_quality}, "", "" },
4064     { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&lowres}, "", "" },
4065     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4066     { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
4067     { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
4068     { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
4069     { "skip_cmp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_cmp}, "frame skip compare function", "compare function" },
4070
4071     /* audio options */
4072     { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
4073     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4074     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4075     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4076     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4077     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4078
4079     /* grab options */
4080     { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
4081     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4082     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4083     { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
4084
4085     /* G.2 grab options */
4086     { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
4087     { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
4088
4089     /* muxer options */
4090     { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
4091     { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
4092     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4093     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4094     { NULL, },
4095 };
4096
4097 static void show_banner(void)
4098 {
4099     fprintf(stderr, "ffmpeg version " FFMPEG_VERSION ", build %d, Copyright (c) 2000-2004 Fabrice Bellard\n",
4100         LIBAVCODEC_BUILD);
4101     fprintf(stderr, "  configuration: %s\n", FFMPEG_CONFIGURATION);
4102     fprintf(stderr, "  built on " __DATE__ " " __TIME__);
4103 #ifdef __GNUC__
4104     fprintf(stderr, ", gcc: %s\n", __VERSION__);
4105 #else
4106     fprintf(stderr, ", using a non-gcc compiler\n");
4107 #endif
4108 }
4109
4110 static void show_license(void)
4111 {
4112     show_banner();
4113 #ifdef CONFIG_GPL
4114     printf(
4115     "This program is free software; you can redistribute it and/or modify\n"
4116     "it under the terms of the GNU General Public License as published by\n"
4117     "the Free Software Foundation; either version 2 of the License, or\n"
4118     "(at your option) any later version.\n"
4119     "\n"
4120     "This program is distributed in the hope that it will be useful,\n"
4121     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4122     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
4123     "GNU General Public License for more details.\n"
4124     "\n"
4125     "You should have received a copy of the GNU General Public License\n"
4126     "along with this program; if not, write to the Free Software\n"
4127     "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
4128     );
4129 #else
4130     printf(
4131     "This library is free software; you can redistribute it and/or\n"
4132     "modify it under the terms of the GNU Lesser General Public\n"
4133     "License as published by the Free Software Foundation; either\n"
4134     "version 2 of the License, or (at your option) any later version.\n"
4135     "\n"
4136     "This library is distributed in the hope that it will be useful,\n"
4137     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4138     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
4139     "Lesser General Public License for more details.\n"
4140     "\n"
4141     "You should have received a copy of the GNU Lesser General Public\n"
4142     "License along with this library; if not, write to the Free Software\n"
4143     "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
4144     );
4145 #endif
4146     exit(1);
4147 }
4148
4149 static void show_help(void)
4150 {
4151     show_banner();
4152     printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4153            "Hyper fast Audio and Video encoder\n");
4154     printf("\n");
4155     show_help_options(options, "Main options:\n",
4156                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4157     show_help_options(options, "\nVideo options:\n",
4158                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4159                       OPT_VIDEO);
4160     show_help_options(options, "\nAdvanced Video options:\n",
4161                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4162                       OPT_VIDEO | OPT_EXPERT);
4163     show_help_options(options, "\nAudio options:\n",
4164                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4165                       OPT_AUDIO);
4166     show_help_options(options, "\nAdvanced Audio options:\n",
4167                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4168                       OPT_AUDIO | OPT_EXPERT);
4169     show_help_options(options, "\nAudio/Video grab options:\n",
4170                       OPT_GRAB,
4171                       OPT_GRAB);
4172     show_help_options(options, "\nAdvanced options:\n",
4173                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4174                       OPT_EXPERT);
4175     exit(1);
4176 }
4177
4178 void parse_arg_file(const char *filename)
4179 {
4180     opt_output_file(filename);
4181 }
4182
4183 int main(int argc, char **argv)
4184 {
4185     int i;
4186     int64_t ti;
4187
4188     av_register_all();
4189
4190     if (argc <= 1)
4191         show_help();
4192     else
4193         show_banner();
4194
4195     /* parse options */
4196     parse_options(argc, argv, options);
4197
4198     /* file converter / grab */
4199     if (nb_output_files <= 0) {
4200         fprintf(stderr, "Must supply at least one output file\n");
4201         exit(1);
4202     }
4203
4204     if (nb_input_files == 0) {
4205         input_sync = 1;
4206         prepare_grab();
4207     }
4208
4209     ti = getutime();
4210     av_encode(output_files, nb_output_files, input_files, nb_input_files,
4211               stream_maps, nb_stream_maps);
4212     ti = getutime() - ti;
4213     if (do_benchmark) {
4214         printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4215     }
4216
4217     /* close files */
4218     for(i=0;i<nb_output_files;i++) {
4219         /* maybe av_close_output_file ??? */
4220         AVFormatContext *s = output_files[i];
4221         int j;
4222         if (!(s->oformat->flags & AVFMT_NOFILE))
4223             url_fclose(&s->pb);
4224         for(j=0;j<s->nb_streams;j++)
4225             av_free(s->streams[j]);
4226         av_free(s);
4227     }
4228     for(i=0;i<nb_input_files;i++)
4229         av_close_input_file(input_files[i]);
4230
4231     av_free_static();
4232
4233     if(intra_matrix)
4234         av_free(intra_matrix);
4235     if(inter_matrix)
4236         av_free(inter_matrix);
4237
4238 #ifdef POWERPC_PERFORMANCE_REPORT
4239     extern void powerpc_display_perf_report(void);
4240     powerpc_display_perf_report();
4241 #endif /* POWERPC_PERFORMANCE_REPORT */
4242
4243 #ifndef CONFIG_WIN32
4244     if (received_sigterm) {
4245         fprintf(stderr,
4246             "Received signal %d: terminating.\n",
4247             (int) received_sigterm);
4248         exit (255);
4249     }
4250 #endif
4251     exit(0); /* not all OS-es handle main() return value */
4252     return 0;
4253 }