git.sesse.net Git - ffmpeg/blob - ffmpeg.c

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