framecode.c

DM642的mpeg4编码

			for (i = 0; i < 4; i++)
			{
				iPosition =  iStride * ((i/2)*8) + ix*16+ (i%2)*8;
				//将当前块的值拷贝到pCurImage图象中去   
				TransferBlock16ToImage8(iPosition+CurRecFrameBufferPong->Y,  DCT_COEFF+i*64,iStride);
			}
			iPosition = ix*8;
			TransferBlock16ToImage8(iPosition+CurRecFrameBufferPong->Cb,  DCT_COEFF+256, iStrideHalf);
			TransferBlock16ToImage8(iPosition+CurRecFrameBufferPong->Cr, DCT_COEFF+320, iStrideHalf);
				
					
	   }//for (ix = 0; ix < iMBWidth; ix++)
		CurRecFrameBufferPong->Y-=IMAGE_EDGE;
		CurRecFrameBufferPong->Cb-=IMAGE_EDGE_HALF;
		CurRecFrameBufferPong->Cr-=IMAGE_EDGE_HALF;
		
		if(iy>0)
			DAT_wait(transferIdYRec);

		SWAP(Image8*,CurRecFrameBufferPing, CurRecFrameBufferPong);
		
		//起始行的地址
	   iPositionLum = iy * iStride * 16-IMAGE_EDGE;
	   iPositionChro =iy * iStrideHalf * 8-IMAGE_EDGE_HALF;
		DAT_copy(CurRecFrameBufferPing->Cb,iPositionChro + pEncoder->pCurImage8->Cb,64*iExtMBWidth);
		DAT_copy(CurRecFrameBufferPing->Cr,iPositionChro + pEncoder->pCurImage8->Cr,64*iExtMBWidth);
		transferIdYRec=DAT_copy(CurRecFrameBufferPing->Y,iPositionLum + pEncoder->pCurImage8->Y,4*64*iExtMBWidth);
   }
   StreamPad(bs);
			
   return 1;
}

