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     int nb_streams;       /* number of stream that avconv is aware of; may be different
 243                              from ctx.nb_streams if new streams appear during av_read_frame() */
 244 } InputFile;
 245
 246 typedef struct OutputStream {
 247     int file_index;          /* file index */
 248     int index;               /* stream index in the output file */
 249     int source_index;        /* InputStream index */
 250     AVStream *st;            /* stream in the output file */
 251     int encoding_needed;     /* true if encoding needed for this stream */
 252     int frame_number;
 253     /* input pts and corresponding output pts
 254        for A/V sync */
 255     //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
 256     struct InputStream *sync_ist; /* input stream to sync against */
 257     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
 258     AVBitStreamFilterContext *bitstream_filters;
 259     AVCodec *enc;
 260
 261     /* video only */
 262     int video_resample;
 263     AVFrame pict_tmp;      /* temporary image for resampling */
 264     struct SwsContext *img_resample_ctx; /* for image resampling */
 265     int resample_height;
 266     int resample_width;
 267     int resample_pix_fmt;
 268     AVRational frame_rate;
 269
 270     float frame_aspect_ratio;
 271
 272     /* forced key frames */
 273     int64_t *forced_kf_pts;
 274     int forced_kf_count;
 275     int forced_kf_index;
 276
 277     /* audio only */
 278     int audio_resample;
 279     ReSampleContext *resample; /* for audio resampling */
 280     int resample_sample_fmt;
 281     int resample_channels;
 282     int resample_sample_rate;
 283     int reformat_pair;
 284     AVAudioConvert *reformat_ctx;
 285     AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
 286     FILE *logfile;
 287
 288 #if CONFIG_AVFILTER
 289     AVFilterContext *output_video_filter;
 290     AVFilterContext *input_video_filter;
 291     AVFilterBufferRef *picref;
 292     char *avfilter;
 293     AVFilterGraph *graph;
 294 #endif
 295
 296    int sws_flags;
 297    AVDictionary *opts;
 298    int is_past_recording_time;
 299 } OutputStream;
 300
 301
 302 typedef struct OutputFile {
 303     AVFormatContext *ctx;
 304     AVDictionary *opts;
 305     int ost_index;       /* index of the first stream in output_streams */
 306     int64_t recording_time; /* desired length of the resulting file in microseconds */
 307     int64_t start_time;     /* start time in microseconds */
 308     uint64_t limit_filesize;
 309 } OutputFile;
 310
 311 static InputStream *input_streams = NULL;
 312 static int         nb_input_streams = 0;
 313 static InputFile   *input_files   = NULL;
 314 static int         nb_input_files   = 0;
 315
 316 static OutputStream *output_streams = NULL;
 317 static int        nb_output_streams = 0;
 318 static OutputFile   *output_files   = NULL;
 319 static int        nb_output_files   = 0;
 320
 321 #if CONFIG_AVFILTER
 322
 323 static int configure_video_filters(InputStream *ist, OutputStream *ost)
 324 {
 325     AVFilterContext *last_filter, *filter;
 326     /** filter graph containing all filters including input & output */
 327     AVCodecContext *codec = ost->st->codec;
 328     AVCodecContext *icodec = ist->st->codec;
 329     FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
 330     AVRational sample_aspect_ratio;
 331     char args[255];
 332     int ret;
 333
 334     ost->graph = avfilter_graph_alloc();
 335
 336     if (ist->st->sample_aspect_ratio.num){
 337         sample_aspect_ratio = ist->st->sample_aspect_ratio;
 338     }else
 339         sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
 340
 341     snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
 342              ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
 343              sample_aspect_ratio.num, sample_aspect_ratio.den);
 344
 345     ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
 346                                        "src", args, NULL, ost->graph);
 347     if (ret < 0)
 348         return ret;
 349     ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
 350                                        "out", NULL, &ffsink_ctx, ost->graph);
 351     if (ret < 0)
 352         return ret;
 353     last_filter = ost->input_video_filter;
 354
 355     if (codec->width  != icodec->width || codec->height != icodec->height) {
 356         snprintf(args, 255, "%d:%d:flags=0x%X",
 357                  codec->width,
 358                  codec->height,
 359                  ost->sws_flags);
 360         if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
 361                                                 NULL, args, NULL, ost->graph)) < 0)
 362             return ret;
 363         if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
 364             return ret;
 365         last_filter = filter;
 366     }
 367
 368     snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
 369     ost->graph->scale_sws_opts = av_strdup(args);
 370
 371     if (ost->avfilter) {
 372         AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
 373         AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
 374
 375         outputs->name    = av_strdup("in");
 376         outputs->filter_ctx = last_filter;
 377         outputs->pad_idx = 0;
 378         outputs->next    = NULL;
 379
 380         inputs->name    = av_strdup("out");
 381         inputs->filter_ctx = ost->output_video_filter;
 382         inputs->pad_idx = 0;
 383         inputs->next    = NULL;
 384
 385         if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
 386             return ret;
 387         av_freep(&ost->avfilter);
 388     } else {
 389         if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
 390             return ret;
 391     }
 392
 393     if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
 394         return ret;
 395
 396     codec->width  = ost->output_video_filter->inputs[0]->w;
 397     codec->height = ost->output_video_filter->inputs[0]->h;
 398     codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
 399         ost->frame_aspect_ratio ? // overridden by the -aspect cli option
 400         av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
 401         ost->output_video_filter->inputs[0]->sample_aspect_ratio;
 402
 403     return 0;
 404 }
 405 #endif /* CONFIG_AVFILTER */
 406
 407 static void term_exit(void)
 408 {
 409     av_log(NULL, AV_LOG_QUIET, "");
 410 }
 411
 412 static volatile int received_sigterm = 0;
 413 static volatile int received_nb_signals = 0;
 414
 415 static void
 416 sigterm_handler(int sig)
 417 {
 418     received_sigterm = sig;
 419     received_nb_signals++;
 420     term_exit();
 421 }
 422
 423 static void term_init(void)
 424 {
 425     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
 426     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
 427 #ifdef SIGXCPU
 428     signal(SIGXCPU, sigterm_handler);
 429 #endif
 430 }
 431
 432 static int decode_interrupt_cb(void)
 433 {
 434     return received_nb_signals > 1;
 435 }
 436
 437 static int exit_program(int ret)
 438 {
 439     int i;
 440
 441     /* close files */
 442     for(i=0;i<nb_output_files;i++) {
 443         AVFormatContext *s = output_files[i].ctx;
 444         if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
 445             avio_close(s->pb);
 446         avformat_free_context(s);
 447         av_dict_free(&output_files[i].opts);
 448     }
 449     for(i=0;i<nb_input_files;i++) {
 450         av_close_input_file(input_files[i].ctx);
 451     }
 452     for (i = 0; i < nb_input_streams; i++)
 453         av_dict_free(&input_streams[i].opts);
 454
 455     av_free(intra_matrix);
 456     av_free(inter_matrix);
 457
 458     if (vstats_file)
 459         fclose(vstats_file);
 460     av_free(vstats_filename);
 461
 462     av_free(meta_data_maps);
 463
 464     av_freep(&input_streams);
 465     av_freep(&input_files);
 466     av_freep(&output_streams);
 467     av_freep(&output_files);
 468
 469     uninit_opts();
 470     av_free(audio_buf);
 471     av_free(audio_out);
 472     allocated_audio_buf_size= allocated_audio_out_size= 0;
 473     av_free(samples);
 474
 475 #if CONFIG_AVFILTER
 476     avfilter_uninit();
 477 #endif
 478
 479     if (received_sigterm) {
 480         fprintf(stderr,
 481             "Received signal %d: terminating.\n",
 482             (int) received_sigterm);
 483         exit (255);
 484     }
 485
 486     exit(ret); /* not all OS-es handle main() return value */
 487     return ret;
 488 }
 489
 490 static void assert_avoptions(AVDictionary *m)
 491 {
 492     AVDictionaryEntry *t;
 493     if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
 494         av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
 495         exit_program(1);
 496     }
 497 }
 498
 499 static void assert_codec_experimental(AVCodecContext *c, int encoder)
 500 {
 501     const char *codec_string = encoder ? "encoder" : "decoder";
 502     AVCodec *codec;
 503     if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
 504         c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
 505         av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
 506                 "results.\nAdd '-strict experimental' if you want to use it.\n",
 507                 codec_string, c->codec->name);
 508         codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
 509         if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
 510             av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
 511                    codec_string, codec->name);
 512         exit_program(1);
 513     }
 514 }
 515
 516 /* similar to ff_dynarray_add() and av_fast_realloc() */
 517 static void *grow_array(void *array, int elem_size, int *size, int new_size)
 518 {
 519     if (new_size >= INT_MAX / elem_size) {
 520         fprintf(stderr, "Array too big.\n");
 521         exit_program(1);
 522     }
 523     if (*size < new_size) {
 524         uint8_t *tmp = av_realloc(array, new_size*elem_size);
 525         if (!tmp) {
 526             fprintf(stderr, "Could not alloc buffer.\n");
 527             exit_program(1);
 528         }
 529         memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
 530         *size = new_size;
 531         return tmp;
 532     }
 533     return array;
 534 }
 535
 536 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
 537 {
 538     if(codec && codec->sample_fmts){
 539         const enum AVSampleFormat *p= codec->sample_fmts;
 540         for(; *p!=-1; p++){
 541             if(*p == st->codec->sample_fmt)
 542                 break;
 543         }
 544         if (*p == -1) {
 545             av_log(NULL, AV_LOG_WARNING,
 546                    "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
 547                    av_get_sample_fmt_name(st->codec->sample_fmt),
 548                    codec->name,
 549                    av_get_sample_fmt_name(codec->sample_fmts[0]));
 550             st->codec->sample_fmt = codec->sample_fmts[0];
 551         }
 552     }
 553 }
 554
 555 /**
 556  * Update the requested input sample format based on the output sample format.
 557  * This is currently only used to request float output from decoders which
 558  * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
 559  * Ideally this will be removed in the future when decoders do not do format
 560  * conversion and only output in their native format.
 561  */
 562 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
 563                               AVCodecContext *enc)
 564 {
 565     /* if sample formats match or a decoder sample format has already been
 566        requested, just return */
 567     if (enc->sample_fmt == dec->sample_fmt ||
 568         dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
 569         return;
 570
 571     /* if decoder supports more than one output format */
 572     if (dec_codec && dec_codec->sample_fmts &&
 573         dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
 574         dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
 575         const enum AVSampleFormat *p;
 576         int min_dec = -1, min_inc = -1;
 577
 578         /* find a matching sample format in the encoder */
 579         for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
 580             if (*p == enc->sample_fmt) {
 581                 dec->request_sample_fmt = *p;
 582                 return;
 583             } else if (*p > enc->sample_fmt) {
 584                 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
 585             } else
 586                 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
 587         }
 588
 589         /* if none match, provide the one that matches quality closest */
 590         dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
 591                                   enc->sample_fmt - min_dec;
 592     }
 593 }
 594
 595 static void choose_sample_rate(AVStream *st, AVCodec *codec)
 596 {
 597     if(codec && codec->supported_samplerates){
 598         const int *p= codec->supported_samplerates;
 599         int best=0;
 600         int best_dist=INT_MAX;
 601         for(; *p; p++){
 602             int dist= abs(st->codec->sample_rate - *p);
 603             if(dist < best_dist){
 604                 best_dist= dist;
 605                 best= *p;
 606             }
 607         }
 608         if(best_dist){
 609             av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
 610         }
 611         st->codec->sample_rate= best;
 612     }
 613 }
 614
 615 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
 616 {
 617     if(codec && codec->pix_fmts){
 618         const enum PixelFormat *p= codec->pix_fmts;
 619         if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
 620             if(st->codec->codec_id==CODEC_ID_MJPEG){
 621                 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
 622             }else if(st->codec->codec_id==CODEC_ID_LJPEG){
 623                 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};
 624             }
 625         }
 626         for(; *p!=-1; p++){
 627             if(*p == st->codec->pix_fmt)
 628                 break;
 629         }
 630         if (*p == -1) {
 631             if(st->codec->pix_fmt != PIX_FMT_NONE)
 632                 av_log(NULL, AV_LOG_WARNING,
 633                         "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
 634                         av_pix_fmt_descriptors[st->codec->pix_fmt].name,
 635                         codec->name,
 636                         av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
 637             st->codec->pix_fmt = codec->pix_fmts[0];
 638         }
 639     }
 640 }
 641
 642 static double
 643 get_sync_ipts(const OutputStream *ost)
 644 {
 645     const InputStream *ist = ost->sync_ist;
 646     OutputFile *of = &output_files[ost->file_index];
 647     return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
 648 }
 649
 650 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
 651     int ret;
 652
 653     while(bsfc){
 654         AVPacket new_pkt= *pkt;
 655         int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
 656                                           &new_pkt.data, &new_pkt.size,
 657                                           pkt->data, pkt->size,
 658                                           pkt->flags & AV_PKT_FLAG_KEY);
 659         if(a>0){
 660             av_free_packet(pkt);
 661             new_pkt.destruct= av_destruct_packet;
 662         } else if(a<0){
 663             fprintf(stderr, "%s failed for stream %d, codec %s",
 664                     bsfc->filter->name, pkt->stream_index,
 665                     avctx->codec ? avctx->codec->name : "copy");
 666             print_error("", a);
 667             if (exit_on_error)
 668                 exit_program(1);
 669         }
 670         *pkt= new_pkt;
 671
 672         bsfc= bsfc->next;
 673     }
 674
 675     ret= av_interleaved_write_frame(s, pkt);
 676     if(ret < 0){
 677         print_error("av_interleaved_write_frame()", ret);
 678         exit_program(1);
 679     }
 680 }
 681
 682 static void do_audio_out(AVFormatContext *s,
 683                          OutputStream *ost,
 684                          InputStream *ist,
 685                          unsigned char *buf, int size)
 686 {
 687     uint8_t *buftmp;
 688     int64_t audio_out_size, audio_buf_size;
 689     int64_t allocated_for_size= size;
 690
 691     int size_out, frame_bytes, ret, resample_changed;
 692     AVCodecContext *enc= ost->st->codec;
 693     AVCodecContext *dec= ist->st->codec;
 694     int osize = av_get_bytes_per_sample(enc->sample_fmt);
 695     int isize = av_get_bytes_per_sample(dec->sample_fmt);
 696     const int coded_bps = av_get_bits_per_sample(enc->codec->id);
 697
 698 need_realloc:
 699     audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
 700     audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
 701     audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
 702     audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
 703     audio_buf_size*= osize*enc->channels;
 704
 705     audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
 706     if(coded_bps > 8*osize)
 707         audio_out_size= audio_out_size * coded_bps / (8*osize);
 708     audio_out_size += FF_MIN_BUFFER_SIZE;
 709
 710     if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
 711         fprintf(stderr, "Buffer sizes too large\n");
 712         exit_program(1);
 713     }
 714
 715     av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
 716     av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
 717     if (!audio_buf || !audio_out){
 718         fprintf(stderr, "Out of memory in do_audio_out\n");
 719         exit_program(1);
 720     }
 721
 722     if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
 723         ost->audio_resample = 1;
 724
 725     resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
 726                        ost->resample_channels    != dec->channels   ||
 727                        ost->resample_sample_rate != dec->sample_rate;
 728
 729     if ((ost->audio_resample && !ost->resample) || resample_changed) {
 730         if (resample_changed) {
 731             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",
 732                    ist->file_index, ist->st->index,
 733                    ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
 734                    dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
 735             ost->resample_sample_fmt  = dec->sample_fmt;
 736             ost->resample_channels    = dec->channels;
 737             ost->resample_sample_rate = dec->sample_rate;
 738             if (ost->resample)
 739                 audio_resample_close(ost->resample);
 740         }
 741         /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
 742         if (audio_sync_method <= 1 &&
 743             ost->resample_sample_fmt  == enc->sample_fmt &&
 744             ost->resample_channels    == enc->channels   &&
 745             ost->resample_sample_rate == enc->sample_rate) {
 746             ost->resample = NULL;
 747             ost->audio_resample = 0;
 748         } else if (ost->audio_resample) {
 749             if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
 750                 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
 751             ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
 752                                                    enc->sample_rate, dec->sample_rate,
 753                                                    enc->sample_fmt,  dec->sample_fmt,
 754                                                    16, 10, 0, 0.8);
 755             if (!ost->resample) {
 756                 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
 757                         dec->channels, dec->sample_rate,
 758                         enc->channels, enc->sample_rate);
 759                 exit_program(1);
 760             }
 761         }
 762     }
 763
 764 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
 765     if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
 766         MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
 767         if (ost->reformat_ctx)
 768             av_audio_convert_free(ost->reformat_ctx);
 769         ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
 770                                                    dec->sample_fmt, 1, NULL, 0);
 771         if (!ost->reformat_ctx) {
 772             fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
 773                 av_get_sample_fmt_name(dec->sample_fmt),
 774                 av_get_sample_fmt_name(enc->sample_fmt));
 775             exit_program(1);
 776         }
 777         ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
 778     }
 779
 780     if(audio_sync_method){
 781         double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
 782                 - av_fifo_size(ost->fifo)/(enc->channels * 2);
 783         double idelta= delta*dec->sample_rate / enc->sample_rate;
 784         int byte_delta= ((int)idelta)*2*dec->channels;
 785
 786         //FIXME resample delay
 787         if(fabs(delta) > 50){
 788             if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
 789                 if(byte_delta < 0){
 790                     byte_delta= FFMAX(byte_delta, -size);
 791                     size += byte_delta;
 792                     buf  -= byte_delta;
 793                     if(verbose > 2)
 794                         fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
 795                     if(!size)
 796                         return;
 797                     ist->is_start=0;
 798                 }else{
 799                     static uint8_t *input_tmp= NULL;
 800                     input_tmp= av_realloc(input_tmp, byte_delta + size);
 801
 802                     if(byte_delta > allocated_for_size - size){
 803                         allocated_for_size= byte_delta + (int64_t)size;
 804                         goto need_realloc;
 805                     }
 806                     ist->is_start=0;
 807
 808                     memset(input_tmp, 0, byte_delta);
 809                     memcpy(input_tmp + byte_delta, buf, size);
 810                     buf= input_tmp;
 811                     size += byte_delta;
 812                     if(verbose > 2)
 813                         fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
 814                 }
 815             }else if(audio_sync_method>1){
 816                 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
 817                 av_assert0(ost->audio_resample);
 818                 if(verbose > 2)
 819                     fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
 820 //                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));
 821                 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
 822             }
 823         }
 824     }else
 825         ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
 826                         - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
 827
 828     if (ost->audio_resample) {
 829         buftmp = audio_buf;
 830         size_out = audio_resample(ost->resample,
 831                                   (short *)buftmp, (short *)buf,
 832                                   size / (dec->channels * isize));
 833         size_out = size_out * enc->channels * osize;
 834     } else {
 835         buftmp = buf;
 836         size_out = size;
 837     }
 838
 839     if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
 840         const void *ibuf[6]= {buftmp};
 841         void *obuf[6]= {audio_buf};
 842         int istride[6]= {isize};
 843         int ostride[6]= {osize};
 844         int len= size_out/istride[0];
 845         if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
 846             printf("av_audio_convert() failed\n");
 847             if (exit_on_error)
 848                 exit_program(1);
 849             return;
 850         }
 851         buftmp = audio_buf;
 852         size_out = len*osize;
 853     }
 854
 855     /* now encode as many frames as possible */
 856     if (enc->frame_size > 1) {
 857         /* output resampled raw samples */
 858         if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
 859             fprintf(stderr, "av_fifo_realloc2() failed\n");
 860             exit_program(1);
 861         }
 862         av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
 863
 864         frame_bytes = enc->frame_size * osize * enc->channels;
 865
 866         while (av_fifo_size(ost->fifo) >= frame_bytes) {
 867             AVPacket pkt;
 868             av_init_packet(&pkt);
 869
 870             av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
 871
 872             //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
 873
 874             ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
 875                                        (short *)audio_buf);
 876             if (ret < 0) {
 877                 fprintf(stderr, "Audio encoding failed\n");
 878                 exit_program(1);
 879             }
 880             audio_size += ret;
 881             pkt.stream_index= ost->index;
 882             pkt.data= audio_out;
 883             pkt.size= ret;
 884             if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
 885                 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
 886             pkt.flags |= AV_PKT_FLAG_KEY;
 887             write_frame(s, &pkt, enc, ost->bitstream_filters);
 888
 889             ost->sync_opts += enc->frame_size;
 890         }
 891     } else {
 892         AVPacket pkt;
 893         av_init_packet(&pkt);
 894
 895         ost->sync_opts += size_out / (osize * enc->channels);
 896
 897         /* output a pcm frame */
 898         /* determine the size of the coded buffer */
 899         size_out /= osize;
 900         if (coded_bps)
 901             size_out = size_out*coded_bps/8;
 902
 903         if(size_out > audio_out_size){
 904             fprintf(stderr, "Internal error, buffer size too small\n");
 905             exit_program(1);
 906         }
 907
 908         //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
 909         ret = avcodec_encode_audio(enc, audio_out, size_out,
 910                                    (short *)buftmp);
 911         if (ret < 0) {
 912             fprintf(stderr, "Audio encoding failed\n");
 913             exit_program(1);
 914         }
 915         audio_size += ret;
 916         pkt.stream_index= ost->index;
 917         pkt.data= audio_out;
 918         pkt.size= ret;
 919         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
 920             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
 921         pkt.flags |= AV_PKT_FLAG_KEY;
 922         write_frame(s, &pkt, enc, ost->bitstream_filters);
 923     }
 924 }
 925
 926 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
 927 {
 928     AVCodecContext *dec;
 929     AVPicture *picture2;
 930     AVPicture picture_tmp;
 931     uint8_t *buf = 0;
 932
 933     dec = ist->st->codec;
 934
 935     /* deinterlace : must be done before any resize */
 936     if (do_deinterlace) {
 937         int size;
 938
 939         /* create temporary picture */
 940         size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
 941         buf = av_malloc(size);
 942         if (!buf)
 943             return;
 944
 945         picture2 = &picture_tmp;
 946         avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
 947
 948         if(avpicture_deinterlace(picture2, picture,
 949                                  dec->pix_fmt, dec->width, dec->height) < 0) {
 950             /* if error, do not deinterlace */
 951             fprintf(stderr, "Deinterlacing failed\n");
 952             av_free(buf);
 953             buf = NULL;
 954             picture2 = picture;
 955         }
 956     } else {
 957         picture2 = picture;
 958     }
 959
 960     if (picture != picture2)
 961         *picture = *picture2;
 962     *bufp = buf;
 963 }
 964
 965 static void do_subtitle_out(AVFormatContext *s,
 966                             OutputStream *ost,
 967                             InputStream *ist,
 968                             AVSubtitle *sub,
 969                             int64_t pts)
 970 {
 971     static uint8_t *subtitle_out = NULL;
 972     int subtitle_out_max_size = 1024 * 1024;
 973     int subtitle_out_size, nb, i;
 974     AVCodecContext *enc;
 975     AVPacket pkt;
 976
 977     if (pts == AV_NOPTS_VALUE) {
 978         fprintf(stderr, "Subtitle packets must have a pts\n");
 979         if (exit_on_error)
 980             exit_program(1);
 981         return;
 982     }
 983
 984     enc = ost->st->codec;
 985
 986     if (!subtitle_out) {
 987         subtitle_out = av_malloc(subtitle_out_max_size);
 988     }
 989
 990     /* Note: DVB subtitle need one packet to draw them and one other
 991        packet to clear them */
 992     /* XXX: signal it in the codec context ? */
 993     if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
 994         nb = 2;
 995     else
 996         nb = 1;
 997
 998     for(i = 0; i < nb; i++) {
 999         sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1000         // start_display_time is required to be 0
1001         sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1002         sub->end_display_time -= sub->start_display_time;
1003         sub->start_display_time = 0;
1004         subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1005                                                     subtitle_out_max_size, sub);
1006         if (subtitle_out_size < 0) {
1007             fprintf(stderr, "Subtitle encoding failed\n");
1008             exit_program(1);
1009         }
1010
1011         av_init_packet(&pkt);
1012         pkt.stream_index = ost->index;
1013         pkt.data = subtitle_out;
1014         pkt.size = subtitle_out_size;
1015         pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1016         if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1017             /* XXX: the pts correction is handled here. Maybe handling
1018                it in the codec would be better */
1019             if (i == 0)
1020                 pkt.pts += 90 * sub->start_display_time;
1021             else
1022                 pkt.pts += 90 * sub->end_display_time;
1023         }
1024         write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1025     }
1026 }
1027
1028 static int bit_buffer_size= 1024*256;
1029 static uint8_t *bit_buffer= NULL;
1030
1031 static void do_video_resample(OutputStream *ost,
1032                               InputStream *ist,
1033                               AVFrame *in_picture,
1034                               AVFrame **out_picture)
1035 {
1036     int resample_changed = 0;
1037     AVCodecContext *dec = ist->st->codec;
1038     *out_picture = in_picture;
1039
1040     resample_changed = ost->resample_width   != dec->width  ||
1041                        ost->resample_height  != dec->height ||
1042                        ost->resample_pix_fmt != dec->pix_fmt;
1043
1044     if (resample_changed) {
1045         av_log(NULL, AV_LOG_INFO,
1046                "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1047                ist->file_index, ist->st->index,
1048                ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1049                dec->width         , dec->height         , av_get_pix_fmt_name(dec->pix_fmt));
1050         if(!ost->video_resample)
1051             ost->video_resample = 1;
1052     }
1053
1054 #if !CONFIG_AVFILTER
1055     if (ost->video_resample) {
1056         *out_picture = &ost->pict_tmp;
1057         if (resample_changed) {
1058             /* initialize a new scaler context */
1059             sws_freeContext(ost->img_resample_ctx);
1060             ost->img_resample_ctx = sws_getContext(
1061                 ist->st->codec->width,
1062                 ist->st->codec->height,
1063                 ist->st->codec->pix_fmt,
1064                 ost->st->codec->width,
1065                 ost->st->codec->height,
1066                 ost->st->codec->pix_fmt,
1067                 ost->sws_flags, NULL, NULL, NULL);
1068             if (ost->img_resample_ctx == NULL) {
1069                 fprintf(stderr, "Cannot get resampling context\n");
1070                 exit_program(1);
1071             }
1072         }
1073         sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1074               0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1075     }
1076 #else
1077     if (resample_changed) {
1078         avfilter_graph_free(&ost->graph);
1079         if (configure_video_filters(ist, ost)) {
1080             fprintf(stderr, "Error reinitializing filters!\n");
1081             exit_program(1);
1082         }
1083     }
1084 #endif
1085     if (resample_changed) {
1086         ost->resample_width   = dec->width;
1087         ost->resample_height  = dec->height;
1088         ost->resample_pix_fmt = dec->pix_fmt;
1089     }
1090 }
1091
1092
1093 static void do_video_out(AVFormatContext *s,
1094                          OutputStream *ost,
1095                          InputStream *ist,
1096                          AVFrame *in_picture,
1097                          int *frame_size, float quality)
1098 {
1099     int nb_frames, i, ret, format_video_sync;
1100     AVFrame *final_picture;
1101     AVCodecContext *enc, *dec;
1102     double sync_ipts;
1103
1104     enc = ost->st->codec;
1105     dec = ist->st->codec;
1106
1107     sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1108
1109     /* by default, we output a single frame */
1110     nb_frames = 1;
1111
1112     *frame_size = 0;
1113
1114     format_video_sync = video_sync_method;
1115     if (format_video_sync < 0)
1116         format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1117
1118     if (format_video_sync) {
1119         double vdelta = sync_ipts - ost->sync_opts;
1120         //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1121         if (vdelta < -1.1)
1122             nb_frames = 0;
1123         else if (format_video_sync == 2) {
1124             if(vdelta<=-0.6){
1125                 nb_frames=0;
1126             }else if(vdelta>0.6)
1127                 ost->sync_opts= lrintf(sync_ipts);
1128         }else if (vdelta > 1.1)
1129             nb_frames = lrintf(vdelta);
1130 //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);
1131         if (nb_frames == 0){
1132             ++nb_frames_drop;
1133             if (verbose>2)
1134                 fprintf(stderr, "*** drop!\n");
1135         }else if (nb_frames > 1) {
1136             nb_frames_dup += nb_frames - 1;
1137             if (verbose>2)
1138                 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1139         }
1140     }else
1141         ost->sync_opts= lrintf(sync_ipts);
1142
1143     nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1144     if (nb_frames <= 0)
1145         return;
1146
1147     do_video_resample(ost, ist, in_picture, &final_picture);
1148
1149     /* duplicates frame if needed */
1150     for(i=0;i<nb_frames;i++) {
1151         AVPacket pkt;
1152         av_init_packet(&pkt);
1153         pkt.stream_index= ost->index;
1154
1155         if (s->oformat->flags & AVFMT_RAWPICTURE) {
1156             /* raw pictures are written as AVPicture structure to
1157                avoid any copies. We support temporarily the older
1158                method. */
1159             AVFrame* old_frame = enc->coded_frame;
1160             enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1161             pkt.data= (uint8_t *)final_picture;
1162             pkt.size=  sizeof(AVPicture);
1163             pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1164             pkt.flags |= AV_PKT_FLAG_KEY;
1165
1166             write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1167             enc->coded_frame = old_frame;
1168         } else {
1169             AVFrame big_picture;
1170
1171             big_picture= *final_picture;
1172             /* better than nothing: use input picture interlaced
1173                settings */
1174             big_picture.interlaced_frame = in_picture->interlaced_frame;
1175             if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1176                 if(top_field_first == -1)
1177                     big_picture.top_field_first = in_picture->top_field_first;
1178                 else
1179                     big_picture.top_field_first = top_field_first;
1180             }
1181
1182             /* handles same_quant here. This is not correct because it may
1183                not be a global option */
1184             big_picture.quality = quality;
1185             if(!me_threshold)
1186                 big_picture.pict_type = 0;
1187 //            big_picture.pts = AV_NOPTS_VALUE;
1188             big_picture.pts= ost->sync_opts;
1189 //            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1190 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1191             if (ost->forced_kf_index < ost->forced_kf_count &&
1192                 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1193                 big_picture.pict_type = AV_PICTURE_TYPE_I;
1194                 ost->forced_kf_index++;
1195             }
1196             ret = avcodec_encode_video(enc,
1197                                        bit_buffer, bit_buffer_size,
1198                                        &big_picture);
1199             if (ret < 0) {
1200                 fprintf(stderr, "Video encoding failed\n");
1201                 exit_program(1);
1202             }
1203
1204             if(ret>0){
1205                 pkt.data= bit_buffer;
1206                 pkt.size= ret;
1207                 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1208                     pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1209 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1210    pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1211    pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1212
1213                 if(enc->coded_frame->key_frame)
1214                     pkt.flags |= AV_PKT_FLAG_KEY;
1215                 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1216                 *frame_size = ret;
1217                 video_size += ret;
1218                 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1219                 //        enc->frame_number-1, ret, enc->pict_type);
1220                 /* if two pass, output log */
1221                 if (ost->logfile && enc->stats_out) {
1222                     fprintf(ost->logfile, "%s", enc->stats_out);
1223                 }
1224             }
1225         }
1226         ost->sync_opts++;
1227         ost->frame_number++;
1228     }
1229 }
1230
1231 static double psnr(double d){
1232     return -10.0*log(d)/log(10.0);
1233 }
1234
1235 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1236                            int frame_size)
1237 {
1238     AVCodecContext *enc;
1239     int frame_number;
1240     double ti1, bitrate, avg_bitrate;
1241
1242     /* this is executed just the first time do_video_stats is called */
1243     if (!vstats_file) {
1244         vstats_file = fopen(vstats_filename, "w");
1245         if (!vstats_file) {
1246             perror("fopen");
1247             exit_program(1);
1248         }
1249     }
1250
1251     enc = ost->st->codec;
1252     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1253         frame_number = ost->frame_number;
1254         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1255         if (enc->flags&CODEC_FLAG_PSNR)
1256             fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1257
1258         fprintf(vstats_file,"f_size= %6d ", frame_size);
1259         /* compute pts value */
1260         ti1 = ost->sync_opts * av_q2d(enc->time_base);
1261         if (ti1 < 0.01)
1262             ti1 = 0.01;
1263
1264         bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1265         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1266         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1267             (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1268         fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1269     }
1270 }
1271
1272 static void print_report(OutputFile *output_files,
1273                          OutputStream *ost_table, int nb_ostreams,
1274                          int is_last_report, int64_t timer_start)
1275 {
1276     char buf[1024];
1277     OutputStream *ost;
1278     AVFormatContext *oc;
1279     int64_t total_size;
1280     AVCodecContext *enc;
1281     int frame_number, vid, i;
1282     double bitrate, ti1, pts;
1283     static int64_t last_time = -1;
1284     static int qp_histogram[52];
1285
1286     if (!is_last_report) {
1287         int64_t cur_time;
1288         /* display the report every 0.5 seconds */
1289         cur_time = av_gettime();
1290         if (last_time == -1) {
1291             last_time = cur_time;
1292             return;
1293         }
1294         if ((cur_time - last_time) < 500000)
1295             return;
1296         last_time = cur_time;
1297     }
1298
1299
1300     oc = output_files[0].ctx;
1301
1302     total_size = avio_size(oc->pb);
1303     if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1304         total_size= avio_tell(oc->pb);
1305
1306     buf[0] = '\0';
1307     ti1 = 1e10;
1308     vid = 0;
1309     for(i=0;i<nb_ostreams;i++) {
1310         float q = -1;
1311         ost = &ost_table[i];
1312         enc = ost->st->codec;
1313         if (!ost->st->stream_copy && enc->coded_frame)
1314             q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1315         if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1316             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1317         }
1318         if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1319             float t = (av_gettime()-timer_start) / 1000000.0;
1320
1321             frame_number = ost->frame_number;
1322             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1323                      frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1324             if(is_last_report)
1325                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1326             if(qp_hist){
1327                 int j;
1328                 int qp = lrintf(q);
1329                 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1330                     qp_histogram[qp]++;
1331                 for(j=0; j<32; j++)
1332                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1333             }
1334             if (enc->flags&CODEC_FLAG_PSNR){
1335                 int j;
1336                 double error, error_sum=0;
1337                 double scale, scale_sum=0;
1338                 char type[3]= {'Y','U','V'};
1339                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1340                 for(j=0; j<3; j++){
1341                     if(is_last_report){
1342                         error= enc->error[j];
1343                         scale= enc->width*enc->height*255.0*255.0*frame_number;
1344                     }else{
1345                         error= enc->coded_frame->error[j];
1346                         scale= enc->width*enc->height*255.0*255.0;
1347                     }
1348                     if(j) scale/=4;
1349                     error_sum += error;
1350                     scale_sum += scale;
1351                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1352                 }
1353                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1354             }
1355             vid = 1;
1356         }
1357         /* compute min output value */
1358         pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1359         if ((pts < ti1) && (pts > 0))
1360             ti1 = pts;
1361     }
1362     if (ti1 < 0.01)
1363         ti1 = 0.01;
1364
1365     if (verbose > 0 || is_last_report) {
1366         bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1367
1368         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1369             "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1370             (double)total_size / 1024, ti1, bitrate);
1371
1372         if (nb_frames_dup || nb_frames_drop)
1373           snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1374                   nb_frames_dup, nb_frames_drop);
1375
1376         if (verbose >= 0)
1377             fprintf(stderr, "%s    \r", buf);
1378
1379         fflush(stderr);
1380     }
1381
1382     if (is_last_report && verbose >= 0){
1383         int64_t raw= audio_size + video_size + extra_size;
1384         fprintf(stderr, "\n");
1385         fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1386                 video_size/1024.0,
1387                 audio_size/1024.0,
1388                 extra_size/1024.0,
1389                 100.0*(total_size - raw)/raw
1390         );
1391     }
1392 }
1393
1394 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1395 {
1396     int fill_char = 0x00;
1397     if (sample_fmt == AV_SAMPLE_FMT_U8)
1398         fill_char = 0x80;
1399     memset(buf, fill_char, size);
1400 }
1401
1402 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1403 {
1404     int i, ret;
1405
1406     for (i = 0; i < nb_ostreams; i++) {
1407         OutputStream   *ost = &ost_table[i];
1408         AVCodecContext *enc = ost->st->codec;
1409         AVFormatContext *os = output_files[ost->file_index].ctx;
1410
1411         if (!ost->encoding_needed)
1412             continue;
1413
1414         if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1415             continue;
1416         if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1417             continue;
1418
1419         for(;;) {
1420             AVPacket pkt;
1421             int fifo_bytes;
1422             av_init_packet(&pkt);
1423             pkt.stream_index= ost->index;
1424
1425             switch (ost->st->codec->codec_type) {
1426             case AVMEDIA_TYPE_AUDIO:
1427                 fifo_bytes = av_fifo_size(ost->fifo);
1428                 ret = 0;
1429                 /* encode any samples remaining in fifo */
1430                 if (fifo_bytes > 0) {
1431                     int osize = av_get_bytes_per_sample(enc->sample_fmt);
1432                     int fs_tmp = enc->frame_size;
1433
1434                     av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1435                     if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1436                         enc->frame_size = fifo_bytes / (osize * enc->channels);
1437                     } else { /* pad */
1438                         int frame_bytes = enc->frame_size*osize*enc->channels;
1439                         if (allocated_audio_buf_size < frame_bytes)
1440                             exit_program(1);
1441                         generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1442                     }
1443
1444                     ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1445                     pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1446                                               ost->st->time_base.num, enc->sample_rate);
1447                     enc->frame_size = fs_tmp;
1448                 }
1449                 if (ret <= 0) {
1450                     ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1451                 }
1452                 if (ret < 0) {
1453                     fprintf(stderr, "Audio encoding failed\n");
1454                     exit_program(1);
1455                 }
1456                 audio_size += ret;
1457                 pkt.flags |= AV_PKT_FLAG_KEY;
1458                 break;
1459             case AVMEDIA_TYPE_VIDEO:
1460                 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1461                 if (ret < 0) {
1462                     fprintf(stderr, "Video encoding failed\n");
1463                     exit_program(1);
1464                 }
1465                 video_size += ret;
1466                 if(enc->coded_frame && enc->coded_frame->key_frame)
1467                     pkt.flags |= AV_PKT_FLAG_KEY;
1468                 if (ost->logfile && enc->stats_out) {
1469                     fprintf(ost->logfile, "%s", enc->stats_out);
1470                 }
1471                 break;
1472             default:
1473                 ret=-1;
1474             }
1475
1476             if (ret <= 0)
1477                 break;
1478             pkt.data = bit_buffer;
1479             pkt.size = ret;
1480             if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1481                 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1482             write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1483         }
1484     }
1485 }
1486
1487 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1488 static int output_packet(InputStream *ist, int ist_index,
1489                          OutputStream *ost_table, int nb_ostreams,
1490                          const AVPacket *pkt)
1491 {
1492     AVFormatContext *os;
1493     OutputStream *ost;
1494     int ret, i;
1495     int got_output;
1496     AVFrame picture;
1497     void *buffer_to_free = NULL;
1498     static unsigned int samples_size= 0;
1499     AVSubtitle subtitle, *subtitle_to_free;
1500     int64_t pkt_pts = AV_NOPTS_VALUE;
1501 #if CONFIG_AVFILTER
1502     int frame_available;
1503 #endif
1504     float quality;
1505
1506     AVPacket avpkt;
1507     int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1508
1509     if(ist->next_pts == AV_NOPTS_VALUE)
1510         ist->next_pts= ist->pts;
1511
1512     if (pkt == NULL) {
1513         /* EOF handling */
1514         av_init_packet(&avpkt);
1515         avpkt.data = NULL;
1516         avpkt.size = 0;
1517         goto handle_eof;
1518     } else {
1519         avpkt = *pkt;
1520     }
1521
1522     if(pkt->dts != AV_NOPTS_VALUE)
1523         ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1524     if(pkt->pts != AV_NOPTS_VALUE)
1525         pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1526
1527     //while we have more to decode or while the decoder did output something on EOF
1528     while (avpkt.size > 0 || (!pkt && got_output)) {
1529         uint8_t *data_buf, *decoded_data_buf;
1530         int data_size, decoded_data_size;
1531     handle_eof:
1532         ist->pts= ist->next_pts;
1533
1534         if(avpkt.size && avpkt.size != pkt->size &&
1535            ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1536             fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1537             ist->showed_multi_packet_warning=1;
1538         }
1539
1540         /* decode the packet if needed */
1541         decoded_data_buf = NULL; /* fail safe */
1542         decoded_data_size= 0;
1543         data_buf  = avpkt.data;
1544         data_size = avpkt.size;
1545         subtitle_to_free = NULL;
1546         if (ist->decoding_needed) {
1547             switch(ist->st->codec->codec_type) {
1548             case AVMEDIA_TYPE_AUDIO:{
1549                 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1550                     samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1551                     av_free(samples);
1552                     samples= av_malloc(samples_size);
1553                 }
1554                 decoded_data_size= samples_size;
1555                     /* XXX: could avoid copy if PCM 16 bits with same
1556                        endianness as CPU */
1557                 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1558                                             &avpkt);
1559                 if (ret < 0)
1560                     return ret;
1561                 avpkt.data += ret;
1562                 avpkt.size -= ret;
1563                 data_size   = ret;
1564                 got_output  = decoded_data_size > 0;
1565                 /* Some bug in mpeg audio decoder gives */
1566                 /* decoded_data_size < 0, it seems they are overflows */
1567                 if (!got_output) {
1568                     /* no audio frame */
1569                     continue;
1570                 }
1571                 decoded_data_buf = (uint8_t *)samples;
1572                 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1573                     (ist->st->codec->sample_rate * ist->st->codec->channels);
1574                 break;}
1575             case AVMEDIA_TYPE_VIDEO:
1576                     decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1577                     /* XXX: allocate picture correctly */
1578                     avcodec_get_frame_defaults(&picture);
1579                     avpkt.pts = pkt_pts;
1580                     avpkt.dts = ist->pts;
1581                     pkt_pts = AV_NOPTS_VALUE;
1582
1583                     ret = avcodec_decode_video2(ist->st->codec,
1584                                                 &picture, &got_output, &avpkt);
1585                     quality = same_quant ? picture.quality : 0;
1586                     if (ret < 0)
1587                         return ret;
1588                     if (!got_output) {
1589                         /* no picture yet */
1590                         goto discard_packet;
1591                     }
1592                     ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1593                     if (ist->st->codec->time_base.num != 0) {
1594                         int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1595                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1596                                           ist->st->codec->time_base.num * ticks) /
1597                             ist->st->codec->time_base.den;
1598                     }
1599                     avpkt.size = 0;
1600                     buffer_to_free = NULL;
1601                     pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1602                     break;
1603             case AVMEDIA_TYPE_SUBTITLE:
1604                 ret = avcodec_decode_subtitle2(ist->st->codec,
1605                                                &subtitle, &got_output, &avpkt);
1606                 if (ret < 0)
1607                     return ret;
1608                 if (!got_output) {
1609                     goto discard_packet;
1610                 }
1611                 subtitle_to_free = &subtitle;
1612                 avpkt.size = 0;
1613                 break;
1614             default:
1615                 return -1;
1616             }
1617         } else {
1618             switch(ist->st->codec->codec_type) {
1619             case AVMEDIA_TYPE_AUDIO:
1620                 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1621                     ist->st->codec->sample_rate;
1622                 break;
1623             case AVMEDIA_TYPE_VIDEO:
1624                 if (ist->st->codec->time_base.num != 0) {
1625                     int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1626                     ist->next_pts += ((int64_t)AV_TIME_BASE *
1627                                       ist->st->codec->time_base.num * ticks) /
1628                         ist->st->codec->time_base.den;
1629                 }
1630                 break;
1631             }
1632             avpkt.size = 0;
1633         }
1634
1635         // preprocess audio (volume)
1636         if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1637             if (audio_volume != 256) {
1638                 short *volp;
1639                 volp = samples;
1640                 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1641                     int v = ((*volp) * audio_volume + 128) >> 8;
1642                     *volp++ = av_clip_int16(v);
1643                 }
1644             }
1645         }
1646
1647         /* frame rate emulation */
1648         if (rate_emu) {
1649             int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1650             int64_t now = av_gettime() - ist->start;
1651             if (pts > now)
1652                 usleep(pts - now);
1653         }
1654         /* if output time reached then transcode raw format,
1655            encode packets and output them */
1656         for (i = 0; i < nb_ostreams; i++) {
1657             OutputFile *of = &output_files[ost_table[i].file_index];
1658             int frame_size;
1659
1660             ost = &ost_table[i];
1661             if (ost->source_index != ist_index)
1662                 continue;
1663
1664             if (of->start_time && ist->pts < of->start_time)
1665                 continue;
1666
1667             if (of->recording_time != INT64_MAX &&
1668                 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1669                               (AVRational){1, 1000000}) >= 0) {
1670                 ost->is_past_recording_time = 1;
1671                 continue;
1672             }
1673
1674 #if CONFIG_AVFILTER
1675             if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1676                 ost->input_video_filter) {
1677                 AVRational sar;
1678                 if (ist->st->sample_aspect_ratio.num)
1679                     sar = ist->st->sample_aspect_ratio;
1680                 else
1681                     sar = ist->st->codec->sample_aspect_ratio;
1682                 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, ist->pts, sar);
1683             }
1684             frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1685                 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1686             while (frame_available) {
1687                 AVRational ist_pts_tb;
1688                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1689                     get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1690                 if (ost->picref)
1691                     ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1692 #endif
1693                 os = output_files[ost->file_index].ctx;
1694
1695                 /* set the input output pts pairs */
1696                 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1697
1698                 if (ost->encoding_needed) {
1699                     av_assert0(ist->decoding_needed);
1700                     switch(ost->st->codec->codec_type) {
1701                     case AVMEDIA_TYPE_AUDIO:
1702                         do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1703                         break;
1704                     case AVMEDIA_TYPE_VIDEO:
1705 #if CONFIG_AVFILTER
1706                         if (ost->picref->video && !ost->frame_aspect_ratio)
1707                             ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1708 #endif
1709                         do_video_out(os, ost, ist, &picture, &frame_size,
1710                                      same_quant ? quality : ost->st->codec->global_quality);
1711                         if (vstats_filename && frame_size)
1712                             do_video_stats(os, ost, frame_size);
1713                         break;
1714                     case AVMEDIA_TYPE_SUBTITLE:
1715                         do_subtitle_out(os, ost, ist, &subtitle,
1716                                         pkt->pts);
1717                         break;
1718                     default:
1719                         abort();
1720                     }
1721                 } else {
1722                     AVFrame avframe; //FIXME/XXX remove this
1723                     AVPacket opkt;
1724                     int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1725
1726                     av_init_packet(&opkt);
1727
1728                     if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1729 #if !CONFIG_AVFILTER
1730                         continue;
1731 #else
1732                         goto cont;
1733 #endif
1734
1735                     /* no reencoding needed : output the packet directly */
1736                     /* force the input stream PTS */
1737
1738                     avcodec_get_frame_defaults(&avframe);
1739                     ost->st->codec->coded_frame= &avframe;
1740                     avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1741
1742                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1743                         audio_size += data_size;
1744                     else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1745                         video_size += data_size;
1746                         ost->sync_opts++;
1747                     }
1748
1749                     opkt.stream_index= ost->index;
1750                     if(pkt->pts != AV_NOPTS_VALUE)
1751                         opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1752                     else
1753                         opkt.pts= AV_NOPTS_VALUE;
1754
1755                     if (pkt->dts == AV_NOPTS_VALUE)
1756                         opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1757                     else
1758                         opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1759                     opkt.dts -= ost_tb_start_time;
1760
1761                     opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1762                     opkt.flags= pkt->flags;
1763
1764                     //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1765                     if(   ost->st->codec->codec_id != CODEC_ID_H264
1766                        && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1767                        && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1768                        ) {
1769                         if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1770                             opkt.destruct= av_destruct_packet;
1771                     } else {
1772                         opkt.data = data_buf;
1773                         opkt.size = data_size;
1774                     }
1775
1776                     write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1777                     ost->st->codec->frame_number++;
1778                     ost->frame_number++;
1779                     av_free_packet(&opkt);
1780                 }
1781 #if CONFIG_AVFILTER
1782                 cont:
1783                 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1784                                    ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1785                 if (ost->picref)
1786                     avfilter_unref_buffer(ost->picref);
1787             }
1788 #endif
1789             }
1790
1791         av_free(buffer_to_free);
1792         /* XXX: allocate the subtitles in the codec ? */
1793         if (subtitle_to_free) {
1794             avsubtitle_free(subtitle_to_free);
1795             subtitle_to_free = NULL;
1796         }
1797     }
1798  discard_packet:
1799
1800     return 0;
1801 }
1802
1803 static void print_sdp(OutputFile *output_files, int n)
1804 {
1805     char sdp[2048];
1806     int i;
1807     AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1808
1809     if (!avc)
1810         exit_program(1);
1811     for (i = 0; i < n; i++)
1812         avc[i] = output_files[i].ctx;
1813
1814     av_sdp_create(avc, n, sdp, sizeof(sdp));
1815     printf("SDP:\n%s\n", sdp);
1816     fflush(stdout);
1817     av_freep(&avc);
1818 }
1819
1820 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1821                              char *error, int error_len)
1822 {
1823     int i;
1824     InputStream *ist = &input_streams[ist_index];
1825     if (ist->decoding_needed) {
1826         AVCodec *codec = ist->dec;
1827         if (!codec) {
1828             snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
1829                     ist->st->codec->codec_id, ist->file_index, ist->st->index);
1830             return AVERROR(EINVAL);
1831         }
1832
1833         /* update requested sample format for the decoder based on the
1834            corresponding encoder sample format */
1835         for (i = 0; i < nb_output_streams; i++) {
1836             OutputStream *ost = &output_streams[i];
1837             if (ost->source_index == ist_index) {
1838                 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
1839                 break;
1840             }
1841         }
1842
1843         if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1844             snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
1845                     ist->file_index, ist->st->index);
1846             return AVERROR(EINVAL);
1847         }
1848         assert_codec_experimental(ist->st->codec, 0);
1849         assert_avoptions(ist->opts);
1850     }
1851
1852     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;
1853     ist->next_pts = AV_NOPTS_VALUE;
1854     init_pts_correction(&ist->pts_ctx);
1855     ist->is_start = 1;
1856
1857     return 0;
1858 }
1859
1860 static int transcode_init(OutputFile *output_files,
1861                           int nb_output_files,
1862                           InputFile *input_files,
1863                           int nb_input_files)
1864 {
1865     int ret = 0, i;
1866     AVFormatContext *os;
1867     AVCodecContext *codec, *icodec;
1868     OutputStream *ost;
1869     InputStream *ist;
1870     char error[1024];
1871     int want_sdp = 1;
1872
1873     if (rate_emu)
1874         for (i = 0; i < nb_input_streams; i++)
1875             input_streams[i].start = av_gettime();
1876
1877     /* output stream init */
1878     for(i=0;i<nb_output_files;i++) {
1879         os = output_files[i].ctx;
1880         if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1881             av_dump_format(os, i, os->filename, 1);
1882             fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1883             return AVERROR(EINVAL);
1884         }
1885     }
1886
1887     /* for each output stream, we compute the right encoding parameters */
1888     for (i = 0; i < nb_output_streams; i++) {
1889         ost = &output_streams[i];
1890         os = output_files[ost->file_index].ctx;
1891         ist = &input_streams[ost->source_index];
1892
1893         codec = ost->st->codec;
1894         icodec = ist->st->codec;
1895
1896         ost->st->disposition = ist->st->disposition;
1897         codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1898         codec->chroma_sample_location = icodec->chroma_sample_location;
1899
1900         if (ost->st->stream_copy) {
1901             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
1902
1903             if (extra_size > INT_MAX) {
1904                 return AVERROR(EINVAL);
1905             }
1906
1907             /* if stream_copy is selected, no need to decode or encode */
1908             codec->codec_id = icodec->codec_id;
1909             codec->codec_type = icodec->codec_type;
1910
1911             if(!codec->codec_tag){
1912                 if(   !os->oformat->codec_tag
1913                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1914                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1915                     codec->codec_tag = icodec->codec_tag;
1916             }
1917
1918             codec->bit_rate = icodec->bit_rate;
1919             codec->rc_max_rate    = icodec->rc_max_rate;
1920             codec->rc_buffer_size = icodec->rc_buffer_size;
1921             codec->extradata= av_mallocz(extra_size);
1922             if (!codec->extradata) {
1923                 return AVERROR(ENOMEM);
1924             }
1925             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
1926             codec->extradata_size= icodec->extradata_size;
1927             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){
1928                 codec->time_base = icodec->time_base;
1929                 codec->time_base.num *= icodec->ticks_per_frame;
1930                 av_reduce(&codec->time_base.num, &codec->time_base.den,
1931                           codec->time_base.num, codec->time_base.den, INT_MAX);
1932             }else
1933                 codec->time_base = ist->st->time_base;
1934             switch(codec->codec_type) {
1935             case AVMEDIA_TYPE_AUDIO:
1936                 if(audio_volume != 256) {
1937                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1938                     exit_program(1);
1939                 }
1940                 codec->channel_layout = icodec->channel_layout;
1941                 codec->sample_rate = icodec->sample_rate;
1942                 codec->channels = icodec->channels;
1943                 codec->frame_size = icodec->frame_size;
1944                 codec->audio_service_type = icodec->audio_service_type;
1945                 codec->block_align= icodec->block_align;
1946                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1947                     codec->block_align= 0;
1948                 if(codec->codec_id == CODEC_ID_AC3)
1949                     codec->block_align= 0;
1950                 break;
1951             case AVMEDIA_TYPE_VIDEO:
1952                 codec->pix_fmt = icodec->pix_fmt;
1953                 codec->width = icodec->width;
1954                 codec->height = icodec->height;
1955                 codec->has_b_frames = icodec->has_b_frames;
1956                 if (!codec->sample_aspect_ratio.num) {
1957                     codec->sample_aspect_ratio =
1958                     ost->st->sample_aspect_ratio =
1959                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
1960                         ist->st->codec->sample_aspect_ratio.num ?
1961                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
1962                 }
1963                 break;
1964             case AVMEDIA_TYPE_SUBTITLE:
1965                 codec->width = icodec->width;
1966                 codec->height = icodec->height;
1967                 break;
1968             case AVMEDIA_TYPE_DATA:
1969                 break;
1970             default:
1971                 abort();
1972             }
1973         } else {
1974             if (!ost->enc)
1975                 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1976             switch(codec->codec_type) {
1977             case AVMEDIA_TYPE_AUDIO:
1978                 ost->fifo= av_fifo_alloc(1024);
1979                 if (!ost->fifo) {
1980                     return AVERROR(ENOMEM);
1981                 }
1982                 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
1983                 if (!codec->sample_rate) {
1984                     codec->sample_rate = icodec->sample_rate;
1985                     if (icodec->lowres)
1986                         codec->sample_rate >>= icodec->lowres;
1987                 }
1988                 choose_sample_rate(ost->st, ost->enc);
1989                 codec->time_base = (AVRational){1, codec->sample_rate};
1990                 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
1991                     codec->sample_fmt = icodec->sample_fmt;
1992                 choose_sample_fmt(ost->st, ost->enc);
1993                 if (!codec->channels)
1994                     codec->channels = icodec->channels;
1995                 codec->channel_layout = icodec->channel_layout;
1996                 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
1997                     codec->channel_layout = 0;
1998                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1999                 icodec->request_channels = codec->channels;
2000                 ist->decoding_needed = 1;
2001                 ost->encoding_needed = 1;
2002                 ost->resample_sample_fmt  = icodec->sample_fmt;
2003                 ost->resample_sample_rate = icodec->sample_rate;
2004                 ost->resample_channels    = icodec->channels;
2005                 break;
2006             case AVMEDIA_TYPE_VIDEO:
2007                 if (codec->pix_fmt == PIX_FMT_NONE)
2008                     codec->pix_fmt = icodec->pix_fmt;
2009                 choose_pixel_fmt(ost->st, ost->enc);
2010
2011                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2012                     fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2013                     exit_program(1);
2014                 }
2015
2016                 if (!codec->width || !codec->height) {
2017                     codec->width  = icodec->width;
2018                     codec->height = icodec->height;
2019                 }
2020
2021                 ost->video_resample = codec->width   != icodec->width  ||
2022                                       codec->height  != icodec->height ||
2023                                       codec->pix_fmt != icodec->pix_fmt;
2024                 if (ost->video_resample) {
2025 #if !CONFIG_AVFILTER
2026                     avcodec_get_frame_defaults(&ost->pict_tmp);
2027                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2028                                        codec->width, codec->height)) {
2029                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2030                         exit_program(1);
2031                     }
2032                     ost->img_resample_ctx = sws_getContext(
2033                         icodec->width,
2034                         icodec->height,
2035                         icodec->pix_fmt,
2036                         codec->width,
2037                         codec->height,
2038                         codec->pix_fmt,
2039                         ost->sws_flags, NULL, NULL, NULL);
2040                     if (ost->img_resample_ctx == NULL) {
2041                         fprintf(stderr, "Cannot get resampling context\n");
2042                         exit_program(1);
2043                     }
2044 #endif
2045                     codec->bits_per_raw_sample= 0;
2046                 }
2047
2048                 ost->resample_height = icodec->height;
2049                 ost->resample_width  = icodec->width;
2050                 ost->resample_pix_fmt= icodec->pix_fmt;
2051                 ost->encoding_needed = 1;
2052                 ist->decoding_needed = 1;
2053
2054                 if (!ost->frame_rate.num)
2055                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2056                 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2057                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2058                     ost->frame_rate = ost->enc->supported_framerates[idx];
2059                 }
2060                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2061
2062 #if CONFIG_AVFILTER
2063                 if (configure_video_filters(ist, ost)) {
2064                     fprintf(stderr, "Error opening filters!\n");
2065                     exit(1);
2066                 }
2067 #endif
2068                 break;
2069             case AVMEDIA_TYPE_SUBTITLE:
2070                 ost->encoding_needed = 1;
2071                 ist->decoding_needed = 1;
2072                 break;
2073             default:
2074                 abort();
2075                 break;
2076             }
2077             /* two pass mode */
2078             if (ost->encoding_needed &&
2079                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2080                 char logfilename[1024];
2081                 FILE *f;
2082
2083                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2084                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2085                          i);
2086                 if (codec->flags & CODEC_FLAG_PASS1) {
2087                     f = fopen(logfilename, "wb");
2088                     if (!f) {
2089                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2090                         exit_program(1);
2091                     }
2092                     ost->logfile = f;
2093                 } else {
2094                     char  *logbuffer;
2095                     size_t logbuffer_size;
2096                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2097                         fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2098                         exit_program(1);
2099                     }
2100                     codec->stats_in = logbuffer;
2101                 }
2102             }
2103         }
2104         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2105             int size= codec->width * codec->height;
2106             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2107         }
2108     }
2109
2110     if (!bit_buffer)
2111         bit_buffer = av_malloc(bit_buffer_size);
2112     if (!bit_buffer) {
2113         fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2114                 bit_buffer_size);
2115         return AVERROR(ENOMEM);
2116     }
2117
2118     /* open each encoder */
2119     for (i = 0; i < nb_output_streams; i++) {
2120         ost = &output_streams[i];
2121         if (ost->encoding_needed) {
2122             AVCodec *codec = ost->enc;
2123             AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2124             if (!codec) {
2125                 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2126                          ost->st->codec->codec_id, ost->file_index, ost->index);
2127                 ret = AVERROR(EINVAL);
2128                 goto dump_format;
2129             }
2130             if (dec->subtitle_header) {
2131                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2132                 if (!ost->st->codec->subtitle_header) {
2133                     ret = AVERROR(ENOMEM);
2134                     goto dump_format;
2135                 }
2136                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2137                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2138             }
2139             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2140                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2141                         ost->file_index, ost->index);
2142                 ret = AVERROR(EINVAL);
2143                 goto dump_format;
2144             }
2145             assert_codec_experimental(ost->st->codec, 1);
2146             assert_avoptions(ost->opts);
2147             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2148                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2149                                              "It takes bits/s as argument, not kbits/s\n");
2150             extra_size += ost->st->codec->extradata_size;
2151         }
2152     }
2153
2154     /* init input streams */
2155     for (i = 0; i < nb_input_streams; i++)
2156         if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error)) < 0))
2157             goto dump_format;
2158
2159     /* open files and write file headers */
2160     for (i = 0; i < nb_output_files; i++) {
2161         os = output_files[i].ctx;
2162         if (avformat_write_header(os, &output_files[i].opts) < 0) {
2163             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2164             ret = AVERROR(EINVAL);
2165             goto dump_format;
2166         }
2167         assert_avoptions(output_files[i].opts);
2168         if (strcmp(os->oformat->name, "rtp")) {
2169             want_sdp = 0;
2170         }
2171     }
2172
2173  dump_format:
2174     /* dump the file output parameters - cannot be done before in case
2175        of stream copy */
2176     for(i=0;i<nb_output_files;i++) {
2177         av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2178     }
2179
2180     /* dump the stream mapping */
2181     if (verbose >= 0) {
2182         fprintf(stderr, "Stream mapping:\n");
2183         for (i = 0; i < nb_output_streams;i ++) {
2184             ost = &output_streams[i];
2185             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2186                     input_streams[ost->source_index].file_index,
2187                     input_streams[ost->source_index].st->index,
2188                     ost->file_index,
2189                     ost->index);
2190             if (ost->sync_ist != &input_streams[ost->source_index])
2191                 fprintf(stderr, " [sync #%d.%d]",
2192                         ost->sync_ist->file_index,
2193                         ost->sync_ist->st->index);
2194             if (ost->st->stream_copy)
2195                 fprintf(stderr, " (copy)");
2196             else
2197                 fprintf(stderr, " (%s -> %s)", input_streams[ost->source_index].dec ?
2198                         input_streams[ost->source_index].dec->name : "?",
2199                         ost->enc ? ost->enc->name : "?");
2200             fprintf(stderr, "\n");
2201         }
2202     }
2203
2204     if (ret) {
2205         fprintf(stderr, "%s\n", error);
2206         return ret;
2207     }
2208
2209     if (want_sdp) {
2210         print_sdp(output_files, nb_output_files);
2211     }
2212
2213     return 0;
2214 }
2215
2216 /*
2217  * The following code is the main loop of the file converter
2218  */
2219 static int transcode(OutputFile *output_files,
2220                      int nb_output_files,
2221                      InputFile *input_files,
2222                      int nb_input_files)
2223 {
2224     int ret, i;
2225     AVFormatContext *is, *os;
2226     OutputStream *ost;
2227     InputStream *ist;
2228     uint8_t *no_packet;
2229     int no_packet_count=0;
2230     int64_t timer_start;
2231
2232     if (!(no_packet = av_mallocz(nb_input_files)))
2233         exit_program(1);
2234
2235     ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2236     if (ret < 0)
2237         goto fail;
2238
2239     if (verbose >= 0)
2240         fprintf(stderr, "Press ctrl-c to stop encoding\n");
2241     term_init();
2242
2243     timer_start = av_gettime();
2244
2245     for(; received_sigterm == 0;) {
2246         int file_index, ist_index;
2247         AVPacket pkt;
2248         int64_t ipts_min;
2249         double opts_min;
2250
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].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             continue;
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].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].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].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     input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3074
3075     frame_rate    = (AVRational){0, 0};
3076     frame_pix_fmt = PIX_FMT_NONE;
3077     frame_height = 0;
3078     frame_width  = 0;
3079     audio_sample_rate = 0;
3080     audio_channels    = 0;
3081     audio_sample_fmt  = AV_SAMPLE_FMT_NONE;
3082     av_dict_free(&ts_scale);
3083     input_ts_offset = 0;
3084
3085     for (i = 0; i < orig_nb_streams; i++)
3086         av_dict_free(&opts[i]);
3087     av_freep(&opts);
3088     av_dict_free(&codec_names);
3089     uninit_opts();
3090     init_opts();
3091     return 0;
3092 }
3093
3094 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3095                                     AVCodecContext *avctx)
3096 {
3097     char *p;
3098     int n = 1, i;
3099     int64_t t;
3100
3101     for (p = kf; *p; p++)
3102         if (*p == ',')
3103             n++;
3104     ost->forced_kf_count = n;
3105     ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3106     if (!ost->forced_kf_pts) {
3107         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3108         exit_program(1);
3109     }
3110     for (i = 0; i < n; i++) {
3111         p = i ? strchr(p, ',') + 1 : kf;
3112         t = parse_time_or_die("force_key_frames", p, 1);
3113         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3114     }
3115 }
3116
3117 static OutputStream *new_output_stream(AVFormatContext *oc, enum AVMediaType type)
3118 {
3119     OutputStream *ost;
3120     AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3121     int idx      = oc->nb_streams - 1;
3122
3123     if (!st) {
3124         av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
3125         exit_program(1);
3126     }
3127
3128     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3129                                 nb_output_streams + 1);
3130     ost = &output_streams[nb_output_streams - 1];
3131     ost->file_index = nb_output_files;
3132     ost->index = idx;
3133     ost->st    = st;
3134     st->codec->codec_type = type;
3135     ost->enc = choose_codec(oc, st, type, codec_names);
3136     if (ost->enc) {
3137         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3138     }
3139
3140     avcodec_get_context_defaults3(st->codec, ost->enc);
3141     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3142
3143     ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3144     return ost;
3145 }
3146
3147 static OutputStream *new_video_stream(AVFormatContext *oc)
3148 {
3149     AVStream *st;
3150     OutputStream *ost;
3151     AVCodecContext *video_enc;
3152
3153     ost = new_output_stream(oc, AVMEDIA_TYPE_VIDEO);
3154     st  = ost->st;
3155     if (!st->stream_copy) {
3156         ost->frame_aspect_ratio = frame_aspect_ratio;
3157         frame_aspect_ratio = 0;
3158 #if CONFIG_AVFILTER
3159         ost->avfilter= vfilters;
3160         vfilters = NULL;
3161 #endif
3162     }
3163
3164     ost->bitstream_filters = video_bitstream_filters;
3165     video_bitstream_filters= NULL;
3166
3167     st->codec->thread_count= thread_count;
3168
3169     video_enc = st->codec;
3170
3171     if(video_codec_tag)
3172         video_enc->codec_tag= video_codec_tag;
3173
3174     if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3175         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3176     }
3177
3178     if (st->stream_copy) {
3179         video_enc->sample_aspect_ratio =
3180         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3181     } else {
3182         const char *p;
3183         int i;
3184
3185         if (frame_rate.num)
3186             ost->frame_rate = frame_rate;
3187
3188         video_enc->width = frame_width;
3189         video_enc->height = frame_height;
3190         video_enc->pix_fmt = frame_pix_fmt;
3191         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3192
3193         if (video_qscale || same_quant) {
3194             video_enc->flags |= CODEC_FLAG_QSCALE;
3195             video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3196         }
3197
3198         if(intra_matrix)
3199             video_enc->intra_matrix = intra_matrix;
3200         if(inter_matrix)
3201             video_enc->inter_matrix = inter_matrix;
3202
3203         p= video_rc_override_string;
3204         for(i=0; p; i++){
3205             int start, end, q;
3206             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3207             if(e!=3){
3208                 fprintf(stderr, "error parsing rc_override\n");
3209                 exit_program(1);
3210             }
3211             video_enc->rc_override=
3212                 av_realloc(video_enc->rc_override,
3213                            sizeof(RcOverride)*(i+1));
3214             video_enc->rc_override[i].start_frame= start;
3215             video_enc->rc_override[i].end_frame  = end;
3216             if(q>0){
3217                 video_enc->rc_override[i].qscale= q;
3218                 video_enc->rc_override[i].quality_factor= 1.0;
3219             }
3220             else{
3221                 video_enc->rc_override[i].qscale= 0;
3222                 video_enc->rc_override[i].quality_factor= -q/100.0;
3223             }
3224             p= strchr(p, '/');
3225             if(p) p++;
3226         }
3227         video_enc->rc_override_count=i;
3228         if (!video_enc->rc_initial_buffer_occupancy)
3229             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3230         video_enc->me_threshold= me_threshold;
3231         video_enc->intra_dc_precision= intra_dc_precision - 8;
3232
3233         if (do_psnr)
3234             video_enc->flags|= CODEC_FLAG_PSNR;
3235
3236         /* two pass mode */
3237         if (do_pass) {
3238             if (do_pass == 1) {
3239                 video_enc->flags |= CODEC_FLAG_PASS1;
3240             } else {
3241                 video_enc->flags |= CODEC_FLAG_PASS2;
3242             }
3243         }
3244
3245         if (forced_key_frames)
3246             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3247     }
3248     if (video_language) {
3249         av_dict_set(&st->metadata, "language", video_language, 0);
3250         av_freep(&video_language);
3251     }
3252
3253     /* reset some key parameters */
3254     video_disable = 0;
3255     av_freep(&forced_key_frames);
3256     frame_pix_fmt = PIX_FMT_NONE;
3257     return ost;
3258 }
3259
3260 static OutputStream *new_audio_stream(AVFormatContext *oc)
3261 {
3262     AVStream *st;
3263     OutputStream *ost;
3264     AVCodecContext *audio_enc;
3265
3266     ost = new_output_stream(oc, AVMEDIA_TYPE_AUDIO);
3267     st  = ost->st;
3268
3269     ost->bitstream_filters = audio_bitstream_filters;
3270     audio_bitstream_filters= NULL;
3271
3272     st->codec->thread_count= thread_count;
3273
3274     audio_enc = st->codec;
3275     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3276
3277     if(audio_codec_tag)
3278         audio_enc->codec_tag= audio_codec_tag;
3279
3280     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3281         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3282     }
3283     if (!st->stream_copy) {
3284         if (audio_qscale > QSCALE_NONE) {
3285             audio_enc->flags |= CODEC_FLAG_QSCALE;
3286             audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3287         }
3288         if (audio_channels)
3289             audio_enc->channels = audio_channels;
3290         if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3291             audio_enc->sample_fmt = audio_sample_fmt;
3292         if (audio_sample_rate)
3293             audio_enc->sample_rate = audio_sample_rate;
3294     }
3295     if (audio_language) {
3296         av_dict_set(&st->metadata, "language", audio_language, 0);
3297         av_freep(&audio_language);
3298     }
3299
3300     /* reset some key parameters */
3301     audio_disable = 0;
3302
3303     return ost;
3304 }
3305
3306 static OutputStream *new_data_stream(AVFormatContext *oc)
3307 {
3308     AVStream *st;
3309     OutputStream *ost;
3310     AVCodecContext *data_enc;
3311
3312     ost = new_output_stream(oc, AVMEDIA_TYPE_DATA);
3313     st  = ost->st;
3314     data_enc = st->codec;
3315     if (!st->stream_copy) {
3316         fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3317         exit_program(1);
3318     }
3319
3320     if (data_codec_tag)
3321         data_enc->codec_tag= data_codec_tag;
3322
3323     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3324         data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3325     }
3326
3327     data_disable = 0;
3328     return ost;
3329 }
3330
3331 static OutputStream *new_subtitle_stream(AVFormatContext *oc)
3332 {
3333     AVStream *st;
3334     OutputStream *ost;
3335     AVCodecContext *subtitle_enc;
3336
3337     ost = new_output_stream(oc, AVMEDIA_TYPE_SUBTITLE);
3338     st  = ost->st;
3339     subtitle_enc = st->codec;
3340
3341     ost->bitstream_filters = subtitle_bitstream_filters;
3342     subtitle_bitstream_filters= NULL;
3343
3344     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3345
3346     if(subtitle_codec_tag)
3347         subtitle_enc->codec_tag= subtitle_codec_tag;
3348
3349     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3350         subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3351     }
3352
3353     if (subtitle_language) {
3354         av_dict_set(&st->metadata, "language", subtitle_language, 0);
3355         av_freep(&subtitle_language);
3356     }
3357
3358     subtitle_disable = 0;
3359     return ost;
3360 }
3361
3362 /* arg format is "output-stream-index:streamid-value". */
3363 static int opt_streamid(const char *opt, const char *arg)
3364 {
3365     int idx;
3366     char *p;
3367     char idx_str[16];
3368
3369     av_strlcpy(idx_str, arg, sizeof(idx_str));
3370     p = strchr(idx_str, ':');
3371     if (!p) {
3372         fprintf(stderr,
3373                 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3374                 arg, opt);
3375         exit_program(1);
3376     }
3377     *p++ = '\0';
3378     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3379     streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3380     streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3381     return 0;
3382 }
3383
3384 static int copy_chapters(int infile, int outfile)
3385 {
3386     AVFormatContext *is = input_files[infile].ctx;
3387     AVFormatContext *os = output_files[outfile].ctx;
3388     int i;
3389
3390     for (i = 0; i < is->nb_chapters; i++) {
3391         AVChapter *in_ch = is->chapters[i], *out_ch;
3392         int64_t ts_off   = av_rescale_q(start_time - input_files[infile].ts_offset,
3393                                       AV_TIME_BASE_Q, in_ch->time_base);
3394         int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
3395                            av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3396
3397
3398         if (in_ch->end < ts_off)
3399             continue;
3400         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3401             break;
3402
3403         out_ch = av_mallocz(sizeof(AVChapter));
3404         if (!out_ch)
3405             return AVERROR(ENOMEM);
3406
3407         out_ch->id        = in_ch->id;
3408         out_ch->time_base = in_ch->time_base;
3409         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
3410         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
3411
3412         if (metadata_chapters_autocopy)
3413             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3414
3415         os->nb_chapters++;
3416         os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3417         if (!os->chapters)
3418             return AVERROR(ENOMEM);
3419         os->chapters[os->nb_chapters - 1] = out_ch;
3420     }
3421     return 0;
3422 }
3423
3424 static int read_avserver_streams(AVFormatContext *s, const char *filename)
3425 {
3426     int i, err;
3427     AVFormatContext *ic = NULL;
3428
3429     err = avformat_open_input(&ic, filename, NULL, NULL);
3430     if (err < 0)
3431         return err;
3432     /* copy stream format */
3433     for(i=0;i<ic->nb_streams;i++) {
3434         AVStream *st;
3435         OutputStream *ost;
3436         AVCodec *codec;
3437
3438         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3439         ost   = new_output_stream(s, codec->type);
3440         st    = ost->st;
3441
3442         // FIXME: a more elegant solution is needed
3443         memcpy(st, ic->streams[i], sizeof(AVStream));
3444         st->info = NULL;
3445         avcodec_copy_context(st->codec, ic->streams[i]->codec);
3446
3447         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3448             choose_sample_fmt(st, codec);
3449         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3450             choose_pixel_fmt(st, codec);
3451     }
3452
3453     av_close_input_file(ic);
3454     return 0;
3455 }
3456
3457 static void opt_output_file(const char *filename)
3458 {
3459     AVFormatContext *oc;
3460     int i, err;
3461     AVOutputFormat *file_oformat;
3462     OutputStream *ost;
3463     InputStream  *ist;
3464
3465     if (!strcmp(filename, "-"))
3466         filename = "pipe:";
3467
3468     oc = avformat_alloc_context();
3469     if (!oc) {
3470         print_error(filename, AVERROR(ENOMEM));
3471         exit_program(1);
3472     }
3473
3474     if (last_asked_format) {
3475         file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3476         if (!file_oformat) {
3477             fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3478             exit_program(1);
3479         }
3480         last_asked_format = NULL;
3481     } else {
3482         file_oformat = av_guess_format(NULL, filename, NULL);
3483         if (!file_oformat) {
3484             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3485                     filename);
3486             exit_program(1);
3487         }
3488     }
3489
3490     oc->oformat = file_oformat;
3491     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3492
3493     if (!strcmp(file_oformat->name, "ffm") &&
3494         av_strstart(filename, "http:", NULL)) {
3495         /* special case for files sent to avserver: we get the stream
3496            parameters from avserver */
3497         int err = read_avserver_streams(oc, filename);
3498         if (err < 0) {
3499             print_error(filename, err);
3500             exit_program(1);
3501         }
3502     } else if (!nb_stream_maps) {
3503         /* pick the "best" stream of each type */
3504 #define NEW_STREAM(type, index)\
3505         if (index >= 0) {\
3506             ost = new_ ## type ## _stream(oc);\
3507             ost->source_index = index;\
3508             ost->sync_ist     = &input_streams[index];\
3509             input_streams[index].discard = 0;\
3510         }
3511
3512         /* video: highest resolution */
3513         if (!video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3514             int area = 0, idx = -1;
3515             for (i = 0; i < nb_input_streams; i++) {
3516                 ist = &input_streams[i];
3517                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3518                     ist->st->codec->width * ist->st->codec->height > area) {
3519                     area = ist->st->codec->width * ist->st->codec->height;
3520                     idx = i;
3521                 }
3522             }
3523             NEW_STREAM(video, idx);
3524         }
3525
3526         /* audio: most channels */
3527         if (!audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3528             int channels = 0, idx = -1;
3529             for (i = 0; i < nb_input_streams; i++) {
3530                 ist = &input_streams[i];
3531                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3532                     ist->st->codec->channels > channels) {
3533                     channels = ist->st->codec->channels;
3534                     idx = i;
3535                 }
3536             }
3537             NEW_STREAM(audio, idx);
3538         }
3539
3540         /* subtitles: pick first */
3541         if (!subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3542             for (i = 0; i < nb_input_streams; i++)
3543                 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3544                     NEW_STREAM(subtitle, i);
3545                     break;
3546                 }
3547         }
3548         /* do something with data? */
3549     } else {
3550         for (i = 0; i < nb_stream_maps; i++) {
3551             StreamMap *map = &stream_maps[i];
3552
3553             if (map->disabled)
3554                 continue;
3555
3556             ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3557             switch (ist->st->codec->codec_type) {
3558             case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(oc);    break;
3559             case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(oc);    break;
3560             case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(oc); break;
3561             case AVMEDIA_TYPE_DATA:     ost = new_data_stream(oc);     break;
3562             default:
3563                 av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
3564                        map->file_index, map->stream_index);
3565                 exit_program(1);
3566             }
3567
3568             ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3569             ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3570                                            map->sync_stream_index];
3571             ist->discard = 0;
3572         }
3573     }
3574
3575     av_dict_copy(&oc->metadata, metadata, 0);
3576     av_dict_free(&metadata);
3577
3578
3579     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3580     output_files[nb_output_files - 1].ctx       = oc;
3581     output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3582     output_files[nb_output_files - 1].recording_time = recording_time;
3583     output_files[nb_output_files - 1].start_time     = start_time;
3584     output_files[nb_output_files - 1].limit_filesize = limit_filesize;
3585     av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3586
3587     /* check filename in case of an image number is expected */
3588     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3589         if (!av_filename_number_test(oc->filename)) {
3590             print_error(oc->filename, AVERROR(EINVAL));
3591             exit_program(1);
3592         }
3593     }
3594
3595     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3596         /* test if it already exists to avoid loosing precious files */
3597         if (!file_overwrite &&
3598             (strchr(filename, ':') == NULL ||
3599              filename[1] == ':' ||
3600              av_strstart(filename, "file:", NULL))) {
3601             if (avio_check(filename, 0) == 0) {
3602                 if (!using_stdin) {
3603                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3604                     fflush(stderr);
3605                     if (!read_yesno()) {
3606                         fprintf(stderr, "Not overwriting - exiting\n");
3607                         exit_program(1);
3608                     }
3609                 }
3610                 else {
3611                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3612                     exit_program(1);
3613                 }
3614             }
3615         }
3616
3617         /* open the file */
3618         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3619             print_error(filename, err);
3620             exit_program(1);
3621         }
3622     }
3623
3624     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3625     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3626     oc->flags |= AVFMT_FLAG_NONBLOCK;
3627
3628     /* copy chapters */
3629     if (chapters_input_file >= nb_input_files) {
3630         if (chapters_input_file == INT_MAX) {
3631             /* copy chapters from the first input file that has them*/
3632             chapters_input_file = -1;
3633             for (i = 0; i < nb_input_files; i++)
3634                 if (input_files[i].ctx->nb_chapters) {
3635                     chapters_input_file = i;
3636                     break;
3637                 }
3638         } else {
3639             av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3640                    chapters_input_file);
3641             exit_program(1);
3642         }
3643     }
3644     if (chapters_input_file >= 0)
3645         copy_chapters(chapters_input_file, nb_output_files - 1);
3646
3647     /* copy metadata */
3648     for (i = 0; i < nb_meta_data_maps; i++) {
3649         AVFormatContext *files[2];
3650         AVDictionary    **meta[2];
3651         int j;
3652
3653 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3654         if ((index) < 0 || (index) >= (nb_elems)) {\
3655             av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3656                      (desc), (index));\
3657             exit_program(1);\
3658         }
3659
3660         int in_file_index = meta_data_maps[i][1].file;
3661         if (in_file_index < 0)
3662             continue;
3663         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3664
3665         files[0] = oc;
3666         files[1] = input_files[in_file_index].ctx;
3667
3668         for (j = 0; j < 2; j++) {
3669             MetadataMap *map = &meta_data_maps[i][j];
3670
3671             switch (map->type) {
3672             case 'g':
3673                 meta[j] = &files[j]->metadata;
3674                 break;
3675             case 's':
3676                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3677                 meta[j] = &files[j]->streams[map->index]->metadata;
3678                 break;
3679             case 'c':
3680                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3681                 meta[j] = &files[j]->chapters[map->index]->metadata;
3682                 break;
3683             case 'p':
3684                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3685                 meta[j] = &files[j]->programs[map->index]->metadata;
3686                 break;
3687             }
3688         }
3689
3690         av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3691     }
3692
3693     /* copy global metadata by default */
3694     if (metadata_global_autocopy && nb_input_files)
3695         av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3696                      AV_DICT_DONT_OVERWRITE);
3697     if (metadata_streams_autocopy)
3698         for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3699             InputStream *ist = &input_streams[output_streams[i].source_index];
3700             av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3701         }
3702
3703     frame_rate    = (AVRational){0, 0};
3704     frame_width   = 0;
3705     frame_height  = 0;
3706     audio_sample_rate = 0;
3707     audio_channels    = 0;
3708     audio_sample_fmt  = AV_SAMPLE_FMT_NONE;
3709     chapters_input_file = INT_MAX;
3710     recording_time = INT64_MAX;
3711     start_time     = 0;
3712     limit_filesize = UINT64_MAX;
3713
3714     av_freep(&meta_data_maps);
3715     nb_meta_data_maps = 0;
3716     metadata_global_autocopy   = 1;
3717     metadata_streams_autocopy  = 1;
3718     metadata_chapters_autocopy = 1;
3719     av_freep(&stream_maps);
3720     nb_stream_maps = 0;
3721     av_freep(&streamid_map);
3722     nb_streamid_map = 0;
3723
3724     av_dict_free(&codec_names);
3725
3726     av_freep(&forced_key_frames);
3727     uninit_opts();
3728     init_opts();
3729 }
3730
3731 /* same option as mencoder */
3732 static int opt_pass(const char *opt, const char *arg)
3733 {
3734     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3735     return 0;
3736 }
3737
3738 static int64_t getutime(void)
3739 {
3740 #if HAVE_GETRUSAGE
3741     struct rusage rusage;
3742
3743     getrusage(RUSAGE_SELF, &rusage);
3744     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3745 #elif HAVE_GETPROCESSTIMES
3746     HANDLE proc;
3747     FILETIME c, e, k, u;
3748     proc = GetCurrentProcess();
3749     GetProcessTimes(proc, &c, &e, &k, &u);
3750     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3751 #else
3752     return av_gettime();
3753 #endif
3754 }
3755
3756 static int64_t getmaxrss(void)
3757 {
3758 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3759     struct rusage rusage;
3760     getrusage(RUSAGE_SELF, &rusage);
3761     return (int64_t)rusage.ru_maxrss * 1024;
3762 #elif HAVE_GETPROCESSMEMORYINFO
3763     HANDLE proc;
3764     PROCESS_MEMORY_COUNTERS memcounters;
3765     proc = GetCurrentProcess();
3766     memcounters.cb = sizeof(memcounters);
3767     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3768     return memcounters.PeakPagefileUsage;
3769 #else
3770     return 0;
3771 #endif
3772 }
3773
3774 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3775 {
3776     int i;
3777     const char *p = str;
3778     for(i = 0;; i++) {
3779         dest[i] = atoi(p);
3780         if(i == 63)
3781             break;
3782         p = strchr(p, ',');
3783         if(!p) {
3784             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3785             exit_program(1);
3786         }
3787         p++;
3788     }
3789 }
3790
3791 static void opt_inter_matrix(const char *arg)
3792 {
3793     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3794     parse_matrix_coeffs(inter_matrix, arg);
3795 }
3796
3797 static void opt_intra_matrix(const char *arg)
3798 {
3799     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3800     parse_matrix_coeffs(intra_matrix, arg);
3801 }
3802
3803 static void show_usage(void)
3804 {
3805     printf("Hyper fast Audio and Video encoder\n");
3806     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3807     printf("\n");
3808 }
3809
3810 static void show_help(void)
3811 {
3812     AVCodec *c;
3813     AVOutputFormat *oformat = NULL;
3814     AVInputFormat  *iformat = NULL;
3815
3816     av_log_set_callback(log_callback_help);
3817     show_usage();
3818     show_help_options(options, "Main options:\n",
3819                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3820     show_help_options(options, "\nAdvanced options:\n",
3821                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3822                       OPT_EXPERT);
3823     show_help_options(options, "\nVideo options:\n",
3824                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3825                       OPT_VIDEO);
3826     show_help_options(options, "\nAdvanced Video options:\n",
3827                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3828                       OPT_VIDEO | OPT_EXPERT);
3829     show_help_options(options, "\nAudio options:\n",
3830                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3831                       OPT_AUDIO);
3832     show_help_options(options, "\nAdvanced Audio options:\n",
3833                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3834                       OPT_AUDIO | OPT_EXPERT);
3835     show_help_options(options, "\nSubtitle options:\n",
3836                       OPT_SUBTITLE | OPT_GRAB,
3837                       OPT_SUBTITLE);
3838     show_help_options(options, "\nAudio/Video grab options:\n",
3839                       OPT_GRAB,
3840                       OPT_GRAB);
3841     printf("\n");
3842     av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3843     printf("\n");
3844
3845     /* individual codec options */
3846     c = NULL;
3847     while ((c = av_codec_next(c))) {
3848         if (c->priv_class) {
3849             av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3850             printf("\n");
3851         }
3852     }
3853
3854     av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3855     printf("\n");
3856
3857     /* individual muxer options */
3858     while ((oformat = av_oformat_next(oformat))) {
3859         if (oformat->priv_class) {
3860             av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3861             printf("\n");
3862         }
3863     }
3864
3865     /* individual demuxer options */
3866     while ((iformat = av_iformat_next(iformat))) {
3867         if (iformat->priv_class) {
3868             av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3869             printf("\n");
3870         }
3871     }
3872
3873     av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3874 }
3875
3876 static int opt_target(const char *opt, const char *arg)
3877 {
3878     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3879     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3880
3881     if(!strncmp(arg, "pal-", 4)) {
3882         norm = PAL;
3883         arg += 4;
3884     } else if(!strncmp(arg, "ntsc-", 5)) {
3885         norm = NTSC;
3886         arg += 5;
3887     } else if(!strncmp(arg, "film-", 5)) {
3888         norm = FILM;
3889         arg += 5;
3890     } else {
3891         int fr;
3892         /* Calculate FR via float to avoid int overflow */
3893         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3894         if(fr == 25000) {
3895             norm = PAL;
3896         } else if((fr == 29970) || (fr == 23976)) {
3897             norm = NTSC;
3898         } else {
3899             /* Try to determine PAL/NTSC by peeking in the input files */
3900             if(nb_input_files) {
3901                 int i, j;
3902                 for (j = 0; j < nb_input_files; j++) {
3903                     for (i = 0; i < input_files[j].nb_streams; i++) {
3904                         AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3905                         if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3906                             continue;
3907                         fr = c->time_base.den * 1000 / c->time_base.num;
3908                         if(fr == 25000) {
3909                             norm = PAL;
3910                             break;
3911                         } else if((fr == 29970) || (fr == 23976)) {
3912                             norm = NTSC;
3913                             break;
3914                         }
3915                     }
3916                     if(norm != UNKNOWN)
3917                         break;
3918                 }
3919             }
3920         }
3921         if(verbose > 0 && norm != UNKNOWN)
3922             fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3923     }
3924
3925     if(norm == UNKNOWN) {
3926         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3927         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3928         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3929         exit_program(1);
3930     }
3931
3932     if(!strcmp(arg, "vcd")) {
3933         opt_codec("c:v", "mpeg1video");
3934         opt_codec("c:a", "mp2");
3935         opt_format("f", "vcd");
3936
3937         opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
3938         opt_frame_rate("r", frame_rates[norm]);
3939         opt_default("g", norm == PAL ? "15" : "18");
3940
3941         opt_default("b", "1150000");
3942         opt_default("maxrate", "1150000");
3943         opt_default("minrate", "1150000");
3944         opt_default("bufsize", "327680"); // 40*1024*8;
3945
3946         opt_default("b:a", "224000");
3947         audio_sample_rate = 44100;
3948         audio_channels = 2;
3949
3950         opt_default("packetsize", "2324");
3951         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3952
3953         /* We have to offset the PTS, so that it is consistent with the SCR.
3954            SCR starts at 36000, but the first two packs contain only padding
3955            and the first pack from the other stream, respectively, may also have
3956            been written before.
3957            So the real data starts at SCR 36000+3*1200. */
3958         mux_preload= (36000+3*1200) / 90000.0; //0.44
3959     } else if(!strcmp(arg, "svcd")) {
3960
3961         opt_codec("c:v", "mpeg2video");
3962         opt_codec("c:a", "mp2");
3963         opt_format("f", "svcd");
3964
3965         opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
3966         opt_frame_rate("r", frame_rates[norm]);
3967         opt_default("g", norm == PAL ? "15" : "18");
3968
3969         opt_default("b", "2040000");
3970         opt_default("maxrate", "2516000");
3971         opt_default("minrate", "0"); //1145000;
3972         opt_default("bufsize", "1835008"); //224*1024*8;
3973         opt_default("flags", "+scan_offset");
3974
3975
3976         opt_default("b:a", "224000");
3977         audio_sample_rate = 44100;
3978
3979         opt_default("packetsize", "2324");
3980
3981     } else if(!strcmp(arg, "dvd")) {
3982
3983         opt_codec("c:v", "mpeg2video");
3984         opt_codec("c:a", "ac3");
3985         opt_format("f", "dvd");
3986
3987         opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
3988         opt_frame_rate("r", frame_rates[norm]);
3989         opt_default("g", norm == PAL ? "15" : "18");
3990
3991         opt_default("b", "6000000");
3992         opt_default("maxrate", "9000000");
3993         opt_default("minrate", "0"); //1500000;
3994         opt_default("bufsize", "1835008"); //224*1024*8;
3995
3996         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3997         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3998
3999         opt_default("b:a", "448000");
4000         audio_sample_rate = 48000;
4001
4002     } else if(!strncmp(arg, "dv", 2)) {
4003
4004         opt_format("f", "dv");
4005
4006         opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4007         opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4008                           norm == PAL ? "yuv420p" : "yuv411p");
4009         opt_frame_rate("r", frame_rates[norm]);
4010
4011         audio_sample_rate = 48000;
4012         audio_channels = 2;
4013
4014     } else {
4015         fprintf(stderr, "Unknown target: %s\n", arg);
4016         return AVERROR(EINVAL);
4017     }
4018     return 0;
4019 }
4020
4021 static int opt_vstats_file(const char *opt, const char *arg)
4022 {
4023     av_free (vstats_filename);
4024     vstats_filename=av_strdup (arg);
4025     return 0;
4026 }
4027
4028 static int opt_vstats(const char *opt, const char *arg)
4029 {
4030     char filename[40];
4031     time_t today2 = time(NULL);
4032     struct tm *today = localtime(&today2);
4033
4034     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4035              today->tm_sec);
4036     return opt_vstats_file(opt, filename);
4037 }
4038
4039 static int opt_bsf(const char *opt, const char *arg)
4040 {
4041     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4042     AVBitStreamFilterContext **bsfp;
4043
4044     if(!bsfc){
4045         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4046         exit_program(1);
4047     }
4048
4049     bsfp= *opt == 'v' ? &video_bitstream_filters :
4050           *opt == 'a' ? &audio_bitstream_filters :
4051                         &subtitle_bitstream_filters;
4052     while(*bsfp)
4053         bsfp= &(*bsfp)->next;
4054
4055     *bsfp= bsfc;
4056
4057     return 0;
4058 }
4059
4060 static const OptionDef options[] = {
4061     /* main options */
4062 #include "cmdutils_common_opts.h"
4063     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4064     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4065     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4066     { "c", HAS_ARG, {(void*)opt_codec}, "codec name", "codec" },
4067     { "codec", HAS_ARG, {(void*)opt_codec}, "codec name", "codec" },
4068     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4069     { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4070       "outfile[,metadata]:infile[,metadata]" },
4071     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&chapters_input_file},  "set chapters mapping", "input_file_index" },
4072     { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4073     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4074     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4075     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4076     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "scale" },
4077     { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4078     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4079     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4080       "add timings for benchmarking" },
4081     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4082     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4083       "dump each input packet" },
4084     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4085       "when dumping packets, also dump the payload" },
4086     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4087     { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
4088     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4089     { "threads",  HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4090     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4091     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4092     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4093     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4094     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4095     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4096     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4097     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4098     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4099     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4100
4101     /* video options */
4102     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4103     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4104     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4105     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4106     { "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" },
4107     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4108     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4109     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4110     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4111     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4112     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4113     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4114     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4115     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4116     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4117     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4118     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4119     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4120     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4121     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimation threshold",  "threshold" },
4122     { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4123       "use same quantizer as source (implies VBR)" },
4124     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4125     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4126     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4127       "deinterlace pictures" },
4128     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4129     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4130     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4131 #if CONFIG_AVFILTER
4132     { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4133 #endif
4134     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4135     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4136     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4137     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4138     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4139     { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4140     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4141     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4142     { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4143     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4144
4145     /* audio options */
4146     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4147     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4148     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4149     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4150     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4151     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4152     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4153     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4154     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4155     { "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" },
4156
4157     /* subtitle options */
4158     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4159     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4160     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4161     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4162
4163     /* grab options */
4164     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4165
4166     /* muxer options */
4167     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4168     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4169
4170     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4171     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4172     { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4173
4174     /* data codec support */
4175     { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4176
4177     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4178     { NULL, },
4179 };
4180
4181 int main(int argc, char **argv)
4182 {
4183     int64_t ti;
4184
4185     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4186
4187     avcodec_register_all();
4188 #if CONFIG_AVDEVICE
4189     avdevice_register_all();
4190 #endif
4191 #if CONFIG_AVFILTER
4192     avfilter_register_all();
4193 #endif
4194     av_register_all();
4195
4196     avio_set_interrupt_cb(decode_interrupt_cb);
4197
4198     init_opts();
4199
4200     show_banner();
4201
4202     /* parse options */
4203     parse_options(argc, argv, options, opt_output_file);
4204
4205     if(nb_output_files <= 0 && nb_input_files == 0) {
4206         show_usage();
4207         fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4208         exit_program(1);
4209     }
4210
4211     /* file converter / grab */
4212     if (nb_output_files <= 0) {
4213         fprintf(stderr, "At least one output file must be specified\n");
4214         exit_program(1);
4215     }
4216
4217     if (nb_input_files == 0) {
4218         fprintf(stderr, "At least one input file must be specified\n");
4219         exit_program(1);
4220     }
4221
4222     ti = getutime();
4223     if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4224         exit_program(1);
4225     ti = getutime() - ti;
4226     if (do_benchmark) {
4227         int maxrss = getmaxrss() / 1024;
4228         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4229     }
4230
4231     return exit_program(0);
4232 }