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

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