avconv.c

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