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