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

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