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