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

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