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

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