s3c24a0disp.cpp

来自「S3C24A0的完整BSP包,对开发此芯片的开发者很有用.」· C++ 代码 · 共 1,374 行 · 第 1/3 页

	
}

void	S3C24A0DISP::CursorOff (void)
{
	UCHAR	*ptrScreen = (UCHAR*)m_pPrimarySurface->Buffer();
	UCHAR	*ptrLine;
	UCHAR	*cbsLine;
	int		x, y;

	RETAILMSG(DBGLCD1, (TEXT("++S3C24A0DISP::CursorOff\r\n")));

	if (!m_CursorForcedOff && !m_CursorDisabled && m_CursorVisible)
	{
		if (!m_CursorBackingStore)
		{
			RETAILMSG(0, (TEXT("S3C24A0DISP::CursorOff - No backing store available\r\n")));
			return;
		}

		for (y = m_CursorRect.top; y < m_CursorRect.bottom; y++)
		{
			// clip to displayable screen area (top/bottom)
			if (y < 0)
			{
				continue;
			}
			if (y >= m_nScreenHeight)
			{
				break;
			}

			ptrLine = &ptrScreen[y * m_pPrimarySurface->Stride()];
			cbsLine = &m_CursorBackingStore[(y - m_CursorRect.top) * (m_CursorSize.x * (m_colorDepth >> 3))];

			for (x = m_CursorRect.left; x < m_CursorRect.right; x++)
			{
				// clip to displayable screen area (left/right)
				if (x < 0)
				{
					continue;
				}
				if (x >= m_nScreenWidth)
				{
					break;
				}

				ptrLine[x * (m_colorDepth >> 3)] = cbsLine[(x - m_CursorRect.left) * (m_colorDepth >> 3)];
				if (m_colorDepth > 8)
				{
					ptrLine[x * (m_colorDepth >> 3) + 1] = cbsLine[(x - m_CursorRect.left) * (m_colorDepth >> 3) + 1];
					if (m_colorDepth > 16)
					{
						ptrLine[x * (m_colorDepth >> 3) + 2] = cbsLine[(x - m_CursorRect.left) * (m_colorDepth >> 3) + 2];
					}
				}
			}
		}
		m_CursorVisible = FALSE;
	}

	RETAILMSG(DBGLCD1, (TEXT("--S3C24A0DISP::CursorOff\r\n")));
}

SCODE	S3C24A0DISP::SetPointerShape(GPESurf *pMask, GPESurf *pColorSurf, INT xHot, INT yHot, INT cX, INT cY)
{
	UCHAR	*andPtr;		// input pointer
	UCHAR	*xorPtr;		// input pointer
	UCHAR	*andLine;		// output pointer
	UCHAR	*xorLine;		// output pointer
	char	bAnd;
	char	bXor;
	int		row;
	int		col;
	int		i;
	int		bitMask;

	RETAILMSG(DBGLCD1, (TEXT("++S3C24A0DISP::SetPointerShape(0x%X, 0x%X, %d, %d, %d, %d)\r\n"),pMask, pColorSurf, xHot, yHot, cX, cY));

	// turn current cursor off
	CursorOff();

	// release memory associated with old cursor
	if (m_CursorBackingStore)
	{
		delete (void*)m_CursorBackingStore;
		m_CursorBackingStore = NULL;
	}
	if (m_CursorXorShape)
	{
		delete (void*)m_CursorXorShape;
        m_CursorXorShape = NULL;
	}
	if (m_CursorAndShape)
	{
		delete (void*)m_CursorAndShape;
        m_CursorAndShape = NULL;
	}

	if (!pMask)							// do we have a new cursor shape
	{
		m_CursorDisabled = TRUE;		// no, so tag as disabled
	}
	else
	{
		m_CursorDisabled = FALSE;		// yes, so tag as not disabled

		// allocate memory based on new cursor size
        m_CursorBackingStore = new UCHAR[(cX * (m_colorDepth >> 3)) * cY];
        m_CursorXorShape = new UCHAR[cX * cY];
        m_CursorAndShape = new UCHAR[cX * cY];

		// store size and hotspot for new cursor
		m_CursorSize.x = cX;
		m_CursorSize.y = cY;
		m_CursorHotspot.x = xHot;
		m_CursorHotspot.y = yHot;

		andPtr = (UCHAR*)pMask->Buffer();
		xorPtr = (UCHAR*)pMask->Buffer() + (cY * pMask->Stride());

		// store OR and AND mask for new cursor
		for (row = 0; row < cY; row++)
		{
			andLine = &m_CursorAndShape[cX * row];
			xorLine = &m_CursorXorShape[cX * row];

			for (col = 0; col < cX / 8; col++)
			{
				bAnd = andPtr[row * pMask->Stride() + col];
				bXor = xorPtr[row * pMask->Stride() + col];

				for (bitMask = 0x0080, i = 0; i < 8; bitMask >>= 1, i++)
				{
					andLine[(col * 8) + i] = bAnd & bitMask ? 0xFF : 0x00;
					xorLine[(col * 8) + i] = bXor & bitMask ? 0xFF : 0x00;
				}
			}
		}
	}

	return	S_OK;
}

