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