halsurf.cpp

Samsung公司S3C6400芯片的BSP源码包

				&& pddpf->dwBBitMask == 0x001F)
			{
				// RGB16
				if (width%2)	// Word Align
				{
					goto CannotCreate;
				}
				else
				{
					goto CanCreate;
				}
			}
			else if (pddpf->dwRGBBitCount == 32
				&& pddpf->dwRBitMask == 0x00FF0000
				&& pddpf->dwGBitMask == 0x0000FF00
				&& pddpf->dwBBitMask == 0x000000FF)
			{
				// RGB32
				goto CanCreate;
			}
			else
			{
				goto CannotCreate;
			}
		}
		else if (pddpf->dwFlags & DDPF_FOURCC)
		{
			DDHAL_INF((_T("[DDHAL:INF] HalCanCreateSurface() : FOURCC = %08x ('%c','%c','%c','%c')\n\r"),
						pddpf->dwFourCC,
						(pddpf->dwFourCC)&0xff,
						(pddpf->dwFourCC>>8)&0xff,
						(pddpf->dwFourCC>>16)&0xff,
						(pddpf->dwFourCC>>24)&0xff));

			switch (pddpf->dwFourCC)
			{
			case FOURCC_I420:	// YUV420
			case FOURCC_YV12:	// YVU420
				if (width%8 || width<8 || height<4)	// Word Align
				{
					goto CannotCreate;
				}
				else
				{
					pddpf->dwYUVBitCount=12;		// just in case App doesn't fill this
					goto CanCreate;
				}
				break;
			case FOURCC_YUYV:	// 422 (YCbYCr)
			case FOURCC_YUY2:	// 422 (YCbYCr)
			case FOURCC_UYVY:	// 422 (CbYCrY)
			case FOURCC_YVYU:	// 422 (YCrYCb)
			case FOURCC_VYUY:	// 422 (CrYCbY)
				if (width%2 || width<2  || height<2)	// Word Align
				{
					goto CannotCreate;
				}
				else
				{
					pddpf->dwYUVBitCount=16;		// just in case App doesn't fill this
					goto CanCreate;
				}
				break;
			default:
				goto CannotCreate;
				break;
			}
		}
	}
	else		// Non Primary, Non Overlay Surface (Maybe Offscreen Surface)
	{
		return DDGPECanCreateSurface(lpccsd);
	}

CanCreate:

	DDHAL_MSG((_T("[DDHAL] HalCanCreateSurface() OK\n\r")));
	lpccsd->ddRVal = DD_OK;

	return DDHAL_DRIVER_HANDLED;

CannotCreate:

	DDHAL_ERR((_T("[DDHAL:ERR] HalCanCreateSurface() : Unsupported Surface\n\r")));
	lpccsd->ddRVal = DDERR_UNSUPPORTEDFORMAT;

	return DDHAL_DRIVER_HANDLED;
}

//////////////////////////// DDHAL_DDSURFACECALLBACKS ////////////////////////////

