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

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