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