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