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

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