ddhsurf.cpp

WinCE 3.0 BSP, 包含Inter SA1110, Intel_815E, Advantech_PCM9574 等

				//ASSERT(pPrimary != NULL);

				if (pPrimary != NULL)
				{
					//DEBUGMSG(HAL_ZONE_INFO, (TEXT("Setting up lpGbl\r\n") ));
					pSurf->lpGbl->fpVidMem = (unsigned long)(g_pVideoMemory) + pPrimary->OffsetInVideoMemory();
					pSurf->lpGbl->lPitch = pPrimary->Stride();

					// BUGBUG
					// This will cause a problem if more than one process creates a primary surface
					// but I don't think ddraw lets that happen.
					//DEBUGMSG(HAL_ZONE_INFO, (TEXT("Setting DDGPESurf for new ddraw primary surface\r\n") ));
					//
					// Note: pSurf is stored in lcl so we need to attach it to the surface
					pPrimary->SetDDGPESurf(pSurf->lpGbl);

					// No change is required to g_pDDrawPrimarySurface, because it is by default
					// the primary surface.
					// If it's not the primary surface then it's been split and we definitely
					// don't want to change the ddraw primary
					/*
					// This should already be the case in an un-split world
					if (!DDGPEGDIHasSplitFromDDraw())
					{
						g_pDDrawPrimarySurface = pPrimary;
					}
					*/

					// the ddraw primary should already be visible if necessary (it's the GDI surface)
					//g_pGPE->SetVisibleSurface(pPrimary, NULL, FALSE);
				}
			}

			DEBUGMSG(
				HAL_ZONE_INFO | GPE_ZONE_CREATE,
				(TEXT("Create %s Primary Surface! (&GPESurf = 0x%08x, fpvidmem=0x%08x)\r\n"),
				(((pSurf->lpSurfMore->ddsCapsEx.dwCaps4 & DDSCAPS4_NONGDIPRIMARY) == DDSCAPS4_NONGDIPRIMARY) 
					? L"SPLIT" : L""),
				(unsigned long)g_pDDrawPrimarySurface,
				pSurf->lpGbl->fpVidMem
				));
        }
		else
		{
			unsigned long offset;
			if( !(pd->lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY ) )
			{
				sc = g_pGPE->AllocVideoSurface(
						pSurf->lpGbl,
						nWidth,
						nHeight,
						format,
						pixelFormat,//EGPEFormatToEDDGPEPixelFormat[format],
						&offset );

				if( SUCCEEDED(sc) )
				{
					DDGPESurf* pGPESurf = DDGPESurf::GetDDGPESurf(pSurf);

					pSurf->lpGbl->fpVidMem = (unsigned long)(g_pVideoMemory + offset);
					pSurf->lpGbl->lPitch = pGPESurf->Stride();
					pd->lpDDSurfaceDesc->ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY;

					DEBUGMSG(HAL_ZONE_SUCCESS, (TEXT("Created a surface at: 0x%x (%d)\r\n"), offset, offset));
				}
			}
			if( ( ( sc == E_OUTOFMEMORY )
				&& ( ! ( pd->lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY ) )
				&& ( ! ( pd->lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_FRONTBUFFER ) )
				&& ( ! ( pd->lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_BACKBUFFER ) )
				&& ( ! ( pd->lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_COMPLEX ) )
				)
				|| (pd->lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY ) )
			{
				// Try allocating in system memory
				//DWORD	nPitch;
				//nPitch = ( nWidth * nBPP ) >>3;
				//nPitch = ( nPitch + 3 ) & ~3;
				DWORD	nBPP = EGPEFormatToBpp[format];

				// don't LocalAlloc here any more
				//pSurf->lpGbl->lPitch = ( nWidth * nBPP / 8 + 3 ) & 0xFFFFFFFC;
				//pSurf->lpGbl->fpVidMem = (unsigned long)LocalAlloc( LMEM_FIXED, pSurf->lpGbl->lPitch * nHeight );
				//if( !pSurf->lpGbl->fpVidMem )
				//{
				//	pd->ddRVal = DDERR_OUTOFMEMORY;
				//	DEBUGMSG(GPE_ZONE_ERROR,(TEXT("Failed to create surface, sc=0x%08x\r\n"),sc));
				//	return DDHAL_DRIVER_HANDLED;
				//}
                if (pd->lpDDSurfaceDesc->dwFlags & DDSD_LPSURFACE)
                {
    				sc = g_pGPE->WrapSurface(
    						pSurf->lpGbl,
    						nWidth,
    						nHeight,
    						format,
    						pixelFormat,//EGPEFormatToEDDGPEPixelFormat[format],
    						(unsigned char *)pd->lpDDSurfaceDesc->lpSurface,
    						pd->lpDDSurfaceDesc->lPitch
    						);
                }
                else
                {
    				sc = g_pGPE->WrapSurface(
    						pSurf->lpGbl,
    						nWidth,
    						nHeight,
    						format,
    						pixelFormat,//EGPEFormatToEDDGPEPixelFormat[format],
    						//(unsigned char *)pSurf->lpGbl->fpVidMem,
    						pSurf->lpGbl->lPitch,
    						0);
                }

				if( SUCCEEDED(sc) )
				{
					DEBUGMSG(1, (TEXT("DDGPEHAL: DDGPE has allocated system memory surface for me at 0x%08x\r\n"), pSurf->lpGbl->fpVidMem));
					pSurf->ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
				}
			}
			else if ( sc == E_OUTOFMEMORY )
			{
                sc = DDERR_OUTOFVIDEOMEMORY;
				DEBUGMSG(GPE_ZONE_CREATE,(TEXT("Not attempting system memory allocation!")));
			}

			if( FAILED( sc ) )
			{
				pd->ddRVal = sc;
				DEBUGMSG(GPE_ZONE_ERROR,(TEXT("Failed to create surface, sc=0x%08x\r\n"),sc));
				return DDHAL_DRIVER_HANDLED;
			}

			pd->lpDDSurfaceDesc->lPitch = pSurf->lpGbl->lPitch;
			DEBUGMSG(GPE_ZONE_CREATE,(TEXT("Create Non-Primary Surface! (&GPESurf = 0x%08x, fpvidmem=0x%08x)\r\n"),
				DDGPESurf::GetDDGPESurf(pSurf),
				pSurf->lpGbl->fpVidMem));

        }

		// any operations that should be performed on all created surfaces
		if (pSurf != NULL)
		{
			DDGPESurf*	pDDGPESurf = NULL;
			
			pDDGPESurf = DDGPESurf::GetDDGPESurf(pSurf);
			if (pDDGPESurf != NULL)
			{
				pDDGPESurf->SetColorKeyLow(pd->lpDDSurfaceDesc->ddckCKDestBlt.dwColorSpaceLowValue);
				pDDGPESurf->SetColorKeyHigh(pd->lpDDSurfaceDesc->ddckCKDestBlt.dwColorSpaceHighValue);

			}

		}

	} // end of for loop

	pd->ddRVal = DD_OK;
	DEBUGLEAVE( DDGPECreateSurface );
	return DDHAL_DRIVER_HANDLED;
}

