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