halvpe.cpp

SM501基于ARMV4/ARMV4I平台

		}
    }

	pd->ddRVal = DD_OK;
	return DDHAL_DRIVER_HANDLED;
};

// SMI Implemented
DWORD WINAPI HalDestroyVideoPort(LPDDHAL_DESTROYVPORTDATA pd) {
/*
typedef struct _DDHAL_DESTROYVPORTDATA {
	LPDDRAWI_DIRECTDRAW_LCL     lpDD;		    // driver struct
	LPDDRAWI_DDVIDEOPORT_LCL    lpVideoPort;	    // Video port object
	HRESULT 		    ddRVal;		    // return value
	LPDDHALVPORTCB_DESTROYVPORT DestroyVideoPort;	    // PRIVATE: ptr to callback
} DDHAL_DESTROYVPORTDATA;

*/

	DEBUGENTER(HalDestroyVideoPort);

	((SMI *)g_pGPE)->VPE_Disable();
	((SMI *)g_pGPE)->VPE_DisableOverlayWindow();
	bVPEWeave = FALSE;

	pd->ddRVal = DD_OK;
	return DDHAL_DRIVER_NOTHANDLED;
};

// SMI Implemented
DWORD WINAPI HalGetVideoPortFlipStatus(LPDDHAL_GETVPORTFLIPSTATUSDATA pd) 
{
/*
typedef struct _DDHAL_GETVPORTFLIPSTATUSDATA {
	LPDDRAWI_DIRECTDRAW_LCL     lpDD;		    // driver struct
	FLATPTR 		    fpSurface;		    // surface struct
	HRESULT 		    ddRVal;		    // return value
	LPDDHALVPORTCB_GETFLIPSTATUS GetVideoPortFlipStatus; // PRIVATE: ptr to callback
} DDHAL_GETVPORTFLIPSTATUSDATA;
*/

	DEBUGENTER(HalGetVideoPortFlipStatus);
	//DebugBreak();

	DWORD dwBase = 	((SMI *)g_pGPE)->VPE_GetDst();

	if (dwBase == dwCurrentSurface)
	{
		pd->ddRVal = DD_OK;
	}
	else
	{
		pd->ddRVal = DDERR_WASSTILLDRAWING;
	}

	return DDHAL_DRIVER_HANDLED;
};

