vram2b.c

基于东南大学开发的SEP3203的ARM7中的所有驱动

					}
					break;
				default:
					break;
			}
			
	#ifdef BIG_ENDIAN_ORDER
			mask = ~MAKEMASK( 16 - r );
			mask = ex2byte(mask);
			tempValue = (WORD)( ( (*((DWORD *)srcPos)) >> t ) );//old
//			tempValue = (WORD)( ( (*((DWORD *)srcPos)) >> ( 16 - t ) ) );
	#else
			mask = MAKEMASK( r );
			mask = test(mask);
			tempValue = (WORD)( ( (*((DWORD *)srcPos)) >> t ) );
	#endif
			UnitMaskOp( desPos, tempValue, mask, op );			
		}
	}
}

/*
 * LineOp_gfd 对指定的两行进行逻辑操作（包括按位与、或、异或、复制等）
 * 以8比特为一组
 */
void LineOp_gfd( PIXEL *desLinePos, CHAR desBitOffset, PIXEL *srcLinePos, CHAR srcBitOffset, WORD len, WORD op )
{
	WORD i;
	CHAR *srcPos = (CHAR *)srcLinePos, *desPos = (CHAR *)desLinePos;
	CHAR mask, mask_t,set_t;
	DWORD totalOffset, num, r = 0; 

	num = (((len<<LOG_PIXEL_BITS)>>LOG_UNIT)<<LOG_UNIT_BYTE);
	#if PIXEL_UNIT <= 8
	r = len%PIXELS_PER_UNIT;
	#endif
	
	if(!(desBitOffset|srcBitOffset))			//fisrt pixel in byte aligning
	{
		for( i = 0; i < num; i++, desPos++, srcPos++ )
			(*desPos) = (*srcPos);

		if(r)
		{
			mask = ~((1<<(8-2*r))-1);
			(*desPos) = ( (*desPos) & ~mask ) | ( (*srcPos) & mask );			
		}
	}else{
			if(desBitOffset == srcBitOffset){		
				if(num == 0)	{
					if((4-desBitOffset/2)>=r){
						mask = (((0xff>>desBitOffset)<<(8-desBitOffset-2*r))>>(8-desBitOffset-2*r));
						(*desPos) = ( (*desPos) & ~mask ) | ( (*srcPos) & mask );			
					}else{
						mask = 0xff>>desBitOffset;
						(*desPos) = ( (*desPos) & ~mask ) | ( (*srcPos) & mask );	
						desPos++;
						srcPos++;
						mask = ~(0xff>>(2*r - (8 -desBitOffset )));
						(*desPos) = ( (*desPos) & ~mask ) | ( (*srcPos) & mask );
					}
				}else{
					mask = 0xff>>desBitOffset;
					(*desPos) = ( (*desPos) & ~mask ) | ( (*srcPos) & mask );	
					desPos++;
					srcPos++;
					
					len = len - (8 -desBitOffset )/2;
					num = len/4;
					r = len%4;
					
					for( i = 0; i < num; i++, desPos++, srcPos++ )
					(*desPos) = (*srcPos);
					
					if(r){
						mask = ~((1<<(8-2*r))-1);
						(*desPos) = ( (*desPos) & ~mask ) | ( (*srcPos) & mask );			
					}

				}
			}else{
				while(len>0){
					if(desBitOffset > srcBitOffset){
						if(4-desBitOffset/2>=len){
							set_t = 2*(4-desBitOffset/2-len);
							mask = ((0xff>>desBitOffset)>>set_t)<<set_t;
							set_t = 2*(4-srcBitOffset/2-len);
							mask_t = ((0xff>>srcBitOffset)>>set_t)<<set_t;
							(*desPos) = ( (*desPos) & ~mask ) | (( (*srcPos) & mask_t)>>(desBitOffset - srcBitOffset));
							len = 0;
							if(4-desBitOffset/2 == len)desPos++;
						}else{
							mask = 0xff>>desBitOffset;
							mask_t = 0xff>>srcBitOffset;
							(*desPos) = ( (*desPos) & ~mask ) | (( (*srcPos) & mask_t)>>(desBitOffset - srcBitOffset));
							len -= (4-desBitOffset/2);
							desPos++;
							srcBitOffset += 2*(4-desBitOffset/2);
							desBitOffset = 0;
						}
					}else{
						if(4 -srcBitOffset/2>=len ){
							set_t = 2*(4-srcBitOffset/2-len);
							mask_t = ((0xff>>srcBitOffset)>>set_t)<<set_t;
							set_t = 2*(4-desBitOffset/2-len);
							mask = ((0xff>>desBitOffset)>>set_t)<<set_t;
							(*desPos) = ( (*desPos) & ~mask ) | (( (*srcPos) & mask_t)<<(srcBitOffset - desBitOffset));
							len = 0;
							if(4 -srcBitOffset/2 == len)srcPos++;
						}else{
							mask_t = 0xff>>srcBitOffset;
							mask = ((0xff>>desBitOffset)>>(srcBitOffset - desBitOffset))<<(srcBitOffset - desBitOffset);
							(*desPos) = ( (*desPos) & ~mask ) | (( (*srcPos) & mask_t)<<(srcBitOffset - desBitOffset));
							len -= (4-srcBitOffset/2);
							srcPos++;
							desBitOffset += 2*(4-srcBitOffset/2);
							srcBitOffset = 0;
						}
					}
				}
							
			}
		}
}


