vram.c

一个操作系统源代码 用于嵌入式设备 在Vc++环境下仿真 成功移植到多款处理器上

/***************************************************************
This file is add by DSA 2004.07.19
TO fit 
BLACK_WHITE_PDA && COLOR_PDA
It replce for vram2b.c and vramop.c
****************************************************************/

#include <string.h>
#include <sys\gpc.h>
#include <sys\lmalloc.h>
#include <sys\vramop.h>

#ifdef BLACK_WHITE_PDA
/************************************
* 
*
* DESCRIPTION:
* 对像素深度为1、2、4比特的VRAM进行操作的函数集合
*
*
* FUNCTION LIST:
* GetPixel					获取指定位置的像素值
* GetPixelPosition			获取指定像素的物理地址
* GetNextPixelPosition		获取指定像素的下一个像素的物理地址
* GetLine					获取指定行的行首像素的物理地址
* GetNextLine				获取指定行的下一行的行首像素的物理地址（同列）
* SetPixel					设置指定像素的值
* PixelOp					对指定像素进行逻辑操作（包括按位与、或、异或、复制等）
* PixelMaskOp				利用掩码对指定像素进行逻辑操作（包括按位与、或、异或、复制等）
* SetLine					设置指定行的值
* LineUnicolorOp			对指定行进行单色逻辑操作（包括按位与、或、异或、复制等）
* LineOp					对指定的两行进行逻辑操作（包括按位与、或、异或、复制等）
* BlockUnicolorOP			对指定块进行单色逻辑操作（包括按位与、或、异或、复制等）
* BlockOP					对指定的两块区域进行逻辑操作（包括按位与、或、异或、复制等）
*
* HISTORY:
*
*
***********************************************************************/
#ifdef		BIG_ENDIAN_ORDER
const WORD maskEx[] = {
0x0000, 0x0003, 0x000c, 0x000f, 0x0030, 0x0033, 0x003c, 0x003f, 0x00c0, 0x00c3, 0x00cc, 0x00cf, 0x00f0, 0x00f3, 0x00fc, 0x00ff, 
0x0300, 0x0303, 0x030c, 0x030f, 0x0330, 0x0333, 0x033c, 0x033f, 0x03c0, 0x03c3, 0x03cc, 0x03cf, 0x03f0, 0x03f3, 0x03fc, 0x03ff, 
0x0c00, 0x0c03, 0x0c0c, 0x0c0f, 0x0c30, 0x0c33, 0x0c3c, 0x0c3f, 0x0cc0, 0x0cc3, 0x0ccc, 0x0ccf, 0x0cf0, 0x0cf3, 0x0cfc, 0x0cff, 
0x0f00, 0x0f03, 0x0f0c, 0x0f0f, 0x0f30, 0x0f33, 0x0f3c, 0x0f3f, 0x0fc0, 0x0fc3, 0x0fcc, 0x0fcf, 0x0ff0, 0x0ff3, 0x0ffc, 0x0fff, 
0x3000, 0x3003, 0x300c, 0x300f, 0x3030, 0x3033, 0x303c, 0x303f, 0x30c0, 0x30c3, 0x30cc, 0x30cf, 0x30f0, 0x30f3, 0x30fc, 0x30ff, 
0x3300, 0x3303, 0x330c, 0x330f, 0x3330, 0x3333, 0x333c, 0x333f, 0x33c0, 0x33c3, 0x33cc, 0x33cf, 0x33f0, 0x33f3, 0x33fc, 0x33ff, 
0x3c00, 0x3c03, 0x3c0c, 0x3c0f, 0x3c30, 0x3c33, 0x3c3c, 0x3c3f, 0x3cc0, 0x3cc3, 0x3ccc, 0x3ccf, 0x3cf0, 0x3cf3, 0x3cfc, 0x3cff, 
0x3f00, 0x3f03, 0x3f0c, 0x3f0f, 0x3f30, 0x3f33, 0x3f3c, 0x3f3f, 0x3fc0, 0x3fc3, 0x3fcc, 0x3fcf, 0x3ff0, 0x3ff3, 0x3ffc, 0x3fff, 
0xc000, 0xc003, 0xc00c, 0xc00f, 0xc030, 0xc033, 0xc03c, 0xc03f, 0xc0c0, 0xc0c3, 0xc0cc, 0xc0cf, 0xc0f0, 0xc0f3, 0xc0fc, 0xc0ff, 
0xc300, 0xc303, 0xc30c, 0xc30f, 0xc330, 0xc333, 0xc33c, 0xc33f, 0xc3c0, 0xc3c3, 0xc3cc, 0xc3cf, 0xc3f0, 0xc3f3, 0xc3fc, 0xc3ff, 
0xcc00, 0xcc03, 0xcc0c, 0xcc0f, 0xcc30, 0xcc33, 0xcc3c, 0xcc3f, 0xccc0, 0xccc3, 0xcccc, 0xcccf, 0xccf0, 0xccf3, 0xccfc, 0xccff, 
0xcf00, 0xcf03, 0xcf0c, 0xcf0f, 0xcf30, 0xcf33, 0xcf3c, 0xcf3f, 0xcfc0, 0xcfc3, 0xcfcc, 0xcfcf, 0xcff0, 0xcff3, 0xcffc, 0xcfff, 
0xf000, 0xf003, 0xf00c, 0xf00f, 0xf030, 0xf033, 0xf03c, 0xf03f, 0xf0c0, 0xf0c3, 0xf0cc, 0xf0cf, 0xf0f0, 0xf0f3, 0xf0fc, 0xf0ff, 
0xf300, 0xf303, 0xf30c, 0xf30f, 0xf330, 0xf333, 0xf33c, 0xf33f, 0xf3c0, 0xf3c3, 0xf3cc, 0xf3cf, 0xf3f0, 0xf3f3, 0xf3fc, 0xf3ff, 
0xfc00, 0xfc03, 0xfc0c, 0xfc0f, 0xfc30, 0xfc33, 0xfc3c, 0xfc3f, 0xfcc0, 0xfcc3, 0xfccc, 0xfccf, 0xfcf0, 0xfcf3, 0xfcfc, 0xfcff, 
0xff00, 0xff03, 0xff0c, 0xff0f, 0xff30, 0xff33, 0xff3c, 0xff3f, 0xffc0, 0xffc3, 0xffcc, 0xffcf, 0xfff0, 0xfff3, 0xfffc, 0xffff
};
#else
const WORD maskEx[] = {
0x0000, 0xc000, 0x3000, 0xf000, 0x0c00, 0xcc00, 0x3c00, 0xfc00, 0x0300, 0xc300, 0x3300, 0xf300, 0x0f00, 0xcf00, 0x3f00, 0xff00, 
0x00c0, 0xc0c0, 0x30c0, 0xf0c0, 0x0cc0, 0xccc0, 0x3cc0, 0xfcc0, 0x03c0, 0xc3c0, 0x33c0, 0xf3c0, 0x0fc0, 0xcfc0, 0x3fc0, 0xffc0, 
0x0030, 0xc030, 0x3030, 0xf030, 0x0c30, 0xcc30, 0x3c30, 0xfc30, 0x0330, 0xc330, 0x3330, 0xf330, 0x0f30, 0xcf30, 0x3f30, 0xff30, 
0x00f0, 0xc0f0, 0x30f0, 0xf0f0, 0x0cf0, 0xccf0, 0x3cf0, 0xfcf0, 0x03f0, 0xc3f0, 0x33f0, 0xf3f0, 0x0ff0, 0xcff0, 0x3ff0, 0xfff0, 
0x000c, 0xc00c, 0x300c, 0xf00c, 0x0c0c, 0xcc0c, 0x3c0c, 0xfc0c, 0x030c, 0xc30c, 0x330c, 0xf30c, 0x0f0c, 0xcf0c, 0x3f0c, 0xff0c, 
0x00cc, 0xc0cc, 0x30cc, 0xf0cc, 0x0ccc, 0xcccc, 0x3ccc, 0xfccc, 0x03cc, 0xc3cc, 0x33cc, 0xf3cc, 0x0fcc, 0xcfcc, 0x3fcc, 0xffcc, 
0x003c, 0xc03c, 0x303c, 0xf03c, 0x0c3c, 0xcc3c, 0x3c3c, 0xfc3c, 0x033c, 0xc33c, 0x333c, 0xf33c, 0x0f3c, 0xcf3c, 0x3f3c, 0xff3c, 
0x00fc, 0xc0fc, 0x30fc, 0xf0fc, 0x0cfc, 0xccfc, 0x3cfc, 0xfcfc, 0x03fc, 0xc3fc, 0x33fc, 0xf3fc, 0x0ffc, 0xcffc, 0x3ffc, 0xfffc, 
0x0003, 0xc003, 0x3003, 0xf003, 0x0c03, 0xcc03, 0x3c03, 0xfc03, 0x0303, 0xc303, 0x3303, 0xf303, 0x0f03, 0xcf03, 0x3f03, 0xff03, 
0x00c3, 0xc0c3, 0x30c3, 0xf0c3, 0x0cc3, 0xccc3, 0x3cc3, 0xfcc3, 0x03c3, 0xc3c3, 0x33c3, 0xf3c3, 0x0fc3, 0xcfc3, 0x3fc3, 0xffc3, 
0x0033, 0xc033, 0x3033, 0xf033, 0x0c33, 0xcc33, 0x3c33, 0xfc33, 0x0333, 0xc333, 0x3333, 0xf333, 0x0f33, 0xcf33, 0x3f33, 0xff33, 
0x00f3, 0xc0f3, 0x30f3, 0xf0f3, 0x0cf3, 0xccf3, 0x3cf3, 0xfcf3, 0x03f3, 0xc3f3, 0x33f3, 0xf3f3, 0x0ff3, 0xcff3, 0x3ff3, 0xfff3, 
0x000f, 0xc00f, 0x300f, 0xf00f, 0x0c0f, 0xcc0f, 0x3c0f, 0xfc0f, 0x030f, 0xc30f, 0x330f, 0xf30f, 0x0f0f, 0xcf0f, 0x3f0f, 0xff0f, 
0x00cf, 0xc0cf, 0x30cf, 0xf0cf, 0x0ccf, 0xcccf, 0x3ccf, 0xfccf, 0x03cf, 0xc3cf, 0x33cf, 0xf3cf, 0x0fcf, 0xcfcf, 0x3fcf, 0xffcf, 
0x003f, 0xc03f, 0x303f, 0xf03f, 0x0c3f, 0xcc3f, 0x3c3f, 0xfc3f, 0x033f, 0xc33f, 0x333f, 0xf33f, 0x0f3f, 0xcf3f, 0x3f3f, 0xff3f, 
0x00ff, 0xc0ff, 0x30ff, 0xf0ff, 0x0cff, 0xccff, 0x3cff, 0xfcff, 0x03ff, 0xc3ff, 0x33ff, 0xf3ff, 0x0fff, 0xcfff, 0x3fff, 0xffff
};
#endif

