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