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