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->field_order    = icodec->field_order;
2217             codec->extradata      = av_mallocz(extra_size);
2218             if (!codec->extradata) {
2219                 return AVERROR(ENOMEM);
2220             }
2221             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2222             codec->extradata_size= icodec->extradata_size;
2223
2224             codec->time_base = ist->st->time_base;
2225             if(!strcmp(oc->oformat->name, "avi")) {
2226                 if (   copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
2227                                  && av_q2d(ist->st->time_base) < 1.0/500
2228                     || copy_tb==0){
2229                     codec->time_base = icodec->time_base;
2230                     codec->time_base.num *= icodec->ticks_per_frame;
2231                     codec->time_base.den *= 2;
2232                 }
2233             } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
2234                       && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
2235                       && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
2236             ) {
2237                 if(   copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
2238                                 && av_q2d(ist->st->time_base) < 1.0/500
2239                    || copy_tb==0){
2240                     codec->time_base = icodec->time_base;
2241                     codec->time_base.num *= icodec->ticks_per_frame;
2242                 }
2243             }
2244             av_reduce(&codec->time_base.num, &codec->time_base.den,
2245                         codec->time_base.num, codec->time_base.den, INT_MAX);
2246
2247             switch(codec->codec_type) {
2248             case AVMEDIA_TYPE_AUDIO:
2249                 if(audio_volume != 256) {
2250                     av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2251                     exit_program(1);
2252                 }
2253                 codec->channel_layout     = icodec->channel_layout;
2254                 codec->sample_rate        = icodec->sample_rate;
2255                 codec->channels           = icodec->channels;
2256                 codec->frame_size         = icodec->frame_size;
2257                 codec->audio_service_type = icodec->audio_service_type;
2258                 codec->block_align        = icodec->block_align;
2259                 break;
2260             case AVMEDIA_TYPE_VIDEO:
2261                 codec->pix_fmt            = icodec->pix_fmt;
2262                 codec->width              = icodec->width;
2263                 codec->height             = icodec->height;
2264                 codec->has_b_frames       = icodec->has_b_frames;
2265                 if (!codec->sample_aspect_ratio.num) {
2266                     codec->sample_aspect_ratio   =
2267                     ost->st->sample_aspect_ratio =
2268                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2269                         ist->st->codec->sample_aspect_ratio.num ?
2270                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2271                 }
2272                 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
2273                 break;
2274             case AVMEDIA_TYPE_SUBTITLE:
2275                 codec->width  = icodec->width;
2276                 codec->height = icodec->height;
2277                 break;
2278             case AVMEDIA_TYPE_DATA:
2279             case AVMEDIA_TYPE_ATTACHMENT:
2280                 break;
2281             default:
2282                 abort();
2283             }
2284         } else {
2285             if (!ost->enc)
2286                 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2287
2288             ist->decoding_needed = 1;
2289             ost->encoding_needed = 1;
2290
2291             switch(codec->codec_type) {
2292             case AVMEDIA_TYPE_AUDIO:
2293                 ost->fifo = av_fifo_alloc(1024);
2294                 if (!ost->fifo) {
2295                     return AVERROR(ENOMEM);
2296                 }
2297                 if (!codec->sample_rate)
2298                     codec->sample_rate = icodec->sample_rate;
2299                 choose_sample_rate(ost->st, ost->enc);
2300                 codec->time_base = (AVRational){1, codec->sample_rate};
2301
2302                 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2303                     codec->sample_fmt = icodec->sample_fmt;
2304                 choose_sample_fmt(ost->st, ost->enc);
2305
2306                 if (ost->audio_channels_mapped) {
2307                     /* the requested output channel is set to the number of
2308                      * -map_channel only if no -ac are specified */
2309                     if (!codec->channels) {
2310                         codec->channels       = ost->audio_channels_mapped;
2311                         codec->channel_layout = av_get_default_channel_layout(codec->channels);
2312                         if (!codec->channel_layout) {
2313                             av_log(NULL, AV_LOG_FATAL, "Unable to find an appropriate channel layout for requested number of channel\n");
2314                             exit_program(1);
2315                         }
2316                     }
2317                     /* fill unused channel mapping with -1 (which means a muted
2318                      * channel in case the number of output channels is bigger
2319                      * than the number of mapped channel) */
2320                     for (j = ost->audio_channels_mapped; j < FF_ARRAY_ELEMS(ost->audio_channels_map); j++)
2321                         ost->audio_channels_map[j] = -1;
2322                 } else if (!codec->channels) {
2323                     codec->channels = icodec->channels;
2324                     codec->channel_layout = icodec->channel_layout;
2325                 }
2326                 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2327                     codec->channel_layout = 0;
2328
2329                 ost->audio_resample       = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2330                 ost->audio_resample      |=    codec->sample_fmt     != icodec->sample_fmt
2331                                             || codec->channel_layout != icodec->channel_layout;
2332                 icodec->request_channels  = codec->channels;
2333                 ost->resample_sample_fmt  = icodec->sample_fmt;
2334                 ost->resample_sample_rate = icodec->sample_rate;
2335                 ost->resample_channels    = icodec->channels;
2336                 break;
2337             case AVMEDIA_TYPE_VIDEO:
2338                 if (codec->pix_fmt == PIX_FMT_NONE)
2339                     codec->pix_fmt = icodec->pix_fmt;
2340                 choose_pixel_fmt(ost->st, ost->enc);
2341
2342                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2343                     av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2344                     exit_program(1);
2345                 }
2346
2347                 if (!codec->width || !codec->height) {
2348                     codec->width  = icodec->width;
2349                     codec->height = icodec->height;
2350                 }
2351
2352                 ost->video_resample = codec->width   != icodec->width  ||
2353                                       codec->height  != icodec->height ||
2354                                       codec->pix_fmt != icodec->pix_fmt;
2355                 if (ost->video_resample) {
2356                     codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2357                 }
2358
2359                 ost->resample_height  = icodec->height;
2360                 ost->resample_width   = icodec->width;
2361                 ost->resample_pix_fmt = icodec->pix_fmt;
2362
2363                 if (!ost->frame_rate.num)
2364                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2365                 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2366                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2367                     ost->frame_rate = ost->enc->supported_framerates[idx];
2368                 }
2369                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2370                 if(   av_q2d(codec->time_base) < 0.001 && video_sync_method
2371                    && (video_sync_method==1 || (video_sync_method<0 && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
2372                     av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2373                                                "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2374                 }
2375                 for (j = 0; j < ost->forced_kf_count; j++)
2376                     ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
2377                                                          AV_TIME_BASE_Q,
2378                                                          codec->time_base);
2379
2380 #if CONFIG_AVFILTER
2381                 if (configure_video_filters(ist, ost)) {
2382                     av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2383                     exit(1);
2384                 }
2385 #endif
2386                 break;
2387             case AVMEDIA_TYPE_SUBTITLE:
2388                 break;
2389             default:
2390                 abort();
2391                 break;
2392             }
2393             /* two pass mode */
2394             if (codec->codec_id != CODEC_ID_H264 &&
2395                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2396                 char logfilename[1024];
2397                 FILE *f;
2398
2399                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2400                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2401                          i);
2402                 if (codec->flags & CODEC_FLAG_PASS2) {
2403                     char  *logbuffer;
2404                     size_t logbuffer_size;
2405                     if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2406                         av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2407                                logfilename);
2408                         exit_program(1);
2409                     }
2410                     codec->stats_in = logbuffer;
2411                 }
2412                 if (codec->flags & CODEC_FLAG_PASS1) {
2413                     f = fopen(logfilename, "wb");
2414                     if (!f) {
2415                         av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2416                                logfilename, strerror(errno));
2417                         exit_program(1);
2418                     }
2419                     ost->logfile = f;
2420                 }
2421             }
2422         }
2423         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2424             /* maximum video buffer size is 6-bytes per pixel, plus DPX header size (1664)*/
2425             int size        = codec->width * codec->height;
2426             bit_buffer_size = FFMAX(bit_buffer_size, 7*size + 10000);
2427         }
2428     }
2429
2430     if (!bit_buffer)
2431         bit_buffer = av_malloc(bit_buffer_size);
2432     if (!bit_buffer) {
2433         av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2434                bit_buffer_size);
2435         return AVERROR(ENOMEM);
2436     }
2437
2438     /* open each encoder */
2439     for (i = 0; i < nb_output_streams; i++) {
2440         ost = &output_streams[i];
2441         if (ost->encoding_needed) {
2442             AVCodec      *codec = ost->enc;
2443             AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2444             if (!codec) {
2445                 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
2446                          avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2447                 ret = AVERROR(EINVAL);
2448                 goto dump_format;
2449             }
2450             if (dec->subtitle_header) {
2451                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2452                 if (!ost->st->codec->subtitle_header) {
2453                     ret = AVERROR(ENOMEM);
2454                     goto dump_format;
2455                 }
2456                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2457                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2458             }
2459             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2460                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2461                         ost->file_index, ost->index);
2462                 ret = AVERROR(EINVAL);
2463                 goto dump_format;
2464             }
2465             assert_codec_experimental(ost->st->codec, 1);
2466             assert_avoptions(ost->opts);
2467             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2468                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2469                                              " It takes bits/s as argument, not kbits/s\n");
2470             extra_size += ost->st->codec->extradata_size;
2471
2472             if (ost->st->codec->me_threshold)
2473                 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2474         }
2475     }
2476
2477     /* init input streams */
2478     for (i = 0; i < nb_input_streams; i++)
2479         if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2480             goto dump_format;
2481
2482     /* discard unused programs */
2483     for (i = 0; i < nb_input_files; i++) {
2484         InputFile *ifile = &input_files[i];
2485         for (j = 0; j < ifile->ctx->nb_programs; j++) {
2486             AVProgram *p = ifile->ctx->programs[j];
2487             int discard  = AVDISCARD_ALL;
2488
2489             for (k = 0; k < p->nb_stream_indexes; k++)
2490                 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2491                     discard = AVDISCARD_DEFAULT;
2492                     break;
2493                 }
2494             p->discard = discard;
2495         }
2496     }
2497
2498     /* open files and write file headers */
2499     for (i = 0; i < nb_output_files; i++) {
2500         oc = output_files[i].ctx;
2501         oc->interrupt_callback = int_cb;
2502         if (avformat_write_header(oc, &output_files[i].opts) < 0) {
2503             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2504             ret = AVERROR(EINVAL);
2505             goto dump_format;
2506         }
2507 //        assert_avoptions(output_files[i].opts);
2508         if (strcmp(oc->oformat->name, "rtp")) {
2509             want_sdp = 0;
2510         }
2511     }
2512
2513  dump_format:
2514     /* dump the file output parameters - cannot be done before in case
2515        of stream copy */
2516     for (i = 0; i < nb_output_files; i++) {
2517         av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2518     }
2519
2520     /* dump the stream mapping */
2521     av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2522     for (i = 0; i < nb_output_streams; i++) {
2523         ost = &output_streams[i];
2524
2525         if (ost->attachment_filename) {
2526             /* an attached file */
2527             av_log(NULL, AV_LOG_INFO, "  File %s -> Stream #%d:%d\n",
2528                    ost->attachment_filename, ost->file_index, ost->index);
2529             continue;
2530         }
2531         av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d -> #%d:%d",
2532                input_streams[ost->source_index].file_index,
2533                input_streams[ost->source_index].st->index,
2534                ost->file_index,
2535                ost->index);
2536         if (ost->audio_channels_mapped) {
2537             av_log(NULL, AV_LOG_INFO, " [ch:");
2538             for (j = 0; j < ost->audio_channels_mapped; j++)
2539                 if (ost->audio_channels_map[j] == -1)
2540                     av_log(NULL, AV_LOG_INFO, " M");
2541                 else
2542                     av_log(NULL, AV_LOG_INFO, " %d", ost->audio_channels_map[j]);
2543             av_log(NULL, AV_LOG_INFO, "]");
2544         }
2545         if (ost->sync_ist != &input_streams[ost->source_index])
2546             av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2547                    ost->sync_ist->file_index,
2548                    ost->sync_ist->st->index);
2549         if (ost->stream_copy)
2550             av_log(NULL, AV_LOG_INFO, " (copy)");
2551         else
2552             av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2553                    input_streams[ost->source_index].dec->name : "?",
2554                    ost->enc ? ost->enc->name : "?");
2555         av_log(NULL, AV_LOG_INFO, "\n");
2556     }
2557
2558     if (ret) {
2559         av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2560         return ret;
2561     }
2562
2563     if (want_sdp) {
2564         print_sdp(output_files, nb_output_files);
2565     }
2566
2567     return 0;
2568 }
2569
2570 /*
2571  * The following code is the main loop of the file converter
2572  */
2573 static int transcode(OutputFile *output_files, int nb_output_files,
2574                      InputFile  *input_files,  int nb_input_files)
2575 {
2576     int ret, i;
2577     AVFormatContext *is, *os;
2578     OutputStream *ost;
2579     InputStream *ist;
2580     uint8_t *no_packet;
2581     int no_packet_count=0;
2582     int64_t timer_start;
2583     int key;
2584
2585     if (!(no_packet = av_mallocz(nb_input_files)))
2586         exit_program(1);
2587
2588     ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2589     if (ret < 0)
2590         goto fail;
2591
2592     if (!using_stdin) {
2593         av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2594     }
2595
2596     timer_start = av_gettime();
2597
2598     for(; received_sigterm == 0;) {
2599         int file_index, ist_index;
2600         AVPacket pkt;
2601         int64_t ipts_min;
2602         double opts_min;
2603         int64_t cur_time= av_gettime();
2604
2605         ipts_min= INT64_MAX;
2606         opts_min= 1e100;
2607         /* if 'q' pressed, exits */
2608         if (!using_stdin) {
2609             static int64_t last_time;
2610             if (received_nb_signals)
2611                 break;
2612             /* read_key() returns 0 on EOF */
2613             if(cur_time - last_time >= 100000 && !run_as_daemon){
2614                 key =  read_key();
2615                 last_time = cur_time;
2616             }else
2617                 key = -1;
2618             if (key == 'q')
2619                 break;
2620             if (key == '+') av_log_set_level(av_log_get_level()+10);
2621             if (key == '-') av_log_set_level(av_log_get_level()-10);
2622             if (key == 's') qp_hist     ^= 1;
2623             if (key == 'h'){
2624                 if (do_hex_dump){
2625                     do_hex_dump = do_pkt_dump = 0;
2626                 } else if(do_pkt_dump){
2627                     do_hex_dump = 1;
2628                 } else
2629                     do_pkt_dump = 1;
2630                 av_log_set_level(AV_LOG_DEBUG);
2631             }
2632 #if CONFIG_AVFILTER
2633             if (key == 'c' || key == 'C'){
2634                 char buf[4096], target[64], command[256], arg[256] = {0};
2635                 double time;
2636                 int k, n = 0;
2637                 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2638                 i = 0;
2639                 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
2640                     if (k > 0)
2641                         buf[i++] = k;
2642                 buf[i] = 0;
2643                 if (k > 0 &&
2644                     (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
2645                     av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
2646                            target, time, command, arg);
2647                     for (i = 0; i < nb_output_streams; i++) {
2648                         ost = &output_streams[i];
2649                         if (ost->graph) {
2650                             if (time < 0) {
2651                                 ret = avfilter_graph_send_command(ost->graph, target, command, arg, buf, sizeof(buf),
2652                                                                   key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2653                                 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
2654                             } else {
2655                                 ret = avfilter_graph_queue_command(ost->graph, target, command, arg, 0, time);
2656                             }
2657                         }
2658                     }
2659                 } else {
2660                     av_log(NULL, AV_LOG_ERROR,
2661                            "Parse error, at least 3 arguments were expected, "
2662                            "only %d given in string '%s'\n", n, buf);
2663                 }
2664             }
2665 #endif
2666             if (key == 'd' || key == 'D'){
2667                 int debug=0;
2668                 if(key == 'D') {
2669                     debug = input_streams[0].st->codec->debug<<1;
2670                     if(!debug) debug = 1;
2671                     while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2672                         debug += debug;
2673                 }else
2674                     if(scanf("%d", &debug)!=1)
2675                         fprintf(stderr,"error parsing debug value\n");
2676                 for(i=0;i<nb_input_streams;i++) {
2677                     input_streams[i].st->codec->debug = debug;
2678                 }
2679                 for(i=0;i<nb_output_streams;i++) {
2680                     ost = &output_streams[i];
2681                     ost->st->codec->debug = debug;
2682                 }
2683                 if(debug) av_log_set_level(AV_LOG_DEBUG);
2684                 fprintf(stderr,"debug=%d\n", debug);
2685             }
2686             if (key == '?'){
2687                 fprintf(stderr, "key    function\n"
2688                                 "?      show this help\n"
2689                                 "+      increase verbosity\n"
2690                                 "-      decrease verbosity\n"
2691                                 "c      Send command to filtergraph\n"
2692                                 "D      cycle through available debug modes\n"
2693                                 "h      dump packets/hex press to cycle through the 3 states\n"
2694                                 "q      quit\n"
2695                                 "s      Show QP histogram\n"
2696                 );
2697             }
2698         }
2699
2700         /* select the stream that we must read now by looking at the
2701            smallest output pts */
2702         file_index = -1;
2703         for (i = 0; i < nb_output_streams; i++) {
2704             OutputFile *of;
2705             int64_t ipts;
2706             double  opts;
2707             ost = &output_streams[i];
2708             of = &output_files[ost->file_index];
2709             os = output_files[ost->file_index].ctx;
2710             ist = &input_streams[ost->source_index];
2711             if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2712                 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2713                 continue;
2714             opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2715             ipts = ist->pts;
2716             if (!input_files[ist->file_index].eof_reached){
2717                 if(ipts < ipts_min) {
2718                     ipts_min = ipts;
2719                     if(input_sync ) file_index = ist->file_index;
2720                 }
2721                 if(opts < opts_min) {
2722                     opts_min = opts;
2723                     if(!input_sync) file_index = ist->file_index;
2724                 }
2725             }
2726             if (ost->frame_number >= ost->max_frames) {
2727                 int j;
2728                 for (j = 0; j < of->ctx->nb_streams; j++)
2729                     output_streams[of->ost_index + j].is_past_recording_time = 1;
2730                 continue;
2731             }
2732         }
2733         /* if none, if is finished */
2734         if (file_index < 0) {
2735             if(no_packet_count){
2736                 no_packet_count=0;
2737                 memset(no_packet, 0, nb_input_files);
2738                 usleep(10000);
2739                 continue;
2740             }
2741             break;
2742         }
2743
2744         /* read a frame from it and output it in the fifo */
2745         is = input_files[file_index].ctx;
2746         ret= av_read_frame(is, &pkt);
2747         if(ret == AVERROR(EAGAIN)){
2748             no_packet[file_index]=1;
2749             no_packet_count++;
2750             continue;
2751         }
2752         if (ret < 0) {
2753             input_files[file_index].eof_reached = 1;
2754             if (opt_shortest)
2755                 break;
2756             else
2757                 continue;
2758         }
2759
2760         no_packet_count=0;
2761         memset(no_packet, 0, nb_input_files);
2762
2763         if (do_pkt_dump) {
2764             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2765                              is->streams[pkt.stream_index]);
2766         }
2767         /* the following test is needed in case new streams appear
2768            dynamically in stream : we ignore them */
2769         if (pkt.stream_index >= input_files[file_index].nb_streams)
2770             goto discard_packet;
2771         ist_index = input_files[file_index].ist_index + pkt.stream_index;
2772         ist = &input_streams[ist_index];
2773         if (ist->discard)
2774             goto discard_packet;
2775
2776         if (pkt.dts != AV_NOPTS_VALUE)
2777             pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2778         if (pkt.pts != AV_NOPTS_VALUE)
2779             pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2780
2781         if(pkt.pts != AV_NOPTS_VALUE)
2782             pkt.pts *= ist->ts_scale;
2783         if(pkt.dts != AV_NOPTS_VALUE)
2784             pkt.dts *= ist->ts_scale;
2785
2786 //        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);
2787         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2788             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2789             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2790             int64_t delta= pkt_dts - ist->next_pts;
2791             if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2792                 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2793                  ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2794                 pkt_dts+1<ist->pts)&& !copy_ts){
2795                 input_files[ist->file_index].ts_offset -= delta;
2796                 av_log(NULL, AV_LOG_DEBUG, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2797                        delta, input_files[ist->file_index].ts_offset);
2798                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2799                 if(pkt.pts != AV_NOPTS_VALUE)
2800                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2801             }
2802         }
2803
2804         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2805         if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {
2806
2807             av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
2808                    ist->file_index, ist->st->index);
2809             if (exit_on_error)
2810                 exit_program(1);
2811             av_free_packet(&pkt);
2812             continue;
2813         }
2814
2815     discard_packet:
2816         av_free_packet(&pkt);
2817
2818         /* dump report by using the output first video and audio streams */
2819         print_report(output_files, output_streams, nb_output_streams, 0, timer_start, cur_time);
2820     }
2821
2822     /* at the end of stream, we must flush the decoder buffers */
2823     for (i = 0; i < nb_input_streams; i++) {
2824         ist = &input_streams[i];
2825         if (ist->decoding_needed) {
2826             output_packet(ist, output_streams, nb_output_streams, NULL);
2827         }
2828     }
2829     flush_encoders(output_streams, nb_output_streams);
2830
2831     term_exit();
2832
2833     /* write the trailer if needed and close file */
2834     for(i=0;i<nb_output_files;i++) {
2835         os = output_files[i].ctx;
2836         av_write_trailer(os);
2837     }
2838
2839     /* dump report by using the first video and audio streams */
2840     print_report(output_files, output_streams, nb_output_streams, 1, timer_start, av_gettime());
2841
2842     /* close each encoder */
2843     for (i = 0; i < nb_output_streams; i++) {
2844         ost = &output_streams[i];
2845         if (ost->encoding_needed) {
2846             av_freep(&ost->st->codec->stats_in);
2847             avcodec_close(ost->st->codec);
2848         }
2849 #if CONFIG_AVFILTER
2850         avfilter_graph_free(&ost->graph);
2851 #endif
2852     }
2853
2854     /* close each decoder */
2855     for (i = 0; i < nb_input_streams; i++) {
2856         ist = &input_streams[i];
2857         if (ist->decoding_needed) {
2858             avcodec_close(ist->st->codec);
2859         }
2860     }
2861
2862     /* finished ! */
2863     ret = 0;
2864
2865  fail:
2866     av_freep(&bit_buffer);
2867     av_freep(&no_packet);
2868
2869     if (output_streams) {
2870         for (i = 0; i < nb_output_streams; i++) {
2871             ost = &output_streams[i];
2872             if (ost) {
2873                 if (ost->stream_copy)
2874                     av_freep(&ost->st->codec->extradata);
2875                 if (ost->logfile) {
2876                     fclose(ost->logfile);
2877                     ost->logfile = NULL;
2878                 }
2879                 av_fifo_free(ost->fifo); /* works even if fifo is not
2880                                              initialized but set to zero */
2881                 av_freep(&ost->st->codec->subtitle_header);
2882                 av_free(ost->resample_frame.data[0]);
2883                 av_free(ost->forced_kf_pts);
2884                 if (ost->video_resample)
2885                     sws_freeContext(ost->img_resample_ctx);
2886                 swr_free(&ost->swr);
2887                 av_dict_free(&ost->opts);
2888             }
2889         }
2890     }
2891     return ret;
2892 }
2893
2894 static int opt_frame_crop(const char *opt, const char *arg)
2895 {
2896     av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
2897     return AVERROR(EINVAL);
2898 }
2899
2900 static int opt_pad(const char *opt, const char *arg)
2901 {
2902     av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
2903     return -1;
2904 }
2905
2906 static double parse_frame_aspect_ratio(const char *arg)
2907 {
2908     int x = 0, y = 0;
2909     double ar = 0;
2910     const char *p;
2911     char *end;
2912
2913     p = strchr(arg, ':');
2914     if (p) {
2915         x = strtol(arg, &end, 10);
2916         if (end == p)
2917             y = strtol(end+1, &end, 10);
2918         if (x > 0 && y > 0)
2919             ar = (double)x / (double)y;
2920     } else
2921         ar = strtod(arg, NULL);
2922
2923     if (!ar) {
2924         av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2925         exit_program(1);
2926     }
2927     return ar;
2928 }
2929
2930 static int opt_video_channel(const char *opt, const char *arg)
2931 {
2932     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2933     return opt_default("channel", arg);
2934 }
2935
2936 static int opt_video_standard(const char *opt, const char *arg)
2937 {
2938     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2939     return opt_default("standard", arg);
2940 }
2941
2942 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2943 {
2944     audio_codec_name = arg;
2945     return parse_option(o, "codec:a", arg, options);
2946 }
2947
2948 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2949 {
2950     video_codec_name = arg;
2951     return parse_option(o, "codec:v", arg, options);
2952 }
2953
2954 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2955 {
2956     subtitle_codec_name = arg;
2957     return parse_option(o, "codec:s", arg, options);
2958 }
2959
2960 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2961 {
2962     return parse_option(o, "codec:d", arg, options);
2963 }
2964
2965 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2966 {
2967     StreamMap *m = NULL;
2968     int i, negative = 0, file_idx;
2969     int sync_file_idx = -1, sync_stream_idx;
2970     char *p, *sync;
2971     char *map;
2972
2973     if (*arg == '-') {
2974         negative = 1;
2975         arg++;
2976     }
2977     map = av_strdup(arg);
2978
2979     /* parse sync stream first, just pick first matching stream */
2980     if (sync = strchr(map, ',')) {
2981         *sync = 0;
2982         sync_file_idx = strtol(sync + 1, &sync, 0);
2983         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2984             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2985             exit_program(1);
2986         }
2987         if (*sync)
2988             sync++;
2989         for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2990             if (check_stream_specifier(input_files[sync_file_idx].ctx,
2991                                        input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2992                 sync_stream_idx = i;
2993                 break;
2994             }
2995         if (i == input_files[sync_file_idx].nb_streams) {
2996             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2997                                        "match any streams.\n", arg);
2998             exit_program(1);
2999         }
3000     }
3001
3002
3003     file_idx = strtol(map, &p, 0);
3004     if (file_idx >= nb_input_files || file_idx < 0) {
3005         av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3006         exit_program(1);
3007     }
3008     if (negative)
3009         /* disable some already defined maps */
3010         for (i = 0; i < o->nb_stream_maps; i++) {
3011             m = &o->stream_maps[i];
3012             if (file_idx == m->file_index &&
3013                 check_stream_specifier(input_files[m->file_index].ctx,
3014                                        input_files[m->file_index].ctx->streams[m->stream_index],
3015                                        *p == ':' ? p + 1 : p) > 0)
3016                 m->disabled = 1;
3017         }
3018     else
3019         for (i = 0; i < input_files[file_idx].nb_streams; i++) {
3020             if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
3021                         *p == ':' ? p + 1 : p) <= 0)
3022                 continue;
3023             o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3024                                         &o->nb_stream_maps, o->nb_stream_maps + 1);
3025             m = &o->stream_maps[o->nb_stream_maps - 1];
3026
3027             m->file_index   = file_idx;
3028             m->stream_index = i;
3029
3030             if (sync_file_idx >= 0) {
3031                 m->sync_file_index   = sync_file_idx;
3032                 m->sync_stream_index = sync_stream_idx;
3033             } else {
3034                 m->sync_file_index   = file_idx;
3035                 m->sync_stream_index = i;
3036             }
3037         }
3038
3039     if (!m) {
3040         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3041         exit_program(1);
3042     }
3043
3044     av_freep(&map);
3045     return 0;
3046 }
3047
3048 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3049 {
3050     o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3051                                 &o->nb_attachments, o->nb_attachments + 1);
3052     o->attachments[o->nb_attachments - 1] = arg;
3053     return 0;
3054 }
3055
3056 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
3057 {
3058     int n;
3059     AVStream *st;
3060     AudioChannelMap *m;
3061
3062     o->audio_channel_maps =
3063         grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
3064                    &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
3065     m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
3066
3067     /* muted channel syntax */
3068     n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
3069     if ((n == 1 || n == 3) && m->channel_idx == -1) {
3070         m->file_idx = m->stream_idx = -1;
3071         if (n == 1)
3072             m->ofile_idx = m->ostream_idx = -1;
3073         return 0;
3074     }
3075
3076     /* normal syntax */
3077     n = sscanf(arg, "%d.%d.%d:%d.%d",
3078                &m->file_idx,  &m->stream_idx, &m->channel_idx,
3079                &m->ofile_idx, &m->ostream_idx);
3080
3081     if (n != 3 && n != 5) {
3082         av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
3083                "[file.stream.channel|-1][:syncfile:syncstream]\n");
3084         exit_program(1);
3085     }
3086
3087     if (n != 5) // only file.stream.channel specified
3088         m->ofile_idx = m->ostream_idx = -1;
3089
3090     /* check input */
3091     if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
3092         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
3093                m->file_idx);
3094         exit_program(1);
3095     }
3096     if (m->stream_idx < 0 ||
3097         m->stream_idx >= input_files[m->file_idx].nb_streams) {
3098         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
3099                m->file_idx, m->stream_idx);
3100         exit_program(1);
3101     }
3102     st = input_files[m->file_idx].ctx->streams[m->stream_idx];
3103     if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
3104         av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
3105                m->file_idx, m->stream_idx);
3106         exit_program(1);
3107     }
3108     if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
3109         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
3110                m->file_idx, m->stream_idx, m->channel_idx);
3111         exit_program(1);
3112     }
3113     return 0;
3114 }
3115
3116 /**
3117  * Parse a metadata specifier in arg.
3118  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3119  * @param index for type c/p, chapter/program index is written here
3120  * @param stream_spec for type s, the stream specifier is written here
3121  */
3122 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3123 {
3124     if (*arg) {
3125         *type = *arg;
3126         switch (*arg) {
3127         case 'g':
3128             break;
3129         case 's':
3130             if (*(++arg) && *arg != ':') {
3131                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3132                 exit_program(1);
3133             }
3134             *stream_spec = *arg == ':' ? arg + 1 : "";
3135             break;
3136         case 'c':
3137         case 'p':
3138             if (*(++arg) == ':')
3139                 *index = strtol(++arg, NULL, 0);
3140             break;
3141         default:
3142             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3143             exit_program(1);
3144         }
3145     } else
3146         *type = 'g';
3147 }
3148
3149 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3150 {
3151     AVDictionary **meta_in = NULL;
3152     AVDictionary **meta_out;
3153     int i, ret = 0;
3154     char type_in, type_out;
3155     const char *istream_spec = NULL, *ostream_spec = NULL;
3156     int idx_in = 0, idx_out = 0;
3157
3158     parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
3159     parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3160
3161     if (type_in == 'g' || type_out == 'g')
3162         o->metadata_global_manual = 1;
3163     if (type_in == 's' || type_out == 's')
3164         o->metadata_streams_manual = 1;
3165     if (type_in == 'c' || type_out == 'c')
3166         o->metadata_chapters_manual = 1;
3167
3168 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3169     if ((index) < 0 || (index) >= (nb_elems)) {\
3170         av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
3171                 (desc), (index));\
3172         exit_program(1);\
3173     }
3174
3175 #define SET_DICT(type, meta, context, index)\
3176         switch (type) {\
3177         case 'g':\
3178             meta = &context->metadata;\
3179             break;\
3180         case 'c':\
3181             METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
3182             meta = &context->chapters[index]->metadata;\
3183             break;\
3184         case 'p':\
3185             METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
3186             meta = &context->programs[index]->metadata;\
3187             break;\
3188         }\
3189
3190     SET_DICT(type_in, meta_in, ic, idx_in);
3191     SET_DICT(type_out, meta_out, oc, idx_out);
3192
3193     /* for input streams choose first matching stream */
3194     if (type_in == 's') {
3195         for (i = 0; i < ic->nb_streams; i++) {
3196             if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
3197                 meta_in = &ic->streams[i]->metadata;
3198                 break;
3199             } else if (ret < 0)
3200                 exit_program(1);
3201         }
3202         if (!meta_in) {
3203             av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
3204             exit_program(1);
3205         }
3206     }
3207
3208     if (type_out == 's') {
3209         for (i = 0; i < oc->nb_streams; i++) {
3210             if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
3211                 meta_out = &oc->streams[i]->metadata;
3212                 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3213             } else if (ret < 0)
3214                 exit_program(1);
3215         }
3216     } else
3217         av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3218
3219     return 0;
3220 }
3221
3222 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
3223 {
3224     char buf[128];
3225     int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3226     struct tm time = *gmtime((time_t*)&recording_timestamp);
3227     strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3228     parse_option(o, "metadata", buf, options);
3229
3230     av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3231                                  "tag instead.\n", opt);
3232     return 0;
3233 }
3234
3235 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3236 {
3237     const char *codec_string = encoder ? "encoder" : "decoder";
3238     AVCodec *codec;
3239
3240     codec = encoder ?
3241         avcodec_find_encoder_by_name(name) :
3242         avcodec_find_decoder_by_name(name);
3243     if(!codec) {
3244         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3245         exit_program(1);
3246     }
3247     if(codec->type != type) {
3248         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3249         exit_program(1);
3250     }
3251     return codec;
3252 }
3253
3254 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3255 {
3256     char *codec_name = NULL;
3257
3258     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3259     if (codec_name) {
3260         AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3261         st->codec->codec_id = codec->id;
3262         return codec;
3263     } else
3264         return avcodec_find_decoder(st->codec->codec_id);
3265 }
3266
3267 /**
3268  * Add all the streams from the given input file to the global
3269  * list of input streams.
3270  */
3271 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3272 {
3273     int i, rfps, rfps_base;
3274     char *next, *codec_tag = NULL;
3275
3276     for (i = 0; i < ic->nb_streams; i++) {
3277         AVStream *st = ic->streams[i];
3278         AVCodecContext *dec = st->codec;
3279         InputStream *ist;
3280
3281         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3282         ist = &input_streams[nb_input_streams - 1];
3283         ist->st = st;
3284         ist->file_index = nb_input_files;
3285         ist->discard = 1;
3286         ist->opts = filter_codec_opts(codec_opts, choose_decoder(o, ic, st), ic, st);
3287
3288         ist->ts_scale = 1.0;
3289         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
3290
3291         MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
3292         if (codec_tag) {
3293             uint32_t tag = strtol(codec_tag, &next, 0);
3294             if (*next)
3295                 tag = AV_RL32(codec_tag);
3296             st->codec->codec_tag = tag;
3297         }
3298
3299         ist->dec = choose_decoder(o, ic, st);
3300
3301         switch (dec->codec_type) {
3302         case AVMEDIA_TYPE_AUDIO:
3303             if(!ist->dec)
3304                 ist->dec = avcodec_find_decoder(dec->codec_id);
3305             if(o->audio_disable)
3306                 st->discard= AVDISCARD_ALL;
3307             break;
3308         case AVMEDIA_TYPE_VIDEO:
3309             if(!ist->dec)
3310                 ist->dec = avcodec_find_decoder(dec->codec_id);
3311             rfps      = ic->streams[i]->r_frame_rate.num;
3312             rfps_base = ic->streams[i]->r_frame_rate.den;
3313             if (dec->lowres) {
3314                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3315             }
3316
3317             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3318
3319                 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",
3320                        i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3321                        (float)rfps / rfps_base, rfps, rfps_base);
3322             }
3323
3324             if (o->video_disable)
3325                 st->discard= AVDISCARD_ALL;
3326             else if(video_discard)
3327                 st->discard= video_discard;
3328             break;
3329         case AVMEDIA_TYPE_DATA:
3330             if (o->data_disable)
3331                 st->discard= AVDISCARD_ALL;
3332             break;
3333         case AVMEDIA_TYPE_SUBTITLE:
3334             if(!ist->dec)
3335                 ist->dec = avcodec_find_decoder(dec->codec_id);
3336             if(o->subtitle_disable)
3337                 st->discard = AVDISCARD_ALL;
3338             break;
3339         case AVMEDIA_TYPE_ATTACHMENT:
3340         case AVMEDIA_TYPE_UNKNOWN:
3341             break;
3342         default:
3343             abort();
3344         }
3345     }
3346 }
3347
3348 static void assert_file_overwrite(const char *filename)
3349 {
3350     if ((!file_overwrite || no_file_overwrite) &&
3351         (strchr(filename, ':') == NULL || filename[1] == ':' ||
3352          av_strstart(filename, "file:", NULL))) {
3353         if (avio_check(filename, 0) == 0) {
3354             if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
3355                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3356                 fflush(stderr);
3357                 term_exit();
3358                 signal(SIGINT, SIG_DFL);
3359                 if (!read_yesno()) {
3360                     av_log(0, AV_LOG_FATAL, "Not overwriting - exiting\n");
3361                     exit_program(1);
3362                 }
3363                 term_init();
3364             }
3365             else {
3366                 av_log(0, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
3367                 exit_program(1);
3368             }
3369         }
3370     }
3371 }
3372
3373 static void dump_attachment(AVStream *st, const char *filename)
3374 {
3375     int ret;
3376     AVIOContext *out = NULL;
3377     AVDictionaryEntry *e;
3378
3379     if (!st->codec->extradata_size) {
3380         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
3381                nb_input_files - 1, st->index);
3382         return;
3383     }
3384     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3385         filename = e->value;
3386     if (!*filename) {
3387         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
3388                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3389         exit_program(1);
3390     }
3391
3392     assert_file_overwrite(filename);
3393
3394     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
3395         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3396                filename);
3397         exit_program(1);
3398     }
3399
3400     avio_write(out, st->codec->extradata, st->codec->extradata_size);
3401     avio_flush(out);
3402     avio_close(out);
3403 }
3404
3405 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3406 {
3407     AVFormatContext *ic;
3408     AVInputFormat *file_iformat = NULL;
3409     int err, i, ret;
3410     int64_t timestamp;
3411     uint8_t buf[128];
3412     AVDictionary **opts;
3413     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
3414
3415     if (o->format) {
3416         if (!(file_iformat = av_find_input_format(o->format))) {
3417             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3418             exit_program(1);
3419         }
3420     }
3421
3422     if (!strcmp(filename, "-"))
3423         filename = "pipe:";
3424
3425     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3426                     !strcmp(filename, "/dev/stdin");
3427
3428     /* get default parameters from command line */
3429     ic = avformat_alloc_context();
3430     if (!ic) {
3431         print_error(filename, AVERROR(ENOMEM));
3432         exit_program(1);
3433     }
3434     if (o->nb_audio_sample_rate) {
3435         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3436         av_dict_set(&format_opts, "sample_rate", buf, 0);
3437     }
3438     if (o->nb_audio_channels) {
3439         snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3440         av_dict_set(&format_opts, "channels", buf, 0);
3441     }
3442     if (o->nb_frame_rates) {
3443         av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3444     }
3445     if (o->nb_frame_sizes) {
3446         av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3447     }
3448     if (o->nb_frame_pix_fmts)
3449         av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3450
3451     ic->video_codec_id   = video_codec_name ?
3452         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0)->id : CODEC_ID_NONE;
3453     ic->audio_codec_id   = audio_codec_name ?
3454         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0)->id : CODEC_ID_NONE;
3455     ic->subtitle_codec_id= subtitle_codec_name ?
3456         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
3457     ic->flags |= AVFMT_FLAG_NONBLOCK;
3458     ic->interrupt_callback = int_cb;
3459
3460     if (loop_input) {
3461         av_log(NULL, AV_LOG_WARNING,
3462             "-loop_input is deprecated, use -loop 1\n"
3463             "Note, both loop options only work with -f image2\n"
3464         );
3465         ic->loop_input = loop_input;
3466     }
3467
3468     /* open the input file with generic avformat function */
3469     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3470     if (err < 0) {
3471         print_error(filename, err);
3472         exit_program(1);
3473     }
3474     assert_avoptions(format_opts);
3475
3476     /* apply forced codec ids */
3477     for (i = 0; i < ic->nb_streams; i++)
3478         choose_decoder(o, ic, ic->streams[i]);
3479
3480     /* Set AVCodecContext options for avformat_find_stream_info */
3481     opts = setup_find_stream_info_opts(ic, codec_opts);
3482     orig_nb_streams = ic->nb_streams;
3483
3484     /* If not enough info to get the stream parameters, we decode the
3485        first frames to get it. (used in mpeg case for example) */
3486     ret = avformat_find_stream_info(ic, opts);
3487     if (ret < 0) {
3488         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3489         avformat_close_input(&ic);
3490         exit_program(1);
3491     }
3492
3493     timestamp = o->start_time;
3494     /* add the stream start time */
3495     if (ic->start_time != AV_NOPTS_VALUE)
3496         timestamp += ic->start_time;
3497
3498     /* if seeking requested, we execute it */
3499     if (o->start_time != 0) {
3500         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3501         if (ret < 0) {
3502             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3503                    filename, (double)timestamp / AV_TIME_BASE);
3504         }
3505     }
3506
3507     /* update the current parameters so that they match the one of the input stream */
3508     add_input_streams(o, ic);
3509
3510     /* dump the file content */
3511     av_dump_format(ic, nb_input_files, filename, 0);
3512
3513     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3514     input_files[nb_input_files - 1].ctx        = ic;
3515     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3516     input_files[nb_input_files - 1].ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3517     input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3518     input_files[nb_input_files - 1].rate_emu   = o->rate_emu;
3519
3520     for (i = 0; i < o->nb_dump_attachment; i++) {
3521         int j;
3522
3523         for (j = 0; j < ic->nb_streams; j++) {
3524             AVStream *st = ic->streams[j];
3525
3526             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3527                 dump_attachment(st, o->dump_attachment[i].u.str);
3528         }
3529     }
3530
3531     for (i = 0; i < orig_nb_streams; i++)
3532         av_dict_free(&opts[i]);
3533     av_freep(&opts);
3534
3535     reset_options(o, 1);
3536     return 0;
3537 }
3538
3539 static void parse_forced_key_frames(char *kf, OutputStream *ost)
3540 {
3541     char *p;
3542     int n = 1, i;
3543
3544     for (p = kf; *p; p++)
3545         if (*p == ',')
3546             n++;
3547     ost->forced_kf_count = n;
3548     ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3549     if (!ost->forced_kf_pts) {
3550         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3551         exit_program(1);
3552     }
3553     for (i = 0; i < n; i++) {
3554         p = i ? strchr(p, ',') + 1 : kf;
3555         ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
3556     }
3557 }
3558
3559 static uint8_t *get_line(AVIOContext *s)
3560 {
3561     AVIOContext *line;
3562     uint8_t *buf;
3563     char c;
3564
3565     if (avio_open_dyn_buf(&line) < 0) {
3566         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3567         exit_program(1);
3568     }
3569
3570     while ((c = avio_r8(s)) && c != '\n')
3571         avio_w8(line, c);
3572     avio_w8(line, 0);
3573     avio_close_dyn_buf(line, &buf);
3574
3575     return buf;
3576 }
3577
3578 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3579 {
3580     int i, ret = 1;
3581     char filename[1000];
3582     const char *base[3] = { getenv("AVCONV_DATADIR"),
3583                             getenv("HOME"),
3584                             AVCONV_DATADIR,
3585                             };
3586
3587     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3588         if (!base[i])
3589             continue;
3590         if (codec_name) {
3591             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3592                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
3593             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3594         }
3595         if (ret) {
3596             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3597                      i != 1 ? "" : "/.avconv", preset_name);
3598             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3599         }
3600     }
3601     return ret;
3602 }
3603
3604 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3605 {
3606     char *codec_name = NULL;
3607
3608     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3609     if (!codec_name) {
3610         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3611                                                   NULL, ost->st->codec->codec_type);
3612         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3613     } else if (!strcmp(codec_name, "copy"))
3614         ost->stream_copy = 1;
3615     else {
3616         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3617         ost->st->codec->codec_id = ost->enc->id;
3618     }
3619 }
3620
3621 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3622 {
3623     OutputStream *ost;
3624     AVStream *st = avformat_new_stream(oc, NULL);
3625     int idx      = oc->nb_streams - 1, ret = 0;
3626     char *bsf = NULL, *next, *codec_tag = NULL;
3627     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3628     double qscale = -1;
3629     char *buf = NULL, *arg = NULL, *preset = NULL;
3630     AVIOContext *s = NULL;
3631
3632     if (!st) {
3633         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3634         exit_program(1);
3635     }
3636
3637     if (oc->nb_streams - 1 < o->nb_streamid_map)
3638         st->id = o->streamid_map[oc->nb_streams - 1];
3639
3640     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3641                                 nb_output_streams + 1);
3642     ost = &output_streams[nb_output_streams - 1];
3643     ost->file_index = nb_output_files;
3644     ost->index = idx;
3645     ost->st    = st;
3646     st->codec->codec_type = type;
3647     choose_encoder(o, oc, ost);
3648     if (ost->enc) {
3649         ost->opts  = filter_codec_opts(codec_opts, ost->enc, oc, st);
3650     }
3651
3652     avcodec_get_context_defaults3(st->codec, ost->enc);
3653     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3654
3655     MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3656     if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3657         do  {
3658             buf = get_line(s);
3659             if (!buf[0] || buf[0] == '#') {
3660                 av_free(buf);
3661                 continue;
3662             }
3663             if (!(arg = strchr(buf, '='))) {
3664                 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3665                 exit_program(1);
3666             }
3667             *arg++ = 0;
3668             av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3669             av_free(buf);
3670         } while (!s->eof_reached);
3671         avio_close(s);
3672     }
3673     if (ret) {
3674         av_log(NULL, AV_LOG_FATAL,
3675                "Preset %s specified for stream %d:%d, but could not be opened.\n",
3676                preset, ost->file_index, ost->index);
3677         exit_program(1);
3678     }
3679
3680     ost->max_frames = INT64_MAX;
3681     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3682
3683     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3684     while (bsf) {
3685         if (next = strchr(bsf, ','))
3686             *next++ = 0;
3687         if (!(bsfc = av_bitstream_filter_init(bsf))) {
3688             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3689             exit_program(1);
3690         }
3691         if (bsfc_prev)
3692             bsfc_prev->next = bsfc;
3693         else
3694             ost->bitstream_filters = bsfc;
3695
3696         bsfc_prev = bsfc;
3697         bsf       = next;
3698     }
3699
3700     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3701     if (codec_tag) {
3702         uint32_t tag = strtol(codec_tag, &next, 0);
3703         if (*next)
3704             tag = AV_RL32(codec_tag);
3705         st->codec->codec_tag = tag;
3706     }
3707
3708     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3709     if (qscale >= 0 || same_quant) {
3710         st->codec->flags |= CODEC_FLAG_QSCALE;
3711         st->codec->global_quality = FF_QP2LAMBDA * qscale;
3712     }
3713
3714     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3715         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3716
3717     av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3718     return ost;
3719 }
3720
3721 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3722 {
3723     int i;
3724     const char *p = str;
3725     for(i = 0;; i++) {
3726         dest[i] = atoi(p);
3727         if(i == 63)
3728             break;
3729         p = strchr(p, ',');
3730         if(!p) {
3731             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3732             exit_program(1);
3733         }
3734         p++;
3735     }
3736 }
3737
3738 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3739 {
3740     AVStream *st;
3741     OutputStream *ost;
3742     AVCodecContext *video_enc;
3743
3744     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3745     st  = ost->st;
3746     video_enc = st->codec;
3747
3748     if (!ost->stream_copy) {
3749         const char *p = NULL;
3750         char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3751         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3752         char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3753         int i;
3754
3755         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3756         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3757             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3758             exit_program(1);
3759         }
3760
3761         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3762         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3763             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3764             exit_program(1);
3765         }
3766
3767         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3768         if (frame_aspect_ratio)
3769             ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3770
3771         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3772         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3773         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3774             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3775             exit_program(1);
3776         }
3777         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3778
3779         if (intra_only)
3780             video_enc->gop_size = 0;
3781         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3782         if (intra_matrix) {
3783             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3784                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3785                 exit_program(1);
3786             }
3787             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3788         }
3789         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3790         if (inter_matrix) {
3791             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3792                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3793                 exit_program(1);
3794             }
3795             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3796         }
3797
3798         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3799         for(i=0; p; i++){
3800             int start, end, q;
3801             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3802             if(e!=3){
3803                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3804                 exit_program(1);
3805             }
3806             /* FIXME realloc failure */
3807             video_enc->rc_override=
3808                 av_realloc(video_enc->rc_override,
3809                            sizeof(RcOverride)*(i+1));
3810             video_enc->rc_override[i].start_frame= start;
3811             video_enc->rc_override[i].end_frame  = end;
3812             if(q>0){
3813                 video_enc->rc_override[i].qscale= q;
3814                 video_enc->rc_override[i].quality_factor= 1.0;
3815             }
3816             else{
3817                 video_enc->rc_override[i].qscale= 0;
3818                 video_enc->rc_override[i].quality_factor= -q/100.0;
3819             }
3820             p= strchr(p, '/');
3821             if(p) p++;
3822         }
3823         video_enc->rc_override_count=i;
3824         if (!video_enc->rc_initial_buffer_occupancy)
3825             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3826         video_enc->intra_dc_precision= intra_dc_precision - 8;
3827
3828         if (do_psnr)
3829             video_enc->flags|= CODEC_FLAG_PSNR;
3830
3831         /* two pass mode */
3832         if (do_pass) {
3833             if (do_pass & 1) {
3834                 video_enc->flags |= CODEC_FLAG_PASS1;
3835             }
3836             if (do_pass & 2) {
3837                 video_enc->flags |= CODEC_FLAG_PASS2;
3838             }
3839         }
3840
3841         MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3842         if (forced_key_frames)
3843             parse_forced_key_frames(forced_key_frames, ost);
3844
3845         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
3846
3847         ost->top_field_first = -1;
3848         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
3849
3850         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
3851
3852 #if CONFIG_AVFILTER
3853         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3854         if (filters)
3855             ost->avfilter = av_strdup(filters);
3856 #endif
3857     }
3858
3859     return ost;
3860 }
3861
3862 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3863 {
3864     int n;
3865     AVStream *st;
3866     OutputStream *ost;
3867     AVCodecContext *audio_enc;
3868
3869     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3870     st  = ost->st;
3871
3872     audio_enc = st->codec;
3873     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3874
3875     if (!ost->stream_copy) {
3876         char *sample_fmt = NULL;
3877
3878         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3879
3880         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3881         if (sample_fmt &&
3882             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3883             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3884             exit_program(1);
3885         }
3886
3887         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3888
3889         ost->rematrix_volume=1.0;
3890         MATCH_PER_STREAM_OPT(rematrix_volume, f, ost->rematrix_volume, oc, st);
3891     }
3892
3893     /* check for channel mapping for this audio stream */
3894     for (n = 0; n < o->nb_audio_channel_maps; n++) {
3895         AudioChannelMap *map = &o->audio_channel_maps[n];
3896         InputStream *ist = &input_streams[ost->source_index];
3897         if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
3898             (map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
3899             (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
3900             if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
3901                 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
3902             else
3903                 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
3904                        ost->file_index, ost->st->index);
3905         }
3906     }
3907
3908     return ost;
3909 }
3910
3911 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3912 {
3913     OutputStream *ost;
3914
3915     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3916     if (!ost->stream_copy) {
3917         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3918         exit_program(1);
3919     }
3920
3921     return ost;
3922 }
3923
3924 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3925 {
3926     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3927     ost->stream_copy = 1;
3928     return ost;
3929 }
3930
3931 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3932 {
3933     AVStream *st;
3934     OutputStream *ost;
3935     AVCodecContext *subtitle_enc;
3936
3937     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3938     st  = ost->st;
3939     subtitle_enc = st->codec;
3940
3941     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3942
3943     return ost;
3944 }
3945
3946 /* arg format is "output-stream-index:streamid-value". */
3947 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3948 {
3949     int idx;
3950     char *p;
3951     char idx_str[16];
3952
3953     av_strlcpy(idx_str, arg, sizeof(idx_str));
3954     p = strchr(idx_str, ':');
3955     if (!p) {
3956         av_log(NULL, AV_LOG_FATAL,
3957                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3958                arg, opt);
3959         exit_program(1);
3960     }
3961     *p++ = '\0';
3962     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3963     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3964     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3965     return 0;
3966 }
3967
3968 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3969 {
3970     AVFormatContext *is = ifile->ctx;
3971     AVFormatContext *os = ofile->ctx;
3972     int i;
3973
3974     for (i = 0; i < is->nb_chapters; i++) {
3975         AVChapter *in_ch = is->chapters[i], *out_ch;
3976         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
3977                                       AV_TIME_BASE_Q, in_ch->time_base);
3978         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3979                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3980
3981
3982         if (in_ch->end < ts_off)
3983             continue;
3984         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3985             break;
3986
3987         out_ch = av_mallocz(sizeof(AVChapter));
3988         if (!out_ch)
3989             return AVERROR(ENOMEM);
3990
3991         out_ch->id        = in_ch->id;
3992         out_ch->time_base = in_ch->time_base;
3993         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
3994         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
3995
3996         if (copy_metadata)
3997             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3998
3999         os->nb_chapters++;
4000         os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
4001         if (!os->chapters)
4002             return AVERROR(ENOMEM);
4003         os->chapters[os->nb_chapters - 1] = out_ch;
4004     }
4005     return 0;
4006 }
4007
4008 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
4009 {
4010     int i, err;
4011     AVFormatContext *ic = avformat_alloc_context();
4012
4013     ic->interrupt_callback = int_cb;
4014     err = avformat_open_input(&ic, filename, NULL, NULL);
4015     if (err < 0)
4016         return err;
4017     /* copy stream format */
4018     for(i=0;i<ic->nb_streams;i++) {
4019         AVStream *st;
4020         OutputStream *ost;
4021         AVCodec *codec;
4022         AVCodecContext *avctx;
4023
4024         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
4025         ost   = new_output_stream(o, s, codec->type);
4026         st    = ost->st;
4027         avctx = st->codec;
4028         ost->enc = codec;
4029
4030         // FIXME: a more elegant solution is needed
4031         memcpy(st, ic->streams[i], sizeof(AVStream));
4032         st->info = av_malloc(sizeof(*st->info));
4033         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
4034         st->codec= avctx;
4035         avcodec_copy_context(st->codec, ic->streams[i]->codec);
4036
4037         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
4038             choose_sample_fmt(st, codec);
4039         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
4040             choose_pixel_fmt(st, codec);
4041     }
4042
4043     av_close_input_file(ic);
4044     return 0;
4045 }
4046
4047 static void opt_output_file(void *optctx, const char *filename)
4048 {
4049     OptionsContext *o = optctx;
4050     AVFormatContext *oc;
4051     int i, err;
4052     AVOutputFormat *file_oformat;
4053     OutputStream *ost;
4054     InputStream  *ist;
4055
4056     if (!strcmp(filename, "-"))
4057         filename = "pipe:";
4058
4059     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
4060     if (!oc) {
4061         print_error(filename, err);
4062         exit_program(1);
4063     }
4064     file_oformat= oc->oformat;
4065     oc->interrupt_callback = int_cb;
4066
4067     if (!strcmp(file_oformat->name, "ffm") &&
4068         av_strstart(filename, "http:", NULL)) {
4069         int j;
4070         /* special case for files sent to ffserver: we get the stream
4071            parameters from ffserver */
4072         int err = read_ffserver_streams(o, oc, filename);
4073         if (err < 0) {
4074             print_error(filename, err);
4075             exit_program(1);
4076         }
4077         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
4078             ost = &output_streams[j];
4079             for (i = 0; i < nb_input_streams; i++) {
4080                 ist = &input_streams[i];
4081                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
4082                     ost->sync_ist= ist;
4083                     ost->source_index= i;
4084                     ist->discard = 0;
4085                     break;
4086                 }
4087             }
4088             if(!ost->sync_ist){
4089                 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));
4090                 exit_program(1);
4091             }
4092         }
4093     } else if (!o->nb_stream_maps) {
4094         /* pick the "best" stream of each type */
4095 #define NEW_STREAM(type, index)\
4096         if (index >= 0) {\
4097             ost = new_ ## type ## _stream(o, oc);\
4098             ost->source_index = index;\
4099             ost->sync_ist     = &input_streams[index];\
4100             input_streams[index].discard = 0;\
4101         }
4102
4103         /* video: highest resolution */
4104         if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
4105             int area = 0, idx = -1;
4106             for (i = 0; i < nb_input_streams; i++) {
4107                 ist = &input_streams[i];
4108                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
4109                     ist->st->codec->width * ist->st->codec->height > area) {
4110                     area = ist->st->codec->width * ist->st->codec->height;
4111                     idx = i;
4112                 }
4113             }
4114             NEW_STREAM(video, idx);
4115         }
4116
4117         /* audio: most channels */
4118         if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
4119             int channels = 0, idx = -1;
4120             for (i = 0; i < nb_input_streams; i++) {
4121                 ist = &input_streams[i];
4122                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
4123                     ist->st->codec->channels > channels) {
4124                     channels = ist->st->codec->channels;
4125                     idx = i;
4126                 }
4127             }
4128             NEW_STREAM(audio, idx);
4129         }
4130
4131         /* subtitles: pick first */
4132         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
4133             for (i = 0; i < nb_input_streams; i++)
4134                 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
4135                     NEW_STREAM(subtitle, i);
4136                     break;
4137                 }
4138         }
4139         /* do something with data? */
4140     } else {
4141         for (i = 0; i < o->nb_stream_maps; i++) {
4142             StreamMap *map = &o->stream_maps[i];
4143
4144             if (map->disabled)
4145                 continue;
4146
4147             ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
4148             if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
4149                 continue;
4150             if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
4151                 continue;
4152             if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
4153                 continue;
4154             if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
4155                 continue;
4156
4157             switch (ist->st->codec->codec_type) {
4158             case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
4159             case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
4160             case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
4161             case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
4162             case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
4163             default:
4164                 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
4165                        map->file_index, map->stream_index);
4166                 exit_program(1);
4167             }
4168
4169             ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
4170             ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
4171                                            map->sync_stream_index];
4172             ist->discard = 0;
4173         }
4174     }
4175
4176     /* handle attached files */
4177     for (i = 0; i < o->nb_attachments; i++) {
4178         AVIOContext *pb;
4179         uint8_t *attachment;
4180         const char *p;
4181         int64_t len;
4182
4183         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
4184             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
4185                    o->attachments[i]);
4186             exit_program(1);
4187         }
4188         if ((len = avio_size(pb)) <= 0) {
4189             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
4190                    o->attachments[i]);
4191             exit_program(1);
4192         }
4193         if (!(attachment = av_malloc(len))) {
4194             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
4195                    o->attachments[i]);
4196             exit_program(1);
4197         }
4198         avio_read(pb, attachment, len);
4199
4200         ost = new_attachment_stream(o, oc);
4201         ost->stream_copy               = 0;
4202         ost->source_index              = -1;
4203         ost->attachment_filename       = o->attachments[i];
4204         ost->st->codec->extradata      = attachment;
4205         ost->st->codec->extradata_size = len;
4206
4207         p = strrchr(o->attachments[i], '/');
4208         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
4209         avio_close(pb);
4210     }
4211
4212     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
4213     output_files[nb_output_files - 1].ctx       = oc;
4214     output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
4215     output_files[nb_output_files - 1].recording_time = o->recording_time;
4216     output_files[nb_output_files - 1].start_time     = o->start_time;
4217     output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
4218     av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
4219
4220     /* check filename in case of an image number is expected */
4221     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
4222         if (!av_filename_number_test(oc->filename)) {
4223             print_error(oc->filename, AVERROR(EINVAL));
4224             exit_program(1);
4225         }
4226     }
4227
4228     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
4229         /* test if it already exists to avoid losing precious files */
4230         assert_file_overwrite(filename);
4231
4232         /* open the file */
4233         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
4234                               &oc->interrupt_callback,
4235                               &output_files[nb_output_files - 1].opts)) < 0) {
4236             print_error(filename, err);
4237             exit_program(1);
4238         }
4239     }
4240
4241     if (o->mux_preload) {
4242         uint8_t buf[64];
4243         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
4244         av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
4245     }
4246     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
4247
4248     if (loop_output >= 0) {
4249         av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
4250         oc->loop_output = loop_output;
4251     }
4252
4253     /* copy metadata */
4254     for (i = 0; i < o->nb_metadata_map; i++) {
4255         char *p;
4256         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
4257
4258         if (in_file_index < 0)
4259             continue;
4260         if (in_file_index >= nb_input_files) {
4261             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
4262             exit_program(1);
4263         }
4264         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index].ctx, o);
4265     }
4266
4267     /* copy chapters */
4268     if (o->chapters_input_file >= nb_input_files) {
4269         if (o->chapters_input_file == INT_MAX) {
4270             /* copy chapters from the first input file that has them*/
4271             o->chapters_input_file = -1;
4272             for (i = 0; i < nb_input_files; i++)
4273                 if (input_files[i].ctx->nb_chapters) {
4274                     o->chapters_input_file = i;
4275                     break;
4276                 }
4277         } else {
4278             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4279                    o->chapters_input_file);
4280             exit_program(1);
4281         }
4282     }
4283     if (o->chapters_input_file >= 0)
4284         copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
4285                       !o->metadata_chapters_manual);
4286
4287     /* copy global metadata by default */
4288     if (!o->metadata_global_manual && nb_input_files){
4289         av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
4290                      AV_DICT_DONT_OVERWRITE);
4291         if(o->recording_time != INT64_MAX)
4292             av_dict_set(&oc->metadata, "duration", NULL, 0);
4293     }
4294     if (!o->metadata_streams_manual)
4295         for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
4296             InputStream *ist;
4297             if (output_streams[i].source_index < 0)         /* this is true e.g. for attached files */
4298                 continue;
4299             ist = &input_streams[output_streams[i].source_index];
4300             av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4301         }
4302
4303     /* process manually set metadata */
4304     for (i = 0; i < o->nb_metadata; i++) {
4305         AVDictionary **m;
4306         char type, *val;
4307         const char *stream_spec;
4308         int index = 0, j, ret;
4309
4310         val = strchr(o->metadata[i].u.str, '=');
4311         if (!val) {
4312             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4313                    o->metadata[i].u.str);
4314             exit_program(1);
4315         }
4316         *val++ = 0;
4317
4318         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
4319         if (type == 's') {
4320             for (j = 0; j < oc->nb_streams; j++) {
4321                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
4322                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
4323                 } else if (ret < 0)
4324                     exit_program(1);
4325             }
4326             printf("ret %d, stream_spec %s\n", ret, stream_spec);
4327         }
4328         else {
4329             switch (type) {
4330             case 'g':
4331                 m = &oc->metadata;
4332                 break;
4333             case 'c':
4334                 if (index < 0 || index >= oc->nb_chapters) {
4335                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4336                     exit_program(1);
4337                 }
4338                 m = &oc->chapters[index]->metadata;
4339                 break;
4340             default:
4341                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4342                 exit_program(1);
4343             }
4344             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4345         }
4346     }
4347
4348     reset_options(o, 0);
4349 }
4350
4351 /* same option as mencoder */
4352 static int opt_pass(const char *opt, const char *arg)
4353 {
4354     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
4355     return 0;
4356 }
4357
4358 static int64_t getutime(void)
4359 {
4360 #if HAVE_GETRUSAGE
4361     struct rusage rusage;
4362
4363     getrusage(RUSAGE_SELF, &rusage);
4364     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4365 #elif HAVE_GETPROCESSTIMES
4366     HANDLE proc;
4367     FILETIME c, e, k, u;
4368     proc = GetCurrentProcess();
4369     GetProcessTimes(proc, &c, &e, &k, &u);
4370     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4371 #else
4372     return av_gettime();
4373 #endif
4374 }
4375
4376 static int64_t getmaxrss(void)
4377 {
4378 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4379     struct rusage rusage;
4380     getrusage(RUSAGE_SELF, &rusage);
4381     return (int64_t)rusage.ru_maxrss * 1024;
4382 #elif HAVE_GETPROCESSMEMORYINFO
4383     HANDLE proc;
4384     PROCESS_MEMORY_COUNTERS memcounters;
4385     proc = GetCurrentProcess();
4386     memcounters.cb = sizeof(memcounters);
4387     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4388     return memcounters.PeakPagefileUsage;
4389 #else
4390     return 0;
4391 #endif
4392 }
4393
4394 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4395 {
4396     return parse_option(o, "q:a", arg, options);
4397 }
4398
4399 static void show_usage(void)
4400 {
4401     printf("Hyper fast Audio and Video encoder\n");
4402     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4403     printf("\n");
4404 }
4405
4406 static int opt_help(const char *opt, const char *arg)
4407 {
4408     int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4409     av_log_set_callback(log_callback_help);
4410     show_usage();
4411     show_help_options(options, "Main options:\n",
4412                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4413     show_help_options(options, "\nAdvanced options:\n",
4414                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4415                       OPT_EXPERT);
4416     show_help_options(options, "\nVideo options:\n",
4417                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4418                       OPT_VIDEO);
4419     show_help_options(options, "\nAdvanced Video options:\n",
4420                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4421                       OPT_VIDEO | OPT_EXPERT);
4422     show_help_options(options, "\nAudio options:\n",
4423                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4424                       OPT_AUDIO);
4425     show_help_options(options, "\nAdvanced Audio options:\n",
4426                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4427                       OPT_AUDIO | OPT_EXPERT);
4428     show_help_options(options, "\nSubtitle options:\n",
4429                       OPT_SUBTITLE | OPT_GRAB,
4430                       OPT_SUBTITLE);
4431     show_help_options(options, "\nAudio/Video grab options:\n",
4432                       OPT_GRAB,
4433                       OPT_GRAB);
4434     printf("\n");
4435     show_help_children(avcodec_get_class(), flags);
4436     show_help_children(avformat_get_class(), flags);
4437     show_help_children(sws_get_class(), flags);
4438
4439     return 0;
4440 }
4441
4442 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4443 {
4444     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4445     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4446
4447     if(!strncmp(arg, "pal-", 4)) {
4448         norm = PAL;
4449         arg += 4;
4450     } else if(!strncmp(arg, "ntsc-", 5)) {
4451         norm = NTSC;
4452         arg += 5;
4453     } else if(!strncmp(arg, "film-", 5)) {
4454         norm = FILM;
4455         arg += 5;
4456     } else {
4457         /* Try to determine PAL/NTSC by peeking in the input files */
4458         if(nb_input_files) {
4459             int i, j, fr;
4460             for (j = 0; j < nb_input_files; j++) {
4461                 for (i = 0; i < input_files[j].nb_streams; i++) {
4462                     AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4463                     if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4464                         continue;
4465                     fr = c->time_base.den * 1000 / c->time_base.num;
4466                     if(fr == 25000) {
4467                         norm = PAL;
4468                         break;
4469                     } else if((fr == 29970) || (fr == 23976)) {
4470                         norm = NTSC;
4471                         break;
4472                     }
4473                 }
4474                 if(norm != UNKNOWN)
4475                     break;
4476             }
4477         }
4478         if (norm != UNKNOWN)
4479             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4480     }
4481
4482     if(norm == UNKNOWN) {
4483         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4484         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4485         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4486         exit_program(1);
4487     }
4488
4489     if(!strcmp(arg, "vcd")) {
4490         opt_video_codec(o, "c:v", "mpeg1video");
4491         opt_audio_codec(o, "c:a", "mp2");
4492         parse_option(o, "f", "vcd", options);
4493
4494         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4495         parse_option(o, "r", frame_rates[norm], options);
4496         opt_default("g", norm == PAL ? "15" : "18");
4497
4498         opt_default("b:v", "1150000");
4499         opt_default("maxrate", "1150000");
4500         opt_default("minrate", "1150000");
4501         opt_default("bufsize", "327680"); // 40*1024*8;
4502
4503         opt_default("b:a", "224000");
4504         parse_option(o, "ar", "44100", options);
4505         parse_option(o, "ac", "2", options);
4506
4507         opt_default("packetsize", "2324");
4508         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4509
4510         /* We have to offset the PTS, so that it is consistent with the SCR.
4511            SCR starts at 36000, but the first two packs contain only padding
4512            and the first pack from the other stream, respectively, may also have
4513            been written before.
4514            So the real data starts at SCR 36000+3*1200. */
4515         o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4516     } else if(!strcmp(arg, "svcd")) {
4517
4518         opt_video_codec(o, "c:v", "mpeg2video");
4519         opt_audio_codec(o, "c:a", "mp2");
4520         parse_option(o, "f", "svcd", options);
4521
4522         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4523         parse_option(o, "r", frame_rates[norm], options);
4524         parse_option(o, "pix_fmt", "yuv420p", options);
4525         opt_default("g", norm == PAL ? "15" : "18");
4526
4527         opt_default("b:v", "2040000");
4528         opt_default("maxrate", "2516000");
4529         opt_default("minrate", "0"); //1145000;
4530         opt_default("bufsize", "1835008"); //224*1024*8;
4531         opt_default("flags", "+scan_offset");
4532
4533
4534         opt_default("b:a", "224000");
4535         parse_option(o, "ar", "44100", options);
4536
4537         opt_default("packetsize", "2324");
4538
4539     } else if(!strcmp(arg, "dvd")) {
4540
4541         opt_video_codec(o, "c:v", "mpeg2video");
4542         opt_audio_codec(o, "c:a", "ac3");
4543         parse_option(o, "f", "dvd", options);
4544
4545         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4546         parse_option(o, "r", frame_rates[norm], options);
4547         parse_option(o, "pix_fmt", "yuv420p", options);
4548         opt_default("g", norm == PAL ? "15" : "18");
4549
4550         opt_default("b:v", "6000000");
4551         opt_default("maxrate", "9000000");
4552         opt_default("minrate", "0"); //1500000;
4553         opt_default("bufsize", "1835008"); //224*1024*8;
4554
4555         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4556         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4557
4558         opt_default("b:a", "448000");
4559         parse_option(o, "ar", "48000", options);
4560
4561     } else if(!strncmp(arg, "dv", 2)) {
4562
4563         parse_option(o, "f", "dv", options);
4564
4565         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4566         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4567                           norm == PAL ? "yuv420p" : "yuv411p", options);
4568         parse_option(o, "r", frame_rates[norm], options);
4569
4570         parse_option(o, "ar", "48000", options);
4571         parse_option(o, "ac", "2", options);
4572
4573     } else {
4574         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4575         return AVERROR(EINVAL);
4576     }
4577     return 0;
4578 }
4579
4580 static int opt_vstats_file(const char *opt, const char *arg)
4581 {
4582     av_free (vstats_filename);
4583     vstats_filename=av_strdup (arg);
4584     return 0;
4585 }
4586
4587 static int opt_vstats(const char *opt, const char *arg)
4588 {
4589     char filename[40];
4590     time_t today2 = time(NULL);
4591     struct tm *today = localtime(&today2);
4592
4593     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4594              today->tm_sec);
4595     return opt_vstats_file(opt, filename);
4596 }
4597
4598 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4599 {
4600     return parse_option(o, "frames:v", arg, options);
4601 }
4602
4603 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4604 {
4605     return parse_option(o, "frames:a", arg, options);
4606 }
4607
4608 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4609 {
4610     return parse_option(o, "frames:d", arg, options);
4611 }
4612
4613 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4614 {
4615     FILE *f=NULL;
4616     char filename[1000], tmp[1000], tmp2[1000], line[1000];
4617     const char *codec_name = *opt == 'v' ? video_codec_name :
4618                              *opt == 'a' ? audio_codec_name :
4619                                            subtitle_codec_name;
4620
4621     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4622         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
4623             av_log(0, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
4624         }else
4625             av_log(0, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
4626         exit_program(1);
4627     }
4628
4629     while(!feof(f)){
4630         int e= fscanf(f, "%999[^\n]\n", line) - 1;
4631         if(line[0] == '#' && !e)
4632             continue;
4633         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4634         if(e){
4635             av_log(0, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
4636             exit_program(1);
4637         }
4638         if(!strcmp(tmp, "acodec")){
4639             opt_audio_codec(o, tmp, tmp2);
4640         }else if(!strcmp(tmp, "vcodec")){
4641             opt_video_codec(o, tmp, tmp2);
4642         }else if(!strcmp(tmp, "scodec")){
4643             opt_subtitle_codec(o, tmp, tmp2);
4644         }else if(!strcmp(tmp, "dcodec")){
4645             opt_data_codec(o, tmp, tmp2);
4646         }else if(opt_default(tmp, tmp2) < 0){
4647             av_log(0, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4648             exit_program(1);
4649         }
4650     }
4651
4652     fclose(f);
4653
4654     return 0;
4655 }
4656
4657 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4658 {
4659 }
4660
4661 static int opt_passlogfile(const char *opt, const char *arg)
4662 {
4663     pass_logfilename_prefix = arg;
4664 #if CONFIG_LIBX264_ENCODER
4665     return opt_default("passlogfile", arg);
4666 #else
4667     return 0;
4668 #endif
4669 }
4670
4671 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4672 {
4673     char *s= av_malloc(strlen(opt)+2);
4674     snprintf(s, strlen(opt)+2, "%s:%c", opt+1, *opt);
4675     return parse_option(o, s, arg, options);
4676 }
4677
4678 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
4679 {
4680     if(!strcmp(opt, "b")){
4681         av_log(0,AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
4682         return parse_option(o, av_strdup("b:v"), arg, options);
4683     }
4684     return opt_default(opt, arg);
4685 }
4686
4687 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4688 {
4689     return parse_option(o, "filter:v", arg, options);
4690 }
4691
4692 #define OFFSET(x) offsetof(OptionsContext, x)
4693 static const OptionDef options[] = {
4694     /* main options */
4695 #include "cmdutils_common_opts.h"
4696     { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4697     { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4698     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4699     { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
4700     { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4701     { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4702     { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4703     { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
4704     { "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]" },
4705     { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
4706       "outfile[,metadata]:infile[,metadata]" },
4707     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)},  "set chapters mapping", "input_file_index" },
4708     { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4709     { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4710     { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4711     { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4712     { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4713     { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4714     { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4715     { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4716     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4717       "add timings for benchmarking" },
4718     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4719     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4720       "dump each input packet" },
4721     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4722       "when dumping packets, also dump the payload" },
4723     { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4724     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4725     { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4726     { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4727     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4728     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4729     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4730     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4731     { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying", "source" },
4732     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4733     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4734     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4735     { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4736     { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4737     { "tag",   OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4738     { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4739     { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4740 #if CONFIG_AVFILTER
4741     { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4742 #endif
4743     { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4744     { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4745     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4746
4747     /* video options */
4748     { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4749     { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4750     { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4751     { "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" },
4752     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4753     { "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" },
4754     { "croptop",  HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4755     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4756     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4757     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4758     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4759     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4760     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4761     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4762     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4763     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4764     { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4765     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4766     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4767     { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4768     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4769     { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4770       "use same quantizer as source (implies VBR)" },
4771     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4772     { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4773     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4774       "deinterlace pictures" },
4775     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4776     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4777     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4778 #if CONFIG_AVFILTER
4779     { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4780 #endif
4781     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4782     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4783     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4784     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4785     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
4786     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4787     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4788     { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4789     { "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" },
4790     { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
4791
4792     /* audio options */
4793     { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4794     { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4795     { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4796     { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4797     { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4798     { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4799     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
4800     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4801     { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4802     { "rmvol", HAS_ARG | OPT_AUDIO | OPT_FLOAT | OPT_SPEC, {.off = OFFSET(rematrix_volume)}, "rematrix volume (as factor)", "volume" },
4803
4804     /* subtitle options */
4805     { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4806     { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4807     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
4808
4809     /* grab options */
4810     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4811     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4812     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4813
4814     /* muxer options */
4815     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT   | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4816     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)},   "set the initial demux-decode delay", "seconds" },
4817
4818     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4819     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
4820     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
4821
4822     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4823     { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4824     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4825     { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4826     /* data codec support */
4827     { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4828     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
4829
4830     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4831     { NULL, },
4832 };
4833
4834 int main(int argc, char **argv)
4835 {
4836     OptionsContext o = { 0 };
4837     int64_t ti;
4838
4839     reset_options(&o, 0);
4840
4841     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4842     parse_loglevel(argc, argv, options);
4843
4844     if(argc>1 && !strcmp(argv[1], "-d")){
4845         run_as_daemon=1;
4846         av_log_set_callback(log_callback_null);
4847         argc--;
4848         argv++;
4849     }
4850
4851     avcodec_register_all();
4852 #if CONFIG_AVDEVICE
4853     avdevice_register_all();
4854 #endif
4855 #if CONFIG_AVFILTER
4856     avfilter_register_all();
4857 #endif
4858     av_register_all();
4859     avformat_network_init();
4860
4861     show_banner(argc, argv, options);
4862
4863     term_init();
4864
4865     /* parse options */
4866     parse_options(&o, argc, argv, options, opt_output_file);
4867
4868     if(nb_output_files <= 0 && nb_input_files == 0) {
4869         show_usage();
4870         av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4871         exit_program(1);
4872     }
4873
4874     /* file converter / grab */
4875     if (nb_output_files <= 0) {
4876         av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
4877         exit_program(1);
4878     }
4879
4880     if (nb_input_files == 0) {
4881         av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4882         exit_program(1);
4883     }
4884
4885     ti = getutime();
4886     if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4887         exit_program(1);
4888     ti = getutime() - ti;
4889     if (do_benchmark) {
4890         int maxrss = getmaxrss() / 1024;
4891         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4892     }
4893
4894     exit_program(0);
4895     return 0;
4896 }