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->pix_fmt = icodec->pix_fmt;
1665                 codec->width = icodec->width;
1666                 codec->height = icodec->height;
1667                 codec->has_b_frames = icodec->has_b_frames;
1668                 break;
1669             case CODEC_TYPE_SUBTITLE:
1670                 break;
1671             default:
1672                 av_abort();
1673             }
1674         } else {
1675             switch(codec->codec_type) {
1676             case CODEC_TYPE_AUDIO:
1677                 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1678                     goto fail;
1679
1680                 if (codec->channels == icodec->channels &&
1681                     codec->sample_rate == icodec->sample_rate) {
1682                     ost->audio_resample = 0;
1683                 } else {
1684                     if (codec->channels != icodec->channels &&
1685                         (icodec->codec_id == CODEC_ID_AC3 ||
1686                          icodec->codec_id == CODEC_ID_DTS)) {
1687                         /* Special case for 5:1 AC3 and DTS input */
1688                         /* and mono or stereo output      */
1689                         /* Request specific number of channels */
1690                         icodec->channels = codec->channels;
1691                         if (codec->sample_rate == icodec->sample_rate)
1692                             ost->audio_resample = 0;
1693                         else {
1694                             ost->audio_resample = 1;
1695                         }
1696                     } else {
1697                         ost->audio_resample = 1;
1698                     }
1699                 }
1700                 if(audio_sync_method>1)
1701                     ost->audio_resample = 1;
1702
1703                 if(ost->audio_resample){
1704                     ost->resample = audio_resample_init(codec->channels, icodec->channels,
1705                                                     codec->sample_rate, icodec->sample_rate);
1706                     if(!ost->resample){
1707                         printf("Can't resample.  Aborting.\n");
1708                         av_abort();
1709                     }
1710                 }
1711                 ist->decoding_needed = 1;
1712                 ost->encoding_needed = 1;
1713                 break;
1714             case CODEC_TYPE_VIDEO:
1715                 if (codec->width == icodec->width &&
1716                     codec->height == icodec->height &&
1717                     frame_topBand == 0 &&
1718                     frame_bottomBand == 0 &&
1719                     frame_leftBand == 0 &&
1720                     frame_rightBand == 0 &&
1721                     frame_padtop == 0 &&
1722                     frame_padbottom == 0 &&
1723                     frame_padleft == 0 &&
1724                     frame_padright == 0)
1725                 {
1726                     ost->video_resample = 0;
1727                     ost->video_crop = 0;
1728                     ost->video_pad = 0;
1729                 } else if ((codec->width == icodec->width -
1730                                 (frame_leftBand + frame_rightBand)) &&
1731                         (codec->height == icodec->height -
1732                                 (frame_topBand  + frame_bottomBand)))
1733                 {
1734                     ost->video_resample = 0;
1735                     ost->video_crop = 1;
1736                     ost->topBand = frame_topBand;
1737                     ost->leftBand = frame_leftBand;
1738                 } else if ((codec->width == icodec->width +
1739                                 (frame_padleft + frame_padright)) &&
1740                         (codec->height == icodec->height +
1741                                 (frame_padtop + frame_padbottom))) {
1742                     ost->video_resample = 0;
1743                     ost->video_crop = 0;
1744                     ost->video_pad = 1;
1745                     ost->padtop = frame_padtop;
1746                     ost->padleft = frame_padleft;
1747                     ost->padbottom = frame_padbottom;
1748                     ost->padright = frame_padright;
1749                     avcodec_get_frame_defaults(&ost->pict_tmp);
1750                     if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1751                                 codec->width, codec->height ) )
1752                         goto fail;
1753                 } else {
1754                     ost->video_resample = 1;
1755                     ost->video_crop = 0; // cropping is handled as part of resample
1756                     avcodec_get_frame_defaults(&ost->pict_tmp);
1757                     if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1758                                          codec->width, codec->height ) )
1759                         goto fail;
1760
1761                     ost->img_resample_ctx = img_resample_full_init(
1762                                       codec->width, codec->height,
1763                                       icodec->width, icodec->height,
1764                                       frame_topBand, frame_bottomBand,
1765                             frame_leftBand, frame_rightBand,
1766                             frame_padtop, frame_padbottom,
1767                             frame_padleft, frame_padright);
1768
1769                     ost->padtop = frame_padtop;
1770                     ost->padleft = frame_padleft;
1771                     ost->padbottom = frame_padbottom;
1772                     ost->padright = frame_padright;
1773
1774                 }
1775                 ost->encoding_needed = 1;
1776                 ist->decoding_needed = 1;
1777                 break;
1778             case CODEC_TYPE_SUBTITLE:
1779                 ost->encoding_needed = 1;
1780                 ist->decoding_needed = 1;
1781                 break;
1782             default:
1783                 av_abort();
1784                 break;
1785             }
1786             /* two pass mode */
1787             if (ost->encoding_needed &&
1788                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1789                 char logfilename[1024];
1790                 FILE *f;
1791                 int size;
1792                 char *logbuffer;
1793
1794                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1795                          pass_logfilename ?
1796                          pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1797                 if (codec->flags & CODEC_FLAG_PASS1) {
1798                     f = fopen(logfilename, "w");
1799                     if (!f) {
1800                         perror(logfilename);
1801                         exit(1);
1802                     }
1803                     ost->logfile = f;
1804                 } else {
1805                     /* read the log file */
1806                     f = fopen(logfilename, "r");
1807                     if (!f) {
1808                         perror(logfilename);
1809                         exit(1);
1810                     }
1811                     fseek(f, 0, SEEK_END);
1812                     size = ftell(f);
1813                     fseek(f, 0, SEEK_SET);
1814                     logbuffer = av_malloc(size + 1);
1815                     if (!logbuffer) {
1816                         fprintf(stderr, "Could not allocate log buffer\n");
1817                         exit(1);
1818                     }
1819                     size = fread(logbuffer, 1, size, f);
1820                     fclose(f);
1821                     logbuffer[size] = '\0';
1822                     codec->stats_in = logbuffer;
1823                 }
1824             }
1825         }
1826         if(codec->codec_type == CODEC_TYPE_VIDEO){
1827             int size= codec->width * codec->height;
1828             bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1829         }
1830     }
1831
1832     if (!bit_buffer)
1833         bit_buffer = av_malloc(bit_buffer_size);
1834     if (!bit_buffer)
1835         goto fail;
1836
1837     /* dump the file output parameters - cannot be done before in case
1838        of stream copy */
1839     for(i=0;i<nb_output_files;i++) {
1840         dump_format(output_files[i], i, output_files[i]->filename, 1);
1841     }
1842
1843     /* dump the stream mapping */
1844     if (verbose >= 0) {
1845         fprintf(stderr, "Stream mapping:\n");
1846         for(i=0;i<nb_ostreams;i++) {
1847             ost = ost_table[i];
1848             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1849                     ist_table[ost->source_index]->file_index,
1850                     ist_table[ost->source_index]->index,
1851                     ost->file_index,
1852                     ost->index);
1853             if (ost->sync_ist != ist_table[ost->source_index])
1854                 fprintf(stderr, " [sync #%d.%d]",
1855                         ost->sync_ist->file_index,
1856                         ost->sync_ist->index);
1857             fprintf(stderr, "\n");
1858         }
1859     }
1860
1861     /* open each encoder */
1862     for(i=0;i<nb_ostreams;i++) {
1863         ost = ost_table[i];
1864         if (ost->encoding_needed) {
1865             AVCodec *codec;
1866             codec = avcodec_find_encoder(ost->st->codec->codec_id);
1867             if (!codec) {
1868                 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1869                         ost->file_index, ost->index);
1870                 exit(1);
1871             }
1872             if (avcodec_open(ost->st->codec, codec) < 0) {
1873                 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1874                         ost->file_index, ost->index);
1875                 exit(1);
1876             }
1877             extra_size += ost->st->codec->extradata_size;
1878         }
1879     }
1880
1881     /* open each decoder */
1882     for(i=0;i<nb_istreams;i++) {
1883         ist = ist_table[i];
1884         if (ist->decoding_needed) {
1885             AVCodec *codec;
1886             codec = avcodec_find_decoder(ist->st->codec->codec_id);
1887             if (!codec) {
1888                 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1889                         ist->st->codec->codec_id, ist->file_index, ist->index);
1890                 exit(1);
1891             }
1892             if (avcodec_open(ist->st->codec, codec) < 0) {
1893                 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1894                         ist->file_index, ist->index);
1895                 exit(1);
1896             }
1897             //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1898             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1899         }
1900     }
1901
1902     /* init pts */
1903     for(i=0;i<nb_istreams;i++) {
1904         ist = ist_table[i];
1905         is = input_files[ist->file_index];
1906         ist->pts = 0;
1907         ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1908         if(ist->st->start_time == AV_NOPTS_VALUE)
1909             ist->next_pts=0;
1910         if(input_files_ts_offset[ist->file_index])
1911             ist->next_pts= AV_NOPTS_VALUE;
1912         ist->is_start = 1;
1913     }
1914
1915     /* compute buffer size max (should use a complete heuristic) */
1916     for(i=0;i<nb_input_files;i++) {
1917         file_table[i].buffer_size_max = 2048;
1918     }
1919
1920     /* set meta data information from input file if required */
1921     for (i=0;i<nb_meta_data_maps;i++) {
1922         AVFormatContext *out_file;
1923         AVFormatContext *in_file;
1924
1925         int out_file_index = meta_data_maps[i].out_file;
1926         int in_file_index = meta_data_maps[i].in_file;
1927         if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1928             fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1929             ret = -EINVAL;
1930             goto fail;
1931         }
1932         if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1933             fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1934             ret = -EINVAL;
1935             goto fail;
1936         }
1937
1938         out_file = output_files[out_file_index];
1939         in_file = input_files[in_file_index];
1940
1941         strcpy(out_file->title, in_file->title);
1942         strcpy(out_file->author, in_file->author);
1943         strcpy(out_file->copyright, in_file->copyright);
1944         strcpy(out_file->comment, in_file->comment);
1945         strcpy(out_file->album, in_file->album);
1946         out_file->year = in_file->year;
1947         out_file->track = in_file->track;
1948         strcpy(out_file->genre, in_file->genre);
1949     }
1950
1951     /* open files and write file headers */
1952     for(i=0;i<nb_output_files;i++) {
1953         os = output_files[i];
1954         if (av_write_header(os) < 0) {
1955             fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1956             ret = -EINVAL;
1957             goto fail;
1958         }
1959     }
1960
1961 #ifndef CONFIG_WIN32
1962     if ( !using_stdin && verbose >= 0) {
1963         fprintf(stderr, "Press [q] to stop encoding\n");
1964         url_set_interrupt_cb(decode_interrupt_cb);
1965     }
1966 #endif
1967     term_init();
1968
1969     stream_no_data = 0;
1970     key = -1;
1971
1972     for(; received_sigterm == 0;) {
1973         int file_index, ist_index;
1974         AVPacket pkt;
1975         double ipts_min;
1976         double opts_min;
1977
1978     redo:
1979         ipts_min= 1e100;
1980         opts_min= 1e100;
1981         /* if 'q' pressed, exits */
1982         if (!using_stdin) {
1983             if (q_pressed)
1984                 break;
1985             /* read_key() returns 0 on EOF */
1986             key = read_key();
1987             if (key == 'q')
1988                 break;
1989         }
1990
1991         /* select the stream that we must read now by looking at the
1992            smallest output pts */
1993         file_index = -1;
1994         for(i=0;i<nb_ostreams;i++) {
1995             double ipts, opts;
1996             ost = ost_table[i];
1997             os = output_files[ost->file_index];
1998             ist = ist_table[ost->source_index];
1999             if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2000                 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2001             else
2002                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2003             ipts = (double)ist->pts;
2004             if (!file_table[ist->file_index].eof_reached){
2005                 if(ipts < ipts_min) {
2006                     ipts_min = ipts;
2007                     if(input_sync ) file_index = ist->file_index;
2008                 }
2009                 if(opts < opts_min) {
2010                     opts_min = opts;
2011                     if(!input_sync) file_index = ist->file_index;
2012                 }
2013             }
2014             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2015                 file_index= -1;
2016                 break;
2017             }
2018         }
2019         /* if none, if is finished */
2020         if (file_index < 0) {
2021             break;
2022         }
2023
2024         /* finish if recording time exhausted */
2025         if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
2026             break;
2027
2028         /* finish if limit size exhausted */
2029         if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
2030             break;
2031
2032         /* read a frame from it and output it in the fifo */
2033         is = input_files[file_index];
2034         if (av_read_frame(is, &pkt) < 0) {
2035             file_table[file_index].eof_reached = 1;
2036             if (opt_shortest) break; else continue; //
2037         }
2038
2039         if (!pkt.size) {
2040             stream_no_data = is;
2041         } else {
2042             stream_no_data = 0;
2043         }
2044         if (do_pkt_dump) {
2045             av_pkt_dump(stdout, &pkt, do_hex_dump);
2046         }
2047         /* the following test is needed in case new streams appear
2048            dynamically in stream : we ignore them */
2049         if (pkt.stream_index >= file_table[file_index].nb_streams)
2050             goto discard_packet;
2051         ist_index = file_table[file_index].ist_index + pkt.stream_index;
2052         ist = ist_table[ist_index];
2053         if (ist->discard)
2054             goto discard_packet;
2055
2056 //        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);
2057         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2058             int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
2059             if(ABS(delta) > 10LL*AV_TIME_BASE && !copy_ts){
2060                 input_files_ts_offset[ist->file_index]-= delta;
2061                 if (verbose > 2)
2062                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2063                 for(i=0; i<file_table[file_index].nb_streams; i++){
2064                     int index= file_table[file_index].ist_index + i;
2065                     ist_table[index]->next_pts += delta;
2066                     ist_table[index]->is_start=1;
2067                 }
2068             }
2069         }
2070
2071         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2072         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2073
2074             if (verbose >= 0)
2075                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2076                         ist->file_index, ist->index);
2077
2078             av_free_packet(&pkt);
2079             goto redo;
2080         }
2081
2082     discard_packet:
2083         av_free_packet(&pkt);
2084
2085         /* dump report by using the output first video and audio streams */
2086         print_report(output_files, ost_table, nb_ostreams, 0);
2087     }
2088
2089     /* at the end of stream, we must flush the decoder buffers */
2090     for(i=0;i<nb_istreams;i++) {
2091         ist = ist_table[i];
2092         if (ist->decoding_needed) {
2093             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2094         }
2095     }
2096
2097     term_exit();
2098
2099     /* write the trailer if needed and close file */
2100     for(i=0;i<nb_output_files;i++) {
2101         os = output_files[i];
2102         av_write_trailer(os);
2103     }
2104
2105     /* dump report by using the first video and audio streams */
2106     print_report(output_files, ost_table, nb_ostreams, 1);
2107
2108     /* close each encoder */
2109     for(i=0;i<nb_ostreams;i++) {
2110         ost = ost_table[i];
2111         if (ost->encoding_needed) {
2112             av_freep(&ost->st->codec->stats_in);
2113             avcodec_close(ost->st->codec);
2114         }
2115     }
2116
2117     /* close each decoder */
2118     for(i=0;i<nb_istreams;i++) {
2119         ist = ist_table[i];
2120         if (ist->decoding_needed) {
2121             avcodec_close(ist->st->codec);
2122         }
2123     }
2124
2125     /* finished ! */
2126
2127     ret = 0;
2128  fail1:
2129     av_freep(&bit_buffer);
2130     av_free(file_table);
2131
2132     if (ist_table) {
2133         for(i=0;i<nb_istreams;i++) {
2134             ist = ist_table[i];
2135             av_free(ist);
2136         }
2137         av_free(ist_table);
2138     }
2139     if (ost_table) {
2140         for(i=0;i<nb_ostreams;i++) {
2141             ost = ost_table[i];
2142             if (ost) {
2143                 if (ost->logfile) {
2144                     fclose(ost->logfile);
2145                     ost->logfile = NULL;
2146                 }
2147                 fifo_free(&ost->fifo); /* works even if fifo is not
2148                                           initialized but set to zero */
2149                 av_free(ost->pict_tmp.data[0]);
2150                 if (ost->video_resample)
2151                     img_resample_close(ost->img_resample_ctx);
2152                 if (ost->audio_resample)
2153                     audio_resample_close(ost->resample);
2154                 av_free(ost);
2155             }
2156         }
2157         av_free(ost_table);
2158     }
2159     return ret;
2160  fail:
2161     ret = -ENOMEM;
2162     goto fail1;
2163 }
2164
2165 #if 0
2166 int file_read(const char *filename)
2167 {
2168     URLContext *h;
2169     unsigned char buffer[1024];
2170     int len, i;
2171
2172     if (url_open(&h, filename, O_RDONLY) < 0) {
2173         printf("could not open '%s'\n", filename);
2174         return -1;
2175     }
2176     for(;;) {
2177         len = url_read(h, buffer, sizeof(buffer));
2178         if (len <= 0)
2179             break;
2180         for(i=0;i<len;i++) putchar(buffer[i]);
2181     }
2182     url_close(h);
2183     return 0;
2184 }
2185 #endif
2186
2187 static void opt_image_format(const char *arg)
2188 {
2189     AVImageFormat *f;
2190
2191     for(f = first_image_format; f != NULL; f = f->next) {
2192         if (!strcmp(arg, f->name))
2193             break;
2194     }
2195     if (!f) {
2196         fprintf(stderr, "Unknown image format: '%s'\n", arg);
2197         exit(1);
2198     }
2199     image_format = f;
2200 }
2201
2202 static void opt_format(const char *arg)
2203 {
2204     /* compatibility stuff for pgmyuv */
2205     if (!strcmp(arg, "pgmyuv")) {
2206         pgmyuv_compatibility_hack=1;
2207 //        opt_image_format(arg);
2208         arg = "image2";
2209     }
2210
2211     file_iformat = av_find_input_format(arg);
2212     file_oformat = guess_format(arg, NULL, NULL);
2213     if (!file_iformat && !file_oformat) {
2214         fprintf(stderr, "Unknown input or output format: %s\n", arg);
2215         exit(1);
2216     }
2217 }
2218
2219 static void opt_video_bitrate(const char *arg)
2220 {
2221     video_bit_rate = atoi(arg) * 1000;
2222 }
2223
2224 static void opt_video_bitrate_tolerance(const char *arg)
2225 {
2226     video_bit_rate_tolerance = atoi(arg) * 1000;
2227 }
2228
2229 static void opt_video_bitrate_max(const char *arg)
2230 {
2231     video_rc_max_rate = atoi(arg) * 1000;
2232 }
2233
2234 static void opt_video_bitrate_min(const char *arg)
2235 {
2236     video_rc_min_rate = atoi(arg) * 1000;
2237 }
2238
2239 static void opt_video_buffer_size(const char *arg)
2240 {
2241     video_rc_buffer_size = atoi(arg) * 8*1024;
2242 }
2243
2244 static void opt_video_rc_eq(char *arg)
2245 {
2246     video_rc_eq = arg;
2247 }
2248
2249 static void opt_video_rc_override_string(char *arg)
2250 {
2251     video_rc_override_string = arg;
2252 }
2253
2254
2255 static void opt_workaround_bugs(const char *arg)
2256 {
2257     workaround_bugs = atoi(arg);
2258 }
2259
2260 static void opt_me_threshold(const char *arg)
2261 {
2262     me_threshold = atoi(arg);
2263 }
2264
2265 static void opt_mb_threshold(const char *arg)
2266 {
2267     mb_threshold = atoi(arg);
2268 }
2269
2270 static void opt_verbose(const char *arg)
2271 {
2272     verbose = atoi(arg);
2273     av_log_set_level(atoi(arg));
2274 }
2275
2276 static void opt_frame_rate(const char *arg)
2277 {
2278     if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2279         fprintf(stderr, "Incorrect frame rate\n");
2280         exit(1);
2281     }
2282 }
2283
2284 static void opt_frame_crop_top(const char *arg)
2285 {
2286     frame_topBand = atoi(arg);
2287     if (frame_topBand < 0) {
2288         fprintf(stderr, "Incorrect top crop size\n");
2289         exit(1);
2290     }
2291     if ((frame_topBand % 2) != 0) {
2292         fprintf(stderr, "Top crop size must be a multiple of 2\n");
2293         exit(1);
2294     }
2295     if ((frame_topBand) >= frame_height){
2296         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2297         exit(1);
2298     }
2299     frame_height -= frame_topBand;
2300 }
2301
2302 static void opt_frame_crop_bottom(const char *arg)
2303 {
2304     frame_bottomBand = atoi(arg);
2305     if (frame_bottomBand < 0) {
2306         fprintf(stderr, "Incorrect bottom crop size\n");
2307         exit(1);
2308     }
2309     if ((frame_bottomBand % 2) != 0) {
2310         fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2311         exit(1);
2312     }
2313     if ((frame_bottomBand) >= frame_height){
2314         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2315         exit(1);
2316     }
2317     frame_height -= frame_bottomBand;
2318 }
2319
2320 static void opt_frame_crop_left(const char *arg)
2321 {
2322     frame_leftBand = atoi(arg);
2323     if (frame_leftBand < 0) {
2324         fprintf(stderr, "Incorrect left crop size\n");
2325         exit(1);
2326     }
2327     if ((frame_leftBand % 2) != 0) {
2328         fprintf(stderr, "Left crop size must be a multiple of 2\n");
2329         exit(1);
2330     }
2331     if ((frame_leftBand) >= frame_width){
2332         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2333         exit(1);
2334     }
2335     frame_width -= frame_leftBand;
2336 }
2337
2338 static void opt_frame_crop_right(const char *arg)
2339 {
2340     frame_rightBand = atoi(arg);
2341     if (frame_rightBand < 0) {
2342         fprintf(stderr, "Incorrect right crop size\n");
2343         exit(1);
2344     }
2345     if ((frame_rightBand % 2) != 0) {
2346         fprintf(stderr, "Right crop size must be a multiple of 2\n");
2347         exit(1);
2348     }
2349     if ((frame_rightBand) >= frame_width){
2350         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2351         exit(1);
2352     }
2353     frame_width -= frame_rightBand;
2354 }
2355
2356 static void opt_frame_size(const char *arg)
2357 {
2358     if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2359         fprintf(stderr, "Incorrect frame size\n");
2360         exit(1);
2361     }
2362     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2363         fprintf(stderr, "Frame size must be a multiple of 2\n");
2364         exit(1);
2365     }
2366 }
2367
2368
2369 #define SCALEBITS 10
2370 #define ONE_HALF  (1 << (SCALEBITS - 1))
2371 #define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2372
2373 #define RGB_TO_Y(r, g, b) \
2374 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2375   FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2376
2377 #define RGB_TO_U(r1, g1, b1, shift)\
2378 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2379      FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2380
2381 #define RGB_TO_V(r1, g1, b1, shift)\
2382 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2383    FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2384
2385 static void opt_pad_color(const char *arg) {
2386     /* Input is expected to be six hex digits similar to
2387        how colors are expressed in html tags (but without the #) */
2388     int rgb = strtol(arg, NULL, 16);
2389     int r,g,b;
2390
2391     r = (rgb >> 16);
2392     g = ((rgb >> 8) & 255);
2393     b = (rgb & 255);
2394
2395     padcolor[0] = RGB_TO_Y(r,g,b);
2396     padcolor[1] = RGB_TO_U(r,g,b,0);
2397     padcolor[2] = RGB_TO_V(r,g,b,0);
2398 }
2399
2400 static void opt_frame_pad_top(const char *arg)
2401 {
2402     frame_padtop = atoi(arg);
2403     if (frame_padtop < 0) {
2404         fprintf(stderr, "Incorrect top pad size\n");
2405         exit(1);
2406     }
2407     if ((frame_padtop % 2) != 0) {
2408         fprintf(stderr, "Top pad size must be a multiple of 2\n");
2409         exit(1);
2410     }
2411 }
2412
2413 static void opt_frame_pad_bottom(const char *arg)
2414 {
2415     frame_padbottom = atoi(arg);
2416     if (frame_padbottom < 0) {
2417         fprintf(stderr, "Incorrect bottom pad size\n");
2418         exit(1);
2419     }
2420     if ((frame_padbottom % 2) != 0) {
2421         fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2422         exit(1);
2423     }
2424 }
2425
2426
2427 static void opt_frame_pad_left(const char *arg)
2428 {
2429     frame_padleft = atoi(arg);
2430     if (frame_padleft < 0) {
2431         fprintf(stderr, "Incorrect left pad size\n");
2432         exit(1);
2433     }
2434     if ((frame_padleft % 2) != 0) {
2435         fprintf(stderr, "Left pad size must be a multiple of 2\n");
2436         exit(1);
2437     }
2438 }
2439
2440
2441 static void opt_frame_pad_right(const char *arg)
2442 {
2443     frame_padright = atoi(arg);
2444     if (frame_padright < 0) {
2445         fprintf(stderr, "Incorrect right pad size\n");
2446         exit(1);
2447     }
2448     if ((frame_padright % 2) != 0) {
2449         fprintf(stderr, "Right pad size must be a multiple of 2\n");
2450         exit(1);
2451     }
2452 }
2453
2454
2455 static void opt_frame_pix_fmt(const char *arg)
2456 {
2457     frame_pix_fmt = avcodec_get_pix_fmt(arg);
2458 }
2459
2460 static void opt_frame_aspect_ratio(const char *arg)
2461 {
2462     int x = 0, y = 0;
2463     double ar = 0;
2464     const char *p;
2465
2466     p = strchr(arg, ':');
2467     if (p) {
2468         x = strtol(arg, (char **)&arg, 10);
2469         if (arg == p)
2470             y = strtol(arg+1, (char **)&arg, 10);
2471         if (x > 0 && y > 0)
2472             ar = (double)x / (double)y;
2473     } else
2474         ar = strtod(arg, (char **)&arg);
2475
2476     if (!ar) {
2477         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2478         exit(1);
2479     }
2480     frame_aspect_ratio = ar;
2481 }
2482
2483 static void opt_gop_size(const char *arg)
2484 {
2485     gop_size = atoi(arg);
2486 }
2487
2488 static void opt_b_frames(const char *arg)
2489 {
2490     b_frames = atoi(arg);
2491     if (b_frames > FF_MAX_B_FRAMES) {
2492         fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2493         exit(1);
2494     } else if (b_frames < 1) {
2495         fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2496         exit(1);
2497     }
2498 }
2499
2500 static void opt_pre_me(const char *arg)
2501 {
2502     pre_me = atoi(arg);
2503 }
2504
2505 static void opt_qscale(const char *arg)
2506 {
2507     video_qscale = atof(arg);
2508     if (video_qscale < 0.01 ||
2509         video_qscale > 255) {
2510         fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2511         exit(1);
2512     }
2513 }
2514
2515 static void opt_qsquish(const char *arg)
2516 {
2517     video_qsquish = atof(arg);
2518     if (video_qsquish < 0.0 ||
2519         video_qsquish > 99.0) {
2520         fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
2521         exit(1);
2522     }
2523 }
2524
2525 static void opt_lmax(const char *arg)
2526 {
2527     video_lmax = atof(arg)*FF_QP2LAMBDA;
2528 }
2529
2530 static void opt_lmin(const char *arg)
2531 {
2532     video_lmin = atof(arg)*FF_QP2LAMBDA;
2533 }
2534
2535 static void opt_qmin(const char *arg)
2536 {
2537     video_qmin = atoi(arg);
2538     if (video_qmin < 1 ||
2539         video_qmin > 51) {
2540         fprintf(stderr, "qmin must be >= 1 and <= 51\n");
2541         exit(1);
2542     }
2543 }
2544
2545 static void opt_qmax(const char *arg)
2546 {
2547     video_qmax = atoi(arg);
2548     if (video_qmax < 1 ||
2549         video_qmax > 51) {
2550         fprintf(stderr, "qmax must be >= 1 and <= 51\n");
2551         exit(1);
2552     }
2553 }
2554
2555 static void opt_mb_lmin(const char *arg)
2556 {
2557     video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2558     if (video_mb_lmin < 1 ||
2559         video_mb_lmin > FF_LAMBDA_MAX) {
2560         fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2561         exit(1);
2562     }
2563 }
2564
2565 static void opt_mb_lmax(const char *arg)
2566 {
2567     video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2568     if (video_mb_lmax < 1 ||
2569         video_mb_lmax > FF_LAMBDA_MAX) {
2570         fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2571         exit(1);
2572     }
2573 }
2574
2575 static void opt_qdiff(const char *arg)
2576 {
2577     video_qdiff = atoi(arg);
2578     if (video_qdiff < 0 ||
2579         video_qdiff > 31) {
2580         fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2581         exit(1);
2582     }
2583 }
2584
2585 static void opt_qblur(const char *arg)
2586 {
2587     video_qblur = atof(arg);
2588 }
2589
2590 static void opt_qcomp(const char *arg)
2591 {
2592     video_qcomp = atof(arg);
2593 }
2594
2595 static void opt_rc_initial_cplx(const char *arg)
2596 {
2597     video_rc_initial_cplx = atof(arg);
2598 }
2599 static void opt_b_qfactor(const char *arg)
2600 {
2601     video_b_qfactor = atof(arg);
2602 }
2603 static void opt_i_qfactor(const char *arg)
2604 {
2605     video_i_qfactor = atof(arg);
2606 }
2607 static void opt_b_qoffset(const char *arg)
2608 {
2609     video_b_qoffset = atof(arg);
2610 }
2611 static void opt_i_qoffset(const char *arg)
2612 {
2613     video_i_qoffset = atof(arg);
2614 }
2615
2616 static void opt_ibias(const char *arg)
2617 {
2618     video_intra_quant_bias = atoi(arg);
2619 }
2620 static void opt_pbias(const char *arg)
2621 {
2622     video_inter_quant_bias = atoi(arg);
2623 }
2624
2625 static void opt_packet_size(const char *arg)
2626 {
2627     packet_size= atoi(arg);
2628 }
2629
2630 static void opt_error_rate(const char *arg)
2631 {
2632     error_rate= atoi(arg);
2633 }
2634
2635 static void opt_strict(const char *arg)
2636 {
2637     strict= atoi(arg);
2638 }
2639
2640 static void opt_top_field_first(const char *arg)
2641 {
2642     top_field_first= atoi(arg);
2643 }
2644
2645 static void opt_sc_threshold(const char *arg)
2646 {
2647     sc_threshold= atoi(arg);
2648 }
2649
2650 static void opt_me_range(const char *arg)
2651 {
2652     me_range = atoi(arg);
2653 }
2654
2655 static void opt_thread_count(const char *arg)
2656 {
2657     thread_count= atoi(arg);
2658 #if !defined(HAVE_THREADS)
2659     if (verbose >= 0)
2660         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2661 #endif
2662 }
2663
2664 static void opt_audio_bitrate(const char *arg)
2665 {
2666     audio_bit_rate = atoi(arg) * 1000;
2667 }
2668
2669 static void opt_audio_rate(const char *arg)
2670 {
2671     audio_sample_rate = atoi(arg);
2672 }
2673
2674 static void opt_audio_channels(const char *arg)
2675 {
2676     audio_channels = atoi(arg);
2677 }
2678
2679 static void opt_video_device(const char *arg)
2680 {
2681     video_device = av_strdup(arg);
2682 }
2683
2684 static void opt_grab_device(const char *arg)
2685 {
2686     grab_device = av_strdup(arg);
2687 }
2688
2689 static void opt_video_channel(const char *arg)
2690 {
2691     video_channel = strtol(arg, NULL, 0);
2692 }
2693
2694 static void opt_video_standard(const char *arg)
2695 {
2696     video_standard = av_strdup(arg);
2697 }
2698
2699 static void opt_audio_device(const char *arg)
2700 {
2701     audio_device = av_strdup(arg);
2702 }
2703
2704 static void opt_codec(int *pstream_copy, int *pcodec_id,
2705                       int codec_type, const char *arg)
2706 {
2707     AVCodec *p;
2708
2709     if (!strcmp(arg, "copy")) {
2710         *pstream_copy = 1;
2711     } else {
2712         p = first_avcodec;
2713         while (p) {
2714             if (!strcmp(p->name, arg) && p->type == codec_type)
2715                 break;
2716             p = p->next;
2717         }
2718         if (p == NULL) {
2719             fprintf(stderr, "Unknown codec '%s'\n", arg);
2720             exit(1);
2721         } else {
2722             *pcodec_id = p->id;
2723         }
2724     }
2725 }
2726
2727 static void opt_audio_codec(const char *arg)
2728 {
2729     opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2730 }
2731
2732 static void opt_audio_tag(const char *arg)
2733 {
2734     char *tail;
2735     audio_codec_tag= strtol(arg, &tail, 0);
2736
2737     if(!tail || *tail)
2738         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2739 }
2740
2741 static void opt_video_tag(const char *arg)
2742 {
2743     char *tail;
2744     video_codec_tag= strtol(arg, &tail, 0);
2745
2746     if(!tail || *tail)
2747         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2748 }
2749
2750 static void add_frame_hooker(const char *arg)
2751 {
2752     int argc = 0;
2753     char *argv[64];
2754     int i;
2755     char *args = av_strdup(arg);
2756
2757     using_vhook = 1;
2758
2759     argv[0] = strtok(args, " ");
2760     while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2761     }
2762
2763     i = frame_hook_add(argc, argv);
2764
2765     if (i != 0) {
2766         fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2767         exit(1);
2768     }
2769 }
2770
2771 const char *motion_str[] = {
2772     "zero",
2773     "full",
2774     "log",
2775     "phods",
2776     "epzs",
2777     "x1",
2778     "hex",
2779     "umh",
2780     "iter",
2781     NULL,
2782 };
2783
2784 static void opt_motion_estimation(const char *arg)
2785 {
2786     const char **p;
2787     p = motion_str;
2788     for(;;) {
2789         if (!*p) {
2790             fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2791             exit(1);
2792         }
2793         if (!strcmp(*p, arg))
2794             break;
2795         p++;
2796     }
2797     me_method = (p - motion_str) + 1;
2798 }
2799
2800 static void opt_video_codec(const char *arg)
2801 {
2802     opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2803 }
2804
2805 static void opt_subtitle_codec(const char *arg)
2806 {
2807     opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2808 }
2809
2810 static void opt_map(const char *arg)
2811 {
2812     AVStreamMap *m;
2813     const char *p;
2814
2815     p = arg;
2816     m = &stream_maps[nb_stream_maps++];
2817
2818     m->file_index = strtol(arg, (char **)&p, 0);
2819     if (*p)
2820         p++;
2821
2822     m->stream_index = strtol(p, (char **)&p, 0);
2823     if (*p) {
2824         p++;
2825         m->sync_file_index = strtol(p, (char **)&p, 0);
2826         if (*p)
2827             p++;
2828         m->sync_stream_index = strtol(p, (char **)&p, 0);
2829     } else {
2830         m->sync_file_index = m->file_index;
2831         m->sync_stream_index = m->stream_index;
2832     }
2833 }
2834
2835 static void opt_map_meta_data(const char *arg)
2836 {
2837     AVMetaDataMap *m;
2838     const char *p;
2839
2840     p = arg;
2841     m = &meta_data_maps[nb_meta_data_maps++];
2842
2843     m->out_file = strtol(arg, (char **)&p, 0);
2844     if (*p)
2845         p++;
2846
2847     m->in_file = strtol(p, (char **)&p, 0);
2848 }
2849
2850 static void opt_recording_time(const char *arg)
2851 {
2852     recording_time = parse_date(arg, 1);
2853 }
2854
2855 static void opt_start_time(const char *arg)
2856 {
2857     start_time = parse_date(arg, 1);
2858 }
2859
2860 static void opt_rec_timestamp(const char *arg)
2861 {
2862     rec_timestamp = parse_date(arg, 0) / 1000000;
2863 }
2864
2865 static void opt_input_ts_offset(const char *arg)
2866 {
2867     input_ts_offset = parse_date(arg, 1);
2868 }
2869
2870 static void opt_input_file(const char *filename)
2871 {
2872     AVFormatContext *ic;
2873     AVFormatParameters params, *ap = &params;
2874     int err, i, ret, rfps, rfps_base;
2875     int64_t timestamp;
2876
2877     if (!strcmp(filename, "-"))
2878         filename = "pipe:";
2879
2880     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2881                    !strcmp( filename, "/dev/stdin" );
2882
2883     /* get default parameters from command line */
2884     memset(ap, 0, sizeof(*ap));
2885     ap->sample_rate = audio_sample_rate;
2886     ap->channels = audio_channels;
2887     ap->time_base.den = frame_rate;
2888     ap->time_base.num = frame_rate_base;
2889     ap->width = frame_width + frame_padleft + frame_padright;
2890     ap->height = frame_height + frame_padtop + frame_padbottom;
2891     ap->image_format = image_format;
2892     ap->pix_fmt = frame_pix_fmt;
2893     ap->device  = grab_device;
2894     ap->channel = video_channel;
2895     ap->standard = video_standard;
2896     ap->video_codec_id = video_codec_id;
2897     ap->audio_codec_id = audio_codec_id;
2898     if(pgmyuv_compatibility_hack)
2899         ap->video_codec_id= CODEC_ID_PGMYUV;
2900
2901     /* open the input file with generic libav function */
2902     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2903     if (err < 0) {
2904         print_error(filename, err);
2905         exit(1);
2906     }
2907
2908     if(genpts)
2909         ic->flags|= AVFMT_FLAG_GENPTS;
2910
2911     /* If not enough info to get the stream parameters, we decode the
2912        first frames to get it. (used in mpeg case for example) */
2913     ret = av_find_stream_info(ic);
2914     if (ret < 0 && verbose >= 0) {
2915         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2916         exit(1);
2917     }
2918
2919     timestamp = start_time;
2920     /* add the stream start time */
2921     if (ic->start_time != AV_NOPTS_VALUE)
2922         timestamp += ic->start_time;
2923
2924     /* if seeking requested, we execute it */
2925     if (start_time != 0) {
2926         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2927         if (ret < 0) {
2928             fprintf(stderr, "%s: could not seek to position %0.3f\n",
2929                     filename, (double)timestamp / AV_TIME_BASE);
2930         }
2931         /* reset seek info */
2932         start_time = 0;
2933     }
2934
2935     /* update the current parameters so that they match the one of the input stream */
2936     for(i=0;i<ic->nb_streams;i++) {
2937         int j;
2938         AVCodecContext *enc = ic->streams[i]->codec;
2939 #if defined(HAVE_THREADS)
2940         if(thread_count>1)
2941             avcodec_thread_init(enc, thread_count);
2942 #endif
2943         enc->thread_count= thread_count;
2944         switch(enc->codec_type) {
2945         case CODEC_TYPE_AUDIO:
2946             for(j=0; j<opt_name_count; j++){
2947                 AVOption *opt;
2948                 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2949                 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2950                     av_set_double(enc, opt_names[j], d);
2951             }
2952             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2953             audio_channels = enc->channels;
2954             audio_sample_rate = enc->sample_rate;
2955             if(audio_disable)
2956                 ic->streams[i]->discard= AVDISCARD_ALL;
2957             break;
2958         case CODEC_TYPE_VIDEO:
2959             for(j=0; j<opt_name_count; j++){
2960                 AVOption *opt;
2961                 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2962                 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2963                     av_set_double(enc, opt_names[j], d);
2964             }
2965             frame_height = enc->height;
2966             frame_width = enc->width;
2967             frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2968             frame_pix_fmt = enc->pix_fmt;
2969             rfps      = ic->streams[i]->r_frame_rate.num;
2970             rfps_base = ic->streams[i]->r_frame_rate.den;
2971             enc->workaround_bugs = workaround_bugs;
2972             if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2973             if(me_threshold)
2974                 enc->debug |= FF_DEBUG_MV;
2975
2976             if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2977
2978                 if (verbose >= 0)
2979                     fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2980                             i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2981
2982                     (float)rfps / rfps_base, rfps, rfps_base);
2983             }
2984             /* update the current frame rate to match the stream frame rate */
2985             frame_rate      = rfps;
2986             frame_rate_base = rfps_base;
2987
2988             enc->rate_emu = rate_emu;
2989             if(video_disable)
2990                 ic->streams[i]->discard= AVDISCARD_ALL;
2991             else if(video_discard)
2992                 ic->streams[i]->discard= video_discard;
2993             break;
2994         case CODEC_TYPE_DATA:
2995             break;
2996         case CODEC_TYPE_SUBTITLE:
2997             break;
2998         case CODEC_TYPE_UNKNOWN:
2999             break;
3000         default:
3001             av_abort();
3002         }
3003     }
3004
3005     input_files[nb_input_files] = ic;
3006     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3007     /* dump the file content */
3008     if (verbose >= 0)
3009         dump_format(ic, nb_input_files, filename, 0);
3010
3011     nb_input_files++;
3012     file_iformat = NULL;
3013     file_oformat = NULL;
3014     image_format = NULL;
3015
3016     grab_device = NULL;
3017     video_channel = 0;
3018
3019     rate_emu = 0;
3020 }
3021
3022 static void opt_grab(const char *arg)
3023 {
3024     file_iformat = av_find_input_format(arg);
3025     opt_input_file("");
3026 }
3027
3028 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
3029 {
3030     int has_video, has_audio, i, j;
3031     AVFormatContext *ic;
3032
3033     has_video = 0;
3034     has_audio = 0;
3035     for(j=0;j<nb_input_files;j++) {
3036         ic = input_files[j];
3037         for(i=0;i<ic->nb_streams;i++) {
3038             AVCodecContext *enc = ic->streams[i]->codec;
3039             switch(enc->codec_type) {
3040             case CODEC_TYPE_AUDIO:
3041                 has_audio = 1;
3042                 break;
3043             case CODEC_TYPE_VIDEO:
3044                 has_video = 1;
3045                 break;
3046             case CODEC_TYPE_DATA:
3047             case CODEC_TYPE_UNKNOWN:
3048             case CODEC_TYPE_SUBTITLE:
3049                 break;
3050             default:
3051                 av_abort();
3052             }
3053         }
3054     }
3055     *has_video_ptr = has_video;
3056     *has_audio_ptr = has_audio;
3057 }
3058
3059 static void new_video_stream(AVFormatContext *oc)
3060 {
3061     AVStream *st;
3062     AVCodecContext *video_enc;
3063     int codec_id;
3064
3065     st = av_new_stream(oc, oc->nb_streams);
3066     if (!st) {
3067         fprintf(stderr, "Could not alloc stream\n");
3068         exit(1);
3069     }
3070 #if defined(HAVE_THREADS)
3071     if(thread_count>1)
3072         avcodec_thread_init(st->codec, thread_count);
3073 #endif
3074
3075     video_enc = st->codec;
3076
3077     if(video_codec_tag)
3078         video_enc->codec_tag= video_codec_tag;
3079
3080     if(   (video_global_header&1)
3081        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3082         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3083         avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3084     }
3085     if(video_global_header&2){
3086         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3087         avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3088     }
3089
3090     if (video_stream_copy) {
3091         st->stream_copy = 1;
3092         video_enc->codec_type = CODEC_TYPE_VIDEO;
3093     } else {
3094         char *p;
3095         int i;
3096         AVCodec *codec;
3097
3098         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3099         if (video_codec_id != CODEC_ID_NONE)
3100             codec_id = video_codec_id;
3101
3102         video_enc->codec_id = codec_id;
3103         codec = avcodec_find_encoder(codec_id);
3104
3105         for(i=0; i<opt_name_count; i++){
3106              AVOption *opt;
3107              double d= av_get_double(avctx_opts, opt_names[i], &opt);
3108              if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3109                  av_set_double(video_enc, opt_names[i], d);
3110         }
3111
3112         video_enc->bit_rate = video_bit_rate;
3113         video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
3114         video_enc->time_base.den = frame_rate;
3115         video_enc->time_base.num = frame_rate_base;
3116         if(codec && codec->supported_framerates){
3117             const AVRational *p= codec->supported_framerates;
3118             AVRational req= (AVRational){frame_rate, frame_rate_base};
3119             const AVRational *best=NULL;
3120             AVRational best_error= (AVRational){INT_MAX, 1};
3121             for(; p->den!=0; p++){
3122                 AVRational error= av_sub_q(req, *p);
3123                 if(error.num <0) error.num *= -1;
3124                 if(av_cmp_q(error, best_error) < 0){
3125                     best_error= error;
3126                     best= p;
3127                 }
3128             }
3129             video_enc->time_base.den= best->num;
3130             video_enc->time_base.num= best->den;
3131         }
3132
3133         video_enc->width = frame_width + frame_padright + frame_padleft;
3134         video_enc->height = frame_height + frame_padtop + frame_padbottom;
3135         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3136         video_enc->pix_fmt = frame_pix_fmt;
3137
3138         if(codec && codec->pix_fmts){
3139             const enum PixelFormat *p= codec->pix_fmts;
3140             for(; *p!=-1; p++){
3141                 if(*p == video_enc->pix_fmt)
3142                     break;
3143             }
3144             if(*p == -1)
3145                 video_enc->pix_fmt = codec->pix_fmts[0];
3146         }
3147
3148         if (!intra_only)
3149             video_enc->gop_size = gop_size;
3150         else
3151             video_enc->gop_size = 0;
3152         if (video_qscale || same_quality) {
3153             video_enc->flags |= CODEC_FLAG_QSCALE;
3154             video_enc->global_quality=
3155                 st->quality = FF_QP2LAMBDA * video_qscale;
3156         }
3157
3158         if(intra_matrix)
3159             video_enc->intra_matrix = intra_matrix;
3160         if(inter_matrix)
3161             video_enc->inter_matrix = inter_matrix;
3162
3163         video_enc->pre_me = pre_me;
3164
3165         if (b_frames) {
3166             video_enc->max_b_frames = b_frames;
3167             video_enc->b_quant_factor = 2.0;
3168         }
3169         video_enc->qmin = video_qmin;
3170         video_enc->qmax = video_qmax;
3171         video_enc->lmin = video_lmin;
3172         video_enc->lmax = video_lmax;
3173         video_enc->rc_qsquish = video_qsquish;
3174         video_enc->mb_lmin = video_mb_lmin;
3175         video_enc->mb_lmax = video_mb_lmax;
3176         video_enc->max_qdiff = video_qdiff;
3177         video_enc->qblur = video_qblur;
3178         video_enc->qcompress = video_qcomp;
3179         video_enc->rc_eq = video_rc_eq;
3180         video_enc->workaround_bugs = workaround_bugs;
3181         video_enc->thread_count = thread_count;
3182         p= video_rc_override_string;
3183         for(i=0; p; i++){
3184             int start, end, q;
3185             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3186             if(e!=3){
3187                 fprintf(stderr, "error parsing rc_override\n");
3188                 exit(1);
3189             }
3190             video_enc->rc_override=
3191                 av_realloc(video_enc->rc_override,
3192                            sizeof(RcOverride)*(i+1));
3193             video_enc->rc_override[i].start_frame= start;
3194             video_enc->rc_override[i].end_frame  = end;
3195             if(q>0){
3196                 video_enc->rc_override[i].qscale= q;
3197                 video_enc->rc_override[i].quality_factor= 1.0;
3198             }
3199             else{
3200                 video_enc->rc_override[i].qscale= 0;
3201                 video_enc->rc_override[i].quality_factor= -q/100.0;
3202             }
3203             p= strchr(p, '/');
3204             if(p) p++;
3205         }
3206         video_enc->rc_override_count=i;
3207
3208         video_enc->rc_max_rate = video_rc_max_rate;
3209         video_enc->rc_min_rate = video_rc_min_rate;
3210         video_enc->rc_buffer_size = video_rc_buffer_size;
3211         video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3212         video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3213         video_enc->rc_initial_cplx= video_rc_initial_cplx;
3214         video_enc->i_quant_factor = video_i_qfactor;
3215         video_enc->b_quant_factor = video_b_qfactor;
3216         video_enc->i_quant_offset = video_i_qoffset;
3217         video_enc->b_quant_offset = video_b_qoffset;
3218         video_enc->intra_quant_bias = video_intra_quant_bias;
3219         video_enc->inter_quant_bias = video_inter_quant_bias;
3220         video_enc->me_threshold= me_threshold;
3221         video_enc->mb_threshold= mb_threshold;
3222         video_enc->intra_dc_precision= intra_dc_precision - 8;
3223         video_enc->strict_std_compliance = strict;
3224         video_enc->error_rate = error_rate;
3225         video_enc->scenechange_threshold= sc_threshold;
3226         video_enc->me_range = me_range;
3227         video_enc->me_penalty_compensation= me_penalty_compensation;
3228         video_enc->frame_skip_threshold= frame_skip_threshold;
3229         video_enc->frame_skip_factor= frame_skip_factor;
3230         video_enc->frame_skip_exp= frame_skip_exp;
3231
3232         if(packet_size){
3233             video_enc->rtp_mode= 1;
3234             video_enc->rtp_payload_size= packet_size;
3235         }
3236
3237         if (do_psnr)
3238             video_enc->flags|= CODEC_FLAG_PSNR;
3239
3240         video_enc->me_method = me_method;
3241
3242         /* two pass mode */
3243         if (do_pass) {
3244             if (do_pass == 1) {
3245                 video_enc->flags |= CODEC_FLAG_PASS1;
3246             } else {
3247                 video_enc->flags |= CODEC_FLAG_PASS2;
3248             }
3249         }
3250     }
3251
3252     /* reset some key parameters */
3253     video_disable = 0;
3254     video_codec_id = CODEC_ID_NONE;
3255     video_stream_copy = 0;
3256 }
3257
3258 static void new_audio_stream(AVFormatContext *oc)
3259 {
3260     AVStream *st;
3261     AVCodecContext *audio_enc;
3262     int codec_id, i;
3263
3264     st = av_new_stream(oc, oc->nb_streams);
3265     if (!st) {
3266         fprintf(stderr, "Could not alloc stream\n");
3267         exit(1);
3268     }
3269 #if defined(HAVE_THREADS)
3270     if(thread_count>1)
3271         avcodec_thread_init(st->codec, thread_count);
3272 #endif
3273
3274     audio_enc = st->codec;
3275     audio_enc->codec_type = CODEC_TYPE_AUDIO;
3276
3277     if(audio_codec_tag)
3278         audio_enc->codec_tag= audio_codec_tag;
3279
3280     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3281         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3282         avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3283     }
3284     if (audio_stream_copy) {
3285         st->stream_copy = 1;
3286         audio_enc->channels = audio_channels;
3287     } else {
3288         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3289
3290         for(i=0; i<opt_name_count; i++){
3291             AVOption *opt;
3292             double d= av_get_double(avctx_opts, opt_names[i], &opt);
3293             if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3294                 av_set_double(audio_enc, opt_names[i], d);
3295         }
3296
3297         if (audio_codec_id != CODEC_ID_NONE)
3298             codec_id = audio_codec_id;
3299         audio_enc->codec_id = codec_id;
3300
3301         audio_enc->bit_rate = audio_bit_rate;
3302         if (audio_qscale > QSCALE_NONE) {
3303             audio_enc->flags |= CODEC_FLAG_QSCALE;
3304             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3305         }
3306         audio_enc->strict_std_compliance = strict;
3307         audio_enc->thread_count = thread_count;
3308         /* For audio codecs other than AC3 or DTS we limit */
3309         /* the number of coded channels to stereo   */
3310         if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3311             && codec_id != CODEC_ID_DTS) {
3312             audio_enc->channels = 2;
3313         } else
3314             audio_enc->channels = audio_channels;
3315     }
3316     audio_enc->sample_rate = audio_sample_rate;
3317     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3318     if (audio_language) {
3319         pstrcpy(st->language, sizeof(st->language), audio_language);
3320         av_free(audio_language);
3321         audio_language = NULL;
3322     }
3323
3324     /* reset some key parameters */
3325     audio_disable = 0;
3326     audio_codec_id = CODEC_ID_NONE;
3327     audio_stream_copy = 0;
3328 }
3329
3330 static void opt_new_subtitle_stream(void)
3331 {
3332     AVFormatContext *oc;
3333     AVStream *st;
3334     AVCodecContext *subtitle_enc;
3335     int i;
3336
3337     if (nb_output_files <= 0) {
3338         fprintf(stderr, "At least one output file must be specified\n");
3339         exit(1);
3340     }
3341     oc = output_files[nb_output_files - 1];
3342
3343     st = av_new_stream(oc, oc->nb_streams);
3344     if (!st) {
3345         fprintf(stderr, "Could not alloc stream\n");
3346         exit(1);
3347     }
3348
3349     subtitle_enc = st->codec;
3350     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3351     if (subtitle_stream_copy) {
3352         st->stream_copy = 1;
3353     } else {
3354         for(i=0; i<opt_name_count; i++){
3355              AVOption *opt;
3356              double d= av_get_double(avctx_opts, opt_names[i], &opt);
3357              if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3358                  av_set_double(subtitle_enc, opt_names[i], d);
3359         }
3360         subtitle_enc->codec_id = subtitle_codec_id;
3361     }
3362
3363     if (subtitle_language) {
3364         pstrcpy(st->language, sizeof(st->language), subtitle_language);
3365         av_free(subtitle_language);
3366         subtitle_language = NULL;
3367     }
3368
3369     subtitle_codec_id = CODEC_ID_NONE;
3370     subtitle_stream_copy = 0;
3371 }
3372
3373 static void opt_new_audio_stream(void)
3374 {
3375     AVFormatContext *oc;
3376     if (nb_output_files <= 0) {
3377         fprintf(stderr, "At least one output file must be specified\n");
3378         exit(1);
3379     }
3380     oc = output_files[nb_output_files - 1];
3381     new_audio_stream(oc);
3382 }
3383
3384 static void opt_new_video_stream(void)
3385 {
3386     AVFormatContext *oc;
3387     if (nb_output_files <= 0) {
3388         fprintf(stderr, "At least one output file must be specified\n");
3389         exit(1);
3390     }
3391     oc = output_files[nb_output_files - 1];
3392     new_video_stream(oc);
3393 }
3394
3395 static void opt_output_file(const char *filename)
3396 {
3397     AVFormatContext *oc;
3398     int use_video, use_audio, input_has_video, input_has_audio;
3399     AVFormatParameters params, *ap = &params;
3400
3401     if (!strcmp(filename, "-"))
3402         filename = "pipe:";
3403
3404     oc = av_alloc_format_context();
3405
3406     if (!file_oformat) {
3407         file_oformat = guess_format(NULL, filename, NULL);
3408         if (!file_oformat) {
3409             fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3410                     filename);
3411             exit(1);
3412         }
3413     }
3414
3415     oc->oformat = file_oformat;
3416     pstrcpy(oc->filename, sizeof(oc->filename), filename);
3417
3418     if (!strcmp(file_oformat->name, "ffm") &&
3419         strstart(filename, "http:", NULL)) {
3420         /* special case for files sent to ffserver: we get the stream
3421            parameters from ffserver */
3422         if (read_ffserver_streams(oc, filename) < 0) {
3423             fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3424             exit(1);
3425         }
3426     } else {
3427         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3428         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3429
3430         /* disable if no corresponding type found and at least one
3431            input file */
3432         if (nb_input_files > 0) {
3433             check_audio_video_inputs(&input_has_video, &input_has_audio);
3434             if (!input_has_video)
3435                 use_video = 0;
3436             if (!input_has_audio)
3437                 use_audio = 0;
3438         }
3439
3440         /* manual disable */
3441         if (audio_disable) {
3442             use_audio = 0;
3443         }
3444         if (video_disable) {
3445             use_video = 0;
3446         }
3447
3448         if (use_video) {
3449             new_video_stream(oc);
3450         }
3451
3452         if (use_audio) {
3453             new_audio_stream(oc);
3454         }
3455
3456         if (!oc->nb_streams) {
3457             fprintf(stderr, "No audio or video streams available\n");
3458             exit(1);
3459         }
3460
3461         oc->timestamp = rec_timestamp;
3462
3463         if (str_title)
3464             pstrcpy(oc->title, sizeof(oc->title), str_title);
3465         if (str_author)
3466             pstrcpy(oc->author, sizeof(oc->author), str_author);
3467         if (str_copyright)
3468             pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3469         if (str_comment)
3470             pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3471     }
3472
3473     output_files[nb_output_files++] = oc;
3474
3475     /* check filename in case of an image number is expected */
3476     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3477         if (filename_number_test(oc->filename) < 0) {
3478             print_error(oc->filename, AVERROR_NUMEXPECTED);
3479             exit(1);
3480         }
3481     }
3482
3483     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3484         /* test if it already exists to avoid loosing precious files */
3485         if (!file_overwrite &&
3486             (strchr(filename, ':') == NULL ||
3487              strstart(filename, "file:", NULL))) {
3488             if (url_exist(filename)) {
3489                 int c;
3490
3491                 if ( !using_stdin ) {
3492                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3493                     fflush(stderr);
3494                     c = getchar();
3495                     if (toupper(c) != 'Y') {
3496                         fprintf(stderr, "Not overwriting - exiting\n");
3497                         exit(1);
3498                     }
3499                                 }
3500                                 else {
3501                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3502                     exit(1);
3503                                 }
3504             }
3505         }
3506
3507         /* open the file */
3508         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3509             fprintf(stderr, "Could not open '%s'\n", filename);
3510             exit(1);
3511         }
3512     }
3513
3514     memset(ap, 0, sizeof(*ap));
3515     ap->image_format = image_format;
3516     if (av_set_parameters(oc, ap) < 0) {
3517         fprintf(stderr, "%s: Invalid encoding parameters\n",
3518                 oc->filename);
3519         exit(1);
3520     }
3521
3522     oc->packet_size= mux_packet_size;
3523     oc->mux_rate= mux_rate;
3524     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3525     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3526     oc->loop_output = loop_output;
3527
3528     /* reset some options */
3529     file_oformat = NULL;
3530     file_iformat = NULL;
3531     image_format = NULL;
3532 }
3533
3534 /* prepare dummy protocols for grab */
3535 static void prepare_grab(void)
3536 {
3537     int has_video, has_audio, i, j;
3538     AVFormatContext *oc;
3539     AVFormatContext *ic;
3540     AVFormatParameters vp1, *vp = &vp1;
3541     AVFormatParameters ap1, *ap = &ap1;
3542
3543     /* see if audio/video inputs are needed */
3544     has_video = 0;
3545     has_audio = 0;
3546     memset(ap, 0, sizeof(*ap));
3547     memset(vp, 0, sizeof(*vp));
3548     vp->time_base.num= 1;
3549     for(j=0;j<nb_output_files;j++) {
3550         oc = output_files[j];
3551         for(i=0;i<oc->nb_streams;i++) {
3552             AVCodecContext *enc = oc->streams[i]->codec;
3553             switch(enc->codec_type) {
3554             case CODEC_TYPE_AUDIO:
3555                 if (enc->sample_rate > ap->sample_rate)
3556                     ap->sample_rate = enc->sample_rate;
3557                 if (enc->channels > ap->channels)
3558                     ap->channels = enc->channels;
3559                 has_audio = 1;
3560                 break;
3561             case CODEC_TYPE_VIDEO:
3562                 if (enc->width > vp->width)
3563                     vp->width = enc->width;
3564                 if (enc->height > vp->height)
3565                     vp->height = enc->height;
3566
3567                 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3568                     vp->time_base = enc->time_base;
3569                 }
3570                 has_video = 1;
3571                 break;
3572             default:
3573                 av_abort();
3574             }
3575         }
3576     }
3577
3578     if (has_video == 0 && has_audio == 0) {
3579         fprintf(stderr, "Output file must have at least one audio or video stream\n");
3580         exit(1);
3581     }
3582
3583     if (has_video) {
3584         AVInputFormat *fmt1;
3585         fmt1 = av_find_input_format(video_grab_format);
3586         vp->device  = video_device;
3587         vp->channel = video_channel;
3588         vp->standard = video_standard;
3589         vp->pix_fmt = frame_pix_fmt;
3590         if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3591             fprintf(stderr, "Could not find video grab device\n");
3592             exit(1);
3593         }
3594         /* If not enough info to get the stream parameters, we decode the
3595            first frames to get it. */
3596         if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3597             fprintf(stderr, "Could not find video grab parameters\n");
3598             exit(1);
3599         }
3600         /* by now video grab has one stream */
3601         ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3602         ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3603         input_files[nb_input_files] = ic;
3604
3605         if (verbose >= 0)
3606             dump_format(ic, nb_input_files, "", 0);
3607
3608         nb_input_files++;
3609     }
3610     if (has_audio && audio_grab_format) {
3611         AVInputFormat *fmt1;
3612         fmt1 = av_find_input_format(audio_grab_format);
3613         ap->device = audio_device;
3614         if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3615             fprintf(stderr, "Could not find audio grab device\n");
3616             exit(1);
3617         }
3618         input_files[nb_input_files] = ic;
3619
3620         if (verbose >= 0)
3621             dump_format(ic, nb_input_files, "", 0);
3622
3623         nb_input_files++;
3624     }
3625 }
3626
3627 /* same option as mencoder */
3628 static void opt_pass(const char *pass_str)
3629 {
3630     int pass;
3631     pass = atoi(pass_str);
3632     if (pass != 1 && pass != 2) {
3633         fprintf(stderr, "pass number can be only 1 or 2\n");
3634         exit(1);
3635     }
3636     do_pass = pass;
3637 }
3638
3639 #if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3640 static int64_t getutime(void)
3641 {
3642   return av_gettime();
3643 }
3644 #else
3645 static int64_t getutime(void)
3646 {
3647     struct rusage rusage;
3648
3649     getrusage(RUSAGE_SELF, &rusage);
3650     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3651 }
3652 #endif
3653
3654 extern int ffm_nopts;
3655
3656 static void show_formats(void)
3657 {
3658     AVInputFormat *ifmt;
3659     AVOutputFormat *ofmt;
3660     AVImageFormat *image_fmt;
3661     URLProtocol *up;
3662     AVCodec *p, *p2;
3663     const char **pp, *last_name;
3664
3665     printf("File formats:\n");
3666     last_name= "000";
3667     for(;;){
3668         int decode=0;
3669         int encode=0;
3670         const char *name=NULL;
3671         const char *long_name=NULL;
3672
3673         for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3674             if((name == NULL || strcmp(ofmt->name, name)<0) &&
3675                 strcmp(ofmt->name, last_name)>0){
3676                 name= ofmt->name;
3677                 long_name= ofmt->long_name;
3678                 encode=1;
3679             }
3680         }
3681         for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3682             if((name == NULL || strcmp(ifmt->name, name)<0) &&
3683                 strcmp(ifmt->name, last_name)>0){
3684                 name= ifmt->name;
3685                 long_name= ifmt->long_name;
3686                 encode=0;
3687             }
3688             if(name && strcmp(ifmt->name, name)==0)
3689                 decode=1;
3690         }
3691         if(name==NULL)
3692             break;
3693         last_name= name;
3694
3695         printf(
3696             " %s%s %-15s %s\n",
3697             decode ? "D":" ",
3698             encode ? "E":" ",
3699             name,
3700             long_name ? long_name:" ");
3701     }
3702     printf("\n");
3703
3704     printf("Image formats (filename extensions, if any, follow):\n");
3705     for(image_fmt = first_image_format; image_fmt != NULL;
3706         image_fmt = image_fmt->next) {
3707         printf(
3708             " %s%s %-6s %s\n",
3709             image_fmt->img_read  ? "D":" ",
3710             image_fmt->img_write ? "E":" ",
3711             image_fmt->name,
3712             image_fmt->extensions ? image_fmt->extensions:" ");
3713     }
3714     printf("\n");
3715
3716     printf("Codecs:\n");
3717     last_name= "000";
3718     for(;;){
3719         int decode=0;
3720         int encode=0;
3721         int cap=0;
3722         const char *type_str;
3723
3724         p2=NULL;
3725         for(p = first_avcodec; p != NULL; p = p->next) {
3726             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3727                 strcmp(p->name, last_name)>0){
3728                 p2= p;
3729                 decode= encode= cap=0;
3730             }
3731             if(p2 && strcmp(p->name, p2->name)==0){
3732                 if(p->decode) decode=1;
3733                 if(p->encode) encode=1;
3734                 cap |= p->capabilities;
3735             }
3736         }
3737         if(p2==NULL)
3738             break;
3739         last_name= p2->name;
3740
3741         switch(p2->type) {
3742         case CODEC_TYPE_VIDEO:
3743             type_str = "V";
3744             break;
3745         case CODEC_TYPE_AUDIO:
3746             type_str = "A";
3747             break;
3748         case CODEC_TYPE_SUBTITLE:
3749             type_str = "S";
3750             break;
3751         default:
3752             type_str = "?";
3753             break;
3754         }
3755         printf(
3756             " %s%s%s%s%s%s %s",
3757             decode ? "D": (/*p2->decoder ? "d":*/" "),
3758             encode ? "E":" ",
3759             type_str,
3760             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3761             cap & CODEC_CAP_DR1 ? "D":" ",
3762             cap & CODEC_CAP_TRUNCATED ? "T":" ",
3763             p2->name);
3764        /* if(p2->decoder && decode==0)
3765             printf(" use %s for decoding", p2->decoder->name);*/
3766         printf("\n");
3767     }
3768     printf("\n");
3769
3770     printf("Supported file protocols:\n");
3771     for(up = first_protocol; up != NULL; up = up->next)
3772         printf(" %s:", up->name);
3773     printf("\n");
3774
3775     printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3776     printf("Motion estimation methods:\n");
3777     pp = motion_str;
3778     while (*pp) {
3779         printf(" %s", *pp);
3780         if ((pp - motion_str + 1) == ME_ZERO)
3781             printf("(fastest)");
3782         else if ((pp - motion_str + 1) == ME_FULL)
3783             printf("(slowest)");
3784         else if ((pp - motion_str + 1) == ME_EPZS)
3785             printf("(default)");
3786         pp++;
3787     }
3788     printf("\n\n");
3789     printf(
3790 "Note, the names of encoders and decoders dont always match, so there are\n"
3791 "several cases where the above table shows encoder only or decoder only entries\n"
3792 "even though both encoding and decoding are supported for example, the h263\n"
3793 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3794 "worse\n");
3795     exit(1);
3796 }
3797
3798 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3799 {
3800     int i;
3801     const char *p = str;
3802     for(i = 0;; i++) {
3803         dest[i] = atoi(p);
3804         if(i == 63)
3805             break;
3806         p = strchr(p, ',');
3807         if(!p) {
3808             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3809             exit(1);
3810         }
3811         p++;
3812     }
3813 }
3814
3815 static void opt_inter_matrix(const char *arg)
3816 {
3817     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3818     parse_matrix_coeffs(inter_matrix, arg);
3819 }
3820
3821 static void opt_intra_matrix(const char *arg)
3822 {
3823     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3824     parse_matrix_coeffs(intra_matrix, arg);
3825 }
3826
3827 static void opt_target(const char *arg)
3828 {
3829     int norm = -1;
3830     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3831
3832     if(!strncmp(arg, "pal-", 4)) {
3833         norm = 0;
3834         arg += 4;
3835     } else if(!strncmp(arg, "ntsc-", 5)) {
3836         norm = 1;
3837         arg += 5;
3838     } else if(!strncmp(arg, "film-", 5)) {
3839         norm = 2;
3840         arg += 5;
3841     } else {
3842         int fr;
3843         /* Calculate FR via float to avoid int overflow */
3844         fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3845         if(fr == 25000) {
3846             norm = 0;
3847         } else if((fr == 29970) || (fr == 23976)) {
3848             norm = 1;
3849         } else {
3850             /* Try to determine PAL/NTSC by peeking in the input files */
3851             if(nb_input_files) {
3852                 int i, j;
3853                 for(j = 0; j < nb_input_files; j++) {
3854                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3855                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3856                         if(c->codec_type != CODEC_TYPE_VIDEO)
3857                             continue;
3858                         fr = c->time_base.den * 1000 / c->time_base.num;
3859                         if(fr == 25000) {
3860                             norm = 0;
3861                             break;
3862                         } else if((fr == 29970) || (fr == 23976)) {
3863                             norm = 1;
3864                             break;
3865                         }
3866                     }
3867                     if(norm >= 0)
3868                         break;
3869                 }
3870             }
3871         }
3872         if(verbose && norm >= 0)
3873             fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3874     }
3875
3876     if(norm < 0) {
3877         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3878         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3879         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3880         exit(1);
3881     }
3882
3883     if(!strcmp(arg, "vcd")) {
3884
3885         opt_video_codec("mpeg1video");
3886         opt_audio_codec("mp2");
3887         opt_format("vcd");
3888
3889         opt_frame_size(norm ? "352x240" : "352x288");
3890         opt_frame_rate(frame_rates[norm]);
3891         opt_gop_size(norm ? "18" : "15");
3892
3893         video_bit_rate = 1150000;
3894         video_rc_max_rate = 1150000;
3895         video_rc_min_rate = 1150000;
3896         video_rc_buffer_size = 40*1024*8;
3897
3898         audio_bit_rate = 224000;
3899         audio_sample_rate = 44100;
3900
3901         mux_packet_size= 2324;
3902         mux_rate= 2352 * 75 * 8;
3903
3904         /* We have to offset the PTS, so that it is consistent with the SCR.
3905            SCR starts at 36000, but the first two packs contain only padding
3906            and the first pack from the other stream, respectively, may also have
3907            been written before.
3908            So the real data starts at SCR 36000+3*1200. */
3909         mux_preload= (36000+3*1200) / 90000.0; //0.44
3910     } else if(!strcmp(arg, "svcd")) {
3911
3912         opt_video_codec("mpeg2video");
3913         opt_audio_codec("mp2");
3914         opt_format("svcd");
3915
3916         opt_frame_size(norm ? "480x480" : "480x576");
3917         opt_frame_rate(frame_rates[norm]);
3918         opt_gop_size(norm ? "18" : "15");
3919
3920         video_bit_rate = 2040000;
3921         video_rc_max_rate = 2516000;
3922         video_rc_min_rate = 0; //1145000;
3923         video_rc_buffer_size = 224*1024*8;
3924         opt_default("flags", "+SCAN_OFFSET");
3925
3926
3927         audio_bit_rate = 224000;
3928         audio_sample_rate = 44100;
3929
3930         mux_packet_size= 2324;
3931
3932     } else if(!strcmp(arg, "dvd")) {
3933
3934         opt_video_codec("mpeg2video");
3935         opt_audio_codec("ac3");
3936         opt_format("dvd");
3937
3938         opt_frame_size(norm ? "720x480" : "720x576");
3939         opt_frame_rate(frame_rates[norm]);
3940         opt_gop_size(norm ? "18" : "15");
3941
3942         video_bit_rate = 6000000;
3943         video_rc_max_rate = 9000000;
3944         video_rc_min_rate = 0; //1500000;
3945         video_rc_buffer_size = 224*1024*8;
3946
3947         mux_packet_size= 2048;  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3948         mux_rate = 10080000;    // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3949
3950         audio_bit_rate = 448000;
3951         audio_sample_rate = 48000;
3952
3953     } else if(!strcmp(arg, "dv")) {
3954
3955         opt_format("dv");
3956
3957         opt_frame_size(norm ? "720x480" : "720x576");
3958         opt_frame_rate(frame_rates[norm]);
3959
3960         audio_sample_rate = 48000;
3961         audio_channels = 2;
3962
3963     } else {
3964         fprintf(stderr, "Unknown target: %s\n", arg);
3965         exit(1);
3966     }
3967 }
3968
3969 static void show_version(void)
3970 {
3971     /* TODO: add function interface to avutil and avformat */
3972     fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3973            "libavutil   %d\n"
3974            "libavcodec  %d\n"
3975            "libavformat %d\n",
3976            LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3977     exit(1);
3978 }
3979
3980 static int opt_default(const char *opt, const char *arg){
3981     AVOption *o= av_set_string(avctx_opts, opt, arg);
3982     if(!o)
3983         return -1;
3984
3985 //    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));
3986
3987     //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3988     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3989     opt_names[opt_name_count++]= o->name;
3990
3991     /* disable generate of real time pts in ffm (need to be supressed anyway) */
3992     if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3993         ffm_nopts = 1;
3994
3995     if(avctx_opts->debug)
3996         av_log_set_level(AV_LOG_DEBUG);
3997     return 0;
3998 }
3999
4000 const OptionDef options[] = {
4001     /* main options */
4002     { "L", 0, {(void*)show_license}, "show license" },
4003     { "h", 0, {(void*)show_help}, "show help" },
4004     { "version", 0, {(void*)show_version}, "show version" },
4005     { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
4006     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4007     { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
4008     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4009     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4010     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4011     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
4012     { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
4013     { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
4014     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4015     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4016     { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
4017     { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
4018     { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
4019     { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
4020     { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
4021     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4022       "add timings for benchmarking" },
4023     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4024       "dump each input packet" },
4025     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4026       "when dumping packets, also dump the payload" },
4027     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4028     { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4029     { "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)", "" },
4030     { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
4031     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4032     { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4033     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4034     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4035     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4036     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4037     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4038
4039     /* video options */
4040     { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
4041     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4042     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4043     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
4044     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4045     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4046     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4047     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
4048     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
4049     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
4050     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
4051     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
4052     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
4053     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
4054     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
4055     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
4056     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
4057     { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
4058     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4059     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4060     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4061     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
4062     { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
4063     { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
4064     { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
4065     { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
4066     { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
4067     { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "max macroblock quantiser scale (VBR)", "q" },
4068     { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
4069     { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
4070     { "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" },
4071     { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
4072     { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
4073     { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
4074     { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
4075     { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
4076     { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
4077     { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
4078     { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
4079     { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
4080     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4081     { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
4082     { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
4083     { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
4084     { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
4085     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4086     { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
4087       "method" },
4088     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
4089     { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold",  "" },
4090     { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
4091     { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
4092     { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
4093     { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
4094     { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
4095     { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
4096     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4097       "use same video quality as source (implies VBR)" },
4098     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4099     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
4100     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4101       "deinterlace pictures" },
4102     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4103     { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
4104     { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
4105     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4106     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4107     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4108     { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
4109     { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
4110     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4111     { "mepc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&me_penalty_compensation}, "motion estimation bitrate penalty compensation", "factor (1.0 = 256)" },
4112     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4113     { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
4114     { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
4115     { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
4116     { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
4117     { "genpts", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&genpts }, "generate pts" },
4118     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4119
4120     /* audio options */
4121     { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
4122     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4123     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4124     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4125     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4126     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4127     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4128     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4129     { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
4130     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4131
4132     /* subtitle options */
4133     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4134     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
4135     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4136
4137     /* grab options */
4138     { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
4139     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4140     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4141     { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
4142
4143     /* G.2 grab options */
4144     { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
4145     { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
4146
4147     /* muxer options */
4148     { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
4149     { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
4150     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4151     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4152     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4153     { NULL, },
4154 };
4155
4156 static void show_banner(void)
4157 {
4158     fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2004 Fabrice Bellard\n");
4159     fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
4160     fprintf(stderr, "  libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
4161     fprintf(stderr, "  libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
4162     fprintf(stderr, "  libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
4163     fprintf(stderr, "  built on " __DATE__ " " __TIME__);
4164 #ifdef __GNUC__
4165     fprintf(stderr, ", gcc: " __VERSION__ "\n");
4166 #else
4167     fprintf(stderr, ", using a non-gcc compiler\n");
4168 #endif
4169 }
4170
4171 static void show_license(void)
4172 {
4173     show_banner();
4174 #ifdef CONFIG_GPL
4175     printf(
4176     "This program is free software; you can redistribute it and/or modify\n"
4177     "it under the terms of the GNU General Public License as published by\n"
4178     "the Free Software Foundation; either version 2 of the License, or\n"
4179     "(at your option) any later version.\n"
4180     "\n"
4181     "This program is distributed in the hope that it will be useful,\n"
4182     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4183     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
4184     "GNU General Public License for more details.\n"
4185     "\n"
4186     "You should have received a copy of the GNU General Public License\n"
4187     "along with this program; if not, write to the Free Software\n"
4188     "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
4189     );
4190 #else
4191     printf(
4192     "This library is free software; you can redistribute it and/or\n"
4193     "modify it under the terms of the GNU Lesser General Public\n"
4194     "License as published by the Free Software Foundation; either\n"
4195     "version 2 of the License, or (at your option) any later version.\n"
4196     "\n"
4197     "This library is distributed in the hope that it will be useful,\n"
4198     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4199     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
4200     "Lesser General Public License for more details.\n"
4201     "\n"
4202     "You should have received a copy of the GNU Lesser General Public\n"
4203     "License along with this library; if not, write to the Free Software\n"
4204     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
4205     );
4206 #endif
4207     exit(1);
4208 }
4209
4210 static void show_help(void)
4211 {
4212     show_banner();
4213     printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4214            "Hyper fast Audio and Video encoder\n");
4215     printf("\n");
4216     show_help_options(options, "Main options:\n",
4217                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4218     show_help_options(options, "\nVideo options:\n",
4219                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4220                       OPT_VIDEO);
4221     show_help_options(options, "\nAdvanced Video options:\n",
4222                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4223                       OPT_VIDEO | OPT_EXPERT);
4224     show_help_options(options, "\nAudio options:\n",
4225                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4226                       OPT_AUDIO);
4227     show_help_options(options, "\nAdvanced Audio options:\n",
4228                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4229                       OPT_AUDIO | OPT_EXPERT);
4230     show_help_options(options, "\nSubtitle options:\n",
4231                       OPT_SUBTITLE | OPT_GRAB,
4232                       OPT_SUBTITLE);
4233     show_help_options(options, "\nAudio/Video grab options:\n",
4234                       OPT_GRAB,
4235                       OPT_GRAB);
4236     show_help_options(options, "\nAdvanced options:\n",
4237                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4238                       OPT_EXPERT);
4239     av_opt_show(avctx_opts, NULL);
4240
4241     exit(1);
4242 }
4243
4244 void parse_arg_file(const char *filename)
4245 {
4246     opt_output_file(filename);
4247 }
4248
4249 int main(int argc, char **argv)
4250 {
4251     int i;
4252     int64_t ti;
4253
4254     av_register_all();
4255
4256     avctx_opts= avcodec_alloc_context();
4257
4258     if (argc <= 1)
4259         show_help();
4260     else
4261         show_banner();
4262
4263     /* parse options */
4264     parse_options(argc, argv, options);
4265
4266     /* file converter / grab */
4267     if (nb_output_files <= 0) {
4268         fprintf(stderr, "Must supply at least one output file\n");
4269         exit(1);
4270     }
4271
4272     if (nb_input_files == 0) {
4273         input_sync = 1;
4274         prepare_grab();
4275     }
4276
4277     ti = getutime();
4278     av_encode(output_files, nb_output_files, input_files, nb_input_files,
4279               stream_maps, nb_stream_maps);
4280     ti = getutime() - ti;
4281     if (do_benchmark) {
4282         printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4283     }
4284
4285     /* close files */
4286     for(i=0;i<nb_output_files;i++) {
4287         /* maybe av_close_output_file ??? */
4288         AVFormatContext *s = output_files[i];
4289         int j;
4290         if (!(s->oformat->flags & AVFMT_NOFILE))
4291             url_fclose(&s->pb);
4292         for(j=0;j<s->nb_streams;j++)
4293             av_free(s->streams[j]);
4294         av_free(s);
4295     }
4296     for(i=0;i<nb_input_files;i++)
4297         av_close_input_file(input_files[i]);
4298
4299     av_free_static();
4300
4301     if(intra_matrix)
4302         av_free(intra_matrix);
4303     if(inter_matrix)
4304         av_free(inter_matrix);
4305
4306 #ifdef POWERPC_PERFORMANCE_REPORT
4307     extern void powerpc_display_perf_report(void);
4308     powerpc_display_perf_report();
4309 #endif /* POWERPC_PERFORMANCE_REPORT */
4310
4311 #ifndef CONFIG_WIN32
4312     if (received_sigterm) {
4313         fprintf(stderr,
4314             "Received signal %d: terminating.\n",
4315             (int) received_sigterm);
4316         exit (255);
4317     }
4318 #endif
4319     exit(0); /* not all OS-es handle main() return value */
4320     return 0;
4321 }