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