git.sesse.net Git - ffmpeg/blob - avconv.c

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