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