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