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