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

   1 /*
   2  * FFmpeg main
   3  * Copyright (c) 2000-2003 Fabrice Bellard
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  18  */
  19 #define HAVE_AV_CONFIG_H
  20 #include <limits.h>
  21 #include "avformat.h"
  22 #include "framehook.h"
  23 #include "dsputil.h"
  24 #include "opt.h"
  25
  26 #ifndef CONFIG_WIN32
  27 #include <unistd.h>
  28 #include <fcntl.h>
  29 #include <sys/ioctl.h>
  30 #include <sys/time.h>
  31 #include <termios.h>
  32 #include <sys/resource.h>
  33 #include <signal.h>
  34 #endif
  35 #ifdef CONFIG_OS2
  36 #include <sys/types.h>
  37 #include <sys/select.h>
  38 #include <stdlib.h>
  39 #endif
  40 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
  41 #include <time.h>
  42
  43 #include "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 extern int loop_input; /* currently a hack */
 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 CONFIG_WIN32
 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 CONFIG_WIN32
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     if(genpts)
2847         ic->flags|= AVFMT_FLAG_GENPTS;
2848
2849     /* If not enough info to get the stream parameters, we decode the
2850        first frames to get it. (used in mpeg case for example) */
2851     ret = av_find_stream_info(ic);
2852     if (ret < 0 && verbose >= 0) {
2853         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2854         exit(1);
2855     }
2856
2857     timestamp = start_time;
2858     /* add the stream start time */
2859     if (ic->start_time != AV_NOPTS_VALUE)
2860         timestamp += ic->start_time;
2861
2862     /* if seeking requested, we execute it */
2863     if (start_time != 0) {
2864         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2865         if (ret < 0) {
2866             fprintf(stderr, "%s: could not seek to position %0.3f\n",
2867                     filename, (double)timestamp / AV_TIME_BASE);
2868         }
2869         /* reset seek info */
2870         start_time = 0;
2871     }
2872
2873     /* update the current parameters so that they match the one of the input stream */
2874     for(i=0;i<ic->nb_streams;i++) {
2875         int j;
2876         AVCodecContext *enc = ic->streams[i]->codec;
2877 #if defined(HAVE_THREADS)
2878         if(thread_count>1)
2879             avcodec_thread_init(enc, thread_count);
2880 #endif
2881         enc->thread_count= thread_count;
2882         switch(enc->codec_type) {
2883         case CODEC_TYPE_AUDIO:
2884             for(j=0; j<opt_name_count; j++){
2885                 AVOption *opt;
2886                 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2887                 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2888                     av_set_double(enc, opt_names[j], d);
2889             }
2890             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2891             audio_channels = enc->channels;
2892             audio_sample_rate = enc->sample_rate;
2893             if(audio_disable)
2894                 ic->streams[i]->discard= AVDISCARD_ALL;
2895             break;
2896         case CODEC_TYPE_VIDEO:
2897             for(j=0; j<opt_name_count; j++){
2898                 AVOption *opt;
2899                 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2900                 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2901                     av_set_double(enc, opt_names[j], d);
2902             }
2903             frame_height = enc->height;
2904             frame_width = enc->width;
2905             frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2906             frame_pix_fmt = enc->pix_fmt;
2907             rfps      = ic->streams[i]->r_frame_rate.num;
2908             rfps_base = ic->streams[i]->r_frame_rate.den;
2909             enc->workaround_bugs = workaround_bugs;
2910             if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2911             if(me_threshold)
2912                 enc->debug |= FF_DEBUG_MV;
2913
2914             if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2915
2916                 if (verbose >= 0)
2917                     fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2918                             i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2919
2920                     (float)rfps / rfps_base, rfps, rfps_base);
2921             }
2922             /* update the current frame rate to match the stream frame rate */
2923             frame_rate      = rfps;
2924             frame_rate_base = rfps_base;
2925
2926             enc->rate_emu = rate_emu;
2927             if(video_disable)
2928                 ic->streams[i]->discard= AVDISCARD_ALL;
2929             else if(video_discard)
2930                 ic->streams[i]->discard= video_discard;
2931             break;
2932         case CODEC_TYPE_DATA:
2933             break;
2934         case CODEC_TYPE_SUBTITLE:
2935             break;
2936         case CODEC_TYPE_UNKNOWN:
2937             break;
2938         default:
2939             av_abort();
2940         }
2941     }
2942
2943     input_files[nb_input_files] = ic;
2944     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2945     /* dump the file content */
2946     if (verbose >= 0)
2947         dump_format(ic, nb_input_files, filename, 0);
2948
2949     nb_input_files++;
2950     file_iformat = NULL;
2951     file_oformat = NULL;
2952     image_format = NULL;
2953
2954     grab_device = NULL;
2955     video_channel = 0;
2956
2957     rate_emu = 0;
2958 }
2959
2960 static void opt_grab(const char *arg)
2961 {
2962     file_iformat = av_find_input_format(arg);
2963     opt_input_file("");
2964 }
2965
2966 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2967 {
2968     int has_video, has_audio, i, j;
2969     AVFormatContext *ic;
2970
2971     has_video = 0;
2972     has_audio = 0;
2973     for(j=0;j<nb_input_files;j++) {
2974         ic = input_files[j];
2975         for(i=0;i<ic->nb_streams;i++) {
2976             AVCodecContext *enc = ic->streams[i]->codec;
2977             switch(enc->codec_type) {
2978             case CODEC_TYPE_AUDIO:
2979                 has_audio = 1;
2980                 break;
2981             case CODEC_TYPE_VIDEO:
2982                 has_video = 1;
2983                 break;
2984             case CODEC_TYPE_DATA:
2985             case CODEC_TYPE_UNKNOWN:
2986             case CODEC_TYPE_SUBTITLE:
2987                 break;
2988             default:
2989                 av_abort();
2990             }
2991         }
2992     }
2993     *has_video_ptr = has_video;
2994     *has_audio_ptr = has_audio;
2995 }
2996
2997 static void new_video_stream(AVFormatContext *oc)
2998 {
2999     AVStream *st;
3000     AVCodecContext *video_enc;
3001     int codec_id;
3002
3003     st = av_new_stream(oc, oc->nb_streams);
3004     if (!st) {
3005         fprintf(stderr, "Could not alloc stream\n");
3006         exit(1);
3007     }
3008     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3009     video_bitstream_filters= NULL;
3010
3011 #if defined(HAVE_THREADS)
3012     if(thread_count>1)
3013         avcodec_thread_init(st->codec, thread_count);
3014 #endif
3015
3016     video_enc = st->codec;
3017
3018     if(video_codec_tag)
3019         video_enc->codec_tag= video_codec_tag;
3020
3021     if(   (video_global_header&1)
3022        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3023         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3024         avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3025     }
3026     if(video_global_header&2){
3027         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3028         avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3029     }
3030
3031     if (video_stream_copy) {
3032         st->stream_copy = 1;
3033         video_enc->codec_type = CODEC_TYPE_VIDEO;
3034     } else {
3035         char *p;
3036         int i;
3037         AVCodec *codec;
3038
3039         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3040         if (video_codec_id != CODEC_ID_NONE)
3041             codec_id = video_codec_id;
3042
3043         video_enc->codec_id = codec_id;
3044         codec = avcodec_find_encoder(codec_id);
3045
3046         for(i=0; i<opt_name_count; i++){
3047              AVOption *opt;
3048              double d= av_get_double(avctx_opts, opt_names[i], &opt);
3049              if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3050                  av_set_double(video_enc, opt_names[i], d);
3051         }
3052
3053         video_enc->bit_rate = video_bit_rate;
3054         video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
3055         video_enc->time_base.den = frame_rate;
3056         video_enc->time_base.num = frame_rate_base;
3057         if(codec && codec->supported_framerates){
3058             const AVRational *p= codec->supported_framerates;
3059             AVRational req= (AVRational){frame_rate, frame_rate_base};
3060             const AVRational *best=NULL;
3061             AVRational best_error= (AVRational){INT_MAX, 1};
3062             for(; p->den!=0; p++){
3063                 AVRational error= av_sub_q(req, *p);
3064                 if(error.num <0) error.num *= -1;
3065                 if(av_cmp_q(error, best_error) < 0){
3066                     best_error= error;
3067                     best= p;
3068                 }
3069             }
3070             video_enc->time_base.den= best->num;
3071             video_enc->time_base.num= best->den;
3072         }
3073
3074         video_enc->width = frame_width + frame_padright + frame_padleft;
3075         video_enc->height = frame_height + frame_padtop + frame_padbottom;
3076         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3077         video_enc->pix_fmt = frame_pix_fmt;
3078
3079         if(codec && codec->pix_fmts){
3080             const enum PixelFormat *p= codec->pix_fmts;
3081             for(; *p!=-1; p++){
3082                 if(*p == video_enc->pix_fmt)
3083                     break;
3084             }
3085             if(*p == -1)
3086                 video_enc->pix_fmt = codec->pix_fmts[0];
3087         }
3088
3089         if (!intra_only)
3090             video_enc->gop_size = gop_size;
3091         else
3092             video_enc->gop_size = 0;
3093         if (video_qscale || same_quality) {
3094             video_enc->flags |= CODEC_FLAG_QSCALE;
3095             video_enc->global_quality=
3096                 st->quality = FF_QP2LAMBDA * video_qscale;
3097         }
3098
3099         if(intra_matrix)
3100             video_enc->intra_matrix = intra_matrix;
3101         if(inter_matrix)
3102             video_enc->inter_matrix = inter_matrix;
3103
3104         video_enc->pre_me = pre_me;
3105
3106         if (b_frames) {
3107             video_enc->max_b_frames = b_frames;
3108             video_enc->b_quant_factor = 2.0;
3109         }
3110         video_enc->qmin = video_qmin;
3111         video_enc->qmax = video_qmax;
3112         video_enc->lmin = video_lmin;
3113         video_enc->lmax = video_lmax;
3114         video_enc->rc_qsquish = video_qsquish;
3115         video_enc->mb_lmin = video_mb_lmin;
3116         video_enc->mb_lmax = video_mb_lmax;
3117         video_enc->max_qdiff = video_qdiff;
3118         video_enc->qblur = video_qblur;
3119         video_enc->qcompress = video_qcomp;
3120         video_enc->rc_eq = video_rc_eq;
3121         video_enc->workaround_bugs = workaround_bugs;
3122         video_enc->thread_count = thread_count;
3123         p= video_rc_override_string;
3124         for(i=0; p; i++){
3125             int start, end, q;
3126             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3127             if(e!=3){
3128                 fprintf(stderr, "error parsing rc_override\n");
3129                 exit(1);
3130             }
3131             video_enc->rc_override=
3132                 av_realloc(video_enc->rc_override,
3133                            sizeof(RcOverride)*(i+1));
3134             video_enc->rc_override[i].start_frame= start;
3135             video_enc->rc_override[i].end_frame  = end;
3136             if(q>0){
3137                 video_enc->rc_override[i].qscale= q;
3138                 video_enc->rc_override[i].quality_factor= 1.0;
3139             }
3140             else{
3141                 video_enc->rc_override[i].qscale= 0;
3142                 video_enc->rc_override[i].quality_factor= -q/100.0;
3143             }
3144             p= strchr(p, '/');
3145             if(p) p++;
3146         }
3147         video_enc->rc_override_count=i;
3148
3149         video_enc->rc_max_rate = video_rc_max_rate;
3150         video_enc->rc_min_rate = video_rc_min_rate;
3151         video_enc->rc_buffer_size = video_rc_buffer_size;
3152         video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3153         video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3154         video_enc->rc_initial_cplx= video_rc_initial_cplx;
3155         video_enc->i_quant_factor = video_i_qfactor;
3156         video_enc->b_quant_factor = video_b_qfactor;
3157         video_enc->i_quant_offset = video_i_qoffset;
3158         video_enc->b_quant_offset = video_b_qoffset;
3159         video_enc->intra_quant_bias = video_intra_quant_bias;
3160         video_enc->inter_quant_bias = video_inter_quant_bias;
3161         video_enc->me_threshold= me_threshold;
3162         video_enc->mb_threshold= mb_threshold;
3163         video_enc->intra_dc_precision= intra_dc_precision - 8;
3164         video_enc->strict_std_compliance = strict;
3165         video_enc->error_rate = error_rate;
3166         video_enc->scenechange_threshold= sc_threshold;
3167         video_enc->me_range = me_range;
3168         video_enc->me_penalty_compensation= me_penalty_compensation;
3169         video_enc->frame_skip_threshold= frame_skip_threshold;
3170         video_enc->frame_skip_factor= frame_skip_factor;
3171         video_enc->frame_skip_exp= frame_skip_exp;
3172
3173         if(packet_size){
3174             video_enc->rtp_mode= 1;
3175             video_enc->rtp_payload_size= packet_size;
3176         }
3177
3178         if (do_psnr)
3179             video_enc->flags|= CODEC_FLAG_PSNR;
3180
3181         video_enc->me_method = me_method;
3182
3183         /* two pass mode */
3184         if (do_pass) {
3185             if (do_pass == 1) {
3186                 video_enc->flags |= CODEC_FLAG_PASS1;
3187             } else {
3188                 video_enc->flags |= CODEC_FLAG_PASS2;
3189             }
3190         }
3191     }
3192
3193     /* reset some key parameters */
3194     video_disable = 0;
3195     video_codec_id = CODEC_ID_NONE;
3196     video_stream_copy = 0;
3197 }
3198
3199 static void new_audio_stream(AVFormatContext *oc)
3200 {
3201     AVStream *st;
3202     AVCodecContext *audio_enc;
3203     int codec_id, i;
3204
3205     st = av_new_stream(oc, oc->nb_streams);
3206     if (!st) {
3207         fprintf(stderr, "Could not alloc stream\n");
3208         exit(1);
3209     }
3210
3211     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3212     audio_bitstream_filters= NULL;
3213
3214 #if defined(HAVE_THREADS)
3215     if(thread_count>1)
3216         avcodec_thread_init(st->codec, thread_count);
3217 #endif
3218
3219     audio_enc = st->codec;
3220     audio_enc->codec_type = CODEC_TYPE_AUDIO;
3221
3222     if(audio_codec_tag)
3223         audio_enc->codec_tag= audio_codec_tag;
3224
3225     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3226         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3227         avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3228     }
3229     if (audio_stream_copy) {
3230         st->stream_copy = 1;
3231         audio_enc->channels = audio_channels;
3232     } else {
3233         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3234
3235         for(i=0; i<opt_name_count; i++){
3236             AVOption *opt;
3237             double d= av_get_double(avctx_opts, opt_names[i], &opt);
3238             if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3239                 av_set_double(audio_enc, opt_names[i], d);
3240         }
3241
3242         if (audio_codec_id != CODEC_ID_NONE)
3243             codec_id = audio_codec_id;
3244         audio_enc->codec_id = codec_id;
3245
3246         audio_enc->bit_rate = audio_bit_rate;
3247         if (audio_qscale > QSCALE_NONE) {
3248             audio_enc->flags |= CODEC_FLAG_QSCALE;
3249             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3250         }
3251         audio_enc->strict_std_compliance = strict;
3252         audio_enc->thread_count = thread_count;
3253         /* For audio codecs other than AC3 or DTS we limit */
3254         /* the number of coded channels to stereo   */
3255         if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3256             && codec_id != CODEC_ID_DTS) {
3257             audio_enc->channels = 2;
3258         } else
3259             audio_enc->channels = audio_channels;
3260     }
3261     audio_enc->sample_rate = audio_sample_rate;
3262     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3263     if (audio_language) {
3264         pstrcpy(st->language, sizeof(st->language), audio_language);
3265         av_free(audio_language);
3266         audio_language = NULL;
3267     }
3268
3269     /* reset some key parameters */
3270     audio_disable = 0;
3271     audio_codec_id = CODEC_ID_NONE;
3272     audio_stream_copy = 0;
3273 }
3274
3275 static void opt_new_subtitle_stream(void)
3276 {
3277     AVFormatContext *oc;
3278     AVStream *st;
3279     AVCodecContext *subtitle_enc;
3280     int i;
3281
3282     if (nb_output_files <= 0) {
3283         fprintf(stderr, "At least one output file must be specified\n");
3284         exit(1);
3285     }
3286     oc = output_files[nb_output_files - 1];
3287
3288     st = av_new_stream(oc, oc->nb_streams);
3289     if (!st) {
3290         fprintf(stderr, "Could not alloc stream\n");
3291         exit(1);
3292     }
3293
3294     subtitle_enc = st->codec;
3295     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3296     if (subtitle_stream_copy) {
3297         st->stream_copy = 1;
3298     } else {
3299         for(i=0; i<opt_name_count; i++){
3300              AVOption *opt;
3301              double d= av_get_double(avctx_opts, opt_names[i], &opt);
3302              if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3303                  av_set_double(subtitle_enc, opt_names[i], d);
3304         }
3305         subtitle_enc->codec_id = subtitle_codec_id;
3306     }
3307
3308     if (subtitle_language) {
3309         pstrcpy(st->language, sizeof(st->language), subtitle_language);
3310         av_free(subtitle_language);
3311         subtitle_language = NULL;
3312     }
3313
3314     subtitle_codec_id = CODEC_ID_NONE;
3315     subtitle_stream_copy = 0;
3316 }
3317
3318 static void opt_new_audio_stream(void)
3319 {
3320     AVFormatContext *oc;
3321     if (nb_output_files <= 0) {
3322         fprintf(stderr, "At least one output file must be specified\n");
3323         exit(1);
3324     }
3325     oc = output_files[nb_output_files - 1];
3326     new_audio_stream(oc);
3327 }
3328
3329 static void opt_new_video_stream(void)
3330 {
3331     AVFormatContext *oc;
3332     if (nb_output_files <= 0) {
3333         fprintf(stderr, "At least one output file must be specified\n");
3334         exit(1);
3335     }
3336     oc = output_files[nb_output_files - 1];
3337     new_video_stream(oc);
3338 }
3339
3340 static void opt_output_file(const char *filename)
3341 {
3342     AVFormatContext *oc;
3343     int use_video, use_audio, input_has_video, input_has_audio;
3344     AVFormatParameters params, *ap = &params;
3345
3346     if (!strcmp(filename, "-"))
3347         filename = "pipe:";
3348
3349     oc = av_alloc_format_context();
3350
3351     if (!file_oformat) {
3352         file_oformat = guess_format(NULL, filename, NULL);
3353         if (!file_oformat) {
3354             fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3355                     filename);
3356             exit(1);
3357         }
3358     }
3359
3360     oc->oformat = file_oformat;
3361     pstrcpy(oc->filename, sizeof(oc->filename), filename);
3362
3363     if (!strcmp(file_oformat->name, "ffm") &&
3364         strstart(filename, "http:", NULL)) {
3365         /* special case for files sent to ffserver: we get the stream
3366            parameters from ffserver */
3367         if (read_ffserver_streams(oc, filename) < 0) {
3368             fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3369             exit(1);
3370         }
3371     } else {
3372         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3373         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3374
3375         /* disable if no corresponding type found and at least one
3376            input file */
3377         if (nb_input_files > 0) {
3378             check_audio_video_inputs(&input_has_video, &input_has_audio);
3379             if (!input_has_video)
3380                 use_video = 0;
3381             if (!input_has_audio)
3382                 use_audio = 0;
3383         }
3384
3385         /* manual disable */
3386         if (audio_disable) {
3387             use_audio = 0;
3388         }
3389         if (video_disable) {
3390             use_video = 0;
3391         }
3392
3393         if (use_video) {
3394             new_video_stream(oc);
3395         }
3396
3397         if (use_audio) {
3398             new_audio_stream(oc);
3399         }
3400
3401         if (!oc->nb_streams) {
3402             fprintf(stderr, "No audio or video streams available\n");
3403             exit(1);
3404         }
3405
3406         oc->timestamp = rec_timestamp;
3407
3408         if (str_title)
3409             pstrcpy(oc->title, sizeof(oc->title), str_title);
3410         if (str_author)
3411             pstrcpy(oc->author, sizeof(oc->author), str_author);
3412         if (str_copyright)
3413             pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3414         if (str_comment)
3415             pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3416     }
3417
3418     output_files[nb_output_files++] = oc;
3419
3420     /* check filename in case of an image number is expected */
3421     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3422         if (filename_number_test(oc->filename) < 0) {
3423             print_error(oc->filename, AVERROR_NUMEXPECTED);
3424             exit(1);
3425         }
3426     }
3427
3428     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3429         /* test if it already exists to avoid loosing precious files */
3430         if (!file_overwrite &&
3431             (strchr(filename, ':') == NULL ||
3432              strstart(filename, "file:", NULL))) {
3433             if (url_exist(filename)) {
3434                 int c;
3435
3436                 if ( !using_stdin ) {
3437                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3438                     fflush(stderr);
3439                     c = getchar();
3440                     if (toupper(c) != 'Y') {
3441                         fprintf(stderr, "Not overwriting - exiting\n");
3442                         exit(1);
3443                     }
3444                                 }
3445                                 else {
3446                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3447                     exit(1);
3448                                 }
3449             }
3450         }
3451
3452         /* open the file */
3453         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3454             fprintf(stderr, "Could not open '%s'\n", filename);
3455             exit(1);
3456         }
3457     }
3458
3459     memset(ap, 0, sizeof(*ap));
3460     ap->image_format = image_format;
3461     if (av_set_parameters(oc, ap) < 0) {
3462         fprintf(stderr, "%s: Invalid encoding parameters\n",
3463                 oc->filename);
3464         exit(1);
3465     }
3466
3467     oc->packet_size= mux_packet_size;
3468     oc->mux_rate= mux_rate;
3469     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3470     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3471     oc->loop_output = loop_output;
3472
3473     /* reset some options */
3474     file_oformat = NULL;
3475     file_iformat = NULL;
3476     image_format = NULL;
3477 }
3478
3479 /* prepare dummy protocols for grab */
3480 static void prepare_grab(void)
3481 {
3482     int has_video, has_audio, i, j;
3483     AVFormatContext *oc;
3484     AVFormatContext *ic;
3485     AVFormatParameters vp1, *vp = &vp1;
3486     AVFormatParameters ap1, *ap = &ap1;
3487
3488     /* see if audio/video inputs are needed */
3489     has_video = 0;
3490     has_audio = 0;
3491     memset(ap, 0, sizeof(*ap));
3492     memset(vp, 0, sizeof(*vp));
3493     vp->time_base.num= 1;
3494     for(j=0;j<nb_output_files;j++) {
3495         oc = output_files[j];
3496         for(i=0;i<oc->nb_streams;i++) {
3497             AVCodecContext *enc = oc->streams[i]->codec;
3498             switch(enc->codec_type) {
3499             case CODEC_TYPE_AUDIO:
3500                 if (enc->sample_rate > ap->sample_rate)
3501                     ap->sample_rate = enc->sample_rate;
3502                 if (enc->channels > ap->channels)
3503                     ap->channels = enc->channels;
3504                 has_audio = 1;
3505                 break;
3506             case CODEC_TYPE_VIDEO:
3507                 if (enc->width > vp->width)
3508                     vp->width = enc->width;
3509                 if (enc->height > vp->height)
3510                     vp->height = enc->height;
3511
3512                 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3513                     vp->time_base = enc->time_base;
3514                     vp->width += frame_leftBand + frame_rightBand;
3515                     vp->width -= (frame_padleft + frame_padright);
3516                     vp->height += frame_topBand + frame_bottomBand;
3517                     vp->height -= (frame_padtop + frame_padbottom);
3518                 }
3519                 has_video = 1;
3520                 break;
3521             default:
3522                 av_abort();
3523             }
3524         }
3525     }
3526
3527     if (has_video == 0 && has_audio == 0) {
3528         fprintf(stderr, "Output file must have at least one audio or video stream\n");
3529         exit(1);
3530     }
3531
3532     if (has_video) {
3533         AVInputFormat *fmt1;
3534         fmt1 = av_find_input_format(video_grab_format);
3535         vp->device  = video_device;
3536         vp->channel = video_channel;
3537         vp->standard = video_standard;
3538         vp->pix_fmt = frame_pix_fmt;
3539         if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3540             fprintf(stderr, "Could not find video grab device\n");
3541             exit(1);
3542         }
3543         /* If not enough info to get the stream parameters, we decode the
3544            first frames to get it. */
3545         if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3546             fprintf(stderr, "Could not find video grab parameters\n");
3547             exit(1);
3548         }
3549         /* by now video grab has one stream */
3550         ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3551         ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3552         input_files[nb_input_files] = ic;
3553
3554         if (verbose >= 0)
3555             dump_format(ic, nb_input_files, "", 0);
3556
3557         nb_input_files++;
3558     }
3559     if (has_audio && audio_grab_format) {
3560         AVInputFormat *fmt1;
3561         fmt1 = av_find_input_format(audio_grab_format);
3562         ap->device = audio_device;
3563         if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3564             fprintf(stderr, "Could not find audio grab device\n");
3565             exit(1);
3566         }
3567         input_files[nb_input_files] = ic;
3568
3569         if (verbose >= 0)
3570             dump_format(ic, nb_input_files, "", 0);
3571
3572         nb_input_files++;
3573     }
3574 }
3575
3576 /* same option as mencoder */
3577 static void opt_pass(const char *pass_str)
3578 {
3579     int pass;
3580     pass = atoi(pass_str);
3581     if (pass != 1 && pass != 2) {
3582         fprintf(stderr, "pass number can be only 1 or 2\n");
3583         exit(1);
3584     }
3585     do_pass = pass;
3586 }
3587
3588 #if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3589 static int64_t getutime(void)
3590 {
3591   return av_gettime();
3592 }
3593 #else
3594 static int64_t getutime(void)
3595 {
3596     struct rusage rusage;
3597
3598     getrusage(RUSAGE_SELF, &rusage);
3599     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3600 }
3601 #endif
3602
3603 extern int ffm_nopts;
3604
3605 static void show_formats(void)
3606 {
3607     AVInputFormat *ifmt;
3608     AVOutputFormat *ofmt;
3609     AVImageFormat *image_fmt;
3610     URLProtocol *up;
3611     AVCodec *p, *p2;
3612     const char **pp, *last_name;
3613
3614     printf("File formats:\n");
3615     last_name= "000";
3616     for(;;){
3617         int decode=0;
3618         int encode=0;
3619         const char *name=NULL;
3620         const char *long_name=NULL;
3621
3622         for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3623             if((name == NULL || strcmp(ofmt->name, name)<0) &&
3624                 strcmp(ofmt->name, last_name)>0){
3625                 name= ofmt->name;
3626                 long_name= ofmt->long_name;
3627                 encode=1;
3628             }
3629         }
3630         for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3631             if((name == NULL || strcmp(ifmt->name, name)<0) &&
3632                 strcmp(ifmt->name, last_name)>0){
3633                 name= ifmt->name;
3634                 long_name= ifmt->long_name;
3635                 encode=0;
3636             }
3637             if(name && strcmp(ifmt->name, name)==0)
3638                 decode=1;
3639         }
3640         if(name==NULL)
3641             break;
3642         last_name= name;
3643
3644         printf(
3645             " %s%s %-15s %s\n",
3646             decode ? "D":" ",
3647             encode ? "E":" ",
3648             name,
3649             long_name ? long_name:" ");
3650     }
3651     printf("\n");
3652
3653     printf("Image formats (filename extensions, if any, follow):\n");
3654     for(image_fmt = first_image_format; image_fmt != NULL;
3655         image_fmt = image_fmt->next) {
3656         printf(
3657             " %s%s %-6s %s\n",
3658             image_fmt->img_read  ? "D":" ",
3659             image_fmt->img_write ? "E":" ",
3660             image_fmt->name,
3661             image_fmt->extensions ? image_fmt->extensions:" ");
3662     }
3663     printf("\n");
3664
3665     printf("Codecs:\n");
3666     last_name= "000";
3667     for(;;){
3668         int decode=0;
3669         int encode=0;
3670         int cap=0;
3671         const char *type_str;
3672
3673         p2=NULL;
3674         for(p = first_avcodec; p != NULL; p = p->next) {
3675             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3676                 strcmp(p->name, last_name)>0){
3677                 p2= p;
3678                 decode= encode= cap=0;
3679             }
3680             if(p2 && strcmp(p->name, p2->name)==0){
3681                 if(p->decode) decode=1;
3682                 if(p->encode) encode=1;
3683                 cap |= p->capabilities;
3684             }
3685         }
3686         if(p2==NULL)
3687             break;
3688         last_name= p2->name;
3689
3690         switch(p2->type) {
3691         case CODEC_TYPE_VIDEO:
3692             type_str = "V";
3693             break;
3694         case CODEC_TYPE_AUDIO:
3695             type_str = "A";
3696             break;
3697         case CODEC_TYPE_SUBTITLE:
3698             type_str = "S";
3699             break;
3700         default:
3701             type_str = "?";
3702             break;
3703         }
3704         printf(
3705             " %s%s%s%s%s%s %s",
3706             decode ? "D": (/*p2->decoder ? "d":*/" "),
3707             encode ? "E":" ",
3708             type_str,
3709             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3710             cap & CODEC_CAP_DR1 ? "D":" ",
3711             cap & CODEC_CAP_TRUNCATED ? "T":" ",
3712             p2->name);
3713        /* if(p2->decoder && decode==0)
3714             printf(" use %s for decoding", p2->decoder->name);*/
3715         printf("\n");
3716     }
3717     printf("\n");
3718
3719     printf("Supported file protocols:\n");
3720     for(up = first_protocol; up != NULL; up = up->next)
3721         printf(" %s:", up->name);
3722     printf("\n");
3723
3724     printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3725     printf("Motion estimation methods:\n");
3726     pp = motion_str;
3727     while (*pp) {
3728         printf(" %s", *pp);
3729         if ((pp - motion_str + 1) == ME_ZERO)
3730             printf("(fastest)");
3731         else if ((pp - motion_str + 1) == ME_FULL)
3732             printf("(slowest)");
3733         else if ((pp - motion_str + 1) == ME_EPZS)
3734             printf("(default)");
3735         pp++;
3736     }
3737     printf("\n\n");
3738     printf(
3739 "Note, the names of encoders and decoders dont always match, so there are\n"
3740 "several cases where the above table shows encoder only or decoder only entries\n"
3741 "even though both encoding and decoding are supported for example, the h263\n"
3742 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3743 "worse\n");
3744     exit(1);
3745 }
3746
3747 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3748 {
3749     int i;
3750     const char *p = str;
3751     for(i = 0;; i++) {
3752         dest[i] = atoi(p);
3753         if(i == 63)
3754             break;
3755         p = strchr(p, ',');
3756         if(!p) {
3757             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3758             exit(1);
3759         }
3760         p++;
3761     }
3762 }
3763
3764 static void opt_inter_matrix(const char *arg)
3765 {
3766     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3767     parse_matrix_coeffs(inter_matrix, arg);
3768 }
3769
3770 static void opt_intra_matrix(const char *arg)
3771 {
3772     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3773     parse_matrix_coeffs(intra_matrix, arg);
3774 }
3775
3776 static void opt_target(const char *arg)
3777 {
3778     int norm = -1;
3779     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3780
3781     if(!strncmp(arg, "pal-", 4)) {
3782         norm = 0;
3783         arg += 4;
3784     } else if(!strncmp(arg, "ntsc-", 5)) {
3785         norm = 1;
3786         arg += 5;
3787     } else if(!strncmp(arg, "film-", 5)) {
3788         norm = 2;
3789         arg += 5;
3790     } else {
3791         int fr;
3792         /* Calculate FR via float to avoid int overflow */
3793         fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3794         if(fr == 25000) {
3795             norm = 0;
3796         } else if((fr == 29970) || (fr == 23976)) {
3797             norm = 1;
3798         } else {
3799             /* Try to determine PAL/NTSC by peeking in the input files */
3800             if(nb_input_files) {
3801                 int i, j;
3802                 for(j = 0; j < nb_input_files; j++) {
3803                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3804                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3805                         if(c->codec_type != CODEC_TYPE_VIDEO)
3806                             continue;
3807                         fr = c->time_base.den * 1000 / c->time_base.num;
3808                         if(fr == 25000) {
3809                             norm = 0;
3810                             break;
3811                         } else if((fr == 29970) || (fr == 23976)) {
3812                             norm = 1;
3813                             break;
3814                         }
3815                     }
3816                     if(norm >= 0)
3817                         break;
3818                 }
3819             }
3820         }
3821         if(verbose && norm >= 0)
3822             fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3823     }
3824
3825     if(norm < 0) {
3826         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3827         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3828         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3829         exit(1);
3830     }
3831
3832     if(!strcmp(arg, "vcd")) {
3833
3834         opt_video_codec("mpeg1video");
3835         opt_audio_codec("mp2");
3836         opt_format("vcd");
3837
3838         opt_frame_size(norm ? "352x240" : "352x288");
3839         opt_frame_rate(frame_rates[norm]);
3840         opt_gop_size(norm ? "18" : "15");
3841
3842         video_bit_rate = 1150000;
3843         video_rc_max_rate = 1150000;
3844         video_rc_min_rate = 1150000;
3845         video_rc_buffer_size = 40*1024*8;
3846
3847         audio_bit_rate = 224000;
3848         audio_sample_rate = 44100;
3849
3850         mux_packet_size= 2324;
3851         mux_rate= 2352 * 75 * 8;
3852
3853         /* We have to offset the PTS, so that it is consistent with the SCR.
3854            SCR starts at 36000, but the first two packs contain only padding
3855            and the first pack from the other stream, respectively, may also have
3856            been written before.
3857            So the real data starts at SCR 36000+3*1200. */
3858         mux_preload= (36000+3*1200) / 90000.0; //0.44
3859     } else if(!strcmp(arg, "svcd")) {
3860
3861         opt_video_codec("mpeg2video");
3862         opt_audio_codec("mp2");
3863         opt_format("svcd");
3864
3865         opt_frame_size(norm ? "480x480" : "480x576");
3866         opt_frame_rate(frame_rates[norm]);
3867         opt_gop_size(norm ? "18" : "15");
3868
3869         video_bit_rate = 2040000;
3870         video_rc_max_rate = 2516000;
3871         video_rc_min_rate = 0; //1145000;
3872         video_rc_buffer_size = 224*1024*8;
3873         opt_default("flags", "+SCAN_OFFSET");
3874
3875
3876         audio_bit_rate = 224000;
3877         audio_sample_rate = 44100;
3878
3879         mux_packet_size= 2324;
3880
3881     } else if(!strcmp(arg, "dvd")) {
3882
3883         opt_video_codec("mpeg2video");
3884         opt_audio_codec("ac3");
3885         opt_format("dvd");
3886
3887         opt_frame_size(norm ? "720x480" : "720x576");
3888         opt_frame_rate(frame_rates[norm]);
3889         opt_gop_size(norm ? "18" : "15");
3890
3891         video_bit_rate = 6000000;
3892         video_rc_max_rate = 9000000;
3893         video_rc_min_rate = 0; //1500000;
3894         video_rc_buffer_size = 224*1024*8;
3895
3896         mux_packet_size= 2048;  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3897         mux_rate = 10080000;    // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3898
3899         audio_bit_rate = 448000;
3900         audio_sample_rate = 48000;
3901
3902     } else if(!strncmp(arg, "dv", 2)) {
3903
3904         opt_format("dv");
3905
3906         opt_frame_size(norm ? "720x480" : "720x576");
3907         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3908                                              (norm ? "yuv411p" : "yuv420p"));
3909         opt_frame_rate(frame_rates[norm]);
3910
3911         audio_sample_rate = 48000;
3912         audio_channels = 2;
3913
3914     } else {
3915         fprintf(stderr, "Unknown target: %s\n", arg);
3916         exit(1);
3917     }
3918 }
3919
3920 static void opt_video_bsf(const char *arg)
3921 {
3922     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3923     AVBitStreamFilterContext **bsfp;
3924
3925     if(!bsfc){
3926         fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3927         exit(1);
3928     }
3929
3930     bsfp= &video_bitstream_filters;
3931     while(*bsfp)
3932         bsfp= &(*bsfp)->next;
3933
3934     *bsfp= bsfc;
3935 }
3936
3937 //FIXME avoid audio - video code duplication
3938 static void opt_audio_bsf(const char *arg)
3939 {
3940     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3941     AVBitStreamFilterContext **bsfp;
3942
3943     if(!bsfc){
3944         fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3945         exit(1);
3946     }
3947
3948     bsfp= &audio_bitstream_filters;
3949     while(*bsfp)
3950         bsfp= &(*bsfp)->next;
3951
3952     *bsfp= bsfc;
3953 }
3954
3955 static void show_version(void)
3956 {
3957     /* TODO: add function interface to avutil and avformat */
3958     fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3959            "libavutil   %d\n"
3960            "libavcodec  %d\n"
3961            "libavformat %d\n",
3962            LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3963     exit(1);
3964 }
3965
3966 static int opt_default(const char *opt, const char *arg){
3967     AVOption *o= av_set_string(avctx_opts, opt, arg);
3968     if(!o)
3969         return -1;
3970
3971 //    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));
3972
3973     //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3974     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3975     opt_names[opt_name_count++]= o->name;
3976
3977     /* disable generate of real time pts in ffm (need to be supressed anyway) */
3978     if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3979         ffm_nopts = 1;
3980
3981     if(avctx_opts->debug)
3982         av_log_set_level(AV_LOG_DEBUG);
3983     return 0;
3984 }
3985
3986 const OptionDef options[] = {
3987     /* main options */
3988     { "L", 0, {(void*)show_license}, "show license" },
3989     { "h", 0, {(void*)show_help}, "show help" },
3990     { "version", 0, {(void*)show_version}, "show version" },
3991     { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3992     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3993     { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3994     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3995     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3996     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3997     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3998     { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3999     { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
4000     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4001     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4002     { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
4003     { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
4004     { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
4005     { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
4006     { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
4007     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4008       "add timings for benchmarking" },
4009     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4010       "dump each input packet" },
4011     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4012       "when dumping packets, also dump the payload" },
4013     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4014     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4015     { "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)", "" },
4016     { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
4017     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4018     { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4019     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4020     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4021     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4022     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4023     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4024     { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
4025
4026     /* video options */
4027     { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
4028     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4029     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4030     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
4031     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4032     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4033     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4034     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
4035     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
4036     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
4037     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
4038     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
4039     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
4040     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
4041     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
4042     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
4043     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
4044     { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
4045     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4046     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4047     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4048     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
4049     { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
4050     { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
4051     { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
4052     { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
4053     { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
4054     { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "max macroblock quantiser scale (VBR)", "q" },
4055     { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
4056     { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
4057     { "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" },
4058     { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
4059     { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
4060     { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
4061     { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
4062     { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
4063     { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
4064     { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
4065     { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
4066     { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
4067     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4068     { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
4069     { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
4070     { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
4071     { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
4072     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4073     { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
4074       "method" },
4075     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
4076     { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold",  "" },
4077     { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
4078     { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
4079     { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
4080     { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
4081     { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
4082     { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
4083     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4084       "use same video quality as source (implies VBR)" },
4085     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4086     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
4087     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4088       "deinterlace pictures" },
4089     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4090     { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
4091     { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
4092     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4093     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4094     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4095     { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
4096     { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
4097     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4098     { "mepc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&me_penalty_compensation}, "motion estimation bitrate penalty compensation", "factor (1.0 = 256)" },
4099     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4100     { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
4101     { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
4102     { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
4103     { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
4104     { "genpts", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&genpts }, "generate pts" },
4105     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4106
4107     /* audio options */
4108     { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
4109     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4110     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4111     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4112     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4113     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4114     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4115     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4116     { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
4117     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4118
4119     /* subtitle options */
4120     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4121     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
4122     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4123
4124     /* grab options */
4125     { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
4126     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4127     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4128     { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
4129
4130     /* G.2 grab options */
4131     { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
4132     { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
4133
4134     /* muxer options */
4135     { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
4136     { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
4137     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4138     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4139
4140     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
4141     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
4142
4143     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4144     { NULL, },
4145 };
4146
4147 static void show_banner(void)
4148 {
4149     fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2004 Fabrice Bellard\n");
4150     fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
4151     fprintf(stderr, "  libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
4152     fprintf(stderr, "  libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
4153     fprintf(stderr, "  libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
4154     fprintf(stderr, "  built on " __DATE__ " " __TIME__);
4155 #ifdef __GNUC__
4156     fprintf(stderr, ", gcc: " __VERSION__ "\n");
4157 #else
4158     fprintf(stderr, ", using a non-gcc compiler\n");
4159 #endif
4160 }
4161
4162 static void show_license(void)
4163 {
4164     show_banner();
4165 #ifdef CONFIG_GPL
4166     printf(
4167     "This program is free software; you can redistribute it and/or modify\n"
4168     "it under the terms of the GNU General Public License as published by\n"
4169     "the Free Software Foundation; either version 2 of the License, or\n"
4170     "(at your option) any later version.\n"
4171     "\n"
4172     "This program is distributed in the hope that it will be useful,\n"
4173     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4174     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
4175     "GNU General Public License for more details.\n"
4176     "\n"
4177     "You should have received a copy of the GNU General Public License\n"
4178     "along with this program; if not, write to the Free Software\n"
4179     "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
4180     );
4181 #else
4182     printf(
4183     "This library is free software; you can redistribute it and/or\n"
4184     "modify it under the terms of the GNU Lesser General Public\n"
4185     "License as published by the Free Software Foundation; either\n"
4186     "version 2 of the License, or (at your option) any later version.\n"
4187     "\n"
4188     "This library is distributed in the hope that it will be useful,\n"
4189     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4190     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
4191     "Lesser General Public License for more details.\n"
4192     "\n"
4193     "You should have received a copy of the GNU Lesser General Public\n"
4194     "License along with this library; if not, write to the Free Software\n"
4195     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
4196     );
4197 #endif
4198     exit(1);
4199 }
4200
4201 static void show_help(void)
4202 {
4203     show_banner();
4204     printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4205            "Hyper fast Audio and Video encoder\n");
4206     printf("\n");
4207     show_help_options(options, "Main options:\n",
4208                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4209     show_help_options(options, "\nVideo options:\n",
4210                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4211                       OPT_VIDEO);
4212     show_help_options(options, "\nAdvanced Video options:\n",
4213                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4214                       OPT_VIDEO | OPT_EXPERT);
4215     show_help_options(options, "\nAudio options:\n",
4216                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4217                       OPT_AUDIO);
4218     show_help_options(options, "\nAdvanced Audio options:\n",
4219                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4220                       OPT_AUDIO | OPT_EXPERT);
4221     show_help_options(options, "\nSubtitle options:\n",
4222                       OPT_SUBTITLE | OPT_GRAB,
4223                       OPT_SUBTITLE);
4224     show_help_options(options, "\nAudio/Video grab options:\n",
4225                       OPT_GRAB,
4226                       OPT_GRAB);
4227     show_help_options(options, "\nAdvanced options:\n",
4228                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4229                       OPT_EXPERT);
4230     av_opt_show(avctx_opts, NULL);
4231
4232     exit(1);
4233 }
4234
4235 void parse_arg_file(const char *filename)
4236 {
4237     opt_output_file(filename);
4238 }
4239
4240 int main(int argc, char **argv)
4241 {
4242     int i;
4243     int64_t ti;
4244
4245     av_register_all();
4246
4247     avctx_opts= avcodec_alloc_context();
4248
4249     if (argc <= 1)
4250         show_help();
4251     else
4252         show_banner();
4253
4254     /* parse options */
4255     parse_options(argc, argv, options);
4256
4257     /* file converter / grab */
4258     if (nb_output_files <= 0) {
4259         fprintf(stderr, "Must supply at least one output file\n");
4260         exit(1);
4261     }
4262
4263     if (nb_input_files == 0) {
4264         input_sync = 1;
4265         prepare_grab();
4266     }
4267
4268     ti = getutime();
4269     av_encode(output_files, nb_output_files, input_files, nb_input_files,
4270               stream_maps, nb_stream_maps);
4271     ti = getutime() - ti;
4272     if (do_benchmark) {
4273         printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4274     }
4275
4276     /* close files */
4277     for(i=0;i<nb_output_files;i++) {
4278         /* maybe av_close_output_file ??? */
4279         AVFormatContext *s = output_files[i];
4280         int j;
4281         if (!(s->oformat->flags & AVFMT_NOFILE))
4282             url_fclose(&s->pb);
4283         for(j=0;j<s->nb_streams;j++)
4284             av_free(s->streams[j]);
4285         av_free(s);
4286     }
4287     for(i=0;i<nb_input_files;i++)
4288         av_close_input_file(input_files[i]);
4289
4290     av_free_static();
4291
4292     if(intra_matrix)
4293         av_free(intra_matrix);
4294     if(inter_matrix)
4295         av_free(inter_matrix);
4296
4297 #ifdef POWERPC_PERFORMANCE_REPORT
4298     extern void powerpc_display_perf_report(void);
4299     powerpc_display_perf_report();
4300 #endif /* POWERPC_PERFORMANCE_REPORT */
4301
4302 #ifndef CONFIG_WIN32
4303     if (received_sigterm) {
4304         fprintf(stderr,
4305             "Received signal %d: terminating.\n",
4306             (int) received_sigterm);
4307         exit (255);
4308     }
4309 #endif
4310     exit(0); /* not all OS-es handle main() return value */
4311     return 0;
4312 }