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