////gfd modified
void VertLineUnicolorOp( PIXEL *desLinePos, CHAR desBitOffset, WORD len, PIXEL srcValue, WORD mask, WORD op, VRAM *vram )
{
/*
#ifdef	BIG_ENDIAN_ORDER
	PIXEL	srcMask = PixelMask << ( PIXEL_UNIT - BITS_PER_PIXEL - desBitOffset );
#else
	PIXEL	srcMask = PixelMask << desBitOffset;
#endif
	WORD	lw = vram->widthInUnit;
	WORD	i;
	WORD 	enBit = 0;

#ifdef	BIG_ENDIAN_ORDER
	srcValue = srcValue << ( PIXEL_UNIT - desBitOffset - BITS_PER_PIXEL );
#else
	srcValue = srcValue << desBitOffset;
#endif
*/
////test for gfd:
	PIXEL	srcMask = PixelMask << ( PIXEL_UNIT - BITS_PER_PIXEL - desBitOffset );
	WORD	lw = vram->widthInUnit;
	WORD	i;
	WORD 	enBit = 0;
	srcValue = srcValue << ( PIXEL_UNIT - desBitOffset - BITS_PER_PIXEL );
////test end;

	switch( op )
	{
		case GPC_REPLACE_STYLE:
		case GPC_COPY_STYLE:
			for( i = 0; i < len; i++, desLinePos += lw )
			{
				if( enBit == 0 )
					enBit = 0x8000;
				if( enBit & mask )
					(*desLinePos) = ( (*desLinePos) & ~srcMask ) | ( srcValue & srcMask );
				enBit = enBit >> 1;
			}
			break;
		case GPC_XOR_STYLE:
			for( i = 0; i < len; i++, desLinePos += lw )
			{
				if( enBit == 0 )
					enBit = 0x8000;
				if( enBit & mask )
					(*desLinePos) = (*desLinePos) ^ ( srcValue & srcMask );
				enBit = enBit >> 1;
			}
			break;
		case GPC_AND_STYLE:
			for( i = 0; i < len; i++, desLinePos += lw )
			{
				if( enBit == 0 )
					enBit = 0x8000;
				if( enBit & mask )
					(*desLinePos) = (*desLinePos) & ( ( ~srcMask ) | ( srcValue & srcMask ) );
				enBit = enBit >> 1;
			}
			break;
		case GPC_OR_STYLE:
			for( i = 0; i < len; i++, desLinePos += lw )
			{
				if( enBit == 0 )
					enBit = 0x8000;
				if( enBit & mask )
					(*desLinePos) = (*desLinePos) | ( srcValue & srcMask );
				enBit = enBit >> 1;
			}
			break;
		default:
			break;
	}

	return;
}

