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