// SMI Implemented
DWORD WINAPI HalWaitForVideoPortSync(LPDDHAL_WAITFORVPORTSYNCDATA pd) 
{
/*
typedef struct _DDHAL_WAITFORVPORTSYNCDATA {
	LPDDRAWI_DIRECTDRAW_LCL     lpDD;		    // driver struct
	LPDDRAWI_DDVIDEOPORT_LCL    lpVideoPort;	    // Video port object
	DWORD			    dwFlags;		    // DDVPEVENT_XXXX
	DWORD			    dwLine;
	DWORD			    dwTimeOut;		    // Max time to wait before returning
	HRESULT 		    ddRVal;		    // return value
	LPDDHALVPORTCB_WAITFORSYNC  WaitForVideoPortSync;   // PRIVATE: ptr to callback
} DDHAL_WAITFORVPORTSYNCDATA;
*/
	DEBUGENTER(HalWaitForVideoPortSync);
//	DebugBreak();

	DWORD dwTime;
	if (pd->dwFlags == DDVPWAIT_BEGIN)
	{
		DEBUGMSG(GPE_ZONE_VPE,(TEXT("VPE_WaitForSync: DDVPWAIT_BEGIN\r\n")));

#ifndef DISABLE_INTERRUPT_MANAGEMENT
		pd->ddRVal = DDERR_VIDEONOTACTIVE;
		if (((SMI *)g_pGPE)->VPE_WaitForVSync(pd->dwTimeOut))
			pd->ddRVal = DD_OK;

		DEBUGMSG(GPE_ZONE_VPE,(TEXT("VPE_WaitForSync: DDVPWAIT_BEGIN---\r\n")));
#else
        // 
        // Wait for the beginning of the video VSYNC
        //
		dwTime = GetTickCount();
        if (((SMI *)g_pGPE)->VPE_IsVsync())
        {
            // VSYNC is already active, wait till VSYNC inactive first.
            while (((SMI *)g_pGPE)->VPE_IsVsync()) 
            {
                if (GetTickCount()-dwTime >= pd->dwTimeOut) 
                {
                    pd->ddRVal = DDERR_VIDEONOTACTIVE;
                    return DDHAL_DRIVER_HANDLED;
                }
            }
        }
            
        // now wait till vsync active.
        while (!(((SMI *)g_pGPE)->VPE_IsVsync())) 
        {
            if (GetTickCount()-dwTime >= pd->dwTimeOut) 
            {
            	pd->ddRVal = DDERR_VIDEONOTACTIVE;
                return DDHAL_DRIVER_HANDLED;
            }
        }
        pd->ddRVal = DD_OK;
#endif
	}
	else if (pd->dwFlags == DDVPWAIT_END)
	{
		DEBUGMSG(GPE_ZONE_VPE,(TEXT("VPE_WaitForSync: DDVPWAIT_END\r\n")));

        // 
        // Wait for the end of the video VSYNC
        // 
		dwTime = GetTickCount();

        if (!(((SMI *)g_pGPE)->VPE_IsVsync()))
        {
            // VSYNC is already inactive, wait till VSYNC active first.
            while (!(((SMI *)g_pGPE)->VPE_IsVsync())) 
            {
                if (GetTickCount()-dwTime >= pd->dwTimeOut) 
                {
                    pd->ddRVal = DDERR_VIDEONOTACTIVE;
                    return DDHAL_DRIVER_HANDLED;
                }
            }
        }
        
        // now wait till vsync inactive.
        while (((SMI *)g_pGPE)->VPE_IsVsync()) 
        {
            if (GetTickCount()-dwTime >= pd->dwTimeOut) {
            	pd->ddRVal = DDERR_VIDEONOTACTIVE;
                return DDHAL_DRIVER_HANDLED;
            }
        }
        pd->ddRVal = DD_OK;
	}
	else
	{
        pd->ddRVal = DDERR_UNSUPPORTED;
        return DDHAL_DRIVER_NOTHANDLED;
	}

    return DDHAL_DRIVER_HANDLED;
};

// SMI Implemented
DWORD WINAPI HalGetVideoSignalStatus(LPDDHAL_GETVPORTSIGNALDATA pd) 
{
/*
typedef struct _DDHAL_GETVPORTSIGNALDATA {
	LPDDRAWI_DIRECTDRAW_LCL     lpDD;		    // driver struct
	LPDDRAWI_DDVIDEOPORT_LCL    lpVideoPort;	    // Video port object
	DWORD			    dwStatus;		    // Video signal status
	HRESULT 		    ddRVal;		    // return value
	LPDDHALVPORTCB_GETSIGNALSTATUS GetVideoSignalStatus;// PRIVATE: ptr to callback
} DDHAL_GETVPORTSIGNALDATA;
*/

	DEBUGENTER(HalGetVideoSignalStatus);
//	DebugBreak();

	int wGUID = IsVPTypeSupported(&(pd->lpVideoPort->ddvpDesc.VideoPortType.guidTypeID));

    pd->ddRVal = DD_OK;
	if (wGUID == -1) {
		pd->dwStatus = DDVPSQ_NOSIGNAL;
		return DDHAL_DRIVER_HANDLED;
	}
	else if (!(((SMI *)g_pGPE)->VPE_IsEnable())) 
	{
		pd->dwStatus = DDVPSQ_NOSIGNAL;
		return DDHAL_DRIVER_HANDLED;
	}

	DWORD dwTimeOut = 2000; // 2 seconds
	DWORD dwTime = GetTickCount();
	BOOL bVsync = ((SMI *)g_pGPE)->VPE_IsVsync();
	while (((SMI *)g_pGPE)->VPE_IsVsync() == bVsync)
	{
		if (GetTickCount()-dwTime >= dwTimeOut)
		{
			pd->dwStatus = DDVPSQ_NOSIGNAL;
			return DDHAL_DRIVER_HANDLED;
		}
	}

	pd->dwStatus = DDVPSQ_SIGNALOK;

	return DDHAL_DRIVER_HANDLED;	
};

