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