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