halsurf.cpp

SM501基于ARMV4/ARMV4I平台

    else if (IS_BUSY)
    {
        pd->ddRVal = DDERR_WASSTILLDRAWING;
        return DDHAL_DRIVER_HANDLED;
    }

    ULONG ulAddress = pd->lpDDSurface->lpGbl->fpVidMem;
    if (pd->bHasRect)
    {
        DWORD bitcnt;
        LPDDRAWI_DDRAWSURFACE_GBL pGbl = pd->lpDDSurface->lpGbl;

        if (pd->lpDDSurface->dwFlags & DDRAWISURF_HASPIXELFORMAT)
            bitcnt = pGbl->ddpfSurface.dwRGBBitCount;
        else
            bitcnt = pGbl->lpDD->vmiData.ddpfDisplay.dwRGBBitCount;

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

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

	// Implementation
	pd->ddRVal = DD_OK;
	
//	RETAILMSG(1,(TEXT("SMI:: -Lock()\r\n")));
	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;
	*/

	// Implementation
	pd->ddRVal = DD_OK;

	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 )
{
	//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;
	*/

	return ((SMI *)g_pGPE)->Flip(pd);

}

DWORD SMI::Flip(LPDDHAL_FLIPDATA pd)
{
	//	RETAILMSG(1,(TEXT("+HalFlip\r\n")));
	DEBUGENTER( HalFlip );
		
	if (pd->dwFlags & DDFLIP_WAIT)
	{
		WaitForNotBusy();
	}
	else if (IS_BUSY)
	{
		DEBUGMSG(GPE_ZONE_FLIP,(TEXT("Graphics engine busy\r\n")));

		pd->ddRVal = DDERR_WASSTILLDRAWING;
		return DDHAL_DRIVER_HANDLED;
	}

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

	if (pd->lpSurfCurr->ddsCaps.dwCaps & DDSCAPS_OVERLAY)
    {
	    DDGPESurf* surfCurr = DDGPESurf::GetDDGPESurf(pd->lpSurfCurr);
        if (surfCurr == m_pVisibleOverlay)
        {
			
			POKE_32(VIDEO_FB_0_ADDRESS, 
				FIELD_SET(0, VIDEO_FB_0_ADDRESS, STATUS, PENDING) |
				FIELD_VALUE(0, VIDEO_FB_0_ADDRESS, EXT, m_SMISettings.m_bUMA) |
				FIELD_VALUE(0, VIDEO_FB_0_ADDRESS, ADDRESS, VgxSurfAddr(surfTarg->OffsetInVideoMemory() + m_dwOverlayFlipOffset)) |
				0);

#ifdef x86
			if (!(pd->dwFlags & DDFLIP_NOVSYNC))
				while (FIELD_GET(PEEK_32(VIDEO_FB_0_ADDRESS), VIDEO_FB_0_ADDRESS, STATUS) 
					== VIDEO_FB_0_ADDRESS_STATUS_PENDING);
#endif
				m_pVisibleOverlay = surfTarg;
        }
        else
        {
            pd->ddRVal = DDERR_OUTOFCAPS;
            return DDHAL_DRIVER_HANDLED;
        }
	}
	else
	{
		SetVisibleSurface((GPESurf *)surfTarg, !(pd->dwFlags & DDFLIP_NOVSYNC));
	}

	pd->ddRVal = DD_OK;
	
	// RETAILMSG(1,(TEXT("-HalFlip\r\n")));
	
	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;
	*/

	return ((SMI *)g_pGPE)->Blt(pd);
	// Implementation
	// pd->ddRVal = DD_OK;
	// return DDHAL_DRIVER_HANDLED;
}

