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