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

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