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