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