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