SCODE	S3C24A0DISP::MovePointer(INT xPosition, INT yPosition)
{
	RETAILMSG(DBGLCD1, (TEXT("+++S3C24A0DISP::MovePointer(%d, %d)\r\n"), xPosition, yPosition));

	CursorOff();

	if (xPosition != -1 || yPosition != -1)
	{
		// compute new cursor rect
		m_CursorRect.left = xPosition - m_CursorHotspot.x;
		m_CursorRect.right = m_CursorRect.left + m_CursorSize.x;
		m_CursorRect.top = yPosition - m_CursorHotspot.y;
		m_CursorRect.bottom = m_CursorRect.top + m_CursorSize.y;

		CursorOn();
	}

	RETAILMSG(DBGLCD1, (TEXT("--S3C24A0DISP::MovePointer()\r\n")));

	return	S_OK;
}

void	S3C24A0DISP::WaitForNotBusy(void)
{
	RETAILMSG(DBGLCD, (TEXT("S3C24A0DISP::WaitForNotBusy\r\n")));
	return;
}

int		S3C24A0DISP::IsBusy(void)
{
	RETAILMSG(DBGLCD, (TEXT("S3C24A0DISP::IsBusy\r\n")));
	return	0;
}

void	S3C24A0DISP::GetPhysicalVideoMemory(unsigned long *physicalMemoryBase, unsigned long *videoMemorySize)
{
	RETAILMSG(DBGLCD, (TEXT("S3C24A0DISP::GetPhysicalVideoMemory\r\n")));

	*physicalMemoryBase = gdwLCDVirtualFrameBase;
	*videoMemorySize = m_cbScanLineLength * m_nScreenHeight;
}
#ifdef	DD_ENABLE
void	S3C24A0DISP::GetVirtualVideoMemory(unsigned long *virtualMemoryBase, unsigned long *videoMemorySize)
{
	RETAILMSG(1, (TEXT("+++S3C24A0DISP::GetVirtualVideoMemory\r\n")));

	*virtualMemoryBase = m_VirtualFrameBuffer;
	*videoMemorySize = m_cbScanLineLength * m_cyPhysicalScreen;
	RETAILMSG(1, (TEXT("---S3C24A0DISP::GetVirtualVideoMemory\r\n")));
}
#endif	// DD_ENABLE

