halsurf.cpp

s3c2443的display driver.

	}
	else
	{
		// SIMPLE BLT
		RETAILMSG(1,(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;
			}
		}

		rop4 = 0xCCCC;	// SRCCOPY

	}

	/*
	DEBUGMSG(GPE_ZONE_BLT_HI, (TEXT("DDRAW Dest Info:\n\r") ));
	DEBUGMSG(GPE_ZONE_BLT_HI, (TEXT("    left    = %d\n\r"),  prclDst->left ));
	DEBUGMSG(GPE_ZONE_BLT_HI, (TEXT("    top     = %d\n\r"),  prclDst->top ));
	DEBUGMSG(GPE_ZONE_BLT_HI, (TEXT("    right   = %d\n\r"),  prclDst->right ));
	DEBUGMSG(GPE_ZONE_BLT_HI, (TEXT("    bottom  = %d\n\r"),  prclDst->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"),  prclSrc->left ));
		DEBUGMSG(GPE_ZONE_BLT_HI, (TEXT("    top     = %d\n\r"),  prclSrc->top ));
		DEBUGMSG(GPE_ZONE_BLT_HI, (TEXT("    right   = %d\n\r"),  prclSrc->right ));
		DEBUGMSG(GPE_ZONE_BLT_HI, (TEXT("    bottom  = %d\n\r"),  prclSrc->bottom ));
	}
	*/
		
	pd->ddRVal = g_pGPE->BltExpanded(
					pDst,
					pSrc,
					pPattern,
					NULL, // pMask
					NULL, // pco
					NULL, // pxlo
					prclDst,
					prclSrc,
					solidColor,
					bltFlags,
					rop4
					);

	DEBUGLEAVE( HalBlt );
	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;
    */

    // Implementation
    pd->ddRVal = DD_OK;

    return DDHAL_DRIVER_HANDLED;
}

DWORD WINAPI HalGetFlipStatus( LPDDHAL_GETFLIPSTATUSDATA pd )
{
    DEBUGENTER( HalGetFlipStatus );
    /*
    typedef struct _DDHAL_GETFLIPSTATUSDATA
    {
        LPDDRAWI_DIRECTDRAW_GBL     lpDD;           // driver struct
        LPDDRAWI_DDRAWSURFACE_LCL   lpDDSurface;    // surface struct
        DWORD                       dwFlags;        // flags
        HRESULT                     ddRVal;         // return value
        LPDDHALSURFCB_GETFLIPSTATUS GetFlipStatus;  // PRIVATE: ptr to callback
    } DDHAL_GETFLIPSTATUSDATA;
    */

    // Implementation
    pd->ddRVal = DD_OK;

    return DDHAL_DRIVER_HANDLED;
}

