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