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