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