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

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