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

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