//////////////////////////// DDHAL_DDEXEBUFCALLBACKS ////////////////////////////

EXTERN_C DWORD WINAPI DDGPECreateExecuteBuffer( LPDDHAL_CREATESURFACEDATA pd )
{
	unsigned int	iSurf;		// Surface index
	LPDDRAWI_DDRAWSURFACE_LCL
					pSurf;		// Pointer to surface data
	SCODE			sc;

	DEBUGENTER( DDGPECreateExecuteBuffer );
	/*
	typedef struct _DDHAL_CREATESURFACEDATA
	{
	    LPDDRAWI_DIRECTDRAW_GBL     lpDD;           // driver struct
	    LPDDSURFACEDESC             lpDDSurfaceDesc;// description of surface being created
	    LPDDRAWI_DDRAWSURFACE_LCL   FAR *lplpSList; // list of created surface objects
	    DWORD                       dwSCnt;         // number of surfaces in SList
	    HRESULT                     ddRVal;         // return value
	    LPDDHAL_CREATESURFACE       CreateSurface;  // PRIVATE: ptr to callback
	} DDHAL_CREATESURFACEDATA;
	*/

	for( iSurf=0; iSurf<pd->dwSCnt; iSurf++ )
	{
		pSurf = pd->lplpSList[iSurf];

		DEBUGMSG(GPE_ZONE_CREATE,(TEXT("Surface #%d: LCL:%08x Size: %d bytes"),
			iSurf, pSurf, pSurf->lpGbl->dwLinearSize ));

		// Try allocating in system memory but do the allocation in the user's space
		/*pSurf->lpGbl->fpVidMem = (unsigned long)LocalAlloc( LMEM_FIXED, pSurf->lpGbl->dwLinearSize );
		if( !pSurf->lpGbl->fpVidMem )
		{
			pd->ddRVal = sc;
			DEBUGMSG(GPE_ZONE_ERROR,(TEXT("Failed to create surface, sc=0x%08x\r\n"),sc));
			return DDHAL_DRIVER_HANDLED;
		}
		sc = g_pGPE->WrapSurface(
				pSurf,
				pSurf->lpGbl->dwLinearSize,
				1,
				gpe8Bpp,
				ddgpePixelFormat_8bpp,
				(unsigned char *)pSurf->lpGbl->fpVidMem,
				pSurf->lpGbl->dwLinearSize );*/

		sc = g_pGPE->WrapSurface(
				pSurf->lpGbl,
				pSurf->lpGbl->dwLinearSize,
				1,
				gpe8Bpp,
				ddgpePixelFormat_8bpp,//EGPEFormatToEDDGPEPixelFormat[format],
				//(unsigned char *)pSurf->lpGbl->fpVidMem,
				pSurf->lpGbl->lPitch,
				0);

		if( SUCCEEDED(sc) )
		{
			pd->lpDDSurfaceDesc->ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
		}

		if( FAILED( sc ) )
		{
			pd->ddRVal = sc;
			DEBUGMSG(GPE_ZONE_ERROR,(TEXT("Failed to create execute buffer, sc=0x%08x\r\n"),sc));
			return DDHAL_DRIVER_HANDLED;
		}
	}
	pd->ddRVal = DD_OK;
	DEBUGLEAVE( DDGPECreateExecuteBuffer );
	return DDHAL_DRIVER_HANDLED;
}


