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