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