texdata.c

Lido PXA270平台开发板的最新BSP,包括源代码

	{
		/* Optimises writes for 2x2 block */
		for(ui32Count = 0; ui32Count < ui32Width*ui32Height; ui32Count += 4)
		{
			aui32Pos[0]=0; /*U*/
			aui32Pos[1]=0; /*V*/
			
			getUV(aui32Pos, ui32Count, ui32USize, ui32VSize);
			ui32Address = (aui32Pos[1] * ui32StrideIn) + aui32Pos[0];
			
			pui32Address[ui32Count]		= pui32Pixels[ui32Address];
			pui32Address[ui32Count+1]	= pui32Pixels[ui32Address + ui32StrideIn];
			pui32Address[ui32Count+2]	= pui32Pixels[ui32Address + 1];
			pui32Address[ui32Count+3]	= pui32Pixels[ui32Address + ui32StrideIn + 1];
		}
	}
	else
	{
		for(ui32Count = 0; ui32Count < ui32Width*ui32Height; ui32Count++)
		{
			aui32Pos[0]=0; /*U*/
			aui32Pos[1]=0; /*V*/
			
			getUV(aui32Pos, ui32Count, ui32USize, ui32VSize);
			ui32Address = (aui32Pos[1] * ui32StrideIn) + aui32Pos[0];			

			pui32Address[ui32Count]		= pui32Pixels[ui32Address];
		}
	}
}


/***********************************************************************************
 Function Name      : ReadBackTwiddle[8/16/32]bpp
 Inputs             : pvSrc, ui32Log2Width, ui32Log2Height, ui32X, ui32Y, ui32Width, 
					  ui32Height, ui32DstStride
 Outputs            : pvDest
 Returns            : -
 Description        : Reads a subreagion back from a twiddled texture
					  using random read, sequential write.
************************************************************************************/

static IMG_VOID ReadBackTwiddle8bpp(IMG_VOID *pvDest, const IMG_VOID *pvSrc, IMG_UINT32 ui32Log2Width, 
									IMG_UINT32 ui32Log2Height, IMG_UINT32 ui32X, IMG_UINT32 ui32Y, 
									IMG_UINT32 ui32Width, IMG_UINT32 ui32Height, IMG_UINT32 ui32DstStride)
{
	IMG_UINT32 ui32XCount, ui32YCount, ui32Address;
	IMG_UINT8 *pui8Address = (IMG_UINT8 *)pvDest;
	IMG_UINT8 *pui8Pixels = (IMG_UINT8 *)pvSrc;
	
	for(ui32YCount=0; ui32YCount < ui32Height; ui32YCount++)
	{
		for(ui32XCount=0; ui32XCount < ui32Width; ui32XCount++)
		{
			ui32Address = getTwiddledAddress(ui32XCount + ui32X, ui32YCount + ui32Y, ui32Log2Width, ui32Log2Height);
		
			pui8Address[ui32YCount*ui32DstStride + ui32XCount] = pui8Pixels[ui32Address];
		}
	}
}

static IMG_VOID ReadBackTwiddle16bpp(IMG_VOID *pvDest, const IMG_VOID *pvSrc, IMG_UINT32 ui32Log2Width, 
									IMG_UINT32 ui32Log2Height, IMG_UINT32 ui32X, IMG_UINT32 ui32Y, 
									IMG_UINT32 ui32Width, IMG_UINT32 ui32Height, IMG_UINT32 ui32DstStride)
{
	IMG_UINT32 ui32XCount, ui32YCount, ui32Address;
	IMG_UINT16 *pui16Address = (IMG_UINT16 *)pvDest;
	IMG_UINT16 *pui16Pixels = (IMG_UINT16 *)pvSrc;
	
	for(ui32YCount=0;ui32YCount < ui32Height;ui32YCount++)
	{
		for(ui32XCount=0; ui32XCount < ui32Width; ui32XCount++)
		{
			ui32Address = getTwiddledAddress(ui32XCount + ui32X, ui32YCount + ui32Y, ui32Log2Width, ui32Log2Height);
		
			pui16Address[ui32YCount*ui32DstStride + ui32XCount] = pui16Pixels[ui32Address];
		}
	}
}

static IMG_VOID ReadBackTwiddle32bpp(IMG_VOID *pvDest, const IMG_VOID *pvSrc, IMG_UINT32 ui32Log2Width, 
									IMG_UINT32 ui32Log2Height, IMG_UINT32 ui32X, IMG_UINT32 ui32Y, 
									IMG_UINT32 ui32Width, IMG_UINT32 ui32Height, IMG_UINT32 ui32DstStride)
{
	IMG_UINT32 ui32XCount, ui32YCount, ui32Address;
	IMG_UINT32 *pui32Address = (IMG_UINT32 *)pvDest;
	IMG_UINT32 *pui32Pixels = (IMG_UINT32 *)pvSrc;
	
	for(ui32YCount=0;ui32YCount < ui32Height;ui32YCount++)
	{
		for(ui32XCount=0; ui32XCount < ui32Width; ui32XCount++)
		{
			ui32Address = getTwiddledAddress(ui32XCount + ui32X, ui32YCount + ui32Y, ui32Log2Width, ui32Log2Height);
		
			pui32Address[ui32YCount*ui32DstStride + ui32XCount] = pui32Pixels[ui32Address];
		}
	}
}


