layeriii.cpp

完整的MP3播放器源码

    }
    
    // apply formula per block type
    for (j=0; j<m_arrNonZero[dwCh]; j++) 
	{
        
        if (mIndex == nextCbBound)  
		{ /* Adjust critical band boundary */
            if (pGRLOCAL->wndSwitchFlag && 
			   (pGRLOCAL->nBlockType == 2)) 
			{
                if (pGRLOCAL->mixedBlockFlag)  
				{
                    if (mIndex == sfBandIndex[m_nFreqIdx].l[8])  
					{
                        nextCbBound = sfBandIndex[m_nFreqIdx].s[4];
                        nextCbBound = (nextCbBound << 2) - nextCbBound;
                        nCountb = 3;
                        nWidthCb = sfBandIndex[m_nFreqIdx].s[4] - sfBandIndex[m_nFreqIdx].s[3];
                        nBeginCb = sfBandIndex[m_nFreqIdx].s[3];
                        nBeginCb = (nBeginCb << 2) - nBeginCb;
                        
                    } 
					else if (mIndex < sfBandIndex[m_nFreqIdx].l[8]) 
					{
                        nextCbBound = sfBandIndex[m_nFreqIdx].l[(++nCountb)+1];
                    } 
					else 
					{
                        
                        nextCbBound = sfBandIndex[m_nFreqIdx].s[(++nCountb)+1];
                        nextCbBound = (nextCbBound << 2) - nextCbBound;
                        nBeginCb = sfBandIndex[m_nFreqIdx].s[nCountb];
                        nWidthCb = sfBandIndex[m_nFreqIdx].s[nCountb+1] -  nBeginCb;
                        nBeginCb = (nBeginCb << 2) - nBeginCb;
                    }
                    
                } 
				else  
				{
                    nextCbBound = sfBandIndex[m_nFreqIdx].s[(++nCountb)+1];
                    nextCbBound = (nextCbBound << 2) - nextCbBound;
                    nBeginCb = sfBandIndex[m_nFreqIdx].s[nCountb];
                    nWidthCb = sfBandIndex[m_nFreqIdx].s[nCountb+1] - nBeginCb;
                    nBeginCb = (nBeginCb << 2) - nBeginCb;
                }
           } 
		   else  
		   { // long blocks
              nextCbBound = sfBandIndex[m_nFreqIdx].l[(++nCountb)+1];
           }
        }
        // Do long/short dependent scaling operations
        
        if (pGRLOCAL->wndSwitchFlag &&
            (((pGRLOCAL->nBlockType == 2) && 
		    (pGRLOCAL->mixedBlockFlag == 0)) ||
			((pGRLOCAL->nBlockType == 2) && 
			pGRLOCAL->mixedBlockFlag && (j >= 36)) ))
        {
            
            tIndex = (mIndex - nBeginCb) / nWidthCb;
            /*            dbRectArr[sb][ss] *= pow(2.0, ((-2.0 * pGRLOCAL->arrSubBlockGain[tIndex])
                                           -(0.5 * (1.0 + pGRLOCAL->scaleFactScale)
                                           * m_sCALEF[dwCh].s[tIndex][nCountb]))); */
            DWORD idx = m_sCALEF[dwCh].s[tIndex][nCountb]  << pGRLOCAL->scaleFactScale;
            idx += (pGRLOCAL->arrSubBlockGain[tIndex] << 2);
            pDblRectArr[j] *= two_to_negative_half_pow[idx];
            
        } 
		else 
		{   // LONG block types 0,1,3 & 1st 2 subbands of switched blocks
            /*    dbRectArr[sb][ss] *= pow(2.0, -0.5 * (1.0+pGRLOCAL->scaleFactScale)
                                   * (m_sCALEF[dwCh].l[nCountb]
                                   + pGRLOCAL->preflag * pretab[nCountb])); */
			DWORD idx = m_sCALEF[dwCh].l[nCountb];
            
			if (pGRLOCAL->preflag)
				idx += pretab[nCountb];
			idx = idx << pGRLOCAL->scaleFactScale;
			pDblRectArr[j] *= two_to_negative_half_pow[idx];
        }
        mIndex++;
    }
	int nIndexx = m_arrNonZero[dwCh];
	ZeroMemory(pDblRectArr+nIndexx,sizeof(double)*(576-nIndexx));
    return;
}


