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