ffmpeg.c

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