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