avconv.c

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