const DWORD ColorPalette[] = { 0x0000, 0x5555, 0xaaaa, 0xffff};
#if ( BITS_PER_PIXEL == 1 || BITS_PER_PIXEL == 2 || BITS_PER_PIXEL == 4 )
// 针对1、2、4比特像素深度进行优化

#if ( BITS_PER_PIXEL == 1 )
const PIXEL PixelMask = 0x01;
#elif ( BITS_PER_PIXEL == 2 )
const PIXEL PixelMask = 0x03;
#elif ( BITS_PER_PIXEL == 4 )
const PIXEL PixelMask = 0x0f;
#endif

#define PIXELMASKOP( desPixelPos, srcValue, srcMask, op )\
	switch( (op) )\
	{\
		case GPC_REPLACE_STYLE:\
		case GPC_COPY_STYLE:\
			(*(desPixelPos)) = ( (*(desPixelPos)) & ~(srcMask) ) | ( (srcValue) & (srcMask) );\
			break;\
		case GPC_XOR_STYLE:\
			(*(desPixelPos)) ^= ( (srcValue) & (srcMask) );\
			break;\
		case GPC_AND_STYLE:\
			(*(desPixelPos)) &= ( ( ~(srcMask) ) | ( (srcValue) & (srcMask) ) );\
			break;\
		case GPC_OR_STYLE:\
			(*(desPixelPos)) |= ( (srcValue) & (srcMask) );\
			break;\
		default:\
			break;\
	}

