texdata.c

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

/**************************************************************************
 * Name         : texdata.c
 * Author       : BCB
 * Created      : 02/06/2003
 *
 * Copyright    : 2003 by Imagination Technologies Limited. All rights reserved.
 *              : No part of this software, either material or conceptual 
 *              : may be copied or distributed, transmitted, transcribed,
 *              : stored in a retrieval system or translated into any 
 *              : human or computer language in any form by any means,
 *              : electronic, mechanical, manual or other-wise, or 
 *              : disclosed to third parties without the express written
 *              : permission of Imagination Technologies Limited, Unit 8, HomePark
 *              : Industrial Estate, King's Langley, Hertfordshire,
 *              : WD4 8LZ, U.K.
 *
 * Platform     : ANSI
 *
 * $Date: 2004/07/12 16:05:49 $ $Revision: 1.6 $
 * $Log: texdata.c $
 **************************************************************************/
#define MODULE_ID MODID_TEXDATA

#include "context.h"


/***********************************************************************************
 Function Name      : getUV
 Inputs             : ui32Val, ui32USize, ui32VSize
 Outputs            : pui32Pos
 Returns            : -
 Description        : Deinterleaves UV addresses from twiddled address
************************************************************************************/

static IMG_VOID getUV(IMG_UINT32 *pui32Pos, IMG_UINT32 ui32Val, IMG_UINT32 ui32USize, IMG_UINT32 ui32VSize)
{
	IMG_UINT32 ui32Valids=0;
	IMG_UINT32 ui32Mask = 1;
	IMG_UINT32 ui32UValid=0,ui32VValid=0;

	while(ui32VSize || ui32USize)
	{
		ui32UValid = ui32VValid = 0;

		if(ui32VSize)
		{
			pui32Pos[1] |= (ui32Val & ui32Mask) >> ui32Valids;
			ui32Mask <<= 1;
			ui32VSize--;
			ui32VValid++;
		}
		if(ui32USize)
		{
			pui32Pos[0] |= (ui32Val & ui32Mask) >> (ui32Valids + ui32VValid);
			ui32Mask <<= 1;
			ui32USize--;
			ui32UValid++;
		}

		ui32Valids += ui32UValid + ui32VValid - 1;
	}
}

/***********************************************************************************
 Function Name      : getTwiddledAddress
 Inputs             : ui32UPos, ui32VPos, ui32USize, ui32VSize
 Outputs            : -
 Returns            : Twiddled address
 Description        : Interleaves UV addresses to form a twiddled address 
************************************************************************************/

static IMG_UINT32 getTwiddledAddress(IMG_UINT32 ui32UPos, IMG_UINT32 ui32VPos, IMG_UINT32 ui32USize, IMG_UINT32 ui32VSize)
{
	IMG_UINT32 ui32Valids=0;
	IMG_UINT32 ui32Mask = 1;
	IMG_UINT32 ui32UValid=0,ui32VValid=0;
	IMG_UINT32 ui32Addr = 0;

	while(ui32VSize || ui32USize)
	{
		ui32UValid = ui32VValid = 0;

		if(ui32VSize)
		{
			ui32Addr |= (ui32VPos & ui32Mask) << ui32Valids;
			ui32VSize--;
			ui32VValid++;
		}

		if(ui32USize)
		{
			ui32Addr |= (ui32UPos & ui32Mask) << (ui32Valids + ui32VValid);
			ui32USize--;
			ui32UValid++;
		}

		ui32Mask <<= 1;
		ui32Valids += ui32UValid + ui32VValid - 1;
	}
	return ui32Addr;
}

/***********************************************************************************
 Function Name      : TwiddleAddress[8/16/32]bpp
 Inputs             : pvSrc, ui32Log2Width, ui32Log2Height, ui32X, ui32Y, ui32WWidth, 
					  ui32Height, ui32SrcStride
 Outputs            : pvDest
 Returns            : -
 Description        : Twiddles a subtexture using seqential read, random write.
************************************************************************************/

static IMG_VOID TwiddleAddress8bpp(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 ui32SrcStride)
{
	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[ui32Address] = pui8Pixels[ui32YCount*ui32SrcStride + ui32XCount];
		}
	}
}

static IMG_VOID TwiddleAddress16bpp(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 ui32SrcStride)
{
	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[ui32Address] = pui16Pixels[ui32YCount*ui32SrcStride + ui32XCount];
		}
	}
}

static IMG_VOID TwiddleAddress32bpp(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 ui32SrcStride)
{
	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[ui32Address] = pui32Pixels[ui32YCount*ui32SrcStride + ui32XCount];
		}
	}
}