void CLayerIII::SubBands(double dbRectArr[32][18])
{
   // 32 bands 18 samples/band
   
   
        

}
///////////////////////////////////////////////////////////////////////////////
//
void CLayerIII::Reorder(double dbRectArr[32][18], DWORD dwCh, DWORD dwGr)
{
    DWORD		dFreq, dFrew3;
    int			mIndex;
    int			nSfb, nSfbStart, nSfbLines;
    int			mSrcLine, iDesLine;
	STR_GRINFO*	pGRLOCAL	= &(m_SIDEINF.sArrCH[dwCh].sArrGRINF[dwGr]);
    double*		pDblRectArr = &dbRectArr[0][0];
    
    if (pGRLOCAL->wndSwitchFlag && (pGRLOCAL->nBlockType == 2)) 
	{
        
		ZeroMemory(m_dOutArr,sizeof(m_dOutArr));
        
        if (pGRLOCAL->mixedBlockFlag) 
		{
            // NO REORDER FOR LOW 2 SUBBANDS
			CopyMemory(m_dOutArr,pDblRectArr,sizeof(double)*36);

			
            
            // REORDERING FOR REST SWITCHED SHORT
            for(nSfb=3,nSfbStart=sfBandIndex[m_nFreqIdx].s[3],
				nSfbLines=sfBandIndex[m_nFreqIdx].s[4] - nSfbStart;
				nSfb < 13; nSfb++,nSfbStart = sfBandIndex[m_nFreqIdx].s[nSfb],
                (nSfbLines=sfBandIndex[m_nFreqIdx].s[nSfb+1] - nSfbStart))
            {
                int nSfbStart3 = (nSfbStart << 2) - nSfbStart;
                
                for(dFreq = 0, dFrew3 = 0; dFreq < (DWORD)nSfbLines; dFreq++, dFrew3 += 3) 
				{
                    
                    mSrcLine = nSfbStart3 + dFreq;
                    iDesLine = nSfbStart3 + dFrew3;
                    m_dOutArr[iDesLine] = pDblRectArr[mSrcLine];
                    mSrcLine += nSfbLines;
                    iDesLine++;
                    m_dOutArr[iDesLine] = pDblRectArr[mSrcLine];
                    mSrcLine += nSfbLines;
                    iDesLine++;
                    m_dOutArr[iDesLine] = pDblRectArr[mSrcLine];
                }
            }
            
		} 
		else 
		{  
			mIndex = 0;
			while(mIndex<576)
			{
				m_dOutArr[mIndex] = pDblRectArr[reorder_table[m_nFreqIdx][mIndex++]];
			}
        }
    }
    else 
	{
		CopyMemory(m_dOutArr,pDblRectArr,32*18*sizeof(DOUBLE));//sizeof(m_dOutArr));
    }
}

///////////////////////////////////////////////////////////////////////////////
//
void CLayerIII::IStereoKValues(DWORD dwIsPos, DWORD dwIoType,  DWORD dw)
{
     if (dwIsPos == 0) 
	{
        m_theKArray[0][dw] = 1.0f;
		m_theKArray[1][dw] = 1.0f;
    } 
	else if (dwIsPos & 1) 
	{
		m_theKArray[0][dw] = io[dwIoType][(dwIsPos + 1) >> 1];
        m_theKArray[1][dw] = 1.0f;
    } 
	else 
	{
        m_theKArray[0][dw] = 1.0f;
        m_theKArray[1][dw] = io[dwIoType][dwIsPos >> 1];
    }
}

