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

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