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