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