dispperf.h

Lido PXA270平台开发板的最新BSP,包括源代码

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
/*******************************************************************************
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.

DISPPERF.H

*******************************************************************************/

#ifndef _DISPPERF_H_
#define _DISPPERF_H_

#ifdef __cplusplus
extern "C" {
#endif

#ifdef DO_DISPPERF  
    
#ifdef DISPPERF_DECLARE
#define DISPPERF_EXTERN
#else
#define DISPPERF_EXTERN extern
#endif

#define MAX_BLT_PARAMS			8

#define PARAM_COLLOOKUP				0
#define PARAM_COLCONVERT			1
#define PARAM_SRCINVIDMEM			2
#define PARAM_DESTINVIDMEM			3
#define PARAM_COLORBLACK			4
#define PARAM_COLORWHITE			5
#define PARAM_STRETCH				6
#define PARAM_TRANSPARENT			7

#ifdef DISPPERF_DECLARE
DISPPERF_EXTERN WCHAR *apszBltParam[] = 
{
	L"Color Lookup",
	L"Color Convert",
	L"Src In Video Mem",
	L"Dest In Video Mem",
	L"Color Black",
	L"Color White",
	L"Stretch Blt",
	L"Transparent Blt"
};
#else
DISPPERF_EXTERN WCHAR apszBltParam;
#endif 

typedef struct _DISPPERF_TIMING
{
    DWORD   RopCode;
    DWORD   cGPE;
    DWORD   dwGPETime;
    DWORD   cEmul;
    DWORD   dwEmulTime;
    DWORD   dwEmulSyncTime;
    DWORD   dwEmulSlaveportTime;
    DWORD	dwEmulPixDrawn;
        
	DWORD   cHardware;
    DWORD   dwHardwareTime;
    DWORD   dwHardwareSyncTime;
    DWORD   dwHardwareSlaveportTime;

	DWORD   cUpload;
    DWORD   dwHardwareUploadTime;
    DWORD   dwHardwareMiscSetupTime;
    DWORD	dwHardwarePixDrawn;

	DWORD	dwWaitTime;
	DWORD	dwBltParams[MAX_BLT_PARAMS];
} DISPPERF_TIMING, *PDISPPERF_TIMING;

// The global variables used
DISPPERF_EXTERN DWORD   v_dwDPTimerStart;
#ifdef DISPPERF_DECLARE
DISPPERF_EXTERN DWORD   v_dwCurRop = -1;
#else
DISPPERF_EXTERN DWORD   v_dwCurRop;
#endif
DISPPERF_EXTERN DWORD   v_dwAccelType;
DISPPERF_EXTERN DWORD   v_dwLastRop;
DISPPERF_EXTERN DWORD   v_dwUnhandled;
DISPPERF_EXTERN DWORD   v_dwTimerStart;
DISPPERF_EXTERN DWORD   v_dwWaitTimer;
DISPPERF_EXTERN DWORD	v_dwPrevRop;
DISPPERF_EXTERN DWORD   v_dwUploadTimer;
DISPPERF_EXTERN DWORD   v_dwSlaveportTimer;

#ifndef NUM_ROP_TIMES
#define NUM_ROP_TIMES   32
#endif

#define DP_STACK_DEPTH 2

//#ifdef DISPPERF_DECLARE
//DISPPERF_EXTERN DISPPERF_CONTEXT DPContext[DP_STACK_DEPTH] = {{-1,0,0,0}, {-1,0,0,0}};
//DISPPERF_EXTERN long			 v_lContextID = 0;
//#else
//DISPPERF_EXTERN DISPPERF_CONTEXT DPContext[DP_STACK_DEPTH];
//DISPPERF_EXTERN long			 v_lContextID;
//#endif
//
//#define CONTEXT(var)			DPContext[v_lContextID].var

DISPPERF_EXTERN DISPPERF_TIMING v_dptData[NUM_ROP_TIMES];

#define DISPPERF_ACCEL_GPE          0
#define DISPPERF_ACCEL_EMUL         1
#define DISPPERF_ACCEL_HARDWARE     2

// Let's define some temporary ROP's for line etc.
#define ROP_LINE                0xFEFEFFF1  
#define ROP_MOVE_CURSOR         0xFEFEFFF2
#define ROP_SET_POINTER_SHP     0xFEFEFFF3

// Let's define the ExtEscape codes for this.
#define DISPPERF_EXTESC_GETSIZE         0xFEFEFFF0
#define DISPPERF_EXTESC_GETTIMING       0xFEFEFFF1
#define DISPPERF_EXTESC_CLEARTIMING     0xFEFEFFF2
#define DISPPERF_EXTESC_GETUNHANDLED    0xFEFEFFF3

//call checking
#define SYNC_TIMER 			0x1
#define UPLOAD_TIMER 		0x2
#define SLAVEPORT_TIMER 	0x4
#define MISC_TIMER			0x8
static bDPState = 0;


__inline void DispPerfPush ()
{
//	ASSERT (v_lContextID < (DP_STACK_DEPTH - 1));
    ASSERT (v_dwCurRop != -1);

//	v_lContextID++;

    ASSERT (v_dwCurRop == -1);
}

__inline void DispPerfPop ()
{
//	ASSERT (v_lContextID > 0);
    ASSERT (v_dwCurRop == -1);

//	v_lContextID--;

    ASSERT (v_dwCurRop != -1);
}

__inline void DispPerfStart (DWORD RopCode)
{
    LARGE_INTEGER   LargeInt;
        
	// Check to see if we get re-entered
    ASSERT (v_dwCurRop == -1);
	ASSERT (bDPState==0);
	
    for (v_dwCurRop = 0; v_dwCurRop < NUM_ROP_TIMES; v_dwCurRop++)
	{
        if (v_dptData[v_dwCurRop].RopCode == RopCode)
		{
            break;
        }
    }
    if (NUM_ROP_TIMES == v_dwCurRop)
	{
        // Is there room for another rop?
        for (v_dwCurRop = 0; v_dwCurRop < NUM_ROP_TIMES; v_dwCurRop++)
		{
            if ((0 == v_dptData[v_dwCurRop].RopCode) &&
                (0 == v_dptData[v_dwCurRop].cGPE) &&
                (0 == v_dptData[v_dwCurRop].cEmul) &&
                (0 == v_dptData[v_dwCurRop].cHardware))
			{
                v_dptData[v_dwCurRop].RopCode = RopCode;
                break;
            }
        }
        // No room, Save the last ROP code
        if (NUM_ROP_TIMES == v_dwCurRop)
		{
            v_dwLastRop = v_dptData[v_dwCurRop].RopCode;
            v_dwCurRop = -1;
        }
    }
    QueryPerformanceCounter (&LargeInt);
    
    v_dwTimerStart = LargeInt.LowPart;
    v_dwAccelType = DISPPERF_ACCEL_GPE;
}

__inline VOID DispPerfSync(BOOL StartSync)
{
    LARGE_INTEGER LargeInt;
	DWORD           dwOpTime;

	ASSERT (v_dwCurRop != -1);

	QueryPerformanceCounter (&LargeInt);
	dwOpTime = LargeInt.LowPart - v_dwTimerStart;

	if(StartSync)
	{
		ASSERT(bDPState==0);
		bDPState |= SYNC_TIMER;
	}
	else	
	{
		ASSERT(bDPState==SYNC_TIMER);
		bDPState &= ~SYNC_TIMER;
	}

	if (v_dwAccelType == DISPPERF_ACCEL_EMUL)
	{
		if (!StartSync)
		{
			v_dptData[v_dwCurRop].dwEmulSyncTime += dwOpTime;
		}
		else
		{
			v_dptData[v_dwCurRop].dwEmulTime += dwOpTime;
		}
	}
	else if (v_dwAccelType == DISPPERF_ACCEL_HARDWARE)
	{
		if (!StartSync)
		{
			v_dptData[v_dwCurRop].dwHardwareSyncTime += dwOpTime;
		}
		else
		{
			v_dptData[v_dwCurRop].dwHardwareTime += dwOpTime;
		}
	}
	else
	{
		DebugBreak ();
	}

//	v_dwTimerStart = LargeInt.LowPart;
}

__inline VOID DispPerfPixelsDrawn(DWORD dwPixels)
{
	ASSERT (v_dwCurRop != -1);

	if (v_dwAccelType == DISPPERF_ACCEL_HARDWARE)
	{
		v_dptData[v_dwCurRop].dwHardwarePixDrawn += dwPixels;
	}
	else
	{
		v_dptData[v_dwCurRop].dwEmulPixDrawn += dwPixels;
	}
}

__inline VOID DispPerfUpload(BOOL Start)
{
    LARGE_INTEGER LargeInt;
//	DWORD           dwOpTime;

	ASSERT (v_dwCurRop != -1);
	ASSERT (v_dwAccelType == DISPPERF_ACCEL_HARDWARE);

	QueryPerformanceCounter (&LargeInt);
//	dwOpTime = LargeInt.LowPart - CONTEXT(v_dwTimerStart);

	if(Start)
	{
		ASSERT(bDPState==0);
		bDPState |= UPLOAD_TIMER;
	}
	else	
	{
		ASSERT(bDPState==UPLOAD_TIMER);
		bDPState &= ~UPLOAD_TIMER;
	}

	if (Start)
	{
//		v_dptData[CONTEXT(v_dwCurRop)].dwHardwareSetupTime += dwOpTime;
		v_dwUploadTimer = LargeInt.LowPart;
	}
	else
	{
		v_dwUploadTimer = LargeInt.LowPart - v_dwUploadTimer;
		v_dptData[v_dwCurRop].dwHardwareUploadTime += v_dwUploadTimer;
		v_dptData[v_dwCurRop].cUpload++;
	}

//	v_dwTimerStart = LargeInt.LowPart;
}
__inline VOID DispPerfSlaveport(BOOL Start)
{
    LARGE_INTEGER LargeInt;
//	DWORD           dwOpTime;

	ASSERT (v_dwCurRop != -1);
	ASSERT ((v_dwAccelType == DISPPERF_ACCEL_HARDWARE) ||
			(v_dwAccelType == DISPPERF_ACCEL_EMUL));

	QueryPerformanceCounter (&LargeInt);
//	dwOpTime = LargeInt.LowPart - CONTEXT(v_dwTimerStart);

	if(Start)
	{
		ASSERT(bDPState==0);
		bDPState |= SLAVEPORT_TIMER;
	}
	else	
	{
		ASSERT(bDPState==SLAVEPORT_TIMER);
		bDPState &= ~SLAVEPORT_TIMER;
	}
	
	if (Start)
	{
//		if (CONTEXT(v_dwAccelType) == DISPPERF_ACCEL_HARDWARE)
//		{
//			v_dptData[CONTEXT(v_dwCurRop)].dwHardwareSetupTime += dwOpTime;
//		}
//		else
//		{
//			v_dptData[CONTEXT(v_dwCurRop)].dwEmulSetupTime += dwOpTime;
//		}
		v_dwSlaveportTimer = LargeInt.LowPart;
	}
	else
	{
		v_dwSlaveportTimer = LargeInt.LowPart - v_dwSlaveportTimer;
		if (v_dwAccelType == DISPPERF_ACCEL_HARDWARE)
		{
			v_dptData[v_dwCurRop].dwHardwareSlaveportTime += v_dwSlaveportTimer;
		}
		else
		{
			v_dptData[v_dwCurRop].dwEmulSlaveportTime += v_dwSlaveportTimer;
		}
	}

//	v_dwTimerStart = LargeInt.LowPart;
}


__inline VOID DispPerfMiscSetup(BOOL Start)
{
    LARGE_INTEGER LargeInt;
	DWORD         dwOpTime;

	ASSERT (v_dwCurRop != -1);
	ASSERT (v_dwAccelType == DISPPERF_ACCEL_HARDWARE);

	QueryPerformanceCounter (&LargeInt);
	dwOpTime = LargeInt.LowPart - v_dwTimerStart;

	if(Start)
	{
		ASSERT(bDPState==0);
		bDPState |= MISC_TIMER;
	}
	else	
	{
		ASSERT(bDPState==MISC_TIMER);
		bDPState &= ~MISC_TIMER;
	}

	if (Start)
	{
		v_dptData[v_dwCurRop].dwHardwareTime += dwOpTime;
	}
	else
	{
		v_dptData[v_dwCurRop].dwHardwareMiscSetupTime += dwOpTime;
	}

	v_dwTimerStart = LargeInt.LowPart;
}


__inline VOID DispPerfType(DWORD Type)
{
//    ASSERT (v_dwCurRop != -1);

//	if (!((v_dwAccelType == DISPPERF_ACCEL_HARDWARE) && (Type == DISPPERF_ACCEL_EMUL)) &&
//		!((v_dwAccelType == DISPPERF_ACCEL_EMUL) && (Type == DISPPERF_ACCEL_HARDWARE)) &&
//		!((v_dwAccelType == DISPPERF_ACCEL_HARDWARE) && (Type == DISPPERF_ACCEL_HARDWARE)))
//	{
//		ASSERT (v_dwAccelType == DISPPERF_ACCEL_GPE);
//	}

	v_dwAccelType = Type;
}

__inline VOID DispPerfBeginWait()
{
	LARGE_INTEGER LargeInt;
	QueryPerformanceCounter(&LargeInt);
	v_dwWaitTimer = LargeInt.LowPart;
}

__inline VOID DispPerfEndWait()
{
 //	if (v_dwCurRop != -1)
	{
		LARGE_INTEGER LargeInt;
		QueryPerformanceCounter(&LargeInt);
		v_dwWaitTimer = LargeInt.LowPart - v_dwWaitTimer;
//		v_dptData[v_dwCurRop].dwWaitTime += v_dwWaitTimer;
	}

}

__inline VOID DispPerfParam(GPEBltParms *pBltParams)
{
	ASSERT(pBltParams);
	if (v_dwCurRop != -1) {
		if (pBltParams->pLookup)
			v_dptData[v_dwCurRop].dwBltParams[PARAM_COLLOOKUP]++;
		if (pBltParams->pConvert)
			v_dptData[v_dwCurRop].dwBltParams[PARAM_COLCONVERT]++;
		if (pBltParams->pSrc && pBltParams->pSrc->InVideoMemory())
			v_dptData[v_dwCurRop].dwBltParams[PARAM_SRCINVIDMEM]++;
		if (pBltParams->pDst && pBltParams->pDst->InVideoMemory())
			v_dptData[v_dwCurRop].dwBltParams[PARAM_DESTINVIDMEM]++;
		if (pBltParams->solidColor == 0x0)
			v_dptData[v_dwCurRop].dwBltParams[PARAM_COLORBLACK]++;
		if (pBltParams->solidColor == -1)
			v_dptData[v_dwCurRop].dwBltParams[PARAM_COLORWHITE]++;
		if (pBltParams->bltFlags & BLT_STRETCH)
			v_dptData[v_dwCurRop].dwBltParams[PARAM_STRETCH]++;
		if (pBltParams->bltFlags & BLT_TRANSPARENT)
			v_dptData[v_dwCurRop].dwBltParams[PARAM_TRANSPARENT]++;
	}
}

__inline VOID DispPerfEnd(DWORD arg)
{
    LARGE_INTEGER LargeInt;
    DWORD           dwOpTime;
    
	ASSERT (v_dwCurRop != -1);
	ASSERT (bDPState==0);
	
	QueryPerformanceCounter (&LargeInt);
    dwOpTime = LargeInt.LowPart - v_dwTimerStart;
    switch (v_dwAccelType)
	{
        case DISPPERF_ACCEL_GPE :
            v_dptData[v_dwCurRop].cGPE++;
            v_dptData[v_dwCurRop].dwGPETime += dwOpTime;
            break;
		case DISPPERF_ACCEL_EMUL :
			v_dptData[v_dwCurRop].cEmul++;
			v_dptData[v_dwCurRop].dwEmulTime += dwOpTime;
			break;
		case DISPPERF_ACCEL_HARDWARE :
			v_dptData[v_dwCurRop].cHardware++;
			v_dptData[v_dwCurRop].dwHardwareTime += dwOpTime;
//			if (dwOpTime > 30000)
//			{
//				ASSERT (v_dptData[v_dwCurRop].RopCode != 0xCCCC);
//			}
			break;
		default:
			DebugBreak();
			break;
    }

	v_dwPrevRop = v_dwCurRop;
    v_dwCurRop = -1;
	v_dwAccelType = DISPPERF_ACCEL_GPE;
}

__inline int DispPerfQueryEsc(DWORD SupportChk)
{
    if ((SupportChk == DISPPERF_EXTESC_GETSIZE) ||
        (SupportChk == DISPPERF_EXTESC_GETTIMING) ||
        (SupportChk == DISPPERF_EXTESC_CLEARTIMING) ||  
        (SupportChk == DISPPERF_EXTESC_GETUNHANDLED))
	{
        return 1;
    }
    return 0;
}
__inline int DispPerfDrvEscape (ULONG iEsc, ULONG cjIn, PVOID pvIn,
                               ULONG cjOut, PVOID pvOut)
{
    int RetVal;
    switch (iEsc) {
        case  DISPPERF_EXTESC_GETSIZE:
            if ((cjOut >= sizeof(DWORD)) && (pvOut != NULL))
			{
                *(DWORD *)pvOut = sizeof(v_dptData);
                RetVal = 1;
            }
			else
			{
                SetLastError (ERROR_INVALID_PARAMETER);
                RetVal = -1;
            }
            break;

        case  DISPPERF_EXTESC_GETTIMING:
            if ((cjOut >= sizeof(v_dptData)) && (pvOut != NULL))
			{
                memcpy ((char *)pvOut, (char *)v_dptData, sizeof(v_dptData));
                RetVal = 1;
            }
			else
			{
                SetLastError (ERROR_INVALID_PARAMETER);
                RetVal = -1;
            }
            break;

        case  DISPPERF_EXTESC_CLEARTIMING:
            memset (v_dptData, 0, sizeof(v_dptData));
            RetVal = 1;
            break;

        case  DISPPERF_EXTESC_GETUNHANDLED:
            if ((cjOut >= sizeof(DWORD)) && (pvOut != NULL)) {
                *(DWORD *)pvOut = v_dwUnhandled;
                RetVal = 1;
            } else {
                SetLastError (ERROR_INVALID_PARAMETER);
                RetVal = -1;
            }
            break;

        default :
            SetLastError (ERROR_INVALID_PARAMETER);
            RetVal = -1;
            break;
    }
    return RetVal;
}


#else // DO_DISPPERF

#define DispPerfStart(x)    (0)
#define DispPerfType(x)     (0)
#define DispPerfEnd(x)      (0)
#define DispPerfQueryEsc(x) (0)
#define DispPerfDrvEscape(e,ci,pi,co,po) (0)
#define DispPerfSync(x);
#define DispPerfUpload(x);
#define DispPerfSlaveport(x);
#define DispPerfBeginWait() (0)
#define DispPerfEndWait()	(0)
#define DispPerfParam(x)     (0)

#endif // DO_DISPPERF


#ifdef __cplusplus
}
#endif

#endif // ifndef _DISPPERF_H_