/***********************************************************************************
 Function Name      : GetMipMapOffset
 Inputs             : ui32MapLevel, ui32TopUSize, ui32TopVSize
 Outputs            : -
 Returns            : Mipmap offset in pixels
 Description        : Calculates the pixel offset to a given map in a mipmap chain.
************************************************************************************/

IMG_UINT32 GetMipMapOffset(IMG_UINT32 ui32MapLevel, IMG_UINT32 ui32TopUSize, IMG_UINT32 ui32TopVSize)
{
    IMG_UINT32 i, ui32USize, ui32VSize, ui32MapOffset = 0;

	ui32USize = ui32TopUSize;
	ui32VSize = ui32TopVSize;
	
	/* Calculate the space taken up by all the map levels previous to this one */
	for (i = 0; i < ui32MapLevel; i++)
	{
		ui32MapOffset += (ui32USize * ui32VSize);
		
		ui32USize >>= 1;
		
		if(ui32USize==0)
			ui32USize=1;
		
		ui32VSize >>= 1;
		
		if(ui32VSize==0)
			ui32VSize=1;
	}

	return ui32MapOffset;

}


/***********************************************************************************
 Function Name      : GetCompressedMipMapOffset
 Inputs             : ui32MapLevel, ui32TopUSize, ui32TopVSize
 Outputs            : -
 Returns            : Mipmap offset in pixels
 Description        : Calculates the pixel offset to a given map in a mipmap chain.
************************************************************************************/

IMG_UINT32 GetCompressedMipMapOffset(IMG_UINT32 ui32MapLevel, IMG_UINT32 ui32TopUSize, 
									 IMG_UINT32 ui32TopVSize, IMG_BOOL bIs2Bpp)
{
    IMG_UINT32 i, ui32USize, ui32VSize, ui32MapOffset = 0;

	ui32USize = ui32TopUSize;
	ui32VSize = ui32TopVSize;
	
	if(bIs2Bpp)
	{
		/* Calculate the space taken up by all the map levels previous to this one */
		for (i = 0; i < ui32MapLevel; i++)
		{
			ui32MapOffset += (ui32USize * ui32VSize);
			
			ui32USize >>= 1;
			
			if(ui32USize==8)
				ui32USize=16;
			
			ui32VSize >>= 1;
			
			if(ui32VSize==4)
				ui32VSize=8;
		}
		/* PVRTC2 stores 8x4 texels in a block,
		 * so divide by 32 for number of compressed blocks
		 */
		ui32MapOffset >>= 5;

	}
	else
	{
		/* Calculate the space taken up by all the map levels previous to this one */
		for (i = 0; i < ui32MapLevel; i++)
		{
			ui32MapOffset += (ui32USize * ui32VSize);
			
			ui32USize >>= 1;
			
			if(ui32USize==4)
				ui32USize=8;
			
			ui32VSize >>= 1;
			
			if(ui32VSize==4)
				ui32VSize=8;
		}

		/* PVRTC4 stores 4x4 texels in a block,
		 * so divide by 16 for number of compressed blocks
		 */
		ui32MapOffset >>= 4;
	}
	return ui32MapOffset;
}

/***********************************************************************************
 Function Name      : TwiddleLoadData
 Inputs             : psTex, ui32Width, ui32Height, ui32SrcLod, ui32DstLod, pvBuffer
 Outputs            : psTex
 Returns            : -
 Description        : Twiddles and loads texture data for a mipmap level into a 
					  texture.
************************************************************************************/