/*
SCODE	S3C24A0DISP::AllocSurface(GPESurf **ppSurf, INT width, INT height, EGPEFormat format, INT surfaceFlags)
{
#ifdef	DD_ENABLE
	RETAILMSG (0, (TEXT("++S3C24A0DISP::AllocSurface\n")));

	return	AllocSurface ((DDGPESurf**)ppSurf,
						  width,
						  height,
						  format,
						  EGPEFormatToEDDGPEPixelFormat[format],
						  surfaceFlags);
}
SCODE 
S3C24A0DISP::AllocSurface(DDGPESurf **ppSurf, int width, int height, EGPEFormat format, EDDGPEPixelFormat pixelFormat, int surfaceFlags)
{
#endif	// DD_ENABLE
	RETAILMSG(DBGLCD, (TEXT("++S3C24A0DISP::AllocSurface\r\n")));

	if (surfaceFlags & GPE_REQUIRE_VIDEO_MEMORY)
	{
#ifdef	DD_ENABLE
			*ppSurf = (DDGPESurf *)NULL;
#else	// DD_ENABLE
			*ppSurf = (GPESurf *)NULL;
#endif	// DD_ENABLE
		RETAILMSG(DBGLCD, (TEXT("### Out of Memory in AllocSurface ###\r\n")));
		return	E_OUTOFMEMORY;
	}

	// Allocate from system memory
#ifdef	DD_ENABLE
	{
	DWORD bpp  = EGPEFormatToBpp[format];
	DWORD stride = ((bpp * width + 31) >> 5) << 2;
	DWORD nSurfaceBytes = stride * height;

	*ppSurf = new DDGPESurf(width, height, stride, format, pixelFormat);
	}
#else	// DD_ENABLE
	*ppSurf = new GPESurf(width, height, format);
#endif	// DD_ENABLE

	RETAILMSG(DBGLCD, (TEXT("S3C24A0DISP::AllocSurface %x \r\n"), ppSurf));

	if (*ppSurf != NULL)
	{
		// Check that the bits were allocated succesfully
		if (((*ppSurf)->Buffer()) == NULL)
		{
			delete *ppSurf;				// Clean up
		}
		else
		{
			return S_OK;
		}
	}

	RETAILMSG(DBGLCD, (TEXT("--S3C24A0DISP::AllocSurface\r\n")));

	return E_OUTOFMEMORY;
}
*/
	
SCODE	S3C24A0DISP::WrappedEmulatedLine (GPELineParms *lineParameters)
{
	SCODE	retval;
	RECT	bounds;
	int		N_plus_1;				// Minor length of bounding rect + 1

	RETAILMSG(DBGLCD1, (TEXT("++S3C24A0DISP::WrappedEmulatedLine\r\n")));

	// calculate the bounding-rect to determine overlap with cursor
	if (lineParameters->dN)			// The line has a diagonal component (we'll refresh the bounding rect)
	{
		N_plus_1 = 2 + ((lineParameters->cPels * lineParameters->dN) / lineParameters->dM);
	}
	else
	{
		N_plus_1 = 1;
	}

	switch(lineParameters->iDir)
	{
		case 0:
			bounds.left = lineParameters->xStart;
			bounds.top = lineParameters->yStart;
			bounds.right = lineParameters->xStart + lineParameters->cPels + 1;
			bounds.bottom = bounds.top + N_plus_1;
			break;
		case 1:
			bounds.left = lineParameters->xStart;
			bounds.top = lineParameters->yStart;
			bounds.bottom = lineParameters->yStart + lineParameters->cPels + 1;
			bounds.right = bounds.left + N_plus_1;
			break;
		case 2:
			bounds.right = lineParameters->xStart + 1;
			bounds.top = lineParameters->yStart;
			bounds.bottom = lineParameters->yStart + lineParameters->cPels + 1;
			bounds.left = bounds.right - N_plus_1;
			break;
		case 3:
			bounds.right = lineParameters->xStart + 1;
			bounds.top = lineParameters->yStart;
			bounds.left = lineParameters->xStart - lineParameters->cPels;
			bounds.bottom = bounds.top + N_plus_1;
			break;
		case 4:
			bounds.right = lineParameters->xStart + 1;
			bounds.bottom = lineParameters->yStart + 1;
			bounds.left = lineParameters->xStart - lineParameters->cPels;
			bounds.top = bounds.bottom - N_plus_1;
			break;
		case 5:
			bounds.right = lineParameters->xStart + 1;
			bounds.bottom = lineParameters->yStart + 1;
			bounds.top = lineParameters->yStart - lineParameters->cPels;
			bounds.left = bounds.right - N_plus_1;
			break;
		case 6:
			bounds.left = lineParameters->xStart;
			bounds.bottom = lineParameters->yStart + 1;
			bounds.top = lineParameters->yStart - lineParameters->cPels;
			bounds.right = bounds.left + N_plus_1;
			break;
		case 7:
			bounds.left = lineParameters->xStart;
			bounds.bottom = lineParameters->yStart + 1;
			bounds.right = lineParameters->xStart + lineParameters->cPels + 1;
			bounds.top = bounds.bottom - N_plus_1;
			break;
		default:
			RETAILMSG(DBGLCD1, (TEXT("Invalid direction: %d\r\n"), lineParameters->iDir));
			return E_INVALIDARG;
	}

	// check for line overlap with cursor and turn off cursor if overlaps
	if (m_CursorVisible && !m_CursorDisabled &&
		m_CursorRect.top < bounds.bottom && m_CursorRect.bottom > bounds.top &&
		m_CursorRect.left < bounds.right && m_CursorRect.right > bounds.left)
	{
		CursorOff();
		m_CursorForcedOff = TRUE;
	}

	// do emulated line
	retval = EmulatedLine (lineParameters);

	// se if cursor was forced off because of overlap with line bouneds and turn back on
	if (m_CursorForcedOff)
	{
		m_CursorForcedOff = FALSE;
		CursorOn();
	}

	RETAILMSG(DBGLCD, (TEXT("--S3C24A0DISP::WrappedEmulatedLine\r\n")));

	return	retval;

}

