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

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