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