mbdec.cpp

网络MPEG4IP流媒体开发源代码

                                        if (pmbmd->m_bMerged [1])       iDstBlk = (Int) Y_BLOCK2;
                                        else if (pmbmd->m_bMerged [3])  iDstBlk = (Int) Y_BLOCK3;
                                        else if (pmbmd->m_bMerged [5])  iDstBlk = (Int) Y_BLOCK4;
                                        break;
                                case (Y_BLOCK2):
                                        if (pmbmd->m_bMerged [4])       iDstBlk = (Int) Y_BLOCK4;
                                        else if (pmbmd->m_bMerged [6])  iDstBlk = (Int) Y_BLOCK3;
                                        break;
                                case (Y_BLOCK3):
                                        if (pmbmd->m_bMerged [2])       iDstBlk = (Int) Y_BLOCK4;
                                        break;
                        }
                        if (iDstBlk) {
                                MacroBlockMemory* pmbmCurr = m_rgpmbmCurr [iMBX];
                                pmbmCurr->rgblkm [iDstBlk-1][0] = pmbmCurr->rgblkm [iBlk-1][0];
                                for (UInt x = 1; x < (BLOCK_SIZE<<1)-1; x++)
                                        pmbmCurr->rgblkm [iDstBlk-1][x] = 0;
                        }
                }
		// End of Hyundai(1998-5-9)*/
	}
}