//关于vram的操作
//GetPixel 获取指定位置的像素值
void newGetPixel( PIXEL *pixelValue, PIXEL *pixelPos, CHAR bitOffset )
{
#ifdef	BIG_ENDIAN_ORDER
	*pixelValue = ( (*pixelPos) >> ( PIXEL_UNIT - BITS_PER_PIXEL - bitOffset ) ) & PixelMask;
#else
	*pixelValue = ( (*pixelPos) >> bitOffset ) & PixelMask;
#endif
}

//GetPixelPosition 获取指定像素的物理地址
void GetPixelPosition( PIXEL **pixelPos, CHAR *bitOffset, VRAM *vram, WORD x, WORD y )
{
	DWORD lineOffset;
	
	lineOffset = x << LOG_PIXEL_BITS;
	*pixelPos = vram->ad + y * vram->widthInUnit + ( x >> LOG_PIXEL_NUM );	
	(*bitOffset) = ( CHAR ) ( lineOffset & ( PIXEL_UNIT -1 ) );
}

//GetNextPixelPosition 获取指定像素的下一个像素的物理地址
void GetNextPixelPosition( PIXEL **nextPixelPos, CHAR *newBitOffset, PIXEL *pixelPos, CHAR bitOffset )
{
	CHAR r;
	
	r = PIXEL_UNIT - bitOffset;
	if( r > BITS_PER_PIXEL )	// 像素尺寸小于剩余单位
	{
		*nextPixelPos = pixelPos;
		*newBitOffset = bitOffset + BITS_PER_PIXEL;
	}
	else    // 像素越过或恰好到达边界
	{
		*nextPixelPos = pixelPos +1;
		*newBitOffset = BITS_PER_PIXEL - r;
	}
}