//BlockUnicolorOP 对指定块进行单色逻辑操作（包括按位与、或、异或、复制等）
void BlockUnicolorOp( PIXEL *desLinePos, CHAR desBitOffset, WORD width, WORD height, PIXEL srcValue, WORD op, VRAM *vram )
{
	PIXEL *curPos = desLinePos;
//	PIXEL *nextPos;
	CHAR curBitOffset = desBitOffset;
//	CHAR nextBitOffset;
	WORD i;

	for( i = 0; i < height; i++ )
	{
		LineUnicolorOp( curPos, curBitOffset, width, srcValue, op );
		GetNextLine( &curPos, &curBitOffset, curPos, curBitOffset, vram );
//		curPos = nextPos;
//		curBitOffset = nextBitOffset;
	}
}

void BlockUnicolorMaskOp( PIXEL *desLinePos, CHAR desBitOffset, WORD width, WORD height, PIXEL srcValue, WORD mask, WORD op, VRAM *vram )
{
	PIXEL *curPos = desLinePos;
//	PIXEL *nextPos;
	CHAR curBitOffset = desBitOffset;
//	CHAR nextBitOffset;
	WORD i;

	for( i = 0; i < height; i++ )
	{
		LineUnicolorMaskOp( curPos, curBitOffset, width, srcValue, mask, op );
		GetNextLine( &curPos, &curBitOffset, curPos, curBitOffset, vram );
//		curPos = nextPos;
//		curBitOffset = nextBitOffset;
	}
}

//InvertBlock 对指定块进行反色操作
void InvertBlock( PIXEL *desLinePos, CHAR desBitOffset, WORD width, WORD height, VRAM *vram )
{
	PIXEL *curPos = desLinePos;
//	PIXEL *nextPos;
	CHAR curBitOffset = desBitOffset;
//	CHAR nextBitOffset;
	WORD i;

	for( i = 0; i < height; i++ )
	{
		InvertLine( curPos, curBitOffset, width );
		GetNextLine( &curPos, &curBitOffset, curPos, curBitOffset, vram );
//		curPos = nextPos;
//		curBitOffset = nextBitOffset;
	}
}

//BlockOP 对指定的两块区域进行逻辑操作（包括按位与、或、异或、复制等）
void BlockOp( PIXEL *desLinePos, CHAR desBitOffset, PIXEL *srcLinePos, CHAR srcBitOffset, WORD width, WORD height, WORD op, VRAM *desVram, VRAM *srcVram )
{
	PIXEL *curDesPos = desLinePos, *curSrcPos = srcLinePos;
//	PIXEL *nextDesPos, *nextSrcPos;
	CHAR curDesOffset = desBitOffset, curSrcOffset = srcBitOffset;
//	CHAR nextDesOffset, nextSrcOffset;
	WORD i;

	for( i = 0; i < height; i++ )
	{
////		LineOp( curDesPos, curDesOffset, curSrcPos, curSrcOffset, width, op );
		LineOp_gfd( curDesPos, curDesOffset, curSrcPos, curSrcOffset, width, op );
		GetNextLine( &curDesPos, &curDesOffset, curDesPos, curDesOffset, desVram );
		GetNextLine( &curSrcPos, &curSrcOffset, curSrcPos, curSrcOffset, srcVram );
//		curDesPos = nextDesPos;
//		curDesOffset = nextDesOffset;
//		curSrcPos = nextSrcPos;
//		curSrcOffset = nextSrcOffset;
	}
}

//---------------functions for test------------------------
//GetVRAM 申请一块指定大小的vram
VRAM *GetVRAM( WORD width, WORD height )
{
	VRAM *vram;
	DWORD size;

	vram = (VRAM *)SysLmalloc( sizeof( VRAM ) );
	if( vram == NULL )
		return NULL;

	vram->widthInPixel = width;
	vram->widthInBit = width << LOG_PIXEL_BITS;
	vram->widthInUnit = ( vram->widthInBit + PIXEL_UNIT -1 ) >> LOG_UNIT;
	vram->height = height;
	vram->lcdx = 0;
	vram->lcdy = 0;
	size = vram->widthInUnit * vram->height << LOG_UNIT_BYTE;
	vram->ad = ( PIXEL * )SysLmalloc( size);
////	vram->ad = ( PIXEL * )SysLmalloc( size + 0xfff );
////	vram->ad = ((int)vram->ad)&(0xfffff000);
////	vram->ad += 0x1000;
////	vram->ad = ( PIXEL * )(((int)SysLmalloc( size + 0xfff))&(0xfffff000) + 0x1000);
	if( vram->ad == NULL )
		return NULL;
	else
	{
		memset( vram->ad, 0xff, size );
		return vram;
	}
}

