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