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

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