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