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