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