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