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

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