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 = FF_ER_CAREFULL;
 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                 if (subtitle_to_free->rects != NULL) {
1427                     for (i = 0; i < subtitle_to_free->num_rects; i++) {
1428                         av_free(subtitle_to_free->rects[i].bitmap);
1429                         av_free(subtitle_to_free->rects[i].rgba_palette);
1430                     }
1431                     av_freep(&subtitle_to_free->rects);
1432                 }
1433                 subtitle_to_free->num_rects = 0;
1434                 subtitle_to_free = NULL;
1435             }
1436         }
1437  discard_packet:
1438     if (pkt == NULL) {
1439         /* EOF handling */
1440
1441         for(i=0;i<nb_ostreams;i++) {
1442             ost = ost_table[i];
1443             if (ost->source_index == ist_index) {
1444                 AVCodecContext *enc= ost->st->codec;
1445                 os = output_files[ost->file_index];
1446
1447                 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1448                     continue;
1449                 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1450                     continue;
1451
1452                 if (ost->encoding_needed) {
1453                     for(;;) {
1454                         AVPacket pkt;
1455                         av_init_packet(&pkt);
1456                         pkt.stream_index= ost->index;
1457
1458                         switch(ost->st->codec->codec_type) {
1459                         case CODEC_TYPE_AUDIO:
1460                             ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1461                             audio_size += ret;
1462                             pkt.flags |= PKT_FLAG_KEY;
1463                             break;
1464                         case CODEC_TYPE_VIDEO:
1465                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1466                             video_size += ret;
1467                             if(enc->coded_frame && enc->coded_frame->key_frame)
1468                                 pkt.flags |= PKT_FLAG_KEY;
1469                             if (ost->logfile && enc->stats_out) {
1470                                 fprintf(ost->logfile, "%s", enc->stats_out);
1471                             }
1472                             break;
1473                         default:
1474                             ret=-1;
1475                         }
1476
1477                         if(ret<=0)
1478                             break;
1479                         pkt.data= bit_buffer;
1480                         pkt.size= ret;
1481                         if(enc->coded_frame)
1482                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1483                         av_interleaved_write_frame(os, &pkt);
1484                     }
1485                 }
1486             }
1487         }
1488     }
1489
1490     return 0;
1491  fail_decode:
1492     return -1;
1493 }
1494
1495
1496 /*
1497  * The following code is the main loop of the file converter
1498  */
1499 static int av_encode(AVFormatContext **output_files,
1500                      int nb_output_files,
1501                      AVFormatContext **input_files,
1502                      int nb_input_files,
1503                      AVStreamMap *stream_maps, int nb_stream_maps)
1504 {
1505     int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1506     AVFormatContext *is, *os;
1507     AVCodecContext *codec, *icodec;
1508     AVOutputStream *ost, **ost_table = NULL;
1509     AVInputStream *ist, **ist_table = NULL;
1510     AVInputFile *file_table;
1511     AVFormatContext *stream_no_data;
1512     int key;
1513
1514     file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1515     if (!file_table)
1516         goto fail;
1517
1518     /* input stream init */
1519     j = 0;
1520     for(i=0;i<nb_input_files;i++) {
1521         is = input_files[i];
1522         file_table[i].ist_index = j;
1523         file_table[i].nb_streams = is->nb_streams;
1524         j += is->nb_streams;
1525     }
1526     nb_istreams = j;
1527
1528     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1529     if (!ist_table)
1530         goto fail;
1531
1532     for(i=0;i<nb_istreams;i++) {
1533         ist = av_mallocz(sizeof(AVInputStream));
1534         if (!ist)
1535             goto fail;
1536         ist_table[i] = ist;
1537     }
1538     j = 0;
1539     for(i=0;i<nb_input_files;i++) {
1540         is = input_files[i];
1541         for(k=0;k<is->nb_streams;k++) {
1542             ist = ist_table[j++];
1543             ist->st = is->streams[k];
1544             ist->file_index = i;
1545             ist->index = k;
1546             ist->discard = 1; /* the stream is discarded by default
1547                                  (changed later) */
1548
1549             if (ist->st->codec->rate_emu) {
1550                 ist->start = av_gettime();
1551                 ist->frame = 0;
1552             }
1553         }
1554     }
1555
1556     /* output stream init */
1557     nb_ostreams = 0;
1558     for(i=0;i<nb_output_files;i++) {
1559         os = output_files[i];
1560         nb_ostreams += os->nb_streams;
1561     }
1562     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1563         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1564         exit(1);
1565     }
1566
1567     /* Sanity check the mapping args -- do the input files & streams exist? */
1568     for(i=0;i<nb_stream_maps;i++) {
1569         int fi = stream_maps[i].file_index;
1570         int si = stream_maps[i].stream_index;
1571
1572         if (fi < 0 || fi > nb_input_files - 1 ||
1573             si < 0 || si > file_table[fi].nb_streams - 1) {
1574             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1575             exit(1);
1576         }
1577         fi = stream_maps[i].sync_file_index;
1578         si = stream_maps[i].sync_stream_index;
1579         if (fi < 0 || fi > nb_input_files - 1 ||
1580             si < 0 || si > file_table[fi].nb_streams - 1) {
1581             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1582             exit(1);
1583         }
1584     }
1585
1586     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1587     if (!ost_table)
1588         goto fail;
1589     for(i=0;i<nb_ostreams;i++) {
1590         ost = av_mallocz(sizeof(AVOutputStream));
1591         if (!ost)
1592             goto fail;
1593         ost_table[i] = ost;
1594     }
1595
1596     n = 0;
1597     for(k=0;k<nb_output_files;k++) {
1598         os = output_files[k];
1599         for(i=0;i<os->nb_streams;i++) {
1600             int found;
1601             ost = ost_table[n++];
1602             ost->file_index = k;
1603             ost->index = i;
1604             ost->st = os->streams[i];
1605             if (nb_stream_maps > 0) {
1606                 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1607                     stream_maps[n-1].stream_index;
1608
1609                 /* Sanity check that the stream types match */
1610                 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1611                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1612                         stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1613                         ost->file_index, ost->index);
1614                     exit(1);
1615                 }
1616
1617             } else {
1618                 /* get corresponding input stream index : we select the first one with the right type */
1619                 found = 0;
1620                 for(j=0;j<nb_istreams;j++) {
1621                     ist = ist_table[j];
1622                     if (ist->discard &&
1623                         ist->st->codec->codec_type == ost->st->codec->codec_type) {
1624                         ost->source_index = j;
1625                         found = 1;
1626                         break;
1627                     }
1628                 }
1629
1630                 if (!found) {
1631                     /* try again and reuse existing stream */
1632                     for(j=0;j<nb_istreams;j++) {
1633                         ist = ist_table[j];
1634                         if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1635                             ost->source_index = j;
1636                             found = 1;
1637                         }
1638                     }
1639                     if (!found) {
1640                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1641                                 ost->file_index, ost->index);
1642                         exit(1);
1643                     }
1644                 }
1645             }
1646             ist = ist_table[ost->source_index];
1647             ist->discard = 0;
1648             ost->sync_ist = (nb_stream_maps > 0) ?
1649                 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1650                          stream_maps[n-1].sync_stream_index] : ist;
1651         }
1652     }
1653
1654     /* for each output stream, we compute the right encoding parameters */
1655     for(i=0;i<nb_ostreams;i++) {
1656         ost = ost_table[i];
1657         ist = ist_table[ost->source_index];
1658
1659         codec = ost->st->codec;
1660         icodec = ist->st->codec;
1661
1662         if (ost->st->stream_copy) {
1663             /* if stream_copy is selected, no need to decode or encode */
1664             codec->codec_id = icodec->codec_id;
1665             codec->codec_type = icodec->codec_type;
1666             if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1667             codec->bit_rate = icodec->bit_rate;
1668             codec->extradata= icodec->extradata;
1669             codec->extradata_size= icodec->extradata_size;
1670             switch(codec->codec_type) {
1671             case CODEC_TYPE_AUDIO:
1672                 codec->sample_rate = icodec->sample_rate;
1673                 codec->channels = icodec->channels;
1674                 codec->frame_size = icodec->frame_size;
1675                 codec->block_align= icodec->block_align;
1676                 break;
1677             case CODEC_TYPE_VIDEO:
1678                 codec->time_base = icodec->time_base;
1679                 codec->width = icodec->width;
1680                 codec->height = icodec->height;
1681                 codec->has_b_frames = icodec->has_b_frames;
1682                 break;
1683             case CODEC_TYPE_SUBTITLE:
1684                 break;
1685             default:
1686                 av_abort();
1687             }
1688         } else {
1689             switch(codec->codec_type) {
1690             case CODEC_TYPE_AUDIO:
1691                 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1692                     goto fail;
1693
1694                 if (codec->channels == icodec->channels &&
1695                     codec->sample_rate == icodec->sample_rate) {
1696                     ost->audio_resample = 0;
1697                 } else {
1698                     if (codec->channels != icodec->channels &&
1699                         (icodec->codec_id == CODEC_ID_AC3 ||
1700                          icodec->codec_id == CODEC_ID_DTS)) {
1701                         /* Special case for 5:1 AC3 and DTS input */
1702                         /* and mono or stereo output      */
1703                         /* Request specific number of channels */
1704                         icodec->channels = codec->channels;
1705                         if (codec->sample_rate == icodec->sample_rate)
1706                             ost->audio_resample = 0;
1707                         else {
1708                             ost->audio_resample = 1;
1709                         }
1710                     } else {
1711                         ost->audio_resample = 1;
1712                     }
1713                 }
1714                 if(audio_sync_method>1)
1715                     ost->audio_resample = 1;
1716
1717                 if(ost->audio_resample){
1718                     ost->resample = audio_resample_init(codec->channels, icodec->channels,
1719                                                     codec->sample_rate, icodec->sample_rate);
1720                     if(!ost->resample){
1721                         printf("Can't resample.  Aborting.\n");
1722                         av_abort();
1723                     }
1724                 }
1725                 ist->decoding_needed = 1;
1726                 ost->encoding_needed = 1;
1727                 break;
1728             case CODEC_TYPE_VIDEO:
1729                 if (codec->width == icodec->width &&
1730                     codec->height == icodec->height &&
1731                     frame_topBand == 0 &&
1732                     frame_bottomBand == 0 &&
1733                     frame_leftBand == 0 &&
1734                     frame_rightBand == 0 &&
1735                     frame_padtop == 0 &&
1736                     frame_padbottom == 0 &&
1737                     frame_padleft == 0 &&
1738                     frame_padright == 0)
1739                 {
1740                     ost->video_resample = 0;
1741                     ost->video_crop = 0;
1742                     ost->video_pad = 0;
1743                 } else if ((codec->width == icodec->width -
1744                                 (frame_leftBand + frame_rightBand)) &&
1745                         (codec->height == icodec->height -
1746                                 (frame_topBand  + frame_bottomBand)))
1747                 {
1748                     ost->video_resample = 0;
1749                     ost->video_crop = 1;
1750                     ost->topBand = frame_topBand;
1751                     ost->leftBand = frame_leftBand;
1752                 } else if ((codec->width == icodec->width +
1753                                 (frame_padleft + frame_padright)) &&
1754                         (codec->height == icodec->height +
1755                                 (frame_padtop + frame_padbottom))) {
1756                     ost->video_resample = 0;
1757                     ost->video_crop = 0;
1758                     ost->video_pad = 1;
1759                     ost->padtop = frame_padtop;
1760                     ost->padleft = frame_padleft;
1761                     ost->padbottom = frame_padbottom;
1762                     ost->padright = frame_padright;
1763                     avcodec_get_frame_defaults(&ost->pict_tmp);
1764                     if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1765                                 codec->width, codec->height ) )
1766                         goto fail;
1767                 } else {
1768                     ost->video_resample = 1;
1769                     ost->video_crop = 0; // cropping is handled as part of resample
1770                     avcodec_get_frame_defaults(&ost->pict_tmp);
1771                     if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1772                                          codec->width, codec->height ) )
1773                         goto fail;
1774
1775                     ost->img_resample_ctx = img_resample_full_init(
1776                                       ost->st->codec->width, ost->st->codec->height,
1777                                       ist->st->codec->width, ist->st->codec->height,
1778                                       frame_topBand, frame_bottomBand,
1779                             frame_leftBand, frame_rightBand,
1780                             frame_padtop, frame_padbottom,
1781                             frame_padleft, frame_padright);
1782
1783                     ost->padtop = frame_padtop;
1784                     ost->padleft = frame_padleft;
1785                     ost->padbottom = frame_padbottom;
1786                     ost->padright = frame_padright;
1787
1788                 }
1789                 ost->encoding_needed = 1;
1790                 ist->decoding_needed = 1;
1791                 break;
1792             case CODEC_TYPE_SUBTITLE:
1793                 ost->encoding_needed = 1;
1794                 ist->decoding_needed = 1;
1795                 break;
1796             default:
1797                 av_abort();
1798                 break;
1799             }
1800             /* two pass mode */
1801             if (ost->encoding_needed &&
1802                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1803                 char logfilename[1024];
1804                 FILE *f;
1805                 int size;
1806                 char *logbuffer;
1807
1808                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1809                          pass_logfilename ?
1810                          pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1811                 if (codec->flags & CODEC_FLAG_PASS1) {
1812                     f = fopen(logfilename, "w");
1813                     if (!f) {
1814                         perror(logfilename);
1815                         exit(1);
1816                     }
1817                     ost->logfile = f;
1818                 } else {
1819                     /* read the log file */
1820                     f = fopen(logfilename, "r");
1821                     if (!f) {
1822                         perror(logfilename);
1823                         exit(1);
1824                     }
1825                     fseek(f, 0, SEEK_END);
1826                     size = ftell(f);
1827                     fseek(f, 0, SEEK_SET);
1828                     logbuffer = av_malloc(size + 1);
1829                     if (!logbuffer) {
1830                         fprintf(stderr, "Could not allocate log buffer\n");
1831                         exit(1);
1832                     }
1833                     size = fread(logbuffer, 1, size, f);
1834                     fclose(f);
1835                     logbuffer[size] = '\0';
1836                     codec->stats_in = logbuffer;
1837                 }
1838             }
1839         }
1840         if(codec->codec_type == CODEC_TYPE_VIDEO){
1841             int size= codec->width * codec->height;
1842             bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1843         }
1844     }
1845
1846     if (!bit_buffer)
1847         bit_buffer = av_malloc(bit_buffer_size);
1848     if (!bit_buffer)
1849         goto fail;
1850
1851     /* dump the file output parameters - cannot be done before in case
1852        of stream copy */
1853     for(i=0;i<nb_output_files;i++) {
1854         dump_format(output_files[i], i, output_files[i]->filename, 1);
1855     }
1856
1857     /* dump the stream mapping */
1858     if (verbose >= 0) {
1859         fprintf(stderr, "Stream mapping:\n");
1860         for(i=0;i<nb_ostreams;i++) {
1861             ost = ost_table[i];
1862             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1863                     ist_table[ost->source_index]->file_index,
1864                     ist_table[ost->source_index]->index,
1865                     ost->file_index,
1866                     ost->index);
1867             if (ost->sync_ist != ist_table[ost->source_index])
1868                 fprintf(stderr, " [sync #%d.%d]",
1869                         ost->sync_ist->file_index,
1870                         ost->sync_ist->index);
1871             fprintf(stderr, "\n");
1872         }
1873     }
1874
1875     /* open each encoder */
1876     for(i=0;i<nb_ostreams;i++) {
1877         ost = ost_table[i];
1878         if (ost->encoding_needed) {
1879             AVCodec *codec;
1880             codec = avcodec_find_encoder(ost->st->codec->codec_id);
1881             if (!codec) {
1882                 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1883                         ost->file_index, ost->index);
1884                 exit(1);
1885             }
1886             if (avcodec_open(ost->st->codec, codec) < 0) {
1887                 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1888                         ost->file_index, ost->index);
1889                 exit(1);
1890             }
1891             extra_size += ost->st->codec->extradata_size;
1892         }
1893     }
1894
1895     /* open each decoder */
1896     for(i=0;i<nb_istreams;i++) {
1897         ist = ist_table[i];
1898         if (ist->decoding_needed) {
1899             AVCodec *codec;
1900             codec = avcodec_find_decoder(ist->st->codec->codec_id);
1901             if (!codec) {
1902                 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1903                         ist->st->codec->codec_id, ist->file_index, ist->index);
1904                 exit(1);
1905             }
1906             if (avcodec_open(ist->st->codec, codec) < 0) {
1907                 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1908                         ist->file_index, ist->index);
1909                 exit(1);
1910             }
1911             //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1912             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1913         }
1914     }
1915
1916     /* init pts */
1917     for(i=0;i<nb_istreams;i++) {
1918         ist = ist_table[i];
1919         is = input_files[ist->file_index];
1920         ist->pts = 0;
1921         ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1922         if(ist->st->start_time == AV_NOPTS_VALUE)
1923             ist->next_pts=0;
1924         if(input_files_ts_offset[ist->file_index])
1925             ist->next_pts= AV_NOPTS_VALUE;
1926         ist->is_start = 1;
1927     }
1928
1929     /* compute buffer size max (should use a complete heuristic) */
1930     for(i=0;i<nb_input_files;i++) {
1931         file_table[i].buffer_size_max = 2048;
1932     }
1933
1934     /* set meta data information from input file if required */
1935     for (i=0;i<nb_meta_data_maps;i++) {
1936         AVFormatContext *out_file;
1937         AVFormatContext *in_file;
1938
1939         int out_file_index = meta_data_maps[i].out_file;
1940         int in_file_index = meta_data_maps[i].in_file;
1941         if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1942             fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1943             ret = -EINVAL;
1944             goto fail;
1945         }
1946         if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1947             fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1948             ret = -EINVAL;
1949             goto fail;
1950         }
1951
1952         out_file = output_files[out_file_index];
1953         in_file = input_files[in_file_index];
1954
1955         strcpy(out_file->title, in_file->title);
1956         strcpy(out_file->author, in_file->author);
1957         strcpy(out_file->copyright, in_file->copyright);
1958         strcpy(out_file->comment, in_file->comment);
1959         strcpy(out_file->album, in_file->album);
1960         out_file->year = in_file->year;
1961         out_file->track = in_file->track;
1962         strcpy(out_file->genre, in_file->genre);
1963     }
1964
1965     /* open files and write file headers */
1966     for(i=0;i<nb_output_files;i++) {
1967         os = output_files[i];
1968         if (av_write_header(os) < 0) {
1969             fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1970             ret = -EINVAL;
1971             goto fail;
1972         }
1973     }
1974
1975 #ifndef CONFIG_WIN32
1976     if ( !using_stdin && verbose >= 0) {
1977         fprintf(stderr, "Press [q] to stop encoding\n");
1978         url_set_interrupt_cb(decode_interrupt_cb);
1979     }
1980 #endif
1981     term_init();
1982
1983     stream_no_data = 0;
1984     key = -1;
1985
1986     for(; received_sigterm == 0;) {
1987         int file_index, ist_index;
1988         AVPacket pkt;
1989         double ipts_min;
1990         double opts_min;
1991
1992     redo:
1993         ipts_min= 1e100;
1994         opts_min= 1e100;
1995         /* if 'q' pressed, exits */
1996         if (!using_stdin) {
1997             if (q_pressed)
1998                 break;
1999             /* read_key() returns 0 on EOF */
2000             key = read_key();
2001             if (key == 'q')
2002                 break;
2003         }
2004
2005         /* select the stream that we must read now by looking at the
2006            smallest output pts */
2007         file_index = -1;
2008         for(i=0;i<nb_ostreams;i++) {
2009             double ipts, opts;
2010             ost = ost_table[i];
2011             os = output_files[ost->file_index];
2012             ist = ist_table[ost->source_index];
2013             if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2014                 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2015             else
2016                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2017             ipts = (double)ist->pts;
2018             if (!file_table[ist->file_index].eof_reached){
2019                 if(ipts < ipts_min) {
2020                     ipts_min = ipts;
2021                     if(input_sync ) file_index = ist->file_index;
2022                 }
2023                 if(opts < opts_min) {
2024                     opts_min = opts;
2025                     if(!input_sync) file_index = ist->file_index;
2026                 }
2027             }
2028             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2029                 file_index= -1;
2030                 break;
2031             }
2032         }
2033         /* if none, if is finished */
2034         if (file_index < 0) {
2035             break;
2036         }
2037
2038         /* finish if recording time exhausted */
2039         if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
2040             break;
2041
2042         /* finish if limit size exhausted */
2043         if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
2044             break;
2045
2046         /* read a frame from it and output it in the fifo */
2047         is = input_files[file_index];
2048         if (av_read_frame(is, &pkt) < 0) {
2049             file_table[file_index].eof_reached = 1;
2050             if (opt_shortest) break; else continue; //
2051         }
2052
2053         if (!pkt.size) {
2054             stream_no_data = is;
2055         } else {
2056             stream_no_data = 0;
2057         }
2058         if (do_pkt_dump) {
2059             av_pkt_dump(stdout, &pkt, do_hex_dump);
2060         }
2061         /* the following test is needed in case new streams appear
2062            dynamically in stream : we ignore them */
2063         if (pkt.stream_index >= file_table[file_index].nb_streams)
2064             goto discard_packet;
2065         ist_index = file_table[file_index].ist_index + pkt.stream_index;
2066         ist = ist_table[ist_index];
2067         if (ist->discard)
2068             goto discard_packet;
2069
2070 //        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);
2071         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2072             int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
2073             if(ABS(delta) > 10LL*AV_TIME_BASE && !copy_ts){
2074                 input_files_ts_offset[ist->file_index]-= delta;
2075                 if (verbose > 2)
2076                     fprintf(stderr, "timestamp discontinuity %lld, new offset= %lld\n", delta, input_files_ts_offset[ist->file_index]);
2077                 for(i=0; i<file_table[file_index].nb_streams; i++){
2078                     int index= file_table[file_index].ist_index + i;
2079                     ist_table[index]->next_pts += delta;
2080                     ist_table[index]->is_start=1;
2081                 }
2082             }
2083         }
2084
2085         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2086         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2087
2088             if (verbose >= 0)
2089                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2090                         ist->file_index, ist->index);
2091
2092             av_free_packet(&pkt);
2093             goto redo;
2094         }
2095
2096     discard_packet:
2097         av_free_packet(&pkt);
2098
2099         /* dump report by using the output first video and audio streams */
2100         print_report(output_files, ost_table, nb_ostreams, 0);
2101     }
2102
2103     /* at the end of stream, we must flush the decoder buffers */
2104     for(i=0;i<nb_istreams;i++) {
2105         ist = ist_table[i];
2106         if (ist->decoding_needed) {
2107             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2108         }
2109     }
2110
2111     term_exit();
2112
2113     /* write the trailer if needed and close file */
2114     for(i=0;i<nb_output_files;i++) {
2115         os = output_files[i];
2116         av_write_trailer(os);
2117     }
2118
2119     /* dump report by using the first video and audio streams */
2120     print_report(output_files, ost_table, nb_ostreams, 1);
2121
2122     /* close each encoder */
2123     for(i=0;i<nb_ostreams;i++) {
2124         ost = ost_table[i];
2125         if (ost->encoding_needed) {
2126             av_freep(&ost->st->codec->stats_in);
2127             avcodec_close(ost->st->codec);
2128         }
2129     }
2130
2131     /* close each decoder */
2132     for(i=0;i<nb_istreams;i++) {
2133         ist = ist_table[i];
2134         if (ist->decoding_needed) {
2135             avcodec_close(ist->st->codec);
2136         }
2137     }
2138
2139     /* finished ! */
2140
2141     ret = 0;
2142  fail1:
2143     av_freep(&bit_buffer);
2144     av_free(file_table);
2145
2146     if (ist_table) {
2147         for(i=0;i<nb_istreams;i++) {
2148             ist = ist_table[i];
2149             av_free(ist);
2150         }
2151         av_free(ist_table);
2152     }
2153     if (ost_table) {
2154         for(i=0;i<nb_ostreams;i++) {
2155             ost = ost_table[i];
2156             if (ost) {
2157                 if (ost->logfile) {
2158                     fclose(ost->logfile);
2159                     ost->logfile = NULL;
2160                 }
2161                 fifo_free(&ost->fifo); /* works even if fifo is not
2162                                           initialized but set to zero */
2163                 av_free(ost->pict_tmp.data[0]);
2164                 if (ost->video_resample)
2165                     img_resample_close(ost->img_resample_ctx);
2166                 if (ost->audio_resample)
2167                     audio_resample_close(ost->resample);
2168                 av_free(ost);
2169             }
2170         }
2171         av_free(ost_table);
2172     }
2173     return ret;
2174  fail:
2175     ret = -ENOMEM;
2176     goto fail1;
2177 }
2178
2179 #if 0
2180 int file_read(const char *filename)
2181 {
2182     URLContext *h;
2183     unsigned char buffer[1024];
2184     int len, i;
2185
2186     if (url_open(&h, filename, O_RDONLY) < 0) {
2187         printf("could not open '%s'\n", filename);
2188         return -1;
2189     }
2190     for(;;) {
2191         len = url_read(h, buffer, sizeof(buffer));
2192         if (len <= 0)
2193             break;
2194         for(i=0;i<len;i++) putchar(buffer[i]);
2195     }
2196     url_close(h);
2197     return 0;
2198 }
2199 #endif
2200
2201 static void opt_image_format(const char *arg)
2202 {
2203     AVImageFormat *f;
2204
2205     for(f = first_image_format; f != NULL; f = f->next) {
2206         if (!strcmp(arg, f->name))
2207             break;
2208     }
2209     if (!f) {
2210         fprintf(stderr, "Unknown image format: '%s'\n", arg);
2211         exit(1);
2212     }
2213     image_format = f;
2214 }
2215
2216 static void opt_format(const char *arg)
2217 {
2218     /* compatibility stuff for pgmyuv */
2219     if (!strcmp(arg, "pgmyuv")) {
2220         pgmyuv_compatibility_hack=1;
2221 //        opt_image_format(arg);
2222         arg = "image2";
2223     }
2224
2225     file_iformat = av_find_input_format(arg);
2226     file_oformat = guess_format(arg, NULL, NULL);
2227     if (!file_iformat && !file_oformat) {
2228         fprintf(stderr, "Unknown input or output format: %s\n", arg);
2229         exit(1);
2230     }
2231 }
2232
2233 static void opt_video_bitrate(const char *arg)
2234 {
2235     video_bit_rate = atoi(arg) * 1000;
2236 }
2237
2238 static void opt_video_bitrate_tolerance(const char *arg)
2239 {
2240     video_bit_rate_tolerance = atoi(arg) * 1000;
2241 }
2242
2243 static void opt_video_bitrate_max(const char *arg)
2244 {
2245     video_rc_max_rate = atoi(arg) * 1000;
2246 }
2247
2248 static void opt_video_bitrate_min(const char *arg)
2249 {
2250     video_rc_min_rate = atoi(arg) * 1000;
2251 }
2252
2253 static void opt_video_buffer_size(const char *arg)
2254 {
2255     video_rc_buffer_size = atoi(arg) * 8*1024;
2256 }
2257
2258 static void opt_video_rc_eq(char *arg)
2259 {
2260     video_rc_eq = arg;
2261 }
2262
2263 static void opt_video_rc_override_string(char *arg)
2264 {
2265     video_rc_override_string = arg;
2266 }
2267
2268
2269 static void opt_workaround_bugs(const char *arg)
2270 {
2271     workaround_bugs = atoi(arg);
2272 }
2273
2274 static void opt_dct_algo(const char *arg)
2275 {
2276     dct_algo = atoi(arg);
2277 }
2278
2279 static void opt_idct_algo(const char *arg)
2280 {
2281     idct_algo = atoi(arg);
2282 }
2283
2284 static void opt_me_threshold(const char *arg)
2285 {
2286     me_threshold = atoi(arg);
2287 }
2288
2289 static void opt_mb_threshold(const char *arg)
2290 {
2291     mb_threshold = atoi(arg);
2292 }
2293
2294 static void opt_error_resilience(const char *arg)
2295 {
2296     error_resilience = atoi(arg);
2297 }
2298
2299 static void opt_error_concealment(const char *arg)
2300 {
2301     error_concealment = atoi(arg);
2302 }
2303
2304 static void opt_debug(const char *arg)
2305 {
2306     debug = atoi(arg);
2307     av_log_set_level(AV_LOG_DEBUG);
2308 }
2309
2310 static void opt_vismv(const char *arg)
2311 {
2312     debug_mv = atoi(arg);
2313 }
2314
2315 static void opt_verbose(const char *arg)
2316 {
2317     verbose = atoi(arg);
2318     av_log_set_level(atoi(arg));
2319 }
2320
2321 static void opt_frame_rate(const char *arg)
2322 {
2323     if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2324         fprintf(stderr, "Incorrect frame rate\n");
2325         exit(1);
2326     }
2327 }
2328
2329 static void opt_frame_crop_top(const char *arg)
2330 {
2331     frame_topBand = atoi(arg);
2332     if (frame_topBand < 0) {
2333         fprintf(stderr, "Incorrect top crop size\n");
2334         exit(1);
2335     }
2336     if ((frame_topBand % 2) != 0) {
2337         fprintf(stderr, "Top crop size must be a multiple of 2\n");
2338         exit(1);
2339     }
2340     if ((frame_topBand) >= frame_height){
2341         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2342         exit(1);
2343     }
2344     frame_height -= frame_topBand;
2345 }
2346
2347 static void opt_frame_crop_bottom(const char *arg)
2348 {
2349     frame_bottomBand = atoi(arg);
2350     if (frame_bottomBand < 0) {
2351         fprintf(stderr, "Incorrect bottom crop size\n");
2352         exit(1);
2353     }
2354     if ((frame_bottomBand % 2) != 0) {
2355         fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2356         exit(1);
2357     }
2358     if ((frame_bottomBand) >= frame_height){
2359         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2360         exit(1);
2361     }
2362     frame_height -= frame_bottomBand;
2363 }
2364
2365 static void opt_frame_crop_left(const char *arg)
2366 {
2367     frame_leftBand = atoi(arg);
2368     if (frame_leftBand < 0) {
2369         fprintf(stderr, "Incorrect left crop size\n");
2370         exit(1);
2371     }
2372     if ((frame_leftBand % 2) != 0) {
2373         fprintf(stderr, "Left crop size must be a multiple of 2\n");
2374         exit(1);
2375     }
2376     if ((frame_leftBand) >= frame_width){
2377         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2378         exit(1);
2379     }
2380     frame_width -= frame_leftBand;
2381 }
2382
2383 static void opt_frame_crop_right(const char *arg)
2384 {
2385     frame_rightBand = atoi(arg);
2386     if (frame_rightBand < 0) {
2387         fprintf(stderr, "Incorrect right crop size\n");
2388         exit(1);
2389     }
2390     if ((frame_rightBand % 2) != 0) {
2391         fprintf(stderr, "Right crop size must be a multiple of 2\n");
2392         exit(1);
2393     }
2394     if ((frame_rightBand) >= frame_width){
2395         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2396         exit(1);
2397     }
2398     frame_width -= frame_rightBand;
2399 }
2400
2401 static void opt_frame_size(const char *arg)
2402 {
2403     if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2404         fprintf(stderr, "Incorrect frame size\n");
2405         exit(1);
2406     }
2407     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2408         fprintf(stderr, "Frame size must be a multiple of 2\n");
2409         exit(1);
2410     }
2411 }
2412
2413
2414 #define SCALEBITS 10
2415 #define ONE_HALF  (1 << (SCALEBITS - 1))
2416 #define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2417
2418 #define RGB_TO_Y(r, g, b) \
2419 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2420   FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2421
2422 #define RGB_TO_U(r1, g1, b1, shift)\
2423 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2424      FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2425
2426 #define RGB_TO_V(r1, g1, b1, shift)\
2427 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2428    FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2429
2430 static void opt_pad_color(const char *arg) {
2431     /* Input is expected to be six hex digits similar to
2432        how colors are expressed in html tags (but without the #) */
2433     int rgb = strtol(arg, NULL, 16);
2434     int r,g,b;
2435
2436     r = (rgb >> 16);
2437     g = ((rgb >> 8) & 255);
2438     b = (rgb & 255);
2439
2440     padcolor[0] = RGB_TO_Y(r,g,b);
2441     padcolor[1] = RGB_TO_U(r,g,b,0);
2442     padcolor[2] = RGB_TO_V(r,g,b,0);
2443 }
2444
2445 static void opt_frame_pad_top(const char *arg)
2446 {
2447     frame_padtop = atoi(arg);
2448     if (frame_padtop < 0) {
2449         fprintf(stderr, "Incorrect top pad size\n");
2450         exit(1);
2451     }
2452     if ((frame_padtop % 2) != 0) {
2453         fprintf(stderr, "Top pad size must be a multiple of 2\n");
2454         exit(1);
2455     }
2456 }
2457
2458 static void opt_frame_pad_bottom(const char *arg)
2459 {
2460     frame_padbottom = atoi(arg);
2461     if (frame_padbottom < 0) {
2462         fprintf(stderr, "Incorrect bottom pad size\n");
2463         exit(1);
2464     }
2465     if ((frame_padbottom % 2) != 0) {
2466         fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2467         exit(1);
2468     }
2469 }
2470
2471
2472 static void opt_frame_pad_left(const char *arg)
2473 {
2474     frame_padleft = atoi(arg);
2475     if (frame_padleft < 0) {
2476         fprintf(stderr, "Incorrect left pad size\n");
2477         exit(1);
2478     }
2479     if ((frame_padleft % 2) != 0) {
2480         fprintf(stderr, "Left pad size must be a multiple of 2\n");
2481         exit(1);
2482     }
2483 }
2484
2485
2486 static void opt_frame_pad_right(const char *arg)
2487 {
2488     frame_padright = atoi(arg);
2489     if (frame_padright < 0) {
2490         fprintf(stderr, "Incorrect right pad size\n");
2491         exit(1);
2492     }
2493     if ((frame_padright % 2) != 0) {
2494         fprintf(stderr, "Right pad size must be a multiple of 2\n");
2495         exit(1);
2496     }
2497 }
2498
2499
2500 static void opt_frame_pix_fmt(const char *arg)
2501 {
2502     frame_pix_fmt = avcodec_get_pix_fmt(arg);
2503 }
2504
2505 static void opt_frame_aspect_ratio(const char *arg)
2506 {
2507     int x = 0, y = 0;
2508     double ar = 0;
2509     const char *p;
2510
2511     p = strchr(arg, ':');
2512     if (p) {
2513         x = strtol(arg, (char **)&arg, 10);
2514         if (arg == p)
2515             y = strtol(arg+1, (char **)&arg, 10);
2516         if (x > 0 && y > 0)
2517             ar = (double)x / (double)y;
2518     } else
2519         ar = strtod(arg, (char **)&arg);
2520
2521     if (!ar) {
2522         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2523         exit(1);
2524     }
2525     frame_aspect_ratio = ar;
2526 }
2527
2528 static void opt_gop_size(const char *arg)
2529 {
2530     gop_size = atoi(arg);
2531 }
2532
2533 static void opt_b_frames(const char *arg)
2534 {
2535     b_frames = atoi(arg);
2536     if (b_frames > FF_MAX_B_FRAMES) {
2537         fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2538         exit(1);
2539     } else if (b_frames < 1) {
2540         fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2541         exit(1);
2542     }
2543 }
2544
2545 static void opt_mb_decision(const char *arg)
2546 {
2547     mb_decision = atoi(arg);
2548 }
2549
2550 static void opt_mb_cmp(const char *arg)
2551 {
2552     mb_cmp = atoi(arg);
2553 }
2554
2555 static void opt_ildct_cmp(const char *arg)
2556 {
2557     ildct_cmp = atoi(arg);
2558 }
2559
2560 static void opt_sub_cmp(const char *arg)
2561 {
2562     sub_cmp = atoi(arg);
2563 }
2564
2565 static void opt_cmp(const char *arg)
2566 {
2567     cmp = atoi(arg);
2568 }
2569
2570 static void opt_pre_cmp(const char *arg)
2571 {
2572     pre_cmp = atoi(arg);
2573 }
2574
2575 static void opt_pre_me(const char *arg)
2576 {
2577     pre_me = atoi(arg);
2578 }
2579
2580 static void opt_lumi_mask(const char *arg)
2581 {
2582     lumi_mask = atof(arg);
2583 }
2584
2585 static void opt_dark_mask(const char *arg)
2586 {
2587     dark_mask = atof(arg);
2588 }
2589
2590 static void opt_scplx_mask(const char *arg)
2591 {
2592     scplx_mask = atof(arg);
2593 }
2594
2595 static void opt_tcplx_mask(const char *arg)
2596 {
2597     tcplx_mask = atof(arg);
2598 }
2599
2600 static void opt_p_mask(const char *arg)
2601 {
2602     p_mask = atof(arg);
2603 }
2604
2605 static void opt_qscale(const char *arg)
2606 {
2607     video_qscale = atof(arg);
2608     if (video_qscale < 0.01 ||
2609         video_qscale > 255) {
2610         fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2611         exit(1);
2612     }
2613 }
2614
2615 static void opt_qsquish(const char *arg)
2616 {
2617     video_qsquish = atof(arg);
2618     if (video_qsquish < 0.0 ||
2619         video_qsquish > 99.0) {
2620         fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
2621         exit(1);
2622     }
2623 }
2624
2625 static void opt_lelim(const char *arg)
2626 {
2627     video_lelim = atoi(arg);
2628     if (video_lelim < -99 ||
2629         video_lelim > 99) {
2630         fprintf(stderr, "lelim must be >= -99 and <= 99\n");
2631         exit(1);
2632     }
2633 }
2634
2635 static void opt_celim(const char *arg)
2636 {
2637     video_celim = atoi(arg);
2638     if (video_celim < -99 ||
2639         video_celim > 99) {
2640         fprintf(stderr, "celim must be >= -99 and <= 99\n");
2641         exit(1);
2642     }
2643 }
2644
2645 static void opt_lmax(const char *arg)
2646 {
2647     video_lmax = atof(arg)*FF_QP2LAMBDA;
2648 }
2649
2650 static void opt_lmin(const char *arg)
2651 {
2652     video_lmin = atof(arg)*FF_QP2LAMBDA;
2653 }
2654
2655 static void opt_qmin(const char *arg)
2656 {
2657     video_qmin = atoi(arg);
2658     if (video_qmin < 1 ||
2659         video_qmin > 31) {
2660         fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2661         exit(1);
2662     }
2663 }
2664
2665 static void opt_qmax(const char *arg)
2666 {
2667     video_qmax = atoi(arg);
2668     if (video_qmax < 1 ||
2669         video_qmax > 31) {
2670         fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2671         exit(1);
2672     }
2673 }
2674
2675 static void opt_mb_lmin(const char *arg)
2676 {
2677     video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2678     if (video_mb_lmin < 1 ||
2679         video_mb_lmin > FF_LAMBDA_MAX) {
2680         fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2681         exit(1);
2682     }
2683 }
2684
2685 static void opt_mb_lmax(const char *arg)
2686 {
2687     video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2688     if (video_mb_lmax < 1 ||
2689         video_mb_lmax > FF_LAMBDA_MAX) {
2690         fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2691         exit(1);
2692     }
2693 }
2694
2695 static void opt_qdiff(const char *arg)
2696 {
2697     video_qdiff = atoi(arg);
2698     if (video_qdiff < 0 ||
2699         video_qdiff > 31) {
2700         fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2701         exit(1);
2702     }
2703 }
2704
2705 static void opt_qblur(const char *arg)
2706 {
2707     video_qblur = atof(arg);
2708 }
2709
2710 static void opt_qcomp(const char *arg)
2711 {
2712     video_qcomp = atof(arg);
2713 }
2714
2715 static void opt_rc_initial_cplx(const char *arg)
2716 {
2717     video_rc_initial_cplx = atof(arg);
2718 }
2719 static void opt_b_qfactor(const char *arg)
2720 {
2721     video_b_qfactor = atof(arg);
2722 }
2723 static void opt_i_qfactor(const char *arg)
2724 {
2725     video_i_qfactor = atof(arg);
2726 }
2727 static void opt_b_qoffset(const char *arg)
2728 {
2729     video_b_qoffset = atof(arg);
2730 }
2731 static void opt_i_qoffset(const char *arg)
2732 {
2733     video_i_qoffset = atof(arg);
2734 }
2735
2736 static void opt_ibias(const char *arg)
2737 {
2738     video_intra_quant_bias = atoi(arg);
2739 }
2740 static void opt_pbias(const char *arg)
2741 {
2742     video_inter_quant_bias = atoi(arg);
2743 }
2744
2745 static void opt_packet_size(const char *arg)
2746 {
2747     packet_size= atoi(arg);
2748 }
2749
2750 static void opt_error_rate(const char *arg)
2751 {
2752     error_rate= atoi(arg);
2753 }
2754
2755 static void opt_strict(const char *arg)
2756 {
2757     strict= atoi(arg);
2758 }
2759
2760 static void opt_top_field_first(const char *arg)
2761 {
2762     top_field_first= atoi(arg);
2763 }
2764
2765 static void opt_noise_reduction(const char *arg)
2766 {
2767     noise_reduction= atoi(arg);
2768 }
2769
2770 static void opt_qns(const char *arg)
2771 {
2772     qns= atoi(arg);
2773 }
2774
2775 static void opt_sc_threshold(const char *arg)
2776 {
2777     sc_threshold= atoi(arg);
2778 }
2779
2780 static void opt_me_range(const char *arg)
2781 {
2782     me_range = atoi(arg);
2783 }
2784
2785 static void opt_thread_count(const char *arg)
2786 {
2787     thread_count= atoi(arg);
2788 #if !defined(HAVE_THREADS)
2789     if (verbose >= 0)
2790         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2791 #endif
2792 }
2793
2794 static void opt_audio_bitrate(const char *arg)
2795 {
2796     audio_bit_rate = atoi(arg) * 1000;
2797 }
2798
2799 static void opt_audio_rate(const char *arg)
2800 {
2801     audio_sample_rate = atoi(arg);
2802 }
2803
2804 static void opt_audio_channels(const char *arg)
2805 {
2806     audio_channels = atoi(arg);
2807 }
2808
2809 static void opt_video_device(const char *arg)
2810 {
2811     video_device = av_strdup(arg);
2812 }
2813
2814 static void opt_grab_device(const char *arg)
2815 {
2816     grab_device = av_strdup(arg);
2817 }
2818
2819 static void opt_video_channel(const char *arg)
2820 {
2821     video_channel = strtol(arg, NULL, 0);
2822 }
2823
2824 static void opt_video_standard(const char *arg)
2825 {
2826     video_standard = av_strdup(arg);
2827 }
2828
2829 static void opt_audio_device(const char *arg)
2830 {
2831     audio_device = av_strdup(arg);
2832 }
2833
2834 static void opt_codec(int *pstream_copy, int *pcodec_id,
2835                       int codec_type, const char *arg)
2836 {
2837     AVCodec *p;
2838
2839     if (!strcmp(arg, "copy")) {
2840         *pstream_copy = 1;
2841     } else {
2842         p = first_avcodec;
2843         while (p) {
2844             if (!strcmp(p->name, arg) && p->type == codec_type)
2845                 break;
2846             p = p->next;
2847         }
2848         if (p == NULL) {
2849             fprintf(stderr, "Unknown codec '%s'\n", arg);
2850             exit(1);
2851         } else {
2852             *pcodec_id = p->id;
2853         }
2854     }
2855 }
2856
2857 static void opt_audio_codec(const char *arg)
2858 {
2859     opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2860 }
2861
2862 static void opt_audio_tag(const char *arg)
2863 {
2864     char *tail;
2865     audio_codec_tag= strtol(arg, &tail, 0);
2866
2867     if(!tail || *tail)
2868         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2869 }
2870
2871 static void opt_video_tag(const char *arg)
2872 {
2873     char *tail;
2874     video_codec_tag= strtol(arg, &tail, 0);
2875
2876     if(!tail || *tail)
2877         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2878 }
2879
2880 static void add_frame_hooker(const char *arg)
2881 {
2882     int argc = 0;
2883     char *argv[64];
2884     int i;
2885     char *args = av_strdup(arg);
2886
2887     using_vhook = 1;
2888
2889     argv[0] = strtok(args, " ");
2890     while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2891     }
2892
2893     i = frame_hook_add(argc, argv);
2894
2895     if (i != 0) {
2896         fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2897         exit(1);
2898     }
2899 }
2900
2901 const char *motion_str[] = {
2902     "zero",
2903     "full",
2904     "log",
2905     "phods",
2906     "epzs",
2907     "x1",
2908     NULL,
2909 };
2910
2911 static void opt_motion_estimation(const char *arg)
2912 {
2913     const char **p;
2914     p = motion_str;
2915     for(;;) {
2916         if (!*p) {
2917             fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2918             exit(1);
2919         }
2920         if (!strcmp(*p, arg))
2921             break;
2922         p++;
2923     }
2924     me_method = (p - motion_str) + 1;
2925 }
2926
2927 static void opt_video_codec(const char *arg)
2928 {
2929     opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2930 }
2931
2932 static void opt_subtitle_codec(const char *arg)
2933 {
2934     opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2935 }
2936
2937 static void opt_map(const char *arg)
2938 {
2939     AVStreamMap *m;
2940     const char *p;
2941
2942     p = arg;
2943     m = &stream_maps[nb_stream_maps++];
2944
2945     m->file_index = strtol(arg, (char **)&p, 0);
2946     if (*p)
2947         p++;
2948
2949     m->stream_index = strtol(p, (char **)&p, 0);
2950     if (*p) {
2951         p++;
2952         m->sync_file_index = strtol(p, (char **)&p, 0);
2953         if (*p)
2954             p++;
2955         m->sync_stream_index = strtol(p, (char **)&p, 0);
2956     } else {
2957         m->sync_file_index = m->file_index;
2958         m->sync_stream_index = m->stream_index;
2959     }
2960 }
2961
2962 static void opt_map_meta_data(const char *arg)
2963 {
2964     AVMetaDataMap *m;
2965     const char *p;
2966
2967     p = arg;
2968     m = &meta_data_maps[nb_meta_data_maps++];
2969
2970     m->out_file = strtol(arg, (char **)&p, 0);
2971     if (*p)
2972         p++;
2973
2974     m->in_file = strtol(p, (char **)&p, 0);
2975 }
2976
2977 static void opt_recording_time(const char *arg)
2978 {
2979     recording_time = parse_date(arg, 1);
2980 }
2981
2982 static void opt_start_time(const char *arg)
2983 {
2984     start_time = parse_date(arg, 1);
2985 }
2986
2987 static void opt_rec_timestamp(const char *arg)
2988 {
2989     rec_timestamp = parse_date(arg, 0) / 1000000;
2990 }
2991
2992 static void opt_input_ts_offset(const char *arg)
2993 {
2994     input_ts_offset = parse_date(arg, 1);
2995 }
2996
2997 static void opt_input_file(const char *filename)
2998 {
2999     AVFormatContext *ic;
3000     AVFormatParameters params, *ap = &params;
3001     int err, i, ret, rfps, rfps_base;
3002     int64_t timestamp;
3003
3004     if (!strcmp(filename, "-"))
3005         filename = "pipe:";
3006
3007     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3008                    !strcmp( filename, "/dev/stdin" );
3009
3010     /* get default parameters from command line */
3011     memset(ap, 0, sizeof(*ap));
3012     ap->sample_rate = audio_sample_rate;
3013     ap->channels = audio_channels;
3014     ap->time_base.den = frame_rate;
3015     ap->time_base.num = frame_rate_base;
3016     ap->width = frame_width + frame_padleft + frame_padright;
3017     ap->height = frame_height + frame_padtop + frame_padbottom;
3018     ap->image_format = image_format;
3019     ap->pix_fmt = frame_pix_fmt;
3020     ap->device  = grab_device;
3021     ap->channel = video_channel;
3022     ap->standard = video_standard;
3023     ap->video_codec_id = video_codec_id;
3024     ap->audio_codec_id = audio_codec_id;
3025     if(pgmyuv_compatibility_hack)
3026         ap->video_codec_id= CODEC_ID_PGMYUV;
3027
3028     /* open the input file with generic libav function */
3029     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3030     if (err < 0) {
3031         print_error(filename, err);
3032         exit(1);
3033     }
3034
3035     /* If not enough info to get the stream parameters, we decode the
3036        first frames to get it. (used in mpeg case for example) */
3037     ret = av_find_stream_info(ic);
3038     if (ret < 0 && verbose >= 0) {
3039         fprintf(stderr, "%s: could not find codec parameters\n", filename);
3040         exit(1);
3041     }
3042
3043     timestamp = start_time;
3044     /* add the stream start time */
3045     if (ic->start_time != AV_NOPTS_VALUE)
3046         timestamp += ic->start_time;
3047
3048     /* if seeking requested, we execute it */
3049     if (start_time != 0) {
3050         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3051         if (ret < 0) {
3052             fprintf(stderr, "%s: could not seek to position %0.3f\n",
3053                     filename, (double)timestamp / AV_TIME_BASE);
3054         }
3055         /* reset seek info */
3056         start_time = 0;
3057     }
3058
3059     /* update the current parameters so that they match the one of the input stream */
3060     for(i=0;i<ic->nb_streams;i++) {
3061         AVCodecContext *enc = ic->streams[i]->codec;
3062 #if defined(HAVE_THREADS)
3063         if(thread_count>1)
3064             avcodec_thread_init(enc, thread_count);
3065 #endif
3066         enc->thread_count= thread_count;
3067         switch(enc->codec_type) {
3068         case CODEC_TYPE_AUDIO:
3069             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
3070             audio_channels = enc->channels;
3071             audio_sample_rate = enc->sample_rate;
3072             if(audio_disable)
3073                 ic->streams[i]->discard= AVDISCARD_ALL;
3074             break;
3075         case CODEC_TYPE_VIDEO:
3076             frame_height = enc->height;
3077             frame_width = enc->width;
3078             frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
3079             frame_pix_fmt = enc->pix_fmt;
3080             rfps      = ic->streams[i]->r_frame_rate.num;
3081             rfps_base = ic->streams[i]->r_frame_rate.den;
3082             enc->workaround_bugs = workaround_bugs;
3083             enc->error_resilience = error_resilience;
3084             enc->error_concealment = error_concealment;
3085             enc->idct_algo = idct_algo;
3086             enc->debug = debug;
3087             enc->debug_mv = debug_mv;
3088             enc->lowres= lowres;
3089             if(lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
3090             if(bitexact)
3091                 enc->flags|= CODEC_FLAG_BITEXACT;
3092             if(me_threshold)
3093                 enc->debug |= FF_DEBUG_MV;
3094             if(gray_only)
3095                 enc->flags |= CODEC_FLAG_GRAY;
3096
3097             if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
3098
3099                 if (verbose >= 0)
3100                     fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3101                             i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
3102
3103                     (float)rfps / rfps_base, rfps, rfps_base);
3104             }
3105             /* update the current frame rate to match the stream frame rate */
3106             frame_rate      = rfps;
3107             frame_rate_base = rfps_base;
3108
3109             enc->rate_emu = rate_emu;
3110             if(video_disable)
3111                 ic->streams[i]->discard= AVDISCARD_ALL;
3112             else if(video_discard)
3113                 ic->streams[i]->discard= video_discard;
3114             break;
3115         case CODEC_TYPE_DATA:
3116             break;
3117         case CODEC_TYPE_SUBTITLE:
3118             break;
3119         default:
3120             av_abort();
3121         }
3122     }
3123
3124     input_files[nb_input_files] = ic;
3125     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3126     /* dump the file content */
3127     if (verbose >= 0)
3128         dump_format(ic, nb_input_files, filename, 0);
3129
3130     nb_input_files++;
3131     file_iformat = NULL;
3132     file_oformat = NULL;
3133     image_format = NULL;
3134
3135     grab_device = NULL;
3136     video_channel = 0;
3137
3138     rate_emu = 0;
3139 }
3140
3141 static void opt_grab(const char *arg)
3142 {
3143     file_iformat = av_find_input_format(arg);
3144     opt_input_file("");
3145 }
3146
3147 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
3148 {
3149     int has_video, has_audio, i, j;
3150     AVFormatContext *ic;
3151
3152     has_video = 0;
3153     has_audio = 0;
3154     for(j=0;j<nb_input_files;j++) {
3155         ic = input_files[j];
3156         for(i=0;i<ic->nb_streams;i++) {
3157             AVCodecContext *enc = ic->streams[i]->codec;
3158             switch(enc->codec_type) {
3159             case CODEC_TYPE_AUDIO:
3160                 has_audio = 1;
3161                 break;
3162             case CODEC_TYPE_VIDEO:
3163                 has_video = 1;
3164                 break;
3165             case CODEC_TYPE_DATA:
3166             case CODEC_TYPE_SUBTITLE:
3167                 break;
3168             default:
3169                 av_abort();
3170             }
3171         }
3172     }
3173     *has_video_ptr = has_video;
3174     *has_audio_ptr = has_audio;
3175 }
3176
3177 static void new_video_stream(AVFormatContext *oc)
3178 {
3179     AVStream *st;
3180     AVCodecContext *video_enc;
3181     int codec_id;
3182
3183     st = av_new_stream(oc, oc->nb_streams);
3184     if (!st) {
3185         fprintf(stderr, "Could not alloc stream\n");
3186         exit(1);
3187     }
3188 #if defined(HAVE_THREADS)
3189     if(thread_count>1)
3190         avcodec_thread_init(st->codec, thread_count);
3191 #endif
3192
3193     video_enc = st->codec;
3194
3195     if(video_codec_tag)
3196         video_enc->codec_tag= video_codec_tag;
3197
3198     if(   (video_global_header&1)
3199        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER)))
3200         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3201     if(video_global_header&2)
3202         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3203
3204     if (video_stream_copy) {
3205         st->stream_copy = 1;
3206         video_enc->codec_type = CODEC_TYPE_VIDEO;
3207     } else {
3208         char *p;
3209         int i;
3210         AVCodec *codec;
3211
3212         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3213         if (video_codec_id != CODEC_ID_NONE)
3214             codec_id = video_codec_id;
3215
3216         video_enc->codec_id = codec_id;
3217         codec = avcodec_find_encoder(codec_id);
3218
3219         video_enc->bit_rate = video_bit_rate;
3220         video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
3221         video_enc->time_base.den = frame_rate;
3222         video_enc->time_base.num = frame_rate_base;
3223         if(codec && codec->supported_framerates){
3224             const AVRational *p= codec->supported_framerates;
3225             AVRational req= (AVRational){frame_rate, frame_rate_base};
3226             const AVRational *best=NULL;
3227             AVRational best_error= (AVRational){INT_MAX, 1};
3228             for(; p->den!=0; p++){
3229                 AVRational error= av_sub_q(req, *p);
3230                 if(error.num <0) error.num *= -1;
3231                 if(av_cmp_q(error, best_error) < 0){
3232                     best_error= error;
3233                     best= p;
3234                 }
3235             }
3236             video_enc->time_base.den= best->num;
3237             video_enc->time_base.num= best->den;
3238         }
3239
3240         video_enc->width = frame_width + frame_padright + frame_padleft;
3241         video_enc->height = frame_height + frame_padtop + frame_padbottom;
3242         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3243         video_enc->pix_fmt = frame_pix_fmt;
3244
3245         if(codec && codec->pix_fmts){
3246             const enum PixelFormat *p= codec->pix_fmts;
3247             for(; *p!=-1; p++){
3248                 if(*p == video_enc->pix_fmt)
3249                     break;
3250             }
3251             if(*p == -1)
3252                 video_enc->pix_fmt = codec->pix_fmts[0];
3253         }
3254
3255         if (!intra_only)
3256             video_enc->gop_size = gop_size;
3257         else
3258             video_enc->gop_size = 0;
3259         if (video_qscale || same_quality) {
3260             video_enc->flags |= CODEC_FLAG_QSCALE;
3261             video_enc->global_quality=
3262                 st->quality = FF_QP2LAMBDA * video_qscale;
3263         }
3264
3265         if(intra_matrix)
3266             video_enc->intra_matrix = intra_matrix;
3267         if(inter_matrix)
3268             video_enc->inter_matrix = inter_matrix;
3269
3270         if(bitexact)
3271             video_enc->flags |= CODEC_FLAG_BITEXACT;
3272
3273         video_enc->mb_decision = mb_decision;
3274         video_enc->mb_cmp = mb_cmp;
3275         video_enc->ildct_cmp = ildct_cmp;
3276         video_enc->me_sub_cmp = sub_cmp;
3277         video_enc->me_cmp = cmp;
3278         video_enc->me_pre_cmp = pre_cmp;
3279         video_enc->pre_me = pre_me;
3280         video_enc->lumi_masking = lumi_mask;
3281         video_enc->dark_masking = dark_mask;
3282         video_enc->spatial_cplx_masking = scplx_mask;
3283         video_enc->temporal_cplx_masking = tcplx_mask;
3284         video_enc->p_masking = p_mask;
3285         video_enc->quantizer_noise_shaping= qns;
3286
3287         if (use_umv) {
3288             video_enc->flags |= CODEC_FLAG_H263P_UMV;
3289         }
3290         if (use_ss) {
3291             video_enc->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
3292         }
3293         if (use_aic) {
3294             video_enc->flags |= CODEC_FLAG_H263P_AIC;
3295         }
3296         if (use_aiv) {
3297             video_enc->flags |= CODEC_FLAG_H263P_AIV;
3298         }
3299         if (use_4mv) {
3300             video_enc->flags |= CODEC_FLAG_4MV;
3301         }
3302         if (use_obmc) {
3303             video_enc->flags |= CODEC_FLAG_OBMC;
3304         }
3305         if (use_loop) {
3306             video_enc->flags |= CODEC_FLAG_LOOP_FILTER;
3307         }
3308
3309         if(use_part) {
3310             video_enc->flags |= CODEC_FLAG_PART;
3311         }
3312         if (use_alt_scan) {
3313             video_enc->flags |= CODEC_FLAG_ALT_SCAN;
3314         }
3315         if (use_trell) {
3316             video_enc->flags |= CODEC_FLAG_TRELLIS_QUANT;
3317         }
3318         if (use_mv0) {
3319             video_enc->flags |= CODEC_FLAG_MV0;
3320         }
3321         if (do_normalize_aqp) {
3322             video_enc->flags |= CODEC_FLAG_NORMALIZE_AQP;
3323         }
3324         if (use_scan_offset) {
3325             video_enc->flags |= CODEC_FLAG_SVCD_SCAN_OFFSET;
3326         }
3327         if (closed_gop) {
3328             video_enc->flags |= CODEC_FLAG_CLOSED_GOP;
3329         }
3330         if (strict_gop) {
3331             video_enc->flags2 |= CODEC_FLAG2_STRICT_GOP;
3332         }
3333         if (use_qpel) {
3334             video_enc->flags |= CODEC_FLAG_QPEL;
3335         }
3336         if (use_qprd) {
3337             video_enc->flags |= CODEC_FLAG_QP_RD;
3338         }
3339         if (use_cbprd) {
3340             video_enc->flags |= CODEC_FLAG_CBP_RD;
3341         }
3342         if (b_frames) {
3343             video_enc->max_b_frames = b_frames;
3344             video_enc->b_frame_strategy = b_strategy;
3345             video_enc->b_quant_factor = 2.0;
3346         }
3347         if (do_interlace_dct) {
3348             video_enc->flags |= CODEC_FLAG_INTERLACED_DCT;
3349         }
3350         if (do_interlace_me) {
3351             video_enc->flags |= CODEC_FLAG_INTERLACED_ME;
3352         }
3353         if (no_output) {
3354             video_enc->flags2 |= CODEC_FLAG2_NO_OUTPUT;
3355         }
3356         if (gray_only) {
3357             video_enc->flags |= CODEC_FLAG_GRAY;
3358         }
3359         video_enc->qmin = video_qmin;
3360         video_enc->qmax = video_qmax;
3361         video_enc->lmin = video_lmin;
3362         video_enc->lmax = video_lmax;
3363         video_enc->rc_qsquish = video_qsquish;
3364         video_enc->luma_elim_threshold = video_lelim;
3365         video_enc->chroma_elim_threshold = video_celim;
3366         video_enc->mb_lmin = video_mb_lmin;
3367         video_enc->mb_lmax = video_mb_lmax;
3368         video_enc->max_qdiff = video_qdiff;
3369         video_enc->qblur = video_qblur;
3370         video_enc->qcompress = video_qcomp;
3371         video_enc->rc_eq = video_rc_eq;
3372         video_enc->debug = debug;
3373         video_enc->debug_mv = debug_mv;
3374         video_enc->workaround_bugs = workaround_bugs;
3375         video_enc->thread_count = thread_count;
3376         p= video_rc_override_string;
3377         for(i=0; p; i++){
3378             int start, end, q;
3379             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3380             if(e!=3){
3381                 fprintf(stderr, "error parsing rc_override\n");
3382                 exit(1);
3383             }
3384             video_enc->rc_override=
3385                 av_realloc(video_enc->rc_override,
3386                            sizeof(RcOverride)*(i+1));
3387             video_enc->rc_override[i].start_frame= start;
3388             video_enc->rc_override[i].end_frame  = end;
3389             if(q>0){
3390                 video_enc->rc_override[i].qscale= q;
3391                 video_enc->rc_override[i].quality_factor= 1.0;
3392             }
3393             else{
3394                 video_enc->rc_override[i].qscale= 0;
3395                 video_enc->rc_override[i].quality_factor= -q/100.0;
3396             }
3397             p= strchr(p, '/');
3398             if(p) p++;
3399         }
3400         video_enc->rc_override_count=i;
3401
3402         video_enc->rc_max_rate = video_rc_max_rate;
3403         video_enc->rc_min_rate = video_rc_min_rate;
3404         video_enc->rc_buffer_size = video_rc_buffer_size;
3405         video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3406         video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3407         video_enc->rc_initial_cplx= video_rc_initial_cplx;
3408         video_enc->i_quant_factor = video_i_qfactor;
3409         video_enc->b_quant_factor = video_b_qfactor;
3410         video_enc->i_quant_offset = video_i_qoffset;
3411         video_enc->b_quant_offset = video_b_qoffset;
3412         video_enc->intra_quant_bias = video_intra_quant_bias;
3413         video_enc->inter_quant_bias = video_inter_quant_bias;
3414         video_enc->dct_algo = dct_algo;
3415         video_enc->idct_algo = idct_algo;
3416         video_enc->me_threshold= me_threshold;
3417         video_enc->mb_threshold= mb_threshold;
3418         video_enc->intra_dc_precision= intra_dc_precision - 8;
3419         video_enc->strict_std_compliance = strict;
3420         video_enc->error_rate = error_rate;
3421         video_enc->noise_reduction= noise_reduction;
3422         video_enc->scenechange_threshold= sc_threshold;
3423         video_enc->me_range = me_range;
3424         video_enc->coder_type= coder;
3425         video_enc->context_model= context;
3426         video_enc->prediction_method= predictor;
3427         video_enc->profile= video_profile;
3428         video_enc->level= video_level;
3429         video_enc->nsse_weight= nsse_weight;
3430         video_enc->me_subpel_quality= subpel_quality;
3431         video_enc->me_penalty_compensation= me_penalty_compensation;
3432         video_enc->frame_skip_threshold= frame_skip_threshold;
3433         video_enc->frame_skip_factor= frame_skip_factor;
3434         video_enc->frame_skip_exp= frame_skip_exp;
3435         video_enc->frame_skip_cmp= frame_skip_cmp;
3436
3437         if(packet_size){
3438             video_enc->rtp_mode= 1;
3439             video_enc->rtp_payload_size= packet_size;
3440         }
3441
3442         if (do_psnr)
3443             video_enc->flags|= CODEC_FLAG_PSNR;
3444
3445         video_enc->me_method = me_method;
3446
3447         /* two pass mode */
3448         if (do_pass) {
3449             if (do_pass == 1) {
3450                 video_enc->flags |= CODEC_FLAG_PASS1;
3451             } else {
3452                 video_enc->flags |= CODEC_FLAG_PASS2;
3453             }
3454         }
3455     }
3456
3457     /* reset some key parameters */
3458     video_disable = 0;
3459     video_codec_id = CODEC_ID_NONE;
3460     video_stream_copy = 0;
3461 }
3462
3463 static void new_audio_stream(AVFormatContext *oc)
3464 {
3465     AVStream *st;
3466     AVCodecContext *audio_enc;
3467     int codec_id;
3468
3469     st = av_new_stream(oc, oc->nb_streams);
3470     if (!st) {
3471         fprintf(stderr, "Could not alloc stream\n");
3472         exit(1);
3473     }
3474 #if defined(HAVE_THREADS)
3475     if(thread_count>1)
3476         avcodec_thread_init(st->codec, thread_count);
3477 #endif
3478
3479     audio_enc = st->codec;
3480     audio_enc->codec_type = CODEC_TYPE_AUDIO;
3481
3482     if(audio_codec_tag)
3483         audio_enc->codec_tag= audio_codec_tag;
3484
3485     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3486         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3487     if (audio_stream_copy) {
3488         st->stream_copy = 1;
3489         audio_enc->channels = audio_channels;
3490     } else {
3491         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3492         if (audio_codec_id != CODEC_ID_NONE)
3493             codec_id = audio_codec_id;
3494         audio_enc->codec_id = codec_id;
3495
3496         audio_enc->bit_rate = audio_bit_rate;
3497         audio_enc->strict_std_compliance = strict;
3498         audio_enc->thread_count = thread_count;
3499         /* For audio codecs other than AC3 or DTS we limit */
3500         /* the number of coded channels to stereo   */
3501         if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3502             && codec_id != CODEC_ID_DTS) {
3503             audio_enc->channels = 2;
3504         } else
3505             audio_enc->channels = audio_channels;
3506     }
3507     audio_enc->sample_rate = audio_sample_rate;
3508     if (audio_language) {
3509         pstrcpy(st->language, sizeof(st->language), audio_language);
3510         av_free(audio_language);
3511         audio_language = NULL;
3512     }
3513
3514     /* reset some key parameters */
3515     audio_disable = 0;
3516     audio_codec_id = CODEC_ID_NONE;
3517     audio_stream_copy = 0;
3518 }
3519
3520 static void opt_new_subtitle_stream(void)
3521 {
3522     AVFormatContext *oc;
3523     AVStream *st;
3524     AVCodecContext *subtitle_enc;
3525
3526     if (nb_output_files <= 0) {
3527         fprintf(stderr, "At least one output file must be specified\n");
3528         exit(1);
3529     }
3530     oc = output_files[nb_output_files - 1];
3531
3532     st = av_new_stream(oc, oc->nb_streams);
3533     if (!st) {
3534         fprintf(stderr, "Could not alloc stream\n");
3535         exit(1);
3536     }
3537
3538     subtitle_enc = st->codec;
3539     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3540     if (subtitle_stream_copy) {
3541         st->stream_copy = 1;
3542     } else {
3543         subtitle_enc->codec_id = subtitle_codec_id;
3544     }
3545
3546     if (subtitle_language) {
3547         pstrcpy(st->language, sizeof(st->language), subtitle_language);
3548         av_free(subtitle_language);
3549         subtitle_language = NULL;
3550     }
3551
3552     subtitle_codec_id = CODEC_ID_NONE;
3553     subtitle_stream_copy = 0;
3554 }
3555
3556 static void opt_new_audio_stream(void)
3557 {
3558     AVFormatContext *oc;
3559     if (nb_output_files <= 0) {
3560         fprintf(stderr, "At least one output file must be specified\n");
3561         exit(1);
3562     }
3563     oc = output_files[nb_output_files - 1];
3564     new_audio_stream(oc);
3565 }
3566
3567 static void opt_new_video_stream(void)
3568 {
3569     AVFormatContext *oc;
3570     if (nb_output_files <= 0) {
3571         fprintf(stderr, "At least one output file must be specified\n");
3572         exit(1);
3573     }
3574     oc = output_files[nb_output_files - 1];
3575     new_video_stream(oc);
3576 }
3577
3578 static void opt_output_file(const char *filename)
3579 {
3580     AVFormatContext *oc;
3581     int use_video, use_audio, input_has_video, input_has_audio;
3582     AVFormatParameters params, *ap = &params;
3583
3584     if (!strcmp(filename, "-"))
3585         filename = "pipe:";
3586
3587     oc = av_alloc_format_context();
3588
3589     if (!file_oformat) {
3590         file_oformat = guess_format(NULL, filename, NULL);
3591         if (!file_oformat) {
3592             fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3593                     filename);
3594             exit(1);
3595         }
3596     }
3597
3598     oc->oformat = file_oformat;
3599     pstrcpy(oc->filename, sizeof(oc->filename), filename);
3600
3601     if (!strcmp(file_oformat->name, "ffm") &&
3602         strstart(filename, "http:", NULL)) {
3603         /* special case for files sent to ffserver: we get the stream
3604            parameters from ffserver */
3605         if (read_ffserver_streams(oc, filename) < 0) {
3606             fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3607             exit(1);
3608         }
3609     } else {
3610         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3611         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3612
3613         /* disable if no corresponding type found and at least one
3614            input file */
3615         if (nb_input_files > 0) {
3616             check_audio_video_inputs(&input_has_video, &input_has_audio);
3617             if (!input_has_video)
3618                 use_video = 0;
3619             if (!input_has_audio)
3620                 use_audio = 0;
3621         }
3622
3623         /* manual disable */
3624         if (audio_disable) {
3625             use_audio = 0;
3626         }
3627         if (video_disable) {
3628             use_video = 0;
3629         }
3630
3631         if (use_video) {
3632             new_video_stream(oc);
3633         }
3634
3635         if (use_audio) {
3636             new_audio_stream(oc);
3637         }
3638
3639         if (!oc->nb_streams) {
3640             fprintf(stderr, "No audio or video streams available\n");
3641             exit(1);
3642         }
3643
3644         oc->timestamp = rec_timestamp;
3645
3646         if (str_title)
3647             pstrcpy(oc->title, sizeof(oc->title), str_title);
3648         if (str_author)
3649             pstrcpy(oc->author, sizeof(oc->author), str_author);
3650         if (str_copyright)
3651             pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3652         if (str_comment)
3653             pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3654     }
3655
3656     output_files[nb_output_files++] = oc;
3657
3658     /* check filename in case of an image number is expected */
3659     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3660         if (filename_number_test(oc->filename) < 0) {
3661             print_error(oc->filename, AVERROR_NUMEXPECTED);
3662             exit(1);
3663         }
3664     }
3665
3666     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3667         /* test if it already exists to avoid loosing precious files */
3668         if (!file_overwrite &&
3669             (strchr(filename, ':') == NULL ||
3670              strstart(filename, "file:", NULL))) {
3671             if (url_exist(filename)) {
3672                 int c;
3673
3674                 if ( !using_stdin ) {
3675                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3676                     fflush(stderr);
3677                     c = getchar();
3678                     if (toupper(c) != 'Y') {
3679                         fprintf(stderr, "Not overwriting - exiting\n");
3680                         exit(1);
3681                     }
3682                                 }
3683                                 else {
3684                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3685                     exit(1);
3686                                 }
3687             }
3688         }
3689
3690         /* open the file */
3691         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3692             fprintf(stderr, "Could not open '%s'\n", filename);
3693             exit(1);
3694         }
3695     }
3696
3697     memset(ap, 0, sizeof(*ap));
3698     ap->image_format = image_format;
3699     if (av_set_parameters(oc, ap) < 0) {
3700         fprintf(stderr, "%s: Invalid encoding parameters\n",
3701                 oc->filename);
3702         exit(1);
3703     }
3704
3705     oc->packet_size= mux_packet_size;
3706     oc->mux_rate= mux_rate;
3707     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3708     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3709     oc->loop_output = loop_output;
3710
3711     /* reset some options */
3712     file_oformat = NULL;
3713     file_iformat = NULL;
3714     image_format = NULL;
3715 }
3716
3717 /* prepare dummy protocols for grab */
3718 static void prepare_grab(void)
3719 {
3720     int has_video, has_audio, i, j;
3721     AVFormatContext *oc;
3722     AVFormatContext *ic;
3723     AVFormatParameters vp1, *vp = &vp1;
3724     AVFormatParameters ap1, *ap = &ap1;
3725
3726     /* see if audio/video inputs are needed */
3727     has_video = 0;
3728     has_audio = 0;
3729     memset(ap, 0, sizeof(*ap));
3730     memset(vp, 0, sizeof(*vp));
3731     vp->time_base.num= 1;
3732     for(j=0;j<nb_output_files;j++) {
3733         oc = output_files[j];
3734         for(i=0;i<oc->nb_streams;i++) {
3735             AVCodecContext *enc = oc->streams[i]->codec;
3736             switch(enc->codec_type) {
3737             case CODEC_TYPE_AUDIO:
3738                 if (enc->sample_rate > ap->sample_rate)
3739                     ap->sample_rate = enc->sample_rate;
3740                 if (enc->channels > ap->channels)
3741                     ap->channels = enc->channels;
3742                 has_audio = 1;
3743                 break;
3744             case CODEC_TYPE_VIDEO:
3745                 if (enc->width > vp->width)
3746                     vp->width = enc->width;
3747                 if (enc->height > vp->height)
3748                     vp->height = enc->height;
3749
3750                 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3751                     vp->time_base = enc->time_base;
3752                 }
3753                 has_video = 1;
3754                 break;
3755             default:
3756                 av_abort();
3757             }
3758         }
3759     }
3760
3761     if (has_video == 0 && has_audio == 0) {
3762         fprintf(stderr, "Output file must have at least one audio or video stream\n");
3763         exit(1);
3764     }
3765
3766     if (has_video) {
3767         AVInputFormat *fmt1;
3768         fmt1 = av_find_input_format(video_grab_format);
3769         vp->device  = video_device;
3770         vp->channel = video_channel;
3771         vp->standard = video_standard;
3772         if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3773             fprintf(stderr, "Could not find video grab device\n");
3774             exit(1);
3775         }
3776         /* If not enough info to get the stream parameters, we decode the
3777            first frames to get it. */
3778         if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3779             fprintf(stderr, "Could not find video grab parameters\n");
3780             exit(1);
3781         }
3782         /* by now video grab has one stream */
3783         ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3784         ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3785         input_files[nb_input_files] = ic;
3786
3787         if (verbose >= 0)
3788             dump_format(ic, nb_input_files, "", 0);
3789
3790         nb_input_files++;
3791     }
3792     if (has_audio && audio_grab_format) {
3793         AVInputFormat *fmt1;
3794         fmt1 = av_find_input_format(audio_grab_format);
3795         ap->device = audio_device;
3796         if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3797             fprintf(stderr, "Could not find audio grab device\n");
3798             exit(1);
3799         }
3800         input_files[nb_input_files] = ic;
3801
3802         if (verbose >= 0)
3803             dump_format(ic, nb_input_files, "", 0);
3804
3805         nb_input_files++;
3806     }
3807 }
3808
3809 /* same option as mencoder */
3810 static void opt_pass(const char *pass_str)
3811 {
3812     int pass;
3813     pass = atoi(pass_str);
3814     if (pass != 1 && pass != 2) {
3815         fprintf(stderr, "pass number can be only 1 or 2\n");
3816         exit(1);
3817     }
3818     do_pass = pass;
3819 }
3820
3821 #if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3822 static int64_t getutime(void)
3823 {
3824   return av_gettime();
3825 }
3826 #else
3827 static int64_t getutime(void)
3828 {
3829     struct rusage rusage;
3830
3831     getrusage(RUSAGE_SELF, &rusage);
3832     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3833 }
3834 #endif
3835
3836 extern int ffm_nopts;
3837
3838 static void opt_bitexact(void)
3839 {
3840     bitexact=1;
3841     /* disable generate of real time pts in ffm (need to be supressed anyway) */
3842     ffm_nopts = 1;
3843 }
3844
3845 static void show_formats(void)
3846 {
3847     AVInputFormat *ifmt;
3848     AVOutputFormat *ofmt;
3849     AVImageFormat *image_fmt;
3850     URLProtocol *up;
3851     AVCodec *p, *p2;
3852     const char **pp, *last_name;
3853
3854     printf("File formats:\n");
3855     last_name= "000";
3856     for(;;){
3857         int decode=0;
3858         int encode=0;
3859         const char *name=NULL;
3860         const char *long_name=NULL;
3861
3862         for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3863             if((name == NULL || strcmp(ofmt->name, name)<0) &&
3864                 strcmp(ofmt->name, last_name)>0){
3865                 name= ofmt->name;
3866                 long_name= ofmt->long_name;
3867                 encode=1;
3868             }
3869         }
3870         for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3871             if((name == NULL || strcmp(ifmt->name, name)<0) &&
3872                 strcmp(ifmt->name, last_name)>0){
3873                 name= ifmt->name;
3874                 long_name= ifmt->long_name;
3875                 encode=0;
3876             }
3877             if(name && strcmp(ifmt->name, name)==0)
3878                 decode=1;
3879         }
3880         if(name==NULL)
3881             break;
3882         last_name= name;
3883
3884         printf(
3885             " %s%s %-15s %s\n",
3886             decode ? "D":" ",
3887             encode ? "E":" ",
3888             name,
3889             long_name ? long_name:" ");
3890     }
3891     printf("\n");
3892
3893     printf("Image formats (filename extensions, if any, follow):\n");
3894     for(image_fmt = first_image_format; image_fmt != NULL;
3895         image_fmt = image_fmt->next) {
3896         printf(
3897             " %s%s %-6s %s\n",
3898             image_fmt->img_read  ? "D":" ",
3899             image_fmt->img_write ? "E":" ",
3900             image_fmt->name,
3901             image_fmt->extensions ? image_fmt->extensions:" ");
3902     }
3903     printf("\n");
3904
3905     printf("Codecs:\n");
3906     last_name= "000";
3907     for(;;){
3908         int decode=0;
3909         int encode=0;
3910         int cap=0;
3911         const char *type_str;
3912
3913         p2=NULL;
3914         for(p = first_avcodec; p != NULL; p = p->next) {
3915             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3916                 strcmp(p->name, last_name)>0){
3917                 p2= p;
3918                 decode= encode= cap=0;
3919             }
3920             if(p2 && strcmp(p->name, p2->name)==0){
3921                 if(p->decode) decode=1;
3922                 if(p->encode) encode=1;
3923                 cap |= p->capabilities;
3924             }
3925         }
3926         if(p2==NULL)
3927             break;
3928         last_name= p2->name;
3929
3930         switch(p2->type) {
3931         case CODEC_TYPE_VIDEO:
3932             type_str = "V";
3933             break;
3934         case CODEC_TYPE_AUDIO:
3935             type_str = "A";
3936             break;
3937         case CODEC_TYPE_SUBTITLE:
3938             type_str = "S";
3939             break;
3940         default:
3941             type_str = "?";
3942             break;
3943         }
3944         printf(
3945             " %s%s%s%s%s%s %s",
3946             decode ? "D": (/*p2->decoder ? "d":*/" "),
3947             encode ? "E":" ",
3948             type_str,
3949             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3950             cap & CODEC_CAP_DR1 ? "D":" ",
3951             cap & CODEC_CAP_TRUNCATED ? "T":" ",
3952             p2->name);
3953        /* if(p2->decoder && decode==0)
3954             printf(" use %s for decoding", p2->decoder->name);*/
3955         printf("\n");
3956     }
3957     printf("\n");
3958
3959     printf("Supported file protocols:\n");
3960     for(up = first_protocol; up != NULL; up = up->next)
3961         printf(" %s:", up->name);
3962     printf("\n");
3963
3964     printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3965     printf("Motion estimation methods:\n");
3966     pp = motion_str;
3967     while (*pp) {
3968         printf(" %s", *pp);
3969         if ((pp - motion_str + 1) == ME_ZERO)
3970             printf("(fastest)");
3971         else if ((pp - motion_str + 1) == ME_FULL)
3972             printf("(slowest)");
3973         else if ((pp - motion_str + 1) == ME_EPZS)
3974             printf("(default)");
3975         pp++;
3976     }
3977     printf("\n\n");
3978     printf(
3979 "Note, the names of encoders and decoders dont always match, so there are\n"
3980 "several cases where the above table shows encoder only or decoder only entries\n"
3981 "even though both encoding and decoding are supported for example, the h263\n"
3982 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3983 "worse\n");
3984     exit(1);
3985 }
3986
3987 void parse_matrix_coeffs(uint16_t *dest, const char *str)
3988 {
3989     int i;
3990     const char *p = str;
3991     for(i = 0;; i++) {
3992         dest[i] = atoi(p);
3993         if(i == 63)
3994             break;
3995         p = strchr(p, ',');
3996         if(!p) {
3997             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3998             exit(1);
3999         }
4000         p++;
4001     }
4002 }
4003
4004 void opt_inter_matrix(const char *arg)
4005 {
4006     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
4007     parse_matrix_coeffs(inter_matrix, arg);
4008 }
4009
4010 void opt_intra_matrix(const char *arg)
4011 {
4012     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
4013     parse_matrix_coeffs(intra_matrix, arg);
4014 }
4015
4016 static void opt_target(const char *arg)
4017 {
4018     int norm = -1;
4019     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4020
4021     if(!strncmp(arg, "pal-", 4)) {
4022         norm = 0;
4023         arg += 4;
4024     } else if(!strncmp(arg, "ntsc-", 5)) {
4025         norm = 1;
4026         arg += 5;
4027     } else if(!strncmp(arg, "film-", 5)) {
4028         norm = 2;
4029         arg += 5;
4030     } else {
4031         int fr;
4032         /* Calculate FR via float to avoid int overflow */
4033         fr = (int)(frame_rate * 1000.0 / frame_rate_base);
4034         if(fr == 25000) {
4035             norm = 0;
4036         } else if((fr == 29970) || (fr == 23976)) {
4037             norm = 1;
4038         } else {
4039             /* Try to determine PAL/NTSC by peeking in the input files */
4040             if(nb_input_files) {
4041                 int i, j;
4042                 for(j = 0; j < nb_input_files; j++) {
4043                     for(i = 0; i < input_files[j]->nb_streams; i++) {
4044                         AVCodecContext *c = input_files[j]->streams[i]->codec;
4045                         if(c->codec_type != CODEC_TYPE_VIDEO)
4046                             continue;
4047                         fr = c->time_base.den * 1000 / c->time_base.num;
4048                         if(fr == 25000) {
4049                             norm = 0;
4050                             break;
4051                         } else if((fr == 29970) || (fr == 23976)) {
4052                             norm = 1;
4053                             break;
4054                         }
4055                     }
4056                     if(norm >= 0)
4057                         break;
4058                 }
4059             }
4060         }
4061         if(verbose && norm >= 0)
4062             fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
4063     }
4064
4065     if(norm < 0) {
4066         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4067         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4068         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4069         exit(1);
4070     }
4071
4072     if(!strcmp(arg, "vcd")) {
4073
4074         opt_video_codec("mpeg1video");
4075         opt_audio_codec("mp2");
4076         opt_format("vcd");
4077
4078         opt_frame_size(norm ? "352x240" : "352x288");
4079         opt_frame_rate(frame_rates[norm]);
4080         opt_gop_size(norm ? "18" : "15");
4081
4082         video_bit_rate = 1150000;
4083         video_rc_max_rate = 1150000;
4084         video_rc_min_rate = 1150000;
4085         video_rc_buffer_size = 40*1024*8;
4086
4087         audio_bit_rate = 224000;
4088         audio_sample_rate = 44100;
4089
4090         mux_packet_size= 2324;
4091         mux_rate= 2352 * 75 * 8;
4092
4093         /* We have to offset the PTS, so that it is consistent with the SCR.
4094            SCR starts at 36000, but the first two packs contain only padding
4095            and the first pack from the other stream, respectively, may also have
4096            been written before.
4097            So the real data starts at SCR 36000+3*1200. */
4098         mux_preload= (36000+3*1200) / 90000.0; //0.44
4099     } else if(!strcmp(arg, "svcd")) {
4100
4101         opt_video_codec("mpeg2video");
4102         opt_audio_codec("mp2");
4103         opt_format("svcd");
4104
4105         opt_frame_size(norm ? "480x480" : "480x576");
4106         opt_frame_rate(frame_rates[norm]);
4107         opt_gop_size(norm ? "18" : "15");
4108
4109         video_bit_rate = 2040000;
4110         video_rc_max_rate = 2516000;
4111         video_rc_min_rate = 0; //1145000;
4112         video_rc_buffer_size = 224*1024*8;
4113         use_scan_offset = 1;
4114
4115         audio_bit_rate = 224000;
4116         audio_sample_rate = 44100;
4117
4118         mux_packet_size= 2324;
4119
4120     } else if(!strcmp(arg, "dvd")) {
4121
4122         opt_video_codec("mpeg2video");
4123         opt_audio_codec("ac3");
4124         opt_format("dvd");
4125
4126         opt_frame_size(norm ? "720x480" : "720x576");
4127         opt_frame_rate(frame_rates[norm]);
4128         opt_gop_size(norm ? "18" : "15");
4129
4130         video_bit_rate = 6000000;
4131         video_rc_max_rate = 9000000;
4132         video_rc_min_rate = 0; //1500000;
4133         video_rc_buffer_size = 224*1024*8;
4134
4135         mux_packet_size= 2048;  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4136         mux_rate = 10080000;    // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4137
4138         audio_bit_rate = 448000;
4139         audio_sample_rate = 48000;
4140
4141     } else if(!strcmp(arg, "dv")) {
4142
4143         opt_format("dv");
4144
4145         opt_frame_size(norm ? "720x480" : "720x576");
4146         opt_frame_rate(frame_rates[norm]);
4147
4148         audio_sample_rate = 48000;
4149         audio_channels = 2;
4150
4151     } else {
4152         fprintf(stderr, "Unknown target: %s\n", arg);
4153         exit(1);
4154     }
4155 }
4156
4157 static void show_version(void)
4158 {
4159     fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
4160            "libavcodec  %d\n"
4161            "libavformat %d\n",
4162            avcodec_build(), LIBAVFORMAT_BUILD);
4163     exit(1);
4164 }
4165
4166 const OptionDef options[] = {
4167     /* main options */
4168     { "L", 0, {(void*)show_license}, "show license" },
4169     { "h", 0, {(void*)show_help}, "show help" },
4170     { "version", 0, {(void*)show_version}, "show version" },
4171     { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
4172     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4173     { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
4174     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4175     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4176     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4177     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
4178     { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
4179     { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
4180     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4181     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4182     { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
4183     { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
4184     { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
4185     { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
4186     { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
4187     { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
4188     { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
4189     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4190       "add timings for benchmarking" },
4191     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4192       "dump each input packet" },
4193     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4194       "when dumping packets, also dump the payload" },
4195     { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" },
4196     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4197     { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4198     { "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)", "" },
4199     { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
4200     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4201     { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4202     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4203     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4204     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4205     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4206     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4207
4208     /* video options */
4209     { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
4210     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4211     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4212     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
4213     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4214     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4215     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4216     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
4217     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
4218     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
4219     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
4220     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
4221     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
4222     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
4223     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
4224     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
4225     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
4226     { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
4227     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4228     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4229     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4230     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
4231     { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
4232     { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
4233     { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
4234     { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
4235     { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
4236     { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "max macroblock quantiser scale (VBR)", "q" },
4237     { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
4238     { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
4239     { "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" },
4240     { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
4241     { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
4242     { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
4243     { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
4244     { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
4245     { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
4246     { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
4247     { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
4248     { "b_strategy", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&b_strategy}, "dynamic b frame selection strategy", "strategy" },
4249     { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
4250     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4251     { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
4252     { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
4253     { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
4254     { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
4255     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4256     { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
4257       "method" },
4258     { "dct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dct_algo}, "set dct algo",  "algo" },
4259     { "idct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_idct_algo}, "set idct algo",  "algo" },
4260     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
4261     { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold",  "" },
4262     { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience",  "n" },
4263     { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment",  "bit_mask" },
4264     { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
4265     { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
4266     { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
4267     { "mbcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_cmp}, "macroblock compare function", "cmp function" },
4268     { "ildctcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ildct_cmp}, "ildct compare function", "cmp function" },
4269     { "subcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sub_cmp}, "subpel compare function", "cmp function" },
4270     { "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
4271     { "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
4272     { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
4273     { "lelim", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lelim}, "single coefficient elimination threshold for luminance (negative values also consider DC coefficient)", "elim" },
4274     { "celim", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_celim}, "single coefficient elimination threshold for chrominance (negative values also consider DC coefficient)", "elim" },
4275     { "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
4276     { "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
4277     { "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
4278     { "tcplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_tcplx_mask}, "temporal complexity masking", "" },
4279     { "p_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_p_mask}, "inter masking", "" },
4280     { "4mv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_4mv}, "use four motion vector by macroblock (MPEG4)" },
4281     { "obmc", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_obmc}, "use overlapped block motion compensation (h263+)" },
4282     { "lf", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_loop}, "use loop filter (h263+)" },
4283     { "part", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_part}, "use data partitioning (MPEG4)" },
4284     { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
4285     { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
4286     { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
4287     { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
4288     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4289       "use same video quality as source (implies VBR)" },
4290     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4291     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
4292     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4293       "deinterlace pictures" },
4294     { "ildct", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_dct},
4295       "force interlaced dct support in encoder (MPEG2/MPEG4)" },
4296     { "ilme", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_me},
4297       "force interlaced me support in encoder (MPEG2/MPEG4)" },
4298     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4299     { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
4300     { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
4301     { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
4302     { "aiv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aiv}, "enable Alternative inter vlc (h263+)" },
4303     { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
4304     { "ssm", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_ss}, "enable Slice Structured mode (h263+)" },
4305     { "alt", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_alt_scan}, "enable alternate scantable (MPEG2/MPEG4)" },
4306     { "qprd", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qprd}, "" },
4307     { "cbp", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_cbprd}, "" },
4308     { "trell", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_trell}, "enable trellis quantization" },
4309     { "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)" },
4310     { "naq", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_normalize_aqp}, "normalize adaptive quantization" },
4311     { "cgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&closed_gop}, "closed gop" },
4312     { "sgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&strict_gop}, "strict gop" },
4313     { "noout", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&no_output}, "skip bitstream encoding" },
4314     { "scan_offset", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_scan_offset}, "enable SVCD Scan Offset placeholder" },
4315     { "qpel", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qpel}, "enable 1/4-pel" },
4316     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4317     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4318     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4319     { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },
4320     { "qns", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qns}, "quantization noise shaping", "" },
4321     { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
4322     { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
4323     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4324     { "coder", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&coder}, "coder type", "" },
4325     { "context", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&context}, "context model", "" },
4326     { "pred", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&predictor}, "prediction method", "" },
4327     { "vprofile", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_profile}, "profile", "" },
4328     { "vlevel", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_level}, "level", "" },
4329     { "nssew", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&nsse_weight}, "weight", "" },
4330     { "subq", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&subpel_quality}, "", "" },
4331     { "mepc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&me_penalty_compensation}, "motion estimation bitrate penalty compensation", "factor (1.0 = 256)" },
4332     { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&lowres}, "", "" },
4333     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4334     { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
4335     { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
4336     { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
4337     { "skip_cmp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_cmp}, "frame skip compare function", "compare function" },
4338     { "gray", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&gray_only }, "encode/decode grayscale" },
4339     { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
4340
4341     /* audio options */
4342     { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
4343     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4344     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4345     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4346     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4347     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4348     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4349     { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
4350     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4351
4352     /* subtitle options */
4353     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4354     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
4355     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4356
4357     /* grab options */
4358     { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
4359     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4360     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4361     { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
4362
4363     /* G.2 grab options */
4364     { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
4365     { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
4366
4367     /* muxer options */
4368     { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
4369     { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
4370     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4371     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4372     { NULL, },
4373 };
4374
4375 static void show_banner(void)
4376 {
4377     fprintf(stderr, "ffmpeg version " FFMPEG_VERSION ", build %d, Copyright (c) 2000-2004 Fabrice Bellard\n",
4378         LIBAVCODEC_BUILD);
4379     fprintf(stderr, "  configuration: %s\n", FFMPEG_CONFIGURATION);
4380     fprintf(stderr, "  built on " __DATE__ " " __TIME__);
4381 #ifdef __GNUC__
4382     fprintf(stderr, ", gcc: %s\n", __VERSION__);
4383 #else
4384     fprintf(stderr, ", using a non-gcc compiler\n");
4385 #endif
4386 }
4387
4388 static void show_license(void)
4389 {
4390     show_banner();
4391 #ifdef CONFIG_GPL
4392     printf(
4393     "This program is free software; you can redistribute it and/or modify\n"
4394     "it under the terms of the GNU General Public License as published by\n"
4395     "the Free Software Foundation; either version 2 of the License, or\n"
4396     "(at your option) any later version.\n"
4397     "\n"
4398     "This program is distributed in the hope that it will be useful,\n"
4399     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4400     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
4401     "GNU General Public License for more details.\n"
4402     "\n"
4403     "You should have received a copy of the GNU General Public License\n"
4404     "along with this program; if not, write to the Free Software\n"
4405     "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
4406     );
4407 #else
4408     printf(
4409     "This library is free software; you can redistribute it and/or\n"
4410     "modify it under the terms of the GNU Lesser General Public\n"
4411     "License as published by the Free Software Foundation; either\n"
4412     "version 2 of the License, or (at your option) any later version.\n"
4413     "\n"
4414     "This library is distributed in the hope that it will be useful,\n"
4415     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4416     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
4417     "Lesser General Public License for more details.\n"
4418     "\n"
4419     "You should have received a copy of the GNU Lesser General Public\n"
4420     "License along with this library; if not, write to the Free Software\n"
4421     "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
4422     );
4423 #endif
4424     exit(1);
4425 }
4426
4427 static void show_help(void)
4428 {
4429     show_banner();
4430     printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4431            "Hyper fast Audio and Video encoder\n");
4432     printf("\n");
4433     show_help_options(options, "Main options:\n",
4434                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4435     show_help_options(options, "\nVideo options:\n",
4436                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4437                       OPT_VIDEO);
4438     show_help_options(options, "\nAdvanced Video options:\n",
4439                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4440                       OPT_VIDEO | OPT_EXPERT);
4441     show_help_options(options, "\nAudio options:\n",
4442                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4443                       OPT_AUDIO);
4444     show_help_options(options, "\nAdvanced Audio options:\n",
4445                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4446                       OPT_AUDIO | OPT_EXPERT);
4447     show_help_options(options, "\nSubtitle options:\n",
4448                       OPT_SUBTITLE | OPT_GRAB,
4449                       OPT_SUBTITLE);
4450     show_help_options(options, "\nAudio/Video grab options:\n",
4451                       OPT_GRAB,
4452                       OPT_GRAB);
4453     show_help_options(options, "\nAdvanced options:\n",
4454                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4455                       OPT_EXPERT);
4456     exit(1);
4457 }
4458
4459 void parse_arg_file(const char *filename)
4460 {
4461     opt_output_file(filename);
4462 }
4463
4464 int main(int argc, char **argv)
4465 {
4466     int i;
4467     int64_t ti;
4468
4469     av_register_all();
4470
4471     if (argc <= 1)
4472         show_help();
4473     else
4474         show_banner();
4475
4476     /* parse options */
4477     parse_options(argc, argv, options);
4478
4479     /* file converter / grab */
4480     if (nb_output_files <= 0) {
4481         fprintf(stderr, "Must supply at least one output file\n");
4482         exit(1);
4483     }
4484
4485     if (nb_input_files == 0) {
4486         input_sync = 1;
4487         prepare_grab();
4488     }
4489
4490     ti = getutime();
4491     av_encode(output_files, nb_output_files, input_files, nb_input_files,
4492               stream_maps, nb_stream_maps);
4493     ti = getutime() - ti;
4494     if (do_benchmark) {
4495         printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4496     }
4497
4498     /* close files */
4499     for(i=0;i<nb_output_files;i++) {
4500         /* maybe av_close_output_file ??? */
4501         AVFormatContext *s = output_files[i];
4502         int j;
4503         if (!(s->oformat->flags & AVFMT_NOFILE))
4504             url_fclose(&s->pb);
4505         for(j=0;j<s->nb_streams;j++)
4506             av_free(s->streams[j]);
4507         av_free(s);
4508     }
4509     for(i=0;i<nb_input_files;i++)
4510         av_close_input_file(input_files[i]);
4511
4512     av_free_static();
4513
4514     if(intra_matrix)
4515         av_free(intra_matrix);
4516     if(inter_matrix)
4517         av_free(inter_matrix);
4518
4519 #ifdef POWERPC_PERFORMANCE_REPORT
4520     extern void powerpc_display_perf_report(void);
4521     powerpc_display_perf_report();
4522 #endif /* POWERPC_PERFORMANCE_REPORT */
4523
4524 #ifndef CONFIG_WIN32
4525     if (received_sigterm) {
4526         fprintf(stderr,
4527             "Received signal %d: terminating.\n",
4528             (int) received_sigterm);
4529         exit (255);
4530     }
4531 #endif
4532     exit(0); /* not all OS-es handle main() return value */
4533     return 0;
4534 }