git.sesse.net Git - ffmpeg/blob - ffmpeg.c

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