DWORD SMI::Blt(LPDDHAL_BLTDATA pd)
{
   /*
    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;
    */

    DDGPESurf* pSurf = DDGPESurf::GetDDGPESurf(pd->lpDDDestSurface);

    //
    // Wait for SMI engine to be idle, allows blts to complete before
    // another command is attempted. Failure to wait can cause unwanted
    // data to appear on the display.
    //
/*
    if (SurfaceBusyFlipping(pSurf))
    {
        pd->ddRVal = DDERR_WASSTILLDRAWING;
        return DDHAL_DRIVER_HANDLED;
    }
*/
	if (pd->dwFlags & DDBLT_WAIT)
	{
		WaitForNotBusy();
	}
	else if (IS_BUSY)
    {
        pd->ddRVal = DDERR_WASSTILLDRAWING;
        return DDHAL_DRIVER_HANDLED;
    }

    DDGPESurf* pDstSurf = DDGPESurf::GetDDGPESurf(pd->lpDDDestSurface);
    DDGPESurf* pSrcSurf = (DDGPESurf* )NULL;
    DDGPESurf* pPattern = (DDGPESurf* )NULL;
    RECT *prclDst = (RECT *)&(pd->rDest);
    RECT *prclSrc = (RECT *)&(pd->rSrc);
    ULONG solidColor;
    ULONG bltFlags = 0; //(pd->dwFlags & DDBLT_WAIT)?0x100:0;
    ULONG rop4;

	//RETAILMSG(1,(TEXT("HalSurf.cpp -- Blt dwFlags=%08x dwROPFlags=%08x\r\n"), pd->dwFlags, pd->dwROPFlags));

    if(pd->lpDDSrcSurface)
    {
        pSrcSurf = DDGPESurf::GetDDGPESurf(pd->lpDDSrcSurface);

		if (pd->lpDDSrcSurface->dwFlags & DDRAWISURF_HASPIXELFORMAT)
		{
			if(pd->lpDDSrcSurface->lpGbl->ddpfSurface.dwFlags & DDPF_FOURCC)
			{
				pd->ddRVal = CSCStretchBlt(pd);
			    return DDHAL_DRIVER_HANDLED;
			}
		}

    }

    if ((pd->dwFlags & DDBLT_COLORFILL) ||
        ((pd->dwFlags & DDBLT_ROP) &&
         (pd->bltFX.dwROP == BLACKNESS || pd->bltFX.dwROP == WHITENESS)))
    {
        // FILL BLT
        DEBUGMSG(GPE_ZONE_BLT_LO,(TEXT("FILL BLT\n")));

        if ((pd->dwFlags & DDBLT_ROP) && (pd->bltFX.dwROP == BLACKNESS))
        {
            rop4 = 0x0000;
        }
        else if ((pd->dwFlags & DDBLT_ROP) && (pd->bltFX.dwROP == WHITENESS))
        {
            rop4 = 0xFFFF;
        }
        else
        {
            rop4 = 0xF0F0;  // PATCOPY
            solidColor = pd->bltFX.dwFillColor;
            switch (pDstSurf->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) && (pd->bltFX.dwROP == PATCOPY))
    {
        // PAT BLT
        DEBUGMSG(GPE_ZONE_BLT_LO,(TEXT("PAT BLT\n")));
        rop4 = 0xF0F0;  // PATCOPY;
        solidColor = 0xFFFFFFFF;    // i.e. not a solid color blt
        pPattern = DDGPESurf::GetDDGPESurf(
                       (LPDDRAWI_DDRAWSURFACE_LCL)(pd->bltFX.lpDDSPattern));
    }
    else if (pd->dwFlags & (DDBLT_KEYSRCOVERRIDE | DDBLT_KEYSRC))
    {
        // TRANSPARENT BLT
        DEBUGMSG(GPE_ZONE_BLT_LO,(TEXT("TRANSPARENT BLT\n")));

        if (pd->dwFlags & DDBLT_KEYSRCOVERRIDE)
        {
            DEBUGMSG(GPE_ZONE_BLT_LO,
                     (TEXT("DDBLT_KEYSRCOVERRIDE, xparent = 0x%x\n"),
                      pd->bltFX.ddckSrcColorkey.dwColorSpaceLowValue));
            solidColor = pd->bltFX.ddckSrcColorkey.dwColorSpaceLowValue;
        }
        else
        {
            DEBUGMSG(GPE_ZONE_BLT_LO,
                     (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;
				//RETAILMSG(1, (TEXT("SMI: STRETCH BLT Flag!\r\n")));
            }
        }
    }
    else
    {
        // SIMPLE BLT
        DEBUGMSG(GPE_ZONE_BLT_LO,(TEXT("SIMPLE BLT\n")));

        // 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;
				//RETAILMSG(1, (TEXT("SMI: STRETCH BLT Flag!\r\n")));
            }
        }
        rop4 = 0xCCCC;  // SRCCOPY

    }

    pd->ddRVal = BltExpanded(
                    pDstSurf,
                    pSrcSurf,
                    pPattern,
                    prclDst,
                    prclSrc,
                    solidColor,
                    bltFlags,
                    rop4 );

    return DDHAL_DRIVER_HANDLED;
}


// not to be confused with
// DWORD WINAPI HalSetColorKey( LPDDHAL_DRVSETCOLORKEYDATA pd )
DWORD WINAPI HalSetColorKey( LPDDHAL_SETCOLORKEYDATA pd )
{
	DEBUGENTER( HalSetColorKey );
	/*
	typedef struct _DDHAL_DRVSETCOLORKEYDATA
	{
	    LPDDRAWI_DDRAWSURFACE_LCL   lpDDSurface;    // surface struct
	    DWORD                       dwFlags;        // flags
	    DDCOLORKEY                  ckNew;          // new color key
	    HRESULT                     ddRVal;         // return value
	    LPDDHAL_SETCOLORKEY         SetColorKey;    // PRIVATE: ptr to callback
	} DDHAL_DRVSETCOLORKEYDATA;
	*/

	pd->ddRVal = DD_OK;
	return DDHAL_DRIVER_HANDLED;
}

DWORD WINAPI HalAddAttachedSurface( LPDDHAL_ADDATTACHEDSURFACEDATA pd )
{
	DEBUGENTER( HalAddAttachedSurface );
	/*
	typedef struct _DDHAL_ADDATTACHEDSURFACEDATA
	{
	    LPDDRAWI_DIRECTDRAW_GBL		lpDD;           // driver struct
	    LPDDRAWI_DDRAWSURFACE_LCL	lpDDSurface;    // surface struct
	    LPDDRAWI_DDRAWSURFACE_LCL	lpSurfAttached; // surface to attach
	    HRESULT						ddRVal;         // return value
	    LPDDHALSURFCB_ADDATTACHEDSURFACE AddAttachedSurface;
	    											// PRIVATE: ptr to callback
	} DDHAL_ADDATTACHEDSURFACEDATA;
	*/

	// Implementation
	pd->ddRVal = DD_OK;

	return DDHAL_DRIVER_HANDLED;
}

DWORD WINAPI HalGetBltStatus( LPDDHAL_GETBLTSTATUSDATA pd )
{
	DEBUGENTER( HalGetBltStatus );
	/*
	typedef struct _DDHAL_GETBLTSTATUSDATA
	{
	    LPDDRAWI_DIRECTDRAW_GBL     lpDD;           // driver struct
	    LPDDRAWI_DDRAWSURFACE_LCL   lpDDSurface;    // surface struct
	    DWORD                       dwFlags;        // flags
	    HRESULT                     ddRVal;         // return value
	    LPDDHALSURFCB_GETBLTSTATUS  GetBltStatus;   // PRIVATE: ptr to callback
	} DDHAL_GETBLTSTATUSDATA;