DWORD WINAPI HalUpdateOverlay( LPDDHAL_UPDATEOVERLAYDATA lpUpdateOverlay )
{
    LPDDRAWI_DDRAWSURFACE_LCL   lpLcl = lpUpdateOverlay->lpDDSrcSurface;
    LPDDRAWI_DDRAWSURFACE_GBL   lpGbl = lpLcl->lpGbl;
    LPDDRAWI_DDRAWSURFACE_GBL   lpSource;
    LPDDRAWI_DDRAWSURFACE_GBL   lpDestination;
    S3C2443Surf               * lpSurfInfo;
    DWORD                       dwStride;
//    LONG                        lSrcWidth;
//    LONG                        lSrcHeight;
//    LONG                        lDstWidth;
//    LONG                        lDstHeight;
//    LONG                        lHInc;
    DWORD /*SrcBufOffset,*/ Temp;
//    RECTL rOverlay;
//    DWORD dwVideoInSave;

    BOOL  bAllocatedOverlay = FALSE;
    ULONG ulController = 0;

    DEBUGENTER( HalUpdateOverlay );

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

    lpSource = lpUpdateOverlay->lpDDSrcSurface->lpGbl;
	
	//RETAILMSG(1,(TEXT("lpSource->fpVidMem=0x%08X\n"),lpSource->fpVidMem));

    dwStride = lpSource->lPitch;

	//RETAILMSG(1,(TEXT("%X %X %X %X %X\n"),DDOVER_HIDE,DDOVER_SHOW,DDOVER_KEYSRCOVERRIDE,DDOVER_DDFX,lpUpdateOverlay->dwFlags));
    if (lpUpdateOverlay->dwFlags & DDOVER_HIDE)
    {
        /* Turn off overlay */

        if (lpSource->fpVidMem)
        {
        	//RETAILMSG(1,(TEXT("((S3C2443DISP *)g_pGPE)->fpOverlayFlipFrom=0x%08X\n"),((S3C2443DISP *)g_pGPE)->fpOverlayFlipFrom));
            if ((lpSource->fpVidMem == (FLATPTR) ((S3C2443DISP *)g_pGPE)->fpVisibleOverlay) ||
            	(lpSource->fpVidMem == (FLATPTR) ((S3C2443DISP *)g_pGPE)->fpOverlayFlipFrom))
            {
            	((S3C2443DISP *)g_pGPE)->fpVisibleOverlay = 0;
            	((S3C2443DISP *)g_pGPE)->fpOverlayFlipFrom = 0;
                ((S3C2443DISP *)g_pGPE)->DisableOverlay();
            }
        }

        lpUpdateOverlay->ddRVal = DD_OK;
        return (DDHAL_DRIVER_HANDLED);
    }

    /*
     * Dereference 'lpDDDestSurface' only after checking for the DDOVER_HIDE
     * case:
     */

    lpDestination = lpUpdateOverlay->lpDDDestSurface->lpGbl;

    /* check, if the overlay was already allocated and in use */

    if (lpSource->fpVidMem)
    {
        if ( (lpSource->fpVidMem != (FLATPTR) ((S3C2443DISP *)g_pGPE)->fpVisibleOverlay) &&
        	(lpSource->fpVidMem != (FLATPTR) ((S3C2443DISP *)g_pGPE)->fpOverlayFlipFrom))
        {
            if (lpUpdateOverlay->dwFlags & DDOVER_SHOW)
            {
                if (((S3C2443DISP *)g_pGPE)->fpVisibleOverlay)
                {
                    // Some other overlay is already visible:

                    lpUpdateOverlay->ddRVal = DDERR_OUTOFCAPS;
                    return (DDHAL_DRIVER_HANDLED);
                }
                else
                {
                    // We're going to make the overlay visible, so mark it as
                    // such:
                    ((S3C2443DISP *)g_pGPE)->fpVisibleOverlay = lpSource->fpVidMem;

                    // initialize overlay hardware
                    //((S3C2443DISP *)g_pGPE)->EnableOverlay();
                }
            }
            else
            {
                // The overlay isn't visible, and we haven't been asked to make
                // it visible, so this call is trivially easy:

                lpUpdateOverlay->ddRVal = DD_OK;
                return(DDHAL_DRIVER_HANDLED);
            }
        }
    }
    
    lpSurfInfo = (S3C2443Surf *) lpGbl->dwReserved1;
    
    ((S3C2443DISP *)g_pGPE)->InitOverlay(lpSurfInfo, lpUpdateOverlay->rSrc);
    ((S3C2443DISP *)g_pGPE)->SetOverlayPosition(lpUpdateOverlay->rDest.left,lpUpdateOverlay->rDest.top, lpSurfInfo->Width(), lpSurfInfo->Height());

    /* Set up the colour keying, if any? */

    if (lpUpdateOverlay->dwFlags & DDOVER_KEYSRC          ||
         lpUpdateOverlay->dwFlags & DDOVER_KEYSRCOVERRIDE  ||
         lpUpdateOverlay->dwFlags & DDOVER_KEYDEST         ||
         lpUpdateOverlay->dwFlags & DDOVER_KEYDESTOVERRIDE)
    {

        if (lpUpdateOverlay->dwFlags & DDOVER_KEYSRC ||
             lpUpdateOverlay->dwFlags & DDOVER_KEYSRCOVERRIDE)
        {
            //Set source colour key
            if (lpUpdateOverlay->dwFlags & DDOVER_KEYSRC)
            {
                Temp = lpUpdateOverlay->lpDDDestSurface->ddckCKSrcOverlay.dwColorSpaceLowValue;
            }
            else
            {
                Temp = lpUpdateOverlay->overlayFX.dckSrcColorkey.dwColorSpaceLowValue;
            }
            ((S3C2443DISP *)g_pGPE)->SetOverlayColorKey(TRUE,Temp);
		}
    }
    else
    {
		((S3C2443DISP *)g_pGPE)->SetOverlayColorKey(FALSE,0);
    }
    
     /* Set up the alpha blending, if any? */
    if (lpUpdateOverlay->dwFlags & DDOVER_ALPHASRC          ||
         lpUpdateOverlay->dwFlags & DDOVER_ALPHASRCCONSTOVERRIDE)
    {
        //Set source colour key
        if (lpUpdateOverlay->dwFlags & DDOVER_ALPHASRC)
        {
            ((S3C2443DISP *)g_pGPE)->SetOverlayAlpha(TRUE, TRUE, 0);
        }
        else
        {
            ((S3C2443DISP *)g_pGPE)->SetOverlayAlpha(TRUE, FALSE, lpUpdateOverlay->overlayFX.dwAlphaSrcConst);
        }
    }
    else
    {
		((S3C2443DISP *)g_pGPE)->SetOverlayAlpha(FALSE, FALSE, 0);
    }    
    
    ((S3C2443DISP *)g_pGPE)->EnableOverlay();
    /*
     * return to DirectDraw.
     */
	//RETAILMSG(1,(TEXT("UpdateOverlay End!!\n")));
    lpUpdateOverlay->ddRVal = DD_OK;
    return DDHAL_DRIVER_HANDLED;
}

