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