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