git.sesse.net Git - ffmpeg/blob - ffmpeg.c

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