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, av_get_pix_fmt_name(ost->resample_pix_fmt),
1212                dec->width         , dec->height         , av_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, final_picture->data, final_picture->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         if (start_time == 0 || ist->pts >= start_time) {
1662             for(i=0;i<nb_ostreams;i++) {
1663                 ost = ost_table[i];
1664                 if (ost->input_video_filter && ost->source_index == ist_index) {
1665                     if (!picture.sample_aspect_ratio.num)
1666                         picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
1667                     picture.pts = ist->pts;
1668
1669                     av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, AV_VSRC_BUF_FLAG_OVERWRITE);
1670                 }
1671             }
1672         }
1673 #endif
1674
1675         // preprocess audio (volume)
1676         if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1677             if (audio_volume != 256) {
1678                 short *volp;
1679                 volp = samples;
1680                 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1681                     int v = ((*volp) * audio_volume + 128) >> 8;
1682                     if (v < -32768) v = -32768;
1683                     if (v >  32767) v = 32767;
1684                     *volp++ = v;
1685                 }
1686             }
1687         }
1688
1689         /* frame rate emulation */
1690         if (rate_emu) {
1691             int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1692             int64_t now = av_gettime() - ist->start;
1693             if (pts > now)
1694                 usleep(pts - now);
1695         }
1696         /* if output time reached then transcode raw format,
1697            encode packets and output them */
1698         if (start_time == 0 || ist->pts >= start_time)
1699             for(i=0;i<nb_ostreams;i++) {
1700                 int frame_size;
1701
1702                 ost = ost_table[i];
1703                 if (ost->source_index == ist_index) {
1704 #if CONFIG_AVFILTER
1705                 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1706                     !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1707                 while (frame_available) {
1708                     AVRational ist_pts_tb;
1709                     if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1710                         if (get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb) < 0)
1711                             goto cont;
1712                     if (ost->picref)
1713                         ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1714 #endif
1715                     os = output_files[ost->file_index];
1716
1717                     /* set the input output pts pairs */
1718                     //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1719
1720                     if (ost->encoding_needed) {
1721                         av_assert0(ist->decoding_needed);
1722                         switch(ost->st->codec->codec_type) {
1723                         case AVMEDIA_TYPE_AUDIO:
1724                             do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1725                             break;
1726                         case AVMEDIA_TYPE_VIDEO:
1727 #if CONFIG_AVFILTER
1728                             if (ost->picref->video && !ost->frame_aspect_ratio)
1729                                 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1730 #endif
1731                             do_video_out(os, ost, ist, &picture, &frame_size);
1732                             if (vstats_filename && frame_size)
1733                                 do_video_stats(os, ost, frame_size);
1734                             break;
1735                         case AVMEDIA_TYPE_SUBTITLE:
1736                             do_subtitle_out(os, ost, ist, &subtitle,
1737                                             pkt->pts);
1738                             break;
1739                         default:
1740                             abort();
1741                         }
1742                     } else {
1743                         AVFrame avframe; //FIXME/XXX remove this
1744                         AVPicture pict;
1745                         AVPacket opkt;
1746                         int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1747
1748                         av_init_packet(&opkt);
1749
1750                         if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1751 #if !CONFIG_AVFILTER
1752                             continue;
1753 #else
1754                             goto cont;
1755 #endif
1756
1757                         /* no reencoding needed : output the packet directly */
1758                         /* force the input stream PTS */
1759
1760                         avcodec_get_frame_defaults(&avframe);
1761                         ost->st->codec->coded_frame= &avframe;
1762                         avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1763
1764                         if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1765                             audio_size += data_size;
1766                         else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1767                             video_size += data_size;
1768                             ost->sync_opts++;
1769                         }
1770
1771                         opkt.stream_index= ost->index;
1772                         if(pkt->pts != AV_NOPTS_VALUE)
1773                             opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1774                         else
1775                             opkt.pts= AV_NOPTS_VALUE;
1776
1777                         if (pkt->dts == AV_NOPTS_VALUE)
1778                             opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1779                         else
1780                             opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1781                         opkt.dts -= ost_tb_start_time;
1782
1783                         opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1784                         opkt.flags= pkt->flags;
1785
1786                         //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1787                         if(   ost->st->codec->codec_id != CODEC_ID_H264
1788                            && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1789                            && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1790                            ) {
1791                             if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1792                                 opkt.destruct= av_destruct_packet;
1793                         } else {
1794                             opkt.data = data_buf;
1795                             opkt.size = data_size;
1796                         }
1797
1798                         if (os->oformat->flags & AVFMT_RAWPICTURE) {
1799                             /* store AVPicture in AVPacket, as expected by the output format */
1800                             avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1801                             opkt.data = (uint8_t *)&pict;
1802                             opkt.size = sizeof(AVPicture);
1803                             opkt.flags |= AV_PKT_FLAG_KEY;
1804                         }
1805                         write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1806                         ost->st->codec->frame_number++;
1807                         ost->frame_number++;
1808                         av_free_packet(&opkt);
1809                     }
1810 #if CONFIG_AVFILTER
1811                     cont:
1812                     frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1813                                        ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1814                     avfilter_unref_buffer(ost->picref);
1815                 }
1816 #endif
1817                 }
1818             }
1819
1820         av_free(buffer_to_free);
1821         /* XXX: allocate the subtitles in the codec ? */
1822         if (subtitle_to_free) {
1823             avsubtitle_free(subtitle_to_free);
1824             subtitle_to_free = NULL;
1825         }
1826     }
1827  discard_packet:
1828     if (pkt == NULL) {
1829         /* EOF handling */
1830
1831         for(i=0;i<nb_ostreams;i++) {
1832             ost = ost_table[i];
1833             if (ost->source_index == ist_index) {
1834                 AVCodecContext *enc= ost->st->codec;
1835                 os = output_files[ost->file_index];
1836
1837                 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1838                     continue;
1839                 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1840                     continue;
1841
1842                 if (ost->encoding_needed) {
1843                     for(;;) {
1844                         AVPacket pkt;
1845                         int fifo_bytes;
1846                         av_init_packet(&pkt);
1847                         pkt.stream_index= ost->index;
1848
1849                         switch(ost->st->codec->codec_type) {
1850                         case AVMEDIA_TYPE_AUDIO:
1851                             fifo_bytes = av_fifo_size(ost->fifo);
1852                             ret = 0;
1853                             /* encode any samples remaining in fifo */
1854                             if (fifo_bytes > 0) {
1855                                 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1856                                 int fs_tmp = enc->frame_size;
1857
1858                                 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1859                                 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1860                                     enc->frame_size = fifo_bytes / (osize * enc->channels);
1861                                 } else { /* pad */
1862                                     int frame_bytes = enc->frame_size*osize*enc->channels;
1863                                     if (allocated_audio_buf_size < frame_bytes)
1864                                         ffmpeg_exit(1);
1865                                     generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1866                                 }
1867
1868                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1869                                 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1870                                                           ost->st->time_base.num, enc->sample_rate);
1871                                 enc->frame_size = fs_tmp;
1872                             }
1873                             if(ret <= 0) {
1874                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1875                             }
1876                             if (ret < 0) {
1877                                 fprintf(stderr, "Audio encoding failed\n");
1878                                 ffmpeg_exit(1);
1879                             }
1880                             audio_size += ret;
1881                             pkt.flags |= AV_PKT_FLAG_KEY;
1882                             break;
1883                         case AVMEDIA_TYPE_VIDEO:
1884                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1885                             if (ret < 0) {
1886                                 fprintf(stderr, "Video encoding failed\n");
1887                                 ffmpeg_exit(1);
1888                             }
1889                             video_size += ret;
1890                             if(enc->coded_frame && enc->coded_frame->key_frame)
1891                                 pkt.flags |= AV_PKT_FLAG_KEY;
1892                             if (ost->logfile && enc->stats_out) {
1893                                 fprintf(ost->logfile, "%s", enc->stats_out);
1894                             }
1895                             break;
1896                         default:
1897                             ret=-1;
1898                         }
1899
1900                         if(ret<=0)
1901                             break;
1902                         pkt.data= bit_buffer;
1903                         pkt.size= ret;
1904                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1905                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1906                         write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1907                     }
1908                 }
1909             }
1910         }
1911     }
1912
1913     return 0;
1914  fail_decode:
1915     return -1;
1916 }
1917
1918 static void print_sdp(AVFormatContext **avc, int n)
1919 {
1920     char sdp[2048];
1921
1922     av_sdp_create(avc, n, sdp, sizeof(sdp));
1923     printf("SDP:\n%s\n", sdp);
1924     fflush(stdout);
1925 }
1926
1927 static int copy_chapters(int infile, int outfile)
1928 {
1929     AVFormatContext *is = input_files[infile].ctx;
1930     AVFormatContext *os = output_files[outfile];
1931     int i;
1932
1933     for (i = 0; i < is->nb_chapters; i++) {
1934         AVChapter *in_ch = is->chapters[i], *out_ch;
1935         int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1936                                       AV_TIME_BASE_Q, in_ch->time_base);
1937         int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1938                            av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1939
1940
1941         if (in_ch->end < ts_off)
1942             continue;
1943         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1944             break;
1945
1946         out_ch = av_mallocz(sizeof(AVChapter));
1947         if (!out_ch)
1948             return AVERROR(ENOMEM);
1949
1950         out_ch->id        = in_ch->id;
1951         out_ch->time_base = in_ch->time_base;
1952         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1953         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1954
1955         if (metadata_chapters_autocopy)
1956             av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1957
1958         os->nb_chapters++;
1959         os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1960         if (!os->chapters)
1961             return AVERROR(ENOMEM);
1962         os->chapters[os->nb_chapters - 1] = out_ch;
1963     }
1964     return 0;
1965 }
1966
1967 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1968                                     AVCodecContext *avctx)
1969 {
1970     char *p;
1971     int n = 1, i;
1972     int64_t t;
1973
1974     for (p = kf; *p; p++)
1975         if (*p == ',')
1976             n++;
1977     ost->forced_kf_count = n;
1978     ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1979     if (!ost->forced_kf_pts) {
1980         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1981         ffmpeg_exit(1);
1982     }
1983     for (i = 0; i < n; i++) {
1984         p = i ? strchr(p, ',') + 1 : kf;
1985         t = parse_time_or_die("force_key_frames", p, 1);
1986         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1987     }
1988 }
1989
1990 /*
1991  * The following code is the main loop of the file converter
1992  */
1993 static int transcode(AVFormatContext **output_files,
1994                      int nb_output_files,
1995                      AVInputFile *input_files,
1996                      int nb_input_files,
1997                      AVStreamMap *stream_maps, int nb_stream_maps)
1998 {
1999     int ret = 0, i, j, k, n, nb_ostreams = 0, step;
2000
2001     AVFormatContext *is, *os;
2002     AVCodecContext *codec, *icodec;
2003     AVOutputStream *ost, **ost_table = NULL;
2004     AVInputStream *ist;
2005     char error[1024];
2006     int key;
2007     int want_sdp = 1;
2008     uint8_t no_packet[MAX_FILES]={0};
2009     int no_packet_count=0;
2010     int nb_frame_threshold[AVMEDIA_TYPE_NB]={0};
2011     int nb_streams[AVMEDIA_TYPE_NB]={0};
2012
2013     if (rate_emu)
2014         for (i = 0; i < nb_input_streams; i++)
2015             input_streams[i].start = av_gettime();
2016
2017     /* output stream init */
2018     nb_ostreams = 0;
2019     for(i=0;i<nb_output_files;i++) {
2020         os = output_files[i];
2021         if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2022             av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2023             fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2024             ret = AVERROR(EINVAL);
2025             goto fail;
2026         }
2027         nb_ostreams += os->nb_streams;
2028     }
2029     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2030         fprintf(stderr, "Number of stream maps must match number of output streams\n");
2031         ret = AVERROR(EINVAL);
2032         goto fail;
2033     }
2034
2035     /* Sanity check the mapping args -- do the input files & streams exist? */
2036     for(i=0;i<nb_stream_maps;i++) {
2037         int fi = stream_maps[i].file_index;
2038         int si = stream_maps[i].stream_index;
2039
2040         if (fi < 0 || fi > nb_input_files - 1 ||
2041             si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
2042             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2043             ret = AVERROR(EINVAL);
2044             goto fail;
2045         }
2046         fi = stream_maps[i].sync_file_index;
2047         si = stream_maps[i].sync_stream_index;
2048         if (fi < 0 || fi > nb_input_files - 1 ||
2049             si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
2050             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2051             ret = AVERROR(EINVAL);
2052             goto fail;
2053         }
2054     }
2055
2056     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2057     if (!ost_table)
2058         goto fail;
2059
2060     for(k=0;k<nb_output_files;k++) {
2061         os = output_files[k];
2062         for(i=0;i<os->nb_streams;i++,n++) {
2063             nb_streams[os->streams[i]->codec->codec_type]++;
2064         }
2065     }
2066     for(step=1<<30; step; step>>=1){
2067         int found_streams[AVMEDIA_TYPE_NB]={0};
2068         for(j=0; j<AVMEDIA_TYPE_NB; j++)
2069             nb_frame_threshold[j] += step;
2070
2071         for(j=0; j<nb_input_streams; j++) {
2072             int skip=0;
2073             ist = &input_streams[j];
2074             if(opt_programid){
2075                 int pi,si;
2076                 AVFormatContext *f= input_files[ ist->file_index ].ctx;
2077                 skip=1;
2078                 for(pi=0; pi<f->nb_programs; pi++){
2079                     AVProgram *p= f->programs[pi];
2080                     if(p->id == opt_programid)
2081                         for(si=0; si<p->nb_stream_indexes; si++){
2082                             if(f->streams[ p->stream_index[si] ] == ist->st)
2083                                 skip=0;
2084                         }
2085                 }
2086             }
2087             if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip
2088                 && nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames){
2089                 found_streams[ist->st->codec->codec_type]++;
2090             }
2091         }
2092         for(j=0; j<AVMEDIA_TYPE_NB; j++)
2093             if(found_streams[j] < nb_streams[j])
2094                 nb_frame_threshold[j] -= step;
2095     }
2096     n = 0;
2097     for(k=0;k<nb_output_files;k++) {
2098         os = output_files[k];
2099         for(i=0;i<os->nb_streams;i++,n++) {
2100             int found;
2101             ost = ost_table[n] = output_streams_for_file[k][i];
2102             ost->st = os->streams[i];
2103             if (nb_stream_maps > 0) {
2104                 ost->source_index = input_files[stream_maps[n].file_index].ist_index +
2105                     stream_maps[n].stream_index;
2106
2107                 /* Sanity check that the stream types match */
2108                 if (input_streams[ost->source_index].st->codec->codec_type != ost->st->codec->codec_type) {
2109                     int i= ost->file_index;
2110                     av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2111                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2112                         stream_maps[n].file_index, stream_maps[n].stream_index,
2113                         ost->file_index, ost->index);
2114                     ffmpeg_exit(1);
2115                 }
2116
2117             } else {
2118                 /* get corresponding input stream index : we select the first one with the right type */
2119                 found = 0;
2120                 for (j = 0; j < nb_input_streams; j++) {
2121                     int skip=0;
2122                     ist = &input_streams[j];
2123                     if(opt_programid){
2124                         int pi,si;
2125                         AVFormatContext *f = input_files[ist->file_index].ctx;
2126                         skip=1;
2127                         for(pi=0; pi<f->nb_programs; pi++){
2128                             AVProgram *p= f->programs[pi];
2129                             if(p->id == opt_programid)
2130                                 for(si=0; si<p->nb_stream_indexes; si++){
2131                                     if(f->streams[ p->stream_index[si] ] == ist->st)
2132                                         skip=0;
2133                                 }
2134                         }
2135                     }
2136                     if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2137                         ist->st->codec->codec_type == ost->st->codec->codec_type &&
2138                         nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames) {
2139                             ost->source_index = j;
2140                             found = 1;
2141                             break;
2142                     }
2143                 }
2144
2145                 if (!found) {
2146                     if(! opt_programid) {
2147                         /* try again and reuse existing stream */
2148                         for (j = 0; j < nb_input_streams; j++) {
2149                             ist = &input_streams[j];
2150                             if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2151                                 && ist->st->discard != AVDISCARD_ALL) {
2152                                 ost->source_index = j;
2153                                 found = 1;
2154                             }
2155                         }
2156                     }
2157                     if (!found) {
2158                         int i= ost->file_index;
2159                         av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2160                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2161                                 ost->file_index, ost->index);
2162                         ffmpeg_exit(1);
2163                     }
2164                 }
2165             }
2166             ist = &input_streams[ost->source_index];
2167             ist->discard = 0;
2168             ost->sync_ist = (nb_stream_maps > 0) ?
2169                 &input_streams[input_files[stream_maps[n].sync_file_index].ist_index +
2170                          stream_maps[n].sync_stream_index] : ist;
2171         }
2172     }
2173
2174     /* for each output stream, we compute the right encoding parameters */
2175     for(i=0;i<nb_ostreams;i++) {
2176         ost = ost_table[i];
2177         os = output_files[ost->file_index];
2178         ist = &input_streams[ost->source_index];
2179
2180         codec = ost->st->codec;
2181         icodec = ist->st->codec;
2182
2183         if (metadata_streams_autocopy)
2184             av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2185                              AV_METADATA_DONT_OVERWRITE);
2186
2187         ost->st->disposition = ist->st->disposition;
2188         codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2189         codec->chroma_sample_location = icodec->chroma_sample_location;
2190
2191         if (ost->st->stream_copy) {
2192             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2193
2194             if (extra_size > INT_MAX)
2195                 goto fail;
2196
2197             /* if stream_copy is selected, no need to decode or encode */
2198             codec->codec_id = icodec->codec_id;
2199             codec->codec_type = icodec->codec_type;
2200
2201             if(!codec->codec_tag){
2202                 if(   !os->oformat->codec_tag
2203                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2204                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2205                     codec->codec_tag = icodec->codec_tag;
2206             }
2207
2208             codec->bit_rate = icodec->bit_rate;
2209             codec->rc_max_rate    = icodec->rc_max_rate;
2210             codec->rc_buffer_size = icodec->rc_buffer_size;
2211             codec->extradata= av_mallocz(extra_size);
2212             if (!codec->extradata)
2213                 goto fail;
2214             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2215             codec->extradata_size= icodec->extradata_size;
2216             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){
2217                 codec->time_base = icodec->time_base;
2218                 codec->time_base.num *= icodec->ticks_per_frame;
2219                 av_reduce(&codec->time_base.num, &codec->time_base.den,
2220                           codec->time_base.num, codec->time_base.den, INT_MAX);
2221             }else
2222                 codec->time_base = ist->st->time_base;
2223             switch(codec->codec_type) {
2224             case AVMEDIA_TYPE_AUDIO:
2225                 if(audio_volume != 256) {
2226                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2227                     ffmpeg_exit(1);
2228                 }
2229                 codec->channel_layout = icodec->channel_layout;
2230                 codec->sample_rate = icodec->sample_rate;
2231                 codec->channels = icodec->channels;
2232                 codec->frame_size = icodec->frame_size;
2233                 codec->audio_service_type = icodec->audio_service_type;
2234                 codec->block_align= icodec->block_align;
2235                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2236                     codec->block_align= 0;
2237                 if(codec->codec_id == CODEC_ID_AC3)
2238                     codec->block_align= 0;
2239                 break;
2240             case AVMEDIA_TYPE_VIDEO:
2241                 codec->pix_fmt = icodec->pix_fmt;
2242                 codec->width = icodec->width;
2243                 codec->height = icodec->height;
2244                 codec->has_b_frames = icodec->has_b_frames;
2245                 if (!codec->sample_aspect_ratio.num) {
2246                     codec->sample_aspect_ratio =
2247                     ost->st->sample_aspect_ratio =
2248                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2249                         ist->st->codec->sample_aspect_ratio.num ?
2250                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2251                 }
2252                 break;
2253             case AVMEDIA_TYPE_SUBTITLE:
2254                 codec->width = icodec->width;
2255                 codec->height = icodec->height;
2256                 break;
2257             case AVMEDIA_TYPE_DATA:
2258                 break;
2259             default:
2260                 abort();
2261             }
2262         } else {
2263             switch(codec->codec_type) {
2264             case AVMEDIA_TYPE_AUDIO:
2265                 ost->fifo= av_fifo_alloc(1024);
2266                 if(!ost->fifo)
2267                     goto fail;
2268                 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2269                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2270                 icodec->request_channels = codec->channels;
2271                 ist->decoding_needed = 1;
2272                 ost->encoding_needed = 1;
2273                 ost->resample_sample_fmt  = icodec->sample_fmt;
2274                 ost->resample_sample_rate = icodec->sample_rate;
2275                 ost->resample_channels    = icodec->channels;
2276                 break;
2277             case AVMEDIA_TYPE_VIDEO:
2278                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2279                     fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2280                     ffmpeg_exit(1);
2281                 }
2282                 ost->video_resample = codec->width   != icodec->width  ||
2283                                       codec->height  != icodec->height ||
2284                                       codec->pix_fmt != icodec->pix_fmt;
2285                 if (ost->video_resample) {
2286                     codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2287                 }
2288                 ost->resample_height = icodec->height;
2289                 ost->resample_width  = icodec->width;
2290                 ost->resample_pix_fmt= icodec->pix_fmt;
2291                 ost->encoding_needed = 1;
2292                 ist->decoding_needed = 1;
2293
2294 #if CONFIG_AVFILTER
2295                 if (configure_video_filters(ist, ost)) {
2296                     fprintf(stderr, "Error opening filters!\n");
2297                     exit(1);
2298                 }
2299 #endif
2300                 break;
2301             case AVMEDIA_TYPE_SUBTITLE:
2302                 ost->encoding_needed = 1;
2303                 ist->decoding_needed = 1;
2304                 break;
2305             default:
2306                 abort();
2307                 break;
2308             }
2309             /* two pass mode */
2310             if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2311                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2312                 char logfilename[1024];
2313                 FILE *f;
2314
2315                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2316                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2317                          i);
2318                 if (codec->flags & CODEC_FLAG_PASS1) {
2319                     f = fopen(logfilename, "wb");
2320                     if (!f) {
2321                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2322                         ffmpeg_exit(1);
2323                     }
2324                     ost->logfile = f;
2325                 } else {
2326                     char  *logbuffer;
2327                     size_t logbuffer_size;
2328                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2329                         fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2330                         ffmpeg_exit(1);
2331                     }
2332                     codec->stats_in = logbuffer;
2333                 }
2334             }
2335         }
2336         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2337             /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2338             int size= codec->width * codec->height;
2339             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2340         }
2341     }
2342
2343     if (!bit_buffer)
2344         bit_buffer = av_malloc(bit_buffer_size);
2345     if (!bit_buffer) {
2346         fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2347                 bit_buffer_size);
2348         ret = AVERROR(ENOMEM);
2349         goto fail;
2350     }
2351
2352     /* open each encoder */
2353     for(i=0;i<nb_ostreams;i++) {
2354         ost = ost_table[i];
2355         if (ost->encoding_needed) {
2356             AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2357             AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2358             if (!codec)
2359                 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2360             if (!codec) {
2361                 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2362                          ost->st->codec->codec_id, ost->file_index, ost->index);
2363                 ret = AVERROR(EINVAL);
2364                 goto dump_format;
2365             }
2366             if (dec->subtitle_header) {
2367                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2368                 if (!ost->st->codec->subtitle_header) {
2369                     ret = AVERROR(ENOMEM);
2370                     goto dump_format;
2371                 }
2372                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2373                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2374             }
2375             if (avcodec_open(ost->st->codec, codec) < 0) {
2376                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2377                         ost->file_index, ost->index);
2378                 ret = AVERROR(EINVAL);
2379                 goto dump_format;
2380             }
2381             extra_size += ost->st->codec->extradata_size;
2382         }
2383     }
2384
2385     /* open each decoder */
2386     for (i = 0; i < nb_input_streams; i++) {
2387         ist = &input_streams[i];
2388         if (ist->decoding_needed) {
2389             AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2390             if (!codec)
2391                 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2392             if (!codec) {
2393                 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2394                         ist->st->codec->codec_id, ist->file_index, ist->st->index);
2395                 ret = AVERROR(EINVAL);
2396                 goto dump_format;
2397             }
2398             if (avcodec_open(ist->st->codec, codec) < 0) {
2399                 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2400                         ist->file_index, ist->st->index);
2401                 ret = AVERROR(EINVAL);
2402                 goto dump_format;
2403             }
2404             //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2405             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2406         }
2407     }
2408
2409     /* init pts */
2410     for (i = 0; i < nb_input_streams; i++) {
2411         AVStream *st;
2412         ist = &input_streams[i];
2413         st= ist->st;
2414         ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2415         ist->next_pts = AV_NOPTS_VALUE;
2416         ist->is_start = 1;
2417     }
2418
2419     /* set meta data information from input file if required */
2420     for (i=0;i<nb_meta_data_maps;i++) {
2421         AVFormatContext *files[2];
2422         AVMetadata      **meta[2];
2423         int j;
2424
2425 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2426         if ((index) < 0 || (index) >= (nb_elems)) {\
2427             snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2428                      (desc), (index));\
2429             ret = AVERROR(EINVAL);\
2430             goto dump_format;\
2431         }
2432
2433         int out_file_index = meta_data_maps[i][0].file;
2434         int in_file_index = meta_data_maps[i][1].file;
2435         if (in_file_index < 0 || out_file_index < 0)
2436             continue;
2437         METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2438         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2439
2440         files[0] = output_files[out_file_index];
2441         files[1] = input_files[in_file_index].ctx;
2442
2443         for (j = 0; j < 2; j++) {
2444             AVMetaDataMap *map = &meta_data_maps[i][j];
2445
2446             switch (map->type) {
2447             case 'g':
2448                 meta[j] = &files[j]->metadata;
2449                 break;
2450             case 's':
2451                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2452                 meta[j] = &files[j]->streams[map->index]->metadata;
2453                 break;
2454             case 'c':
2455                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2456                 meta[j] = &files[j]->chapters[map->index]->metadata;
2457                 break;
2458             case 'p':
2459                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2460                 meta[j] = &files[j]->programs[map->index]->metadata;
2461                 break;
2462             }
2463         }
2464
2465         av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2466     }
2467
2468     /* copy global metadata by default */
2469     if (metadata_global_autocopy) {
2470
2471         for (i = 0; i < nb_output_files; i++)
2472             av_metadata_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2473                              AV_METADATA_DONT_OVERWRITE);
2474     }
2475
2476     /* copy chapters according to chapter maps */
2477     for (i = 0; i < nb_chapter_maps; i++) {
2478         int infile  = chapter_maps[i].in_file;
2479         int outfile = chapter_maps[i].out_file;
2480
2481         if (infile < 0 || outfile < 0)
2482             continue;
2483         if (infile >= nb_input_files) {
2484             snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2485             ret = AVERROR(EINVAL);
2486             goto dump_format;
2487         }
2488         if (outfile >= nb_output_files) {
2489             snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2490             ret = AVERROR(EINVAL);
2491             goto dump_format;
2492         }
2493         copy_chapters(infile, outfile);
2494     }
2495
2496     /* copy chapters from the first input file that has them*/
2497     if (!nb_chapter_maps)
2498         for (i = 0; i < nb_input_files; i++) {
2499             if (!input_files[i].ctx->nb_chapters)
2500                 continue;
2501
2502             for (j = 0; j < nb_output_files; j++)
2503                 if ((ret = copy_chapters(i, j)) < 0)
2504                     goto dump_format;
2505             break;
2506         }
2507
2508     /* open files and write file headers */
2509     for(i=0;i<nb_output_files;i++) {
2510         os = output_files[i];
2511         if (av_write_header(os) < 0) {
2512             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2513             ret = AVERROR(EINVAL);
2514             goto dump_format;
2515         }
2516         if (strcmp(output_files[i]->oformat->name, "rtp")) {
2517             want_sdp = 0;
2518         }
2519     }
2520
2521  dump_format:
2522     /* dump the file output parameters - cannot be done before in case
2523        of stream copy */
2524     for(i=0;i<nb_output_files;i++) {
2525         av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2526     }
2527
2528     /* dump the stream mapping */
2529     if (verbose >= 0) {
2530         fprintf(stderr, "Stream mapping:\n");
2531         for(i=0;i<nb_ostreams;i++) {
2532             ost = ost_table[i];
2533             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2534                     input_streams[ost->source_index].file_index,
2535                     input_streams[ost->source_index].st->index,
2536                     ost->file_index,
2537                     ost->index);
2538             if (ost->sync_ist != &input_streams[ost->source_index])
2539                 fprintf(stderr, " [sync #%d.%d]",
2540                         ost->sync_ist->file_index,
2541                         ost->sync_ist->st->index);
2542             fprintf(stderr, "\n");
2543         }
2544     }
2545
2546     if (ret) {
2547         fprintf(stderr, "%s\n", error);
2548         goto fail;
2549     }
2550
2551     if (want_sdp) {
2552         print_sdp(output_files, nb_output_files);
2553     }
2554
2555     if (!using_stdin) {
2556         if(verbose >= 0)
2557             fprintf(stderr, "Press [q] to stop, [?] for help\n");
2558         avio_set_interrupt_cb(decode_interrupt_cb);
2559     }
2560     term_init();
2561
2562     timer_start = av_gettime();
2563
2564     for(; received_sigterm == 0;) {
2565         int file_index, ist_index;
2566         AVPacket pkt;
2567         double ipts_min;
2568         double opts_min;
2569
2570     redo:
2571         ipts_min= 1e100;
2572         opts_min= 1e100;
2573         /* if 'q' pressed, exits */
2574         if (!using_stdin) {
2575             if (q_pressed)
2576                 break;
2577             /* read_key() returns 0 on EOF */
2578             key = read_key();
2579             if (key == 'q')
2580                 break;
2581             if (key == '+') verbose++;
2582             if (key == '-') verbose--;
2583             if (key == 's') qp_hist     ^= 1;
2584             if (key == 'h'){
2585                 if (do_hex_dump){
2586                     do_hex_dump = do_pkt_dump = 0;
2587                 } else if(do_pkt_dump){
2588                     do_hex_dump = 1;
2589                 } else
2590                     do_pkt_dump = 1;
2591                 av_log_set_level(AV_LOG_DEBUG);
2592             }
2593             if (key == 'd' || key == 'D'){
2594                 int debug=0;
2595                 if(key == 'D') {
2596                     debug = input_streams[0].st->codec->debug<<1;
2597                     if(!debug) debug = 1;
2598                     while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2599                         debug += debug;
2600                 }else
2601                     scanf("%d", &debug);
2602                 for(i=0;i<nb_input_streams;i++) {
2603                     input_streams[i].st->codec->debug = debug;
2604                 }
2605                 for(i=0;i<nb_ostreams;i++) {
2606                     ost = ost_table[i];
2607                     ost->st->codec->debug = debug;
2608                 }
2609                 if(debug) av_log_set_level(AV_LOG_DEBUG);
2610                 fprintf(stderr,"debug=%d\n", debug);
2611             }
2612             if (key == '?'){
2613                 fprintf(stderr, "key    function\n"
2614                                 "?      show this help\n"
2615                                 "+      increase verbosity\n"
2616                                 "-      decrease verbosity\n"
2617                                 "D      cycle through available debug modes\n"
2618                                 "h      dump packets/hex press to cycle through the 3 states\n"
2619                                 "q      quit\n"
2620                                 "s      Show QP histogram\n"
2621                 );
2622             }
2623         }
2624
2625         /* select the stream that we must read now by looking at the
2626            smallest output pts */
2627         file_index = -1;
2628         for(i=0;i<nb_ostreams;i++) {
2629             double ipts, opts;
2630             ost = ost_table[i];
2631             os = output_files[ost->file_index];
2632             ist = &input_streams[ost->source_index];
2633             if(ist->is_past_recording_time || no_packet[ist->file_index])
2634                 continue;
2635                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2636             ipts = (double)ist->pts;
2637             if (!input_files[ist->file_index].eof_reached){
2638                 if(ipts < ipts_min) {
2639                     ipts_min = ipts;
2640                     if(input_sync ) file_index = ist->file_index;
2641                 }
2642                 if(opts < opts_min) {
2643                     opts_min = opts;
2644                     if(!input_sync) file_index = ist->file_index;
2645                 }
2646             }
2647             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2648                 file_index= -1;
2649                 break;
2650             }
2651         }
2652         /* if none, if is finished */
2653         if (file_index < 0) {
2654             if(no_packet_count){
2655                 no_packet_count=0;
2656                 memset(no_packet, 0, sizeof(no_packet));
2657                 usleep(10000);
2658                 continue;
2659             }
2660             break;
2661         }
2662
2663         /* finish if limit size exhausted */
2664         if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2665             break;
2666
2667         /* read a frame from it and output it in the fifo */
2668         is = input_files[file_index].ctx;
2669         ret= av_read_frame(is, &pkt);
2670         if(ret == AVERROR(EAGAIN)){
2671             no_packet[file_index]=1;
2672             no_packet_count++;
2673             continue;
2674         }
2675         if (ret < 0) {
2676             input_files[file_index].eof_reached = 1;
2677             if (opt_shortest)
2678                 break;
2679             else
2680                 continue;
2681         }
2682
2683         no_packet_count=0;
2684         memset(no_packet, 0, sizeof(no_packet));
2685
2686         if (do_pkt_dump) {
2687             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2688                              is->streams[pkt.stream_index]);
2689         }
2690         /* the following test is needed in case new streams appear
2691            dynamically in stream : we ignore them */
2692         if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
2693             goto discard_packet;
2694         ist_index = input_files[file_index].ist_index + pkt.stream_index;
2695         ist = &input_streams[ist_index];
2696         if (ist->discard)
2697             goto discard_packet;
2698
2699         if (pkt.dts != AV_NOPTS_VALUE)
2700             pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2701         if (pkt.pts != AV_NOPTS_VALUE)
2702             pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2703
2704         if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2705             && input_files_ts_scale[file_index][pkt.stream_index]){
2706             if(pkt.pts != AV_NOPTS_VALUE)
2707                 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2708             if(pkt.dts != AV_NOPTS_VALUE)
2709                 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2710         }
2711
2712 //        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);
2713         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2714             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2715             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2716             int64_t delta= pkt_dts - ist->next_pts;
2717             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2718                 input_files_ts_offset[ist->file_index]-= delta;
2719                 if (verbose > 2)
2720                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2721                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2722                 if(pkt.pts != AV_NOPTS_VALUE)
2723                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2724             }
2725         }
2726
2727         /* finish if recording time exhausted */
2728         if (recording_time != INT64_MAX &&
2729             (pkt.pts != AV_NOPTS_VALUE || pkt.dts != AV_NOPTS_VALUE ?
2730                 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000})
2731                     :
2732                 av_compare_ts(ist->pts, AV_TIME_BASE_Q, recording_time + start_time, (AVRational){1, 1000000})
2733             )>= 0) {
2734             ist->is_past_recording_time = 1;
2735             goto discard_packet;
2736         }
2737
2738         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2739         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2740
2741             if (verbose >= 0)
2742                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2743                         ist->file_index, ist->st->index);
2744             if (exit_on_error)
2745                 ffmpeg_exit(1);
2746             av_free_packet(&pkt);
2747             goto redo;
2748         }
2749
2750     discard_packet:
2751         av_free_packet(&pkt);
2752
2753         /* dump report by using the output first video and audio streams */
2754         print_report(output_files, ost_table, nb_ostreams, 0);
2755     }
2756
2757     /* at the end of stream, we must flush the decoder buffers */
2758     for (i = 0; i < nb_input_streams; i++) {
2759         ist = &input_streams[i];
2760         if (ist->decoding_needed) {
2761             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2762         }
2763     }
2764
2765     term_exit();
2766
2767     /* write the trailer if needed and close file */
2768     for(i=0;i<nb_output_files;i++) {
2769         os = output_files[i];
2770         av_write_trailer(os);
2771     }
2772
2773     /* dump report by using the first video and audio streams */
2774     print_report(output_files, ost_table, nb_ostreams, 1);
2775
2776     /* close each encoder */
2777     for(i=0;i<nb_ostreams;i++) {
2778         ost = ost_table[i];
2779         if (ost->encoding_needed) {
2780             av_freep(&ost->st->codec->stats_in);
2781             avcodec_close(ost->st->codec);
2782         }
2783 #if CONFIG_AVFILTER
2784         avfilter_graph_free(&ost->graph);
2785 #endif
2786     }
2787
2788     /* close each decoder */
2789     for (i = 0; i < nb_input_streams; i++) {
2790         ist = &input_streams[i];
2791         if (ist->decoding_needed) {
2792             avcodec_close(ist->st->codec);
2793         }
2794     }
2795
2796     /* finished ! */
2797     ret = 0;
2798
2799  fail:
2800     av_freep(&bit_buffer);
2801
2802     if (ost_table) {
2803         for(i=0;i<nb_ostreams;i++) {
2804             ost = ost_table[i];
2805             if (ost) {
2806                 if (ost->st->stream_copy)
2807                     av_freep(&ost->st->codec->extradata);
2808                 if (ost->logfile) {
2809                     fclose(ost->logfile);
2810                     ost->logfile = NULL;
2811                 }
2812                 av_fifo_free(ost->fifo); /* works even if fifo is not
2813                                              initialized but set to zero */
2814                 av_freep(&ost->st->codec->subtitle_header);
2815                 av_free(ost->resample_frame.data[0]);
2816                 av_free(ost->forced_kf_pts);
2817                 if (ost->video_resample)
2818                     sws_freeContext(ost->img_resample_ctx);
2819                 if (ost->resample)
2820                     audio_resample_close(ost->resample);
2821                 if (ost->reformat_ctx)
2822                     av_audio_convert_free(ost->reformat_ctx);
2823                 av_free(ost);
2824             }
2825         }
2826         av_free(ost_table);
2827     }
2828     return ret;
2829 }
2830
2831 static int opt_format(const char *opt, const char *arg)
2832 {
2833     last_asked_format = arg;
2834     return 0;
2835 }
2836
2837 static int opt_video_rc_override_string(const char *opt, const char *arg)
2838 {
2839     video_rc_override_string = arg;
2840     return 0;
2841 }
2842
2843 static int opt_me_threshold(const char *opt, const char *arg)
2844 {
2845     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2846     return 0;
2847 }
2848
2849 static int opt_verbose(const char *opt, const char *arg)
2850 {
2851     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2852     return 0;
2853 }
2854
2855 static int opt_frame_rate(const char *opt, const char *arg)
2856 {
2857     if (av_parse_video_rate(&frame_rate, arg) < 0) {
2858         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2859         ffmpeg_exit(1);
2860     }
2861     return 0;
2862 }
2863
2864 static int opt_bitrate(const char *opt, const char *arg)
2865 {
2866     int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2867
2868     opt_default(opt, arg);
2869
2870     if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2871         fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2872
2873     return 0;
2874 }
2875
2876 static int opt_frame_crop(const char *opt, const char *arg)
2877 {
2878     fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2879     return AVERROR(EINVAL);
2880 }
2881
2882 static int opt_frame_size(const char *opt, const char *arg)
2883 {
2884     if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2885         fprintf(stderr, "Incorrect frame size\n");
2886         return AVERROR(EINVAL);
2887     }
2888     return 0;
2889 }
2890
2891 static int opt_pad(const char *opt, const char *arg) {
2892     fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2893     return -1;
2894 }
2895
2896 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2897 {
2898     if (strcmp(arg, "list")) {
2899         frame_pix_fmt = av_get_pix_fmt(arg);
2900         if (frame_pix_fmt == PIX_FMT_NONE) {
2901             fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2902             return AVERROR(EINVAL);
2903         }
2904     } else {
2905         show_pix_fmts();
2906         ffmpeg_exit(0);
2907     }
2908     return 0;
2909 }
2910
2911 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2912 {
2913     int x = 0, y = 0;
2914     double ar = 0;
2915     const char *p;
2916     char *end;
2917
2918     p = strchr(arg, ':');
2919     if (p) {
2920         x = strtol(arg, &end, 10);
2921         if (end == p)
2922             y = strtol(end+1, &end, 10);
2923         if (x > 0 && y > 0)
2924             ar = (double)x / (double)y;
2925     } else
2926         ar = strtod(arg, NULL);
2927
2928     if (!ar) {
2929         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2930         return AVERROR(EINVAL);
2931     }
2932     frame_aspect_ratio = ar;
2933     return 0;
2934 }
2935
2936 static int opt_metadata(const char *opt, const char *arg)
2937 {
2938     char *mid= strchr(arg, '=');
2939
2940     if(!mid){
2941         fprintf(stderr, "Missing =\n");
2942         ffmpeg_exit(1);
2943     }
2944     *mid++= 0;
2945
2946     av_metadata_set2(&metadata, arg, mid, 0);
2947
2948     return 0;
2949 }
2950
2951 static int opt_qscale(const char *opt, const char *arg)
2952 {
2953     video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2954     if (video_qscale <= 0 || video_qscale > 255) {
2955         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2956         return AVERROR(EINVAL);
2957     }
2958     return 0;
2959 }
2960
2961 static int opt_top_field_first(const char *opt, const char *arg)
2962 {
2963     top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2964     opt_default(opt, arg);
2965     return 0;
2966 }
2967
2968 static int opt_thread_count(const char *opt, const char *arg)
2969 {
2970     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2971 #if !HAVE_THREADS
2972     if (verbose >= 0)
2973         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2974 #endif
2975     return 0;
2976 }
2977
2978 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2979 {
2980     if (strcmp(arg, "list")) {
2981         audio_sample_fmt = av_get_sample_fmt(arg);
2982         if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2983             av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2984             return AVERROR(EINVAL);
2985         }
2986     } else {
2987         int i;
2988         char fmt_str[128];
2989         for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2990             printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2991         ffmpeg_exit(0);
2992     }
2993     return 0;
2994 }
2995
2996 static int opt_audio_rate(const char *opt, const char *arg)
2997 {
2998     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2999     return 0;
3000 }
3001
3002 static int opt_audio_channels(const char *opt, const char *arg)
3003 {
3004     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3005     return 0;
3006 }
3007
3008 static int opt_video_channel(const char *opt, const char *arg)
3009 {
3010     video_channel = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3011     return 0;
3012 }
3013
3014 static int opt_video_standard(const char *opt, const char *arg)
3015 {
3016     video_standard = av_strdup(arg);
3017     return 0;
3018 }
3019
3020 static int opt_codec(const char *opt, const char *arg)
3021 {
3022     int *pstream_copy; char **pcodec_name; enum AVMediaType codec_type;
3023
3024     if      (!strcmp(opt, "acodec")) { pstream_copy = &audio_stream_copy;    pcodec_name = &audio_codec_name;    codec_type = AVMEDIA_TYPE_AUDIO;    }
3025     else if (!strcmp(opt, "vcodec")) { pstream_copy = &video_stream_copy;    pcodec_name = &video_codec_name;    codec_type = AVMEDIA_TYPE_VIDEO;    }
3026     else if (!strcmp(opt, "scodec")) { pstream_copy = &subtitle_stream_copy; pcodec_name = &subtitle_codec_name; codec_type = AVMEDIA_TYPE_SUBTITLE; }
3027     else if (!strcmp(opt, "dcodec")) { pstream_copy = &data_stream_copy;     pcodec_name = &data_codec_name;     codec_type = AVMEDIA_TYPE_DATA;     }
3028
3029     av_freep(pcodec_name);
3030     if (!strcmp(arg, "copy")) {
3031         *pstream_copy = 1;
3032     } else {
3033         *pcodec_name = av_strdup(arg);
3034     }
3035     return 0;
3036 }
3037
3038 static int opt_codec_tag(const char *opt, const char *arg)
3039 {
3040     char *tail;
3041     uint32_t *codec_tag;
3042
3043     codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
3044                 !strcmp(opt, "vtag") ? &video_codec_tag :
3045                 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
3046     if (!codec_tag)
3047         return -1;
3048
3049     *codec_tag = strtol(arg, &tail, 0);
3050     if (!tail || *tail)
3051         *codec_tag = AV_RL32(arg);
3052
3053     return 0;
3054 }
3055
3056 static int opt_map(const char *opt, const char *arg)
3057 {
3058     AVStreamMap *m;
3059     char *p;
3060
3061     stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
3062     m = &stream_maps[nb_stream_maps-1];
3063
3064     m->file_index = strtol(arg, &p, 0);
3065     if (*p)
3066         p++;
3067
3068     m->stream_index = strtol(p, &p, 0);
3069     if (*p) {
3070         p++;
3071         m->sync_file_index = strtol(p, &p, 0);
3072         if (*p)
3073             p++;
3074         m->sync_stream_index = strtol(p, &p, 0);
3075     } else {
3076         m->sync_file_index = m->file_index;
3077         m->sync_stream_index = m->stream_index;
3078     }
3079     return 0;
3080 }
3081
3082 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3083 {
3084     *endptr = arg;
3085     if (*arg == ',') {
3086         *type = *(++arg);
3087         switch (*arg) {
3088         case 'g':
3089             break;
3090         case 's':
3091         case 'c':
3092         case 'p':
3093             *index = strtol(++arg, endptr, 0);
3094             break;
3095         default:
3096             fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3097             ffmpeg_exit(1);
3098         }
3099     } else
3100         *type = 'g';
3101 }
3102
3103 static int opt_map_metadata(const char *opt, const char *arg)
3104 {
3105     AVMetaDataMap *m, *m1;
3106     char *p;
3107
3108     meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3109                                 &nb_meta_data_maps, nb_meta_data_maps + 1);
3110
3111     m = &meta_data_maps[nb_meta_data_maps - 1][0];
3112     m->file = strtol(arg, &p, 0);
3113     parse_meta_type(p, &m->type, &m->index, &p);
3114     if (*p)
3115         p++;
3116
3117     m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3118     m1->file = strtol(p, &p, 0);
3119     parse_meta_type(p, &m1->type, &m1->index, &p);
3120
3121     if (m->type == 'g' || m1->type == 'g')
3122         metadata_global_autocopy = 0;
3123     if (m->type == 's' || m1->type == 's')
3124         metadata_streams_autocopy = 0;
3125     if (m->type == 'c' || m1->type == 'c')
3126         metadata_chapters_autocopy = 0;
3127
3128     return 0;
3129 }
3130
3131 static int opt_map_meta_data(const char *opt, const char *arg)
3132 {
3133     fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3134                     "Use -map_metadata instead.\n");
3135     return opt_map_metadata(opt, arg);
3136 }
3137
3138 static int opt_map_chapters(const char *opt, const char *arg)
3139 {
3140     AVChapterMap *c;
3141     char *p;
3142
3143     chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3144                               nb_chapter_maps + 1);
3145     c = &chapter_maps[nb_chapter_maps - 1];
3146     c->out_file = strtol(arg, &p, 0);
3147     if (*p)
3148         p++;
3149
3150     c->in_file = strtol(p, &p, 0);
3151     return 0;
3152 }
3153
3154 static int opt_input_ts_scale(const char *opt, const char *arg)
3155 {
3156     unsigned int stream;
3157     double scale;
3158     char *p;
3159
3160     stream = strtol(arg, &p, 0);
3161     if (*p)
3162         p++;
3163     scale= strtod(p, &p);
3164
3165     if(stream >= MAX_STREAMS)
3166         ffmpeg_exit(1);
3167
3168     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);
3169     input_files_ts_scale[nb_input_files][stream]= scale;
3170     return 0;
3171 }
3172
3173 static int opt_recording_time(const char *opt, const char *arg)
3174 {
3175     recording_time = parse_time_or_die(opt, arg, 1);
3176     return 0;
3177 }
3178
3179 static int opt_start_time(const char *opt, const char *arg)
3180 {
3181     start_time = parse_time_or_die(opt, arg, 1);
3182     return 0;
3183 }
3184
3185 static int opt_recording_timestamp(const char *opt, const char *arg)
3186 {
3187     recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3188     return 0;
3189 }
3190
3191 static int opt_input_ts_offset(const char *opt, const char *arg)
3192 {
3193     input_ts_offset = parse_time_or_die(opt, arg, 1);
3194     return 0;
3195 }
3196
3197 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3198 {
3199     const char *codec_string = encoder ? "encoder" : "decoder";
3200     AVCodec *codec;
3201
3202     if(!name)
3203         return CODEC_ID_NONE;
3204     codec = encoder ?
3205         avcodec_find_encoder_by_name(name) :
3206         avcodec_find_decoder_by_name(name);
3207     if(!codec) {
3208         fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3209         ffmpeg_exit(1);
3210     }
3211     if(codec->type != type) {
3212         fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3213         ffmpeg_exit(1);
3214     }
3215     if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3216        strict > FF_COMPLIANCE_EXPERIMENTAL) {
3217         fprintf(stderr, "%s '%s' is experimental and might produce bad "
3218                 "results.\nAdd '-strict experimental' if you want to use it.\n",
3219                 codec_string, codec->name);
3220         codec = encoder ?
3221             avcodec_find_encoder(codec->id) :
3222             avcodec_find_decoder(codec->id);
3223         if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3224             fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3225                     codec_string, codec->name);
3226         ffmpeg_exit(1);
3227     }
3228     return codec->id;
3229 }
3230
3231 static int opt_input_file(const char *opt, const char *filename)
3232 {
3233     AVFormatContext *ic;
3234     AVFormatParameters params, *ap = &params;
3235     AVInputFormat *file_iformat = NULL;
3236     int err, i, ret, rfps, rfps_base;
3237     int64_t timestamp;
3238
3239     if (last_asked_format) {
3240         if (!(file_iformat = av_find_input_format(last_asked_format))) {
3241             fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3242             ffmpeg_exit(1);
3243         }
3244         last_asked_format = NULL;
3245     }
3246
3247     if (!strcmp(filename, "-"))
3248         filename = "pipe:";
3249
3250     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3251                     !strcmp(filename, "/dev/stdin");
3252
3253     /* get default parameters from command line */
3254     ic = avformat_alloc_context();
3255     if (!ic) {
3256         print_error(filename, AVERROR(ENOMEM));
3257         ffmpeg_exit(1);
3258     }
3259
3260     memset(ap, 0, sizeof(*ap));
3261     ap->prealloced_context = 1;
3262     ap->sample_rate = audio_sample_rate;
3263     ap->channels = audio_channels;
3264     ap->time_base.den = frame_rate.num;
3265     ap->time_base.num = frame_rate.den;
3266     ap->width = frame_width;
3267     ap->height = frame_height;
3268     ap->pix_fmt = frame_pix_fmt;
3269    // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3270     ap->channel = video_channel;
3271     ap->standard = video_standard;
3272
3273     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3274
3275     ic->video_codec_id   =
3276         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3277                           avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3278     ic->audio_codec_id   =
3279         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3280                           avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3281     ic->subtitle_codec_id=
3282         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3283                           avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3284     ic->flags |= AVFMT_FLAG_NONBLOCK | AVFMT_FLAG_PRIV_OPT;
3285
3286     /* open the input file with generic libav function */
3287     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3288     if(err >= 0){
3289         set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3290         err = av_demuxer_open(ic, ap);
3291         if(err < 0)
3292             avformat_free_context(ic);
3293     }
3294     if (err < 0) {
3295         print_error(filename, err);
3296         ffmpeg_exit(1);
3297     }
3298     if(opt_programid) {
3299         int i, j;
3300         int found=0;
3301         for(i=0; i<ic->nb_streams; i++){
3302             ic->streams[i]->discard= AVDISCARD_ALL;
3303         }
3304         for(i=0; i<ic->nb_programs; i++){
3305             AVProgram *p= ic->programs[i];
3306             if(p->id != opt_programid){
3307                 p->discard = AVDISCARD_ALL;
3308             }else{
3309                 found=1;
3310                 for(j=0; j<p->nb_stream_indexes; j++){
3311                     ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3312                 }
3313             }
3314         }
3315         if(!found){
3316             fprintf(stderr, "Specified program id not found\n");
3317             ffmpeg_exit(1);
3318         }
3319         opt_programid=0;
3320     }
3321
3322     ic->loop_input = loop_input;
3323
3324     /* If not enough info to get the stream parameters, we decode the
3325        first frames to get it. (used in mpeg case for example) */
3326     ret = av_find_stream_info(ic);
3327     if (ret < 0 && verbose >= 0) {
3328         fprintf(stderr, "%s: could not find codec parameters\n", filename);
3329         av_close_input_file(ic);
3330         ffmpeg_exit(1);
3331     }
3332
3333     timestamp = start_time;
3334     /* add the stream start time */
3335     if (ic->start_time != AV_NOPTS_VALUE)
3336         timestamp += ic->start_time;
3337
3338     /* if seeking requested, we execute it */
3339     if (start_time != 0) {
3340         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3341         if (ret < 0) {
3342             fprintf(stderr, "%s: could not seek to position %0.3f\n",
3343                     filename, (double)timestamp / AV_TIME_BASE);
3344         }
3345         /* reset seek info */
3346         start_time = 0;
3347     }
3348
3349     /* update the current parameters so that they match the one of the input stream */
3350     for(i=0;i<ic->nb_streams;i++) {
3351         AVStream *st = ic->streams[i];
3352         AVCodecContext *dec = st->codec;
3353         AVInputStream *ist;
3354
3355         dec->thread_count = thread_count;
3356         input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3357
3358         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3359         ist = &input_streams[nb_input_streams - 1];
3360         ist->st = st;
3361         ist->file_index = nb_input_files;
3362         ist->discard = 1;
3363
3364         switch (dec->codec_type) {
3365         case AVMEDIA_TYPE_AUDIO:
3366             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3367             if(!input_codecs[nb_input_codecs-1])
3368                 input_codecs[nb_input_codecs-1] = avcodec_find_decoder(dec->codec_id);
3369             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]);
3370             channel_layout    = dec->channel_layout;
3371             audio_channels    = dec->channels;
3372             audio_sample_rate = dec->sample_rate;
3373             audio_sample_fmt  = dec->sample_fmt;
3374             if(audio_disable)
3375                 st->discard= AVDISCARD_ALL;
3376             /* Note that av_find_stream_info can add more streams, and we
3377              * currently have no chance of setting up lowres decoding
3378              * early enough for them. */
3379             if (dec->lowres)
3380                 audio_sample_rate >>= dec->lowres;
3381             break;
3382         case AVMEDIA_TYPE_VIDEO:
3383             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3384             if(!input_codecs[nb_input_codecs-1])
3385                 input_codecs[nb_input_codecs-1] = avcodec_find_decoder(dec->codec_id);
3386             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]);
3387             frame_height = dec->height;
3388             frame_width  = dec->width;
3389             frame_pix_fmt = dec->pix_fmt;
3390             rfps      = ic->streams[i]->r_frame_rate.num;
3391             rfps_base = ic->streams[i]->r_frame_rate.den;
3392             if (dec->lowres) {
3393                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3394                 frame_height >>= dec->lowres;
3395                 frame_width  >>= dec->lowres;
3396                 dec->height = frame_height;
3397                 dec->width  = frame_width;
3398             }
3399             if(me_threshold)
3400                 dec->debug |= FF_DEBUG_MV;
3401
3402             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3403
3404                 if (verbose >= 0)
3405                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3406                             i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3407
3408                     (float)rfps / rfps_base, rfps, rfps_base);
3409             }
3410             /* update the current frame rate to match the stream frame rate */
3411             frame_rate.num = rfps;
3412             frame_rate.den = rfps_base;
3413
3414             if(video_disable)
3415                 st->discard= AVDISCARD_ALL;
3416             else if(video_discard)
3417                 st->discard= video_discard;
3418             break;
3419         case AVMEDIA_TYPE_DATA:
3420             break;
3421         case AVMEDIA_TYPE_SUBTITLE:
3422             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3423             if(!input_codecs[nb_input_codecs-1])
3424                 input_codecs[nb_input_codecs-1] = avcodec_find_decoder(dec->codec_id);
3425             if(subtitle_disable)
3426                 st->discard = AVDISCARD_ALL;
3427             break;
3428         case AVMEDIA_TYPE_ATTACHMENT:
3429         case AVMEDIA_TYPE_UNKNOWN:
3430             break;
3431         default:
3432             abort();
3433         }
3434     }
3435
3436     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3437     /* dump the file content */
3438     if (verbose >= 0)
3439         av_dump_format(ic, nb_input_files, filename, 0);
3440
3441     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3442     input_files[nb_input_files - 1].ctx        = ic;
3443     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3444
3445     video_channel = 0;
3446     top_field_first = -1;
3447
3448     av_freep(&video_codec_name);
3449     av_freep(&audio_codec_name);
3450     av_freep(&subtitle_codec_name);
3451     uninit_opts();
3452     init_opts();
3453     return 0;
3454 }
3455
3456 static void check_inputs(int *has_video_ptr,
3457                          int *has_audio_ptr,
3458                          int *has_subtitle_ptr,
3459                          int *has_data_ptr)
3460 {
3461     int has_video, has_audio, has_subtitle, has_data, i, j;
3462     AVFormatContext *ic;
3463
3464     has_video = 0;
3465     has_audio = 0;
3466     has_subtitle = 0;
3467     has_data = 0;
3468
3469     for(j=0;j<nb_input_files;j++) {
3470         ic = input_files[j].ctx;
3471         for(i=0;i<ic->nb_streams;i++) {
3472             AVCodecContext *enc = ic->streams[i]->codec;
3473             switch(enc->codec_type) {
3474             case AVMEDIA_TYPE_AUDIO:
3475                 has_audio = 1;
3476                 break;
3477             case AVMEDIA_TYPE_VIDEO:
3478                 has_video = 1;
3479                 break;
3480             case AVMEDIA_TYPE_SUBTITLE:
3481                 has_subtitle = 1;
3482                 break;
3483             case AVMEDIA_TYPE_DATA:
3484             case AVMEDIA_TYPE_ATTACHMENT:
3485             case AVMEDIA_TYPE_UNKNOWN:
3486                 has_data = 1;
3487                 break;
3488             default:
3489                 abort();
3490             }
3491         }
3492     }
3493     *has_video_ptr = has_video;
3494     *has_audio_ptr = has_audio;
3495     *has_subtitle_ptr = has_subtitle;
3496     *has_data_ptr = has_data;
3497 }
3498
3499 static void new_video_stream(AVFormatContext *oc, int file_idx)
3500 {
3501     AVStream *st;
3502     AVOutputStream *ost;
3503     AVCodecContext *video_enc;
3504     enum CodecID codec_id = CODEC_ID_NONE;
3505     AVCodec *codec= NULL;
3506
3507     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3508     if (!st) {
3509         fprintf(stderr, "Could not alloc stream\n");
3510         ffmpeg_exit(1);
3511     }
3512     ost = new_output_stream(oc, file_idx);
3513
3514     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3515     if(!video_stream_copy){
3516         if (video_codec_name) {
3517             codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3518                                          avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3519             codec = avcodec_find_encoder_by_name(video_codec_name);
3520             output_codecs[nb_output_codecs-1] = codec;
3521         } else {
3522             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3523             codec = avcodec_find_encoder(codec_id);
3524         }
3525         ost->frame_aspect_ratio = frame_aspect_ratio;
3526         frame_aspect_ratio = 0;
3527 #if CONFIG_AVFILTER
3528         ost->avfilter = vfilters;
3529         vfilters = NULL;
3530 #endif
3531     }
3532
3533     avcodec_get_context_defaults3(st->codec, codec);
3534     ost->bitstream_filters = video_bitstream_filters;
3535     video_bitstream_filters= NULL;
3536
3537     st->codec->thread_count= thread_count;
3538
3539     video_enc = st->codec;
3540
3541     if(video_codec_tag)
3542         video_enc->codec_tag= video_codec_tag;
3543
3544     if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3545         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3546         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3547     }
3548
3549     if (video_stream_copy) {
3550         st->stream_copy = 1;
3551         video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3552         video_enc->sample_aspect_ratio =
3553         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3554     } else {
3555         const char *p;
3556         int i;
3557         AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3558
3559         video_enc->codec_id = codec_id;
3560         set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3561
3562         if (codec && codec->supported_framerates && !force_fps)
3563             fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3564         video_enc->time_base.den = fps.num;
3565         video_enc->time_base.num = fps.den;
3566
3567         video_enc->width = frame_width;
3568         video_enc->height = frame_height;
3569         video_enc->pix_fmt = frame_pix_fmt;
3570         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3571         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3572
3573         choose_pixel_fmt(st, codec);
3574
3575         if (intra_only)
3576             video_enc->gop_size = 0;
3577         if (video_qscale || same_quality) {
3578             video_enc->flags |= CODEC_FLAG_QSCALE;
3579             video_enc->global_quality=
3580                 st->quality = FF_QP2LAMBDA * video_qscale;
3581         }
3582
3583         if(intra_matrix)
3584             video_enc->intra_matrix = intra_matrix;
3585         if(inter_matrix)
3586             video_enc->inter_matrix = inter_matrix;
3587
3588         p= video_rc_override_string;
3589         for(i=0; p; i++){
3590             int start, end, q;
3591             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3592             if(e!=3){
3593                 fprintf(stderr, "error parsing rc_override\n");
3594                 ffmpeg_exit(1);
3595             }
3596             video_enc->rc_override=
3597                 av_realloc(video_enc->rc_override,
3598                            sizeof(RcOverride)*(i+1));
3599             video_enc->rc_override[i].start_frame= start;
3600             video_enc->rc_override[i].end_frame  = end;
3601             if(q>0){
3602                 video_enc->rc_override[i].qscale= q;
3603                 video_enc->rc_override[i].quality_factor= 1.0;
3604             }
3605             else{
3606                 video_enc->rc_override[i].qscale= 0;
3607                 video_enc->rc_override[i].quality_factor= -q/100.0;
3608             }
3609             p= strchr(p, '/');
3610             if(p) p++;
3611         }
3612         video_enc->rc_override_count=i;
3613         if (!video_enc->rc_initial_buffer_occupancy)
3614             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3615         video_enc->me_threshold= me_threshold;
3616         video_enc->intra_dc_precision= intra_dc_precision - 8;
3617
3618         if (do_psnr)
3619             video_enc->flags|= CODEC_FLAG_PSNR;
3620
3621         /* two pass mode */
3622         if (do_pass) {
3623             if (do_pass == 1) {
3624                 video_enc->flags |= CODEC_FLAG_PASS1;
3625             } else {
3626                 video_enc->flags |= CODEC_FLAG_PASS2;
3627             }
3628         }
3629
3630         if (forced_key_frames)
3631             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3632     }
3633     if (video_language) {
3634         av_metadata_set2(&st->metadata, "language", video_language, 0);
3635         av_freep(&video_language);
3636     }
3637
3638     /* reset some key parameters */
3639     video_disable = 0;
3640     av_freep(&video_codec_name);
3641     av_freep(&forced_key_frames);
3642     video_stream_copy = 0;
3643     frame_pix_fmt = PIX_FMT_NONE;
3644 }
3645
3646 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3647 {
3648     AVStream *st;
3649     AVOutputStream *ost;
3650     AVCodec *codec= NULL;
3651     AVCodecContext *audio_enc;
3652     enum CodecID codec_id = CODEC_ID_NONE;
3653
3654     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3655     if (!st) {
3656         fprintf(stderr, "Could not alloc stream\n");
3657         ffmpeg_exit(1);
3658     }
3659     ost = new_output_stream(oc, file_idx);
3660
3661     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3662     if(!audio_stream_copy){
3663         if (audio_codec_name) {
3664             codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3665                                          avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3666             codec = avcodec_find_encoder_by_name(audio_codec_name);
3667             output_codecs[nb_output_codecs-1] = codec;
3668         } else {
3669             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3670             codec = avcodec_find_encoder(codec_id);
3671         }
3672     }
3673
3674     avcodec_get_context_defaults3(st->codec, codec);
3675
3676     ost->bitstream_filters = audio_bitstream_filters;
3677     audio_bitstream_filters= NULL;
3678
3679     st->codec->thread_count= thread_count;
3680
3681     audio_enc = st->codec;
3682     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3683
3684     if(audio_codec_tag)
3685         audio_enc->codec_tag= audio_codec_tag;
3686
3687     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3688         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3689         avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3690     }
3691     if (audio_stream_copy) {
3692         st->stream_copy = 1;
3693         audio_enc->channels = audio_channels;
3694         audio_enc->sample_rate = audio_sample_rate;
3695     } else {
3696         audio_enc->codec_id = codec_id;
3697         set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3698
3699         if (audio_qscale > QSCALE_NONE) {
3700             audio_enc->flags |= CODEC_FLAG_QSCALE;
3701             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3702         }
3703         audio_enc->channels = audio_channels;
3704         audio_enc->sample_fmt = audio_sample_fmt;
3705         audio_enc->sample_rate = audio_sample_rate;
3706         audio_enc->channel_layout = channel_layout;
3707         if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3708             audio_enc->channel_layout = 0;
3709         choose_sample_fmt(st, codec);
3710         choose_sample_rate(st, codec);
3711     }
3712     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3713     if (audio_language) {
3714         av_metadata_set2(&st->metadata, "language", audio_language, 0);
3715         av_freep(&audio_language);
3716     }
3717
3718     /* reset some key parameters */
3719     audio_disable = 0;
3720     av_freep(&audio_codec_name);
3721     audio_stream_copy = 0;
3722 }
3723
3724 static void new_data_stream(AVFormatContext *oc, int file_idx)
3725 {
3726     AVStream *st;
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     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 int opt_output_file(const char *opt, 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(nb_output_files >= FF_ARRAY_ELEMS(output_files)){
3868         fprintf(stderr, "Too many output files\n");
3869         ffmpeg_exit(1);
3870     }
3871
3872     if (!strcmp(filename, "-"))
3873         filename = "pipe:";
3874
3875     err = avformat_alloc_output_context2(&oc, NULL, last_asked_format, filename);
3876     last_asked_format = NULL;
3877     if (!oc) {
3878         print_error(filename, err);
3879         ffmpeg_exit(1);
3880     }
3881     file_oformat= oc->oformat;
3882
3883     if (!strcmp(file_oformat->name, "ffm") &&
3884         av_strstart(filename, "http:", NULL)) {
3885         /* special case for files sent to ffserver: we get the stream
3886            parameters from ffserver */
3887         int err = read_ffserver_streams(oc, filename);
3888         if (err < 0) {
3889             print_error(filename, err);
3890             ffmpeg_exit(1);
3891         }
3892     } else {
3893         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3894         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3895         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3896         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 */
3897
3898         /* disable if no corresponding type found and at least one
3899            input file */
3900         if (nb_input_files > 0) {
3901             check_inputs(&input_has_video,
3902                          &input_has_audio,
3903                          &input_has_subtitle,
3904                          &input_has_data);
3905
3906             if (!input_has_video)
3907                 use_video = 0;
3908             if (!input_has_audio)
3909                 use_audio = 0;
3910             if (!input_has_subtitle)
3911                 use_subtitle = 0;
3912             if (!input_has_data)
3913                 use_data = 0;
3914         }
3915
3916         /* manual disable */
3917         if (audio_disable)    use_audio    = 0;
3918         if (video_disable)    use_video    = 0;
3919         if (subtitle_disable) use_subtitle = 0;
3920         if (data_disable)     use_data     = 0;
3921
3922         if (use_video)    new_video_stream(oc, nb_output_files);
3923         if (use_audio)    new_audio_stream(oc, nb_output_files);
3924         if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3925         if (use_data)     new_data_stream(oc, nb_output_files);
3926
3927         oc->timestamp = recording_timestamp;
3928
3929         av_metadata_copy(&oc->metadata, metadata, 0);
3930         av_metadata_free(&metadata);
3931     }
3932
3933     output_files[nb_output_files++] = oc;
3934
3935     /* check filename in case of an image number is expected */
3936     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3937         if (!av_filename_number_test(oc->filename)) {
3938             print_error(oc->filename, AVERROR(EINVAL));
3939             ffmpeg_exit(1);
3940         }
3941     }
3942
3943     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3944         /* test if it already exists to avoid loosing precious files */
3945         if (!file_overwrite &&
3946             (strchr(filename, ':') == NULL ||
3947              filename[1] == ':' ||
3948              av_strstart(filename, "file:", NULL))) {
3949             if (avio_check(filename, 0) == 0) {
3950                 if (!using_stdin) {
3951                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3952                     fflush(stderr);
3953                     if (!read_yesno()) {
3954                         fprintf(stderr, "Not overwriting - exiting\n");
3955                         ffmpeg_exit(1);
3956                     }
3957                 }
3958                 else {
3959                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3960                     ffmpeg_exit(1);
3961                 }
3962             }
3963         }
3964
3965         /* open the file */
3966         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3967             print_error(filename, err);
3968             ffmpeg_exit(1);
3969         }
3970     }
3971
3972     memset(ap, 0, sizeof(*ap));
3973     if (av_set_parameters(oc, ap) < 0) {
3974         fprintf(stderr, "%s: Invalid encoding parameters\n",
3975                 oc->filename);
3976         ffmpeg_exit(1);
3977     }
3978
3979     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3980     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3981     oc->loop_output = loop_output;
3982
3983     set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3984
3985     av_freep(&forced_key_frames);
3986     uninit_opts();
3987     init_opts();
3988     return 0;
3989 }
3990
3991 /* same option as mencoder */
3992 static int opt_pass(const char *opt, const char *arg)
3993 {
3994     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3995     return 0;
3996 }
3997
3998 static int64_t getutime(void)
3999 {
4000 #if HAVE_GETRUSAGE
4001     struct rusage rusage;
4002
4003     getrusage(RUSAGE_SELF, &rusage);
4004     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4005 #elif HAVE_GETPROCESSTIMES
4006     HANDLE proc;
4007     FILETIME c, e, k, u;
4008     proc = GetCurrentProcess();
4009     GetProcessTimes(proc, &c, &e, &k, &u);
4010     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4011 #else
4012     return av_gettime();
4013 #endif
4014 }
4015
4016 static int64_t getmaxrss(void)
4017 {
4018 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4019     struct rusage rusage;
4020     getrusage(RUSAGE_SELF, &rusage);
4021     return (int64_t)rusage.ru_maxrss * 1024;
4022 #elif HAVE_GETPROCESSMEMORYINFO
4023     HANDLE proc;
4024     PROCESS_MEMORY_COUNTERS memcounters;
4025     proc = GetCurrentProcess();
4026     memcounters.cb = sizeof(memcounters);
4027     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4028     return memcounters.PeakPagefileUsage;
4029 #else
4030     return 0;
4031 #endif
4032 }
4033
4034 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4035 {
4036     int i;
4037     const char *p = str;
4038     for(i = 0;; i++) {
4039         dest[i] = atoi(p);
4040         if(i == 63)
4041             break;
4042         p = strchr(p, ',');
4043         if(!p) {
4044             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4045             ffmpeg_exit(1);
4046         }
4047         p++;
4048     }
4049 }
4050
4051 static void opt_inter_matrix(const char *arg)
4052 {
4053     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
4054     parse_matrix_coeffs(inter_matrix, arg);
4055 }
4056
4057 static void opt_intra_matrix(const char *arg)
4058 {
4059     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
4060     parse_matrix_coeffs(intra_matrix, arg);
4061 }
4062
4063 static void show_usage(void)
4064 {
4065     printf("Hyper fast Audio and Video encoder\n");
4066     printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
4067     printf("\n");
4068 }
4069
4070 static void show_help(void)
4071 {
4072     AVCodec *c;
4073     AVOutputFormat *oformat = NULL;
4074
4075     av_log_set_callback(log_callback_help);
4076     show_usage();
4077     show_help_options(options, "Main options:\n",
4078                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4079     show_help_options(options, "\nAdvanced options:\n",
4080                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4081                       OPT_EXPERT);
4082     show_help_options(options, "\nVideo options:\n",
4083                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4084                       OPT_VIDEO);
4085     show_help_options(options, "\nAdvanced Video options:\n",
4086                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4087                       OPT_VIDEO | OPT_EXPERT);
4088     show_help_options(options, "\nAudio options:\n",
4089                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4090                       OPT_AUDIO);
4091     show_help_options(options, "\nAdvanced Audio options:\n",
4092                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4093                       OPT_AUDIO | OPT_EXPERT);
4094     show_help_options(options, "\nSubtitle options:\n",
4095                       OPT_SUBTITLE | OPT_GRAB,
4096                       OPT_SUBTITLE);
4097     show_help_options(options, "\nAudio/Video grab options:\n",
4098                       OPT_GRAB,
4099                       OPT_GRAB);
4100     printf("\n");
4101     av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4102     printf("\n");
4103
4104     /* individual codec options */
4105     c = NULL;
4106     while ((c = av_codec_next(c))) {
4107         if (c->priv_class) {
4108             av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4109             printf("\n");
4110         }
4111     }
4112
4113     av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4114     printf("\n");
4115
4116     /* individual muxer options */
4117     while ((oformat = av_oformat_next(oformat))) {
4118         if (oformat->priv_class) {
4119             av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4120             printf("\n");
4121         }
4122     }
4123
4124     av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4125 }
4126
4127 static int opt_target(const char *opt, const char *arg)
4128 {
4129     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4130     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4131
4132     if(!strncmp(arg, "pal-", 4)) {
4133         norm = PAL;
4134         arg += 4;
4135     } else if(!strncmp(arg, "ntsc-", 5)) {
4136         norm = NTSC;
4137         arg += 5;
4138     } else if(!strncmp(arg, "film-", 5)) {
4139         norm = FILM;
4140         arg += 5;
4141     } else {
4142         int fr;
4143         /* Calculate FR via float to avoid int overflow */
4144         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4145         if(fr == 25000) {
4146             norm = PAL;
4147         } else if((fr == 29970) || (fr == 23976)) {
4148             norm = NTSC;
4149         } else {
4150             /* Try to determine PAL/NTSC by peeking in the input files */
4151             if(nb_input_files) {
4152                 int i, j;
4153                 for (j = 0; j < nb_input_files; j++) {
4154                     for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4155                         AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4156                         if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4157                             continue;
4158                         fr = c->time_base.den * 1000 / c->time_base.num;
4159                         if(fr == 25000) {
4160                             norm = PAL;
4161                             break;
4162                         } else if((fr == 29970) || (fr == 23976)) {
4163                             norm = NTSC;
4164                             break;
4165                         }
4166                     }
4167                     if(norm != UNKNOWN)
4168                         break;
4169                 }
4170             }
4171         }
4172         if(verbose > 0 && norm != UNKNOWN)
4173             fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4174     }
4175
4176     if(norm == UNKNOWN) {
4177         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4178         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4179         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4180         ffmpeg_exit(1);
4181     }
4182
4183     if(!strcmp(arg, "vcd")) {
4184         opt_codec("vcodec", "mpeg1video");
4185         opt_codec("acodec", "mp2");
4186         opt_format("f", "vcd");
4187
4188         opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4189         opt_frame_rate("r", frame_rates[norm]);
4190         opt_default("g", norm == PAL ? "15" : "18");
4191
4192         opt_default("b", "1150000");
4193         opt_default("maxrate", "1150000");
4194         opt_default("minrate", "1150000");
4195         opt_default("bufsize", "327680"); // 40*1024*8;
4196
4197         opt_default("ab", "224000");
4198         audio_sample_rate = 44100;
4199         audio_channels = 2;
4200
4201         opt_default("packetsize", "2324");
4202         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4203
4204         /* We have to offset the PTS, so that it is consistent with the SCR.
4205            SCR starts at 36000, but the first two packs contain only padding
4206            and the first pack from the other stream, respectively, may also have
4207            been written before.
4208            So the real data starts at SCR 36000+3*1200. */
4209         mux_preload= (36000+3*1200) / 90000.0; //0.44
4210     } else if(!strcmp(arg, "svcd")) {
4211
4212         opt_codec("vcodec", "mpeg2video");
4213         opt_codec("acodec", "mp2");
4214         opt_format("f", "svcd");
4215
4216         opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4217         opt_frame_rate("r", frame_rates[norm]);
4218         opt_default("g", norm == PAL ? "15" : "18");
4219
4220         opt_default("b", "2040000");
4221         opt_default("maxrate", "2516000");
4222         opt_default("minrate", "0"); //1145000;
4223         opt_default("bufsize", "1835008"); //224*1024*8;
4224         opt_default("flags", "+scan_offset");
4225
4226
4227         opt_default("ab", "224000");
4228         audio_sample_rate = 44100;
4229
4230         opt_default("packetsize", "2324");
4231
4232     } else if(!strcmp(arg, "dvd")) {
4233
4234         opt_codec("vcodec", "mpeg2video");
4235         opt_codec("acodec", "ac3");
4236         opt_format("f", "dvd");
4237
4238         opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4239         opt_frame_rate("r", frame_rates[norm]);
4240         opt_default("g", norm == PAL ? "15" : "18");
4241
4242         opt_default("b", "6000000");
4243         opt_default("maxrate", "9000000");
4244         opt_default("minrate", "0"); //1500000;
4245         opt_default("bufsize", "1835008"); //224*1024*8;
4246
4247         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4248         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4249
4250         opt_default("ab", "448000");
4251         audio_sample_rate = 48000;
4252
4253     } else if(!strncmp(arg, "dv", 2)) {
4254
4255         opt_format("f", "dv");
4256
4257         opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4258         opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4259                           norm == PAL ? "yuv420p" : "yuv411p");
4260         opt_frame_rate("r", frame_rates[norm]);
4261
4262         audio_sample_rate = 48000;
4263         audio_channels = 2;
4264
4265     } else {
4266         fprintf(stderr, "Unknown target: %s\n", arg);
4267         return AVERROR(EINVAL);
4268     }
4269     return 0;
4270 }
4271
4272 static int opt_vstats_file(const char *opt, const char *arg)
4273 {
4274     av_free (vstats_filename);
4275     vstats_filename=av_strdup (arg);
4276     return 0;
4277 }
4278
4279 static int opt_vstats(const char *opt, const char *arg)
4280 {
4281     char filename[40];
4282     time_t today2 = time(NULL);
4283     struct tm *today = localtime(&today2);
4284
4285     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4286              today->tm_sec);
4287     return opt_vstats_file(opt, filename);
4288 }
4289
4290 static int opt_bsf(const char *opt, const char *arg)
4291 {
4292     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4293     AVBitStreamFilterContext **bsfp;
4294
4295     if(!bsfc){
4296         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4297         ffmpeg_exit(1);
4298     }
4299
4300     bsfp= *opt == 'v' ? &video_bitstream_filters :
4301           *opt == 'a' ? &audio_bitstream_filters :
4302                         &subtitle_bitstream_filters;
4303     while(*bsfp)
4304         bsfp= &(*bsfp)->next;
4305
4306     *bsfp= bsfc;
4307
4308     return 0;
4309 }
4310
4311 static int opt_preset(const char *opt, const char *arg)
4312 {
4313     FILE *f=NULL;
4314     char filename[1000], tmp[1000], tmp2[1000], line[1000];
4315     char *codec_name = *opt == 'v' ? video_codec_name :
4316                        *opt == 'a' ? audio_codec_name :
4317                                      subtitle_codec_name;
4318
4319     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4320         fprintf(stderr, "File for preset '%s' not found\n", arg);
4321         ffmpeg_exit(1);
4322     }
4323
4324     while(!feof(f)){
4325         int e= fscanf(f, "%999[^\n]\n", line) - 1;
4326         if(line[0] == '#' && !e)
4327             continue;
4328         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4329         if(e){
4330             fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4331             ffmpeg_exit(1);
4332         }
4333         if (!strcmp(tmp, "acodec") ||
4334             !strcmp(tmp, "vcodec") ||
4335             !strcmp(tmp, "scodec") ||
4336             !strcmp(tmp, "dcodec")) {
4337             opt_codec(tmp, tmp2);
4338         }else if(opt_default(tmp, tmp2) < 0){
4339             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4340             ffmpeg_exit(1);
4341         }
4342     }
4343
4344     fclose(f);
4345
4346     return 0;
4347 }
4348
4349 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4350 {
4351 }
4352
4353 static void opt_passlogfile(const char *arg)
4354 {
4355     pass_logfilename_prefix = arg;
4356     opt_default("passlogfile", arg);
4357 }
4358
4359 static const OptionDef options[] = {
4360     /* main options */
4361 #include "cmdutils_common_opts.h"
4362     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4363     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4364     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4365     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4366     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4367       "outfile[,metadata]:infile[,metadata]" },
4368     { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4369       "outfile[,metadata]:infile[,metadata]" },
4370     { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4371     { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4372     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4373     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4374     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4375     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4376     { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4377     { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4378     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4379     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4380       "add timings for benchmarking" },
4381     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4382     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4383       "dump each input packet" },
4384     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4385       "when dumping packets, also dump the payload" },
4386     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4387     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4388     { "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)", "" },
4389     { "v", HAS_ARG, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4390     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4391     { "threads",  HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4392     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4393     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4394     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4395     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4396     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4397     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4398     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4399     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4400     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4401     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4402
4403     /* video options */
4404     { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4405     { "vb", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4406     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4407     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4408     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4409     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4410     { "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" },
4411     { "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" },
4412     { "croptop",  HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4413     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4414     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4415     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4416     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4417     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4418     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4419     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4420     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4421     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4422     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4423     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4424     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4425     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4426     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_codec}, "force video codec ('copy' to copy stream)", "codec" },
4427     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4428     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4429       "use same quantizer as source (implies VBR)" },
4430     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4431     { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4432     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4433       "deinterlace pictures" },
4434     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4435     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4436     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4437 #if CONFIG_AVFILTER
4438     { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4439 #endif
4440     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4441     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4442     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4443     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4444     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4445     { "newvideo", OPT_VIDEO, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4446     { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4447     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4448     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4449     { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4450     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4451
4452     /* audio options */
4453     { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4454     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4455     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4456     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4457     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4458     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4459     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4460     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4461     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4462     { "newaudio", OPT_AUDIO, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4463     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4464     { "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" },
4465
4466     /* subtitle options */
4467     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4468     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4469     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4470     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4471     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4472
4473     /* grab options */
4474     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4475     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4476     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4477
4478     /* muxer options */
4479     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4480     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4481
4482     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4483     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4484     { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4485
4486     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4487     { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4488     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4489     { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4490     /* data codec support */
4491     { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_codec}, "force data codec ('copy' to copy stream)", "codec" },
4492
4493     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4494     { NULL, },
4495 };
4496
4497 int main(int argc, char **argv)
4498 {
4499     int64_t ti;
4500
4501     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4502
4503     if(argc>1 && !strcmp(argv[1], "-d")){
4504         run_as_daemon=1;
4505         verbose=-1;
4506         av_log_set_callback(log_callback_null);
4507         argc--;
4508         argv++;
4509     }
4510
4511     avcodec_register_all();
4512 #if CONFIG_AVDEVICE
4513     avdevice_register_all();
4514 #endif
4515 #if CONFIG_AVFILTER
4516     avfilter_register_all();
4517 #endif
4518     av_register_all();
4519
4520 #if HAVE_ISATTY
4521     if(isatty(STDIN_FILENO))
4522         avio_set_interrupt_cb(decode_interrupt_cb);
4523 #endif
4524
4525     init_opts();
4526
4527     if(verbose>=0)
4528         show_banner();
4529
4530     /* parse options */
4531     parse_options(argc, argv, options, opt_output_file);
4532
4533     if(nb_output_files <= 0 && nb_input_files == 0) {
4534         show_usage();
4535         fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4536         ffmpeg_exit(1);
4537     }
4538
4539     /* file converter / grab */
4540     if (nb_output_files <= 0) {
4541         fprintf(stderr, "At least one output file must be specified\n");
4542         ffmpeg_exit(1);
4543     }
4544
4545     if (nb_input_files == 0) {
4546         fprintf(stderr, "At least one input file must be specified\n");
4547         ffmpeg_exit(1);
4548     }
4549
4550     ti = getutime();
4551     if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4552                   stream_maps, nb_stream_maps) < 0)
4553         ffmpeg_exit(1);
4554     ti = getutime() - ti;
4555     if (do_benchmark) {
4556         int maxrss = getmaxrss() / 1024;
4557         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4558     }
4559
4560     return ffmpeg_exit(0);
4561 }