sys_encoder_vopmbenc.cpp

完整的RTP RTSP代码库

			// shape quantization part
			m_statsMB.reset ();
#endif // __TRACE_AND_STATS_


			// MB rate control
			if (m_uiRateControl>=RC_TM5) 
			{
				Int iNewQP = m_tm5rc.tm5rc_calc_mquant(iMB, m_statsVOP.total());
				if(iNewQP>iQPPrev)
					iNewQP = iQPPrev + 2;
				else if(iNewQP<iQPPrev)
					iNewQP = iQPPrev - 2;
				updateQP(pmbmd, iQPPrev, iNewQP);
			}
			else
			{
#ifdef _MBQP_CHANGE_		
				Int iDQuant = 2*(rand() % 3) - 2;
				updateQP(pmbmd, iQPPrev, iQPPrev + iDQuant);
#else
				// no change in step size, but still need to call...
				updateQP(pmbmd, iQPPrev, iQPPrev);
#endif //_MBQP_CHANGE_
			}

			if(pmbmd->m_intStepDelta==-1 || pmbmd->m_intStepDelta==1 
				|| pmbmd->m_bColocatedMBSkip || pmbmd->m_mbType == DIRECT || pmbmd->m_bColocatedMBMCSEL)
				cancelQPUpdate(pmbmd);

			if ( m_volmd.bVPBitTh >= 0) {
				Int iCounter = m_pbitstrmOut -> getCounter();
				if( iCounter - m_iVPCounter > m_volmd.bVPBitTh ) {
					codeVideoPacketHeader (iMBX, iMBY, iQPPrev);	// video packet header
					m_iVPCounter = iCounter;
					//reset MV predictor
					m_vctForwardMvPredBVOP[0].x  = m_vctForwardMvPredBVOP[0].y  = 0;
					m_vctBackwardMvPredBVOP[0].x = m_vctBackwardMvPredBVOP[0].y = 0;
					m_vctForwardMvPredBVOP[1].x  = m_vctForwardMvPredBVOP[1].y  = 0;
					m_vctBackwardMvPredBVOP[1].x = m_vctBackwardMvPredBVOP[1].y = 0;

				}
			}

			if ((pmbmd->m_bColocatedMBSkip && !(pmbmd->m_bColocatedMBMCSEL)) && // GMC
			(m_volmd.volType == BASE_LAYER || (m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 3 && m_volmd.iEnhnType == 0)))
			{ // don't need to send any bit for this mode
				copyFromRefToCurrQ (
					m_pvopcRefQ0,
					x, y, 
					ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, NULL
				);
			}
			else {
				copyToCurrBuff (ppxlcOrigMBY, ppxlcOrigMBU, ppxlcOrigMBV, m_iFrameWidthY, m_iFrameWidthUV); 
				encodeBVOPMB (
					ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV,
					pmbmd, pmv, pmvBackward,
					pmbmdRef, pmvRef,
					iMBX, iMBY,
					x, y
				);
			}
		
			//printf("(%d)", pmbmd->m_stepSize);
			iQPPrev = pmbmd->m_stepSize;

			pmbmd++;
			pmv         += BVOP_MV_PER_REF_PER_MB;
			pmvBackward += BVOP_MV_PER_REF_PER_MB;
			pmvRef      += PVOP_MV_PER_REF_PER_MB;
			pmbmdRef++;
			m_statsVOP += m_statsMB;
			ppxlcCurrQMBY += MB_SIZE;
			ppxlcCurrQMBU += BLOCK_SIZE;
			ppxlcCurrQMBV += BLOCK_SIZE;
			ppxlcOrigMBY += MB_SIZE;
			ppxlcOrigMBU += BLOCK_SIZE;
			ppxlcOrigMBV += BLOCK_SIZE;
		}
		ppxlcCurrQY += m_iFrameWidthYxMBSize;
		ppxlcCurrQU += m_iFrameWidthUVxBlkSize;
		ppxlcCurrQV += m_iFrameWidthUVxBlkSize;
		
		ppxlcOrigY += m_iFrameWidthYxMBSize;
		ppxlcOrigU += m_iFrameWidthUVxBlkSize;
		ppxlcOrigV += m_iFrameWidthUVxBlkSize;
	}
}

