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