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 void opt_format(const char *arg)
2708 {
2709     last_asked_format = arg;
2710 }
2711
2712 static void opt_video_rc_override_string(const char *arg)
2713 {
2714     video_rc_override_string = arg;
2715 }
2716
2717 static int opt_me_threshold(const char *opt, const char *arg)
2718 {
2719     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2720     return 0;
2721 }
2722
2723 static int opt_verbose(const char *opt, const char *arg)
2724 {
2725     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2726     return 0;
2727 }
2728
2729 static int opt_frame_rate(const char *opt, const char *arg)
2730 {
2731     if (av_parse_video_rate(&frame_rate, arg) < 0) {
2732         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2733         ffmpeg_exit(1);
2734     }
2735     return 0;
2736 }
2737
2738 static int opt_bitrate(const char *opt, const char *arg)
2739 {
2740     int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2741
2742     opt_default(opt, arg);
2743
2744     if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2745         fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2746
2747     return 0;
2748 }
2749
2750 static int opt_frame_crop(const char *opt, const char *arg)
2751 {
2752     fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2753     return AVERROR(EINVAL);
2754 }
2755
2756 static void opt_frame_size(const char *arg)
2757 {
2758     if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2759         fprintf(stderr, "Incorrect frame size\n");
2760         ffmpeg_exit(1);
2761     }
2762 }
2763
2764 static int opt_pad(const char *opt, const char *arg) {
2765     fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2766     return -1;
2767 }
2768
2769 static void opt_frame_pix_fmt(const char *arg)
2770 {
2771     if (strcmp(arg, "list")) {
2772         frame_pix_fmt = av_get_pix_fmt(arg);
2773         if (frame_pix_fmt == PIX_FMT_NONE) {
2774             fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2775             ffmpeg_exit(1);
2776         }
2777     } else {
2778         show_pix_fmts();
2779         ffmpeg_exit(0);
2780     }
2781 }
2782
2783 static void opt_frame_aspect_ratio(const char *arg)
2784 {
2785     int x = 0, y = 0;
2786     double ar = 0;
2787     const char *p;
2788     char *end;
2789
2790     p = strchr(arg, ':');
2791     if (p) {
2792         x = strtol(arg, &end, 10);
2793         if (end == p)
2794             y = strtol(end+1, &end, 10);
2795         if (x > 0 && y > 0)
2796             ar = (double)x / (double)y;
2797     } else
2798         ar = strtod(arg, NULL);
2799
2800     if (!ar) {
2801         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2802         ffmpeg_exit(1);
2803     }
2804     frame_aspect_ratio = ar;
2805 }
2806
2807 static int opt_metadata(const char *opt, const char *arg)
2808 {
2809     char *mid= strchr(arg, '=');
2810
2811     if(!mid){
2812         fprintf(stderr, "Missing =\n");
2813         ffmpeg_exit(1);
2814     }
2815     *mid++= 0;
2816
2817     av_metadata_set2(&metadata, arg, mid, 0);
2818
2819     return 0;
2820 }
2821
2822 static int opt_qscale(const char *opt, const char *arg)
2823 {
2824     video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2825     if (video_qscale == 0) {
2826         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2827         return AVERROR(EINVAL);
2828     }
2829     return 0;
2830 }
2831
2832 static int opt_top_field_first(const char *opt, const char *arg)
2833 {
2834     top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2835     return 0;
2836 }
2837
2838 static int opt_thread_count(const char *opt, const char *arg)
2839 {
2840     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2841 #if !HAVE_THREADS
2842     if (verbose >= 0)
2843         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2844 #endif
2845     return 0;
2846 }
2847
2848 static void opt_audio_sample_fmt(const char *arg)
2849 {
2850     if (strcmp(arg, "list")) {
2851         audio_sample_fmt = av_get_sample_fmt(arg);
2852         if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2853             av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2854             ffmpeg_exit(1);
2855         }
2856     } else {
2857         int i;
2858         char fmt_str[128];
2859         for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2860             printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2861         ffmpeg_exit(0);
2862     }
2863 }
2864
2865 static int opt_audio_rate(const char *opt, const char *arg)
2866 {
2867     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2868     return 0;
2869 }
2870
2871 static int opt_audio_channels(const char *opt, const char *arg)
2872 {
2873     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2874     return 0;
2875 }
2876
2877 static int opt_video_channel(const char *opt, const char *arg)
2878 {
2879     video_channel = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2880     return 0;
2881 }
2882
2883 static void opt_video_standard(const char *arg)
2884 {
2885     video_standard = av_strdup(arg);
2886 }
2887
2888 static void opt_codec(int *pstream_copy, char **pcodec_name,
2889                       int codec_type, const char *arg)
2890 {
2891     av_freep(pcodec_name);
2892     if (!strcmp(arg, "copy")) {
2893         *pstream_copy = 1;
2894     } else {
2895         *pcodec_name = av_strdup(arg);
2896     }
2897 }
2898
2899 static void opt_audio_codec(const char *arg)
2900 {
2901     opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2902 }
2903
2904 static void opt_video_codec(const char *arg)
2905 {
2906     opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2907 }
2908
2909 static void opt_subtitle_codec(const char *arg)
2910 {
2911     opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2912 }
2913
2914 static void opt_data_codec(const char *arg)
2915 {
2916     opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2917 }
2918
2919 static int opt_codec_tag(const char *opt, const char *arg)
2920 {
2921     char *tail;
2922     uint32_t *codec_tag;
2923
2924     codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2925                 !strcmp(opt, "vtag") ? &video_codec_tag :
2926                 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2927     if (!codec_tag)
2928         return -1;
2929
2930     *codec_tag = strtol(arg, &tail, 0);
2931     if (!tail || *tail)
2932         *codec_tag = AV_RL32(arg);
2933
2934     return 0;
2935 }
2936
2937 static void opt_map(const char *arg)
2938 {
2939     AVStreamMap *m;
2940     char *p;
2941
2942     stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2943     m = &stream_maps[nb_stream_maps-1];
2944
2945     m->file_index = strtol(arg, &p, 0);
2946     if (*p)
2947         p++;
2948
2949     m->stream_index = strtol(p, &p, 0);
2950     if (*p) {
2951         p++;
2952         m->sync_file_index = strtol(p, &p, 0);
2953         if (*p)
2954             p++;
2955         m->sync_stream_index = strtol(p, &p, 0);
2956     } else {
2957         m->sync_file_index = m->file_index;
2958         m->sync_stream_index = m->stream_index;
2959     }
2960 }
2961
2962 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2963 {
2964     *endptr = arg;
2965     if (*arg == ',') {
2966         *type = *(++arg);
2967         switch (*arg) {
2968         case 'g':
2969             break;
2970         case 's':
2971         case 'c':
2972         case 'p':
2973             *index = strtol(++arg, endptr, 0);
2974             break;
2975         default:
2976             fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2977             ffmpeg_exit(1);
2978         }
2979     } else
2980         *type = 'g';
2981 }
2982
2983 static void opt_map_metadata(const char *arg)
2984 {
2985     AVMetaDataMap *m, *m1;
2986     char *p;
2987
2988     meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2989                                 &nb_meta_data_maps, nb_meta_data_maps + 1);
2990
2991     m = &meta_data_maps[nb_meta_data_maps - 1][0];
2992     m->file = strtol(arg, &p, 0);
2993     parse_meta_type(p, &m->type, &m->index, &p);
2994     if (*p)
2995         p++;
2996
2997     m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
2998     m1->file = strtol(p, &p, 0);
2999     parse_meta_type(p, &m1->type, &m1->index, &p);
3000
3001     if (m->type == 'g' || m1->type == 'g')
3002         metadata_global_autocopy = 0;
3003     if (m->type == 's' || m1->type == 's')
3004         metadata_streams_autocopy = 0;
3005     if (m->type == 'c' || m1->type == 'c')
3006         metadata_chapters_autocopy = 0;
3007 }
3008
3009 static void opt_map_meta_data(const char *arg)
3010 {
3011     fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3012                     "Use -map_metadata instead.\n");
3013     opt_map_metadata(arg);
3014 }
3015
3016 static void opt_map_chapters(const char *arg)
3017 {
3018     AVChapterMap *c;
3019     char *p;
3020
3021     chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3022                               nb_chapter_maps + 1);
3023     c = &chapter_maps[nb_chapter_maps - 1];
3024     c->out_file = strtol(arg, &p, 0);
3025     if (*p)
3026         p++;
3027
3028     c->in_file = strtol(p, &p, 0);
3029 }
3030
3031 static void opt_input_ts_scale(const char *arg)
3032 {
3033     unsigned int stream;
3034     double scale;
3035     char *p;
3036
3037     stream = strtol(arg, &p, 0);
3038     if (*p)
3039         p++;
3040     scale= strtod(p, &p);
3041
3042     if(stream >= MAX_STREAMS)
3043         ffmpeg_exit(1);
3044
3045     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);
3046     input_files_ts_scale[nb_input_files][stream]= scale;
3047 }
3048
3049 static int opt_recording_time(const char *opt, const char *arg)
3050 {
3051     recording_time = parse_time_or_die(opt, arg, 1);
3052     return 0;
3053 }
3054
3055 static int opt_start_time(const char *opt, const char *arg)
3056 {
3057     start_time = parse_time_or_die(opt, arg, 1);
3058     return 0;
3059 }
3060
3061 static int opt_recording_timestamp(const char *opt, const char *arg)
3062 {
3063     recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3064     return 0;
3065 }
3066
3067 static int opt_input_ts_offset(const char *opt, const char *arg)
3068 {
3069     input_ts_offset = parse_time_or_die(opt, arg, 1);
3070     return 0;
3071 }
3072
3073 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3074 {
3075     const char *codec_string = encoder ? "encoder" : "decoder";
3076     AVCodec *codec;
3077
3078     if(!name)
3079         return CODEC_ID_NONE;
3080     codec = encoder ?
3081         avcodec_find_encoder_by_name(name) :
3082         avcodec_find_decoder_by_name(name);
3083     if(!codec) {
3084         fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3085         ffmpeg_exit(1);
3086     }
3087     if(codec->type != type) {
3088         fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3089         ffmpeg_exit(1);
3090     }
3091     if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3092        strict > FF_COMPLIANCE_EXPERIMENTAL) {
3093         fprintf(stderr, "%s '%s' is experimental and might produce bad "
3094                 "results.\nAdd '-strict experimental' if you want to use it.\n",
3095                 codec_string, codec->name);
3096         codec = encoder ?
3097             avcodec_find_encoder(codec->id) :
3098             avcodec_find_decoder(codec->id);
3099         if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3100             fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3101                     codec_string, codec->name);
3102         ffmpeg_exit(1);
3103     }
3104     return codec->id;
3105 }
3106
3107 static void opt_input_file(const char *filename)
3108 {
3109     AVFormatContext *ic;
3110     AVFormatParameters params, *ap = &params;
3111     AVInputFormat *file_iformat = NULL;
3112     int err, i, ret, rfps, rfps_base;
3113     int64_t timestamp;
3114
3115     if (last_asked_format) {
3116         if (!(file_iformat = av_find_input_format(last_asked_format))) {
3117             fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3118             ffmpeg_exit(1);
3119         }
3120         last_asked_format = NULL;
3121     }
3122
3123     if (!strcmp(filename, "-"))
3124         filename = "pipe:";
3125
3126     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3127                     !strcmp(filename, "/dev/stdin");
3128
3129     /* get default parameters from command line */
3130     ic = avformat_alloc_context();
3131     if (!ic) {
3132         print_error(filename, AVERROR(ENOMEM));
3133         ffmpeg_exit(1);
3134     }
3135
3136     memset(ap, 0, sizeof(*ap));
3137     ap->prealloced_context = 1;
3138     ap->sample_rate = audio_sample_rate;
3139     ap->channels = audio_channels;
3140     ap->time_base.den = frame_rate.num;
3141     ap->time_base.num = frame_rate.den;
3142     ap->width = frame_width;
3143     ap->height = frame_height;
3144     ap->pix_fmt = frame_pix_fmt;
3145    // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3146     ap->channel = video_channel;
3147     ap->standard = video_standard;
3148
3149     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3150
3151     ic->video_codec_id   =
3152         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3153                           avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3154     ic->audio_codec_id   =
3155         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3156                           avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3157     ic->subtitle_codec_id=
3158         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3159                           avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3160     ic->flags |= AVFMT_FLAG_NONBLOCK;
3161
3162     /* open the input file with generic libav function */
3163     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3164     if (err < 0) {
3165         print_error(filename, err);
3166         ffmpeg_exit(1);
3167     }
3168     if(opt_programid) {
3169         int i, j;
3170         int found=0;
3171         for(i=0; i<ic->nb_streams; i++){
3172             ic->streams[i]->discard= AVDISCARD_ALL;
3173         }
3174         for(i=0; i<ic->nb_programs; i++){
3175             AVProgram *p= ic->programs[i];
3176             if(p->id != opt_programid){
3177                 p->discard = AVDISCARD_ALL;
3178             }else{
3179                 found=1;
3180                 for(j=0; j<p->nb_stream_indexes; j++){
3181                     ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3182                 }
3183             }
3184         }
3185         if(!found){
3186             fprintf(stderr, "Specified program id not found\n");
3187             ffmpeg_exit(1);
3188         }
3189         opt_programid=0;
3190     }
3191
3192     ic->loop_input = loop_input;
3193
3194     /* Set AVCodecContext options so they will be seen by av_find_stream_info() */
3195     for (i = 0; i < ic->nb_streams; i++) {
3196         AVCodecContext *dec = ic->streams[i]->codec;
3197         switch (dec->codec_type) {
3198         case AVMEDIA_TYPE_AUDIO:
3199             set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO],
3200                              AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM,
3201                              NULL);
3202             break;
3203         case AVMEDIA_TYPE_VIDEO:
3204             set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO],
3205                              AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM,
3206                              NULL);
3207             break;
3208         }
3209     }
3210
3211     /* If not enough info to get the stream parameters, we decode the
3212        first frames to get it. (used in mpeg case for example) */
3213     ret = av_find_stream_info(ic);
3214     if (ret < 0 && verbose >= 0) {
3215         fprintf(stderr, "%s: could not find codec parameters\n", filename);
3216         av_close_input_file(ic);
3217         ffmpeg_exit(1);
3218     }
3219
3220     timestamp = start_time;
3221     /* add the stream start time */
3222     if (ic->start_time != AV_NOPTS_VALUE)
3223         timestamp += ic->start_time;
3224
3225     /* if seeking requested, we execute it */
3226     if (start_time != 0) {
3227         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3228         if (ret < 0) {
3229             fprintf(stderr, "%s: could not seek to position %0.3f\n",
3230                     filename, (double)timestamp / AV_TIME_BASE);
3231         }
3232         /* reset seek info */
3233         start_time = 0;
3234     }
3235
3236     /* update the current parameters so that they match the one of the input stream */
3237     for(i=0;i<ic->nb_streams;i++) {
3238         AVStream *st = ic->streams[i];
3239         AVCodecContext *dec = st->codec;
3240         AVInputStream *ist;
3241
3242         dec->thread_count = thread_count;
3243         input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3244
3245         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3246         ist = &input_streams[nb_input_streams - 1];
3247         ist->st = st;
3248         ist->file_index = nb_input_files;
3249         ist->discard = 1;
3250
3251         switch (dec->codec_type) {
3252         case AVMEDIA_TYPE_AUDIO:
3253             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3254             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]);
3255             channel_layout    = dec->channel_layout;
3256             audio_channels    = dec->channels;
3257             audio_sample_rate = dec->sample_rate;
3258             audio_sample_fmt  = dec->sample_fmt;
3259             if(audio_disable)
3260                 st->discard= AVDISCARD_ALL;
3261             /* Note that av_find_stream_info can add more streams, and we
3262              * currently have no chance of setting up lowres decoding
3263              * early enough for them. */
3264             if (dec->lowres)
3265                 audio_sample_rate >>= dec->lowres;
3266             break;
3267         case AVMEDIA_TYPE_VIDEO:
3268             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3269             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]);
3270             frame_height = dec->height;
3271             frame_width  = dec->width;
3272             frame_pix_fmt = dec->pix_fmt;
3273             rfps      = ic->streams[i]->r_frame_rate.num;
3274             rfps_base = ic->streams[i]->r_frame_rate.den;
3275             if (dec->lowres) {
3276                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3277                 frame_height >>= dec->lowres;
3278                 frame_width  >>= dec->lowres;
3279                 dec->height = frame_height;
3280                 dec->width  = frame_width;
3281             }
3282             if(me_threshold)
3283                 dec->debug |= FF_DEBUG_MV;
3284
3285             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3286
3287                 if (verbose >= 0)
3288                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3289                             i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3290
3291                     (float)rfps / rfps_base, rfps, rfps_base);
3292             }
3293             /* update the current frame rate to match the stream frame rate */
3294             frame_rate.num = rfps;
3295             frame_rate.den = rfps_base;
3296
3297             if(video_disable)
3298                 st->discard= AVDISCARD_ALL;
3299             else if(video_discard)
3300                 st->discard= video_discard;
3301             break;
3302         case AVMEDIA_TYPE_DATA:
3303             break;
3304         case AVMEDIA_TYPE_SUBTITLE:
3305             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3306             if(subtitle_disable)
3307                 st->discard = AVDISCARD_ALL;
3308             break;
3309         case AVMEDIA_TYPE_ATTACHMENT:
3310         case AVMEDIA_TYPE_UNKNOWN:
3311             break;
3312         default:
3313             abort();
3314         }
3315     }
3316
3317     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3318     /* dump the file content */
3319     if (verbose >= 0)
3320         av_dump_format(ic, nb_input_files, filename, 0);
3321
3322     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3323     input_files[nb_input_files - 1].ctx        = ic;
3324     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3325
3326     video_channel = 0;
3327
3328     av_freep(&video_codec_name);
3329     av_freep(&audio_codec_name);
3330     av_freep(&subtitle_codec_name);
3331     uninit_opts();
3332     init_opts();
3333 }
3334
3335 static void check_inputs(int *has_video_ptr,
3336                          int *has_audio_ptr,
3337                          int *has_subtitle_ptr,
3338                          int *has_data_ptr)
3339 {
3340     int has_video, has_audio, has_subtitle, has_data, i, j;
3341     AVFormatContext *ic;
3342
3343     has_video = 0;
3344     has_audio = 0;
3345     has_subtitle = 0;
3346     has_data = 0;
3347
3348     for(j=0;j<nb_input_files;j++) {
3349         ic = input_files[j].ctx;
3350         for(i=0;i<ic->nb_streams;i++) {
3351             AVCodecContext *enc = ic->streams[i]->codec;
3352             switch(enc->codec_type) {
3353             case AVMEDIA_TYPE_AUDIO:
3354                 has_audio = 1;
3355                 break;
3356             case AVMEDIA_TYPE_VIDEO:
3357                 has_video = 1;
3358                 break;
3359             case AVMEDIA_TYPE_SUBTITLE:
3360                 has_subtitle = 1;
3361                 break;
3362             case AVMEDIA_TYPE_DATA:
3363             case AVMEDIA_TYPE_ATTACHMENT:
3364             case AVMEDIA_TYPE_UNKNOWN:
3365                 has_data = 1;
3366                 break;
3367             default:
3368                 abort();
3369             }
3370         }
3371     }
3372     *has_video_ptr = has_video;
3373     *has_audio_ptr = has_audio;
3374     *has_subtitle_ptr = has_subtitle;
3375     *has_data_ptr = has_data;
3376 }
3377
3378 static void new_video_stream(AVFormatContext *oc, int file_idx)
3379 {
3380     AVStream *st;
3381     AVOutputStream *ost;
3382     AVCodecContext *video_enc;
3383     enum CodecID codec_id = CODEC_ID_NONE;
3384     AVCodec *codec= NULL;
3385
3386     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3387     if (!st) {
3388         fprintf(stderr, "Could not alloc stream\n");
3389         ffmpeg_exit(1);
3390     }
3391     ost = new_output_stream(oc, file_idx);
3392
3393     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3394     if(!video_stream_copy){
3395         if (video_codec_name) {
3396             codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3397                                          avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3398             codec = avcodec_find_encoder_by_name(video_codec_name);
3399             output_codecs[nb_output_codecs-1] = codec;
3400         } else {
3401             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3402             codec = avcodec_find_encoder(codec_id);
3403         }
3404
3405         ost->frame_aspect_ratio = frame_aspect_ratio;
3406         frame_aspect_ratio = 0;
3407 #if CONFIG_AVFILTER
3408         ost->avfilter= vfilters;
3409         vfilters = NULL;
3410 #endif
3411     }
3412
3413     avcodec_get_context_defaults3(st->codec, codec);
3414     ost->bitstream_filters = video_bitstream_filters;
3415     video_bitstream_filters= NULL;
3416
3417     st->codec->thread_count= thread_count;
3418
3419     video_enc = st->codec;
3420
3421     if(video_codec_tag)
3422         video_enc->codec_tag= video_codec_tag;
3423
3424     if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3425         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3426         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3427     }
3428
3429     if (video_stream_copy) {
3430         st->stream_copy = 1;
3431         video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3432         video_enc->sample_aspect_ratio =
3433         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3434     } else {
3435         const char *p;
3436         int i;
3437         AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3438
3439         video_enc->codec_id = codec_id;
3440         set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3441
3442         if (codec && codec->supported_framerates && !force_fps)
3443             fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3444         video_enc->time_base.den = fps.num;
3445         video_enc->time_base.num = fps.den;
3446
3447         video_enc->width = frame_width;
3448         video_enc->height = frame_height;
3449         video_enc->pix_fmt = frame_pix_fmt;
3450         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3451
3452         choose_pixel_fmt(st, codec);
3453
3454         if (intra_only)
3455             video_enc->gop_size = 0;
3456         if (video_qscale || same_quality) {
3457             video_enc->flags |= CODEC_FLAG_QSCALE;
3458             video_enc->global_quality=
3459                 st->quality = FF_QP2LAMBDA * video_qscale;
3460         }
3461
3462         if(intra_matrix)
3463             video_enc->intra_matrix = intra_matrix;
3464         if(inter_matrix)
3465             video_enc->inter_matrix = inter_matrix;
3466
3467         p= video_rc_override_string;
3468         for(i=0; p; i++){
3469             int start, end, q;
3470             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3471             if(e!=3){
3472                 fprintf(stderr, "error parsing rc_override\n");
3473                 ffmpeg_exit(1);
3474             }
3475             video_enc->rc_override=
3476                 av_realloc(video_enc->rc_override,
3477                            sizeof(RcOverride)*(i+1));
3478             video_enc->rc_override[i].start_frame= start;
3479             video_enc->rc_override[i].end_frame  = end;
3480             if(q>0){
3481                 video_enc->rc_override[i].qscale= q;
3482                 video_enc->rc_override[i].quality_factor= 1.0;
3483             }
3484             else{
3485                 video_enc->rc_override[i].qscale= 0;
3486                 video_enc->rc_override[i].quality_factor= -q/100.0;
3487             }
3488             p= strchr(p, '/');
3489             if(p) p++;
3490         }
3491         video_enc->rc_override_count=i;
3492         if (!video_enc->rc_initial_buffer_occupancy)
3493             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3494         video_enc->me_threshold= me_threshold;
3495         video_enc->intra_dc_precision= intra_dc_precision - 8;
3496
3497         if (do_psnr)
3498             video_enc->flags|= CODEC_FLAG_PSNR;
3499
3500         /* two pass mode */
3501         if (do_pass) {
3502             if (do_pass == 1) {
3503                 video_enc->flags |= CODEC_FLAG_PASS1;
3504             } else {
3505                 video_enc->flags |= CODEC_FLAG_PASS2;
3506             }
3507         }
3508
3509         if (forced_key_frames)
3510             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3511     }
3512     if (video_language) {
3513         av_metadata_set2(&st->metadata, "language", video_language, 0);
3514         av_freep(&video_language);
3515     }
3516
3517     /* reset some key parameters */
3518     video_disable = 0;
3519     av_freep(&video_codec_name);
3520     av_freep(&forced_key_frames);
3521     video_stream_copy = 0;
3522     frame_pix_fmt = PIX_FMT_NONE;
3523 }
3524
3525 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3526 {
3527     AVStream *st;
3528     AVOutputStream *ost;
3529     AVCodec *codec= NULL;
3530     AVCodecContext *audio_enc;
3531     enum CodecID codec_id = CODEC_ID_NONE;
3532
3533     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3534     if (!st) {
3535         fprintf(stderr, "Could not alloc stream\n");
3536         ffmpeg_exit(1);
3537     }
3538     ost = new_output_stream(oc, file_idx);
3539
3540     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3541     if(!audio_stream_copy){
3542         if (audio_codec_name) {
3543             codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3544                                          avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3545             codec = avcodec_find_encoder_by_name(audio_codec_name);
3546             output_codecs[nb_output_codecs-1] = codec;
3547         } else {
3548             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3549             codec = avcodec_find_encoder(codec_id);
3550         }
3551     }
3552
3553     avcodec_get_context_defaults3(st->codec, codec);
3554
3555     ost->bitstream_filters = audio_bitstream_filters;
3556     audio_bitstream_filters= NULL;
3557
3558     st->codec->thread_count= thread_count;
3559
3560     audio_enc = st->codec;
3561     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3562
3563     if(audio_codec_tag)
3564         audio_enc->codec_tag= audio_codec_tag;
3565
3566     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3567         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3568         avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3569     }
3570     if (audio_stream_copy) {
3571         st->stream_copy = 1;
3572         audio_enc->channels = audio_channels;
3573         audio_enc->sample_rate = audio_sample_rate;
3574     } else {
3575         audio_enc->codec_id = codec_id;
3576         set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3577
3578         if (audio_qscale > QSCALE_NONE) {
3579             audio_enc->flags |= CODEC_FLAG_QSCALE;
3580             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3581         }
3582         audio_enc->channels = audio_channels;
3583         audio_enc->sample_fmt = audio_sample_fmt;
3584         audio_enc->sample_rate = audio_sample_rate;
3585         audio_enc->channel_layout = channel_layout;
3586         if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3587             audio_enc->channel_layout = 0;
3588         choose_sample_fmt(st, codec);
3589         choose_sample_rate(st, codec);
3590     }
3591     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3592     if (audio_language) {
3593         av_metadata_set2(&st->metadata, "language", audio_language, 0);
3594         av_freep(&audio_language);
3595     }
3596
3597     /* reset some key parameters */
3598     audio_disable = 0;
3599     av_freep(&audio_codec_name);
3600     audio_stream_copy = 0;
3601 }
3602
3603 static void new_data_stream(AVFormatContext *oc, int file_idx)
3604 {
3605     AVStream *st;
3606     AVOutputStream *ost;
3607     AVCodec *codec=NULL;
3608     AVCodecContext *data_enc;
3609
3610     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3611     if (!st) {
3612         fprintf(stderr, "Could not alloc stream\n");
3613         ffmpeg_exit(1);
3614     }
3615     ost = new_output_stream(oc, file_idx);
3616     data_enc = st->codec;
3617     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3618     if (!data_stream_copy) {
3619         fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3620         ffmpeg_exit(1);
3621     }
3622     avcodec_get_context_defaults3(st->codec, codec);
3623
3624     data_enc->codec_type = AVMEDIA_TYPE_DATA;
3625
3626     if (data_codec_tag)
3627         data_enc->codec_tag= data_codec_tag;
3628
3629     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3630         data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3631         avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3632     }
3633     if (data_stream_copy) {
3634         st->stream_copy = 1;
3635     }
3636
3637     data_disable = 0;
3638     av_freep(&data_codec_name);
3639     data_stream_copy = 0;
3640 }
3641
3642 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3643 {
3644     AVStream *st;
3645     AVOutputStream *ost;
3646     AVCodec *codec=NULL;
3647     AVCodecContext *subtitle_enc;
3648     enum CodecID codec_id = CODEC_ID_NONE;
3649
3650     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3651     if (!st) {
3652         fprintf(stderr, "Could not alloc stream\n");
3653         ffmpeg_exit(1);
3654     }
3655     ost = new_output_stream(oc, file_idx);
3656     subtitle_enc = st->codec;
3657     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3658     if(!subtitle_stream_copy){
3659         if (subtitle_codec_name) {
3660             codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3661                                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3662             codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3663         } else {
3664             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3665             codec = avcodec_find_encoder(codec_id);
3666         }
3667     }
3668     avcodec_get_context_defaults3(st->codec, codec);
3669
3670     ost->bitstream_filters = subtitle_bitstream_filters;
3671     subtitle_bitstream_filters= NULL;
3672
3673     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3674
3675     if(subtitle_codec_tag)
3676         subtitle_enc->codec_tag= subtitle_codec_tag;
3677
3678     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3679         subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3680         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3681     }
3682     if (subtitle_stream_copy) {
3683         st->stream_copy = 1;
3684     } else {
3685         subtitle_enc->codec_id = codec_id;
3686         set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3687     }
3688
3689     if (subtitle_language) {
3690         av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3691         av_freep(&subtitle_language);
3692     }
3693
3694     subtitle_disable = 0;
3695     av_freep(&subtitle_codec_name);
3696     subtitle_stream_copy = 0;
3697 }
3698
3699 static int opt_new_stream(const char *opt, const char *arg)
3700 {
3701     AVFormatContext *oc;
3702     int file_idx = nb_output_files - 1;
3703     if (nb_output_files <= 0) {
3704         fprintf(stderr, "At least one output file must be specified\n");
3705         ffmpeg_exit(1);
3706     }
3707     oc = output_files[file_idx];
3708
3709     if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3710     else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3711     else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3712     else if (!strcmp(opt, "newdata"    )) new_data_stream    (oc, file_idx);
3713     else av_assert0(0);
3714     return 0;
3715 }
3716
3717 /* arg format is "output-stream-index:streamid-value". */
3718 static int opt_streamid(const char *opt, const char *arg)
3719 {
3720     int idx;
3721     char *p;
3722     char idx_str[16];
3723
3724     av_strlcpy(idx_str, arg, sizeof(idx_str));
3725     p = strchr(idx_str, ':');
3726     if (!p) {
3727         fprintf(stderr,
3728                 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3729                 arg, opt);
3730         ffmpeg_exit(1);
3731     }
3732     *p++ = '\0';
3733     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3734     streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3735     streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3736     return 0;
3737 }
3738
3739 static void opt_output_file(const char *filename)
3740 {
3741     AVFormatContext *oc;
3742     int err, use_video, use_audio, use_subtitle, use_data;
3743     int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3744     AVFormatParameters params, *ap = &params;
3745     AVOutputFormat *file_oformat;
3746
3747     if (!strcmp(filename, "-"))
3748         filename = "pipe:";
3749
3750     oc = avformat_alloc_context();
3751     if (!oc) {
3752         print_error(filename, AVERROR(ENOMEM));
3753         ffmpeg_exit(1);
3754     }
3755
3756     if (last_asked_format) {
3757         file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3758         if (!file_oformat) {
3759             fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3760             ffmpeg_exit(1);
3761         }
3762         last_asked_format = NULL;
3763     } else {
3764         file_oformat = av_guess_format(NULL, filename, NULL);
3765         if (!file_oformat) {
3766             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3767                     filename);
3768             ffmpeg_exit(1);
3769         }
3770     }
3771
3772     oc->oformat = file_oformat;
3773     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3774
3775     if (!strcmp(file_oformat->name, "ffm") &&
3776         av_strstart(filename, "http:", NULL)) {
3777         /* special case for files sent to ffserver: we get the stream
3778            parameters from ffserver */
3779         int err = read_ffserver_streams(oc, filename);
3780         if (err < 0) {
3781             print_error(filename, err);
3782             ffmpeg_exit(1);
3783         }
3784     } else {
3785         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3786         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3787         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3788         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 */
3789
3790         /* disable if no corresponding type found and at least one
3791            input file */
3792         if (nb_input_files > 0) {
3793             check_inputs(&input_has_video,
3794                          &input_has_audio,
3795                          &input_has_subtitle,
3796                          &input_has_data);
3797
3798             if (!input_has_video)
3799                 use_video = 0;
3800             if (!input_has_audio)
3801                 use_audio = 0;
3802             if (!input_has_subtitle)
3803                 use_subtitle = 0;
3804             if (!input_has_data)
3805                 use_data = 0;
3806         }
3807
3808         /* manual disable */
3809         if (audio_disable)    use_audio    = 0;
3810         if (video_disable)    use_video    = 0;
3811         if (subtitle_disable) use_subtitle = 0;
3812         if (data_disable)     use_data     = 0;
3813
3814         if (use_video)    new_video_stream(oc, nb_output_files);
3815         if (use_audio)    new_audio_stream(oc, nb_output_files);
3816         if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3817         if (use_data)     new_data_stream(oc, nb_output_files);
3818
3819         oc->timestamp = recording_timestamp;
3820
3821         av_metadata_copy(&oc->metadata, metadata, 0);
3822         av_metadata_free(&metadata);
3823     }
3824
3825     output_files[nb_output_files++] = oc;
3826
3827     /* check filename in case of an image number is expected */
3828     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3829         if (!av_filename_number_test(oc->filename)) {
3830             print_error(oc->filename, AVERROR(EINVAL));
3831             ffmpeg_exit(1);
3832         }
3833     }
3834
3835     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3836         /* test if it already exists to avoid loosing precious files */
3837         if (!file_overwrite &&
3838             (strchr(filename, ':') == NULL ||
3839              filename[1] == ':' ||
3840              av_strstart(filename, "file:", NULL))) {
3841             if (avio_check(filename, 0) == 0) {
3842                 if (!using_stdin) {
3843                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3844                     fflush(stderr);
3845                     if (!read_yesno()) {
3846                         fprintf(stderr, "Not overwriting - exiting\n");
3847                         ffmpeg_exit(1);
3848                     }
3849                 }
3850                 else {
3851                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3852                     ffmpeg_exit(1);
3853                 }
3854             }
3855         }
3856
3857         /* open the file */
3858         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3859             print_error(filename, err);
3860             ffmpeg_exit(1);
3861         }
3862     }
3863
3864     memset(ap, 0, sizeof(*ap));
3865     if (av_set_parameters(oc, ap) < 0) {
3866         fprintf(stderr, "%s: Invalid encoding parameters\n",
3867                 oc->filename);
3868         ffmpeg_exit(1);
3869     }
3870
3871     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3872     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3873     oc->loop_output = loop_output;
3874     oc->flags |= AVFMT_FLAG_NONBLOCK;
3875
3876     set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3877
3878     av_freep(&forced_key_frames);
3879     uninit_opts();
3880     init_opts();
3881 }
3882
3883 /* same option as mencoder */
3884 static int opt_pass(const char *opt, const char *arg)
3885 {
3886     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3887     return 0;
3888 }
3889
3890 static int64_t getutime(void)
3891 {
3892 #if HAVE_GETRUSAGE
3893     struct rusage rusage;
3894
3895     getrusage(RUSAGE_SELF, &rusage);
3896     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3897 #elif HAVE_GETPROCESSTIMES
3898     HANDLE proc;
3899     FILETIME c, e, k, u;
3900     proc = GetCurrentProcess();
3901     GetProcessTimes(proc, &c, &e, &k, &u);
3902     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3903 #else
3904     return av_gettime();
3905 #endif
3906 }
3907
3908 static int64_t getmaxrss(void)
3909 {
3910 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3911     struct rusage rusage;
3912     getrusage(RUSAGE_SELF, &rusage);
3913     return (int64_t)rusage.ru_maxrss * 1024;
3914 #elif HAVE_GETPROCESSMEMORYINFO
3915     HANDLE proc;
3916     PROCESS_MEMORY_COUNTERS memcounters;
3917     proc = GetCurrentProcess();
3918     memcounters.cb = sizeof(memcounters);
3919     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3920     return memcounters.PeakPagefileUsage;
3921 #else
3922     return 0;
3923 #endif
3924 }
3925
3926 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3927 {
3928     int i;
3929     const char *p = str;
3930     for(i = 0;; i++) {
3931         dest[i] = atoi(p);
3932         if(i == 63)
3933             break;
3934         p = strchr(p, ',');
3935         if(!p) {
3936             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3937             ffmpeg_exit(1);
3938         }
3939         p++;
3940     }
3941 }
3942
3943 static void opt_inter_matrix(const char *arg)
3944 {
3945     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3946     parse_matrix_coeffs(inter_matrix, arg);
3947 }
3948
3949 static void opt_intra_matrix(const char *arg)
3950 {
3951     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3952     parse_matrix_coeffs(intra_matrix, arg);
3953 }
3954
3955 static void show_usage(void)
3956 {
3957     printf("Hyper fast Audio and Video encoder\n");
3958     printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3959     printf("\n");
3960 }
3961
3962 static void show_help(void)
3963 {
3964     AVCodec *c;
3965     AVOutputFormat *oformat = NULL;
3966
3967     av_log_set_callback(log_callback_help);
3968     show_usage();
3969     show_help_options(options, "Main options:\n",
3970                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3971     show_help_options(options, "\nAdvanced options:\n",
3972                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3973                       OPT_EXPERT);
3974     show_help_options(options, "\nVideo options:\n",
3975                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3976                       OPT_VIDEO);
3977     show_help_options(options, "\nAdvanced Video options:\n",
3978                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3979                       OPT_VIDEO | OPT_EXPERT);
3980     show_help_options(options, "\nAudio options:\n",
3981                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3982                       OPT_AUDIO);
3983     show_help_options(options, "\nAdvanced Audio options:\n",
3984                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3985                       OPT_AUDIO | OPT_EXPERT);
3986     show_help_options(options, "\nSubtitle options:\n",
3987                       OPT_SUBTITLE | OPT_GRAB,
3988                       OPT_SUBTITLE);
3989     show_help_options(options, "\nAudio/Video grab options:\n",
3990                       OPT_GRAB,
3991                       OPT_GRAB);
3992     printf("\n");
3993     av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3994     printf("\n");
3995
3996     /* individual codec options */
3997     c = NULL;
3998     while ((c = av_codec_next(c))) {
3999         if (c->priv_class) {
4000             av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4001             printf("\n");
4002         }
4003     }
4004
4005     av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4006     printf("\n");
4007
4008     /* individual muxer options */
4009     while ((oformat = av_oformat_next(oformat))) {
4010         if (oformat->priv_class) {
4011             av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4012             printf("\n");
4013         }
4014     }
4015
4016     av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4017 }
4018
4019 static void opt_target(const char *arg)
4020 {
4021     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4022     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4023
4024     if(!strncmp(arg, "pal-", 4)) {
4025         norm = PAL;
4026         arg += 4;
4027     } else if(!strncmp(arg, "ntsc-", 5)) {
4028         norm = NTSC;
4029         arg += 5;
4030     } else if(!strncmp(arg, "film-", 5)) {
4031         norm = FILM;
4032         arg += 5;
4033     } else {
4034         int fr;
4035         /* Calculate FR via float to avoid int overflow */
4036         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4037         if(fr == 25000) {
4038             norm = PAL;
4039         } else if((fr == 29970) || (fr == 23976)) {
4040             norm = NTSC;
4041         } else {
4042             /* Try to determine PAL/NTSC by peeking in the input files */
4043             if(nb_input_files) {
4044                 int i, j;
4045                 for (j = 0; j < nb_input_files; j++) {
4046                     for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4047                         AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4048                         if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4049                             continue;
4050                         fr = c->time_base.den * 1000 / c->time_base.num;
4051                         if(fr == 25000) {
4052                             norm = PAL;
4053                             break;
4054                         } else if((fr == 29970) || (fr == 23976)) {
4055                             norm = NTSC;
4056                             break;
4057                         }
4058                     }
4059                     if(norm != UNKNOWN)
4060                         break;
4061                 }
4062             }
4063         }
4064         if(verbose > 0 && norm != UNKNOWN)
4065             fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4066     }
4067
4068     if(norm == UNKNOWN) {
4069         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4070         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4071         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4072         ffmpeg_exit(1);
4073     }
4074
4075     if(!strcmp(arg, "vcd")) {
4076
4077         opt_video_codec("mpeg1video");
4078         opt_audio_codec("mp2");
4079         opt_format("vcd");
4080
4081         opt_frame_size(norm == PAL ? "352x288" : "352x240");
4082         opt_frame_rate(NULL, frame_rates[norm]);
4083         opt_default("g", norm == PAL ? "15" : "18");
4084
4085         opt_default("b", "1150000");
4086         opt_default("maxrate", "1150000");
4087         opt_default("minrate", "1150000");
4088         opt_default("bufsize", "327680"); // 40*1024*8;
4089
4090         opt_default("ab", "224000");
4091         audio_sample_rate = 44100;
4092         audio_channels = 2;
4093
4094         opt_default("packetsize", "2324");
4095         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4096
4097         /* We have to offset the PTS, so that it is consistent with the SCR.
4098            SCR starts at 36000, but the first two packs contain only padding
4099            and the first pack from the other stream, respectively, may also have
4100            been written before.
4101            So the real data starts at SCR 36000+3*1200. */
4102         mux_preload= (36000+3*1200) / 90000.0; //0.44
4103     } else if(!strcmp(arg, "svcd")) {
4104
4105         opt_video_codec("mpeg2video");
4106         opt_audio_codec("mp2");
4107         opt_format("svcd");
4108
4109         opt_frame_size(norm == PAL ? "480x576" : "480x480");
4110         opt_frame_rate(NULL, frame_rates[norm]);
4111         opt_default("g", norm == PAL ? "15" : "18");
4112
4113         opt_default("b", "2040000");
4114         opt_default("maxrate", "2516000");
4115         opt_default("minrate", "0"); //1145000;
4116         opt_default("bufsize", "1835008"); //224*1024*8;
4117         opt_default("flags", "+scan_offset");
4118
4119
4120         opt_default("ab", "224000");
4121         audio_sample_rate = 44100;
4122
4123         opt_default("packetsize", "2324");
4124
4125     } else if(!strcmp(arg, "dvd")) {
4126
4127         opt_video_codec("mpeg2video");
4128         opt_audio_codec("ac3");
4129         opt_format("dvd");
4130
4131         opt_frame_size(norm == PAL ? "720x576" : "720x480");
4132         opt_frame_rate(NULL, frame_rates[norm]);
4133         opt_default("g", norm == PAL ? "15" : "18");
4134
4135         opt_default("b", "6000000");
4136         opt_default("maxrate", "9000000");
4137         opt_default("minrate", "0"); //1500000;
4138         opt_default("bufsize", "1835008"); //224*1024*8;
4139
4140         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4141         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4142
4143         opt_default("ab", "448000");
4144         audio_sample_rate = 48000;
4145
4146     } else if(!strncmp(arg, "dv", 2)) {
4147
4148         opt_format("dv");
4149
4150         opt_frame_size(norm == PAL ? "720x576" : "720x480");
4151         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4152                           (norm == PAL ? "yuv420p" : "yuv411p"));
4153         opt_frame_rate(NULL, frame_rates[norm]);
4154
4155         audio_sample_rate = 48000;
4156         audio_channels = 2;
4157
4158     } else {
4159         fprintf(stderr, "Unknown target: %s\n", arg);
4160         ffmpeg_exit(1);
4161     }
4162 }
4163
4164 static void opt_vstats_file (const char *arg)
4165 {
4166     av_free (vstats_filename);
4167     vstats_filename=av_strdup (arg);
4168 }
4169
4170 static void opt_vstats (void)
4171 {
4172     char filename[40];
4173     time_t today2 = time(NULL);
4174     struct tm *today = localtime(&today2);
4175
4176     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4177              today->tm_sec);
4178     opt_vstats_file(filename);
4179 }
4180
4181 static int opt_bsf(const char *opt, const char *arg)
4182 {
4183     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4184     AVBitStreamFilterContext **bsfp;
4185
4186     if(!bsfc){
4187         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4188         ffmpeg_exit(1);
4189     }
4190
4191     bsfp= *opt == 'v' ? &video_bitstream_filters :
4192           *opt == 'a' ? &audio_bitstream_filters :
4193                         &subtitle_bitstream_filters;
4194     while(*bsfp)
4195         bsfp= &(*bsfp)->next;
4196
4197     *bsfp= bsfc;
4198
4199     return 0;
4200 }
4201
4202 static int opt_preset(const char *opt, const char *arg)
4203 {
4204     FILE *f=NULL;
4205     char filename[1000], tmp[1000], tmp2[1000], line[1000];
4206     char *codec_name = *opt == 'v' ? video_codec_name :
4207                        *opt == 'a' ? audio_codec_name :
4208                                      subtitle_codec_name;
4209
4210     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4211         fprintf(stderr, "File for preset '%s' not found\n", arg);
4212         ffmpeg_exit(1);
4213     }
4214
4215     while(!feof(f)){
4216         int e= fscanf(f, "%999[^\n]\n", line) - 1;
4217         if(line[0] == '#' && !e)
4218             continue;
4219         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4220         if(e){
4221             fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4222             ffmpeg_exit(1);
4223         }
4224         if(!strcmp(tmp, "acodec")){
4225             opt_audio_codec(tmp2);
4226         }else if(!strcmp(tmp, "vcodec")){
4227             opt_video_codec(tmp2);
4228         }else if(!strcmp(tmp, "scodec")){
4229             opt_subtitle_codec(tmp2);
4230         }else if(!strcmp(tmp, "dcodec")){
4231             opt_data_codec(tmp2);
4232         }else if(opt_default(tmp, tmp2) < 0){
4233             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4234             ffmpeg_exit(1);
4235         }
4236     }
4237
4238     fclose(f);
4239
4240     return 0;
4241 }
4242
4243 static const OptionDef options[] = {
4244     /* main options */
4245 #include "cmdutils_common_opts.h"
4246     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4247     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4248     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4249     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4250     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4251       "outfile[,metadata]:infile[,metadata]" },
4252     { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4253       "outfile[,metadata]:infile[,metadata]" },
4254     { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4255     { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4256     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4257     { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4258     { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4259     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4260     { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4261     { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4262     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4263     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4264       "add timings for benchmarking" },
4265     { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4266     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4267       "dump each input packet" },
4268     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4269       "when dumping packets, also dump the payload" },
4270     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4271     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4272     { "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)", "" },
4273     { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4274     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4275     { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4276     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4277     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4278     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4279     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4280     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4281     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4282     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4283     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4284     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4285     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4286
4287     /* video options */
4288     { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4289     { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4290     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4291     { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4292     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4293     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4294     { "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" },
4295     { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4296     { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4297     { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4298     { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4299     { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4300     { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4301     { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4302     { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4303     { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4304     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4305     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4306     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4307     { "qscale", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4308     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4309     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4310     { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4311     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4312       "use same quantizer as source (implies VBR)" },
4313     { "pass", HAS_ARG | OPT_FUNC2 | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4314     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4315     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4316       "deinterlace pictures" },
4317     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4318     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4319     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4320 #if CONFIG_AVFILTER
4321     { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4322 #endif
4323     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4324     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4325     { "top", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4326     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4327     { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4328     { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4329     { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4330     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4331     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4332     { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4333     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4334
4335     /* audio options */
4336     { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4337     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4338     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4339     { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4340     { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4341     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4342     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4343     { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4344     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4345     { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4346     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4347     { "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" },
4348
4349     /* subtitle options */
4350     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4351     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4352     { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4353     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4354     { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4355
4356     /* grab options */
4357     { "vc", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4358     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4359     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4360
4361     /* muxer options */
4362     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4363     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4364
4365     { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4366     { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4367     { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4368
4369     { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4370     { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4371     { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4372     { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4373     /* data codec support */
4374     { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4375
4376     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4377     { NULL, },
4378 };
4379
4380 int main(int argc, char **argv)
4381 {
4382     int64_t ti;
4383
4384     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4385
4386     avcodec_register_all();
4387 #if CONFIG_AVDEVICE
4388     avdevice_register_all();
4389 #endif
4390 #if CONFIG_AVFILTER
4391     avfilter_register_all();
4392 #endif
4393     av_register_all();
4394
4395     avio_set_interrupt_cb(decode_interrupt_cb);
4396
4397     init_opts();
4398
4399     show_banner();
4400
4401     /* parse options */
4402     parse_options(argc, argv, options, opt_output_file);
4403
4404     if(nb_output_files <= 0 && nb_input_files == 0) {
4405         show_usage();
4406         fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4407         ffmpeg_exit(1);
4408     }
4409
4410     /* file converter / grab */
4411     if (nb_output_files <= 0) {
4412         fprintf(stderr, "At least one output file must be specified\n");
4413         ffmpeg_exit(1);
4414     }
4415
4416     if (nb_input_files == 0) {
4417         fprintf(stderr, "At least one input file must be specified\n");
4418         ffmpeg_exit(1);
4419     }
4420
4421     ti = getutime();
4422     if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4423                   stream_maps, nb_stream_maps) < 0)
4424         ffmpeg_exit(1);
4425     ti = getutime() - ti;
4426     if (do_benchmark) {
4427         int maxrss = getmaxrss() / 1024;
4428         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4429     }
4430
4431     return ffmpeg_exit(0);
4432 }