git.sesse.net Git - ffmpeg/blob - ffmpeg.c

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