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

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