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

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