//GetLine 获取指定行的行首像素的物理地址
// repalce with macro
void GetLine( PIXEL **pixelPos, CHAR *bitOffset, VRAM *vram, WORD y )
{
	*pixelPos = vram->ad + y * vram->widthInUnit;
	(*bitOffset) = 0;
}

//GetNextLine 获取指定行的下一行的行首像素的物理地址
// repalce with macro
/*
void GetNextLine( PIXEL **nextPixelPos, CHAR *nextBitOffset, PIXEL *pixelPos, CHAR bitOffset, VRAM *vram )
{
	*nextPixelPos = pixelPos + vram->widthInUnit;
	(*nextBitOffset) = bitOffset;
}
*/

//SetPixel 设置指定像素的值
void newSetPixel( PIXEL *pixelPos, CHAR bitOffset, PIXEL pixelValue )
{
#ifdef	BIG_ENDIAN_ORDER
	PIXEL	mask = PixelMask << ( PIXEL_UNIT - BITS_PER_PIXEL - bitOffset );
#else
	PIXEL	mask = PixelMask << bitOffset;
#endif

#ifdef	BIG_ENDIAN_ORDER
	pixelValue = pixelValue << ( PIXEL_UNIT - BITS_PER_PIXEL - bitOffset );
#else
	pixelValue = pixelValue << bitOffset;
#endif
	(*pixelPos) = ( (*pixelPos) & ~mask ) | pixelValue;
}