static IMG_VOID TwiddleLoadData(GLEStexture *psTex, IMG_UINT32 ui32Width,IMG_UINT32 ui32Height, 
								IMG_UINT32 ui32SrcLod, IMG_UINT32 ui32DstLod, IMG_VOID *pvBuffer)
{
	IMG_UINT32 ui32OffsetInBytes;
	IMG_UINT32 ui32TopUsize, ui32TopVsize;
    const GLEStextureFormat *psTexFmt = psTex->psFormat;
	IMG_UINT32 ui32BytesPerPixel;
	IMG_VOID *pvDest;

	ui32TopUsize = 1 << (((psTex->ui32HWSize & ~MBX1_TSPPL1_TUSIZECLRMASK) >> MBX1_TSPPL1_TUSIZESHIFT) + 
						GLES_MIN_TEXTURE_LEVEL);
	
	ui32TopVsize = 1 << (((psTex->ui32HWSize & ~MBX1_TSPPL1_TVSIZECLRMASK) >> MBX1_TSPPL1_TVSIZESHIFT) + 
						GLES_MIN_TEXTURE_LEVEL);

	ui32BytesPerPixel = (psTexFmt->ui32BitsPerTexel+7) >> 3;

	if(ui32BytesPerPixel == 8)
	{
		ui32OffsetInBytes = ui32BytesPerPixel * 
			GetCompressedMipMapOffset(ui32DstLod, ui32TopUsize, ui32TopVsize, 
			psTexFmt->ui32HWFormat == MBX1_TSPPL1_TPIXFORMPVRTC2 ? IMG_TRUE : IMG_FALSE);

#if defined(DEBUG)
		if(psTex->asMipLevel[ui32SrcLod].ui32ImageSize + ui32OffsetInBytes > psTex->psMemInfo->ui32AllocSize)
		{
			DPF((DBG_ERROR,"Memory calculation error somewhere"));
			return;
		}
#endif
	}
	else
	{
		ui32OffsetInBytes = ui32BytesPerPixel * GetMipMapOffset(ui32DstLod, ui32TopUsize, ui32TopVsize);
		
#if defined(DEBUG)
		if(ui32Width * ui32Height * ui32BytesPerPixel + ui32OffsetInBytes > psTex->psMemInfo->ui32AllocSize)
		{
			DPF((DBG_ERROR,"Memory calculation error somewhere"));
			return;

		}
#endif
	}

	pvDest = (IMG_UINT8 *)psTex->psMemInfo->pvLinAddr + ui32OffsetInBytes;
	
	if(ui32BytesPerPixel == 8)
	{
		/* PVRTC */
		HostMemCopy(pvDest, pvBuffer, psTex->asMipLevel[ui32SrcLod].ui32ImageSize);
	}
	else
	{
		psTex->pfnTextureTwiddle(pvDest, pvBuffer, ui32Width, ui32Height, ui32Width);
	}
}

/***********************************************************************************
 Function Name      : TwiddleLoadSubData
 Inputs             : psTex, ui32Lod, ui32X, ui32Y, ui32Width, ui32Height, pvBuffer
 Outputs            : psTex
 Returns            : -
 Description        : Twiddles and loads texture data for a mipmap level into a 
					  sub region of a texture.
************************************************************************************/

static IMG_VOID TwiddleLoadSubData(GLEStexture *psTex, IMG_UINT32 ui32Lod, IMG_UINT32 ui32X, IMG_UINT32 ui32Y, 
								   IMG_UINT32 ui32Width, IMG_UINT32 ui32Height, IMG_VOID *pvBuffer)
{
	IMG_UINT32 ui32OffsetInBytes;
	IMG_UINT32 ui32WidthLog2, ui32HeightLog2;
    const GLEStextureFormat *psTexFmt = psTex->psFormat;
	IMG_UINT32 ui32BytesPerPixel, ui32SrcStride;
	IMG_VOID *pvDest;

	ui32WidthLog2 = ((psTex->ui32HWSize & ~MBX1_TSPPL1_TUSIZECLRMASK) >> MBX1_TSPPL1_TUSIZESHIFT) + GLES_MIN_TEXTURE_LEVEL;
	ui32HeightLog2 = ((psTex->ui32HWSize & ~MBX1_TSPPL1_TVSIZECLRMASK) >> MBX1_TSPPL1_TVSIZESHIFT) + GLES_MIN_TEXTURE_LEVEL;
	
	ui32BytesPerPixel = (psTexFmt->ui32BitsPerTexel+7) >> 3;
	ui32SrcStride = psTex->asMipLevel[ui32Lod].ui32Width;

	ui32OffsetInBytes = ui32BytesPerPixel * GetMipMapOffset(ui32Lod, 1 << ui32WidthLog2, 1 << ui32HeightLog2);
	
	if(ui32Width * ui32Height * ui32BytesPerPixel + ui32OffsetInBytes > psTex->psMemInfo->ui32AllocSize)
	{
		/* Do something */
		return;
	}

	pvDest = (IMG_UINT8 *)psTex->psMemInfo->pvLinAddr + ui32OffsetInBytes;

	if(ui32Lod > ui32WidthLog2)
		ui32WidthLog2 = 0;
	else
		ui32WidthLog2 -= ui32Lod;

	if(ui32Lod > ui32HeightLog2)
		ui32HeightLog2 = 0;
	else
		ui32HeightLog2 -= ui32Lod;

	psTex->pfnSubTextureTwiddle(pvDest, pvBuffer, ui32WidthLog2, ui32HeightLog2, ui32X, ui32Y, 
								ui32Width, ui32Height, ui32SrcStride);
}

/***********************************************************************************
 Function Name      : TranslateScaleTexture
 Inputs             : gc, psTex, ui32Lod, pui8Src, ui32Width, ui32Height, 
					  ui32BytesPerPixel, ui32Factor
 Outputs            : psTex
 Returns            : -
 Description        : Scales a texture by doubling its size factor times.
************************************************************************************/