Subversion Repositories Games.Descent

/*

    SMPEG - SDL MPEG Player Library

    Copyright (C) 1999  Loki Entertainment Software

    - Modified by Michel Darricau from eProcess <mdarricau@eprocess.fr>  for popcorn -

    This library is free software; you can redistribute it and/or

    modify it under the terms of the GNU Library General Public

    License as published by the Free Software Foundation; either

    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public

    License along with this library; if not, write to the Free

    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

/* A class based on the MPEG stream class, used to parse and play audio */

#ifndef _MPEGAUDIO_H_

#define _MPEGAUDIO_H_

#include "SDL.h"

#include "MPEGerror.h"

#include "MPEGaction.h"

#ifdef THREADED_AUDIO

#include "MPEGring.h"

#endif

void Play_MPEGaudioSDL(void *udata, Uint8 *stream, int len);

#ifdef THREADED_AUDIO

    int Decode_MPEGaudio(void *udata);

#endif

class MPEGstream;

/* MPEG/WAVE Sound library

   (C) 1997 by Woo-jae Jung */

/**************************/

/* Define values for MPEG */

/**************************/

#define SCALEBLOCK     12

#define CALCBUFFERSIZE 512

#define MAXSUBBAND     32

#define MAXCHANNEL     2

#define MAXTABLE       2

#define SCALE          32768

#define MAXSCALE       (SCALE-1)

#define MINSCALE       (-SCALE)

#define RAWDATASIZE    (2*2*32*SSLIMIT)

#define LS 0

#define RS 1

#define SSLIMIT      18

#define SBLIMIT      32

#define WINDOWSIZE    4096

// Huffmancode

#define HTN 34

/********************/

/* Type definitions */

/********************/

typedef float REAL;

typedef struct

{

  bool         generalflag;

  unsigned int part2_3_length;

  unsigned int big_values;

  unsigned int global_gain;

  unsigned int scalefac_compress;

  unsigned int window_switching_flag;

  unsigned int block_type;

  unsigned int mixed_block_flag;

  unsigned int table_select[3];

  unsigned int subblock_gain[3];

  unsigned int region0_count;

  unsigned int region1_count;

  unsigned int preflag;

  unsigned int scalefac_scale;

  unsigned int count1table_select;

}layer3grinfo;

typedef struct

{

  unsigned main_data_begin;

  unsigned private_bits;

  struct

  {

    unsigned scfsi[4];

    layer3grinfo gr[2];

  }ch[2];

}layer3sideinfo;

typedef struct

{

  int l[23];            /* [cb] */

  int s[3][13];         /* [window][cb] */

}layer3scalefactor;     /* [ch] */

typedef struct

{

  int tablename;

  unsigned int xlen,ylen;

  unsigned int linbits;

  unsigned int treelen;

  const unsigned int (*val)[2];

}HUFFMANCODETABLE;

// Class for Mpeg layer3

class Mpegbitwindow

{

public:

  Mpegbitwindow(){bitindex=point=0;};

  void initialize(void)  {bitindex=point=0;};

  int  gettotalbit(void) const {return bitindex;};

  void putbyte(int c)    {buffer[point&(WINDOWSIZE-1)]=c;point++;};

  void wrap(void);

  void rewind(int bits)  {bitindex-=bits;};

  void forward(int bits) {bitindex+=bits;};

  int getbit(void) {

      register int r=(buffer[bitindex>>3]>>(7-(bitindex&7)))&1;

      bitindex++;

      return r;

  }

  int getbits9(int bits)

  {

      register unsigned short a;

      { int offset=bitindex>>3;

        a=(((unsigned char)buffer[offset])<<8) | ((unsigned char)buffer[offset+1]);

      }

      a<<=(bitindex&7);

      bitindex+=bits;

      return (int)((unsigned int)(a>>(16-bits)));

  }

  int  getbits(int bits);

private:

  int  point,bitindex;