DWORD
WINAPI
HalFlip(LPDDHAL_FLIPDATA lpfd)
{
	DWORD dwFlags;

	/*
	typedef struct _DDHAL_FLIPDATA
	{
		LPDDRAWI_DIRECTDRAW_GBL lpDD;
		LPDDRAWI_DDRAWSURFACE_LCL lpSurfCurr;
		LPDDRAWI_DDRAWSURFACE_LCL lpSurfTarg;
		DWORD dwFlags;
		HRESULT ddRVal;
	} DDHAL_FLIPDATA;
	*/

	DEBUGENTER( HalFlip );
	//DDHAL_MSG((_T("[DDHAL] ++HalFlip()\n\r")));

	dwFlags = lpfd->dwFlags;

	if (dwFlags & (DDFLIP_INTERVAL1|DDFLIP_INTERVAL2|DDFLIP_INTERVAL4))
	{
		DDHAL_ERR((_T("[DDHAL:ERR] HalFlip() : DDFLIP_INTERVAL is not supported\n\r")));
		lpfd->ddRVal = DDERR_UNSUPPORTED;
	}
	else
	{
		if (dwFlags & DDFLIP_WAITNOTBUSY)
		{
#if	0	// Our H/W always not busy.. so skip it (see S3C5300Disp::IsBusy() function)
			while(((S3C6400Disp *)GetDDGPE())->IsBusy());
#endif
		}

		DDGPESurf* surfTarg = DDGPESurf::GetDDGPESurf(lpfd->lpSurfTarg);

		if (surfTarg->IsOverlay())
		{
			((S3C6400Disp *)GetDDGPE())->m_fpPreviousOverlay = surfTarg->OffsetInVideoMemory();
		}

		if (dwFlags & DDFLIP_WAITVSYNC)
		{
			((S3C6400Disp *)GetDDGPE())->SetVisibleSurface(surfTarg, TRUE);
		}
		else
		{
			((S3C6400Disp *)GetDDGPE())->SetVisibleSurface(surfTarg, FALSE);
		}

		lpfd->ddRVal = DD_OK;
	}

	DEBUGLEAVE( HalFlip );
	//DDHAL_MSG((_T("[DDHAL] --HalFlip()\n\r")));

	return DDHAL_DRIVER_HANDLED;
}

DWORD WINAPI HalGetBltStatus( LPDDHAL_GETBLTSTATUSDATA lpgbsd )
{
	DEBUGENTER( HalGetBltStatus );
	/*
	typedef struct _DDHAL_GETBLTSTATUSDATA
	{
		LPDDRAWI_DIRECTDRAW_GBL lpDD;
		LPDDRAWI_DDRAWSURFACE_LCL lpDDSurface;
		DWORD dwFlags;
		HRESULT ddRVal;
	} DDHAL_GETBLTSTATUSDATA;
	*/

	// Implementation
	lpgbsd->ddRVal = DD_OK;

	return DDHAL_DRIVER_HANDLED;
}

DWORD WINAPI HalGetFlipStatus( LPDDHAL_GETFLIPSTATUSDATA lpgfsd)
{
	DEBUGENTER( HalGetFlipStatus );
	/*
	typedef struct _DDHAL_GETFLIPSTATUSDATA
	{
		LPDDRAWI_DIRECTDRAW_GBL lpDD;
		LPDDRAWI_DDRAWSURFACE_LCL lpDDSurface;
		DWORD dwFlags;
		HRESULT ddRVal;
	} DDHAL_GETFLIPSTATUSDATA;
	*/

	// Implementation
	lpgfsd->ddRVal = DD_OK;

	return DDHAL_DRIVER_HANDLED;
}