///////////////////////////////////////////////////////////////////////////////
//
int CLayerIII::Stereo(DWORD dwGr)
{
    int sb, ss;



    if  (m_nChanels == 1) 
    {
		memcpy(m_cubeLr[0], m_cubeRo[0], sizeof(m_cubeLr[0][0][0]) * 18 * 32);
        /*
		for(ss=0; ss < 32; ss++)

			for(sb=0; sb < 18; sb+=3) 
            {
				m_cubeLr[0][ss][sb]   = m_cubeRo[0][ss][sb];
                m_cubeLr[0][ss][sb+1] = m_cubeRo[0][ss][sb+1];
				m_cubeLr[0][ss][sb+2] = m_cubeRo[0][ss][sb+2];
            }
			*/
    }
    else
    {
   	DWORD		dwIsPos[576];
	double		dRatio[576];
	STR_GRINFO *pGRLOCAL = &(m_SIDEINF.sArrCH[0].sArrGRINF[dwGr]);
	DWORD		dwExtensionMode = m_dwExtensionMode;
	int			nSfb;
	int			dw	= 0;
	int			lines, temp, temp2;

	BOOL	bStereoMs	= (m_flMode == 1) && (dwExtensionMode & 0x2);
	BOOL	bIStereo	= (m_flMode == 1) && (dwExtensionMode & 0x1);
	BOOL	bLayerVers	= (m_version == 0);
	DWORD	dwIoType	= (pGRLOCAL->scaleFactCompress & 1);

	// initialization
	while(dw < 576)        
		dwIsPos[dw++] = 7;
	

	if (bIStereo) 
	{
		if (pGRLOCAL->wndSwitchFlag && (pGRLOCAL->nBlockType == 2)) 
		{
			if (pGRLOCAL->mixedBlockFlag) 
			{
				int iSfbMax = 0;
            
				for (DWORD j=0; j<3; j++) 
				{
					int nSfbcnt = 2;
                
					for( nSfb=12; nSfb >=3; nSfb-- ) 
					{
						dw		= sfBandIndex[m_nFreqIdx].s[nSfb];
						lines	= sfBandIndex[m_nFreqIdx].s[nSfb+1] - dw;
						dw		= (dw << 2) - dw + (j+1) * lines - 1;
                    
						while (lines > 0) 
						{
							if (m_cubeRo[1][ss_div[dw]][ss_mod[dw]] != 0.0f) 
							{
								nSfbcnt = nSfb;
								nSfb = -10;
								lines = -10;
							}
							lines--;
							dw--;
						} 
					} 
					nSfb = nSfbcnt + 1;
					if (nSfb > iSfbMax)
					   iSfbMax = nSfb;
                
					while(nSfb < 12) 
					{
						temp = sfBandIndex[m_nFreqIdx].s[nSfb];
						sb   = sfBandIndex[m_nFreqIdx].s[nSfb+1] - temp;
						dw    = (temp << 2) - temp + j * sb;
                    
						for ( ; sb > 0; sb--) 
						{
							dwIsPos[dw] = m_sCALEF[1].s[j][nSfb];
							if (dwIsPos[dw] != 7)
							   if (bLayerVers)
							   IStereoKValues(dwIsPos[dw], dwIoType, dw);
							else
								dRatio[dw] = TAN12[dwIsPos[dw]];
                        
							dw++;
						} // for (; sb>0...
						nSfb++;
					} // while (nSfb < 12)
					nSfb	= sfBandIndex[m_nFreqIdx].s[10];
					sb  = sfBandIndex[m_nFreqIdx].s[11] - nSfb;
					nSfb	= (nSfb << 2) - nSfb + j * sb;
					temp	= sfBandIndex[m_nFreqIdx].s[11];
					sb	= sfBandIndex[m_nFreqIdx].s[12] - temp;
					dw		= (temp << 2) - temp + j * sb;
					for (; sb > 0; sb--) 
					{
						dwIsPos[dw] = dwIsPos[nSfb];
                    
						if (bLayerVers) 
						{
							m_theKArray[0][dw] = m_theKArray[0][nSfb];
							m_theKArray[1][dw] = m_theKArray[1][nSfb];
						} 
						else 
						{
							dRatio[dw] = dRatio[nSfb];
						}
						dw++;
					} 
				}
				if (iSfbMax <= 3) 
				{
					dw		= 2;
					ss	= 17;
					sb	= -1;

					while (dw >= 0) 
					{
						if (m_cubeRo[1][dw][ss] != 0.0f) 
						{
							sb = (dw<<4) + (dw<<1) + ss;
							dw = -1;
						} 
						else 
						{
							ss--;
							if (ss < 0) 
							{
								dw--;
								ss = 17;
							}
						} 
					} 
					dw = 0;
					while (sfBandIndex[m_nFreqIdx].l[dw] <= sb)
						  dw++;
					nSfb = dw;
					dw = sfBandIndex[m_nFreqIdx].l[dw];
					for (; nSfb<8; nSfb++) 
					{
						sb = sfBandIndex[m_nFreqIdx].l[nSfb+1] - 
								 sfBandIndex[m_nFreqIdx].l[nSfb];
						for (; sb>0; sb--) 
						{
							dwIsPos[dw] = m_sCALEF[1].l[nSfb];
							if (dwIsPos[dw] != 7)
							{
							   if (bLayerVers)
									IStereoKValues(dwIsPos[dw], dwIoType, dw);
							}
							else
								dRatio[dw] = TAN12[dwIsPos[dw]];
							dw++;
						} 
					} 
				} 
			} 
			else 
			{
				for (DWORD j=0; j<3; j++) 
				{
					int nSfbcnt = -1;
					for( nSfb=12; nSfb >=0; nSfb-- )
					{
						temp	= sfBandIndex[m_nFreqIdx].s[nSfb];
						lines	= sfBandIndex[m_nFreqIdx].s[nSfb+1] - temp;
						dw		= (temp << 2) - temp + (j+1) * lines - 1;
                    
						while (lines > 0) {
							if (m_cubeRo[1][ss_div[dw]][ss_mod[dw]] != 0.0f) 
							{
								nSfbcnt = nSfb;
								nSfb = -10;
								lines = -10;
							}
							lines--;
							dw--;
						} 
                    
					} 
					nSfb = nSfbcnt + 1;
					while(nSfb<12) 
					{
						temp	= sfBandIndex[m_nFreqIdx].s[nSfb];
						sb  = sfBandIndex[m_nFreqIdx].s[nSfb+1] - temp;
						dw		= (temp << 2) - temp + j * sb;
						for ( ; sb > 0; sb--) 
						{
							dwIsPos[dw] = m_sCALEF[1].s[j][nSfb];
							if (dwIsPos[dw] != 7)
							   if (bLayerVers)
							   IStereoKValues(dwIsPos[dw], dwIoType, dw);
							else
								dRatio[dw] = TAN12[dwIsPos[dw]];
							dw++;
						}
						nSfb++;
					} // while (nSfb<12)
                
					temp	= sfBandIndex[m_nFreqIdx].s[10];
					temp2	= sfBandIndex[m_nFreqIdx].s[11];
					sb  = temp2 - temp;
					nSfb	= (temp << 2) - temp + j * sb;
					sb  = sfBandIndex[m_nFreqIdx].s[12] - temp2;
					dw		= (temp2 << 2) - temp2 + j * sb;
                
					for (; sb>0; sb--) 
					{
						dwIsPos[dw] = dwIsPos[nSfb];
						if (bLayerVers) 
						{
							m_theKArray[0][dw] = m_theKArray[0][nSfb];
							m_theKArray[1][dw] = m_theKArray[1][nSfb];
						} 
						else 
						{
							dRatio[dw] = dRatio[nSfb];
						}
						dw++;