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

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