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

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