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