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