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