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