//---------------functions for test------------------------
//GetGRAM 申请一块指定大小的gram
VRAM *GetGRAM( WORD width, WORD height )
{
	VRAM *vram;
	DWORD size;

	vram = (VRAM *)SysLmalloc( sizeof( VRAM ) );
	if( vram == NULL )
		return NULL;

	vram->widthInPixel = width;
	vram->widthInBit = width << LOG_PIXEL_BITS;
	vram->widthInUnit = ( vram->widthInBit + PIXEL_UNIT -1 ) >> LOG_UNIT;
	vram->height = height;
	vram->lcdx = 0;
	vram->lcdy = 0;
	size = vram->widthInUnit * vram->height << LOG_UNIT_BYTE;
	vram->ad = ( PIXEL * )SysLmalloc( size);
	vram->ad = ( PIXEL * )SysLmalloc( size + 0xfff );
	vram->ad = ((int)vram->ad)&(0xfffff000);
	vram->ad += 0x1000;
	if( vram->ad == NULL )
		return NULL;
	else
	{
		memset( vram->ad, 0xff, size );
		return vram;
	}
}

//GetVRAMSize 获取指定vram的大小(字节单位)
DWORD GetVRAMSize( VRAM *vram )
{
	DWORD size;

	if( vram == NULL )
		return 0;

	size = vram->widthInUnit * vram->height << LOG_UNIT_BYTE;
	
	return size;
}

//GetBlock 申请一块指定大小的vram
PIXEL *GetBlock( WORD width, WORD height )
{
	PIXEL *block;
	DWORD size;
	
	size = ( ( width * BITS_PER_PIXEL + PIXEL_UNIT -1 ) >> ( LOG_UNIT - LOG_UNIT_BYTE ) ) * height;
	block = ( PIXEL * )SysLmalloc( size );
	if( block == NULL )
		return NULL;
	else
		return block;
}

//FreeVRAM 释放一块指定的vram
void FreeVRAM( VRAM *vram )
{
	if( vram == NULL )
		return;

	if( vram->ad != NULL )
		SysLfree( vram->ad );

	SysLfree( vram );
	
	return;
}


/*
void VRAMMap( WORD *x2, WORD *y2, WORD x1, WORD y1, VRAM *vram )
{
	*x2 = x1 < vram->lcdx ? 0 : x1 - vram->lcdx;
	*y2 = y1 < vram->lcdy ? 0 : y1 - vram->lcdy;
	if( *x2 >= vram->widthInPixel )
		*x2 = vram->widthInPixel -1;
	if( *y2 >= vram->height )
		*y2 = vram->height -1;
}
*/

/////////////////////////////////////////////////////////////////////////////////
void LinearColorMap( BYTE *color, BYTE index, BYTE maxColor, BYTE maxIndex)
{
	//if( index > maxIndex || !maxIndex || !maxColor )
	//	return E_PAR;
	
	if( maxIndex == maxColor )
		*color = index;
	else
		*color = index * maxColor / maxIndex;
		
	return;
}

///////////////////////////////////////////////////////////////////////////////////
void Unit1to2Op( PIXEL *desPos, CHAR desBitOffset, BYTE mask, WORD FrColor, WORD BkColor, WORD op )
{
	WORD	Value;
	WORD	index;
	
	Value = maskEx[mask];
	index = (WORD)( Value & ColorPalette[FrColor] );
	index |= ~Value & ColorPalette[BkColor];

	LineOp( desPos, desBitOffset, (PIXEL *)(&index), 0, 8, op );
}