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 #include "config.h"
  23 #include <ctype.h>
  24 #include <string.h>
  25 #include <math.h>
  26 #include <stdlib.h>
  27 #include <errno.h>
  28 #include <signal.h>
  29 #include <limits.h>
  30 #include <unistd.h>
  31 #include "libavformat/avformat.h"
  32 #include "libavdevice/avdevice.h"
  33 #include "libswscale/swscale.h"
  34 #include "libavutil/opt.h"
  35 #include "libavcodec/audioconvert.h"
  36 #include "libavutil/audioconvert.h"
  37 #include "libavutil/parseutils.h"
  38 #include "libavutil/samplefmt.h"
  39 #include "libavutil/colorspace.h"
  40 #include "libavutil/fifo.h"
  41 #include "libavutil/intreadwrite.h"
  42 #include "libavutil/dict.h"
  43 #include "libavutil/mathematics.h"
  44 #include "libavutil/pixdesc.h"
  45 #include "libavutil/avstring.h"
  46 #include "libavutil/libm.h"
  47 #include "libavformat/os_support.h"
  48 #include "libswresample/swresample.h"
  49
  50 #include "libavformat/ffm.h" // not public API
  51
  52 #if CONFIG_AVFILTER
  53 # include "libavfilter/avcodec.h"
  54 # include "libavfilter/avfilter.h"
  55 # include "libavfilter/avfiltergraph.h"
  56 # include "libavfilter/buffersink.h"
  57 # include "libavfilter/vsrc_buffer.h"
  58 #endif
  59
  60 #if HAVE_SYS_RESOURCE_H
  61 #include <sys/types.h>
  62 #include <sys/time.h>
  63 #include <sys/resource.h>
  64 #elif HAVE_GETPROCESSTIMES
  65 #include <windows.h>
  66 #endif
  67 #if HAVE_GETPROCESSMEMORYINFO
  68 #include <windows.h>
  69 #include <psapi.h>
  70 #endif
  71
  72 #if HAVE_SYS_SELECT_H
  73 #include <sys/select.h>
  74 #endif
  75
  76 #if HAVE_TERMIOS_H
  77 #include <fcntl.h>
  78 #include <sys/ioctl.h>
  79 #include <sys/time.h>
  80 #include <termios.h>
  81 #elif HAVE_KBHIT
  82 #include <conio.h>
  83 #endif
  84 #include <time.h>
  85
  86 #include "cmdutils.h"
  87
  88 #include "libavutil/avassert.h"
  89
  90 const char program_name[] = "ffmpeg";
  91 const int program_birth_year = 2000;
  92
  93 /* select an input stream for an output stream */
  94 typedef struct StreamMap {
  95     int disabled;           /** 1 is this mapping is disabled by a negative map */
  96     int file_index;
  97     int stream_index;
  98     int sync_file_index;
  99     int sync_stream_index;
 100 } StreamMap;
 101
 102 typedef struct {
 103     int  file_idx,  stream_idx,  channel_idx; // input
 104     int ofile_idx, ostream_idx;               // output
 105 } AudioChannelMap;
 106
 107 /**
 108  * select an input file for an output file
 109  */
 110 typedef struct MetadataMap {
 111     int  file;      ///< file index
 112     char type;      ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
 113     int  index;     ///< stream/chapter/program number
 114 } MetadataMap;
 115
 116 static const OptionDef options[];
 117
 118 #define MAX_STREAMS 1024    /* arbitrary sanity check value */
 119
 120 static int frame_bits_per_raw_sample = 0;
 121 static int video_discard = 0;
 122 static int same_quant = 0;
 123 static int do_deinterlace = 0;
 124 static int intra_dc_precision = 8;
 125 static int loop_input = 0;
 126 static int loop_output = AVFMT_NOOUTPUTLOOP;
 127 static int qp_hist = 0;
 128 static int intra_only = 0;
 129 static const char *video_codec_name    = NULL;
 130 static const char *audio_codec_name    = NULL;
 131 static const char *subtitle_codec_name = NULL;
 132
 133 static int file_overwrite = 0;
 134 static int do_benchmark = 0;
 135 static int do_hex_dump = 0;
 136 static int do_pkt_dump = 0;
 137 static int do_psnr = 0;
 138 static int do_pass = 0;
 139 static const char *pass_logfilename_prefix;
 140 static int video_sync_method= -1;
 141 static int audio_sync_method= 0;
 142 static float audio_drift_threshold= 0.1;
 143 static int copy_ts= 0;
 144 static int copy_tb= 0;
 145 static int opt_shortest = 0;
 146 static char *vstats_filename;
 147 static FILE *vstats_file;
 148
 149 static int audio_volume = 256;
 150
 151 static int exit_on_error = 0;
 152 static int using_stdin = 0;
 153 static int run_as_daemon  = 0;
 154 static volatile int received_nb_signals = 0;
 155 static int64_t video_size = 0;
 156 static int64_t audio_size = 0;
 157 static int64_t extra_size = 0;
 158 static int nb_frames_dup = 0;
 159 static int nb_frames_drop = 0;
 160 static int input_sync;
 161
 162 static float dts_delta_threshold = 10;
 163
 164 static int print_stats = 1;
 165
 166 static uint8_t *audio_buf;
 167 static uint8_t *audio_out;
 168 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
 169
 170 static void *samples;
 171 static uint8_t *input_tmp= NULL;
 172
 173 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
 174
 175 typedef struct InputStream {
 176     int file_index;
 177     AVStream *st;
 178     int discard;             /* true if stream data should be discarded */
 179     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
 180     AVCodec *dec;
 181
 182     int64_t       start;     /* time when read started */
 183     int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
 184                                 is not defined */
 185     int64_t       pts;       /* current pts */
 186     double ts_scale;
 187     int is_start;            /* is 1 at the start and after a discontinuity */
 188     int showed_multi_packet_warning;
 189     AVDictionary *opts;
 190 } InputStream;
 191
 192 typedef struct InputFile {
 193     AVFormatContext *ctx;
 194     int eof_reached;      /* true if eof reached */
 195     int ist_index;        /* index of first stream in input_streams */
 196     int buffer_size;      /* current total buffer size */
 197     int64_t ts_offset;
 198     int nb_streams;       /* number of stream that ffmpeg is aware of; may be different
 199                              from ctx.nb_streams if new streams appear during av_read_frame() */
 200     int rate_emu;
 201 } InputFile;
 202
 203 typedef struct OutputStream {
 204     int file_index;          /* file index */
 205     int index;               /* stream index in the output file */
 206     int source_index;        /* InputStream index */
 207     AVStream *st;            /* stream in the output file */
 208     int encoding_needed;     /* true if encoding needed for this stream */
 209     int frame_number;
 210     /* input pts and corresponding output pts
 211        for A/V sync */
 212     //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
 213     struct InputStream *sync_ist; /* input stream to sync against */
 214     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
 215     AVBitStreamFilterContext *bitstream_filters;
 216     AVCodec *enc;
 217     int64_t max_frames;
 218
 219     /* video only */
 220     int video_resample;
 221     AVFrame resample_frame;              /* temporary frame for image resampling */
 222     struct SwsContext *img_resample_ctx; /* for image resampling */
 223     int resample_height;
 224     int resample_width;
 225     int resample_pix_fmt;
 226     AVRational frame_rate;
 227     int force_fps;
 228     int top_field_first;
 229
 230     float frame_aspect_ratio;
 231
 232     /* forced key frames */
 233     int64_t *forced_kf_pts;
 234     int forced_kf_count;
 235     int forced_kf_index;
 236
 237     /* audio only */
 238     int audio_resample;
 239     int audio_channels_map[SWR_CH_MAX];  ///< list of the channels id to pick from the source stream
 240     int audio_channels_mapped;           ///< number of channels in audio_channels_map
 241     int resample_sample_fmt;
 242     int resample_channels;
 243     int resample_sample_rate;
 244     float rematrix_volume;
 245     AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
 246     FILE *logfile;
 247
 248     struct SwrContext *swr;
 249
 250 #if CONFIG_AVFILTER
 251     AVFilterContext *output_video_filter;
 252     AVFilterContext *input_video_filter;
 253     AVFilterBufferRef *picref;
 254     char *avfilter;
 255     AVFilterGraph *graph;
 256 #endif
 257
 258     int64_t sws_flags;
 259     AVDictionary *opts;
 260     int is_past_recording_time;
 261     int stream_copy;
 262     const char *attachment_filename;
 263     int copy_initial_nonkeyframes;
 264 } OutputStream;
 265
 266
 267 #if HAVE_TERMIOS_H
 268
 269 /* init terminal so that we can grab keys */
 270 static struct termios oldtty;
 271 #endif
 272
 273 typedef struct OutputFile {
 274     AVFormatContext *ctx;
 275     AVDictionary *opts;
 276     int ost_index;       /* index of the first stream in output_streams */
 277     int64_t recording_time; /* desired length of the resulting file in microseconds */
 278     int64_t start_time;     /* start time in microseconds */
 279     uint64_t limit_filesize;
 280 } OutputFile;
 281
 282 static InputStream *input_streams = NULL;
 283 static int         nb_input_streams = 0;
 284 static InputFile   *input_files   = NULL;
 285 static int         nb_input_files   = 0;
 286
 287 static OutputStream *output_streams = NULL;
 288 static int        nb_output_streams = 0;
 289 static OutputFile   *output_files   = NULL;
 290 static int        nb_output_files   = 0;
 291
 292 typedef struct OptionsContext {
 293     /* input/output options */
 294     int64_t start_time;
 295     const char *format;
 296
 297     SpecifierOpt *codec_names;
 298     int        nb_codec_names;
 299     SpecifierOpt *audio_channels;
 300     int        nb_audio_channels;
 301     SpecifierOpt *audio_sample_rate;
 302     int        nb_audio_sample_rate;
 303     SpecifierOpt *rematrix_volume;
 304     int        nb_rematrix_volume;
 305     SpecifierOpt *frame_rates;
 306     int        nb_frame_rates;
 307     SpecifierOpt *frame_sizes;
 308     int        nb_frame_sizes;
 309     SpecifierOpt *frame_pix_fmts;
 310     int        nb_frame_pix_fmts;
 311
 312     /* input options */
 313     int64_t input_ts_offset;
 314     int rate_emu;
 315
 316     SpecifierOpt *ts_scale;
 317     int        nb_ts_scale;
 318     SpecifierOpt *dump_attachment;
 319     int        nb_dump_attachment;
 320
 321     /* output options */
 322     StreamMap *stream_maps;
 323     int     nb_stream_maps;
 324     AudioChannelMap *audio_channel_maps; ///< one info entry per -map_channel
 325     int           nb_audio_channel_maps; ///< number of (valid) -map_channel settings
 326     /* first item specifies output metadata, second is input */
 327     MetadataMap (*meta_data_maps)[2];
 328     int nb_meta_data_maps;
 329     int metadata_global_manual;
 330     int metadata_streams_manual;
 331     int metadata_chapters_manual;
 332     const char **attachments;
 333     int       nb_attachments;
 334
 335     int chapters_input_file;
 336
 337     int64_t recording_time;
 338     uint64_t limit_filesize;
 339     float mux_preload;
 340     float mux_max_delay;
 341
 342     int video_disable;
 343     int audio_disable;
 344     int subtitle_disable;
 345     int data_disable;
 346
 347     /* indexed by output file stream index */
 348     int   *streamid_map;
 349     int nb_streamid_map;
 350
 351     SpecifierOpt *metadata;
 352     int        nb_metadata;
 353     SpecifierOpt *max_frames;
 354     int        nb_max_frames;
 355     SpecifierOpt *bitstream_filters;
 356     int        nb_bitstream_filters;
 357     SpecifierOpt *codec_tags;
 358     int        nb_codec_tags;
 359     SpecifierOpt *sample_fmts;
 360     int        nb_sample_fmts;
 361     SpecifierOpt *qscale;
 362     int        nb_qscale;
 363     SpecifierOpt *forced_key_frames;
 364     int        nb_forced_key_frames;
 365     SpecifierOpt *force_fps;
 366     int        nb_force_fps;
 367     SpecifierOpt *frame_aspect_ratios;
 368     int        nb_frame_aspect_ratios;
 369     SpecifierOpt *rc_overrides;
 370     int        nb_rc_overrides;
 371     SpecifierOpt *intra_matrices;
 372     int        nb_intra_matrices;
 373     SpecifierOpt *inter_matrices;
 374     int        nb_inter_matrices;
 375     SpecifierOpt *top_field_first;
 376     int        nb_top_field_first;
 377     SpecifierOpt *presets;
 378     int        nb_presets;
 379     SpecifierOpt *copy_initial_nonkeyframes;
 380     int        nb_copy_initial_nonkeyframes;
 381 #if CONFIG_AVFILTER
 382     SpecifierOpt *filters;
 383     int        nb_filters;
 384 #endif
 385 } OptionsContext;
 386
 387 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
 388 {\
 389     int i, ret;\
 390     for (i = 0; i < o->nb_ ## name; i++) {\
 391         char *spec = o->name[i].specifier;\
 392         if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
 393             outvar = o->name[i].u.type;\
 394         else if (ret < 0)\
 395             exit_program(1);\
 396     }\
 397 }
 398
 399 static void reset_options(OptionsContext *o, int is_input)
 400 {
 401     const OptionDef *po = options;
 402     OptionsContext bak= *o;
 403
 404     /* all OPT_SPEC and OPT_STRING can be freed in generic way */
 405     while (po->name) {
 406         void *dst = (uint8_t*)o + po->u.off;
 407
 408         if (po->flags & OPT_SPEC) {
 409             SpecifierOpt **so = dst;
 410             int i, *count = (int*)(so + 1);
 411             for (i = 0; i < *count; i++) {
 412                 av_freep(&(*so)[i].specifier);
 413                 if (po->flags & OPT_STRING)
 414                     av_freep(&(*so)[i].u.str);
 415             }
 416             av_freep(so);
 417             *count = 0;
 418         } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
 419             av_freep(dst);
 420         po++;
 421     }
 422
 423     av_freep(&o->stream_maps);
 424     av_freep(&o->audio_channel_maps);
 425     av_freep(&o->meta_data_maps);
 426     av_freep(&o->streamid_map);
 427
 428     memset(o, 0, sizeof(*o));
 429
 430     if(is_input) o->recording_time = bak.recording_time;
 431     else         o->recording_time = INT64_MAX;
 432     o->mux_max_delay  = 0.7;
 433     o->limit_filesize = UINT64_MAX;
 434     o->chapters_input_file = INT_MAX;
 435
 436     uninit_opts();
 437     init_opts();
 438 }
 439
 440 #if CONFIG_AVFILTER
 441
 442 static int configure_video_filters(InputStream *ist, OutputStream *ost)
 443 {
 444     AVFilterContext *last_filter, *filter;
 445     /** filter graph containing all filters including input & output */
 446     AVCodecContext *codec = ost->st->codec;
 447     AVCodecContext *icodec = ist->st->codec;
 448     enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
 449     AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
 450     AVRational sample_aspect_ratio;
 451     char args[255];
 452     int ret;
 453
 454     ost->graph = avfilter_graph_alloc();
 455
 456     if (ist->st->sample_aspect_ratio.num){
 457         sample_aspect_ratio = ist->st->sample_aspect_ratio;
 458     }else
 459         sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
 460
 461     snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
 462              ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
 463              sample_aspect_ratio.num, sample_aspect_ratio.den);
 464
 465     ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
 466                                        "src", args, NULL, ost->graph);
 467     if (ret < 0)
 468         return ret;
 469 #if FF_API_OLD_VSINK_API
 470     ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
 471                                        "out", NULL, pix_fmts, ost->graph);
 472 #else
 473     buffersink_params->pixel_fmts = pix_fmts;
 474     ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
 475                                        "out", NULL, buffersink_params, ost->graph);
 476 #endif
 477     av_freep(&buffersink_params);
 478     if (ret < 0)
 479         return ret;
 480     last_filter = ost->input_video_filter;
 481
 482     if (codec->width  != icodec->width || codec->height != icodec->height) {
 483         snprintf(args, 255, "%d:%d:flags=0x%X",
 484                  codec->width,
 485                  codec->height,
 486                  (unsigned)ost->sws_flags);
 487         if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
 488                                                 NULL, args, NULL, ost->graph)) < 0)
 489             return ret;
 490         if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
 491             return ret;
 492         last_filter = filter;
 493     }
 494
 495     snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
 496     ost->graph->scale_sws_opts = av_strdup(args);
 497
 498     if (ost->avfilter) {
 499         AVFilterInOut *outputs = avfilter_inout_alloc();
 500         AVFilterInOut *inputs  = avfilter_inout_alloc();
 501
 502         outputs->name    = av_strdup("in");
 503         outputs->filter_ctx = last_filter;
 504         outputs->pad_idx = 0;
 505         outputs->next    = NULL;
 506
 507         inputs->name    = av_strdup("out");
 508         inputs->filter_ctx = ost->output_video_filter;
 509         inputs->pad_idx = 0;
 510         inputs->next    = NULL;
 511
 512         if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
 513             return ret;
 514         av_freep(&ost->avfilter);
 515     } else {
 516         if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
 517             return ret;
 518     }
 519
 520     if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
 521         return ret;
 522
 523     codec->width  = ost->output_video_filter->inputs[0]->w;
 524     codec->height = ost->output_video_filter->inputs[0]->h;
 525     codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
 526         ost->frame_aspect_ratio ? // overridden by the -aspect cli option
 527         av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
 528         ost->output_video_filter->inputs[0]->sample_aspect_ratio;
 529
 530     return 0;
 531 }
 532 #endif /* CONFIG_AVFILTER */
 533
 534 static void term_exit(void)
 535 {
 536     av_log(NULL, AV_LOG_QUIET, "%s", "");
 537 #if HAVE_TERMIOS_H
 538     if(!run_as_daemon)
 539         tcsetattr (0, TCSANOW, &oldtty);
 540 #endif
 541 }
 542
 543 static volatile int received_sigterm = 0;
 544
 545 static void sigterm_handler(int sig)
 546 {
 547     received_sigterm = sig;
 548     received_nb_signals++;
 549     term_exit();
 550 }
 551
 552 static void term_init(void)
 553 {
 554 #if HAVE_TERMIOS_H
 555     if(!run_as_daemon){
 556     struct termios tty;
 557
 558     tcgetattr (0, &tty);
 559     oldtty = tty;
 560     atexit(term_exit);
 561
 562     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 563                           |INLCR|IGNCR|ICRNL|IXON);
 564     tty.c_oflag |= OPOST;
 565     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
 566     tty.c_cflag &= ~(CSIZE|PARENB);
 567     tty.c_cflag |= CS8;
 568     tty.c_cc[VMIN] = 1;
 569     tty.c_cc[VTIME] = 0;
 570
 571     tcsetattr (0, TCSANOW, &tty);
 572     signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
 573     }
 574 #endif
 575     avformat_network_deinit();
 576
 577     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
 578     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
 579 #ifdef SIGXCPU
 580     signal(SIGXCPU, sigterm_handler);
 581 #endif
 582 }
 583
 584 /* read a key without blocking */
 585 static int read_key(void)
 586 {
 587     unsigned char ch;
 588 #if HAVE_TERMIOS_H
 589     int n = 1;
 590     struct timeval tv;
 591     fd_set rfds;
 592
 593     FD_ZERO(&rfds);
 594     FD_SET(0, &rfds);
 595     tv.tv_sec = 0;
 596     tv.tv_usec = 0;
 597     n = select(1, &rfds, NULL, NULL, &tv);
 598     if (n > 0) {
 599         n = read(0, &ch, 1);
 600         if (n == 1)
 601             return ch;
 602
 603         return n;
 604     }
 605 #elif HAVE_KBHIT
 606 #    if HAVE_PEEKNAMEDPIPE
 607     static int is_pipe;
 608     static HANDLE input_handle;
 609     DWORD dw, nchars;
 610     if(!input_handle){
 611         input_handle = GetStdHandle(STD_INPUT_HANDLE);
 612         is_pipe = !GetConsoleMode(input_handle, &dw);
 613     }
 614
 615     if (stdin->_cnt > 0) {
 616         read(0, &ch, 1);
 617         return ch;
 618     }
 619     if (is_pipe) {
 620         /* When running under a GUI, you will end here. */
 621         if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
 622             return -1;
 623         //Read it
 624         if(nchars != 0) {
 625             read(0, &ch, 1);
 626             return ch;
 627         }else{
 628             return -1;
 629         }
 630     }
 631 #    endif
 632     if(kbhit())
 633         return(getch());
 634 #endif
 635     return -1;
 636 }
 637
 638 static int decode_interrupt_cb(void)
 639 {
 640     return received_nb_signals > 1;
 641 }
 642
 643 void exit_program(int ret)
 644 {
 645     int i;
 646
 647     /* close files */
 648     for(i=0;i<nb_output_files;i++) {
 649         AVFormatContext *s = output_files[i].ctx;
 650         if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
 651             avio_close(s->pb);
 652         avformat_free_context(s);
 653         av_dict_free(&output_files[i].opts);
 654     }
 655     for(i=0;i<nb_input_files;i++) {
 656         av_close_input_file(input_files[i].ctx);
 657     }
 658     for (i = 0; i < nb_input_streams; i++)
 659         av_dict_free(&input_streams[i].opts);
 660
 661     if (vstats_file)
 662         fclose(vstats_file);
 663     av_free(vstats_filename);
 664
 665     av_freep(&input_streams);
 666     av_freep(&input_files);
 667     av_freep(&output_streams);
 668     av_freep(&output_files);
 669
 670     uninit_opts();
 671     av_free(audio_buf);
 672     av_free(audio_out);
 673     allocated_audio_buf_size= allocated_audio_out_size= 0;
 674     av_free(samples);
 675
 676 #if CONFIG_AVFILTER
 677     avfilter_uninit();
 678 #endif
 679     avformat_network_deinit();
 680
 681     av_freep(&input_tmp);
 682
 683     if (received_sigterm) {
 684         av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
 685                (int) received_sigterm);
 686         exit (255);
 687     }
 688
 689     exit(ret); /* not all OS-es handle main() return value */
 690 }
 691
 692 static void assert_avoptions(AVDictionary *m)
 693 {
 694     AVDictionaryEntry *t;
 695     if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
 696         av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
 697         exit_program(1);
 698     }
 699 }
 700
 701 static void assert_codec_experimental(AVCodecContext *c, int encoder)
 702 {
 703     const char *codec_string = encoder ? "encoder" : "decoder";
 704     AVCodec *codec;
 705     if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
 706         c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
 707         av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
 708                 "results.\nAdd '-strict experimental' if you want to use it.\n",
 709                 codec_string, c->codec->name);
 710         codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
 711         if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
 712             av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
 713                    codec_string, codec->name);
 714         exit_program(1);
 715     }
 716 }
 717
 718 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
 719 {
 720     if(codec && codec->sample_fmts){
 721         const enum AVSampleFormat *p= codec->sample_fmts;
 722         for(; *p!=-1; p++){
 723             if(*p == st->codec->sample_fmt)
 724                 break;
 725         }
 726         if (*p == -1) {
 727             if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
 728                 av_log(NULL, AV_LOG_ERROR, "Conversion will not be lossless.\n");
 729             if(av_get_sample_fmt_name(st->codec->sample_fmt))
 730             av_log(NULL, AV_LOG_WARNING,
 731                    "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
 732                    av_get_sample_fmt_name(st->codec->sample_fmt),
 733                    codec->name,
 734                    av_get_sample_fmt_name(codec->sample_fmts[0]));
 735             st->codec->sample_fmt = codec->sample_fmts[0];
 736         }
 737     }
 738 }
 739
 740 static void choose_sample_rate(AVStream *st, AVCodec *codec)
 741 {
 742     if(codec && codec->supported_samplerates){
 743         const int *p= codec->supported_samplerates;
 744         int best=0;
 745         int best_dist=INT_MAX;
 746         for(; *p; p++){
 747             int dist= abs(st->codec->sample_rate - *p);
 748             if(dist < best_dist){
 749                 best_dist= dist;
 750                 best= *p;
 751             }
 752         }
 753         if(best_dist){
 754             av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
 755         }
 756         st->codec->sample_rate= best;
 757     }
 758 }
 759
 760 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
 761 {
 762     if(codec && codec->pix_fmts){
 763         const enum PixelFormat *p= codec->pix_fmts;
 764         if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
 765             if(st->codec->codec_id==CODEC_ID_MJPEG){
 766                 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
 767             }else if(st->codec->codec_id==CODEC_ID_LJPEG){
 768                 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE};
 769             }
 770         }
 771         for(; *p!=-1; p++){
 772             if(*p == st->codec->pix_fmt)
 773                 break;
 774         }
 775         if (*p == -1) {
 776             if(st->codec->pix_fmt != PIX_FMT_NONE)
 777                 av_log(NULL, AV_LOG_WARNING,
 778                         "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
 779                         av_pix_fmt_descriptors[st->codec->pix_fmt].name,
 780                         codec->name,
 781                         av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
 782             st->codec->pix_fmt = codec->pix_fmts[0];
 783         }
 784     }
 785 }
 786
 787 static double get_sync_ipts(const OutputStream *ost)
 788 {
 789     const InputStream *ist = ost->sync_ist;
 790     OutputFile *of = &output_files[ost->file_index];
 791     return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
 792 }
 793
 794 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc)
 795 {
 796     int ret;
 797
 798     while(bsfc){
 799         AVPacket new_pkt= *pkt;
 800         int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
 801                                           &new_pkt.data, &new_pkt.size,
 802                                           pkt->data, pkt->size,
 803                                           pkt->flags & AV_PKT_FLAG_KEY);
 804         if(a>0){
 805             av_free_packet(pkt);
 806             new_pkt.destruct= av_destruct_packet;
 807         } else if(a<0){
 808             av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
 809                    bsfc->filter->name, pkt->stream_index,
 810                    avctx->codec ? avctx->codec->name : "copy");
 811             print_error("", a);
 812             if (exit_on_error)
 813                 exit_program(1);
 814         }
 815         *pkt= new_pkt;
 816
 817         bsfc= bsfc->next;
 818     }
 819
 820     ret= av_interleaved_write_frame(s, pkt);
 821     if(ret < 0){
 822         print_error("av_interleaved_write_frame()", ret);
 823         exit_program(1);
 824     }
 825 }
 826
 827 static void do_audio_out(AVFormatContext *s,
 828                          OutputStream *ost,
 829                          InputStream *ist,
 830                          unsigned char *buf, int size)
 831 {
 832     uint8_t *buftmp;
 833     int64_t audio_out_size, audio_buf_size;
 834     int64_t allocated_for_size= size;
 835
 836     int size_out, frame_bytes, ret, resample_changed;
 837     AVCodecContext *enc= ost->st->codec;
 838     AVCodecContext *dec= ist->st->codec;
 839     int osize = av_get_bytes_per_sample(enc->sample_fmt);
 840     int isize = av_get_bytes_per_sample(dec->sample_fmt);
 841     const int coded_bps = av_get_bits_per_sample(enc->codec->id);
 842
 843 need_realloc:
 844     audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
 845     audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
 846     audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
 847     audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
 848     audio_buf_size*= osize*enc->channels;
 849
 850     audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
 851     if(coded_bps > 8*osize)
 852         audio_out_size= audio_out_size * coded_bps / (8*osize);
 853     audio_out_size += FF_MIN_BUFFER_SIZE;
 854
 855     if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
 856         av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");
 857         exit_program(1);
 858     }
 859
 860     av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
 861     av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
 862     if (!audio_buf || !audio_out){
 863         av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
 864         exit_program(1);
 865     }
 866
 867     if (enc->channels != dec->channels
 868      || enc->sample_fmt != dec->sample_fmt)
 869         ost->audio_resample = 1;
 870
 871     resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
 872                        ost->resample_channels    != dec->channels   ||
 873                        ost->resample_sample_rate != dec->sample_rate;
 874
 875     if ((ost->audio_resample && !ost->swr) || resample_changed || ost->audio_channels_mapped) {
 876         if (resample_changed) {
 877             av_log(NULL, AV_LOG_INFO, "Input stream #%d:%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",
 878                    ist->file_index, ist->st->index,
 879                    ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
 880                    dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
 881             ost->resample_sample_fmt  = dec->sample_fmt;
 882             ost->resample_channels    = dec->channels;
 883             ost->resample_sample_rate = dec->sample_rate;
 884             swr_free(&ost->swr);
 885         }
 886         /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
 887         if (audio_sync_method <= 1 && !ost->audio_channels_mapped &&
 888             ost->resample_sample_fmt  == enc->sample_fmt &&
 889             ost->resample_channels    == enc->channels   &&
 890             ost->resample_sample_rate == enc->sample_rate) {
 891             //ost->swr = NULL;
 892             ost->audio_resample = 0;
 893         } else {
 894             ost->swr = swr_alloc2(ost->swr,
 895                                   enc->channel_layout, enc->sample_fmt, enc->sample_rate,
 896                                   dec->channel_layout, dec->sample_fmt, dec->sample_rate,
 897                                   ost->audio_channels_mapped ? ost->audio_channels_map : NULL,
 898                                   0, NULL);
 899             av_set_double(ost->swr, "rmvol", ost->rematrix_volume);
 900             if (ost->audio_channels_mapped) {
 901                 av_set_int(ost->swr, "icl", av_get_default_channel_layout(ost->audio_channels_mapped));
 902                 av_set_int(ost->swr, "uch", ost->audio_channels_mapped);
 903             }
 904             av_set_int(ost->swr, "ich", dec->channels);
 905             av_set_int(ost->swr, "och", enc->channels);
 906             if(audio_sync_method>1) av_set_int(ost->swr, "flags", SWR_FLAG_RESAMPLE);
 907             if(ost->swr && swr_init(ost->swr) < 0){
 908                 av_log(NULL, AV_LOG_FATAL, "swr_init() failed\n");
 909                 swr_free(&ost->swr);
 910             }
 911
 912             if (!ost->swr) {
 913                 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
 914                         dec->channels, dec->sample_rate,
 915                         enc->channels, enc->sample_rate);
 916                 exit_program(1);
 917             }
 918         }
 919     }
 920
 921     av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
 922
 923     if(audio_sync_method){
 924         double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
 925                 - av_fifo_size(ost->fifo)/(enc->channels * 2);
 926         double idelta= delta*dec->sample_rate / enc->sample_rate;
 927         int byte_delta= ((int)idelta)*2*dec->channels;
 928
 929         //FIXME resample delay
 930         if(fabs(delta) > 50){
 931             if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
 932                 if(byte_delta < 0){
 933                     byte_delta= FFMAX(byte_delta, -size);
 934                     size += byte_delta;
 935                     buf  -= byte_delta;
 936                     av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n", (int)-delta);
 937                     if(!size)
 938                         return;
 939                     ist->is_start=0;
 940                 }else{
 941                     input_tmp= av_realloc(input_tmp, byte_delta + size);
 942
 943                     if(byte_delta > allocated_for_size - size){
 944                         allocated_for_size= byte_delta + (int64_t)size;
 945                         goto need_realloc;
 946                     }
 947                     ist->is_start=0;
 948
 949                     memset(input_tmp, 0, byte_delta);
 950                     memcpy(input_tmp + byte_delta, buf, size);
 951                     buf= input_tmp;
 952                     size += byte_delta;
 953                     av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", (int)delta);
 954                 }
 955             }else if(audio_sync_method>1){
 956                 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
 957                 av_assert0(ost->audio_resample);
 958                 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
 959                        delta, comp, enc->sample_rate);
 960 //                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));
 961                 swr_compensate(ost->swr, comp, enc->sample_rate);
 962             }
 963         }
 964     }else
 965         ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
 966                         - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
 967
 968     if (ost->audio_resample) {
 969         buftmp = audio_buf;
 970         size_out = swr_convert(ost->swr, (      uint8_t*[]){buftmp}, audio_buf_size / (enc->channels * osize),
 971                                          (const uint8_t*[]){buf   }, size / (dec->channels * isize));
 972         size_out = size_out * enc->channels * osize;
 973     } else {
 974         buftmp = buf;
 975         size_out = size;
 976     }
 977
 978     av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
 979
 980     /* now encode as many frames as possible */
 981     if (enc->frame_size > 1) {
 982         /* output resampled raw samples */
 983         if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
 984             av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
 985             exit_program(1);
 986         }
 987         av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
 988
 989         frame_bytes = enc->frame_size * osize * enc->channels;
 990
 991         while (av_fifo_size(ost->fifo) >= frame_bytes) {
 992             AVPacket pkt;
 993             av_init_packet(&pkt);
 994
 995             av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
 996
 997             //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
 998
 999             ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
1000                                        (short *)audio_buf);
1001             if (ret < 0) {
1002                 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1003                 exit_program(1);
1004             }
1005             audio_size += ret;
1006             pkt.stream_index= ost->index;
1007             pkt.data= audio_out;
1008             pkt.size= ret;
1009             if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1010                 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1011             pkt.flags |= AV_PKT_FLAG_KEY;
1012             write_frame(s, &pkt, enc, ost->bitstream_filters);
1013
1014             ost->sync_opts += enc->frame_size;
1015         }
1016     } else {
1017         AVPacket pkt;
1018         av_init_packet(&pkt);
1019
1020         ost->sync_opts += size_out / (osize * enc->channels);
1021
1022         /* output a pcm frame */
1023         /* determine the size of the coded buffer */
1024         size_out /= osize;
1025         if (coded_bps)
1026             size_out = size_out*coded_bps/8;
1027
1028         if(size_out > audio_out_size){
1029             av_log(NULL, AV_LOG_FATAL, "Internal error, buffer size too small\n");
1030             exit_program(1);
1031         }
1032
1033         //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1034         ret = avcodec_encode_audio(enc, audio_out, size_out,
1035                                    (short *)buftmp);
1036         if (ret < 0) {
1037             av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1038             exit_program(1);
1039         }
1040         audio_size += ret;
1041         pkt.stream_index= ost->index;
1042         pkt.data= audio_out;
1043         pkt.size= ret;
1044         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1045             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1046         pkt.flags |= AV_PKT_FLAG_KEY;
1047         write_frame(s, &pkt, enc, ost->bitstream_filters);
1048     }
1049 }
1050
1051 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1052 {
1053     AVCodecContext *dec;
1054     AVPicture *picture2;
1055     AVPicture picture_tmp;
1056     uint8_t *buf = 0;
1057
1058     dec = ist->st->codec;
1059
1060     /* deinterlace : must be done before any resize */
1061     if (do_deinterlace) {
1062         int size;
1063
1064         /* create temporary picture */
1065         size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1066         buf = av_malloc(size);
1067         if (!buf)
1068             return;
1069
1070         picture2 = &picture_tmp;
1071         avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1072
1073         if(avpicture_deinterlace(picture2, picture,
1074                                  dec->pix_fmt, dec->width, dec->height) < 0) {
1075             /* if error, do not deinterlace */
1076             av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1077             av_free(buf);
1078             buf = NULL;
1079             picture2 = picture;
1080         }
1081     } else {
1082         picture2 = picture;
1083     }
1084
1085     if (picture != picture2)
1086         *picture = *picture2;
1087     *bufp = buf;
1088 }
1089
1090 static void do_subtitle_out(AVFormatContext *s,
1091                             OutputStream *ost,
1092                             InputStream *ist,
1093                             AVSubtitle *sub,
1094                             int64_t pts)
1095 {
1096     static uint8_t *subtitle_out = NULL;
1097     int subtitle_out_max_size = 1024 * 1024;
1098     int subtitle_out_size, nb, i;
1099     AVCodecContext *enc;
1100     AVPacket pkt;
1101
1102     if (pts == AV_NOPTS_VALUE) {
1103         av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1104         if (exit_on_error)
1105             exit_program(1);
1106         return;
1107     }
1108
1109     enc = ost->st->codec;
1110
1111     if (!subtitle_out) {
1112         subtitle_out = av_malloc(subtitle_out_max_size);
1113     }
1114
1115     /* Note: DVB subtitle need one packet to draw them and one other
1116        packet to clear them */
1117     /* XXX: signal it in the codec context ? */
1118     if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1119         nb = 2;
1120     else
1121         nb = 1;
1122
1123     for(i = 0; i < nb; i++) {
1124         sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1125         // start_display_time is required to be 0
1126         sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1127         sub->end_display_time -= sub->start_display_time;
1128         sub->start_display_time = 0;
1129         subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1130                                                     subtitle_out_max_size, sub);
1131         if (subtitle_out_size < 0) {
1132             av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1133             exit_program(1);
1134         }
1135
1136         av_init_packet(&pkt);
1137         pkt.stream_index = ost->index;
1138         pkt.data = subtitle_out;
1139         pkt.size = subtitle_out_size;
1140         pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1141         if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1142             /* XXX: the pts correction is handled here. Maybe handling
1143                it in the codec would be better */
1144             if (i == 0)
1145                 pkt.pts += 90 * sub->start_display_time;
1146             else
1147                 pkt.pts += 90 * sub->end_display_time;
1148         }
1149         write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1150     }
1151 }
1152
1153 static int bit_buffer_size= 1024*256;
1154 static uint8_t *bit_buffer= NULL;
1155
1156 static void do_video_resample(OutputStream *ost,
1157                               InputStream *ist,
1158                               AVFrame *in_picture,
1159                               AVFrame **out_picture)
1160 {
1161 #if CONFIG_AVFILTER
1162     *out_picture = in_picture;
1163 #else
1164     AVCodecContext *dec = ist->st->codec;
1165     AVCodecContext *enc = ost->st->codec;
1166     int resample_changed = ost->resample_width   != dec->width  ||
1167                            ost->resample_height  != dec->height ||
1168                            ost->resample_pix_fmt != dec->pix_fmt;
1169
1170     *out_picture = in_picture;
1171     if (resample_changed) {
1172         av_log(NULL, AV_LOG_INFO,
1173                "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1174                ist->file_index, ist->st->index,
1175                ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1176                dec->width         , dec->height         , av_get_pix_fmt_name(dec->pix_fmt));
1177         ost->resample_width   = dec->width;
1178         ost->resample_height  = dec->height;
1179         ost->resample_pix_fmt = dec->pix_fmt;
1180     }
1181
1182     ost->video_resample = dec->width   != enc->width  ||
1183                           dec->height  != enc->height ||
1184                           dec->pix_fmt != enc->pix_fmt;
1185
1186     if (ost->video_resample) {
1187         *out_picture = &ost->resample_frame;
1188         if (!ost->img_resample_ctx || resample_changed) {
1189             /* initialize the destination picture */
1190             if (!ost->resample_frame.data[0]) {
1191                 avcodec_get_frame_defaults(&ost->resample_frame);
1192                 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1193                                     enc->width, enc->height)) {
1194                     av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
1195                     exit_program(1);
1196                 }
1197             }
1198             /* initialize a new scaler context */
1199             sws_freeContext(ost->img_resample_ctx);
1200             ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1201                                                    enc->width, enc->height, enc->pix_fmt,
1202                                                    ost->sws_flags, NULL, NULL, NULL);
1203             if (ost->img_resample_ctx == NULL) {
1204                 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1205                 exit_program(1);
1206             }
1207         }
1208         sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1209               0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1210     }
1211 #endif
1212 }
1213
1214
1215 static void do_video_out(AVFormatContext *s,
1216                          OutputStream *ost,
1217                          InputStream *ist,
1218                          AVFrame *in_picture,
1219                          int *frame_size, float quality)
1220 {
1221     int nb_frames, i, ret, format_video_sync;
1222     AVFrame *final_picture;
1223     AVCodecContext *enc;
1224     double sync_ipts;
1225     double duration = 0;
1226
1227     enc = ost->st->codec;
1228
1229     if (ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE) {
1230         duration = FFMAX(av_q2d(ist->st->time_base), av_q2d(ist->st->codec->time_base));
1231         if(ist->st->avg_frame_rate.num)
1232             duration= FFMAX(duration, 1/av_q2d(ist->st->avg_frame_rate));
1233
1234         duration /= av_q2d(enc->time_base);
1235     }
1236
1237     sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1238
1239     /* by default, we output a single frame */
1240     nb_frames = 1;
1241
1242     *frame_size = 0;
1243
1244     format_video_sync = video_sync_method;
1245     if (format_video_sync < 0)
1246         format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1247
1248     if (format_video_sync) {
1249         double vdelta = sync_ipts - ost->sync_opts + duration;
1250         //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1251         if (vdelta < -1.1)
1252             nb_frames = 0;
1253         else if (format_video_sync == 2) {
1254             if(vdelta<=-0.6){
1255                 nb_frames=0;
1256             }else if(vdelta>0.6)
1257                 ost->sync_opts= lrintf(sync_ipts);
1258         }else if (vdelta > 1.1)
1259             nb_frames = lrintf(vdelta);
1260 //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);
1261         if (nb_frames == 0){
1262             ++nb_frames_drop;
1263             av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1264         }else if (nb_frames > 1) {
1265             nb_frames_dup += nb_frames - 1;
1266             av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames-1);
1267         }
1268     }else
1269         ost->sync_opts= lrintf(sync_ipts);
1270
1271     nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1272     if (nb_frames <= 0)
1273         return;
1274
1275     do_video_resample(ost, ist, in_picture, &final_picture);
1276
1277     /* duplicates frame if needed */
1278     for(i=0;i<nb_frames;i++) {
1279         AVPacket pkt;
1280         av_init_packet(&pkt);
1281         pkt.stream_index= ost->index;
1282
1283         if (s->oformat->flags & AVFMT_RAWPICTURE) {
1284             /* raw pictures are written as AVPicture structure to
1285                avoid any copies. We support temporarily the older
1286                method. */
1287             enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1288             enc->coded_frame->top_field_first  = in_picture->top_field_first;
1289             pkt.data= (uint8_t *)final_picture;
1290             pkt.size=  sizeof(AVPicture);
1291             pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1292             pkt.flags |= AV_PKT_FLAG_KEY;
1293
1294             write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1295         } else {
1296             AVFrame big_picture;
1297
1298             big_picture= *final_picture;
1299             /* better than nothing: use input picture interlaced
1300                settings */
1301             big_picture.interlaced_frame = in_picture->interlaced_frame;
1302             if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1303                 if (ost->top_field_first == -1)
1304                     big_picture.top_field_first = in_picture->top_field_first;
1305                 else
1306                     big_picture.top_field_first = !!ost->top_field_first;
1307             }
1308
1309             /* handles same_quant here. This is not correct because it may
1310                not be a global option */
1311             big_picture.quality = quality;
1312             if (!enc->me_threshold)
1313                 big_picture.pict_type = 0;
1314 //            big_picture.pts = AV_NOPTS_VALUE;
1315             big_picture.pts= ost->sync_opts;
1316 //            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1317 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1318             if (ost->forced_kf_index < ost->forced_kf_count &&
1319                 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1320                 big_picture.pict_type = AV_PICTURE_TYPE_I;
1321                 ost->forced_kf_index++;
1322             }
1323             ret = avcodec_encode_video(enc,
1324                                        bit_buffer, bit_buffer_size,
1325                                        &big_picture);
1326             if (ret < 0) {
1327                 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1328                 exit_program(1);
1329             }
1330
1331             if(ret>0){
1332                 pkt.data= bit_buffer;
1333                 pkt.size= ret;
1334                 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1335                     pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1336 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1337    pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1338    pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1339
1340                 if(enc->coded_frame->key_frame)
1341                     pkt.flags |= AV_PKT_FLAG_KEY;
1342                 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1343                 *frame_size = ret;
1344                 video_size += ret;
1345                 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1346                 //        enc->frame_number-1, ret, enc->pict_type);
1347                 /* if two pass, output log */
1348                 if (ost->logfile && enc->stats_out) {
1349                     fprintf(ost->logfile, "%s", enc->stats_out);
1350                 }
1351             }
1352         }
1353         ost->sync_opts++;
1354         ost->frame_number++;
1355     }
1356 }
1357
1358 static double psnr(double d)
1359 {
1360     return -10.0*log(d)/log(10.0);
1361 }
1362
1363 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1364                            int frame_size)
1365 {
1366     AVCodecContext *enc;
1367     int frame_number;
1368     double ti1, bitrate, avg_bitrate;
1369
1370     /* this is executed just the first time do_video_stats is called */
1371     if (!vstats_file) {
1372         vstats_file = fopen(vstats_filename, "w");
1373         if (!vstats_file) {
1374             perror("fopen");
1375             exit_program(1);
1376         }
1377     }
1378
1379     enc = ost->st->codec;
1380     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1381         frame_number = ost->frame_number;
1382         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1383         if (enc->flags&CODEC_FLAG_PSNR)
1384             fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1385
1386         fprintf(vstats_file,"f_size= %6d ", frame_size);
1387         /* compute pts value */
1388         ti1 = ost->sync_opts * av_q2d(enc->time_base);
1389         if (ti1 < 0.01)
1390             ti1 = 0.01;
1391
1392         bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1393         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1394         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1395             (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1396         fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1397     }
1398 }
1399
1400 static void print_report(OutputFile *output_files,
1401                          OutputStream *ost_table, int nb_ostreams,
1402                          int is_last_report, int64_t timer_start, int64_t cur_time)
1403 {
1404     char buf[1024];
1405     OutputStream *ost;
1406     AVFormatContext *oc;
1407     int64_t total_size;
1408     AVCodecContext *enc;
1409     int frame_number, vid, i;
1410     double bitrate;
1411     int64_t pts = INT64_MAX;
1412     static int64_t last_time = -1;
1413     static int qp_histogram[52];
1414     int hours, mins, secs, us;
1415
1416     if (!print_stats && !is_last_report)
1417         return;
1418
1419     if (!is_last_report) {
1420         if (last_time == -1) {
1421             last_time = cur_time;
1422             return;
1423         }
1424         if ((cur_time - last_time) < 500000)
1425             return;
1426         last_time = cur_time;
1427     }
1428
1429
1430     oc = output_files[0].ctx;
1431
1432     total_size = avio_size(oc->pb);
1433     if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1434         total_size= avio_tell(oc->pb);
1435
1436     buf[0] = '\0';
1437     vid = 0;
1438     for(i=0;i<nb_ostreams;i++) {
1439         float q = -1;
1440         ost = &ost_table[i];
1441         enc = ost->st->codec;
1442         if (!ost->stream_copy && enc->coded_frame)
1443             q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1444         if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1445             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1446         }
1447         if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1448             float t = (cur_time-timer_start) / 1000000.0;
1449
1450             frame_number = ost->frame_number;
1451             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1452                      frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1453             if(is_last_report)
1454                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1455             if(qp_hist){
1456                 int j;
1457                 int qp = lrintf(q);
1458                 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1459                     qp_histogram[qp]++;
1460                 for(j=0; j<32; j++)
1461                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1462             }
1463             if (enc->flags&CODEC_FLAG_PSNR){
1464                 int j;
1465                 double error, error_sum=0;
1466                 double scale, scale_sum=0;
1467                 char type[3]= {'Y','U','V'};
1468                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1469                 for(j=0; j<3; j++){
1470                     if(is_last_report){
1471                         error= enc->error[j];
1472                         scale= enc->width*enc->height*255.0*255.0*frame_number;
1473                     }else{
1474                         error= enc->coded_frame->error[j];
1475                         scale= enc->width*enc->height*255.0*255.0;
1476                     }
1477                     if(j) scale/=4;
1478                     error_sum += error;
1479                     scale_sum += scale;
1480                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1481                 }
1482                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1483             }
1484             vid = 1;
1485         }
1486         /* compute min output value */
1487         pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1488                                       ost->st->time_base, AV_TIME_BASE_Q));
1489     }
1490
1491     secs = pts / AV_TIME_BASE;
1492     us = pts % AV_TIME_BASE;
1493     mins = secs / 60;
1494     secs %= 60;
1495     hours = mins / 60;
1496     mins %= 60;
1497
1498     bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1499
1500     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1501              "size=%8.0fkB time=", total_size / 1024.0);
1502     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1503              "%02d:%02d:%02d.%02d ", hours, mins, secs,
1504              (100 * us) / AV_TIME_BASE);
1505     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1506              "bitrate=%6.1fkbits/s", bitrate);
1507
1508     if (nb_frames_dup || nb_frames_drop)
1509         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1510                 nb_frames_dup, nb_frames_drop);
1511
1512     av_log(NULL, AV_LOG_INFO, "%s    \r", buf);
1513
1514     fflush(stderr);
1515
1516     if (is_last_report) {
1517         int64_t raw= audio_size + video_size + extra_size;
1518         av_log(NULL, AV_LOG_INFO, "\n");
1519         av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1520                video_size/1024.0,
1521                audio_size/1024.0,
1522                extra_size/1024.0,
1523                100.0*(total_size - raw)/raw
1524         );
1525     }
1526 }
1527
1528 static void generate_silence(uint8_t *buf, enum AVSampleFormat sample_fmt, size_t size)
1529 {
1530     int fill_char = 0x00;
1531     if (sample_fmt == AV_SAMPLE_FMT_U8)
1532         fill_char = 0x80;
1533     memset(buf, fill_char, size);
1534 }
1535
1536 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1537 {
1538     int i, ret;
1539
1540     for (i = 0; i < nb_ostreams; i++) {
1541         OutputStream   *ost = &ost_table[i];
1542         AVCodecContext *enc = ost->st->codec;
1543         AVFormatContext *os = output_files[ost->file_index].ctx;
1544
1545         if (!ost->encoding_needed)
1546             continue;
1547
1548         if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1549             continue;
1550         if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1551             continue;
1552
1553         for(;;) {
1554             AVPacket pkt;
1555             int fifo_bytes;
1556             av_init_packet(&pkt);
1557             pkt.stream_index= ost->index;
1558
1559             switch (ost->st->codec->codec_type) {
1560             case AVMEDIA_TYPE_AUDIO:
1561                 fifo_bytes = av_fifo_size(ost->fifo);
1562                 ret = 0;
1563                 /* encode any samples remaining in fifo */
1564                 if (fifo_bytes > 0) {
1565                     int osize = av_get_bytes_per_sample(enc->sample_fmt);
1566                     int fs_tmp = enc->frame_size;
1567
1568                     av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1569                     if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1570                         enc->frame_size = fifo_bytes / (osize * enc->channels);
1571                     } else { /* pad */
1572                         int frame_bytes = enc->frame_size*osize*enc->channels;
1573                         if (allocated_audio_buf_size < frame_bytes)
1574                             exit_program(1);
1575                         generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1576                     }
1577
1578                     ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1579                     pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1580                                               ost->st->time_base.num, enc->sample_rate);
1581                     enc->frame_size = fs_tmp;
1582                 }
1583                 if (ret <= 0) {
1584                     ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1585                 }
1586                 if (ret < 0) {
1587                     av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1588                     exit_program(1);
1589                 }
1590                 audio_size += ret;
1591                 pkt.flags |= AV_PKT_FLAG_KEY;
1592                 break;
1593             case AVMEDIA_TYPE_VIDEO:
1594                 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1595                 if (ret < 0) {
1596                     av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1597                     exit_program(1);
1598                 }
1599                 video_size += ret;
1600                 if(enc->coded_frame && enc->coded_frame->key_frame)
1601                     pkt.flags |= AV_PKT_FLAG_KEY;
1602                 if (ost->logfile && enc->stats_out) {
1603                     fprintf(ost->logfile, "%s", enc->stats_out);
1604                 }
1605                 break;
1606             default:
1607                 ret=-1;
1608             }
1609
1610             if (ret <= 0)
1611                 break;
1612             pkt.data = bit_buffer;
1613             pkt.size = ret;
1614             if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1615                 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1616             write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1617         }
1618     }
1619 }
1620
1621 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1622 static int output_packet(InputStream *ist, int ist_index,
1623                          OutputStream *ost_table, int nb_ostreams,
1624                          const AVPacket *pkt)
1625 {
1626     AVFormatContext *os;
1627     OutputStream *ost;
1628     int ret = 0, i;
1629     int got_output;
1630     void *buffer_to_free = NULL;
1631     static unsigned int samples_size= 0;
1632     AVSubtitle subtitle, *subtitle_to_free;
1633     int64_t pkt_dts = AV_NOPTS_VALUE;
1634     int64_t pkt_pts = AV_NOPTS_VALUE;
1635 #if CONFIG_AVFILTER
1636     int frame_available;
1637 #endif
1638     float quality = 0;
1639
1640     AVPacket avpkt;
1641     int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1642
1643     if(ist->next_pts == AV_NOPTS_VALUE)
1644         ist->next_pts= ist->pts;
1645
1646     if (pkt == NULL) {
1647         /* EOF handling */
1648         av_init_packet(&avpkt);
1649         avpkt.data = NULL;
1650         avpkt.size = 0;
1651         goto handle_eof;
1652     } else {
1653         avpkt = *pkt;
1654     }
1655
1656     if(pkt->dts != AV_NOPTS_VALUE){
1657         if(ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
1658             ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1659         pkt_dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1660     }
1661     if(pkt->pts != AV_NOPTS_VALUE)
1662         pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1663
1664     //while we have more to decode or while the decoder did output something on EOF
1665     while (avpkt.size > 0 || (!pkt && got_output)) {
1666         uint8_t *data_buf, *decoded_data_buf;
1667         int data_size, decoded_data_size;
1668         AVFrame *decoded_frame, *filtered_frame;
1669     handle_eof:
1670         ist->pts= ist->next_pts;
1671
1672         if(avpkt.size && avpkt.size != pkt->size)
1673             av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
1674                    "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1675             ist->showed_multi_packet_warning=1;
1676
1677         /* decode the packet if needed */
1678         decoded_frame    = filtered_frame = NULL;
1679         decoded_data_buf = NULL; /* fail safe */
1680         decoded_data_size= 0;
1681         data_buf  = avpkt.data;
1682         data_size = avpkt.size;
1683         subtitle_to_free = NULL;
1684         if (ist->decoding_needed) {
1685             switch(ist->st->codec->codec_type) {
1686             case AVMEDIA_TYPE_AUDIO:{
1687                 if(pkt && samples_size < FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1688                     samples_size = FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1689                     av_free(samples);
1690                     samples= av_malloc(samples_size);
1691                 }
1692                 decoded_data_size= samples_size;
1693                     /* XXX: could avoid copy if PCM 16 bits with same
1694                        endianness as CPU */
1695                 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1696                                             &avpkt);
1697                 if (ret < 0)
1698                     return ret;
1699                 avpkt.data += ret;
1700                 avpkt.size -= ret;
1701                 data_size   = ret;
1702                 got_output  = decoded_data_size > 0;
1703                 /* Some bug in mpeg audio decoder gives */
1704                 /* decoded_data_size < 0, it seems they are overflows */
1705                 if (!got_output) {
1706                     /* no audio frame */
1707                     continue;
1708                 }
1709                 decoded_data_buf = (uint8_t *)samples;
1710                 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1711                     (ist->st->codec->sample_rate * ist->st->codec->channels);
1712                 break;}
1713             case AVMEDIA_TYPE_VIDEO:
1714                     if (!(decoded_frame = avcodec_alloc_frame()))
1715                         return AVERROR(ENOMEM);
1716                     avpkt.pts = pkt_pts;
1717                     avpkt.dts = pkt_dts;
1718                     pkt_pts = AV_NOPTS_VALUE;
1719                     if(pkt_dts != AV_NOPTS_VALUE && ist->st->codec->time_base.num != 0) {
1720                         int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1721                         pkt_dts += ((int64_t)AV_TIME_BASE *
1722                                           ist->st->codec->time_base.num * ticks) /
1723                             ist->st->codec->time_base.den;
1724                     }else
1725                         pkt_dts = AV_NOPTS_VALUE;
1726
1727                     ret = avcodec_decode_video2(ist->st->codec,
1728                                                 decoded_frame, &got_output, &avpkt);
1729                     quality = same_quant ? decoded_frame->quality : 0;
1730                     if (ret < 0)
1731                         goto fail;
1732                     if (!got_output) {
1733                         /* no picture yet */
1734                         av_freep(&decoded_frame);
1735                         goto discard_packet;
1736                     }
1737
1738                     if(decoded_frame->best_effort_timestamp != AV_NOPTS_VALUE)
1739                         ist->next_pts = ist->pts = decoded_frame->best_effort_timestamp;
1740
1741                     if (ist->st->codec->time_base.num != 0) {
1742                         int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1743                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1744                                           ist->st->codec->time_base.num * ticks) /
1745                             ist->st->codec->time_base.den;
1746                     }
1747                     avpkt.size = 0;
1748                     buffer_to_free = NULL;
1749                     pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
1750                     break;
1751             case AVMEDIA_TYPE_SUBTITLE:
1752                 ret = avcodec_decode_subtitle2(ist->st->codec,
1753                                                &subtitle, &got_output, &avpkt);
1754                 if (ret < 0)
1755                     return ret;
1756                 if (!got_output) {
1757                     goto discard_packet;
1758                 }
1759                 subtitle_to_free = &subtitle;
1760                 avpkt.size = 0;
1761                 break;
1762             default:
1763                 return -1;
1764             }
1765         } else {
1766             switch(ist->st->codec->codec_type) {
1767             case AVMEDIA_TYPE_AUDIO:
1768                 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1769                     ist->st->codec->sample_rate;
1770                 break;
1771             case AVMEDIA_TYPE_VIDEO:
1772                 if (ist->st->codec->time_base.num != 0) {
1773                     int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1774                     ist->next_pts += ((int64_t)AV_TIME_BASE *
1775                                       ist->st->codec->time_base.num * ticks) /
1776                         ist->st->codec->time_base.den;
1777                 }
1778                 break;
1779             }
1780             avpkt.size = 0;
1781         }
1782
1783 #if CONFIG_AVFILTER
1784         if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1785         for(i=0;i<nb_ostreams;i++) {
1786             OutputFile *of = &output_files[ost_table[i].file_index];
1787             if (of->start_time == 0 || ist->pts >= of->start_time) {
1788                 ost = &ost_table[i];
1789                 if (ost->input_video_filter && ost->source_index == ist_index) {
1790                     if (!decoded_frame->sample_aspect_ratio.num)
1791                         decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
1792                     decoded_frame->pts = ist->pts;
1793
1794                     av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, AV_VSRC_BUF_FLAG_OVERWRITE);
1795                 }
1796             }
1797         }
1798 #endif
1799
1800         // preprocess audio (volume)
1801         if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1802             if (audio_volume != 256) {
1803                 switch (ist->st->codec->sample_fmt) {
1804                 case AV_SAMPLE_FMT_U8:
1805                 {
1806                     uint8_t *volp = samples;
1807                     for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1808                         int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1809                         *volp++ = av_clip_uint8(v);
1810                     }
1811                     break;
1812                 }
1813                 case AV_SAMPLE_FMT_S16:
1814                 {
1815                     int16_t *volp = samples;
1816                     for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1817                         int v = ((*volp) * audio_volume + 128) >> 8;
1818                         *volp++ = av_clip_int16(v);
1819                     }
1820                     break;
1821                 }
1822                 case AV_SAMPLE_FMT_S32:
1823                 {
1824                     int32_t *volp = samples;
1825                     for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1826                         int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1827                         *volp++ = av_clipl_int32(v);
1828                     }
1829                     break;
1830                 }
1831                 case AV_SAMPLE_FMT_FLT:
1832                 {
1833                     float *volp = samples;
1834                     float scale = audio_volume / 256.f;
1835                     for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1836                         *volp++ *= scale;
1837                     }
1838                     break;
1839                 }
1840                 case AV_SAMPLE_FMT_DBL:
1841                 {
1842                     double *volp = samples;
1843                     double scale = audio_volume / 256.;
1844                     for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1845                         *volp++ *= scale;
1846                     }
1847                     break;
1848                 }
1849                 default:
1850                     av_log(NULL, AV_LOG_FATAL,
1851                            "Audio volume adjustment on sample format %s is not supported.\n",
1852                            av_get_sample_fmt_name(ist->st->codec->sample_fmt));
1853                     exit_program(1);
1854                 }
1855             }
1856         }
1857
1858         /* frame rate emulation */
1859         if (input_files[ist->file_index].rate_emu) {
1860             int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1861             int64_t now = av_gettime() - ist->start;
1862             if (pts > now)
1863                 usleep(pts - now);
1864         }
1865         /* if output time reached then transcode raw format,
1866            encode packets and output them */
1867         for (i = 0; i < nb_ostreams; i++) {
1868             OutputFile *of = &output_files[ost_table[i].file_index];
1869             int frame_size;
1870
1871             ost = &ost_table[i];
1872             if (ost->source_index != ist_index)
1873                 continue;
1874
1875             if (of->start_time && ist->pts < of->start_time)
1876                 continue;
1877
1878             if (of->recording_time != INT64_MAX &&
1879                 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1880                               (AVRational){1, 1000000}) >= 0) {
1881                 ost->is_past_recording_time = 1;
1882                 continue;
1883             }
1884
1885 #if CONFIG_AVFILTER
1886             frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1887                 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1888             while (frame_available) {
1889                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
1890                     AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1891                     if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
1892                         goto cont;
1893                     if (!filtered_frame && !(filtered_frame = avcodec_alloc_frame())) {
1894                         ret = AVERROR(ENOMEM);
1895                         goto fail;
1896                     }
1897                     *filtered_frame= *decoded_frame; //for me_threshold
1898                     if (ost->picref) {
1899                         avfilter_fill_frame_from_video_buffer_ref(filtered_frame, ost->picref);
1900                         ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1901                     }
1902                 }
1903 #else
1904                 filtered_frame = decoded_frame;
1905 #endif
1906                 os = output_files[ost->file_index].ctx;
1907
1908                 /* set the input output pts pairs */
1909                 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1910
1911                 if (ost->encoding_needed) {
1912                     av_assert0(ist->decoding_needed);
1913                     switch(ost->st->codec->codec_type) {
1914                     case AVMEDIA_TYPE_AUDIO:
1915                         do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1916                         break;
1917                     case AVMEDIA_TYPE_VIDEO:
1918 #if CONFIG_AVFILTER
1919                         if (ost->picref->video && !ost->frame_aspect_ratio)
1920                             ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1921 #endif
1922                         do_video_out(os, ost, ist, filtered_frame, &frame_size,
1923                                      same_quant ? quality : ost->st->codec->global_quality);
1924                         if (vstats_filename && frame_size)
1925                             do_video_stats(os, ost, frame_size);
1926                         break;
1927                     case AVMEDIA_TYPE_SUBTITLE:
1928                         do_subtitle_out(os, ost, ist, &subtitle,
1929                                         pkt->pts);
1930                         break;
1931                     default:
1932                         abort();
1933                     }
1934                 } else {
1935                     AVPicture pict;
1936                     AVPacket opkt;
1937                     int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1938                     av_init_packet(&opkt);
1939
1940                     if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1941                         !ost->copy_initial_nonkeyframes)
1942 #if !CONFIG_AVFILTER
1943                         continue;
1944 #else
1945                         goto cont;
1946 #endif
1947
1948                     /* no reencoding needed : output the packet directly */
1949                     /* force the input stream PTS */
1950
1951                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1952                         audio_size += data_size;
1953                     else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1954                         video_size += data_size;
1955                         ost->sync_opts++;
1956                     }
1957
1958                     opkt.stream_index= ost->index;
1959                     if(pkt->pts != AV_NOPTS_VALUE)
1960                         opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1961                     else
1962                         opkt.pts= AV_NOPTS_VALUE;
1963
1964                     if (pkt->dts == AV_NOPTS_VALUE)
1965                         opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1966                     else
1967                         opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1968                     opkt.dts -= ost_tb_start_time;
1969
1970                     opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1971                     opkt.flags= pkt->flags;
1972
1973                     //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1974                     if(   ost->st->codec->codec_id != CODEC_ID_H264
1975                        && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1976                        && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1977                        ) {
1978                         if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1979                             opkt.destruct= av_destruct_packet;
1980                     } else {
1981                         opkt.data = data_buf;
1982                         opkt.size = data_size;
1983                     }
1984
1985                     if (os->oformat->flags & AVFMT_RAWPICTURE) {
1986                         /* store AVPicture in AVPacket, as expected by the output format */
1987                         avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1988                         opkt.data = (uint8_t *)&pict;
1989                         opkt.size = sizeof(AVPicture);
1990                         opkt.flags |= AV_PKT_FLAG_KEY;
1991                     }
1992                     write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1993                     ost->st->codec->frame_number++;
1994                     ost->frame_number++;
1995                     av_free_packet(&opkt);
1996                 }
1997 #if CONFIG_AVFILTER
1998                 cont:
1999                 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
2000                                    ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
2001                 avfilter_unref_buffer(ost->picref);
2002             }
2003             av_freep(&filtered_frame);
2004 #endif
2005         }
2006
2007 fail:
2008         av_free(buffer_to_free);
2009         /* XXX: allocate the subtitles in the codec ? */
2010         if (subtitle_to_free) {
2011             avsubtitle_free(subtitle_to_free);
2012             subtitle_to_free = NULL;
2013         }
2014         av_freep(&decoded_frame);
2015         if (ret < 0)
2016             return ret;
2017     }
2018  discard_packet:
2019
2020     return 0;
2021 }
2022
2023 static void print_sdp(OutputFile *output_files, int n)
2024 {
2025     char sdp[2048];
2026     int i;
2027     AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
2028
2029     if (!avc)
2030         exit_program(1);
2031     for (i = 0; i < n; i++)
2032         avc[i] = output_files[i].ctx;
2033
2034     av_sdp_create(avc, n, sdp, sizeof(sdp));
2035     printf("SDP:\n%s\n", sdp);
2036     fflush(stdout);
2037     av_freep(&avc);
2038 }
2039
2040 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
2041                              char *error, int error_len)
2042 {
2043     InputStream *ist = &input_streams[ist_index];
2044     if (ist->decoding_needed) {
2045         AVCodec *codec = ist->dec;
2046         if (!codec) {
2047             snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2048                     avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2049             return AVERROR(EINVAL);
2050         }
2051         if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2052             snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2053                     ist->file_index, ist->st->index);
2054             return AVERROR(EINVAL);
2055         }
2056         assert_codec_experimental(ist->st->codec, 0);
2057         assert_avoptions(ist->opts);
2058     }
2059
2060     ist->pts = ist->st->avg_frame_rate.num ? - ist->st->codec->has_b_frames*AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
2061     ist->next_pts = AV_NOPTS_VALUE;
2062     ist->is_start = 1;
2063
2064     return 0;
2065 }
2066
2067 static int transcode_init(OutputFile *output_files, int nb_output_files,
2068                           InputFile  *input_files,  int nb_input_files)
2069 {
2070     int ret = 0, i, j, k;
2071     AVFormatContext *os;
2072     AVCodecContext *codec, *icodec;
2073     OutputStream *ost;
2074     InputStream *ist;
2075     char error[1024];
2076     int want_sdp = 1;
2077
2078     /* init framerate emulation */
2079     for (i = 0; i < nb_input_files; i++) {
2080         InputFile *ifile = &input_files[i];
2081         if (ifile->rate_emu)
2082             for (j = 0; j < ifile->nb_streams; j++)
2083                 input_streams[j + ifile->ist_index].start = av_gettime();
2084     }
2085
2086     /* output stream init */
2087     for(i=0;i<nb_output_files;i++) {
2088         os = output_files[i].ctx;
2089         if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2090             av_dump_format(os, i, os->filename, 1);
2091             av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2092             return AVERROR(EINVAL);
2093         }
2094     }
2095
2096     /* for each output stream, we compute the right encoding parameters */
2097     for (i = 0; i < nb_output_streams; i++) {
2098         ost = &output_streams[i];
2099         os = output_files[ost->file_index].ctx;
2100         ist = &input_streams[ost->source_index];
2101
2102         if (ost->attachment_filename)
2103             continue;
2104
2105         codec = ost->st->codec;
2106         icodec = ist->st->codec;
2107
2108         ost->st->disposition = ist->st->disposition;
2109         codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2110         codec->chroma_sample_location = icodec->chroma_sample_location;
2111
2112         if (ost->stream_copy) {
2113             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2114
2115             if (extra_size > INT_MAX) {
2116                 return AVERROR(EINVAL);
2117             }
2118
2119             /* if stream_copy is selected, no need to decode or encode */
2120             codec->codec_id = icodec->codec_id;
2121             codec->codec_type = icodec->codec_type;
2122
2123             if(!codec->codec_tag){
2124                 if(   !os->oformat->codec_tag
2125                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2126                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2127                     codec->codec_tag = icodec->codec_tag;
2128             }
2129
2130             codec->bit_rate = icodec->bit_rate;
2131             codec->rc_max_rate    = icodec->rc_max_rate;
2132             codec->rc_buffer_size = icodec->rc_buffer_size;
2133             codec->extradata= av_mallocz(extra_size);
2134             if (!codec->extradata) {
2135                 return AVERROR(ENOMEM);
2136             }
2137             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2138             codec->extradata_size= icodec->extradata_size;
2139
2140             codec->time_base = ist->st->time_base;
2141             if(!strcmp(os->oformat->name, "avi")) {
2142                 if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
2143                     codec->time_base = icodec->time_base;
2144                     codec->time_base.num *= icodec->ticks_per_frame;
2145                     codec->time_base.den *= 2;
2146                 }
2147             } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
2148                 if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
2149                     codec->time_base = icodec->time_base;
2150                     codec->time_base.num *= icodec->ticks_per_frame;
2151                 }
2152             }
2153             av_reduce(&codec->time_base.num, &codec->time_base.den,
2154                         codec->time_base.num, codec->time_base.den, INT_MAX);
2155
2156             switch(codec->codec_type) {
2157             case AVMEDIA_TYPE_AUDIO:
2158                 if(audio_volume != 256) {
2159                     av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2160                     exit_program(1);
2161                 }
2162                 codec->channel_layout = icodec->channel_layout;
2163                 codec->sample_rate = icodec->sample_rate;
2164                 codec->channels = icodec->channels;
2165                 codec->frame_size = icodec->frame_size;
2166                 codec->audio_service_type = icodec->audio_service_type;
2167                 codec->block_align= icodec->block_align;
2168                 break;
2169             case AVMEDIA_TYPE_VIDEO:
2170                 codec->pix_fmt = icodec->pix_fmt;
2171                 codec->width = icodec->width;
2172                 codec->height = icodec->height;
2173                 codec->has_b_frames = icodec->has_b_frames;
2174                 if (!codec->sample_aspect_ratio.num) {
2175                     codec->sample_aspect_ratio =
2176                     ost->st->sample_aspect_ratio =
2177                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2178                         ist->st->codec->sample_aspect_ratio.num ?
2179                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2180                 }
2181                 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
2182                 break;
2183             case AVMEDIA_TYPE_SUBTITLE:
2184                 codec->width = icodec->width;
2185                 codec->height = icodec->height;
2186                 break;
2187             case AVMEDIA_TYPE_DATA:
2188             case AVMEDIA_TYPE_ATTACHMENT:
2189                 break;
2190             default:
2191                 abort();
2192             }
2193         } else {
2194             if (!ost->enc)
2195                 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2196             ist->decoding_needed = 1;
2197             ost->encoding_needed = 1;
2198             switch(codec->codec_type) {
2199             case AVMEDIA_TYPE_AUDIO:
2200                 ost->fifo= av_fifo_alloc(1024);
2201                 if (!ost->fifo) {
2202                     return AVERROR(ENOMEM);
2203                 }
2204                 if (!codec->sample_rate)
2205                     codec->sample_rate = icodec->sample_rate;
2206                 choose_sample_rate(ost->st, ost->enc);
2207                 codec->time_base = (AVRational){1, codec->sample_rate};
2208                 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2209                     codec->sample_fmt = icodec->sample_fmt;
2210                 choose_sample_fmt(ost->st, ost->enc);
2211                 if (ost->audio_channels_mapped) {
2212                     /* the requested output channel is set to the number of
2213                      * -map_channel only if no -ac are specified */
2214                     if (!codec->channels) {
2215                         codec->channels       = ost->audio_channels_mapped;
2216                         codec->channel_layout = av_get_default_channel_layout(codec->channels);
2217                         if (!codec->channel_layout) {
2218                             av_log(NULL, AV_LOG_FATAL, "Unable to find an appropriate channel layout for requested number of channel\n");
2219                             exit_program(1);
2220                         }
2221                     }
2222                     /* fill unused channel mapping with -1 (which means a muted
2223                      * channel in case the number of output channels is bigger
2224                      * than the number of mapped channel) */
2225                     for (j = ost->audio_channels_mapped; j < FF_ARRAY_ELEMS(ost->audio_channels_map); j++)
2226                         ost->audio_channels_map[j] = -1;
2227                 } else if (!codec->channels) {
2228                     codec->channels = icodec->channels;
2229                     codec->channel_layout = icodec->channel_layout;
2230                 }
2231                 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2232                     codec->channel_layout = 0;
2233                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2234                 ost->audio_resample |=    codec->sample_fmt     != icodec->sample_fmt
2235                                        || codec->channel_layout != icodec->channel_layout;
2236                 icodec->request_channels = codec->channels;
2237                 ost->resample_sample_fmt  = icodec->sample_fmt;
2238                 ost->resample_sample_rate = icodec->sample_rate;
2239                 ost->resample_channels    = icodec->channels;
2240                 break;
2241             case AVMEDIA_TYPE_VIDEO:
2242                 if (codec->pix_fmt == PIX_FMT_NONE)
2243                     codec->pix_fmt = icodec->pix_fmt;
2244                 choose_pixel_fmt(ost->st, ost->enc);
2245
2246                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2247                     av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2248                     exit_program(1);
2249                 }
2250
2251                 if (!codec->width || !codec->height) {
2252                     codec->width  = icodec->width;
2253                     codec->height = icodec->height;
2254                 }
2255
2256                 ost->video_resample = codec->width   != icodec->width  ||
2257                                       codec->height  != icodec->height ||
2258                                       codec->pix_fmt != icodec->pix_fmt;
2259                 if (ost->video_resample) {
2260                     codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2261                 }
2262
2263                 ost->resample_height = icodec->height;
2264                 ost->resample_width  = icodec->width;
2265                 ost->resample_pix_fmt= icodec->pix_fmt;
2266
2267                 if (!ost->frame_rate.num)
2268                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2269                 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2270                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2271                     ost->frame_rate = ost->enc->supported_framerates[idx];
2272                 }
2273                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2274                 if(   av_q2d(codec->time_base) < 0.001 && video_sync_method
2275                    && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2276                     av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2277                                                "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2278                 }
2279                 for (j = 0; j < ost->forced_kf_count; j++)
2280                     ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
2281                                                          AV_TIME_BASE_Q,
2282                                                          codec->time_base);
2283
2284 #if CONFIG_AVFILTER
2285                 if (configure_video_filters(ist, ost)) {
2286                     av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2287                     exit(1);
2288                 }
2289 #endif
2290                 break;
2291             case AVMEDIA_TYPE_SUBTITLE:
2292                 break;
2293             default:
2294                 abort();
2295                 break;
2296             }
2297             /* two pass mode */
2298             if (codec->codec_id != CODEC_ID_H264 &&
2299                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2300                 char logfilename[1024];
2301                 FILE *f;
2302
2303                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2304                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2305                          i);
2306                 if (codec->flags & CODEC_FLAG_PASS2) {
2307                     char  *logbuffer;
2308                     size_t logbuffer_size;
2309                     if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2310                         av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2311                                logfilename);
2312                         exit_program(1);
2313                     }
2314                     codec->stats_in = logbuffer;
2315                 }
2316                 if (codec->flags & CODEC_FLAG_PASS1) {
2317                     f = fopen(logfilename, "wb");
2318                     if (!f) {
2319                         av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2320                                logfilename, strerror(errno));
2321                         exit_program(1);
2322                     }
2323                     ost->logfile = f;
2324                 }
2325             }
2326         }
2327         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2328             /* maximum video buffer size is 6-bytes per pixel, plus DPX header size (1664)*/
2329             int size= codec->width * codec->height;
2330             bit_buffer_size= FFMAX(bit_buffer_size, 7*size + 10000);
2331         }
2332     }
2333
2334     if (!bit_buffer)
2335         bit_buffer = av_malloc(bit_buffer_size);
2336     if (!bit_buffer) {
2337         av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2338                bit_buffer_size);
2339         return AVERROR(ENOMEM);
2340     }
2341
2342     /* open each encoder */
2343     for (i = 0; i < nb_output_streams; i++) {
2344         ost = &output_streams[i];
2345         if (ost->encoding_needed) {
2346             AVCodec *codec = ost->enc;
2347             AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2348             if (!codec) {
2349                 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
2350                          avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2351                 ret = AVERROR(EINVAL);
2352                 goto dump_format;
2353             }
2354             if (dec->subtitle_header) {
2355                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2356                 if (!ost->st->codec->subtitle_header) {
2357                     ret = AVERROR(ENOMEM);
2358                     goto dump_format;
2359                 }
2360                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2361                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2362             }
2363             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2364                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2365                         ost->file_index, ost->index);
2366                 ret = AVERROR(EINVAL);
2367                 goto dump_format;
2368             }
2369             assert_codec_experimental(ost->st->codec, 1);
2370             assert_avoptions(ost->opts);
2371             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2372                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2373                                              " It takes bits/s as argument, not kbits/s\n");
2374             extra_size += ost->st->codec->extradata_size;
2375
2376             if (ost->st->codec->me_threshold)
2377                 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2378         }
2379     }
2380
2381     /* init input streams */
2382     for (i = 0; i < nb_input_streams; i++)
2383         if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2384             goto dump_format;
2385
2386     /* discard unused programs */
2387     for (i = 0; i < nb_input_files; i++) {
2388         InputFile *ifile = &input_files[i];
2389         for (j = 0; j < ifile->ctx->nb_programs; j++) {
2390             AVProgram *p = ifile->ctx->programs[j];
2391             int discard  = AVDISCARD_ALL;
2392
2393             for (k = 0; k < p->nb_stream_indexes; k++)
2394                 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2395                     discard = AVDISCARD_DEFAULT;
2396                     break;
2397                 }
2398             p->discard = discard;
2399         }
2400     }
2401
2402     /* open files and write file headers */
2403     for (i = 0; i < nb_output_files; i++) {
2404         os = output_files[i].ctx;
2405         if (avformat_write_header(os, &output_files[i].opts) < 0) {
2406             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2407             ret = AVERROR(EINVAL);
2408             goto dump_format;
2409         }
2410 //        assert_avoptions(output_files[i].opts);
2411         if (strcmp(os->oformat->name, "rtp")) {
2412             want_sdp = 0;
2413         }
2414     }
2415
2416  dump_format:
2417     /* dump the file output parameters - cannot be done before in case
2418        of stream copy */
2419     for(i=0;i<nb_output_files;i++) {
2420         av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2421     }
2422
2423     /* dump the stream mapping */
2424     av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2425     for (i = 0; i < nb_output_streams; i++) {
2426         ost = &output_streams[i];
2427
2428         if (ost->attachment_filename) {
2429             /* an attached file */
2430             av_log(NULL, AV_LOG_INFO, "  File %s -> Stream #%d:%d\n",
2431                    ost->attachment_filename, ost->file_index, ost->index);
2432             continue;
2433         }
2434         av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d -> #%d:%d",
2435                input_streams[ost->source_index].file_index,
2436                input_streams[ost->source_index].st->index,
2437                ost->file_index,
2438                ost->index);
2439         if (ost->audio_channels_mapped) {
2440             av_log(NULL, AV_LOG_INFO, " [ch:");
2441             for (j = 0; j < ost->audio_channels_mapped; j++)
2442                 if (ost->audio_channels_map[j] == -1)
2443                     av_log(NULL, AV_LOG_INFO, " M");
2444                 else
2445                     av_log(NULL, AV_LOG_INFO, " %d", ost->audio_channels_map[j]);
2446             av_log(NULL, AV_LOG_INFO, "]");
2447         }
2448         if (ost->sync_ist != &input_streams[ost->source_index])
2449             av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2450                    ost->sync_ist->file_index,
2451                    ost->sync_ist->st->index);
2452         if (ost->stream_copy)
2453             av_log(NULL, AV_LOG_INFO, " (copy)");
2454         else
2455             av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2456                    input_streams[ost->source_index].dec->name : "?",
2457                    ost->enc ? ost->enc->name : "?");
2458         av_log(NULL, AV_LOG_INFO, "\n");
2459     }
2460
2461     if (ret) {
2462         av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2463         return ret;
2464     }
2465
2466     if (want_sdp) {
2467         print_sdp(output_files, nb_output_files);
2468     }
2469
2470     return 0;
2471 }
2472
2473 /*
2474  * The following code is the main loop of the file converter
2475  */
2476 static int transcode(OutputFile *output_files, int nb_output_files,
2477                      InputFile  *input_files,  int nb_input_files)
2478 {
2479     int ret, i;
2480     AVFormatContext *is, *os;
2481     OutputStream *ost;
2482     InputStream *ist;
2483     uint8_t *no_packet;
2484     int no_packet_count=0;
2485     int64_t timer_start;
2486     int key;
2487
2488     if (!(no_packet = av_mallocz(nb_input_files)))
2489         exit_program(1);
2490
2491     ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2492     if (ret < 0)
2493         goto fail;
2494
2495     if (!using_stdin) {
2496         av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2497         avio_set_interrupt_cb(decode_interrupt_cb);
2498     }
2499
2500     timer_start = av_gettime();
2501
2502     for(; received_sigterm == 0;) {
2503         int file_index, ist_index;
2504         AVPacket pkt;
2505         int64_t ipts_min;
2506         double opts_min;
2507         int64_t cur_time= av_gettime();
2508
2509         ipts_min= INT64_MAX;
2510         opts_min= 1e100;
2511         /* if 'q' pressed, exits */
2512         if (!using_stdin) {
2513             static int64_t last_time;
2514             if (received_nb_signals)
2515                 break;
2516             /* read_key() returns 0 on EOF */
2517             if(cur_time - last_time >= 100000 && !run_as_daemon){
2518                 key =  read_key();
2519                 last_time = cur_time;
2520             }else
2521                 key = -1;
2522             if (key == 'q')
2523                 break;
2524             if (key == '+') av_log_set_level(av_log_get_level()+10);
2525             if (key == '-') av_log_set_level(av_log_get_level()-10);
2526             if (key == 's') qp_hist     ^= 1;
2527             if (key == 'h'){
2528                 if (do_hex_dump){
2529                     do_hex_dump = do_pkt_dump = 0;
2530                 } else if(do_pkt_dump){
2531                     do_hex_dump = 1;
2532                 } else
2533                     do_pkt_dump = 1;
2534                 av_log_set_level(AV_LOG_DEBUG);
2535             }
2536 #if CONFIG_AVFILTER
2537             if (key == 'c' || key == 'C'){
2538                 char buf[4096], target[64], command[256], arg[256] = {0};
2539                 double time;
2540                 int k, n = 0;
2541                 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2542                 i = 0;
2543                 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
2544                     if (k > 0)
2545                         buf[i++] = k;
2546                 buf[i] = 0;
2547                 if (k > 0 &&
2548                     (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
2549                     av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
2550                            target, time, command, arg);
2551                     for (i = 0; i < nb_output_streams; i++) {
2552                         ost = &output_streams[i];
2553                         if (ost->graph) {
2554                             if (time < 0) {
2555                                 ret = avfilter_graph_send_command(ost->graph, target, command, arg, buf, sizeof(buf),
2556                                                                   key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2557                                 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
2558                             } else {
2559                                 ret = avfilter_graph_queue_command(ost->graph, target, command, arg, 0, time);
2560                             }
2561                         }
2562                     }
2563                 } else {
2564                     av_log(NULL, AV_LOG_ERROR,
2565                            "Parse error, at least 3 arguments were expected, "
2566                            "only %d given in string '%s'\n", n, buf);
2567                 }
2568             }
2569 #endif
2570             if (key == 'd' || key == 'D'){
2571                 int debug=0;
2572                 if(key == 'D') {
2573                     debug = input_streams[0].st->codec->debug<<1;
2574                     if(!debug) debug = 1;
2575                     while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2576                         debug += debug;
2577                 }else
2578                     scanf("%d", &debug);
2579                 for(i=0;i<nb_input_streams;i++) {
2580                     input_streams[i].st->codec->debug = debug;
2581                 }
2582                 for(i=0;i<nb_output_streams;i++) {
2583                     ost = &output_streams[i];
2584                     ost->st->codec->debug = debug;
2585                 }
2586                 if(debug) av_log_set_level(AV_LOG_DEBUG);
2587                 fprintf(stderr,"debug=%d\n", debug);
2588             }
2589             if (key == '?'){
2590                 fprintf(stderr, "key    function\n"
2591                                 "?      show this help\n"
2592                                 "+      increase verbosity\n"
2593                                 "-      decrease verbosity\n"
2594                                 "c      Send command to filtergraph\n"
2595                                 "D      cycle through available debug modes\n"
2596                                 "h      dump packets/hex press to cycle through the 3 states\n"
2597                                 "q      quit\n"
2598                                 "s      Show QP histogram\n"
2599                 );
2600             }
2601         }
2602
2603         /* select the stream that we must read now by looking at the
2604            smallest output pts */
2605         file_index = -1;
2606         for (i = 0; i < nb_output_streams; i++) {
2607             OutputFile *of;
2608             int64_t ipts;
2609             double  opts;
2610             ost = &output_streams[i];
2611             of = &output_files[ost->file_index];
2612             os = output_files[ost->file_index].ctx;
2613             ist = &input_streams[ost->source_index];
2614             if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2615                 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2616                 continue;
2617             opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2618             ipts = ist->pts;
2619             if (!input_files[ist->file_index].eof_reached){
2620                 if(ipts < ipts_min) {
2621                     ipts_min = ipts;
2622                     if(input_sync ) file_index = ist->file_index;
2623                 }
2624                 if(opts < opts_min) {
2625                     opts_min = opts;
2626                     if(!input_sync) file_index = ist->file_index;
2627                 }
2628             }
2629             if (ost->frame_number >= ost->max_frames) {
2630                 int j;
2631                 for (j = 0; j < of->ctx->nb_streams; j++)
2632                     output_streams[of->ost_index + j].is_past_recording_time = 1;
2633                 continue;
2634             }
2635         }
2636         /* if none, if is finished */
2637         if (file_index < 0) {
2638             if(no_packet_count){
2639                 no_packet_count=0;
2640                 memset(no_packet, 0, nb_input_files);
2641                 usleep(10000);
2642                 continue;
2643             }
2644             break;
2645         }
2646
2647         /* read a frame from it and output it in the fifo */
2648         is = input_files[file_index].ctx;
2649         ret= av_read_frame(is, &pkt);
2650         if(ret == AVERROR(EAGAIN)){
2651             no_packet[file_index]=1;
2652             no_packet_count++;
2653             continue;
2654         }
2655         if (ret < 0) {
2656             input_files[file_index].eof_reached = 1;
2657             if (opt_shortest)
2658                 break;
2659             else
2660                 continue;
2661         }
2662
2663         no_packet_count=0;
2664         memset(no_packet, 0, nb_input_files);
2665
2666         if (do_pkt_dump) {
2667             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2668                              is->streams[pkt.stream_index]);
2669         }
2670         /* the following test is needed in case new streams appear
2671            dynamically in stream : we ignore them */
2672         if (pkt.stream_index >= input_files[file_index].nb_streams)
2673             goto discard_packet;
2674         ist_index = input_files[file_index].ist_index + pkt.stream_index;
2675         ist = &input_streams[ist_index];
2676         if (ist->discard)
2677             goto discard_packet;
2678
2679         if (pkt.dts != AV_NOPTS_VALUE)
2680             pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2681         if (pkt.pts != AV_NOPTS_VALUE)
2682             pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2683
2684         if(pkt.pts != AV_NOPTS_VALUE)
2685             pkt.pts *= ist->ts_scale;
2686         if(pkt.dts != AV_NOPTS_VALUE)
2687             pkt.dts *= ist->ts_scale;
2688
2689 //        fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files[ist->file_index].ts_offset, ist->st->codec->codec_type);
2690         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2691             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2692             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2693             int64_t delta= pkt_dts - ist->next_pts;
2694             if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2695                 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2696                  ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2697                 pkt_dts+1<ist->pts)&& !copy_ts){
2698                 input_files[ist->file_index].ts_offset -= delta;
2699                 av_log(NULL, AV_LOG_DEBUG, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2700                        delta, input_files[ist->file_index].ts_offset);
2701                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2702                 if(pkt.pts != AV_NOPTS_VALUE)
2703                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2704             }
2705         }
2706
2707         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2708         if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2709
2710             av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
2711                    ist->file_index, ist->st->index);
2712             if (exit_on_error)
2713                 exit_program(1);
2714             av_free_packet(&pkt);
2715             continue;
2716         }
2717
2718     discard_packet:
2719         av_free_packet(&pkt);
2720
2721         /* dump report by using the output first video and audio streams */
2722         print_report(output_files, output_streams, nb_output_streams, 0, timer_start, cur_time);
2723     }
2724
2725     /* at the end of stream, we must flush the decoder buffers */
2726     for (i = 0; i < nb_input_streams; i++) {
2727         ist = &input_streams[i];
2728         if (ist->decoding_needed) {
2729             output_packet(ist, i, output_streams, nb_output_streams, NULL);
2730         }
2731     }
2732     flush_encoders(output_streams, nb_output_streams);
2733
2734     term_exit();
2735
2736     /* write the trailer if needed and close file */
2737     for(i=0;i<nb_output_files;i++) {
2738         os = output_files[i].ctx;
2739         av_write_trailer(os);
2740     }
2741
2742     /* dump report by using the first video and audio streams */
2743     print_report(output_files, output_streams, nb_output_streams, 1, timer_start, av_gettime());
2744
2745     /* close each encoder */
2746     for (i = 0; i < nb_output_streams; i++) {
2747         ost = &output_streams[i];
2748         if (ost->encoding_needed) {
2749             av_freep(&ost->st->codec->stats_in);
2750             avcodec_close(ost->st->codec);
2751         }
2752 #if CONFIG_AVFILTER
2753         avfilter_graph_free(&ost->graph);
2754 #endif
2755     }
2756
2757     /* close each decoder */
2758     for (i = 0; i < nb_input_streams; i++) {
2759         ist = &input_streams[i];
2760         if (ist->decoding_needed) {
2761             avcodec_close(ist->st->codec);
2762         }
2763     }
2764
2765     /* finished ! */
2766     ret = 0;
2767
2768  fail:
2769     av_freep(&bit_buffer);
2770     av_freep(&no_packet);
2771
2772     if (output_streams) {
2773         for (i = 0; i < nb_output_streams; i++) {
2774             ost = &output_streams[i];
2775             if (ost) {
2776                 if (ost->stream_copy)
2777                     av_freep(&ost->st->codec->extradata);
2778                 if (ost->logfile) {
2779                     fclose(ost->logfile);
2780                     ost->logfile = NULL;
2781                 }
2782                 av_fifo_free(ost->fifo); /* works even if fifo is not
2783                                              initialized but set to zero */
2784                 av_freep(&ost->st->codec->subtitle_header);
2785                 av_free(ost->resample_frame.data[0]);
2786                 av_free(ost->forced_kf_pts);
2787                 if (ost->video_resample)
2788                     sws_freeContext(ost->img_resample_ctx);
2789                 swr_free(&ost->swr);
2790                 av_dict_free(&ost->opts);
2791             }
2792         }
2793     }
2794     return ret;
2795 }
2796
2797 static int opt_frame_crop(const char *opt, const char *arg)
2798 {
2799     av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
2800     return AVERROR(EINVAL);
2801 }
2802
2803 static int opt_pad(const char *opt, const char *arg)
2804 {
2805     av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
2806     return -1;
2807 }
2808
2809 static double parse_frame_aspect_ratio(const char *arg)
2810 {
2811     int x = 0, y = 0;
2812     double ar = 0;
2813     const char *p;
2814     char *end;
2815
2816     p = strchr(arg, ':');
2817     if (p) {
2818         x = strtol(arg, &end, 10);
2819         if (end == p)
2820             y = strtol(end+1, &end, 10);
2821         if (x > 0 && y > 0)
2822             ar = (double)x / (double)y;
2823     } else
2824         ar = strtod(arg, NULL);
2825
2826     if (!ar) {
2827         av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2828         exit_program(1);
2829     }
2830     return ar;
2831 }
2832
2833 static int opt_video_channel(const char *opt, const char *arg)
2834 {
2835     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2836     return opt_default("channel", arg);
2837 }
2838
2839 static int opt_video_standard(const char *opt, const char *arg)
2840 {
2841     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2842     return opt_default("standard", arg);
2843 }
2844
2845 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2846 {
2847     audio_codec_name = arg;
2848     return parse_option(o, "codec:a", arg, options);
2849 }
2850
2851 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2852 {
2853     video_codec_name = arg;
2854     return parse_option(o, "codec:v", arg, options);
2855 }
2856
2857 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2858 {
2859     subtitle_codec_name = arg;
2860     return parse_option(o, "codec:s", arg, options);
2861 }
2862
2863 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2864 {
2865     return parse_option(o, "codec:d", arg, options);
2866 }
2867
2868 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2869 {
2870     StreamMap *m = NULL;
2871     int i, negative = 0, file_idx;
2872     int sync_file_idx = -1, sync_stream_idx;
2873     char *p, *sync;
2874     char *map;
2875
2876     if (*arg == '-') {
2877         negative = 1;
2878         arg++;
2879     }
2880     map = av_strdup(arg);
2881
2882     /* parse sync stream first, just pick first matching stream */
2883     if (sync = strchr(map, ',')) {
2884         *sync = 0;
2885         sync_file_idx = strtol(sync + 1, &sync, 0);
2886         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2887             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2888             exit_program(1);
2889         }
2890         if (*sync)
2891             sync++;
2892         for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2893             if (check_stream_specifier(input_files[sync_file_idx].ctx,
2894                                        input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2895                 sync_stream_idx = i;
2896                 break;
2897             }
2898         if (i == input_files[sync_file_idx].nb_streams) {
2899             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2900                                        "match any streams.\n", arg);
2901             exit_program(1);
2902         }
2903     }
2904
2905
2906     file_idx = strtol(map, &p, 0);
2907     if (file_idx >= nb_input_files || file_idx < 0) {
2908         av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
2909         exit_program(1);
2910     }
2911     if (negative)
2912         /* disable some already defined maps */
2913         for (i = 0; i < o->nb_stream_maps; i++) {
2914             m = &o->stream_maps[i];
2915             if (file_idx == m->file_index &&
2916                 check_stream_specifier(input_files[m->file_index].ctx,
2917                                        input_files[m->file_index].ctx->streams[m->stream_index],
2918                                        *p == ':' ? p + 1 : p) > 0)
2919                 m->disabled = 1;
2920         }
2921     else
2922         for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2923             if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2924                         *p == ':' ? p + 1 : p) <= 0)
2925                 continue;
2926             o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2927                                         &o->nb_stream_maps, o->nb_stream_maps + 1);
2928             m = &o->stream_maps[o->nb_stream_maps - 1];
2929
2930             m->file_index   = file_idx;
2931             m->stream_index = i;
2932
2933             if (sync_file_idx >= 0) {
2934                 m->sync_file_index   = sync_file_idx;
2935                 m->sync_stream_index = sync_stream_idx;
2936             } else {
2937                 m->sync_file_index   = file_idx;
2938                 m->sync_stream_index = i;
2939             }
2940         }
2941
2942     if (!m) {
2943         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
2944         exit_program(1);
2945     }
2946
2947     av_freep(&map);
2948     return 0;
2949 }
2950
2951 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
2952 {
2953     o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
2954                                 &o->nb_attachments, o->nb_attachments + 1);
2955     o->attachments[o->nb_attachments - 1] = arg;
2956     return 0;
2957 }
2958
2959 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
2960 {
2961     int n;
2962     AVStream *st;
2963     AudioChannelMap *m;
2964
2965     o->audio_channel_maps =
2966         grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
2967                    &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
2968     m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
2969
2970     /* muted channel syntax */
2971     n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
2972     if ((n == 1 || n == 3) && m->channel_idx == -1) {
2973         m->file_idx = m->stream_idx = -1;
2974         if (n == 1)
2975             m->ofile_idx = m->ostream_idx = -1;
2976         return 0;
2977     }
2978
2979     /* normal syntax */
2980     n = sscanf(arg, "%d.%d.%d:%d.%d",
2981                &m->file_idx,  &m->stream_idx, &m->channel_idx,
2982                &m->ofile_idx, &m->ostream_idx);
2983
2984     if (n != 3 && n != 5) {
2985         av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
2986                "[file.stream.channel|-1][:syncfile:syncstream]\n");
2987         exit_program(1);
2988     }
2989
2990     if (n != 5) // only file.stream.channel specified
2991         m->ofile_idx = m->ostream_idx = -1;
2992
2993     /* check input */
2994     if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
2995         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
2996                m->file_idx);
2997         exit_program(1);
2998     }
2999     if (m->stream_idx < 0 ||
3000         m->stream_idx >= input_files[m->file_idx].nb_streams) {
3001         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
3002                m->file_idx, m->stream_idx);
3003         exit_program(1);
3004     }
3005     st = input_files[m->file_idx].ctx->streams[m->stream_idx];
3006     if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
3007         av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
3008                m->file_idx, m->stream_idx);
3009         exit_program(1);
3010     }
3011     if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
3012         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
3013                m->file_idx, m->stream_idx, m->channel_idx);
3014         exit_program(1);
3015     }
3016     return 0;
3017 }
3018
3019 static void parse_meta_type(char *arg, char *type, int *index)
3020 {
3021     if (*arg) {
3022         *type = *arg;
3023         switch (*arg) {
3024         case 'g':
3025             break;
3026         case 's':
3027         case 'c':
3028         case 'p':
3029             if (*(++arg) == ':')
3030                 *index = strtol(++arg, NULL, 0);
3031             break;
3032         default:
3033             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3034             exit_program(1);
3035         }
3036     } else
3037         *type = 'g';
3038 }
3039
3040 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
3041 {
3042     MetadataMap *m, *m1;
3043     char *p;
3044
3045     o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
3046                                    &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
3047
3048     m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
3049     m->file = strtol(arg, &p, 0);
3050     parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
3051
3052     m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
3053     if (p = strchr(opt, ':'))
3054         parse_meta_type(p + 1, &m1->type, &m1->index);
3055     else
3056         m1->type = 'g';
3057
3058     if (m->type == 'g' || m1->type == 'g')
3059         o->metadata_global_manual = 1;
3060     if (m->type == 's' || m1->type == 's')
3061         o->metadata_streams_manual = 1;
3062     if (m->type == 'c' || m1->type == 'c')
3063         o->metadata_chapters_manual = 1;
3064
3065     return 0;
3066 }
3067
3068 static int opt_map_meta_data(OptionsContext *o, const char *opt, const char *arg)
3069 {
3070     av_log(NULL, AV_LOG_WARNING, "-map_meta_data is deprecated and will be removed soon. "
3071                     "Use -map_metadata instead.\n");
3072     return opt_map_metadata(o, opt, arg);
3073 }
3074
3075 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
3076 {
3077     char buf[128];
3078     int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3079     struct tm time = *gmtime((time_t*)&recording_timestamp);
3080     strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3081     parse_option(o, "metadata", buf, options);
3082
3083     av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3084                                  "tag instead.\n", opt);
3085     return 0;
3086 }
3087
3088 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3089 {
3090     const char *codec_string = encoder ? "encoder" : "decoder";
3091     AVCodec *codec;
3092
3093     codec = encoder ?
3094         avcodec_find_encoder_by_name(name) :
3095         avcodec_find_decoder_by_name(name);
3096     if(!codec) {
3097         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3098         exit_program(1);
3099     }
3100     if(codec->type != type) {
3101         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3102         exit_program(1);
3103     }
3104     return codec;
3105 }
3106
3107 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3108 {
3109     char *codec_name = NULL;
3110
3111     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3112     if (codec_name) {
3113         AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3114         st->codec->codec_id = codec->id;
3115         return codec;
3116     } else
3117         return avcodec_find_decoder(st->codec->codec_id);
3118 }
3119
3120 /**
3121  * Add all the streams from the given input file to the global
3122  * list of input streams.
3123  */
3124 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3125 {
3126     int i, rfps, rfps_base;
3127     char *next, *codec_tag = NULL;
3128
3129     for (i = 0; i < ic->nb_streams; i++) {
3130         AVStream *st = ic->streams[i];
3131         AVCodecContext *dec = st->codec;
3132         InputStream *ist;
3133
3134         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3135         ist = &input_streams[nb_input_streams - 1];
3136         ist->st = st;
3137         ist->file_index = nb_input_files;
3138         ist->discard = 1;
3139         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3140
3141         ist->ts_scale = 1.0;
3142         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
3143
3144         MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
3145         if (codec_tag) {
3146             uint32_t tag = strtol(codec_tag, &next, 0);
3147             if (*next)
3148                 tag = AV_RL32(codec_tag);
3149             st->codec->codec_tag = tag;
3150         }
3151
3152         ist->dec = choose_decoder(o, ic, st);
3153
3154         switch (dec->codec_type) {
3155         case AVMEDIA_TYPE_AUDIO:
3156             if(!ist->dec)
3157                 ist->dec = avcodec_find_decoder(dec->codec_id);
3158             if(o->audio_disable)
3159                 st->discard= AVDISCARD_ALL;
3160             break;
3161         case AVMEDIA_TYPE_VIDEO:
3162             if(!ist->dec)
3163                 ist->dec = avcodec_find_decoder(dec->codec_id);
3164             rfps      = ic->streams[i]->r_frame_rate.num;
3165             rfps_base = ic->streams[i]->r_frame_rate.den;
3166             if (dec->lowres) {
3167                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3168             }
3169
3170             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3171
3172                 av_log(NULL, AV_LOG_INFO,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3173                        i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3174                        (float)rfps / rfps_base, rfps, rfps_base);
3175             }
3176
3177             if (o->video_disable)
3178                 st->discard= AVDISCARD_ALL;
3179             else if(video_discard)
3180                 st->discard= video_discard;
3181             break;
3182         case AVMEDIA_TYPE_DATA:
3183             break;
3184         case AVMEDIA_TYPE_SUBTITLE:
3185             if(!ist->dec)
3186                 ist->dec = avcodec_find_decoder(dec->codec_id);
3187             if(o->subtitle_disable)
3188                 st->discard = AVDISCARD_ALL;
3189             break;
3190         case AVMEDIA_TYPE_ATTACHMENT:
3191         case AVMEDIA_TYPE_UNKNOWN:
3192             break;
3193         default:
3194             abort();
3195         }
3196     }
3197 }
3198
3199 static void assert_file_overwrite(const char *filename)
3200 {
3201     if (!file_overwrite &&
3202         (strchr(filename, ':') == NULL || filename[1] == ':' ||
3203          av_strstart(filename, "file:", NULL))) {
3204         if (avio_check(filename, 0) == 0) {
3205             if (!using_stdin) {
3206                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3207                 fflush(stderr);
3208                 term_exit();
3209                 if (!read_yesno()) {
3210                     av_log(0, AV_LOG_FATAL, "Not overwriting - exiting\n");
3211                     exit_program(1);
3212                 }
3213                 term_init();
3214             }
3215             else {
3216                 av_log(0, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
3217                 exit_program(1);
3218             }
3219         }
3220     }
3221 }
3222
3223 static void dump_attachment(AVStream *st, const char *filename)
3224 {
3225     int ret;
3226     AVIOContext *out = NULL;
3227     AVDictionaryEntry *e;
3228
3229     if (!st->codec->extradata_size) {
3230         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
3231                nb_input_files - 1, st->index);
3232         return;
3233     }
3234     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3235         filename = e->value;
3236     if (!*filename) {
3237         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
3238                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3239         exit_program(1);
3240     }
3241
3242     assert_file_overwrite(filename);
3243
3244     if ((ret = avio_open (&out, filename, AVIO_FLAG_WRITE)) < 0) {
3245         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3246                filename);
3247         exit_program(1);
3248     }
3249
3250     avio_write(out, st->codec->extradata, st->codec->extradata_size);
3251     avio_flush(out);
3252     avio_close(out);
3253 }
3254
3255 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3256 {
3257     AVFormatContext *ic;
3258     AVInputFormat *file_iformat = NULL;
3259     int err, i, ret;
3260     int64_t timestamp;
3261     uint8_t buf[128];
3262     AVDictionary **opts;
3263     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
3264
3265     if (o->format) {
3266         if (!(file_iformat = av_find_input_format(o->format))) {
3267             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3268             exit_program(1);
3269         }
3270     }
3271
3272     if (!strcmp(filename, "-"))
3273         filename = "pipe:";
3274
3275     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3276                     !strcmp(filename, "/dev/stdin");
3277
3278     /* get default parameters from command line */
3279     ic = avformat_alloc_context();
3280     if (!ic) {
3281         print_error(filename, AVERROR(ENOMEM));
3282         exit_program(1);
3283     }
3284     if (o->nb_audio_sample_rate) {
3285         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3286         av_dict_set(&format_opts, "sample_rate", buf, 0);
3287     }
3288     if (o->nb_audio_channels) {
3289         snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3290         av_dict_set(&format_opts, "channels", buf, 0);
3291     }
3292     if (o->nb_frame_rates) {
3293         av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3294     }
3295     if (o->nb_frame_sizes) {
3296         av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3297     }
3298     if (o->nb_frame_pix_fmts)
3299         av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3300
3301     ic->video_codec_id   = video_codec_name ?
3302         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0)->id : CODEC_ID_NONE;
3303     ic->audio_codec_id   = audio_codec_name ?
3304         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0)->id : CODEC_ID_NONE;
3305     ic->subtitle_codec_id= subtitle_codec_name ?
3306         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
3307     ic->flags |= AVFMT_FLAG_NONBLOCK;
3308
3309     if (loop_input) {
3310         av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3311         ic->loop_input = loop_input;
3312     }
3313
3314     /* open the input file with generic libav function */
3315     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3316     if (err < 0) {
3317         print_error(filename, err);
3318         exit_program(1);
3319     }
3320     assert_avoptions(format_opts);
3321
3322     /* apply forced codec ids */
3323     for (i = 0; i < ic->nb_streams; i++)
3324         choose_decoder(o, ic, ic->streams[i]);
3325
3326     /* Set AVCodecContext options for avformat_find_stream_info */
3327     opts = setup_find_stream_info_opts(ic, codec_opts);
3328     orig_nb_streams = ic->nb_streams;
3329
3330     /* If not enough info to get the stream parameters, we decode the
3331        first frames to get it. (used in mpeg case for example) */
3332     ret = avformat_find_stream_info(ic, opts);
3333     if (ret < 0) {
3334         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3335         av_close_input_file(ic);
3336         exit_program(1);
3337     }
3338
3339     timestamp = o->start_time;
3340     /* add the stream start time */
3341     if (ic->start_time != AV_NOPTS_VALUE)
3342         timestamp += ic->start_time;
3343
3344     /* if seeking requested, we execute it */
3345     if (o->start_time != 0) {
3346         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3347         if (ret < 0) {
3348             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3349                    filename, (double)timestamp / AV_TIME_BASE);
3350         }
3351     }
3352
3353     /* update the current parameters so that they match the one of the input stream */
3354     add_input_streams(o, ic);
3355
3356     /* dump the file content */
3357     av_dump_format(ic, nb_input_files, filename, 0);
3358
3359     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3360     input_files[nb_input_files - 1].ctx        = ic;
3361     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3362     input_files[nb_input_files - 1].ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3363     input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3364     input_files[nb_input_files - 1].rate_emu   = o->rate_emu;
3365
3366     for (i = 0; i < o->nb_dump_attachment; i++) {
3367         int j;
3368
3369         for (j = 0; j < ic->nb_streams; j++) {
3370             AVStream *st = ic->streams[j];
3371
3372             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3373                 dump_attachment(st, o->dump_attachment[i].u.str);
3374         }
3375     }
3376
3377     for (i = 0; i < orig_nb_streams; i++)
3378         av_dict_free(&opts[i]);
3379     av_freep(&opts);
3380
3381     reset_options(o, 1);
3382     return 0;
3383 }
3384
3385 static void parse_forced_key_frames(char *kf, OutputStream *ost)
3386 {
3387     char *p;
3388     int n = 1, i;
3389
3390     for (p = kf; *p; p++)
3391         if (*p == ',')
3392             n++;
3393     ost->forced_kf_count = n;
3394     ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3395     if (!ost->forced_kf_pts) {
3396         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3397         exit_program(1);
3398     }
3399     for (i = 0; i < n; i++) {
3400         p = i ? strchr(p, ',') + 1 : kf;
3401         ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
3402     }
3403 }
3404
3405 static uint8_t *get_line(AVIOContext *s)
3406 {
3407     AVIOContext *line;
3408     uint8_t *buf;
3409     char c;
3410
3411     if (avio_open_dyn_buf(&line) < 0) {
3412         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3413         exit_program(1);
3414     }
3415
3416     while ((c = avio_r8(s)) && c != '\n')
3417         avio_w8(line, c);
3418     avio_w8(line, 0);
3419     avio_close_dyn_buf(line, &buf);
3420
3421     return buf;
3422 }
3423
3424 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3425 {
3426     int i, ret = 1;
3427     char filename[1000];
3428     const char *base[3] = { getenv("AVCONV_DATADIR"),
3429                             getenv("HOME"),
3430                             AVCONV_DATADIR,
3431                             };
3432
3433     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3434         if (!base[i])
3435             continue;
3436         if (codec_name) {
3437             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3438                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
3439             ret = avio_open(s, filename, AVIO_FLAG_READ);
3440         }
3441         if (ret) {
3442             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3443                      i != 1 ? "" : "/.avconv", preset_name);
3444             ret = avio_open(s, filename, AVIO_FLAG_READ);
3445         }
3446     }
3447     return ret;
3448 }
3449
3450 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3451 {
3452     char *codec_name = NULL;
3453
3454     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3455     if (!codec_name) {
3456         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3457                                                   NULL, ost->st->codec->codec_type);
3458         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3459     } else if (!strcmp(codec_name, "copy"))
3460         ost->stream_copy = 1;
3461     else {
3462         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3463         ost->st->codec->codec_id = ost->enc->id;
3464     }
3465 }
3466
3467 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3468 {
3469     OutputStream *ost;
3470     AVStream *st = avformat_new_stream(oc, NULL);
3471     int idx      = oc->nb_streams - 1, ret = 0;
3472     char *bsf = NULL, *next, *codec_tag = NULL;
3473     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3474     double qscale = -1;
3475     char *buf = NULL, *arg = NULL, *preset = NULL;
3476     AVIOContext *s = NULL;
3477
3478     if (!st) {
3479         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3480         exit_program(1);
3481     }
3482
3483     if (oc->nb_streams - 1 < o->nb_streamid_map)
3484         st->id = o->streamid_map[oc->nb_streams - 1];
3485
3486     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3487                                 nb_output_streams + 1);
3488     ost = &output_streams[nb_output_streams - 1];
3489     ost->file_index = nb_output_files;
3490     ost->index = idx;
3491     ost->st    = st;
3492     st->codec->codec_type = type;
3493     choose_encoder(o, oc, ost);
3494     if (ost->enc) {
3495         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3496     }
3497
3498     avcodec_get_context_defaults3(st->codec, ost->enc);
3499     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3500
3501     MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3502     if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3503         do  {
3504             buf = get_line(s);
3505             if (!buf[0] || buf[0] == '#') {
3506                 av_free(buf);
3507                 continue;
3508             }
3509             if (!(arg = strchr(buf, '='))) {
3510                 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3511                 exit_program(1);
3512             }
3513             *arg++ = 0;
3514             av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3515             av_free(buf);
3516         } while (!s->eof_reached);
3517         avio_close(s);
3518     }
3519     if (ret) {
3520         av_log(NULL, AV_LOG_FATAL,
3521                "Preset %s specified for stream %d:%d, but could not be opened.\n",
3522                preset, ost->file_index, ost->index);
3523         exit_program(1);
3524     }
3525
3526     ost->max_frames = INT64_MAX;
3527     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3528
3529     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3530     while (bsf) {
3531         if (next = strchr(bsf, ','))
3532             *next++ = 0;
3533         if (!(bsfc = av_bitstream_filter_init(bsf))) {
3534             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3535             exit_program(1);
3536         }
3537         if (bsfc_prev)
3538             bsfc_prev->next = bsfc;
3539         else
3540             ost->bitstream_filters = bsfc;
3541
3542         bsfc_prev = bsfc;
3543         bsf       = next;
3544     }
3545
3546     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3547     if (codec_tag) {
3548         uint32_t tag = strtol(codec_tag, &next, 0);
3549         if (*next)
3550             tag = AV_RL32(codec_tag);
3551         st->codec->codec_tag = tag;
3552     }
3553
3554     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3555     if (qscale >= 0 || same_quant) {
3556         st->codec->flags |= CODEC_FLAG_QSCALE;
3557         st->codec->global_quality = FF_QP2LAMBDA * qscale;
3558     }
3559
3560     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3561         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3562
3563     av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3564     return ost;
3565 }
3566
3567 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3568 {
3569     int i;
3570     const char *p = str;
3571     for(i = 0;; i++) {
3572         dest[i] = atoi(p);
3573         if(i == 63)
3574             break;
3575         p = strchr(p, ',');
3576         if(!p) {
3577             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3578             exit_program(1);
3579         }
3580         p++;
3581     }
3582 }
3583
3584 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3585 {
3586     AVStream *st;
3587     OutputStream *ost;
3588     AVCodecContext *video_enc;
3589
3590     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3591     st  = ost->st;
3592     video_enc = st->codec;
3593
3594     if (!ost->stream_copy) {
3595         const char *p = NULL;
3596         char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3597         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3598         char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3599         int i;
3600
3601         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3602         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3603             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3604             exit_program(1);
3605         }
3606
3607         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3608         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3609             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3610             exit_program(1);
3611         }
3612
3613         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3614         if (frame_aspect_ratio)
3615             ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3616
3617         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3618         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3619         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3620             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3621             exit_program(1);
3622         }
3623         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3624
3625         if (intra_only)
3626             video_enc->gop_size = 0;
3627         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3628         if (intra_matrix) {
3629             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3630                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3631                 exit_program(1);
3632             }
3633             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3634         }
3635         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3636         if (inter_matrix) {
3637             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3638                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3639                 exit_program(1);
3640             }
3641             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3642         }
3643
3644         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3645         for(i=0; p; i++){
3646             int start, end, q;
3647             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3648             if(e!=3){
3649                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3650                 exit_program(1);
3651             }
3652             /* FIXME realloc failure */
3653             video_enc->rc_override=
3654                 av_realloc(video_enc->rc_override,
3655                            sizeof(RcOverride)*(i+1));
3656             video_enc->rc_override[i].start_frame= start;
3657             video_enc->rc_override[i].end_frame  = end;
3658             if(q>0){
3659                 video_enc->rc_override[i].qscale= q;
3660                 video_enc->rc_override[i].quality_factor= 1.0;
3661             }
3662             else{
3663                 video_enc->rc_override[i].qscale= 0;
3664                 video_enc->rc_override[i].quality_factor= -q/100.0;
3665             }
3666             p= strchr(p, '/');
3667             if(p) p++;
3668         }
3669         video_enc->rc_override_count=i;
3670         if (!video_enc->rc_initial_buffer_occupancy)
3671             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3672         video_enc->intra_dc_precision= intra_dc_precision - 8;
3673
3674         if (do_psnr)
3675             video_enc->flags|= CODEC_FLAG_PSNR;
3676
3677         /* two pass mode */
3678         if (do_pass) {
3679             if (do_pass & 1) {
3680                 video_enc->flags |= CODEC_FLAG_PASS1;
3681             }
3682             if (do_pass & 2) {
3683                 video_enc->flags |= CODEC_FLAG_PASS2;
3684             }
3685         }
3686
3687         MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3688         if (forced_key_frames)
3689             parse_forced_key_frames(forced_key_frames, ost);
3690
3691         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
3692
3693         ost->top_field_first = -1;
3694         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
3695
3696         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
3697
3698 #if CONFIG_AVFILTER
3699         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3700         if (filters)
3701             ost->avfilter = av_strdup(filters);
3702 #endif
3703     }
3704
3705     return ost;
3706 }
3707
3708 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3709 {
3710     int n;
3711     AVStream *st;
3712     OutputStream *ost;
3713     AVCodecContext *audio_enc;
3714
3715     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3716     st  = ost->st;
3717
3718     audio_enc = st->codec;
3719     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3720
3721     if (!ost->stream_copy) {
3722         char *sample_fmt = NULL;
3723
3724         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3725
3726         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3727         if (sample_fmt &&
3728             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3729             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3730             exit_program(1);
3731         }
3732
3733         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3734
3735         ost->rematrix_volume=1.0;
3736         MATCH_PER_STREAM_OPT(rematrix_volume, f, ost->rematrix_volume, oc, st);
3737     }
3738
3739     /* check for channel mapping for this audio stream */
3740     for (n = 0; n < o->nb_audio_channel_maps; n++) {
3741         AudioChannelMap *map = &o->audio_channel_maps[n];
3742         InputStream *ist = &input_streams[ost->source_index];
3743         if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
3744             (map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
3745             (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
3746             if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
3747                 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
3748             else
3749                 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
3750                        ost->file_index, ost->st->index);
3751         }
3752     }
3753
3754     return ost;
3755 }
3756
3757 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3758 {
3759     OutputStream *ost;
3760
3761     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3762     if (!ost->stream_copy) {
3763         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3764         exit_program(1);
3765     }
3766
3767     return ost;
3768 }
3769
3770 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3771 {
3772     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3773     ost->stream_copy = 1;
3774     return ost;
3775 }
3776
3777 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3778 {
3779     AVStream *st;
3780     OutputStream *ost;
3781     AVCodecContext *subtitle_enc;
3782
3783     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3784     st  = ost->st;
3785     subtitle_enc = st->codec;
3786
3787     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3788
3789     return ost;
3790 }
3791
3792 /* arg format is "output-stream-index:streamid-value". */
3793 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3794 {
3795     int idx;
3796     char *p;
3797     char idx_str[16];
3798
3799     av_strlcpy(idx_str, arg, sizeof(idx_str));
3800     p = strchr(idx_str, ':');
3801     if (!p) {
3802         av_log(NULL, AV_LOG_FATAL,
3803                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3804                arg, opt);
3805         exit_program(1);
3806     }
3807     *p++ = '\0';
3808     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3809     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3810     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3811     return 0;
3812 }
3813
3814 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3815 {
3816     AVFormatContext *is = ifile->ctx;
3817     AVFormatContext *os = ofile->ctx;
3818     int i;
3819
3820     for (i = 0; i < is->nb_chapters; i++) {
3821         AVChapter *in_ch = is->chapters[i], *out_ch;
3822         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
3823                                       AV_TIME_BASE_Q, in_ch->time_base);
3824         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3825                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3826
3827
3828         if (in_ch->end < ts_off)
3829             continue;
3830         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3831             break;
3832
3833         out_ch = av_mallocz(sizeof(AVChapter));
3834         if (!out_ch)
3835             return AVERROR(ENOMEM);
3836
3837         out_ch->id        = in_ch->id;
3838         out_ch->time_base = in_ch->time_base;
3839         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
3840         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
3841
3842         if (copy_metadata)
3843             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3844
3845         os->nb_chapters++;
3846         os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
3847         if (!os->chapters)
3848             return AVERROR(ENOMEM);
3849         os->chapters[os->nb_chapters - 1] = out_ch;
3850     }
3851     return 0;
3852 }
3853
3854 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3855 {
3856     int i, err;
3857     AVFormatContext *ic = NULL;
3858
3859     err = avformat_open_input(&ic, filename, NULL, NULL);
3860     if (err < 0)
3861         return err;
3862     /* copy stream format */
3863     for(i=0;i<ic->nb_streams;i++) {
3864         AVStream *st;
3865         OutputStream *ost;
3866         AVCodec *codec;
3867         AVCodecContext *avctx;
3868
3869         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3870         ost   = new_output_stream(o, s, codec->type);
3871         st    = ost->st;
3872         avctx = st->codec;
3873
3874         // FIXME: a more elegant solution is needed
3875         memcpy(st, ic->streams[i], sizeof(AVStream));
3876         st->info = av_malloc(sizeof(*st->info));
3877         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3878         st->codec= avctx;
3879         avcodec_copy_context(st->codec, ic->streams[i]->codec);
3880
3881         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
3882             choose_sample_fmt(st, codec);
3883         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
3884             choose_pixel_fmt(st, codec);
3885     }
3886
3887     av_close_input_file(ic);
3888     return 0;
3889 }
3890
3891 static void opt_output_file(void *optctx, const char *filename)
3892 {
3893     OptionsContext *o = optctx;
3894     AVFormatContext *oc;
3895     int i, err;
3896     AVOutputFormat *file_oformat;
3897     OutputStream *ost;
3898     InputStream  *ist;
3899
3900     if (!strcmp(filename, "-"))
3901         filename = "pipe:";
3902
3903     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3904     if (!oc) {
3905         print_error(filename, err);
3906         exit_program(1);
3907     }
3908     file_oformat= oc->oformat;
3909
3910     if (!strcmp(file_oformat->name, "ffm") &&
3911         av_strstart(filename, "http:", NULL)) {
3912         int j;
3913         /* special case for files sent to ffserver: we get the stream
3914            parameters from ffserver */
3915         int err = read_ffserver_streams(o, oc, filename);
3916         if (err < 0) {
3917             print_error(filename, err);
3918             exit_program(1);
3919         }
3920         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
3921             ost = &output_streams[j];
3922             for (i = 0; i < nb_input_streams; i++) {
3923                 ist = &input_streams[i];
3924                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
3925                     ost->sync_ist= ist;
3926                     ost->source_index= i;
3927                     ist->discard = 0;
3928                     break;
3929                 }
3930             }
3931         }
3932     } else if (!o->nb_stream_maps) {
3933         /* pick the "best" stream of each type */
3934 #define NEW_STREAM(type, index)\
3935         if (index >= 0) {\
3936             ost = new_ ## type ## _stream(o, oc);\
3937             ost->source_index = index;\
3938             ost->sync_ist     = &input_streams[index];\
3939             input_streams[index].discard = 0;\
3940         }
3941
3942         /* video: highest resolution */
3943         if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3944             int area = 0, idx = -1;
3945             for (i = 0; i < nb_input_streams; i++) {
3946                 ist = &input_streams[i];
3947                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3948                     ist->st->codec->width * ist->st->codec->height > area) {
3949                     area = ist->st->codec->width * ist->st->codec->height;
3950                     idx = i;
3951                 }
3952             }
3953             NEW_STREAM(video, idx);
3954         }
3955
3956         /* audio: most channels */
3957         if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3958             int channels = 0, idx = -1;
3959             for (i = 0; i < nb_input_streams; i++) {
3960                 ist = &input_streams[i];
3961                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3962                     ist->st->codec->channels > channels) {
3963                     channels = ist->st->codec->channels;
3964                     idx = i;
3965                 }
3966             }
3967             NEW_STREAM(audio, idx);
3968         }
3969
3970         /* subtitles: pick first */
3971         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
3972             for (i = 0; i < nb_input_streams; i++)
3973                 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3974                     NEW_STREAM(subtitle, i);
3975                     break;
3976                 }
3977         }
3978         /* do something with data? */
3979     } else {
3980         for (i = 0; i < o->nb_stream_maps; i++) {
3981             StreamMap *map = &o->stream_maps[i];
3982
3983             if (map->disabled)
3984                 continue;
3985
3986             ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3987             if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
3988                 continue;
3989             if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
3990                 continue;
3991             if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3992                 continue;
3993
3994             switch (ist->st->codec->codec_type) {
3995             case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
3996             case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
3997             case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3998             case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
3999             case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
4000             default:
4001                 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
4002                        map->file_index, map->stream_index);
4003                 exit_program(1);
4004             }
4005
4006             ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
4007             ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
4008                                            map->sync_stream_index];
4009             ist->discard = 0;
4010         }
4011     }
4012
4013     /* handle attached files */
4014     for (i = 0; i < o->nb_attachments; i++) {
4015         AVIOContext *pb;
4016         uint8_t *attachment;
4017         const char *p;
4018         int64_t len;
4019
4020         if ((err = avio_open(&pb, o->attachments[i], AVIO_FLAG_READ)) < 0) {
4021             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
4022                    o->attachments[i]);
4023             exit_program(1);
4024         }
4025         if ((len = avio_size(pb)) <= 0) {
4026             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
4027                    o->attachments[i]);
4028             exit_program(1);
4029         }
4030         if (!(attachment = av_malloc(len))) {
4031             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
4032                    o->attachments[i]);
4033             exit_program(1);
4034         }
4035         avio_read(pb, attachment, len);
4036
4037         ost = new_attachment_stream(o, oc);
4038         ost->stream_copy               = 0;
4039         ost->source_index              = -1;
4040         ost->attachment_filename       = o->attachments[i];
4041         ost->st->codec->extradata      = attachment;
4042         ost->st->codec->extradata_size = len;
4043
4044         p = strrchr(o->attachments[i], '/');
4045         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
4046         avio_close(pb);
4047     }
4048
4049     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
4050     output_files[nb_output_files - 1].ctx       = oc;
4051     output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
4052     output_files[nb_output_files - 1].recording_time = o->recording_time;
4053     output_files[nb_output_files - 1].start_time     = o->start_time;
4054     output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
4055     av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
4056
4057     /* check filename in case of an image number is expected */
4058     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
4059         if (!av_filename_number_test(oc->filename)) {
4060             print_error(oc->filename, AVERROR(EINVAL));
4061             exit_program(1);
4062         }
4063     }
4064
4065     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
4066         /* test if it already exists to avoid loosing precious files */
4067         assert_file_overwrite(filename);
4068
4069         /* open the file */
4070         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
4071             print_error(filename, err);
4072             exit_program(1);
4073         }
4074     }
4075
4076     if (o->mux_preload) {
4077         uint8_t buf[64];
4078         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
4079         av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
4080     }
4081     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
4082
4083     if (loop_output >= 0) {
4084         av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
4085         oc->loop_output = loop_output;
4086     }
4087
4088     /* copy chapters */
4089     if (o->chapters_input_file >= nb_input_files) {
4090         if (o->chapters_input_file == INT_MAX) {
4091             /* copy chapters from the first input file that has them*/
4092             o->chapters_input_file = -1;
4093             for (i = 0; i < nb_input_files; i++)
4094                 if (input_files[i].ctx->nb_chapters) {
4095                     o->chapters_input_file = i;
4096                     break;
4097                 }
4098         } else {
4099             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4100                    o->chapters_input_file);
4101             exit_program(1);
4102         }
4103     }
4104     if (o->chapters_input_file >= 0)
4105         copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
4106                       !o->metadata_chapters_manual);
4107
4108     /* copy metadata */
4109     for (i = 0; i < o->nb_meta_data_maps; i++) {
4110         AVFormatContext *files[2];
4111         AVDictionary    **meta[2];
4112         int j;
4113
4114 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
4115         if ((index) < 0 || (index) >= (nb_elems)) {\
4116             av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps\n",\
4117                      (desc), (index));\
4118             exit_program(1);\
4119         }
4120
4121         int in_file_index = o->meta_data_maps[i][1].file;
4122         if (in_file_index < 0)
4123             continue;
4124         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
4125
4126         files[0] = oc;
4127         files[1] = input_files[in_file_index].ctx;
4128
4129         for (j = 0; j < 2; j++) {
4130             MetadataMap *map = &o->meta_data_maps[i][j];
4131
4132             switch (map->type) {
4133             case 'g':
4134                 meta[j] = &files[j]->metadata;
4135                 break;
4136             case 's':
4137                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
4138                 meta[j] = &files[j]->streams[map->index]->metadata;
4139                 break;
4140             case 'c':
4141                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
4142                 meta[j] = &files[j]->chapters[map->index]->metadata;
4143                 break;
4144             case 'p':
4145                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
4146                 meta[j] = &files[j]->programs[map->index]->metadata;
4147                 break;
4148             default:
4149                 abort();
4150             }
4151         }
4152
4153         av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
4154     }
4155
4156     /* copy global metadata by default */
4157     if (!o->metadata_global_manual && nb_input_files){
4158         av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
4159                      AV_DICT_DONT_OVERWRITE);
4160         if(o->recording_time != INT64_MAX)
4161             av_dict_set(&oc->metadata, "duration", NULL, 0);
4162     }
4163     if (!o->metadata_streams_manual)
4164         for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
4165             InputStream *ist;
4166             if (output_streams[i].source_index < 0)         /* this is true e.g. for attached files */
4167                 continue;
4168             ist = &input_streams[output_streams[i].source_index];
4169             av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4170         }
4171
4172     /* process manually set metadata */
4173     for (i = 0; i < o->nb_metadata; i++) {
4174         AVDictionary **m;
4175         char type, *val;
4176         int index = 0;
4177
4178         val = strchr(o->metadata[i].u.str, '=');
4179         if (!val) {
4180             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4181                    o->metadata[i].u.str);
4182             exit_program(1);
4183         }
4184         *val++ = 0;
4185
4186         parse_meta_type(o->metadata[i].specifier, &type, &index);
4187         switch (type) {
4188         case 'g':
4189             m = &oc->metadata;
4190             break;
4191         case 's':
4192             if (index < 0 || index >= oc->nb_streams) {
4193                 av_log(NULL, AV_LOG_FATAL, "Invalid stream index %d in metadata specifier.\n", index);
4194                 exit_program(1);
4195             }
4196             m = &oc->streams[index]->metadata;
4197             break;
4198         case 'c':
4199             if (index < 0 || index >= oc->nb_chapters) {
4200                 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4201                 exit_program(1);
4202             }
4203             m = &oc->chapters[index]->metadata;
4204             break;
4205         default:
4206             av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4207             exit_program(1);
4208         }
4209
4210         av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4211     }
4212
4213     reset_options(o, 0);
4214 }
4215
4216 /* same option as mencoder */
4217 static int opt_pass(const char *opt, const char *arg)
4218 {
4219     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
4220     return 0;
4221 }
4222
4223 static int64_t getutime(void)
4224 {
4225 #if HAVE_GETRUSAGE
4226     struct rusage rusage;
4227
4228     getrusage(RUSAGE_SELF, &rusage);
4229     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4230 #elif HAVE_GETPROCESSTIMES
4231     HANDLE proc;
4232     FILETIME c, e, k, u;
4233     proc = GetCurrentProcess();
4234     GetProcessTimes(proc, &c, &e, &k, &u);
4235     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4236 #else
4237     return av_gettime();
4238 #endif
4239 }
4240
4241 static int64_t getmaxrss(void)
4242 {
4243 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4244     struct rusage rusage;
4245     getrusage(RUSAGE_SELF, &rusage);
4246     return (int64_t)rusage.ru_maxrss * 1024;
4247 #elif HAVE_GETPROCESSMEMORYINFO
4248     HANDLE proc;
4249     PROCESS_MEMORY_COUNTERS memcounters;
4250     proc = GetCurrentProcess();
4251     memcounters.cb = sizeof(memcounters);
4252     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4253     return memcounters.PeakPagefileUsage;
4254 #else
4255     return 0;
4256 #endif
4257 }
4258
4259 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4260 {
4261     return parse_option(o, "q:a", arg, options);
4262 }
4263
4264 static void show_usage(void)
4265 {
4266     printf("Hyper fast Audio and Video encoder\n");
4267     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4268     printf("\n");
4269 }
4270
4271 static int opt_help(const char *opt, const char *arg)
4272 {
4273     int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4274     av_log_set_callback(log_callback_help);
4275     show_usage();
4276     show_help_options(options, "Main options:\n",
4277                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4278     show_help_options(options, "\nAdvanced options:\n",
4279                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4280                       OPT_EXPERT);
4281     show_help_options(options, "\nVideo options:\n",
4282                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4283                       OPT_VIDEO);
4284     show_help_options(options, "\nAdvanced Video options:\n",
4285                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4286                       OPT_VIDEO | OPT_EXPERT);
4287     show_help_options(options, "\nAudio options:\n",
4288                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4289                       OPT_AUDIO);
4290     show_help_options(options, "\nAdvanced Audio options:\n",
4291                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4292                       OPT_AUDIO | OPT_EXPERT);
4293     show_help_options(options, "\nSubtitle options:\n",
4294                       OPT_SUBTITLE | OPT_GRAB,
4295                       OPT_SUBTITLE);
4296     show_help_options(options, "\nAudio/Video grab options:\n",
4297                       OPT_GRAB,
4298                       OPT_GRAB);
4299     printf("\n");
4300     show_help_children(avcodec_get_class(), flags);
4301     show_help_children(avformat_get_class(), flags);
4302     show_help_children(sws_get_class(), flags);
4303
4304     return 0;
4305 }
4306
4307 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4308 {
4309     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4310     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4311
4312     if(!strncmp(arg, "pal-", 4)) {
4313         norm = PAL;
4314         arg += 4;
4315     } else if(!strncmp(arg, "ntsc-", 5)) {
4316         norm = NTSC;
4317         arg += 5;
4318     } else if(!strncmp(arg, "film-", 5)) {
4319         norm = FILM;
4320         arg += 5;
4321     } else {
4322         /* Try to determine PAL/NTSC by peeking in the input files */
4323         if(nb_input_files) {
4324             int i, j, fr;
4325             for (j = 0; j < nb_input_files; j++) {
4326                 for (i = 0; i < input_files[j].nb_streams; i++) {
4327                     AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4328                     if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4329                         continue;
4330                     fr = c->time_base.den * 1000 / c->time_base.num;
4331                     if(fr == 25000) {
4332                         norm = PAL;
4333                         break;
4334                     } else if((fr == 29970) || (fr == 23976)) {
4335                         norm = NTSC;
4336                         break;
4337                     }
4338                 }
4339                 if(norm != UNKNOWN)
4340                     break;
4341             }
4342         }
4343         if (norm != UNKNOWN)
4344             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4345     }
4346
4347     if(norm == UNKNOWN) {
4348         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4349         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4350         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4351         exit_program(1);
4352     }
4353
4354     if(!strcmp(arg, "vcd")) {
4355         opt_video_codec(o, "c:v", "mpeg1video");
4356         opt_audio_codec(o, "c:a", "mp2");
4357         parse_option(o, "f", "vcd", options);
4358
4359         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4360         parse_option(o, "r", frame_rates[norm], options);
4361         opt_default("g", norm == PAL ? "15" : "18");
4362
4363         opt_default("b", "1150000");
4364         opt_default("maxrate", "1150000");
4365         opt_default("minrate", "1150000");
4366         opt_default("bufsize", "327680"); // 40*1024*8;
4367
4368         opt_default("b:a", "224000");
4369         parse_option(o, "ar", "44100", options);
4370         parse_option(o, "ac", "2", options);
4371
4372         opt_default("packetsize", "2324");
4373         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4374
4375         /* We have to offset the PTS, so that it is consistent with the SCR.
4376            SCR starts at 36000, but the first two packs contain only padding
4377            and the first pack from the other stream, respectively, may also have
4378            been written before.
4379            So the real data starts at SCR 36000+3*1200. */
4380         o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4381     } else if(!strcmp(arg, "svcd")) {
4382
4383         opt_video_codec(o, "c:v", "mpeg2video");
4384         opt_audio_codec(o, "c:a", "mp2");
4385         parse_option(o, "f", "svcd", options);
4386
4387         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4388         parse_option(o, "r", frame_rates[norm], options);
4389         parse_option(o, "pix_fmt", "yuv420p", options);
4390         opt_default("g", norm == PAL ? "15" : "18");
4391
4392         opt_default("b", "2040000");
4393         opt_default("maxrate", "2516000");
4394         opt_default("minrate", "0"); //1145000;
4395         opt_default("bufsize", "1835008"); //224*1024*8;
4396         opt_default("flags", "+scan_offset");
4397
4398
4399         opt_default("b:a", "224000");
4400         parse_option(o, "ar", "44100", options);
4401
4402         opt_default("packetsize", "2324");
4403
4404     } else if(!strcmp(arg, "dvd")) {
4405
4406         opt_video_codec(o, "c:v", "mpeg2video");
4407         opt_audio_codec(o, "c:a", "ac3");
4408         parse_option(o, "f", "dvd", options);
4409
4410         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4411         parse_option(o, "r", frame_rates[norm], options);
4412         parse_option(o, "pix_fmt", "yuv420p", options);
4413         opt_default("g", norm == PAL ? "15" : "18");
4414
4415         opt_default("b", "6000000");
4416         opt_default("maxrate", "9000000");
4417         opt_default("minrate", "0"); //1500000;
4418         opt_default("bufsize", "1835008"); //224*1024*8;
4419
4420         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4421         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4422
4423         opt_default("b:a", "448000");
4424         parse_option(o, "ar", "48000", options);
4425
4426     } else if(!strncmp(arg, "dv", 2)) {
4427
4428         parse_option(o, "f", "dv", options);
4429
4430         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4431         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4432                           norm == PAL ? "yuv420p" : "yuv411p", options);
4433         parse_option(o, "r", frame_rates[norm], options);
4434
4435         parse_option(o, "ar", "48000", options);
4436         parse_option(o, "ac", "2", options);
4437
4438     } else {
4439         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4440         return AVERROR(EINVAL);
4441     }
4442     return 0;
4443 }
4444
4445 static int opt_vstats_file(const char *opt, const char *arg)
4446 {
4447     av_free (vstats_filename);
4448     vstats_filename=av_strdup (arg);
4449     return 0;
4450 }
4451
4452 static int opt_vstats(const char *opt, const char *arg)
4453 {
4454     char filename[40];
4455     time_t today2 = time(NULL);
4456     struct tm *today = localtime(&today2);
4457
4458     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4459              today->tm_sec);
4460     return opt_vstats_file(opt, filename);
4461 }
4462
4463 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4464 {
4465     return parse_option(o, "frames:v", arg, options);
4466 }
4467
4468 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4469 {
4470     return parse_option(o, "frames:a", arg, options);
4471 }
4472
4473 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4474 {
4475     return parse_option(o, "frames:d", arg, options);
4476 }
4477
4478 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4479 {
4480     FILE *f=NULL;
4481     char filename[1000], tmp[1000], tmp2[1000], line[1000];
4482     const char *codec_name = *opt == 'v' ? video_codec_name :
4483                              *opt == 'a' ? audio_codec_name :
4484                                            subtitle_codec_name;
4485
4486     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4487         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
4488             av_log(0, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
4489         }else
4490             av_log(0, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
4491         exit_program(1);
4492     }
4493
4494     while(!feof(f)){
4495         int e= fscanf(f, "%999[^\n]\n", line) - 1;
4496         if(line[0] == '#' && !e)
4497             continue;
4498         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4499         if(e){
4500             av_log(0, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
4501             exit_program(1);
4502         }
4503         if(!strcmp(tmp, "acodec")){
4504             opt_audio_codec(o, tmp, tmp2);
4505         }else if(!strcmp(tmp, "vcodec")){
4506             opt_video_codec(o, tmp, tmp2);
4507         }else if(!strcmp(tmp, "scodec")){
4508             opt_subtitle_codec(o, tmp, tmp2);
4509         }else if(!strcmp(tmp, "dcodec")){
4510             opt_data_codec(o, tmp, tmp2);
4511         }else if(opt_default(tmp, tmp2) < 0){
4512             av_log(0, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4513             exit_program(1);
4514         }
4515     }
4516
4517     fclose(f);
4518
4519     return 0;
4520 }
4521
4522 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4523 {
4524 }
4525
4526 static int opt_passlogfile(const char *opt, const char *arg)
4527 {
4528     pass_logfilename_prefix = arg;
4529 #if CONFIG_LIBX264_ENCODER
4530     return opt_default("passlogfile", arg);
4531 #else
4532     return 0;
4533 #endif
4534 }
4535
4536 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4537 {
4538     char *s= av_malloc(strlen(opt)+2);
4539     snprintf(s, strlen(opt)+2, "%s:%c", opt+1, *opt);
4540     return parse_option(o, s, arg, options);
4541 }
4542
4543 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
4544 {
4545     if(!strcmp(opt, "b")){
4546         av_log(0,AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
4547         return parse_option(o, av_strdup("b:v"), arg, options);
4548     }
4549     return opt_default(opt, arg);
4550 }
4551
4552 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4553 {
4554     return parse_option(o, "filter:v", arg, options);
4555 }
4556
4557 #define OFFSET(x) offsetof(OptionsContext, x)
4558 static const OptionDef options[] = {
4559     /* main options */
4560 #include "cmdutils_common_opts.h"
4561     { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4562     { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4563     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4564     { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4565     { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4566     { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4567     { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4568     { "map_channel", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_channel}, "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
4569     { "map_meta_data", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4570       "outfile[,metadata]:infile[,metadata]" },
4571     { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4572       "outfile[,metadata]:infile[,metadata]" },
4573     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)},  "set chapters mapping", "input_file_index" },
4574     { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4575     { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4576     { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4577     { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4578     { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4579     { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4580     { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4581     { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4582     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4583       "add timings for benchmarking" },
4584     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4585     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4586       "dump each input packet" },
4587     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4588       "when dumping packets, also dump the payload" },
4589     { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4590     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4591     { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4592     { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4593     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4594     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4595     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4596     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4597     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4598     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4599     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4600     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4601     { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4602     { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4603     { "tag",   OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4604     { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4605     { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4606 #if CONFIG_AVFILTER
4607     { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4608 #endif
4609     { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4610     { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4611     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4612
4613     /* video options */
4614     { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4615     { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4616     { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4617     { "aspect", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_aspect_ratios)}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4618     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4619     { "bits_per_raw_sample", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&frame_bits_per_raw_sample}, "set the number of bits per raw sample", "number" },
4620     { "croptop",  HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4621     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4622     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4623     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4624     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4625     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4626     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4627     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4628     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4629     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4630     { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4631     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4632     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4633     { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4634     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4635     { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4636       "use same quantizer as source (implies VBR)" },
4637     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4638     { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4639     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4640       "deinterlace pictures" },
4641     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4642     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4643     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4644 #if CONFIG_AVFILTER
4645     { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4646 #endif
4647     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4648     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4649     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4650     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4651     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
4652     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4653     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4654     { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4655     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(forced_key_frames)}, "force key frames at specified timestamps", "timestamps" },
4656     { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
4657
4658     /* audio options */
4659     { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4660     { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4661     { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4662     { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4663     { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4664     { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4665     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
4666     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4667     { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4668     { "rmvol", HAS_ARG | OPT_AUDIO | OPT_FLOAT | OPT_SPEC, {.off = OFFSET(rematrix_volume)}, "rematrix volume (as factor)", "volume" },
4669
4670     /* subtitle options */
4671     { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4672     { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4673     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
4674
4675     /* grab options */
4676     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4677     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4678     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4679
4680     /* muxer options */
4681     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT   | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4682     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)},   "set the initial demux-decode delay", "seconds" },
4683
4684     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4685     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
4686     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
4687
4688     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4689     { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4690     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4691     { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4692     /* data codec support */
4693     { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4694
4695     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4696     { NULL, },
4697 };
4698
4699 int main(int argc, char **argv)
4700 {
4701     OptionsContext o = { 0 };
4702     int64_t ti;
4703
4704     reset_options(&o, 0);
4705
4706     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4707     parse_loglevel(argc, argv, options);
4708
4709     if(argc>1 && !strcmp(argv[1], "-d")){
4710         run_as_daemon=1;
4711         av_log_set_callback(log_callback_null);
4712         argc--;
4713         argv++;
4714     }
4715
4716     avcodec_register_all();
4717 #if CONFIG_AVDEVICE
4718     avdevice_register_all();
4719 #endif
4720 #if CONFIG_AVFILTER
4721     avfilter_register_all();
4722 #endif
4723     av_register_all();
4724     avformat_network_init();
4725
4726 #if HAVE_ISATTY
4727     if(isatty(STDIN_FILENO))
4728         avio_set_interrupt_cb(decode_interrupt_cb);
4729 #endif
4730
4731     show_banner();
4732
4733     term_init();
4734
4735     /* parse options */
4736     parse_options(&o, argc, argv, options, opt_output_file);
4737
4738     if(nb_output_files <= 0 && nb_input_files == 0) {
4739         show_usage();
4740         av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4741         exit_program(1);
4742     }
4743
4744     /* file converter / grab */
4745     if (nb_output_files <= 0) {
4746         av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
4747         exit_program(1);
4748     }
4749
4750     if (nb_input_files == 0) {
4751         av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4752         exit_program(1);
4753     }
4754
4755     ti = getutime();
4756     if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4757         exit_program(1);
4758     ti = getutime() - ti;
4759     if (do_benchmark) {
4760         int maxrss = getmaxrss() / 1024;
4761         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4762     }
4763
4764     exit_program(0);
4765     return 0;
4766 }