Void CVideoObjectEncoder::encodeNSForBVOP_WithShape ()
{
	motionEstBVOP_WithShape ();
	
	// decide prediction direction for shape
	//OBSSFIX_MODE3
	if(m_volmd.volType == ENHN_LAYER && m_volmd.bSpatialScalability && m_volmd.iHierarchyType == 0 &&
		m_volmd.iEnhnType != 0 && m_volmd.iuseRefShape == 1)
	{
		m_vopmd.fShapeBPredDir = B_FORWARD;
	}
	else if(m_bCodedFutureRef==FALSE)
		m_vopmd.fShapeBPredDir = B_FORWARD;
	else
	{
		if(m_tFutureRef - m_t >= m_t - m_tPastRef)
			m_vopmd.fShapeBPredDir = B_FORWARD;
		else
			m_vopmd.fShapeBPredDir = B_BACKWARD;
	}
	
	Int iQPPrev = m_vopmd.intStepB;
	
	CoordI y = m_rctCurrVOPY.top; 
	CMBMode*	   pmbmd = m_rgmbmd;
	// Added for field based MC padding by Hyundai(1998-5-9)
	CMBMode* field_pmbmd = m_rgmbmd;
	// End of Hyundai(1998-5-9)
	
	CMotionVector* pmv = m_rgmv;
	CMotionVector* pmvBackward = m_rgmvBackward;
	CMotionVector* pmvBY = m_rgmvBY;
	
	//OBSS_SAIT_991015
	if(m_volmd.volType == BASE_LAYER && m_volmd.bSpatialScalability) {
		m_rgmvBaseBY = m_rgmvBY;
		m_rctBase = m_rctCurrVOPY;
	}
	Int xIndex, yIndex;
	xIndex = yIndex = 0;
	//OBSSFIX_MODE3
	if( m_volmd.volType == ENHN_LAYER && (m_volmd.bSpatialScalability && m_volmd.iHierarchyType==0) &&
		!(m_volmd.iEnhnType != 0 && m_volmd.iuseRefShape == 1)) {
		//	if(m_volmd.volType == ENHN_LAYER && (m_volmd.bSpatialScalability && m_volmd.iHierarchyType==0)) {
		//~OBSSFIX_MODE3
		xIndex = (m_rctCurrVOPY.left - (m_rctBase.left*	m_volmd.ihor_sampling_factor_n_shape/m_volmd.ihor_sampling_factor_m_shape));			
		yIndex = (m_rctCurrVOPY.top - (m_rctBase.top*m_volmd.iver_sampling_factor_n_shape/m_volmd.iver_sampling_factor_m_shape));			
		xIndex /= MB_SIZE;
		yIndex /= MB_SIZE;
	}
	//~OBSS_SAIT_991015
	
	PixelC* ppxlcCurrQY = (PixelC*) m_pvopcCurrQ->pixelsY () + m_iStartInRefToCurrRctY;
	PixelC* ppxlcCurrQU = (PixelC*) m_pvopcCurrQ->pixelsU () + m_iStartInRefToCurrRctUV;
	PixelC* ppxlcCurrQV = (PixelC*) m_pvopcCurrQ->pixelsV () + m_iStartInRefToCurrRctUV;
	PixelC* ppxlcCurrQBY = (PixelC*) m_pvopcCurrQ->pixelsBY () + m_iStartInRefToCurrRctY;
	PixelC **pppxlcCurrQA = NULL, **pppxlcOrigA = NULL;
	
	PixelC* ppxlcOrigY = (PixelC*) m_pvopcOrig->pixelsBoundY ();
	PixelC* ppxlcOrigU = (PixelC*) m_pvopcOrig->pixelsBoundU ();
	PixelC* ppxlcOrigV = (PixelC*) m_pvopcOrig->pixelsBoundV ();
	PixelC* ppxlcOrigBY = (PixelC*) m_pvopcOrig->pixelsBoundBY ();
	
	// MAC (SB) 26-Nov-99
	PixelC** pppxlcCurrQMBA = NULL;
	const PixelC** pppxlcOrigMBA = NULL;
	if (m_volmd.fAUsage == EIGHT_BIT) {
		pppxlcCurrQA   = new PixelC* [m_volmd.iAuxCompCount];
		pppxlcOrigA    = new PixelC* [m_volmd.iAuxCompCount];
		pppxlcCurrQMBA = new PixelC* [m_volmd.iAuxCompCount];
		pppxlcOrigMBA  = new const PixelC* [m_volmd.iAuxCompCount];
		for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 26-Nov-99
			pppxlcCurrQA[iAuxComp] = (PixelC*) m_pvopcCurrQ->pixelsA (iAuxComp) + m_iStartInRefToCurrRctY;
			pppxlcOrigA[iAuxComp]  = (PixelC*) m_pvopcOrig->pixelsBoundA (iAuxComp);
		}
	}
	//~MAC
	
	Int iMBX, iMBY, iMB = 0;
	const CMBMode* pmbmdRef;
	const CMotionVector* pmvRef;
	for (iMBY = 0; iMBY < m_iNumMBY; iMBY++, y += MB_SIZE) {
		PixelC* ppxlcCurrQMBY = ppxlcCurrQY;
		PixelC* ppxlcCurrQMBU = ppxlcCurrQU;
		PixelC* ppxlcCurrQMBV = ppxlcCurrQV;
		PixelC* ppxlcCurrQMBBY = ppxlcCurrQBY;
		//PixelC* ppxlcCurrQMBA = ppxlcCurrQA;
		PixelC* ppxlcOrigMBY = ppxlcOrigY;
		PixelC* ppxlcOrigMBU = ppxlcOrigU;
		PixelC* ppxlcOrigMBV = ppxlcOrigV;
		PixelC* ppxlcOrigMBBY = ppxlcOrigBY;
		//PixelC* ppxlcOrigMBA = ppxlcOrigA;
		if (m_volmd.fAUsage == EIGHT_BIT) {
			for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { // MAC (SB) 26-Nov-99
				pppxlcCurrQMBA[iAuxComp] = pppxlcCurrQA[iAuxComp];
				pppxlcOrigMBA[iAuxComp]  = pppxlcOrigA[iAuxComp];
			}
		}
		
		CoordI x = m_rctCurrVOPY.left;
		m_vctForwardMvPredBVOP[0].x  = m_vctForwardMvPredBVOP[0].y  = 0;
		m_vctBackwardMvPredBVOP[0].x = m_vctBackwardMvPredBVOP[0].y = 0;
		m_vctForwardMvPredBVOP[1].x  = m_vctForwardMvPredBVOP[1].y  = 0;
		m_vctBackwardMvPredBVOP[1].x = m_vctBackwardMvPredBVOP[1].y = 0;
		
		for (iMBX = 0; iMBX < m_iNumMBX; iMBX++, x += MB_SIZE, iMB++)	{
			pmbmd->m_intStepDelta = 0;	//sharp added this
			pmbmd->m_bPadded=FALSE;
			// shape quantization part
			m_statsMB.reset ();
			
			// MB rate control
			if (m_uiRateControl>=RC_TM5) 
			{
				Int iNewQP = m_tm5rc.tm5rc_calc_mquant(iMB, m_statsVOP.total());
				if(iNewQP>iQPPrev)
					iNewQP = iQPPrev + 2;
				else if(iNewQP<iQPPrev)
					iNewQP = iQPPrev - 2;
				updateQP(pmbmd, iQPPrev, iNewQP);
			}
			else
			{
#ifdef _MBQP_CHANGE_		
				Int iDQuant = 2*(rand() % 3) - 2;
				updateQP(pmbmd, iQPPrev, iQPPrev + iDQuant);
#else
				// no change in step size, but still need to call...
				updateQP(pmbmd, iQPPrev, iQPPrev);
#endif //_MBQP_CHANGE_
			}
			
			if(pmbmd->m_intStepDelta==-1 || pmbmd->m_intStepDelta==1 
				|| pmbmd->m_bColocatedMBSkip || pmbmd->m_mbType == DIRECT || pmbmd->m_bColocatedMBMCSEL)
				cancelQPUpdate(pmbmd);
			
			if ( m_volmd.bVPBitTh >= 0) {
				Int iCounter = m_pbitstrmOut -> getCounter();
				if( iCounter - m_iVPCounter > m_volmd.bVPBitTh ) {
					codeVideoPacketHeader (iMBX, iMBY, iQPPrev);	// video packet header
					m_iVPCounter = iCounter;
					//reset MV predictor
					m_vctForwardMvPredBVOP[0].x  = m_vctForwardMvPredBVOP[0].y  = 0;
					m_vctBackwardMvPredBVOP[0].x = m_vctBackwardMvPredBVOP[0].y = 0;
					m_vctForwardMvPredBVOP[1].x  = m_vctForwardMvPredBVOP[1].y  = 0;
					m_vctBackwardMvPredBVOP[1].x = m_vctBackwardMvPredBVOP[1].y = 0;
				}
			}
			// End Toshiba(1998-1-16)
			
			findColocatedMB (iMBX, iMBY,  pmbmdRef, pmvRef);
			
			ShapeMode shpmdColocatedMB;
			if(!(m_volmd.bSpatialScalability && m_volmd.iHierarchyType==0)){		
				if(m_vopmd.fShapeBPredDir==B_FORWARD)
					shpmdColocatedMB = m_rgshpmd [min (max (0, iMBX), m_iRefShpNumMBX - 1) 
					+ min (max (0, iMBY), m_iRefShpNumMBY - 1) * m_iRefShpNumMBX];
				else
					shpmdColocatedMB = m_rgmbmdRef [min (max (0, iMBX), m_iNumMBXRef - 1)
					+ min (max (0, iMBY), m_iNumMBYRef - 1) * m_iNumMBXRef].m_shpmd;
			}
			else {
				if(m_volmd.volType == BASE_LAYER){                      
					if(m_vopmd.fShapeBPredDir==B_FORWARD)
						shpmdColocatedMB = m_rgshpmd [min (max (0, iMBX), m_iRefShpNumMBX - 1) 
						+ min (max (0, iMBY), m_iRefShpNumMBY - 1) * m_iRefShpNumMBX];
					else
						shpmdColocatedMB = m_rgmbmdRef [min (max (0, iMBX), m_iNumMBXRef - 1)
						+ min (max (0, iMBY), m_iNumMBYRef - 1) * m_iNumMBXRef].m_shpmd;
				}
				else if (m_volmd.volType == ENHN_LAYER){
					if(m_volmd.iEnhnType!=0 &&m_volmd.iuseRefShape ==1){
						shpmdColocatedMB = m_rgmbmdRef [min (max (0, iMBX), m_iNumMBXRef - 1)
							+ min (max (0, iMBY), m_iNumMBYRef - 1) * m_iNumMBXRef].m_shpmd;
					}else{
						Int index = min (max (0, (iMBX+xIndex)*m_volmd.ihor_sampling_factor_m_shape/m_volmd.ihor_sampling_factor_n_shape), (m_iNumMBBaseXRef-1)) + min (max (0, (iMBY+yIndex)*m_volmd.iver_sampling_factor_m_shape/m_volmd.iver_sampling_factor_n_shape), (m_iNumMBBaseYRef-1)) * (m_iNumMBBaseXRef);                       
						shpmdColocatedMB = m_rgBaseshpmd [index];
					}
				}
			}
			
			if ((pmbmd->m_bColocatedMBSkip && !(pmbmd->m_bColocatedMBMCSEL)) && // GMC
				(m_volmd.volType == BASE_LAYER || (m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 3 && m_volmd.iEnhnType == 0)))
			{ 
				// don't need to send any bit for this mode
				copyToCurrBuffJustShape( ppxlcOrigMBBY, m_iFrameWidthY );
				m_statsMB.nBitsShape += codeInterShape (
					ppxlcCurrQMBBY,
					m_vopmd.fShapeBPredDir==B_FORWARD ? m_pvopcRefQ0 : m_pvopcRefQ1,
					pmbmd, shpmdColocatedMB,
					NULL, pmvBY,
					x, y, 
					iMBX, iMBY
					);
				//Changed HHI 2000-04-11
				decideTransparencyStatus (pmbmd, m_ppxlcCurrMBBY); // change pmbmd to inter if all transparent
				downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV, pmbmd);
				
				// reset motion vectors to zero because of skip
				memset (pmv, 0, BVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
				memset (pmvBackward, 0, BVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
				if (m_volmd.fAUsage == EIGHT_BIT)
					copyAlphaFromRefToCurrQ(m_pvopcRefQ0, x, y, pppxlcCurrQMBA, &m_rctRefVOPY0);
				copyFromRefToCurrQ(
					m_pvopcRefQ0,
					x, y, 
					ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, &m_rctRefVOPY0
					);
			}
			else {
				copyToCurrBuffWithShape (
					ppxlcOrigMBY, ppxlcOrigMBU, ppxlcOrigMBV, 
					ppxlcOrigMBBY, pppxlcOrigMBA,
					m_iFrameWidthY, m_iFrameWidthUV
					);
				
				// HHI Schueuer: added for sadct
				if (!m_volmd.bSadctDisable) {
					Int index=0;						
					//					if(!(m_volmd.volType == BASE_LAYER))
					if(!(m_volmd.volType == BASE_LAYER) && (m_volmd.bSpatialScalability && m_volmd.iHierarchyType==0))    //OBSSFIX_V2-8_after
						index = min (max (0,(iMBX+xIndex)*m_volmd.ihor_sampling_factor_m_shape/m_volmd.ihor_sampling_factor_n_shape),((m_iNumMBBaseXRef-1)))
						+ min (max (0,(iMBY+yIndex)*m_volmd.iver_sampling_factor_m_shape/m_volmd.iver_sampling_factor_n_shape),(m_iNumMBBaseYRef-1)) 
						* (m_iNumMBBaseXRef);	
					encodeBVOPMB_WithShape (
						ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, pppxlcCurrQMBA, ppxlcCurrQMBBY,
						pmbmd, pmv,	pmvBackward,
						pmvBY, shpmdColocatedMB,
						pmbmdRef, pmvRef,
						iMBX, iMBY,
						x, y, index,				//for OBSS
						m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV);
				}
				else {
					Int index=0;						
					//					if(!(m_volmd.volType == BASE_LAYER))
					if(!(m_volmd.volType == BASE_LAYER) && (m_volmd.bSpatialScalability && m_volmd.iHierarchyType==0))    //OBSSFIX_V2-8_after
						index = min (max (0,(iMBX+xIndex)*m_volmd.ihor_sampling_factor_m_shape/m_volmd.ihor_sampling_factor_n_shape),((m_iNumMBBaseXRef-1)))
						+ min (max (0,(iMBY+yIndex)*m_volmd.iver_sampling_factor_m_shape/m_volmd.iver_sampling_factor_n_shape),(m_iNumMBBaseYRef-1)) 
						* (m_iNumMBBaseXRef);	
					
					encodeBVOPMB_WithShape (
						ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, pppxlcCurrQMBA, ppxlcCurrQMBBY,
						pmbmd, pmv,	pmvBackward,
						pmvBY, shpmdColocatedMB,
						pmbmdRef, pmvRef,
						iMBX, iMBY,
						x, y, index		//for OBSS 
						);
				}
				
			}
			//padding of bvop is necessary for temporal scalability: bvop in base layer is used for prediction in enhancement layer
			if(m_volmd.bShapeOnly == FALSE)	{
				// Added for field based MC padding by Hyundai(1998-5-9)
				if (!m_vopmd.bInterlace) {
					if (pmbmd -> m_rgTranspStatus [0] != ALL) {
						if (pmbmd -> m_rgTranspStatus [0] == PARTIAL)
							mcPadCurrMB (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, pppxlcCurrQMBA);
						padNeighborTranspMBs (
							iMBX, iMBY,
							pmbmd,
							ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, pppxlcCurrQMBA
							);
					}
					else {
						padCurrAndTopTranspMBFromNeighbor (
							iMBX, iMBY,
							pmbmd,
							ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, pppxlcCurrQMBA
							); 
					}
				}
				// End of Hyundai(1998-5-9)
			}
			
			// update qp
			iQPPrev = pmbmd->m_stepSize;
			
			pmvBY++;
			pmbmd++;
			pmv         += BVOP_MV_PER_REF_PER_MB;
			pmvBackward += BVOP_MV_PER_REF_PER_MB;
			m_statsVOP += m_statsMB;
			ppxlcCurrQMBY += MB_SIZE;
			ppxlcCurrQMBU += BLOCK_SIZE;
			ppxlcCurrQMBV += BLOCK_SIZE;
			ppxlcCurrQMBBY += MB_SIZE;
			//ppxlcCurrQMBA += MB_SIZE;
			ppxlcOrigMBY += MB_SIZE;
			ppxlcOrigMBU += BLOCK_SIZE;
			ppxlcOrigMBV += BLOCK_SIZE;
			ppxlcOrigMBBY += MB_SIZE;
			//ppxlcOrigMBA += MB_SIZE;
			if (m_volmd.fAUsage == EIGHT_BIT) {  // MAC (SB) 26-Nov-99
				for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) {
					pppxlcCurrQMBA[iAuxComp] += MB_SIZE;
					pppxlcOrigMBA[iAuxComp] += MB_SIZE;
				}
			}
		}
		ppxlcCurrQY += m_iFrameWidthYxMBSize;
		ppxlcCurrQU += m_iFrameWidthUVxBlkSize;
		ppxlcCurrQV += m_iFrameWidthUVxBlkSize;
		ppxlcCurrQBY += m_iFrameWidthYxMBSize;
		//	ppxlcCurrQA += m_iFrameWidthYxMBSize;
		
		ppxlcOrigY += m_iFrameWidthYxMBSize;
		ppxlcOrigU += m_iFrameWidthUVxBlkSize;
		ppxlcOrigV += m_iFrameWidthUVxBlkSize;
		ppxlcOrigBY += m_iFrameWidthYxMBSize;
		//	ppxlcOrigA += m_iFrameWidthYxMBSize;
		
		if (m_volmd.fAUsage == EIGHT_BIT) { // MAC (SB) 26-Nov-99
			for(Int iAuxComp=0;iAuxComp<m_volmd.iAuxCompCount;iAuxComp++) { 
				pppxlcCurrQA[iAuxComp] += m_iFrameWidthYxMBSize;
				pppxlcOrigA[iAuxComp] += m_iFrameWidthYxMBSize;
			}
		}
	}
	// Added for field based MC padding by Hyundai(1998-5-9)
	if (m_vopmd.bInterlace && m_volmd.bShapeOnly == FALSE)
		fieldBasedMCPadding (field_pmbmd, m_pvopcCurrQ);
	// End of Hyundai(1998-5-9)
	//OBSS_SAIT_991015
	//OBSSFIX_MODE3
	if((m_volmd.bSpatialScalability && m_volmd.iHierarchyType==0) && m_volmd.volType == ENHN_LAYER &&!(m_volmd.iEnhnType != 0 && m_volmd.iuseRefShape == 1)) {        // if SpatialScalability
		//		if((m_volmd.bSpatialScalability && m_volmd.iHierarchyType==0) && m_volmd.volType == ENHN_LAYER) {	// if SpatialScalability
		//~OBSSFIX_MODE3
		delete m_pvopcRefQ1->getPlane (BY_PLANE)->m_pbHorSamplingChk;
		delete m_pvopcRefQ1->getPlane (BY_PLANE)->m_pbVerSamplingChk;
	}
	//~OBSS_SAIT_991015
	
    //MAC
    if (m_volmd.fAUsage == EIGHT_BIT) {
		delete [] pppxlcCurrQA;
		delete [] pppxlcOrigA;
		delete [] pppxlcCurrQMBA;
		delete [] pppxlcOrigMBA;
    }
    //~MAC
}