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