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