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