sbrside.c

从FFMPEG转换而来的H264解码程序,VC下编译..

		sbrGrid->envTimeBorder[env] = border * SAMPLES_PER_SLOT;
	}

	rel = 0;
	border = absBordTrail;
	for (env = sbrGrid->numEnv - 1; env > numRelLead; env--) {
		border -= relBordTrail[rel++];
		sbrGrid->envTimeBorder[env] = border * SAMPLES_PER_SLOT;
	}

	sbrGrid->envTimeBorder[sbrGrid->numEnv] = absBordTrail * SAMPLES_PER_SLOT;

	if (sbrGrid->numEnv > 1) {
		sbrGrid->numNoiseFloors = 2;
		sbrGrid->noiseTimeBorder[0] = sbrGrid->envTimeBorder[0];
		sbrGrid->noiseTimeBorder[1] = sbrGrid->envTimeBorder[middleBorder];
		sbrGrid->noiseTimeBorder[2] = sbrGrid->envTimeBorder[sbrGrid->numEnv];
	} else {
		sbrGrid->numNoiseFloors = 1;
		sbrGrid->noiseTimeBorder[0] = sbrGrid->envTimeBorder[0];
		sbrGrid->noiseTimeBorder[1] = sbrGrid->envTimeBorder[1];
	}
}

/**************************************************************************************
 * Function:    UnpackDeltaTimeFreq
 *
 * Description: unpack time/freq flags for delta coding of SBR envelopes (table 4.63)
 *
 * Inputs:      BitStreamInfo struct pointing to start of dt/df flags
 *              number of envelopes
 *              number of noise floors
 *
 * Outputs:     delta flags for envelope and noise floors
 *
 * Return:      none
 **************************************************************************************/
static void UnpackDeltaTimeFreq(BitStreamInfo *bsi, int numEnv, unsigned char *deltaFlagEnv,
								int numNoiseFloors, unsigned char *deltaFlagNoise)
{
	int env, noiseFloor;

	for (env = 0; env < numEnv; env++)
		deltaFlagEnv[env] = GetBits(bsi, 1);

	for (noiseFloor = 0; noiseFloor < numNoiseFloors; noiseFloor++)
		deltaFlagNoise[noiseFloor] = GetBits(bsi, 1);
}

/**************************************************************************************
 * Function:    UnpackInverseFilterMode
 *
 * Description: unpack invf flags for chirp factor calculation (table 4.64)
 *
 * Inputs:      BitStreamInfo struct pointing to start of invf flags
 *              number of noise floor bands
 *
 * Outputs:     invf flags for noise floor bands
 *
 * Return:      none
 **************************************************************************************/
static void UnpackInverseFilterMode(BitStreamInfo *bsi, int numNoiseFloorBands, unsigned char *mode)
{
	int n;

	for (n = 0; n < numNoiseFloorBands; n++)
		mode[n] = GetBits(bsi, 2);
}

/**************************************************************************************
 * Function:    UnpackSinusoids
 *
 * Description: unpack sinusoid (harmonic) flags for each SBR subband (table 4.67)
 *
 * Inputs:      BitStreamInfo struct pointing to start of sinusoid flags
 *              number of high resolution SBR subbands (nHigh)
 *
 * Outputs:     sinusoid flags for each SBR subband, zero-filled above nHigh
 *
 * Return:      none
 **************************************************************************************/
static void UnpackSinusoids(BitStreamInfo *bsi, int nHigh, int addHarmonicFlag, unsigned char *addHarmonic)
{
	int n;

	n = 0;
	if (addHarmonicFlag) {
		for (  ; n < nHigh; n++)
			addHarmonic[n] = GetBits(bsi, 1);
	}

	/* zero out unused bands */
	for (     ; n < MAX_QMF_BANDS; n++)
		addHarmonic[n] = 0;
}

/**************************************************************************************
 * Function:    CopyCouplingGrid
 *
 * Description: copy grid parameters from left to right for channel coupling
 *
 * Inputs:      initialized SBRGrid struct for left channel
 *
 * Outputs:     initialized SBRGrid struct for right channel
 *
 * Return:      none
 **************************************************************************************/
