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