ffmpeg.c

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