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