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