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