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 (!av_dict_get(ist->opts, "threads", NULL, 0))
2288             av_dict_set(&ist->opts, "threads", "auto", 0);
2289         if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2290             snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2291                     ist->file_index, ist->st->index);
2292             return AVERROR(EINVAL);
2293         }
2294         assert_codec_experimental(ist->st->codec, 0);
2295         assert_avoptions(ist->opts);
2296     }
2297
2298     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;
2299     ist->next_pts = AV_NOPTS_VALUE;
2300     ist->is_start = 1;
2301
2302     return 0;
2303 }
2304
2305 static int transcode_init(OutputFile *output_files,
2306                           int nb_output_files,
2307                           InputFile *input_files,
2308                           int nb_input_files)
2309 {
2310     int ret = 0, i, j, k;
2311     AVFormatContext *oc;
2312     AVCodecContext *codec, *icodec;
2313     OutputStream *ost;
2314     InputStream *ist;
2315     char error[1024];
2316     int want_sdp = 1;
2317
2318     /* init framerate emulation */
2319     for (i = 0; i < nb_input_files; i++) {
2320         InputFile *ifile = &input_files[i];
2321         if (ifile->rate_emu)
2322             for (j = 0; j < ifile->nb_streams; j++)
2323                 input_streams[j + ifile->ist_index].start = av_gettime();
2324     }
2325
2326     /* output stream init */
2327     for (i = 0; i < nb_output_files; i++) {
2328         oc = output_files[i].ctx;
2329         if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2330             av_dump_format(oc, i, oc->filename, 1);
2331             av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2332             return AVERROR(EINVAL);
2333         }
2334     }
2335
2336     /* for each output stream, we compute the right encoding parameters */
2337     for (i = 0; i < nb_output_streams; i++) {
2338         ost = &output_streams[i];
2339         oc  = output_files[ost->file_index].ctx;
2340         ist = &input_streams[ost->source_index];
2341
2342         if (ost->attachment_filename)
2343             continue;
2344
2345         codec  = ost->st->codec;
2346         icodec = ist->st->codec;
2347
2348         ost->st->disposition          = ist->st->disposition;
2349         codec->bits_per_raw_sample    = icodec->bits_per_raw_sample;
2350         codec->chroma_sample_location = icodec->chroma_sample_location;
2351
2352         if (ost->stream_copy) {
2353             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2354
2355             if (extra_size > INT_MAX) {
2356                 return AVERROR(EINVAL);
2357             }
2358
2359             /* if stream_copy is selected, no need to decode or encode */
2360             codec->codec_id   = icodec->codec_id;
2361             codec->codec_type = icodec->codec_type;
2362
2363             if (!codec->codec_tag) {
2364                 if (!oc->oformat->codec_tag ||
2365                      av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2366                      av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2367                     codec->codec_tag = icodec->codec_tag;
2368             }
2369
2370             codec->bit_rate       = icodec->bit_rate;
2371             codec->rc_max_rate    = icodec->rc_max_rate;
2372             codec->rc_buffer_size = icodec->rc_buffer_size;
2373             codec->field_order    = icodec->field_order;
2374             codec->extradata      = av_mallocz(extra_size);
2375             if (!codec->extradata) {
2376                 return AVERROR(ENOMEM);
2377             }
2378             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2379
2380             codec->extradata_size = icodec->extradata_size;
2381             if (!copy_tb) {
2382                 codec->time_base      = icodec->time_base;
2383                 codec->time_base.num *= icodec->ticks_per_frame;
2384                 av_reduce(&codec->time_base.num, &codec->time_base.den,
2385                           codec->time_base.num, codec->time_base.den, INT_MAX);
2386             } else
2387                 codec->time_base = ist->st->time_base;
2388
2389             switch (codec->codec_type) {
2390             case AVMEDIA_TYPE_AUDIO:
2391                 if (audio_volume != 256) {
2392                     av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2393                     exit_program(1);
2394                 }
2395                 codec->channel_layout     = icodec->channel_layout;
2396                 codec->sample_rate        = icodec->sample_rate;
2397                 codec->channels           = icodec->channels;
2398                 codec->frame_size         = icodec->frame_size;
2399                 codec->audio_service_type = icodec->audio_service_type;
2400                 codec->block_align        = icodec->block_align;
2401                 break;
2402             case AVMEDIA_TYPE_VIDEO:
2403                 codec->pix_fmt            = icodec->pix_fmt;
2404                 codec->width              = icodec->width;
2405                 codec->height             = icodec->height;
2406                 codec->has_b_frames       = icodec->has_b_frames;
2407                 if (!codec->sample_aspect_ratio.num) {
2408                     codec->sample_aspect_ratio   =
2409                     ost->st->sample_aspect_ratio =
2410                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2411                         ist->st->codec->sample_aspect_ratio.num ?
2412                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2413                 }
2414                 break;
2415             case AVMEDIA_TYPE_SUBTITLE:
2416                 codec->width  = icodec->width;
2417                 codec->height = icodec->height;
2418                 break;
2419             case AVMEDIA_TYPE_DATA:
2420             case AVMEDIA_TYPE_ATTACHMENT:
2421                 break;
2422             default:
2423                 abort();
2424             }
2425         } else {
2426             if (!ost->enc)
2427                 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2428
2429             ist->decoding_needed = 1;
2430             ost->encoding_needed = 1;
2431
2432             switch (codec->codec_type) {
2433             case AVMEDIA_TYPE_AUDIO:
2434                 ost->fifo = av_fifo_alloc(1024);
2435                 if (!ost->fifo) {
2436                     return AVERROR(ENOMEM);
2437                 }
2438                 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2439
2440                 if (!codec->sample_rate)
2441                     codec->sample_rate = icodec->sample_rate;
2442                 choose_sample_rate(ost->st, ost->enc);
2443                 codec->time_base = (AVRational){ 1, codec->sample_rate };
2444
2445                 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2446                     codec->sample_fmt = icodec->sample_fmt;
2447                 choose_sample_fmt(ost->st, ost->enc);
2448
2449                 if (!codec->channels) {
2450                     codec->channels = icodec->channels;
2451                     codec->channel_layout = icodec->channel_layout;
2452                 }
2453                 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2454                     codec->channel_layout = 0;
2455
2456                 ost->audio_resample       = codec-> sample_rate != icodec->sample_rate || audio_sync_method > 1;
2457                 icodec->request_channels  = codec-> channels;
2458                 ost->resample_sample_fmt  = icodec->sample_fmt;
2459                 ost->resample_sample_rate = icodec->sample_rate;
2460                 ost->resample_channels    = icodec->channels;
2461                 break;
2462             case AVMEDIA_TYPE_VIDEO:
2463                 if (codec->pix_fmt == PIX_FMT_NONE)
2464                     codec->pix_fmt = icodec->pix_fmt;
2465                 choose_pixel_fmt(ost->st, ost->enc);
2466
2467                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2468                     av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2469                     exit_program(1);
2470                 }
2471
2472                 if (!codec->width || !codec->height) {
2473                     codec->width  = icodec->width;
2474                     codec->height = icodec->height;
2475                 }
2476
2477                 ost->video_resample = codec->width   != icodec->width  ||
2478                                       codec->height  != icodec->height ||
2479                                       codec->pix_fmt != icodec->pix_fmt;
2480                 if (ost->video_resample) {
2481                     codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2482                 }
2483
2484                 ost->resample_height  = icodec->height;
2485                 ost->resample_width   = icodec->width;
2486                 ost->resample_pix_fmt = icodec->pix_fmt;
2487
2488                 if (!ost->frame_rate.num)
2489                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational) { 25, 1 };
2490                 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2491                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2492                     ost->frame_rate = ost->enc->supported_framerates[idx];
2493                 }
2494                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2495                 if(   av_q2d(codec->time_base) < 0.001 && video_sync_method
2496                    && (video_sync_method==1 || (video_sync_method<0 && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
2497                     av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2498                                                "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2499                 }
2500
2501 #if CONFIG_AVFILTER
2502                 if (configure_video_filters(ist, ost)) {
2503                     av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2504                     exit(1);
2505                 }
2506 #endif
2507                 break;
2508             case AVMEDIA_TYPE_SUBTITLE:
2509                 break;
2510             default:
2511                 abort();
2512                 break;
2513             }
2514             /* two pass mode */
2515             if (codec->codec_id != CODEC_ID_H264 &&
2516                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2517                 char logfilename[1024];
2518                 FILE *f;
2519
2520                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2521                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2522                          i);
2523                 if (codec->flags & CODEC_FLAG_PASS1) {
2524                     f = fopen(logfilename, "wb");
2525                     if (!f) {
2526                         av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2527                                logfilename, strerror(errno));
2528                         exit_program(1);
2529                     }
2530                     ost->logfile = f;
2531                 } else {
2532                     char  *logbuffer;
2533                     size_t logbuffer_size;
2534                     if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2535                         av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2536                                logfilename);
2537                         exit_program(1);
2538                     }
2539                     codec->stats_in = logbuffer;
2540                 }
2541             }
2542         }
2543         if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2544             /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2545             int        size = codec->width * codec->height;
2546             bit_buffer_size = FFMAX(bit_buffer_size, 6 * size + 1664);
2547         }
2548     }
2549
2550     if (!bit_buffer)
2551         bit_buffer = av_malloc(bit_buffer_size);
2552     if (!bit_buffer) {
2553         av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2554                bit_buffer_size);
2555         return AVERROR(ENOMEM);
2556     }
2557
2558     /* open each encoder */
2559     for (i = 0; i < nb_output_streams; i++) {
2560         ost = &output_streams[i];
2561         if (ost->encoding_needed) {
2562             AVCodec      *codec = ost->enc;
2563             AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2564             if (!codec) {
2565                 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d:%d",
2566                          ost->st->codec->codec_id, ost->file_index, ost->index);
2567                 ret = AVERROR(EINVAL);
2568                 goto dump_format;
2569             }
2570             if (dec->subtitle_header) {
2571                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2572                 if (!ost->st->codec->subtitle_header) {
2573                     ret = AVERROR(ENOMEM);
2574                     goto dump_format;
2575                 }
2576                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2577                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2578             }
2579             if (!av_dict_get(ost->opts, "threads", NULL, 0))
2580                 av_dict_set(&ost->opts, "threads", "auto", 0);
2581             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2582                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2583                         ost->file_index, ost->index);
2584                 ret = AVERROR(EINVAL);
2585                 goto dump_format;
2586             }
2587             assert_codec_experimental(ost->st->codec, 1);
2588             assert_avoptions(ost->opts);
2589             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2590                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2591                                              "It takes bits/s as argument, not kbits/s\n");
2592             extra_size += ost->st->codec->extradata_size;
2593
2594             if (ost->st->codec->me_threshold)
2595                 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2596         }
2597     }
2598
2599     /* init input streams */
2600     for (i = 0; i < nb_input_streams; i++)
2601         if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2602             goto dump_format;
2603
2604     /* discard unused programs */
2605     for (i = 0; i < nb_input_files; i++) {
2606         InputFile *ifile = &input_files[i];
2607         for (j = 0; j < ifile->ctx->nb_programs; j++) {
2608             AVProgram *p = ifile->ctx->programs[j];
2609             int discard  = AVDISCARD_ALL;
2610
2611             for (k = 0; k < p->nb_stream_indexes; k++)
2612                 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2613                     discard = AVDISCARD_DEFAULT;
2614                     break;
2615                 }
2616             p->discard = discard;
2617         }
2618     }
2619
2620     /* open files and write file headers */
2621     for (i = 0; i < nb_output_files; i++) {
2622         oc = output_files[i].ctx;
2623         oc->interrupt_callback = int_cb;
2624         if (avformat_write_header(oc, &output_files[i].opts) < 0) {
2625             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2626             ret = AVERROR(EINVAL);
2627             goto dump_format;
2628         }
2629 //        assert_avoptions(output_files[i].opts);
2630         if (strcmp(oc->oformat->name, "rtp")) {
2631             want_sdp = 0;
2632         }
2633     }
2634
2635  dump_format:
2636     /* dump the file output parameters - cannot be done before in case
2637        of stream copy */
2638     for (i = 0; i < nb_output_files; i++) {
2639         av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2640     }
2641
2642     /* dump the stream mapping */
2643     av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2644     for (i = 0; i < nb_output_streams; i++) {
2645         ost = &output_streams[i];
2646
2647         if (ost->attachment_filename) {
2648             /* an attached file */
2649             av_log(NULL, AV_LOG_INFO, "  File %s -> Stream #%d:%d\n",
2650                    ost->attachment_filename, ost->file_index, ost->index);
2651             continue;
2652         }
2653         av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d -> #%d:%d",
2654                input_streams[ost->source_index].file_index,
2655                input_streams[ost->source_index].st->index,
2656                ost->file_index,
2657                ost->index);
2658         if (ost->sync_ist != &input_streams[ost->source_index])
2659             av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2660                    ost->sync_ist->file_index,
2661                    ost->sync_ist->st->index);
2662         if (ost->stream_copy)
2663             av_log(NULL, AV_LOG_INFO, " (copy)");
2664         else
2665             av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2666                    input_streams[ost->source_index].dec->name : "?",
2667                    ost->enc ? ost->enc->name : "?");
2668         av_log(NULL, AV_LOG_INFO, "\n");
2669     }
2670
2671     if (ret) {
2672         av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2673         return ret;
2674     }
2675
2676     if (want_sdp) {
2677         print_sdp(output_files, nb_output_files);
2678     }
2679
2680     return 0;
2681 }
2682
2683 /*
2684  * The following code is the main loop of the file converter
2685  */
2686 static int transcode(OutputFile *output_files,
2687                      int nb_output_files,
2688                      InputFile *input_files,
2689                      int nb_input_files)
2690 {
2691     int ret, i;
2692     AVFormatContext *is, *os;
2693     OutputStream *ost;
2694     InputStream *ist;
2695     uint8_t *no_packet;
2696     int no_packet_count = 0;
2697     int64_t timer_start;
2698     int key;
2699
2700     if (!(no_packet = av_mallocz(nb_input_files)))
2701         exit_program(1);
2702
2703     ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2704     if (ret < 0)
2705         goto fail;
2706
2707     if (!using_stdin) {
2708         av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2709         avio_set_interrupt_cb(decode_interrupt_cb);
2710     }
2711     term_init();
2712
2713     timer_start = av_gettime();
2714
2715     for (; received_sigterm == 0;) {
2716         int file_index, ist_index;
2717         AVPacket pkt;
2718         int64_t ipts_min;
2719         double opts_min;
2720
2721         ipts_min = INT64_MAX;
2722         opts_min = 1e100;
2723         /* if 'q' pressed, exits */
2724         if (!using_stdin) {
2725             if (q_pressed)
2726                 break;
2727             /* read_key() returns 0 on EOF */
2728             key = read_key();
2729             if (key == 'q')
2730                 break;
2731             if (key == '+') av_log_set_level(av_log_get_level()+10);
2732             if (key == '-') av_log_set_level(av_log_get_level()-10);
2733             if (key == 's') qp_hist     ^= 1;
2734             if (key == 'h'){
2735                 if (do_hex_dump){
2736                     do_hex_dump = do_pkt_dump = 0;
2737                 } else if(do_pkt_dump){
2738                     do_hex_dump = 1;
2739                 } else
2740                     do_pkt_dump = 1;
2741                 av_log_set_level(AV_LOG_DEBUG);
2742             }
2743             if (key == 'd' || key == 'D'){
2744                 int debug=0;
2745                 if(key == 'D') {
2746                     debug = input_streams[0].st->codec->debug<<1;
2747                     if(!debug) debug = 1;
2748                     while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2749                         debug += debug;
2750                 }else
2751                     scanf("%d", &debug);
2752                 for(i=0;i<nb_input_streams;i++) {
2753                     input_streams[i].st->codec->debug = debug;
2754                 }
2755                 for(i=0;i<nb_output_streams;i++) {
2756                     ost = &output_streams[i];
2757                     ost->st->codec->debug = debug;
2758                 }
2759                 if(debug) av_log_set_level(AV_LOG_DEBUG);
2760                 fprintf(stderr,"debug=%d\n", debug);
2761             }
2762             if (key == '?'){
2763                 fprintf(stderr, "key    function\n"
2764                                 "?      show this help\n"
2765                                 "+      increase verbosity\n"
2766                                 "-      decrease verbosity\n"
2767                                 "D      cycle through available debug modes\n"
2768                                 "h      dump packets/hex press to cycle through the 3 states\n"
2769                                 "q      quit\n"
2770                                 "s      Show QP histogram\n"
2771                 );
2772             }
2773         }
2774
2775         /* select the stream that we must read now by looking at the
2776            smallest output pts */
2777         file_index = -1;
2778         for (i = 0; i < nb_output_streams; i++) {
2779             OutputFile *of;
2780             int64_t ipts;
2781             double  opts;
2782             ost = &output_streams[i];
2783             of = &output_files[ost->file_index];
2784             os = output_files[ost->file_index].ctx;
2785             ist = &input_streams[ost->source_index];
2786             if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2787                 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2788                 continue;
2789             opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2790             ipts = ist->pts;
2791             if (!input_files[ist->file_index].eof_reached) {
2792                 if (ipts < ipts_min) {
2793                     ipts_min = ipts;
2794                     if (input_sync)
2795                         file_index = ist->file_index;
2796                 }
2797                 if (opts < opts_min) {
2798                     opts_min = opts;
2799                     if (!input_sync) file_index = ist->file_index;
2800                 }
2801             }
2802             if (ost->frame_number >= ost->max_frames) {
2803                 int j;
2804                 for (j = 0; j < of->ctx->nb_streams; j++)
2805                     output_streams[of->ost_index + j].is_past_recording_time = 1;
2806                 continue;
2807             }
2808         }
2809         /* if none, if is finished */
2810         if (file_index < 0) {
2811             if (no_packet_count) {
2812                 no_packet_count = 0;
2813                 memset(no_packet, 0, nb_input_files);
2814                 usleep(10000);
2815                 continue;
2816             }
2817             break;
2818         }
2819
2820         /* read a frame from it and output it in the fifo */
2821         is  = input_files[file_index].ctx;
2822         ret = av_read_frame(is, &pkt);
2823         if (ret == AVERROR(EAGAIN)) {
2824             no_packet[file_index] = 1;
2825             no_packet_count++;
2826             continue;
2827         }
2828         if (ret < 0) {
2829             input_files[file_index].eof_reached = 1;
2830             if (opt_shortest)
2831                 break;
2832             else
2833                 continue;
2834         }
2835
2836         no_packet_count = 0;
2837         memset(no_packet, 0, nb_input_files);
2838
2839         if (do_pkt_dump) {
2840             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2841                              is->streams[pkt.stream_index]);
2842         }
2843         /* the following test is needed in case new streams appear
2844            dynamically in stream : we ignore them */
2845         if (pkt.stream_index >= input_files[file_index].nb_streams)
2846             goto discard_packet;
2847         ist_index = input_files[file_index].ist_index + pkt.stream_index;
2848         ist = &input_streams[ist_index];
2849         if (ist->discard)
2850             goto discard_packet;
2851
2852         if (pkt.dts != AV_NOPTS_VALUE)
2853             pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2854         if (pkt.pts != AV_NOPTS_VALUE)
2855             pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2856
2857         if (pkt.pts != AV_NOPTS_VALUE)
2858             pkt.pts *= ist->ts_scale;
2859         if (pkt.dts != AV_NOPTS_VALUE)
2860             pkt.dts *= ist->ts_scale;
2861
2862         //fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n",
2863         //        ist->next_pts,
2864         //        pkt.dts, input_files[ist->file_index].ts_offset,
2865         //        ist->st->codec->codec_type);
2866         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2867             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2868             int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2869             int64_t delta   = pkt_dts - ist->next_pts;
2870             if ((FFABS(delta) > 1LL * dts_delta_threshold * AV_TIME_BASE || pkt_dts + 1 < ist->pts) && !copy_ts) {
2871                 input_files[ist->file_index].ts_offset -= delta;
2872                 av_log(NULL, AV_LOG_DEBUG,
2873                        "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2874                        delta, input_files[ist->file_index].ts_offset);
2875                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2876                 if (pkt.pts != AV_NOPTS_VALUE)
2877                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2878             }
2879         }
2880
2881         // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2882         if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {
2883
2884             av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
2885                    ist->file_index, ist->st->index);
2886             if (exit_on_error)
2887                 exit_program(1);
2888             av_free_packet(&pkt);
2889             continue;
2890         }
2891
2892     discard_packet:
2893         av_free_packet(&pkt);
2894
2895         /* dump report by using the output first video and audio streams */
2896         print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2897     }
2898
2899     /* at the end of stream, we must flush the decoder buffers */
2900     for (i = 0; i < nb_input_streams; i++) {
2901         ist = &input_streams[i];
2902         if (ist->decoding_needed) {
2903             output_packet(ist, output_streams, nb_output_streams, NULL);
2904         }
2905     }
2906     flush_encoders(output_streams, nb_output_streams);
2907
2908     term_exit();
2909
2910     /* write the trailer if needed and close file */
2911     for (i = 0; i < nb_output_files; i++) {
2912         os = output_files[i].ctx;
2913         av_write_trailer(os);
2914     }
2915
2916     /* dump report by using the first video and audio streams */
2917     print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2918
2919     /* close each encoder */
2920     for (i = 0; i < nb_output_streams; i++) {
2921         ost = &output_streams[i];
2922         if (ost->encoding_needed) {
2923             av_freep(&ost->st->codec->stats_in);
2924             avcodec_close(ost->st->codec);
2925         }
2926 #if CONFIG_AVFILTER
2927         avfilter_graph_free(&ost->graph);
2928 #endif
2929     }
2930
2931     /* close each decoder */
2932     for (i = 0; i < nb_input_streams; i++) {
2933         ist = &input_streams[i];
2934         if (ist->decoding_needed) {
2935             avcodec_close(ist->st->codec);
2936         }
2937     }
2938
2939     /* finished ! */
2940     ret = 0;
2941
2942  fail:
2943     av_freep(&bit_buffer);
2944     av_freep(&no_packet);
2945
2946     if (output_streams) {
2947         for (i = 0; i < nb_output_streams; i++) {
2948             ost = &output_streams[i];
2949             if (ost) {
2950                 if (ost->stream_copy)
2951                     av_freep(&ost->st->codec->extradata);
2952                 if (ost->logfile) {
2953                     fclose(ost->logfile);
2954                     ost->logfile = NULL;
2955                 }
2956                 av_fifo_free(ost->fifo); /* works even if fifo is not
2957                                              initialized but set to zero */
2958                 av_freep(&ost->st->codec->subtitle_header);
2959                 av_free(ost->resample_frame.data[0]);
2960                 av_free(ost->forced_kf_pts);
2961                 if (ost->video_resample)
2962                     sws_freeContext(ost->img_resample_ctx);
2963                 if (ost->resample)
2964                     audio_resample_close(ost->resample);
2965                 if (ost->reformat_ctx)
2966                     av_audio_convert_free(ost->reformat_ctx);
2967                 av_dict_free(&ost->opts);
2968             }
2969         }
2970     }
2971     return ret;
2972 }
2973
2974 static double parse_frame_aspect_ratio(const char *arg)
2975 {
2976     int x = 0, y = 0;
2977     double ar = 0;
2978     const char *p;
2979     char *end;
2980
2981     p = strchr(arg, ':');
2982     if (p) {
2983         x = strtol(arg, &end, 10);
2984         if (end == p)
2985             y = strtol(end + 1, &end, 10);
2986         if (x > 0 && y > 0)
2987             ar = (double)x / (double)y;
2988     } else
2989         ar = strtod(arg, NULL);
2990
2991     if (!ar) {
2992         av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2993         exit_program(1);
2994     }
2995     return ar;
2996 }
2997
2998 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2999 {
3000     return parse_option(o, "codec:a", arg, options);
3001 }
3002
3003 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3004 {
3005     return parse_option(o, "codec:v", arg, options);
3006 }
3007
3008 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3009 {
3010     return parse_option(o, "codec:s", arg, options);
3011 }
3012
3013 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3014 {
3015     return parse_option(o, "codec:d", arg, options);
3016 }
3017
3018 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3019 {
3020     StreamMap *m = NULL;
3021     int i, negative = 0, file_idx;
3022     int sync_file_idx = -1, sync_stream_idx;
3023     char *p, *sync;
3024     char *map;
3025
3026     if (*arg == '-') {
3027         negative = 1;
3028         arg++;
3029     }
3030     map = av_strdup(arg);
3031
3032     /* parse sync stream first, just pick first matching stream */
3033     if (sync = strchr(map, ',')) {
3034         *sync = 0;
3035         sync_file_idx = strtol(sync + 1, &sync, 0);
3036         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3037             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3038             exit_program(1);
3039         }
3040         if (*sync)
3041             sync++;
3042         for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
3043             if (check_stream_specifier(input_files[sync_file_idx].ctx,
3044                                        input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
3045                 sync_stream_idx = i;
3046                 break;
3047             }
3048         if (i == input_files[sync_file_idx].nb_streams) {
3049             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3050                                        "match any streams.\n", arg);
3051             exit_program(1);
3052         }
3053     }
3054
3055
3056     file_idx = strtol(map, &p, 0);
3057     if (file_idx >= nb_input_files || file_idx < 0) {
3058         av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3059         exit_program(1);
3060     }
3061     if (negative)
3062         /* disable some already defined maps */
3063         for (i = 0; i < o->nb_stream_maps; i++) {
3064             m = &o->stream_maps[i];
3065             if (file_idx == m->file_index &&
3066                 check_stream_specifier(input_files[m->file_index].ctx,
3067                                        input_files[m->file_index].ctx->streams[m->stream_index],
3068                                        *p == ':' ? p + 1 : p) > 0)
3069                 m->disabled = 1;
3070         }
3071     else
3072         for (i = 0; i < input_files[file_idx].nb_streams; i++) {
3073             if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
3074                         *p == ':' ? p + 1 : p) <= 0)
3075                 continue;
3076             o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3077                                         &o->nb_stream_maps, o->nb_stream_maps + 1);
3078             m = &o->stream_maps[o->nb_stream_maps - 1];
3079
3080             m->file_index   = file_idx;
3081             m->stream_index = i;
3082
3083             if (sync_file_idx >= 0) {
3084                 m->sync_file_index   = sync_file_idx;
3085                 m->sync_stream_index = sync_stream_idx;
3086             } else {
3087                 m->sync_file_index   = file_idx;
3088                 m->sync_stream_index = i;
3089             }
3090         }
3091
3092     if (!m) {
3093         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3094         exit_program(1);
3095     }
3096
3097     av_freep(&map);
3098     return 0;
3099 }
3100
3101 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3102 {
3103     o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3104                                 &o->nb_attachments, o->nb_attachments + 1);
3105     o->attachments[o->nb_attachments - 1] = arg;
3106     return 0;
3107 }
3108
3109 /**
3110  * Parse a metadata specifier in arg.
3111  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3112  * @param index for type c/p, chapter/program index is written here
3113  * @param stream_spec for type s, the stream specifier is written here
3114  */
3115 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3116 {
3117     if (*arg) {
3118         *type = *arg;
3119         switch (*arg) {
3120         case 'g':
3121             break;
3122         case 's':
3123             if (*(++arg) && *arg != ':') {
3124                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3125                 exit_program(1);
3126             }
3127             *stream_spec = *arg == ':' ? arg + 1 : "";
3128             break;
3129         case 'c':
3130         case 'p':
3131             if (*(++arg) == ':')
3132                 *index = strtol(++arg, NULL, 0);
3133             break;
3134         default:
3135             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3136             exit_program(1);
3137         }
3138     } else
3139         *type = 'g';
3140 }
3141
3142 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3143 {
3144     AVDictionary **meta_in = NULL;
3145     AVDictionary **meta_out;
3146     int i, ret = 0;
3147     char type_in, type_out;
3148     const char *istream_spec = NULL, *ostream_spec = NULL;
3149     int idx_in = 0, idx_out = 0;
3150
3151     parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
3152     parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3153
3154     if (type_in == 'g' || type_out == 'g')
3155         o->metadata_global_manual = 1;
3156     if (type_in == 's' || type_out == 's')
3157         o->metadata_streams_manual = 1;
3158     if (type_in == 'c' || type_out == 'c')
3159         o->metadata_chapters_manual = 1;
3160
3161 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3162     if ((index) < 0 || (index) >= (nb_elems)) {\
3163         av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
3164                 (desc), (index));\
3165         exit_program(1);\
3166     }
3167
3168 #define SET_DICT(type, meta, context, index)\
3169         switch (type) {\
3170         case 'g':\
3171             meta = &context->metadata;\
3172             break;\
3173         case 'c':\
3174             METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
3175             meta = &context->chapters[index]->metadata;\
3176             break;\
3177         case 'p':\
3178             METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
3179             meta = &context->programs[index]->metadata;\
3180             break;\
3181         }\
3182
3183     SET_DICT(type_in, meta_in, ic, idx_in);
3184     SET_DICT(type_out, meta_out, oc, idx_out);
3185
3186     /* for input streams choose first matching stream */
3187     if (type_in == 's') {
3188         for (i = 0; i < ic->nb_streams; i++) {
3189             if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
3190                 meta_in = &ic->streams[i]->metadata;
3191                 break;
3192             } else if (ret < 0)
3193                 exit_program(1);
3194         }
3195         if (!meta_in) {
3196             av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
3197             exit_program(1);
3198         }
3199     }
3200
3201     if (type_out == 's') {
3202         for (i = 0; i < oc->nb_streams; i++) {
3203             if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
3204                 meta_out = &oc->streams[i]->metadata;
3205                 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3206             } else if (ret < 0)
3207                 exit_program(1);
3208         }
3209     } else
3210         av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3211
3212     return 0;
3213 }
3214
3215 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3216 {
3217     const char *codec_string = encoder ? "encoder" : "decoder";
3218     AVCodec *codec;
3219
3220     codec = encoder ?
3221         avcodec_find_encoder_by_name(name) :
3222         avcodec_find_decoder_by_name(name);
3223     if (!codec) {
3224         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3225         exit_program(1);
3226     }
3227     if (codec->type != type) {
3228         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3229         exit_program(1);
3230     }
3231     return codec;
3232 }
3233
3234 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3235 {
3236     char *codec_name = NULL;
3237
3238     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3239     if (codec_name) {
3240         AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3241         st->codec->codec_id = codec->id;
3242         return codec;
3243     } else
3244         return avcodec_find_decoder(st->codec->codec_id);
3245 }
3246
3247 /**
3248  * Add all the streams from the given input file to the global
3249  * list of input streams.
3250  */
3251 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3252 {
3253     int i;
3254
3255     for (i = 0; i < ic->nb_streams; i++) {
3256         AVStream *st = ic->streams[i];
3257         AVCodecContext *dec = st->codec;
3258         InputStream *ist;
3259
3260         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3261         ist = &input_streams[nb_input_streams - 1];
3262         ist->st = st;
3263         ist->file_index = nb_input_files;
3264         ist->discard = 1;
3265         ist->opts = filter_codec_opts(codec_opts, choose_decoder(o, ic, st), ic, st);
3266
3267         ist->ts_scale = 1.0;
3268         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
3269
3270         ist->dec = choose_decoder(o, ic, st);
3271
3272         switch (dec->codec_type) {
3273         case AVMEDIA_TYPE_AUDIO:
3274             if(!ist->dec)
3275                 ist->dec = avcodec_find_decoder(dec->codec_id);
3276             if(o->audio_disable)
3277                 st->discard = AVDISCARD_ALL;
3278             break;
3279         case AVMEDIA_TYPE_VIDEO:
3280             if(!ist->dec)
3281                 ist->dec = avcodec_find_decoder(dec->codec_id);
3282             if (dec->lowres) {
3283                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3284             }
3285
3286             if (o->video_disable)
3287                 st->discard = AVDISCARD_ALL;
3288             else if (video_discard)
3289                 st->discard = video_discard;
3290             break;
3291         case AVMEDIA_TYPE_DATA:
3292             break;
3293         case AVMEDIA_TYPE_SUBTITLE:
3294             if(!ist->dec)
3295                 ist->dec = avcodec_find_decoder(dec->codec_id);
3296             if(o->subtitle_disable)
3297                 st->discard = AVDISCARD_ALL;
3298             break;
3299         case AVMEDIA_TYPE_ATTACHMENT:
3300         case AVMEDIA_TYPE_UNKNOWN:
3301             break;
3302         default:
3303             abort();
3304         }
3305     }
3306 }
3307
3308 static void assert_file_overwrite(const char *filename)
3309 {
3310     if ((!file_overwrite || no_file_overwrite) &&
3311         (strchr(filename, ':') == NULL || filename[1] == ':' ||
3312          av_strstart(filename, "file:", NULL))) {
3313         if (avio_check(filename, 0) == 0) {
3314             if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
3315                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3316                 fflush(stderr);
3317                 if (!read_yesno()) {
3318                     fprintf(stderr, "Not overwriting - exiting\n");
3319                     exit_program(1);
3320                 }
3321             }
3322             else {
3323                 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3324                 exit_program(1);
3325             }
3326         }
3327     }
3328 }
3329
3330 static void dump_attachment(AVStream *st, const char *filename)
3331 {
3332     int ret;
3333     AVIOContext *out = NULL;
3334     AVDictionaryEntry *e;
3335
3336     if (!st->codec->extradata_size) {
3337         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
3338                nb_input_files - 1, st->index);
3339         return;
3340     }
3341     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3342         filename = e->value;
3343     if (!*filename) {
3344         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
3345                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3346         exit_program(1);
3347     }
3348
3349     assert_file_overwrite(filename);
3350
3351     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
3352         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3353                filename);
3354         exit_program(1);
3355     }
3356
3357     avio_write(out, st->codec->extradata, st->codec->extradata_size);
3358     avio_flush(out);
3359     avio_close(out);
3360 }
3361
3362 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3363 {
3364     AVFormatContext *ic;
3365     AVInputFormat *file_iformat = NULL;
3366     int err, i, ret;
3367     int64_t timestamp;
3368     uint8_t buf[128];
3369     AVDictionary **opts;
3370     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
3371
3372     if (o->format) {
3373         if (!(file_iformat = av_find_input_format(o->format))) {
3374             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3375             exit_program(1);
3376         }
3377     }
3378
3379     if (!strcmp(filename, "-"))
3380         filename = "pipe:";
3381
3382     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3383                     !strcmp(filename, "/dev/stdin");
3384
3385     /* get default parameters from command line */
3386     ic = avformat_alloc_context();
3387     if (!ic) {
3388         print_error(filename, AVERROR(ENOMEM));
3389         exit_program(1);
3390     }
3391     if (o->nb_audio_sample_rate) {
3392         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3393         av_dict_set(&format_opts, "sample_rate", buf, 0);
3394     }
3395     if (o->nb_audio_channels) {
3396         snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3397         av_dict_set(&format_opts, "channels", buf, 0);
3398     }
3399     if (o->nb_frame_rates) {
3400         av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3401     }
3402     if (o->nb_frame_sizes) {
3403         av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3404     }
3405     if (o->nb_frame_pix_fmts)
3406         av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3407
3408     ic->flags |= AVFMT_FLAG_NONBLOCK;
3409     ic->interrupt_callback = int_cb;
3410
3411     /* open the input file with generic avformat function */
3412     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3413     if (err < 0) {
3414         print_error(filename, err);
3415         exit_program(1);
3416     }
3417     assert_avoptions(format_opts);
3418
3419     /* apply forced codec ids */
3420     for (i = 0; i < ic->nb_streams; i++)
3421         choose_decoder(o, ic, ic->streams[i]);
3422
3423     /* Set AVCodecContext options for avformat_find_stream_info */
3424     opts = setup_find_stream_info_opts(ic, codec_opts);
3425     orig_nb_streams = ic->nb_streams;
3426
3427     /* If not enough info to get the stream parameters, we decode the
3428        first frames to get it. (used in mpeg case for example) */
3429     ret = avformat_find_stream_info(ic, opts);
3430     if (ret < 0) {
3431         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3432         avformat_close_input(&ic);
3433         exit_program(1);
3434     }
3435
3436     timestamp = o->start_time;
3437     /* add the stream start time */
3438     if (ic->start_time != AV_NOPTS_VALUE)
3439         timestamp += ic->start_time;
3440
3441     /* if seeking requested, we execute it */
3442     if (o->start_time != 0) {
3443         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3444         if (ret < 0) {
3445             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3446                    filename, (double)timestamp / AV_TIME_BASE);
3447         }
3448     }
3449
3450     /* update the current parameters so that they match the one of the input stream */
3451     add_input_streams(o, ic);
3452
3453     /* dump the file content */
3454     av_dump_format(ic, nb_input_files, filename, 0);
3455
3456     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3457     input_files[nb_input_files - 1].ctx        = ic;
3458     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3459     input_files[nb_input_files - 1].ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3460     input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3461     input_files[nb_input_files - 1].rate_emu   = o->rate_emu;
3462
3463     for (i = 0; i < o->nb_dump_attachment; i++) {
3464         int j;
3465
3466         for (j = 0; j < ic->nb_streams; j++) {
3467             AVStream *st = ic->streams[j];
3468
3469             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3470                 dump_attachment(st, o->dump_attachment[i].u.str);
3471         }
3472     }
3473
3474     for (i = 0; i < orig_nb_streams; i++)
3475         av_dict_free(&opts[i]);
3476     av_freep(&opts);
3477
3478     reset_options(o);
3479     return 0;
3480 }
3481
3482 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3483                                     AVCodecContext *avctx)
3484 {
3485     char *p;
3486     int n = 1, i;
3487     int64_t t;
3488
3489     for (p = kf; *p; p++)
3490         if (*p == ',')
3491             n++;
3492     ost->forced_kf_count = n;
3493     ost->forced_kf_pts   = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3494     if (!ost->forced_kf_pts) {
3495         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3496         exit_program(1);
3497     }
3498     for (i = 0; i < n; i++) {
3499         p = i ? strchr(p, ',') + 1 : kf;
3500         t = parse_time_or_die("force_key_frames", p, 1);
3501         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3502     }
3503 }
3504
3505 static uint8_t *get_line(AVIOContext *s)
3506 {
3507     AVIOContext *line;
3508     uint8_t *buf;
3509     char c;
3510
3511     if (avio_open_dyn_buf(&line) < 0) {
3512         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3513         exit_program(1);
3514     }
3515
3516     while ((c = avio_r8(s)) && c != '\n')
3517         avio_w8(line, c);
3518     avio_w8(line, 0);
3519     avio_close_dyn_buf(line, &buf);
3520
3521     return buf;
3522 }
3523
3524 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3525 {
3526     int i, ret = 1;
3527     char filename[1000];
3528     const char *base[3] = { getenv("AVCONV_DATADIR"),
3529                             getenv("HOME"),
3530                             AVCONV_DATADIR,
3531                             };
3532
3533     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3534         if (!base[i])
3535             continue;
3536         if (codec_name) {
3537             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3538                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
3539             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3540         }
3541         if (ret) {
3542             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3543                      i != 1 ? "" : "/.avconv", preset_name);
3544             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3545         }
3546     }
3547     return ret;
3548 }
3549
3550 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3551 {
3552     char *codec_name = NULL;
3553
3554     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3555     if (!codec_name) {
3556         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3557                                                   NULL, ost->st->codec->codec_type);
3558         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3559     } else if (!strcmp(codec_name, "copy"))
3560         ost->stream_copy = 1;
3561     else {
3562         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3563         ost->st->codec->codec_id = ost->enc->id;
3564     }
3565 }
3566
3567 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3568 {
3569     OutputStream *ost;
3570     AVStream *st = avformat_new_stream(oc, NULL);
3571     int idx      = oc->nb_streams - 1, ret = 0;
3572     char *bsf = NULL, *next, *codec_tag = NULL;
3573     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3574     double qscale = -1;
3575     char *buf = NULL, *arg = NULL, *preset = NULL;
3576     AVIOContext *s = NULL;
3577
3578     if (!st) {
3579         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3580         exit_program(1);
3581     }
3582
3583     if (oc->nb_streams - 1 < o->nb_streamid_map)
3584         st->id = o->streamid_map[oc->nb_streams - 1];
3585
3586     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3587                                 nb_output_streams + 1);
3588     ost = &output_streams[nb_output_streams - 1];
3589     ost->file_index = nb_output_files;
3590     ost->index      = idx;
3591     ost->st         = st;
3592     st->codec->codec_type = type;
3593     choose_encoder(o, oc, ost);
3594     if (ost->enc) {
3595         ost->opts  = filter_codec_opts(codec_opts, ost->enc, oc, st);
3596     }
3597
3598     avcodec_get_context_defaults3(st->codec, ost->enc);
3599     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3600
3601     MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3602     if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3603         do  {
3604             buf = get_line(s);
3605             if (!buf[0] || buf[0] == '#') {
3606                 av_free(buf);
3607                 continue;
3608             }
3609             if (!(arg = strchr(buf, '='))) {
3610                 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3611                 exit_program(1);
3612             }
3613             *arg++ = 0;
3614             av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3615             av_free(buf);
3616         } while (!s->eof_reached);
3617         avio_close(s);
3618     }
3619     if (ret) {
3620         av_log(NULL, AV_LOG_FATAL,
3621                "Preset %s specified for stream %d:%d, but could not be opened.\n",
3622                preset, ost->file_index, ost->index);
3623         exit_program(1);
3624     }
3625
3626     ost->max_frames = INT64_MAX;
3627     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3628
3629     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3630     while (bsf) {
3631         if (next = strchr(bsf, ','))
3632             *next++ = 0;
3633         if (!(bsfc = av_bitstream_filter_init(bsf))) {
3634             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3635             exit_program(1);
3636         }
3637         if (bsfc_prev)
3638             bsfc_prev->next = bsfc;
3639         else
3640             ost->bitstream_filters = bsfc;
3641
3642         bsfc_prev = bsfc;
3643         bsf       = next;
3644     }
3645
3646     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3647     if (codec_tag) {
3648         uint32_t tag = strtol(codec_tag, &next, 0);
3649         if (*next)
3650             tag = AV_RL32(codec_tag);
3651         st->codec->codec_tag = tag;
3652     }
3653
3654     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3655     if (qscale >= 0 || same_quant) {
3656         st->codec->flags |= CODEC_FLAG_QSCALE;
3657         st->codec->global_quality = FF_QP2LAMBDA * qscale;
3658     }
3659
3660     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3661         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3662
3663     av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3664     return ost;
3665 }
3666
3667 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3668 {
3669     int i;
3670     const char *p = str;
3671     for (i = 0;; i++) {
3672         dest[i] = atoi(p);
3673         if (i == 63)
3674             break;
3675         p = strchr(p, ',');
3676         if (!p) {
3677             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3678             exit_program(1);
3679         }
3680         p++;
3681     }
3682 }
3683
3684 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3685 {
3686     AVStream *st;
3687     OutputStream *ost;
3688     AVCodecContext *video_enc;
3689
3690     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3691     st  = ost->st;
3692     video_enc = st->codec;
3693
3694     if (!ost->stream_copy) {
3695         const char *p = NULL;
3696         char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3697         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3698         char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3699         int i;
3700
3701         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3702         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3703             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3704             exit_program(1);
3705         }
3706
3707         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3708         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3709             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3710             exit_program(1);
3711         }
3712
3713         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3714         if (frame_aspect_ratio)
3715             ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3716
3717         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3718         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3719             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3720             exit_program(1);
3721         }
3722         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3723
3724         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3725         if (intra_matrix) {
3726             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3727                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3728                 exit_program(1);
3729             }
3730             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3731         }
3732         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3733         if (inter_matrix) {
3734             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3735                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3736                 exit_program(1);
3737             }
3738             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3739         }
3740
3741         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3742         for (i = 0; p; i++) {
3743             int start, end, q;
3744             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
3745             if (e != 3) {
3746                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3747                 exit_program(1);
3748             }
3749             video_enc->rc_override =
3750                 av_realloc(video_enc->rc_override,
3751                            sizeof(RcOverride) * (i + 1));
3752             video_enc->rc_override[i].start_frame = start;
3753             video_enc->rc_override[i].end_frame   = end;
3754             if (q > 0) {
3755                 video_enc->rc_override[i].qscale         = q;
3756                 video_enc->rc_override[i].quality_factor = 1.0;
3757             }
3758             else {
3759                 video_enc->rc_override[i].qscale         = 0;
3760                 video_enc->rc_override[i].quality_factor = -q/100.0;
3761             }
3762             p = strchr(p, '/');
3763             if (p) p++;
3764         }
3765         video_enc->rc_override_count = i;
3766         if (!video_enc->rc_initial_buffer_occupancy)
3767             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
3768         video_enc->intra_dc_precision = intra_dc_precision - 8;
3769
3770         /* two pass mode */
3771         if (do_pass) {
3772             if (do_pass == 1) {
3773                 video_enc->flags |= CODEC_FLAG_PASS1;
3774             } else {
3775                 video_enc->flags |= CODEC_FLAG_PASS2;
3776             }
3777         }
3778
3779         MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3780         if (forced_key_frames)
3781             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3782
3783         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
3784
3785         ost->top_field_first = -1;
3786         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
3787
3788 #if CONFIG_AVFILTER
3789         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3790         if (filters)
3791             ost->avfilter = av_strdup(filters);
3792 #endif
3793     } else {
3794         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
3795     }
3796
3797     return ost;
3798 }
3799
3800 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3801 {
3802     AVStream *st;
3803     OutputStream *ost;
3804     AVCodecContext *audio_enc;
3805
3806     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3807     st  = ost->st;
3808
3809     audio_enc = st->codec;
3810     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3811
3812     if (!ost->stream_copy) {
3813         char *sample_fmt = NULL;
3814
3815         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3816
3817         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3818         if (sample_fmt &&
3819             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3820             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3821             exit_program(1);
3822         }
3823
3824         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3825     }
3826
3827     return ost;
3828 }
3829
3830 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3831 {
3832     OutputStream *ost;
3833
3834     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3835     if (!ost->stream_copy) {
3836         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3837         exit_program(1);
3838     }
3839
3840     return ost;
3841 }
3842
3843 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3844 {
3845     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3846     ost->stream_copy = 1;
3847     return ost;
3848 }
3849
3850 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3851 {
3852     AVStream *st;
3853     OutputStream *ost;
3854     AVCodecContext *subtitle_enc;
3855
3856     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3857     st  = ost->st;
3858     subtitle_enc = st->codec;
3859
3860     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3861
3862     return ost;
3863 }
3864
3865 /* arg format is "output-stream-index:streamid-value". */
3866 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3867 {
3868     int idx;
3869     char *p;
3870     char idx_str[16];
3871
3872     av_strlcpy(idx_str, arg, sizeof(idx_str));
3873     p = strchr(idx_str, ':');
3874     if (!p) {
3875         av_log(NULL, AV_LOG_FATAL,
3876                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3877                arg, opt);
3878         exit_program(1);
3879     }
3880     *p++ = '\0';
3881     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3882     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3883     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3884     return 0;
3885 }
3886
3887 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3888 {
3889     AVFormatContext *is = ifile->ctx;
3890     AVFormatContext *os = ofile->ctx;
3891     int i;
3892
3893     for (i = 0; i < is->nb_chapters; i++) {
3894         AVChapter *in_ch = is->chapters[i], *out_ch;
3895         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
3896                                        AV_TIME_BASE_Q, in_ch->time_base);
3897         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3898                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3899
3900
3901         if (in_ch->end < ts_off)
3902             continue;
3903         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3904             break;
3905
3906         out_ch = av_mallocz(sizeof(AVChapter));
3907         if (!out_ch)
3908             return AVERROR(ENOMEM);
3909
3910         out_ch->id        = in_ch->id;
3911         out_ch->time_base = in_ch->time_base;
3912         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
3913         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
3914
3915         if (copy_metadata)
3916             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3917
3918         os->nb_chapters++;
3919         os->chapters = av_realloc(os->chapters, sizeof(AVChapter) * os->nb_chapters);
3920         if (!os->chapters)
3921             return AVERROR(ENOMEM);
3922         os->chapters[os->nb_chapters - 1] = out_ch;
3923     }
3924     return 0;
3925 }
3926
3927 static void opt_output_file(void *optctx, const char *filename)
3928 {
3929     OptionsContext *o = optctx;
3930     AVFormatContext *oc;
3931     int i, err;
3932     AVOutputFormat *file_oformat;
3933     OutputStream *ost;
3934     InputStream  *ist;
3935
3936     if (!strcmp(filename, "-"))
3937         filename = "pipe:";
3938
3939     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3940     if (!oc) {
3941         print_error(filename, err);
3942         exit_program(1);
3943     }
3944
3945     file_oformat= oc->oformat;
3946     oc->interrupt_callback = int_cb;
3947
3948     if (!o->nb_stream_maps) {
3949         /* pick the "best" stream of each type */
3950 #define NEW_STREAM(type, index)\
3951         if (index >= 0) {\
3952             ost = new_ ## type ## _stream(o, oc);\
3953             ost->source_index = index;\
3954             ost->sync_ist     = &input_streams[index];\
3955             input_streams[index].discard = 0;\
3956         }
3957
3958         /* video: highest resolution */
3959         if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3960             int area = 0, idx = -1;
3961             for (i = 0; i < nb_input_streams; i++) {
3962                 ist = &input_streams[i];
3963                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3964                     ist->st->codec->width * ist->st->codec->height > area) {
3965                     area = ist->st->codec->width * ist->st->codec->height;
3966                     idx = i;
3967                 }
3968             }
3969             NEW_STREAM(video, idx);
3970         }
3971
3972         /* audio: most channels */
3973         if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3974             int channels = 0, idx = -1;
3975             for (i = 0; i < nb_input_streams; i++) {
3976                 ist = &input_streams[i];
3977                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3978                     ist->st->codec->channels > channels) {
3979                     channels = ist->st->codec->channels;
3980                     idx = i;
3981                 }
3982             }
3983             NEW_STREAM(audio, idx);
3984         }
3985
3986         /* subtitles: pick first */
3987         if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3988             for (i = 0; i < nb_input_streams; i++)
3989                 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3990                     NEW_STREAM(subtitle, i);
3991                     break;
3992                 }
3993         }
3994         /* do something with data? */
3995     } else {
3996         for (i = 0; i < o->nb_stream_maps; i++) {
3997             StreamMap *map = &o->stream_maps[i];
3998
3999             if (map->disabled)
4000                 continue;
4001
4002             ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
4003             switch (ist->st->codec->codec_type) {
4004             case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
4005             case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
4006             case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
4007             case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
4008             case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
4009             default:
4010                 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
4011                        map->file_index, map->stream_index);
4012                 exit_program(1);
4013             }
4014
4015             ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
4016             ost->sync_ist     = &input_streams[input_files[map->sync_file_index].ist_index +
4017                                            map->sync_stream_index];
4018             ist->discard = 0;
4019         }
4020     }
4021
4022     /* handle attached files */
4023     for (i = 0; i < o->nb_attachments; i++) {
4024         AVIOContext *pb;
4025         uint8_t *attachment;
4026         const char *p;
4027         int64_t len;
4028
4029         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
4030             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
4031                    o->attachments[i]);
4032             exit_program(1);
4033         }
4034         if ((len = avio_size(pb)) <= 0) {
4035             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
4036                    o->attachments[i]);
4037             exit_program(1);
4038         }
4039         if (!(attachment = av_malloc(len))) {
4040             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
4041                    o->attachments[i]);
4042             exit_program(1);
4043         }
4044         avio_read(pb, attachment, len);
4045
4046         ost = new_attachment_stream(o, oc);
4047         ost->stream_copy               = 0;
4048         ost->source_index              = -1;
4049         ost->attachment_filename       = o->attachments[i];
4050         ost->st->codec->extradata      = attachment;
4051         ost->st->codec->extradata_size = len;
4052
4053         p = strrchr(o->attachments[i], '/');
4054         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
4055         avio_close(pb);
4056     }
4057
4058     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
4059     output_files[nb_output_files - 1].ctx       = oc;
4060     output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
4061     output_files[nb_output_files - 1].recording_time = o->recording_time;
4062     output_files[nb_output_files - 1].start_time     = o->start_time;
4063     output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
4064     av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
4065
4066     /* check filename in case of an image number is expected */
4067     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
4068         if (!av_filename_number_test(oc->filename)) {
4069             print_error(oc->filename, AVERROR(EINVAL));
4070             exit_program(1);
4071         }
4072     }
4073
4074     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
4075         /* test if it already exists to avoid losing precious files */
4076         assert_file_overwrite(filename);
4077
4078         /* open the file */
4079         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
4080                               &oc->interrupt_callback,
4081                               &output_files[nb_output_files - 1].opts)) < 0) {
4082             print_error(filename, err);
4083             exit_program(1);
4084         }
4085     }
4086
4087     if (o->mux_preload) {
4088         uint8_t buf[64];
4089         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
4090         av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
4091     }
4092     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
4093
4094     /* copy metadata */
4095     for (i = 0; i < o->nb_metadata_map; i++) {
4096         char *p;
4097         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
4098
4099         if (in_file_index < 0)
4100             continue;
4101         if (in_file_index >= nb_input_files) {
4102             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
4103             exit_program(1);
4104         }
4105         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index].ctx, o);
4106     }
4107
4108     /* copy chapters */
4109     if (o->chapters_input_file >= nb_input_files) {
4110         if (o->chapters_input_file == INT_MAX) {
4111             /* copy chapters from the first input file that has them*/
4112             o->chapters_input_file = -1;
4113             for (i = 0; i < nb_input_files; i++)
4114                 if (input_files[i].ctx->nb_chapters) {
4115                     o->chapters_input_file = i;
4116                     break;
4117                 }
4118         } else {
4119             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4120                    o->chapters_input_file);
4121             exit_program(1);
4122         }
4123     }
4124     if (o->chapters_input_file >= 0)
4125         copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
4126                       !o->metadata_chapters_manual);
4127
4128     /* copy global metadata by default */
4129     if (!o->metadata_global_manual && nb_input_files)
4130         av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
4131                      AV_DICT_DONT_OVERWRITE);
4132     if (!o->metadata_streams_manual)
4133         for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
4134             InputStream *ist;
4135             if (output_streams[i].source_index < 0)         /* this is true e.g. for attached files */
4136                 continue;
4137             ist = &input_streams[output_streams[i].source_index];
4138             av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4139         }
4140
4141     /* process manually set metadata */
4142     for (i = 0; i < o->nb_metadata; i++) {
4143         AVDictionary **m;
4144         char type, *val;
4145         const char *stream_spec;
4146         int index = 0, j, ret;
4147
4148         val = strchr(o->metadata[i].u.str, '=');
4149         if (!val) {
4150             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4151                    o->metadata[i].u.str);
4152             exit_program(1);
4153         }
4154         *val++ = 0;
4155
4156         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
4157         if (type == 's') {
4158             for (j = 0; j < oc->nb_streams; j++) {
4159                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
4160                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
4161                 } else if (ret < 0)
4162                     exit_program(1);
4163             }
4164             printf("ret %d, stream_spec %s\n", ret, stream_spec);
4165         }
4166         else {
4167             switch (type) {
4168             case 'g':
4169                 m = &oc->metadata;
4170                 break;
4171             case 'c':
4172                 if (index < 0 || index >= oc->nb_chapters) {
4173                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4174                     exit_program(1);
4175                 }
4176                 m = &oc->chapters[index]->metadata;
4177                 break;
4178             default:
4179                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4180                 exit_program(1);
4181             }
4182             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4183         }
4184     }
4185
4186     reset_options(o);
4187 }
4188
4189 /* same option as mencoder */
4190 static int opt_pass(const char *opt, const char *arg)
4191 {
4192     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
4193     return 0;
4194 }
4195
4196 static int64_t getutime(void)
4197 {
4198 #if HAVE_GETRUSAGE
4199     struct rusage rusage;
4200
4201     getrusage(RUSAGE_SELF, &rusage);
4202     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4203 #elif HAVE_GETPROCESSTIMES
4204     HANDLE proc;
4205     FILETIME c, e, k, u;
4206     proc = GetCurrentProcess();
4207     GetProcessTimes(proc, &c, &e, &k, &u);
4208     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4209 #else
4210     return av_gettime();
4211 #endif
4212 }
4213
4214 static int64_t getmaxrss(void)
4215 {
4216 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4217     struct rusage rusage;
4218     getrusage(RUSAGE_SELF, &rusage);
4219     return (int64_t)rusage.ru_maxrss * 1024;
4220 #elif HAVE_GETPROCESSMEMORYINFO
4221     HANDLE proc;
4222     PROCESS_MEMORY_COUNTERS memcounters;
4223     proc = GetCurrentProcess();
4224     memcounters.cb = sizeof(memcounters);
4225     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4226     return memcounters.PeakPagefileUsage;
4227 #else
4228     return 0;
4229 #endif
4230 }
4231
4232 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4233 {
4234     return parse_option(o, "q:a", arg, options);
4235 }
4236
4237 static void show_usage(void)
4238 {
4239     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
4240     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4241     av_log(NULL, AV_LOG_INFO, "\n");
4242 }
4243
4244 static int opt_help(const char *opt, const char *arg)
4245 {
4246     int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4247     av_log_set_callback(log_callback_help);
4248     show_usage();
4249     show_help_options(options, "Main options:\n",
4250                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4251     show_help_options(options, "\nAdvanced options:\n",
4252                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4253                       OPT_EXPERT);
4254     show_help_options(options, "\nVideo options:\n",
4255                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4256                       OPT_VIDEO);
4257     show_help_options(options, "\nAdvanced Video options:\n",
4258                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4259                       OPT_VIDEO | OPT_EXPERT);
4260     show_help_options(options, "\nAudio options:\n",
4261                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4262                       OPT_AUDIO);
4263     show_help_options(options, "\nAdvanced Audio options:\n",
4264                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4265                       OPT_AUDIO | OPT_EXPERT);
4266     show_help_options(options, "\nSubtitle options:\n",
4267                       OPT_SUBTITLE | OPT_GRAB,
4268                       OPT_SUBTITLE);
4269     show_help_options(options, "\nAudio/Video grab options:\n",
4270                       OPT_GRAB,
4271                       OPT_GRAB);
4272     printf("\n");
4273     show_help_children(avcodec_get_class(), flags);
4274     show_help_children(avformat_get_class(), flags);
4275     show_help_children(sws_get_class(), flags);
4276
4277     return 0;
4278 }
4279
4280 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4281 {
4282     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4283     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
4284
4285     if (!strncmp(arg, "pal-", 4)) {
4286         norm = PAL;
4287         arg += 4;
4288     } else if (!strncmp(arg, "ntsc-", 5)) {
4289         norm = NTSC;
4290         arg += 5;
4291     } else if (!strncmp(arg, "film-", 5)) {
4292         norm = FILM;
4293         arg += 5;
4294     } else {
4295         /* Try to determine PAL/NTSC by peeking in the input files */
4296         if (nb_input_files) {
4297             int i, j, fr;
4298             for (j = 0; j < nb_input_files; j++) {
4299                 for (i = 0; i < input_files[j].nb_streams; i++) {
4300                     AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4301                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
4302                         continue;
4303                     fr = c->time_base.den * 1000 / c->time_base.num;
4304                     if (fr == 25000) {
4305                         norm = PAL;
4306                         break;
4307                     } else if ((fr == 29970) || (fr == 23976)) {
4308                         norm = NTSC;
4309                         break;
4310                     }
4311                 }
4312                 if (norm != UNKNOWN)
4313                     break;
4314             }
4315         }
4316         if (norm != UNKNOWN)
4317             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4318     }
4319
4320     if (norm == UNKNOWN) {
4321         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4322         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4323         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4324         exit_program(1);
4325     }
4326
4327     if (!strcmp(arg, "vcd")) {
4328         opt_video_codec(o, "c:v", "mpeg1video");
4329         opt_audio_codec(o, "c:a", "mp2");
4330         parse_option(o, "f", "vcd", options);
4331
4332         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4333         parse_option(o, "r", frame_rates[norm], options);
4334         opt_default("g", norm == PAL ? "15" : "18");
4335
4336         opt_default("b", "1150000");
4337         opt_default("maxrate", "1150000");
4338         opt_default("minrate", "1150000");
4339         opt_default("bufsize", "327680"); // 40*1024*8;
4340
4341         opt_default("b:a", "224000");
4342         parse_option(o, "ar", "44100", options);
4343         parse_option(o, "ac", "2", options);
4344
4345         opt_default("packetsize", "2324");
4346         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4347
4348         /* We have to offset the PTS, so that it is consistent with the SCR.
4349            SCR starts at 36000, but the first two packs contain only padding
4350            and the first pack from the other stream, respectively, may also have
4351            been written before.
4352            So the real data starts at SCR 36000+3*1200. */
4353         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
4354     } else if (!strcmp(arg, "svcd")) {
4355
4356         opt_video_codec(o, "c:v", "mpeg2video");
4357         opt_audio_codec(o, "c:a", "mp2");
4358         parse_option(o, "f", "svcd", options);
4359
4360         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4361         parse_option(o, "r", frame_rates[norm], options);
4362         opt_default("g", norm == PAL ? "15" : "18");
4363
4364         opt_default("b", "2040000");
4365         opt_default("maxrate", "2516000");
4366         opt_default("minrate", "0"); // 1145000;
4367         opt_default("bufsize", "1835008"); // 224*1024*8;
4368         opt_default("flags", "+scan_offset");
4369
4370
4371         opt_default("b:a", "224000");
4372         parse_option(o, "ar", "44100", options);
4373
4374         opt_default("packetsize", "2324");
4375
4376     } else if (!strcmp(arg, "dvd")) {
4377
4378         opt_video_codec(o, "c:v", "mpeg2video");
4379         opt_audio_codec(o, "c:a", "ac3");
4380         parse_option(o, "f", "dvd", options);
4381
4382         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4383         parse_option(o, "r", frame_rates[norm], options);
4384         opt_default("g", norm == PAL ? "15" : "18");
4385
4386         opt_default("b", "6000000");
4387         opt_default("maxrate", "9000000");
4388         opt_default("minrate", "0"); // 1500000;
4389         opt_default("bufsize", "1835008"); // 224*1024*8;
4390
4391         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4392         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4393
4394         opt_default("b:a", "448000");
4395         parse_option(o, "ar", "48000", options);
4396
4397     } else if (!strncmp(arg, "dv", 2)) {
4398
4399         parse_option(o, "f", "dv", options);
4400
4401         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4402         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4403                           norm == PAL ? "yuv420p" : "yuv411p", options);
4404         parse_option(o, "r", frame_rates[norm], options);
4405
4406         parse_option(o, "ar", "48000", options);
4407         parse_option(o, "ac", "2", options);
4408
4409     } else {
4410         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4411         return AVERROR(EINVAL);
4412     }
4413     return 0;
4414 }
4415
4416 static int opt_vstats_file(const char *opt, const char *arg)
4417 {
4418     av_free (vstats_filename);
4419     vstats_filename = av_strdup (arg);
4420     return 0;
4421 }
4422
4423 static int opt_vstats(const char *opt, const char *arg)
4424 {
4425     char filename[40];
4426     time_t today2 = time(NULL);
4427     struct tm *today = localtime(&today2);
4428
4429     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4430              today->tm_sec);
4431     return opt_vstats_file(opt, filename);
4432 }
4433
4434 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4435 {
4436     return parse_option(o, "frames:v", arg, options);
4437 }
4438
4439 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4440 {
4441     return parse_option(o, "frames:a", arg, options);
4442 }
4443
4444 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4445 {
4446     return parse_option(o, "frames:d", arg, options);
4447 }
4448
4449 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4450 {
4451 }
4452
4453 static int opt_passlogfile(const char *opt, const char *arg)
4454 {
4455     pass_logfilename_prefix = arg;
4456 #if CONFIG_LIBX264_ENCODER
4457     return opt_default("passlogfile", arg);
4458 #else
4459     return 0;
4460 #endif
4461 }
4462
4463 static int opt_video_tag(OptionsContext *o, const char *opt, const char *arg)
4464 {
4465     return parse_option(o, "tag:v", arg, options);
4466 }
4467
4468 static int opt_audio_tag(OptionsContext *o, const char *opt, const char *arg)
4469 {
4470     return parse_option(o, "tag:a", arg, options);
4471 }
4472
4473 static int opt_subtitle_tag(OptionsContext *o, const char *opt, const char *arg)
4474 {
4475     return parse_option(o, "tag:s", arg, options);
4476 }
4477
4478 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4479 {
4480     return parse_option(o, "filter:v", arg, options);
4481 }
4482
4483 static int opt_vsync(const char *opt, const char *arg)
4484 {
4485     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
4486     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
4487     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
4488
4489     if (video_sync_method == VSYNC_AUTO)
4490         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
4491     return 0;
4492 }
4493
4494 #define OFFSET(x) offsetof(OptionsContext, x)
4495 static const OptionDef options[] = {
4496     /* main options */
4497 #include "cmdutils_common_opts.h"
4498     { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4499     { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4500     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4501     { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
4502     { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4503     { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4504     { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4505     { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
4506     { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
4507       "outfile[,metadata]:infile[,metadata]" },
4508     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)},  "set chapters mapping", "input_file_index" },
4509     { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4510     { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4511     { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4512     { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4513     { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4514     { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4515     { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4516     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4517       "add timings for benchmarking" },
4518     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4519     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4520       "dump each input packet" },
4521     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4522       "when dumping packets, also dump the payload" },
4523     { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4524     { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4525     { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
4526     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4527     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4528     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4529     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4530     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4531     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4532     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4533     { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4534     { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4535     { "tag",   OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4536     { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4537     { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4538 #if CONFIG_AVFILTER
4539     { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4540 #endif
4541     { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4542     { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4543     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4544
4545     /* video options */
4546     { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4547     { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4548     { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4549     { "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" },
4550     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4551     { "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" },
4552     { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4553     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4554     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4555     { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4556     { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4557       "use same quantizer as source (implies VBR)" },
4558     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4559     { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4560     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4561       "deinterlace pictures" },
4562     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4563     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4564 #if CONFIG_AVFILTER
4565     { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4566 #endif
4567     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4568     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4569     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4570     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4571     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4572     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4573     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4574     { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4575     { "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" },
4576
4577     /* audio options */
4578     { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4579     { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4580     { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4581     { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4582     { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4583     { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4584     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4585     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4586     { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4587
4588     /* subtitle options */
4589     { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4590     { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4591     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4592
4593     /* grab options */
4594     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4595
4596     /* muxer options */
4597     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT   | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4598     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)},   "set the initial demux-decode delay", "seconds" },
4599
4600     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4601
4602     /* data codec support */
4603     { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4604
4605     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4606     { NULL, },
4607 };
4608
4609 int main(int argc, char **argv)
4610 {
4611     OptionsContext o = { 0 };
4612     int64_t ti;
4613
4614     reset_options(&o);
4615
4616     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4617     parse_loglevel(argc, argv, options);
4618
4619     if(argc>1 && !strcmp(argv[1], "-d")){
4620         run_as_daemon=1;
4621         av_log_set_callback(log_callback_null);
4622         argc--;
4623         argv++;
4624     }
4625
4626     avcodec_register_all();
4627 #if CONFIG_AVDEVICE
4628     avdevice_register_all();
4629 #endif
4630 #if CONFIG_AVFILTER
4631     avfilter_register_all();
4632 #endif
4633     av_register_all();
4634     avformat_network_init();
4635
4636     show_banner(argc, argv, options);
4637
4638     /* parse options */
4639     parse_options(&o, argc, argv, options, opt_output_file);
4640
4641     if (nb_output_files <= 0 && nb_input_files == 0) {
4642         show_usage();
4643         av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4644         exit_program(1);
4645     }
4646
4647     /* file converter / grab */
4648     if (nb_output_files <= 0) {
4649         fprintf(stderr, "At least one output file must be specified\n");
4650         exit_program(1);
4651     }
4652
4653     if (nb_input_files == 0) {
4654         av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4655         exit_program(1);
4656     }
4657
4658     ti = getutime();
4659     if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4660         exit_program(1);
4661     ti = getutime() - ti;
4662     if (do_benchmark) {
4663         int maxrss = getmaxrss() / 1024;
4664         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4665     }
4666
4667     exit_program(0);
4668     return 0;
4669 }