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