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