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