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

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