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

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