// SMI Implemented
DWORD WINAPI HalColorControl(LPDDHAL_VPORTCOLORDATA pd) 
{
/*
typedef struct _DDHAL_VPORTCOLORDATA {
	LPDDRAWI_DIRECTDRAW_LCL     lpDD;		    // driver struct
	LPDDRAWI_DDVIDEOPORT_LCL    lpVideoPort;	    // Video port object
	DWORD			    dwFlags;		    // Video signal status
	LPDDCOLORCONTROL	    lpColorData;
	HRESULT 		    ddRVal;		    // return value
	LPDDHALVPORTCB_COLORCONTROL ColorControl;	    // PRIVATE: ptr to callback
} DDHAL_VPORTCOLORDATA;
*/
	DEBUGENTER(HalColorControl);
//	DebugBreak();

	return DDHAL_DRIVER_NOTHANDLED;
};

// SMI Implemented
DWORD WINAPI HalUpdateVideoPort(LPDDHAL_UPDATEVPORTDATA pd) 
{
/*
typedef struct _DDHAL_UPDATEVPORTDATA {
	LPDDRAWI_DIRECTDRAW_LCL     lpDD;		    // driver struct
	LPDDRAWI_DDVIDEOPORT_LCL    lpVideoPort;	    // Video port object
	LPDDRAWI_DDRAWSURFACE_INT   *lplpDDSurface;	    // surface struct
	LPDDRAWI_DDRAWSURFACE_INT   *lplpDDVBISurface;	    // VBI surface structure
	LPDDVIDEOPORTINFO	    lpVideoInfo;	    // Video information
	DWORD			    dwFlags;		    // DDRAWI_VPORTSTART, DDRAWI_VPORTSTOP, DDRAWI_VPORTUPDATE
	DWORD			    dwNumAutoflip;	    // # of autoflip surfaces. If > 1, lpDDSurface and lpDDVBISurface are arrays.
	DWORD			    dwNumVBIAutoflip;	    // # of autoflip surfaces. If > 1, lpDDSurface and lpDDVBISurface are arrays.
	HRESULT 		    ddRVal;		    // return value
	LPDDHALVPORTCB_UPDATE	    UpdateVideoPort;	    // PRIVATE: ptr to callback
} DDHAL_UPDATEVPORTDATA;
*/

	DEBUGENTER(HalUpdateVideoPort);
	//DebugBreak();

	if (pd->dwFlags == DDRAWI_VPORTSTOP) 
	{
		// Turn off Video Port
		DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - VPE Stop\r\n")));
		((SMI *)g_pGPE)->VPE_Disable();
		pd->ddRVal = DD_OK;
		return DDHAL_DRIVER_HANDLED;
	}

	DWORD gate = FIELD_SET(0, CURRENT_POWER_GATE, ZVPORT, ENABLE);
	// Enable gate
	((SMI *)g_pGPE)->setGate(gate, gate);

	DEBUGMSG(GPE_ZONE_VPE,(TEXT("dwVPFlags = 0x%08X\r\n"),pd->lpVideoInfo->dwVPFlags));

	BOOL bDoubleBuffer = FALSE;
	if (pd->lpVideoInfo->dwVPFlags & DDVP_AUTOFLIP)
    {
		DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - DDVP_AUTOFLIP Set\r\n")));

		if (pd->dwNumAutoflip == 2)
		{
			if (!(pd->lpVideoInfo->dwVPFlags & DDVP_INTERLEAVE))
			{
				bDoubleBuffer = TRUE;
			}
			else
			{
				DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - DDVP_INTERLEAVE Set - UNSUPPORTED!\r\n")));
				pd->ddRVal = DDERR_UNSUPPORTED;
				return DDHAL_DRIVER_HANDLED;
			}

		}
#if 0 //ndef DISABLE_INTERRUPT_MANAGEMENT
		else if (pd->dwNumAutoflip <= MAX_FLIP_ENTRIES)
		{

			if (!(pd->lpVideoInfo->dwVPFlags & DDVP_INTERLEAVE))
			{
				bDoubleBuffer = TRUE;

			    DWORD dwStride = pd->lplpDDSurface[0]->lpLcl->lpGbl->lPitch;
			    DWORD dwBytesPerPixel = dwStride / pd->lplpDDSurface[0]->lpLcl->lpGbl->wWidth;
			    DWORD dwBaseOffset = dwBytesPerPixel * pd->lpVideoInfo->dwOriginX + dwStride * pd->lpVideoInfo->dwOriginY;
        
			    DWORD dwBuffer[MAX_FLIP_ENTRIES];
			    
			    dwBuffer[0] = pd->dwNumAutoflip;
			    for(DWORD i=0; i<dwBuffer[0]; i++)
   			 	{
        			DWORD DstOfs = pd->lplpDDSurface[i]->lpLcl->lpGbl->fpVidMem - (DWORD)g_pVideoMemory;
        			DstOfs += dwBaseOffset;
        			dwBuffer[i+1] = DstOfs;
    			}

    			((SMI *)g_pGPE)->VPE_InitSwAutoflip(dwBuffer);
    			((SMI *)g_pGPE)->VPE_SetDst(dwBuffer[1]);
    			((SMI *)g_pGPE)->VPE_SetDst2(dwBuffer[1]);
			}
			else
			{
				DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - DDVP_INTERLEAVE Set - UNSUPPORTED!\r\n")));
				pd->ddRVal = DDERR_UNSUPPORTED;
				return DDHAL_DRIVER_HANDLED;
			}
		}
#endif
		else
		{
			DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - Unsupported dwAutoflipNum!\r\n")));
			pd->ddRVal = DDERR_UNSUPPORTED;
			return DDHAL_DRIVER_HANDLED;

		}
    }

	//when they STOP VIDEOPORT, lplpDDSurface is NULL :-)
	LPDDRAWI_DDRAWSURFACE_INT	pDstInt = *pd->lplpDDSurface;
	LPDDRAWI_DDRAWSURFACE_LCL	pDstSurfLcl = pDstInt->lpLcl;
	LPDDRAWI_DDRAWSURFACE_GBL	pDstSurfGbl = pDstSurfLcl->lpGbl;

	//WORD wDstBytePP = (WORD)(pd->lpVideoInfo->lpddpfInputFormat->dwYUVBitCount / 8);
	WORD wDstBytePP = 2;	//SMI VPE is always 16 bit width
    //WORD wDstStride = pDstSurfGbl->wWidth * wDstBytePP;
	WORD wDstPitch	= (WORD)pDstSurfGbl->lPitch;

	bVPEWeave = FALSE;
	if (pd->lpVideoInfo->dwVPFlags & DDVP_INTERLEAVE) 
	{
		// Special case - Double buffer for weave mode
		DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - DDVP_INTERLEAVE Set\r\n")));
		bVPEWeave = TRUE;
	}

	if (pd->dwFlags != DDRAWI_VPORTUPDATE &&
		pd->dwFlags != DDRAWI_VPORTSTART) 
	{
		DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - Unknown dwFlags\r\n")));
		pd->ddRVal = DDERR_UNSUPPORTED;
		return DDHAL_DRIVER_NOTHANDLED;
	}

	DWORD dwMode = 0;

	// Disable BOB mode interlaced
	((SMI *)g_pGPE)->VPE_DisableBOB();
    if (pd->lpVideoPort->ddvpDesc.VideoPortType.dwFlags & DDVPCONNECT_INTERLACED) 
    {
		DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - DDVPCONNECT_INTERLACED Set\r\n")));
		//dwMode = FIELD_SET(dwMode, CAPTURE_CONTROL, INTERLACE, ENABLE);
    }

    if (pd->lpVideoInfo->dwVPFlags & DDVP_SKIPEVENFIELDS)
    {
		DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - DDVP_SKIPEVENFIELDS Set\r\n")));
        //dwMode |= VPE_CAP_SKIP_EVEN;
        //
        // some VPE client set both skip field and DoubleBuffer flag at the
        // same time. This violates VPE rules. We simply ignore the DoubleBuffer
	    // flag here and use only one hardware buffer.
        //
        bDoubleBuffer = FALSE;
    }
    if (pd->lpVideoInfo->dwVPFlags & DDVP_SKIPODDFIELDS)
    {
		DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - DDVP_SKIPODDFIELDS Set\r\n")));
        //dwMode |= VPE_CAP_SKIP_ODD;
        //
        // some VPE client set both skip field and auto flip flag at the
        // same time. This violates VPE rules. We simply ignore the auto
        // flip flag here and use only one hardware buffer.
        //
       bDoubleBuffer = FALSE;
    }

	// Seems most VPE needs byte swap
	dwMode = FIELD_SET(dwMode, CAPTURE_CONTROL, BYTE_SWAP, ENABLE);	

    int wGUID = IsVPTypeSupported(&(pd->lpVideoPort->ddvpDesc.VideoPortType.guidTypeID));
	switch(wGUID)
	{
/*
		case VPE_CCIR656:
			DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - DDVPTYPE_CCIR656\r\n")));
			break;
		case VPE_BROOKTREE:
			DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - DDVPTYPE_BROOKTREE\r\n")));
			break;
*/
		case VPE_PHILIPS:
			DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - DDVPTYPE_PHILIPS\r\n")));
			dwMode = FIELD_SET(dwMode, CAPTURE_CONTROL, HREF_PHASE, ACTIVE_LOW);
			dwMode = FIELD_SET(dwMode, CAPTURE_CONTROL, VSYNC_PHASE, ACTIVE_HIGH);
			dwMode = FIELD_SET(dwMode, CAPTURE_CONTROL, FIELD_DETECT, FALLING);
			break;
		case VPE_E_HREFH_VREFL:
			DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - DDVPTYPE_E_HREFH_VREFL\r\n")));
			dwMode = FIELD_SET(dwMode, CAPTURE_CONTROL, HREF_PHASE, ACTIVE_HIGH);
			dwMode = FIELD_SET(dwMode, CAPTURE_CONTROL, VSYNC_PHASE, ACTIVE_LOW);
			dwMode = FIELD_SET(dwMode, CAPTURE_CONTROL, FIELD_DETECT, FALLING);
			break;
		case VPE_E_HREFH_VREFH:
			DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - DDVPTYPE_E_HREFH_VREFH\r\n")));
			dwMode = FIELD_SET(dwMode, CAPTURE_CONTROL, HREF_PHASE, ACTIVE_HIGH);
			dwMode = FIELD_SET(dwMode, CAPTURE_CONTROL, VSYNC_PHASE, ACTIVE_HIGH);
			dwMode = FIELD_SET(dwMode, CAPTURE_CONTROL, FIELD_DETECT, FALLING);
			break;
		case VPE_E_HREFL_VREFL:
			DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - DDVPTYPE_E_HREFL_VREFL\r\n")));
			dwMode = FIELD_SET(dwMode, CAPTURE_CONTROL, HREF_PHASE, ACTIVE_LOW);
			dwMode = FIELD_SET(dwMode, CAPTURE_CONTROL, VSYNC_PHASE, ACTIVE_LOW);
			dwMode = FIELD_SET(dwMode, CAPTURE_CONTROL, FIELD_DETECT, FALLING);
 			break;
		case VPE_E_HREFL_VREFH:
			DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - DDVPTYPE_E_HREFL_VREFH\r\n")));