testpattern.c

用C语言设计的EPSON LCD控制器S1D13700驱动。

					DisplayAddr += 1;
					}

				if (gfISVRAM)
					halWriteDisplay8(DisplayAddr, WHITE8, 1);
				else
					*(UInt8*)DisplayAddr = WHITE8;  // white right border
			
				LineAddr += gGraphStride;  // convert stride to words
				DisplayAddr = LineAddr;
				}
			
			// Draw bottom white border
			if (gfISVRAM)
				halWriteDisplay8(DisplayAddr, WHITE8, xMax+1);
			else for ( x=0; x<=xMax; x++ )
			{
				*(UInt8*)DisplayAddr = WHITE8;  // white
				DisplayAddr += 1;
			}
			break;

		case 16:
			// Draw three color bars and a gray shade bar
			xStep64 = (width*PRECISION) / 64;  // green bars have 64 shades
			xStep32 = (width*PRECISION) / 32;
			yStep = (height*PRECISION) / 4;

			yTickHeight = yStep / 2 / PRECISION;	// Ensure tick mark doesn't go below red color bar
			if ( yTickHeight < 1 )
				yTickHeight = 2;		// Tick mark must be at least two lines high

			// Ensure that steps are not zero
			if (xStep64 == 0)	xStep64 = width*PRECISION;
			if (xStep32 == 0)	xStep32 = width*PRECISION;
			if (yStep == 0)		yStep = height*PRECISION;

			CurrentColor = RED;
			xStep = xStep32;  // red only has 32 shades
			
			DisplayAddr = LineAddr;
			
			// Draw top white border
			if (gfISVRAM)
				{
				halWriteDisplay16(DisplayAddr, WHITE16, xMax+1);
//				DisplayAddr += 2*(xMax+1);
				}
			else for ( x=0; x<=xMax; x++ )
			{
				*(UInt16*)DisplayAddr = WHITE16;
				DisplayAddr += 2;
			}
			
			// The stride may be greater than the physical width, so don't
			// rely on just incrementing DisplayAddr to go to the next line.
			LineAddr += gGraphStride;  // convert stride to words
			DisplayAddr = LineAddr;
			
			
			// This loop writes lines 1 to height - 2
			yNext = yStep;
			yNextInt = yNext / PRECISION;

			for ( y=1; y<yMax; y++ )
				{
				if (gfISVRAM)
					halWriteDisplay16(DisplayAddr, WHITE16, 1);
				else
					*(UInt16*)DisplayAddr = WHITE16;  // white left border
				DisplayAddr += 2;

				if ( y == yNextInt )
					{
					yNext += yStep;
					yNextInt = yNext / PRECISION;

					++CurrentColor;
			
					if (CurrentColor == GREEN)
						xStep = xStep64;
					else
						xStep = xStep32;
					}
			
				color16 = 0x0000;

				// This loop writes columns 1 to width - 2
				xNext = xStep;
				xNextInt = xStep / PRECISION;

				for ( x=1; x<xMax; x++ )
					{
					if ((x >= xNextInt) || (xNext < PRECISION))
						{
						xNext += xStep;
						xNextInt = xNext / PRECISION;

						if (CurrentColor==RED)
							_AdvanceRed16( &color16 );
						else if (CurrentColor==BLUE)
							_AdvanceBlue16( &color16 );
						else if (CurrentColor==GRAY)
							{
							_AdvanceRed16( &color16 );
							_AdvanceBlue16( &color16 );
							_AdvanceGreen16( &color16, 2 );
							}
						else
							_AdvanceGreen16( &color16, 1 );
						}
			
					if ( (y<yTickHeight) && (x>=xTickLeft) && (x<=xTickRight) )
						{
						if (gfISVRAM)
							halWriteDisplay16(DisplayAddr, (UInt16) ~color16, 1);
						else
							*(UInt16*)DisplayAddr = (UInt16) ~color16;  // tick mark at top of display (inverted color to make mark visible)
						}
					else
						{
						if (gfISVRAM)
							halWriteDisplay16(DisplayAddr, color16, 1);
						else
							*(UInt16*)DisplayAddr = color16;
						}
					DisplayAddr += 2;
					}


				if (gfISVRAM)
					halWriteDisplay16(DisplayAddr, WHITE16, 1);
				else
					*(UInt16*)DisplayAddr = WHITE16;  // white right border
			
				LineAddr += gGraphStride;  // convert stride to words
				DisplayAddr = LineAddr;
				}
			
			// Draw bottom white border
			if (gfISVRAM)
				halWriteDisplay16(DisplayAddr, WHITE16, xMax+1);
			else for ( x=0; x<=xMax; x++ )
			{
				*(UInt16*)DisplayAddr = WHITE16;  // white
				DisplayAddr += 2;
			}
			break;

		case 32:
			// Draw three color bars and a gray shade bar
			xStep256 = (width*PRECISION) / 256;  // green bars have 256 shades
			yStep = (height*PRECISION) / 4;

			// Ensure that steps are not zero
			if (xStep256 == 0)	xStep256 = 1;
			if (yStep == 0)		yStep = 1;

			yTickHeight = yStep / 2 / PRECISION;	// Ensure tick mark doesn't go below red color bar
			if ( yTickHeight < 1 )
				yTickHeight = 2;		// Tick mark must be at least two lines high

			CurrentColor = RED;
			xStep = xStep256;  // red has 256 shades
		
			DisplayAddr = LineAddr;  // used for 32 bpp
		
			// Draw top white border
			if (gfISVRAM)
				{
				halWriteDisplay32(DisplayAddr, WHITE32, xMax+1);
//				DisplayAddr += 4*(xMax+1);
				}
			else for ( x=0; x<=xMax; x++ )
			{
				*(UInt32*)DisplayAddr = WHITE32;
				DisplayAddr += 4;
			}
		
			// The stride may be greater than the physical width, so don't
			// rely on just incrementing pDisplay32 to go to the next line.
			LineAddr += gGraphStride;  // convert stride to dwords
			DisplayAddr = LineAddr;
		
			
			// This loop writes lines 1 to height - 2
			yNext = yStep;
			yNextInt = yNext / PRECISION;

			for ( y=1; y<yMax; y++ )
				{
				if (gfISVRAM)
					halWriteDisplay32(DisplayAddr, WHITE32, 1);
				else
					*(UInt32*)DisplayAddr = WHITE32;  // white left border
				DisplayAddr += 4;
		
				if ( y == yNextInt )
					{
					yNext += yStep;
					yNextInt = yNext / PRECISION;

					++CurrentColor;
					xStep = xStep256;
					}
		
				red = 0x00;
				green = 0x00;
				blue = 0x00;
		
				// This loop writes columns 1 to width - 2
				xNext = xStep;
				xNextInt = xStep / PRECISION;

				for ( x=1; x<xMax; x++ )
					{
					while (x >= xNextInt)
						{
						xNext += xStep;
						xNextInt = xNext / PRECISION;

						if (CurrentColor==RED)
							++red;
						else if (CurrentColor==BLUE)
							++blue;
						else if (CurrentColor==GRAY)
							{
							++red;
							++green;
							++blue;
							}
						else
							++green;
						}
		
					color32 = ((UInt32)red << 16) | ((UInt16)green << 8) | blue;
					
					if ( (y<yTickHeight) && (x>=xTickLeft) && (x<=xTickRight) )
						{
						if (gfISVRAM)
							halWriteDisplay32(DisplayAddr, (UInt32) ~color32, 1);
						else
							*(UInt32*)DisplayAddr = (UInt32) ~color32;  // tick mark at top of display (inverted color to make mark visible)
						}
					else
						{
						if (gfISVRAM)
							halWriteDisplay32(DisplayAddr, color32, 1);
						else
							*(UInt32*)DisplayAddr = color32;
						}
					DisplayAddr += 4;
					}
		
				if (gfISVRAM)
					halWriteDisplay32(DisplayAddr, WHITE32, 1);
				else
					*(UInt32*)DisplayAddr = WHITE32;  // white right border
		
				LineAddr += gGraphStride;  // convert stride to dwords
				DisplayAddr = LineAddr;
				}
		
			// Draw bottom white border
			if (gfISVRAM)
				halWriteDisplay32(DisplayAddr, WHITE32, xMax+1);
			else for (x = 0; x <= xMax; ++x)
			{
				*(UInt32*)DisplayAddr = WHITE32;  // white
				DisplayAddr += 4;
			}
			break;
		}
}

