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