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