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

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