avconv.c

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