static void CopyCouplingGrid(SBRGrid *sbrGridLeft, SBRGrid *sbrGridRight)
{
	int env, noiseFloor;

	sbrGridRight->frameClass =     sbrGridLeft->frameClass;
	sbrGridRight->ampResFrame =    sbrGridLeft->ampResFrame;
	sbrGridRight->pointer =        sbrGridLeft->pointer;

	sbrGridRight->numEnv =         sbrGridLeft->numEnv;
	for (env = 0; env < sbrGridLeft->numEnv; env++) {
		sbrGridRight->envTimeBorder[env] = sbrGridLeft->envTimeBorder[env];
		sbrGridRight->freqRes[env] =       sbrGridLeft->freqRes[env];
	}
	sbrGridRight->envTimeBorder[env] = sbrGridLeft->envTimeBorder[env];	/* borders are [0, numEnv] inclusive */

	sbrGridRight->numNoiseFloors = sbrGridLeft->numNoiseFloors;
	for (noiseFloor = 0; noiseFloor <= sbrGridLeft->numNoiseFloors; noiseFloor++)
		sbrGridRight->noiseTimeBorder[noiseFloor] = sbrGridLeft->noiseTimeBorder[noiseFloor];

	/* numEnvPrev, numNoiseFloorsPrev, freqResPrev are updated in DecodeSBREnvelope() and DecodeSBRNoise() */
}

/**************************************************************************************
 * Function:    CopyCouplingInverseFilterMode
 *
 * Description: copy invf flags from left to right for channel coupling
 *
 * Inputs:      invf flags for left channel
 *              number of noise floor bands
 *
 * Outputs:     invf flags for right channel
 *
 * Return:      none
 **************************************************************************************/
static void CopyCouplingInverseFilterMode(int numNoiseFloorBands, unsigned char *modeLeft, unsigned char *modeRight)
{
	int band;

	for (band = 0; band < numNoiseFloorBands; band++)
		modeRight[band] = modeLeft[band];
}

/**************************************************************************************
 * Function:    UnpackSBRSingleChannel
 *
 * Description: unpack sideband info (grid, delta flags, invf flags, envelope and
 *                noise floor configuration, sinusoids) for a single channel
 *
 * Inputs:      BitStreamInfo struct pointing to start of sideband info
 *              initialized PSInfoSBR struct (after parsing SBR header and building
 *                frequency tables)
 *              base output channel (range = [0, nChans-1])
 *
 * Outputs:     updated PSInfoSBR struct (SBRGrid and SBRChan)
 *
 * Return:      none
 **************************************************************************************/
void UnpackSBRSingleChannel(BitStreamInfo *bsi, PSInfoSBR *psi, int chBase)
{
	int bitsLeft;
	SBRHeader *sbrHdr = &(psi->sbrHdr[chBase]);
	SBRGrid *sbrGridL = &(psi->sbrGrid[chBase+0]);
	SBRFreq *sbrFreq =  &(psi->sbrFreq[chBase]);
	SBRChan *sbrChanL = &(psi->sbrChan[chBase+0]);

	psi->dataExtra = GetBits(bsi, 1);
	if (psi->dataExtra)
		psi->resBitsData = GetBits(bsi, 4);

	UnpackSBRGrid(bsi, sbrHdr, sbrGridL);
	UnpackDeltaTimeFreq(bsi, sbrGridL->numEnv, sbrChanL->deltaFlagEnv, sbrGridL->numNoiseFloors, sbrChanL->deltaFlagNoise);
	UnpackInverseFilterMode(bsi, sbrFreq->numNoiseFloorBands, sbrChanL->invfMode[1]);

	DecodeSBREnvelope(bsi, psi, sbrGridL, sbrFreq, sbrChanL, 0);
	DecodeSBRNoise(bsi, psi, sbrGridL, sbrFreq, sbrChanL, 0);

	sbrChanL->addHarmonicFlag[1] = GetBits(bsi, 1);
	UnpackSinusoids(bsi, sbrFreq->nHigh, sbrChanL->addHarmonicFlag[1], sbrChanL->addHarmonic[1]);

	psi->extendedDataPresent = GetBits(bsi, 1);
	if (psi->extendedDataPresent) {
		psi->extendedDataSize = GetBits(bsi, 4);
		if (psi->extendedDataSize == 15)
			psi->extendedDataSize += GetBits(bsi, 8);

		bitsLeft = 8 * psi->extendedDataSize;

		/* get ID, unpack extension info, do whatever is necessary with it... */
		while (bitsLeft > 0) {
			GetBits(bsi, 8);
			bitsLeft -= 8;
		}
	}
}

/**************************************************************************************
 * Function:    UnpackSBRChannelPair
 *
 * Description: unpack sideband info (grid, delta flags, invf flags, envelope and
 *                noise floor configuration, sinusoids) for a channel pair
 *
 * Inputs:      BitStreamInfo struct pointing to start of sideband info
 *              initialized PSInfoSBR struct (after parsing SBR header and building
 *                frequency tables)
 *              base output channel (range = [0, nChans-1])
 *
 * Outputs:     updated PSInfoSBR struct (SBRGrid and SBRChan for both channels)
 *
 * Return:      none
 **************************************************************************************/
