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