SCODE	S3C24A0DISP::Line(GPELineParms *lineParameters, EGPEPhase phase)
{
	RETAILMSG(DBGLCD1, (TEXT("++S3C24A0DISP::Line\r\n")));

	if (phase == gpeSingle || phase == gpePrepare)
	{
		//DispPerfStart(ROP_LINE); //Guru 

		if ((lineParameters->pDst != m_pPrimarySurface))
		{
			lineParameters->pLine = EmulatedLine;
		}
		else
		{
			lineParameters->pLine = (SCODE (GPE::*)(struct GPELineParms *)) WrappedEmulatedLine;
		}
	}
	else if (phase == gpeComplete)
	{
	}
	RETAILMSG(DBGLCD1, (TEXT("--S3C24A0DISP::Line\r\n")));
	return S_OK;
}

SCODE	S3C24A0DISP::BltPrepare(GPEBltParms *blitParameters)
{
	RECTL	rectl;

	RETAILMSG(DBGLCD1, (TEXT("++S3C24A0DISP::BltPrepare\r\n")));
	//DispPerfStart(blitParameters->rop4); //Guru

	// default to base EmulatedBlt routine
	blitParameters->pBlt = EmulatedBlt;

	// see if we need to deal with cursor
	if (m_CursorVisible && !m_CursorDisabled)
	{
		// check for destination overlap with cursor and turn off cursor if overlaps
		if (blitParameters->pDst == m_pPrimarySurface)	// only care if dest is main display surface
		{
			if (blitParameters->prclDst != NULL)		// make sure there is a valid prclDst
			{
				rectl = *blitParameters->prclDst;		// if so, use it
			}
			else
			{
				rectl = m_CursorRect;					// if not, use the Cursor rect - this forces the cursor to be turned off in this case
			}

			if (m_CursorRect.top <= rectl.bottom && m_CursorRect.bottom >= rectl.top &&
				m_CursorRect.left <= rectl.right && m_CursorRect.right >= rectl.left)
			{
				CursorOff();
				m_CursorForcedOff = TRUE;
			}
		}

		// check for source overlap with cursor and turn off cursor if overlaps
		if (blitParameters->pSrc == m_pPrimarySurface)	// only care if source is main display surface
		{
			if (blitParameters->prclSrc != NULL)		// make sure there is a valid prclSrc
			{
				rectl = *blitParameters->prclSrc;		// if so, use it
			}
			else
			{
				rectl = m_CursorRect;					// if not, use the CUrsor rect - this forces the cursor to be turned off in this case
			}
			if (m_CursorRect.top < rectl.bottom && m_CursorRect.bottom > rectl.top &&
				m_CursorRect.left < rectl.right && m_CursorRect.right > rectl.left)
			{
				CursorOff();
				m_CursorForcedOff = TRUE;
			}
		}
	}


	// see if there are any optimized software blits available
	EmulatedBltSelect02(blitParameters);
	EmulatedBltSelect08(blitParameters);
	EmulatedBltSelect16(blitParameters);

	RETAILMSG(DBGLCD1, (TEXT("--S3C24A0DISP::BltPrepare\r\n")));

	return S_OK;
}

SCODE	S3C24A0DISP::BltComplete(GPEBltParms *blitParameters)
{
	RETAILMSG(DBGLCD1, (TEXT("++S3C24A0DISP::BltComplete\r\n")));

	// see if cursor was forced off because of overlap with source or destination and turn back on
	if (m_CursorForcedOff)
	{
		m_CursorForcedOff = FALSE;
		CursorOn();
	}

	RETAILMSG(DBGLCD1, (TEXT("--S3C24A0DISP::BltComplete\r\n")));