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