ffmpeg.c

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