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   != in_picture->width  ||
1320                        ost->resample_height  != in_picture->height ||
1321                        ost->resample_pix_fmt != in_picture->format;
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 / frm 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                in_picture->width, in_picture->height, av_get_pix_fmt_name(in_picture->format));
1330         ost->resample_width   = in_picture->width;
1331         ost->resample_height  = in_picture->height;
1332         ost->resample_pix_fmt = in_picture->format;
1333     }
1334
1335     ost->video_resample = dec->width   != enc->width  ||
1336                           dec->height  != enc->height ||
1337                           dec->pix_fmt != enc->pix_fmt;
1338
1339
1340     if (ost->video_resample) {
1341         *out_picture = &ost->resample_frame;
1342         if (!ost->img_resample_ctx || resample_changed) {
1343             /* initialize the destination picture */
1344             if (!ost->resample_frame.data[0]) {
1345                 avcodec_get_frame_defaults(&ost->resample_frame);
1346                 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1347                                     enc->width, enc->height)) {
1348                     fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1349                     exit_program(1);
1350                 }
1351             }
1352             /* initialize a new scaler context */
1353             sws_freeContext(ost->img_resample_ctx);
1354             ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1355                                                    enc->width, enc->height, enc->pix_fmt,
1356                                                    ost->sws_flags, NULL, NULL, NULL);
1357             if (ost->img_resample_ctx == NULL) {
1358                 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1359                 exit_program(1);
1360             }
1361         }
1362         sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1363               0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1364     }
1365     if (resample_changed) {
1366         ost->resample_width   = in_picture->width;
1367         ost->resample_height  = in_picture->height;
1368         ost->resample_pix_fmt = in_picture->format;
1369     }
1370 }
1371 #endif
1372
1373
1374 static void do_video_out(AVFormatContext *s,
1375                          OutputStream *ost,
1376                          InputStream *ist,
1377                          AVFrame *in_picture,
1378                          int *frame_size, float quality)
1379 {
1380     int nb_frames, i, ret, format_video_sync;
1381     AVFrame *final_picture;
1382     AVCodecContext *enc;
1383     double sync_ipts;
1384
1385     enc = ost->st->codec;
1386
1387     sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1388
1389     /* by default, we output a single frame */
1390     nb_frames = 1;
1391
1392     *frame_size = 0;
1393
1394     format_video_sync = video_sync_method;
1395     if (format_video_sync == VSYNC_AUTO)
1396         format_video_sync = (s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH :
1397                             (s->oformat->flags & AVFMT_VARIABLE_FPS) ? VSYNC_VFR : VSYNC_CFR;
1398
1399     if (format_video_sync != VSYNC_PASSTHROUGH) {
1400         double vdelta = sync_ipts - ost->sync_opts;
1401         // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1402         if (vdelta < -1.1)
1403             nb_frames = 0;
1404         else if (format_video_sync == VSYNC_VFR) {
1405             if (vdelta <= -0.6) {
1406                 nb_frames = 0;
1407             } else if (vdelta > 0.6)
1408                 ost->sync_opts = lrintf(sync_ipts);
1409         } else if (vdelta > 1.1)
1410             nb_frames = lrintf(vdelta);
1411 //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);
1412         if (nb_frames == 0) {
1413             ++nb_frames_drop;
1414             av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1415         } else if (nb_frames > 1) {
1416             nb_frames_dup += nb_frames - 1;
1417             av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1418         }
1419     } else
1420         ost->sync_opts = lrintf(sync_ipts);
1421
1422     nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1423     if (nb_frames <= 0)
1424         return;
1425
1426 #if !CONFIG_AVFILTER
1427     do_video_resample(ost, ist, in_picture, &final_picture);
1428 #else
1429     final_picture = in_picture;
1430 #endif
1431
1432     /* duplicates frame if needed */
1433     for (i = 0; i < nb_frames; i++) {
1434         AVPacket pkt;
1435         av_init_packet(&pkt);
1436         pkt.stream_index = ost->index;
1437
1438         if (s->oformat->flags & AVFMT_RAWPICTURE &&
1439             enc->codec->id == CODEC_ID_RAWVIDEO) {
1440             /* raw pictures are written as AVPicture structure to
1441                avoid any copies. We support temporarily the older
1442                method. */
1443             enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1444             enc->coded_frame->top_field_first  = in_picture->top_field_first;
1445             pkt.data   = (uint8_t *)final_picture;
1446             pkt.size   =  sizeof(AVPicture);
1447             pkt.pts    = av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1448             pkt.flags |= AV_PKT_FLAG_KEY;
1449
1450             write_frame(s, &pkt, ost);
1451         } else {
1452             AVFrame big_picture;
1453
1454             big_picture = *final_picture;
1455             /* better than nothing: use input picture interlaced
1456                settings */
1457             big_picture.interlaced_frame = in_picture->interlaced_frame;
1458             if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1459                 if (ost->top_field_first == -1)
1460                     big_picture.top_field_first = in_picture->top_field_first;
1461                 else
1462                     big_picture.top_field_first = !!ost->top_field_first;
1463             }
1464
1465             /* handles same_quant here. This is not correct because it may
1466                not be a global option */
1467             big_picture.quality = quality;
1468             if (!enc->me_threshold)
1469                 big_picture.pict_type = 0;
1470 //            big_picture.pts = AV_NOPTS_VALUE;
1471             big_picture.pts = ost->sync_opts;
1472 //            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1473 // av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1474             if (ost->forced_kf_index < ost->forced_kf_count &&
1475                 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1476                 big_picture.pict_type = AV_PICTURE_TYPE_I;
1477                 ost->forced_kf_index++;
1478             }
1479             ret = avcodec_encode_video(enc,
1480                                        bit_buffer, bit_buffer_size,
1481                                        &big_picture);
1482             if (ret < 0) {
1483                 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1484                 exit_program(1);
1485             }
1486
1487             if (ret > 0) {
1488                 pkt.data = bit_buffer;
1489                 pkt.size = ret;
1490                 if (enc->coded_frame->pts != AV_NOPTS_VALUE)
1491                     pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1492 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1493    pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1494    pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1495
1496                 if (enc->coded_frame->key_frame)
1497                     pkt.flags |= AV_PKT_FLAG_KEY;
1498                 write_frame(s, &pkt, ost);
1499                 *frame_size = ret;
1500                 video_size += ret;
1501                 // fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1502                 //         enc->frame_number-1, ret, enc->pict_type);
1503                 /* if two pass, output log */
1504                 if (ost->logfile && enc->stats_out) {
1505                     fprintf(ost->logfile, "%s", enc->stats_out);
1506                 }
1507             }
1508         }
1509         ost->sync_opts++;
1510     }
1511 }
1512
1513 static double psnr(double d)
1514 {
1515     return -10.0 * log(d) / log(10.0);
1516 }
1517
1518 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1519                            int frame_size)
1520 {
1521     AVCodecContext *enc;
1522     int frame_number;
1523     double ti1, bitrate, avg_bitrate;
1524
1525     /* this is executed just the first time do_video_stats is called */
1526     if (!vstats_file) {
1527         vstats_file = fopen(vstats_filename, "w");
1528         if (!vstats_file) {
1529             perror("fopen");
1530             exit_program(1);
1531         }
1532     }
1533
1534     enc = ost->st->codec;
1535     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1536         frame_number = ost->frame_number;
1537         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
1538         if (enc->flags&CODEC_FLAG_PSNR)
1539             fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1540
1541         fprintf(vstats_file,"f_size= %6d ", frame_size);
1542         /* compute pts value */
1543         ti1 = ost->sync_opts * av_q2d(enc->time_base);
1544         if (ti1 < 0.01)
1545             ti1 = 0.01;
1546
1547         bitrate     = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1548         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1549         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1550                (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1551         fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1552     }
1553 }
1554
1555 static void print_report(OutputFile *output_files,
1556                          OutputStream *ost_table, int nb_ostreams,
1557                          int is_last_report, int64_t timer_start)
1558 {
1559     char buf[1024];
1560     OutputStream *ost;
1561     AVFormatContext *oc;
1562     int64_t total_size;
1563     AVCodecContext *enc;
1564     int frame_number, vid, i;
1565     double bitrate;
1566     int64_t pts = INT64_MAX;
1567     static int64_t last_time = -1;
1568     static int qp_histogram[52];
1569     int hours, mins, secs, us;
1570
1571     if (!print_stats && !is_last_report)
1572         return;
1573
1574     if (!is_last_report) {
1575         int64_t cur_time;
1576         /* display the report every 0.5 seconds */
1577         cur_time = av_gettime();
1578         if (last_time == -1) {
1579             last_time = cur_time;
1580             return;
1581         }
1582         if ((cur_time - last_time) < 500000)
1583             return;
1584         last_time = cur_time;
1585     }
1586
1587
1588     oc = output_files[0].ctx;
1589
1590     total_size = avio_size(oc->pb);
1591     if (total_size < 0) // FIXME improve avio_size() so it works with non seekable output too
1592         total_size = avio_tell(oc->pb);
1593
1594     buf[0] = '\0';
1595     vid = 0;
1596     for (i = 0; i < nb_ostreams; i++) {
1597         float q = -1;
1598         ost = &ost_table[i];
1599         enc = ost->st->codec;
1600         if (!ost->stream_copy && enc->coded_frame)
1601             q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
1602         if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1603             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1604         }
1605         if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1606             float t = (av_gettime() - timer_start) / 1000000.0;
1607
1608             frame_number = ost->frame_number;
1609             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1610                      frame_number, (t > 1) ? (int)(frame_number / t + 0.5) : 0, q);
1611             if (is_last_report)
1612                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1613             if (qp_hist) {
1614                 int j;
1615                 int qp = lrintf(q);
1616                 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
1617                     qp_histogram[qp]++;
1618                 for (j = 0; j < 32; j++)
1619                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
1620             }
1621             if (enc->flags&CODEC_FLAG_PSNR) {
1622                 int j;
1623                 double error, error_sum = 0;
1624                 double scale, scale_sum = 0;
1625                 char type[3] = { 'Y','U','V' };
1626                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1627                 for (j = 0; j < 3; j++) {
1628                     if (is_last_report) {
1629                         error = enc->error[j];
1630                         scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
1631                     } else {
1632                         error = enc->coded_frame->error[j];
1633                         scale = enc->width * enc->height * 255.0 * 255.0;
1634                     }
1635                     if (j)
1636                         scale /= 4;
1637                     error_sum += error;
1638                     scale_sum += scale;
1639                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
1640                 }
1641                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
1642             }
1643             vid = 1;
1644         }
1645         /* compute min output value */
1646         pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1647                                       ost->st->time_base, AV_TIME_BASE_Q));
1648     }
1649
1650     secs = pts / AV_TIME_BASE;
1651     us = pts % AV_TIME_BASE;
1652     mins = secs / 60;
1653     secs %= 60;
1654     hours = mins / 60;
1655     mins %= 60;
1656
1657     bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1658
1659     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1660              "size=%8.0fkB time=", total_size / 1024.0);
1661     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1662              "%02d:%02d:%02d.%02d ", hours, mins, secs,
1663              (100 * us) / AV_TIME_BASE);
1664     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1665              "bitrate=%6.1fkbits/s", bitrate);
1666
1667     if (nb_frames_dup || nb_frames_drop)
1668         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1669                 nb_frames_dup, nb_frames_drop);
1670
1671     av_log(NULL, AV_LOG_INFO, "%s    \r", buf);
1672
1673     fflush(stderr);
1674
1675     if (is_last_report) {
1676         int64_t raw= audio_size + video_size + extra_size;
1677         av_log(NULL, AV_LOG_INFO, "\n");
1678         av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1679                video_size / 1024.0,
1680                audio_size / 1024.0,
1681                extra_size / 1024.0,
1682                100.0 * (total_size - raw) / raw
1683         );
1684     }
1685 }
1686
1687 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1688 {
1689     int i, ret;
1690
1691     for (i = 0; i < nb_ostreams; i++) {
1692         OutputStream   *ost = &ost_table[i];
1693         AVCodecContext *enc = ost->st->codec;
1694         AVFormatContext *os = output_files[ost->file_index].ctx;
1695
1696         if (!ost->encoding_needed)
1697             continue;
1698
1699         if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
1700             continue;
1701         if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
1702             continue;
1703
1704         for (;;) {
1705             AVPacket pkt;
1706             int fifo_bytes;
1707             av_init_packet(&pkt);
1708             pkt.stream_index = ost->index;
1709
1710             switch (ost->st->codec->codec_type) {
1711             case AVMEDIA_TYPE_AUDIO:
1712                 fifo_bytes = av_fifo_size(ost->fifo);
1713                 ret = 0;
1714                 /* encode any samples remaining in fifo */
1715                 if (fifo_bytes > 0) {
1716                     int osize = av_get_bytes_per_sample(enc->sample_fmt);
1717                     int fs_tmp = enc->frame_size;
1718
1719                     av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1720                     if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1721                         enc->frame_size = fifo_bytes / (osize * enc->channels);
1722                     } else { /* pad */
1723                         int frame_bytes = enc->frame_size*osize*enc->channels;
1724                         if (allocated_audio_buf_size < frame_bytes)
1725                             exit_program(1);
1726                         generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1727                     }
1728
1729                     ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1730                     pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1731                                               ost->st->time_base.num, enc->sample_rate);
1732                     enc->frame_size = fs_tmp;
1733                 }
1734                 if (ret <= 0) {
1735                     ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1736                 }
1737                 if (ret < 0) {
1738                     av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1739                     exit_program(1);
1740                 }
1741                 audio_size += ret;
1742                 pkt.flags  |= AV_PKT_FLAG_KEY;
1743                 break;
1744             case AVMEDIA_TYPE_VIDEO:
1745                 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1746                 if (ret < 0) {
1747                     av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1748                     exit_program(1);
1749                 }
1750                 video_size += ret;
1751                 if (enc->coded_frame && enc->coded_frame->key_frame)
1752                     pkt.flags |= AV_PKT_FLAG_KEY;
1753                 if (ost->logfile && enc->stats_out) {
1754                     fprintf(ost->logfile, "%s", enc->stats_out);
1755                 }
1756                 break;
1757             default:
1758                 ret = -1;
1759             }
1760
1761             if (ret <= 0)
1762                 break;
1763             pkt.data = bit_buffer;
1764             pkt.size = ret;
1765             if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1766                 pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1767             write_frame(os, &pkt, ost);
1768         }
1769     }
1770 }
1771
1772 /*
1773  * Check whether a packet from ist should be written into ost at this time
1774  */
1775 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1776 {
1777     OutputFile *of = &output_files[ost->file_index];
1778     int ist_index  = ist - input_streams;
1779
1780     if (ost->source_index != ist_index)
1781         return 0;
1782
1783     if (of->start_time && ist->pts < of->start_time)
1784         return 0;
1785
1786     if (of->recording_time != INT64_MAX &&
1787         av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1788                       (AVRational){ 1, 1000000 }) >= 0) {
1789         ost->is_past_recording_time = 1;
1790         return 0;
1791     }
1792
1793     return 1;
1794 }
1795
1796 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1797 {
1798     OutputFile *of = &output_files[ost->file_index];
1799     int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1800     AVPicture pict;
1801     AVPacket opkt;
1802
1803     av_init_packet(&opkt);
1804
1805     if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1806         !ost->copy_initial_nonkeyframes)
1807         return;
1808
1809     /* force the input stream PTS */
1810     if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1811         audio_size += pkt->size;
1812     else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1813         video_size += pkt->size;
1814         ost->sync_opts++;
1815     }
1816
1817     opkt.stream_index = ost->index;
1818     if (pkt->pts != AV_NOPTS_VALUE)
1819         opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1820     else
1821         opkt.pts = AV_NOPTS_VALUE;
1822
1823     if (pkt->dts == AV_NOPTS_VALUE)
1824         opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1825     else
1826         opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1827     opkt.dts -= ost_tb_start_time;
1828
1829     opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1830     opkt.flags    = pkt->flags;
1831
1832     // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1833     if (  ost->st->codec->codec_id != CODEC_ID_H264
1834        && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1835        && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1836        ) {
1837         if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
1838             opkt.destruct = av_destruct_packet;
1839     } else {
1840         opkt.data = pkt->data;
1841         opkt.size = pkt->size;
1842     }
1843     if (of->ctx->oformat->flags & AVFMT_RAWPICTURE) {
1844         /* store AVPicture in AVPacket, as expected by the output format */
1845         avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1846         opkt.data = (uint8_t *)&pict;
1847         opkt.size = sizeof(AVPicture);
1848         opkt.flags |= AV_PKT_FLAG_KEY;
1849     }
1850
1851     write_frame(of->ctx, &opkt, ost);
1852     ost->st->codec->frame_number++;
1853     av_free_packet(&opkt);
1854 }
1855
1856 static void rate_emu_sleep(InputStream *ist)
1857 {
1858     if (input_files[ist->file_index].rate_emu) {
1859         int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1860         int64_t now = av_gettime() - ist->start;
1861         if (pts > now)
1862             usleep(pts - now);
1863     }
1864 }
1865
1866 static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1867 {
1868     AVFrame *decoded_frame;
1869     AVCodecContext *avctx = ist->st->codec;
1870     int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1871     int i, ret;
1872
1873     if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1874         return AVERROR(ENOMEM);
1875     else
1876         avcodec_get_frame_defaults(ist->decoded_frame);
1877     decoded_frame = ist->decoded_frame;
1878
1879     ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1880     if (ret < 0) {
1881         return ret;
1882     }
1883
1884     if (!*got_output) {
1885         /* no audio frame */
1886         return ret;
1887     }
1888
1889     /* if the decoder provides a pts, use it instead of the last packet pts.
1890        the decoder could be delaying output by a packet or more. */
1891     if (decoded_frame->pts != AV_NOPTS_VALUE)
1892         ist->next_pts = decoded_frame->pts;
1893
1894     /* increment next_pts to use for the case where the input stream does not
1895        have timestamps or there are multiple frames in the packet */
1896     ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
1897                      avctx->sample_rate;
1898
1899     // preprocess audio (volume)
1900     if (audio_volume != 256) {
1901         int decoded_data_size = decoded_frame->nb_samples * avctx->channels * bps;
1902         void *samples = decoded_frame->data[0];
1903         switch (avctx->sample_fmt) {
1904         case AV_SAMPLE_FMT_U8:
1905         {
1906             uint8_t *volp = samples;
1907             for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1908                 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1909                 *volp++ = av_clip_uint8(v);
1910             }
1911             break;
1912         }
1913         case AV_SAMPLE_FMT_S16:
1914         {
1915             int16_t *volp = samples;
1916             for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1917                 int v = ((*volp) * audio_volume + 128) >> 8;
1918                 *volp++ = av_clip_int16(v);
1919             }
1920             break;
1921         }
1922         case AV_SAMPLE_FMT_S32:
1923         {
1924             int32_t *volp = samples;
1925             for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1926                 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1927                 *volp++ = av_clipl_int32(v);
1928             }
1929             break;
1930         }
1931         case AV_SAMPLE_FMT_FLT:
1932         {
1933             float *volp = samples;
1934             float scale = audio_volume / 256.f;
1935             for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1936                 *volp++ *= scale;
1937             }
1938             break;
1939         }
1940         case AV_SAMPLE_FMT_DBL:
1941         {
1942             double *volp = samples;
1943             double scale = audio_volume / 256.;
1944             for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1945                 *volp++ *= scale;
1946             }
1947             break;
1948         }
1949         default:
1950             av_log(NULL, AV_LOG_FATAL,
1951                    "Audio volume adjustment on sample format %s is not supported.\n",
1952                    av_get_sample_fmt_name(ist->st->codec->sample_fmt));
1953             exit_program(1);
1954         }
1955     }
1956
1957     rate_emu_sleep(ist);
1958
1959     for (i = 0; i < nb_output_streams; i++) {
1960         OutputStream *ost = &output_streams[i];
1961
1962         if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1963             continue;
1964         do_audio_out(output_files[ost->file_index].ctx, ost, ist, decoded_frame);
1965     }
1966
1967     return ret;
1968 }
1969
1970 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts)
1971 {
1972     AVFrame *decoded_frame, *filtered_frame = NULL;
1973     void *buffer_to_free = NULL;
1974     int i, ret = 0;
1975     float quality;
1976 #if CONFIG_AVFILTER
1977     int frame_available = 1;
1978 #endif
1979
1980     if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1981         return AVERROR(ENOMEM);
1982     else
1983         avcodec_get_frame_defaults(ist->decoded_frame);
1984     decoded_frame = ist->decoded_frame;
1985     pkt->pts  = *pkt_pts;
1986     pkt->dts  = ist->pts;
1987     *pkt_pts  = AV_NOPTS_VALUE;
1988
1989     ret = avcodec_decode_video2(ist->st->codec,
1990                                 decoded_frame, got_output, pkt);
1991     if (ret < 0)
1992         return ret;
1993
1994     quality = same_quant ? decoded_frame->quality : 0;
1995     if (!*got_output) {
1996         /* no picture yet */
1997         return ret;
1998     }
1999     ist->next_pts = ist->pts = decoded_frame->best_effort_timestamp;
2000     if (pkt->duration)
2001         ist->next_pts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2002     else if (ist->st->codec->time_base.num != 0) {
2003         int ticks      = ist->st->parser ? ist->st->parser->repeat_pict + 1 :
2004                                            ist->st->codec->ticks_per_frame;
2005         ist->next_pts += ((int64_t)AV_TIME_BASE *
2006                           ist->st->codec->time_base.num * ticks) /
2007                           ist->st->codec->time_base.den;
2008     }
2009     pkt->size = 0;
2010     pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
2011
2012     rate_emu_sleep(ist);
2013
2014     for (i = 0; i < nb_output_streams; i++) {
2015         OutputStream *ost = &output_streams[i];
2016         int frame_size, resample_changed;
2017
2018         if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2019             continue;
2020
2021 #if CONFIG_AVFILTER
2022         resample_changed = ost->resample_width   != decoded_frame->width  ||
2023                            ost->resample_height  != decoded_frame->height ||
2024                            ost->resample_pix_fmt != decoded_frame->format;
2025         if (resample_changed) {
2026             av_log(NULL, AV_LOG_INFO,
2027                     "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
2028                     ist->file_index, ist->st->index,
2029                     ost->resample_width,  ost->resample_height,  av_get_pix_fmt_name(ost->resample_pix_fmt),
2030                     decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
2031
2032             avfilter_graph_free(&ost->graph);
2033             if (configure_video_filters(ist, ost)) {
2034                 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2035                 exit_program(1);
2036             }
2037
2038             ost->resample_width   = decoded_frame->width;
2039             ost->resample_height  = decoded_frame->height;
2040             ost->resample_pix_fmt = decoded_frame->format;
2041         }
2042
2043         if (!decoded_frame->sample_aspect_ratio.num)
2044             decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2045         decoded_frame->pts = ist->pts;
2046         if (ist->st->codec->codec->capabilities & CODEC_CAP_DR1) {
2047             FrameBuffer      *buf = decoded_frame->opaque;
2048             AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2049                                         decoded_frame->data, decoded_frame->linesize,
2050                                         AV_PERM_READ | AV_PERM_PRESERVE,
2051                                         ist->st->codec->width, ist->st->codec->height,
2052                                         ist->st->codec->pix_fmt);
2053
2054             avfilter_copy_frame_props(fb, decoded_frame);
2055             fb->pts                 = ist->pts;
2056             fb->buf->priv           = buf;
2057             fb->buf->free           = filter_release_buffer;
2058
2059             buf->refcount++;
2060             av_buffersrc_buffer(ost->input_video_filter, fb);
2061         } else
2062             av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, AV_VSRC_BUF_FLAG_OVERWRITE);
2063
2064         if (!ist->filtered_frame && !(ist->filtered_frame = avcodec_alloc_frame())) {
2065             av_free(buffer_to_free);
2066             return AVERROR(ENOMEM);
2067         } else
2068             avcodec_get_frame_defaults(ist->filtered_frame);
2069         filtered_frame = ist->filtered_frame;
2070
2071         frame_available = avfilter_poll_frame(ost->output_video_filter->inputs[0]);
2072         while (frame_available) {
2073             if (ost->output_video_filter) {
2074                 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
2075                 if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
2076                     goto cont;
2077                 if (ost->picref) {
2078                     avfilter_fill_frame_from_video_buffer_ref(filtered_frame, ost->picref);
2079                     ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
2080                 }
2081             }
2082             if (ost->picref->video && !ost->frame_aspect_ratio)
2083                 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
2084 #else
2085             filtered_frame = decoded_frame;
2086 #endif
2087
2088             do_video_out(output_files[ost->file_index].ctx, ost, ist, filtered_frame, &frame_size,
2089                          same_quant ? quality : ost->st->codec->global_quality);
2090             if (vstats_filename && frame_size)
2091                 do_video_stats(output_files[ost->file_index].ctx, ost, frame_size);
2092 #if CONFIG_AVFILTER
2093             cont:
2094             frame_available = ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
2095             if (ost->picref)
2096                 avfilter_unref_buffer(ost->picref);
2097         }
2098 #endif
2099     }
2100
2101     av_free(buffer_to_free);
2102     return ret;
2103 }
2104
2105 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2106 {
2107     AVSubtitle subtitle;
2108     int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2109                                           &subtitle, got_output, pkt);
2110     if (ret < 0)
2111         return ret;
2112     if (!*got_output)
2113         return ret;
2114
2115     rate_emu_sleep(ist);
2116
2117     for (i = 0; i < nb_output_streams; i++) {
2118         OutputStream *ost = &output_streams[i];
2119
2120         if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2121             continue;
2122
2123         do_subtitle_out(output_files[ost->file_index].ctx, ost, ist, &subtitle, pkt->pts);
2124     }
2125
2126     avsubtitle_free(&subtitle);
2127     return ret;
2128 }
2129
2130 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2131 static int output_packet(InputStream *ist,
2132                          OutputStream *ost_table, int nb_ostreams,
2133                          const AVPacket *pkt)
2134 {
2135     int i;
2136     int got_output;
2137     int64_t pkt_pts = AV_NOPTS_VALUE;
2138     AVPacket avpkt;
2139
2140     if (ist->next_pts == AV_NOPTS_VALUE)
2141         ist->next_pts = ist->pts;
2142
2143     if (pkt == NULL) {
2144         /* EOF handling */
2145         av_init_packet(&avpkt);
2146         avpkt.data = NULL;
2147         avpkt.size = 0;
2148         goto handle_eof;
2149     } else {
2150         avpkt = *pkt;
2151     }
2152
2153     if (pkt->dts != AV_NOPTS_VALUE)
2154         ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2155     if (pkt->pts != AV_NOPTS_VALUE)
2156         pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2157
2158     // while we have more to decode or while the decoder did output something on EOF
2159     while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2160         int ret = 0;
2161     handle_eof:
2162
2163         ist->pts = ist->next_pts;
2164
2165         if (avpkt.size && avpkt.size != pkt->size) {
2166             av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2167                    "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2168             ist->showed_multi_packet_warning = 1;
2169         }
2170
2171         switch (ist->st->codec->codec_type) {
2172         case AVMEDIA_TYPE_AUDIO:
2173             ret = transcode_audio    (ist, &avpkt, &got_output);
2174             break;
2175         case AVMEDIA_TYPE_VIDEO:
2176             ret = transcode_video    (ist, &avpkt, &got_output, &pkt_pts);
2177             break;
2178         case AVMEDIA_TYPE_SUBTITLE:
2179             ret = transcode_subtitles(ist, &avpkt, &got_output);
2180             break;
2181         default:
2182             return -1;
2183         }
2184
2185         if (ret < 0)
2186             return ret;
2187         // touch data and size only if not EOF
2188         if (pkt) {
2189             avpkt.data += ret;
2190             avpkt.size -= ret;
2191         }
2192         if (!got_output) {
2193             continue;
2194         }
2195     }
2196
2197     /* handle stream copy */
2198     if (!ist->decoding_needed) {
2199         rate_emu_sleep(ist);
2200         ist->pts = ist->next_pts;
2201         switch (ist->st->codec->codec_type) {
2202         case AVMEDIA_TYPE_AUDIO:
2203             ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2204                              ist->st->codec->sample_rate;
2205             break;
2206         case AVMEDIA_TYPE_VIDEO:
2207             if (ist->st->codec->time_base.num != 0) {
2208                 int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2209                 ist->next_pts += ((int64_t)AV_TIME_BASE *
2210                                   ist->st->codec->time_base.num * ticks) /
2211                                   ist->st->codec->time_base.den;
2212             }
2213             break;
2214         }
2215     }
2216     for (i = 0; pkt && i < nb_ostreams; i++) {
2217         OutputStream *ost = &ost_table[i];
2218
2219         if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2220             continue;
2221
2222         do_streamcopy(ist, ost, pkt);
2223     }
2224
2225     return 0;
2226 }
2227
2228 static void print_sdp(OutputFile *output_files, int n)
2229 {
2230     char sdp[2048];
2231     int i;
2232     AVFormatContext **avc = av_malloc(sizeof(*avc) * n);
2233
2234     if (!avc)
2235         exit_program(1);
2236     for (i = 0; i < n; i++)
2237         avc[i] = output_files[i].ctx;
2238
2239     av_sdp_create(avc, n, sdp, sizeof(sdp));
2240     printf("SDP:\n%s\n", sdp);
2241     fflush(stdout);
2242     av_freep(&avc);
2243 }
2244
2245 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
2246                              char *error, int error_len)
2247 {
2248     int i;
2249     InputStream *ist = &input_streams[ist_index];
2250     if (ist->decoding_needed) {
2251         AVCodec *codec = ist->dec;
2252         if (!codec) {
2253             snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d:%d",
2254                     ist->st->codec->codec_id, ist->file_index, ist->st->index);
2255             return AVERROR(EINVAL);
2256         }
2257
2258         if (codec->type == AVMEDIA_TYPE_VIDEO && codec->capabilities & CODEC_CAP_DR1) {
2259             ist->st->codec->get_buffer     = codec_get_buffer;
2260             ist->st->codec->release_buffer = codec_release_buffer;
2261             ist->st->codec->opaque         = ist;
2262         }
2263
2264         if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2265             snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2266                     ist->file_index, ist->st->index);
2267             return AVERROR(EINVAL);
2268         }
2269         assert_codec_experimental(ist->st->codec, 0);
2270         assert_avoptions(ist->opts);
2271     }
2272
2273     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;
2274     ist->next_pts = AV_NOPTS_VALUE;
2275     ist->is_start = 1;
2276
2277     return 0;
2278 }
2279
2280 static int transcode_init(OutputFile *output_files,
2281                           int nb_output_files,
2282                           InputFile *input_files,
2283                           int nb_input_files)
2284 {
2285     int ret = 0, i, j, k;
2286     AVFormatContext *oc;
2287     AVCodecContext *codec, *icodec;
2288     OutputStream *ost;
2289     InputStream *ist;
2290     char error[1024];
2291     int want_sdp = 1;
2292
2293     /* init framerate emulation */
2294     for (i = 0; i < nb_input_files; i++) {
2295         InputFile *ifile = &input_files[i];
2296         if (ifile->rate_emu)
2297             for (j = 0; j < ifile->nb_streams; j++)
2298                 input_streams[j + ifile->ist_index].start = av_gettime();
2299     }
2300
2301     /* output stream init */
2302     for (i = 0; i < nb_output_files; i++) {
2303         oc = output_files[i].ctx;
2304         if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2305             av_dump_format(oc, i, oc->filename, 1);
2306             av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2307             return AVERROR(EINVAL);
2308         }
2309     }
2310
2311     /* for each output stream, we compute the right encoding parameters */
2312     for (i = 0; i < nb_output_streams; i++) {
2313         ost = &output_streams[i];
2314         oc  = output_files[ost->file_index].ctx;
2315         ist = &input_streams[ost->source_index];
2316
2317         if (ost->attachment_filename)
2318             continue;
2319
2320         codec  = ost->st->codec;
2321         icodec = ist->st->codec;
2322
2323         ost->st->disposition          = ist->st->disposition;
2324         codec->bits_per_raw_sample    = icodec->bits_per_raw_sample;
2325         codec->chroma_sample_location = icodec->chroma_sample_location;
2326
2327         if (ost->stream_copy) {
2328             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2329
2330             if (extra_size > INT_MAX) {
2331                 return AVERROR(EINVAL);
2332             }
2333
2334             /* if stream_copy is selected, no need to decode or encode */
2335             codec->codec_id   = icodec->codec_id;
2336             codec->codec_type = icodec->codec_type;
2337
2338             if (!codec->codec_tag) {
2339                 if (!oc->oformat->codec_tag ||
2340                      av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2341                      av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2342                     codec->codec_tag = icodec->codec_tag;
2343             }
2344
2345             codec->bit_rate       = icodec->bit_rate;
2346             codec->rc_max_rate    = icodec->rc_max_rate;
2347             codec->rc_buffer_size = icodec->rc_buffer_size;
2348             codec->field_order    = icodec->field_order;
2349             codec->extradata      = av_mallocz(extra_size);
2350             if (!codec->extradata) {
2351                 return AVERROR(ENOMEM);
2352             }
2353             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2354
2355             codec->extradata_size = icodec->extradata_size;
2356             if (!copy_tb) {
2357                 codec->time_base      = icodec->time_base;
2358                 codec->time_base.num *= icodec->ticks_per_frame;
2359                 av_reduce(&codec->time_base.num, &codec->time_base.den,
2360                           codec->time_base.num, codec->time_base.den, INT_MAX);
2361             } else
2362                 codec->time_base = ist->st->time_base;
2363
2364             switch (codec->codec_type) {
2365             case AVMEDIA_TYPE_AUDIO:
2366                 if (audio_volume != 256) {
2367                     av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2368                     exit_program(1);
2369                 }
2370                 codec->channel_layout     = icodec->channel_layout;
2371                 codec->sample_rate        = icodec->sample_rate;
2372                 codec->channels           = icodec->channels;
2373                 codec->frame_size         = icodec->frame_size;
2374                 codec->audio_service_type = icodec->audio_service_type;
2375                 codec->block_align        = icodec->block_align;
2376                 break;
2377             case AVMEDIA_TYPE_VIDEO:
2378                 codec->pix_fmt            = icodec->pix_fmt;
2379                 codec->width              = icodec->width;
2380                 codec->height             = icodec->height;
2381                 codec->has_b_frames       = icodec->has_b_frames;
2382                 if (!codec->sample_aspect_ratio.num) {
2383                     codec->sample_aspect_ratio   =
2384                     ost->st->sample_aspect_ratio =
2385                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2386                         ist->st->codec->sample_aspect_ratio.num ?
2387                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2388                 }
2389                 break;
2390             case AVMEDIA_TYPE_SUBTITLE:
2391                 codec->width  = icodec->width;
2392                 codec->height = icodec->height;
2393                 break;
2394             case AVMEDIA_TYPE_DATA:
2395             case AVMEDIA_TYPE_ATTACHMENT:
2396                 break;
2397             default:
2398                 abort();
2399             }
2400         } else {
2401             if (!ost->enc)
2402                 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2403
2404             ist->decoding_needed = 1;
2405             ost->encoding_needed = 1;
2406
2407             switch (codec->codec_type) {
2408             case AVMEDIA_TYPE_AUDIO:
2409                 ost->fifo = av_fifo_alloc(1024);
2410                 if (!ost->fifo) {
2411                     return AVERROR(ENOMEM);
2412                 }
2413                 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2414
2415                 if (!codec->sample_rate)
2416                     codec->sample_rate = icodec->sample_rate;
2417                 choose_sample_rate(ost->st, ost->enc);
2418                 codec->time_base = (AVRational){ 1, codec->sample_rate };
2419
2420                 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2421                     codec->sample_fmt = icodec->sample_fmt;
2422                 choose_sample_fmt(ost->st, ost->enc);
2423
2424                 if (!codec->channels) {
2425                     codec->channels = icodec->channels;
2426                     codec->channel_layout = icodec->channel_layout;
2427                 }
2428                 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2429                     codec->channel_layout = 0;
2430
2431                 ost->audio_resample       = codec-> sample_rate != icodec->sample_rate || audio_sync_method > 1;
2432                 icodec->request_channels  = codec-> channels;
2433                 ost->resample_sample_fmt  = icodec->sample_fmt;
2434                 ost->resample_sample_rate = icodec->sample_rate;
2435                 ost->resample_channels    = icodec->channels;
2436                 break;
2437             case AVMEDIA_TYPE_VIDEO:
2438                 if (codec->pix_fmt == PIX_FMT_NONE)
2439                     codec->pix_fmt = icodec->pix_fmt;
2440                 choose_pixel_fmt(ost->st, ost->enc);
2441
2442                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2443                     av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2444                     exit_program(1);
2445                 }
2446
2447                 if (!codec->width || !codec->height) {
2448                     codec->width  = icodec->width;
2449                     codec->height = icodec->height;
2450                 }
2451
2452                 ost->video_resample = codec->width   != icodec->width  ||
2453                                       codec->height  != icodec->height ||
2454                                       codec->pix_fmt != icodec->pix_fmt;
2455                 if (ost->video_resample) {
2456                     codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2457                 }
2458
2459                 ost->resample_height  = icodec->height;
2460                 ost->resample_width   = icodec->width;
2461                 ost->resample_pix_fmt = icodec->pix_fmt;
2462
2463                 if (!ost->frame_rate.num)
2464                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational) { 25, 1 };
2465                 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2466                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2467                     ost->frame_rate = ost->enc->supported_framerates[idx];
2468                 }
2469                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2470                 if(   av_q2d(codec->time_base) < 0.001 && video_sync_method
2471                    && (video_sync_method==1 || (video_sync_method<0 && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
2472                     av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2473                                                "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2474                 }
2475
2476 #if CONFIG_AVFILTER
2477                 if (configure_video_filters(ist, ost)) {
2478                     av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2479                     exit(1);
2480                 }
2481 #endif
2482                 break;
2483             case AVMEDIA_TYPE_SUBTITLE:
2484                 break;
2485             default:
2486                 abort();
2487                 break;
2488             }
2489             /* two pass mode */
2490             if (codec->codec_id != CODEC_ID_H264 &&
2491                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2492                 char logfilename[1024];
2493                 FILE *f;
2494
2495                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2496                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2497                          i);
2498                 if (codec->flags & CODEC_FLAG_PASS1) {
2499                     f = fopen(logfilename, "wb");
2500                     if (!f) {
2501                         av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2502                                logfilename, strerror(errno));
2503                         exit_program(1);
2504                     }
2505                     ost->logfile = f;
2506                 } else {
2507                     char  *logbuffer;
2508                     size_t logbuffer_size;
2509                     if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2510                         av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2511                                logfilename);
2512                         exit_program(1);
2513                     }
2514                     codec->stats_in = logbuffer;
2515                 }
2516             }
2517         }
2518         if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2519             /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2520             int        size = codec->width * codec->height;
2521             bit_buffer_size = FFMAX(bit_buffer_size, 6 * size + 1664);
2522         }
2523     }
2524
2525     if (!bit_buffer)
2526         bit_buffer = av_malloc(bit_buffer_size);
2527     if (!bit_buffer) {
2528         av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2529                bit_buffer_size);
2530         return AVERROR(ENOMEM);
2531     }
2532
2533     /* open each encoder */
2534     for (i = 0; i < nb_output_streams; i++) {
2535         ost = &output_streams[i];
2536         if (ost->encoding_needed) {
2537             AVCodec      *codec = ost->enc;
2538             AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2539             if (!codec) {
2540                 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d:%d",
2541                          ost->st->codec->codec_id, ost->file_index, ost->index);
2542                 ret = AVERROR(EINVAL);
2543                 goto dump_format;
2544             }
2545             if (dec->subtitle_header) {
2546                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2547                 if (!ost->st->codec->subtitle_header) {
2548                     ret = AVERROR(ENOMEM);
2549                     goto dump_format;
2550                 }
2551                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2552                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2553             }
2554             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2555                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2556                         ost->file_index, ost->index);
2557                 ret = AVERROR(EINVAL);
2558                 goto dump_format;
2559             }
2560             assert_codec_experimental(ost->st->codec, 1);
2561             assert_avoptions(ost->opts);
2562             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2563                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2564                                              "It takes bits/s as argument, not kbits/s\n");
2565             extra_size += ost->st->codec->extradata_size;
2566
2567             if (ost->st->codec->me_threshold)
2568                 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2569         }
2570     }
2571
2572     /* init input streams */
2573     for (i = 0; i < nb_input_streams; i++)
2574         if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2575             goto dump_format;
2576
2577     /* discard unused programs */
2578     for (i = 0; i < nb_input_files; i++) {
2579         InputFile *ifile = &input_files[i];
2580         for (j = 0; j < ifile->ctx->nb_programs; j++) {
2581             AVProgram *p = ifile->ctx->programs[j];
2582             int discard  = AVDISCARD_ALL;
2583
2584             for (k = 0; k < p->nb_stream_indexes; k++)
2585                 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2586                     discard = AVDISCARD_DEFAULT;
2587                     break;
2588                 }
2589             p->discard = discard;
2590         }
2591     }
2592
2593     /* open files and write file headers */
2594     for (i = 0; i < nb_output_files; i++) {
2595         oc = output_files[i].ctx;
2596         oc->interrupt_callback = int_cb;
2597         if (avformat_write_header(oc, &output_files[i].opts) < 0) {
2598             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2599             ret = AVERROR(EINVAL);
2600             goto dump_format;
2601         }
2602 //        assert_avoptions(output_files[i].opts);
2603         if (strcmp(oc->oformat->name, "rtp")) {
2604             want_sdp = 0;
2605         }
2606     }
2607
2608  dump_format:
2609     /* dump the file output parameters - cannot be done before in case
2610        of stream copy */
2611     for (i = 0; i < nb_output_files; i++) {
2612         av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2613     }
2614
2615     /* dump the stream mapping */
2616     av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2617     for (i = 0; i < nb_output_streams; i++) {
2618         ost = &output_streams[i];
2619
2620         if (ost->attachment_filename) {
2621             /* an attached file */
2622             av_log(NULL, AV_LOG_INFO, "  File %s -> Stream #%d:%d\n",
2623                    ost->attachment_filename, ost->file_index, ost->index);
2624             continue;
2625         }
2626         av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d -> #%d:%d",
2627                input_streams[ost->source_index].file_index,
2628                input_streams[ost->source_index].st->index,
2629                ost->file_index,
2630                ost->index);
2631         if (ost->sync_ist != &input_streams[ost->source_index])
2632             av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2633                    ost->sync_ist->file_index,
2634                    ost->sync_ist->st->index);
2635         if (ost->stream_copy)
2636             av_log(NULL, AV_LOG_INFO, " (copy)");
2637         else
2638             av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2639                    input_streams[ost->source_index].dec->name : "?",
2640                    ost->enc ? ost->enc->name : "?");
2641         av_log(NULL, AV_LOG_INFO, "\n");
2642     }
2643
2644     if (ret) {
2645         av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2646         return ret;
2647     }
2648
2649     if (want_sdp) {
2650         print_sdp(output_files, nb_output_files);
2651     }
2652
2653     return 0;
2654 }
2655
2656 /*
2657  * The following code is the main loop of the file converter
2658  */
2659 static int transcode(OutputFile *output_files,
2660                      int nb_output_files,
2661                      InputFile *input_files,
2662                      int nb_input_files)
2663 {
2664     int ret, i;
2665     AVFormatContext *is, *os;
2666     OutputStream *ost;
2667     InputStream *ist;
2668     uint8_t *no_packet;
2669     int no_packet_count = 0;
2670     int64_t timer_start;
2671     int key;
2672
2673     if (!(no_packet = av_mallocz(nb_input_files)))
2674         exit_program(1);
2675
2676     ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2677     if (ret < 0)
2678         goto fail;
2679
2680     if (!using_stdin) {
2681         av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2682         avio_set_interrupt_cb(decode_interrupt_cb);
2683     }
2684     term_init();
2685
2686     timer_start = av_gettime();
2687
2688     for (; received_sigterm == 0;) {
2689         int file_index, ist_index;
2690         AVPacket pkt;
2691         int64_t ipts_min;
2692         double opts_min;
2693
2694         ipts_min = INT64_MAX;
2695         opts_min = 1e100;
2696         /* if 'q' pressed, exits */
2697         if (!using_stdin) {
2698             if (q_pressed)
2699                 break;
2700             /* read_key() returns 0 on EOF */
2701             key = read_key();
2702             if (key == 'q')
2703                 break;
2704             if (key == '+') av_log_set_level(av_log_get_level()+10);
2705             if (key == '-') av_log_set_level(av_log_get_level()-10);
2706             if (key == 's') qp_hist     ^= 1;
2707             if (key == 'h'){
2708                 if (do_hex_dump){
2709                     do_hex_dump = do_pkt_dump = 0;
2710                 } else if(do_pkt_dump){
2711                     do_hex_dump = 1;
2712                 } else
2713                     do_pkt_dump = 1;
2714                 av_log_set_level(AV_LOG_DEBUG);
2715             }
2716             if (key == 'd' || key == 'D'){
2717                 int debug=0;
2718                 if(key == 'D') {
2719                     debug = input_streams[0].st->codec->debug<<1;
2720                     if(!debug) debug = 1;
2721                     while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2722                         debug += debug;
2723                 }else
2724                     scanf("%d", &debug);
2725                 for(i=0;i<nb_input_streams;i++) {
2726                     input_streams[i].st->codec->debug = debug;
2727                 }
2728                 for(i=0;i<nb_output_streams;i++) {
2729                     ost = &output_streams[i];
2730                     ost->st->codec->debug = debug;
2731                 }
2732                 if(debug) av_log_set_level(AV_LOG_DEBUG);
2733                 fprintf(stderr,"debug=%d\n", debug);
2734             }
2735             if (key == '?'){
2736                 fprintf(stderr, "key    function\n"
2737                                 "?      show this help\n"
2738                                 "+      increase verbosity\n"
2739                                 "-      decrease verbosity\n"
2740                                 "D      cycle through available debug modes\n"
2741                                 "h      dump packets/hex press to cycle through the 3 states\n"
2742                                 "q      quit\n"
2743                                 "s      Show QP histogram\n"
2744                 );
2745             }
2746         }
2747
2748         /* select the stream that we must read now by looking at the
2749            smallest output pts */
2750         file_index = -1;
2751         for (i = 0; i < nb_output_streams; i++) {
2752             OutputFile *of;
2753             int64_t ipts;
2754             double  opts;
2755             ost = &output_streams[i];
2756             of = &output_files[ost->file_index];
2757             os = output_files[ost->file_index].ctx;
2758             ist = &input_streams[ost->source_index];
2759             if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2760                 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2761                 continue;
2762             opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2763             ipts = ist->pts;
2764             if (!input_files[ist->file_index].eof_reached) {
2765                 if (ipts < ipts_min) {
2766                     ipts_min = ipts;
2767                     if (input_sync)
2768                         file_index = ist->file_index;
2769                 }
2770                 if (opts < opts_min) {
2771                     opts_min = opts;
2772                     if (!input_sync) file_index = ist->file_index;
2773                 }
2774             }
2775             if (ost->frame_number >= ost->max_frames) {
2776                 int j;
2777                 for (j = 0; j < of->ctx->nb_streams; j++)
2778                     output_streams[of->ost_index + j].is_past_recording_time = 1;
2779                 continue;
2780             }
2781         }
2782         /* if none, if is finished */
2783         if (file_index < 0) {
2784             if (no_packet_count) {
2785                 no_packet_count = 0;
2786                 memset(no_packet, 0, nb_input_files);
2787                 usleep(10000);
2788                 continue;
2789             }
2790             break;
2791         }
2792
2793         /* read a frame from it and output it in the fifo */
2794         is  = input_files[file_index].ctx;
2795         ret = av_read_frame(is, &pkt);
2796         if (ret == AVERROR(EAGAIN)) {
2797             no_packet[file_index] = 1;
2798             no_packet_count++;
2799             continue;
2800         }
2801         if (ret < 0) {
2802             input_files[file_index].eof_reached = 1;
2803             if (opt_shortest)
2804                 break;
2805             else
2806                 continue;
2807         }
2808
2809         no_packet_count = 0;
2810         memset(no_packet, 0, nb_input_files);
2811
2812         if (do_pkt_dump) {
2813             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2814                              is->streams[pkt.stream_index]);
2815         }
2816         /* the following test is needed in case new streams appear
2817            dynamically in stream : we ignore them */
2818         if (pkt.stream_index >= input_files[file_index].nb_streams)
2819             goto discard_packet;
2820         ist_index = input_files[file_index].ist_index + pkt.stream_index;
2821         ist = &input_streams[ist_index];
2822         if (ist->discard)
2823             goto discard_packet;
2824
2825         if (pkt.dts != AV_NOPTS_VALUE)
2826             pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2827         if (pkt.pts != AV_NOPTS_VALUE)
2828             pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2829
2830         if (pkt.pts != AV_NOPTS_VALUE)
2831             pkt.pts *= ist->ts_scale;
2832         if (pkt.dts != AV_NOPTS_VALUE)
2833             pkt.dts *= ist->ts_scale;
2834
2835         //fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n",
2836         //        ist->next_pts,
2837         //        pkt.dts, input_files[ist->file_index].ts_offset,
2838         //        ist->st->codec->codec_type);
2839         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2840             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2841             int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2842             int64_t delta   = pkt_dts - ist->next_pts;
2843             if ((FFABS(delta) > 1LL * dts_delta_threshold * AV_TIME_BASE || pkt_dts + 1 < ist->pts) && !copy_ts) {
2844                 input_files[ist->file_index].ts_offset -= delta;
2845                 av_log(NULL, AV_LOG_DEBUG,
2846                        "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2847                        delta, input_files[ist->file_index].ts_offset);
2848                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2849                 if (pkt.pts != AV_NOPTS_VALUE)
2850                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2851             }
2852         }
2853
2854         // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2855         if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {
2856
2857             av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
2858                    ist->file_index, ist->st->index);
2859             if (exit_on_error)
2860                 exit_program(1);
2861             av_free_packet(&pkt);
2862             continue;
2863         }
2864
2865     discard_packet:
2866         av_free_packet(&pkt);
2867
2868         /* dump report by using the output first video and audio streams */
2869         print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2870     }
2871
2872     /* at the end of stream, we must flush the decoder buffers */
2873     for (i = 0; i < nb_input_streams; i++) {
2874         ist = &input_streams[i];
2875         if (ist->decoding_needed) {
2876             output_packet(ist, output_streams, nb_output_streams, NULL);
2877         }
2878     }
2879     flush_encoders(output_streams, nb_output_streams);
2880
2881     term_exit();
2882
2883     /* write the trailer if needed and close file */
2884     for (i = 0; i < nb_output_files; i++) {
2885         os = output_files[i].ctx;
2886         av_write_trailer(os);
2887     }
2888
2889     /* dump report by using the first video and audio streams */
2890     print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2891
2892     /* close each encoder */
2893     for (i = 0; i < nb_output_streams; i++) {
2894         ost = &output_streams[i];
2895         if (ost->encoding_needed) {
2896             av_freep(&ost->st->codec->stats_in);
2897             avcodec_close(ost->st->codec);
2898         }
2899 #if CONFIG_AVFILTER
2900         avfilter_graph_free(&ost->graph);
2901 #endif
2902     }
2903
2904     /* close each decoder */
2905     for (i = 0; i < nb_input_streams; i++) {
2906         ist = &input_streams[i];
2907         if (ist->decoding_needed) {
2908             avcodec_close(ist->st->codec);
2909         }
2910     }
2911
2912     /* finished ! */
2913     ret = 0;
2914
2915  fail:
2916     av_freep(&bit_buffer);
2917     av_freep(&no_packet);
2918
2919     if (output_streams) {
2920         for (i = 0; i < nb_output_streams; i++) {
2921             ost = &output_streams[i];
2922             if (ost) {
2923                 if (ost->stream_copy)
2924                     av_freep(&ost->st->codec->extradata);
2925                 if (ost->logfile) {
2926                     fclose(ost->logfile);
2927                     ost->logfile = NULL;
2928                 }
2929                 av_fifo_free(ost->fifo); /* works even if fifo is not
2930                                              initialized but set to zero */
2931                 av_freep(&ost->st->codec->subtitle_header);
2932                 av_free(ost->resample_frame.data[0]);
2933                 av_free(ost->forced_kf_pts);
2934                 if (ost->video_resample)
2935                     sws_freeContext(ost->img_resample_ctx);
2936                 if (ost->resample)
2937                     audio_resample_close(ost->resample);
2938                 if (ost->reformat_ctx)
2939                     av_audio_convert_free(ost->reformat_ctx);
2940                 av_dict_free(&ost->opts);
2941             }
2942         }
2943     }
2944     return ret;
2945 }
2946
2947 static double parse_frame_aspect_ratio(const char *arg)
2948 {
2949     int x = 0, y = 0;
2950     double ar = 0;
2951     const char *p;
2952     char *end;
2953
2954     p = strchr(arg, ':');
2955     if (p) {
2956         x = strtol(arg, &end, 10);
2957         if (end == p)
2958             y = strtol(end + 1, &end, 10);
2959         if (x > 0 && y > 0)
2960             ar = (double)x / (double)y;
2961     } else
2962         ar = strtod(arg, NULL);
2963
2964     if (!ar) {
2965         av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2966         exit_program(1);
2967     }
2968     return ar;
2969 }
2970
2971 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2972 {
2973     return parse_option(o, "codec:a", arg, options);
2974 }
2975
2976 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2977 {
2978     return parse_option(o, "codec:v", arg, options);
2979 }
2980
2981 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2982 {
2983     return parse_option(o, "codec:s", arg, options);
2984 }
2985
2986 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2987 {
2988     return parse_option(o, "codec:d", arg, options);
2989 }
2990
2991 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2992 {
2993     StreamMap *m = NULL;
2994     int i, negative = 0, file_idx;
2995     int sync_file_idx = -1, sync_stream_idx;
2996     char *p, *sync;
2997     char *map;
2998
2999     if (*arg == '-') {
3000         negative = 1;
3001         arg++;
3002     }
3003     map = av_strdup(arg);
3004
3005     /* parse sync stream first, just pick first matching stream */
3006     if (sync = strchr(map, ',')) {
3007         *sync = 0;
3008         sync_file_idx = strtol(sync + 1, &sync, 0);
3009         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3010             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3011             exit_program(1);
3012         }
3013         if (*sync)
3014             sync++;
3015         for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
3016             if (check_stream_specifier(input_files[sync_file_idx].ctx,
3017                                        input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
3018                 sync_stream_idx = i;
3019                 break;
3020             }
3021         if (i == input_files[sync_file_idx].nb_streams) {
3022             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3023                                        "match any streams.\n", arg);
3024             exit_program(1);
3025         }
3026     }
3027
3028
3029     file_idx = strtol(map, &p, 0);
3030     if (file_idx >= nb_input_files || file_idx < 0) {
3031         av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3032         exit_program(1);
3033     }
3034     if (negative)
3035         /* disable some already defined maps */
3036         for (i = 0; i < o->nb_stream_maps; i++) {
3037             m = &o->stream_maps[i];
3038             if (file_idx == m->file_index &&
3039                 check_stream_specifier(input_files[m->file_index].ctx,
3040                                        input_files[m->file_index].ctx->streams[m->stream_index],
3041                                        *p == ':' ? p + 1 : p) > 0)
3042                 m->disabled = 1;
3043         }
3044     else
3045         for (i = 0; i < input_files[file_idx].nb_streams; i++) {
3046             if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
3047                         *p == ':' ? p + 1 : p) <= 0)
3048                 continue;
3049             o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3050                                         &o->nb_stream_maps, o->nb_stream_maps + 1);
3051             m = &o->stream_maps[o->nb_stream_maps - 1];
3052
3053             m->file_index   = file_idx;
3054             m->stream_index = i;
3055
3056             if (sync_file_idx >= 0) {
3057                 m->sync_file_index   = sync_file_idx;
3058                 m->sync_stream_index = sync_stream_idx;
3059             } else {
3060                 m->sync_file_index   = file_idx;
3061                 m->sync_stream_index = i;
3062             }
3063         }
3064
3065     if (!m) {
3066         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3067         exit_program(1);
3068     }
3069
3070     av_freep(&map);
3071     return 0;
3072 }
3073
3074 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3075 {
3076     o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3077                                 &o->nb_attachments, o->nb_attachments + 1);
3078     o->attachments[o->nb_attachments - 1] = arg;
3079     return 0;
3080 }
3081
3082 /**
3083  * Parse a metadata specifier in arg.
3084  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3085  * @param index for type c/p, chapter/program index is written here
3086  * @param stream_spec for type s, the stream specifier is written here
3087  */
3088 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3089 {
3090     if (*arg) {
3091         *type = *arg;
3092         switch (*arg) {
3093         case 'g':
3094             break;
3095         case 's':
3096             if (*(++arg) && *arg != ':') {
3097                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3098                 exit_program(1);
3099             }
3100             *stream_spec = *arg == ':' ? arg + 1 : "";
3101             break;
3102         case 'c':
3103         case 'p':
3104             if (*(++arg) == ':')
3105                 *index = strtol(++arg, NULL, 0);
3106             break;
3107         default:
3108             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3109             exit_program(1);
3110         }
3111     } else
3112         *type = 'g';
3113 }
3114
3115 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3116 {
3117     AVDictionary **meta_in = NULL;
3118     AVDictionary **meta_out;
3119     int i, ret = 0;
3120     char type_in, type_out;
3121     const char *istream_spec = NULL, *ostream_spec = NULL;
3122     int idx_in = 0, idx_out = 0;
3123
3124     parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
3125     parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3126
3127     if (type_in == 'g' || type_out == 'g')
3128         o->metadata_global_manual = 1;
3129     if (type_in == 's' || type_out == 's')
3130         o->metadata_streams_manual = 1;
3131     if (type_in == 'c' || type_out == 'c')
3132         o->metadata_chapters_manual = 1;
3133
3134 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3135     if ((index) < 0 || (index) >= (nb_elems)) {\
3136         av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
3137                 (desc), (index));\
3138         exit_program(1);\
3139     }
3140
3141 #define SET_DICT(type, meta, context, index)\
3142         switch (type) {\
3143         case 'g':\
3144             meta = &context->metadata;\
3145             break;\
3146         case 'c':\
3147             METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
3148             meta = &context->chapters[index]->metadata;\
3149             break;\
3150         case 'p':\
3151             METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
3152             meta = &context->programs[index]->metadata;\
3153             break;\
3154         }\
3155
3156     SET_DICT(type_in, meta_in, ic, idx_in);
3157     SET_DICT(type_out, meta_out, oc, idx_out);
3158
3159     /* for input streams choose first matching stream */
3160     if (type_in == 's') {
3161         for (i = 0; i < ic->nb_streams; i++) {
3162             if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
3163                 meta_in = &ic->streams[i]->metadata;
3164                 break;
3165             } else if (ret < 0)
3166                 exit_program(1);
3167         }
3168         if (!meta_in) {
3169             av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
3170             exit_program(1);
3171         }
3172     }
3173
3174     if (type_out == 's') {
3175         for (i = 0; i < oc->nb_streams; i++) {
3176             if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
3177                 meta_out = &oc->streams[i]->metadata;
3178                 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3179             } else if (ret < 0)
3180                 exit_program(1);
3181         }
3182     } else
3183         av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3184
3185     return 0;
3186 }
3187
3188 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3189 {
3190     const char *codec_string = encoder ? "encoder" : "decoder";
3191     AVCodec *codec;
3192
3193     codec = encoder ?
3194         avcodec_find_encoder_by_name(name) :
3195         avcodec_find_decoder_by_name(name);
3196     if (!codec) {
3197         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3198         exit_program(1);
3199     }
3200     if (codec->type != type) {
3201         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3202         exit_program(1);
3203     }
3204     return codec;
3205 }
3206
3207 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3208 {
3209     char *codec_name = NULL;
3210
3211     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3212     if (codec_name) {
3213         AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3214         st->codec->codec_id = codec->id;
3215         return codec;
3216     } else
3217         return avcodec_find_decoder(st->codec->codec_id);
3218 }
3219
3220 /**
3221  * Add all the streams from the given input file to the global
3222  * list of input streams.
3223  */
3224 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3225 {
3226     int i;
3227
3228     for (i = 0; i < ic->nb_streams; i++) {
3229         AVStream *st = ic->streams[i];
3230         AVCodecContext *dec = st->codec;
3231         InputStream *ist;
3232
3233         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3234         ist = &input_streams[nb_input_streams - 1];
3235         ist->st = st;
3236         ist->file_index = nb_input_files;
3237         ist->discard = 1;
3238         ist->opts = filter_codec_opts(codec_opts, choose_decoder(o, ic, st), ic, st);
3239
3240         ist->ts_scale = 1.0;
3241         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
3242
3243         ist->dec = choose_decoder(o, ic, st);
3244
3245         switch (dec->codec_type) {
3246         case AVMEDIA_TYPE_AUDIO:
3247             if(!ist->dec)
3248                 ist->dec = avcodec_find_decoder(dec->codec_id);
3249             if(o->audio_disable)
3250                 st->discard = AVDISCARD_ALL;
3251             break;
3252         case AVMEDIA_TYPE_VIDEO:
3253             if(!ist->dec)
3254                 ist->dec = avcodec_find_decoder(dec->codec_id);
3255             if (dec->lowres) {
3256                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3257             }
3258
3259             if (o->video_disable)
3260                 st->discard = AVDISCARD_ALL;
3261             else if (video_discard)
3262                 st->discard = video_discard;
3263             break;
3264         case AVMEDIA_TYPE_DATA:
3265             break;
3266         case AVMEDIA_TYPE_SUBTITLE:
3267             if(!ist->dec)
3268                 ist->dec = avcodec_find_decoder(dec->codec_id);
3269             if(o->subtitle_disable)
3270                 st->discard = AVDISCARD_ALL;
3271             break;
3272         case AVMEDIA_TYPE_ATTACHMENT:
3273         case AVMEDIA_TYPE_UNKNOWN:
3274             break;
3275         default:
3276             abort();
3277         }
3278     }
3279 }
3280
3281 static void assert_file_overwrite(const char *filename)
3282 {
3283     if ((!file_overwrite || no_file_overwrite) &&
3284         (strchr(filename, ':') == NULL || filename[1] == ':' ||
3285          av_strstart(filename, "file:", NULL))) {
3286         if (avio_check(filename, 0) == 0) {
3287             if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
3288                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3289                 fflush(stderr);
3290                 if (!read_yesno()) {
3291                     fprintf(stderr, "Not overwriting - exiting\n");
3292                     exit_program(1);
3293                 }
3294             }
3295             else {
3296                 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3297                 exit_program(1);
3298             }
3299         }
3300     }
3301 }
3302
3303 static void dump_attachment(AVStream *st, const char *filename)
3304 {
3305     int ret;
3306     AVIOContext *out = NULL;
3307     AVDictionaryEntry *e;
3308
3309     if (!st->codec->extradata_size) {
3310         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
3311                nb_input_files - 1, st->index);
3312         return;
3313     }
3314     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3315         filename = e->value;
3316     if (!*filename) {
3317         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
3318                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3319         exit_program(1);
3320     }
3321
3322     assert_file_overwrite(filename);
3323
3324     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
3325         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3326                filename);
3327         exit_program(1);
3328     }
3329
3330     avio_write(out, st->codec->extradata, st->codec->extradata_size);
3331     avio_flush(out);
3332     avio_close(out);
3333 }
3334
3335 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3336 {
3337     AVFormatContext *ic;
3338     AVInputFormat *file_iformat = NULL;
3339     int err, i, ret;
3340     int64_t timestamp;
3341     uint8_t buf[128];
3342     AVDictionary **opts;
3343     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
3344
3345     if (o->format) {
3346         if (!(file_iformat = av_find_input_format(o->format))) {
3347             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3348             exit_program(1);
3349         }
3350     }
3351
3352     if (!strcmp(filename, "-"))
3353         filename = "pipe:";
3354
3355     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3356                     !strcmp(filename, "/dev/stdin");
3357
3358     /* get default parameters from command line */
3359     ic = avformat_alloc_context();
3360     if (!ic) {
3361         print_error(filename, AVERROR(ENOMEM));
3362         exit_program(1);
3363     }
3364     if (o->nb_audio_sample_rate) {
3365         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3366         av_dict_set(&format_opts, "sample_rate", buf, 0);
3367     }
3368     if (o->nb_audio_channels) {
3369         snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3370         av_dict_set(&format_opts, "channels", buf, 0);
3371     }
3372     if (o->nb_frame_rates) {
3373         av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3374     }
3375     if (o->nb_frame_sizes) {
3376         av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3377     }
3378     if (o->nb_frame_pix_fmts)
3379         av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3380
3381     ic->flags |= AVFMT_FLAG_NONBLOCK;
3382     ic->interrupt_callback = int_cb;
3383
3384     /* open the input file with generic avformat function */
3385     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3386     if (err < 0) {
3387         print_error(filename, err);
3388         exit_program(1);
3389     }
3390     assert_avoptions(format_opts);
3391
3392     /* apply forced codec ids */
3393     for (i = 0; i < ic->nb_streams; i++)
3394         choose_decoder(o, ic, ic->streams[i]);
3395
3396     /* Set AVCodecContext options for avformat_find_stream_info */
3397     opts = setup_find_stream_info_opts(ic, codec_opts);
3398     orig_nb_streams = ic->nb_streams;
3399
3400     /* If not enough info to get the stream parameters, we decode the
3401        first frames to get it. (used in mpeg case for example) */
3402     ret = avformat_find_stream_info(ic, opts);
3403     if (ret < 0) {
3404         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3405         avformat_close_input(&ic);
3406         exit_program(1);
3407     }
3408
3409     timestamp = o->start_time;
3410     /* add the stream start time */
3411     if (ic->start_time != AV_NOPTS_VALUE)
3412         timestamp += ic->start_time;
3413
3414     /* if seeking requested, we execute it */
3415     if (o->start_time != 0) {
3416         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3417         if (ret < 0) {
3418             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3419                    filename, (double)timestamp / AV_TIME_BASE);
3420         }
3421     }
3422
3423     /* update the current parameters so that they match the one of the input stream */
3424     add_input_streams(o, ic);
3425
3426     /* dump the file content */
3427     av_dump_format(ic, nb_input_files, filename, 0);
3428
3429     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3430     input_files[nb_input_files - 1].ctx        = ic;
3431     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3432     input_files[nb_input_files - 1].ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3433     input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3434     input_files[nb_input_files - 1].rate_emu   = o->rate_emu;
3435
3436     for (i = 0; i < o->nb_dump_attachment; i++) {
3437         int j;
3438
3439         for (j = 0; j < ic->nb_streams; j++) {
3440             AVStream *st = ic->streams[j];
3441
3442             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3443                 dump_attachment(st, o->dump_attachment[i].u.str);
3444         }
3445     }
3446
3447     for (i = 0; i < orig_nb_streams; i++)
3448         av_dict_free(&opts[i]);
3449     av_freep(&opts);
3450
3451     reset_options(o);
3452     return 0;
3453 }
3454
3455 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3456                                     AVCodecContext *avctx)
3457 {
3458     char *p;
3459     int n = 1, i;
3460     int64_t t;
3461
3462     for (p = kf; *p; p++)
3463         if (*p == ',')
3464             n++;
3465     ost->forced_kf_count = n;
3466     ost->forced_kf_pts   = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3467     if (!ost->forced_kf_pts) {
3468         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3469         exit_program(1);
3470     }
3471     for (i = 0; i < n; i++) {
3472         p = i ? strchr(p, ',') + 1 : kf;
3473         t = parse_time_or_die("force_key_frames", p, 1);
3474         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3475     }
3476 }
3477
3478 static uint8_t *get_line(AVIOContext *s)
3479 {
3480     AVIOContext *line;
3481     uint8_t *buf;
3482     char c;
3483
3484     if (avio_open_dyn_buf(&line) < 0) {
3485         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3486         exit_program(1);
3487     }
3488
3489     while ((c = avio_r8(s)) && c != '\n')
3490         avio_w8(line, c);
3491     avio_w8(line, 0);
3492     avio_close_dyn_buf(line, &buf);
3493
3494     return buf;
3495 }
3496
3497 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3498 {
3499     int i, ret = 1;
3500     char filename[1000];
3501     const char *base[3] = { getenv("AVCONV_DATADIR"),
3502                             getenv("HOME"),
3503                             AVCONV_DATADIR,
3504                             };
3505
3506     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3507         if (!base[i])
3508             continue;
3509         if (codec_name) {
3510             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3511                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
3512             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3513         }
3514         if (ret) {
3515             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3516                      i != 1 ? "" : "/.avconv", preset_name);
3517             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3518         }
3519     }
3520     return ret;
3521 }
3522
3523 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3524 {
3525     char *codec_name = NULL;
3526
3527     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3528     if (!codec_name) {
3529         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3530                                                   NULL, ost->st->codec->codec_type);
3531         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3532     } else if (!strcmp(codec_name, "copy"))
3533         ost->stream_copy = 1;
3534     else {
3535         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3536         ost->st->codec->codec_id = ost->enc->id;
3537     }
3538 }
3539
3540 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3541 {
3542     OutputStream *ost;
3543     AVStream *st = avformat_new_stream(oc, NULL);
3544     int idx      = oc->nb_streams - 1, ret = 0;
3545     char *bsf = NULL, *next, *codec_tag = NULL;
3546     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3547     double qscale = -1;
3548     char *buf = NULL, *arg = NULL, *preset = NULL;
3549     AVIOContext *s = NULL;
3550
3551     if (!st) {
3552         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3553         exit_program(1);
3554     }
3555
3556     if (oc->nb_streams - 1 < o->nb_streamid_map)
3557         st->id = o->streamid_map[oc->nb_streams - 1];
3558
3559     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3560                                 nb_output_streams + 1);
3561     ost = &output_streams[nb_output_streams - 1];
3562     ost->file_index = nb_output_files;
3563     ost->index      = idx;
3564     ost->st         = st;
3565     st->codec->codec_type = type;
3566     choose_encoder(o, oc, ost);
3567     if (ost->enc) {
3568         ost->opts  = filter_codec_opts(codec_opts, ost->enc, oc, st);
3569     }
3570
3571     avcodec_get_context_defaults3(st->codec, ost->enc);
3572     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3573
3574     MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3575     if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3576         do  {
3577             buf = get_line(s);
3578             if (!buf[0] || buf[0] == '#') {
3579                 av_free(buf);
3580                 continue;
3581             }
3582             if (!(arg = strchr(buf, '='))) {
3583                 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3584                 exit_program(1);
3585             }
3586             *arg++ = 0;
3587             av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3588             av_free(buf);
3589         } while (!s->eof_reached);
3590         avio_close(s);
3591     }
3592     if (ret) {
3593         av_log(NULL, AV_LOG_FATAL,
3594                "Preset %s specified for stream %d:%d, but could not be opened.\n",
3595                preset, ost->file_index, ost->index);
3596         exit_program(1);
3597     }
3598
3599     ost->max_frames = INT64_MAX;
3600     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3601
3602     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3603     while (bsf) {
3604         if (next = strchr(bsf, ','))
3605             *next++ = 0;
3606         if (!(bsfc = av_bitstream_filter_init(bsf))) {
3607             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3608             exit_program(1);
3609         }
3610         if (bsfc_prev)
3611             bsfc_prev->next = bsfc;
3612         else
3613             ost->bitstream_filters = bsfc;
3614
3615         bsfc_prev = bsfc;
3616         bsf       = next;
3617     }
3618
3619     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3620     if (codec_tag) {
3621         uint32_t tag = strtol(codec_tag, &next, 0);
3622         if (*next)
3623             tag = AV_RL32(codec_tag);
3624         st->codec->codec_tag = tag;
3625     }
3626
3627     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3628     if (qscale >= 0 || same_quant) {
3629         st->codec->flags |= CODEC_FLAG_QSCALE;
3630         st->codec->global_quality = FF_QP2LAMBDA * qscale;
3631     }
3632
3633     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3634         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3635
3636     av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3637     return ost;
3638 }
3639
3640 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3641 {
3642     int i;
3643     const char *p = str;
3644     for (i = 0;; i++) {
3645         dest[i] = atoi(p);
3646         if (i == 63)
3647             break;
3648         p = strchr(p, ',');
3649         if (!p) {
3650             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3651             exit_program(1);
3652         }
3653         p++;
3654     }
3655 }
3656
3657 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3658 {
3659     AVStream *st;
3660     OutputStream *ost;
3661     AVCodecContext *video_enc;
3662
3663     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3664     st  = ost->st;
3665     video_enc = st->codec;
3666
3667     if (!ost->stream_copy) {
3668         const char *p = NULL;
3669         char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3670         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3671         char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3672         int i;
3673
3674         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3675         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3676             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3677             exit_program(1);
3678         }
3679
3680         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3681         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3682             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3683             exit_program(1);
3684         }
3685
3686         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3687         if (frame_aspect_ratio)
3688             ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3689
3690         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3691         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3692             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3693             exit_program(1);
3694         }
3695         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3696
3697         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3698         if (intra_matrix) {
3699             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3700                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3701                 exit_program(1);
3702             }
3703             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3704         }
3705         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3706         if (inter_matrix) {
3707             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3708                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3709                 exit_program(1);
3710             }
3711             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3712         }
3713
3714         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3715         for (i = 0; p; i++) {
3716             int start, end, q;
3717             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
3718             if (e != 3) {
3719                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3720                 exit_program(1);
3721             }
3722             video_enc->rc_override =
3723                 av_realloc(video_enc->rc_override,
3724                            sizeof(RcOverride) * (i + 1));
3725             video_enc->rc_override[i].start_frame = start;
3726             video_enc->rc_override[i].end_frame   = end;
3727             if (q > 0) {
3728                 video_enc->rc_override[i].qscale         = q;
3729                 video_enc->rc_override[i].quality_factor = 1.0;
3730             }
3731             else {
3732                 video_enc->rc_override[i].qscale         = 0;
3733                 video_enc->rc_override[i].quality_factor = -q/100.0;
3734             }
3735             p = strchr(p, '/');
3736             if (p) p++;
3737         }
3738         video_enc->rc_override_count = i;
3739         if (!video_enc->rc_initial_buffer_occupancy)
3740             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
3741         video_enc->intra_dc_precision = intra_dc_precision - 8;
3742
3743         /* two pass mode */
3744         if (do_pass) {
3745             if (do_pass == 1) {
3746                 video_enc->flags |= CODEC_FLAG_PASS1;
3747             } else {
3748                 video_enc->flags |= CODEC_FLAG_PASS2;
3749             }
3750         }
3751
3752         MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3753         if (forced_key_frames)
3754             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3755
3756         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
3757
3758         ost->top_field_first = -1;
3759         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
3760
3761 #if CONFIG_AVFILTER
3762         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3763         if (filters)
3764             ost->avfilter = av_strdup(filters);
3765 #endif
3766     } else {
3767         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
3768     }
3769
3770     return ost;
3771 }
3772
3773 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3774 {
3775     AVStream *st;
3776     OutputStream *ost;
3777     AVCodecContext *audio_enc;
3778
3779     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3780     st  = ost->st;
3781
3782     audio_enc = st->codec;
3783     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3784
3785     if (!ost->stream_copy) {
3786         char *sample_fmt = NULL;
3787
3788         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3789
3790         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3791         if (sample_fmt &&
3792             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3793             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3794             exit_program(1);
3795         }
3796
3797         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3798     }
3799
3800     return ost;
3801 }
3802
3803 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3804 {
3805     OutputStream *ost;
3806
3807     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3808     if (!ost->stream_copy) {
3809         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3810         exit_program(1);
3811     }
3812
3813     return ost;
3814 }
3815
3816 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3817 {
3818     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3819     ost->stream_copy = 1;
3820     return ost;
3821 }
3822
3823 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3824 {
3825     AVStream *st;
3826     OutputStream *ost;
3827     AVCodecContext *subtitle_enc;
3828
3829     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3830     st  = ost->st;
3831     subtitle_enc = st->codec;
3832
3833     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3834
3835     return ost;
3836 }
3837
3838 /* arg format is "output-stream-index:streamid-value". */
3839 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3840 {
3841     int idx;
3842     char *p;
3843     char idx_str[16];
3844
3845     av_strlcpy(idx_str, arg, sizeof(idx_str));
3846     p = strchr(idx_str, ':');
3847     if (!p) {
3848         av_log(NULL, AV_LOG_FATAL,
3849                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3850                arg, opt);
3851         exit_program(1);
3852     }
3853     *p++ = '\0';
3854     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3855     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3856     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3857     return 0;
3858 }
3859
3860 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3861 {
3862     AVFormatContext *is = ifile->ctx;
3863     AVFormatContext *os = ofile->ctx;
3864     int i;
3865
3866     for (i = 0; i < is->nb_chapters; i++) {
3867         AVChapter *in_ch = is->chapters[i], *out_ch;
3868         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
3869                                        AV_TIME_BASE_Q, in_ch->time_base);
3870         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3871                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3872
3873
3874         if (in_ch->end < ts_off)
3875             continue;
3876         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3877             break;
3878
3879         out_ch = av_mallocz(sizeof(AVChapter));
3880         if (!out_ch)
3881             return AVERROR(ENOMEM);
3882
3883         out_ch->id        = in_ch->id;
3884         out_ch->time_base = in_ch->time_base;
3885         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
3886         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
3887
3888         if (copy_metadata)
3889             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3890
3891         os->nb_chapters++;
3892         os->chapters = av_realloc(os->chapters, sizeof(AVChapter) * os->nb_chapters);
3893         if (!os->chapters)
3894             return AVERROR(ENOMEM);
3895         os->chapters[os->nb_chapters - 1] = out_ch;
3896     }
3897     return 0;
3898 }
3899
3900 static void opt_output_file(void *optctx, const char *filename)
3901 {
3902     OptionsContext *o = optctx;
3903     AVFormatContext *oc;
3904     int i, err;
3905     AVOutputFormat *file_oformat;
3906     OutputStream *ost;
3907     InputStream  *ist;
3908
3909     if (!strcmp(filename, "-"))
3910         filename = "pipe:";
3911
3912     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3913     if (!oc) {
3914         print_error(filename, err);
3915         exit_program(1);
3916     }
3917
3918     file_oformat= oc->oformat;
3919     oc->interrupt_callback = int_cb;
3920
3921     if (!o->nb_stream_maps) {
3922         /* pick the "best" stream of each type */
3923 #define NEW_STREAM(type, index)\
3924         if (index >= 0) {\
3925             ost = new_ ## type ## _stream(o, oc);\
3926             ost->source_index = index;\
3927             ost->sync_ist     = &input_streams[index];\
3928             input_streams[index].discard = 0;\
3929         }
3930
3931         /* video: highest resolution */
3932         if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3933             int area = 0, idx = -1;
3934             for (i = 0; i < nb_input_streams; i++) {
3935                 ist = &input_streams[i];
3936                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3937                     ist->st->codec->width * ist->st->codec->height > area) {
3938                     area = ist->st->codec->width * ist->st->codec->height;
3939                     idx = i;
3940                 }
3941             }
3942             NEW_STREAM(video, idx);
3943         }
3944
3945         /* audio: most channels */
3946         if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3947             int channels = 0, idx = -1;
3948             for (i = 0; i < nb_input_streams; i++) {
3949                 ist = &input_streams[i];
3950                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3951                     ist->st->codec->channels > channels) {
3952                     channels = ist->st->codec->channels;
3953                     idx = i;
3954                 }
3955             }
3956             NEW_STREAM(audio, idx);
3957         }
3958
3959         /* subtitles: pick first */
3960         if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3961             for (i = 0; i < nb_input_streams; i++)
3962                 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3963                     NEW_STREAM(subtitle, i);
3964                     break;
3965                 }
3966         }
3967         /* do something with data? */
3968     } else {
3969         for (i = 0; i < o->nb_stream_maps; i++) {
3970             StreamMap *map = &o->stream_maps[i];
3971
3972             if (map->disabled)
3973                 continue;
3974
3975             ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3976             switch (ist->st->codec->codec_type) {
3977             case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
3978             case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
3979             case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3980             case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
3981             case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
3982             default:
3983                 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
3984                        map->file_index, map->stream_index);
3985                 exit_program(1);
3986             }
3987
3988             ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3989             ost->sync_ist     = &input_streams[input_files[map->sync_file_index].ist_index +
3990                                            map->sync_stream_index];
3991             ist->discard = 0;
3992         }
3993     }
3994
3995     /* handle attached files */
3996     for (i = 0; i < o->nb_attachments; i++) {
3997         AVIOContext *pb;
3998         uint8_t *attachment;
3999         const char *p;
4000         int64_t len;
4001
4002         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
4003             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
4004                    o->attachments[i]);
4005             exit_program(1);
4006         }
4007         if ((len = avio_size(pb)) <= 0) {
4008             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
4009                    o->attachments[i]);
4010             exit_program(1);
4011         }
4012         if (!(attachment = av_malloc(len))) {
4013             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
4014                    o->attachments[i]);
4015             exit_program(1);
4016         }
4017         avio_read(pb, attachment, len);
4018
4019         ost = new_attachment_stream(o, oc);
4020         ost->stream_copy               = 0;
4021         ost->source_index              = -1;
4022         ost->attachment_filename       = o->attachments[i];
4023         ost->st->codec->extradata      = attachment;
4024         ost->st->codec->extradata_size = len;
4025
4026         p = strrchr(o->attachments[i], '/');
4027         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
4028         avio_close(pb);
4029     }
4030
4031     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
4032     output_files[nb_output_files - 1].ctx       = oc;
4033     output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
4034     output_files[nb_output_files - 1].recording_time = o->recording_time;
4035     output_files[nb_output_files - 1].start_time     = o->start_time;
4036     output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
4037     av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
4038
4039     /* check filename in case of an image number is expected */
4040     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
4041         if (!av_filename_number_test(oc->filename)) {
4042             print_error(oc->filename, AVERROR(EINVAL));
4043             exit_program(1);
4044         }
4045     }
4046
4047     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
4048         /* test if it already exists to avoid losing precious files */
4049         assert_file_overwrite(filename);
4050
4051         /* open the file */
4052         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
4053                               &oc->interrupt_callback,
4054                               &output_files[nb_output_files - 1].opts)) < 0) {
4055             print_error(filename, err);
4056             exit_program(1);
4057         }
4058     }
4059
4060     if (o->mux_preload) {
4061         uint8_t buf[64];
4062         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
4063         av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
4064     }
4065     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
4066
4067     /* copy metadata */
4068     for (i = 0; i < o->nb_metadata_map; i++) {
4069         char *p;
4070         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
4071
4072         if (in_file_index < 0)
4073             continue;
4074         if (in_file_index >= nb_input_files) {
4075             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
4076             exit_program(1);
4077         }
4078         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index].ctx, o);
4079     }
4080
4081     /* copy chapters */
4082     if (o->chapters_input_file >= nb_input_files) {
4083         if (o->chapters_input_file == INT_MAX) {
4084             /* copy chapters from the first input file that has them*/
4085             o->chapters_input_file = -1;
4086             for (i = 0; i < nb_input_files; i++)
4087                 if (input_files[i].ctx->nb_chapters) {
4088                     o->chapters_input_file = i;
4089                     break;
4090                 }
4091         } else {
4092             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4093                    o->chapters_input_file);
4094             exit_program(1);
4095         }
4096     }
4097     if (o->chapters_input_file >= 0)
4098         copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
4099                       !o->metadata_chapters_manual);
4100
4101     /* copy global metadata by default */
4102     if (!o->metadata_global_manual && nb_input_files)
4103         av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
4104                      AV_DICT_DONT_OVERWRITE);
4105     if (!o->metadata_streams_manual)
4106         for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
4107             InputStream *ist;
4108             if (output_streams[i].source_index < 0)         /* this is true e.g. for attached files */
4109                 continue;
4110             ist = &input_streams[output_streams[i].source_index];
4111             av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4112         }
4113
4114     /* process manually set metadata */
4115     for (i = 0; i < o->nb_metadata; i++) {
4116         AVDictionary **m;
4117         char type, *val;
4118         const char *stream_spec;
4119         int index = 0, j, ret;
4120
4121         val = strchr(o->metadata[i].u.str, '=');
4122         if (!val) {
4123             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4124                    o->metadata[i].u.str);
4125             exit_program(1);
4126         }
4127         *val++ = 0;
4128
4129         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
4130         if (type == 's') {
4131             for (j = 0; j < oc->nb_streams; j++) {
4132                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
4133                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
4134                 } else if (ret < 0)
4135                     exit_program(1);
4136             }
4137             printf("ret %d, stream_spec %s\n", ret, stream_spec);
4138         }
4139         else {
4140             switch (type) {
4141             case 'g':
4142                 m = &oc->metadata;
4143                 break;
4144             case 'c':
4145                 if (index < 0 || index >= oc->nb_chapters) {
4146                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4147                     exit_program(1);
4148                 }
4149                 m = &oc->chapters[index]->metadata;
4150                 break;
4151             default:
4152                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4153                 exit_program(1);
4154             }
4155             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4156         }
4157     }
4158
4159     reset_options(o);
4160 }
4161
4162 /* same option as mencoder */
4163 static int opt_pass(const char *opt, const char *arg)
4164 {
4165     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
4166     return 0;
4167 }
4168
4169 static int64_t getutime(void)
4170 {
4171 #if HAVE_GETRUSAGE
4172     struct rusage rusage;
4173
4174     getrusage(RUSAGE_SELF, &rusage);
4175     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4176 #elif HAVE_GETPROCESSTIMES
4177     HANDLE proc;
4178     FILETIME c, e, k, u;
4179     proc = GetCurrentProcess();
4180     GetProcessTimes(proc, &c, &e, &k, &u);
4181     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4182 #else
4183     return av_gettime();
4184 #endif
4185 }
4186
4187 static int64_t getmaxrss(void)
4188 {
4189 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4190     struct rusage rusage;
4191     getrusage(RUSAGE_SELF, &rusage);
4192     return (int64_t)rusage.ru_maxrss * 1024;
4193 #elif HAVE_GETPROCESSMEMORYINFO
4194     HANDLE proc;
4195     PROCESS_MEMORY_COUNTERS memcounters;
4196     proc = GetCurrentProcess();
4197     memcounters.cb = sizeof(memcounters);
4198     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4199     return memcounters.PeakPagefileUsage;
4200 #else
4201     return 0;
4202 #endif
4203 }
4204
4205 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4206 {
4207     return parse_option(o, "q:a", arg, options);
4208 }
4209
4210 static void show_usage(void)
4211 {
4212     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
4213     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4214     av_log(NULL, AV_LOG_INFO, "\n");
4215 }
4216
4217 static int opt_help(const char *opt, const char *arg)
4218 {
4219     int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4220     av_log_set_callback(log_callback_help);
4221     show_usage();
4222     show_help_options(options, "Main options:\n",
4223                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4224     show_help_options(options, "\nAdvanced options:\n",
4225                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4226                       OPT_EXPERT);
4227     show_help_options(options, "\nVideo options:\n",
4228                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4229                       OPT_VIDEO);
4230     show_help_options(options, "\nAdvanced Video options:\n",
4231                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4232                       OPT_VIDEO | OPT_EXPERT);
4233     show_help_options(options, "\nAudio options:\n",
4234                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4235                       OPT_AUDIO);
4236     show_help_options(options, "\nAdvanced Audio options:\n",
4237                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4238                       OPT_AUDIO | OPT_EXPERT);
4239     show_help_options(options, "\nSubtitle options:\n",
4240                       OPT_SUBTITLE | OPT_GRAB,
4241                       OPT_SUBTITLE);
4242     show_help_options(options, "\nAudio/Video grab options:\n",
4243                       OPT_GRAB,
4244                       OPT_GRAB);
4245     printf("\n");
4246     show_help_children(avcodec_get_class(), flags);
4247     show_help_children(avformat_get_class(), flags);
4248     show_help_children(sws_get_class(), flags);
4249
4250     return 0;
4251 }
4252
4253 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4254 {
4255     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4256     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
4257
4258     if (!strncmp(arg, "pal-", 4)) {
4259         norm = PAL;
4260         arg += 4;
4261     } else if (!strncmp(arg, "ntsc-", 5)) {
4262         norm = NTSC;
4263         arg += 5;
4264     } else if (!strncmp(arg, "film-", 5)) {
4265         norm = FILM;
4266         arg += 5;
4267     } else {
4268         /* Try to determine PAL/NTSC by peeking in the input files */
4269         if (nb_input_files) {
4270             int i, j, fr;
4271             for (j = 0; j < nb_input_files; j++) {
4272                 for (i = 0; i < input_files[j].nb_streams; i++) {
4273                     AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4274                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
4275                         continue;
4276                     fr = c->time_base.den * 1000 / c->time_base.num;
4277                     if (fr == 25000) {
4278                         norm = PAL;
4279                         break;
4280                     } else if ((fr == 29970) || (fr == 23976)) {
4281                         norm = NTSC;
4282                         break;
4283                     }
4284                 }
4285                 if (norm != UNKNOWN)
4286                     break;
4287             }
4288         }
4289         if (norm != UNKNOWN)
4290             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4291     }
4292
4293     if (norm == UNKNOWN) {
4294         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4295         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4296         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4297         exit_program(1);
4298     }
4299
4300     if (!strcmp(arg, "vcd")) {
4301         opt_video_codec(o, "c:v", "mpeg1video");
4302         opt_audio_codec(o, "c:a", "mp2");
4303         parse_option(o, "f", "vcd", options);
4304
4305         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4306         parse_option(o, "r", frame_rates[norm], options);
4307         opt_default("g", norm == PAL ? "15" : "18");
4308
4309         opt_default("b", "1150000");
4310         opt_default("maxrate", "1150000");
4311         opt_default("minrate", "1150000");
4312         opt_default("bufsize", "327680"); // 40*1024*8;
4313
4314         opt_default("b:a", "224000");
4315         parse_option(o, "ar", "44100", options);
4316         parse_option(o, "ac", "2", options);
4317
4318         opt_default("packetsize", "2324");
4319         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4320
4321         /* We have to offset the PTS, so that it is consistent with the SCR.
4322            SCR starts at 36000, but the first two packs contain only padding
4323            and the first pack from the other stream, respectively, may also have
4324            been written before.
4325            So the real data starts at SCR 36000+3*1200. */
4326         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
4327     } else if (!strcmp(arg, "svcd")) {
4328
4329         opt_video_codec(o, "c:v", "mpeg2video");
4330         opt_audio_codec(o, "c:a", "mp2");
4331         parse_option(o, "f", "svcd", options);
4332
4333         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4334         parse_option(o, "r", frame_rates[norm], options);
4335         opt_default("g", norm == PAL ? "15" : "18");
4336
4337         opt_default("b", "2040000");
4338         opt_default("maxrate", "2516000");
4339         opt_default("minrate", "0"); // 1145000;
4340         opt_default("bufsize", "1835008"); // 224*1024*8;
4341         opt_default("flags", "+scan_offset");
4342
4343
4344         opt_default("b:a", "224000");
4345         parse_option(o, "ar", "44100", options);
4346
4347         opt_default("packetsize", "2324");
4348
4349     } else if (!strcmp(arg, "dvd")) {
4350
4351         opt_video_codec(o, "c:v", "mpeg2video");
4352         opt_audio_codec(o, "c:a", "ac3");
4353         parse_option(o, "f", "dvd", options);
4354
4355         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4356         parse_option(o, "r", frame_rates[norm], options);
4357         opt_default("g", norm == PAL ? "15" : "18");
4358
4359         opt_default("b", "6000000");
4360         opt_default("maxrate", "9000000");
4361         opt_default("minrate", "0"); // 1500000;
4362         opt_default("bufsize", "1835008"); // 224*1024*8;
4363
4364         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4365         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4366
4367         opt_default("b:a", "448000");
4368         parse_option(o, "ar", "48000", options);
4369
4370     } else if (!strncmp(arg, "dv", 2)) {
4371
4372         parse_option(o, "f", "dv", options);
4373
4374         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4375         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4376                           norm == PAL ? "yuv420p" : "yuv411p", options);
4377         parse_option(o, "r", frame_rates[norm], options);
4378
4379         parse_option(o, "ar", "48000", options);
4380         parse_option(o, "ac", "2", options);
4381
4382     } else {
4383         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4384         return AVERROR(EINVAL);
4385     }
4386     return 0;
4387 }
4388
4389 static int opt_vstats_file(const char *opt, const char *arg)
4390 {
4391     av_free (vstats_filename);
4392     vstats_filename = av_strdup (arg);
4393     return 0;
4394 }
4395
4396 static int opt_vstats(const char *opt, const char *arg)
4397 {
4398     char filename[40];
4399     time_t today2 = time(NULL);
4400     struct tm *today = localtime(&today2);
4401
4402     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4403              today->tm_sec);
4404     return opt_vstats_file(opt, filename);
4405 }
4406
4407 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4408 {
4409     return parse_option(o, "frames:v", arg, options);
4410 }
4411
4412 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4413 {
4414     return parse_option(o, "frames:a", arg, options);
4415 }
4416
4417 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4418 {
4419     return parse_option(o, "frames:d", arg, options);
4420 }
4421
4422 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4423 {
4424 }
4425
4426 static int opt_passlogfile(const char *opt, const char *arg)
4427 {
4428     pass_logfilename_prefix = arg;
4429 #if CONFIG_LIBX264_ENCODER
4430     return opt_default("passlogfile", arg);
4431 #else
4432     return 0;
4433 #endif
4434 }
4435
4436 static int opt_video_tag(OptionsContext *o, const char *opt, const char *arg)
4437 {
4438     return parse_option(o, "tag:v", arg, options);
4439 }
4440
4441 static int opt_audio_tag(OptionsContext *o, const char *opt, const char *arg)
4442 {
4443     return parse_option(o, "tag:a", arg, options);
4444 }
4445
4446 static int opt_subtitle_tag(OptionsContext *o, const char *opt, const char *arg)
4447 {
4448     return parse_option(o, "tag:s", arg, options);
4449 }
4450
4451 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4452 {
4453     return parse_option(o, "filter:v", arg, options);
4454 }
4455
4456 static int opt_vsync(const char *opt, const char *arg)
4457 {
4458     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
4459     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
4460     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
4461
4462     if (video_sync_method == VSYNC_AUTO)
4463         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
4464     return 0;
4465 }
4466
4467 #define OFFSET(x) offsetof(OptionsContext, x)
4468 static const OptionDef options[] = {
4469     /* main options */
4470 #include "cmdutils_common_opts.h"
4471     { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4472     { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4473     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4474     { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
4475     { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4476     { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4477     { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4478     { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
4479     { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
4480       "outfile[,metadata]:infile[,metadata]" },
4481     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)},  "set chapters mapping", "input_file_index" },
4482     { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4483     { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4484     { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4485     { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4486     { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4487     { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4488     { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4489     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4490       "add timings for benchmarking" },
4491     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4492     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4493       "dump each input packet" },
4494     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4495       "when dumping packets, also dump the payload" },
4496     { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4497     { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4498     { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
4499     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4500     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4501     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4502     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4503     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4504     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4505     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4506     { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4507     { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4508     { "tag",   OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4509     { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4510     { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4511 #if CONFIG_AVFILTER
4512     { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4513 #endif
4514     { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4515     { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4516     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4517
4518     /* video options */
4519     { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4520     { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4521     { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4522     { "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" },
4523     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4524     { "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" },
4525     { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4526     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4527     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4528     { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4529     { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4530       "use same quantizer as source (implies VBR)" },
4531     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4532     { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4533     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4534       "deinterlace pictures" },
4535     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4536     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4537 #if CONFIG_AVFILTER
4538     { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4539 #endif
4540     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4541     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4542     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4543     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4544     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4545     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4546     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4547     { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4548     { "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" },
4549
4550     /* audio options */
4551     { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4552     { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4553     { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4554     { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4555     { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4556     { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4557     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4558     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4559     { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4560
4561     /* subtitle options */
4562     { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4563     { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4564     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4565
4566     /* grab options */
4567     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4568
4569     /* muxer options */
4570     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT   | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4571     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)},   "set the initial demux-decode delay", "seconds" },
4572
4573     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4574
4575     /* data codec support */
4576     { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4577
4578     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4579     { NULL, },
4580 };
4581
4582 int main(int argc, char **argv)
4583 {
4584     OptionsContext o = { 0 };
4585     int64_t ti;
4586
4587     reset_options(&o);
4588
4589     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4590     parse_loglevel(argc, argv, options);
4591
4592     if(argc>1 && !strcmp(argv[1], "-d")){
4593         run_as_daemon=1;
4594         av_log_set_callback(log_callback_null);
4595         argc--;
4596         argv++;
4597     }
4598
4599     avcodec_register_all();
4600 #if CONFIG_AVDEVICE
4601     avdevice_register_all();
4602 #endif
4603 #if CONFIG_AVFILTER
4604     avfilter_register_all();
4605 #endif
4606     av_register_all();
4607     avformat_network_init();
4608
4609     show_banner(argc, argv, options);
4610
4611     /* parse options */
4612     parse_options(&o, argc, argv, options, opt_output_file);
4613
4614     if (nb_output_files <= 0 && nb_input_files == 0) {
4615         show_usage();
4616         av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4617         exit_program(1);
4618     }
4619
4620     /* file converter / grab */
4621     if (nb_output_files <= 0) {
4622         fprintf(stderr, "At least one output file must be specified\n");
4623         exit_program(1);
4624     }
4625
4626     if (nb_input_files == 0) {
4627         av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4628         exit_program(1);
4629     }
4630
4631     ti = getutime();
4632     if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4633         exit_program(1);
4634     ti = getutime() - ti;
4635     if (do_benchmark) {
4636         int maxrss = getmaxrss() / 1024;
4637         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4638     }
4639
4640     exit_program(0);
4641     return 0;
4642 }