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

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