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

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