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->field_order    = icodec->field_order;
2074             codec->extradata      = av_mallocz(extra_size);
2075             if (!codec->extradata) {
2076                 return AVERROR(ENOMEM);
2077             }
2078             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2079             codec->extradata_size = icodec->extradata_size;
2080             if (!copy_tb) {
2081                 codec->time_base      = icodec->time_base;
2082                 codec->time_base.num *= icodec->ticks_per_frame;
2083                 av_reduce(&codec->time_base.num, &codec->time_base.den,
2084                           codec->time_base.num, codec->time_base.den, INT_MAX);
2085             } else
2086                 codec->time_base = ist->st->time_base;
2087
2088             switch(codec->codec_type) {
2089             case AVMEDIA_TYPE_AUDIO:
2090                 if(audio_volume != 256) {
2091                     av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2092                     exit_program(1);
2093                 }
2094                 codec->channel_layout     = icodec->channel_layout;
2095                 codec->sample_rate        = icodec->sample_rate;
2096                 codec->channels           = icodec->channels;
2097                 codec->frame_size         = icodec->frame_size;
2098                 codec->audio_service_type = icodec->audio_service_type;
2099                 codec->block_align        = icodec->block_align;
2100                 break;
2101             case AVMEDIA_TYPE_VIDEO:
2102                 codec->pix_fmt            = icodec->pix_fmt;
2103                 codec->width              = icodec->width;
2104                 codec->height             = icodec->height;
2105                 codec->has_b_frames       = icodec->has_b_frames;
2106                 if (!codec->sample_aspect_ratio.num) {
2107                     codec->sample_aspect_ratio   =
2108                     ost->st->sample_aspect_ratio =
2109                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2110                         ist->st->codec->sample_aspect_ratio.num ?
2111                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2112                 }
2113                 break;
2114             case AVMEDIA_TYPE_SUBTITLE:
2115                 codec->width  = icodec->width;
2116                 codec->height = icodec->height;
2117                 break;
2118             case AVMEDIA_TYPE_DATA:
2119             case AVMEDIA_TYPE_ATTACHMENT:
2120                 break;
2121             default:
2122                 abort();
2123             }
2124         } else {
2125             if (!ost->enc)
2126                 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2127
2128             ist->decoding_needed = 1;
2129             ost->encoding_needed = 1;
2130
2131             switch(codec->codec_type) {
2132             case AVMEDIA_TYPE_AUDIO:
2133                 ost->fifo = av_fifo_alloc(1024);
2134                 if (!ost->fifo) {
2135                     return AVERROR(ENOMEM);
2136                 }
2137                 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2138
2139                 if (!codec->sample_rate)
2140                     codec->sample_rate = icodec->sample_rate;
2141                 choose_sample_rate(ost->st, ost->enc);
2142                 codec->time_base = (AVRational){1, codec->sample_rate};
2143
2144                 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2145                     codec->sample_fmt = icodec->sample_fmt;
2146                 choose_sample_fmt(ost->st, ost->enc);
2147
2148                 if (!codec->channels)
2149                     codec->channels = icodec->channels;
2150                 codec->channel_layout = icodec->channel_layout;
2151                 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2152                     codec->channel_layout = 0;
2153
2154                 ost->audio_resample       = codec-> sample_rate != icodec->sample_rate || audio_sync_method > 1;
2155                 icodec->request_channels  = codec-> channels;
2156                 ost->resample_sample_fmt  = icodec->sample_fmt;
2157                 ost->resample_sample_rate = icodec->sample_rate;
2158                 ost->resample_channels    = icodec->channels;
2159                 break;
2160             case AVMEDIA_TYPE_VIDEO:
2161                 if (codec->pix_fmt == PIX_FMT_NONE)
2162                     codec->pix_fmt = icodec->pix_fmt;
2163                 choose_pixel_fmt(ost->st, ost->enc);
2164
2165                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2166                     av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2167                     exit_program(1);
2168                 }
2169
2170                 if (!codec->width || !codec->height) {
2171                     codec->width  = icodec->width;
2172                     codec->height = icodec->height;
2173                 }
2174
2175                 ost->video_resample = codec->width   != icodec->width  ||
2176                                       codec->height  != icodec->height ||
2177                                       codec->pix_fmt != icodec->pix_fmt;
2178                 if (ost->video_resample) {
2179 #if !CONFIG_AVFILTER
2180                     avcodec_get_frame_defaults(&ost->pict_tmp);
2181                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2182                                        codec->width, codec->height)) {
2183                         av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
2184                         exit_program(1);
2185                     }
2186                     ost->img_resample_ctx = sws_getContext(
2187                         icodec->width,
2188                         icodec->height,
2189                         icodec->pix_fmt,
2190                         codec->width,
2191                         codec->height,
2192                         codec->pix_fmt,
2193                         ost->sws_flags, NULL, NULL, NULL);
2194                     if (ost->img_resample_ctx == NULL) {
2195                         av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
2196                         exit_program(1);
2197                     }
2198 #endif
2199                     codec->bits_per_raw_sample= 0;
2200                 }
2201
2202                 ost->resample_height  = icodec->height;
2203                 ost->resample_width   = icodec->width;
2204                 ost->resample_pix_fmt = icodec->pix_fmt;
2205
2206                 if (!ost->frame_rate.num)
2207                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2208                 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2209                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2210                     ost->frame_rate = ost->enc->supported_framerates[idx];
2211                 }
2212                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2213
2214 #if CONFIG_AVFILTER
2215                 if (configure_video_filters(ist, ost)) {
2216                     av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2217                     exit(1);
2218                 }
2219 #endif
2220                 break;
2221             case AVMEDIA_TYPE_SUBTITLE:
2222                 break;
2223             default:
2224                 abort();
2225                 break;
2226             }
2227             /* two pass mode */
2228             if ((codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2229                 char logfilename[1024];
2230                 FILE *f;
2231
2232                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2233                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2234                          i);
2235                 if (codec->flags & CODEC_FLAG_PASS1) {
2236                     f = fopen(logfilename, "wb");
2237                     if (!f) {
2238                         av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2239                                logfilename, strerror(errno));
2240                         exit_program(1);
2241                     }
2242                     ost->logfile = f;
2243                 } else {
2244                     char  *logbuffer;
2245                     size_t logbuffer_size;
2246                     if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2247                         av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2248                                logfilename);
2249                         exit_program(1);
2250                     }
2251                     codec->stats_in = logbuffer;
2252                 }
2253             }
2254         }
2255         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2256             int        size = codec->width * codec->height;
2257             bit_buffer_size = FFMAX(bit_buffer_size, 6*size + 200);
2258         }
2259     }
2260
2261     if (!bit_buffer)
2262         bit_buffer = av_malloc(bit_buffer_size);
2263     if (!bit_buffer) {
2264         av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2265                bit_buffer_size);
2266         return AVERROR(ENOMEM);
2267     }
2268
2269     /* open each encoder */
2270     for (i = 0; i < nb_output_streams; i++) {
2271         ost = &output_streams[i];
2272         if (ost->encoding_needed) {
2273             AVCodec      *codec = ost->enc;
2274             AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2275             if (!codec) {
2276                 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d:%d",
2277                          ost->st->codec->codec_id, ost->file_index, ost->index);
2278                 ret = AVERROR(EINVAL);
2279                 goto dump_format;
2280             }
2281             if (dec->subtitle_header) {
2282                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2283                 if (!ost->st->codec->subtitle_header) {
2284                     ret = AVERROR(ENOMEM);
2285                     goto dump_format;
2286                 }
2287                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2288                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2289             }
2290             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2291                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2292                         ost->file_index, ost->index);
2293                 ret = AVERROR(EINVAL);
2294                 goto dump_format;
2295             }
2296             assert_codec_experimental(ost->st->codec, 1);
2297             assert_avoptions(ost->opts);
2298             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2299                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2300                                              "It takes bits/s as argument, not kbits/s\n");
2301             extra_size += ost->st->codec->extradata_size;
2302
2303             if (ost->st->codec->me_threshold)
2304                 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2305         }
2306     }
2307
2308     /* init input streams */
2309     for (i = 0; i < nb_input_streams; i++)
2310         if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2311             goto dump_format;
2312
2313     /* discard unused programs */
2314     for (i = 0; i < nb_input_files; i++) {
2315         InputFile *ifile = &input_files[i];
2316         for (j = 0; j < ifile->ctx->nb_programs; j++) {
2317             AVProgram *p = ifile->ctx->programs[j];
2318             int discard  = AVDISCARD_ALL;
2319
2320             for (k = 0; k < p->nb_stream_indexes; k++)
2321                 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2322                     discard = AVDISCARD_DEFAULT;
2323                     break;
2324                 }
2325             p->discard = discard;
2326         }
2327     }
2328
2329     /* open files and write file headers */
2330     for (i = 0; i < nb_output_files; i++) {
2331         oc = output_files[i].ctx;
2332         oc->interrupt_callback = int_cb;
2333         if (avformat_write_header(oc, &output_files[i].opts) < 0) {
2334             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2335             ret = AVERROR(EINVAL);
2336             goto dump_format;
2337         }
2338         assert_avoptions(output_files[i].opts);
2339         if (strcmp(oc->oformat->name, "rtp")) {
2340             want_sdp = 0;
2341         }
2342     }
2343
2344  dump_format:
2345     /* dump the file output parameters - cannot be done before in case
2346        of stream copy */
2347     for (i = 0; i < nb_output_files; i++) {
2348         av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2349     }
2350
2351     /* dump the stream mapping */
2352     av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2353     for (i = 0; i < nb_output_streams; i++) {
2354         ost = &output_streams[i];
2355
2356         if (ost->attachment_filename) {
2357             /* an attached file */
2358             av_log(NULL, AV_LOG_INFO, "  File %s -> Stream #%d:%d\n",
2359                    ost->attachment_filename, ost->file_index, ost->index);
2360             continue;
2361         }
2362         av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d -> #%d:%d",
2363                input_streams[ost->source_index].file_index,
2364                input_streams[ost->source_index].st->index,
2365                ost->file_index,
2366                ost->index);
2367         if (ost->sync_ist != &input_streams[ost->source_index])
2368             av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2369                    ost->sync_ist->file_index,
2370                    ost->sync_ist->st->index);
2371         if (ost->stream_copy)
2372             av_log(NULL, AV_LOG_INFO, " (copy)");
2373         else
2374             av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2375                    input_streams[ost->source_index].dec->name : "?",
2376                    ost->enc ? ost->enc->name : "?");
2377         av_log(NULL, AV_LOG_INFO, "\n");
2378     }
2379
2380     if (ret) {
2381         av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2382         return ret;
2383     }
2384
2385     if (want_sdp) {
2386         print_sdp(output_files, nb_output_files);
2387     }
2388
2389     return 0;
2390 }
2391
2392 /*
2393  * The following code is the main loop of the file converter
2394  */
2395 static int transcode(OutputFile *output_files,
2396                      int nb_output_files,
2397                      InputFile *input_files,
2398                      int nb_input_files)
2399 {
2400     int ret, i;
2401     AVFormatContext *is, *os;
2402     OutputStream *ost;
2403     InputStream *ist;
2404     uint8_t *no_packet;
2405     int no_packet_count=0;
2406     int64_t timer_start;
2407
2408     if (!(no_packet = av_mallocz(nb_input_files)))
2409         exit_program(1);
2410
2411     ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2412     if (ret < 0)
2413         goto fail;
2414
2415     av_log(NULL, AV_LOG_INFO, "Press ctrl-c to stop encoding\n");
2416     term_init();
2417
2418     timer_start = av_gettime();
2419
2420     for(; received_sigterm == 0;) {
2421         int file_index, ist_index;
2422         AVPacket pkt;
2423         int64_t ipts_min;
2424         double opts_min;
2425
2426         ipts_min = INT64_MAX;
2427         opts_min= 1e100;
2428
2429         /* select the stream that we must read now by looking at the
2430            smallest output pts */
2431         file_index = -1;
2432         for (i = 0; i < nb_output_streams; i++) {
2433             OutputFile *of;
2434             int64_t ipts;
2435             double  opts;
2436             ost = &output_streams[i];
2437             of = &output_files[ost->file_index];
2438             os = output_files[ost->file_index].ctx;
2439             ist = &input_streams[ost->source_index];
2440             if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2441                 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2442                 continue;
2443             opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2444             ipts = ist->pts;
2445             if (!input_files[ist->file_index].eof_reached){
2446                 if(ipts < ipts_min) {
2447                     ipts_min = ipts;
2448                     if(input_sync ) file_index = ist->file_index;
2449                 }
2450                 if(opts < opts_min) {
2451                     opts_min = opts;
2452                     if(!input_sync) file_index = ist->file_index;
2453                 }
2454             }
2455             if (ost->frame_number >= ost->max_frames) {
2456                 int j;
2457                 for (j = 0; j < of->ctx->nb_streams; j++)
2458                     output_streams[of->ost_index + j].is_past_recording_time = 1;
2459                 continue;
2460             }
2461         }
2462         /* if none, if is finished */
2463         if (file_index < 0) {
2464             if(no_packet_count){
2465                 no_packet_count=0;
2466                 memset(no_packet, 0, nb_input_files);
2467                 usleep(10000);
2468                 continue;
2469             }
2470             break;
2471         }
2472
2473         /* read a frame from it and output it in the fifo */
2474         is = input_files[file_index].ctx;
2475         ret= av_read_frame(is, &pkt);
2476         if(ret == AVERROR(EAGAIN)){
2477             no_packet[file_index]=1;
2478             no_packet_count++;
2479             continue;
2480         }
2481         if (ret < 0) {
2482             input_files[file_index].eof_reached = 1;
2483             if (opt_shortest)
2484                 break;
2485             else
2486                 continue;
2487         }
2488
2489         no_packet_count=0;
2490         memset(no_packet, 0, nb_input_files);
2491
2492         if (do_pkt_dump) {
2493             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2494                              is->streams[pkt.stream_index]);
2495         }
2496         /* the following test is needed in case new streams appear
2497            dynamically in stream : we ignore them */
2498         if (pkt.stream_index >= input_files[file_index].nb_streams)
2499             goto discard_packet;
2500         ist_index = input_files[file_index].ist_index + pkt.stream_index;
2501         ist = &input_streams[ist_index];
2502         if (ist->discard)
2503             goto discard_packet;
2504
2505         if (pkt.dts != AV_NOPTS_VALUE)
2506             pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2507         if (pkt.pts != AV_NOPTS_VALUE)
2508             pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2509
2510         if(pkt.pts != AV_NOPTS_VALUE)
2511             pkt.pts *= ist->ts_scale;
2512         if(pkt.dts != AV_NOPTS_VALUE)
2513             pkt.dts *= ist->ts_scale;
2514
2515 //        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);
2516         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2517             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2518             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2519             int64_t delta= pkt_dts - ist->next_pts;
2520             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2521                 input_files[ist->file_index].ts_offset -= delta;
2522                 av_log(NULL, AV_LOG_DEBUG, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2523                        delta, input_files[ist->file_index].ts_offset);
2524                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2525                 if(pkt.pts != AV_NOPTS_VALUE)
2526                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2527             }
2528         }
2529
2530         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2531         if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {
2532
2533             av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
2534                    ist->file_index, ist->st->index);
2535             if (exit_on_error)
2536                 exit_program(1);
2537             av_free_packet(&pkt);
2538             continue;
2539         }
2540
2541     discard_packet:
2542         av_free_packet(&pkt);
2543
2544         /* dump report by using the output first video and audio streams */
2545         print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2546     }
2547
2548     /* at the end of stream, we must flush the decoder buffers */
2549     for (i = 0; i < nb_input_streams; i++) {
2550         ist = &input_streams[i];
2551         if (ist->decoding_needed) {
2552             output_packet(ist, output_streams, nb_output_streams, NULL);
2553         }
2554     }
2555     flush_encoders(output_streams, nb_output_streams);
2556
2557     term_exit();
2558
2559     /* write the trailer if needed and close file */
2560     for(i=0;i<nb_output_files;i++) {
2561         os = output_files[i].ctx;
2562         av_write_trailer(os);
2563     }
2564
2565     /* dump report by using the first video and audio streams */
2566     print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2567
2568     /* close each encoder */
2569     for (i = 0; i < nb_output_streams; i++) {
2570         ost = &output_streams[i];
2571         if (ost->encoding_needed) {
2572             av_freep(&ost->st->codec->stats_in);
2573             avcodec_close(ost->st->codec);
2574         }
2575 #if CONFIG_AVFILTER
2576         avfilter_graph_free(&ost->graph);
2577 #endif
2578     }
2579
2580     /* close each decoder */
2581     for (i = 0; i < nb_input_streams; i++) {
2582         ist = &input_streams[i];
2583         if (ist->decoding_needed) {
2584             avcodec_close(ist->st->codec);
2585         }
2586     }
2587
2588     /* finished ! */
2589     ret = 0;
2590
2591  fail:
2592     av_freep(&bit_buffer);
2593     av_freep(&no_packet);
2594
2595     if (output_streams) {
2596         for (i = 0; i < nb_output_streams; i++) {
2597             ost = &output_streams[i];
2598             if (ost) {
2599                 if (ost->stream_copy)
2600                     av_freep(&ost->st->codec->extradata);
2601                 if (ost->logfile) {
2602                     fclose(ost->logfile);
2603                     ost->logfile = NULL;
2604                 }
2605                 av_fifo_free(ost->fifo); /* works even if fifo is not
2606                                              initialized but set to zero */
2607                 av_freep(&ost->st->codec->subtitle_header);
2608                 av_free(ost->pict_tmp.data[0]);
2609                 av_free(ost->forced_kf_pts);
2610                 if (ost->video_resample)
2611                     sws_freeContext(ost->img_resample_ctx);
2612                 if (ost->resample)
2613                     audio_resample_close(ost->resample);
2614                 if (ost->reformat_ctx)
2615                     av_audio_convert_free(ost->reformat_ctx);
2616                 av_dict_free(&ost->opts);
2617             }
2618         }
2619     }
2620     return ret;
2621 }
2622
2623 static double parse_frame_aspect_ratio(const char *arg)
2624 {
2625     int x = 0, y = 0;
2626     double ar = 0;
2627     const char *p;
2628     char *end;
2629
2630     p = strchr(arg, ':');
2631     if (p) {
2632         x = strtol(arg, &end, 10);
2633         if (end == p)
2634             y = strtol(end+1, &end, 10);
2635         if (x > 0 && y > 0)
2636             ar = (double)x / (double)y;
2637     } else
2638         ar = strtod(arg, NULL);
2639
2640     if (!ar) {
2641         av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2642         exit_program(1);
2643     }
2644     return ar;
2645 }
2646
2647 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2648 {
2649     return parse_option(o, "codec:a", arg, options);
2650 }
2651
2652 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2653 {
2654     return parse_option(o, "codec:v", arg, options);
2655 }
2656
2657 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2658 {
2659     return parse_option(o, "codec:s", arg, options);
2660 }
2661
2662 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2663 {
2664     return parse_option(o, "codec:d", arg, options);
2665 }
2666
2667 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2668 {
2669     StreamMap *m = NULL;
2670     int i, negative = 0, file_idx;
2671     int sync_file_idx = -1, sync_stream_idx;
2672     char *p, *sync;
2673     char *map;
2674
2675     if (*arg == '-') {
2676         negative = 1;
2677         arg++;
2678     }
2679     map = av_strdup(arg);
2680
2681     /* parse sync stream first, just pick first matching stream */
2682     if (sync = strchr(map, ',')) {
2683         *sync = 0;
2684         sync_file_idx = strtol(sync + 1, &sync, 0);
2685         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2686             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2687             exit_program(1);
2688         }
2689         if (*sync)
2690             sync++;
2691         for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2692             if (check_stream_specifier(input_files[sync_file_idx].ctx,
2693                                        input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2694                 sync_stream_idx = i;
2695                 break;
2696             }
2697         if (i == input_files[sync_file_idx].nb_streams) {
2698             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2699                                        "match any streams.\n", arg);
2700             exit_program(1);
2701         }
2702     }
2703
2704
2705     file_idx = strtol(map, &p, 0);
2706     if (file_idx >= nb_input_files || file_idx < 0) {
2707         av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
2708         exit_program(1);
2709     }
2710     if (negative)
2711         /* disable some already defined maps */
2712         for (i = 0; i < o->nb_stream_maps; i++) {
2713             m = &o->stream_maps[i];
2714             if (file_idx == m->file_index &&
2715                 check_stream_specifier(input_files[m->file_index].ctx,
2716                                        input_files[m->file_index].ctx->streams[m->stream_index],
2717                                        *p == ':' ? p + 1 : p) > 0)
2718                 m->disabled = 1;
2719         }
2720     else
2721         for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2722             if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2723                         *p == ':' ? p + 1 : p) <= 0)
2724                 continue;
2725             o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2726                                         &o->nb_stream_maps, o->nb_stream_maps + 1);
2727             m = &o->stream_maps[o->nb_stream_maps - 1];
2728
2729             m->file_index   = file_idx;
2730             m->stream_index = i;
2731
2732             if (sync_file_idx >= 0) {
2733                 m->sync_file_index   = sync_file_idx;
2734                 m->sync_stream_index = sync_stream_idx;
2735             } else {
2736                 m->sync_file_index   = file_idx;
2737                 m->sync_stream_index = i;
2738             }
2739         }
2740
2741     if (!m) {
2742         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
2743         exit_program(1);
2744     }
2745
2746     av_freep(&map);
2747     return 0;
2748 }
2749
2750 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
2751 {
2752     o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
2753                                 &o->nb_attachments, o->nb_attachments + 1);
2754     o->attachments[o->nb_attachments - 1] = arg;
2755     return 0;
2756 }
2757
2758 /**
2759  * Parse a metadata specifier in arg.
2760  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
2761  * @param index for type c/p, chapter/program index is written here
2762  * @param stream_spec for type s, the stream specifier is written here
2763  */
2764 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
2765 {
2766     if (*arg) {
2767         *type = *arg;
2768         switch (*arg) {
2769         case 'g':
2770             break;
2771         case 's':
2772             if (*(++arg) && *arg != ':') {
2773                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
2774                 exit_program(1);
2775             }
2776             *stream_spec = *arg == ':' ? arg + 1 : "";
2777             break;
2778         case 'c':
2779         case 'p':
2780             if (*(++arg) == ':')
2781                 *index = strtol(++arg, NULL, 0);
2782             break;
2783         default:
2784             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
2785             exit_program(1);
2786         }
2787     } else
2788         *type = 'g';
2789 }
2790
2791 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
2792 {
2793     AVDictionary **meta_in = NULL;
2794     AVDictionary **meta_out;
2795     int i, ret = 0;
2796     char type_in, type_out;
2797     const char *istream_spec = NULL, *ostream_spec = NULL;
2798     int idx_in = 0, idx_out = 0;
2799
2800     parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
2801     parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
2802
2803     if (type_in == 'g' || type_out == 'g')
2804         o->metadata_global_manual = 1;
2805     if (type_in == 's' || type_out == 's')
2806         o->metadata_streams_manual = 1;
2807     if (type_in == 'c' || type_out == 'c')
2808         o->metadata_chapters_manual = 1;
2809
2810 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2811     if ((index) < 0 || (index) >= (nb_elems)) {\
2812         av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
2813                 (desc), (index));\
2814         exit_program(1);\
2815     }
2816
2817 #define SET_DICT(type, meta, context, index)\
2818         switch (type) {\
2819         case 'g':\
2820             meta = &context->metadata;\
2821             break;\
2822         case 'c':\
2823             METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
2824             meta = &context->chapters[index]->metadata;\
2825             break;\
2826         case 'p':\
2827             METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
2828             meta = &context->programs[index]->metadata;\
2829             break;\
2830         }\
2831
2832     SET_DICT(type_in, meta_in, ic, idx_in);
2833     SET_DICT(type_out, meta_out, oc, idx_out);
2834
2835     /* for input streams choose first matching stream */
2836     if (type_in == 's') {
2837         for (i = 0; i < ic->nb_streams; i++) {
2838             if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
2839                 meta_in = &ic->streams[i]->metadata;
2840                 break;
2841             } else if (ret < 0)
2842                 exit_program(1);
2843         }
2844         if (!meta_in) {
2845             av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
2846             exit_program(1);
2847         }
2848     }
2849
2850     if (type_out == 's') {
2851         for (i = 0; i < oc->nb_streams; i++) {
2852             if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
2853                 meta_out = &oc->streams[i]->metadata;
2854                 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
2855             } else if (ret < 0)
2856                 exit_program(1);
2857         }
2858     } else
2859         av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
2860
2861     return 0;
2862 }
2863
2864 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2865 {
2866     const char *codec_string = encoder ? "encoder" : "decoder";
2867     AVCodec *codec;
2868
2869     codec = encoder ?
2870         avcodec_find_encoder_by_name(name) :
2871         avcodec_find_decoder_by_name(name);
2872     if(!codec) {
2873         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
2874         exit_program(1);
2875     }
2876     if(codec->type != type) {
2877         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
2878         exit_program(1);
2879     }
2880     return codec;
2881 }
2882
2883 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
2884 {
2885     char *codec_name = NULL;
2886
2887     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2888     if (codec_name) {
2889         AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
2890         st->codec->codec_id = codec->id;
2891         return codec;
2892     } else
2893         return avcodec_find_decoder(st->codec->codec_id);
2894 }
2895
2896 /**
2897  * Add all the streams from the given input file to the global
2898  * list of input streams.
2899  */
2900 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2901 {
2902     int i, rfps, rfps_base;
2903
2904     for (i = 0; i < ic->nb_streams; i++) {
2905         AVStream *st = ic->streams[i];
2906         AVCodecContext *dec = st->codec;
2907         InputStream *ist;
2908
2909         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2910         ist = &input_streams[nb_input_streams - 1];
2911         ist->st = st;
2912         ist->file_index = nb_input_files;
2913         ist->discard = 1;
2914         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2915
2916         ist->ts_scale = 1.0;
2917         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
2918
2919         ist->dec = choose_decoder(o, ic, st);
2920
2921         switch (dec->codec_type) {
2922         case AVMEDIA_TYPE_AUDIO:
2923             if (o->audio_disable)
2924                 st->discard= AVDISCARD_ALL;
2925             break;
2926         case AVMEDIA_TYPE_VIDEO:
2927             rfps      = ic->streams[i]->r_frame_rate.num;
2928             rfps_base = ic->streams[i]->r_frame_rate.den;
2929             if (dec->lowres) {
2930                 dec->flags |= CODEC_FLAG_EMU_EDGE;
2931                 dec->height >>= dec->lowres;
2932                 dec->width  >>= dec->lowres;
2933             }
2934
2935             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2936
2937                 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",
2938                        i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2939                        (float)rfps / rfps_base, rfps, rfps_base);
2940             }
2941
2942             if (o->video_disable)
2943                 st->discard= AVDISCARD_ALL;
2944             else if(video_discard)
2945                 st->discard= video_discard;
2946             break;
2947         case AVMEDIA_TYPE_DATA:
2948             break;
2949         case AVMEDIA_TYPE_SUBTITLE:
2950             if (o->subtitle_disable)
2951                 st->discard = AVDISCARD_ALL;
2952             break;
2953         case AVMEDIA_TYPE_ATTACHMENT:
2954         case AVMEDIA_TYPE_UNKNOWN:
2955             break;
2956         default:
2957             abort();
2958         }
2959     }
2960 }
2961
2962 static void assert_file_overwrite(const char *filename)
2963 {
2964     if (!file_overwrite &&
2965         (strchr(filename, ':') == NULL || filename[1] == ':' ||
2966          av_strstart(filename, "file:", NULL))) {
2967         if (avio_check(filename, 0) == 0) {
2968             if (!using_stdin) {
2969                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
2970                 fflush(stderr);
2971                 if (!read_yesno()) {
2972                     fprintf(stderr, "Not overwriting - exiting\n");
2973                     exit_program(1);
2974                 }
2975             }
2976             else {
2977                 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
2978                 exit_program(1);
2979             }
2980         }
2981     }
2982 }
2983
2984 static void dump_attachment(AVStream *st, const char *filename)
2985 {
2986     int ret;
2987     AVIOContext *out = NULL;
2988     AVDictionaryEntry *e;
2989
2990     if (!st->codec->extradata_size) {
2991         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
2992                nb_input_files - 1, st->index);
2993         return;
2994     }
2995     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
2996         filename = e->value;
2997     if (!*filename) {
2998         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
2999                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3000         exit_program(1);
3001     }
3002
3003     assert_file_overwrite(filename);
3004
3005     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
3006         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3007                filename);
3008         exit_program(1);
3009     }
3010
3011     avio_write(out, st->codec->extradata, st->codec->extradata_size);
3012     avio_flush(out);
3013     avio_close(out);
3014 }
3015
3016 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3017 {
3018     AVFormatContext *ic;
3019     AVInputFormat *file_iformat = NULL;
3020     int err, i, ret;
3021     int64_t timestamp;
3022     uint8_t buf[128];
3023     AVDictionary **opts;
3024     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
3025
3026     if (o->format) {
3027         if (!(file_iformat = av_find_input_format(o->format))) {
3028             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3029             exit_program(1);
3030         }
3031     }
3032
3033     if (!strcmp(filename, "-"))
3034         filename = "pipe:";
3035
3036     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3037                     !strcmp(filename, "/dev/stdin");
3038
3039     /* get default parameters from command line */
3040     ic = avformat_alloc_context();
3041     if (!ic) {
3042         print_error(filename, AVERROR(ENOMEM));
3043         exit_program(1);
3044     }
3045     if (o->nb_audio_sample_rate) {
3046         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3047         av_dict_set(&format_opts, "sample_rate", buf, 0);
3048     }
3049     if (o->nb_audio_channels) {
3050         snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3051         av_dict_set(&format_opts, "channels", buf, 0);
3052     }
3053     if (o->nb_frame_rates) {
3054         av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3055     }
3056     if (o->nb_frame_sizes) {
3057         av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3058     }
3059     if (o->nb_frame_pix_fmts)
3060         av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3061
3062     ic->flags |= AVFMT_FLAG_NONBLOCK;
3063     ic->interrupt_callback = int_cb;
3064
3065     /* open the input file with generic libav function */
3066     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3067     if (err < 0) {
3068         print_error(filename, err);
3069         exit_program(1);
3070     }
3071     assert_avoptions(format_opts);
3072
3073     /* apply forced codec ids */
3074     for (i = 0; i < ic->nb_streams; i++)
3075         choose_decoder(o, ic, ic->streams[i]);
3076
3077     /* Set AVCodecContext options for avformat_find_stream_info */
3078     opts = setup_find_stream_info_opts(ic, codec_opts);
3079     orig_nb_streams = ic->nb_streams;
3080
3081     /* If not enough info to get the stream parameters, we decode the
3082        first frames to get it. (used in mpeg case for example) */
3083     ret = avformat_find_stream_info(ic, opts);
3084     if (ret < 0) {
3085         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3086         avformat_close_input(&ic);
3087         exit_program(1);
3088     }
3089
3090     timestamp = o->start_time;
3091     /* add the stream start time */
3092     if (ic->start_time != AV_NOPTS_VALUE)
3093         timestamp += ic->start_time;
3094
3095     /* if seeking requested, we execute it */
3096     if (o->start_time != 0) {
3097         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3098         if (ret < 0) {
3099             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3100                    filename, (double)timestamp / AV_TIME_BASE);
3101         }
3102     }
3103
3104     /* update the current parameters so that they match the one of the input stream */
3105     add_input_streams(o, ic);
3106
3107     /* dump the file content */
3108     av_dump_format(ic, nb_input_files, filename, 0);
3109
3110     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3111     input_files[nb_input_files - 1].ctx        = ic;
3112     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3113     input_files[nb_input_files - 1].ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3114     input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3115     input_files[nb_input_files - 1].rate_emu   = o->rate_emu;
3116
3117     for (i = 0; i < o->nb_dump_attachment; i++) {
3118         int j;
3119
3120         for (j = 0; j < ic->nb_streams; j++) {
3121             AVStream *st = ic->streams[j];
3122
3123             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3124                 dump_attachment(st, o->dump_attachment[i].u.str);
3125         }
3126     }
3127
3128     for (i = 0; i < orig_nb_streams; i++)
3129         av_dict_free(&opts[i]);
3130     av_freep(&opts);
3131
3132     reset_options(o);
3133     return 0;
3134 }
3135
3136 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3137                                     AVCodecContext *avctx)
3138 {
3139     char *p;
3140     int n = 1, i;
3141     int64_t t;
3142
3143     for (p = kf; *p; p++)
3144         if (*p == ',')
3145             n++;
3146     ost->forced_kf_count = n;
3147     ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3148     if (!ost->forced_kf_pts) {
3149         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3150         exit_program(1);
3151     }
3152     for (i = 0; i < n; i++) {
3153         p = i ? strchr(p, ',') + 1 : kf;
3154         t = parse_time_or_die("force_key_frames", p, 1);
3155         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3156     }
3157 }
3158
3159 static uint8_t *get_line(AVIOContext *s)
3160 {
3161     AVIOContext *line;
3162     uint8_t *buf;
3163     char c;
3164
3165     if (avio_open_dyn_buf(&line) < 0) {
3166         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3167         exit_program(1);
3168     }
3169
3170     while ((c = avio_r8(s)) && c != '\n')
3171         avio_w8(line, c);
3172     avio_w8(line, 0);
3173     avio_close_dyn_buf(line, &buf);
3174
3175     return buf;
3176 }
3177
3178 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3179 {
3180     int i, ret = 1;
3181     char filename[1000];
3182     const char *base[3] = { getenv("AVCONV_DATADIR"),
3183                             getenv("HOME"),
3184                             AVCONV_DATADIR,
3185                             };
3186
3187     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3188         if (!base[i])
3189             continue;
3190         if (codec_name) {
3191             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3192                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
3193             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3194         }
3195         if (ret) {
3196             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3197                      i != 1 ? "" : "/.avconv", preset_name);
3198             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3199         }
3200     }
3201     return ret;
3202 }
3203
3204 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3205 {
3206     char *codec_name = NULL;
3207
3208     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3209     if (!codec_name) {
3210         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3211                                                   NULL, ost->st->codec->codec_type);
3212         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3213     } else if (!strcmp(codec_name, "copy"))
3214         ost->stream_copy = 1;
3215     else {
3216         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3217         ost->st->codec->codec_id = ost->enc->id;
3218     }
3219 }
3220
3221 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3222 {
3223     OutputStream *ost;
3224     AVStream *st = avformat_new_stream(oc, NULL);
3225     int idx      = oc->nb_streams - 1, ret = 0;
3226     char *bsf = NULL, *next, *codec_tag = NULL;
3227     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3228     double qscale = -1;
3229     char *buf = NULL, *arg = NULL, *preset = NULL;
3230     AVIOContext *s = NULL;
3231
3232     if (!st) {
3233         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3234         exit_program(1);
3235     }
3236
3237     if (oc->nb_streams - 1 < o->nb_streamid_map)
3238         st->id = o->streamid_map[oc->nb_streams - 1];
3239
3240     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3241                                 nb_output_streams + 1);
3242     ost = &output_streams[nb_output_streams - 1];
3243     ost->file_index = nb_output_files;
3244     ost->index = idx;
3245     ost->st    = st;
3246     st->codec->codec_type = type;
3247     choose_encoder(o, oc, ost);
3248     if (ost->enc) {
3249         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3250     }
3251
3252     avcodec_get_context_defaults3(st->codec, ost->enc);
3253     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3254
3255     MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3256     if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3257         do  {
3258             buf = get_line(s);
3259             if (!buf[0] || buf[0] == '#') {
3260                 av_free(buf);
3261                 continue;
3262             }
3263             if (!(arg = strchr(buf, '='))) {
3264                 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3265                 exit_program(1);
3266             }
3267             *arg++ = 0;
3268             av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3269             av_free(buf);
3270         } while (!s->eof_reached);
3271         avio_close(s);
3272     }
3273     if (ret) {
3274         av_log(NULL, AV_LOG_FATAL,
3275                "Preset %s specified for stream %d:%d, but could not be opened.\n",
3276                preset, ost->file_index, ost->index);
3277         exit_program(1);
3278     }
3279
3280     ost->max_frames = INT64_MAX;
3281     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3282
3283     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3284     while (bsf) {
3285         if (next = strchr(bsf, ','))
3286             *next++ = 0;
3287         if (!(bsfc = av_bitstream_filter_init(bsf))) {
3288             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3289             exit_program(1);
3290         }
3291         if (bsfc_prev)
3292             bsfc_prev->next = bsfc;
3293         else
3294             ost->bitstream_filters = bsfc;
3295
3296         bsfc_prev = bsfc;
3297         bsf       = next;
3298     }
3299
3300     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3301     if (codec_tag) {
3302         uint32_t tag = strtol(codec_tag, &next, 0);
3303         if (*next)
3304             tag = AV_RL32(codec_tag);
3305         st->codec->codec_tag = tag;
3306     }
3307
3308     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3309     if (qscale >= 0 || same_quant) {
3310         st->codec->flags |= CODEC_FLAG_QSCALE;
3311         st->codec->global_quality = FF_QP2LAMBDA * qscale;
3312     }
3313
3314     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3315         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3316
3317     av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3318     return ost;
3319 }
3320
3321 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3322 {
3323     int i;
3324     const char *p = str;
3325     for(i = 0;; i++) {
3326         dest[i] = atoi(p);
3327         if(i == 63)
3328             break;
3329         p = strchr(p, ',');
3330         if(!p) {
3331             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3332             exit_program(1);
3333         }
3334         p++;
3335     }
3336 }
3337
3338 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3339 {
3340     AVStream *st;
3341     OutputStream *ost;
3342     AVCodecContext *video_enc;
3343
3344     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3345     st  = ost->st;
3346     video_enc = st->codec;
3347
3348     if (!ost->stream_copy) {
3349         const char *p = NULL;
3350         char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3351         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3352         char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3353         int i;
3354
3355         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3356         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3357             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3358             exit_program(1);
3359         }
3360
3361         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3362         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3363             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3364             exit_program(1);
3365         }
3366
3367         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3368         if (frame_aspect_ratio)
3369             ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3370
3371         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3372         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3373             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3374             exit_program(1);
3375         }
3376         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3377
3378         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3379         if (intra_matrix) {
3380             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3381                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3382                 exit_program(1);
3383             }
3384             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3385         }
3386         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3387         if (inter_matrix) {
3388             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3389                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3390                 exit_program(1);
3391             }
3392             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3393         }
3394
3395         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3396         for(i=0; p; i++){
3397             int start, end, q;
3398             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3399             if(e!=3){
3400                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3401                 exit_program(1);
3402             }
3403             video_enc->rc_override=
3404                 av_realloc(video_enc->rc_override,
3405                            sizeof(RcOverride)*(i+1));
3406             video_enc->rc_override[i].start_frame= start;
3407             video_enc->rc_override[i].end_frame  = end;
3408             if(q>0){
3409                 video_enc->rc_override[i].qscale= q;
3410                 video_enc->rc_override[i].quality_factor= 1.0;
3411             }
3412             else{
3413                 video_enc->rc_override[i].qscale= 0;
3414                 video_enc->rc_override[i].quality_factor= -q/100.0;
3415             }
3416             p= strchr(p, '/');
3417             if(p) p++;
3418         }
3419         video_enc->rc_override_count=i;
3420         if (!video_enc->rc_initial_buffer_occupancy)
3421             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3422         video_enc->intra_dc_precision= intra_dc_precision - 8;
3423
3424         /* two pass mode */
3425         if (do_pass) {
3426             if (do_pass == 1) {
3427                 video_enc->flags |= CODEC_FLAG_PASS1;
3428             } else {
3429                 video_enc->flags |= CODEC_FLAG_PASS2;
3430             }
3431         }
3432
3433         MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3434         if (forced_key_frames)
3435             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3436
3437         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
3438
3439         ost->top_field_first = -1;
3440         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
3441
3442         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
3443
3444 #if CONFIG_AVFILTER
3445         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3446         if (filters)
3447             ost->avfilter = av_strdup(filters);
3448 #endif
3449     }
3450
3451     return ost;
3452 }
3453
3454 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3455 {
3456     AVStream *st;
3457     OutputStream *ost;
3458     AVCodecContext *audio_enc;
3459
3460     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3461     st  = ost->st;
3462
3463     audio_enc = st->codec;
3464     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3465
3466     if (!ost->stream_copy) {
3467         char *sample_fmt = NULL;
3468
3469         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3470
3471         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3472         if (sample_fmt &&
3473             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3474             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3475             exit_program(1);
3476         }
3477
3478         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3479     }
3480
3481     return ost;
3482 }
3483
3484 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3485 {
3486     OutputStream *ost;
3487
3488     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3489     if (!ost->stream_copy) {
3490         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3491         exit_program(1);
3492     }
3493
3494     return ost;
3495 }
3496
3497 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3498 {
3499     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3500     ost->stream_copy = 1;
3501     return ost;
3502 }
3503
3504 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3505 {
3506     AVStream *st;
3507     OutputStream *ost;
3508     AVCodecContext *subtitle_enc;
3509
3510     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3511     st  = ost->st;
3512     subtitle_enc = st->codec;
3513
3514     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3515
3516     return ost;
3517 }
3518
3519 /* arg format is "output-stream-index:streamid-value". */
3520 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3521 {
3522     int idx;
3523     char *p;
3524     char idx_str[16];
3525
3526     av_strlcpy(idx_str, arg, sizeof(idx_str));
3527     p = strchr(idx_str, ':');
3528     if (!p) {
3529         av_log(NULL, AV_LOG_FATAL,
3530                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3531                arg, opt);
3532         exit_program(1);
3533     }
3534     *p++ = '\0';
3535     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3536     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3537     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3538     return 0;
3539 }
3540
3541 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3542 {
3543     AVFormatContext *is = ifile->ctx;
3544     AVFormatContext *os = ofile->ctx;
3545     int i;
3546
3547     for (i = 0; i < is->nb_chapters; i++) {
3548         AVChapter *in_ch = is->chapters[i], *out_ch;
3549         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
3550                                       AV_TIME_BASE_Q, in_ch->time_base);
3551         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3552                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3553
3554
3555         if (in_ch->end < ts_off)
3556             continue;
3557         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3558             break;
3559
3560         out_ch = av_mallocz(sizeof(AVChapter));
3561         if (!out_ch)
3562             return AVERROR(ENOMEM);
3563
3564         out_ch->id        = in_ch->id;
3565         out_ch->time_base = in_ch->time_base;
3566         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
3567         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
3568
3569         if (copy_metadata)
3570             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3571
3572         os->nb_chapters++;
3573         os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3574         if (!os->chapters)
3575             return AVERROR(ENOMEM);
3576         os->chapters[os->nb_chapters - 1] = out_ch;
3577     }
3578     return 0;
3579 }
3580
3581 static void opt_output_file(void *optctx, const char *filename)
3582 {
3583     OptionsContext *o = optctx;
3584     AVFormatContext *oc;
3585     int i, err;
3586     AVOutputFormat *file_oformat;
3587     OutputStream *ost;
3588     InputStream  *ist;
3589
3590     if (!strcmp(filename, "-"))
3591         filename = "pipe:";
3592
3593     oc = avformat_alloc_context();
3594     if (!oc) {
3595         print_error(filename, AVERROR(ENOMEM));
3596         exit_program(1);
3597     }
3598
3599     if (o->format) {
3600         file_oformat = av_guess_format(o->format, NULL, NULL);
3601         if (!file_oformat) {
3602             av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
3603             exit_program(1);
3604         }
3605     } else {
3606         file_oformat = av_guess_format(NULL, filename, NULL);
3607         if (!file_oformat) {
3608             av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
3609                    filename);
3610             exit_program(1);
3611         }
3612     }
3613
3614     oc->oformat = file_oformat;
3615     oc->interrupt_callback = int_cb;
3616     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3617
3618     if (!o->nb_stream_maps) {
3619         /* pick the "best" stream of each type */
3620 #define NEW_STREAM(type, index)\
3621         if (index >= 0) {\
3622             ost = new_ ## type ## _stream(o, oc);\
3623             ost->source_index = index;\
3624             ost->sync_ist     = &input_streams[index];\
3625             input_streams[index].discard = 0;\
3626         }
3627
3628         /* video: highest resolution */
3629         if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3630             int area = 0, idx = -1;
3631             for (i = 0; i < nb_input_streams; i++) {
3632                 ist = &input_streams[i];
3633                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3634                     ist->st->codec->width * ist->st->codec->height > area) {
3635                     area = ist->st->codec->width * ist->st->codec->height;
3636                     idx = i;
3637                 }
3638             }
3639             NEW_STREAM(video, idx);
3640         }
3641
3642         /* audio: most channels */
3643         if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3644             int channels = 0, idx = -1;
3645             for (i = 0; i < nb_input_streams; i++) {
3646                 ist = &input_streams[i];
3647                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3648                     ist->st->codec->channels > channels) {
3649                     channels = ist->st->codec->channels;
3650                     idx = i;
3651                 }
3652             }
3653             NEW_STREAM(audio, idx);
3654         }
3655
3656         /* subtitles: pick first */
3657         if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3658             for (i = 0; i < nb_input_streams; i++)
3659                 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3660                     NEW_STREAM(subtitle, i);
3661                     break;
3662                 }
3663         }
3664         /* do something with data? */
3665     } else {
3666         for (i = 0; i < o->nb_stream_maps; i++) {
3667             StreamMap *map = &o->stream_maps[i];
3668
3669             if (map->disabled)
3670                 continue;
3671
3672             ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3673             switch (ist->st->codec->codec_type) {
3674             case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
3675             case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
3676             case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3677             case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
3678             case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
3679             default:
3680                 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
3681                        map->file_index, map->stream_index);
3682                 exit_program(1);
3683             }
3684
3685             ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3686             ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3687                                            map->sync_stream_index];
3688             ist->discard = 0;
3689         }
3690     }
3691
3692     /* handle attached files */
3693     for (i = 0; i < o->nb_attachments; i++) {
3694         AVIOContext *pb;
3695         uint8_t *attachment;
3696         const char *p;
3697         int64_t len;
3698
3699         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
3700             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
3701                    o->attachments[i]);
3702             exit_program(1);
3703         }
3704         if ((len = avio_size(pb)) <= 0) {
3705             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
3706                    o->attachments[i]);
3707             exit_program(1);
3708         }
3709         if (!(attachment = av_malloc(len))) {
3710             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
3711                    o->attachments[i]);
3712             exit_program(1);
3713         }
3714         avio_read(pb, attachment, len);
3715
3716         ost = new_attachment_stream(o, oc);
3717         ost->stream_copy               = 0;
3718         ost->source_index              = -1;
3719         ost->attachment_filename       = o->attachments[i];
3720         ost->st->codec->extradata      = attachment;
3721         ost->st->codec->extradata_size = len;
3722
3723         p = strrchr(o->attachments[i], '/');
3724         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
3725         avio_close(pb);
3726     }
3727
3728     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3729     output_files[nb_output_files - 1].ctx       = oc;
3730     output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3731     output_files[nb_output_files - 1].recording_time = o->recording_time;
3732     output_files[nb_output_files - 1].start_time     = o->start_time;
3733     output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3734     av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3735
3736     /* check filename in case of an image number is expected */
3737     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3738         if (!av_filename_number_test(oc->filename)) {
3739             print_error(oc->filename, AVERROR(EINVAL));
3740             exit_program(1);
3741         }
3742     }
3743
3744     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3745         /* test if it already exists to avoid losing precious files */
3746         assert_file_overwrite(filename);
3747
3748         /* open the file */
3749         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
3750                               &oc->interrupt_callback,
3751                               &output_files[nb_output_files - 1].opts)) < 0) {
3752             print_error(filename, err);
3753             exit_program(1);
3754         }
3755     }
3756
3757     if (o->mux_preload) {
3758         uint8_t buf[64];
3759         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
3760         av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
3761     }
3762     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3763     oc->flags |= AVFMT_FLAG_NONBLOCK;
3764
3765     /* copy metadata */
3766     for (i = 0; i < o->nb_metadata_map; i++) {
3767         char *p;
3768         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
3769
3770         if (in_file_index < 0)
3771             continue;
3772         if (in_file_index >= nb_input_files) {
3773             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
3774             exit_program(1);
3775         }
3776         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index].ctx, o);
3777     }
3778
3779     /* copy chapters */
3780     if (o->chapters_input_file >= nb_input_files) {
3781         if (o->chapters_input_file == INT_MAX) {
3782             /* copy chapters from the first input file that has them*/
3783             o->chapters_input_file = -1;
3784             for (i = 0; i < nb_input_files; i++)
3785                 if (input_files[i].ctx->nb_chapters) {
3786                     o->chapters_input_file = i;
3787                     break;
3788                 }
3789         } else {
3790             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
3791                    o->chapters_input_file);
3792             exit_program(1);
3793         }
3794     }
3795     if (o->chapters_input_file >= 0)
3796         copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3797                       !o->metadata_chapters_manual);
3798
3799     /* copy global metadata by default */
3800     if (!o->metadata_global_manual && nb_input_files)
3801         av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3802                      AV_DICT_DONT_OVERWRITE);
3803     if (!o->metadata_streams_manual)
3804         for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3805             InputStream *ist;
3806             if (output_streams[i].source_index < 0)         /* this is true e.g. for attached files */
3807                 continue;
3808             ist = &input_streams[output_streams[i].source_index];
3809             av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3810         }
3811
3812     /* process manually set metadata */
3813     for (i = 0; i < o->nb_metadata; i++) {
3814         AVDictionary **m;
3815         char type, *val;
3816         const char *stream_spec;
3817         int index = 0, j, ret;
3818
3819         val = strchr(o->metadata[i].u.str, '=');
3820         if (!val) {
3821             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
3822                    o->metadata[i].u.str);
3823             exit_program(1);
3824         }
3825         *val++ = 0;
3826
3827         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
3828         if (type == 's') {
3829             for (j = 0; j < oc->nb_streams; j++) {
3830                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
3831                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
3832                 } else if (ret < 0)
3833                     exit_program(1);
3834             }
3835             printf("ret %d, stream_spec %s\n", ret, stream_spec);
3836         }
3837         else {
3838             switch (type) {
3839             case 'g':
3840                 m = &oc->metadata;
3841                 break;
3842             case 'c':
3843                 if (index < 0 || index >= oc->nb_chapters) {
3844                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
3845                     exit_program(1);
3846                 }
3847                 m = &oc->chapters[index]->metadata;
3848                 break;
3849             default:
3850                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3851                 exit_program(1);
3852             }
3853             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3854         }
3855     }
3856
3857     reset_options(o);
3858 }
3859
3860 /* same option as mencoder */
3861 static int opt_pass(const char *opt, const char *arg)
3862 {
3863     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3864     return 0;
3865 }
3866
3867 static int64_t getutime(void)
3868 {
3869 #if HAVE_GETRUSAGE
3870     struct rusage rusage;
3871
3872     getrusage(RUSAGE_SELF, &rusage);
3873     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3874 #elif HAVE_GETPROCESSTIMES
3875     HANDLE proc;
3876     FILETIME c, e, k, u;
3877     proc = GetCurrentProcess();
3878     GetProcessTimes(proc, &c, &e, &k, &u);
3879     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3880 #else
3881     return av_gettime();
3882 #endif
3883 }
3884
3885 static int64_t getmaxrss(void)
3886 {
3887 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3888     struct rusage rusage;
3889     getrusage(RUSAGE_SELF, &rusage);
3890     return (int64_t)rusage.ru_maxrss * 1024;
3891 #elif HAVE_GETPROCESSMEMORYINFO
3892     HANDLE proc;
3893     PROCESS_MEMORY_COUNTERS memcounters;
3894     proc = GetCurrentProcess();
3895     memcounters.cb = sizeof(memcounters);
3896     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3897     return memcounters.PeakPagefileUsage;
3898 #else
3899     return 0;
3900 #endif
3901 }
3902
3903 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
3904 {
3905     return parse_option(o, "q:a", arg, options);
3906 }
3907
3908 static void show_usage(void)
3909 {
3910     printf("Hyper fast Audio and Video encoder\n");
3911     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3912     printf("\n");
3913 }
3914
3915 static void show_help(void)
3916 {
3917     int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3918     av_log_set_callback(log_callback_help);
3919     show_usage();
3920     show_help_options(options, "Main options:\n",
3921                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3922     show_help_options(options, "\nAdvanced options:\n",
3923                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3924                       OPT_EXPERT);
3925     show_help_options(options, "\nVideo options:\n",
3926                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3927                       OPT_VIDEO);
3928     show_help_options(options, "\nAdvanced Video options:\n",
3929                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3930                       OPT_VIDEO | OPT_EXPERT);
3931     show_help_options(options, "\nAudio options:\n",
3932                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3933                       OPT_AUDIO);
3934     show_help_options(options, "\nAdvanced Audio options:\n",
3935                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3936                       OPT_AUDIO | OPT_EXPERT);
3937     show_help_options(options, "\nSubtitle options:\n",
3938                       OPT_SUBTITLE | OPT_GRAB,
3939                       OPT_SUBTITLE);
3940     show_help_options(options, "\nAudio/Video grab options:\n",
3941                       OPT_GRAB,
3942                       OPT_GRAB);
3943     printf("\n");
3944     show_help_children(avcodec_get_class(), flags);
3945     show_help_children(avformat_get_class(), flags);
3946     show_help_children(sws_get_class(), flags);
3947 }
3948
3949 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
3950 {
3951     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3952     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3953
3954     if(!strncmp(arg, "pal-", 4)) {
3955         norm = PAL;
3956         arg += 4;
3957     } else if(!strncmp(arg, "ntsc-", 5)) {
3958         norm = NTSC;
3959         arg += 5;
3960     } else if(!strncmp(arg, "film-", 5)) {
3961         norm = FILM;
3962         arg += 5;
3963     } else {
3964         /* Try to determine PAL/NTSC by peeking in the input files */
3965         if(nb_input_files) {
3966             int i, j, fr;
3967             for (j = 0; j < nb_input_files; j++) {
3968                 for (i = 0; i < input_files[j].nb_streams; i++) {
3969                     AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3970                     if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3971                         continue;
3972                     fr = c->time_base.den * 1000 / c->time_base.num;
3973                     if(fr == 25000) {
3974                         norm = PAL;
3975                         break;
3976                     } else if((fr == 29970) || (fr == 23976)) {
3977                         norm = NTSC;
3978                         break;
3979                     }
3980                 }
3981                 if(norm != UNKNOWN)
3982                     break;
3983             }
3984         }
3985         if (norm != UNKNOWN)
3986             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3987     }
3988
3989     if(norm == UNKNOWN) {
3990         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3991         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3992         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
3993         exit_program(1);
3994     }
3995
3996     if(!strcmp(arg, "vcd")) {
3997         opt_video_codec(o, "c:v", "mpeg1video");
3998         opt_audio_codec(o, "c:a", "mp2");
3999         parse_option(o, "f", "vcd", options);
4000
4001         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4002         parse_option(o, "r", frame_rates[norm], options);
4003         opt_default("g", norm == PAL ? "15" : "18");
4004
4005         opt_default("b", "1150000");
4006         opt_default("maxrate", "1150000");
4007         opt_default("minrate", "1150000");
4008         opt_default("bufsize", "327680"); // 40*1024*8;
4009
4010         opt_default("b:a", "224000");
4011         parse_option(o, "ar", "44100", options);
4012         parse_option(o, "ac", "2", options);
4013
4014         opt_default("packetsize", "2324");
4015         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4016
4017         /* We have to offset the PTS, so that it is consistent with the SCR.
4018            SCR starts at 36000, but the first two packs contain only padding
4019            and the first pack from the other stream, respectively, may also have
4020            been written before.
4021            So the real data starts at SCR 36000+3*1200. */
4022         o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4023     } else if(!strcmp(arg, "svcd")) {
4024
4025         opt_video_codec(o, "c:v", "mpeg2video");
4026         opt_audio_codec(o, "c:a", "mp2");
4027         parse_option(o, "f", "svcd", options);
4028
4029         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4030         parse_option(o, "r", frame_rates[norm], options);
4031         opt_default("g", norm == PAL ? "15" : "18");
4032
4033         opt_default("b", "2040000");
4034         opt_default("maxrate", "2516000");
4035         opt_default("minrate", "0"); //1145000;
4036         opt_default("bufsize", "1835008"); //224*1024*8;
4037         opt_default("flags", "+scan_offset");
4038
4039
4040         opt_default("b:a", "224000");
4041         parse_option(o, "ar", "44100", options);
4042
4043         opt_default("packetsize", "2324");
4044
4045     } else if(!strcmp(arg, "dvd")) {
4046
4047         opt_video_codec(o, "c:v", "mpeg2video");
4048         opt_audio_codec(o, "c:a", "ac3");
4049         parse_option(o, "f", "dvd", options);
4050
4051         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4052         parse_option(o, "r", frame_rates[norm], options);
4053         opt_default("g", norm == PAL ? "15" : "18");
4054
4055         opt_default("b", "6000000");
4056         opt_default("maxrate", "9000000");
4057         opt_default("minrate", "0"); //1500000;
4058         opt_default("bufsize", "1835008"); //224*1024*8;
4059
4060         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4061         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4062
4063         opt_default("b:a", "448000");
4064         parse_option(o, "ar", "48000", options);
4065
4066     } else if(!strncmp(arg, "dv", 2)) {
4067
4068         parse_option(o, "f", "dv", options);
4069
4070         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4071         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4072                           norm == PAL ? "yuv420p" : "yuv411p", options);
4073         parse_option(o, "r", frame_rates[norm], options);
4074
4075         parse_option(o, "ar", "48000", options);
4076         parse_option(o, "ac", "2", options);
4077
4078     } else {
4079         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4080         return AVERROR(EINVAL);
4081     }
4082     return 0;
4083 }
4084
4085 static int opt_vstats_file(const char *opt, const char *arg)
4086 {
4087     av_free (vstats_filename);
4088     vstats_filename=av_strdup (arg);
4089     return 0;
4090 }
4091
4092 static int opt_vstats(const char *opt, const char *arg)
4093 {
4094     char filename[40];
4095     time_t today2 = time(NULL);
4096     struct tm *today = localtime(&today2);
4097
4098     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4099              today->tm_sec);
4100     return opt_vstats_file(opt, filename);
4101 }
4102
4103 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4104 {
4105     return parse_option(o, "frames:v", arg, options);
4106 }
4107
4108 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4109 {
4110     return parse_option(o, "frames:a", arg, options);
4111 }
4112
4113 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4114 {
4115     return parse_option(o, "frames:d", arg, options);
4116 }
4117
4118 static int opt_video_tag(OptionsContext *o, const char *opt, const char *arg)
4119 {
4120     return parse_option(o, "tag:v", arg, options);
4121 }
4122
4123 static int opt_audio_tag(OptionsContext *o, const char *opt, const char *arg)
4124 {
4125     return parse_option(o, "tag:a", arg, options);
4126 }
4127
4128 static int opt_subtitle_tag(OptionsContext *o, const char *opt, const char *arg)
4129 {
4130     return parse_option(o, "tag:s", arg, options);
4131 }
4132
4133 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4134 {
4135     return parse_option(o, "filter:v", arg, options);
4136 }
4137
4138 #define OFFSET(x) offsetof(OptionsContext, x)
4139 static const OptionDef options[] = {
4140     /* main options */
4141 #include "cmdutils_common_opts.h"
4142     { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4143     { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4144     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4145     { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4146     { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4147     { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4148     { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
4149     { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
4150       "outfile[,metadata]:infile[,metadata]" },
4151     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)},  "set chapters mapping", "input_file_index" },
4152     { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4153     { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4154     { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4155     { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4156     { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4157     { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4158     { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4159     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4160       "add timings for benchmarking" },
4161     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4162     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4163       "dump each input packet" },
4164     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4165       "when dumping packets, also dump the payload" },
4166     { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4167     { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4168     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4169     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4170     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4171     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4172     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4173     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4174     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4175     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4176     { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4177     { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4178     { "tag",   OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4179     { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4180     { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4181 #if CONFIG_AVFILTER
4182     { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4183 #endif
4184     { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4185     { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4186     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4187
4188     /* video options */
4189     { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4190     { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4191     { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4192     { "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" },
4193     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4194     { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4195     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4196     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4197     { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4198     { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4199       "use same quantizer as source (implies VBR)" },
4200     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4201     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4202     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4203       "deinterlace pictures" },
4204     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4205     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4206 #if CONFIG_AVFILTER
4207     { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4208 #endif
4209     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4210     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4211     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4212     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4213     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4214     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4215     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4216     { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4217     { "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" },
4218
4219     /* audio options */
4220     { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4221     { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4222     { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4223     { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4224     { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4225     { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4226     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4227     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4228     { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4229
4230     /* subtitle options */
4231     { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4232     { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4233     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4234
4235     /* grab options */
4236     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4237
4238     /* muxer options */
4239     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT   | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4240     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)},   "set the initial demux-decode delay", "seconds" },
4241
4242     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4243
4244     /* data codec support */
4245     { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4246
4247     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4248     { NULL, },
4249 };
4250
4251 int main(int argc, char **argv)
4252 {
4253     OptionsContext o = { 0 };
4254     int64_t ti;
4255
4256     reset_options(&o);
4257
4258     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4259     parse_loglevel(argc, argv, options);
4260
4261     avcodec_register_all();
4262 #if CONFIG_AVDEVICE
4263     avdevice_register_all();
4264 #endif
4265 #if CONFIG_AVFILTER
4266     avfilter_register_all();
4267 #endif
4268     av_register_all();
4269     avformat_network_init();
4270
4271     show_banner();
4272
4273     /* parse options */
4274     parse_options(&o, argc, argv, options, opt_output_file);
4275
4276     if(nb_output_files <= 0 && nb_input_files == 0) {
4277         show_usage();
4278         av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4279         exit_program(1);
4280     }
4281
4282     /* file converter / grab */
4283     if (nb_output_files <= 0) {
4284         fprintf(stderr, "At least one output file must be specified\n");
4285         exit_program(1);
4286     }
4287
4288     if (nb_input_files == 0) {
4289         av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4290         exit_program(1);
4291     }
4292
4293     ti = getutime();
4294     if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4295         exit_program(1);
4296     ti = getutime() - ti;
4297     if (do_benchmark) {
4298         int maxrss = getmaxrss() / 1024;
4299         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4300     }
4301
4302     exit_program(0);
4303     return 0;
4304 }