//----------------------------------------------------------------------------
//	_AdvanceRed8_RGB332
//
//	Description:	Advances red component of RGB 8 bpp 3-3-2 by specified value
//
//	Input:			pColor		pointer to RGB 8 bpp 3-3-2 value
//
//	Output:			n/a
//
//----------------------------------------------------------------------------
static void _AdvanceRed8_RGB332( UInt8* pColor, int advance )
{
	UInt32 red = *pColor;
	red = (red >> 5) & 0x07;
	red += advance;
	red = (red & 0x07) << 5;
	red = (*pColor & (~0xe0)) | red;

	if (red == 0)
		red = 0xe0;

	*pColor = (UInt8) red;
}

//----------------------------------------------------------------------------
//	_AdvanceGreen8_RGB332
//
//	Description:	Advances green component of RGB 8 bpp 3-3-2 by specified value
//
//	Input:			pColor		pointer to RGB 8 bpp 3-3-2 value
//					advance		amount to advance
//
//	Output:			n/a
//
//----------------------------------------------------------------------------
static void _AdvanceGreen8_RGB332( UInt8* pColor, int advance )
{
	UInt32 green = (*pColor >> 2) & 0x07;
	green += advance;
	green = (green & 0x07) << 2;
	green = (*pColor & (~0x1c)) | green;

	if (green == 0)
		green = 0x1c;

	*pColor = (UInt8) green;
}

