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