git.sesse.net Git - ffmpeg/blob - avconv.c

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