DWORD WINAPI HalSetOverlayPosition( LPDDHAL_SETOVERLAYPOSITIONDATA pd )
{
	S3C2443Surf               * lpSurfInfo;	
    DEBUGENTER( HalSetOverlayPosition );
    /*
    typedef struct _DDHAL_SETOVERLAYPOSITIONDATA
    {
        LPDDRAWI_DIRECTDRAW_GBL     lpDD;           // driver struct
        LPDDRAWI_DDRAWSURFACE_LCL   lpDDSrcSurface; // src surface
        LPDDRAWI_DDRAWSURFACE_LCL   lpDDDestSurface;// dest surface
        LONG                        lXPos;          // x position
        LONG                        lYPos;          // y position
        HRESULT                     ddRVal;         // return value
        LPDDHALSURFCB_SETOVERLAYPOSITION SetOverlayPosition;
                                                    // PRIVATE: ptr to callback
    } DDHAL_SETOVERLAYPOSITIONDATA;
    */

    // Implementation
	lpSurfInfo = (S3C2443Surf *)pd->lpDDSrcSurface->lpGbl->dwReserved1;
	((S3C2443DISP *)g_pGPE)->SetOverlayPosition(pd->lXPos,pd->lYPos, lpSurfInfo->Width(), lpSurfInfo->Height());
    pd->ddRVal = DD_OK;

    return DDHAL_DRIVER_HANDLED;
}

DWORD WINAPI HalSetPalette( LPDDHAL_SETPALETTEDATA pd )
{
    DEBUGENTER( HalSetPalette );
    /*
    typedef struct _DDHAL_SETPALETTEDATA
    {
        LPDDRAWI_DIRECTDRAW_GBL     lpDD;           // driver struct
        LPDDRAWI_DDRAWSURFACE_LCL   lpDDSurface;    // surface struct
        LPDDRAWI_DDRAWPALETTE_GBL   lpDDPalette;    // palette to set to surface
        HRESULT                     ddRVal;         // return value
        LPDDHALSURFCB_SETPALETTE    SetPalette;     // PRIVATE: ptr to callback
        BOOL                        Attach;         // attach this palette?
    } DDHAL_SETPALETTEDATA;
    */

    // Implementation
    pd->ddRVal = DD_OK;

    return DDHAL_DRIVER_HANDLED;
}