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

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