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

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