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

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