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