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

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