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

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