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