ffmpeg.c

   1 /*
   2  * FFmpeg main
   3  * Copyright (c) 2000-2003 Fabrice Bellard
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /* needed for usleep() */
  23 #define _XOPEN_SOURCE 600
  24
  25 #include "config.h"
  26 #include <ctype.h>
  27 #include <string.h>
  28 #include <math.h>
  29 #include <stdlib.h>
  30 #include <errno.h>
  31 #include <signal.h>
  32 #include <limits.h>
  33 #include <unistd.h>
  34 #include "libavformat/avformat.h"
  35 #include "libavdevice/avdevice.h"
  36 #include "libswscale/swscale.h"
  37 #include "libavformat/framehook.h"
  38 #include "libavcodec/opt.h"
  39 #include "libavcodec/audioconvert.h"
  40 #include "libavutil/fifo.h"
  41 #include "libavutil/avstring.h"
  42 #include "libavformat/os_support.h"
  43
  44 #ifdef HAVE_SYS_RESOURCE_H
  45 #include <sys/types.h>
  46 #include <sys/resource.h>
  47 #elif defined(HAVE_GETPROCESSTIMES)
  48 #include <windows.h>
  49 #endif
  50
  51 #ifdef HAVE_SYS_SELECT_H
  52 #include <sys/select.h>
  53 #endif
  54
  55 #ifdef HAVE_TERMIOS_H
  56 #include <fcntl.h>
  57 #include <sys/ioctl.h>
  58 #include <sys/time.h>
  59 #include <termios.h>
  60 #elif defined(HAVE_CONIO_H)
  61 #include <conio.h>
  62 #endif
  63 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
  64 #include <time.h>
  65
  66 #include "cmdutils.h"
  67
  68 #undef NDEBUG
  69 #include <assert.h>
  70
  71 #undef exit
  72
  73 const char program_name[] = "FFmpeg";
  74 const int program_birth_year = 2000;
  75
  76 /* select an input stream for an output stream */
  77 typedef struct AVStreamMap {
  78     int file_index;
  79     int stream_index;
  80     int sync_file_index;
  81     int sync_stream_index;
  82 } AVStreamMap;
  83
  84 /** select an input file for an output file */
  85 typedef struct AVMetaDataMap {
  86     int out_file;
  87     int in_file;
  88 } AVMetaDataMap;
  89
  90 static const OptionDef options[];
  91
  92 #define MAX_FILES 20
  93
  94 static AVFormatContext *input_files[MAX_FILES];
  95 static int64_t input_files_ts_offset[MAX_FILES];
  96 static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
  97 static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
  98 static int nb_input_files = 0;
  99 static int nb_icodecs;
 100
 101 static AVFormatContext *output_files[MAX_FILES];
 102 static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
 103 static int nb_output_files = 0;
 104 static int nb_ocodecs;
 105
 106 static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
 107 static int nb_stream_maps;
 108
 109 static AVMetaDataMap meta_data_maps[MAX_FILES];
 110 static int nb_meta_data_maps;
 111
 112 static AVInputFormat *file_iformat;
 113 static AVOutputFormat *file_oformat;
 114 static int frame_width  = 0;
 115 static int frame_height = 0;
 116 static float frame_aspect_ratio = 0;
 117 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
 118 static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
 119 static int frame_padtop  = 0;
 120 static int frame_padbottom = 0;
 121 static int frame_padleft  = 0;
 122 static int frame_padright = 0;
 123 static int padcolor[3] = {16,128,128}; /* default to black */
 124 static int frame_topBand  = 0;
 125 static int frame_bottomBand = 0;
 126 static int frame_leftBand  = 0;
 127 static int frame_rightBand = 0;
 128 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
 129 static AVRational frame_rate;
 130 static float video_qscale = 0;
 131 static uint16_t *intra_matrix = NULL;
 132 static uint16_t *inter_matrix = NULL;
 133 #if 0 //experimental, (can be removed)
 134 static float video_rc_qsquish=1.0;
 135 static float video_rc_qmod_amp=0;
 136 static int video_rc_qmod_freq=0;
 137 #endif
 138 static const char *video_rc_override_string=NULL;
 139 static int video_disable = 0;
 140 static int video_discard = 0;
 141 static char *video_codec_name = NULL;
 142 static int video_codec_tag = 0;
 143 static int same_quality = 0;
 144 static int do_deinterlace = 0;
 145 static int top_field_first = -1;
 146 static int me_threshold = 0;
 147 static int intra_dc_precision = 8;
 148 static int loop_input = 0;
 149 static int loop_output = AVFMT_NOOUTPUTLOOP;
 150 static int qp_hist = 0;
 151
 152 static int intra_only = 0;
 153 static int audio_sample_rate = 44100;
 154 #define QSCALE_NONE -99999
 155 static float audio_qscale = QSCALE_NONE;
 156 static int audio_disable = 0;
 157 static int audio_channels = 1;
 158 static char  *audio_codec_name = NULL;
 159 static int audio_codec_tag = 0;
 160 static char *audio_language = NULL;
 161
 162 static int subtitle_disable = 0;
 163 static char *subtitle_codec_name = NULL;
 164 static char *subtitle_language = NULL;
 165
 166 static float mux_preload= 0.5;
 167 static float mux_max_delay= 0.7;
 168
 169 static int64_t recording_time = INT64_MAX;
 170 static int64_t start_time = 0;
 171 static int64_t rec_timestamp = 0;
 172 static int64_t input_ts_offset = 0;
 173 static int file_overwrite = 0;
 174 static char *str_title = NULL;
 175 static char *str_author = NULL;
 176 static char *str_copyright = NULL;
 177 static char *str_comment = NULL;
 178 static char *str_genre = NULL;
 179 static char *str_album = NULL;
 180 static int do_benchmark = 0;
 181 static int do_hex_dump = 0;
 182 static int do_pkt_dump = 0;
 183 static int do_psnr = 0;
 184 static int do_pass = 0;
 185 static char *pass_logfilename = NULL;
 186 static int audio_stream_copy = 0;
 187 static int video_stream_copy = 0;
 188 static int subtitle_stream_copy = 0;
 189 static int video_sync_method= -1;
 190 static int audio_sync_method= 0;
 191 static float audio_drift_threshold= 0.1;
 192 static int copy_ts= 0;
 193 static int opt_shortest = 0; //
 194 static int video_global_header = 0;
 195 static char *vstats_filename;
 196 static FILE *vstats_file;
 197 static int opt_programid = 0;
 198
 199 static int rate_emu = 0;
 200
 201 static int  video_channel = 0;
 202 static char *video_standard;
 203
 204 static int audio_volume = 256;
 205
 206 static int exit_on_error = 0;
 207 static int using_stdin = 0;
 208 static int using_vhook = 0;
 209 static int verbose = 1;
 210 static int thread_count= 1;
 211 static int q_pressed = 0;
 212 static int64_t video_size = 0;
 213 static int64_t audio_size = 0;
 214 static int64_t extra_size = 0;
 215 static int nb_frames_dup = 0;
 216 static int nb_frames_drop = 0;
 217 static int input_sync;
 218 static uint64_t limit_filesize = 0; //
 219 static int force_fps = 0;
 220
 221 static int pgmyuv_compatibility_hack=0;
 222 static float dts_delta_threshold = 10;
 223
 224 static unsigned int sws_flags = SWS_BICUBIC;
 225
 226 static int64_t timer_start;
 227
 228 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
 229 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
 230 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
 231 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
 232
 233 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
 234
 235 struct AVInputStream;
 236
 237 typedef struct AVOutputStream {
 238     int file_index;          /* file index */
 239     int index;               /* stream index in the output file */
 240     int source_index;        /* AVInputStream index */
 241     AVStream *st;            /* stream in the output file */
 242     int encoding_needed;     /* true if encoding needed for this stream */
 243     int frame_number;
 244     /* input pts and corresponding output pts
 245        for A/V sync */
 246     //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
 247     struct AVInputStream *sync_ist; /* input stream to sync against */
 248     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
 249     /* video only */
 250     int video_resample;
 251     AVFrame pict_tmp;      /* temporary image for resampling */
 252     struct SwsContext *img_resample_ctx; /* for image resampling */
 253     int resample_height;
 254
 255     int video_crop;
 256     int topBand;             /* cropping area sizes */
 257     int leftBand;
 258
 259     int video_pad;
 260     int padtop;              /* padding area sizes */
 261     int padbottom;
 262     int padleft;
 263     int padright;
 264
 265     /* audio only */
 266     int audio_resample;
 267     ReSampleContext *resample; /* for audio resampling */
 268     int reformat_pair;
 269     AVAudioConvert *reformat_ctx;
 270     AVFifoBuffer fifo;     /* for compression: one audio fifo per codec */
 271     FILE *logfile;
 272 } AVOutputStream;
 273
 274 typedef struct AVInputStream {
 275     int file_index;
 276     int index;
 277     AVStream *st;
 278     int discard;             /* true if stream data should be discarded */
 279     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
 280     int64_t sample_index;      /* current sample */
 281
 282     int64_t       start;     /* time when read started */
 283     unsigned long frame;     /* current frame */
 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 (ist->st->codec->rate_emu) {
1309             int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1310             int64_t now = av_gettime() - ist->start;
1311             if (pts > now)
1312                 usleep(pts - now);
1313
1314             ist->frame++;
1315         }
1316
1317         /* if output time reached then transcode raw format,
1318            encode packets and output them */
1319         if (start_time == 0 || ist->pts >= start_time)
1320             for(i=0;i<nb_ostreams;i++) {
1321                 int frame_size;
1322
1323                 ost = ost_table[i];
1324                 if (ost->source_index == ist_index) {
1325                     os = output_files[ost->file_index];
1326
1327 #if 0
1328                     printf("%d: got pts=%0.3f %0.3f\n", i,
1329                            (double)pkt->pts / AV_TIME_BASE,
1330                            ((double)ist->pts / AV_TIME_BASE) -
1331                            ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1332 #endif
1333                     /* set the input output pts pairs */
1334                     //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1335
1336                     if (ost->encoding_needed) {
1337                         switch(ost->st->codec->codec_type) {
1338                         case CODEC_TYPE_AUDIO:
1339                             do_audio_out(os, ost, ist, data_buf, data_size);
1340                             break;
1341                         case CODEC_TYPE_VIDEO:
1342                             do_video_out(os, ost, ist, &picture, &frame_size);
1343                             if (vstats_filename && frame_size)
1344                                 do_video_stats(os, ost, frame_size);
1345                             break;
1346                         case CODEC_TYPE_SUBTITLE:
1347                             do_subtitle_out(os, ost, ist, &subtitle,
1348                                             pkt->pts);
1349                             break;
1350                         default:
1351                             abort();
1352                         }
1353                     } else {
1354                         AVFrame avframe; //FIXME/XXX remove this
1355                         AVPacket opkt;
1356                         av_init_packet(&opkt);
1357
1358                         if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1359                             continue;
1360
1361                         /* no reencoding needed : output the packet directly */
1362                         /* force the input stream PTS */
1363
1364                         avcodec_get_frame_defaults(&avframe);
1365                         ost->st->codec->coded_frame= &avframe;
1366                         avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1367
1368                         if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1369                             audio_size += data_size;
1370                         else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1371                             video_size += data_size;
1372                             ost->sync_opts++;
1373                         }
1374
1375                         opkt.stream_index= ost->index;
1376                         if(pkt->pts != AV_NOPTS_VALUE)
1377                             opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1378                         else
1379                             opkt.pts= AV_NOPTS_VALUE;
1380
1381                         if (pkt->dts == AV_NOPTS_VALUE)
1382                             opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1383                         else
1384                             opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1385
1386                         opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1387                         opkt.flags= pkt->flags;
1388
1389                         //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1390                         if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1391                             opkt.destruct= av_destruct_packet;
1392
1393                         write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1394                         ost->st->codec->frame_number++;
1395                         ost->frame_number++;
1396                         av_free_packet(&opkt);
1397                     }
1398                 }
1399             }
1400         av_free(buffer_to_free);
1401         /* XXX: allocate the subtitles in the codec ? */
1402         if (subtitle_to_free) {
1403             if (subtitle_to_free->rects != NULL) {
1404                 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1405                     av_free(subtitle_to_free->rects[i].bitmap);
1406                     av_free(subtitle_to_free->rects[i].rgba_palette);
1407                 }
1408                 av_freep(&subtitle_to_free->rects);
1409             }
1410             subtitle_to_free->num_rects = 0;
1411             subtitle_to_free = NULL;
1412         }
1413     }
1414  discard_packet:
1415     if (pkt == NULL) {
1416         /* EOF handling */
1417
1418         for(i=0;i<nb_ostreams;i++) {
1419             ost = ost_table[i];
1420             if (ost->source_index == ist_index) {
1421                 AVCodecContext *enc= ost->st->codec;
1422                 os = output_files[ost->file_index];
1423
1424                 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1425                     continue;
1426                 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1427                     continue;
1428
1429                 if (ost->encoding_needed) {
1430                     for(;;) {
1431                         AVPacket pkt;
1432                         int fifo_bytes;
1433                         av_init_packet(&pkt);
1434                         pkt.stream_index= ost->index;
1435
1436                         switch(ost->st->codec->codec_type) {
1437                         case CODEC_TYPE_AUDIO:
1438                             fifo_bytes = av_fifo_size(&ost->fifo);
1439                             ret = 0;
1440                             /* encode any samples remaining in fifo */
1441                             if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1442                                 int fs_tmp = enc->frame_size;
1443                                 enc->frame_size = fifo_bytes / (2 * enc->channels);
1444                                 av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes);
1445                                     ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1446                                 enc->frame_size = fs_tmp;
1447                             }
1448                             if(ret <= 0) {
1449                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1450                             }
1451                             audio_size += ret;
1452                             pkt.flags |= PKT_FLAG_KEY;
1453                             break;
1454                         case CODEC_TYPE_VIDEO:
1455                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1456                             video_size += ret;
1457                             if(enc->coded_frame && enc->coded_frame->key_frame)
1458                                 pkt.flags |= PKT_FLAG_KEY;
1459                             if (ost->logfile && enc->stats_out) {
1460                                 fprintf(ost->logfile, "%s", enc->stats_out);
1461                             }
1462                             break;
1463                         default:
1464                             ret=-1;
1465                         }
1466
1467                         if(ret<=0)
1468                             break;
1469                         pkt.data= bit_buffer;
1470                         pkt.size= ret;
1471                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1472                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1473                         write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1474                     }
1475                 }
1476             }
1477         }
1478     }
1479
1480     return 0;
1481  fail_decode:
1482     return -1;
1483 }
1484
1485 static void print_sdp(AVFormatContext **avc, int n)
1486 {
1487     char sdp[2048];
1488
1489     avf_sdp_create(avc, n, sdp, sizeof(sdp));
1490     printf("SDP:\n%s\n", sdp);
1491     fflush(stdout);
1492 }
1493
1494 static int stream_index_from_inputs(AVFormatContext **input_files,
1495                                     int nb_input_files,
1496                                     AVInputFile *file_table,
1497                                     AVInputStream **ist_table,
1498                                     enum CodecType type,
1499                                     int programid)
1500 {
1501     int p, q, z;
1502     for(z=0; z<nb_input_files; z++) {
1503         AVFormatContext *ic = input_files[z];
1504         for(p=0; p<ic->nb_programs; p++) {
1505             AVProgram *program = ic->programs[p];
1506             if(program->id != programid)
1507                 continue;
1508             for(q=0; q<program->nb_stream_indexes; q++) {
1509                 int sidx = program->stream_index[q];
1510                 int ris = file_table[z].ist_index + sidx;
1511                 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1512                     return ris;
1513             }
1514         }
1515     }
1516
1517     return -1;
1518 }
1519
1520 /*
1521  * The following code is the main loop of the file converter
1522  */
1523 static int av_encode(AVFormatContext **output_files,
1524                      int nb_output_files,
1525                      AVFormatContext **input_files,
1526                      int nb_input_files,
1527                      AVStreamMap *stream_maps, int nb_stream_maps)
1528 {
1529     int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1530     AVFormatContext *is, *os;
1531     AVCodecContext *codec, *icodec;
1532     AVOutputStream *ost, **ost_table = NULL;
1533     AVInputStream *ist, **ist_table = NULL;
1534     AVInputFile *file_table;
1535     int key;
1536     int want_sdp = 1;
1537
1538     file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1539     if (!file_table)
1540         goto fail;
1541
1542     /* input stream init */
1543     j = 0;
1544     for(i=0;i<nb_input_files;i++) {
1545         is = input_files[i];
1546         file_table[i].ist_index = j;
1547         file_table[i].nb_streams = is->nb_streams;
1548         j += is->nb_streams;
1549     }
1550     nb_istreams = j;
1551
1552     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1553     if (!ist_table)
1554         goto fail;
1555
1556     for(i=0;i<nb_istreams;i++) {
1557         ist = av_mallocz(sizeof(AVInputStream));
1558         if (!ist)
1559             goto fail;
1560         ist_table[i] = ist;
1561     }
1562     j = 0;
1563     for(i=0;i<nb_input_files;i++) {
1564         is = input_files[i];
1565         for(k=0;k<is->nb_streams;k++) {
1566             ist = ist_table[j++];
1567             ist->st = is->streams[k];
1568             ist->file_index = i;
1569             ist->index = k;
1570             ist->discard = 1; /* the stream is discarded by default
1571                                  (changed later) */
1572
1573             if (ist->st->codec->rate_emu) {
1574                 ist->start = av_gettime();
1575                 ist->frame = 0;
1576             }
1577         }
1578     }
1579
1580     /* output stream init */
1581     nb_ostreams = 0;
1582     for(i=0;i<nb_output_files;i++) {
1583         os = output_files[i];
1584         if (!os->nb_streams) {
1585             fprintf(stderr, "Output file does not contain any stream\n");
1586             av_exit(1);
1587         }
1588         nb_ostreams += os->nb_streams;
1589     }
1590     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1591         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1592         av_exit(1);
1593     }
1594
1595     /* Sanity check the mapping args -- do the input files & streams exist? */
1596     for(i=0;i<nb_stream_maps;i++) {
1597         int fi = stream_maps[i].file_index;
1598         int si = stream_maps[i].stream_index;
1599
1600         if (fi < 0 || fi > nb_input_files - 1 ||
1601             si < 0 || si > file_table[fi].nb_streams - 1) {
1602             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1603             av_exit(1);
1604         }
1605         fi = stream_maps[i].sync_file_index;
1606         si = stream_maps[i].sync_stream_index;
1607         if (fi < 0 || fi > nb_input_files - 1 ||
1608             si < 0 || si > file_table[fi].nb_streams - 1) {
1609             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1610             av_exit(1);
1611         }
1612     }
1613
1614     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1615     if (!ost_table)
1616         goto fail;
1617     for(i=0;i<nb_ostreams;i++) {
1618         ost = av_mallocz(sizeof(AVOutputStream));
1619         if (!ost)
1620             goto fail;
1621         ost_table[i] = ost;
1622     }
1623
1624     n = 0;
1625     for(k=0;k<nb_output_files;k++) {
1626         os = output_files[k];
1627         for(i=0;i<os->nb_streams;i++,n++) {
1628             int found;
1629             ost = ost_table[n];
1630             ost->file_index = k;
1631             ost->index = i;
1632             ost->st = os->streams[i];
1633             if (nb_stream_maps > 0) {
1634                 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1635                     stream_maps[n].stream_index;
1636
1637                 /* Sanity check that the stream types match */
1638                 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1639                     int i= ost->file_index;
1640                     dump_format(output_files[i], i, output_files[i]->filename, 1);
1641                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1642                         stream_maps[n].file_index, stream_maps[n].stream_index,
1643                         ost->file_index, ost->index);
1644                     av_exit(1);
1645                 }
1646
1647             } else {
1648                 if(opt_programid) {
1649                     found = 0;
1650                     j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1651                     if(j != -1) {
1652                         ost->source_index = j;
1653                         found = 1;
1654                     }
1655                 } else {
1656                     /* get corresponding input stream index : we select the first one with the right type */
1657                     found = 0;
1658                     for(j=0;j<nb_istreams;j++) {
1659                         ist = ist_table[j];
1660                         if (ist->discard &&
1661                             ist->st->codec->codec_type == ost->st->codec->codec_type) {
1662                             ost->source_index = j;
1663                             found = 1;
1664                             break;
1665                         }
1666                     }
1667                 }
1668
1669                 if (!found) {
1670                     if(! opt_programid) {
1671                         /* try again and reuse existing stream */
1672                         for(j=0;j<nb_istreams;j++) {
1673                             ist = ist_table[j];
1674                             if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1675                                 ost->source_index = j;
1676                                 found = 1;
1677                             }
1678                         }
1679                     }
1680                     if (!found) {
1681                         int i= ost->file_index;
1682                         dump_format(output_files[i], i, output_files[i]->filename, 1);
1683                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1684                                 ost->file_index, ost->index);
1685                         av_exit(1);
1686                     }
1687                 }
1688             }
1689             ist = ist_table[ost->source_index];
1690             ist->discard = 0;
1691             ost->sync_ist = (nb_stream_maps > 0) ?
1692                 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1693                          stream_maps[n].sync_stream_index] : ist;
1694         }
1695     }
1696
1697     /* for each output stream, we compute the right encoding parameters */
1698     for(i=0;i<nb_ostreams;i++) {
1699         ost = ost_table[i];
1700         os = output_files[ost->file_index];
1701         ist = ist_table[ost->source_index];
1702
1703         codec = ost->st->codec;
1704         icodec = ist->st->codec;
1705
1706         if (!ost->st->language[0])
1707             av_strlcpy(ost->st->language, ist->st->language,
1708                        sizeof(ost->st->language));
1709
1710         ost->st->disposition = ist->st->disposition;
1711
1712         if (ost->st->stream_copy) {
1713             /* if stream_copy is selected, no need to decode or encode */
1714             codec->codec_id = icodec->codec_id;
1715             codec->codec_type = icodec->codec_type;
1716
1717             if(!codec->codec_tag){
1718                 if(   !os->oformat->codec_tag
1719                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1720                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1721                     codec->codec_tag = icodec->codec_tag;
1722             }
1723
1724             codec->bit_rate = icodec->bit_rate;
1725             codec->extradata= icodec->extradata;
1726             codec->extradata_size= icodec->extradata_size;
1727             if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1728                 codec->time_base = icodec->time_base;
1729             else
1730                 codec->time_base = ist->st->time_base;
1731             switch(codec->codec_type) {
1732             case CODEC_TYPE_AUDIO:
1733                 if(audio_volume != 256) {
1734                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1735                     av_exit(1);
1736                 }
1737                 codec->sample_rate = icodec->sample_rate;
1738                 codec->channels = icodec->channels;
1739                 codec->frame_size = icodec->frame_size;
1740                 codec->block_align= icodec->block_align;
1741                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1742                     codec->block_align= 0;
1743                 if(codec->codec_id == CODEC_ID_AC3)
1744                     codec->block_align= 0;
1745                 break;
1746             case CODEC_TYPE_VIDEO:
1747                 if(using_vhook) {
1748                     fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1749                     av_exit(1);
1750                 }
1751                 codec->pix_fmt = icodec->pix_fmt;
1752                 codec->width = icodec->width;
1753                 codec->height = icodec->height;
1754                 codec->has_b_frames = icodec->has_b_frames;
1755                 break;
1756             case CODEC_TYPE_SUBTITLE:
1757                 break;
1758             default:
1759                 abort();
1760             }
1761         } else {
1762             switch(codec->codec_type) {
1763             case CODEC_TYPE_AUDIO:
1764                 if (av_fifo_init(&ost->fifo, 1024))
1765                     goto fail;
1766                 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1767                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1768                 icodec->request_channels = codec->channels;
1769                 ist->decoding_needed = 1;
1770                 ost->encoding_needed = 1;
1771                 break;
1772             case CODEC_TYPE_VIDEO:
1773                 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1774                 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1775                 ost->video_resample = ((codec->width != icodec->width -
1776                                 (frame_leftBand + frame_rightBand) +
1777                                 (frame_padleft + frame_padright)) ||
1778                         (codec->height != icodec->height -
1779                                 (frame_topBand  + frame_bottomBand) +
1780                                 (frame_padtop + frame_padbottom)) ||
1781                         (codec->pix_fmt != icodec->pix_fmt));
1782                 if (ost->video_crop) {
1783                     ost->topBand = frame_topBand;
1784                     ost->leftBand = frame_leftBand;
1785                 }
1786                 if (ost->video_pad) {
1787                     ost->padtop = frame_padtop;
1788                     ost->padleft = frame_padleft;
1789                     ost->padbottom = frame_padbottom;
1790                     ost->padright = frame_padright;
1791                     if (!ost->video_resample) {
1792                         avcodec_get_frame_defaults(&ost->pict_tmp);
1793                         if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1794                                          codec->width, codec->height))
1795                             goto fail;
1796                     }
1797                 }
1798                 if (ost->video_resample) {
1799                     avcodec_get_frame_defaults(&ost->pict_tmp);
1800                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1801                                          codec->width, codec->height)) {
1802                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1803                         av_exit(1);
1804                     }
1805                     sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1806                     ost->img_resample_ctx = sws_getContext(
1807                             icodec->width - (frame_leftBand + frame_rightBand),
1808                             icodec->height - (frame_topBand + frame_bottomBand),
1809                             icodec->pix_fmt,
1810                             codec->width - (frame_padleft + frame_padright),
1811                             codec->height - (frame_padtop + frame_padbottom),
1812                             codec->pix_fmt,
1813                             sws_flags, NULL, NULL, NULL);
1814                     if (ost->img_resample_ctx == NULL) {
1815                         fprintf(stderr, "Cannot get resampling context\n");
1816                         av_exit(1);
1817                     }
1818                     ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1819                 }
1820                 ost->encoding_needed = 1;
1821                 ist->decoding_needed = 1;
1822                 break;
1823             case CODEC_TYPE_SUBTITLE:
1824                 ost->encoding_needed = 1;
1825                 ist->decoding_needed = 1;
1826                 break;
1827             default:
1828                 abort();
1829                 break;
1830             }
1831             /* two pass mode */
1832             if (ost->encoding_needed &&
1833                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1834                 char logfilename[1024];
1835                 FILE *f;
1836                 int size;
1837                 char *logbuffer;
1838
1839                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1840                          pass_logfilename ?
1841                          pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1842                 if (codec->flags & CODEC_FLAG_PASS1) {
1843                     f = fopen(logfilename, "w");
1844                     if (!f) {
1845                         perror(logfilename);
1846                         av_exit(1);
1847                     }
1848                     ost->logfile = f;
1849                 } else {
1850                     /* read the log file */
1851                     f = fopen(logfilename, "r");
1852                     if (!f) {
1853                         perror(logfilename);
1854                         av_exit(1);
1855                     }
1856                     fseek(f, 0, SEEK_END);
1857                     size = ftell(f);
1858                     fseek(f, 0, SEEK_SET);
1859                     logbuffer = av_malloc(size + 1);
1860                     if (!logbuffer) {
1861                         fprintf(stderr, "Could not allocate log buffer\n");
1862                         av_exit(1);
1863                     }
1864                     size = fread(logbuffer, 1, size, f);
1865                     fclose(f);
1866                     logbuffer[size] = '\0';
1867                     codec->stats_in = logbuffer;
1868                 }
1869             }
1870         }
1871         if(codec->codec_type == CODEC_TYPE_VIDEO){
1872             int size= codec->width * codec->height;
1873             bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1874         }
1875     }
1876
1877     if (!bit_buffer)
1878         bit_buffer = av_malloc(bit_buffer_size);
1879     if (!bit_buffer)
1880         goto fail;
1881
1882     /* dump the file output parameters - cannot be done before in case
1883        of stream copy */
1884     for(i=0;i<nb_output_files;i++) {
1885         dump_format(output_files[i], i, output_files[i]->filename, 1);
1886     }
1887
1888     /* dump the stream mapping */
1889     if (verbose >= 0) {
1890         fprintf(stderr, "Stream mapping:\n");
1891         for(i=0;i<nb_ostreams;i++) {
1892             ost = ost_table[i];
1893             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1894                     ist_table[ost->source_index]->file_index,
1895                     ist_table[ost->source_index]->index,
1896                     ost->file_index,
1897                     ost->index);
1898             if (ost->sync_ist != ist_table[ost->source_index])
1899                 fprintf(stderr, " [sync #%d.%d]",
1900                         ost->sync_ist->file_index,
1901                         ost->sync_ist->index);
1902             fprintf(stderr, "\n");
1903         }
1904     }
1905
1906     /* open each encoder */
1907     for(i=0;i<nb_ostreams;i++) {
1908         ost = ost_table[i];
1909         if (ost->encoding_needed) {
1910             AVCodec *codec = output_codecs[i];
1911             if (!codec)
1912                 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1913             if (!codec) {
1914                 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1915                         ost->file_index, ost->index);
1916                 av_exit(1);
1917             }
1918             if (avcodec_open(ost->st->codec, codec) < 0) {
1919                 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1920                         ost->file_index, ost->index);
1921                 av_exit(1);
1922             }
1923             extra_size += ost->st->codec->extradata_size;
1924         }
1925     }
1926
1927     /* open each decoder */
1928     for(i=0;i<nb_istreams;i++) {
1929         ist = ist_table[i];
1930         if (ist->decoding_needed) {
1931             AVCodec *codec = input_codecs[i];
1932             if (!codec)
1933                 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1934             if (!codec) {
1935                 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1936                         ist->st->codec->codec_id, ist->file_index, ist->index);
1937                 av_exit(1);
1938             }
1939             if (avcodec_open(ist->st->codec, codec) < 0) {
1940                 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1941                         ist->file_index, ist->index);
1942                 av_exit(1);
1943             }
1944             //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1945             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1946         }
1947     }
1948
1949     /* init pts */
1950     for(i=0;i<nb_istreams;i++) {
1951         ist = ist_table[i];
1952         is = input_files[ist->file_index];
1953         ist->pts = 0;
1954         ist->next_pts = AV_NOPTS_VALUE;
1955         ist->is_start = 1;
1956     }
1957
1958     /* set meta data information from input file if required */
1959     for (i=0;i<nb_meta_data_maps;i++) {
1960         AVFormatContext *out_file;
1961         AVFormatContext *in_file;
1962
1963         int out_file_index = meta_data_maps[i].out_file;
1964         int in_file_index = meta_data_maps[i].in_file;
1965         if (out_file_index < 0 || out_file_index >= nb_output_files) {
1966             fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1967             ret = AVERROR(EINVAL);
1968             goto fail;
1969         }
1970         if (in_file_index < 0 || in_file_index >= nb_input_files) {
1971             fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1972             ret = AVERROR(EINVAL);
1973             goto fail;
1974         }
1975
1976         out_file = output_files[out_file_index];
1977         in_file = input_files[in_file_index];
1978
1979         strcpy(out_file->title, in_file->title);
1980         strcpy(out_file->author, in_file->author);
1981         strcpy(out_file->copyright, in_file->copyright);
1982         strcpy(out_file->comment, in_file->comment);
1983         strcpy(out_file->album, in_file->album);
1984         out_file->year = in_file->year;
1985         out_file->track = in_file->track;
1986         strcpy(out_file->genre, in_file->genre);
1987     }
1988
1989     /* open files and write file headers */
1990     for(i=0;i<nb_output_files;i++) {
1991         os = output_files[i];
1992         if (av_write_header(os) < 0) {
1993             fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1994             ret = AVERROR(EINVAL);
1995             goto fail;
1996         }
1997         if (strcmp(output_files[i]->oformat->name, "rtp")) {
1998             want_sdp = 0;
1999         }
2000     }
2001     if (want_sdp) {
2002         print_sdp(output_files, nb_output_files);
2003     }
2004
2005     if (!using_stdin && verbose >= 0) {
2006         fprintf(stderr, "Press [q] to stop encoding\n");
2007         url_set_interrupt_cb(decode_interrupt_cb);
2008     }
2009     term_init();
2010
2011     key = -1;
2012     timer_start = av_gettime();
2013
2014     for(; received_sigterm == 0;) {
2015         int file_index, ist_index;
2016         AVPacket pkt;
2017         double ipts_min;
2018         double opts_min;
2019
2020     redo:
2021         ipts_min= 1e100;
2022         opts_min= 1e100;
2023         /* if 'q' pressed, exits */
2024         if (!using_stdin) {
2025             if (q_pressed)
2026                 break;
2027             /* read_key() returns 0 on EOF */
2028             key = read_key();
2029             if (key == 'q')
2030                 break;
2031         }
2032
2033         /* select the stream that we must read now by looking at the
2034            smallest output pts */
2035         file_index = -1;
2036         for(i=0;i<nb_ostreams;i++) {
2037             double ipts, opts;
2038             ost = ost_table[i];
2039             os = output_files[ost->file_index];
2040             ist = ist_table[ost->source_index];
2041             if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2042                 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2043             else
2044                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2045             ipts = (double)ist->pts;
2046             if (!file_table[ist->file_index].eof_reached){
2047                 if(ipts < ipts_min) {
2048                     ipts_min = ipts;
2049                     if(input_sync ) file_index = ist->file_index;
2050                 }
2051                 if(opts < opts_min) {
2052                     opts_min = opts;
2053                     if(!input_sync) file_index = ist->file_index;
2054                 }
2055             }
2056             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2057                 file_index= -1;
2058                 break;
2059             }
2060         }
2061         /* if none, if is finished */
2062         if (file_index < 0) {
2063             break;
2064         }
2065
2066         /* finish if recording time exhausted */
2067         if (opts_min >= (recording_time / 1000000.0))
2068             break;
2069
2070         /* finish if limit size exhausted */
2071         if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2072             break;
2073
2074         /* read a frame from it and output it in the fifo */
2075         is = input_files[file_index];
2076         if (av_read_frame(is, &pkt) < 0) {
2077             file_table[file_index].eof_reached = 1;
2078             if (opt_shortest)
2079                 break;
2080             else
2081                 continue;
2082         }
2083
2084         if (do_pkt_dump) {
2085             av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2086         }
2087         /* the following test is needed in case new streams appear
2088            dynamically in stream : we ignore them */
2089         if (pkt.stream_index >= file_table[file_index].nb_streams)
2090             goto discard_packet;
2091         ist_index = file_table[file_index].ist_index + pkt.stream_index;
2092         ist = ist_table[ist_index];
2093         if (ist->discard)
2094             goto discard_packet;
2095
2096         if (pkt.dts != AV_NOPTS_VALUE)
2097             pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2098         if (pkt.pts != AV_NOPTS_VALUE)
2099             pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2100
2101         if(input_files_ts_scale[file_index][pkt.stream_index]){
2102             if(pkt.pts != AV_NOPTS_VALUE)
2103                 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2104             if(pkt.dts != AV_NOPTS_VALUE)
2105                 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2106         }
2107
2108 //        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);
2109         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2110             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2111             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2112             int64_t delta= pkt_dts - ist->next_pts;
2113             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2114                 input_files_ts_offset[ist->file_index]-= delta;
2115                 if (verbose > 2)
2116                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2117                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2118                 if(pkt.pts != AV_NOPTS_VALUE)
2119                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2120             }
2121         }
2122
2123         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2124         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2125
2126             if (verbose >= 0)
2127                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2128                         ist->file_index, ist->index);
2129             if (exit_on_error)
2130                 av_exit(1);
2131             av_free_packet(&pkt);
2132             goto redo;
2133         }
2134
2135     discard_packet:
2136         av_free_packet(&pkt);
2137
2138         /* dump report by using the output first video and audio streams */
2139         print_report(output_files, ost_table, nb_ostreams, 0);
2140     }
2141
2142     /* at the end of stream, we must flush the decoder buffers */
2143     for(i=0;i<nb_istreams;i++) {
2144         ist = ist_table[i];
2145         if (ist->decoding_needed) {
2146             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2147         }
2148     }
2149
2150     term_exit();
2151
2152     /* write the trailer if needed and close file */
2153     for(i=0;i<nb_output_files;i++) {
2154         os = output_files[i];
2155         av_write_trailer(os);
2156     }
2157
2158     /* dump report by using the first video and audio streams */
2159     print_report(output_files, ost_table, nb_ostreams, 1);
2160
2161     /* close each encoder */
2162     for(i=0;i<nb_ostreams;i++) {
2163         ost = ost_table[i];
2164         if (ost->encoding_needed) {
2165             av_freep(&ost->st->codec->stats_in);
2166             avcodec_close(ost->st->codec);
2167         }
2168     }
2169
2170     /* close each decoder */
2171     for(i=0;i<nb_istreams;i++) {
2172         ist = ist_table[i];
2173         if (ist->decoding_needed) {
2174             avcodec_close(ist->st->codec);
2175         }
2176     }
2177
2178     /* finished ! */
2179
2180     ret = 0;
2181  fail1:
2182     av_freep(&bit_buffer);
2183     av_free(file_table);
2184
2185     if (ist_table) {
2186         for(i=0;i<nb_istreams;i++) {
2187             ist = ist_table[i];
2188             av_free(ist);
2189         }
2190         av_free(ist_table);
2191     }
2192     if (ost_table) {
2193         for(i=0;i<nb_ostreams;i++) {
2194             ost = ost_table[i];
2195             if (ost) {
2196                 if (ost->logfile) {
2197                     fclose(ost->logfile);
2198                     ost->logfile = NULL;
2199                 }
2200                 av_fifo_free(&ost->fifo); /* works even if fifo is not
2201                                              initialized but set to zero */
2202                 av_free(ost->pict_tmp.data[0]);
2203                 if (ost->video_resample)
2204                     sws_freeContext(ost->img_resample_ctx);
2205                 if (ost->resample)
2206                     audio_resample_close(ost->resample);
2207                 if (ost->reformat_ctx)
2208                     av_audio_convert_free(ost->reformat_ctx);
2209                 av_free(ost);
2210             }
2211         }
2212         av_free(ost_table);
2213     }
2214     return ret;
2215  fail:
2216     ret = AVERROR(ENOMEM);
2217     goto fail1;
2218 }
2219
2220 #if 0
2221 int file_read(const char *filename)
2222 {
2223     URLContext *h;
2224     unsigned char buffer[1024];
2225     int len, i;
2226
2227     if (url_open(&h, filename, O_RDONLY) < 0) {
2228         printf("could not open '%s'\n", filename);
2229         return -1;
2230     }
2231     for(;;) {
2232         len = url_read(h, buffer, sizeof(buffer));
2233         if (len <= 0)
2234             break;
2235         for(i=0;i<len;i++) putchar(buffer[i]);
2236     }
2237     url_close(h);
2238     return 0;
2239 }
2240 #endif
2241
2242 static void opt_format(const char *arg)
2243 {
2244     /* compatibility stuff for pgmyuv */
2245     if (!strcmp(arg, "pgmyuv")) {
2246         pgmyuv_compatibility_hack=1;
2247 //        opt_image_format(arg);
2248         arg = "image2";
2249         fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2250     }
2251
2252     file_iformat = av_find_input_format(arg);
2253     file_oformat = guess_format(arg, NULL, NULL);
2254     if (!file_iformat && !file_oformat) {
2255         fprintf(stderr, "Unknown input or output format: %s\n", arg);
2256         av_exit(1);
2257     }
2258 }
2259
2260 static void opt_video_rc_override_string(const char *arg)
2261 {
2262     video_rc_override_string = arg;
2263 }
2264
2265 static int opt_me_threshold(const char *opt, const char *arg)
2266 {
2267     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2268     return 0;
2269 }
2270
2271 static int opt_verbose(const char *opt, const char *arg)
2272 {
2273     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2274     av_log_set_level(verbose);
2275     return 0;
2276 }
2277
2278 static int opt_frame_rate(const char *opt, const char *arg)
2279 {
2280     if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2281         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2282         av_exit(1);
2283     }
2284     return 0;
2285 }
2286
2287 static int opt_bitrate(const char *opt, const char *arg)
2288 {
2289     int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2290
2291     opt_default(opt, arg);
2292
2293     if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2294         fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2295
2296     return 0;
2297 }
2298
2299 static void opt_frame_crop_top(const char *arg)
2300 {
2301     frame_topBand = atoi(arg);
2302     if (frame_topBand < 0) {
2303         fprintf(stderr, "Incorrect top crop size\n");
2304         av_exit(1);
2305     }
2306     if ((frame_topBand % 2) != 0) {
2307         fprintf(stderr, "Top crop size must be a multiple of 2\n");
2308         av_exit(1);
2309     }
2310     if ((frame_topBand) >= frame_height){
2311         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2312         av_exit(1);
2313     }
2314     frame_height -= frame_topBand;
2315 }
2316
2317 static void opt_frame_crop_bottom(const char *arg)
2318 {
2319     frame_bottomBand = atoi(arg);
2320     if (frame_bottomBand < 0) {
2321         fprintf(stderr, "Incorrect bottom crop size\n");
2322         av_exit(1);
2323     }
2324     if ((frame_bottomBand % 2) != 0) {
2325         fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2326         av_exit(1);
2327     }
2328     if ((frame_bottomBand) >= frame_height){
2329         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2330         av_exit(1);
2331     }
2332     frame_height -= frame_bottomBand;
2333 }
2334
2335 static void opt_frame_crop_left(const char *arg)
2336 {
2337     frame_leftBand = atoi(arg);
2338     if (frame_leftBand < 0) {
2339         fprintf(stderr, "Incorrect left crop size\n");
2340         av_exit(1);
2341     }
2342     if ((frame_leftBand % 2) != 0) {
2343         fprintf(stderr, "Left crop size must be a multiple of 2\n");
2344         av_exit(1);
2345     }
2346     if ((frame_leftBand) >= frame_width){
2347         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2348         av_exit(1);
2349     }
2350     frame_width -= frame_leftBand;
2351 }
2352
2353 static void opt_frame_crop_right(const char *arg)
2354 {
2355     frame_rightBand = atoi(arg);
2356     if (frame_rightBand < 0) {
2357         fprintf(stderr, "Incorrect right crop size\n");
2358         av_exit(1);
2359     }
2360     if ((frame_rightBand % 2) != 0) {
2361         fprintf(stderr, "Right crop size must be a multiple of 2\n");
2362         av_exit(1);
2363     }
2364     if ((frame_rightBand) >= frame_width){
2365         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2366         av_exit(1);
2367     }
2368     frame_width -= frame_rightBand;
2369 }
2370
2371 static void opt_frame_size(const char *arg)
2372 {
2373     if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2374         fprintf(stderr, "Incorrect frame size\n");
2375         av_exit(1);
2376     }
2377     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2378         fprintf(stderr, "Frame size must be a multiple of 2\n");
2379         av_exit(1);
2380     }
2381 }
2382
2383
2384 #define SCALEBITS 10
2385 #define ONE_HALF  (1 << (SCALEBITS - 1))
2386 #define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2387
2388 #define RGB_TO_Y(r, g, b) \
2389 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2390   FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2391
2392 #define RGB_TO_U(r1, g1, b1, shift)\
2393 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2394      FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2395
2396 #define RGB_TO_V(r1, g1, b1, shift)\
2397 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2398    FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2399
2400 static void opt_pad_color(const char *arg) {
2401     /* Input is expected to be six hex digits similar to
2402        how colors are expressed in html tags (but without the #) */
2403     int rgb = strtol(arg, NULL, 16);
2404     int r,g,b;
2405
2406     r = (rgb >> 16);
2407     g = ((rgb >> 8) & 255);
2408     b = (rgb & 255);
2409
2410     padcolor[0] = RGB_TO_Y(r,g,b);
2411     padcolor[1] = RGB_TO_U(r,g,b,0);
2412     padcolor[2] = RGB_TO_V(r,g,b,0);
2413 }
2414
2415 static void opt_frame_pad_top(const char *arg)
2416 {
2417     frame_padtop = atoi(arg);
2418     if (frame_padtop < 0) {
2419         fprintf(stderr, "Incorrect top pad size\n");
2420         av_exit(1);
2421     }
2422     if ((frame_padtop % 2) != 0) {
2423         fprintf(stderr, "Top pad size must be a multiple of 2\n");
2424         av_exit(1);
2425     }
2426 }
2427
2428 static void opt_frame_pad_bottom(const char *arg)
2429 {
2430     frame_padbottom = atoi(arg);
2431     if (frame_padbottom < 0) {
2432         fprintf(stderr, "Incorrect bottom pad size\n");
2433         av_exit(1);
2434     }
2435     if ((frame_padbottom % 2) != 0) {
2436         fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2437         av_exit(1);
2438     }
2439 }
2440
2441
2442 static void opt_frame_pad_left(const char *arg)
2443 {
2444     frame_padleft = atoi(arg);
2445     if (frame_padleft < 0) {
2446         fprintf(stderr, "Incorrect left pad size\n");
2447         av_exit(1);
2448     }
2449     if ((frame_padleft % 2) != 0) {
2450         fprintf(stderr, "Left pad size must be a multiple of 2\n");
2451         av_exit(1);
2452     }
2453 }
2454
2455
2456 static void opt_frame_pad_right(const char *arg)
2457 {
2458     frame_padright = atoi(arg);
2459     if (frame_padright < 0) {
2460         fprintf(stderr, "Incorrect right pad size\n");
2461         av_exit(1);
2462     }
2463     if ((frame_padright % 2) != 0) {
2464         fprintf(stderr, "Right pad size must be a multiple of 2\n");
2465         av_exit(1);
2466     }
2467 }
2468
2469 static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2470 {
2471     int i;
2472     char fmt_str[128];
2473     for (i=-1; i < nb_fmts; i++) {
2474         get_fmt_string (fmt_str, sizeof(fmt_str), i);
2475         fprintf(stdout, "%s\n", fmt_str);
2476     }
2477 }
2478
2479 static void opt_frame_pix_fmt(const char *arg)
2480 {
2481     if (strcmp(arg, "list"))
2482         frame_pix_fmt = avcodec_get_pix_fmt(arg);
2483     else {
2484         list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2485         av_exit(0);
2486     }
2487 }
2488
2489 static void opt_frame_aspect_ratio(const char *arg)
2490 {
2491     int x = 0, y = 0;
2492     double ar = 0;
2493     const char *p;
2494     char *end;
2495
2496     p = strchr(arg, ':');
2497     if (p) {
2498         x = strtol(arg, &end, 10);
2499         if (end == p)
2500             y = strtol(end+1, &end, 10);
2501         if (x > 0 && y > 0)
2502             ar = (double)x / (double)y;
2503     } else
2504         ar = strtod(arg, NULL);
2505
2506     if (!ar) {
2507         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2508         av_exit(1);
2509     }
2510     frame_aspect_ratio = ar;
2511 }
2512
2513 static void opt_qscale(const char *arg)
2514 {
2515     video_qscale = atof(arg);
2516     if (video_qscale <= 0 ||
2517         video_qscale > 255) {
2518         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2519         av_exit(1);
2520     }
2521 }
2522
2523 static void opt_top_field_first(const char *arg)
2524 {
2525     top_field_first= atoi(arg);
2526 }
2527
2528 static int opt_thread_count(const char *opt, const char *arg)
2529 {
2530     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2531 #if !defined(HAVE_THREADS)
2532     if (verbose >= 0)
2533         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2534 #endif
2535     return 0;
2536 }
2537
2538 static void opt_audio_sample_fmt(const char *arg)
2539 {
2540     if (strcmp(arg, "list"))
2541         audio_sample_fmt = avcodec_get_sample_fmt(arg);
2542     else {
2543         list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2544         av_exit(0);
2545     }
2546 }
2547
2548 static int opt_audio_rate(const char *opt, const char *arg)
2549 {
2550     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2551     return 0;
2552 }
2553
2554 static int opt_audio_channels(const char *opt, const char *arg)
2555 {
2556     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2557     return 0;
2558 }
2559
2560 static void opt_video_channel(const char *arg)
2561 {
2562     video_channel = strtol(arg, NULL, 0);
2563 }
2564
2565 static void opt_video_standard(const char *arg)
2566 {
2567     video_standard = av_strdup(arg);
2568 }
2569
2570 static void opt_codec(int *pstream_copy, char **pcodec_name,
2571                       int codec_type, const char *arg)
2572 {
2573     av_freep(pcodec_name);
2574     if (!strcmp(arg, "copy")) {
2575         *pstream_copy = 1;
2576     } else {
2577         *pcodec_name = av_strdup(arg);
2578     }
2579 }
2580
2581 static void opt_audio_codec(const char *arg)
2582 {
2583     opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2584 }
2585
2586 static void opt_audio_tag(const char *arg)
2587 {
2588     char *tail;
2589     audio_codec_tag= strtol(arg, &tail, 0);
2590
2591     if(!tail || *tail)
2592         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2593 }
2594
2595 static void opt_video_tag(const char *arg)
2596 {
2597     char *tail;
2598     video_codec_tag= strtol(arg, &tail, 0);
2599
2600     if(!tail || *tail)
2601         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2602 }
2603
2604 #ifdef CONFIG_VHOOK
2605 static void add_frame_hooker(const char *arg)
2606 {
2607     int argc = 0;
2608     char *argv[64];
2609     int i;
2610     char *args = av_strdup(arg);
2611
2612     using_vhook = 1;
2613
2614     argv[0] = strtok(args, " ");
2615     while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2616     }
2617
2618     i = frame_hook_add(argc, argv);
2619
2620     if (i != 0) {
2621         fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2622         av_exit(1);
2623     }
2624 }
2625 #endif
2626
2627 static void opt_video_codec(const char *arg)
2628 {
2629     opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2630 }
2631
2632 static void opt_subtitle_codec(const char *arg)
2633 {
2634     opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2635 }
2636
2637 static void opt_map(const char *arg)
2638 {
2639     AVStreamMap *m;
2640     char *p;
2641
2642     m = &stream_maps[nb_stream_maps++];
2643
2644     m->file_index = strtol(arg, &p, 0);
2645     if (*p)
2646         p++;
2647
2648     m->stream_index = strtol(p, &p, 0);
2649     if (*p) {
2650         p++;
2651         m->sync_file_index = strtol(p, &p, 0);
2652         if (*p)
2653             p++;
2654         m->sync_stream_index = strtol(p, &p, 0);
2655     } else {
2656         m->sync_file_index = m->file_index;
2657         m->sync_stream_index = m->stream_index;
2658     }
2659 }
2660
2661 static void opt_map_meta_data(const char *arg)
2662 {
2663     AVMetaDataMap *m;
2664     char *p;
2665
2666     m = &meta_data_maps[nb_meta_data_maps++];
2667
2668     m->out_file = strtol(arg, &p, 0);
2669     if (*p)
2670         p++;
2671
2672     m->in_file = strtol(p, &p, 0);
2673 }
2674
2675 static void opt_input_ts_scale(const char *arg)
2676 {
2677     unsigned int stream;
2678     double scale;
2679     char *p;
2680
2681     stream = strtol(arg, &p, 0);
2682     if (*p)
2683         p++;
2684     scale= strtod(p, &p);
2685
2686     if(stream >= MAX_STREAMS)
2687         av_exit(1);
2688
2689     input_files_ts_scale[nb_input_files][stream]= scale;
2690 }
2691
2692 static int opt_recording_time(const char *opt, const char *arg)
2693 {
2694     recording_time = parse_time_or_die(opt, arg, 1);
2695     return 0;
2696 }
2697
2698 static int opt_start_time(const char *opt, const char *arg)
2699 {
2700     start_time = parse_time_or_die(opt, arg, 1);
2701     return 0;
2702 }
2703
2704 static int opt_rec_timestamp(const char *opt, const char *arg)
2705 {
2706     rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2707     return 0;
2708 }
2709
2710 static int opt_input_ts_offset(const char *opt, const char *arg)
2711 {
2712     input_ts_offset = parse_time_or_die(opt, arg, 1);
2713     return 0;
2714 }
2715
2716 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2717 {
2718     const char *codec_string = encoder ? "encoder" : "decoder";
2719     AVCodec *codec;
2720
2721     if(!name)
2722         return CODEC_ID_NONE;
2723     codec = encoder ?
2724         avcodec_find_encoder_by_name(name) :
2725         avcodec_find_decoder_by_name(name);
2726     if(!codec) {
2727         av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2728         av_exit(1);
2729     }
2730     if(codec->type != type) {
2731         av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2732         av_exit(1);
2733     }
2734     return codec->id;
2735 }
2736
2737 static void opt_input_file(const char *filename)
2738 {
2739     AVFormatContext *ic;
2740     AVFormatParameters params, *ap = &params;
2741     int err, i, ret, rfps, rfps_base;
2742     int64_t timestamp;
2743
2744     if (!strcmp(filename, "-"))
2745         filename = "pipe:";
2746
2747     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2748                     !strcmp(filename, "/dev/stdin");
2749
2750     /* get default parameters from command line */
2751     ic = av_alloc_format_context();
2752
2753     memset(ap, 0, sizeof(*ap));
2754     ap->prealloced_context = 1;
2755     ap->sample_rate = audio_sample_rate;
2756     ap->channels = audio_channels;
2757     ap->time_base.den = frame_rate.num;
2758     ap->time_base.num = frame_rate.den;
2759     ap->width = frame_width + frame_padleft + frame_padright;
2760     ap->height = frame_height + frame_padtop + frame_padbottom;
2761     ap->pix_fmt = frame_pix_fmt;
2762    // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2763     ap->channel = video_channel;
2764     ap->standard = video_standard;
2765     ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2766     ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2767     if(pgmyuv_compatibility_hack)
2768         ap->video_codec_id= CODEC_ID_PGMYUV;
2769
2770     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2771
2772     ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2773     ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2774     ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2775
2776     /* open the input file with generic libav function */
2777     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2778     if (err < 0) {
2779         print_error(filename, err);
2780         av_exit(1);
2781     }
2782     if(opt_programid) {
2783         int i;
2784         for(i=0; i<ic->nb_programs; i++)
2785             if(ic->programs[i]->id != opt_programid)
2786                 ic->programs[i]->discard = AVDISCARD_ALL;
2787     }
2788
2789     ic->loop_input = loop_input;
2790
2791     /* If not enough info to get the stream parameters, we decode the
2792        first frames to get it. (used in mpeg case for example) */
2793     ret = av_find_stream_info(ic);
2794     if (ret < 0 && verbose >= 0) {
2795         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2796         av_exit(1);
2797     }
2798
2799     timestamp = start_time;
2800     /* add the stream start time */
2801     if (ic->start_time != AV_NOPTS_VALUE)
2802         timestamp += ic->start_time;
2803
2804     /* if seeking requested, we execute it */
2805     if (start_time != 0) {
2806         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2807         if (ret < 0) {
2808             fprintf(stderr, "%s: could not seek to position %0.3f\n",
2809                     filename, (double)timestamp / AV_TIME_BASE);
2810         }
2811         /* reset seek info */
2812         start_time = 0;
2813     }
2814
2815     /* update the current parameters so that they match the one of the input stream */
2816     for(i=0;i<ic->nb_streams;i++) {
2817         AVCodecContext *enc = ic->streams[i]->codec;
2818         if(thread_count>1)
2819             avcodec_thread_init(enc, thread_count);
2820         enc->thread_count= thread_count;
2821         switch(enc->codec_type) {
2822         case CODEC_TYPE_AUDIO:
2823             set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2824             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
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             enc->rate_emu = rate_emu;
2861             input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2862             if(video_disable)
2863                 ic->streams[i]->discard= AVDISCARD_ALL;
2864             else if(video_discard)
2865                 ic->streams[i]->discard= video_discard;
2866             break;
2867         case CODEC_TYPE_DATA:
2868             break;
2869         case CODEC_TYPE_SUBTITLE:
2870             input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2871             if(subtitle_disable)
2872                 ic->streams[i]->discard = AVDISCARD_ALL;
2873             break;
2874         case CODEC_TYPE_ATTACHMENT:
2875         case CODEC_TYPE_UNKNOWN:
2876             nb_icodecs++;
2877             break;
2878         default:
2879             abort();
2880         }
2881     }
2882
2883     input_files[nb_input_files] = ic;
2884     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2885     /* dump the file content */
2886     if (verbose >= 0)
2887         dump_format(ic, nb_input_files, filename, 0);
2888
2889     nb_input_files++;
2890     file_iformat = NULL;
2891     file_oformat = NULL;
2892
2893     video_channel = 0;
2894
2895     rate_emu = 0;
2896     av_freep(&video_codec_name);
2897     av_freep(&audio_codec_name);
2898     av_freep(&subtitle_codec_name);
2899 }
2900
2901 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2902                                          int *has_subtitle_ptr)
2903 {
2904     int has_video, has_audio, has_subtitle, i, j;
2905     AVFormatContext *ic;
2906
2907     has_video = 0;
2908     has_audio = 0;
2909     has_subtitle = 0;
2910     for(j=0;j<nb_input_files;j++) {
2911         ic = input_files[j];
2912         for(i=0;i<ic->nb_streams;i++) {
2913             AVCodecContext *enc = ic->streams[i]->codec;
2914             switch(enc->codec_type) {
2915             case CODEC_TYPE_AUDIO:
2916                 has_audio = 1;
2917                 break;
2918             case CODEC_TYPE_VIDEO:
2919                 has_video = 1;
2920                 break;
2921             case CODEC_TYPE_SUBTITLE:
2922                 has_subtitle = 1;
2923                 break;
2924             case CODEC_TYPE_DATA:
2925             case CODEC_TYPE_ATTACHMENT:
2926             case CODEC_TYPE_UNKNOWN:
2927                 break;
2928             default:
2929                 abort();
2930             }
2931         }
2932     }
2933     *has_video_ptr = has_video;
2934     *has_audio_ptr = has_audio;
2935     *has_subtitle_ptr = has_subtitle;
2936 }
2937
2938 static void new_video_stream(AVFormatContext *oc)
2939 {
2940     AVStream *st;
2941     AVCodecContext *video_enc;
2942     int codec_id;
2943
2944     st = av_new_stream(oc, oc->nb_streams);
2945     if (!st) {
2946         fprintf(stderr, "Could not alloc stream\n");
2947         av_exit(1);
2948     }
2949     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2950     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2951     video_bitstream_filters= NULL;
2952
2953     if(thread_count>1)
2954         avcodec_thread_init(st->codec, thread_count);
2955
2956     video_enc = st->codec;
2957
2958     if(video_codec_tag)
2959         video_enc->codec_tag= video_codec_tag;
2960
2961     if(   (video_global_header&1)
2962        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2963         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2964         avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2965     }
2966     if(video_global_header&2){
2967         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2968         avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2969     }
2970
2971     if (video_stream_copy) {
2972         st->stream_copy = 1;
2973         video_enc->codec_type = CODEC_TYPE_VIDEO;
2974         video_enc->sample_aspect_ratio =
2975         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
2976     } else {
2977         const char *p;
2978         int i;
2979         AVCodec *codec;
2980         AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2981
2982         if (video_codec_name) {
2983             codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2984             codec = avcodec_find_encoder_by_name(video_codec_name);
2985             output_codecs[nb_ocodecs] = codec;
2986         } else {
2987             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2988             codec = avcodec_find_encoder(codec_id);
2989         }
2990
2991         video_enc->codec_id = codec_id;
2992
2993         set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
2994
2995         if (codec && codec->supported_framerates && !force_fps)
2996             fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
2997         video_enc->time_base.den = fps.num;
2998         video_enc->time_base.num = fps.den;
2999
3000         video_enc->width = frame_width + frame_padright + frame_padleft;
3001         video_enc->height = frame_height + frame_padtop + frame_padbottom;
3002         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3003         video_enc->pix_fmt = frame_pix_fmt;
3004         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3005
3006         if(codec && codec->pix_fmts){
3007             const enum PixelFormat *p= codec->pix_fmts;
3008             for(; *p!=-1; p++){
3009                 if(*p == video_enc->pix_fmt)
3010                     break;
3011             }
3012             if(*p == -1)
3013                 video_enc->pix_fmt = codec->pix_fmts[0];
3014         }
3015
3016         if (intra_only)
3017             video_enc->gop_size = 0;
3018         if (video_qscale || same_quality) {
3019             video_enc->flags |= CODEC_FLAG_QSCALE;
3020             video_enc->global_quality=
3021                 st->quality = FF_QP2LAMBDA * video_qscale;
3022         }
3023
3024         if(intra_matrix)
3025             video_enc->intra_matrix = intra_matrix;
3026         if(inter_matrix)
3027             video_enc->inter_matrix = inter_matrix;
3028
3029         video_enc->thread_count = thread_count;
3030         p= video_rc_override_string;
3031         for(i=0; p; i++){
3032             int start, end, q;
3033             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3034             if(e!=3){
3035                 fprintf(stderr, "error parsing rc_override\n");
3036                 av_exit(1);
3037             }
3038             video_enc->rc_override=
3039                 av_realloc(video_enc->rc_override,
3040                            sizeof(RcOverride)*(i+1));
3041             video_enc->rc_override[i].start_frame= start;
3042             video_enc->rc_override[i].end_frame  = end;
3043             if(q>0){
3044                 video_enc->rc_override[i].qscale= q;
3045                 video_enc->rc_override[i].quality_factor= 1.0;
3046             }
3047             else{
3048                 video_enc->rc_override[i].qscale= 0;
3049                 video_enc->rc_override[i].quality_factor= -q/100.0;
3050             }
3051             p= strchr(p, '/');
3052             if(p) p++;
3053         }
3054         video_enc->rc_override_count=i;
3055         if (!video_enc->rc_initial_buffer_occupancy)
3056             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3057         video_enc->me_threshold= me_threshold;
3058         video_enc->intra_dc_precision= intra_dc_precision - 8;
3059
3060         if (do_psnr)
3061             video_enc->flags|= CODEC_FLAG_PSNR;
3062
3063         /* two pass mode */
3064         if (do_pass) {
3065             if (do_pass == 1) {
3066                 video_enc->flags |= CODEC_FLAG_PASS1;
3067             } else {
3068                 video_enc->flags |= CODEC_FLAG_PASS2;
3069             }
3070         }
3071     }
3072     nb_ocodecs++;
3073
3074     /* reset some key parameters */
3075     video_disable = 0;
3076     av_freep(&video_codec_name);
3077     video_stream_copy = 0;
3078 }
3079
3080 static void new_audio_stream(AVFormatContext *oc)
3081 {
3082     AVStream *st;
3083     AVCodecContext *audio_enc;
3084     int codec_id;
3085
3086     st = av_new_stream(oc, oc->nb_streams);
3087     if (!st) {
3088         fprintf(stderr, "Could not alloc stream\n");
3089         av_exit(1);
3090     }
3091     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3092
3093     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3094     audio_bitstream_filters= NULL;
3095
3096     if(thread_count>1)
3097         avcodec_thread_init(st->codec, thread_count);
3098
3099     audio_enc = st->codec;
3100     audio_enc->codec_type = CODEC_TYPE_AUDIO;
3101
3102     if(audio_codec_tag)
3103         audio_enc->codec_tag= audio_codec_tag;
3104
3105     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3106         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3107         avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3108     }
3109     if (audio_stream_copy) {
3110         st->stream_copy = 1;
3111         audio_enc->channels = audio_channels;
3112     } else {
3113         AVCodec *codec;
3114
3115         set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3116
3117         if (audio_codec_name) {
3118             codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3119             codec = avcodec_find_encoder_by_name(audio_codec_name);
3120             output_codecs[nb_ocodecs] = codec;
3121         } else {
3122             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3123             codec = avcodec_find_encoder(codec_id);
3124         }
3125         audio_enc->codec_id = codec_id;
3126
3127         if (audio_qscale > QSCALE_NONE) {
3128             audio_enc->flags |= CODEC_FLAG_QSCALE;
3129             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3130         }
3131         audio_enc->thread_count = thread_count;
3132         audio_enc->channels = audio_channels;
3133         audio_enc->sample_fmt = audio_sample_fmt;
3134
3135         if(codec && codec->sample_fmts){
3136             const enum SampleFormat *p= codec->sample_fmts;
3137             for(; *p!=-1; p++){
3138                 if(*p == audio_enc->sample_fmt)
3139                     break;
3140             }
3141             if(*p == -1)
3142                 audio_enc->sample_fmt = codec->sample_fmts[0];
3143         }
3144     }
3145     nb_ocodecs++;
3146     audio_enc->sample_rate = audio_sample_rate;
3147     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3148     if (audio_language) {
3149         av_strlcpy(st->language, audio_language, sizeof(st->language));
3150         av_free(audio_language);
3151         audio_language = NULL;
3152     }
3153
3154     /* reset some key parameters */
3155     audio_disable = 0;
3156     av_freep(&audio_codec_name);
3157     audio_stream_copy = 0;
3158 }
3159
3160 static void new_subtitle_stream(AVFormatContext *oc)
3161 {
3162     AVStream *st;
3163     AVCodecContext *subtitle_enc;
3164
3165     st = av_new_stream(oc, oc->nb_streams);
3166     if (!st) {
3167         fprintf(stderr, "Could not alloc stream\n");
3168         av_exit(1);
3169     }
3170     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3171
3172     bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3173     subtitle_bitstream_filters= NULL;
3174
3175     subtitle_enc = st->codec;
3176     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3177     if (subtitle_stream_copy) {
3178         st->stream_copy = 1;
3179     } else {
3180         set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3181         subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3182         output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3183     }
3184     nb_ocodecs++;
3185
3186     if (subtitle_language) {
3187         av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3188         av_free(subtitle_language);
3189         subtitle_language = NULL;
3190     }
3191
3192     subtitle_disable = 0;
3193     av_freep(&subtitle_codec_name);
3194     subtitle_stream_copy = 0;
3195 }
3196
3197 static void opt_new_audio_stream(void)
3198 {
3199     AVFormatContext *oc;
3200     if (nb_output_files <= 0) {
3201         fprintf(stderr, "At least one output file must be specified\n");
3202         av_exit(1);
3203     }
3204     oc = output_files[nb_output_files - 1];
3205     new_audio_stream(oc);
3206 }
3207
3208 static void opt_new_video_stream(void)
3209 {
3210     AVFormatContext *oc;
3211     if (nb_output_files <= 0) {
3212         fprintf(stderr, "At least one output file must be specified\n");
3213         av_exit(1);
3214     }
3215     oc = output_files[nb_output_files - 1];
3216     new_video_stream(oc);
3217 }
3218
3219 static void opt_new_subtitle_stream(void)
3220 {
3221     AVFormatContext *oc;
3222     if (nb_output_files <= 0) {
3223         fprintf(stderr, "At least one output file must be specified\n");
3224         av_exit(1);
3225     }
3226     oc = output_files[nb_output_files - 1];
3227     new_subtitle_stream(oc);
3228 }
3229
3230 static void opt_output_file(const char *filename)
3231 {
3232     AVFormatContext *oc;
3233     int use_video, use_audio, use_subtitle;
3234     int input_has_video, input_has_audio, input_has_subtitle;
3235     AVFormatParameters params, *ap = &params;
3236
3237     if (!strcmp(filename, "-"))
3238         filename = "pipe:";
3239
3240     oc = av_alloc_format_context();
3241
3242     if (!file_oformat) {
3243         file_oformat = guess_format(NULL, filename, NULL);
3244         if (!file_oformat) {
3245             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3246                     filename);
3247             av_exit(1);
3248         }
3249     }
3250
3251     oc->oformat = file_oformat;
3252     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3253
3254     if (!strcmp(file_oformat->name, "ffm") &&
3255         av_strstart(filename, "http:", NULL)) {
3256         /* special case for files sent to ffserver: we get the stream
3257            parameters from ffserver */
3258         int err = read_ffserver_streams(oc, filename);
3259         if (err < 0) {
3260             print_error(filename, err);
3261             av_exit(1);
3262         }
3263     } else {
3264         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3265         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3266         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3267
3268         /* disable if no corresponding type found and at least one
3269            input file */
3270         if (nb_input_files > 0) {
3271             check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3272                                          &input_has_subtitle);
3273             if (!input_has_video)
3274                 use_video = 0;
3275             if (!input_has_audio)
3276                 use_audio = 0;
3277             if (!input_has_subtitle)
3278                 use_subtitle = 0;
3279         }
3280
3281         /* manual disable */
3282         if (audio_disable) {
3283             use_audio = 0;
3284         }
3285         if (video_disable) {
3286             use_video = 0;
3287         }
3288         if (subtitle_disable) {
3289             use_subtitle = 0;
3290         }
3291
3292         if (use_video) {
3293             new_video_stream(oc);
3294         }
3295
3296         if (use_audio) {
3297             new_audio_stream(oc);
3298         }
3299
3300         if (use_subtitle) {
3301             new_subtitle_stream(oc);
3302         }
3303
3304         oc->timestamp = rec_timestamp;
3305
3306         if (str_title)
3307             av_strlcpy(oc->title, str_title, sizeof(oc->title));
3308         if (str_author)
3309             av_strlcpy(oc->author, str_author, sizeof(oc->author));
3310         if (str_copyright)
3311             av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3312         if (str_comment)
3313             av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3314         if (str_album)
3315             av_strlcpy(oc->album, str_album, sizeof(oc->album));
3316         if (str_genre)
3317             av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3318     }
3319
3320     output_files[nb_output_files++] = oc;
3321
3322     /* check filename in case of an image number is expected */
3323     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3324         if (!av_filename_number_test(oc->filename)) {
3325             print_error(oc->filename, AVERROR_NUMEXPECTED);
3326             av_exit(1);
3327         }
3328     }
3329
3330     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3331         /* test if it already exists to avoid loosing precious files */
3332         if (!file_overwrite &&
3333             (strchr(filename, ':') == NULL ||
3334              filename[1] == ':' ||
3335              av_strstart(filename, "file:", NULL))) {
3336             if (url_exist(filename)) {
3337                 int c;
3338
3339                 if (!using_stdin) {
3340                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3341                     fflush(stderr);
3342                     c = getchar();
3343                     if (toupper(c) != 'Y') {
3344                         fprintf(stderr, "Not overwriting - exiting\n");
3345                         av_exit(1);
3346                     }
3347                 }
3348                 else {
3349                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3350                     av_exit(1);
3351                 }
3352             }
3353         }
3354
3355         /* open the file */
3356         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3357             fprintf(stderr, "Could not open '%s'\n", filename);
3358             av_exit(1);
3359         }
3360     }
3361
3362     memset(ap, 0, sizeof(*ap));
3363     if (av_set_parameters(oc, ap) < 0) {
3364         fprintf(stderr, "%s: Invalid encoding parameters\n",
3365                 oc->filename);
3366         av_exit(1);
3367     }
3368
3369     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3370     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3371     oc->loop_output = loop_output;
3372
3373     set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3374
3375     /* reset some options */
3376     file_oformat = NULL;
3377     file_iformat = NULL;
3378 }
3379
3380 /* same option as mencoder */
3381 static void opt_pass(const char *pass_str)
3382 {
3383     int pass;
3384     pass = atoi(pass_str);
3385     if (pass != 1 && pass != 2) {
3386         fprintf(stderr, "pass number can be only 1 or 2\n");
3387         av_exit(1);
3388     }
3389     do_pass = pass;
3390 }
3391
3392 static int64_t getutime(void)
3393 {
3394 #ifdef HAVE_GETRUSAGE
3395     struct rusage rusage;
3396
3397     getrusage(RUSAGE_SELF, &rusage);
3398     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3399 #elif defined(HAVE_GETPROCESSTIMES)
3400     HANDLE proc;
3401     FILETIME c, e, k, u;
3402     proc = GetCurrentProcess();
3403     GetProcessTimes(proc, &c, &e, &k, &u);
3404     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3405 #else
3406     return av_gettime();
3407 #endif
3408 }
3409
3410 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3411 {
3412     int i;
3413     const char *p = str;
3414     for(i = 0;; i++) {
3415         dest[i] = atoi(p);
3416         if(i == 63)
3417             break;
3418         p = strchr(p, ',');
3419         if(!p) {
3420             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3421             av_exit(1);
3422         }
3423         p++;
3424     }
3425 }
3426
3427 static void opt_inter_matrix(const char *arg)
3428 {
3429     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3430     parse_matrix_coeffs(inter_matrix, arg);
3431 }
3432
3433 static void opt_intra_matrix(const char *arg)
3434 {
3435     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3436     parse_matrix_coeffs(intra_matrix, arg);
3437 }
3438
3439 /**
3440  * Trivial log callback.
3441  * Only suitable for show_help and similar since it lacks prefix handling.
3442  */
3443 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3444 {
3445     vfprintf(stdout, fmt, vl);
3446 }
3447
3448 static void show_help(void)
3449 {
3450     av_log_set_callback(log_callback_help);
3451     printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3452            "Hyper fast Audio and Video encoder\n");
3453     printf("\n");
3454     show_help_options(options, "Main options:\n",
3455                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3456     show_help_options(options, "\nAdvanced options:\n",
3457                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3458                       OPT_EXPERT);
3459     show_help_options(options, "\nVideo options:\n",
3460                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3461                       OPT_VIDEO);
3462     show_help_options(options, "\nAdvanced Video options:\n",
3463                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3464                       OPT_VIDEO | OPT_EXPERT);
3465     show_help_options(options, "\nAudio options:\n",
3466                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3467                       OPT_AUDIO);
3468     show_help_options(options, "\nAdvanced Audio options:\n",
3469                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3470                       OPT_AUDIO | OPT_EXPERT);
3471     show_help_options(options, "\nSubtitle options:\n",
3472                       OPT_SUBTITLE | OPT_GRAB,
3473                       OPT_SUBTITLE);
3474     show_help_options(options, "\nAudio/Video grab options:\n",
3475                       OPT_GRAB,
3476                       OPT_GRAB);
3477     printf("\n");
3478     av_opt_show(avctx_opts[0], NULL);
3479     printf("\n");
3480     av_opt_show(avformat_opts, NULL);
3481     printf("\n");
3482     av_opt_show(sws_opts, NULL);
3483 }
3484
3485 static void opt_target(const char *arg)
3486 {
3487     int norm = -1;
3488     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3489
3490     if(!strncmp(arg, "pal-", 4)) {
3491         norm = 0;
3492         arg += 4;
3493     } else if(!strncmp(arg, "ntsc-", 5)) {
3494         norm = 1;
3495         arg += 5;
3496     } else if(!strncmp(arg, "film-", 5)) {
3497         norm = 2;
3498         arg += 5;
3499     } else {
3500         int fr;
3501         /* Calculate FR via float to avoid int overflow */
3502         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3503         if(fr == 25000) {
3504             norm = 0;
3505         } else if((fr == 29970) || (fr == 23976)) {
3506             norm = 1;
3507         } else {
3508             /* Try to determine PAL/NTSC by peeking in the input files */
3509             if(nb_input_files) {
3510                 int i, j;
3511                 for(j = 0; j < nb_input_files; j++) {
3512                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3513                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3514                         if(c->codec_type != CODEC_TYPE_VIDEO)
3515                             continue;
3516                         fr = c->time_base.den * 1000 / c->time_base.num;
3517                         if(fr == 25000) {
3518                             norm = 0;
3519                             break;
3520                         } else if((fr == 29970) || (fr == 23976)) {
3521                             norm = 1;
3522                             break;
3523                         }
3524                     }
3525                     if(norm >= 0)
3526                         break;
3527                 }
3528             }
3529         }
3530         if(verbose && norm >= 0)
3531             fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3532     }
3533
3534     if(norm < 0) {
3535         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3536         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3537         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3538         av_exit(1);
3539     }
3540
3541     if(!strcmp(arg, "vcd")) {
3542
3543         opt_video_codec("mpeg1video");
3544         opt_audio_codec("mp2");
3545         opt_format("vcd");
3546
3547         opt_frame_size(norm ? "352x240" : "352x288");
3548         opt_frame_rate(NULL, frame_rates[norm]);
3549         opt_default("gop", norm ? "18" : "15");
3550
3551         opt_default("b", "1150000");
3552         opt_default("maxrate", "1150000");
3553         opt_default("minrate", "1150000");
3554         opt_default("bufsize", "327680"); // 40*1024*8;
3555
3556         opt_default("ab", "224000");
3557         audio_sample_rate = 44100;
3558         audio_channels = 2;
3559
3560         opt_default("packetsize", "2324");
3561         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3562
3563         /* We have to offset the PTS, so that it is consistent with the SCR.
3564            SCR starts at 36000, but the first two packs contain only padding
3565            and the first pack from the other stream, respectively, may also have
3566            been written before.
3567            So the real data starts at SCR 36000+3*1200. */
3568         mux_preload= (36000+3*1200) / 90000.0; //0.44
3569     } else if(!strcmp(arg, "svcd")) {
3570
3571         opt_video_codec("mpeg2video");
3572         opt_audio_codec("mp2");
3573         opt_format("svcd");
3574
3575         opt_frame_size(norm ? "480x480" : "480x576");
3576         opt_frame_rate(NULL, frame_rates[norm]);
3577         opt_default("gop", norm ? "18" : "15");
3578
3579         opt_default("b", "2040000");
3580         opt_default("maxrate", "2516000");
3581         opt_default("minrate", "0"); //1145000;
3582         opt_default("bufsize", "1835008"); //224*1024*8;
3583         opt_default("flags", "+scan_offset");
3584
3585
3586         opt_default("ab", "224000");
3587         audio_sample_rate = 44100;
3588
3589         opt_default("packetsize", "2324");
3590
3591     } else if(!strcmp(arg, "dvd")) {
3592
3593         opt_video_codec("mpeg2video");
3594         opt_audio_codec("ac3");
3595         opt_format("dvd");
3596
3597         opt_frame_size(norm ? "720x480" : "720x576");
3598         opt_frame_rate(NULL, frame_rates[norm]);
3599         opt_default("gop", norm ? "18" : "15");
3600
3601         opt_default("b", "6000000");
3602         opt_default("maxrate", "9000000");
3603         opt_default("minrate", "0"); //1500000;
3604         opt_default("bufsize", "1835008"); //224*1024*8;
3605
3606         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3607         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3608
3609         opt_default("ab", "448000");
3610         audio_sample_rate = 48000;
3611
3612     } else if(!strncmp(arg, "dv", 2)) {
3613
3614         opt_format("dv");
3615
3616         opt_frame_size(norm ? "720x480" : "720x576");
3617         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3618                                              (norm ? "yuv411p" : "yuv420p"));
3619         opt_frame_rate(NULL, frame_rates[norm]);
3620
3621         audio_sample_rate = 48000;
3622         audio_channels = 2;
3623
3624     } else {
3625         fprintf(stderr, "Unknown target: %s\n", arg);
3626         av_exit(1);
3627     }
3628 }
3629
3630 static void opt_vstats_file (const char *arg)
3631 {
3632     av_free (vstats_filename);
3633     vstats_filename=av_strdup (arg);
3634 }
3635
3636 static void opt_vstats (void)
3637 {
3638     char filename[40];
3639     time_t today2 = time(NULL);
3640     struct tm *today = localtime(&today2);
3641
3642     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3643              today->tm_sec);
3644     opt_vstats_file(filename);
3645 }
3646
3647 static int opt_bsf(const char *opt, const char *arg)
3648 {
3649     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3650     AVBitStreamFilterContext **bsfp;
3651
3652     if(!bsfc){
3653         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3654         av_exit(1);
3655     }
3656
3657     bsfp= *opt == 'v' ? &video_bitstream_filters :
3658           *opt == 'a' ? &audio_bitstream_filters :
3659                         &subtitle_bitstream_filters;
3660     while(*bsfp)
3661         bsfp= &(*bsfp)->next;
3662
3663     *bsfp= bsfc;
3664
3665     return 0;
3666 }
3667
3668 static int opt_preset(const char *opt, const char *arg)
3669 {
3670     FILE *f=NULL;
3671     char filename[1000], tmp[1000], tmp2[1000], line[1000];
3672     int i;
3673     const char *base[3]= { getenv("HOME"),
3674                            "/usr/local/share",
3675                            "/usr/share",
3676                          };
3677
3678     for(i=!base[0]; i<3 && !f; i++){
3679         snprintf(filename, sizeof(filename), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3680         f= fopen(filename, "r");
3681         if(!f){
3682             char *codec_name= *opt == 'v' ? video_codec_name :
3683                               *opt == 'a' ? audio_codec_name :
3684                                             subtitle_codec_name;
3685             snprintf(filename, sizeof(filename), "%s/%sffmpeg/%s-%s.ffpreset", base[i],  i ? "" : ".", codec_name, arg);
3686             f= fopen(filename, "r");
3687         }
3688     }
3689     if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3690               is_dos_path(arg))){
3691         snprintf(filename, sizeof(filename), arg);
3692         f= fopen(filename, "r");
3693     }
3694
3695     if(!f){
3696         fprintf(stderr, "File for preset '%s' not found\n", arg);
3697         av_exit(1);
3698     }
3699
3700     while(!feof(f)){
3701         int e= fscanf(f, "%999[^\n]\n", line) - 1;
3702         if(line[0] == '#' && !e)
3703             continue;
3704         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3705         if(e){
3706             fprintf(stderr, "%s: Preset file invalid\n", filename);
3707             av_exit(1);
3708         }
3709         if(!strcmp(tmp, "acodec")){
3710             opt_audio_codec(tmp2);
3711         }else if(!strcmp(tmp, "vcodec")){
3712             opt_video_codec(tmp2);
3713         }else if(!strcmp(tmp, "scodec")){
3714             opt_subtitle_codec(tmp2);
3715         }else if(opt_default(tmp, tmp2) < 0){
3716             fprintf(stderr, "%s: Invalid option or argument: %s=%s\n", filename, tmp, tmp2);
3717             av_exit(1);
3718         }
3719     }
3720
3721     fclose(f);
3722
3723     return 0;
3724 }
3725
3726 static const OptionDef options[] = {
3727     /* main options */
3728     { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3729     { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3730     { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3731     { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3732     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3733     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3734     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3735     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3736     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3737     { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3738     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3739     { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3740     { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3741     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3742     { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3743     { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3744     { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3745     { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3746     { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3747     { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3748     { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3749     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3750     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3751       "add timings for benchmarking" },
3752     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3753       "dump each input packet" },
3754     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3755       "when dumping packets, also dump the payload" },
3756     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3757     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3758     { "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)", "" },
3759     { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3760     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3761     { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3762     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3763     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3764     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3765     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3766     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3767     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3768     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3769     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3770     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3771
3772     /* video options */
3773     { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3774     { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3775     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3776     { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3777     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3778     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3779     { "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" },
3780     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3781     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3782     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3783     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3784     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3785     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3786     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3787     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3788     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3789     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3790     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3791     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3792     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3793     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3794     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3795     { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
3796     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3797       "use same video quality as source (implies VBR)" },
3798     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3799     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3800     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3801       "deinterlace pictures" },
3802     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3803     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3804     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3805 #ifdef CONFIG_VHOOK
3806     { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3807 #endif
3808     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3809     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3810     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3811     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3812     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3813     { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3814     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3815     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3816
3817     /* audio options */
3818     { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3819     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3820     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3821     { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3822     { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3823     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3824     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3825     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3826     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3827     { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3828     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3829     { "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" },
3830
3831     /* subtitle options */
3832     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3833     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3834     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3835     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3836
3837     /* grab options */
3838     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3839     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3840     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3841
3842     /* muxer options */
3843     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3844     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3845
3846     { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3847     { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3848     { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3849
3850     { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3851     { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3852     { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3853
3854     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3855     { NULL, },
3856 };
3857
3858 int main(int argc, char **argv)
3859 {
3860     int i;
3861     int64_t ti;
3862
3863     avcodec_register_all();
3864     avdevice_register_all();
3865     av_register_all();
3866
3867     if(isatty(STDIN_FILENO))
3868         url_set_interrupt_cb(decode_interrupt_cb);
3869
3870     for(i=0; i<CODEC_TYPE_NB; i++){
3871         avctx_opts[i]= avcodec_alloc_context2(i);
3872     }
3873     avformat_opts = av_alloc_format_context();
3874     sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3875
3876     show_banner();
3877     if (argc <= 1) {
3878         show_help();
3879         av_exit(1);
3880     }
3881
3882     /* parse options */
3883     parse_options(argc, argv, options, opt_output_file);
3884
3885     /* file converter / grab */
3886     if (nb_output_files <= 0) {
3887         fprintf(stderr, "Must supply at least one output file\n");
3888         av_exit(1);
3889     }
3890
3891     if (nb_input_files == 0) {
3892         fprintf(stderr, "Must supply at least one input file\n");
3893         av_exit(1);
3894     }
3895
3896     ti = getutime();
3897     av_encode(output_files, nb_output_files, input_files, nb_input_files,
3898               stream_maps, nb_stream_maps);
3899     ti = getutime() - ti;
3900     if (do_benchmark) {
3901         printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3902     }
3903
3904     return av_exit(0);
3905 }