流媒体/Mpeg4/MP4

开发平台：
Visual C++

MPEGaudio.h：源码内容
							/*
    SMPEG - SDL MPEG Player Library
    Copyright (C) 1999  Loki Entertainment Software
    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 "systems.h"
/* This improves the performance of the audio player by quite a bit */
#define THREADED_AUDIO
#include "SDL.h"
#include "MPEGerror.h"
#include "MPEGaction.h"
#ifdef THREADED_AUDIO
#include "MPEGring.h"
#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 */
#if 0
class MPEGaudio : public MPEGerror, public MPEGaudioaction {
    friend void Play_MPEGaudio(void *udata, Uint8 *stream, int len);
#ifdef THREADED_AUDIO
    friend int Decode_MPEGaudio(void *udata);
#endif
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);
    MPEGstatus Status(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(const SDL_AudioSpec *actual);
}
#endif
 
class MPEGaudio {
 public:
  MPEGaudio(void);
  ~MPEGaudio();
  int findheader(uint8_t *frombuffer,
		 uint32_t frombuffer_len,
		 uint32_t *framesize = NULL);
  int decodeFrame(uint8_t *tobuffer,
		  uint8_t *frombuffer,
		  uint32_t frombuffer_len);
protected:
    bool sdl_audio;
#if 0
    MPEGstream *mpeg;
#endif
    int valid_stream;
    bool stereo;
    double rate_in_s;
#if 0
    Uint32 frags_playing;
    Uint32 frag_time;
#ifdef THREADED_AUDIO
    bool decoding;
    SDL_Thread *decode_thread;
    void StartDecoding(void);
    void StopDecoding(void);
#endif
#endif
/* Code from splay 1.8.2 */
  /*****************************/
  /* Constant tables for layer */
  /*****************************/
private:
  static const int bitrate[2][3][15],frequencies[9];
  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 layer,protection,bitrateindex,padding,extendedmode;
  bool _mpeg25;
  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;
  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;
  uint32_t framesize;
  /*******************/
  /* Mpegtoraw class */
  /*******************/
public:
  void initialize();
  bool run(int frames, double *timestamp = NULL);
  void clearbuffer(void);
  bool isstereo(void) { return inputstereo == 1; } ;
  int getlayer(void) { return layer; };
  int getfrequency(void) {
    int index;
    index = version * 3 + frequency;
    if (_mpeg25) index += 3;
    return frequencies[index];
  } ;
  int getversion(void) { return version;};
  /*****************************/
  /* Loading MPEG-Audio stream */
  /*****************************/
private:
  unsigned char *_buffer;
  uint32_t _buflen;
  unsigned int _buffer_pos;
  int  bitindex;
  bool fillbuffer(uint32_t 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;
  short *rawdata;
#ifdef THREADED_AUDIO
  MPEG_ring *ring;
#else
  short  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];
};
#endif /* _MPEGAUDIO_H_ */

						