DWORD WINAPI HalUpdateOverlay(LPDDHAL_UPDATEOVERLAYDATA lpuod)
{
	/*
	typedef struct _DDHAL_UPDATEOVERLAYDATA {
		  LPDDRAWI_DIRECTDRAW_GBL lpDD;
		  LPDDRAWI_DDRAWSURFACE_LCL lpDDDestSurface;
		  RECT rDest;
		  LPDDRAWI_DDRAWSURFACE_LCL lpDDSrcSurface;
		  RECT rSrc;
		  DWORD dwFlags;
		  DDOVERLAYFX overlayFX;
		  HRESULT ddRVal;
	} DDHAL_UPDATEOVERLAYDATA;
	*/

	S3C6400Disp	*pDDGPE;
	S3C6400Surf	*pSrcSurf;
	S3C6400Surf	*pDestSurf;
	LPDDRAWI_DDRAWSURFACE_LCL lpSrcLCL;
	LPDDRAWI_DDRAWSURFACE_LCL lpDestLCL;

	BOOL bEnableOverlay = FALSE;

	DEBUGENTER( HalUpdateOverlay );

	/* 'Source' is the overlay surface, 'destination' is the surface to
	* be overlayed:
	*/

	lpSrcLCL = lpuod->lpDDSrcSurface;
	lpDestLCL = lpuod->lpDDDestSurface;

	pSrcSurf = (S3C6400Surf *)DDGPESurf::GetDDGPESurf(lpSrcLCL);
	pDestSurf = (S3C6400Surf *)DDGPESurf::GetDDGPESurf(lpDestLCL);

	pDDGPE = (S3C6400Disp *)GetDDGPE();

	if (lpuod->dwFlags & DDOVER_HIDE)
	{
		// If overlay surface is valid, Turn off overlay
		if (pSrcSurf->OffsetInVideoMemory() != NULL)
		{
			if ((pSrcSurf->OffsetInVideoMemory() == (ULONG_PTR) (pDDGPE->m_fpCurrentOverlay))
				|| (pSrcSurf->OffsetInVideoMemory() == (ULONG_PTR) (pDDGPE->m_fpPreviousOverlay)))
			{
				pDDGPE->m_fpCurrentOverlay = NULL;
				pDDGPE->m_fpPreviousOverlay = NULL;

				if (pDDGPE->m_bOverlayEnable)
				{
					pDDGPE->OverlayDisable();
				}
			}

			lpuod->ddRVal = DD_OK;
		}
		else
		{
			DDHAL_ERR((_T("[DDHAL:ERR] HalUpdateOverlay() : pSrcSurf->OffsetInVideoMemory() = NULL\n\r")));

			lpuod->ddRVal = DDERR_INVALIDPARAMS;
		}

		return (DDHAL_DRIVER_HANDLED);
	}
	else if (lpuod->dwFlags & DDOVER_SHOW)
	{
		if (pSrcSurf->OffsetInVideoMemory() != NULL)
		{
			if ((pSrcSurf->OffsetInVideoMemory() != (ULONG_PTR) (pDDGPE->m_fpCurrentOverlay))
				&& (pSrcSurf->OffsetInVideoMemory() != (ULONG_PTR) (pDDGPE->m_fpPreviousOverlay))
				&& (pDDGPE->m_fpCurrentOverlay != NULL))
			{
				// Some other overlay surface is already visible:
				DDHAL_ERR((_T("[DDHAL:ERR] HalUpdateOverlay() : Overlay is already in use by another surface\n\r")));

				lpuod->ddRVal = DDERR_OUTOFCAPS;

				return (DDHAL_DRIVER_HANDLED);
			}
			else
			{
				// Set surface to overlay frame buffer
				pDDGPE->m_fpCurrentOverlay = pSrcSurf->OffsetInVideoMemory();

				pDDGPE->OverlayInitialize(pSrcSurf, &lpuod->rSrc, &lpuod->rDest);

				// Enable Overlay below... after set up blending
				bEnableOverlay = TRUE;
			}
		}
		else
		{
			DDHAL_ERR((_T("[DDHAL:ERR] HalUpdateOverlay() : pSrcSurf->OffsetInVideoMemory() = NULL\n\r")));

			lpuod->ddRVal = DDERR_INVALIDPARAMS;
		}
	}
	else
	{
		// If overlay surface is not visiable,  Nothing to do
		lpuod->ddRVal = DD_OK;

		return (DDHAL_DRIVER_HANDLED);
	}

	if ((lpuod->dwFlags & (DDOVER_KEYSRC|DDOVER_KEYSRCOVERRIDE|DDOVER_KEYDEST|DDOVER_KEYDESTOVERRIDE))
		&& (lpuod->dwFlags & (DDOVER_ALPHASRC|DDOVER_ALPHACONSTOVERRIDE)))
	{
		DDHAL_ERR((_T("[DDHAL:ERR] HalUpdateOverlay() : Driver Not Support ColorKey & Alpha at the same time (dwFlags = 0x%08x)\n\r"), lpuod->dwFlags));
	}

	// Source Color Key
	if ((lpuod->dwFlags & DDOVER_KEYSRC)
		|| (lpuod->dwFlags & DDOVER_KEYSRCOVERRIDE))
	{
		DWORD dwColorKey;

		if (lpuod->dwFlags & DDOVER_KEYSRCOVERRIDE)
		{
			dwColorKey = lpuod->overlayFX.dckSrcColorkey.dwColorSpaceLowValue;
		}
		else
		{
			// TODO: I don't know Why Reference ddckCKSrcOverlay of Dest Surface, Not of Src Surface
			dwColorKey = lpuod->lpDDDestSurface->ddckCKSrcOverlay.dwColorSpaceLowValue;
		}

		pDDGPE->OverlaySetColorKey(TRUE, DDGPESurf::GetDDGPESurf(lpuod->lpDDSrcSurface)->PixelFormat(), dwColorKey);
	}
	else if ((lpuod->dwFlags & DDOVER_KEYDEST)
		|| (lpuod->dwFlags & DDOVER_KEYDESTOVERRIDE))
	{
		DWORD dwColorKey;

		if (lpuod->dwFlags & DDOVER_KEYDESTOVERRIDE)
		{
			dwColorKey = lpuod->overlayFX.dckDestColorkey.dwColorSpaceLowValue;
		}
		else
		{
			dwColorKey = lpuod->lpDDDestSurface->ddckCKDestOverlay.dwColorSpaceLowValue;
		}

		pDDGPE->OverlaySetColorKey(FALSE, DDGPESurf::GetDDGPESurf(lpuod->lpDDDestSurface)->PixelFormat(), dwColorKey);
	}
	else if ((lpuod->dwFlags & DDOVER_ALPHASRC)
		|| (lpuod->dwFlags & DDOVER_ALPHACONSTOVERRIDE))
	{
		if (lpuod->dwFlags & DDOVER_ALPHACONSTOVERRIDE)	// Per Plane Alpha Blending
		{
			pDDGPE->OverlaySetAlpha(FALSE, lpuod->overlayFX.dwAlphaConst);
		}
		else
		{
			pDDGPE->OverlaySetAlpha(TRUE, lpuod->overlayFX.dwAlphaConst);
		}
	}
	else
	{
		pDDGPE->OverlayBlendDisable();
	}

	// Enable Overlay after set up blending
	if (bEnableOverlay) pDDGPE->OverlayEnable();

	lpuod->ddRVal = DD_OK;

	return (DDHAL_DRIVER_HANDLED);
}

