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