//SetLine 设置指定行的值
//以4个字节为一个操作单位
void SetLine( PIXEL *linePos, CHAR bitOffset, WORD len, PIXEL lineValue )
{
	DWORD *pixelPos = (DWORD *)linePos, ad;
	DWORD unitValue = lineValue;
	SHORT i, k;
	
	DWORD mask;
	WORD totalOffset, num, r;
	
	ad = ( (DWORD)pixelPos ) & 0x3;
	if( ad != 0 )		// 奇地址
	{
		pixelPos = (DWORD *)(( (DWORD)pixelPos ) - ( 4 - ad ));
		bitOffset += (CHAR)( ( 4 - ad )<< 3 );
	}

	totalOffset = ( len << LOG_PIXEL_BITS ) + bitOffset;
	num = totalOffset >> 5;
	r = totalOffset & 0x1f;
	for( i = -2, k = BITS_PER_PIXEL; i < LOG_PIXEL_NUM; i ++ )	// 循环次数为log2( PIXEL_NUM * 4 )
	{
		unitValue |= ( unitValue << k );
		k = k << 1;
	}
	
	if( bitOffset != 0 )
	{						
		if( num == 0 )	// 不到一个整单位
		{
			mask = MAKEMASK( totalOffset - bitOffset ) << bitOffset;
			(*pixelPos) = ( (*pixelPos) & ~mask ) | ( unitValue & mask );
		}
		else	// 超过一个整单位
		{
			mask = MAKEMASK( bitOffset );
			(*pixelPos) = ( (*pixelPos) & mask ) | ( unitValue & ~mask );
			pixelPos++;
			
			for( i = 1; i < num; i++, pixelPos++ )
				(*pixelPos) = unitValue;
			
			if( r != 0 )	// 尾部
			{
				mask = MAKEMASK( r );
				(*pixelPos) = ( (*pixelPos) & ~mask ) | ( unitValue & mask );
			}
		}
	}
	else	// 起始边界对齐
	{
		for( i = 0; i < num; i++, pixelPos++ )
			(*pixelPos) = unitValue;
		
		if( r != 0 )	// 尾部
		{
			mask = MAKEMASK( r );
			(*pixelPos) = ( (*pixelPos) & ~mask ) | ( unitValue & mask );
		}
	}	
}

//PixelOp 对指定像素进行逻辑操作（包括按位与、或、异或、复制等）
void PixelOp( PIXEL *desPixelPos, CHAR desBitOffset, PIXEL srcValue, WORD op )
{
#ifdef	BIG_ENDIAN_ORDER
	PIXEL	srcMask = PixelMask << ( PIXEL_UNIT - BITS_PER_PIXEL - desBitOffset );
#else
	PIXEL	srcMask = PixelMask << desBitOffset;
#endif

#ifdef	BIG_ENDIAN_ORDER
	srcValue = srcValue << ( PIXEL_UNIT - BITS_PER_PIXEL - desBitOffset );
#else
	srcValue = srcValue << desBitOffset;
#endif
	
//	PIXELMASKOP( desPixelPos, srcValue, srcMask, op )		
	
	switch( op )
	{
		case GPC_REPLACE_STYLE:
		case GPC_COPY_STYLE:
			(*desPixelPos) = ( (*desPixelPos) & ~srcMask ) | ( srcValue & srcMask );
			break;
		case GPC_XOR_STYLE:
			(*desPixelPos) ^= ( srcValue & srcMask );
			break;
		case GPC_AND_STYLE:
			(*desPixelPos) &= ( ( ~srcMask ) | ( srcValue & srcMask ) );
			break;
		case GPC_OR_STYLE:
			(*desPixelPos) |= ( srcValue & srcMask );
			break;
		default:
			break;
	}

}

//InvertPixel 对指定像素进行反色逻辑操作
void InvertPixel( PIXEL *desPixelPos, CHAR desBitOffset )
{
#ifdef	BIG_ENDIAN_ORDER
	PIXEL	srcMask = PixelMask << ( PIXEL_UNIT - BITS_PER_PIXEL - desBitOffset );
#else
	PIXEL	srcMask = PixelMask << desBitOffset;
#endif

	(*desPixelPos) ^=  srcMask;
}

