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