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(int ist_index, 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->source_index != ist_index || !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     if (pkt == NULL) {
1801         /* EOF handling */
1802         flush_encoders(ist_index, ost_table, nb_ostreams);
1803     }
1804
1805     return 0;
1806 }
1807
1808 static void print_sdp(OutputFile *output_files, int n)
1809 {
1810     char sdp[2048];
1811     int i;
1812     AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1813
1814     if (!avc)
1815         exit_program(1);
1816     for (i = 0; i < n; i++)
1817         avc[i] = output_files[i].ctx;
1818
1819     av_sdp_create(avc, n, sdp, sizeof(sdp));
1820     printf("SDP:\n%s\n", sdp);
1821     fflush(stdout);
1822     av_freep(&avc);
1823 }
1824
1825 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1826                              char *error, int error_len)
1827 {
1828     int i;
1829     InputStream *ist = &input_streams[ist_index];
1830     if (ist->decoding_needed) {
1831         AVCodec *codec = ist->dec;
1832         if (!codec)
1833             codec = avcodec_find_decoder(ist->st->codec->codec_id);
1834         if (!codec) {
1835             snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
1836                     ist->st->codec->codec_id, ist->file_index, ist->st->index);
1837             return AVERROR(EINVAL);
1838         }
1839
1840         /* update requested sample format for the decoder based on the
1841            corresponding encoder sample format */
1842         for (i = 0; i < nb_output_streams; i++) {
1843             OutputStream *ost = &output_streams[i];
1844             if (ost->source_index == ist_index) {
1845                 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
1846                 break;
1847             }
1848         }
1849
1850         if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1851             snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
1852                     ist->file_index, ist->st->index);
1853             return AVERROR(EINVAL);
1854         }
1855         assert_codec_experimental(ist->st->codec, 0);
1856         assert_avoptions(ist->opts);
1857     }
1858
1859     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;
1860     ist->next_pts = AV_NOPTS_VALUE;
1861     init_pts_correction(&ist->pts_ctx);
1862     ist->is_start = 1;
1863
1864     return 0;
1865 }
1866
1867 /*
1868  * The following code is the main loop of the file converter
1869  */
1870 static int transcode(OutputFile *output_files,
1871                      int nb_output_files,
1872                      InputFile *input_files,
1873                      int nb_input_files)
1874 {
1875     int ret = 0, i;
1876     AVFormatContext *is, *os;
1877     AVCodecContext *codec, *icodec;
1878     OutputStream *ost;
1879     InputStream *ist;
1880     char error[1024];
1881     int want_sdp = 1;
1882     uint8_t *no_packet;
1883     int no_packet_count=0;
1884     int64_t timer_start;
1885
1886     if (!(no_packet = av_mallocz(nb_input_files)))
1887         exit_program(1);
1888
1889     if (rate_emu)
1890         for (i = 0; i < nb_input_streams; i++)
1891             input_streams[i].start = av_gettime();
1892
1893     /* output stream init */
1894     for(i=0;i<nb_output_files;i++) {
1895         os = output_files[i].ctx;
1896         if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1897             av_dump_format(os, i, os->filename, 1);
1898             fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1899             ret = AVERROR(EINVAL);
1900             goto fail;
1901         }
1902     }
1903
1904     /* for each output stream, we compute the right encoding parameters */
1905     for (i = 0; i < nb_output_streams; i++) {
1906         ost = &output_streams[i];
1907         os = output_files[ost->file_index].ctx;
1908         ist = &input_streams[ost->source_index];
1909
1910         codec = ost->st->codec;
1911         icodec = ist->st->codec;
1912
1913         ost->st->disposition = ist->st->disposition;
1914         codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1915         codec->chroma_sample_location = icodec->chroma_sample_location;
1916
1917         if (ost->st->stream_copy) {
1918             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
1919
1920             if (extra_size > INT_MAX) {
1921                 ret = AVERROR(EINVAL);
1922                 goto fail;
1923             }
1924
1925             /* if stream_copy is selected, no need to decode or encode */
1926             codec->codec_id = icodec->codec_id;
1927             codec->codec_type = icodec->codec_type;
1928
1929             if(!codec->codec_tag){
1930                 if(   !os->oformat->codec_tag
1931                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1932                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1933                     codec->codec_tag = icodec->codec_tag;
1934             }
1935
1936             codec->bit_rate = icodec->bit_rate;
1937             codec->rc_max_rate    = icodec->rc_max_rate;
1938             codec->rc_buffer_size = icodec->rc_buffer_size;
1939             codec->extradata= av_mallocz(extra_size);
1940             if (!codec->extradata) {
1941                 ret = AVERROR(ENOMEM);
1942                 goto fail;
1943             }
1944             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
1945             codec->extradata_size= icodec->extradata_size;
1946             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){
1947                 codec->time_base = icodec->time_base;
1948                 codec->time_base.num *= icodec->ticks_per_frame;
1949                 av_reduce(&codec->time_base.num, &codec->time_base.den,
1950                           codec->time_base.num, codec->time_base.den, INT_MAX);
1951             }else
1952                 codec->time_base = ist->st->time_base;
1953             switch(codec->codec_type) {
1954             case AVMEDIA_TYPE_AUDIO:
1955                 if(audio_volume != 256) {
1956                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1957                     exit_program(1);
1958                 }
1959                 codec->channel_layout = icodec->channel_layout;
1960                 codec->sample_rate = icodec->sample_rate;
1961                 codec->channels = icodec->channels;
1962                 codec->frame_size = icodec->frame_size;
1963                 codec->audio_service_type = icodec->audio_service_type;
1964                 codec->block_align= icodec->block_align;
1965                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1966                     codec->block_align= 0;
1967                 if(codec->codec_id == CODEC_ID_AC3)
1968                     codec->block_align= 0;
1969                 break;
1970             case AVMEDIA_TYPE_VIDEO:
1971                 codec->pix_fmt = icodec->pix_fmt;
1972                 codec->width = icodec->width;
1973                 codec->height = icodec->height;
1974                 codec->has_b_frames = icodec->has_b_frames;
1975                 if (!codec->sample_aspect_ratio.num) {
1976                     codec->sample_aspect_ratio =
1977                     ost->st->sample_aspect_ratio =
1978                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
1979                         ist->st->codec->sample_aspect_ratio.num ?
1980                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
1981                 }
1982                 break;
1983             case AVMEDIA_TYPE_SUBTITLE:
1984                 codec->width = icodec->width;
1985                 codec->height = icodec->height;
1986                 break;
1987             case AVMEDIA_TYPE_DATA:
1988                 break;
1989             default:
1990                 abort();
1991             }
1992         } else {
1993             if (!ost->enc)
1994                 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1995             switch(codec->codec_type) {
1996             case AVMEDIA_TYPE_AUDIO:
1997                 ost->fifo= av_fifo_alloc(1024);
1998                 if (!ost->fifo) {
1999                     ret = AVERROR(ENOMEM);
2000                     goto fail;
2001                 }
2002                 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2003                 if (!codec->sample_rate) {
2004                     codec->sample_rate = icodec->sample_rate;
2005                     if (icodec->lowres)
2006                         codec->sample_rate >>= icodec->lowres;
2007                 }
2008                 choose_sample_rate(ost->st, ost->enc);
2009                 codec->time_base = (AVRational){1, codec->sample_rate};
2010                 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2011                     codec->sample_fmt = icodec->sample_fmt;
2012                 choose_sample_fmt(ost->st, ost->enc);
2013                 if (!codec->channels)
2014                     codec->channels = icodec->channels;
2015                 codec->channel_layout = icodec->channel_layout;
2016                 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2017                     codec->channel_layout = 0;
2018                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2019                 icodec->request_channels = codec->channels;
2020                 ist->decoding_needed = 1;
2021                 ost->encoding_needed = 1;
2022                 ost->resample_sample_fmt  = icodec->sample_fmt;
2023                 ost->resample_sample_rate = icodec->sample_rate;
2024                 ost->resample_channels    = icodec->channels;
2025                 break;
2026             case AVMEDIA_TYPE_VIDEO:
2027                 if (codec->pix_fmt == PIX_FMT_NONE)
2028                     codec->pix_fmt = icodec->pix_fmt;
2029                 choose_pixel_fmt(ost->st, ost->enc);
2030
2031                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2032                     fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2033                     exit_program(1);
2034                 }
2035
2036                 if (!codec->width || !codec->height) {
2037                     codec->width  = icodec->width;
2038                     codec->height = icodec->height;
2039                 }
2040
2041                 ost->video_resample = codec->width   != icodec->width  ||
2042                                       codec->height  != icodec->height ||
2043                                       codec->pix_fmt != icodec->pix_fmt;
2044                 if (ost->video_resample) {
2045 #if !CONFIG_AVFILTER
2046                     avcodec_get_frame_defaults(&ost->pict_tmp);
2047                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2048                                        codec->width, codec->height)) {
2049                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2050                         exit_program(1);
2051                     }
2052                     ost->img_resample_ctx = sws_getContext(
2053                         icodec->width,
2054                         icodec->height,
2055                         icodec->pix_fmt,
2056                         codec->width,
2057                         codec->height,
2058                         codec->pix_fmt,
2059                         ost->sws_flags, NULL, NULL, NULL);
2060                     if (ost->img_resample_ctx == NULL) {
2061                         fprintf(stderr, "Cannot get resampling context\n");
2062                         exit_program(1);
2063                     }
2064 #endif
2065                     codec->bits_per_raw_sample= 0;
2066                 }
2067
2068                 ost->resample_height = icodec->height;
2069                 ost->resample_width  = icodec->width;
2070                 ost->resample_pix_fmt= icodec->pix_fmt;
2071                 ost->encoding_needed = 1;
2072                 ist->decoding_needed = 1;
2073
2074                 if (!ost->frame_rate.num)
2075                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2076                 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2077                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2078                     ost->frame_rate = ost->enc->supported_framerates[idx];
2079                 }
2080                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2081
2082 #if CONFIG_AVFILTER
2083                 if (configure_video_filters(ist, ost)) {
2084                     fprintf(stderr, "Error opening filters!\n");
2085                     exit(1);
2086                 }
2087 #endif
2088                 break;
2089             case AVMEDIA_TYPE_SUBTITLE:
2090                 ost->encoding_needed = 1;
2091                 ist->decoding_needed = 1;
2092                 break;
2093             default:
2094                 abort();
2095                 break;
2096             }
2097             /* two pass mode */
2098             if (ost->encoding_needed &&
2099                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2100                 char logfilename[1024];
2101                 FILE *f;
2102
2103                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2104                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2105                          i);
2106                 if (codec->flags & CODEC_FLAG_PASS1) {
2107                     f = fopen(logfilename, "wb");
2108                     if (!f) {
2109                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2110                         exit_program(1);
2111                     }
2112                     ost->logfile = f;
2113                 } else {
2114                     char  *logbuffer;
2115                     size_t logbuffer_size;
2116                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2117                         fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2118                         exit_program(1);
2119                     }
2120                     codec->stats_in = logbuffer;
2121                 }
2122             }
2123         }
2124         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2125             int size= codec->width * codec->height;
2126             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2127         }
2128     }
2129
2130     if (!bit_buffer)
2131         bit_buffer = av_malloc(bit_buffer_size);
2132     if (!bit_buffer) {
2133         fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2134                 bit_buffer_size);
2135         ret = AVERROR(ENOMEM);
2136         goto fail;
2137     }
2138
2139     /* open each encoder */
2140     for (i = 0; i < nb_output_streams; i++) {
2141         ost = &output_streams[i];
2142         if (ost->encoding_needed) {
2143             AVCodec *codec = ost->enc;
2144             AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2145             if (!codec) {
2146                 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2147                          ost->st->codec->codec_id, ost->file_index, ost->index);
2148                 ret = AVERROR(EINVAL);
2149                 goto dump_format;
2150             }
2151             if (dec->subtitle_header) {
2152                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2153                 if (!ost->st->codec->subtitle_header) {
2154                     ret = AVERROR(ENOMEM);
2155                     goto dump_format;
2156                 }
2157                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2158                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2159             }
2160             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2161                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2162                         ost->file_index, ost->index);
2163                 ret = AVERROR(EINVAL);
2164                 goto dump_format;
2165             }
2166             assert_codec_experimental(ost->st->codec, 1);
2167             assert_avoptions(ost->opts);
2168             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2169                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2170                                              "It takes bits/s as argument, not kbits/s\n");
2171             extra_size += ost->st->codec->extradata_size;
2172         }
2173     }
2174
2175     /* init input streams */
2176     for (i = 0; i < nb_input_streams; i++)
2177         if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error)) < 0))
2178             goto dump_format;
2179
2180     /* open files and write file headers */
2181     for (i = 0; i < nb_output_files; i++) {
2182         os = output_files[i].ctx;
2183         if (avformat_write_header(os, &output_files[i].opts) < 0) {
2184             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2185             ret = AVERROR(EINVAL);
2186             goto dump_format;
2187         }
2188         assert_avoptions(output_files[i].opts);
2189         if (strcmp(os->oformat->name, "rtp")) {
2190             want_sdp = 0;
2191         }
2192     }
2193
2194  dump_format:
2195     /* dump the file output parameters - cannot be done before in case
2196        of stream copy */
2197     for(i=0;i<nb_output_files;i++) {
2198         av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2199     }
2200
2201     /* dump the stream mapping */
2202     if (verbose >= 0) {
2203         fprintf(stderr, "Stream mapping:\n");
2204         for (i = 0; i < nb_output_streams;i ++) {
2205             ost = &output_streams[i];
2206             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2207                     input_streams[ost->source_index].file_index,
2208                     input_streams[ost->source_index].st->index,
2209                     ost->file_index,
2210                     ost->index);
2211             if (ost->sync_ist != &input_streams[ost->source_index])
2212                 fprintf(stderr, " [sync #%d.%d]",
2213                         ost->sync_ist->file_index,
2214                         ost->sync_ist->st->index);
2215             if (ost->st->stream_copy)
2216                 fprintf(stderr, " (copy)");
2217             fprintf(stderr, "\n");
2218         }
2219     }
2220
2221     if (ret) {
2222         fprintf(stderr, "%s\n", error);
2223         goto fail;
2224     }
2225
2226     if (want_sdp) {
2227         print_sdp(output_files, nb_output_files);
2228     }
2229
2230     if (verbose >= 0)
2231         fprintf(stderr, "Press ctrl-c to stop encoding\n");
2232     term_init();
2233
2234     timer_start = av_gettime();
2235
2236     for(; received_sigterm == 0;) {
2237         int file_index, ist_index;
2238         AVPacket pkt;
2239         int64_t ipts_min;
2240         double opts_min;
2241
2242     redo:
2243         ipts_min = INT64_MAX;
2244         opts_min= 1e100;
2245
2246         /* select the stream that we must read now by looking at the
2247            smallest output pts */
2248         file_index = -1;
2249         for (i = 0; i < nb_output_streams; i++) {
2250             OutputFile *of;
2251             int64_t ipts;
2252             double  opts;
2253             ost = &output_streams[i];
2254             of = &output_files[ost->file_index];
2255             os = output_files[ost->file_index].ctx;
2256             ist = &input_streams[ost->source_index];
2257             if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2258                 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2259                 continue;
2260             opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2261             ipts = ist->pts;
2262             if (!input_files[ist->file_index].eof_reached){
2263                 if(ipts < ipts_min) {
2264                     ipts_min = ipts;
2265                     if(input_sync ) file_index = ist->file_index;
2266                 }
2267                 if(opts < opts_min) {
2268                     opts_min = opts;
2269                     if(!input_sync) file_index = ist->file_index;
2270                 }
2271             }
2272             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2273                 file_index= -1;
2274                 break;
2275             }
2276         }
2277         /* if none, if is finished */
2278         if (file_index < 0) {
2279             if(no_packet_count){
2280                 no_packet_count=0;
2281                 memset(no_packet, 0, nb_input_files);
2282                 usleep(10000);
2283                 continue;
2284             }
2285             break;
2286         }
2287
2288         /* read a frame from it and output it in the fifo */
2289         is = input_files[file_index].ctx;
2290         ret= av_read_frame(is, &pkt);
2291         if(ret == AVERROR(EAGAIN)){
2292             no_packet[file_index]=1;
2293             no_packet_count++;
2294             continue;
2295         }
2296         if (ret < 0) {
2297             input_files[file_index].eof_reached = 1;
2298             if (opt_shortest)
2299                 break;
2300             else
2301                 continue;
2302         }
2303
2304         no_packet_count=0;
2305         memset(no_packet, 0, nb_input_files);
2306
2307         if (do_pkt_dump) {
2308             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2309                              is->streams[pkt.stream_index]);
2310         }
2311         /* the following test is needed in case new streams appear
2312            dynamically in stream : we ignore them */
2313         if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
2314             goto discard_packet;
2315         ist_index = input_files[file_index].ist_index + pkt.stream_index;
2316         ist = &input_streams[ist_index];
2317         if (ist->discard)
2318             goto discard_packet;
2319
2320         if (pkt.dts != AV_NOPTS_VALUE)
2321             pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2322         if (pkt.pts != AV_NOPTS_VALUE)
2323             pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2324
2325         if (ist->ts_scale) {
2326             if(pkt.pts != AV_NOPTS_VALUE)
2327                 pkt.pts *= ist->ts_scale;
2328             if(pkt.dts != AV_NOPTS_VALUE)
2329                 pkt.dts *= ist->ts_scale;
2330         }
2331
2332 //        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);
2333         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2334             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2335             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2336             int64_t delta= pkt_dts - ist->next_pts;
2337             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2338                 input_files[ist->file_index].ts_offset -= delta;
2339                 if (verbose > 2)
2340                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2341                             delta, input_files[ist->file_index].ts_offset);
2342                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2343                 if(pkt.pts != AV_NOPTS_VALUE)
2344                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2345             }
2346         }
2347
2348         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2349         if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2350
2351             if (verbose >= 0)
2352                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2353                         ist->file_index, ist->st->index);
2354             if (exit_on_error)
2355                 exit_program(1);
2356             av_free_packet(&pkt);
2357             goto redo;
2358         }
2359
2360     discard_packet:
2361         av_free_packet(&pkt);
2362
2363         /* dump report by using the output first video and audio streams */
2364         print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2365     }
2366
2367     /* at the end of stream, we must flush the decoder buffers */
2368     for (i = 0; i < nb_input_streams; i++) {
2369         ist = &input_streams[i];
2370         if (ist->decoding_needed) {
2371             output_packet(ist, i, output_streams, nb_output_streams, NULL);
2372         }
2373     }
2374
2375     term_exit();
2376
2377     /* write the trailer if needed and close file */
2378     for(i=0;i<nb_output_files;i++) {
2379         os = output_files[i].ctx;
2380         av_write_trailer(os);
2381     }
2382
2383     /* dump report by using the first video and audio streams */
2384     print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2385
2386     /* close each encoder */
2387     for (i = 0; i < nb_output_streams; i++) {
2388         ost = &output_streams[i];
2389         if (ost->encoding_needed) {
2390             av_freep(&ost->st->codec->stats_in);
2391             avcodec_close(ost->st->codec);
2392         }
2393 #if CONFIG_AVFILTER
2394         avfilter_graph_free(&ost->graph);
2395 #endif
2396     }
2397
2398     /* close each decoder */
2399     for (i = 0; i < nb_input_streams; i++) {
2400         ist = &input_streams[i];
2401         if (ist->decoding_needed) {
2402             avcodec_close(ist->st->codec);
2403         }
2404     }
2405
2406     /* finished ! */
2407     ret = 0;
2408
2409  fail:
2410     av_freep(&bit_buffer);
2411     av_freep(&no_packet);
2412
2413     if (output_streams) {
2414         for (i = 0; i < nb_output_streams; i++) {
2415             ost = &output_streams[i];
2416             if (ost) {
2417                 if (ost->st->stream_copy)
2418                     av_freep(&ost->st->codec->extradata);
2419                 if (ost->logfile) {
2420                     fclose(ost->logfile);
2421                     ost->logfile = NULL;
2422                 }
2423                 av_fifo_free(ost->fifo); /* works even if fifo is not
2424                                              initialized but set to zero */
2425                 av_freep(&ost->st->codec->subtitle_header);
2426                 av_free(ost->pict_tmp.data[0]);
2427                 av_free(ost->forced_kf_pts);
2428                 if (ost->video_resample)
2429                     sws_freeContext(ost->img_resample_ctx);
2430                 if (ost->resample)
2431                     audio_resample_close(ost->resample);
2432                 if (ost->reformat_ctx)
2433                     av_audio_convert_free(ost->reformat_ctx);
2434                 av_dict_free(&ost->opts);
2435             }
2436         }
2437     }
2438     return ret;
2439 }
2440
2441 static int opt_format(const char *opt, const char *arg)
2442 {
2443     last_asked_format = arg;
2444     return 0;
2445 }
2446
2447 static int opt_video_rc_override_string(const char *opt, const char *arg)
2448 {
2449     video_rc_override_string = arg;
2450     return 0;
2451 }
2452
2453 static int opt_me_threshold(const char *opt, const char *arg)
2454 {
2455     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2456     return 0;
2457 }
2458
2459 static int opt_verbose(const char *opt, const char *arg)
2460 {
2461     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2462     return 0;
2463 }
2464
2465 static int opt_frame_rate(const char *opt, const char *arg)
2466 {
2467     if (av_parse_video_rate(&frame_rate, arg) < 0) {
2468         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2469         exit_program(1);
2470     }
2471     return 0;
2472 }
2473
2474 static int opt_frame_crop(const char *opt, const char *arg)
2475 {
2476     fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2477     return AVERROR(EINVAL);
2478 }
2479
2480 static int opt_frame_size(const char *opt, const char *arg)
2481 {
2482     if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2483         fprintf(stderr, "Incorrect frame size\n");
2484         return AVERROR(EINVAL);
2485     }
2486     return 0;
2487 }
2488
2489 static int opt_pad(const char *opt, const char *arg) {
2490     fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2491     return -1;
2492 }
2493
2494 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2495 {
2496     if (strcmp(arg, "list")) {
2497         frame_pix_fmt = av_get_pix_fmt(arg);
2498         if (frame_pix_fmt == PIX_FMT_NONE) {
2499             fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2500             return AVERROR(EINVAL);
2501         }
2502     } else {
2503         show_pix_fmts();
2504         exit_program(0);
2505     }
2506     return 0;
2507 }
2508
2509 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2510 {
2511     int x = 0, y = 0;
2512     double ar = 0;
2513     const char *p;
2514     char *end;
2515
2516     p = strchr(arg, ':');
2517     if (p) {
2518         x = strtol(arg, &end, 10);
2519         if (end == p)
2520             y = strtol(end+1, &end, 10);
2521         if (x > 0 && y > 0)
2522             ar = (double)x / (double)y;
2523     } else
2524         ar = strtod(arg, NULL);
2525
2526     if (!ar) {
2527         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2528         return AVERROR(EINVAL);
2529     }
2530     frame_aspect_ratio = ar;
2531     return 0;
2532 }
2533
2534 static int opt_metadata(const char *opt, const char *arg)
2535 {
2536     char *mid= strchr(arg, '=');
2537
2538     if(!mid){
2539         fprintf(stderr, "Missing =\n");
2540         exit_program(1);
2541     }
2542     *mid++= 0;
2543
2544     av_dict_set(&metadata, arg, mid, 0);
2545
2546     return 0;
2547 }
2548
2549 static int opt_qscale(const char *opt, const char *arg)
2550 {
2551     video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2552     if (video_qscale == 0) {
2553         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2554         return AVERROR(EINVAL);
2555     }
2556     return 0;
2557 }
2558
2559 static int opt_top_field_first(const char *opt, const char *arg)
2560 {
2561     top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2562     return 0;
2563 }
2564
2565 static int opt_thread_count(const char *opt, const char *arg)
2566 {
2567     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2568 #if !HAVE_THREADS
2569     if (verbose >= 0)
2570         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2571 #endif
2572     return 0;
2573 }
2574
2575 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2576 {
2577     if (strcmp(arg, "list")) {
2578         audio_sample_fmt = av_get_sample_fmt(arg);
2579         if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2580             av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2581             return AVERROR(EINVAL);
2582         }
2583     } else {
2584         int i;
2585         char fmt_str[128];
2586         for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2587             printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2588         exit_program(0);
2589     }
2590     return 0;
2591 }
2592
2593 static int opt_audio_rate(const char *opt, const char *arg)
2594 {
2595     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2596     return 0;
2597 }
2598
2599 static int opt_audio_channels(const char *opt, const char *arg)
2600 {
2601     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2602     return 0;
2603 }
2604
2605 static int opt_codec(const char *opt, const char *arg)
2606 {
2607     return av_dict_set(&codec_names, opt, arg, 0);
2608 }
2609
2610 static int opt_audio_codec(const char *opt, const char *arg)
2611 {
2612     return opt_codec("codec:a", arg);
2613 }
2614
2615 static int opt_video_codec(const char *opt, const char *arg)
2616 {
2617     return opt_codec("codec:v", arg);
2618 }
2619
2620 static int opt_subtitle_codec(const char *opt, const char *arg)
2621 {
2622     return opt_codec("codec:s", arg);
2623 }
2624
2625 static int opt_data_codec(const char *opt, const char *arg)
2626 {
2627     return opt_codec("codec:d", arg);
2628 }
2629
2630 static int opt_codec_tag(const char *opt, const char *arg)
2631 {
2632     char *tail;
2633     uint32_t *codec_tag;
2634
2635     codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2636                 !strcmp(opt, "vtag") ? &video_codec_tag :
2637                 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2638     if (!codec_tag)
2639         return -1;
2640
2641     *codec_tag = strtol(arg, &tail, 0);
2642     if (!tail || *tail)
2643         *codec_tag = AV_RL32(arg);
2644
2645     return 0;
2646 }
2647
2648 static int opt_map(const char *opt, const char *arg)
2649 {
2650     StreamMap *m = NULL;
2651     int i, negative = 0, file_idx;
2652     int sync_file_idx = -1, sync_stream_idx;
2653     char *p, *sync;
2654     char *map;
2655
2656     if (*arg == '-') {
2657         negative = 1;
2658         arg++;
2659     }
2660     map = av_strdup(arg);
2661
2662     /* parse sync stream first, just pick first matching stream */
2663     if (sync = strchr(map, ',')) {
2664         *sync = 0;
2665         sync_file_idx = strtol(sync + 1, &sync, 0);
2666         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2667             av_log(NULL, AV_LOG_ERROR, "Invalid sync file index: %d.\n", sync_file_idx);
2668             exit_program(1);
2669         }
2670         if (*sync)
2671             sync++;
2672         for (i = 0; i < input_files[sync_file_idx].ctx->nb_streams; i++)
2673             if (check_stream_specifier(input_files[sync_file_idx].ctx,
2674                                        input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2675                 sync_stream_idx = i;
2676                 break;
2677             }
2678         if (i == input_files[sync_file_idx].ctx->nb_streams) {
2679             av_log(NULL, AV_LOG_ERROR, "Sync stream specification in map %s does not "
2680                                        "match any streams.\n", arg);
2681             exit_program(1);
2682         }
2683     }
2684
2685
2686     file_idx = strtol(map, &p, 0);
2687     if (file_idx >= nb_input_files || file_idx < 0) {
2688         av_log(NULL, AV_LOG_ERROR, "Invalid input file index: %d.\n", file_idx);
2689         exit_program(1);
2690     }
2691     if (negative)
2692         /* disable some already defined maps */
2693         for (i = 0; i < nb_stream_maps; i++) {
2694             m = &stream_maps[i];
2695             if (check_stream_specifier(input_files[m->file_index].ctx,
2696                                        input_files[m->file_index].ctx->streams[m->stream_index],
2697                                        *p == ':' ? p + 1 : p) > 0)
2698                 m->disabled = 1;
2699         }
2700     else
2701         for (i = 0; i < input_files[file_idx].ctx->nb_streams; i++) {
2702             if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2703                         *p == ':' ? p + 1 : p) <= 0)
2704                 continue;
2705             stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2706             m = &stream_maps[nb_stream_maps - 1];
2707
2708             m->file_index   = file_idx;
2709             m->stream_index = i;
2710
2711             if (sync_file_idx >= 0) {
2712                 m->sync_file_index   = sync_file_idx;
2713                 m->sync_stream_index = sync_stream_idx;
2714             } else {
2715                 m->sync_file_index   = file_idx;
2716                 m->sync_stream_index = i;
2717             }
2718         }
2719
2720     if (!m) {
2721         av_log(NULL, AV_LOG_ERROR, "Stream map '%s' matches no streams.\n", arg);
2722         exit_program(1);
2723     }
2724
2725     av_freep(&map);
2726     return 0;
2727 }
2728
2729 static void parse_meta_type(char *arg, char *type, int *index)
2730 {
2731     if (*arg == ':') {
2732         *type = *(++arg);
2733         switch (*arg) {
2734         case 'g':
2735             break;
2736         case 's':
2737         case 'c':
2738         case 'p':
2739             if (*(++arg) == ':')
2740                 *index = strtol(++arg, NULL, 0);
2741             break;
2742         default:
2743             fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2744             exit_program(1);
2745         }
2746     } else
2747         *type = 'g';
2748 }
2749
2750 static int opt_map_metadata(const char *opt, const char *arg)
2751 {
2752     MetadataMap *m, *m1;
2753     char *p;
2754
2755     meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2756                                 &nb_meta_data_maps, nb_meta_data_maps + 1);
2757
2758     m = &meta_data_maps[nb_meta_data_maps - 1][1];
2759     m->file = strtol(arg, &p, 0);
2760     parse_meta_type(p, &m->type, &m->index);
2761
2762     m1 = &meta_data_maps[nb_meta_data_maps - 1][0];
2763     if (p = strchr(opt, ':'))
2764         parse_meta_type(p, &m1->type, &m1->index);
2765     else
2766         m1->type = 'g';
2767
2768     if (m->type == 'g' || m1->type == 'g')
2769         metadata_global_autocopy = 0;
2770     if (m->type == 's' || m1->type == 's')
2771         metadata_streams_autocopy = 0;
2772     if (m->type == 'c' || m1->type == 'c')
2773         metadata_chapters_autocopy = 0;
2774
2775     return 0;
2776 }
2777
2778 static int opt_input_ts_scale(const char *opt, const char *arg)
2779 {
2780     return av_dict_set(&ts_scale, opt, arg, 0);
2781 }
2782
2783 static int opt_recording_time(const char *opt, const char *arg)
2784 {
2785     recording_time = parse_time_or_die(opt, arg, 1);
2786     return 0;
2787 }
2788
2789 static int opt_start_time(const char *opt, const char *arg)
2790 {
2791     start_time = parse_time_or_die(opt, arg, 1);
2792     return 0;
2793 }
2794
2795 static int opt_input_ts_offset(const char *opt, const char *arg)
2796 {
2797     input_ts_offset = parse_time_or_die(opt, arg, 1);
2798     return 0;
2799 }
2800
2801 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2802 {
2803     const char *codec_string = encoder ? "encoder" : "decoder";
2804     AVCodec *codec;
2805
2806     if(!name)
2807         return CODEC_ID_NONE;
2808     codec = encoder ?
2809         avcodec_find_encoder_by_name(name) :
2810         avcodec_find_decoder_by_name(name);
2811     if(!codec) {
2812         av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2813         exit_program(1);
2814     }
2815     if(codec->type != type) {
2816         av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2817         exit_program(1);
2818     }
2819     return codec->id;
2820 }
2821
2822 static AVCodec *choose_codec(AVFormatContext *s, AVStream *st, enum AVMediaType type, AVDictionary *codec_names)
2823 {
2824     AVDictionaryEntry *e = NULL;
2825     char *codec_name = NULL;
2826     int ret;
2827
2828     while (e = av_dict_get(codec_names, "", e, AV_DICT_IGNORE_SUFFIX)) {
2829         char *p = strchr(e->key, ':');
2830
2831         if ((ret = check_stream_specifier(s, st, p ? p + 1 : "")) > 0)
2832             codec_name = e->value;
2833         else if (ret < 0)
2834             exit_program(1);
2835     }
2836
2837     if (!codec_name) {
2838         if (s->oformat) {
2839             st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
2840             return avcodec_find_encoder(st->codec->codec_id);
2841         }
2842     } else if (!strcmp(codec_name, "copy"))
2843         st->stream_copy = 1;
2844     else {
2845         st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
2846         return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
2847                             avcodec_find_decoder_by_name(codec_name);
2848     }
2849
2850     return NULL;
2851 }
2852
2853 /**
2854  * Add all the streams from the given input file to the global
2855  * list of input streams.
2856  */
2857 static void add_input_streams(AVFormatContext *ic)
2858 {
2859     int i, rfps, rfps_base, ret;
2860
2861     for (i = 0; i < ic->nb_streams; i++) {
2862         AVStream *st = ic->streams[i];
2863         AVCodecContext *dec = st->codec;
2864         AVDictionaryEntry *e = NULL;
2865         InputStream *ist;
2866         char *scale = NULL;
2867
2868         dec->thread_count = thread_count;
2869
2870         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2871         ist = &input_streams[nb_input_streams - 1];
2872         ist->st = st;
2873         ist->file_index = nb_input_files;
2874         ist->discard = 1;
2875         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2876
2877         while (e = av_dict_get(ts_scale, "", e, AV_DICT_IGNORE_SUFFIX)) {
2878             char *p = strchr(e->key, ':');
2879
2880             if ((ret = check_stream_specifier(ic, st, p ? p + 1 : "")) > 0)
2881                 scale = e->value;
2882             else if (ret < 0)
2883                 exit_program(1);
2884         }
2885         if (scale)
2886             ist->ts_scale = strtod(scale, NULL);
2887
2888         ist->dec = choose_codec(ic, st, dec->codec_type, codec_names);
2889
2890         switch (dec->codec_type) {
2891         case AVMEDIA_TYPE_AUDIO:
2892             if(audio_disable)
2893                 st->discard= AVDISCARD_ALL;
2894             break;
2895         case AVMEDIA_TYPE_VIDEO:
2896             rfps      = ic->streams[i]->r_frame_rate.num;
2897             rfps_base = ic->streams[i]->r_frame_rate.den;
2898             if (dec->lowres) {
2899                 dec->flags |= CODEC_FLAG_EMU_EDGE;
2900                 dec->height >>= dec->lowres;
2901                 dec->width  >>= dec->lowres;
2902             }
2903             if(me_threshold)
2904                 dec->debug |= FF_DEBUG_MV;
2905
2906             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2907
2908                 if (verbose >= 0)
2909                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2910                             i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2911
2912                     (float)rfps / rfps_base, rfps, rfps_base);
2913             }
2914
2915             if(video_disable)
2916                 st->discard= AVDISCARD_ALL;
2917             else if(video_discard)
2918                 st->discard= video_discard;
2919             break;
2920         case AVMEDIA_TYPE_DATA:
2921             break;
2922         case AVMEDIA_TYPE_SUBTITLE:
2923             if(subtitle_disable)
2924                 st->discard = AVDISCARD_ALL;
2925             break;
2926         case AVMEDIA_TYPE_ATTACHMENT:
2927         case AVMEDIA_TYPE_UNKNOWN:
2928             break;
2929         default:
2930             abort();
2931         }
2932     }
2933 }
2934
2935 static int opt_input_file(const char *opt, const char *filename)
2936 {
2937     AVFormatContext *ic;
2938     AVInputFormat *file_iformat = NULL;
2939     int err, i, ret;
2940     int64_t timestamp;
2941     uint8_t buf[128];
2942     AVDictionary **opts;
2943     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
2944
2945     if (last_asked_format) {
2946         if (!(file_iformat = av_find_input_format(last_asked_format))) {
2947             fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
2948             exit_program(1);
2949         }
2950         last_asked_format = NULL;
2951     }
2952
2953     if (!strcmp(filename, "-"))
2954         filename = "pipe:";
2955
2956     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2957                     !strcmp(filename, "/dev/stdin");
2958
2959     /* get default parameters from command line */
2960     ic = avformat_alloc_context();
2961     if (!ic) {
2962         print_error(filename, AVERROR(ENOMEM));
2963         exit_program(1);
2964     }
2965     if (audio_sample_rate) {
2966         snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
2967         av_dict_set(&format_opts, "sample_rate", buf, 0);
2968     }
2969     if (audio_channels) {
2970         snprintf(buf, sizeof(buf), "%d", audio_channels);
2971         av_dict_set(&format_opts, "channels", buf, 0);
2972     }
2973     if (frame_rate.num) {
2974         snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
2975         av_dict_set(&format_opts, "framerate", buf, 0);
2976     }
2977     if (frame_width && frame_height) {
2978         snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
2979         av_dict_set(&format_opts, "video_size", buf, 0);
2980     }
2981     if (frame_pix_fmt != PIX_FMT_NONE)
2982         av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
2983
2984     ic->flags |= AVFMT_FLAG_NONBLOCK;
2985
2986     /* open the input file with generic libav function */
2987     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
2988     if (err < 0) {
2989         print_error(filename, err);
2990         exit_program(1);
2991     }
2992     assert_avoptions(format_opts);
2993
2994     if(opt_programid) {
2995         int i, j;
2996         int found=0;
2997         for(i=0; i<ic->nb_streams; i++){
2998             ic->streams[i]->discard= AVDISCARD_ALL;
2999         }
3000         for(i=0; i<ic->nb_programs; i++){
3001             AVProgram *p= ic->programs[i];
3002             if(p->id != opt_programid){
3003                 p->discard = AVDISCARD_ALL;
3004             }else{
3005                 found=1;
3006                 for(j=0; j<p->nb_stream_indexes; j++){
3007                     ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3008                 }
3009             }
3010         }
3011         if(!found){
3012             fprintf(stderr, "Specified program id not found\n");
3013             exit_program(1);
3014         }
3015         opt_programid=0;
3016     }
3017
3018     /* apply forced codec ids */
3019     for (i = 0; i < ic->nb_streams; i++)
3020         choose_codec(ic, ic->streams[i], ic->streams[i]->codec->codec_type, codec_names);
3021
3022     /* Set AVCodecContext options for avformat_find_stream_info */
3023     opts = setup_find_stream_info_opts(ic, codec_opts);
3024     orig_nb_streams = ic->nb_streams;
3025
3026     /* If not enough info to get the stream parameters, we decode the
3027        first frames to get it. (used in mpeg case for example) */
3028     ret = avformat_find_stream_info(ic, opts);
3029     if (ret < 0 && verbose >= 0) {
3030         fprintf(stderr, "%s: could not find codec parameters\n", filename);
3031         av_close_input_file(ic);
3032         exit_program(1);
3033     }
3034
3035     timestamp = start_time;
3036     /* add the stream start time */
3037     if (ic->start_time != AV_NOPTS_VALUE)
3038         timestamp += ic->start_time;
3039
3040     /* if seeking requested, we execute it */
3041     if (start_time != 0) {
3042         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3043         if (ret < 0) {
3044             fprintf(stderr, "%s: could not seek to position %0.3f\n",
3045                     filename, (double)timestamp / AV_TIME_BASE);
3046         }
3047         /* reset seek info */
3048         start_time = 0;
3049     }
3050
3051     /* update the current parameters so that they match the one of the input stream */
3052     add_input_streams(ic);
3053
3054     /* dump the file content */
3055     if (verbose >= 0)
3056         av_dump_format(ic, nb_input_files, filename, 0);
3057
3058     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3059     input_files[nb_input_files - 1].ctx        = ic;
3060     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3061     input_files[nb_input_files - 1].ts_offset  = input_ts_offset - (copy_ts ? 0 : timestamp);
3062
3063     frame_rate    = (AVRational){0, 0};
3064     frame_pix_fmt = PIX_FMT_NONE;
3065     frame_height = 0;
3066     frame_width  = 0;
3067     audio_sample_rate = 0;
3068     audio_channels    = 0;
3069     audio_sample_fmt  = AV_SAMPLE_FMT_NONE;
3070     av_dict_free(&ts_scale);
3071
3072     for (i = 0; i < orig_nb_streams; i++)
3073         av_dict_free(&opts[i]);
3074     av_freep(&opts);
3075     av_dict_free(&codec_names);
3076     uninit_opts();
3077     init_opts();
3078     return 0;
3079 }
3080
3081 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3082                                     AVCodecContext *avctx)
3083 {
3084     char *p;
3085     int n = 1, i;
3086     int64_t t;
3087
3088     for (p = kf; *p; p++)
3089         if (*p == ',')
3090             n++;
3091     ost->forced_kf_count = n;
3092     ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3093     if (!ost->forced_kf_pts) {
3094         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3095         exit_program(1);
3096     }
3097     for (i = 0; i < n; i++) {
3098         p = i ? strchr(p, ',') + 1 : kf;
3099         t = parse_time_or_die("force_key_frames", p, 1);
3100         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3101     }
3102 }
3103
3104 static OutputStream *new_output_stream(AVFormatContext *oc, enum AVMediaType type)
3105 {
3106     OutputStream *ost;
3107     AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3108     int idx      = oc->nb_streams - 1;
3109
3110     if (!st) {
3111         av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
3112         exit_program(1);
3113     }
3114
3115     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3116                                 nb_output_streams + 1);
3117     ost = &output_streams[nb_output_streams - 1];
3118     ost->file_index = nb_output_files;
3119     ost->index = idx;
3120     ost->st    = st;
3121     st->codec->codec_type = type;
3122     ost->enc = choose_codec(oc, st, type, codec_names);
3123     if (ost->enc) {
3124         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3125     }
3126
3127     avcodec_get_context_defaults3(st->codec, ost->enc);
3128     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3129
3130     ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3131     return ost;
3132 }
3133
3134 static OutputStream *new_video_stream(AVFormatContext *oc)
3135 {
3136     AVStream *st;
3137     OutputStream *ost;
3138     AVCodecContext *video_enc;
3139
3140     ost = new_output_stream(oc, AVMEDIA_TYPE_VIDEO);
3141     st  = ost->st;
3142     if (!st->stream_copy) {
3143         ost->frame_aspect_ratio = frame_aspect_ratio;
3144         frame_aspect_ratio = 0;
3145 #if CONFIG_AVFILTER
3146         ost->avfilter= vfilters;
3147         vfilters = NULL;
3148 #endif
3149     }
3150
3151     ost->bitstream_filters = video_bitstream_filters;
3152     video_bitstream_filters= NULL;
3153
3154     st->codec->thread_count= thread_count;
3155
3156     video_enc = st->codec;
3157
3158     if(video_codec_tag)
3159         video_enc->codec_tag= video_codec_tag;
3160
3161     if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3162         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3163     }
3164
3165     if (st->stream_copy) {
3166         video_enc->sample_aspect_ratio =
3167         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3168     } else {
3169         const char *p;
3170         int i;
3171
3172         if (frame_rate.num)
3173             ost->frame_rate = frame_rate;
3174
3175         video_enc->width = frame_width;
3176         video_enc->height = frame_height;
3177         video_enc->pix_fmt = frame_pix_fmt;
3178         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3179
3180         if (video_qscale || same_quant) {
3181             video_enc->flags |= CODEC_FLAG_QSCALE;
3182             video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3183         }
3184
3185         if(intra_matrix)
3186             video_enc->intra_matrix = intra_matrix;
3187         if(inter_matrix)
3188             video_enc->inter_matrix = inter_matrix;
3189
3190         p= video_rc_override_string;
3191         for(i=0; p; i++){
3192             int start, end, q;
3193             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3194             if(e!=3){
3195                 fprintf(stderr, "error parsing rc_override\n");
3196                 exit_program(1);
3197             }
3198             video_enc->rc_override=
3199                 av_realloc(video_enc->rc_override,
3200                            sizeof(RcOverride)*(i+1));
3201             video_enc->rc_override[i].start_frame= start;
3202             video_enc->rc_override[i].end_frame  = end;
3203             if(q>0){
3204                 video_enc->rc_override[i].qscale= q;
3205                 video_enc->rc_override[i].quality_factor= 1.0;
3206             }
3207             else{
3208                 video_enc->rc_override[i].qscale= 0;
3209                 video_enc->rc_override[i].quality_factor= -q/100.0;
3210             }
3211             p= strchr(p, '/');
3212             if(p) p++;
3213         }
3214         video_enc->rc_override_count=i;
3215         if (!video_enc->rc_initial_buffer_occupancy)
3216             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3217         video_enc->me_threshold= me_threshold;
3218         video_enc->intra_dc_precision= intra_dc_precision - 8;
3219
3220         if (do_psnr)
3221             video_enc->flags|= CODEC_FLAG_PSNR;
3222
3223         /* two pass mode */
3224         if (do_pass) {
3225             if (do_pass == 1) {
3226                 video_enc->flags |= CODEC_FLAG_PASS1;
3227             } else {
3228                 video_enc->flags |= CODEC_FLAG_PASS2;
3229             }
3230         }
3231
3232         if (forced_key_frames)
3233             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3234     }
3235     if (video_language) {
3236         av_dict_set(&st->metadata, "language", video_language, 0);
3237         av_freep(&video_language);
3238     }
3239
3240     /* reset some key parameters */
3241     video_disable = 0;
3242     av_freep(&forced_key_frames);
3243     frame_pix_fmt = PIX_FMT_NONE;
3244     return ost;
3245 }
3246
3247 static OutputStream *new_audio_stream(AVFormatContext *oc)
3248 {
3249     AVStream *st;
3250     OutputStream *ost;
3251     AVCodecContext *audio_enc;
3252
3253     ost = new_output_stream(oc, AVMEDIA_TYPE_AUDIO);
3254     st  = ost->st;
3255
3256     ost->bitstream_filters = audio_bitstream_filters;
3257     audio_bitstream_filters= NULL;
3258
3259     st->codec->thread_count= thread_count;
3260
3261     audio_enc = st->codec;
3262     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3263
3264     if(audio_codec_tag)
3265         audio_enc->codec_tag= audio_codec_tag;
3266
3267     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3268         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3269     }
3270     if (!st->stream_copy) {
3271         if (audio_qscale > QSCALE_NONE) {
3272             audio_enc->flags |= CODEC_FLAG_QSCALE;
3273             audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3274         }
3275         if (audio_channels)
3276             audio_enc->channels = audio_channels;
3277         if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3278             audio_enc->sample_fmt = audio_sample_fmt;
3279         if (audio_sample_rate)
3280             audio_enc->sample_rate = audio_sample_rate;
3281     }
3282     if (audio_language) {
3283         av_dict_set(&st->metadata, "language", audio_language, 0);
3284         av_freep(&audio_language);
3285     }
3286
3287     /* reset some key parameters */
3288     audio_disable = 0;
3289
3290     return ost;
3291 }
3292
3293 static OutputStream *new_data_stream(AVFormatContext *oc)
3294 {
3295     AVStream *st;
3296     OutputStream *ost;
3297     AVCodecContext *data_enc;
3298
3299     ost = new_output_stream(oc, AVMEDIA_TYPE_DATA);
3300     st  = ost->st;
3301     data_enc = st->codec;
3302     if (!st->stream_copy) {
3303         fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3304         exit_program(1);
3305     }
3306
3307     if (data_codec_tag)
3308         data_enc->codec_tag= data_codec_tag;
3309
3310     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3311         data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3312     }
3313
3314     data_disable = 0;
3315     return ost;
3316 }
3317
3318 static OutputStream *new_subtitle_stream(AVFormatContext *oc)
3319 {
3320     AVStream *st;
3321     OutputStream *ost;
3322     AVCodecContext *subtitle_enc;
3323
3324     ost = new_output_stream(oc, AVMEDIA_TYPE_SUBTITLE);
3325     st  = ost->st;
3326     subtitle_enc = st->codec;
3327
3328     ost->bitstream_filters = subtitle_bitstream_filters;
3329     subtitle_bitstream_filters= NULL;
3330
3331     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3332
3333     if(subtitle_codec_tag)
3334         subtitle_enc->codec_tag= subtitle_codec_tag;
3335
3336     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3337         subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3338     }
3339
3340     if (subtitle_language) {
3341         av_dict_set(&st->metadata, "language", subtitle_language, 0);
3342         av_freep(&subtitle_language);
3343     }
3344
3345     subtitle_disable = 0;
3346     return ost;
3347 }
3348
3349 /* arg format is "output-stream-index:streamid-value". */
3350 static int opt_streamid(const char *opt, const char *arg)
3351 {
3352     int idx;
3353     char *p;
3354     char idx_str[16];
3355
3356     av_strlcpy(idx_str, arg, sizeof(idx_str));
3357     p = strchr(idx_str, ':');
3358     if (!p) {
3359         fprintf(stderr,
3360                 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3361                 arg, opt);
3362         exit_program(1);
3363     }
3364     *p++ = '\0';
3365     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3366     streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3367     streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3368     return 0;
3369 }
3370
3371 static int copy_chapters(int infile, int outfile)
3372 {
3373     AVFormatContext *is = input_files[infile].ctx;
3374     AVFormatContext *os = output_files[outfile].ctx;
3375     int i;
3376
3377     for (i = 0; i < is->nb_chapters; i++) {
3378         AVChapter *in_ch = is->chapters[i], *out_ch;
3379         int64_t ts_off   = av_rescale_q(start_time - input_files[infile].ts_offset,
3380                                       AV_TIME_BASE_Q, in_ch->time_base);
3381         int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
3382                            av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3383
3384
3385         if (in_ch->end < ts_off)
3386             continue;
3387         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3388             break;
3389
3390         out_ch = av_mallocz(sizeof(AVChapter));
3391         if (!out_ch)
3392             return AVERROR(ENOMEM);
3393
3394         out_ch->id        = in_ch->id;
3395         out_ch->time_base = in_ch->time_base;
3396         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
3397         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
3398
3399         if (metadata_chapters_autocopy)
3400             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3401
3402         os->nb_chapters++;
3403         os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3404         if (!os->chapters)
3405             return AVERROR(ENOMEM);
3406         os->chapters[os->nb_chapters - 1] = out_ch;
3407     }
3408     return 0;
3409 }
3410
3411 static int read_avserver_streams(AVFormatContext *s, const char *filename)
3412 {
3413     int i, err;
3414     AVFormatContext *ic = NULL;
3415
3416     err = avformat_open_input(&ic, filename, NULL, NULL);
3417     if (err < 0)
3418         return err;
3419     /* copy stream format */
3420     for(i=0;i<ic->nb_streams;i++) {
3421         AVStream *st;
3422         OutputStream *ost;
3423         AVCodec *codec;
3424
3425         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3426         ost   = new_output_stream(s, codec->type);
3427         st    = ost->st;
3428
3429         // FIXME: a more elegant solution is needed
3430         memcpy(st, ic->streams[i], sizeof(AVStream));
3431         st->info = NULL;
3432         avcodec_copy_context(st->codec, ic->streams[i]->codec);
3433
3434         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3435             choose_sample_fmt(st, codec);
3436         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3437             choose_pixel_fmt(st, codec);
3438     }
3439
3440     av_close_input_file(ic);
3441     return 0;
3442 }
3443
3444 static void opt_output_file(const char *filename)
3445 {
3446     AVFormatContext *oc;
3447     int i, err;
3448     AVOutputFormat *file_oformat;
3449     OutputStream *ost;
3450     InputStream  *ist;
3451
3452     if (!strcmp(filename, "-"))
3453         filename = "pipe:";
3454
3455     oc = avformat_alloc_context();
3456     if (!oc) {
3457         print_error(filename, AVERROR(ENOMEM));
3458         exit_program(1);
3459     }
3460
3461     if (last_asked_format) {
3462         file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3463         if (!file_oformat) {
3464             fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3465             exit_program(1);
3466         }
3467         last_asked_format = NULL;
3468     } else {
3469         file_oformat = av_guess_format(NULL, filename, NULL);
3470         if (!file_oformat) {
3471             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3472                     filename);
3473             exit_program(1);
3474         }
3475     }
3476
3477     oc->oformat = file_oformat;
3478     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3479
3480     if (!strcmp(file_oformat->name, "ffm") &&
3481         av_strstart(filename, "http:", NULL)) {
3482         /* special case for files sent to avserver: we get the stream
3483            parameters from avserver */
3484         int err = read_avserver_streams(oc, filename);
3485         if (err < 0) {
3486             print_error(filename, err);
3487             exit_program(1);
3488         }
3489     } else if (!nb_stream_maps) {
3490         /* pick the "best" stream of each type */
3491 #define NEW_STREAM(type, index)\
3492         if (index >= 0) {\
3493             ost = new_ ## type ## _stream(oc);\
3494             ost->source_index = index;\
3495             ost->sync_ist     = &input_streams[index];\
3496             input_streams[index].discard = 0;\
3497         }
3498
3499         /* video: highest resolution */
3500         if (!video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3501             int area = 0, idx = -1;
3502             for (i = 0; i < nb_input_streams; i++) {
3503                 ist = &input_streams[i];
3504                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3505                     ist->st->codec->width * ist->st->codec->height > area) {
3506                     area = ist->st->codec->width * ist->st->codec->height;
3507                     idx = i;
3508                 }
3509             }
3510             NEW_STREAM(video, idx);
3511         }
3512
3513         /* audio: most channels */
3514         if (!audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3515             int channels = 0, idx = -1;
3516             for (i = 0; i < nb_input_streams; i++) {
3517                 ist = &input_streams[i];
3518                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3519                     ist->st->codec->channels > channels) {
3520                     channels = ist->st->codec->channels;
3521                     idx = i;
3522                 }
3523             }
3524             NEW_STREAM(audio, idx);
3525         }
3526
3527         /* subtitles: pick first */
3528         if (!subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3529             for (i = 0; i < nb_input_streams; i++)
3530                 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3531                     NEW_STREAM(subtitle, i);
3532                     break;
3533                 }
3534         }
3535         /* do something with data? */
3536     } else {
3537         for (i = 0; i < nb_stream_maps; i++) {
3538             StreamMap *map = &stream_maps[i];
3539
3540             if (map->disabled)
3541                 continue;
3542
3543             ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3544             switch (ist->st->codec->codec_type) {
3545             case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(oc);    break;
3546             case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(oc);    break;
3547             case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(oc); break;
3548             case AVMEDIA_TYPE_DATA:     ost = new_data_stream(oc);     break;
3549             default:
3550                 av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
3551                        map->file_index, map->stream_index);
3552                 exit_program(1);
3553             }
3554
3555             ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3556             ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3557                                            map->sync_stream_index];
3558             ist->discard = 0;
3559         }
3560     }
3561
3562     av_dict_copy(&oc->metadata, metadata, 0);
3563     av_dict_free(&metadata);
3564
3565
3566     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3567     output_files[nb_output_files - 1].ctx       = oc;
3568     output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3569     output_files[nb_output_files - 1].recording_time = recording_time;
3570     output_files[nb_output_files - 1].start_time     = start_time;
3571     output_files[nb_output_files - 1].limit_filesize = limit_filesize;
3572     av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3573
3574     /* check filename in case of an image number is expected */
3575     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3576         if (!av_filename_number_test(oc->filename)) {
3577             print_error(oc->filename, AVERROR(EINVAL));
3578             exit_program(1);
3579         }
3580     }
3581
3582     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3583         /* test if it already exists to avoid loosing precious files */
3584         if (!file_overwrite &&
3585             (strchr(filename, ':') == NULL ||
3586              filename[1] == ':' ||
3587              av_strstart(filename, "file:", NULL))) {
3588             if (avio_check(filename, 0) == 0) {
3589                 if (!using_stdin) {
3590                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3591                     fflush(stderr);
3592                     if (!read_yesno()) {
3593                         fprintf(stderr, "Not overwriting - exiting\n");
3594                         exit_program(1);
3595                     }
3596                 }
3597                 else {
3598                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3599                     exit_program(1);
3600                 }
3601             }
3602         }
3603
3604         /* open the file */
3605         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3606             print_error(filename, err);
3607             exit_program(1);
3608         }
3609     }
3610
3611     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3612     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3613     oc->flags |= AVFMT_FLAG_NONBLOCK;
3614
3615     /* copy chapters */
3616     if (chapters_input_file >= nb_input_files) {
3617         if (chapters_input_file == INT_MAX) {
3618             /* copy chapters from the first input file that has them*/
3619             chapters_input_file = -1;
3620             for (i = 0; i < nb_input_files; i++)
3621                 if (input_files[i].ctx->nb_chapters) {
3622                     chapters_input_file = i;
3623                     break;
3624                 }
3625         } else {
3626             av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3627                    chapters_input_file);
3628             exit_program(1);
3629         }
3630     }
3631     if (chapters_input_file >= 0)
3632         copy_chapters(chapters_input_file, nb_output_files - 1);
3633
3634     /* copy metadata */
3635     for (i = 0; i < nb_meta_data_maps; i++) {
3636         AVFormatContext *files[2];
3637         AVDictionary    **meta[2];
3638         int j;
3639
3640 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3641         if ((index) < 0 || (index) >= (nb_elems)) {\
3642             av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3643                      (desc), (index));\
3644             exit_program(1);\
3645         }
3646
3647         int in_file_index = meta_data_maps[i][1].file;
3648         if (in_file_index < 0)
3649             continue;
3650         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3651
3652         files[0] = oc;
3653         files[1] = input_files[in_file_index].ctx;
3654
3655         for (j = 0; j < 2; j++) {
3656             MetadataMap *map = &meta_data_maps[i][j];
3657
3658             switch (map->type) {
3659             case 'g':
3660                 meta[j] = &files[j]->metadata;
3661                 break;
3662             case 's':
3663                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3664                 meta[j] = &files[j]->streams[map->index]->metadata;
3665                 break;
3666             case 'c':
3667                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3668                 meta[j] = &files[j]->chapters[map->index]->metadata;
3669                 break;
3670             case 'p':
3671                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3672                 meta[j] = &files[j]->programs[map->index]->metadata;
3673                 break;
3674             }
3675         }
3676
3677         av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3678     }
3679
3680     /* copy global metadata by default */
3681     if (metadata_global_autocopy && nb_input_files)
3682         av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3683                      AV_DICT_DONT_OVERWRITE);
3684     if (metadata_streams_autocopy)
3685         for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3686             InputStream *ist = &input_streams[output_streams[i].source_index];
3687             av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3688         }
3689
3690     frame_rate    = (AVRational){0, 0};
3691     frame_width   = 0;
3692     frame_height  = 0;
3693     audio_sample_rate = 0;
3694     audio_channels    = 0;
3695     audio_sample_fmt  = AV_SAMPLE_FMT_NONE;
3696     chapters_input_file = INT_MAX;
3697     recording_time = INT64_MAX;
3698     start_time     = 0;
3699     limit_filesize = UINT64_MAX;
3700
3701     av_freep(&meta_data_maps);
3702     nb_meta_data_maps = 0;
3703     metadata_global_autocopy   = 1;
3704     metadata_streams_autocopy  = 1;
3705     metadata_chapters_autocopy = 1;
3706     av_freep(&stream_maps);
3707     nb_stream_maps = 0;
3708     av_freep(&streamid_map);
3709     nb_streamid_map = 0;
3710
3711     av_dict_free(&codec_names);
3712
3713     av_freep(&forced_key_frames);
3714     uninit_opts();
3715     init_opts();
3716 }
3717
3718 /* same option as mencoder */
3719 static int opt_pass(const char *opt, const char *arg)
3720 {
3721     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3722     return 0;
3723 }
3724
3725 static int64_t getutime(void)
3726 {
3727 #if HAVE_GETRUSAGE
3728     struct rusage rusage;
3729
3730     getrusage(RUSAGE_SELF, &rusage);
3731     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3732 #elif HAVE_GETPROCESSTIMES
3733     HANDLE proc;
3734     FILETIME c, e, k, u;
3735     proc = GetCurrentProcess();
3736     GetProcessTimes(proc, &c, &e, &k, &u);
3737     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3738 #else
3739     return av_gettime();
3740 #endif
3741 }
3742
3743 static int64_t getmaxrss(void)
3744 {
3745 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3746     struct rusage rusage;
3747     getrusage(RUSAGE_SELF, &rusage);
3748     return (int64_t)rusage.ru_maxrss * 1024;
3749 #elif HAVE_GETPROCESSMEMORYINFO
3750     HANDLE proc;
3751     PROCESS_MEMORY_COUNTERS memcounters;
3752     proc = GetCurrentProcess();
3753     memcounters.cb = sizeof(memcounters);
3754     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3755     return memcounters.PeakPagefileUsage;
3756 #else
3757     return 0;
3758 #endif
3759 }
3760
3761 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3762 {
3763     int i;
3764     const char *p = str;
3765     for(i = 0;; i++) {
3766         dest[i] = atoi(p);
3767         if(i == 63)
3768             break;
3769         p = strchr(p, ',');
3770         if(!p) {
3771             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3772             exit_program(1);
3773         }
3774         p++;
3775     }
3776 }
3777
3778 static void opt_inter_matrix(const char *arg)
3779 {
3780     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3781     parse_matrix_coeffs(inter_matrix, arg);
3782 }
3783
3784 static void opt_intra_matrix(const char *arg)
3785 {
3786     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3787     parse_matrix_coeffs(intra_matrix, arg);
3788 }
3789
3790 static void show_usage(void)
3791 {
3792     printf("Hyper fast Audio and Video encoder\n");
3793     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3794     printf("\n");
3795 }
3796
3797 static void show_help(void)
3798 {
3799     AVCodec *c;
3800     AVOutputFormat *oformat = NULL;
3801     AVInputFormat  *iformat = NULL;
3802
3803     av_log_set_callback(log_callback_help);
3804     show_usage();
3805     show_help_options(options, "Main options:\n",
3806                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3807     show_help_options(options, "\nAdvanced options:\n",
3808                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3809                       OPT_EXPERT);
3810     show_help_options(options, "\nVideo options:\n",
3811                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3812                       OPT_VIDEO);
3813     show_help_options(options, "\nAdvanced Video options:\n",
3814                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3815                       OPT_VIDEO | OPT_EXPERT);
3816     show_help_options(options, "\nAudio options:\n",
3817                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3818                       OPT_AUDIO);
3819     show_help_options(options, "\nAdvanced Audio options:\n",
3820                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3821                       OPT_AUDIO | OPT_EXPERT);
3822     show_help_options(options, "\nSubtitle options:\n",
3823                       OPT_SUBTITLE | OPT_GRAB,
3824                       OPT_SUBTITLE);
3825     show_help_options(options, "\nAudio/Video grab options:\n",
3826                       OPT_GRAB,
3827                       OPT_GRAB);
3828     printf("\n");
3829     av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3830     printf("\n");
3831
3832     /* individual codec options */
3833     c = NULL;
3834     while ((c = av_codec_next(c))) {
3835         if (c->priv_class) {
3836             av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3837             printf("\n");
3838         }
3839     }
3840
3841     av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3842     printf("\n");
3843
3844     /* individual muxer options */
3845     while ((oformat = av_oformat_next(oformat))) {
3846         if (oformat->priv_class) {
3847             av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3848             printf("\n");
3849         }
3850     }
3851
3852     /* individual demuxer options */
3853     while ((iformat = av_iformat_next(iformat))) {
3854         if (iformat->priv_class) {
3855             av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3856             printf("\n");
3857         }
3858     }
3859
3860     av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3861 }
3862
3863 static int opt_target(const char *opt, const char *arg)
3864 {
3865     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3866     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3867
3868     if(!strncmp(arg, "pal-", 4)) {
3869         norm = PAL;
3870         arg += 4;
3871     } else if(!strncmp(arg, "ntsc-", 5)) {
3872         norm = NTSC;
3873         arg += 5;
3874     } else if(!strncmp(arg, "film-", 5)) {
3875         norm = FILM;
3876         arg += 5;
3877     } else {
3878         int fr;
3879         /* Calculate FR via float to avoid int overflow */
3880         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3881         if(fr == 25000) {
3882             norm = PAL;
3883         } else if((fr == 29970) || (fr == 23976)) {
3884             norm = NTSC;
3885         } else {
3886             /* Try to determine PAL/NTSC by peeking in the input files */
3887             if(nb_input_files) {
3888                 int i, j;
3889                 for (j = 0; j < nb_input_files; j++) {
3890                     for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
3891                         AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3892                         if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3893                             continue;
3894                         fr = c->time_base.den * 1000 / c->time_base.num;
3895                         if(fr == 25000) {
3896                             norm = PAL;
3897                             break;
3898                         } else if((fr == 29970) || (fr == 23976)) {
3899                             norm = NTSC;
3900                             break;
3901                         }
3902                     }
3903                     if(norm != UNKNOWN)
3904                         break;
3905                 }
3906             }
3907         }
3908         if(verbose > 0 && norm != UNKNOWN)
3909             fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3910     }
3911
3912     if(norm == UNKNOWN) {
3913         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3914         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3915         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3916         exit_program(1);
3917     }
3918
3919     if(!strcmp(arg, "vcd")) {
3920         opt_codec("c:v", "mpeg1video");
3921         opt_codec("c:a", "mp2");
3922         opt_format("f", "vcd");
3923
3924         opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
3925         opt_frame_rate("r", frame_rates[norm]);
3926         opt_default("g", norm == PAL ? "15" : "18");
3927
3928         opt_default("b", "1150000");
3929         opt_default("maxrate", "1150000");
3930         opt_default("minrate", "1150000");
3931         opt_default("bufsize", "327680"); // 40*1024*8;
3932
3933         opt_default("b:a", "224000");
3934         audio_sample_rate = 44100;
3935         audio_channels = 2;
3936
3937         opt_default("packetsize", "2324");
3938         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3939
3940         /* We have to offset the PTS, so that it is consistent with the SCR.
3941            SCR starts at 36000, but the first two packs contain only padding
3942            and the first pack from the other stream, respectively, may also have
3943            been written before.
3944            So the real data starts at SCR 36000+3*1200. */
3945         mux_preload= (36000+3*1200) / 90000.0; //0.44
3946     } else if(!strcmp(arg, "svcd")) {
3947
3948         opt_codec("c:v", "mpeg2video");
3949         opt_codec("c:a", "mp2");
3950         opt_format("f", "svcd");
3951
3952         opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
3953         opt_frame_rate("r", frame_rates[norm]);
3954         opt_default("g", norm == PAL ? "15" : "18");
3955
3956         opt_default("b", "2040000");
3957         opt_default("maxrate", "2516000");
3958         opt_default("minrate", "0"); //1145000;
3959         opt_default("bufsize", "1835008"); //224*1024*8;
3960         opt_default("flags", "+scan_offset");
3961
3962
3963         opt_default("b:a", "224000");
3964         audio_sample_rate = 44100;
3965
3966         opt_default("packetsize", "2324");
3967
3968     } else if(!strcmp(arg, "dvd")) {
3969
3970         opt_codec("c:v", "mpeg2video");
3971         opt_codec("c:a", "ac3");
3972         opt_format("f", "dvd");
3973
3974         opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
3975         opt_frame_rate("r", frame_rates[norm]);
3976         opt_default("g", norm == PAL ? "15" : "18");
3977
3978         opt_default("b", "6000000");
3979         opt_default("maxrate", "9000000");
3980         opt_default("minrate", "0"); //1500000;
3981         opt_default("bufsize", "1835008"); //224*1024*8;
3982
3983         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3984         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3985
3986         opt_default("b:a", "448000");
3987         audio_sample_rate = 48000;
3988
3989     } else if(!strncmp(arg, "dv", 2)) {
3990
3991         opt_format("f", "dv");
3992
3993         opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
3994         opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
3995                           norm == PAL ? "yuv420p" : "yuv411p");
3996         opt_frame_rate("r", frame_rates[norm]);
3997
3998         audio_sample_rate = 48000;
3999         audio_channels = 2;
4000
4001     } else {
4002         fprintf(stderr, "Unknown target: %s\n", arg);
4003         return AVERROR(EINVAL);
4004     }
4005     return 0;
4006 }
4007
4008 static int opt_vstats_file(const char *opt, const char *arg)
4009 {
4010     av_free (vstats_filename);
4011     vstats_filename=av_strdup (arg);
4012     return 0;
4013 }
4014
4015 static int opt_vstats(const char *opt, const char *arg)
4016 {
4017     char filename[40];
4018     time_t today2 = time(NULL);
4019     struct tm *today = localtime(&today2);
4020
4021     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4022              today->tm_sec);
4023     return opt_vstats_file(opt, filename);
4024 }
4025
4026 static int opt_bsf(const char *opt, const char *arg)
4027 {
4028     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4029     AVBitStreamFilterContext **bsfp;
4030
4031     if(!bsfc){
4032         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4033         exit_program(1);
4034     }
4035
4036     bsfp= *opt == 'v' ? &video_bitstream_filters :
4037           *opt == 'a' ? &audio_bitstream_filters :
4038                         &subtitle_bitstream_filters;
4039     while(*bsfp)
4040         bsfp= &(*bsfp)->next;
4041
4042     *bsfp= bsfc;
4043
4044     return 0;
4045 }
4046
4047 static const OptionDef options[] = {
4048     /* main options */
4049 #include "cmdutils_common_opts.h"
4050     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4051     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4052     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4053     { "c", HAS_ARG, {(void*)opt_codec}, "codec name", "codec" },
4054     { "codec", HAS_ARG, {(void*)opt_codec}, "codec name", "codec" },
4055     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4056     { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4057       "outfile[,metadata]:infile[,metadata]" },
4058     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&chapters_input_file},  "set chapters mapping", "input_file_index" },
4059     { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4060     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4061     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4062     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4063     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "scale" },
4064     { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4065     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4066     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4067       "add timings for benchmarking" },
4068     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4069     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4070       "dump each input packet" },
4071     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4072       "when dumping packets, also dump the payload" },
4073     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4074     { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
4075     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4076     { "threads",  HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4077     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4078     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4079     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4080     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4081     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4082     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4083     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4084     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4085     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4086     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4087
4088     /* video options */
4089     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4090     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4091     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4092     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4093     { "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" },
4094     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4095     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4096     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4097     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4098     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4099     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4100     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4101     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4102     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4103     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4104     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4105     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4106     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4107     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4108     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimation threshold",  "threshold" },
4109     { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4110       "use same quantizer as source (implies VBR)" },
4111     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4112     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4113     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4114       "deinterlace pictures" },
4115     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4116     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4117     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4118 #if CONFIG_AVFILTER
4119     { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4120 #endif
4121     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4122     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4123     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4124     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4125     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4126     { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4127     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4128     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4129     { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4130     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4131
4132     /* audio options */
4133     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4134     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4135     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4136     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4137     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4138     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4139     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4140     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4141     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4142     { "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" },
4143
4144     /* subtitle options */
4145     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4146     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4147     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4148     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4149
4150     /* grab options */
4151     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4152
4153     /* muxer options */
4154     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4155     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4156
4157     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4158     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4159     { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4160
4161     /* data codec support */
4162     { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4163
4164     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4165     { NULL, },
4166 };
4167
4168 int main(int argc, char **argv)
4169 {
4170     int64_t ti;
4171
4172     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4173
4174     avcodec_register_all();
4175 #if CONFIG_AVDEVICE
4176     avdevice_register_all();
4177 #endif
4178 #if CONFIG_AVFILTER
4179     avfilter_register_all();
4180 #endif
4181     av_register_all();
4182
4183     avio_set_interrupt_cb(decode_interrupt_cb);
4184
4185     init_opts();
4186
4187     show_banner();
4188
4189     /* parse options */
4190     parse_options(argc, argv, options, opt_output_file);
4191
4192     if(nb_output_files <= 0 && nb_input_files == 0) {
4193         show_usage();
4194         fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4195         exit_program(1);
4196     }
4197
4198     /* file converter / grab */
4199     if (nb_output_files <= 0) {
4200         fprintf(stderr, "At least one output file must be specified\n");
4201         exit_program(1);
4202     }
4203
4204     if (nb_input_files == 0) {
4205         fprintf(stderr, "At least one input file must be specified\n");
4206         exit_program(1);
4207     }
4208
4209     ti = getutime();
4210     if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4211         exit_program(1);
4212     ti = getutime() - ti;
4213     if (do_benchmark) {
4214         int maxrss = getmaxrss() / 1024;
4215         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4216     }
4217
4218     return exit_program(0);
4219 }