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

   1 /*
   2  * ffmpeg main
   3  * Copyright (c) 2000-2003 Fabrice Bellard
   4  *
   5  * This file is part of 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, "");
 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_bits_per_sample_fmt(enc->sample_fmt)/8;
 814     int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
 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_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
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_bits_per_sample_fmt(enc->sample_fmt) >> 3;
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                 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2288                     codec->channel_layout = 0;
2289                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2290                 icodec->request_channels = codec->channels;
2291                 ist->decoding_needed = 1;
2292                 ost->encoding_needed = 1;
2293                 ost->resample_sample_fmt  = icodec->sample_fmt;
2294                 ost->resample_sample_rate = icodec->sample_rate;
2295                 ost->resample_channels    = icodec->channels;
2296                 break;
2297             case AVMEDIA_TYPE_VIDEO:
2298                 if (codec->pix_fmt == PIX_FMT_NONE)
2299                     codec->pix_fmt = icodec->pix_fmt;
2300                 choose_pixel_fmt(ost->st, ost->enc);
2301
2302                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2303                     fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2304                     ffmpeg_exit(1);
2305                 }
2306                 ost->video_resample = codec->width   != icodec->width  ||
2307                                       codec->height  != icodec->height ||
2308                                       codec->pix_fmt != icodec->pix_fmt;
2309                 if (ost->video_resample) {
2310                     codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2311                 }
2312                 if (!codec->width || !codec->height) {
2313                     codec->width  = icodec->width;
2314                     codec->height = icodec->height;
2315                 }
2316                 ost->resample_height = icodec->height;
2317                 ost->resample_width  = icodec->width;
2318                 ost->resample_pix_fmt= icodec->pix_fmt;
2319                 ost->encoding_needed = 1;
2320                 ist->decoding_needed = 1;
2321
2322                 if (!ost->frame_rate.num)
2323                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2324                 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2325                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2326                     ost->frame_rate = ost->enc->supported_framerates[idx];
2327                 }
2328                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2329                 if(   av_q2d(codec->time_base) < 0.001 && video_sync_method
2330                    && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2331                     av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2332                                                "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2333                 }
2334
2335 #if CONFIG_AVFILTER
2336                 if (configure_video_filters(ist, ost)) {
2337                     fprintf(stderr, "Error opening filters!\n");
2338                     exit(1);
2339                 }
2340 #endif
2341                 break;
2342             case AVMEDIA_TYPE_SUBTITLE:
2343                 ost->encoding_needed = 1;
2344                 ist->decoding_needed = 1;
2345                 break;
2346             default:
2347                 abort();
2348                 break;
2349             }
2350             /* two pass mode */
2351             if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2352                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2353                 char logfilename[1024];
2354                 FILE *f;
2355
2356                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2357                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2358                          i);
2359                 if (codec->flags & CODEC_FLAG_PASS1) {
2360                     f = fopen(logfilename, "wb");
2361                     if (!f) {
2362                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2363                         ffmpeg_exit(1);
2364                     }
2365                     ost->logfile = f;
2366                 } else {
2367                     char  *logbuffer;
2368                     size_t logbuffer_size;
2369                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2370                         fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2371                         ffmpeg_exit(1);
2372                     }
2373                     codec->stats_in = logbuffer;
2374                 }
2375             }
2376         }
2377         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2378             /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2379             int size= codec->width * codec->height;
2380             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2381         }
2382     }
2383
2384     if (!bit_buffer)
2385         bit_buffer = av_malloc(bit_buffer_size);
2386     if (!bit_buffer) {
2387         fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2388                 bit_buffer_size);
2389         ret = AVERROR(ENOMEM);
2390         goto fail;
2391     }
2392
2393     /* open each encoder */
2394     for(i=0;i<nb_ostreams;i++) {
2395         ost = ost_table[i];
2396         if (ost->encoding_needed) {
2397             AVCodec *codec = ost->enc;
2398             AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2399             if (!codec) {
2400                 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2401                          ost->st->codec->codec_id, ost->file_index, ost->index);
2402                 ret = AVERROR(EINVAL);
2403                 goto dump_format;
2404             }
2405             if (dec->subtitle_header) {
2406                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2407                 if (!ost->st->codec->subtitle_header) {
2408                     ret = AVERROR(ENOMEM);
2409                     goto dump_format;
2410                 }
2411                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2412                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2413             }
2414             if (avcodec_open(ost->st->codec, codec) < 0) {
2415                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2416                         ost->file_index, ost->index);
2417                 ret = AVERROR(EINVAL);
2418                 goto dump_format;
2419             }
2420             extra_size += ost->st->codec->extradata_size;
2421         }
2422     }
2423
2424     /* open each decoder */
2425     for (i = 0; i < nb_input_streams; i++) {
2426         ist = &input_streams[i];
2427         if (ist->decoding_needed) {
2428             AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2429             if (!codec)
2430                 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2431             if (!codec) {
2432                 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2433                         ist->st->codec->codec_id, ist->file_index, ist->st->index);
2434                 ret = AVERROR(EINVAL);
2435                 goto dump_format;
2436             }
2437             if (avcodec_open(ist->st->codec, codec) < 0) {
2438                 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2439                         ist->file_index, ist->st->index);
2440                 ret = AVERROR(EINVAL);
2441                 goto dump_format;
2442             }
2443             //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2444             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2445         }
2446     }
2447
2448     /* init pts */
2449     for (i = 0; i < nb_input_streams; i++) {
2450         AVStream *st;
2451         ist = &input_streams[i];
2452         st= ist->st;
2453         ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2454         ist->next_pts = AV_NOPTS_VALUE;
2455         ist->is_start = 1;
2456     }
2457
2458     /* set meta data information from input file if required */
2459     for (i=0;i<nb_meta_data_maps;i++) {
2460         AVFormatContext *files[2];
2461         AVDictionary    **meta[2];
2462         int j;
2463
2464 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2465         if ((index) < 0 || (index) >= (nb_elems)) {\
2466             snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2467                      (desc), (index));\
2468             ret = AVERROR(EINVAL);\
2469             goto dump_format;\
2470         }
2471
2472         int out_file_index = meta_data_maps[i][0].file;
2473         int in_file_index = meta_data_maps[i][1].file;
2474         if (in_file_index < 0 || out_file_index < 0)
2475             continue;
2476         METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2477         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2478
2479         files[0] = output_files[out_file_index];
2480         files[1] = input_files[in_file_index].ctx;
2481
2482         for (j = 0; j < 2; j++) {
2483             AVMetaDataMap *map = &meta_data_maps[i][j];
2484
2485             switch (map->type) {
2486             case 'g':
2487                 meta[j] = &files[j]->metadata;
2488                 break;
2489             case 's':
2490                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2491                 meta[j] = &files[j]->streams[map->index]->metadata;
2492                 break;
2493             case 'c':
2494                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2495                 meta[j] = &files[j]->chapters[map->index]->metadata;
2496                 break;
2497             case 'p':
2498                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2499                 meta[j] = &files[j]->programs[map->index]->metadata;
2500                 break;
2501             }
2502         }
2503
2504         av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
2505     }
2506
2507     /* copy global metadata by default */
2508     if (metadata_global_autocopy) {
2509
2510         for (i = 0; i < nb_output_files; i++)
2511             av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2512                          AV_DICT_DONT_OVERWRITE);
2513     }
2514
2515     /* copy chapters according to chapter maps */
2516     for (i = 0; i < nb_chapter_maps; i++) {
2517         int infile  = chapter_maps[i].in_file;
2518         int outfile = chapter_maps[i].out_file;
2519
2520         if (infile < 0 || outfile < 0)
2521             continue;
2522         if (infile >= nb_input_files) {
2523             snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2524             ret = AVERROR(EINVAL);
2525             goto dump_format;
2526         }
2527         if (outfile >= nb_output_files) {
2528             snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2529             ret = AVERROR(EINVAL);
2530             goto dump_format;
2531         }
2532         copy_chapters(infile, outfile);
2533     }
2534
2535     /* copy chapters from the first input file that has them*/
2536     if (!nb_chapter_maps)
2537         for (i = 0; i < nb_input_files; i++) {
2538             if (!input_files[i].ctx->nb_chapters)
2539                 continue;
2540
2541             for (j = 0; j < nb_output_files; j++)
2542                 if ((ret = copy_chapters(i, j)) < 0)
2543                     goto dump_format;
2544             break;
2545         }
2546
2547     /* open files and write file headers */
2548     for(i=0;i<nb_output_files;i++) {
2549         os = output_files[i];
2550         if (av_write_header(os) < 0) {
2551             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2552             ret = AVERROR(EINVAL);
2553             goto dump_format;
2554         }
2555         if (strcmp(output_files[i]->oformat->name, "rtp")) {
2556             want_sdp = 0;
2557         }
2558     }
2559
2560  dump_format:
2561     /* dump the file output parameters - cannot be done before in case
2562        of stream copy */
2563     for(i=0;i<nb_output_files;i++) {
2564         av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2565     }
2566
2567     /* dump the stream mapping */
2568     if (verbose >= 0) {
2569         fprintf(stderr, "Stream mapping:\n");
2570         for(i=0;i<nb_ostreams;i++) {
2571             ost = ost_table[i];
2572             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2573                     input_streams[ost->source_index].file_index,
2574                     input_streams[ost->source_index].st->index,
2575                     ost->file_index,
2576                     ost->index);
2577             if (ost->sync_ist != &input_streams[ost->source_index])
2578                 fprintf(stderr, " [sync #%d.%d]",
2579                         ost->sync_ist->file_index,
2580                         ost->sync_ist->st->index);
2581             fprintf(stderr, "\n");
2582         }
2583     }
2584
2585     if (ret) {
2586         fprintf(stderr, "%s\n", error);
2587         goto fail;
2588     }
2589
2590     if (want_sdp) {
2591         print_sdp(output_files, nb_output_files);
2592     }
2593
2594     if (!using_stdin) {
2595         if(verbose >= 0)
2596             fprintf(stderr, "Press [q] to stop, [?] for help\n");
2597         avio_set_interrupt_cb(decode_interrupt_cb);
2598     }
2599     term_init();
2600
2601     timer_start = av_gettime();
2602
2603     for(; received_sigterm == 0;) {
2604         int file_index, ist_index;
2605         AVPacket pkt;
2606         double ipts_min;
2607         double opts_min;
2608
2609     redo:
2610         ipts_min= 1e100;
2611         opts_min= 1e100;
2612         /* if 'q' pressed, exits */
2613         if (!using_stdin) {
2614             if (q_pressed)
2615                 break;
2616             /* read_key() returns 0 on EOF */
2617             key = read_key();
2618             if (key == 'q')
2619                 break;
2620             if (key == '+') verbose++;
2621             if (key == '-') verbose--;
2622             if (key == 's') qp_hist     ^= 1;
2623             if (key == 'h'){
2624                 if (do_hex_dump){
2625                     do_hex_dump = do_pkt_dump = 0;
2626                 } else if(do_pkt_dump){
2627                     do_hex_dump = 1;
2628                 } else
2629                     do_pkt_dump = 1;
2630                 av_log_set_level(AV_LOG_DEBUG);
2631             }
2632             if (key == 'd' || key == 'D'){
2633                 int debug=0;
2634                 if(key == 'D') {
2635                     debug = input_streams[0].st->codec->debug<<1;
2636                     if(!debug) debug = 1;
2637                     while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2638                         debug += debug;
2639                 }else
2640                     scanf("%d", &debug);
2641                 for(i=0;i<nb_input_streams;i++) {
2642                     input_streams[i].st->codec->debug = debug;
2643                 }
2644                 for(i=0;i<nb_ostreams;i++) {
2645                     ost = ost_table[i];
2646                     ost->st->codec->debug = debug;
2647                 }
2648                 if(debug) av_log_set_level(AV_LOG_DEBUG);
2649                 fprintf(stderr,"debug=%d\n", debug);
2650             }
2651             if (key == '?'){
2652                 fprintf(stderr, "key    function\n"
2653                                 "?      show this help\n"
2654                                 "+      increase verbosity\n"
2655                                 "-      decrease verbosity\n"
2656                                 "D      cycle through available debug modes\n"
2657                                 "h      dump packets/hex press to cycle through the 3 states\n"
2658                                 "q      quit\n"
2659                                 "s      Show QP histogram\n"
2660                 );
2661             }
2662         }
2663
2664         /* select the stream that we must read now by looking at the
2665            smallest output pts */
2666         file_index = -1;
2667         for(i=0;i<nb_ostreams;i++) {
2668             double ipts, opts;
2669             ost = ost_table[i];
2670             os = output_files[ost->file_index];
2671             ist = &input_streams[ost->source_index];
2672             if(ist->is_past_recording_time || no_packet[ist->file_index])
2673                 continue;
2674                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2675             ipts = (double)ist->pts;
2676             if (!input_files[ist->file_index].eof_reached){
2677                 if(ipts < ipts_min) {
2678                     ipts_min = ipts;
2679                     if(input_sync ) file_index = ist->file_index;
2680                 }
2681                 if(opts < opts_min) {
2682                     opts_min = opts;
2683                     if(!input_sync) file_index = ist->file_index;
2684                 }
2685             }
2686             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2687                 file_index= -1;
2688                 break;
2689             }
2690         }
2691         /* if none, if is finished */
2692         if (file_index < 0) {
2693             if(no_packet_count){
2694                 no_packet_count=0;
2695                 memset(no_packet, 0, sizeof(no_packet));
2696                 usleep(10000);
2697                 continue;
2698             }
2699             break;
2700         }
2701
2702         /* finish if limit size exhausted */
2703         if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2704             break;
2705
2706         /* read a frame from it and output it in the fifo */
2707         is = input_files[file_index].ctx;
2708         ret= av_read_frame(is, &pkt);
2709         if(ret == AVERROR(EAGAIN)){
2710             no_packet[file_index]=1;
2711             no_packet_count++;
2712             continue;
2713         }
2714         if (ret < 0) {
2715             input_files[file_index].eof_reached = 1;
2716             if (opt_shortest)
2717                 break;
2718             else
2719                 continue;
2720         }
2721
2722         no_packet_count=0;
2723         memset(no_packet, 0, sizeof(no_packet));
2724
2725         if (do_pkt_dump) {
2726             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2727                              is->streams[pkt.stream_index]);
2728         }
2729         /* the following test is needed in case new streams appear
2730            dynamically in stream : we ignore them */
2731         if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
2732             goto discard_packet;
2733         ist_index = input_files[file_index].ist_index + pkt.stream_index;
2734         ist = &input_streams[ist_index];
2735         if (ist->discard)
2736             goto discard_packet;
2737
2738         if (pkt.dts != AV_NOPTS_VALUE)
2739             pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2740         if (pkt.pts != AV_NOPTS_VALUE)
2741             pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2742
2743         if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2744             && input_files_ts_scale[file_index][pkt.stream_index]){
2745             if(pkt.pts != AV_NOPTS_VALUE)
2746                 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2747             if(pkt.dts != AV_NOPTS_VALUE)
2748                 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2749         }
2750
2751 //        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);
2752         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2753             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2754             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2755             int64_t delta= pkt_dts - ist->next_pts;
2756             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2757                 input_files_ts_offset[ist->file_index]-= delta;
2758                 if (verbose > 2)
2759                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2760                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2761                 if(pkt.pts != AV_NOPTS_VALUE)
2762                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2763             }
2764         }
2765
2766         /* finish if recording time exhausted */
2767         if (recording_time != INT64_MAX &&
2768             (pkt.pts != AV_NOPTS_VALUE ?
2769                 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000})
2770                     :
2771                 av_compare_ts(ist->pts, AV_TIME_BASE_Q, recording_time + start_time, (AVRational){1, 1000000})
2772             )>= 0) {
2773             ist->is_past_recording_time = 1;
2774             goto discard_packet;
2775         }
2776
2777         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2778         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2779
2780             if (verbose >= 0)
2781                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2782                         ist->file_index, ist->st->index);
2783             if (exit_on_error)
2784                 ffmpeg_exit(1);
2785             av_free_packet(&pkt);
2786             goto redo;
2787         }
2788
2789     discard_packet:
2790         av_free_packet(&pkt);
2791
2792         /* dump report by using the output first video and audio streams */
2793         print_report(output_files, ost_table, nb_ostreams, 0);
2794     }
2795
2796     /* at the end of stream, we must flush the decoder buffers */
2797     for (i = 0; i < nb_input_streams; i++) {
2798         ist = &input_streams[i];
2799         if (ist->decoding_needed) {
2800             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2801         }
2802     }
2803
2804     term_exit();
2805
2806     /* write the trailer if needed and close file */
2807     for(i=0;i<nb_output_files;i++) {
2808         os = output_files[i];
2809         av_write_trailer(os);
2810     }
2811
2812     /* dump report by using the first video and audio streams */
2813     print_report(output_files, ost_table, nb_ostreams, 1);
2814
2815     /* close each encoder */
2816     for(i=0;i<nb_ostreams;i++) {
2817         ost = ost_table[i];
2818         if (ost->encoding_needed) {
2819             av_freep(&ost->st->codec->stats_in);
2820             avcodec_close(ost->st->codec);
2821         }
2822 #if CONFIG_AVFILTER
2823         avfilter_graph_free(&ost->graph);
2824 #endif
2825     }
2826
2827     /* close each decoder */
2828     for (i = 0; i < nb_input_streams; i++) {
2829         ist = &input_streams[i];
2830         if (ist->decoding_needed) {
2831             avcodec_close(ist->st->codec);
2832         }
2833     }
2834
2835     /* finished ! */
2836     ret = 0;
2837
2838  fail:
2839     av_freep(&bit_buffer);
2840
2841     if (ost_table) {
2842         for(i=0;i<nb_ostreams;i++) {
2843             ost = ost_table[i];
2844             if (ost) {
2845                 if (ost->st->stream_copy)
2846                     av_freep(&ost->st->codec->extradata);
2847                 if (ost->logfile) {
2848                     fclose(ost->logfile);
2849                     ost->logfile = NULL;
2850                 }
2851                 av_fifo_free(ost->fifo); /* works even if fifo is not
2852                                              initialized but set to zero */
2853                 av_freep(&ost->st->codec->subtitle_header);
2854                 av_free(ost->resample_frame.data[0]);
2855                 av_free(ost->forced_kf_pts);
2856                 if (ost->video_resample)
2857                     sws_freeContext(ost->img_resample_ctx);
2858                 if (ost->resample)
2859                     audio_resample_close(ost->resample);
2860                 if (ost->reformat_ctx)
2861                     av_audio_convert_free(ost->reformat_ctx);
2862                 av_free(ost);
2863             }
2864         }
2865         av_free(ost_table);
2866     }
2867     return ret;
2868 }
2869
2870 static int opt_format(const char *opt, const char *arg)
2871 {
2872     last_asked_format = arg;
2873     return 0;
2874 }
2875
2876 static int opt_video_rc_override_string(const char *opt, const char *arg)
2877 {
2878     video_rc_override_string = arg;
2879     return 0;
2880 }
2881
2882 static int opt_me_threshold(const char *opt, const char *arg)
2883 {
2884     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2885     return 0;
2886 }
2887
2888 static int opt_verbose(const char *opt, const char *arg)
2889 {
2890     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2891     return 0;
2892 }
2893
2894 static int opt_frame_rate(const char *opt, const char *arg)
2895 {
2896     if (av_parse_video_rate(&frame_rate, arg) < 0) {
2897         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2898         ffmpeg_exit(1);
2899     }
2900     return 0;
2901 }
2902
2903 static int opt_bitrate(const char *opt, const char *arg)
2904 {
2905     int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2906
2907     opt_default(opt, arg);
2908
2909     if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2910         fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2911
2912     return 0;
2913 }
2914
2915 static int opt_frame_crop(const char *opt, const char *arg)
2916 {
2917     fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2918     return AVERROR(EINVAL);
2919 }
2920
2921 static int opt_frame_size(const char *opt, const char *arg)
2922 {
2923     if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2924         fprintf(stderr, "Incorrect frame size\n");
2925         return AVERROR(EINVAL);
2926     }
2927     return 0;
2928 }
2929
2930 static int opt_pad(const char *opt, const char *arg) {
2931     fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2932     return -1;
2933 }
2934
2935 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2936 {
2937     if (strcmp(arg, "list")) {
2938         frame_pix_fmt = av_get_pix_fmt(arg);
2939         if (frame_pix_fmt == PIX_FMT_NONE) {
2940             fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2941             return AVERROR(EINVAL);
2942         }
2943     } else {
2944         show_pix_fmts();
2945         ffmpeg_exit(0);
2946     }
2947     return 0;
2948 }
2949
2950 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2951 {
2952     int x = 0, y = 0;
2953     double ar = 0;
2954     const char *p;
2955     char *end;
2956
2957     p = strchr(arg, ':');
2958     if (p) {
2959         x = strtol(arg, &end, 10);
2960         if (end == p)
2961             y = strtol(end+1, &end, 10);
2962         if (x > 0 && y > 0)
2963             ar = (double)x / (double)y;
2964     } else
2965         ar = strtod(arg, NULL);
2966
2967     if (!ar) {
2968         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2969         return AVERROR(EINVAL);
2970     }
2971     frame_aspect_ratio = ar;
2972     return 0;
2973 }
2974
2975 static int opt_metadata(const char *opt, const char *arg)
2976 {
2977     char *mid= strchr(arg, '=');
2978
2979     if(!mid){
2980         fprintf(stderr, "Missing =\n");
2981         ffmpeg_exit(1);
2982     }
2983     *mid++= 0;
2984
2985     av_dict_set(&metadata, arg, mid, 0);
2986
2987     return 0;
2988 }
2989
2990 static int opt_qscale(const char *opt, const char *arg)
2991 {
2992     video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2993     if (video_qscale <= 0 || video_qscale > 255) {
2994         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2995         return AVERROR(EINVAL);
2996     }
2997     return 0;
2998 }
2999
3000 static int opt_top_field_first(const char *opt, const char *arg)
3001 {
3002     top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
3003     opt_default(opt, arg);
3004     return 0;
3005 }
3006
3007 static int opt_thread_count(const char *opt, const char *arg)
3008 {
3009     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3010 #if !HAVE_THREADS
3011     if (verbose >= 0)
3012         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
3013 #endif
3014     return 0;
3015 }
3016
3017 static int opt_audio_sample_fmt(const char *opt, const char *arg)
3018 {
3019     if (strcmp(arg, "list")) {
3020         audio_sample_fmt = av_get_sample_fmt(arg);
3021         if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
3022             av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
3023             return AVERROR(EINVAL);
3024         }
3025     } else {
3026         int i;
3027         char fmt_str[128];
3028         for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
3029             printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
3030         ffmpeg_exit(0);
3031     }
3032     return 0;
3033 }
3034
3035 static int opt_audio_rate(const char *opt, const char *arg)
3036 {
3037     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3038     return 0;
3039 }
3040
3041 static int opt_audio_channels(const char *opt, const char *arg)
3042 {
3043     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3044     return 0;
3045 }
3046
3047 static int opt_video_channel(const char *opt, const char *arg)
3048 {
3049     video_channel = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3050     return 0;
3051 }
3052
3053 static int opt_video_standard(const char *opt, const char *arg)
3054 {
3055     video_standard = av_strdup(arg);
3056     return 0;
3057 }
3058
3059 static int opt_codec(const char *opt, const char *arg)
3060 {
3061     int *pstream_copy; char **pcodec_name; enum AVMediaType codec_type;
3062
3063     if      (!strcmp(opt, "acodec")) { pstream_copy = &audio_stream_copy;    pcodec_name = &audio_codec_name;    codec_type = AVMEDIA_TYPE_AUDIO;    }
3064     else if (!strcmp(opt, "vcodec")) { pstream_copy = &video_stream_copy;    pcodec_name = &video_codec_name;    codec_type = AVMEDIA_TYPE_VIDEO;    }
3065     else if (!strcmp(opt, "scodec")) { pstream_copy = &subtitle_stream_copy; pcodec_name = &subtitle_codec_name; codec_type = AVMEDIA_TYPE_SUBTITLE; }
3066     else if (!strcmp(opt, "dcodec")) { pstream_copy = &data_stream_copy;     pcodec_name = &data_codec_name;     codec_type = AVMEDIA_TYPE_DATA;     }
3067
3068     av_freep(pcodec_name);
3069     if (!strcmp(arg, "copy")) {
3070         *pstream_copy = 1;
3071     } else {
3072         *pcodec_name = av_strdup(arg);
3073     }
3074     return 0;
3075 }
3076
3077 static int opt_codec_tag(const char *opt, const char *arg)
3078 {
3079     char *tail;
3080     uint32_t *codec_tag;
3081
3082     codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
3083                 !strcmp(opt, "vtag") ? &video_codec_tag :
3084                 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
3085     if (!codec_tag)
3086         return -1;
3087
3088     *codec_tag = strtol(arg, &tail, 0);
3089     if (!tail || *tail)
3090         *codec_tag = AV_RL32(arg);
3091
3092     return 0;
3093 }
3094
3095 static int opt_map(const char *opt, const char *arg)
3096 {
3097     AVStreamMap *m;
3098     char *p;
3099
3100     stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
3101     m = &stream_maps[nb_stream_maps-1];
3102
3103     m->file_index = strtol(arg, &p, 0);
3104     if (*p)
3105         p++;
3106
3107     m->stream_index = strtol(p, &p, 0);
3108     if (*p) {
3109         p++;
3110         m->sync_file_index = strtol(p, &p, 0);
3111         if (*p)
3112             p++;
3113         m->sync_stream_index = strtol(p, &p, 0);
3114     } else {
3115         m->sync_file_index = m->file_index;
3116         m->sync_stream_index = m->stream_index;
3117     }
3118     return 0;
3119 }
3120
3121 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3122 {
3123     *endptr = arg;
3124     if (*arg == ',') {
3125         *type = *(++arg);
3126         switch (*arg) {
3127         case 'g':
3128             break;
3129         case 's':
3130         case 'c':
3131         case 'p':
3132             *index = strtol(++arg, endptr, 0);
3133             break;
3134         default:
3135             fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3136             ffmpeg_exit(1);
3137         }
3138     } else
3139         *type = 'g';
3140 }
3141
3142 static int opt_map_metadata(const char *opt, const char *arg)
3143 {
3144     AVMetaDataMap *m, *m1;
3145     char *p;
3146
3147     meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3148                                 &nb_meta_data_maps, nb_meta_data_maps + 1);
3149
3150     m = &meta_data_maps[nb_meta_data_maps - 1][0];
3151     m->file = strtol(arg, &p, 0);
3152     parse_meta_type(p, &m->type, &m->index, &p);
3153     if (*p)
3154         p++;
3155
3156     m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3157     m1->file = strtol(p, &p, 0);
3158     parse_meta_type(p, &m1->type, &m1->index, &p);
3159
3160     if (m->type == 'g' || m1->type == 'g')
3161         metadata_global_autocopy = 0;
3162     if (m->type == 's' || m1->type == 's')
3163         metadata_streams_autocopy = 0;
3164     if (m->type == 'c' || m1->type == 'c')
3165         metadata_chapters_autocopy = 0;
3166
3167     return 0;
3168 }
3169
3170 static int opt_map_meta_data(const char *opt, const char *arg)
3171 {
3172     fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3173                     "Use -map_metadata instead.\n");
3174     return opt_map_metadata(opt, arg);
3175 }
3176
3177 static int opt_map_chapters(const char *opt, const char *arg)
3178 {
3179     AVChapterMap *c;
3180     char *p;
3181
3182     chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3183                               nb_chapter_maps + 1);
3184     c = &chapter_maps[nb_chapter_maps - 1];
3185     c->out_file = strtol(arg, &p, 0);
3186     if (*p)
3187         p++;
3188
3189     c->in_file = strtol(p, &p, 0);
3190     return 0;
3191 }
3192
3193 static int opt_input_ts_scale(const char *opt, const char *arg)
3194 {
3195     unsigned int stream;
3196     double scale;
3197     char *p;
3198
3199     stream = strtol(arg, &p, 0);
3200     if (*p)
3201         p++;
3202     scale= strtod(p, &p);
3203
3204     if(stream >= MAX_STREAMS)
3205         ffmpeg_exit(1);
3206
3207     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);
3208     input_files_ts_scale[nb_input_files][stream]= scale;
3209     return 0;
3210 }
3211
3212 static int opt_recording_time(const char *opt, const char *arg)
3213 {
3214     recording_time = parse_time_or_die(opt, arg, 1);
3215     return 0;
3216 }
3217
3218 static int opt_start_time(const char *opt, const char *arg)
3219 {
3220     start_time = parse_time_or_die(opt, arg, 1);
3221     return 0;
3222 }
3223
3224 static int opt_recording_timestamp(const char *opt, const char *arg)
3225 {
3226     recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3227     return 0;
3228 }
3229
3230 static int opt_input_ts_offset(const char *opt, const char *arg)
3231 {
3232     input_ts_offset = parse_time_or_die(opt, arg, 1);
3233     return 0;
3234 }
3235
3236 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3237 {
3238     const char *codec_string = encoder ? "encoder" : "decoder";
3239     AVCodec *codec;
3240
3241     if(!name)
3242         return CODEC_ID_NONE;
3243     codec = encoder ?
3244         avcodec_find_encoder_by_name(name) :
3245         avcodec_find_decoder_by_name(name);
3246     if(!codec) {
3247         fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3248         ffmpeg_exit(1);
3249     }
3250     if(codec->type != type) {
3251         fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3252         ffmpeg_exit(1);
3253     }
3254     if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3255        strict > FF_COMPLIANCE_EXPERIMENTAL) {
3256         fprintf(stderr, "%s '%s' is experimental and might produce bad "
3257                 "results.\nAdd '-strict experimental' if you want to use it.\n",
3258                 codec_string, codec->name);
3259         codec = encoder ?
3260             avcodec_find_encoder(codec->id) :
3261             avcodec_find_decoder(codec->id);
3262         if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3263             fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3264                     codec_string, codec->name);
3265         ffmpeg_exit(1);
3266     }
3267     return codec->id;
3268 }
3269
3270 static int opt_input_file(const char *opt, const char *filename)
3271 {
3272     AVFormatContext *ic;
3273     AVFormatParameters params, *ap = &params;
3274     AVInputFormat *file_iformat = NULL;
3275     int err, i, ret, rfps, rfps_base;
3276     int64_t timestamp;
3277
3278     if (last_asked_format) {
3279         if (!(file_iformat = av_find_input_format(last_asked_format))) {
3280             fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3281             ffmpeg_exit(1);
3282         }
3283         last_asked_format = NULL;
3284     }
3285
3286     if (!strcmp(filename, "-"))
3287         filename = "pipe:";
3288
3289     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3290                     !strcmp(filename, "/dev/stdin");
3291
3292     /* get default parameters from command line */
3293     ic = avformat_alloc_context();
3294     if (!ic) {
3295         print_error(filename, AVERROR(ENOMEM));
3296         ffmpeg_exit(1);
3297     }
3298
3299     memset(ap, 0, sizeof(*ap));
3300     ap->prealloced_context = 1;
3301     ap->sample_rate = audio_sample_rate;
3302     ap->channels = audio_channels;
3303     ap->time_base.den = frame_rate.num;
3304     ap->time_base.num = frame_rate.den;
3305     ap->width = frame_width;
3306     ap->height = frame_height;
3307     ap->pix_fmt = frame_pix_fmt;
3308    // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3309     ap->channel = video_channel;
3310     ap->standard = video_standard;
3311
3312     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3313
3314     ic->video_codec_id   =
3315         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3316                           avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3317     ic->audio_codec_id   =
3318         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3319                           avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3320     ic->subtitle_codec_id=
3321         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3322                           avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3323     ic->flags |= AVFMT_FLAG_NONBLOCK | AVFMT_FLAG_PRIV_OPT;
3324
3325     /* open the input file with generic libav function */
3326     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3327     if(err >= 0){
3328         set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3329         err = av_demuxer_open(ic, ap);
3330         if(err < 0)
3331             avformat_free_context(ic);
3332     }
3333     if (err < 0) {
3334         print_error(filename, err);
3335         ffmpeg_exit(1);
3336     }
3337     if(opt_programid) {
3338         int i, j;
3339         int found=0;
3340         for(i=0; i<ic->nb_streams; i++){
3341             ic->streams[i]->discard= AVDISCARD_ALL;
3342         }
3343         for(i=0; i<ic->nb_programs; i++){
3344             AVProgram *p= ic->programs[i];
3345             if(p->id != opt_programid){
3346                 p->discard = AVDISCARD_ALL;
3347             }else{
3348                 found=1;
3349                 for(j=0; j<p->nb_stream_indexes; j++){
3350                     ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3351                 }
3352             }
3353         }
3354         if(!found){
3355             fprintf(stderr, "Specified program id not found\n");
3356             ffmpeg_exit(1);
3357         }
3358         opt_programid=0;
3359     }
3360
3361     ic->loop_input = loop_input;
3362
3363     /* If not enough info to get the stream parameters, we decode the
3364        first frames to get it. (used in mpeg case for example) */
3365     ret = av_find_stream_info(ic);
3366     if (ret < 0 && verbose >= 0) {
3367         fprintf(stderr, "%s: could not find codec parameters\n", filename);
3368         av_close_input_file(ic);
3369         ffmpeg_exit(1);
3370     }
3371
3372     timestamp = start_time;
3373     /* add the stream start time */
3374     if (ic->start_time != AV_NOPTS_VALUE)
3375         timestamp += ic->start_time;
3376
3377     /* if seeking requested, we execute it */
3378     if (start_time != 0) {
3379         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3380         if (ret < 0) {
3381             fprintf(stderr, "%s: could not seek to position %0.3f\n",
3382                     filename, (double)timestamp / AV_TIME_BASE);
3383         }
3384         /* reset seek info */
3385         start_time = 0;
3386     }
3387
3388     /* update the current parameters so that they match the one of the input stream */
3389     for(i=0;i<ic->nb_streams;i++) {
3390         AVStream *st = ic->streams[i];
3391         AVCodecContext *dec = st->codec;
3392         AVInputStream *ist;
3393
3394         dec->thread_count = thread_count;
3395         input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3396
3397         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3398         ist = &input_streams[nb_input_streams - 1];
3399         ist->st = st;
3400         ist->file_index = nb_input_files;
3401         ist->discard = 1;
3402
3403         switch (dec->codec_type) {
3404         case AVMEDIA_TYPE_AUDIO:
3405             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3406             if(!input_codecs[nb_input_codecs-1])
3407                 input_codecs[nb_input_codecs-1] = avcodec_find_decoder(dec->codec_id);
3408             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]);
3409             channel_layout    = dec->channel_layout;
3410             audio_sample_fmt  = dec->sample_fmt;
3411             if(audio_disable)
3412                 st->discard= AVDISCARD_ALL;
3413             break;
3414         case AVMEDIA_TYPE_VIDEO:
3415             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3416             if(!input_codecs[nb_input_codecs-1])
3417                 input_codecs[nb_input_codecs-1] = avcodec_find_decoder(dec->codec_id);
3418             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]);
3419             rfps      = ic->streams[i]->r_frame_rate.num;
3420             rfps_base = ic->streams[i]->r_frame_rate.den;
3421             if (dec->lowres) {
3422                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3423                 dec->height >>= dec->lowres;
3424                 dec->width  >>= dec->lowres;
3425             }
3426             if(me_threshold)
3427                 dec->debug |= FF_DEBUG_MV;
3428
3429             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3430
3431                 if (verbose >= 0)
3432                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3433                             i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3434
3435                     (float)rfps / rfps_base, rfps, rfps_base);
3436             }
3437
3438             if(video_disable)
3439                 st->discard= AVDISCARD_ALL;
3440             else if(video_discard)
3441                 st->discard= video_discard;
3442             break;
3443         case AVMEDIA_TYPE_DATA:
3444             break;
3445         case AVMEDIA_TYPE_SUBTITLE:
3446             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3447             if(!input_codecs[nb_input_codecs-1])
3448                 input_codecs[nb_input_codecs-1] = avcodec_find_decoder(dec->codec_id);
3449             if(subtitle_disable)
3450                 st->discard = AVDISCARD_ALL;
3451             break;
3452         case AVMEDIA_TYPE_ATTACHMENT:
3453         case AVMEDIA_TYPE_UNKNOWN:
3454             break;
3455         default:
3456             abort();
3457         }
3458     }
3459
3460     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3461     /* dump the file content */
3462     if (verbose >= 0)
3463         av_dump_format(ic, nb_input_files, filename, 0);
3464
3465     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3466     input_files[nb_input_files - 1].ctx        = ic;
3467     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3468
3469     top_field_first = -1;
3470     video_channel = 0;
3471     frame_rate    = (AVRational){0, 0};
3472     frame_pix_fmt = PIX_FMT_NONE;
3473     frame_height = 0;
3474     frame_width  = 0;
3475     audio_sample_rate = 0;
3476     audio_channels    = 0;
3477
3478     av_freep(&video_codec_name);
3479     av_freep(&audio_codec_name);
3480     av_freep(&subtitle_codec_name);
3481     uninit_opts();
3482     init_opts();
3483     return 0;
3484 }
3485
3486 static void check_inputs(int *has_video_ptr,
3487                          int *has_audio_ptr,
3488                          int *has_subtitle_ptr,
3489                          int *has_data_ptr)
3490 {
3491     int has_video, has_audio, has_subtitle, has_data, i, j;
3492     AVFormatContext *ic;
3493
3494     has_video = 0;
3495     has_audio = 0;
3496     has_subtitle = 0;
3497     has_data = 0;
3498
3499     for(j=0;j<nb_input_files;j++) {
3500         ic = input_files[j].ctx;
3501         for(i=0;i<ic->nb_streams;i++) {
3502             AVCodecContext *enc = ic->streams[i]->codec;
3503             switch(enc->codec_type) {
3504             case AVMEDIA_TYPE_AUDIO:
3505                 has_audio = 1;
3506                 break;
3507             case AVMEDIA_TYPE_VIDEO:
3508                 has_video = 1;
3509                 break;
3510             case AVMEDIA_TYPE_SUBTITLE:
3511                 has_subtitle = 1;
3512                 break;
3513             case AVMEDIA_TYPE_DATA:
3514             case AVMEDIA_TYPE_ATTACHMENT:
3515             case AVMEDIA_TYPE_UNKNOWN:
3516                 has_data = 1;
3517                 break;
3518             default:
3519                 abort();
3520             }
3521         }
3522     }
3523     *has_video_ptr = has_video;
3524     *has_audio_ptr = has_audio;
3525     *has_subtitle_ptr = has_subtitle;
3526     *has_data_ptr = has_data;
3527 }
3528
3529 static void new_video_stream(AVFormatContext *oc, int file_idx)
3530 {
3531     AVStream *st;
3532     AVOutputStream *ost;
3533     AVCodecContext *video_enc;
3534     enum CodecID codec_id = CODEC_ID_NONE;
3535     AVCodec *codec= NULL;
3536
3537     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3538     if (!st) {
3539         fprintf(stderr, "Could not alloc stream\n");
3540         ffmpeg_exit(1);
3541     }
3542     ost = new_output_stream(oc, file_idx);
3543
3544     if(!video_stream_copy){
3545         if (video_codec_name) {
3546             codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3547                                          avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3548             codec = avcodec_find_encoder_by_name(video_codec_name);
3549             ost->enc = codec;
3550         } else {
3551             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3552             codec = avcodec_find_encoder(codec_id);
3553         }
3554         ost->frame_aspect_ratio = frame_aspect_ratio;
3555         frame_aspect_ratio = 0;
3556 #if CONFIG_AVFILTER
3557         ost->avfilter = vfilters;
3558         vfilters = NULL;
3559 #endif
3560     }
3561
3562     avcodec_get_context_defaults3(st->codec, codec);
3563     ost->bitstream_filters = video_bitstream_filters;
3564     video_bitstream_filters= NULL;
3565
3566     st->codec->thread_count= thread_count;
3567
3568     video_enc = st->codec;
3569
3570     if(video_codec_tag)
3571         video_enc->codec_tag= video_codec_tag;
3572
3573     if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3574         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3575         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3576     }
3577
3578     if (video_stream_copy) {
3579         st->stream_copy = 1;
3580         video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3581         video_enc->sample_aspect_ratio =
3582         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3583     } else {
3584         const char *p;
3585         int i;
3586
3587         if (frame_rate.num)
3588             ost->frame_rate = frame_rate;
3589         video_enc->codec_id = codec_id;
3590         set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3591
3592         video_enc->width = frame_width;
3593         video_enc->height = frame_height;
3594         video_enc->pix_fmt = frame_pix_fmt;
3595         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3596         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3597
3598         if (intra_only)
3599             video_enc->gop_size = 0;
3600         if (video_qscale || same_quality) {
3601             video_enc->flags |= CODEC_FLAG_QSCALE;
3602             video_enc->global_quality=
3603                 st->quality = FF_QP2LAMBDA * video_qscale;
3604         }
3605
3606         if(intra_matrix)
3607             video_enc->intra_matrix = intra_matrix;
3608         if(inter_matrix)
3609             video_enc->inter_matrix = inter_matrix;
3610
3611         p= video_rc_override_string;
3612         for(i=0; p; i++){
3613             int start, end, q;
3614             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3615             if(e!=3){
3616                 fprintf(stderr, "error parsing rc_override\n");
3617                 ffmpeg_exit(1);
3618             }
3619             video_enc->rc_override=
3620                 av_realloc(video_enc->rc_override,
3621                            sizeof(RcOverride)*(i+1));
3622             video_enc->rc_override[i].start_frame= start;
3623             video_enc->rc_override[i].end_frame  = end;
3624             if(q>0){
3625                 video_enc->rc_override[i].qscale= q;
3626                 video_enc->rc_override[i].quality_factor= 1.0;
3627             }
3628             else{
3629                 video_enc->rc_override[i].qscale= 0;
3630                 video_enc->rc_override[i].quality_factor= -q/100.0;
3631             }
3632             p= strchr(p, '/');
3633             if(p) p++;
3634         }
3635         video_enc->rc_override_count=i;
3636         if (!video_enc->rc_initial_buffer_occupancy)
3637             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3638         video_enc->me_threshold= me_threshold;
3639         video_enc->intra_dc_precision= intra_dc_precision - 8;
3640
3641         if (do_psnr)
3642             video_enc->flags|= CODEC_FLAG_PSNR;
3643
3644         /* two pass mode */
3645         if (do_pass) {
3646             if (do_pass == 1) {
3647                 video_enc->flags |= CODEC_FLAG_PASS1;
3648             } else {
3649                 video_enc->flags |= CODEC_FLAG_PASS2;
3650             }
3651         }
3652
3653         if (forced_key_frames)
3654             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3655     }
3656     if (video_language) {
3657         av_dict_set(&st->metadata, "language", video_language, 0);
3658         av_freep(&video_language);
3659     }
3660
3661     /* reset some key parameters */
3662     video_disable = 0;
3663     av_freep(&video_codec_name);
3664     av_freep(&forced_key_frames);
3665     video_stream_copy = 0;
3666     frame_pix_fmt = PIX_FMT_NONE;
3667 }
3668
3669 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3670 {
3671     AVStream *st;
3672     AVOutputStream *ost;
3673     AVCodec *codec= NULL;
3674     AVCodecContext *audio_enc;
3675     enum CodecID codec_id = CODEC_ID_NONE;
3676
3677     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3678     if (!st) {
3679         fprintf(stderr, "Could not alloc stream\n");
3680         ffmpeg_exit(1);
3681     }
3682     ost = new_output_stream(oc, file_idx);
3683
3684     if(!audio_stream_copy){
3685         if (audio_codec_name) {
3686             codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3687                                          avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3688             codec = avcodec_find_encoder_by_name(audio_codec_name);
3689             ost->enc = codec;
3690         } else {
3691             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3692             codec = avcodec_find_encoder(codec_id);
3693         }
3694     }
3695
3696     avcodec_get_context_defaults3(st->codec, codec);
3697
3698     ost->bitstream_filters = audio_bitstream_filters;
3699     audio_bitstream_filters= NULL;
3700
3701     st->codec->thread_count= thread_count;
3702
3703     audio_enc = st->codec;
3704     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3705
3706     if(audio_codec_tag)
3707         audio_enc->codec_tag= audio_codec_tag;
3708
3709     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3710         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3711         avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3712     }
3713     if (audio_stream_copy) {
3714         st->stream_copy = 1;
3715     } else {
3716         audio_enc->codec_id = codec_id;
3717         set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3718
3719         if (audio_qscale > QSCALE_NONE) {
3720             audio_enc->flags |= CODEC_FLAG_QSCALE;
3721             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3722         }
3723         if (audio_channels)
3724             audio_enc->channels = audio_channels;
3725         audio_enc->sample_fmt = audio_sample_fmt;
3726         if (audio_sample_rate)
3727             audio_enc->sample_rate = audio_sample_rate;
3728         audio_enc->channel_layout = channel_layout;
3729         choose_sample_fmt(st, codec);
3730     }
3731     if (audio_language) {
3732         av_dict_set(&st->metadata, "language", audio_language, 0);
3733         av_freep(&audio_language);
3734     }
3735
3736     /* reset some key parameters */
3737     audio_disable = 0;
3738     av_freep(&audio_codec_name);
3739     audio_stream_copy = 0;
3740 }
3741
3742 static void new_data_stream(AVFormatContext *oc, int file_idx)
3743 {
3744     AVStream *st;
3745     AVCodec *codec=NULL;
3746     AVCodecContext *data_enc;
3747
3748     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3749     if (!st) {
3750         fprintf(stderr, "Could not alloc stream\n");
3751         ffmpeg_exit(1);
3752     }
3753     new_output_stream(oc, file_idx);
3754     data_enc = st->codec;
3755     if (!data_stream_copy) {
3756         fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3757         ffmpeg_exit(1);
3758     }
3759     avcodec_get_context_defaults3(st->codec, codec);
3760
3761     data_enc->codec_type = AVMEDIA_TYPE_DATA;
3762
3763     if (data_codec_tag)
3764         data_enc->codec_tag= data_codec_tag;
3765
3766     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3767         data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3768         avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3769     }
3770     if (data_stream_copy) {
3771         st->stream_copy = 1;
3772     }
3773
3774     data_disable = 0;
3775     av_freep(&data_codec_name);
3776     data_stream_copy = 0;
3777 }
3778
3779 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3780 {
3781     AVStream *st;
3782     AVOutputStream *ost;
3783     AVCodec *codec=NULL;
3784     AVCodecContext *subtitle_enc;
3785     enum CodecID codec_id = CODEC_ID_NONE;
3786
3787     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3788     if (!st) {
3789         fprintf(stderr, "Could not alloc stream\n");
3790         ffmpeg_exit(1);
3791     }
3792     ost = new_output_stream(oc, file_idx);
3793     subtitle_enc = st->codec;
3794     if(!subtitle_stream_copy){
3795         if (subtitle_codec_name) {
3796             codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3797                                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3798             codec = avcodec_find_encoder_by_name(subtitle_codec_name);
3799             ost->enc = codec;
3800         } else {
3801             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3802             codec = avcodec_find_encoder(codec_id);
3803         }
3804     }
3805     avcodec_get_context_defaults3(st->codec, codec);
3806
3807     ost->bitstream_filters = subtitle_bitstream_filters;
3808     subtitle_bitstream_filters= NULL;
3809
3810     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3811
3812     if(subtitle_codec_tag)
3813         subtitle_enc->codec_tag= subtitle_codec_tag;
3814
3815     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3816         subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3817         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3818     }
3819     if (subtitle_stream_copy) {
3820         st->stream_copy = 1;
3821     } else {
3822         subtitle_enc->codec_id = codec_id;
3823         set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3824     }
3825
3826     if (subtitle_language) {
3827         av_dict_set(&st->metadata, "language", subtitle_language, 0);
3828         av_freep(&subtitle_language);
3829     }
3830
3831     subtitle_disable = 0;
3832     av_freep(&subtitle_codec_name);
3833     subtitle_stream_copy = 0;
3834 }
3835
3836 static int opt_new_stream(const char *opt, const char *arg)
3837 {
3838     AVFormatContext *oc;
3839     int file_idx = nb_output_files - 1;
3840     if (nb_output_files <= 0) {
3841         fprintf(stderr, "At least one output file must be specified\n");
3842         ffmpeg_exit(1);
3843     }
3844     oc = output_files[file_idx];
3845
3846     if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3847     else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3848     else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3849     else if (!strcmp(opt, "newdata"    )) new_data_stream    (oc, file_idx);
3850     else av_assert0(0);
3851     return 0;
3852 }
3853
3854 /* arg format is "output-stream-index:streamid-value". */
3855 static int opt_streamid(const char *opt, const char *arg)
3856 {
3857     int idx;
3858     char *p;
3859     char idx_str[16];
3860
3861     av_strlcpy(idx_str, arg, sizeof(idx_str));
3862     p = strchr(idx_str, ':');
3863     if (!p) {
3864         fprintf(stderr,
3865                 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3866                 arg, opt);
3867         ffmpeg_exit(1);
3868     }
3869     *p++ = '\0';
3870     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3871     streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3872     streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3873     return 0;
3874 }
3875
3876 static int opt_output_file(const char *opt, const char *filename)
3877 {
3878     AVFormatContext *oc;
3879     int err, use_video, use_audio, use_subtitle, use_data;
3880     int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3881     AVFormatParameters params, *ap = &params;
3882     AVOutputFormat *file_oformat;
3883
3884     if(nb_output_files >= FF_ARRAY_ELEMS(output_files)){
3885         fprintf(stderr, "Too many output files\n");
3886         ffmpeg_exit(1);
3887     }
3888
3889     if (!strcmp(filename, "-"))
3890         filename = "pipe:";
3891
3892     err = avformat_alloc_output_context2(&oc, NULL, last_asked_format, filename);
3893     last_asked_format = NULL;
3894     if (!oc) {
3895         print_error(filename, err);
3896         ffmpeg_exit(1);
3897     }
3898     file_oformat= oc->oformat;
3899
3900     if (!strcmp(file_oformat->name, "ffm") &&
3901         av_strstart(filename, "http:", NULL)) {
3902         /* special case for files sent to ffserver: we get the stream
3903            parameters from ffserver */
3904         int err = read_ffserver_streams(oc, filename);
3905         if (err < 0) {
3906             print_error(filename, err);
3907             ffmpeg_exit(1);
3908         }
3909     } else {
3910         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3911         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3912         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3913         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 */
3914
3915         /* disable if no corresponding type found and at least one
3916            input file */
3917         if (nb_input_files > 0) {
3918             check_inputs(&input_has_video,
3919                          &input_has_audio,
3920                          &input_has_subtitle,
3921                          &input_has_data);
3922
3923             if (!input_has_video)
3924                 use_video = 0;
3925             if (!input_has_audio)
3926                 use_audio = 0;
3927             if (!input_has_subtitle)
3928                 use_subtitle = 0;
3929             if (!input_has_data)
3930                 use_data = 0;
3931         }
3932
3933         /* manual disable */
3934         if (audio_disable)    use_audio    = 0;
3935         if (video_disable)    use_video    = 0;
3936         if (subtitle_disable) use_subtitle = 0;
3937         if (data_disable)     use_data     = 0;
3938
3939         if (use_video)    new_video_stream(oc, nb_output_files);
3940         if (use_audio)    new_audio_stream(oc, nb_output_files);
3941         if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3942         if (use_data)     new_data_stream(oc, nb_output_files);
3943
3944         oc->timestamp = recording_timestamp;
3945
3946         av_dict_copy(&oc->metadata, metadata, 0);
3947         av_dict_free(&metadata);
3948     }
3949
3950     output_files[nb_output_files++] = oc;
3951
3952     /* check filename in case of an image number is expected */
3953     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3954         if (!av_filename_number_test(oc->filename)) {
3955             print_error(oc->filename, AVERROR(EINVAL));
3956             ffmpeg_exit(1);
3957         }
3958     }
3959
3960     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3961         /* test if it already exists to avoid loosing precious files */
3962         if (!file_overwrite &&
3963             (strchr(filename, ':') == NULL ||
3964              filename[1] == ':' ||
3965              av_strstart(filename, "file:", NULL))) {
3966             if (avio_check(filename, 0) == 0) {
3967                 if (!using_stdin) {
3968                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3969                     fflush(stderr);
3970                     if (!read_yesno()) {
3971                         fprintf(stderr, "Not overwriting - exiting\n");
3972                         ffmpeg_exit(1);
3973                     }
3974                 }
3975                 else {
3976                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3977                     ffmpeg_exit(1);
3978                 }
3979             }
3980         }
3981
3982         /* open the file */
3983         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3984             print_error(filename, err);
3985             ffmpeg_exit(1);
3986         }
3987     }
3988
3989     memset(ap, 0, sizeof(*ap));
3990     if (av_set_parameters(oc, ap) < 0) {
3991         fprintf(stderr, "%s: Invalid encoding parameters\n",
3992                 oc->filename);
3993         ffmpeg_exit(1);
3994     }
3995
3996     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3997     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3998     oc->loop_output = loop_output;
3999
4000     set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
4001
4002     frame_rate    = (AVRational){0, 0};
4003     frame_width   = 0;
4004     frame_height  = 0;
4005     audio_sample_rate = 0;
4006     audio_channels    = 0;
4007
4008     av_freep(&forced_key_frames);
4009     uninit_opts();
4010     init_opts();
4011     return 0;
4012 }
4013
4014 /* same option as mencoder */
4015 static int opt_pass(const char *opt, const char *arg)
4016 {
4017     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
4018     return 0;
4019 }
4020
4021 static int64_t getutime(void)
4022 {
4023 #if HAVE_GETRUSAGE
4024     struct rusage rusage;
4025
4026     getrusage(RUSAGE_SELF, &rusage);
4027     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4028 #elif HAVE_GETPROCESSTIMES
4029     HANDLE proc;
4030     FILETIME c, e, k, u;
4031     proc = GetCurrentProcess();
4032     GetProcessTimes(proc, &c, &e, &k, &u);
4033     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4034 #else
4035     return av_gettime();
4036 #endif
4037 }
4038
4039 static int64_t getmaxrss(void)
4040 {
4041 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4042     struct rusage rusage;
4043     getrusage(RUSAGE_SELF, &rusage);
4044     return (int64_t)rusage.ru_maxrss * 1024;
4045 #elif HAVE_GETPROCESSMEMORYINFO
4046     HANDLE proc;
4047     PROCESS_MEMORY_COUNTERS memcounters;
4048     proc = GetCurrentProcess();
4049     memcounters.cb = sizeof(memcounters);
4050     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4051     return memcounters.PeakPagefileUsage;
4052 #else
4053     return 0;
4054 #endif
4055 }
4056
4057 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4058 {
4059     int i;
4060     const char *p = str;
4061     for(i = 0;; i++) {
4062         dest[i] = atoi(p);
4063         if(i == 63)
4064             break;
4065         p = strchr(p, ',');
4066         if(!p) {
4067             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4068             ffmpeg_exit(1);
4069         }
4070         p++;
4071     }
4072 }
4073
4074 static void opt_inter_matrix(const char *arg)
4075 {
4076     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
4077     parse_matrix_coeffs(inter_matrix, arg);
4078 }
4079
4080 static void opt_intra_matrix(const char *arg)
4081 {
4082     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
4083     parse_matrix_coeffs(intra_matrix, arg);
4084 }
4085
4086 static void show_usage(void)
4087 {
4088     printf("Hyper fast Audio and Video encoder\n");
4089     printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
4090     printf("\n");
4091 }
4092
4093 static void show_help(void)
4094 {
4095     AVCodec *c;
4096     AVOutputFormat *oformat = NULL;
4097
4098     av_log_set_callback(log_callback_help);
4099     show_usage();
4100     show_help_options(options, "Main options:\n",
4101                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4102     show_help_options(options, "\nAdvanced options:\n",
4103                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4104                       OPT_EXPERT);
4105     show_help_options(options, "\nVideo options:\n",
4106                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4107                       OPT_VIDEO);
4108     show_help_options(options, "\nAdvanced Video options:\n",
4109                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4110                       OPT_VIDEO | OPT_EXPERT);
4111     show_help_options(options, "\nAudio options:\n",
4112                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4113                       OPT_AUDIO);
4114     show_help_options(options, "\nAdvanced Audio options:\n",
4115                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4116                       OPT_AUDIO | OPT_EXPERT);
4117     show_help_options(options, "\nSubtitle options:\n",
4118                       OPT_SUBTITLE | OPT_GRAB,
4119                       OPT_SUBTITLE);
4120     show_help_options(options, "\nAudio/Video grab options:\n",
4121                       OPT_GRAB,
4122                       OPT_GRAB);
4123     printf("\n");
4124     av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4125     printf("\n");
4126
4127     /* individual codec options */
4128     c = NULL;
4129     while ((c = av_codec_next(c))) {
4130         if (c->priv_class) {
4131             av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4132             printf("\n");
4133         }
4134     }
4135
4136     av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4137     printf("\n");
4138
4139     /* individual muxer options */
4140     while ((oformat = av_oformat_next(oformat))) {
4141         if (oformat->priv_class) {
4142             av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4143             printf("\n");
4144         }
4145     }
4146
4147     av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4148 }
4149
4150 static int opt_target(const char *opt, const char *arg)
4151 {
4152     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4153     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4154
4155     if(!strncmp(arg, "pal-", 4)) {
4156         norm = PAL;
4157         arg += 4;
4158     } else if(!strncmp(arg, "ntsc-", 5)) {
4159         norm = NTSC;
4160         arg += 5;
4161     } else if(!strncmp(arg, "film-", 5)) {
4162         norm = FILM;
4163         arg += 5;
4164     } else {
4165         int fr;
4166         /* Calculate FR via float to avoid int overflow */
4167         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4168         if(fr == 25000) {
4169             norm = PAL;
4170         } else if((fr == 29970) || (fr == 23976)) {
4171             norm = NTSC;
4172         } else {
4173             /* Try to determine PAL/NTSC by peeking in the input files */
4174             if(nb_input_files) {
4175                 int i, j;
4176                 for (j = 0; j < nb_input_files; j++) {
4177                     for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4178                         AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4179                         if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4180                             continue;
4181                         fr = c->time_base.den * 1000 / c->time_base.num;
4182                         if(fr == 25000) {
4183                             norm = PAL;
4184                             break;
4185                         } else if((fr == 29970) || (fr == 23976)) {
4186                             norm = NTSC;
4187                             break;
4188                         }
4189                     }
4190                     if(norm != UNKNOWN)
4191                         break;
4192                 }
4193             }
4194         }
4195         if(verbose > 0 && norm != UNKNOWN)
4196             fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4197     }
4198
4199     if(norm == UNKNOWN) {
4200         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4201         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4202         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4203         ffmpeg_exit(1);
4204     }
4205
4206     if(!strcmp(arg, "vcd")) {
4207         opt_codec("vcodec", "mpeg1video");
4208         opt_codec("acodec", "mp2");
4209         opt_format("f", "vcd");
4210
4211         opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4212         opt_frame_rate("r", frame_rates[norm]);
4213         opt_default("g", norm == PAL ? "15" : "18");
4214
4215         opt_default("b", "1150000");
4216         opt_default("maxrate", "1150000");
4217         opt_default("minrate", "1150000");
4218         opt_default("bufsize", "327680"); // 40*1024*8;
4219
4220         opt_default("ab", "224000");
4221         audio_sample_rate = 44100;
4222         audio_channels = 2;
4223
4224         opt_default("packetsize", "2324");
4225         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4226
4227         /* We have to offset the PTS, so that it is consistent with the SCR.
4228            SCR starts at 36000, but the first two packs contain only padding
4229            and the first pack from the other stream, respectively, may also have
4230            been written before.
4231            So the real data starts at SCR 36000+3*1200. */
4232         mux_preload= (36000+3*1200) / 90000.0; //0.44
4233     } else if(!strcmp(arg, "svcd")) {
4234
4235         opt_codec("vcodec", "mpeg2video");
4236         opt_codec("acodec", "mp2");
4237         opt_format("f", "svcd");
4238
4239         opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4240         opt_frame_rate("r", frame_rates[norm]);
4241         opt_frame_pix_fmt("pix_fmt", "yuv420p");
4242         opt_default("g", norm == PAL ? "15" : "18");
4243
4244         opt_default("b", "2040000");
4245         opt_default("maxrate", "2516000");
4246         opt_default("minrate", "0"); //1145000;
4247         opt_default("bufsize", "1835008"); //224*1024*8;
4248         opt_default("flags", "+scan_offset");
4249
4250
4251         opt_default("ab", "224000");
4252         audio_sample_rate = 44100;
4253
4254         opt_default("packetsize", "2324");
4255
4256     } else if(!strcmp(arg, "dvd")) {
4257
4258         opt_codec("vcodec", "mpeg2video");
4259         opt_codec("acodec", "ac3");
4260         opt_format("f", "dvd");
4261
4262         opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4263         opt_frame_rate("r", frame_rates[norm]);
4264         opt_frame_pix_fmt("pix_fmt", "yuv420p");
4265         opt_default("g", norm == PAL ? "15" : "18");
4266
4267         opt_default("b", "6000000");
4268         opt_default("maxrate", "9000000");
4269         opt_default("minrate", "0"); //1500000;
4270         opt_default("bufsize", "1835008"); //224*1024*8;
4271
4272         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4273         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4274
4275         opt_default("ab", "448000");
4276         audio_sample_rate = 48000;
4277
4278     } else if(!strncmp(arg, "dv", 2)) {
4279
4280         opt_format("f", "dv");
4281
4282         opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4283         opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4284                           norm == PAL ? "yuv420p" : "yuv411p");
4285         opt_frame_rate("r", frame_rates[norm]);
4286
4287         audio_sample_rate = 48000;
4288         audio_channels = 2;
4289
4290     } else {
4291         fprintf(stderr, "Unknown target: %s\n", arg);
4292         return AVERROR(EINVAL);
4293     }
4294     return 0;
4295 }
4296
4297 static int opt_vstats_file(const char *opt, const char *arg)
4298 {
4299     av_free (vstats_filename);
4300     vstats_filename=av_strdup (arg);
4301     return 0;
4302 }
4303
4304 static int opt_vstats(const char *opt, const char *arg)
4305 {
4306     char filename[40];
4307     time_t today2 = time(NULL);
4308     struct tm *today = localtime(&today2);
4309
4310     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4311              today->tm_sec);
4312     return opt_vstats_file(opt, filename);
4313 }
4314
4315 static int opt_bsf(const char *opt, const char *arg)
4316 {
4317     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4318     AVBitStreamFilterContext **bsfp;
4319
4320     if(!bsfc){
4321         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4322         ffmpeg_exit(1);
4323     }
4324
4325     bsfp= *opt == 'v' ? &video_bitstream_filters :
4326           *opt == 'a' ? &audio_bitstream_filters :
4327                         &subtitle_bitstream_filters;
4328     while(*bsfp)
4329         bsfp= &(*bsfp)->next;
4330
4331     *bsfp= bsfc;
4332
4333     return 0;
4334 }
4335
4336 static int opt_preset(const char *opt, const char *arg)
4337 {
4338     FILE *f=NULL;
4339     char filename[1000], tmp[1000], tmp2[1000], line[1000];
4340     char *codec_name = *opt == 'v' ? video_codec_name :
4341                        *opt == 'a' ? audio_codec_name :
4342                                      subtitle_codec_name;
4343
4344     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4345         fprintf(stderr, "File for preset '%s' not found\n", arg);
4346         ffmpeg_exit(1);
4347     }
4348
4349     while(!feof(f)){
4350         int e= fscanf(f, "%999[^\n]\n", line) - 1;
4351         if(line[0] == '#' && !e)
4352             continue;
4353         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4354         if(e){
4355             fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4356             ffmpeg_exit(1);
4357         }
4358         if (!strcmp(tmp, "acodec") ||
4359             !strcmp(tmp, "vcodec") ||
4360             !strcmp(tmp, "scodec") ||
4361             !strcmp(tmp, "dcodec")) {
4362             opt_codec(tmp, tmp2);
4363         }else if(opt_default(tmp, tmp2) < 0){
4364             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4365             ffmpeg_exit(1);
4366         }
4367     }
4368
4369     fclose(f);
4370
4371     return 0;
4372 }
4373
4374 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4375 {
4376 }
4377
4378 static void opt_passlogfile(const char *arg)
4379 {
4380     pass_logfilename_prefix = arg;
4381     opt_default("passlogfile", arg);
4382 }
4383
4384 static const OptionDef options[] = {
4385     /* main options */
4386 #include "cmdutils_common_opts.h"
4387     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4388     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4389     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4390     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4391     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4392       "outfile[,metadata]:infile[,metadata]" },
4393     { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4394       "outfile[,metadata]:infile[,metadata]" },
4395     { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4396     { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4397     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4398     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4399     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4400     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4401     { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4402     { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4403     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4404     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4405       "add timings for benchmarking" },
4406     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4407     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4408       "dump each input packet" },
4409     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4410       "when dumping packets, also dump the payload" },
4411     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4412     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4413     { "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)", "" },
4414     { "v", HAS_ARG, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4415     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4416     { "threads",  HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4417     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4418     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4419     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4420     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4421     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4422     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4423     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4424     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4425     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4426     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4427
4428     /* video options */
4429     { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4430     { "vb", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4431     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4432     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4433     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4434     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4435     { "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" },
4436     { "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" },
4437     { "croptop",  HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4438     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4439     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4440     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4441     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4442     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4443     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4444     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4445     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4446     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4447     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4448     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4449     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4450     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4451     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_codec}, "force video codec ('copy' to copy stream)", "codec" },
4452     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4453     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4454       "use same quantizer as source (implies VBR)" },
4455     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4456     { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4457     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4458       "deinterlace pictures" },
4459     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4460     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4461     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4462 #if CONFIG_AVFILTER
4463     { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4464 #endif
4465     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4466     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4467     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4468     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4469     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4470     { "newvideo", OPT_VIDEO, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4471     { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4472     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4473     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4474     { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4475     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4476
4477     /* audio options */
4478     { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4479     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4480     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4481     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4482     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4483     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4484     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4485     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4486     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4487     { "newaudio", OPT_AUDIO, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4488     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4489     { "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" },
4490
4491     /* subtitle options */
4492     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4493     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4494     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4495     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4496     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4497
4498     /* grab options */
4499     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4500     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4501     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4502
4503     /* muxer options */
4504     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4505     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4506
4507     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4508     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4509     { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4510
4511     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4512     { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4513     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4514     { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4515     /* data codec support */
4516     { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_codec}, "force data codec ('copy' to copy stream)", "codec" },
4517
4518     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4519     { NULL, },
4520 };
4521
4522 int main(int argc, char **argv)
4523 {
4524     int64_t ti;
4525
4526     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4527
4528     if(argc>1 && !strcmp(argv[1], "-d")){
4529         run_as_daemon=1;
4530         verbose=-1;
4531         av_log_set_callback(log_callback_null);
4532         argc--;
4533         argv++;
4534     }
4535
4536     avcodec_register_all();
4537 #if CONFIG_AVDEVICE
4538     avdevice_register_all();
4539 #endif
4540 #if CONFIG_AVFILTER
4541     avfilter_register_all();
4542 #endif
4543     av_register_all();
4544
4545 #if HAVE_ISATTY
4546     if(isatty(STDIN_FILENO))
4547         avio_set_interrupt_cb(decode_interrupt_cb);
4548 #endif
4549
4550     init_opts();
4551
4552     if(verbose>=0)
4553         show_banner();
4554
4555     /* parse options */
4556     parse_options(argc, argv, options, opt_output_file);
4557
4558     if(nb_output_files <= 0 && nb_input_files == 0) {
4559         show_usage();
4560         fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4561         ffmpeg_exit(1);
4562     }
4563
4564     /* file converter / grab */
4565     if (nb_output_files <= 0) {
4566         fprintf(stderr, "At least one output file must be specified\n");
4567         ffmpeg_exit(1);
4568     }
4569
4570     if (nb_input_files == 0) {
4571         fprintf(stderr, "At least one input file must be specified\n");
4572         ffmpeg_exit(1);
4573     }
4574
4575     ti = getutime();
4576     if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4577                   stream_maps, nb_stream_maps) < 0)
4578         ffmpeg_exit(1);
4579     ti = getutime() - ti;
4580     if (do_benchmark) {
4581         int maxrss = getmaxrss() / 1024;
4582         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4583     }
4584
4585     return ffmpeg_exit(0);
4586 }