void UnpackSBRChannelPair(BitStreamInfo *bsi, PSInfoSBR *psi, int chBase)
{
	int bitsLeft;
	SBRHeader *sbrHdr = &(psi->sbrHdr[chBase]);
	SBRGrid *sbrGridL = &(psi->sbrGrid[chBase+0]), *sbrGridR = &(psi->sbrGrid[chBase+1]);
	SBRFreq *sbrFreq =  &(psi->sbrFreq[chBase]);
	SBRChan *sbrChanL = &(psi->sbrChan[chBase+0]), *sbrChanR = &(psi->sbrChan[chBase+1]);

	psi->dataExtra = GetBits(bsi, 1);
	if (psi->dataExtra) {
		psi->resBitsData = GetBits(bsi, 4);
		psi->resBitsData = GetBits(bsi, 4);
	}

	psi->couplingFlag = GetBits(bsi, 1);
	if (psi->couplingFlag) {
		UnpackSBRGrid(bsi, sbrHdr, sbrGridL);
		CopyCouplingGrid(sbrGridL, sbrGridR);

		UnpackDeltaTimeFreq(bsi, sbrGridL->numEnv, sbrChanL->deltaFlagEnv, sbrGridL->numNoiseFloors, sbrChanL->deltaFlagNoise);
		UnpackDeltaTimeFreq(bsi, sbrGridR->numEnv, sbrChanR->deltaFlagEnv, sbrGridR->numNoiseFloors, sbrChanR->deltaFlagNoise);

		UnpackInverseFilterMode(bsi, sbrFreq->numNoiseFloorBands, sbrChanL->invfMode[1]);
		CopyCouplingInverseFilterMode(sbrFreq->numNoiseFloorBands, sbrChanL->invfMode[1], sbrChanR->invfMode[1]);

		DecodeSBREnvelope(bsi, psi, sbrGridL, sbrFreq, sbrChanL, 0);
		DecodeSBRNoise(bsi, psi, sbrGridL, sbrFreq, sbrChanL, 0);
		DecodeSBREnvelope(bsi, psi, sbrGridR, sbrFreq, sbrChanR, 1);
		DecodeSBRNoise(bsi, psi, sbrGridR, sbrFreq, sbrChanR, 1);

		/* pass RIGHT sbrChan struct */
		UncoupleSBREnvelope(psi, sbrGridL, sbrFreq, sbrChanR);
		UncoupleSBRNoise(psi, sbrGridL, sbrFreq, sbrChanR);

	} else {
		UnpackSBRGrid(bsi, sbrHdr, sbrGridL);
		UnpackSBRGrid(bsi, sbrHdr, sbrGridR);
		UnpackDeltaTimeFreq(bsi, sbrGridL->numEnv, sbrChanL->deltaFlagEnv, sbrGridL->numNoiseFloors, sbrChanL->deltaFlagNoise);
		UnpackDeltaTimeFreq(bsi, sbrGridR->numEnv, sbrChanR->deltaFlagEnv, sbrGridR->numNoiseFloors, sbrChanR->deltaFlagNoise);
		UnpackInverseFilterMode(bsi, sbrFreq->numNoiseFloorBands, sbrChanL->invfMode[1]);
		UnpackInverseFilterMode(bsi, sbrFreq->numNoiseFloorBands, sbrChanR->invfMode[1]);

		DecodeSBREnvelope(bsi, psi, sbrGridL, sbrFreq, sbrChanL, 0);
		DecodeSBREnvelope(bsi, psi, sbrGridR, sbrFreq, sbrChanR, 1);
		DecodeSBRNoise(bsi, psi, sbrGridL, sbrFreq, sbrChanL, 0);
		DecodeSBRNoise(bsi, psi, sbrGridR, sbrFreq, sbrChanR, 1);
	}

	sbrChanL->addHarmonicFlag[1] = GetBits(bsi, 1);
	UnpackSinusoids(bsi, sbrFreq->nHigh, sbrChanL->addHarmonicFlag[1], sbrChanL->addHarmonic[1]);

	sbrChanR->addHarmonicFlag[1] = GetBits(bsi, 1);
	UnpackSinusoids(bsi, sbrFreq->nHigh, sbrChanR->addHarmonicFlag[1], sbrChanR->addHarmonic[1]);

	psi->extendedDataPresent = GetBits(bsi, 1);
	if (psi->extendedDataPresent) {
		psi->extendedDataSize = GetBits(bsi, 4);
		if (psi->extendedDataSize == 15)
			psi->extendedDataSize += GetBits(bsi, 8);

		bitsLeft = 8 * psi->extendedDataSize;

		/* get ID, unpack extension info, do whatever is necessary with it... */
		while (bitsLeft > 0) {
			GetBits(bsi, 8);
			bitsLeft -= 8;
		}
	}
}