/***********************************************************************************
 Function Name      : DeTwiddleAddress[8/16/32]bpp
 Inputs             : pvSrc, ui32Width, ui32Height, ui32StrideIn
 Outputs            : pvDest
 Returns            : -
 Description        : Twiddles a whole texture using random read, sequential write.
************************************************************************************/

static IMG_VOID DeTwiddleAddress8bpp(IMG_VOID *pvDest,
						  const IMG_VOID *pvSrc,
						  IMG_UINT32 ui32Width,
						  IMG_UINT32 ui32Height,
						  IMG_UINT32 ui32StrideIn)
{
	IMG_UINT32 ui32Count, ui32Address;
	IMG_UINT32 ui32Temp, aui32Pos[2];
	IMG_UINT32 ui32USize = 0, ui32VSize = 0;
	IMG_UINT8 *pui8Address = (IMG_UINT8 *)pvDest;
	IMG_UINT8 *pui8Pixels = (IMG_UINT8 *)pvSrc;

	/* Calculate power of 2 sizes */
	ui32Temp = ui32Width;
	while(ui32Temp>1)
	{
		ui32USize++;
		ui32Temp >>=1;
	}

	ui32Temp = ui32Height;
	while(ui32Temp>1)
	{
		ui32VSize++;
		ui32Temp >>=1;
	}

	
	if(ui32Width > 1 && ui32Height > 1)
	{
		/* 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];
			
			pui8Address[ui32Count]		= pui8Pixels[ui32Address];
			pui8Address[ui32Count+1]	= pui8Pixels[ui32Address + ui32StrideIn];
			pui8Address[ui32Count+2]	= pui8Pixels[ui32Address + 1];
			pui8Address[ui32Count+3]	= pui8Pixels[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];			

			pui8Address[ui32Count]		= pui8Pixels[ui32Address];
		}
	}
}

static IMG_VOID DeTwiddleAddress16bpp(IMG_VOID	*pvDest,
						   const IMG_VOID	*pvSrc,
						   IMG_UINT32 ui32Width,
						   IMG_UINT32 ui32Height,
						   IMG_UINT32 ui32StrideIn)
{
	IMG_UINT32 ui32Count, ui32Address;
	IMG_UINT32 ui32Temp, aui32Pos[2];
	IMG_UINT32 ui32USize = 0, ui32VSize = 0;
	IMG_UINT16 *pui16Address = (IMG_UINT16 *)pvDest;
	IMG_UINT16 *pui16Pixels = (IMG_UINT16 *)pvSrc;

	/* Calculate power of 2 sizes */
	ui32Temp = ui32Width;
	while(ui32Temp>1)
	{
		ui32USize++;
		ui32Temp >>=1;
	}

	ui32Temp = ui32Height;
	while(ui32Temp>1)
	{
		ui32VSize++;
		ui32Temp >>=1;
	}

	
	if(ui32Width > 1 && ui32Height > 1)
	{
		/* 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];
			
			pui16Address[ui32Count]		= pui16Pixels[ui32Address];
			pui16Address[ui32Count+1]	= pui16Pixels[ui32Address + ui32StrideIn];
			pui16Address[ui32Count+2]	= pui16Pixels[ui32Address + 1];
			pui16Address[ui32Count+3]	= pui16Pixels[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];			

			pui16Address[ui32Count]		= pui16Pixels[ui32Address];
		}
	}
}

static IMG_VOID DeTwiddleAddress32bpp(IMG_VOID	*pvDest,
						   const IMG_VOID	*pvSrc,
						   IMG_UINT32 ui32Width,
						   IMG_UINT32 ui32Height,
						   IMG_UINT32 ui32StrideIn)
{
	IMG_UINT32 ui32Count, ui32Address;
	IMG_UINT32 ui32Temp, aui32Pos[2];
	IMG_UINT32 ui32USize = 0, ui32VSize = 0;
	IMG_UINT32 *pui32Address = (IMG_UINT32 *)pvDest;
	IMG_UINT32 *pui32Pixels = (IMG_UINT32 *)pvSrc;

	/* Calculate power of 2 sizes */
	ui32Temp = ui32Width;
	while(ui32Temp>1)
	{
		ui32USize++;
		ui32Temp >>=1;
	}

	ui32Temp = ui32Height;
	while(ui32Temp>1)
	{
		ui32VSize++;
		ui32Temp >>=1;
	}

	
	if(ui32Width > 1 && ui32Height > 1)