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