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

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