//----------------------------------------------------------------------------
//	_AdvanceBlue8_RGB332
//
//	Description:	Advances blue component of RGB 8 bpp 3-3-2 by 1
//
//	Input:			pColor		pointer to RGB 8 bpp 3-3-2 value
//
//	Output:			n/a
//
//----------------------------------------------------------------------------
static void _AdvanceBlue8_RGB332( UInt8* pColor )
{
	UInt32 blue = *pColor & 0x03;
	++blue;
	blue &= 0x03;
	blue = (*pColor & (~0x03)) | blue;

	if (blue == 0)
		blue = 0x03;

	*pColor = (UInt8) blue;
}

//----------------------------------------------------------------------------
//	_AdvanceRed16
//
//	Description:	Advances red component of RGB16 by 1
//
//	Input:			pColor		pointer to RGB16 value
//
//	Output:			n/a
//
//----------------------------------------------------------------------------
static void _AdvanceRed16( UInt16* pColor )
{
	UInt32 red = *pColor;
	red = (red >> 11) & 0x001F;
	++red;
	red = (red & 0x001F) << 11;
	red = ((*pColor & (~0xF800)) | (UInt16)red);
	*pColor = (UInt16)red;
}

//----------------------------------------------------------------------------
//	_AdvanceGreen16
//
//	Description:	Advances green component of RGB16 by specified value
//
//	Input:			pColor		pointer to RGB16 value
//					advance		amount to advance
//
//	Output:			n/a
//
//----------------------------------------------------------------------------
static void _AdvanceGreen16( UInt16* pColor, int advance )
{
	UInt32 green = (*pColor >> 5) & 0x003F;
	green += advance;
	green = (green & 0x003F) << 5;
	green = (*pColor & (~0x07E0)) | green;
	*pColor = (UInt16)green;
}

//----------------------------------------------------------------------------
//	_AdvanceBlue16
//
//	Description:	Advances blue component of RGB16 by 1
//
//	Input:			pColor		pointer to RGB16 value
//
//	Output:			n/a
//
//----------------------------------------------------------------------------
static void _AdvanceBlue16( UInt16* pColor )
{
	UInt32 blue = *pColor & 0x001F;
	++blue;
	blue &= 0x001F;
	blue = (*pColor & (~0x001F)) | blue;
	*pColor = (UInt16)blue;
}

//----------------------------------------------------------------------------