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 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1532 static int output_packet(InputStream *ist, int ist_index,
1533                          OutputStream *ost_table, int nb_ostreams,
1534                          const AVPacket *pkt)
1535 {
1536     AVFormatContext *os;
1537     OutputStream *ost;
1538     int ret = 0, i;
1539     int got_output;
1540     void *buffer_to_free = NULL;
1541     static unsigned int samples_size= 0;
1542     AVSubtitle subtitle, *subtitle_to_free;
1543     int64_t pkt_pts = AV_NOPTS_VALUE;
1544 #if CONFIG_AVFILTER
1545     int frame_available;
1546 #endif
1547     float quality;
1548
1549     AVPacket avpkt;
1550     int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1551
1552     if(ist->next_pts == AV_NOPTS_VALUE)
1553         ist->next_pts= ist->pts;
1554
1555     if (pkt == NULL) {
1556         /* EOF handling */
1557         av_init_packet(&avpkt);
1558         avpkt.data = NULL;
1559         avpkt.size = 0;
1560         goto handle_eof;
1561     } else {
1562         avpkt = *pkt;
1563     }
1564
1565     if(pkt->dts != AV_NOPTS_VALUE)
1566         ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1567     if(pkt->pts != AV_NOPTS_VALUE)
1568         pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1569
1570     //while we have more to decode or while the decoder did output something on EOF
1571     while (avpkt.size > 0 || (!pkt && got_output)) {
1572         uint8_t *data_buf, *decoded_data_buf;
1573         int data_size, decoded_data_size;
1574         AVFrame *decoded_frame, *filtered_frame;
1575     handle_eof:
1576         ist->pts= ist->next_pts;
1577
1578         if(avpkt.size && avpkt.size != pkt->size)
1579             av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
1580                    "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1581             ist->showed_multi_packet_warning=1;
1582
1583         /* decode the packet if needed */
1584         decoded_frame    = filtered_frame = NULL;
1585         decoded_data_buf = NULL; /* fail safe */
1586         decoded_data_size= 0;
1587         data_buf  = avpkt.data;
1588         data_size = avpkt.size;
1589         subtitle_to_free = NULL;
1590         if (ist->decoding_needed) {
1591             switch(ist->st->codec->codec_type) {
1592             case AVMEDIA_TYPE_AUDIO:{
1593                 if(pkt && samples_size < FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1594                     samples_size = FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1595                     av_free(samples);
1596                     samples= av_malloc(samples_size);
1597                 }
1598                 decoded_data_size= samples_size;
1599                     /* XXX: could avoid copy if PCM 16 bits with same
1600                        endianness as CPU */
1601                 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1602                                             &avpkt);
1603                 if (ret < 0)
1604                     return ret;
1605                 avpkt.data += ret;
1606                 avpkt.size -= ret;
1607                 data_size   = ret;
1608                 got_output  = decoded_data_size > 0;
1609                 /* Some bug in mpeg audio decoder gives */
1610                 /* decoded_data_size < 0, it seems they are overflows */
1611                 if (!got_output) {
1612                     /* no audio frame */
1613                     continue;
1614                 }
1615                 decoded_data_buf = (uint8_t *)samples;
1616                 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1617                     (ist->st->codec->sample_rate * ist->st->codec->channels);
1618                 break;}
1619             case AVMEDIA_TYPE_VIDEO:
1620                     if (!(decoded_frame = avcodec_alloc_frame()))
1621                         return AVERROR(ENOMEM);
1622                     avpkt.pts = pkt_pts;
1623                     avpkt.dts = ist->pts;
1624                     pkt_pts = AV_NOPTS_VALUE;
1625
1626                     ret = avcodec_decode_video2(ist->st->codec,
1627                                                 decoded_frame, &got_output, &avpkt);
1628                     quality = same_quant ? decoded_frame->quality : 0;
1629                     if (ret < 0)
1630                         goto fail;
1631                     if (!got_output) {
1632                         /* no picture yet */
1633                         av_freep(&decoded_frame);
1634                         goto discard_packet;
1635                     }
1636                     ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pkt_pts,
1637                                                                  decoded_frame->pkt_dts);
1638                     if (ist->st->codec->time_base.num != 0) {
1639                         int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1640                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1641                                           ist->st->codec->time_base.num * ticks) /
1642                             ist->st->codec->time_base.den;
1643                     }
1644                     avpkt.size = 0;
1645                     buffer_to_free = NULL;
1646                     pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
1647                     break;
1648             case AVMEDIA_TYPE_SUBTITLE:
1649                 ret = avcodec_decode_subtitle2(ist->st->codec,
1650                                                &subtitle, &got_output, &avpkt);
1651                 if (ret < 0)
1652                     return ret;
1653                 if (!got_output) {
1654                     goto discard_packet;
1655                 }
1656                 subtitle_to_free = &subtitle;
1657                 avpkt.size = 0;
1658                 break;
1659             default:
1660                 return -1;
1661             }
1662         } else {
1663             switch(ist->st->codec->codec_type) {
1664             case AVMEDIA_TYPE_AUDIO:
1665                 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1666                     ist->st->codec->sample_rate;
1667                 break;
1668             case AVMEDIA_TYPE_VIDEO:
1669                 if (ist->st->codec->time_base.num != 0) {
1670                     int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1671                     ist->next_pts += ((int64_t)AV_TIME_BASE *
1672                                       ist->st->codec->time_base.num * ticks) /
1673                         ist->st->codec->time_base.den;
1674                 }
1675                 break;
1676             }
1677             avpkt.size = 0;
1678         }
1679
1680         // preprocess audio (volume)
1681         if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1682             if (audio_volume != 256) {
1683                 switch (ist->st->codec->sample_fmt) {
1684                 case AV_SAMPLE_FMT_U8:
1685                 {
1686                     uint8_t *volp = samples;
1687                     for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1688                         int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1689                         *volp++ = av_clip_uint8(v);
1690                     }
1691                     break;
1692                 }
1693                 case AV_SAMPLE_FMT_S16:
1694                 {
1695                     int16_t *volp = samples;
1696                     for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1697                         int v = ((*volp) * audio_volume + 128) >> 8;
1698                         *volp++ = av_clip_int16(v);
1699                     }
1700                     break;
1701                 }
1702                 case AV_SAMPLE_FMT_S32:
1703                 {
1704                     int32_t *volp = samples;
1705                     for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1706                         int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1707                         *volp++ = av_clipl_int32(v);
1708                     }
1709                     break;
1710                 }
1711                 case AV_SAMPLE_FMT_FLT:
1712                 {
1713                     float *volp = samples;
1714                     float scale = audio_volume / 256.f;
1715                     for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1716                         *volp++ *= scale;
1717                     }
1718                     break;
1719                 }
1720                 case AV_SAMPLE_FMT_DBL:
1721                 {
1722                     double *volp = samples;
1723                     double scale = audio_volume / 256.;
1724                     for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1725                         *volp++ *= scale;
1726                     }
1727                     break;
1728                 }
1729                 default:
1730                     av_log(NULL, AV_LOG_FATAL,
1731                            "Audio volume adjustment on sample format %s is not supported.\n",
1732                            av_get_sample_fmt_name(ist->st->codec->sample_fmt));
1733                     exit_program(1);
1734                 }
1735             }
1736         }
1737
1738         /* frame rate emulation */
1739         if (input_files[ist->file_index].rate_emu) {
1740             int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1741             int64_t now = av_gettime() - ist->start;
1742             if (pts > now)
1743                 usleep(pts - now);
1744         }
1745         /* if output time reached then transcode raw format,
1746            encode packets and output them */
1747         for (i = 0; i < nb_ostreams; i++) {
1748             OutputFile *of = &output_files[ost_table[i].file_index];
1749             int frame_size;
1750
1751             ost = &ost_table[i];
1752             if (ost->source_index != ist_index)
1753                 continue;
1754
1755             if (of->start_time && ist->pts < of->start_time)
1756                 continue;
1757
1758             if (of->recording_time != INT64_MAX &&
1759                 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1760                               (AVRational){1, 1000000}) >= 0) {
1761                 ost->is_past_recording_time = 1;
1762                 continue;
1763             }
1764
1765 #if CONFIG_AVFILTER
1766             if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1767                 ost->input_video_filter) {
1768                 AVRational sar;
1769                 if (ist->st->sample_aspect_ratio.num)
1770                     sar = ist->st->sample_aspect_ratio;
1771                 else
1772                     sar = ist->st->codec->sample_aspect_ratio;
1773                 av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, ist->pts, sar);
1774                 if (!(filtered_frame = avcodec_alloc_frame())) {
1775                     ret = AVERROR(ENOMEM);
1776                     goto fail;
1777                 }
1778             }
1779             frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1780                 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1781             while (frame_available) {
1782                 AVRational ist_pts_tb;
1783                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1784                     get_filtered_video_frame(ost->output_video_filter, filtered_frame, &ost->picref, &ist_pts_tb);
1785                 if (ost->picref)
1786                     ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1787 #else
1788                 filtered_frame = decoded_frame;
1789 #endif
1790                 os = output_files[ost->file_index].ctx;
1791
1792                 /* set the input output pts pairs */
1793                 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1794
1795                 if (ost->encoding_needed) {
1796                     av_assert0(ist->decoding_needed);
1797                     switch(ost->st->codec->codec_type) {
1798                     case AVMEDIA_TYPE_AUDIO:
1799                         do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1800                         break;
1801                     case AVMEDIA_TYPE_VIDEO:
1802 #if CONFIG_AVFILTER
1803                         if (ost->picref->video && !ost->frame_aspect_ratio)
1804                             ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1805 #endif
1806                         do_video_out(os, ost, ist, filtered_frame, &frame_size,
1807                                      same_quant ? quality : ost->st->codec->global_quality);
1808                         if (vstats_filename && frame_size)
1809                             do_video_stats(os, ost, frame_size);
1810                         break;
1811                     case AVMEDIA_TYPE_SUBTITLE:
1812                         do_subtitle_out(os, ost, ist, &subtitle,
1813                                         pkt->pts);
1814                         break;
1815                     default:
1816                         abort();
1817                     }
1818                 } else {
1819                     AVPacket opkt;
1820                     int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1821
1822                     av_init_packet(&opkt);
1823
1824                     if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1825                         !ost->copy_initial_nonkeyframes)
1826 #if !CONFIG_AVFILTER
1827                         continue;
1828 #else
1829                         goto cont;
1830 #endif
1831
1832                     /* no reencoding needed : output the packet directly */
1833                     /* force the input stream PTS */
1834
1835                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1836                         audio_size += data_size;
1837                     else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1838                         video_size += data_size;
1839                         ost->sync_opts++;
1840                     }
1841
1842                     opkt.stream_index= ost->index;
1843                     if(pkt->pts != AV_NOPTS_VALUE)
1844                         opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1845                     else
1846                         opkt.pts= AV_NOPTS_VALUE;
1847
1848                     if (pkt->dts == AV_NOPTS_VALUE)
1849                         opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1850                     else
1851                         opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1852                     opkt.dts -= ost_tb_start_time;
1853
1854                     opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1855                     opkt.flags= pkt->flags;
1856
1857                     //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1858                     if(   ost->st->codec->codec_id != CODEC_ID_H264
1859                        && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1860                        && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1861                        ) {
1862                         if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1863                             opkt.destruct= av_destruct_packet;
1864                     } else {
1865                         opkt.data = data_buf;
1866                         opkt.size = data_size;
1867                     }
1868
1869                     write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1870                     ost->st->codec->frame_number++;
1871                     ost->frame_number++;
1872                     av_free_packet(&opkt);
1873                 }
1874 #if CONFIG_AVFILTER
1875                 cont:
1876                 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1877                                    ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1878                 if (ost->picref)
1879                     avfilter_unref_buffer(ost->picref);
1880             }
1881             av_freep(&filtered_frame);
1882 #endif
1883             }
1884
1885 fail:
1886         av_free(buffer_to_free);
1887         /* XXX: allocate the subtitles in the codec ? */
1888         if (subtitle_to_free) {
1889             avsubtitle_free(subtitle_to_free);
1890             subtitle_to_free = NULL;
1891         }
1892         av_freep(&decoded_frame);
1893         if (ret < 0)
1894             return ret;
1895     }
1896  discard_packet:
1897
1898     return 0;
1899 }
1900
1901 static void print_sdp(OutputFile *output_files, int n)
1902 {
1903     char sdp[2048];
1904     int i;
1905     AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1906
1907     if (!avc)
1908         exit_program(1);
1909     for (i = 0; i < n; i++)
1910         avc[i] = output_files[i].ctx;
1911
1912     av_sdp_create(avc, n, sdp, sizeof(sdp));
1913     printf("SDP:\n%s\n", sdp);
1914     fflush(stdout);
1915     av_freep(&avc);
1916 }
1917
1918 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1919                              char *error, int error_len)
1920 {
1921     int i;
1922     InputStream *ist = &input_streams[ist_index];
1923     if (ist->decoding_needed) {
1924         AVCodec *codec = ist->dec;
1925         if (!codec) {
1926             snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d:%d",
1927                     ist->st->codec->codec_id, ist->file_index, ist->st->index);
1928             return AVERROR(EINVAL);
1929         }
1930
1931         /* update requested sample format for the decoder based on the
1932            corresponding encoder sample format */
1933         for (i = 0; i < nb_output_streams; i++) {
1934             OutputStream *ost = &output_streams[i];
1935             if (ost->source_index == ist_index) {
1936                 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
1937                 break;
1938             }
1939         }
1940
1941         if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1942             snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
1943                     ist->file_index, ist->st->index);
1944             return AVERROR(EINVAL);
1945         }
1946         assert_codec_experimental(ist->st->codec, 0);
1947         assert_avoptions(ist->opts);
1948     }
1949
1950     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;
1951     ist->next_pts = AV_NOPTS_VALUE;
1952     init_pts_correction(&ist->pts_ctx);
1953     ist->is_start = 1;
1954
1955     return 0;
1956 }
1957
1958 static int transcode_init(OutputFile *output_files,
1959                           int nb_output_files,
1960                           InputFile *input_files,
1961                           int nb_input_files)
1962 {
1963     int ret = 0, i, j, k;
1964     AVFormatContext *os;
1965     AVCodecContext *codec, *icodec;
1966     OutputStream *ost;
1967     InputStream *ist;
1968     char error[1024];
1969     int want_sdp = 1;
1970
1971     /* init framerate emulation */
1972     for (i = 0; i < nb_input_files; i++) {
1973         InputFile *ifile = &input_files[i];
1974         if (ifile->rate_emu)
1975             for (j = 0; j < ifile->nb_streams; j++)
1976                 input_streams[j + ifile->ist_index].start = av_gettime();
1977     }
1978
1979     /* output stream init */
1980     for(i=0;i<nb_output_files;i++) {
1981         os = output_files[i].ctx;
1982         if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1983             av_dump_format(os, i, os->filename, 1);
1984             av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
1985             return AVERROR(EINVAL);
1986         }
1987     }
1988
1989     /* for each output stream, we compute the right encoding parameters */
1990     for (i = 0; i < nb_output_streams; i++) {
1991         ost = &output_streams[i];
1992         os = output_files[ost->file_index].ctx;
1993         ist = &input_streams[ost->source_index];
1994
1995         if (ost->attachment_filename)
1996             continue;
1997
1998         codec = ost->st->codec;
1999         icodec = ist->st->codec;
2000
2001         ost->st->disposition = ist->st->disposition;
2002         codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2003         codec->chroma_sample_location = icodec->chroma_sample_location;
2004
2005         if (ost->stream_copy) {
2006             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2007
2008             if (extra_size > INT_MAX) {
2009                 return AVERROR(EINVAL);
2010             }
2011
2012             /* if stream_copy is selected, no need to decode or encode */
2013             codec->codec_id = icodec->codec_id;
2014             codec->codec_type = icodec->codec_type;
2015
2016             if(!codec->codec_tag){
2017                 if(   !os->oformat->codec_tag
2018                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2019                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2020                     codec->codec_tag = icodec->codec_tag;
2021             }
2022
2023             codec->bit_rate = icodec->bit_rate;
2024             codec->rc_max_rate    = icodec->rc_max_rate;
2025             codec->rc_buffer_size = icodec->rc_buffer_size;
2026             codec->extradata= av_mallocz(extra_size);
2027             if (!codec->extradata) {
2028                 return AVERROR(ENOMEM);
2029             }
2030             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2031             codec->extradata_size= icodec->extradata_size;
2032             if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
2033                 codec->time_base = icodec->time_base;
2034                 codec->time_base.num *= icodec->ticks_per_frame;
2035                 av_reduce(&codec->time_base.num, &codec->time_base.den,
2036                           codec->time_base.num, codec->time_base.den, INT_MAX);
2037             }else
2038                 codec->time_base = ist->st->time_base;
2039             switch(codec->codec_type) {
2040             case AVMEDIA_TYPE_AUDIO:
2041                 if(audio_volume != 256) {
2042                     av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2043                     exit_program(1);
2044                 }
2045                 codec->channel_layout = icodec->channel_layout;
2046                 codec->sample_rate = icodec->sample_rate;
2047                 codec->channels = icodec->channels;
2048                 codec->frame_size = icodec->frame_size;
2049                 codec->audio_service_type = icodec->audio_service_type;
2050                 codec->block_align= icodec->block_align;
2051                 break;
2052             case AVMEDIA_TYPE_VIDEO:
2053                 codec->pix_fmt = icodec->pix_fmt;
2054                 codec->width = icodec->width;
2055                 codec->height = icodec->height;
2056                 codec->has_b_frames = icodec->has_b_frames;
2057                 if (!codec->sample_aspect_ratio.num) {
2058                     codec->sample_aspect_ratio =
2059                     ost->st->sample_aspect_ratio =
2060                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2061                         ist->st->codec->sample_aspect_ratio.num ?
2062                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2063                 }
2064                 break;
2065             case AVMEDIA_TYPE_SUBTITLE:
2066                 codec->width = icodec->width;
2067                 codec->height = icodec->height;
2068                 break;
2069             case AVMEDIA_TYPE_DATA:
2070             case AVMEDIA_TYPE_ATTACHMENT:
2071                 break;
2072             default:
2073                 abort();
2074             }
2075         } else {
2076             if (!ost->enc)
2077                 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2078             ist->decoding_needed = 1;
2079             ost->encoding_needed = 1;
2080             switch(codec->codec_type) {
2081             case AVMEDIA_TYPE_AUDIO:
2082                 ost->fifo= av_fifo_alloc(1024);
2083                 if (!ost->fifo) {
2084                     return AVERROR(ENOMEM);
2085                 }
2086                 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2087                 if (!codec->sample_rate)
2088                     codec->sample_rate = icodec->sample_rate;
2089                 choose_sample_rate(ost->st, ost->enc);
2090                 codec->time_base = (AVRational){1, codec->sample_rate};
2091                 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2092                     codec->sample_fmt = icodec->sample_fmt;
2093                 choose_sample_fmt(ost->st, ost->enc);
2094                 if (!codec->channels)
2095                     codec->channels = icodec->channels;
2096                 codec->channel_layout = icodec->channel_layout;
2097                 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2098                     codec->channel_layout = 0;
2099                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2100                 icodec->request_channels = codec->channels;
2101                 ost->resample_sample_fmt  = icodec->sample_fmt;
2102                 ost->resample_sample_rate = icodec->sample_rate;
2103                 ost->resample_channels    = icodec->channels;
2104                 break;
2105             case AVMEDIA_TYPE_VIDEO:
2106                 if (codec->pix_fmt == PIX_FMT_NONE)
2107                     codec->pix_fmt = icodec->pix_fmt;
2108                 choose_pixel_fmt(ost->st, ost->enc);
2109
2110                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2111                     av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2112                     exit_program(1);
2113                 }
2114
2115                 if (!codec->width || !codec->height) {
2116                     codec->width  = icodec->width;
2117                     codec->height = icodec->height;
2118                 }
2119
2120                 ost->video_resample = codec->width   != icodec->width  ||
2121                                       codec->height  != icodec->height ||
2122                                       codec->pix_fmt != icodec->pix_fmt;
2123                 if (ost->video_resample) {
2124 #if !CONFIG_AVFILTER
2125                     avcodec_get_frame_defaults(&ost->pict_tmp);
2126                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2127                                        codec->width, codec->height)) {
2128                         av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
2129                         exit_program(1);
2130                     }
2131                     ost->img_resample_ctx = sws_getContext(
2132                         icodec->width,
2133                         icodec->height,
2134                         icodec->pix_fmt,
2135                         codec->width,
2136                         codec->height,
2137                         codec->pix_fmt,
2138                         ost->sws_flags, NULL, NULL, NULL);
2139                     if (ost->img_resample_ctx == NULL) {
2140                         av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
2141                         exit_program(1);
2142                     }
2143 #endif
2144                     codec->bits_per_raw_sample= 0;
2145                 }
2146
2147                 ost->resample_height = icodec->height;
2148                 ost->resample_width  = icodec->width;
2149                 ost->resample_pix_fmt= icodec->pix_fmt;
2150
2151                 if (!ost->frame_rate.num)
2152                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2153                 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2154                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2155                     ost->frame_rate = ost->enc->supported_framerates[idx];
2156                 }
2157                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2158
2159 #if CONFIG_AVFILTER
2160                 if (configure_video_filters(ist, ost)) {
2161                     av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2162                     exit(1);
2163                 }
2164 #endif
2165                 break;
2166             case AVMEDIA_TYPE_SUBTITLE:
2167                 break;
2168             default:
2169                 abort();
2170                 break;
2171             }
2172             /* two pass mode */
2173             if ((codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2174                 char logfilename[1024];
2175                 FILE *f;
2176
2177                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2178                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2179                          i);
2180                 if (codec->flags & CODEC_FLAG_PASS1) {
2181                     f = fopen(logfilename, "wb");
2182                     if (!f) {
2183                         av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2184                                logfilename, strerror(errno));
2185                         exit_program(1);
2186                     }
2187                     ost->logfile = f;
2188                 } else {
2189                     char  *logbuffer;
2190                     size_t logbuffer_size;
2191                     if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2192                         av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2193                                logfilename);
2194                         exit_program(1);
2195                     }
2196                     codec->stats_in = logbuffer;
2197                 }
2198             }
2199         }
2200         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2201             int size= codec->width * codec->height;
2202             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2203         }
2204     }
2205
2206     if (!bit_buffer)
2207         bit_buffer = av_malloc(bit_buffer_size);
2208     if (!bit_buffer) {
2209         av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2210                bit_buffer_size);
2211         return AVERROR(ENOMEM);
2212     }
2213
2214     /* open each encoder */
2215     for (i = 0; i < nb_output_streams; i++) {
2216         ost = &output_streams[i];
2217         if (ost->encoding_needed) {
2218             AVCodec *codec = ost->enc;
2219             AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2220             if (!codec) {
2221                 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d:%d",
2222                          ost->st->codec->codec_id, ost->file_index, ost->index);
2223                 ret = AVERROR(EINVAL);
2224                 goto dump_format;
2225             }
2226             if (dec->subtitle_header) {
2227                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2228                 if (!ost->st->codec->subtitle_header) {
2229                     ret = AVERROR(ENOMEM);
2230                     goto dump_format;
2231                 }
2232                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2233                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2234             }
2235             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2236                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2237                         ost->file_index, ost->index);
2238                 ret = AVERROR(EINVAL);
2239                 goto dump_format;
2240             }
2241             assert_codec_experimental(ost->st->codec, 1);
2242             assert_avoptions(ost->opts);
2243             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2244                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2245                                              "It takes bits/s as argument, not kbits/s\n");
2246             extra_size += ost->st->codec->extradata_size;
2247
2248             if (ost->st->codec->me_threshold)
2249                 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2250         }
2251     }
2252
2253     /* init input streams */
2254     for (i = 0; i < nb_input_streams; i++)
2255         if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2256             goto dump_format;
2257
2258     /* discard unused programs */
2259     for (i = 0; i < nb_input_files; i++) {
2260         InputFile *ifile = &input_files[i];
2261         for (j = 0; j < ifile->ctx->nb_programs; j++) {
2262             AVProgram *p = ifile->ctx->programs[j];
2263             int discard  = AVDISCARD_ALL;
2264
2265             for (k = 0; k < p->nb_stream_indexes; k++)
2266                 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2267                     discard = AVDISCARD_DEFAULT;
2268                     break;
2269                 }
2270             p->discard = discard;
2271         }
2272     }
2273
2274     /* open files and write file headers */
2275     for (i = 0; i < nb_output_files; i++) {
2276         os = output_files[i].ctx;
2277         os->interrupt_callback = int_cb;
2278         if (avformat_write_header(os, &output_files[i].opts) < 0) {
2279             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2280             ret = AVERROR(EINVAL);
2281             goto dump_format;
2282         }
2283         assert_avoptions(output_files[i].opts);
2284         if (strcmp(os->oformat->name, "rtp")) {
2285             want_sdp = 0;
2286         }
2287     }
2288
2289  dump_format:
2290     /* dump the file output parameters - cannot be done before in case
2291        of stream copy */
2292     for(i=0;i<nb_output_files;i++) {
2293         av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2294     }
2295
2296     /* dump the stream mapping */
2297     av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2298     for (i = 0; i < nb_output_streams; i++) {
2299         ost = &output_streams[i];
2300
2301         if (ost->attachment_filename) {
2302             /* an attached file */
2303             av_log(NULL, AV_LOG_INFO, "  File %s -> Stream #%d:%d\n",
2304                    ost->attachment_filename, ost->file_index, ost->index);
2305             continue;
2306         }
2307         av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d -> #%d:%d",
2308                input_streams[ost->source_index].file_index,
2309                input_streams[ost->source_index].st->index,
2310                ost->file_index,
2311                ost->index);
2312         if (ost->sync_ist != &input_streams[ost->source_index])
2313             av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2314                    ost->sync_ist->file_index,
2315                    ost->sync_ist->st->index);
2316         if (ost->stream_copy)
2317             av_log(NULL, AV_LOG_INFO, " (copy)");
2318         else
2319             av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2320                    input_streams[ost->source_index].dec->name : "?",
2321                    ost->enc ? ost->enc->name : "?");
2322         av_log(NULL, AV_LOG_INFO, "\n");
2323     }
2324
2325     if (ret) {
2326         av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2327         return ret;
2328     }
2329
2330     if (want_sdp) {
2331         print_sdp(output_files, nb_output_files);
2332     }
2333
2334     return 0;
2335 }
2336
2337 /*
2338  * The following code is the main loop of the file converter
2339  */
2340 static int transcode(OutputFile *output_files,
2341                      int nb_output_files,
2342                      InputFile *input_files,
2343                      int nb_input_files)
2344 {
2345     int ret, i;
2346     AVFormatContext *is, *os;
2347     OutputStream *ost;
2348     InputStream *ist;
2349     uint8_t *no_packet;
2350     int no_packet_count=0;
2351     int64_t timer_start;
2352
2353     if (!(no_packet = av_mallocz(nb_input_files)))
2354         exit_program(1);
2355
2356     ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2357     if (ret < 0)
2358         goto fail;
2359
2360     av_log(NULL, AV_LOG_INFO, "Press ctrl-c to stop encoding\n");
2361     term_init();
2362
2363     timer_start = av_gettime();
2364
2365     for(; received_sigterm == 0;) {
2366         int file_index, ist_index;
2367         AVPacket pkt;
2368         int64_t ipts_min;
2369         double opts_min;
2370
2371         ipts_min = INT64_MAX;
2372         opts_min= 1e100;
2373
2374         /* select the stream that we must read now by looking at the
2375            smallest output pts */
2376         file_index = -1;
2377         for (i = 0; i < nb_output_streams; i++) {
2378             OutputFile *of;
2379             int64_t ipts;
2380             double  opts;
2381             ost = &output_streams[i];
2382             of = &output_files[ost->file_index];
2383             os = output_files[ost->file_index].ctx;
2384             ist = &input_streams[ost->source_index];
2385             if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2386                 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2387                 continue;
2388             opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2389             ipts = ist->pts;
2390             if (!input_files[ist->file_index].eof_reached){
2391                 if(ipts < ipts_min) {
2392                     ipts_min = ipts;
2393                     if(input_sync ) file_index = ist->file_index;
2394                 }
2395                 if(opts < opts_min) {
2396                     opts_min = opts;
2397                     if(!input_sync) file_index = ist->file_index;
2398                 }
2399             }
2400             if (ost->frame_number >= ost->max_frames) {
2401                 int j;
2402                 for (j = 0; j < of->ctx->nb_streams; j++)
2403                     output_streams[of->ost_index + j].is_past_recording_time = 1;
2404                 continue;
2405             }
2406         }
2407         /* if none, if is finished */
2408         if (file_index < 0) {
2409             if(no_packet_count){
2410                 no_packet_count=0;
2411                 memset(no_packet, 0, nb_input_files);
2412                 usleep(10000);
2413                 continue;
2414             }
2415             break;
2416         }
2417
2418         /* read a frame from it and output it in the fifo */
2419         is = input_files[file_index].ctx;
2420         ret= av_read_frame(is, &pkt);
2421         if(ret == AVERROR(EAGAIN)){
2422             no_packet[file_index]=1;
2423             no_packet_count++;
2424             continue;
2425         }
2426         if (ret < 0) {
2427             input_files[file_index].eof_reached = 1;
2428             if (opt_shortest)
2429                 break;
2430             else
2431                 continue;
2432         }
2433
2434         no_packet_count=0;
2435         memset(no_packet, 0, nb_input_files);
2436
2437         if (do_pkt_dump) {
2438             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2439                              is->streams[pkt.stream_index]);
2440         }
2441         /* the following test is needed in case new streams appear
2442            dynamically in stream : we ignore them */
2443         if (pkt.stream_index >= input_files[file_index].nb_streams)
2444             goto discard_packet;
2445         ist_index = input_files[file_index].ist_index + pkt.stream_index;
2446         ist = &input_streams[ist_index];
2447         if (ist->discard)
2448             goto discard_packet;
2449
2450         if (pkt.dts != AV_NOPTS_VALUE)
2451             pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2452         if (pkt.pts != AV_NOPTS_VALUE)
2453             pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2454
2455         if(pkt.pts != AV_NOPTS_VALUE)
2456             pkt.pts *= ist->ts_scale;
2457         if(pkt.dts != AV_NOPTS_VALUE)
2458             pkt.dts *= ist->ts_scale;
2459
2460 //        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);
2461         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2462             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2463             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2464             int64_t delta= pkt_dts - ist->next_pts;
2465             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2466                 input_files[ist->file_index].ts_offset -= delta;
2467                 av_log(NULL, AV_LOG_DEBUG, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2468                        delta, input_files[ist->file_index].ts_offset);
2469                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2470                 if(pkt.pts != AV_NOPTS_VALUE)
2471                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2472             }
2473         }
2474
2475         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2476         if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2477
2478             av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
2479                    ist->file_index, ist->st->index);
2480             if (exit_on_error)
2481                 exit_program(1);
2482             av_free_packet(&pkt);
2483             continue;
2484         }
2485
2486     discard_packet:
2487         av_free_packet(&pkt);
2488
2489         /* dump report by using the output first video and audio streams */
2490         print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2491     }
2492
2493     /* at the end of stream, we must flush the decoder buffers */
2494     for (i = 0; i < nb_input_streams; i++) {
2495         ist = &input_streams[i];
2496         if (ist->decoding_needed) {
2497             output_packet(ist, i, output_streams, nb_output_streams, NULL);
2498         }
2499     }
2500     flush_encoders(output_streams, nb_output_streams);
2501
2502     term_exit();
2503
2504     /* write the trailer if needed and close file */
2505     for(i=0;i<nb_output_files;i++) {
2506         os = output_files[i].ctx;
2507         av_write_trailer(os);
2508     }
2509
2510     /* dump report by using the first video and audio streams */
2511     print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2512
2513     /* close each encoder */
2514     for (i = 0; i < nb_output_streams; i++) {
2515         ost = &output_streams[i];
2516         if (ost->encoding_needed) {
2517             av_freep(&ost->st->codec->stats_in);
2518             avcodec_close(ost->st->codec);
2519         }
2520 #if CONFIG_AVFILTER
2521         avfilter_graph_free(&ost->graph);
2522 #endif
2523     }
2524
2525     /* close each decoder */
2526     for (i = 0; i < nb_input_streams; i++) {
2527         ist = &input_streams[i];
2528         if (ist->decoding_needed) {
2529             avcodec_close(ist->st->codec);
2530         }
2531     }
2532
2533     /* finished ! */
2534     ret = 0;
2535
2536  fail:
2537     av_freep(&bit_buffer);
2538     av_freep(&no_packet);
2539
2540     if (output_streams) {
2541         for (i = 0; i < nb_output_streams; i++) {
2542             ost = &output_streams[i];
2543             if (ost) {
2544                 if (ost->stream_copy)
2545                     av_freep(&ost->st->codec->extradata);
2546                 if (ost->logfile) {
2547                     fclose(ost->logfile);
2548                     ost->logfile = NULL;
2549                 }
2550                 av_fifo_free(ost->fifo); /* works even if fifo is not
2551                                              initialized but set to zero */
2552                 av_freep(&ost->st->codec->subtitle_header);
2553                 av_free(ost->pict_tmp.data[0]);
2554                 av_free(ost->forced_kf_pts);
2555                 if (ost->video_resample)
2556                     sws_freeContext(ost->img_resample_ctx);
2557                 if (ost->resample)
2558                     audio_resample_close(ost->resample);
2559                 if (ost->reformat_ctx)
2560                     av_audio_convert_free(ost->reformat_ctx);
2561                 av_dict_free(&ost->opts);
2562             }
2563         }
2564     }
2565     return ret;
2566 }
2567
2568 static double parse_frame_aspect_ratio(const char *arg)
2569 {
2570     int x = 0, y = 0;
2571     double ar = 0;
2572     const char *p;
2573     char *end;
2574
2575     p = strchr(arg, ':');
2576     if (p) {
2577         x = strtol(arg, &end, 10);
2578         if (end == p)
2579             y = strtol(end+1, &end, 10);
2580         if (x > 0 && y > 0)
2581             ar = (double)x / (double)y;
2582     } else
2583         ar = strtod(arg, NULL);
2584
2585     if (!ar) {
2586         av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2587         exit_program(1);
2588     }
2589     return ar;
2590 }
2591
2592 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2593 {
2594     return parse_option(o, "codec:a", arg, options);
2595 }
2596
2597 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2598 {
2599     return parse_option(o, "codec:v", arg, options);
2600 }
2601
2602 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2603 {
2604     return parse_option(o, "codec:s", arg, options);
2605 }
2606
2607 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2608 {
2609     return parse_option(o, "codec:d", arg, options);
2610 }
2611
2612 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2613 {
2614     StreamMap *m = NULL;
2615     int i, negative = 0, file_idx;
2616     int sync_file_idx = -1, sync_stream_idx;
2617     char *p, *sync;
2618     char *map;
2619
2620     if (*arg == '-') {
2621         negative = 1;
2622         arg++;
2623     }
2624     map = av_strdup(arg);
2625
2626     /* parse sync stream first, just pick first matching stream */
2627     if (sync = strchr(map, ',')) {
2628         *sync = 0;
2629         sync_file_idx = strtol(sync + 1, &sync, 0);
2630         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2631             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2632             exit_program(1);
2633         }
2634         if (*sync)
2635             sync++;
2636         for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2637             if (check_stream_specifier(input_files[sync_file_idx].ctx,
2638                                        input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2639                 sync_stream_idx = i;
2640                 break;
2641             }
2642         if (i == input_files[sync_file_idx].nb_streams) {
2643             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2644                                        "match any streams.\n", arg);
2645             exit_program(1);
2646         }
2647     }
2648
2649
2650     file_idx = strtol(map, &p, 0);
2651     if (file_idx >= nb_input_files || file_idx < 0) {
2652         av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
2653         exit_program(1);
2654     }
2655     if (negative)
2656         /* disable some already defined maps */
2657         for (i = 0; i < o->nb_stream_maps; i++) {
2658             m = &o->stream_maps[i];
2659             if (file_idx == m->file_index &&
2660                 check_stream_specifier(input_files[m->file_index].ctx,
2661                                        input_files[m->file_index].ctx->streams[m->stream_index],
2662                                        *p == ':' ? p + 1 : p) > 0)
2663                 m->disabled = 1;
2664         }
2665     else
2666         for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2667             if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2668                         *p == ':' ? p + 1 : p) <= 0)
2669                 continue;
2670             o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2671                                         &o->nb_stream_maps, o->nb_stream_maps + 1);
2672             m = &o->stream_maps[o->nb_stream_maps - 1];
2673
2674             m->file_index   = file_idx;
2675             m->stream_index = i;
2676
2677             if (sync_file_idx >= 0) {
2678                 m->sync_file_index   = sync_file_idx;
2679                 m->sync_stream_index = sync_stream_idx;
2680             } else {
2681                 m->sync_file_index   = file_idx;
2682                 m->sync_stream_index = i;
2683             }
2684         }
2685
2686     if (!m) {
2687         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
2688         exit_program(1);
2689     }
2690
2691     av_freep(&map);
2692     return 0;
2693 }
2694
2695 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
2696 {
2697     o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
2698                                 &o->nb_attachments, o->nb_attachments + 1);
2699     o->attachments[o->nb_attachments - 1] = arg;
2700     return 0;
2701 }
2702
2703 static void parse_meta_type(char *arg, char *type, int *index)
2704 {
2705     if (*arg) {
2706         *type = *arg;
2707         switch (*arg) {
2708         case 'g':
2709             break;
2710         case 's':
2711         case 'c':
2712         case 'p':
2713             if (*(++arg) == ':')
2714                 *index = strtol(++arg, NULL, 0);
2715             break;
2716         default:
2717             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
2718             exit_program(1);
2719         }
2720     } else
2721         *type = 'g';
2722 }
2723
2724 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2725 {
2726     MetadataMap *m, *m1;
2727     char *p;
2728
2729     o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2730                                    &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2731
2732     m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2733     m->file = strtol(arg, &p, 0);
2734     parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2735
2736     m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2737     if (p = strchr(opt, ':'))
2738         parse_meta_type(p + 1, &m1->type, &m1->index);
2739     else
2740         m1->type = 'g';
2741
2742     if (m->type == 'g' || m1->type == 'g')
2743         o->metadata_global_manual = 1;
2744     if (m->type == 's' || m1->type == 's')
2745         o->metadata_streams_manual = 1;
2746     if (m->type == 'c' || m1->type == 'c')
2747         o->metadata_chapters_manual = 1;
2748
2749     return 0;
2750 }
2751
2752 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2753 {
2754     const char *codec_string = encoder ? "encoder" : "decoder";
2755     AVCodec *codec;
2756
2757     codec = encoder ?
2758         avcodec_find_encoder_by_name(name) :
2759         avcodec_find_decoder_by_name(name);
2760     if(!codec) {
2761         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
2762         exit_program(1);
2763     }
2764     if(codec->type != type) {
2765         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
2766         exit_program(1);
2767     }
2768     return codec;
2769 }
2770
2771 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
2772 {
2773     char *codec_name = NULL;
2774
2775     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2776     if (codec_name) {
2777         AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
2778         st->codec->codec_id = codec->id;
2779         return codec;
2780     } else
2781         return avcodec_find_decoder(st->codec->codec_id);
2782 }
2783
2784 /**
2785  * Add all the streams from the given input file to the global
2786  * list of input streams.
2787  */
2788 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2789 {
2790     int i, rfps, rfps_base;
2791
2792     for (i = 0; i < ic->nb_streams; i++) {
2793         AVStream *st = ic->streams[i];
2794         AVCodecContext *dec = st->codec;
2795         InputStream *ist;
2796
2797         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2798         ist = &input_streams[nb_input_streams - 1];
2799         ist->st = st;
2800         ist->file_index = nb_input_files;
2801         ist->discard = 1;
2802         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2803
2804         ist->ts_scale = 1.0;
2805         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
2806
2807         ist->dec = choose_decoder(o, ic, st);
2808
2809         switch (dec->codec_type) {
2810         case AVMEDIA_TYPE_AUDIO:
2811             if (o->audio_disable)
2812                 st->discard= AVDISCARD_ALL;
2813             break;
2814         case AVMEDIA_TYPE_VIDEO:
2815             rfps      = ic->streams[i]->r_frame_rate.num;
2816             rfps_base = ic->streams[i]->r_frame_rate.den;
2817             if (dec->lowres) {
2818                 dec->flags |= CODEC_FLAG_EMU_EDGE;
2819                 dec->height >>= dec->lowres;
2820                 dec->width  >>= dec->lowres;
2821             }
2822
2823             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2824
2825                 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",
2826                        i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2827                        (float)rfps / rfps_base, rfps, rfps_base);
2828             }
2829
2830             if (o->video_disable)
2831                 st->discard= AVDISCARD_ALL;
2832             else if(video_discard)
2833                 st->discard= video_discard;
2834             break;
2835         case AVMEDIA_TYPE_DATA:
2836             break;
2837         case AVMEDIA_TYPE_SUBTITLE:
2838             if (o->subtitle_disable)
2839                 st->discard = AVDISCARD_ALL;
2840             break;
2841         case AVMEDIA_TYPE_ATTACHMENT:
2842         case AVMEDIA_TYPE_UNKNOWN:
2843             break;
2844         default:
2845             abort();
2846         }
2847     }
2848 }
2849
2850 static void assert_file_overwrite(const char *filename)
2851 {
2852     if (!file_overwrite &&
2853         (strchr(filename, ':') == NULL || filename[1] == ':' ||
2854          av_strstart(filename, "file:", NULL))) {
2855         if (avio_check(filename, 0) == 0) {
2856             if (!using_stdin) {
2857                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
2858                 fflush(stderr);
2859                 if (!read_yesno()) {
2860                     fprintf(stderr, "Not overwriting - exiting\n");
2861                     exit_program(1);
2862                 }
2863             }
2864             else {
2865                 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
2866                 exit_program(1);
2867             }
2868         }
2869     }
2870 }
2871
2872 static void dump_attachment(AVStream *st, const char *filename)
2873 {
2874     int ret;
2875     AVIOContext *out = NULL;
2876     AVDictionaryEntry *e;
2877
2878     if (!st->codec->extradata_size) {
2879         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
2880                nb_input_files - 1, st->index);
2881         return;
2882     }
2883     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
2884         filename = e->value;
2885     if (!*filename) {
2886         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
2887                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
2888         exit_program(1);
2889     }
2890
2891     assert_file_overwrite(filename);
2892
2893     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
2894         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
2895                filename);
2896         exit_program(1);
2897     }
2898
2899     avio_write(out, st->codec->extradata, st->codec->extradata_size);
2900     avio_flush(out);
2901     avio_close(out);
2902 }
2903
2904 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
2905 {
2906     AVFormatContext *ic;
2907     AVInputFormat *file_iformat = NULL;
2908     int err, i, ret;
2909     int64_t timestamp;
2910     uint8_t buf[128];
2911     AVDictionary **opts;
2912     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
2913
2914     if (o->format) {
2915         if (!(file_iformat = av_find_input_format(o->format))) {
2916             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
2917             exit_program(1);
2918         }
2919     }
2920
2921     if (!strcmp(filename, "-"))
2922         filename = "pipe:";
2923
2924     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2925                     !strcmp(filename, "/dev/stdin");
2926
2927     /* get default parameters from command line */
2928     ic = avformat_alloc_context();
2929     if (!ic) {
2930         print_error(filename, AVERROR(ENOMEM));
2931         exit_program(1);
2932     }
2933     if (o->nb_audio_sample_rate) {
2934         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
2935         av_dict_set(&format_opts, "sample_rate", buf, 0);
2936     }
2937     if (o->nb_audio_channels) {
2938         snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
2939         av_dict_set(&format_opts, "channels", buf, 0);
2940     }
2941     if (o->nb_frame_rates) {
2942         av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
2943     }
2944     if (o->nb_frame_sizes) {
2945         av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
2946     }
2947     if (o->nb_frame_pix_fmts)
2948         av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
2949
2950     ic->flags |= AVFMT_FLAG_NONBLOCK;
2951     ic->interrupt_callback = int_cb;
2952
2953     /* open the input file with generic libav function */
2954     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
2955     if (err < 0) {
2956         print_error(filename, err);
2957         exit_program(1);
2958     }
2959     assert_avoptions(format_opts);
2960
2961     /* apply forced codec ids */
2962     for (i = 0; i < ic->nb_streams; i++)
2963         choose_decoder(o, ic, ic->streams[i]);
2964
2965     /* Set AVCodecContext options for avformat_find_stream_info */
2966     opts = setup_find_stream_info_opts(ic, codec_opts);
2967     orig_nb_streams = ic->nb_streams;
2968
2969     /* If not enough info to get the stream parameters, we decode the
2970        first frames to get it. (used in mpeg case for example) */
2971     ret = avformat_find_stream_info(ic, opts);
2972     if (ret < 0) {
2973         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
2974         av_close_input_file(ic);
2975         exit_program(1);
2976     }
2977
2978     timestamp = o->start_time;
2979     /* add the stream start time */
2980     if (ic->start_time != AV_NOPTS_VALUE)
2981         timestamp += ic->start_time;
2982
2983     /* if seeking requested, we execute it */
2984     if (o->start_time != 0) {
2985         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2986         if (ret < 0) {
2987             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
2988                    filename, (double)timestamp / AV_TIME_BASE);
2989         }
2990     }
2991
2992     /* update the current parameters so that they match the one of the input stream */
2993     add_input_streams(o, ic);
2994
2995     /* dump the file content */
2996     av_dump_format(ic, nb_input_files, filename, 0);
2997
2998     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
2999     input_files[nb_input_files - 1].ctx        = ic;
3000     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3001     input_files[nb_input_files - 1].ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3002     input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3003     input_files[nb_input_files - 1].rate_emu   = o->rate_emu;
3004
3005     for (i = 0; i < o->nb_dump_attachment; i++) {
3006         int j;
3007
3008         for (j = 0; j < ic->nb_streams; j++) {
3009             AVStream *st = ic->streams[j];
3010
3011             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3012                 dump_attachment(st, o->dump_attachment[i].u.str);
3013         }
3014     }
3015
3016     for (i = 0; i < orig_nb_streams; i++)
3017         av_dict_free(&opts[i]);
3018     av_freep(&opts);
3019
3020     reset_options(o);
3021     return 0;
3022 }
3023
3024 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3025                                     AVCodecContext *avctx)
3026 {
3027     char *p;
3028     int n = 1, i;
3029     int64_t t;
3030
3031     for (p = kf; *p; p++)
3032         if (*p == ',')
3033             n++;
3034     ost->forced_kf_count = n;
3035     ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3036     if (!ost->forced_kf_pts) {
3037         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3038         exit_program(1);
3039     }
3040     for (i = 0; i < n; i++) {
3041         p = i ? strchr(p, ',') + 1 : kf;
3042         t = parse_time_or_die("force_key_frames", p, 1);
3043         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3044     }
3045 }
3046
3047 static uint8_t *get_line(AVIOContext *s)
3048 {
3049     AVIOContext *line;
3050     uint8_t *buf;
3051     char c;
3052
3053     if (avio_open_dyn_buf(&line) < 0) {
3054         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3055         exit_program(1);
3056     }
3057
3058     while ((c = avio_r8(s)) && c != '\n')
3059         avio_w8(line, c);
3060     avio_w8(line, 0);
3061     avio_close_dyn_buf(line, &buf);
3062
3063     return buf;
3064 }
3065
3066 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3067 {
3068     int i, ret = 1;
3069     char filename[1000];
3070     const char *base[3] = { getenv("AVCONV_DATADIR"),
3071                             getenv("HOME"),
3072                             AVCONV_DATADIR,
3073                             };
3074
3075     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3076         if (!base[i])
3077             continue;
3078         if (codec_name) {
3079             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3080                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
3081             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3082         }
3083         if (ret) {
3084             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3085                      i != 1 ? "" : "/.avconv", preset_name);
3086             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3087         }
3088     }
3089     return ret;
3090 }
3091
3092 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3093 {
3094     char *codec_name = NULL;
3095
3096     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3097     if (!codec_name) {
3098         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3099                                                   NULL, ost->st->codec->codec_type);
3100         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3101     } else if (!strcmp(codec_name, "copy"))
3102         ost->stream_copy = 1;
3103     else {
3104         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3105         ost->st->codec->codec_id = ost->enc->id;
3106     }
3107 }
3108
3109 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3110 {
3111     OutputStream *ost;
3112     AVStream *st = avformat_new_stream(oc, NULL);
3113     int idx      = oc->nb_streams - 1, ret = 0;
3114     char *bsf = NULL, *next, *codec_tag = NULL;
3115     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3116     double qscale = -1;
3117     char *buf = NULL, *arg = NULL, *preset = NULL;
3118     AVIOContext *s = NULL;
3119
3120     if (!st) {
3121         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3122         exit_program(1);
3123     }
3124
3125     if (oc->nb_streams - 1 < o->nb_streamid_map)
3126         st->id = o->streamid_map[oc->nb_streams - 1];
3127
3128     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3129                                 nb_output_streams + 1);
3130     ost = &output_streams[nb_output_streams - 1];
3131     ost->file_index = nb_output_files;
3132     ost->index = idx;
3133     ost->st    = st;
3134     st->codec->codec_type = type;
3135     choose_encoder(o, oc, ost);
3136     if (ost->enc) {
3137         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3138     }
3139
3140     avcodec_get_context_defaults3(st->codec, ost->enc);
3141     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3142
3143     MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3144     if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3145         do  {
3146             buf = get_line(s);
3147             if (!buf[0] || buf[0] == '#') {
3148                 av_free(buf);
3149                 continue;
3150             }
3151             if (!(arg = strchr(buf, '='))) {
3152                 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3153                 exit_program(1);
3154             }
3155             *arg++ = 0;
3156             av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3157             av_free(buf);
3158         } while (!s->eof_reached);
3159         avio_close(s);
3160     }
3161     if (ret) {
3162         av_log(NULL, AV_LOG_FATAL,
3163                "Preset %s specified for stream %d:%d, but could not be opened.\n",
3164                preset, ost->file_index, ost->index);
3165         exit_program(1);
3166     }
3167
3168     ost->max_frames = INT64_MAX;
3169     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3170
3171     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3172     while (bsf) {
3173         if (next = strchr(bsf, ','))
3174             *next++ = 0;
3175         if (!(bsfc = av_bitstream_filter_init(bsf))) {
3176             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3177             exit_program(1);
3178         }
3179         if (bsfc_prev)
3180             bsfc_prev->next = bsfc;
3181         else
3182             ost->bitstream_filters = bsfc;
3183
3184         bsfc_prev = bsfc;
3185         bsf       = next;
3186     }
3187
3188     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3189     if (codec_tag) {
3190         uint32_t tag = strtol(codec_tag, &next, 0);
3191         if (*next)
3192             tag = AV_RL32(codec_tag);
3193         st->codec->codec_tag = tag;
3194     }
3195
3196     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3197     if (qscale >= 0 || same_quant) {
3198         st->codec->flags |= CODEC_FLAG_QSCALE;
3199         st->codec->global_quality = FF_QP2LAMBDA * qscale;
3200     }
3201
3202     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3203         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3204
3205     av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3206     return ost;
3207 }
3208
3209 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3210 {
3211     int i;
3212     const char *p = str;
3213     for(i = 0;; i++) {
3214         dest[i] = atoi(p);
3215         if(i == 63)
3216             break;
3217         p = strchr(p, ',');
3218         if(!p) {
3219             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3220             exit_program(1);
3221         }
3222         p++;
3223     }
3224 }
3225
3226 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3227 {
3228     AVStream *st;
3229     OutputStream *ost;
3230     AVCodecContext *video_enc;
3231
3232     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3233     st  = ost->st;
3234     video_enc = st->codec;
3235
3236     if (!ost->stream_copy) {
3237         const char *p = NULL;
3238         char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3239         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3240         char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3241         int i;
3242
3243         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3244         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3245             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3246             exit_program(1);
3247         }
3248
3249         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3250         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3251             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3252             exit_program(1);
3253         }
3254
3255         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3256         if (frame_aspect_ratio)
3257             ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3258
3259         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3260         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3261             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3262             exit_program(1);
3263         }
3264         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3265
3266         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3267         if (intra_matrix) {
3268             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3269                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3270                 exit_program(1);
3271             }
3272             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3273         }
3274         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3275         if (inter_matrix) {
3276             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3277                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3278                 exit_program(1);
3279             }
3280             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3281         }
3282
3283         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3284         for(i=0; p; i++){
3285             int start, end, q;
3286             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3287             if(e!=3){
3288                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3289                 exit_program(1);
3290             }
3291             video_enc->rc_override=
3292                 av_realloc(video_enc->rc_override,
3293                            sizeof(RcOverride)*(i+1));
3294             video_enc->rc_override[i].start_frame= start;
3295             video_enc->rc_override[i].end_frame  = end;
3296             if(q>0){
3297                 video_enc->rc_override[i].qscale= q;
3298                 video_enc->rc_override[i].quality_factor= 1.0;
3299             }
3300             else{
3301                 video_enc->rc_override[i].qscale= 0;
3302                 video_enc->rc_override[i].quality_factor= -q/100.0;
3303             }
3304             p= strchr(p, '/');
3305             if(p) p++;
3306         }
3307         video_enc->rc_override_count=i;
3308         if (!video_enc->rc_initial_buffer_occupancy)
3309             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3310         video_enc->intra_dc_precision= intra_dc_precision - 8;
3311
3312         /* two pass mode */
3313         if (do_pass) {
3314             if (do_pass == 1) {
3315                 video_enc->flags |= CODEC_FLAG_PASS1;
3316             } else {
3317                 video_enc->flags |= CODEC_FLAG_PASS2;
3318             }
3319         }
3320
3321         MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3322         if (forced_key_frames)
3323             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3324
3325         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
3326
3327         ost->top_field_first = -1;
3328         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
3329
3330         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
3331
3332 #if CONFIG_AVFILTER
3333         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3334         if (filters)
3335             ost->avfilter = av_strdup(filters);
3336 #endif
3337     }
3338
3339     return ost;
3340 }
3341
3342 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3343 {
3344     AVStream *st;
3345     OutputStream *ost;
3346     AVCodecContext *audio_enc;
3347
3348     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3349     st  = ost->st;
3350
3351     audio_enc = st->codec;
3352     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3353
3354     if (!ost->stream_copy) {
3355         char *sample_fmt = NULL;
3356
3357         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3358
3359         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3360         if (sample_fmt &&
3361             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3362             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3363             exit_program(1);
3364         }
3365
3366         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3367     }
3368
3369     return ost;
3370 }
3371
3372 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3373 {
3374     OutputStream *ost;
3375
3376     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3377     if (!ost->stream_copy) {
3378         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3379         exit_program(1);
3380     }
3381
3382     return ost;
3383 }
3384
3385 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3386 {
3387     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3388     ost->stream_copy = 1;
3389     return ost;
3390 }
3391
3392 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3393 {
3394     AVStream *st;
3395     OutputStream *ost;
3396     AVCodecContext *subtitle_enc;
3397
3398     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3399     st  = ost->st;
3400     subtitle_enc = st->codec;
3401
3402     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3403
3404     return ost;
3405 }
3406
3407 /* arg format is "output-stream-index:streamid-value". */
3408 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3409 {
3410     int idx;
3411     char *p;
3412     char idx_str[16];
3413
3414     av_strlcpy(idx_str, arg, sizeof(idx_str));
3415     p = strchr(idx_str, ':');
3416     if (!p) {
3417         av_log(NULL, AV_LOG_FATAL,
3418                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3419                arg, opt);
3420         exit_program(1);
3421     }
3422     *p++ = '\0';
3423     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3424     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3425     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3426     return 0;
3427 }
3428
3429 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3430 {
3431     AVFormatContext *is = ifile->ctx;
3432     AVFormatContext *os = ofile->ctx;
3433     int i;
3434
3435     for (i = 0; i < is->nb_chapters; i++) {
3436         AVChapter *in_ch = is->chapters[i], *out_ch;
3437         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
3438                                       AV_TIME_BASE_Q, in_ch->time_base);
3439         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3440                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3441
3442
3443         if (in_ch->end < ts_off)
3444             continue;
3445         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3446             break;
3447
3448         out_ch = av_mallocz(sizeof(AVChapter));
3449         if (!out_ch)
3450             return AVERROR(ENOMEM);
3451
3452         out_ch->id        = in_ch->id;
3453         out_ch->time_base = in_ch->time_base;
3454         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
3455         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
3456
3457         if (copy_metadata)
3458             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3459
3460         os->nb_chapters++;
3461         os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3462         if (!os->chapters)
3463             return AVERROR(ENOMEM);
3464         os->chapters[os->nb_chapters - 1] = out_ch;
3465     }
3466     return 0;
3467 }
3468
3469 static int read_avserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3470 {
3471     int i, err;
3472     AVFormatContext *ic = avformat_alloc_context();
3473
3474     ic->interrupt_callback = int_cb;
3475     err = avformat_open_input(&ic, filename, NULL, NULL);
3476     if (err < 0)
3477         return err;
3478     /* copy stream format */
3479     for(i=0;i<ic->nb_streams;i++) {
3480         AVStream *st;
3481         OutputStream *ost;
3482         AVCodec *codec;
3483
3484         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3485         ost   = new_output_stream(o, s, codec->type);
3486         st    = ost->st;
3487
3488         // FIXME: a more elegant solution is needed
3489         memcpy(st, ic->streams[i], sizeof(AVStream));
3490         st->info = NULL;
3491         avcodec_copy_context(st->codec, ic->streams[i]->codec);
3492
3493         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
3494             choose_sample_fmt(st, codec);
3495         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
3496             choose_pixel_fmt(st, codec);
3497     }
3498
3499     av_close_input_file(ic);
3500     return 0;
3501 }
3502
3503 static void opt_output_file(void *optctx, const char *filename)
3504 {
3505     OptionsContext *o = optctx;
3506     AVFormatContext *oc;
3507     int i, err;
3508     AVOutputFormat *file_oformat;
3509     OutputStream *ost;
3510     InputStream  *ist;
3511
3512     if (!strcmp(filename, "-"))
3513         filename = "pipe:";
3514
3515     oc = avformat_alloc_context();
3516     if (!oc) {
3517         print_error(filename, AVERROR(ENOMEM));
3518         exit_program(1);
3519     }
3520
3521     if (o->format) {
3522         file_oformat = av_guess_format(o->format, NULL, NULL);
3523         if (!file_oformat) {
3524             av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
3525             exit_program(1);
3526         }
3527     } else {
3528         file_oformat = av_guess_format(NULL, filename, NULL);
3529         if (!file_oformat) {
3530             av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
3531                    filename);
3532             exit_program(1);
3533         }
3534     }
3535
3536     oc->oformat = file_oformat;
3537     oc->interrupt_callback = int_cb;
3538     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3539
3540     if (!strcmp(file_oformat->name, "ffm") &&
3541         av_strstart(filename, "http:", NULL)) {
3542         /* special case for files sent to avserver: we get the stream
3543            parameters from avserver */
3544         int err = read_avserver_streams(o, oc, filename);
3545         if (err < 0) {
3546             print_error(filename, err);
3547             exit_program(1);
3548         }
3549     } else if (!o->nb_stream_maps) {
3550         /* pick the "best" stream of each type */
3551 #define NEW_STREAM(type, index)\
3552         if (index >= 0) {\
3553             ost = new_ ## type ## _stream(o, oc);\
3554             ost->source_index = index;\
3555             ost->sync_ist     = &input_streams[index];\
3556             input_streams[index].discard = 0;\
3557         }
3558
3559         /* video: highest resolution */
3560         if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3561             int area = 0, idx = -1;
3562             for (i = 0; i < nb_input_streams; i++) {
3563                 ist = &input_streams[i];
3564                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3565                     ist->st->codec->width * ist->st->codec->height > area) {
3566                     area = ist->st->codec->width * ist->st->codec->height;
3567                     idx = i;
3568                 }
3569             }
3570             NEW_STREAM(video, idx);
3571         }
3572
3573         /* audio: most channels */
3574         if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3575             int channels = 0, idx = -1;
3576             for (i = 0; i < nb_input_streams; i++) {
3577                 ist = &input_streams[i];
3578                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3579                     ist->st->codec->channels > channels) {
3580                     channels = ist->st->codec->channels;
3581                     idx = i;
3582                 }
3583             }
3584             NEW_STREAM(audio, idx);
3585         }
3586
3587         /* subtitles: pick first */
3588         if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3589             for (i = 0; i < nb_input_streams; i++)
3590                 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3591                     NEW_STREAM(subtitle, i);
3592                     break;
3593                 }
3594         }
3595         /* do something with data? */
3596     } else {
3597         for (i = 0; i < o->nb_stream_maps; i++) {
3598             StreamMap *map = &o->stream_maps[i];
3599
3600             if (map->disabled)
3601                 continue;
3602
3603             ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3604             switch (ist->st->codec->codec_type) {
3605             case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
3606             case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
3607             case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3608             case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
3609             case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
3610             default:
3611                 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
3612                        map->file_index, map->stream_index);
3613                 exit_program(1);
3614             }
3615
3616             ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3617             ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3618                                            map->sync_stream_index];
3619             ist->discard = 0;
3620         }
3621     }
3622
3623     /* handle attached files */
3624     for (i = 0; i < o->nb_attachments; i++) {
3625         AVIOContext *pb;
3626         uint8_t *attachment;
3627         const char *p;
3628         int64_t len;
3629
3630         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
3631             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
3632                    o->attachments[i]);
3633             exit_program(1);
3634         }
3635         if ((len = avio_size(pb)) <= 0) {
3636             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
3637                    o->attachments[i]);
3638             exit_program(1);
3639         }
3640         if (!(attachment = av_malloc(len))) {
3641             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
3642                    o->attachments[i]);
3643             exit_program(1);
3644         }
3645         avio_read(pb, attachment, len);
3646
3647         ost = new_attachment_stream(o, oc);
3648         ost->stream_copy               = 0;
3649         ost->source_index              = -1;
3650         ost->attachment_filename       = o->attachments[i];
3651         ost->st->codec->extradata      = attachment;
3652         ost->st->codec->extradata_size = len;
3653
3654         p = strrchr(o->attachments[i], '/');
3655         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
3656         avio_close(pb);
3657     }
3658
3659     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3660     output_files[nb_output_files - 1].ctx       = oc;
3661     output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3662     output_files[nb_output_files - 1].recording_time = o->recording_time;
3663     output_files[nb_output_files - 1].start_time     = o->start_time;
3664     output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3665     av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3666
3667     /* check filename in case of an image number is expected */
3668     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3669         if (!av_filename_number_test(oc->filename)) {
3670             print_error(oc->filename, AVERROR(EINVAL));
3671             exit_program(1);
3672         }
3673     }
3674
3675     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3676         /* test if it already exists to avoid loosing precious files */
3677         assert_file_overwrite(filename);
3678
3679         /* open the file */
3680         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
3681                               &oc->interrupt_callback,
3682                               &output_files[nb_output_files - 1].opts)) < 0) {
3683             print_error(filename, err);
3684             exit_program(1);
3685         }
3686     }
3687
3688     if (o->mux_preload) {
3689         uint8_t buf[64];
3690         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
3691         av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
3692     }
3693     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3694     oc->flags |= AVFMT_FLAG_NONBLOCK;
3695
3696     /* copy chapters */
3697     if (o->chapters_input_file >= nb_input_files) {
3698         if (o->chapters_input_file == INT_MAX) {
3699             /* copy chapters from the first input file that has them*/
3700             o->chapters_input_file = -1;
3701             for (i = 0; i < nb_input_files; i++)
3702                 if (input_files[i].ctx->nb_chapters) {
3703                     o->chapters_input_file = i;
3704                     break;
3705                 }
3706         } else {
3707             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
3708                    o->chapters_input_file);
3709             exit_program(1);
3710         }
3711     }
3712     if (o->chapters_input_file >= 0)
3713         copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3714                       !o->metadata_chapters_manual);
3715
3716     /* copy metadata */
3717     for (i = 0; i < o->nb_meta_data_maps; i++) {
3718         AVFormatContext *files[2];
3719         AVDictionary    **meta[2];
3720         int j;
3721
3722 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3723         if ((index) < 0 || (index) >= (nb_elems)) {\
3724             av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps\n",\
3725                      (desc), (index));\
3726             exit_program(1);\
3727         }
3728
3729         int in_file_index = o->meta_data_maps[i][1].file;
3730         if (in_file_index < 0)
3731             continue;
3732         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3733
3734         files[0] = oc;
3735         files[1] = input_files[in_file_index].ctx;
3736
3737         for (j = 0; j < 2; j++) {
3738             MetadataMap *map = &o->meta_data_maps[i][j];
3739
3740             switch (map->type) {
3741             case 'g':
3742                 meta[j] = &files[j]->metadata;
3743                 break;
3744             case 's':
3745                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3746                 meta[j] = &files[j]->streams[map->index]->metadata;
3747                 break;
3748             case 'c':
3749                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3750                 meta[j] = &files[j]->chapters[map->index]->metadata;
3751                 break;
3752             case 'p':
3753                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3754                 meta[j] = &files[j]->programs[map->index]->metadata;
3755                 break;
3756             }
3757         }
3758
3759         av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3760     }
3761
3762     /* copy global metadata by default */
3763     if (!o->metadata_global_manual && nb_input_files)
3764         av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3765                      AV_DICT_DONT_OVERWRITE);
3766     if (!o->metadata_streams_manual)
3767         for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3768             InputStream *ist;
3769             if (output_streams[i].source_index < 0)         /* this is true e.g. for attached files */
3770                 continue;
3771             ist = &input_streams[output_streams[i].source_index];
3772             av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3773         }
3774
3775     /* process manually set metadata */
3776     for (i = 0; i < o->nb_metadata; i++) {
3777         AVDictionary **m;
3778         char type, *val;
3779         int index = 0;
3780
3781         val = strchr(o->metadata[i].u.str, '=');
3782         if (!val) {
3783             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
3784                    o->metadata[i].u.str);
3785             exit_program(1);
3786         }
3787         *val++ = 0;
3788
3789         parse_meta_type(o->metadata[i].specifier, &type, &index);
3790         switch (type) {
3791         case 'g':
3792             m = &oc->metadata;
3793             break;
3794         case 's':
3795             if (index < 0 || index >= oc->nb_streams) {
3796                 av_log(NULL, AV_LOG_FATAL, "Invalid stream index %d in metadata specifier.\n", index);
3797                 exit_program(1);
3798             }
3799             m = &oc->streams[index]->metadata;
3800             break;
3801         case 'c':
3802             if (index < 0 || index >= oc->nb_chapters) {
3803                 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
3804                 exit_program(1);
3805             }
3806             m = &oc->chapters[index]->metadata;
3807             break;
3808         default:
3809             av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3810             exit_program(1);
3811         }
3812
3813         av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3814     }
3815
3816     reset_options(o);
3817 }
3818
3819 /* same option as mencoder */
3820 static int opt_pass(const char *opt, const char *arg)
3821 {
3822     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3823     return 0;
3824 }
3825
3826 static int64_t getutime(void)
3827 {
3828 #if HAVE_GETRUSAGE
3829     struct rusage rusage;
3830
3831     getrusage(RUSAGE_SELF, &rusage);
3832     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3833 #elif HAVE_GETPROCESSTIMES
3834     HANDLE proc;
3835     FILETIME c, e, k, u;
3836     proc = GetCurrentProcess();
3837     GetProcessTimes(proc, &c, &e, &k, &u);
3838     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3839 #else
3840     return av_gettime();
3841 #endif
3842 }
3843
3844 static int64_t getmaxrss(void)
3845 {
3846 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3847     struct rusage rusage;
3848     getrusage(RUSAGE_SELF, &rusage);
3849     return (int64_t)rusage.ru_maxrss * 1024;
3850 #elif HAVE_GETPROCESSMEMORYINFO
3851     HANDLE proc;
3852     PROCESS_MEMORY_COUNTERS memcounters;
3853     proc = GetCurrentProcess();
3854     memcounters.cb = sizeof(memcounters);
3855     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3856     return memcounters.PeakPagefileUsage;
3857 #else
3858     return 0;
3859 #endif
3860 }
3861
3862 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
3863 {
3864     return parse_option(o, "q:a", arg, options);
3865 }
3866
3867 static void show_usage(void)
3868 {
3869     printf("Hyper fast Audio and Video encoder\n");
3870     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3871     printf("\n");
3872 }
3873
3874 static void show_help(void)
3875 {
3876     int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3877     av_log_set_callback(log_callback_help);
3878     show_usage();
3879     show_help_options(options, "Main options:\n",
3880                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3881     show_help_options(options, "\nAdvanced options:\n",
3882                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3883                       OPT_EXPERT);
3884     show_help_options(options, "\nVideo options:\n",
3885                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3886                       OPT_VIDEO);
3887     show_help_options(options, "\nAdvanced Video options:\n",
3888                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3889                       OPT_VIDEO | OPT_EXPERT);
3890     show_help_options(options, "\nAudio options:\n",
3891                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3892                       OPT_AUDIO);
3893     show_help_options(options, "\nAdvanced Audio options:\n",
3894                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3895                       OPT_AUDIO | OPT_EXPERT);
3896     show_help_options(options, "\nSubtitle options:\n",
3897                       OPT_SUBTITLE | OPT_GRAB,
3898                       OPT_SUBTITLE);
3899     show_help_options(options, "\nAudio/Video grab options:\n",
3900                       OPT_GRAB,
3901                       OPT_GRAB);
3902     printf("\n");
3903     show_help_children(avcodec_get_class(), flags);
3904     show_help_children(avformat_get_class(), flags);
3905     show_help_children(sws_get_class(), flags);
3906 }
3907
3908 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
3909 {
3910     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3911     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3912
3913     if(!strncmp(arg, "pal-", 4)) {
3914         norm = PAL;
3915         arg += 4;
3916     } else if(!strncmp(arg, "ntsc-", 5)) {
3917         norm = NTSC;
3918         arg += 5;
3919     } else if(!strncmp(arg, "film-", 5)) {
3920         norm = FILM;
3921         arg += 5;
3922     } else {
3923         /* Try to determine PAL/NTSC by peeking in the input files */
3924         if(nb_input_files) {
3925             int i, j, fr;
3926             for (j = 0; j < nb_input_files; j++) {
3927                 for (i = 0; i < input_files[j].nb_streams; i++) {
3928                     AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3929                     if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3930                         continue;
3931                     fr = c->time_base.den * 1000 / c->time_base.num;
3932                     if(fr == 25000) {
3933                         norm = PAL;
3934                         break;
3935                     } else if((fr == 29970) || (fr == 23976)) {
3936                         norm = NTSC;
3937                         break;
3938                     }
3939                 }
3940                 if(norm != UNKNOWN)
3941                     break;
3942             }
3943         }
3944         if (norm != UNKNOWN)
3945             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3946     }
3947
3948     if(norm == UNKNOWN) {
3949         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3950         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3951         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
3952         exit_program(1);
3953     }
3954
3955     if(!strcmp(arg, "vcd")) {
3956         opt_video_codec(o, "c:v", "mpeg1video");
3957         opt_audio_codec(o, "c:a", "mp2");
3958         parse_option(o, "f", "vcd", options);
3959
3960         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
3961         parse_option(o, "r", frame_rates[norm], options);
3962         opt_default("g", norm == PAL ? "15" : "18");
3963
3964         opt_default("b", "1150000");
3965         opt_default("maxrate", "1150000");
3966         opt_default("minrate", "1150000");
3967         opt_default("bufsize", "327680"); // 40*1024*8;
3968
3969         opt_default("b:a", "224000");
3970         parse_option(o, "ar", "44100", options);
3971         parse_option(o, "ac", "2", options);
3972
3973         opt_default("packetsize", "2324");
3974         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3975
3976         /* We have to offset the PTS, so that it is consistent with the SCR.
3977            SCR starts at 36000, but the first two packs contain only padding
3978            and the first pack from the other stream, respectively, may also have
3979            been written before.
3980            So the real data starts at SCR 36000+3*1200. */
3981         o->mux_preload = (36000+3*1200) / 90000.0; //0.44
3982     } else if(!strcmp(arg, "svcd")) {
3983
3984         opt_video_codec(o, "c:v", "mpeg2video");
3985         opt_audio_codec(o, "c:a", "mp2");
3986         parse_option(o, "f", "svcd", options);
3987
3988         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
3989         parse_option(o, "r", frame_rates[norm], options);
3990         opt_default("g", norm == PAL ? "15" : "18");
3991
3992         opt_default("b", "2040000");
3993         opt_default("maxrate", "2516000");
3994         opt_default("minrate", "0"); //1145000;
3995         opt_default("bufsize", "1835008"); //224*1024*8;
3996         opt_default("flags", "+scan_offset");
3997
3998
3999         opt_default("b:a", "224000");
4000         parse_option(o, "ar", "44100", options);
4001
4002         opt_default("packetsize", "2324");
4003
4004     } else if(!strcmp(arg, "dvd")) {
4005
4006         opt_video_codec(o, "c:v", "mpeg2video");
4007         opt_audio_codec(o, "c:a", "ac3");
4008         parse_option(o, "f", "dvd", options);
4009
4010         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4011         parse_option(o, "r", frame_rates[norm], options);
4012         opt_default("g", norm == PAL ? "15" : "18");
4013
4014         opt_default("b", "6000000");
4015         opt_default("maxrate", "9000000");
4016         opt_default("minrate", "0"); //1500000;
4017         opt_default("bufsize", "1835008"); //224*1024*8;
4018
4019         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4020         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4021
4022         opt_default("b:a", "448000");
4023         parse_option(o, "ar", "48000", options);
4024
4025     } else if(!strncmp(arg, "dv", 2)) {
4026
4027         parse_option(o, "f", "dv", options);
4028
4029         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4030         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4031                           norm == PAL ? "yuv420p" : "yuv411p", options);
4032         parse_option(o, "r", frame_rates[norm], options);
4033
4034         parse_option(o, "ar", "48000", options);
4035         parse_option(o, "ac", "2", options);
4036
4037     } else {
4038         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4039         return AVERROR(EINVAL);
4040     }
4041     return 0;
4042 }
4043
4044 static int opt_vstats_file(const char *opt, const char *arg)
4045 {
4046     av_free (vstats_filename);
4047     vstats_filename=av_strdup (arg);
4048     return 0;
4049 }
4050
4051 static int opt_vstats(const char *opt, const char *arg)
4052 {
4053     char filename[40];
4054     time_t today2 = time(NULL);
4055     struct tm *today = localtime(&today2);
4056
4057     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4058              today->tm_sec);
4059     return opt_vstats_file(opt, filename);
4060 }
4061
4062 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4063 {
4064     return parse_option(o, "frames:v", arg, options);
4065 }
4066
4067 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4068 {
4069     return parse_option(o, "frames:a", arg, options);
4070 }
4071
4072 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4073 {
4074     return parse_option(o, "frames:d", arg, options);
4075 }
4076
4077 static int opt_video_tag(OptionsContext *o, const char *opt, const char *arg)
4078 {
4079     return parse_option(o, "tag:v", arg, options);
4080 }
4081
4082 static int opt_audio_tag(OptionsContext *o, const char *opt, const char *arg)
4083 {
4084     return parse_option(o, "tag:a", arg, options);
4085 }
4086
4087 static int opt_subtitle_tag(OptionsContext *o, const char *opt, const char *arg)
4088 {
4089     return parse_option(o, "tag:s", arg, options);
4090 }
4091
4092 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4093 {
4094     return parse_option(o, "filter:v", arg, options);
4095 }
4096
4097 #define OFFSET(x) offsetof(OptionsContext, x)
4098 static const OptionDef options[] = {
4099     /* main options */
4100 #include "cmdutils_common_opts.h"
4101     { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4102     { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4103     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4104     { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4105     { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4106     { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4107     { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4108     { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4109       "outfile[,metadata]:infile[,metadata]" },
4110     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)},  "set chapters mapping", "input_file_index" },
4111     { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4112     { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4113     { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4114     { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4115     { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4116     { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4117     { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4118     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4119       "add timings for benchmarking" },
4120     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4121     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4122       "dump each input packet" },
4123     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4124       "when dumping packets, also dump the payload" },
4125     { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4126     { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4127     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4128     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4129     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4130     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4131     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4132     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4133     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4134     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4135     { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4136     { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4137     { "tag",   OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4138     { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4139     { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4140 #if CONFIG_AVFILTER
4141     { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4142 #endif
4143     { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4144     { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4145     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4146
4147     /* video options */
4148     { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4149     { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4150     { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4151     { "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" },
4152     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4153     { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4154     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4155     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4156     { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4157     { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4158       "use same quantizer as source (implies VBR)" },
4159     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4160     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4161     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4162       "deinterlace pictures" },
4163     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4164     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4165 #if CONFIG_AVFILTER
4166     { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4167 #endif
4168     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4169     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4170     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4171     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4172     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4173     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4174     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4175     { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4176     { "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" },
4177
4178     /* audio options */
4179     { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4180     { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4181     { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4182     { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4183     { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4184     { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4185     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4186     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4187     { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4188
4189     /* subtitle options */
4190     { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4191     { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4192     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4193
4194     /* grab options */
4195     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4196
4197     /* muxer options */
4198     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT   | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4199     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)},   "set the initial demux-decode delay", "seconds" },
4200
4201     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4202
4203     /* data codec support */
4204     { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4205
4206     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4207     { NULL, },
4208 };
4209
4210 int main(int argc, char **argv)
4211 {
4212     OptionsContext o = { 0 };
4213     int64_t ti;
4214
4215     reset_options(&o);
4216
4217     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4218     parse_loglevel(argc, argv, options);
4219
4220     avcodec_register_all();
4221 #if CONFIG_AVDEVICE
4222     avdevice_register_all();
4223 #endif
4224 #if CONFIG_AVFILTER
4225     avfilter_register_all();
4226 #endif
4227     av_register_all();
4228     avformat_network_init();
4229
4230     show_banner();
4231
4232     /* parse options */
4233     parse_options(&o, argc, argv, options, opt_output_file);
4234
4235     if(nb_output_files <= 0 && nb_input_files == 0) {
4236         show_usage();
4237         av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4238         exit_program(1);
4239     }
4240
4241     /* file converter / grab */
4242     if (nb_output_files <= 0) {
4243         fprintf(stderr, "At least one output file must be specified\n");
4244         exit_program(1);
4245     }
4246
4247     if (nb_input_files == 0) {
4248         av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4249         exit_program(1);
4250     }
4251
4252     ti = getutime();
4253     if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4254         exit_program(1);
4255     ti = getutime() - ti;
4256     if (do_benchmark) {
4257         int maxrss = getmaxrss() / 1024;
4258         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4259     }
4260
4261     exit_program(0);
4262     return 0;
4263 }