git.sesse.net Git - ffmpeg/blob - ffmpeg.c

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