halsurf.cpp

s3c2443的display driver.

    // Implementation
    pd->ddRVal = DD_OK;

    return DDHAL_DRIVER_HANDLED;
}

DWORD WINAPI HalCreateExecuteBuffer( LPDDHAL_CREATESURFACEDATA pd )
{
    DEBUGENTER( HalCreateExecuteBuffer );
    /*
    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;
    */

    // Implementation
    pd->ddRVal = DD_OK;

    return DDHAL_DRIVER_HANDLED;
}


DWORD WINAPI HalDestroyExecuteBuffer( LPDDHAL_DESTROYSURFACEDATA pd )
{
    DEBUGENTER( HalDestroyExecutebuffer );
    /*
    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;
    */

    // Implementation
    pd->ddRVal = DD_OK;

    return DDHAL_DRIVER_HANDLED;
}

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;
}

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

DWORD WINAPI HalDestroySurface( LPDDHAL_DESTROYSURFACEDATA pd )
{
	DEBUGENTER( HalDestroySurface );
	/*
	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;
	*/

	//RETAILMSG(1,(TEXT("Destroy GPESurf *:0x%08x\r\n"), DDGPESurf::GetDDGPESurf(pd->lpDDSurface) ));

	// Make sure we're not destroying the GDI surface.
	if( (DDGPESurf*)(g_pGPE->PrimarySurface()) != DDGPESurf::GetDDGPESurf(pd->lpDDSurface) )
	{
		//RETAILMSG(1,(TEXT("DeleteSurface\n")));
		DDGPESurf::DeleteSurface(pd->lpDDSurface);
		pd->lpDDSurface = NULL;
	}

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

DWORD WINAPI HalSetSurfaceDesc(LPDDHAL_HALSETSURFACEDESCDATA pd)
{
    DEBUGENTER( HalSetSurfaceDesc );
    /*
        typedef struct _DDHAL_HALSETSURFACEDESCDATA
        {
            DWORD           dwSize;                 // Size of this structure
            LPDDRAWI_DDRAWSURFACE_LCL  lpDDSurface; // Surface
            LPDDSURFACEDESC    lpddsd;                    // Description of surface
            HRESULT         ddrval;
        } DDHAL_HALSETSURFACEDESCDATA;
    */

    // Implementation
    pd->ddrval = DD_OK;

    return DDHAL_DRIVER_HANDLED;
}

DWORD WINAPI HalFlip( LPDDHAL_FLIPDATA pd )
{
	S3C2443Surf               * lpSurfInfo;	
    DEBUGENTER( HalFlip );
    /*
    typedef struct _DDHAL_FLIPDATA
    {
        LPDDRAWI_DIRECTDRAW_GBL     lpDD;           // driver struct
        LPDDRAWI_DDRAWSURFACE_LCL   lpSurfCurr;     // current surface
        LPDDRAWI_DDRAWSURFACE_LCL   lpSurfTarg;     // target surface (to flip to)
        DWORD                       dwFlags;        // flags
        HRESULT                     ddRVal;         // return value
        LPDDHALSURFCB_FLIP          Flip;           // PRIVATE: ptr to callback
    } DDHAL_FLIPDATA;
    */

    if( IS_BUSY )
    {
        if( pd->dwFlags & DDFLIP_WAIT )
        {
            WAIT_FOR_NOT_BUSY;
        }
        else
        {
            DEBUGMSG(GPE_ZONE_FLIP,(TEXT("Graphics engine busy\r\n")));
            pd->ddRVal = DDERR_WASSTILLDRAWING;
            return DDHAL_DRIVER_HANDLED;
        }
    }

    //////
    //WAIT_FOR_VBLANK;
    //////
    lpSurfInfo = (S3C2443Surf *)pd->lpSurfTarg->lpGbl->dwReserved1;
	if ( pd->lpSurfTarg->ddsCaps.dwCaps & DDSCAPS_OVERLAY )
	{
		((S3C2443DISP *)g_pGPE)->fpOverlayFlipFrom = pd->lpSurfTarg->lpGbl->fpVidMem;
		lpSurfInfo->m_bIsOverlay = TRUE;
	}
	else
	{
		lpSurfInfo->m_bIsOverlay = FALSE;
	}

    DDGPEFlip(pd);


    //RETAILMSG(1,(TEXT("Flip!\r\n")));
    DEBUGMSG(GPE_ZONE_FLIP,(TEXT("Flip done\r\n")));

    pd->ddRVal = DD_OK;
    return DDHAL_DRIVER_HANDLED;
}

DWORD WINAPI HalSetClipList( LPDDHAL_SETCLIPLISTDATA pd )
{
    DEBUGENTER( HalSetClipList );
    /*
    typedef struct _DDHAL_SETCLIPLISTDATA
    {
        LPDDRAWI_DIRECTDRAW_GBL     lpDD;           // driver struct
        LPDDRAWI_DDRAWSURFACE_LCL   lpDDSurface;    // surface struct
        HRESULT                     ddRVal;         // return value
        LPDDHALSURFCB_SETCLIPLIST   SetClipList;    // PRIVATE: ptr to callback
    } DDHAL_SETCLIPLISTDATA;
    */

    // Implementation
    pd->ddRVal = DD_OK;

    return DDHAL_DRIVER_HANDLED;
}


DWORD WINAPI HalBlt( LPDDHAL_BLTDATA pd )
{
	DEBUGENTER( HalBlt );
	/*
	typedef struct _DDHAL_BLTDATA
	{
	    LPDDRAWI_DIRECTDRAW_GBL     lpDD;           // driver struct
	    LPDDRAWI_DDRAWSURFACE_LCL   lpDDDestSurface;// dest surface
	    RECTL                       rDest;          // dest rect
	    LPDDRAWI_DDRAWSURFACE_LCL   lpDDSrcSurface; // src surface
	    RECTL                       rSrc;           // src rect
	    DWORD                       dwFlags;        // blt flags
	    DWORD                       dwROPFlags;     // ROP flags (valid for ROPS only)
	    DDBLTFX                     bltFX;          // blt FX
	    HRESULT                     ddRVal;         // return value
	    LPDDHALSURFCB_BLT           Blt;            // PRIVATE: ptr to callback
	} DDHAL_BLTDATA;
	*/
	RETAILMSG(1,(TEXT("BLT (dwflags=%08x) rDest= %d,%d - %d,%d\n"),
		pd->dwFlags,
		pd->rDest.left,
		pd->rDest.top,
		pd->rDest.right,
		pd->rDest.bottom
		)); 

	//DebugBreak();

	DDGPESurf * pDst       = DDGPESurf::GetDDGPESurf(pd->lpDDDestSurface);
	DDGPESurf * pSrc       = (DDGPESurf* )NULL;
	DDGPESurf * pPattern   = (DDGPESurf* )NULL;
	RECT      * prclDst    = (RECT *)&(pd->rDest);
	RECT      * prclSrc    = (RECT *)&(pd->rSrc);
	ULONG       solidColor = 0xffffffff;
	ULONG       bltFlags   = (pd->dwFlags & DDBLT_WAIT)?0x100:0;
	ULONG       rop4;
 	DWORD       dwROP      = pd->bltFX.dwROP >> 16;

	//DEBUGMSG(GPE_ZONE_BLT_HI, (TEXT("Blit 0x%x, 0x%x\r\n"), pDst, pDst->OffsetInVideoMemory()));

	if( pd->lpDDSrcSurface )
		pSrc = DDGPESurf::GetDDGPESurf(pd->lpDDSrcSurface);
	else
		pSrc = (DDGPESurf*)NULL;

	if ( ( pd->dwFlags & DDBLT_COLORFILL ) ||
		( ( pd->dwFlags & DDBLT_ROP ) &&
			( dwROP == ( BLACKNESS >> 16 ) || dwROP == ( WHITENESS >> 16 ) ) ) )
	{
		/*
		DEBUGMSG(GPE_ZONE_BLT_HI, (TEXT("DDRAW Dest Info:\n\r") ));
		DEBUGMSG(GPE_ZONE_BLT_HI, (TEXT("    left    = %d\n\r"),  pd->rDest.left ));
		DEBUGMSG(GPE_ZONE_BLT_HI, (TEXT("    top     = %d\n\r"),  pd->rDest.top ));
		DEBUGMSG(GPE_ZONE_BLT_HI, (TEXT("    right   = %d\n\r"),  pd->rDest.right ));
		DEBUGMSG(GPE_ZONE_BLT_HI, (TEXT("    bottom  = %d\n\r"),  pd->rDest.bottom ));

		if (pSrc != NULL)
		{
			DEBUGMSG(GPE_ZONE_BLT_HI, (TEXT("DDRAW Src Info:\n\r") ));
			DEBUGMSG(GPE_ZONE_BLT_HI, (TEXT("    left    = %d\n\r"),  pd->rSrc.left ));
			DEBUGMSG(GPE_ZONE_BLT_HI, (TEXT("    top     = %d\n\r"),  pd->rSrc.top ));
			DEBUGMSG(GPE_ZONE_BLT_HI, (TEXT("    right   = %d\n\r"),  pd->rSrc.right ));
			DEBUGMSG(GPE_ZONE_BLT_HI, (TEXT("    bottom  = %d\n\r"),  pd->rSrc.bottom ));
		}
		*/

		// FILL BLT
		RETAILMSG(1,(TEXT("FILL BLT\n")));

		if( ( pd->dwFlags & DDBLT_ROP ) && ( dwROP == ( BLACKNESS >> 16 ) ) )
			rop4 = 0x0000;
		else if( ( pd->dwFlags & DDBLT_ROP ) && ( dwROP == ( WHITENESS >> 16 ) ) )
			rop4 = 0xffff;
		else
		{
			rop4 = 0xf0f0;	// PATCOPY
			solidColor = pd->bltFX.dwFillColor;
                        switch (pDst->Bpp()) {
                        case 1:
                        case 2:
                        case 4:
                        case 8:
                          solidColor &= 0x000000FF;
                          break;
                        case 15:
                        case 16:
                          solidColor &= 0x0000FFFF;
                          break;
                        case 24:
                          solidColor &= 0x00FFFFFF;
                          break;
                        case 32:
                          solidColor &= 0xFFFFFFFF;
                          break;
                        }
		}
	}
	else if ( ( pd->dwFlags & DDBLT_ROP ) && ( dwROP == ( PATCOPY >> 16 ) ) )
	{
		// PAT BLT
		RETAILMSG(1,(TEXT("PAT BLT\n")));
		rop4 = 0xf0f0;	// PATCOPY;
		pPattern = DDGPESurf::GetDDGPESurf((LPDDRAWI_DDRAWSURFACE_LCL)(pd->bltFX.lpDDSPattern));
	}
	else if ( pd->dwFlags & ( DDBLT_KEYSRCOVERRIDE | DDBLT_KEYSRC ) )
	{
		// TRANSPARENT BLT
		RETAILMSG(1,(TEXT("TRANSPARENT BLT\n")));

		if ( pd->dwFlags & DDBLT_KEYSRCOVERRIDE )
		{
			RETAILMSG(1,(TEXT("DDBLT_KEYSRCOVERRIDE, xparent = 0x%x\n"),pd->bltFX.ddckSrcColorkey.dwColorSpaceLowValue));
			solidColor = pd->bltFX.ddckSrcColorkey.dwColorSpaceLowValue;
		}
		else
		{
			RETAILMSG(1,(TEXT("DDBLT_KEYSRC, xparent = 0x%x\n"),pd->lpDDSrcSurface->ddckCKSrcBlt.dwColorSpaceLowValue));
			solidColor = pd->lpDDSrcSurface->ddckCKSrcBlt.dwColorSpaceLowValue;
		}

		rop4 = 0xCCCC;	// SRCCOPY
		bltFlags |= BLT_TRANSPARENT;

		// BLT_STRETCH?
		if ((prclDst != NULL) && (prclSrc != NULL))
		{
			if (( (prclDst->bottom - prclDst->top) != (prclSrc->bottom - prclSrc->top))
				|| ((prclDst->right - prclDst->left)  != (prclSrc->right - prclSrc->left) ))
			{
				bltFlags |= BLT_STRETCH;
			}
		}