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