layeriii.h

完整的MP3播放器源码

//	LayerIII.h : Declaration of the CLayerIII
//	See Readme.txt
//
//
//////////////////////////////////////////////////////////////////////////////
#ifndef __LAYERIII_H_
#define __LAYERIII_H_

#include "resource.h"       // main symbols
#include "datatables.h"		// PROM DATA


#define EIGHTEEN 18
#define SBLIMIT 32
#define BUFSIZE 4096

// call back in the main thread for each sample Marius C.
typedef unsigned long (*PFN)(double* pSample,double* spec ,int nChannel);

///////////////////////////////////////////////////////////////////////////////
//
//      
class SynthesisFilter
{
  
public:
	
	SynthesisFilter(DWORD nChn);

	int	PrepPCMSampleX(BYTE *pMciBuff,int& samples,int& nOffset,
						PFN pFn = 0,void* pData = 0);

	// triger (bad limitation) of overlimit samples
   	_inline WORD Clip(double dbSamlpe)
	{
	  return ((dbSamlpe > 32767.0f) ? 32767 :
	         ((dbSamlpe < -32768.0f) ? -32768 :
			 (WORD) dbSamlpe));
	}


	_inline double	InSample(double dbSamlpe, DWORD nSubBand)
	{ 
		
//int	m_countIn;
//int m_lastband;
		m_tdbSubSamples[nSubBand] = dbSamlpe * m_gain[nSubBand];  

		// Marius C
		if(dbSamlpe < 0.0f)
			return (dbSamlpe*-1.0);
		return dbSamlpe;
    };


	// Marius C
    _inline void SetGain(double byGain,int idx)
	{
		switch(idx)
        {
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
            case 6:
            case 7:
                m_gain[idx]= byGain;		
                break;
            case 8:
                m_gain[8]= byGain;		
                m_gain[9]= byGain;		
                m_gain[10]= byGain;		
                
                break;
            case 9:
                m_gain[11]= byGain;		
                m_gain[12]= byGain;		
                m_gain[13]= byGain;		
                m_gain[14]= byGain;		
                break;
            case 10:
                m_gain[15]= byGain;		
                m_gain[16]= byGain;		
                m_gain[17]= byGain;		
                m_gain[18]= byGain;		
                m_gain[19]= byGain;		
                m_gain[20]= byGain;		
                
                break;
            case 11:
                m_gain[21]= byGain;		
                m_gain[22]= byGain;		
                m_gain[23]= byGain;		
                m_gain[24]= byGain;		
                m_gain[25]= byGain;		
                m_gain[26]= byGain;		
                m_gain[27]= byGain;		
                m_gain[28]= byGain;		
                m_gain[29]= byGain;		
                m_gain[30]= byGain;		
                m_gain[31]= byGain;		

                break;

        }
        
	}

    void	Reset();
////
private:
	
	// Marius C
	_inline void Append(int channel, int& offset,int& samples ,double dblv,WORD* pBuff)
	{
		pBuff[channel + (offset<<1)] = Clip(dblv);
		offset++;
		samples++;

	}
	
	void	CompNewTable();
private:

	double	m_tableA[512], m_tableB[512];
	double	m_tdbSubSamples[32];			// 32 new subband m_tdbSubSamples
	double*	m_pToTable;			
	DWORD	m_nWriteIndex;					// 0-15
	DWORD	m_nCan;
    double	m_gain[40];

	int	m_countIn;
	int m_lastband;

};

/////////////////////////////////////////////////////////////////////////////
// CLayerIII
//
class CLayerIII
{

public:
	
	void	Reset();
	BOOL	DecodeBlock(BYTE* pVarIn, DWORD nLength, 
						BYTE* pvOut, DWORD* outLevel,
                            DWORD mpVersion,
                            DWORD nMode,
                            DWORD freqIdx,
                            DWORD modeExtension);
	BOOL	Init(	DWORD mpVersion,
                    DWORD nMode,
					DWORD modeExtension, 
                    DWORD freqIdx, 
					long pFnCallBack = 0);

    void SetGain(double byGain,int idx)
	{
		if(m_pFilterX == 0 )
			return;

		m_pFilterX->SetGain(byGain, idx);
		m_pFilterY->SetGain(byGain, idx);

	}


    CLayerIII():m_pfnCallback(0),
	m_offset(0),
	m_PlayedBits(0),
	m_playedOctets(0),
	m_restBits(8),
	m_InWordAcumulated(0),
	m_pDwBuff(0)
	{
		// Marius C
			VERIFY(m_pDwBuff = new DWORD[BUFSIZE]);
	}

