avconv.c

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