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