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