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