git.sesse.net Git - ffmpeg/blob - 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              1, ist->st->codec->sample_rate,
 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     if (decoded_frame->pts != AV_NOPTS_VALUE)
2033         decoded_frame->pts = av_rescale_q(decoded_frame->pts,
2034                                           ist->st->time_base,
2035                                           (AVRational){1, ist->st->codec->sample_rate});
2036     for (i = 0; i < ist->nb_filters; i++)
2037         av_buffersrc_write_frame(ist->filters[i]->filter, decoded_frame);
2038
2039     return ret;
2040 }
2041
2042 static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output)
2043 {
2044     AVFrame *decoded_frame;
2045     void *buffer_to_free = NULL;
2046     int i, ret = 0, resample_changed;
2047     float quality;
2048
2049     if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2050         return AVERROR(ENOMEM);
2051     else
2052         avcodec_get_frame_defaults(ist->decoded_frame);
2053     decoded_frame = ist->decoded_frame;
2054
2055     ret = avcodec_decode_video2(ist->st->codec,
2056                                 decoded_frame, got_output, pkt);
2057     if (ret < 0)
2058         return ret;
2059
2060     quality = same_quant ? decoded_frame->quality : 0;
2061     if (!*got_output) {
2062         /* no picture yet */
2063         if (!pkt->size)
2064             for (i = 0; i < ist->nb_filters; i++)
2065                 av_buffersrc_buffer(ist->filters[i]->filter, NULL);
2066         return ret;
2067     }
2068     decoded_frame->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pkt_pts,
2069                                            decoded_frame->pkt_dts);
2070     pkt->size = 0;
2071     pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
2072
2073     rate_emu_sleep(ist);
2074
2075     if (ist->st->sample_aspect_ratio.num)
2076         decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2077
2078     resample_changed = ist->resample_width   != decoded_frame->width  ||
2079                        ist->resample_height  != decoded_frame->height ||
2080                        ist->resample_pix_fmt != decoded_frame->format;
2081     if (resample_changed) {
2082         av_log(NULL, AV_LOG_INFO,
2083                "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
2084                ist->file_index, ist->st->index,
2085                ist->resample_width,  ist->resample_height,  av_get_pix_fmt_name(ist->resample_pix_fmt),
2086                decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
2087
2088         ist->resample_width   = decoded_frame->width;
2089         ist->resample_height  = decoded_frame->height;
2090         ist->resample_pix_fmt = decoded_frame->format;
2091
2092         for (i = 0; i < nb_filtergraphs; i++)
2093             if (ist_in_filtergraph(filtergraphs[i], ist) &&
2094                 configure_filtergraph(filtergraphs[i]) < 0) {
2095                 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2096                 exit_program(1);
2097             }
2098     }
2099
2100     for (i = 0; i < ist->nb_filters; i++) {
2101         // XXX what an ugly hack
2102         if (ist->filters[i]->graph->nb_outputs == 1)
2103             ist->filters[i]->graph->outputs[0]->ost->last_quality = quality;
2104
2105         if (ist->st->codec->codec->capabilities & CODEC_CAP_DR1) {
2106             FrameBuffer      *buf = decoded_frame->opaque;
2107             AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2108                                         decoded_frame->data, decoded_frame->linesize,
2109                                         AV_PERM_READ | AV_PERM_PRESERVE,
2110                                         ist->st->codec->width, ist->st->codec->height,
2111                                         ist->st->codec->pix_fmt);
2112
2113             avfilter_copy_frame_props(fb, decoded_frame);
2114             fb->buf->priv           = buf;
2115             fb->buf->free           = filter_release_buffer;
2116
2117             buf->refcount++;
2118             av_buffersrc_buffer(ist->filters[i]->filter, fb);
2119         } else
2120             av_buffersrc_write_frame(ist->filters[i]->filter, decoded_frame);
2121     }
2122
2123     av_free(buffer_to_free);
2124     return ret;
2125 }
2126
2127 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2128 {
2129     AVSubtitle subtitle;
2130     int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2131                                           &subtitle, got_output, pkt);
2132     if (ret < 0)
2133         return ret;
2134     if (!*got_output)
2135         return ret;
2136
2137     rate_emu_sleep(ist);
2138
2139     for (i = 0; i < nb_output_streams; i++) {
2140         OutputStream *ost = output_streams[i];
2141
2142         if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2143             continue;
2144
2145         do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle, pkt->pts);
2146     }
2147
2148     avsubtitle_free(&subtitle);
2149     return ret;
2150 }
2151
2152 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2153 static int output_packet(InputStream *ist, const AVPacket *pkt)
2154 {
2155     int i;
2156     int got_output;
2157     AVPacket avpkt;
2158
2159     if (ist->next_dts == AV_NOPTS_VALUE)
2160         ist->next_dts = ist->last_dts;
2161
2162     if (pkt == NULL) {
2163         /* EOF handling */
2164         av_init_packet(&avpkt);
2165         avpkt.data = NULL;
2166         avpkt.size = 0;
2167         goto handle_eof;
2168     } else {
2169         avpkt = *pkt;
2170     }
2171
2172     if (pkt->dts != AV_NOPTS_VALUE)
2173         ist->next_dts = ist->last_dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2174
2175     // while we have more to decode or while the decoder did output something on EOF
2176     while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2177         int ret = 0;
2178     handle_eof:
2179
2180         ist->last_dts = ist->next_dts;
2181
2182         if (avpkt.size && avpkt.size != pkt->size) {
2183             av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2184                    "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2185             ist->showed_multi_packet_warning = 1;
2186         }
2187
2188         switch (ist->st->codec->codec_type) {
2189         case AVMEDIA_TYPE_AUDIO:
2190             ret = decode_audio    (ist, &avpkt, &got_output);
2191             break;
2192         case AVMEDIA_TYPE_VIDEO:
2193             ret = decode_video    (ist, &avpkt, &got_output);
2194             if (avpkt.duration)
2195                 ist->next_dts += av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
2196             else if (ist->st->r_frame_rate.num)
2197                 ist->next_dts += av_rescale_q(1, (AVRational){ist->st->r_frame_rate.den,
2198                                                               ist->st->r_frame_rate.num},
2199                                               AV_TIME_BASE_Q);
2200             else if (ist->st->codec->time_base.num != 0) {
2201                 int ticks      = ist->st->parser ? ist->st->parser->repeat_pict + 1 :
2202                                                    ist->st->codec->ticks_per_frame;
2203                 ist->next_dts += av_rescale_q(ticks, ist->st->codec->time_base, AV_TIME_BASE_Q);
2204             }
2205             break;
2206         case AVMEDIA_TYPE_SUBTITLE:
2207             ret = transcode_subtitles(ist, &avpkt, &got_output);
2208             break;
2209         default:
2210             return -1;
2211         }
2212
2213         if (ret < 0)
2214             return ret;
2215         // touch data and size only if not EOF
2216         if (pkt) {
2217             avpkt.data += ret;
2218             avpkt.size -= ret;
2219         }
2220         if (!got_output) {
2221             continue;
2222         }
2223     }
2224
2225     /* handle stream copy */
2226     if (!ist->decoding_needed) {
2227         rate_emu_sleep(ist);
2228         ist->last_dts = ist->next_dts;
2229         switch (ist->st->codec->codec_type) {
2230         case AVMEDIA_TYPE_AUDIO:
2231             ist->next_dts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2232                              ist->st->codec->sample_rate;
2233             break;
2234         case AVMEDIA_TYPE_VIDEO:
2235             if (ist->st->codec->time_base.num != 0) {
2236                 int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2237                 ist->next_dts += ((int64_t)AV_TIME_BASE *
2238                                   ist->st->codec->time_base.num * ticks) /
2239                                   ist->st->codec->time_base.den;
2240             }
2241             break;
2242         }
2243     }
2244     for (i = 0; pkt && i < nb_output_streams; i++) {
2245         OutputStream *ost = output_streams[i];
2246
2247         if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2248             continue;
2249
2250         do_streamcopy(ist, ost, pkt);
2251     }
2252
2253     return 0;
2254 }
2255
2256 static void print_sdp(void)
2257 {
2258     char sdp[2048];
2259     int i;
2260     AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files);
2261
2262     if (!avc)
2263         exit_program(1);
2264     for (i = 0; i < nb_output_files; i++)
2265         avc[i] = output_files[i]->ctx;
2266
2267     av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp));
2268     printf("SDP:\n%s\n", sdp);
2269     fflush(stdout);
2270     av_freep(&avc);
2271 }
2272
2273 static int init_input_stream(int ist_index, char *error, int error_len)
2274 {
2275     int i;
2276     InputStream *ist = input_streams[ist_index];
2277     if (ist->decoding_needed) {
2278         AVCodec *codec = ist->dec;
2279         if (!codec) {
2280             snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d:%d",
2281                     ist->st->codec->codec_id, ist->file_index, ist->st->index);
2282             return AVERROR(EINVAL);
2283         }
2284
2285         /* update requested sample format for the decoder based on the
2286            corresponding encoder sample format */
2287         for (i = 0; i < nb_output_streams; i++) {
2288             OutputStream *ost = output_streams[i];
2289             if (ost->source_index == ist_index) {
2290                 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2291                 break;
2292             }
2293         }
2294
2295         if (codec->type == AVMEDIA_TYPE_VIDEO && codec->capabilities & CODEC_CAP_DR1) {
2296             ist->st->codec->get_buffer     = codec_get_buffer;
2297             ist->st->codec->release_buffer = codec_release_buffer;
2298             ist->st->codec->opaque         = &ist->buffer_pool;
2299         }
2300
2301         if (!av_dict_get(ist->opts, "threads", NULL, 0))
2302             av_dict_set(&ist->opts, "threads", "auto", 0);
2303         if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2304             snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2305                     ist->file_index, ist->st->index);
2306             return AVERROR(EINVAL);
2307         }
2308         assert_codec_experimental(ist->st->codec, 0);
2309         assert_avoptions(ist->opts);
2310     }
2311
2312     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;
2313     ist->next_dts = AV_NOPTS_VALUE;
2314     init_pts_correction(&ist->pts_ctx);
2315     ist->is_start = 1;
2316
2317     return 0;
2318 }
2319
2320 static InputStream *get_input_stream(OutputStream *ost)
2321 {
2322     if (ost->source_index >= 0)
2323         return input_streams[ost->source_index];
2324
2325     if (ost->filter) {
2326         FilterGraph *fg = ost->filter->graph;
2327         int i;
2328
2329         for (i = 0; i < fg->nb_inputs; i++)
2330             if (fg->inputs[i]->ist->st->codec->codec_type == ost->st->codec->codec_type)
2331                 return fg->inputs[i]->ist;
2332     }
2333
2334     return NULL;
2335 }
2336
2337 static void parse_forced_key_frames(char *kf, OutputStream *ost,
2338                                     AVCodecContext *avctx)
2339 {
2340     char *p;
2341     int n = 1, i;
2342     int64_t t;
2343
2344     for (p = kf; *p; p++)
2345         if (*p == ',')
2346             n++;
2347     ost->forced_kf_count = n;
2348     ost->forced_kf_pts   = av_malloc(sizeof(*ost->forced_kf_pts) * n);
2349     if (!ost->forced_kf_pts) {
2350         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
2351         exit_program(1);
2352     }
2353
2354     p = kf;
2355     for (i = 0; i < n; i++) {
2356         char *next = strchr(p, ',');
2357
2358         if (next)
2359             *next++ = 0;
2360
2361         t = parse_time_or_die("force_key_frames", p, 1);
2362         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2363
2364         p = next;
2365     }
2366 }
2367
2368 static int transcode_init(void)
2369 {
2370     int ret = 0, i, j, k;
2371     AVFormatContext *oc;
2372     AVCodecContext *codec, *icodec;
2373     OutputStream *ost;
2374     InputStream *ist;
2375     char error[1024];
2376     int want_sdp = 1;
2377
2378     /* init framerate emulation */
2379     for (i = 0; i < nb_input_files; i++) {
2380         InputFile *ifile = input_files[i];
2381         if (ifile->rate_emu)
2382             for (j = 0; j < ifile->nb_streams; j++)
2383                 input_streams[j + ifile->ist_index]->start = av_gettime();
2384     }
2385
2386     /* output stream init */
2387     for (i = 0; i < nb_output_files; i++) {
2388         oc = output_files[i]->ctx;
2389         if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2390             av_dump_format(oc, i, oc->filename, 1);
2391             av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2392             return AVERROR(EINVAL);
2393         }
2394     }
2395
2396     /* init complex filtergraphs */
2397     for (i = 0; i < nb_filtergraphs; i++)
2398         if ((ret = avfilter_graph_config(filtergraphs[i]->graph, NULL)) < 0)
2399             return ret;
2400
2401     /* for each output stream, we compute the right encoding parameters */
2402     for (i = 0; i < nb_output_streams; i++) {
2403         ost = output_streams[i];
2404         oc  = output_files[ost->file_index]->ctx;
2405         ist = get_input_stream(ost);
2406
2407         if (ost->attachment_filename)
2408             continue;
2409
2410         codec  = ost->st->codec;
2411
2412         if (ist) {
2413             icodec = ist->st->codec;
2414
2415             ost->st->disposition          = ist->st->disposition;
2416             codec->bits_per_raw_sample    = icodec->bits_per_raw_sample;
2417             codec->chroma_sample_location = icodec->chroma_sample_location;
2418         }
2419
2420         if (ost->stream_copy) {
2421             uint64_t extra_size;
2422
2423             av_assert0(ist && !ost->filter);
2424
2425             extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2426
2427             if (extra_size > INT_MAX) {
2428                 return AVERROR(EINVAL);
2429             }
2430
2431             /* if stream_copy is selected, no need to decode or encode */
2432             codec->codec_id   = icodec->codec_id;
2433             codec->codec_type = icodec->codec_type;
2434
2435             if (!codec->codec_tag) {
2436                 if (!oc->oformat->codec_tag ||
2437                      av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2438                      av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2439                     codec->codec_tag = icodec->codec_tag;
2440             }
2441
2442             codec->bit_rate       = icodec->bit_rate;
2443             codec->rc_max_rate    = icodec->rc_max_rate;
2444             codec->rc_buffer_size = icodec->rc_buffer_size;
2445             codec->field_order    = icodec->field_order;
2446             codec->extradata      = av_mallocz(extra_size);
2447             if (!codec->extradata) {
2448                 return AVERROR(ENOMEM);
2449             }
2450             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2451             codec->extradata_size = icodec->extradata_size;
2452             if (!copy_tb) {
2453                 codec->time_base      = icodec->time_base;
2454                 codec->time_base.num *= icodec->ticks_per_frame;
2455                 av_reduce(&codec->time_base.num, &codec->time_base.den,
2456                           codec->time_base.num, codec->time_base.den, INT_MAX);
2457             } else
2458                 codec->time_base = ist->st->time_base;
2459
2460             switch (codec->codec_type) {
2461             case AVMEDIA_TYPE_AUDIO:
2462                 if (audio_volume != 256) {
2463                     av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2464                     exit_program(1);
2465                 }
2466                 codec->channel_layout     = icodec->channel_layout;
2467                 codec->sample_rate        = icodec->sample_rate;
2468                 codec->channels           = icodec->channels;
2469                 codec->frame_size         = icodec->frame_size;
2470                 codec->audio_service_type = icodec->audio_service_type;
2471                 codec->block_align        = icodec->block_align;
2472                 break;
2473             case AVMEDIA_TYPE_VIDEO:
2474                 codec->pix_fmt            = icodec->pix_fmt;
2475                 codec->width              = icodec->width;
2476                 codec->height             = icodec->height;
2477                 codec->has_b_frames       = icodec->has_b_frames;
2478                 if (!codec->sample_aspect_ratio.num) {
2479                     codec->sample_aspect_ratio   =
2480                     ost->st->sample_aspect_ratio =
2481                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2482                         ist->st->codec->sample_aspect_ratio.num ?
2483                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2484                 }
2485                 break;
2486             case AVMEDIA_TYPE_SUBTITLE:
2487                 codec->width  = icodec->width;
2488                 codec->height = icodec->height;
2489                 break;
2490             case AVMEDIA_TYPE_DATA:
2491             case AVMEDIA_TYPE_ATTACHMENT:
2492                 break;
2493             default:
2494                 abort();
2495             }
2496         } else {
2497             if (!ost->enc) {
2498                 /* should only happen when a default codec is not present. */
2499                 snprintf(error, sizeof(error), "Automatic encoder selection "
2500                          "failed for output stream #%d:%d. Default encoder for "
2501                          "format %s is probably disabled. Please choose an "
2502                          "encoder manually.\n", ost->file_index, ost->index,
2503                          oc->oformat->name);
2504                 ret = AVERROR(EINVAL);
2505                 goto dump_format;
2506             }
2507
2508             if (ist)
2509                 ist->decoding_needed = 1;
2510             ost->encoding_needed = 1;
2511
2512             /*
2513              * We want CFR output if and only if one of those is true:
2514              * 1) user specified output framerate with -r
2515              * 2) user specified -vsync cfr
2516              * 3) output format is CFR and the user didn't force vsync to
2517              *    something else than CFR
2518              *
2519              * in such a case, set ost->frame_rate
2520              */
2521             if (codec->codec_type == AVMEDIA_TYPE_VIDEO &&
2522                 !ost->frame_rate.num && ist &&
2523                 (video_sync_method ==  VSYNC_CFR ||
2524                  (video_sync_method ==  VSYNC_AUTO &&
2525                   !(oc->oformat->flags & (AVFMT_NOTIMESTAMPS | AVFMT_VARIABLE_FPS))))) {
2526                 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25, 1};
2527                 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2528                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2529                     ost->frame_rate = ost->enc->supported_framerates[idx];
2530                 }
2531             }
2532
2533             if (!ost->filter &&
2534                 (codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2535                  codec->codec_type == AVMEDIA_TYPE_AUDIO)) {
2536                     FilterGraph *fg;
2537                     fg = init_simple_filtergraph(ist, ost);
2538                     if (configure_filtergraph(fg)) {
2539                         av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2540                         exit(1);
2541                     }
2542             }
2543
2544             switch (codec->codec_type) {
2545             case AVMEDIA_TYPE_AUDIO:
2546                 codec->sample_fmt     = ost->filter->filter->inputs[0]->format;
2547                 codec->sample_rate    = ost->filter->filter->inputs[0]->sample_rate;
2548                 codec->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
2549                 codec->channels       = av_get_channel_layout_nb_channels(codec->channel_layout);
2550                 codec->time_base      = (AVRational){ 1, codec->sample_rate };
2551                 break;
2552             case AVMEDIA_TYPE_VIDEO:
2553                 codec->time_base = ost->filter->filter->inputs[0]->time_base;
2554
2555                 codec->width  = ost->filter->filter->inputs[0]->w;
2556                 codec->height = ost->filter->filter->inputs[0]->h;
2557                 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
2558                     ost->frame_aspect_ratio ? // overridden by the -aspect cli option
2559                     av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
2560                     ost->filter->filter->inputs[0]->sample_aspect_ratio;
2561                 codec->pix_fmt = ost->filter->filter->inputs[0]->format;
2562
2563                 if (codec->width   != icodec->width  ||
2564                     codec->height  != icodec->height ||
2565                     codec->pix_fmt != icodec->pix_fmt) {
2566                     codec->bits_per_raw_sample = 0;
2567                 }
2568
2569                 if (ost->forced_keyframes)
2570                     parse_forced_key_frames(ost->forced_keyframes, ost,
2571                                             ost->st->codec);
2572                 break;
2573             case AVMEDIA_TYPE_SUBTITLE:
2574                 codec->time_base = (AVRational){1, 1000};
2575                 break;
2576             default:
2577                 abort();
2578                 break;
2579             }
2580             /* two pass mode */
2581             if ((codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2582                 char logfilename[1024];
2583                 FILE *f;
2584
2585                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2586                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2587                          i);
2588                 if (!strcmp(ost->enc->name, "libx264")) {
2589                     av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
2590                 } else {
2591                     if (codec->flags & CODEC_FLAG_PASS1) {
2592                         f = fopen(logfilename, "wb");
2593                         if (!f) {
2594                             av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2595                                    logfilename, strerror(errno));
2596                             exit_program(1);
2597                         }
2598                         ost->logfile = f;
2599                     } else {
2600                         char  *logbuffer;
2601                         size_t logbuffer_size;
2602                         if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2603                             av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2604                                    logfilename);
2605                             exit_program(1);
2606                         }
2607                         codec->stats_in = logbuffer;
2608                     }
2609                 }
2610             }
2611         }
2612     }
2613
2614     /* open each encoder */
2615     for (i = 0; i < nb_output_streams; i++) {
2616         ost = output_streams[i];
2617         if (ost->encoding_needed) {
2618             AVCodec      *codec = ost->enc;
2619             AVCodecContext *dec = NULL;
2620
2621             if ((ist = get_input_stream(ost)))
2622                 dec = ist->st->codec;
2623             if (dec && dec->subtitle_header) {
2624                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2625                 if (!ost->st->codec->subtitle_header) {
2626                     ret = AVERROR(ENOMEM);
2627                     goto dump_format;
2628                 }
2629                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2630                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2631             }
2632             if (!av_dict_get(ost->opts, "threads", NULL, 0))
2633                 av_dict_set(&ost->opts, "threads", "auto", 0);
2634             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2635                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2636                         ost->file_index, ost->index);
2637                 ret = AVERROR(EINVAL);
2638                 goto dump_format;
2639             }
2640             assert_codec_experimental(ost->st->codec, 1);
2641             assert_avoptions(ost->opts);
2642             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2643                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2644                                              "It takes bits/s as argument, not kbits/s\n");
2645             extra_size += ost->st->codec->extradata_size;
2646
2647             if (ost->st->codec->me_threshold)
2648                 input_streams[ost->source_index]->st->codec->debug |= FF_DEBUG_MV;
2649         }
2650     }
2651
2652     /* init input streams */
2653     for (i = 0; i < nb_input_streams; i++)
2654         if ((ret = init_input_stream(i, error, sizeof(error))) < 0)
2655             goto dump_format;
2656
2657     /* discard unused programs */
2658     for (i = 0; i < nb_input_files; i++) {
2659         InputFile *ifile = input_files[i];
2660         for (j = 0; j < ifile->ctx->nb_programs; j++) {
2661             AVProgram *p = ifile->ctx->programs[j];
2662             int discard  = AVDISCARD_ALL;
2663
2664             for (k = 0; k < p->nb_stream_indexes; k++)
2665                 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
2666                     discard = AVDISCARD_DEFAULT;
2667                     break;
2668                 }
2669             p->discard = discard;
2670         }
2671     }
2672
2673     /* open files and write file headers */
2674     for (i = 0; i < nb_output_files; i++) {
2675         oc = output_files[i]->ctx;
2676         oc->interrupt_callback = int_cb;
2677         if ((ret = avformat_write_header(oc, &output_files[i]->opts)) < 0) {
2678             char errbuf[128];
2679             const char *errbuf_ptr = errbuf;
2680             if (av_strerror(ret, errbuf, sizeof(errbuf)) < 0)
2681                 errbuf_ptr = strerror(AVUNERROR(ret));
2682             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?): %s", i, errbuf_ptr);
2683             ret = AVERROR(EINVAL);
2684             goto dump_format;
2685         }
2686         assert_avoptions(output_files[i]->opts);
2687         if (strcmp(oc->oformat->name, "rtp")) {
2688             want_sdp = 0;
2689         }
2690     }
2691
2692  dump_format:
2693     /* dump the file output parameters - cannot be done before in case
2694        of stream copy */
2695     for (i = 0; i < nb_output_files; i++) {
2696         av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
2697     }
2698
2699     /* dump the stream mapping */
2700     av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2701     for (i = 0; i < nb_input_streams; i++) {
2702         ist = input_streams[i];
2703
2704         for (j = 0; j < ist->nb_filters; j++) {
2705             if (ist->filters[j]->graph->graph_desc) {
2706                 av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d (%s) -> %s",
2707                        ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
2708                        ist->filters[j]->name);
2709                 if (nb_filtergraphs > 1)
2710                     av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
2711                 av_log(NULL, AV_LOG_INFO, "\n");
2712             }
2713         }
2714     }
2715
2716     for (i = 0; i < nb_output_streams; i++) {
2717         ost = output_streams[i];
2718
2719         if (ost->attachment_filename) {
2720             /* an attached file */
2721             av_log(NULL, AV_LOG_INFO, "  File %s -> Stream #%d:%d\n",
2722                    ost->attachment_filename, ost->file_index, ost->index);
2723             continue;
2724         }
2725
2726         if (ost->filter && ost->filter->graph->graph_desc) {
2727             /* output from a complex graph */
2728             av_log(NULL, AV_LOG_INFO, "  %s", ost->filter->name);
2729             if (nb_filtergraphs > 1)
2730                 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
2731
2732             av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
2733                    ost->index, ost->enc ? ost->enc->name : "?");
2734             continue;
2735         }
2736
2737         av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d -> #%d:%d",
2738                input_streams[ost->source_index]->file_index,
2739                input_streams[ost->source_index]->st->index,
2740                ost->file_index,
2741                ost->index);
2742         if (ost->sync_ist != input_streams[ost->source_index])
2743             av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2744                    ost->sync_ist->file_index,
2745                    ost->sync_ist->st->index);
2746         if (ost->stream_copy)
2747             av_log(NULL, AV_LOG_INFO, " (copy)");
2748         else
2749             av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index]->dec ?
2750                    input_streams[ost->source_index]->dec->name : "?",
2751                    ost->enc ? ost->enc->name : "?");
2752         av_log(NULL, AV_LOG_INFO, "\n");
2753     }
2754
2755     if (ret) {
2756         av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2757         return ret;
2758     }
2759
2760     if (want_sdp) {
2761         print_sdp();
2762     }
2763
2764     return 0;
2765 }
2766
2767 /**
2768  * @return 1 if there are still streams where more output is wanted,
2769  *         0 otherwise
2770  */
2771 static int need_output(void)
2772 {
2773     int i;
2774
2775     for (i = 0; i < nb_output_streams; i++) {
2776         OutputStream *ost    = output_streams[i];
2777         OutputFile *of       = output_files[ost->file_index];
2778         AVFormatContext *os  = output_files[ost->file_index]->ctx;
2779
2780         if (ost->is_past_recording_time ||
2781             (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2782             continue;
2783         if (ost->frame_number >= ost->max_frames) {
2784             int j;
2785             for (j = 0; j < of->ctx->nb_streams; j++)
2786                 output_streams[of->ost_index + j]->is_past_recording_time = 1;
2787             continue;
2788         }
2789
2790         return 1;
2791     }
2792
2793     return 0;
2794 }
2795
2796 static int select_input_file(uint8_t *no_packet)
2797 {
2798     int64_t ipts_min = INT64_MAX;
2799     int i, file_index = -1;
2800
2801     for (i = 0; i < nb_input_streams; i++) {
2802         InputStream *ist = input_streams[i];
2803         int64_t ipts     = ist->last_dts;
2804
2805         if (ist->discard || no_packet[ist->file_index])
2806             continue;
2807         if (!input_files[ist->file_index]->eof_reached) {
2808             if (ipts < ipts_min) {
2809                 ipts_min = ipts;
2810                 file_index = ist->file_index;
2811             }
2812         }
2813     }
2814
2815     return file_index;
2816 }
2817
2818 #if HAVE_PTHREADS
2819 static void *input_thread(void *arg)
2820 {
2821     InputFile *f = arg;
2822     int ret = 0;
2823
2824     while (!transcoding_finished && ret >= 0) {
2825         AVPacket pkt;
2826         ret = av_read_frame(f->ctx, &pkt);
2827
2828         if (ret == AVERROR(EAGAIN)) {
2829             av_usleep(10000);
2830             ret = 0;
2831             continue;
2832         } else if (ret < 0)
2833             break;
2834
2835         pthread_mutex_lock(&f->fifo_lock);
2836         while (!av_fifo_space(f->fifo))
2837             pthread_cond_wait(&f->fifo_cond, &f->fifo_lock);
2838
2839         av_dup_packet(&pkt);
2840         av_fifo_generic_write(f->fifo, &pkt, sizeof(pkt), NULL);
2841
2842         pthread_mutex_unlock(&f->fifo_lock);
2843     }
2844
2845     f->finished = 1;
2846     return NULL;
2847 }
2848
2849 static void free_input_threads(void)
2850 {
2851     int i;
2852
2853     if (nb_input_files == 1)
2854         return;
2855
2856     transcoding_finished = 1;
2857
2858     for (i = 0; i < nb_input_files; i++) {
2859         InputFile *f = input_files[i];
2860         AVPacket pkt;
2861
2862         if (!f->fifo || f->joined)
2863             continue;
2864
2865         pthread_mutex_lock(&f->fifo_lock);
2866         while (av_fifo_size(f->fifo)) {
2867             av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
2868             av_free_packet(&pkt);
2869         }
2870         pthread_cond_signal(&f->fifo_cond);
2871         pthread_mutex_unlock(&f->fifo_lock);
2872
2873         pthread_join(f->thread, NULL);
2874         f->joined = 1;
2875
2876         while (av_fifo_size(f->fifo)) {
2877             av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
2878             av_free_packet(&pkt);
2879         }
2880         av_fifo_free(f->fifo);
2881     }
2882 }
2883
2884 static int init_input_threads(void)
2885 {
2886     int i, ret;
2887
2888     if (nb_input_files == 1)
2889         return 0;
2890
2891     for (i = 0; i < nb_input_files; i++) {
2892         InputFile *f = input_files[i];
2893
2894         if (!(f->fifo = av_fifo_alloc(8*sizeof(AVPacket))))
2895             return AVERROR(ENOMEM);
2896
2897         pthread_mutex_init(&f->fifo_lock, NULL);
2898         pthread_cond_init (&f->fifo_cond, NULL);
2899
2900         if ((ret = pthread_create(&f->thread, NULL, input_thread, f)))
2901             return AVERROR(ret);
2902     }
2903     return 0;
2904 }
2905
2906 static int get_input_packet_mt(InputFile *f, AVPacket *pkt)
2907 {
2908     int ret = 0;
2909
2910     pthread_mutex_lock(&f->fifo_lock);
2911
2912     if (av_fifo_size(f->fifo)) {
2913         av_fifo_generic_read(f->fifo, pkt, sizeof(*pkt), NULL);
2914         pthread_cond_signal(&f->fifo_cond);
2915     } else {
2916         if (f->finished)
2917             ret = AVERROR_EOF;
2918         else
2919             ret = AVERROR(EAGAIN);
2920     }
2921
2922     pthread_mutex_unlock(&f->fifo_lock);
2923
2924     return ret;
2925 }
2926 #endif
2927
2928 static int get_input_packet(InputFile *f, AVPacket *pkt)
2929 {
2930 #if HAVE_PTHREADS
2931     if (nb_input_files > 1)
2932         return get_input_packet_mt(f, pkt);
2933 #endif
2934     return av_read_frame(f->ctx, pkt);
2935 }
2936
2937 /*
2938  * The following code is the main loop of the file converter
2939  */
2940 static int transcode(void)
2941 {
2942     int ret, i;
2943     AVFormatContext *is, *os;
2944     OutputStream *ost;
2945     InputStream *ist;
2946     uint8_t *no_packet;
2947     int no_packet_count = 0;
2948     int64_t timer_start;
2949
2950     if (!(no_packet = av_mallocz(nb_input_files)))
2951         exit_program(1);
2952
2953     ret = transcode_init();
2954     if (ret < 0)
2955         goto fail;
2956
2957     av_log(NULL, AV_LOG_INFO, "Press ctrl-c to stop encoding\n");
2958     term_init();
2959
2960     timer_start = av_gettime();
2961
2962 #if HAVE_PTHREADS
2963     if ((ret = init_input_threads()) < 0)
2964         goto fail;
2965 #endif
2966
2967     for (; received_sigterm == 0;) {
2968         int file_index, ist_index;
2969         AVPacket pkt;
2970
2971         /* check if there's any stream where output is still needed */
2972         if (!need_output()) {
2973             av_log(NULL, AV_LOG_VERBOSE, "No more output streams to write to, finishing.\n");
2974             break;
2975         }
2976
2977         /* select the stream that we must read now */
2978         file_index = select_input_file(no_packet);
2979         /* if none, if is finished */
2980         if (file_index < 0) {
2981             if (no_packet_count) {
2982                 no_packet_count = 0;
2983                 memset(no_packet, 0, nb_input_files);
2984                 av_usleep(10000);
2985                 continue;
2986             }
2987             av_log(NULL, AV_LOG_VERBOSE, "No more inputs to read from, finishing.\n");
2988             break;
2989         }
2990
2991         is  = input_files[file_index]->ctx;
2992         ret = get_input_packet(input_files[file_index], &pkt);
2993
2994         if (ret == AVERROR(EAGAIN)) {
2995             no_packet[file_index] = 1;
2996             no_packet_count++;
2997             continue;
2998         }
2999         if (ret < 0) {
3000             input_files[file_index]->eof_reached = 1;
3001
3002             for (i = 0; i < input_files[file_index]->nb_streams; i++) {
3003                 ist = input_streams[input_files[file_index]->ist_index + i];
3004                 if (ist->decoding_needed)
3005                     output_packet(ist, NULL);
3006             }
3007
3008             if (opt_shortest)
3009                 break;
3010             else
3011                 continue;
3012         }
3013
3014         no_packet_count = 0;
3015         memset(no_packet, 0, nb_input_files);
3016
3017         if (do_pkt_dump) {
3018             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
3019                              is->streams[pkt.stream_index]);
3020         }
3021         /* the following test is needed in case new streams appear
3022            dynamically in stream : we ignore them */
3023         if (pkt.stream_index >= input_files[file_index]->nb_streams)
3024             goto discard_packet;
3025         ist_index = input_files[file_index]->ist_index + pkt.stream_index;
3026         ist = input_streams[ist_index];
3027         if (ist->discard)
3028             goto discard_packet;
3029
3030         if (pkt.dts != AV_NOPTS_VALUE)
3031             pkt.dts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3032         if (pkt.pts != AV_NOPTS_VALUE)
3033             pkt.pts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3034
3035         if (pkt.pts != AV_NOPTS_VALUE)
3036             pkt.pts *= ist->ts_scale;
3037         if (pkt.dts != AV_NOPTS_VALUE)
3038             pkt.dts *= ist->ts_scale;
3039
3040         //fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n",
3041         //        ist->next_dts,
3042         //        pkt.dts, input_files[ist->file_index].ts_offset,
3043         //        ist->st->codec->codec_type);
3044         if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE
3045             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
3046             int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3047             int64_t delta   = pkt_dts - ist->next_dts;
3048             if ((FFABS(delta) > 1LL * dts_delta_threshold * AV_TIME_BASE || pkt_dts + 1 < ist->last_dts) && !copy_ts) {
3049                 input_files[ist->file_index]->ts_offset -= delta;
3050                 av_log(NULL, AV_LOG_DEBUG,
3051                        "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3052                        delta, input_files[ist->file_index]->ts_offset);
3053                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3054                 if (pkt.pts != AV_NOPTS_VALUE)
3055                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3056             }
3057         }
3058
3059         // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
3060         if (output_packet(ist, &pkt) < 0 || poll_filters() < 0) {
3061             av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
3062                    ist->file_index, ist->st->index);
3063             if (exit_on_error)
3064                 exit_program(1);
3065             av_free_packet(&pkt);
3066             continue;
3067         }
3068
3069     discard_packet:
3070         av_free_packet(&pkt);
3071
3072         /* dump report by using the output first video and audio streams */
3073         print_report(0, timer_start);
3074     }
3075 #if HAVE_PTHREADS
3076     free_input_threads();
3077 #endif
3078
3079     /* at the end of stream, we must flush the decoder buffers */
3080     for (i = 0; i < nb_input_streams; i++) {
3081         ist = input_streams[i];
3082         if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
3083             output_packet(ist, NULL);
3084         }
3085     }
3086     poll_filters();
3087     flush_encoders();
3088
3089     term_exit();
3090
3091     /* write the trailer if needed and close file */
3092     for (i = 0; i < nb_output_files; i++) {
3093         os = output_files[i]->ctx;
3094         av_write_trailer(os);
3095     }
3096
3097     /* dump report by using the first video and audio streams */
3098     print_report(1, timer_start);
3099
3100     /* close each encoder */
3101     for (i = 0; i < nb_output_streams; i++) {
3102         ost = output_streams[i];
3103         if (ost->encoding_needed) {
3104             av_freep(&ost->st->codec->stats_in);
3105             avcodec_close(ost->st->codec);
3106         }
3107     }
3108
3109     /* close each decoder */
3110     for (i = 0; i < nb_input_streams; i++) {
3111         ist = input_streams[i];
3112         if (ist->decoding_needed) {
3113             avcodec_close(ist->st->codec);
3114         }
3115     }
3116
3117     /* finished ! */
3118     ret = 0;
3119
3120  fail:
3121     av_freep(&no_packet);
3122 #if HAVE_PTHREADS
3123     free_input_threads();
3124 #endif
3125
3126     if (output_streams) {
3127         for (i = 0; i < nb_output_streams; i++) {
3128             ost = output_streams[i];
3129             if (ost) {
3130                 if (ost->stream_copy)
3131                     av_freep(&ost->st->codec->extradata);
3132                 if (ost->logfile) {
3133                     fclose(ost->logfile);
3134                     ost->logfile = NULL;
3135                 }
3136                 av_freep(&ost->st->codec->subtitle_header);
3137                 av_free(ost->forced_kf_pts);
3138                 av_dict_free(&ost->opts);
3139             }
3140         }
3141     }
3142     return ret;
3143 }
3144
3145 static double parse_frame_aspect_ratio(const char *arg)
3146 {
3147     int x = 0, y = 0;
3148     double ar = 0;
3149     const char *p;
3150     char *end;
3151
3152     p = strchr(arg, ':');
3153     if (p) {
3154         x = strtol(arg, &end, 10);
3155         if (end == p)
3156             y = strtol(end + 1, &end, 10);
3157         if (x > 0 && y > 0)
3158             ar = (double)x / (double)y;
3159     } else
3160         ar = strtod(arg, NULL);
3161
3162     if (!ar) {
3163         av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
3164         exit_program(1);
3165     }
3166     return ar;
3167 }
3168
3169 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
3170 {
3171     return parse_option(o, "codec:a", arg, options);
3172 }
3173
3174 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3175 {
3176     return parse_option(o, "codec:v", arg, options);
3177 }
3178
3179 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3180 {
3181     return parse_option(o, "codec:s", arg, options);
3182 }
3183
3184 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3185 {
3186     return parse_option(o, "codec:d", arg, options);
3187 }
3188
3189 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3190 {
3191     StreamMap *m = NULL;
3192     int i, negative = 0, file_idx;
3193     int sync_file_idx = -1, sync_stream_idx;
3194     char *p, *sync;
3195     char *map;
3196
3197     if (*arg == '-') {
3198         negative = 1;
3199         arg++;
3200     }
3201     map = av_strdup(arg);
3202
3203     /* parse sync stream first, just pick first matching stream */
3204     if (sync = strchr(map, ',')) {
3205         *sync = 0;
3206         sync_file_idx = strtol(sync + 1, &sync, 0);
3207         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3208             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3209             exit_program(1);
3210         }
3211         if (*sync)
3212             sync++;
3213         for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
3214             if (check_stream_specifier(input_files[sync_file_idx]->ctx,
3215                                        input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
3216                 sync_stream_idx = i;
3217                 break;
3218             }
3219         if (i == input_files[sync_file_idx]->nb_streams) {
3220             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3221                                        "match any streams.\n", arg);
3222             exit_program(1);
3223         }
3224     }
3225
3226
3227     if (map[0] == '[') {
3228         /* this mapping refers to lavfi output */
3229         const char *c = map + 1;
3230         o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3231                                     &o->nb_stream_maps, o->nb_stream_maps + 1);
3232         m = &o->stream_maps[o->nb_stream_maps - 1];
3233         m->linklabel = av_get_token(&c, "]");
3234         if (!m->linklabel) {
3235             av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
3236             exit_program(1);
3237         }
3238     } else {
3239         file_idx = strtol(map, &p, 0);
3240         if (file_idx >= nb_input_files || file_idx < 0) {
3241             av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3242             exit_program(1);
3243         }
3244         if (negative)
3245             /* disable some already defined maps */
3246             for (i = 0; i < o->nb_stream_maps; i++) {
3247                 m = &o->stream_maps[i];
3248                 if (file_idx == m->file_index &&
3249                     check_stream_specifier(input_files[m->file_index]->ctx,
3250                                            input_files[m->file_index]->ctx->streams[m->stream_index],
3251                                            *p == ':' ? p + 1 : p) > 0)
3252                     m->disabled = 1;
3253             }
3254         else
3255             for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
3256                 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
3257                             *p == ':' ? p + 1 : p) <= 0)
3258                     continue;
3259                 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3260                                             &o->nb_stream_maps, o->nb_stream_maps + 1);
3261                 m = &o->stream_maps[o->nb_stream_maps - 1];
3262
3263                 m->file_index   = file_idx;
3264                 m->stream_index = i;
3265
3266                 if (sync_file_idx >= 0) {
3267                     m->sync_file_index   = sync_file_idx;
3268                     m->sync_stream_index = sync_stream_idx;
3269                 } else {
3270                     m->sync_file_index   = file_idx;
3271                     m->sync_stream_index = i;
3272                 }
3273             }
3274     }
3275
3276     if (!m) {
3277         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3278         exit_program(1);
3279     }
3280
3281     av_freep(&map);
3282     return 0;
3283 }
3284
3285 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3286 {
3287     o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3288                                 &o->nb_attachments, o->nb_attachments + 1);
3289     o->attachments[o->nb_attachments - 1] = arg;
3290     return 0;
3291 }
3292
3293 /**
3294  * Parse a metadata specifier in arg.
3295  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3296  * @param index for type c/p, chapter/program index is written here
3297  * @param stream_spec for type s, the stream specifier is written here
3298  */
3299 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3300 {
3301     if (*arg) {
3302         *type = *arg;
3303         switch (*arg) {
3304         case 'g':
3305             break;
3306         case 's':
3307             if (*(++arg) && *arg != ':') {
3308                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3309                 exit_program(1);
3310             }
3311             *stream_spec = *arg == ':' ? arg + 1 : "";
3312             break;
3313         case 'c':
3314         case 'p':
3315             if (*(++arg) == ':')
3316                 *index = strtol(++arg, NULL, 0);
3317             break;
3318         default:
3319             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3320             exit_program(1);
3321         }
3322     } else
3323         *type = 'g';
3324 }
3325
3326 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3327 {
3328     AVDictionary **meta_in = NULL;
3329     AVDictionary **meta_out;
3330     int i, ret = 0;
3331     char type_in, type_out;
3332     const char *istream_spec = NULL, *ostream_spec = NULL;
3333     int idx_in = 0, idx_out = 0;
3334
3335     parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
3336     parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3337
3338     if (type_in == 'g' || type_out == 'g')
3339         o->metadata_global_manual = 1;
3340     if (type_in == 's' || type_out == 's')
3341         o->metadata_streams_manual = 1;
3342     if (type_in == 'c' || type_out == 'c')
3343         o->metadata_chapters_manual = 1;
3344
3345 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3346     if ((index) < 0 || (index) >= (nb_elems)) {\
3347         av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
3348                 (desc), (index));\
3349         exit_program(1);\
3350     }
3351
3352 #define SET_DICT(type, meta, context, index)\
3353         switch (type) {\
3354         case 'g':\
3355             meta = &context->metadata;\
3356             break;\
3357         case 'c':\
3358             METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
3359             meta = &context->chapters[index]->metadata;\
3360             break;\
3361         case 'p':\
3362             METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
3363             meta = &context->programs[index]->metadata;\
3364             break;\
3365         default: av_assert0(0);\
3366         }\
3367
3368     SET_DICT(type_in, meta_in, ic, idx_in);
3369     SET_DICT(type_out, meta_out, oc, idx_out);
3370
3371     /* for input streams choose first matching stream */
3372     if (type_in == 's') {
3373         for (i = 0; i < ic->nb_streams; i++) {
3374             if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
3375                 meta_in = &ic->streams[i]->metadata;
3376                 break;
3377             } else if (ret < 0)
3378                 exit_program(1);
3379         }
3380         if (!meta_in) {
3381             av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
3382             exit_program(1);
3383         }
3384     }
3385
3386     if (type_out == 's') {
3387         for (i = 0; i < oc->nb_streams; i++) {
3388             if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
3389                 meta_out = &oc->streams[i]->metadata;
3390                 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3391             } else if (ret < 0)
3392                 exit_program(1);
3393         }
3394     } else
3395         av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3396
3397     return 0;
3398 }
3399
3400 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3401 {
3402     const char *codec_string = encoder ? "encoder" : "decoder";
3403     AVCodec *codec;
3404
3405     codec = encoder ?
3406         avcodec_find_encoder_by_name(name) :
3407         avcodec_find_decoder_by_name(name);
3408     if (!codec) {
3409         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3410         exit_program(1);
3411     }
3412     if (codec->type != type) {
3413         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3414         exit_program(1);
3415     }
3416     return codec;
3417 }
3418
3419 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3420 {
3421     char *codec_name = NULL;
3422
3423     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3424     if (codec_name) {
3425         AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3426         st->codec->codec_id = codec->id;
3427         return codec;
3428     } else
3429         return avcodec_find_decoder(st->codec->codec_id);
3430 }
3431
3432 /**
3433  * Add all the streams from the given input file to the global
3434  * list of input streams.
3435  */
3436 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3437 {
3438     int i;
3439
3440     for (i = 0; i < ic->nb_streams; i++) {
3441         AVStream *st = ic->streams[i];
3442         AVCodecContext *dec = st->codec;
3443         InputStream *ist = av_mallocz(sizeof(*ist));
3444         char *framerate = NULL;
3445
3446         if (!ist)
3447             exit_program(1);
3448
3449         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3450         input_streams[nb_input_streams - 1] = ist;
3451
3452         ist->st = st;
3453         ist->file_index = nb_input_files;
3454         ist->discard = 1;
3455         st->discard  = AVDISCARD_ALL;
3456         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, NULL);
3457
3458         ist->ts_scale = 1.0;
3459         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
3460
3461         ist->dec = choose_decoder(o, ic, st);
3462
3463         switch (dec->codec_type) {
3464         case AVMEDIA_TYPE_VIDEO:
3465             ist->resample_height  = dec->height;
3466             ist->resample_width   = dec->width;
3467             ist->resample_pix_fmt = dec->pix_fmt;
3468
3469             MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
3470             if (framerate && av_parse_video_rate(&ist->framerate,
3471                                                  framerate) < 0) {
3472                 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
3473                        framerate);
3474                 exit_program(1);
3475             }
3476
3477             break;
3478         case AVMEDIA_TYPE_AUDIO:
3479             guess_input_channel_layout(ist);
3480
3481             ist->resample_sample_fmt     = dec->sample_fmt;
3482             ist->resample_sample_rate    = dec->sample_rate;
3483             ist->resample_channels       = dec->channels;
3484             ist->resample_channel_layout = dec->channel_layout;
3485
3486             break;
3487         case AVMEDIA_TYPE_DATA:
3488         case AVMEDIA_TYPE_SUBTITLE:
3489         case AVMEDIA_TYPE_ATTACHMENT:
3490         case AVMEDIA_TYPE_UNKNOWN:
3491             break;
3492         default:
3493             abort();
3494         }
3495     }
3496 }
3497
3498 static void assert_file_overwrite(const char *filename)
3499 {
3500     if (!file_overwrite &&
3501         (strchr(filename, ':') == NULL || filename[1] == ':' ||
3502          av_strstart(filename, "file:", NULL))) {
3503         if (avio_check(filename, 0) == 0) {
3504             if (!using_stdin) {
3505                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3506                 fflush(stderr);
3507                 if (!read_yesno()) {
3508                     fprintf(stderr, "Not overwriting - exiting\n");
3509                     exit_program(1);
3510                 }
3511             }
3512             else {
3513                 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3514                 exit_program(1);
3515             }
3516         }
3517     }
3518 }
3519
3520 static void dump_attachment(AVStream *st, const char *filename)
3521 {
3522     int ret;
3523     AVIOContext *out = NULL;
3524     AVDictionaryEntry *e;
3525
3526     if (!st->codec->extradata_size) {
3527         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
3528                nb_input_files - 1, st->index);
3529         return;
3530     }
3531     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3532         filename = e->value;
3533     if (!*filename) {
3534         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
3535                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3536         exit_program(1);
3537     }
3538
3539     assert_file_overwrite(filename);
3540
3541     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
3542         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3543                filename);
3544         exit_program(1);
3545     }
3546
3547     avio_write(out, st->codec->extradata, st->codec->extradata_size);
3548     avio_flush(out);
3549     avio_close(out);
3550 }
3551
3552 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3553 {
3554     AVFormatContext *ic;
3555     AVInputFormat *file_iformat = NULL;
3556     int err, i, ret;
3557     int64_t timestamp;
3558     uint8_t buf[128];
3559     AVDictionary **opts;
3560     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
3561
3562     if (o->format) {
3563         if (!(file_iformat = av_find_input_format(o->format))) {
3564             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3565             exit_program(1);
3566         }
3567     }
3568
3569     if (!strcmp(filename, "-"))
3570         filename = "pipe:";
3571
3572     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3573                     !strcmp(filename, "/dev/stdin");
3574
3575     /* get default parameters from command line */
3576     ic = avformat_alloc_context();
3577     if (!ic) {
3578         print_error(filename, AVERROR(ENOMEM));
3579         exit_program(1);
3580     }
3581     if (o->nb_audio_sample_rate) {
3582         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3583         av_dict_set(&format_opts, "sample_rate", buf, 0);
3584     }
3585     if (o->nb_audio_channels) {
3586         /* because we set audio_channels based on both the "ac" and
3587          * "channel_layout" options, we need to check that the specified
3588          * demuxer actually has the "channels" option before setting it */
3589         if (file_iformat && file_iformat->priv_class &&
3590             av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
3591                         AV_OPT_SEARCH_FAKE_OBJ)) {
3592             snprintf(buf, sizeof(buf), "%d",
3593                      o->audio_channels[o->nb_audio_channels - 1].u.i);
3594             av_dict_set(&format_opts, "channels", buf, 0);
3595         }
3596     }
3597     if (o->nb_frame_rates) {
3598         /* set the format-level framerate option;
3599          * this is important for video grabbers, e.g. x11 */
3600         if (file_iformat && file_iformat->priv_class &&
3601             av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
3602                         AV_OPT_SEARCH_FAKE_OBJ)) {
3603             av_dict_set(&format_opts, "framerate",
3604                         o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3605         }
3606     }
3607     if (o->nb_frame_sizes) {
3608         av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3609     }
3610     if (o->nb_frame_pix_fmts)
3611         av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3612
3613     ic->flags |= AVFMT_FLAG_NONBLOCK;
3614     ic->interrupt_callback = int_cb;
3615
3616     /* open the input file with generic libav function */
3617     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3618     if (err < 0) {
3619         print_error(filename, err);
3620         exit_program(1);
3621     }
3622     assert_avoptions(format_opts);
3623
3624     /* apply forced codec ids */
3625     for (i = 0; i < ic->nb_streams; i++)
3626         choose_decoder(o, ic, ic->streams[i]);
3627
3628     /* Set AVCodecContext options for avformat_find_stream_info */
3629     opts = setup_find_stream_info_opts(ic, codec_opts);
3630     orig_nb_streams = ic->nb_streams;
3631
3632     /* If not enough info to get the stream parameters, we decode the
3633        first frames to get it. (used in mpeg case for example) */
3634     ret = avformat_find_stream_info(ic, opts);
3635     if (ret < 0) {
3636         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3637         avformat_close_input(&ic);
3638         exit_program(1);
3639     }
3640
3641     timestamp = o->start_time;
3642     /* add the stream start time */
3643     if (ic->start_time != AV_NOPTS_VALUE)
3644         timestamp += ic->start_time;
3645
3646     /* if seeking requested, we execute it */
3647     if (o->start_time != 0) {
3648         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3649         if (ret < 0) {
3650             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3651                    filename, (double)timestamp / AV_TIME_BASE);
3652         }
3653     }
3654
3655     /* update the current parameters so that they match the one of the input stream */
3656     add_input_streams(o, ic);
3657
3658     /* dump the file content */
3659     av_dump_format(ic, nb_input_files, filename, 0);
3660
3661     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3662     if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
3663         exit_program(1);
3664
3665     input_files[nb_input_files - 1]->ctx        = ic;
3666     input_files[nb_input_files - 1]->ist_index  = nb_input_streams - ic->nb_streams;
3667     input_files[nb_input_files - 1]->ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3668     input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
3669     input_files[nb_input_files - 1]->rate_emu   = o->rate_emu;
3670
3671     for (i = 0; i < o->nb_dump_attachment; i++) {
3672         int j;
3673
3674         for (j = 0; j < ic->nb_streams; j++) {
3675             AVStream *st = ic->streams[j];
3676
3677             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3678                 dump_attachment(st, o->dump_attachment[i].u.str);
3679         }
3680     }
3681
3682     for (i = 0; i < orig_nb_streams; i++)
3683         av_dict_free(&opts[i]);
3684     av_freep(&opts);
3685
3686     reset_options(o);
3687     return 0;
3688 }
3689
3690 static uint8_t *get_line(AVIOContext *s)
3691 {
3692     AVIOContext *line;
3693     uint8_t *buf;
3694     char c;
3695
3696     if (avio_open_dyn_buf(&line) < 0) {
3697         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3698         exit_program(1);
3699     }
3700
3701     while ((c = avio_r8(s)) && c != '\n')
3702         avio_w8(line, c);
3703     avio_w8(line, 0);
3704     avio_close_dyn_buf(line, &buf);
3705
3706     return buf;
3707 }
3708
3709 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3710 {
3711     int i, ret = 1;
3712     char filename[1000];
3713     const char *base[3] = { getenv("AVCONV_DATADIR"),
3714                             getenv("HOME"),
3715                             AVCONV_DATADIR,
3716                             };
3717
3718     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3719         if (!base[i])
3720             continue;
3721         if (codec_name) {
3722             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3723                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
3724             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3725         }
3726         if (ret) {
3727             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3728                      i != 1 ? "" : "/.avconv", preset_name);
3729             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3730         }
3731     }
3732     return ret;
3733 }
3734
3735 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3736 {
3737     char *codec_name = NULL;
3738
3739     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3740     if (!codec_name) {
3741         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3742                                                   NULL, ost->st->codec->codec_type);
3743         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3744     } else if (!strcmp(codec_name, "copy"))
3745         ost->stream_copy = 1;
3746     else {
3747         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3748         ost->st->codec->codec_id = ost->enc->id;
3749     }
3750 }
3751
3752 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3753 {
3754     OutputStream *ost;
3755     AVStream *st = avformat_new_stream(oc, NULL);
3756     int idx      = oc->nb_streams - 1, ret = 0;
3757     char *bsf = NULL, *next, *codec_tag = NULL;
3758     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3759     double qscale = -1;
3760     char *buf = NULL, *arg = NULL, *preset = NULL;
3761     AVIOContext *s = NULL;
3762
3763     if (!st) {
3764         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3765         exit_program(1);
3766     }
3767
3768     if (oc->nb_streams - 1 < o->nb_streamid_map)
3769         st->id = o->streamid_map[oc->nb_streams - 1];
3770
3771     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3772                                 nb_output_streams + 1);
3773     if (!(ost = av_mallocz(sizeof(*ost))))
3774         exit_program(1);
3775     output_streams[nb_output_streams - 1] = ost;
3776
3777     ost->file_index = nb_output_files;
3778     ost->index      = idx;
3779     ost->st         = st;
3780     st->codec->codec_type = type;
3781     choose_encoder(o, oc, ost);
3782     if (ost->enc) {
3783         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
3784     }
3785
3786     avcodec_get_context_defaults3(st->codec, ost->enc);
3787     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3788
3789     MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3790     if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3791         do  {
3792             buf = get_line(s);
3793             if (!buf[0] || buf[0] == '#') {
3794                 av_free(buf);
3795                 continue;
3796             }
3797             if (!(arg = strchr(buf, '='))) {
3798                 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3799                 exit_program(1);
3800             }
3801             *arg++ = 0;
3802             av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3803             av_free(buf);
3804         } while (!s->eof_reached);
3805         avio_close(s);
3806     }
3807     if (ret) {
3808         av_log(NULL, AV_LOG_FATAL,
3809                "Preset %s specified for stream %d:%d, but could not be opened.\n",
3810                preset, ost->file_index, ost->index);
3811         exit_program(1);
3812     }
3813
3814     ost->max_frames = INT64_MAX;
3815     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3816
3817     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3818     while (bsf) {
3819         if (next = strchr(bsf, ','))
3820             *next++ = 0;
3821         if (!(bsfc = av_bitstream_filter_init(bsf))) {
3822             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3823             exit_program(1);
3824         }
3825         if (bsfc_prev)
3826             bsfc_prev->next = bsfc;
3827         else
3828             ost->bitstream_filters = bsfc;
3829
3830         bsfc_prev = bsfc;
3831         bsf       = next;
3832     }
3833
3834     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3835     if (codec_tag) {
3836         uint32_t tag = strtol(codec_tag, &next, 0);
3837         if (*next)
3838             tag = AV_RL32(codec_tag);
3839         st->codec->codec_tag = tag;
3840     }
3841
3842     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3843     if (qscale >= 0 || same_quant) {
3844         st->codec->flags |= CODEC_FLAG_QSCALE;
3845         st->codec->global_quality = FF_QP2LAMBDA * qscale;
3846     }
3847
3848     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3849         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3850
3851     av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3852
3853     ost->pix_fmts[0] = ost->pix_fmts[1] = PIX_FMT_NONE;
3854
3855     return ost;
3856 }
3857
3858 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3859 {
3860     int i;
3861     const char *p = str;
3862     for (i = 0;; i++) {
3863         dest[i] = atoi(p);
3864         if (i == 63)
3865             break;
3866         p = strchr(p, ',');
3867         if (!p) {
3868             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3869             exit_program(1);
3870         }
3871         p++;
3872     }
3873 }
3874
3875 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3876 {
3877     AVStream *st;
3878     OutputStream *ost;
3879     AVCodecContext *video_enc;
3880
3881     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3882     st  = ost->st;
3883     video_enc = st->codec;
3884
3885     if (!ost->stream_copy) {
3886         const char *p = NULL;
3887         char *frame_rate = NULL, *frame_size = NULL;
3888         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3889         char *intra_matrix = NULL, *inter_matrix = NULL;
3890         const char *filters = "null";
3891         int i;
3892
3893         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3894         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3895             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3896             exit_program(1);
3897         }
3898
3899         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3900         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3901             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3902             exit_program(1);
3903         }
3904
3905         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3906         if (frame_aspect_ratio)
3907             ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3908
3909         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3910         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3911             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3912             exit_program(1);
3913         }
3914         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3915
3916         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3917         if (intra_matrix) {
3918             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3919                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3920                 exit_program(1);
3921             }
3922             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3923         }
3924         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3925         if (inter_matrix) {
3926             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3927                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3928                 exit_program(1);
3929             }
3930             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3931         }
3932
3933         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3934         for (i = 0; p; i++) {
3935             int start, end, q;
3936             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
3937             if (e != 3) {
3938                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3939                 exit_program(1);
3940             }
3941             video_enc->rc_override =
3942                 av_realloc(video_enc->rc_override,
3943                            sizeof(RcOverride) * (i + 1));
3944             video_enc->rc_override[i].start_frame = start;
3945             video_enc->rc_override[i].end_frame   = end;
3946             if (q > 0) {
3947                 video_enc->rc_override[i].qscale         = q;
3948                 video_enc->rc_override[i].quality_factor = 1.0;
3949             }
3950             else {
3951                 video_enc->rc_override[i].qscale         = 0;
3952                 video_enc->rc_override[i].quality_factor = -q/100.0;
3953             }
3954             p = strchr(p, '/');
3955             if (p) p++;
3956         }
3957         video_enc->rc_override_count = i;
3958         if (!video_enc->rc_initial_buffer_occupancy)
3959             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
3960         video_enc->intra_dc_precision = intra_dc_precision - 8;
3961
3962         /* two pass mode */
3963         if (do_pass) {
3964             if (do_pass == 1) {
3965                 video_enc->flags |= CODEC_FLAG_PASS1;
3966             } else {
3967                 video_enc->flags |= CODEC_FLAG_PASS2;
3968             }
3969         }
3970
3971         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
3972         if (ost->forced_keyframes)
3973             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
3974
3975         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
3976
3977         ost->top_field_first = -1;
3978         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
3979
3980         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3981         ost->avfilter = av_strdup(filters);
3982     } else {
3983         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
3984     }
3985
3986     return ost;
3987 }
3988
3989 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3990 {
3991     AVStream *st;
3992     OutputStream *ost;
3993     AVCodecContext *audio_enc;
3994
3995     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3996     st  = ost->st;
3997
3998     audio_enc = st->codec;
3999     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
4000
4001     if (!ost->stream_copy) {
4002         char *sample_fmt = NULL;
4003         const char *filters = "anull";
4004
4005         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
4006
4007         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
4008         if (sample_fmt &&
4009             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
4010             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
4011             exit_program(1);
4012         }
4013
4014         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
4015
4016         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4017         ost->avfilter = av_strdup(filters);
4018     }
4019
4020     return ost;
4021 }
4022
4023 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
4024 {
4025     OutputStream *ost;
4026
4027     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
4028     if (!ost->stream_copy) {
4029         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
4030         exit_program(1);
4031     }
4032
4033     return ost;
4034 }
4035
4036 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
4037 {
4038     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
4039     ost->stream_copy = 1;
4040     return ost;
4041 }
4042
4043 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
4044 {
4045     AVStream *st;
4046     OutputStream *ost;
4047     AVCodecContext *subtitle_enc;
4048
4049     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
4050     st  = ost->st;
4051     subtitle_enc = st->codec;
4052
4053     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
4054
4055     return ost;
4056 }
4057
4058 /* arg format is "output-stream-index:streamid-value". */
4059 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
4060 {
4061     int idx;
4062     char *p;
4063     char idx_str[16];
4064
4065     av_strlcpy(idx_str, arg, sizeof(idx_str));
4066     p = strchr(idx_str, ':');
4067     if (!p) {
4068         av_log(NULL, AV_LOG_FATAL,
4069                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
4070                arg, opt);
4071         exit_program(1);
4072     }
4073     *p++ = '\0';
4074     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
4075     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
4076     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
4077     return 0;
4078 }
4079
4080 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
4081 {
4082     AVFormatContext *is = ifile->ctx;
4083     AVFormatContext *os = ofile->ctx;
4084     int i;
4085
4086     for (i = 0; i < is->nb_chapters; i++) {
4087         AVChapter *in_ch = is->chapters[i], *out_ch;
4088         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
4089                                        AV_TIME_BASE_Q, in_ch->time_base);
4090         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
4091                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
4092
4093
4094         if (in_ch->end < ts_off)
4095             continue;
4096         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
4097             break;
4098
4099         out_ch = av_mallocz(sizeof(AVChapter));
4100         if (!out_ch)
4101             return AVERROR(ENOMEM);
4102
4103         out_ch->id        = in_ch->id;
4104         out_ch->time_base = in_ch->time_base;
4105         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
4106         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
4107
4108         if (copy_metadata)
4109             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
4110
4111         os->nb_chapters++;
4112         os->chapters = av_realloc(os->chapters, sizeof(AVChapter) * os->nb_chapters);
4113         if (!os->chapters)
4114             return AVERROR(ENOMEM);
4115         os->chapters[os->nb_chapters - 1] = out_ch;
4116     }
4117     return 0;
4118 }
4119
4120 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
4121                                AVFormatContext *oc)
4122 {
4123     OutputStream *ost;
4124
4125     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
4126                                   ofilter->out_tmp->pad_idx)) {
4127     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
4128     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
4129     default:
4130         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
4131                "currently.\n");
4132         exit_program(1);
4133     }
4134
4135     ost->source_index = -1;
4136     ost->filter       = ofilter;
4137
4138     ofilter->ost      = ost;
4139
4140     if (ost->stream_copy) {
4141         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
4142                "which is fed from a complex filtergraph. Filtering and streamcopy "
4143                "cannot be used together.\n", ost->file_index, ost->index);
4144         exit_program(1);
4145     }
4146
4147     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
4148         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
4149         exit_program(1);
4150     }
4151     avfilter_inout_free(&ofilter->out_tmp);
4152 }
4153
4154 static void opt_output_file(void *optctx, const char *filename)
4155 {
4156     OptionsContext *o = optctx;
4157     AVFormatContext *oc;
4158     int i, j, err;
4159     AVOutputFormat *file_oformat;
4160     OutputStream *ost;
4161     InputStream  *ist;
4162
4163     if (configure_complex_filters() < 0) {
4164         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
4165         exit_program(1);
4166     }
4167
4168     if (!strcmp(filename, "-"))
4169         filename = "pipe:";
4170
4171     oc = avformat_alloc_context();
4172     if (!oc) {
4173         print_error(filename, AVERROR(ENOMEM));
4174         exit_program(1);
4175     }
4176
4177     if (o->format) {
4178         file_oformat = av_guess_format(o->format, NULL, NULL);
4179         if (!file_oformat) {
4180             av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
4181             exit_program(1);
4182         }
4183     } else {
4184         file_oformat = av_guess_format(NULL, filename, NULL);
4185         if (!file_oformat) {
4186             av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
4187                    filename);
4188             exit_program(1);
4189         }
4190     }
4191
4192     oc->oformat = file_oformat;
4193     oc->interrupt_callback = int_cb;
4194     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
4195
4196     /* create streams for all unlabeled output pads */
4197     for (i = 0; i < nb_filtergraphs; i++) {
4198         FilterGraph *fg = filtergraphs[i];
4199         for (j = 0; j < fg->nb_outputs; j++) {
4200             OutputFilter *ofilter = fg->outputs[j];
4201
4202             if (!ofilter->out_tmp || ofilter->out_tmp->name)
4203                 continue;
4204
4205             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
4206                                           ofilter->out_tmp->pad_idx)) {
4207             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
4208             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
4209             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
4210             }
4211             init_output_filter(ofilter, o, oc);
4212         }
4213     }
4214
4215     if (!o->nb_stream_maps) {
4216         /* pick the "best" stream of each type */
4217 #define NEW_STREAM(type, index)\
4218         if (index >= 0) {\
4219             ost = new_ ## type ## _stream(o, oc);\
4220             ost->source_index = index;\
4221             ost->sync_ist     = input_streams[index];\
4222             input_streams[index]->discard = 0;\
4223             input_streams[index]->st->discard = AVDISCARD_NONE;\
4224         }
4225
4226         /* video: highest resolution */
4227         if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
4228             int area = 0, idx = -1;
4229             for (i = 0; i < nb_input_streams; i++) {
4230                 ist = input_streams[i];
4231                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
4232                     ist->st->codec->width * ist->st->codec->height > area) {
4233                     area = ist->st->codec->width * ist->st->codec->height;
4234                     idx = i;
4235                 }
4236             }
4237             NEW_STREAM(video, idx);
4238         }
4239
4240         /* audio: most channels */
4241         if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
4242             int channels = 0, idx = -1;
4243             for (i = 0; i < nb_input_streams; i++) {
4244                 ist = input_streams[i];
4245                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
4246                     ist->st->codec->channels > channels) {
4247                     channels = ist->st->codec->channels;
4248                     idx = i;
4249                 }
4250             }
4251             NEW_STREAM(audio, idx);
4252         }
4253
4254         /* subtitles: pick first */
4255         if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
4256             for (i = 0; i < nb_input_streams; i++)
4257                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
4258                     NEW_STREAM(subtitle, i);
4259                     break;
4260                 }
4261         }
4262         /* do something with data? */
4263     } else {
4264         for (i = 0; i < o->nb_stream_maps; i++) {
4265             StreamMap *map = &o->stream_maps[i];
4266
4267             if (map->disabled)
4268                 continue;
4269
4270             if (map->linklabel) {
4271                 FilterGraph *fg;
4272                 OutputFilter *ofilter = NULL;
4273                 int j, k;
4274
4275                 for (j = 0; j < nb_filtergraphs; j++) {
4276                     fg = filtergraphs[j];
4277                     for (k = 0; k < fg->nb_outputs; k++) {
4278                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
4279                         if (out && !strcmp(out->name, map->linklabel)) {
4280                             ofilter = fg->outputs[k];
4281                             goto loop_end;
4282                         }
4283                     }
4284                 }
4285 loop_end:
4286                 if (!ofilter) {
4287                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
4288                            "in any defined filter graph.\n", map->linklabel);
4289                     exit_program(1);
4290                 }
4291                 init_output_filter(ofilter, o, oc);
4292             } else {
4293                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
4294                 switch (ist->st->codec->codec_type) {
4295                 case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
4296                 case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
4297                 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
4298                 case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
4299                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
4300                 default:
4301                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
4302                            map->file_index, map->stream_index);
4303                     exit_program(1);
4304                 }
4305
4306                 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
4307                 ost->sync_ist     = input_streams[input_files[map->sync_file_index]->ist_index +
4308                                                map->sync_stream_index];
4309                 ist->discard = 0;
4310                 ist->st->discard = AVDISCARD_NONE;
4311             }
4312         }
4313     }
4314
4315     /* handle attached files */
4316     for (i = 0; i < o->nb_attachments; i++) {
4317         AVIOContext *pb;
4318         uint8_t *attachment;
4319         const char *p;
4320         int64_t len;
4321
4322         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
4323             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
4324                    o->attachments[i]);
4325             exit_program(1);
4326         }
4327         if ((len = avio_size(pb)) <= 0) {
4328             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
4329                    o->attachments[i]);
4330             exit_program(1);
4331         }
4332         if (!(attachment = av_malloc(len))) {
4333             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
4334                    o->attachments[i]);
4335             exit_program(1);
4336         }
4337         avio_read(pb, attachment, len);
4338
4339         ost = new_attachment_stream(o, oc);
4340         ost->stream_copy               = 0;
4341         ost->source_index              = -1;
4342         ost->attachment_filename       = o->attachments[i];
4343         ost->st->codec->extradata      = attachment;
4344         ost->st->codec->extradata_size = len;
4345
4346         p = strrchr(o->attachments[i], '/');
4347         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
4348         avio_close(pb);
4349     }
4350
4351     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
4352     if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
4353         exit_program(1);
4354
4355     output_files[nb_output_files - 1]->ctx            = oc;
4356     output_files[nb_output_files - 1]->ost_index      = nb_output_streams - oc->nb_streams;
4357     output_files[nb_output_files - 1]->recording_time = o->recording_time;
4358     if (o->recording_time != INT64_MAX)
4359         oc->duration = o->recording_time;
4360     output_files[nb_output_files - 1]->start_time     = o->start_time;
4361     output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
4362     av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
4363
4364     /* check filename in case of an image number is expected */
4365     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
4366         if (!av_filename_number_test(oc->filename)) {
4367             print_error(oc->filename, AVERROR(EINVAL));
4368             exit_program(1);
4369         }
4370     }
4371
4372     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
4373         /* test if it already exists to avoid losing precious files */
4374         assert_file_overwrite(filename);
4375
4376         /* open the file */
4377         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
4378                               &oc->interrupt_callback,
4379                               &output_files[nb_output_files - 1]->opts)) < 0) {
4380             print_error(filename, err);
4381             exit_program(1);
4382         }
4383     }
4384
4385     if (o->mux_preload) {
4386         uint8_t buf[64];
4387         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
4388         av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
4389     }
4390     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
4391     oc->flags |= AVFMT_FLAG_NONBLOCK;
4392
4393     /* copy metadata */
4394     for (i = 0; i < o->nb_metadata_map; i++) {
4395         char *p;
4396         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
4397
4398         if (in_file_index < 0)
4399             continue;
4400         if (in_file_index >= nb_input_files) {
4401             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
4402             exit_program(1);
4403         }
4404         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index]->ctx, o);
4405     }
4406
4407     /* copy chapters */
4408     if (o->chapters_input_file >= nb_input_files) {
4409         if (o->chapters_input_file == INT_MAX) {
4410             /* copy chapters from the first input file that has them*/
4411             o->chapters_input_file = -1;
4412             for (i = 0; i < nb_input_files; i++)
4413                 if (input_files[i]->ctx->nb_chapters) {
4414                     o->chapters_input_file = i;
4415                     break;
4416                 }
4417         } else {
4418             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4419                    o->chapters_input_file);
4420             exit_program(1);
4421         }
4422     }
4423     if (o->chapters_input_file >= 0)
4424         copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
4425                       !o->metadata_chapters_manual);
4426
4427     /* copy global metadata by default */
4428     if (!o->metadata_global_manual && nb_input_files)
4429         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
4430                      AV_DICT_DONT_OVERWRITE);
4431     if (!o->metadata_streams_manual)
4432         for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
4433             InputStream *ist;
4434             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
4435                 continue;
4436             ist = input_streams[output_streams[i]->source_index];
4437             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4438         }
4439
4440     /* process manually set metadata */
4441     for (i = 0; i < o->nb_metadata; i++) {
4442         AVDictionary **m;
4443         char type, *val;
4444         const char *stream_spec;
4445         int index = 0, j, ret;
4446
4447         val = strchr(o->metadata[i].u.str, '=');
4448         if (!val) {
4449             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4450                    o->metadata[i].u.str);
4451             exit_program(1);
4452         }
4453         *val++ = 0;
4454
4455         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
4456         if (type == 's') {
4457             for (j = 0; j < oc->nb_streams; j++) {
4458                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
4459                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
4460                 } else if (ret < 0)
4461                     exit_program(1);
4462             }
4463         }
4464         else {
4465             switch (type) {
4466             case 'g':
4467                 m = &oc->metadata;
4468                 break;
4469             case 'c':
4470                 if (index < 0 || index >= oc->nb_chapters) {
4471                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4472                     exit_program(1);
4473                 }
4474                 m = &oc->chapters[index]->metadata;
4475                 break;
4476             default:
4477                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4478                 exit_program(1);
4479             }
4480             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4481         }
4482     }
4483
4484     reset_options(o);
4485 }
4486
4487 /* same option as mencoder */
4488 static int opt_pass(const char *opt, const char *arg)
4489 {
4490     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
4491     return 0;
4492 }
4493
4494 static int64_t getutime(void)
4495 {
4496 #if HAVE_GETRUSAGE
4497     struct rusage rusage;
4498
4499     getrusage(RUSAGE_SELF, &rusage);
4500     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4501 #elif HAVE_GETPROCESSTIMES
4502     HANDLE proc;
4503     FILETIME c, e, k, u;
4504     proc = GetCurrentProcess();
4505     GetProcessTimes(proc, &c, &e, &k, &u);
4506     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4507 #else
4508     return av_gettime();
4509 #endif
4510 }
4511
4512 static int64_t getmaxrss(void)
4513 {
4514 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4515     struct rusage rusage;
4516     getrusage(RUSAGE_SELF, &rusage);
4517     return (int64_t)rusage.ru_maxrss * 1024;
4518 #elif HAVE_GETPROCESSMEMORYINFO
4519     HANDLE proc;
4520     PROCESS_MEMORY_COUNTERS memcounters;
4521     proc = GetCurrentProcess();
4522     memcounters.cb = sizeof(memcounters);
4523     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4524     return memcounters.PeakPagefileUsage;
4525 #else
4526     return 0;
4527 #endif
4528 }
4529
4530 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4531 {
4532     return parse_option(o, "q:a", arg, options);
4533 }
4534
4535 static void show_usage(void)
4536 {
4537     printf("Hyper fast Audio and Video encoder\n");
4538     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4539     printf("\n");
4540 }
4541
4542 static void show_help(void)
4543 {
4544     int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4545     av_log_set_callback(log_callback_help);
4546     show_usage();
4547     show_help_options(options, "Main options:\n",
4548                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4549     show_help_options(options, "\nAdvanced options:\n",
4550                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4551                       OPT_EXPERT);
4552     show_help_options(options, "\nVideo options:\n",
4553                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4554                       OPT_VIDEO);
4555     show_help_options(options, "\nAdvanced Video options:\n",
4556                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4557                       OPT_VIDEO | OPT_EXPERT);
4558     show_help_options(options, "\nAudio options:\n",
4559                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4560                       OPT_AUDIO);
4561     show_help_options(options, "\nAdvanced Audio options:\n",
4562                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4563                       OPT_AUDIO | OPT_EXPERT);
4564     show_help_options(options, "\nSubtitle options:\n",
4565                       OPT_SUBTITLE | OPT_GRAB,
4566                       OPT_SUBTITLE);
4567     show_help_options(options, "\nAudio/Video grab options:\n",
4568                       OPT_GRAB,
4569                       OPT_GRAB);
4570     printf("\n");
4571     show_help_children(avcodec_get_class(), flags);
4572     show_help_children(avformat_get_class(), flags);
4573     show_help_children(sws_get_class(), flags);
4574 }
4575
4576 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4577 {
4578     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4579     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
4580
4581     if (!strncmp(arg, "pal-", 4)) {
4582         norm = PAL;
4583         arg += 4;
4584     } else if (!strncmp(arg, "ntsc-", 5)) {
4585         norm = NTSC;
4586         arg += 5;
4587     } else if (!strncmp(arg, "film-", 5)) {
4588         norm = FILM;
4589         arg += 5;
4590     } else {
4591         /* Try to determine PAL/NTSC by peeking in the input files */
4592         if (nb_input_files) {
4593             int i, j, fr;
4594             for (j = 0; j < nb_input_files; j++) {
4595                 for (i = 0; i < input_files[j]->nb_streams; i++) {
4596                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
4597                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
4598                         continue;
4599                     fr = c->time_base.den * 1000 / c->time_base.num;
4600                     if (fr == 25000) {
4601                         norm = PAL;
4602                         break;
4603                     } else if ((fr == 29970) || (fr == 23976)) {
4604                         norm = NTSC;
4605                         break;
4606                     }
4607                 }
4608                 if (norm != UNKNOWN)
4609                     break;
4610             }
4611         }
4612         if (norm != UNKNOWN)
4613             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4614     }
4615
4616     if (norm == UNKNOWN) {
4617         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4618         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4619         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4620         exit_program(1);
4621     }
4622
4623     if (!strcmp(arg, "vcd")) {
4624         opt_video_codec(o, "c:v", "mpeg1video");
4625         opt_audio_codec(o, "c:a", "mp2");
4626         parse_option(o, "f", "vcd", options);
4627
4628         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4629         parse_option(o, "r", frame_rates[norm], options);
4630         opt_default("g", norm == PAL ? "15" : "18");
4631
4632         opt_default("b", "1150000");
4633         opt_default("maxrate", "1150000");
4634         opt_default("minrate", "1150000");
4635         opt_default("bufsize", "327680"); // 40*1024*8;
4636
4637         opt_default("b:a", "224000");
4638         parse_option(o, "ar", "44100", options);
4639         parse_option(o, "ac", "2", options);
4640
4641         opt_default("packetsize", "2324");
4642         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4643
4644         /* We have to offset the PTS, so that it is consistent with the SCR.
4645            SCR starts at 36000, but the first two packs contain only padding
4646            and the first pack from the other stream, respectively, may also have
4647            been written before.
4648            So the real data starts at SCR 36000+3*1200. */
4649         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
4650     } else if (!strcmp(arg, "svcd")) {
4651
4652         opt_video_codec(o, "c:v", "mpeg2video");
4653         opt_audio_codec(o, "c:a", "mp2");
4654         parse_option(o, "f", "svcd", options);
4655
4656         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4657         parse_option(o, "r", frame_rates[norm], options);
4658         opt_default("g", norm == PAL ? "15" : "18");
4659
4660         opt_default("b", "2040000");
4661         opt_default("maxrate", "2516000");
4662         opt_default("minrate", "0"); // 1145000;
4663         opt_default("bufsize", "1835008"); // 224*1024*8;
4664         opt_default("flags", "+scan_offset");
4665
4666
4667         opt_default("b:a", "224000");
4668         parse_option(o, "ar", "44100", options);
4669
4670         opt_default("packetsize", "2324");
4671
4672     } else if (!strcmp(arg, "dvd")) {
4673
4674         opt_video_codec(o, "c:v", "mpeg2video");
4675         opt_audio_codec(o, "c:a", "ac3");
4676         parse_option(o, "f", "dvd", options);
4677
4678         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4679         parse_option(o, "r", frame_rates[norm], options);
4680         opt_default("g", norm == PAL ? "15" : "18");
4681
4682         opt_default("b", "6000000");
4683         opt_default("maxrate", "9000000");
4684         opt_default("minrate", "0"); // 1500000;
4685         opt_default("bufsize", "1835008"); // 224*1024*8;
4686
4687         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4688         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4689
4690         opt_default("b:a", "448000");
4691         parse_option(o, "ar", "48000", options);
4692
4693     } else if (!strncmp(arg, "dv", 2)) {
4694
4695         parse_option(o, "f", "dv", options);
4696
4697         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4698         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4699                           norm == PAL ? "yuv420p" : "yuv411p", options);
4700         parse_option(o, "r", frame_rates[norm], options);
4701
4702         parse_option(o, "ar", "48000", options);
4703         parse_option(o, "ac", "2", options);
4704
4705     } else {
4706         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4707         return AVERROR(EINVAL);
4708     }
4709     return 0;
4710 }
4711
4712 static int opt_vstats_file(const char *opt, const char *arg)
4713 {
4714     av_free (vstats_filename);
4715     vstats_filename = av_strdup (arg);
4716     return 0;
4717 }
4718
4719 static int opt_vstats(const char *opt, const char *arg)
4720 {
4721     char filename[40];
4722     time_t today2 = time(NULL);
4723     struct tm *today = localtime(&today2);
4724
4725     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4726              today->tm_sec);
4727     return opt_vstats_file(opt, filename);
4728 }
4729
4730 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4731 {
4732     return parse_option(o, "frames:v", arg, options);
4733 }
4734
4735 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4736 {
4737     return parse_option(o, "frames:a", arg, options);
4738 }
4739
4740 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4741 {
4742     return parse_option(o, "frames:d", arg, options);
4743 }
4744
4745 static int opt_video_tag(OptionsContext *o, const char *opt, const char *arg)
4746 {
4747     return parse_option(o, "tag:v", arg, options);
4748 }
4749
4750 static int opt_audio_tag(OptionsContext *o, const char *opt, const char *arg)
4751 {
4752     return parse_option(o, "tag:a", arg, options);
4753 }
4754
4755 static int opt_subtitle_tag(OptionsContext *o, const char *opt, const char *arg)
4756 {
4757     return parse_option(o, "tag:s", arg, options);
4758 }
4759
4760 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4761 {
4762     return parse_option(o, "filter:v", arg, options);
4763 }
4764
4765 static int opt_audio_filters(OptionsContext *o, const char *opt, const char *arg)
4766 {
4767     return parse_option(o, "filter:a", arg, options);
4768 }
4769
4770 static int opt_vsync(const char *opt, const char *arg)
4771 {
4772     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
4773     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
4774     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
4775
4776     if (video_sync_method == VSYNC_AUTO)
4777         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
4778     return 0;
4779 }
4780
4781 static int opt_deinterlace(const char *opt, const char *arg)
4782 {
4783     av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
4784     do_deinterlace = 1;
4785     return 0;
4786 }
4787
4788 static int opt_cpuflags(const char *opt, const char *arg)
4789 {
4790     int flags = av_parse_cpu_flags(arg);
4791
4792     if (flags < 0)
4793         return flags;
4794
4795     av_set_cpu_flags_mask(flags);
4796     return 0;
4797 }
4798
4799 static void parse_cpuflags(int argc, char **argv, const OptionDef *options)
4800 {
4801     int idx = locate_option(argc, argv, options, "cpuflags");
4802     if (idx && argv[idx + 1])
4803         opt_cpuflags("cpuflags", argv[idx + 1]);
4804 }
4805
4806 static int opt_channel_layout(OptionsContext *o, const char *opt, const char *arg)
4807 {
4808     char layout_str[32];
4809     char *stream_str;
4810     char *ac_str;
4811     int ret, channels, ac_str_size;
4812     uint64_t layout;
4813
4814     layout = av_get_channel_layout(arg);
4815     if (!layout) {
4816         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
4817         return AVERROR(EINVAL);
4818     }
4819     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
4820     ret = opt_default(opt, layout_str);
4821     if (ret < 0)
4822         return ret;
4823
4824     /* set 'ac' option based on channel layout */
4825     channels = av_get_channel_layout_nb_channels(layout);
4826     snprintf(layout_str, sizeof(layout_str), "%d", channels);
4827     stream_str = strchr(opt, ':');
4828     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
4829     ac_str = av_mallocz(ac_str_size);
4830     if (!ac_str)
4831         return AVERROR(ENOMEM);
4832     av_strlcpy(ac_str, "ac", 3);
4833     if (stream_str)
4834         av_strlcat(ac_str, stream_str, ac_str_size);
4835     ret = parse_option(o, ac_str, layout_str, options);
4836     av_free(ac_str);
4837
4838     return ret;
4839 }
4840
4841 static int opt_filter_complex(const char *opt, const char *arg)
4842 {
4843     filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
4844                               &nb_filtergraphs, nb_filtergraphs + 1);
4845     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
4846         return AVERROR(ENOMEM);
4847     filtergraphs[nb_filtergraphs - 1]->index       = nb_filtergraphs - 1;
4848     filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
4849     return 0;
4850 }
4851
4852 #define OFFSET(x) offsetof(OptionsContext, x)
4853 static const OptionDef options[] = {
4854     /* main options */
4855 #include "cmdutils_common_opts.h"
4856     { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4857     { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4858     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4859     { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4860     { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4861     { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4862     { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
4863     { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
4864       "outfile[,metadata]:infile[,metadata]" },
4865     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)},  "set chapters mapping", "input_file_index" },
4866     { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4867     { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4868     { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4869     { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4870     { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4871     { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4872     { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4873     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4874       "add timings for benchmarking" },
4875     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4876     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4877       "dump each input packet" },
4878     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4879       "when dumping packets, also dump the payload" },
4880     { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4881     { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4882     { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
4883     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4884     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4885     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4886     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4887     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4888     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4889     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4890     { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4891     { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4892     { "tag",   OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4893     { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4894     { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4895     { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4896     { "filter_complex", HAS_ARG | OPT_EXPERT, {(void*)opt_filter_complex}, "create a complex filtergraph", "graph_description" },
4897     { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4898     { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4899     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4900     { "cpuflags", HAS_ARG | OPT_EXPERT, {(void*)opt_cpuflags}, "set CPU flags mask", "mask" },
4901
4902     /* video options */
4903     { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4904     { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4905     { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4906     { "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" },
4907     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4908     { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4909     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4910     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4911     { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4912     { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4913       "use same quantizer as source (implies VBR)" },
4914     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4915     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4916     { "deinterlace", OPT_EXPERT | OPT_VIDEO, {(void*)opt_deinterlace},
4917       "this option is deprecated, use the yadif filter instead" },
4918     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4919     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4920     { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4921     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4922     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4923     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4924     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4925     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4926     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4927     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4928     { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4929     { "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" },
4930
4931     /* audio options */
4932     { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4933     { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4934     { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4935     { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4936     { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4937     { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4938     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4939     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4940     { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4941     { "channel_layout", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_channel_layout}, "set channel layout", "layout" },
4942     { "af", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_filters}, "audio filters", "filter list" },
4943
4944     /* subtitle options */
4945     { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4946     { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4947     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4948
4949     /* grab options */
4950     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4951
4952     /* muxer options */
4953     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT   | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4954     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)},   "set the initial demux-decode delay", "seconds" },
4955
4956     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4957
4958     /* data codec support */
4959     { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4960
4961     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4962     { NULL, },
4963 };
4964
4965 int main(int argc, char **argv)
4966 {
4967     OptionsContext o = { 0 };
4968     int64_t ti;
4969
4970     reset_options(&o);
4971
4972     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4973     parse_loglevel(argc, argv, options);
4974
4975     avcodec_register_all();
4976 #if CONFIG_AVDEVICE
4977     avdevice_register_all();
4978 #endif
4979     avfilter_register_all();
4980     av_register_all();
4981     avformat_network_init();
4982
4983     show_banner();
4984
4985     parse_cpuflags(argc, argv, options);
4986
4987     /* parse options */
4988     parse_options(&o, argc, argv, options, opt_output_file);
4989
4990     if (nb_output_files <= 0 && nb_input_files == 0) {
4991         show_usage();
4992         av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4993         exit_program(1);
4994     }
4995
4996     /* file converter / grab */
4997     if (nb_output_files <= 0) {
4998         fprintf(stderr, "At least one output file must be specified\n");
4999         exit_program(1);
5000     }
5001
5002     if (nb_input_files == 0) {
5003         av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
5004         exit_program(1);
5005     }
5006
5007     ti = getutime();
5008     if (transcode() < 0)
5009         exit_program(1);
5010     ti = getutime() - ti;
5011     if (do_benchmark) {
5012         int maxrss = getmaxrss() / 1024;
5013         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
5014     }
5015
5016     exit_program(0);
5017     return 0;
5018 }