halsurf.cpp

SM501基于ARMV4/ARMV4I平台

	*/

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

#define DDOVER_ALPHA \
    (DDOVER_ALPHASRC | \
     DDOVER_ALPHASRCCONSTOVERRIDE | \
     DDOVER_ALPHADEST | \
     DDOVER_ALPHADESTCONSTOVERRIDE)

#define DDOVER_KEY \
    (DDOVER_KEYSRC | \
     DDOVER_KEYSRCOVERRIDE |\
     DDOVER_KEYDEST | \
     DDOVER_KEYDESTOVERRIDE)

#define KEYING          0x1
#define BLENDING        0x2
#define OPAQUEING       0x4


DWORD WINAPI HalUpdateOverlay( LPDDHAL_UPDATEOVERLAYDATA pd )
{
	DEBUGENTER( HalUpdateOverlay );
	/*
//	typedef struct _DDHAL_UPDATEOVERLAYDATA
//	{
//	    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;        // flags
//	    DDOVERLAYFX                 overlayFX;      // overlay FX
//	    HRESULT                     ddRVal;         // return value
//	    LPDDHALSURFCB_UPDATEOVERLAY UpdateOverlay;  // PRIVATE: ptr to callback
//	} DDHAL_UPDATEOVERLAYDATA;
//	*/
//

	// Implementation
	return ((SMI *)g_pGPE)->UpdateOverlay(pd);
}

DWORD WINAPI HalSetOverlayPosition( LPDDHAL_SETOVERLAYPOSITIONDATA pd )
{
	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
    return ((SMI *)g_pGPE)->SetOverlayPosition(pd);
}

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

#define DDOVER_ALPHA \
    (DDOVER_ALPHASRC | \
     DDOVER_ALPHASRCCONSTOVERRIDE | \
     DDOVER_ALPHADEST | \
     DDOVER_ALPHADESTCONSTOVERRIDE)

#define DDOVER_KEY \
    (DDOVER_KEYSRC | \
     DDOVER_KEYSRCOVERRIDE |\
     DDOVER_KEYDEST | \
     DDOVER_KEYDESTOVERRIDE)

#define KEYING          0x1
#define BLENDING        0x2
#define OPAQUEING       0x4

// #define OPQ_CTRL