DWORD WINAPI HalSetOverlayPosition(LPDDHAL_SETOVERLAYPOSITIONDATA lpsopd)
{
	//S3C6400Surf *pSrcSurf;

	DEBUGENTER( HalSetOverlayPosition );

	/*
	typedef struct _DDHAL_SETOVERLAYPOSITIONDATA
	{
		LPDDRAWI_DIRECTDRAW_GBL lpDD;
		LPDDRAWI_DDRAWSURFACE_LCL lpDDSrcSurface;
		LPDDRAWI_DDRAWSURFACE_LCL lpDDDestSurface;
		LONG lXPos;
		LONG lYPos;
		HRESULT ddRVal;
	} DDHAL_SETOVERLAYPOSITIONDATA;
	*/

	//pSrcSurf = (S3C6400Surf *)DDGPESurf::GetDDGPESurf(lpsopd->lpDDSrcSurface);

	((S3C6400Disp *)GetDDGPE())->OverlaySetPosition((unsigned int)lpsopd->lXPos, (unsigned int)lpsopd->lYPos);

	lpsopd->ddRVal = DD_OK;

	return DDHAL_DRIVER_HANDLED;
}

DWORD WINAPI HalSetColorKey(LPDDHAL_SETCOLORKEYDATA lpdsckd)
{
	/*
	typedef struct _DDHAL_SETCOLORKEYDATA
	{
		LPDDRAWI_DIRECTDRAW_GBL lpDD;
		LPDDRAWI_DDRAWSURFACE_LCL lpDDSurface;
		DWORD dwFlags;
		DDCOLORKEY ckNew;
		HRESULT ddRVal;
	} DDHAL_SETCOLORKEYDATA;
	*/

	DEBUGENTER(HalSetColorKey);

	DDGPESurf* pSurf = DDGPESurf::GetDDGPESurf(lpdsckd->lpDDSurface);
	if (pSurf != NULL)
	{
#if	1
		DDHAL_MSG((_T("[DDHAL] HalSetColorKey() : dwFlags = 0x%08x\n\r"), lpdsckd->dwFlags));

		pSurf->SetColorKeyLow(lpdsckd->ckNew.dwColorSpaceLowValue);
		pSurf->SetColorKeyHigh(lpdsckd->ckNew.dwColorSpaceHighValue);

		lpdsckd->ddRVal = DD_OK;
#else
		if ((lpdsckd->dwFlags == DDCKEY_SRCBLT)
			|| (lpdsckd->dwFlags == DDCKEY_DESTBLT))
		{
			DDHAL_ERR((_T("[DDHAL:ERR] HalSetColorKey() : Color Key Blit is Not Supported\n\r")));
			lpdsckd->ddRVal = DDERR_NOCOLORKEYHW;
		}
		else	 if ((lpdsckd->dwFlags == DDCKEY_SRCOVERLAY)
			|| (lpdsckd->dwFlags == DDCKEY_DESTOVERLAY))
		{
			pSurf->SetColorKeyLow(lpdsckd->ckNew.dwColorSpaceLowValue);
			pSurf->SetColorKeyHigh(lpdsckd->ckNew.dwColorSpaceHighValue);
			lpdsckd->ddRVal = DD_OK;
		}
		else
		{
			DDHAL_ERR((_T("[DDHAL:ERR] HalSetColorKey() : Invalid dwFlags = 0x%08x\n\r"), lpdsckd->dwFlags));
			lpdsckd->ddRVal = DDERR_INVALIDOBJECT;
		}
#endif
	}
	else
	{
		DDHAL_ERR((_T("[DDHAL:ERR] HalSetColorKey() : Surface Object is Null\n\r")));
		lpdsckd->ddRVal = DDERR_INVALIDOBJECT;
	}

	DEBUGLEAVE(HalSetColorKey);

	return DDHAL_DRIVER_HANDLED;
}

