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

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