avconv.c

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