#if	0	// Not Supported in  our driver (Use DDGPE)
DWORD WINAPI HalLock( LPDDHAL_LOCKDATA pd )
{
    DEBUGENTER( HalLock );
    /*
    typedef struct _DDHAL_LOCKDATA
    {
        LPDDRAWI_DIRECTDRAW_GBL     lpDD;           // driver struct
        LPDDRAWI_DDRAWSURFACE_LCL   lpDDSurface;    // surface struct
        DWORD                       bHasRect;       // rArea is valid
        RECTL                       rArea;          // area being locked
        LPVOID                      lpSurfData;     // pointer to screen memory (return value)
        HRESULT                     ddRVal;         // return value
        LPDDHALSURFCB_LOCK          Lock;           // PRIVATE: ptr to callback
    } DDHAL_LOCKDATA;
    */

    // Implementation
    pd->ddRVal = DD_OK;

    return DDHAL_DRIVER_HANDLED;
}

DWORD WINAPI HalUnlock( LPDDHAL_UNLOCKDATA pd )
{
    DEBUGENTER( HalUnlock );
    /*
    typedef struct _DDHAL_UNLOCKDATA
    {
        LPDDRAWI_DIRECTDRAW_GBL     lpDD;           // driver struct
        LPDDRAWI_DDRAWSURFACE_LCL   lpDDSurface;    // surface struct
        HRESULT                     ddRVal;            // return value
        LPDDHALSURFCB_UNLOCK        Unlock;         // PRIVATE: ptr to callback
    } DDHAL_UNLOCKDATA;
    */

    // Implementation
    pd->ddRVal = DD_OK;

    return DDHAL_DRIVER_HANDLED;
}
#endif