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

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