  char buffer[2*WINDOWSIZE];

};

/* The actual MPEG audio class */

class MPEGaudio : public MPEGerror, public MPEGaudioaction {

public:

    MPEGaudio(MPEGstream *stream, bool initSDL = true);

    virtual ~MPEGaudio();

    /* MPEG actions */

    bool GetAudioInfo(MPEG_AudioInfo *info);

    double Time(void);

    void Play(void);

    void Stop(void);

    void Rewind(void);

    void ResetSynchro(double time);

    void Skip(float seconds);

    void Volume(int vol);

                /* Michel Darricau from eProcess <mdarricau@eprocess.fr> conflict name in popcorn */

    MPEGstatus GetStatus(void);

    /* Returns the desired SDL audio spec for this stream */

    bool WantedSpec(SDL_AudioSpec *wanted);

    /* Inform SMPEG of the actual audio format if configuring SDL

       outside of this class */

    void ActualSpec(SDL_AudioSpec *actual);

protected:

    bool sdl_audio;

    MPEGstream *mpeg;

    int valid_stream;

    bool stereo;

    double rate_in_s;

    Uint32 frags_playing;

    Uint32 frag_time;

#ifdef THREADED_AUDIO

    bool decoding;

    SDL_Thread *decode_thread;

    void StartDecoding(void);

    void StopDecoding(void);

#endif

/* Code from splay 1.8.2 */

  /*****************************/

  /* Constant tables for layer */

  /*****************************/

private:

  static const int bitrate[2][3][15],frequencies[2][3];

  static const REAL scalefactorstable[64];

  static const HUFFMANCODETABLE ht[HTN];

  static const REAL filter[512];

  static REAL hcos_64[16],hcos_32[8],hcos_16[4],hcos_8[2],hcos_4;

  /*************************/

  /* MPEG header variables */

  /*************************/

private:

  int last_speed;

  int layer,protection,bitrateindex,padding,extendedmode;

  enum _mpegversion  {mpeg1,mpeg2}                               version;

  enum _mode    {fullstereo,joint,dual,single}                   mode;

  enum _frequency {frequency44100,frequency48000,frequency32000} frequency;

  /***************************************/

  /* Interface for setting music quality */

  /***************************************/

private:

  bool forcetomonoflag;

  bool forcetostereoflag;

  bool swapendianflag;

  int  downfrequency;

public:

  void setforcetomono(bool flag);

  void setdownfrequency(int value);

  /******************************/

  /* Frame management variables */

  /******************************/

private:

  int decodedframe,currentframe,totalframe;

  /***************************************/

  /* Variables made by MPEG-Audio header */

  /***************************************/

private:

  int tableindex,channelbitrate;

  int stereobound,subbandnumber,inputstereo,outputstereo;

  REAL scalefactor;

  int framesize;

  /*******************/

  /* Mpegtoraw class */

  /*******************/

public:

  void initialize();

  bool run(int frames, double *timestamp = NULL);

  void clearbuffer(void);

  /*****************************/

  /* Loading MPEG-Audio stream */

  /*****************************/

private:

  Uint8 _buffer[4096];

  Uint32 _buffer_pos;

  int  bitindex;

  bool fillbuffer(int size);

  void sync(void);

  bool issync(void);

  int getbyte(void);

  int getbit(void);

  int getbits8(void);

  int getbits9(int bits);

  int getbits(int bits);

  /********************/

  /* Global variables */

  /********************/

private:

  int lastfrequency,laststereo;

  // for Layer3

  int layer3slots,layer3framestart,layer3part2start;

  REAL prevblck[2][2][SBLIMIT][SSLIMIT];

  int currentprevblock;

  layer3sideinfo sideinfo;

  layer3scalefactor scalefactors[2];

  Mpegbitwindow bitwindow;

  int wgetbit  (void)    {return bitwindow.getbit  ();    }

  int wgetbits9(int bits){return bitwindow.getbits9(bits);}

