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