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

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