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