EXTERN_C DWORD WINAPI DDGPEDestroyExecuteBuffer( LPDDHAL_DESTROYSURFACEDATA pd )
{
	DEBUGENTER( DDGPEDestroyExecuteBuffer );
	/*
	typedef struct _DDHAL_DESTROYSURFACEDATA
	{
	    LPDDRAWI_DIRECTDRAW_GBL     lpDD;           // driver struct
	    LPDDRAWI_DDRAWSURFACE_LCL   lpDDSurface;    // surface struct
	    HRESULT                     ddRVal;         // return value
	    LPDDHALSURFCB_DESTROYSURFACE DestroySurface;// PRIVATE: ptr to callback
		BOOL						fDestroyGlobal;
	} DDHAL_DESTROYSURFACEDATA;
	*/

	//DEBUGMSG(GPE_ZONE_CREATE,(TEXT("Destroy GPESurf *:0x%08x\r\n"), DDGPESurf::GetDDGPESurfFrom(pd->lpDDSurface) ));
	DDGPESurf::DeleteSurface(pd->lpDDSurface);
	
	LocalFree( (void *)(pd->lpDDSurface->lpGbl->fpVidMem) );
	pd->ddRVal = DD_OK;
	DEBUGLEAVE( DDGPEDestroyExecuteBuffer );
	return DDHAL_DRIVER_HANDLED;
}

// The following two routines are used by numerous HAL sub-functions.
// Actual locking activities may be implimented as necessary
// currently they are simply used to obtain a valid pointer to the
// surface memory (so unlock is a NOP).

inline unsigned long lockSurface( LPDDRAWI_DDRAWSURFACE_LCL pSurface )
{
	return pSurface->lpGbl->fpVidMem;
}

inline void unlockSurface( LPDDRAWI_DDRAWSURFACE_LCL pSurface )
{
	;
}


EXTERN_C DWORD WINAPI DDGPELock( LPDDHAL_LOCKDATA pd )
{
	DEBUGENTER( DDGPELock );
	/*
	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;
	*/

	// TBD: Check that this surface isn't being Blt'ed to currently
    DDGPESurf* pSurf = DDGPESurf::GetDDGPESurf(pd->lpDDSurface);

    if (g_pGPE->SurfaceBusyFlipping(pSurf))
    {
        pd->ddRVal = DDERR_WASSTILLDRAWING;
        return DDHAL_DRIVER_HANDLED;
    }

    if (pd->dwFlags & DDLOCK_WAIT)
    {
        g_pGPE->WaitForNotBusy();
    }
    else if (g_pGPE->IsBusy())
    {
        pd->ddRVal = DDERR_WASSTILLDRAWING;
        return DDHAL_DRIVER_HANDLED;
    }

	ULONG ulAddress = lockSurface(pd->lpDDSurface);
	if (pd->bHasRect)
	{
		DWORD bitcnt;

		LPDDRAWI_DDRAWSURFACE_GBL pGbl = pd->lpDDSurface->lpGbl;

	    if( pd->lpDDSurface->dwFlags & DDRAWISURF_HASPIXELFORMAT )
		{
	        bitcnt = pGbl->ddpfSurface.dwRGBBitCount;
			DEBUGMSG(HAL_ZONE_INFO, (TEXT("pGbl->ddpfSurface.dwRGBBitCount = 0x%08x\r\n"), bitcnt ));
		}
		else
		{
	        bitcnt = pGbl->lpDD->vmiData.ddpfDisplay.dwRGBBitCount;
			DEBUGMSG(HAL_ZONE_INFO, (TEXT("pGbl->lpDD->vmiData.ddpfDisplay.dwRGBBitCount = 0x%08x\r\n"), bitcnt ));
		}

		ulAddress += 	((DWORD)pd->rArea.top * (DDGPESurf::GetDDGPESurf(pd->lpDDSurface))->Stride() +
                          	((DWORD)pd->rArea.left * (UINT)(bitcnt)) / 8u);
	}


	*(int *)&(pd->lpSurfData) = ulAddress;

	pd->ddRVal = DD_OK;
	DEBUGLEAVE( DDGPELock );
	return DDHAL_DRIVER_HANDLED;
}

EXTERN_C DWORD WINAPI DDGPEUnlock( LPDDHAL_UNLOCKDATA pd )
{
	DEBUGENTER( DDGPEUnlock );
	/*
	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;
	*/

	unlockSurface( pd->lpDDSurface );

	pd->ddRVal = DD_OK;
	DEBUGLEAVE( DDGPEUnlock );