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