DWORD SMI::UpdateOverlay(LPDDHAL_UPDATEOVERLAYDATA pd)
{
    /*
    typedef struct _DDHAL_UPDATEOVERLAYDATA
    {
        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;        // flags
        DDOVERLAYFX                 overlayFX;      // overlay FX
        HRESULT                     ddRVal;         // return value
        LPDDHALSURFCB_UPDATEOVERLAY UpdateOverlay;  // PRIVATE: ptr to callback
    } DDHAL_UPDATEOVERLAYDATA;
    */

//	RETAILMSG(1, (TEXT("SMI::+UpdateOverlay\r\n")));
    DDGPESurf* pSrcSurf = DDGPESurf::GetDDGPESurf(pd->lpDDSrcSurface);

    // error if requested both keying and blending
    if ((pd->dwFlags & DDOVER_KEY) && (pd->dwFlags & DDOVER_ALPHA))
    {
        DEBUGMSG(1,
                  (TEXT("Error: can't handle both keying and blending!\r\n")));
        pd->ddRVal = DDERR_INVALIDPARAMS;
        return DDHAL_DRIVER_HANDLED;
    }

    // error if requested both source and dest color keying
    if ((pd->dwFlags & (DDOVER_KEYDEST | DDOVER_KEYDESTOVERRIDE)) &&
        (pd->dwFlags & (DDOVER_KEYSRC | DDOVER_KEYSRCOVERRIDE)))
    {
        DEBUGMSG(1,
          (TEXT("Error: can't handle both source and dest color keying!\r\n")));
        pd->ddRVal = DDERR_INVALIDPARAMS;
        return (DDHAL_DRIVER_HANDLED);
    }

    if (pd->dwFlags & DDOVER_HIDE)
    {
        //RETAILMSG(1, (TEXT("SMI::OVERLAY HIDE REQUEST\r\n")));
        if (pSrcSurf == m_pVisibleOverlay)
        {
            // hide the overlay
			POKE_32(VIDEO_DISPLAY_CTRL,FIELD_SET(PEEK_32(VIDEO_DISPLAY_CTRL),VIDEO_DISPLAY_CTRL, PLANE, DISABLE));
            // reset visible overlay
            m_pVisibleOverlay = NULL;
            //RETAILMSG(1, (TEXT("SMI::OVERLAY HIDE!\r\n")));
        }
        else
        {
            // the overlay is not currently visible
            // nothing we need to do here
        }

        pd->ddRVal = DD_OK;
        return DDHAL_DRIVER_HANDLED;
    }

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

    if (pSrcSurf != m_pVisibleOverlay)
    {
        if (pd->dwFlags & DDOVER_SHOW)
        {
	        //RETAILMSG(1, (TEXT("SMI::OVERLAY SHOW REQUEST\r\n")));
            if (m_pVisibleOverlay != NULL)
            {
                // some other overlay is already visible
                DEBUGMSG(1,
                          (TEXT("Error: Other overlay already visible!\r\n")));
                pd->ddRVal = DDERR_OUTOFCAPS;
                return DDHAL_DRIVER_HANDLED;
            }
            else
            {
                // we are going to make the overlay visible
                // so mark it as such:
                m_pVisibleOverlay = pSrcSurf;
		        //RETAILMSG(1, (TEXT("SMI::OVERLAY SHOW\r\n")));
            }
        }
        else // DDOVER_SHOW not requested
        {
            // the overlay isn't visible, and we haven't been
            // asked to make it visible, so nothing we need to do
            pd->ddRVal = DD_OK;
            return DDHAL_DRIVER_HANDLED;
        }
    }

    DWORD dwSrcWidth = pd->rSrc.right - pd->rSrc.left;
    DWORD dwSrcHeight = pd->rSrc.bottom - pd->rSrc.top;
    DWORD dwDstWidth = pd->rDest.right - pd->rDest.left;
    DWORD dwDstHeight = pd->rDest.bottom - pd->rDest.top;
    DWORD dwSrcStride = pSrcSurf->Stride();

    DWORD dwSrcBytesPerPixel = EGPEFormatToBpp[pSrcSurf->Format()] / 8;
    m_dwOverlayFlipOffset = pd->rSrc.top * dwSrcStride +
                            pd->rSrc.left * dwSrcBytesPerPixel;
    DWORD dwStartAdd = (pSrcSurf->OffsetInVideoMemory() + m_dwOverlayFlipOffset); //>>3

	// OVERLAYSURF memebers should be filled... to be implemented in the future
	os.dwDstX1 = pd->rDest.left;
	os.dwDstY1 = pd->rDest.top;
	os.dwDstW = dwDstWidth;
	os.dwDstH = dwDstHeight;
	os.dwSurfBpp = dwSrcBytesPerPixel;

	DWORD dwControl = PEEK_32(VIDEO_DISPLAY_CTRL);
	int hstretch, vstretch;
	int hmode, vmode;

	BYTE bSPOP = 0;
    DDGPESurf *pColorKeySurf = NULL;
    DWORD dwKeyLow = 0;

    switch (pSrcSurf->PixelFormat())
    {
        case ddgpePixelFormat_UYVY422:
			dwControl = FIELD_SET(dwControl, VIDEO_DISPLAY_CTRL, BYTE_SWAP, ENABLE);
			dwControl = FIELD_SET(dwControl, VIDEO_DISPLAY_CTRL, FORMAT, YUV);
			break;

        case ddgpePixelFormat_YUYV422:
        case ddgpePixelFormat_YUY2422:
			dwControl = FIELD_SET(dwControl, VIDEO_DISPLAY_CTRL, BYTE_SWAP, DISABLE);
			dwControl = FIELD_SET(dwControl, VIDEO_DISPLAY_CTRL, FORMAT, YUV);
            break;

        case ddgpePixelFormat_8bpp:
			dwControl = FIELD_SET(dwControl, VIDEO_DISPLAY_CTRL, FORMAT, 8);
            break;

        case ddgpePixelFormat_565:
			dwControl = FIELD_SET(dwControl, VIDEO_DISPLAY_CTRL, FORMAT, 16);
            break;

        case ddgpePixelFormat_8888:
			dwControl = FIELD_SET(dwControl, VIDEO_DISPLAY_CTRL, FORMAT, 32);
            break;

        default:
            DEBUGMSG(1, (TEXT("Error: Unexpected overlay format!\r\n")));
            pd->ddRVal = DDERR_UNSUPPORTED;
            return DDHAL_DRIVER_HANDLED;
    }

	POKE_32(PANEL_DISPLAY_CTRL,FIELD_SET(PEEK_32(PANEL_DISPLAY_CTRL),PANEL_DISPLAY_CTRL, COLOR_KEY, DISABLE));

    if (pd->dwFlags & DDOVER_KEYDEST)
    {
        bSPOP = KEYING;
        pColorKeySurf = pDstSurf;
        dwKeyLow = pd->lpDDDestSurface->ddckCKDestOverlay.dwColorSpaceLowValue;
		POKE_32(PANEL_DISPLAY_CTRL,FIELD_SET(PEEK_32(PANEL_DISPLAY_CTRL),PANEL_DISPLAY_CTRL, COLOR_KEY, ENABLE));
    }
    else if (pd->dwFlags & DDOVER_KEYDESTOVERRIDE)
    {
        bSPOP = KEYING;
        pColorKeySurf = pDstSurf;
        dwKeyLow  = pd->overlayFX.dckDestColorkey.dwColorSpaceLowValue;
		POKE_32(PANEL_DISPLAY_CTRL,FIELD_SET(PEEK_32(PANEL_DISPLAY_CTRL),PANEL_DISPLAY_CTRL, COLOR_KEY, ENABLE));
    }

	// Note panel with special patch ie. Use Video to enlarge do not support COLORKEY
    if (bSPOP == KEYING)
    {
        switch (pColorKeySurf->PixelFormat())
        {
			case ddgpePixelFormat_YUY2422:
            case ddgpePixelFormat_YUYV422:
            case ddgpePixelFormat_UYVY422:
				if (pSrcSurf->Bpp() == 24) {
					BYTE r,g,b;
					r = (BYTE)(dwKeyLow & 0x000000FF);
					g = (BYTE)((dwKeyLow & 0x0000FF00)>>8);
					b = (BYTE)((dwKeyLow & 0x00FF0000)>>16);
					dwKeyLow = (DWORD)((b>>3) + ((g>>3)<<6) + ((r>>3)<<11));
				}
                break;

			case ddgpePixelFormat_8bpp:
				break;

            case ddgpePixelFormat_565:
                break;

            case ddgpePixelFormat_8888:
					BYTE r,g,b;
					r = (BYTE)(dwKeyLow & 0x000000FF);
					g = (BYTE)((dwKeyLow & 0x0000FF00)>>8);
					b = (BYTE)((dwKeyLow & 0x00FF0000)>>16);
					dwKeyLow = (DWORD)((b>>3) | ((g>>2)<<5) | ((r>>3)<<11));
                break;

            default:
                DEBUGMSG(1, (TEXT("Error: Unexpected colorkey overlay format!\r\n")));
                pd->ddRVal = DDERR_UNSUPPORTED;
                return DDHAL_DRIVER_HANDLED;

        }
    }

	// calc horizontal stretch ratio
	if (dwDstWidth >= dwSrcWidth)
	{
		hstretch = ((40960 * (dwSrcWidth-1) / dwDstWidth) + 5) / 10; //(dwSrcWidth-1) fixed garbage line at right side of overlay window. 9/29/03
		hmode = VIDEO_SCALE_HORIZONTAL_MODE_EXPAND;
	}
	else
	{
		hstretch = ((40960 * dwDstWidth / (dwSrcWidth-1)) + 5) / 10; //(dwSrcWidth-1) fixed garbage line at right side of overlay window. 9/29/03
		hmode = VIDEO_SCALE_HORIZONTAL_MODE_SHRINK;
	}


	// calc vertical stretch ratio
	if (dwDstHeight >= dwSrcHeight)
	{
		vstretch = ((40960 * (dwSrcHeight-1) / dwDstHeight) + 5) / 10; //(dwSrcHeight-1) fixed garbage line at bottom caused by hw interpolation. 9/10/03
		vmode = VIDEO_SCALE_VERTICAL_MODE_EXPAND;
	}
	else
	{
		vstretch = ((40960 * dwDstHeight / (dwSrcHeight-1)) + 5) / 10; //(dwSrcHeight-1) fixed garbage line at bottom caused by hw interpolation. 9/10/03
		vmode = VIDEO_SCALE_VERTICAL_MODE_SHRINK;
	}

	// Enable Interpolation mode
	dwControl = FIELD_SET(dwControl, VIDEO_DISPLAY_CTRL, VERTICAL_MODE, INTERPOLATE);
	dwControl = FIELD_SET(dwControl, VIDEO_DISPLAY_CTRL, HORIZONTAL_MODE, INTERPOLATE);


#ifdef XSCALE
	dwKeyLow = 0x0841;
#endif

    // set the registers to show overlay
	if (bSPOP == KEYING)
	{
		POKE_32(PANEL_COLOR_KEY, 
			FIELD_VALUE(0,PANEL_COLOR_KEY, MASK, 0) |
			FIELD_VALUE(0,PANEL_COLOR_KEY, VALUE, dwKeyLow) |	 // For XScale platform, need fix the color key value 0x0841.
			0);
	}

	POKE_32(VIDEO_PLANE_TL, 
		FIELD_VALUE(0, VIDEO_PLANE_TL, TOP, pd->rDest.top) |
		FIELD_VALUE(0, VIDEO_PLANE_TL, LEFT, pd->rDest.left) |
		0);

	POKE_32(VIDEO_PLANE_BR, 
		FIELD_VALUE(0, VIDEO_PLANE_BR, BOTTOM, pd->rDest.bottom-1) |
		FIELD_VALUE(0, VIDEO_PLANE_BR, RIGHT, pd->rDest.right-1) |
		0);

	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(dwStartAdd)) |
		0);
	
	POKE_32(VIDEO_FB_0_LAST_ADDRESS, 
		FIELD_VALUE(0, VIDEO_FB_0_LAST_ADDRESS, EXT, m_SMISettings.m_bUMA) |
		FIELD_VALUE(0, VIDEO_FB_0_LAST_ADDRESS, ADDRESS, 0x03FFFFFF) |
		0);

	POKE_32(VIDEO_FB_WIDTH, 
		FIELD_VALUE(0, VIDEO_FB_WIDTH, WIDTH, dwSrcStride) |
		FIELD_VALUE(0, VIDEO_FB_WIDTH, OFFSET, dwSrcStride) |
		0);

	POKE_32(VIDEO_SCALE, 
		FIELD_VALUE(0, VIDEO_SCALE, VERTICAL_MODE, vmode) |
		FIELD_VALUE(0, VIDEO_SCALE, VERTICAL_SCALE, vstretch) |
		FIELD_VALUE(0, VIDEO_SCALE, HORIZONTAL_MODE, hmode) |
		FIELD_VALUE(0, VIDEO_SCALE, HORIZONTAL_SCALE, hstretch) |
		0);

	POKE_32(VIDEO_YUV_CONSTANTS, 
		FIELD_VALUE(0, VIDEO_YUV_CONSTANTS, Y, 0) |
		FIELD_VALUE(0, VIDEO_YUV_CONSTANTS, R, 0xED) |
		FIELD_VALUE(0, VIDEO_YUV_CONSTANTS, G, 0xED) |
		FIELD_VALUE(0, VIDEO_YUV_CONSTANTS, B, 0xED) |
		0);


	POKE_32(VIDEO_DISPLAY_CTRL,
		FIELD_SET(dwControl, VIDEO_DISPLAY_CTRL, PLANE, ENABLE)
		); 


//    RETAILMSG(1, (TEXT("SMI::-UudateOverlay\r\n")));
    pd->ddRVal = DD_OK;
    return DDHAL_DRIVER_HANDLED;
}

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

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

    if (pSrcSurf != m_pVisibleOverlay)
    {
        pd->ddRVal = DD_OK;
        return DDHAL_DRIVER_HANDLED;