git.sesse.net Git - ffmpeg/blob - ffmpeg.c

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