Void CVideoObjectDecoder::decodeAlphaIntraMB (CMBMode* pmbmd, Int iMBX, Int iMBY, PixelC* ppxlcRefMBA)
{
	assert (pmbmd != NULL);
	if (pmbmd -> m_rgTranspStatus [0] == ALL) 
		return;

	assert (pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ);
	Int iQP = pmbmd->m_stepSizeAlpha;
	Int iDcScalerA;

	if (pmbmd -> m_stepSizeAlpha < 1)
		pmbmd -> m_stepSizeAlpha = 1;
	if (iQP <= 4)	{
		iDcScalerA = 8;
	}
	else if (iQP >= 5 && iQP <= 8)	{
		iDcScalerA = 2 * iQP;
	}
	else if (iQP >= 9 && iQP <= 24)	{
		iDcScalerA = iQP + 8;
	}
	else	{
		iDcScalerA = 2 * iQP - 16;
	}

	assert (iQP > 0 && iQP < 64);

	// should be stepSizeAlpha and a different table
	//if (pmbmd -> m_stepSize >= grgiDCSwitchingThreshold [m_vopmd.iIntraDcSwitchThr])
	//	pmbmd->m_bCodeDcAsAcAlpha = TRUE;
	//else
	pmbmd->m_bCodeDcAsAcAlpha = FALSE;

	if(pmbmd->m_CODAlpha==ALPHA_ALL255)
	{
		// fill curr macroblock with 255
		Int iY;
		PixelC *ppxlc = ppxlcRefMBA;
		for(iY = 0; iY<MB_SIZE; iY++, ppxlc += m_iFrameWidthY)
			pxlcmemset(ppxlc, 255, MB_SIZE);

		// fix intra prediction
		Int iBlk;
		MacroBlockMemory* pmbmCurr = m_rgpmbmCurr [iMBX];
		for(iBlk = A_BLOCK1; iBlk<=A_BLOCK4; iBlk++)
		{
			Int i;
			pmbmCurr->rgblkm [iBlk - 1] [0] = divroundnearest(255 * 8, iDcScalerA) * iDcScalerA;
			//save recon value of DC for intra pred								//save Qcoef in memory
			for (i = 1; i < BLOCK_SIZE; i++)	{
				pmbmCurr->rgblkm [iBlk - 1] [i] = 0;
				pmbmCurr->rgblkm [iBlk - 1] [i + BLOCK_SIZE - 1] = 0;
			}				
		}

		return;
	}


	//for intra pred
	MacroBlockMemory* pmbmLeft = NULL;
	MacroBlockMemory* pmbmTop = NULL;
	MacroBlockMemory* pmbmLeftTop = NULL;
	CMBMode* pmbmdLeft = NULL;
	CMBMode* pmbmdTop = NULL;
	CMBMode* pmbmdLeftTop = NULL;
											 
	Int iMBTop	= iMBY - 1;
	if (iMBTop >= 0)	{
		if (pmbmd->m_iVideoPacketNumber == (pmbmd - m_iNumMBX)->m_iVideoPacketNumber)	{
			pmbmTop  = m_rgpmbmAbove [iMBX];
			pmbmdTop = pmbmd - m_iNumMBX; 
		}
	}

	if (iMBX > 0)	{
		if (pmbmd->m_iVideoPacketNumber == (pmbmd - 1)->m_iVideoPacketNumber)	{
			pmbmLeft  = m_rgpmbmCurr [iMBX - 1];
			pmbmdLeft = pmbmd -  1; 
		}
	}

	if (iMBTop >= 0 && iMBX > 0)	{
		if (pmbmd->m_iVideoPacketNumber == (pmbmd - m_iNumMBX - 1)->m_iVideoPacketNumber)	{
			pmbmLeftTop  = m_rgpmbmAbove [iMBX - 1];
			pmbmdLeftTop = pmbmd - m_iNumMBX - 1;
		}
	}

	PixelC* rgchBlkDst = NULL;
	Int* rgiCoefQ;
	for (Int iBlk = A_BLOCK1; iBlk <= A_BLOCK4; iBlk++) {
		if (pmbmd -> m_rgTranspStatus [iBlk - 6] == ALL) 
			continue;
		switch (iBlk) 
		{
		case (A_BLOCK1): 
			rgchBlkDst = ppxlcRefMBA;
			break;
		case (A_BLOCK2): 
			rgchBlkDst = ppxlcRefMBA + BLOCK_SIZE;
			break;
		case (A_BLOCK3): 
			rgchBlkDst = ppxlcRefMBA + m_iFrameWidthYxBlkSize;
			break;
		case (A_BLOCK4): 
			rgchBlkDst = ppxlcRefMBA + m_iFrameWidthYxBlkSize + BLOCK_SIZE;
			break;
		}

		rgiCoefQ = m_rgpiCoefQ [iBlk - 1];
		const BlockMemory blkmPred = NULL;
		Int iQpPred = iQP;
		decideIntraPred (blkmPred, 
						 pmbmd,
						 iQpPred,
						 (BlockNum) iBlk,
						 pmbmLeft, 
  						 pmbmTop, 
						 pmbmLeftTop,
						 m_rgpmbmCurr [iMBX], // save for curr coefs
						 pmbmdLeft,
						 pmbmdTop,
						 pmbmdLeftTop);
		decodeIntraBlockTexture (rgchBlkDst,
								 m_iFrameWidthY,
								 iQP, 
								 iDcScalerA,
								 iBlk,	
								 m_rgpmbmCurr [iMBX],
								 pmbmd,
 								 blkmPred, //for intra-pred
								 iQpPred);	
		/*BBM// Added for Boundary by Hyundai(1998-5-9)
                if (m_vopmd.bInterlace && pmbmd->m_bMerged [0]) {
                        Int iDstBlk = 0;
                        switch (iBlk) {
                                case (A_BLOCK1):
                                        if (pmbmd->m_bMerged [1])       iDstBlk = (Int) A_BLOCK2;
                                        else if (pmbmd->m_bMerged [3])  iDstBlk = (Int) A_BLOCK3;
                                        else if (pmbmd->m_bMerged [5])  iDstBlk = (Int) A_BLOCK4;
                                        break;
                                case (A_BLOCK2):
                                        if (pmbmd->m_bMerged [4])       iDstBlk = (Int) A_BLOCK4;
                                        else if (pmbmd->m_bMerged [6])  iDstBlk = (Int) A_BLOCK3;
                                        break;
                                case (A_BLOCK3):
                                        if (pmbmd->m_bMerged [2])       iDstBlk = (Int) A_BLOCK4;
                                        break;
                        }
                        if (iDstBlk) {
                                MacroBlockMemory* pmbmCurr = m_rgpmbmCurr [iMBX];
                                pmbmCurr->rgblkm [iDstBlk-1][0] = pmbmCurr->rgblkm [iBlk-1][0];
                                for (UInt x = 1; x < (BLOCK_SIZE<<1)-1; x++)
                                        pmbmCurr->rgblkm [iDstBlk-1][x] = 0;
                        }
                }
		// End of Hyundai(1998-5-9)*/
	}
}

Void CVideoObjectDecoder::decodeTextureInterMB (CMBMode* pmbmd)
{
	assert (pmbmd != NULL);
	if (pmbmd->m_rgTranspStatus [0] == ALL || pmbmd->m_bSkip) 
		return;

	assert (pmbmd->m_dctMd == INTER || pmbmd->m_dctMd == INTERQ);
	Int iQP = pmbmd->m_stepSize;
	Int* rgiBlkCurrQ = m_ppxliErrorMBY;
	Int iWidthCurrQ;
	for (Int iBlk = Y_BLOCK1; iBlk <= V_BLOCK; iBlk++) {
		if (iBlk < U_BLOCK) {
			if (pmbmd -> m_rgTranspStatus [iBlk] == ALL) 
				continue;
			switch (iBlk) 
			{
			case (Y_BLOCK1): 
				rgiBlkCurrQ = m_ppxliErrorMBY;
				break;
			case (Y_BLOCK2): 
				rgiBlkCurrQ = m_ppxliErrorMBY + BLOCK_SIZE;
				break;
			case (Y_BLOCK3): 
				rgiBlkCurrQ = m_ppxliErrorMBY + MB_SIZE * BLOCK_SIZE;
				break;
			case (Y_BLOCK4): 
				rgiBlkCurrQ = m_ppxliErrorMBY + MB_SIZE * BLOCK_SIZE + BLOCK_SIZE;
				break;
			}
			iWidthCurrQ = MB_SIZE;
		}
		else {
			iWidthCurrQ = BLOCK_SIZE;
			rgiBlkCurrQ = (iBlk == U_BLOCK) ? m_ppxliErrorMBU: m_ppxliErrorMBV;
		}
		if (pmbmd->getCodedBlockPattern ((BlockNum) iBlk))
			decodeTextureInterBlock (rgiBlkCurrQ, iWidthCurrQ, iQP, FALSE); //all for intra-pred
		else 
			for (Int i = 0; i < BLOCK_SIZE; i++)	{
				memset (rgiBlkCurrQ, 0, sizeof (Int) * BLOCK_SIZE);
				rgiBlkCurrQ += iWidthCurrQ;
			}
	}
}

