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