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

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