//***********************************************************************************************
//函 数 名：P_MBCoding()
//函数功能：
//形式参数：
//返 回 值：void
//***********************************************************************************************
int P_MBCoding(Stream* bs, Encoder* pEncoder,Image8* pCurImage,Image8* pRefImage,Image8* pCurRecFrame,short ix,short iy)
{
	int i, iPosition,iPositionLum, iPositionChro;

	short iMBWidth;

	short iMBNo = 0, iQuant;

	short iDcScalarLum, iDcScalarChr;

	short iStride = pEncoder->pCurFrameInfo->vop_extwidth;

	short  iStrideHalf = iStride/2 ;

//	short DCT_COEFF[6*64], PIXEL_COEFF[6*64];

	MacroBlock * pCurMB = NULL;

	MacroBlock * MBs =  pEncoder->pCurFrameInfo->pMB;

	//StreamPad(bs);

	if (pEncoder->pCurFrameInfo->vop_quant > 31)
	{
		pEncoder->pCurFrameInfo->vop_quant = 31;
	}

	iMBWidth = pEncoder->pCurFrameInfo->vop_width / 16;
/*	for (iy = 0; iy < iMBHeight; iy++)
	{
		for (ix = 0; ix < iMBWidth; ix++)
		{
		*/
			iMBNo = ix + iy * iMBWidth;
			pCurMB = &MBs[iMBNo];
			

			if (pCurMB->mb_type == MB_SKIP)
			{
				StreamPutBit(bs, 1);
				pCurMB->Mv[1].x = pCurMB->Mv[2].x = pCurMB->Mv[3].x = pCurMB->Mv[0].x = 0;
				pCurMB->Mv[1].y = pCurMB->Mv[2].y = pCurMB->Mv[3].y = pCurMB->Mv[0].y = 0;
				//			    
				for (i = 0; i < 4; i++)
				{
					iPosition = iStride * (i/2)*8 + ix*16+ (i%2)*8;
					TransferImage8ToImage8(iPosition+pCurRecFrame->Y, iPosition+pRefImage->Y, iStride);
				}
				iPosition = ix*8;
				TransferImage8ToImage8(iPosition+pCurRecFrame->Cb, iPosition+pRefImage->Cb, iStrideHalf);
				TransferImage8ToImage8(iPosition+pCurRecFrame->Cr, iPosition+pRefImage->Cr, iStrideHalf);	  
	//			continue;
			}


			//***********************************************************
			iQuant =  pCurMB->quant = pEncoder->pCurFrameInfo->vop_quant;

			if (pCurMB->mb_type == MB_INTRA_Q || pCurMB->mb_type == MB_INTER_Q)
			{
				iQuant = pCurMB->quant + pCurMB->dquant;
				CLIP(iQuant, 1, 31);
			}

			/*  DCT transform, and get the pEncoder->pDctImage  */
			iPositionLum = ix * 16;
			iPositionChro =ix * 8;


			/*  macroblock coding  */
			if (pCurMB->mb_type == MB_INTRA || pCurMB->mb_type == MB_INTRA_Q)
			{ 
				//****************************************
			/*	for (i = 0; i < 4; i++)
				{   
					iPositionLum = ix * 16+ (i>>1) * 8 * pEncoder->pCurFrameInfo->vop_extwidth + (i%2) * 8;
					//将图象当前块的亮度值读到PIXEL_COEFF中
					TransferImage8ToBlock16(PIXEL_COEFF+i*64, iPositionLum + pCurImage->Y ,iStride);
					fdct(DCT_COEFF+i*64,PIXEL_COEFF+i*64);
				}
				iPositionChro =ix * 8;
				//U
				TransferImage8ToBlock16(PIXEL_COEFF+4*64,  iPositionChro + pCurImage->Cb, iStrideHalf);
				fdct(DCT_COEFF+4*64,PIXEL_COEFF+4*64);
				//V
				TransferImage8ToBlock16(PIXEL_COEFF+5*64,  iPositionChro + pCurImage->Cr, iStrideHalf);
				fdct(DCT_COEFF+5*64,PIXEL_COEFF+5*64);
			*/
			for (i = 0; i < 4; i++)
		   {   
			   	iPositionLum = ix*16+iStride * ((i/2)*8)+ (i%2)*8;
			   //将图象当前块的亮度值读到PIXEL_COEFF中
			    TransferImage8ToBlock16(DCT_COEFF+i*64, iPositionLum + pCurImage->Y ,iStride);  
		   }
		     iPositionChro =ix * 8;
			//U
            TransferImage8ToBlock16(DCT_COEFF+4*64,  iPositionChro + pCurImage->Cb, iStrideHalf);
			//V
		    TransferImage8ToBlock16(DCT_COEFF+5*64,  iPositionChro + pCurImage->Cr, iStrideHalf);
			//对Y/U/V分量进行fdct变换
		  	IMG_fdct_8x8(DCT_COEFF,6);
				//******************************************

				iDcScalarLum = GetDcScaler(iQuant, 1);
				iDcScalarChr = GetDcScaler(iQuant, 0);

				/*  quant, default h263 quant-type  */
				if (!pEncoder->pVol->quant_type)
				{
					Mpeg4IntraQuant2(DCT_COEFF, DCT_COEFF, iQuant, iDcScalarLum);
					Mpeg4IntraQuant2(DCT_COEFF+64, DCT_COEFF+64, iQuant, iDcScalarLum);
					Mpeg4IntraQuant2(DCT_COEFF+128, DCT_COEFF+128, iQuant, iDcScalarLum);
					Mpeg4IntraQuant2(DCT_COEFF+192, DCT_COEFF+192, iQuant, iDcScalarLum);

					Mpeg4IntraQuant2(DCT_COEFF+256, DCT_COEFF+256, iQuant, iDcScalarChr);
					Mpeg4IntraQuant2(DCT_COEFF+320, DCT_COEFF+320, iQuant, iDcScalarChr);
				}
				else 
				{
					Mpeg4IntraQuant1(DCT_COEFF, DCT_COEFF, iQuant, iDcScalarLum, pEncoder->pVol->load_intra_quant_mat);
					Mpeg4IntraQuant1(DCT_COEFF+64, DCT_COEFF+64, iQuant, iDcScalarLum, pEncoder->pVol->load_intra_quant_mat);
					Mpeg4IntraQuant1(DCT_COEFF+128, DCT_COEFF+128, iQuant, iDcScalarLum, pEncoder->pVol->load_intra_quant_mat);
					Mpeg4IntraQuant1(DCT_COEFF+192, DCT_COEFF+192, iQuant, iDcScalarLum, pEncoder->pVol->load_intra_quant_mat);

					Mpeg4IntraQuant1(DCT_COEFF+256, DCT_COEFF+256, iQuant, iDcScalarChr, pEncoder->pVol->load_intra_quant_mat);
					Mpeg4IntraQuant1(DCT_COEFF+320, DCT_COEFF+320, iQuant, iDcScalarChr, pEncoder->pVol->load_intra_quant_mat);
				}			  

				/*  macroblock coding  */
				CodeIntraMB(bs, pEncoder, pCurMB, ix, iy, DCT_COEFF);

				/*  dequant */
				if (!pEncoder->pVol->quant_type)
				{
					Mpeg4IntraDeQuant2(DCT_COEFF, DCT_COEFF, iQuant, iDcScalarLum);
					Mpeg4IntraDeQuant2(DCT_COEFF+64, DCT_COEFF+64, iQuant, iDcScalarLum);
					Mpeg4IntraDeQuant2(DCT_COEFF+128, DCT_COEFF+128, iQuant, iDcScalarLum);
					Mpeg4IntraDeQuant2(DCT_COEFF+192, DCT_COEFF+192, iQuant, iDcScalarLum);

					Mpeg4IntraDeQuant2(DCT_COEFF+256, DCT_COEFF+256, iQuant, iDcScalarChr);
					Mpeg4IntraDeQuant2(DCT_COEFF+320, DCT_COEFF+320, iQuant, iDcScalarChr);
				}
				else 
				{
					Mpeg4IntraDeQuant1(DCT_COEFF, DCT_COEFF, iQuant, iDcScalarLum, pEncoder->pVol->load_intra_quant_mat);
					Mpeg4IntraDeQuant1(DCT_COEFF+64, DCT_COEFF+64, iQuant, iDcScalarLum, pEncoder->pVol->load_intra_quant_mat);
					Mpeg4IntraDeQuant1(DCT_COEFF+128, DCT_COEFF+128, iQuant, iDcScalarLum, pEncoder->pVol->load_intra_quant_mat);
					Mpeg4IntraDeQuant1(DCT_COEFF+192, DCT_COEFF+192, iQuant, iDcScalarLum, pEncoder->pVol->load_intra_quant_mat);

					Mpeg4IntraDeQuant1(DCT_COEFF+256, DCT_COEFF+256, iQuant, iDcScalarChr, pEncoder->pVol->load_intra_quant_mat);
					Mpeg4IntraDeQuant1(DCT_COEFF+320, DCT_COEFF+320, iQuant, iDcScalarChr, pEncoder->pVol->load_intra_quant_mat);
				}

				//帧的重建
			//	for(i=0; i<6; i++)
			//		idct(DCT_COEFF+64*i);
				IMG_idct_8x8(DCT_COEFF,6);
				for (i = 0; i < 384; i++)
				{
					CLIP(DCT_COEFF[i],0,255);
				}
				//********************************
				for (i = 0; i < 4; i++)
				{
					iPosition = iStride * (i/2)*8 + ix*16+ (i%2)*8;
					//将当前块的值拷贝到Ref图象中去
					TransferBlock16ToImage8(iPosition+pCurRecFrame->Y, DCT_COEFF+i*64, iStride);
				}
				iPosition = ix*8;
				TransferBlock16ToImage8(iPosition+pCurRecFrame->Cb, DCT_COEFF+256, iStrideHalf);
				TransferBlock16ToImage8(iPosition+pCurRecFrame->Cr, DCT_COEFF+320, iStrideHalf);
				//*******************************************

			}
			else if (pCurMB->mb_type == MB_INTER || pCurMB->mb_type == MB_INTER_Q || pCurMB->mb_type == MB_INTER_4V)
			{
				//进行前向帧的运动补偿，将运动补偿后的数据放到iCurMBData1中
				if (pCurMB->mb_type == MB_INTER || pCurMB->mb_type == MB_INTER_Q)
				{ 
					OneMvCompensation_Encoder(pEncoder, pCurMB,pRefImage, ix,iy, iCurMBData1, 0);
				}
				if (pCurMB->mb_type == MB_INTER_4V)
				{
					FourMVCompensation_Encoder(pEncoder, pCurMB,pRefImage, ix, iy, iCurMBData1, 0);
				}
				//***************************
				//宏块的补偿和补偿后的DCT变换
				/*
				for (i = 0; i < 4; i++)
				{
					iPosition = iStride*(i/2)*8 + ix*16+ (i%2)*8;
					TransferImage8ToBlock16(PIXEL_COEFF+i*64, pCurImage->Y+iPosition,iStride);
					TransferBlock16SubBlock16(PIXEL_COEFF+i*64,iCurMBData1+64*i);
					fdct(DCT_COEFF+i*64,PIXEL_COEFF+i*64);
				}
				iPosition = ix*8;
				TransferImage8ToBlock16(PIXEL_COEFF+4*64,pCurImage->Cb+iPosition,iStrideHalf);
				TransferBlock16SubBlock16(PIXEL_COEFF+4*64,iCurMBData1+256);
				fdct(DCT_COEFF+4*64,PIXEL_COEFF+4*64);

				TransferImage8ToBlock16(PIXEL_COEFF+5*64,pCurImage->Cr+iPosition,iStrideHalf);
				TransferBlock16SubBlock16(PIXEL_COEFF+5*64,iCurMBData1+320);
				fdct(DCT_COEFF+5*64,PIXEL_COEFF+5*64);
				*/
				for (i = 0; i < 4; i++)
				{
					iPosition = iStride*(i/2)*8 + ix*16+ (i%2)*8;
					TransferImage8ToBlock16(DCT_COEFF+i*64, pCurImage->Y+iPosition,iStride);
					TransferBlock16SubBlock16(DCT_COEFF+i*64,iCurMBData1+64*i);
				}
				iPosition = ix*8;
				TransferImage8ToBlock16(DCT_COEFF+4*64,pCurImage->Cb+iPosition,iStrideHalf);
				TransferBlock16SubBlock16(DCT_COEFF+4*64,iCurMBData1+256);

				TransferImage8ToBlock16(DCT_COEFF+5*64,pCurImage->Cr+iPosition,iStrideHalf);
				TransferBlock16SubBlock16(DCT_COEFF+5*64,iCurMBData1+320);
				
				IMG_fdct_8x8(DCT_COEFF,6);
			
				//*************************
				//宏块的编码
				//  quant, quant-type h263 
				if (!pEncoder->pVol->quant_type)
				{
					Mpeg4InterQuant2(DCT_COEFF, DCT_COEFF, iQuant);
					Mpeg4InterQuant2(DCT_COEFF+64, DCT_COEFF+64, iQuant);
					Mpeg4InterQuant2(DCT_COEFF+128, DCT_COEFF+128, iQuant);
					Mpeg4InterQuant2(DCT_COEFF+192, DCT_COEFF+192, iQuant);

					Mpeg4InterQuant2(DCT_COEFF+256, DCT_COEFF+256, iQuant);
					Mpeg4InterQuant2(DCT_COEFF+320, DCT_COEFF+320, iQuant);
				}
				else 
				{
					Mpeg4InterQuant1(DCT_COEFF, DCT_COEFF, iQuant, pEncoder->pVol->load_inter_quant_mat);
					Mpeg4InterQuant1(DCT_COEFF+64, DCT_COEFF+64, iQuant, pEncoder->pVol->load_inter_quant_mat);
					Mpeg4InterQuant1(DCT_COEFF+128, DCT_COEFF+128, iQuant, pEncoder->pVol->load_inter_quant_mat);
					Mpeg4InterQuant1(DCT_COEFF+192, DCT_COEFF+192, iQuant, pEncoder->pVol->load_inter_quant_mat);

					Mpeg4InterQuant1(DCT_COEFF+256, DCT_COEFF+256, iQuant, pEncoder->pVol->load_intra_quant_mat);
					Mpeg4InterQuant1(DCT_COEFF+320, DCT_COEFF+320, iQuant, pEncoder->pVol->load_intra_quant_mat);
				}


				pCurMB->cbp = GetMBlockCBP(DCT_COEFF, pCurMB->mb_type);

				CodeInterMB(bs, pEncoder, pCurMB, ix, iy, DCT_COEFF);

				//  dequant  
				if (!pEncoder->pVol->quant_type)
				{
					Mpeg4InterDeQuant2(DCT_COEFF, DCT_COEFF, iQuant);
					Mpeg4InterDeQuant2(DCT_COEFF+64, DCT_COEFF+64, iQuant);
					Mpeg4InterDeQuant2(DCT_COEFF+128, DCT_COEFF+128, iQuant);
					Mpeg4InterDeQuant2(DCT_COEFF+192, DCT_COEFF+192, iQuant);

					Mpeg4InterDeQuant2(DCT_COEFF+256, DCT_COEFF+256, iQuant);
					Mpeg4InterDeQuant2(DCT_COEFF+320, DCT_COEFF+320, iQuant);
				}
				else 
				{
					Mpeg4InterDeQuant1(DCT_COEFF, DCT_COEFF, iQuant, pEncoder->pVol->load_inter_quant_mat);
					Mpeg4InterDeQuant1(DCT_COEFF+64, DCT_COEFF+64, iQuant, pEncoder->pVol->load_inter_quant_mat);
					Mpeg4InterDeQuant1(DCT_COEFF+128, DCT_COEFF+128, iQuant, pEncoder->pVol->load_inter_quant_mat);
					Mpeg4InterDeQuant1(DCT_COEFF+192, DCT_COEFF+192, iQuant, pEncoder->pVol->load_inter_quant_mat);

					Mpeg4InterDeQuant1(DCT_COEFF+256, DCT_COEFF+256, iQuant, pEncoder->pVol->load_inter_quant_mat);
					Mpeg4InterDeQuant1(DCT_COEFF+320, DCT_COEFF+320, iQuant, pEncoder->pVol->load_inter_quant_mat);
				}

				//帧的重建
			//	for(i=0; i<6; i++)
			//		idct(DCT_COEFF+64*i);
					IMG_idct_8x8(DCT_COEFF,6);
				//将残差图象叠加上运动补偿后的图象，得到重建的块数据
				for (i = 0; i < 6; i++)
				{
					TransferBlock16AddBlock16(DCT_COEFF+i*64, iCurMBData1+i*64);
				}

				//将重建后的宏块拷贝到pCurImage
				for (i = 0; i < 4; i++)
				{
					iPosition = iStride * (i/2)*8 + ix*16+ (i%2)*8;
					//将当前块的值拷贝到Ref图象中去
					TransferBlock16ToImage8(iPosition+pCurRecFrame->Y, DCT_COEFF+i*64, iStride);
				}
				iPosition =ix*8;
				TransferBlock16ToImage8(iPosition+pCurRecFrame->Cb, DCT_COEFF+256, iStrideHalf);
				TransferBlock16ToImage8(iPosition+pCurRecFrame->Cr, DCT_COEFF+320, iStrideHalf);

			}

	return 1;
}