  int wgetbits (int bits){return bitwindow.getbits (bits);}

  /*************************************/

  /* Decoding functions for each layer */

  /*************************************/

private:

  bool loadheader(void);

  //

  // Subbandsynthesis

  //

  REAL calcbufferL[2][CALCBUFFERSIZE],calcbufferR[2][CALCBUFFERSIZE];

  int  currentcalcbuffer,calcbufferoffset;

  void computebuffer(REAL *fraction,REAL buffer[2][CALCBUFFERSIZE]);

  void generatesingle(void);

  void generate(void);

  void subbandsynthesis(REAL *fractionL,REAL *fractionR);

  void computebuffer_2(REAL *fraction,REAL buffer[2][CALCBUFFERSIZE]);

  void generatesingle_2(void);

  void generate_2(void);

  void subbandsynthesis_2(REAL *fractionL,REAL *fractionR);

  // Extarctor

  void extractlayer1(void);    // MPEG-1

  void extractlayer2(void);

  void extractlayer3(void);

  void extractlayer3_2(void);  // MPEG-2

  // Functions for layer 3

  void layer3initialize(void);

  bool layer3getsideinfo(void);

  bool layer3getsideinfo_2(void);

  void layer3getscalefactors(int ch,int gr);

  void layer3getscalefactors_2(int ch);

  void layer3huffmandecode(int ch,int gr,int out[SBLIMIT][SSLIMIT]);

  REAL layer3twopow2(int scale,int preflag,int pretab_offset,int l);

  REAL layer3twopow2_1(int a,int b,int c);

  void layer3dequantizesample(int ch,int gr,int   in[SBLIMIT][SSLIMIT],

                                REAL out[SBLIMIT][SSLIMIT]);

  void layer3fixtostereo(int gr,REAL  in[2][SBLIMIT][SSLIMIT]);

  void layer3reorderandantialias(int ch,int gr,REAL  in[SBLIMIT][SSLIMIT],

                               REAL out[SBLIMIT][SSLIMIT]);

  void layer3hybrid(int ch,int gr,REAL in[SBLIMIT][SSLIMIT],

                          REAL out[SSLIMIT][SBLIMIT]);

  void huffmandecoder_1(const HUFFMANCODETABLE *h,int *x,int *y);

  void huffmandecoder_2(const HUFFMANCODETABLE *h,int *x,int *y,int *v,int *w);

  /********************/

  /* Playing raw data */

  /********************/

private:

  int     samplesperframe;

  int     rawdatareadoffset, rawdatawriteoffset;

  Sint16 *rawdata;

#ifdef THREADED_AUDIO

  MPEG_ring *ring;

#else

  Sint16  spillover[ RAWDATASIZE ];

#endif

  int volume;

  void clearrawdata(void)    {

        rawdatareadoffset=0;

        rawdatawriteoffset=0;

        rawdata=NULL;

  }

  void putraw(short int pcm) {rawdata[rawdatawriteoffset++]=pcm;}

  /********************/

  /* Timestamp sync   */

  /********************/

public:

#define N_TIMESTAMPS 5

  double timestamp[N_TIMESTAMPS];

  /* Functions which access MPEGaudio internals */

  friend void Play_MPEGaudioSDL(void *udata, Uint8 *stream, int len);

  friend int Play_MPEGaudio(MPEGaudio *audio, Uint8 *stream, int len);

#ifdef THREADED_AUDIO

  friend int Decode_MPEGaudio(void *udata);

#endif

};

/* Need to duplicate the prototypes, this is not a typo :) */

void Play_MPEGaudioSDL(void *udata, Uint8 *stream, int len);

int Play_MPEGaudio(MPEGaudio *audio, Uint8 *stream, int len);

#ifdef THREADED_AUDIO

int Decode_MPEGaudio(void *udata);

#endif

#endif /* _MPEGAUDIO_H_ */