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