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