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