ffmpeg.c

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