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

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