Void CVideoObjectDecoder::decodeAlphaInterMB (CMBMode* pmbmd, PixelC *ppxlcRefMBA)
{
	assert (pmbmd != NULL);

	if (pmbmd->m_rgTranspStatus [0] == ALL)
		return;
	if(pmbmd->m_CODAlpha == ALPHA_ALL255) 
	{
		// fill curr macroblock with 255
		Int iY;
		PixelC *ppxlc = ppxlcRefMBA;
		for(iY = 0; iY<MB_SIZE; iY++, ppxlc += m_iFrameWidthY)
			pxlcmemset(ppxlc, 255, MB_SIZE);
		return;
	}
	if(pmbmd->m_CODAlpha != ALPHA_CODED)
		return;

	assert (pmbmd->m_dctMd == INTER || pmbmd->m_dctMd == INTERQ);

	Int iQP = pmbmd->m_stepSizeAlpha;
	Int* piBlkCurrQ = NULL;
	for (Int iBlk = A_BLOCK1; iBlk <= A_BLOCK4; iBlk++) {
		if (pmbmd -> m_rgTranspStatus [iBlk - 6] == ALL) 
			continue;
		switch (iBlk) 
		{
		case (A_BLOCK1): 
			piBlkCurrQ = m_ppxliErrorMBA;
			break;
		case (A_BLOCK2): 
			piBlkCurrQ = m_ppxliErrorMBA + BLOCK_SIZE;
			break;
		case (A_BLOCK3): 
			piBlkCurrQ = m_ppxliErrorMBA + MB_SIZE * BLOCK_SIZE;
			break;
		case (A_BLOCK4): 
			piBlkCurrQ = m_ppxliErrorMBA + MB_SIZE * BLOCK_SIZE + BLOCK_SIZE;
			break;
		}

		//Int *pix = piBlkCurrQ;
		Int i;
		if (pmbmd->getCodedBlockPattern ((BlockNum) iBlk))
		{
			decodeTextureInterBlock (piBlkCurrQ, MB_SIZE, iQP, TRUE);
			/*printf("\nBlock %d DCT Coefs Quant\n",iBlk);
			for(i=0;i<64;i++)
				printf("%d ",m_rgpiCoefQ [0][i]);
			printf("\n");
			
			printf("Block %d DCT Coefs Inv Quant\n",iBlk);
			for(i=0;i<64;i++)
				printf("%d ",m_rgiDCTcoef[i]);
			printf("\n");*/
		}
		else 
			for (i = 0; i < BLOCK_SIZE; i++)	{
				memset (piBlkCurrQ, 0, sizeof (Int) * BLOCK_SIZE);
				piBlkCurrQ += MB_SIZE;
			}
		/*Int j;
		printf("\nblock %d update\n",iBlk);
		for(i=0;i<BLOCK_SIZE;i++,pix+=BLOCK_SIZE){
			for(j=0;j<BLOCK_SIZE;j++,pix++)
				printf("%3d ",*pix);
			printf("\n");
		}*/
	}
}

Void CVideoObjectDecoder::setCBPYandC (CMBMode* pmbmd, Int iCBPC, Int iCBPY, Int cNonTrnspBlk)
{
	pmbmd->setCodedBlockPattern (U_BLOCK, (iCBPC >> 1) & 1) ;
	pmbmd->setCodedBlockPattern (V_BLOCK, iCBPC & 1) ;
	Int iBitPos = 1, iBlk;
	for (iBlk = Y_BLOCK1; iBlk <= Y_BLOCK4; iBlk++)	{
		if (pmbmd->m_rgTranspStatus [iBlk] != ALL)	{
			pmbmd->setCodedBlockPattern (
				(BlockNum) iBlk, 
				(iCBPY >> (cNonTrnspBlk - iBitPos)) & 1
			);
			iBitPos++;
		}
		else
			pmbmd->setCodedBlockPattern ((BlockNum) iBlk, 0);
	}
}