//PixelMaskOp 利用掩码对指定像素进行逻辑操作（包括按位与、或、异或、复制等）
// replace with macro
void PixelMaskOp( PIXEL *desPixelPos, PIXEL srcValue, PIXEL srcMask, WORD op )
{
//	PIXELMASKOP( desPixelPos, srcValue, srcMask, op )
	switch( op )
	{
		case GPC_REPLACE_STYLE:
		case GPC_COPY_STYLE:
			(*desPixelPos) = ( (*desPixelPos) & ~srcMask ) | ( srcValue & srcMask );
			break;
		case GPC_XOR_STYLE:
			(*desPixelPos) = (*desPixelPos) ^ ( srcValue & srcMask );
			break;
		case GPC_AND_STYLE:
			(*desPixelPos) = (*desPixelPos) & ( ( ~srcMask ) | ( srcValue & srcMask ) );
			break;
		case GPC_OR_STYLE:
			(*desPixelPos) = (*desPixelPos) | ( srcValue & srcMask );
			break;
		default:
			break;
	}	

}

//UnitMaskOp 利用掩码对指定一组像素进行逻辑操作（包括按位与、或、异或、复制等）
void UnitMaskOp( WORD *desPixelPos, WORD srcValue, WORD srcMask, WORD op )
{
//	PIXELMASKOP( desPixelPos, srcValue, srcMask, op )
	switch( op )
	{
		case GPC_REPLACE_STYLE:
		case GPC_COPY_STYLE:
			(*desPixelPos) = ( (*desPixelPos) & ~srcMask ) | ( srcValue & srcMask );
			break;
		case GPC_XOR_STYLE:
			(*desPixelPos) = (*desPixelPos) ^ ( srcValue & srcMask );
			break;
		case GPC_AND_STYLE:
			(*desPixelPos) = (*desPixelPos) & ( ( ~srcMask ) | ( srcValue & srcMask ) );
			break;
		case GPC_OR_STYLE:
			(*desPixelPos) = (*desPixelPos) | ( srcValue & srcMask );
			break;
		default:
			break;
	}	

}

