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