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