//LineUnicolorOp 对指定行进行单色逻辑操作（包括按位与、或、异或、复制等）
//以32比特为一个操作单位
void LineUnicolorOp( PIXEL *desLinePos, CHAR desBitOffset, WORD len, PIXEL srcValue, WORD op )
{
	DWORD *pixelPos = (DWORD *)desLinePos, ad;
	DWORD unitValue = srcValue;
	SHORT i, k;
	
	DWORD mask;
	WORD totalOffset, num, r;
	
	ad = ( (DWORD)pixelPos ) & 0x3;
	if( ad != 0 )		// 奇地址
	{
		pixelPos = (DWORD *)(( (DWORD)pixelPos ) - ( 4 - ad ));
		desBitOffset += (CHAR)( ( 4 - ad )<< 3 );
	}

	totalOffset = ( len << LOG_PIXEL_BITS ) + desBitOffset;
	num = totalOffset >> 5;		// 4 bytes 
	r = totalOffset & 0x1f;
	for( i = -2, k = BITS_PER_PIXEL; i < LOG_PIXEL_NUM; i ++ )	// 循环次数为log2( PIXEL_NUM * 4 )
	{
		unitValue |= ( unitValue << k );
		k = k << 1;
	}
	
	if( desBitOffset != 0 )
	{						
		if( num == 0 )	// 不到一个整单位
		{
	#ifdef BIG_ENDIAN_ORDER
			mask = MAKEMASK( totalOffset - desBitOffset ) << ( 32 - totalOffset );
	#else
			mask = MAKEMASK( totalOffset - desBitOffset ) << desBitOffset;
	#endif
//			PixelMaskOp( pixelPos, unitValue, mask, op );
			PIXELMASKOP( pixelPos, unitValue, mask, op )
		}
		else	// 超过一个整单位
		{
	#ifdef BIG_ENDIAN_ORDER
			mask = MAKEMASK( 32 - desBitOffset );
	#else
			mask = ~MAKEMASK( desBitOffset );
	#endif
//			PixelMaskOp( pixelPos, unitValue, mask, op );	// 头部
			PIXELMASKOP( pixelPos, unitValue, mask, op )	// 头部
			pixelPos++;
			
			switch( op )
			{
				case GPC_REPLACE_STYLE:
				case GPC_COPY_STYLE:
					for( i = 1; i < num; i++, pixelPos++ )
						(*pixelPos) = unitValue;
					break;
				case GPC_XOR_STYLE:
					for( i = 1; i < num; i++, pixelPos++ )
						(*pixelPos) ^= unitValue;
					break;
				case GPC_AND_STYLE:
					for( i = 1; i < num; i++, pixelPos++ )
						(*pixelPos) &= unitValue;
					break;
				case GPC_OR_STYLE:
					for( i = 1; i < num; i++, pixelPos++ )
						(*pixelPos) |= unitValue;
					break;
				default:
					break;
			}
			
			if( r != 0 )	// 尾部
			{
	#ifdef BIG_ENDIAN_ORDER
				mask = ~MAKEMASK( 32 - r );
	#else
				mask = MAKEMASK( r );
	#endif
//				PixelMaskOp( pixelPos, unitValue, mask, op );
				PIXELMASKOP( pixelPos, unitValue, mask, op )
			}
		}
	}
	else	// 起始边界对齐
	{
		switch( op )
		{
			case GPC_REPLACE_STYLE:
			case GPC_COPY_STYLE:
				for( i = 0; i < num; i++, pixelPos++ )
					(*pixelPos) = unitValue;
				break;
			case GPC_XOR_STYLE:
				for( i = 0; i < num; i++, pixelPos++ )
					(*pixelPos) ^= unitValue;
				break;
			case GPC_AND_STYLE:
				for( i = 0; i < num; i++, pixelPos++ )
					(*pixelPos) &= unitValue;
				break;
			case GPC_OR_STYLE:
				for( i = 0; i < num; i++, pixelPos++ )
					(*pixelPos) |= unitValue;
				break;
			default:
				break;
		}
		
		if( r != 0 )	// 尾部
		{
	#ifdef BIG_ENDIAN_ORDER
			mask = ~MAKEMASK( 32 - r );
	#else
			mask = MAKEMASK( r );
	#endif
//			PixelMaskOp( pixelPos, unitValue, mask, op );
			PIXELMASKOP( pixelPos, unitValue, mask, op )
		}
	}	
}

//InvertLine 对指定行进行反色逻辑操作
//以32比特为一个操作单位
void InvertLine( PIXEL *desLinePos, CHAR desBitOffset, WORD len )
{
	DWORD *pixelPos = (DWORD *)desLinePos, ad;
	DWORD unitMask = -1;
	SHORT i;
	
	DWORD mask;
	WORD totalOffset, num, r;
	
	ad = ( (DWORD)pixelPos ) & 0x3;
	if( ad != 0 )		// 奇地址
	{
		pixelPos = (DWORD *)(( (DWORD)pixelPos ) - ( 4 - ad ));
		desBitOffset += (CHAR)( ( 4 - ad )<< 3 );
	}

	totalOffset = ( len << LOG_PIXEL_BITS ) + desBitOffset;
	num = totalOffset >> 5;		// 4 bytes 
	r = totalOffset & 0x1f;
	
	if( desBitOffset != 0 )
	{						
		if( num == 0 )	// 不到一个整单位
		{
	#ifdef BIG_ENDIAN_ORDER
			mask = MAKEMASK( totalOffset - desBitOffset ) << ( 32 - totalOffset );
	#else
			mask = MAKEMASK( totalOffset - desBitOffset ) << desBitOffset;
	#endif
			(*pixelPos) ^= mask;