	~CLayerIII()
	{
		delete[] m_pDwBuff;
	    delete m_pFilterX;
		delete m_pFilterY;
		m_pFilterX = 0;
		m_pFilterY = 0;
//        TRACE("~CLayerIII()\r\n");
	}


// ILayerIII
private:
    	typedef	struct {
			int p23Len;
			int bigVal;
			int glbGain;
			int scaleFactCompress;
			int wndSwitchFlag;
			int nBlockType;
			int mixedBlockFlag;
			int arrSelect[3];
			int arrSubBlockGain[3];
			int region0Count;
			int region1Count;
			int preflag;
			int scaleFactScale;
			int countTblSelect;
		} STR_GRINFO;

	typedef struct {
			  int l[23];            // [cb] 
           int s[3][13];			// [window][cb] 
		  } STR_3SCALEFACT[2];

	typedef struct {
		  int dataMainStart;
 		  int privBits;
 		  struct 
		  {
			  int arrScfSi[4];
			  STR_GRINFO sArrGRINF[2];
		  } sArrCH[2];
	  } STR_3SIDEINFO;



private:
    void    ResolveChannels(int nMode);
	BOOL    GetSideInfo();
	void    GetScaleFact(DWORD dwCh, DWORD dwGr);
	void    GetLSFScaleData(DWORD dwCh, DWORD dwGr);
	void    GetLSFScaleFactor(DWORD dwCh, DWORD dwGr);
	void    HuffmanDecode(DWORD dwCh, DWORD dwGr);
	void    IStereoKValues(DWORD nIsPos, DWORD dwIoType, DWORD i);
	void    DeqSample(double dbRectArr[32][18], DWORD dwCh, DWORD dwGr);
	void    Reorder(double dbRectArr[32][18], DWORD dwCh, DWORD dwGr);
	int     Stereo(DWORD dwGr);
	void    AntiAlias(DWORD dwCh, DWORD dwGr);
	void    Hibrid(DWORD dwCh, DWORD dwGr);
	void    InvMdcdt(double *pDblIn, double *pDblOut, int nBlockType);
	DWORD   Bits(int nCount);
    int     HuffmanDec(sHUFDECTAB *h, int *x, int *y, int *v,int *w);
    void     SubBands(double dbRectArr[32][18]);
	DWORD	GetReadBits() const { return(m_PlayedBits); }
	DWORD	GetBits(DWORD dwBits);
	_inline DWORD	GetFastOneBit()
	{
		DWORD dwRetVal PURE;
		m_PlayedBits++;
		if (m_restBits == 0) 
		{
			m_restBits = 8;
			m_playedOctets++;
		}
		DWORD xmask = 0xFFFFFFFF >> (32 - m_restBits);
		dwRetVal = m_pDwBuff[m_playedOctets & 0xfff] & xmask;
		m_restBits--;
		dwRetVal = dwRetVal >> m_restBits;
		return dwRetVal;
	}

	_inline void AddTail(int dwRetVal)
	{
		m_pDwBuff[m_offset] = (BYTE)dwRetVal;
		m_offset = (m_offset + 1) & 0xfff;
	}

	void	GoBackBits(int dwBits);
	void	GoBackOctets(int bites = BUFSIZE);

private:
    int					m_nArray[SBLIMIT*EIGHTEEN];
	double				m_cubeRo[2][SBLIMIT][EIGHTEEN];
	double				m_cubeLr[2][SBLIMIT][EIGHTEEN];
	double				m_dOutArr[SBLIMIT*EIGHTEEN];
	double				m_PreBlkArr[2][SBLIMIT*EIGHTEEN];
	double				m_theKArray[2][SBLIMIT*EIGHTEEN];
	int					m_arrNonZero[2];
	DWORD				m_dwScale[54];

private:
	int					m_nChanels;
    int                 m_nChanel;
    int                 m_chFirst;
    int                 m_chLast;

	DWORD				m_dwMaxGr;
	int					m_nFrmStart;
	int					m_nPart2Start;
	DWORD				m_nFreqIdx;

	STR_3SIDEINFO		m_SIDEINF;
	STR_3SCALEFACT		m_sCALEF;

private:

	SynthesisFilter*	m_pFilterX; 
	SynthesisFilter*	m_pFilterY;

private:
    BYTE*				m_pbyWalk;
    int					m_nBitsOffset;	
	int					m_flMode;
	DWORD				m_dwExtensionMode;
    PFN                 m_pfnCallback;
    DWORD               m_version;	
	//bit pool reservoir data
	DWORD		m_offset;
	DWORD		m_PlayedBits;
	DWORD		m_playedOctets;
	DWORD		m_restBits;
	DWORD		m_InWordAcumulated;
	DWORD*		m_pDwBuff;

};

#endif //__LAYERIII_H_