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