decoder.c

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

					ui32PixelFormatValid = IMG_TRUE;
			}
		}
	}

	if (ui32PixelFormatValid == IMG_FALSE)
	{
		return M24VAError_GenericError;
	}

	/* The calling application wishes to use DirectDraw. */
	pSurface->bDirectDrawActive = IMG_TRUE;

	/* Return the newly created INT_SM_HANDLE to the caller. */
	*phSurface = (SMSurface) pSurface;

	memset(&DDSurfaceDesc, 0, sizeof(DDSURFACEDESC2));
	hRet = IDirectDrawSurface_Lock(pDDSurface, NULL, &DDSurfaceDesc, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT | DDLOCK_READONLY, NULL);

	if (hRet != DD_OK)
	{
		return M24VAError_GenericError;
	}

	pSurface->ui32FBOffset	= *((IMG_UINT32*) DDSurfaceDesc.lpSurface);
	hRet = IDirectDrawSurface_Unlock(pDDSurface, NULL);

	if (hRet != DD_OK)
	{
		return M24VAError_GenericError;
	}

	pSurface->pui8LinAddress = NULL;
	pSurface->psMemInfo = NULL;

	return(M24VAError_OK);
}

/***********************************************************************************
 Function Name      : M24VA_FreeSMHandle
 Inputs             : hSurface
                      
 Outputs            : 
 Returns            : M24VAError
 Description        : Called by a DirectDraw application to free an INT_SM_HANDLE.
************************************************************************************/
M24VAError PVRAPI M24VA_FreeSMHandle(SMSurface hSurface)
{
	PINT_SM_HANDLE pSurface = (PINT_SM_HANDLE) hSurface;

	free(pSurface);
	return(M24VAError_OK);
}

/*****************************************************************************
 FUNCTION	: M24VA_FCFrameAllocate
    
 PURPOSE	: Allocate surface to act as destination of frame convert.

 PARAMETERS	: 
			  
 RETURNS	: M24VAError

 Notes		: 
*****************************************************************************/
M24VAError PVRAPI M24VA_FCFrameAllocate(SMSurface *phFrame, M24VA_SURF_FORMAT eFormat)
{
	PINT_SM_HANDLE pSurface;

	pSurface = M24VA_FRAMEALLOCATE(g_M24VAState.ui32Width, 
								   g_M24VAState.ui32Height, 
								   eFormat);

	if(!pSurface)
	{
		return(M24VAError_OutOfMemory);
	}

	*phFrame = (SMSurface) pSurface;

	return(M24VAError_OK);
}

/*********************************************************** Debug Functions */


/*****************************************************************************
 FUNCTION	: M24VA_GetStats
    
 PURPOSE	: Returns stats on writes to registers and slave ports

 PARAMETERS	: 
			  
 RETURNS	: nothing

 Notes		: 
*****************************************************************************/

void PVRAPI M24VA_GetStats(IMG_UINT32 *pui32IDCTAccessCount,
					       IMG_UINT32 *pui32RegAccessCount,
					       IMG_UINT32 *pui32CmdCount)
{
#ifdef DEBUG_MODE
	*pui32RegAccessCount	= g_M24VAState.ui32RegAccessCount;
	*pui32IDCTAccessCount	= g_M24VAState.sIDCTSlavePort.ui32AccessCount;
	*pui32CmdCount			= g_M24VAState.sCMDSlavePort.ui32AccessCount;
#else
	*pui32RegAccessCount	= 0;
	*pui32IDCTAccessCount	= 0;
	*pui32CmdCount			= 0;
#endif
}

/*****************************************************************************
 FUNCTION	: M24VA_GetSlavePortStats
    
 PURPOSE	: Returns stats on Cmd slave port

 PARAMETERS	: 
			  
 RETURNS	: nothing

 Notes		: 
*****************************************************************************/

void PVRAPI M24VA_GetSlavePortStats(IMG_UINT32 ui32SlavePortType,
									IMG_UINT32 *pui32CmdCount,
									IMG_UINT32 *pui32CmdPolls,
									IMG_UINT32 *pui32CmdTrys,
									IMG_UINT32 *pui32CmdOverflows)
{
#ifdef DEBUG_MODE
	switch(ui32SlavePortType)
	{
		case 1: 
			*pui32CmdCount			= g_M24VAState.sCMDSlavePort.ui32AccessCount;
			*pui32CmdPolls			= g_M24VAState.sCMDSlavePort.ui32Polls;
			*pui32CmdTrys			= g_M24VAState.sCMDSlavePort.ui32Trys;
			*pui32CmdOverflows		= g_M24VAState.sCMDSlavePort.ui32Overflows;
			break;

		case 2: 
			*pui32CmdCount			= g_M24VAState.sIDCTSlavePort.ui32AccessCount;
			*pui32CmdPolls			= g_M24VAState.sIDCTSlavePort.ui32Polls;
			*pui32CmdTrys			= g_M24VAState.sIDCTSlavePort.ui32Trys;
			*pui32CmdOverflows		= g_M24VAState.sIDCTSlavePort.ui32Overflows;
			break;

		case 3: 
			*pui32CmdCount			= g_M24VAState.sIZZSlavePort.ui32AccessCount;
			*pui32CmdPolls			= g_M24VAState.sIZZSlavePort.ui32Polls;
			*pui32CmdTrys			= g_M24VAState.sIZZSlavePort.ui32Trys;
			*pui32CmdOverflows		= g_M24VAState.sIZZSlavePort.ui32Overflows;
			break;

		case 4: 
			*pui32CmdCount			= g_M24VAState.ui32FlushCount;
			*pui32CmdPolls			= g_M24VAState.ui32InterruptPolls;
			*pui32CmdTrys			= g_M24VAState.ui32InterruptTrys;
			*pui32CmdOverflows		= g_M24VAState.ui32InterruptOverflows;
			break;

		default:
			*pui32CmdCount		= 0;
			*pui32CmdPolls		= 0;
			*pui32CmdTrys		= 0;
			*pui32CmdOverflows	= 0;
			break;
	}

#else
	*pui32CmdCount		= 0;
	*pui32CmdPolls		= 0;
	*pui32CmdTrys		= 0;
	*pui32CmdOverflows	= 0;
#endif
}

/*****************************************************************************
 FUNCTION	: M24VA_SetScriptMode
    
 PURPOSE	: Set the script mode

 PARAMETERS	: 
			  
 RETURNS	: nothing

 Notes		: 
*****************************************************************************/

void PVRAPI M24VA_SetScriptMode(IMG_UINT32 ui32ScriptMode)				
{
#ifdef DEBUG_MODE

	switch(ui32ScriptMode)
	{
		case 0: g_eScriptMode = M24VA_NoScript;		break;	/* Do not generate script */
		case 1: g_eScriptMode = M24VA_LogAccesses;	break;	/* Use h/w log, in script, accesses */
	}

#endif
}

/*****************************************************************************
 FUNCTION	: M24VA_SimScriptOpen
    
 PURPOSE	: Open log file

 PARAMETERS	: 
			  
 RETURNS	: IMG_BOOL - success

 Notes		: 
*****************************************************************************/

IMG_BOOL PVRAPI M24VA_SimScriptOpen(char *pszFileName, int Wipe)
{
#ifdef DEBUG_MODE
	if(g_pfLogFile)
	{
		return(TRUE); 		/* already open */
	}
	
	strcpy(g_szLogFileName, pszFileName);

	if(Wipe)
	{
		g_pfLogFile = fopen(g_szLogFileName,"w");
	}
	else
	{
		g_pfLogFile = fopen(g_szLogFileName,"a");
	}

	return(g_pfLogFile ? TRUE : FALSE);
#else
	return(FALSE);
#endif
}

/*****************************************************************************
 FUNCTION	: M24VA_SimScriptClose
    
 PURPOSE	: Closes SIM script

 PARAMETERS	: 
			  
 RETURNS	: nothing

 Notes		: 
*****************************************************************************/

void PVRAPI M24VA_SimScriptClose()
{
#ifdef DEBUG_MODE
	fclose(g_pfLogFile);
	g_pfLogFile = NULL;
#endif
}

/*****************************************************************************
 FUNCTION	: M24VA_SimScriptFlush
    
 PURPOSE	: Flushes SIM script

 PARAMETERS	: 
			  
 RETURNS	: nothing

 Notes		: 
*****************************************************************************/

void PVRAPI M24VA_SimScriptFlush()
{
#ifdef DEBUG_MODE
	M24VA_SimScriptClose();
	M24VA_SimScriptOpen(g_szLogFileName,0);
#endif
}

/*****************************************************************************
 FUNCTION	: M24VA_SimScriptLog
    
 PURPOSE	: Outputs text to the sim script

 PARAMETERS	: 
			  
 RETURNS	: nothing

 Notes		: 
*****************************************************************************/

void PVRAPI M24VA_SimScriptLog(char *str,...)
{
#ifdef DEBUG_MODE
	if(g_pfLogFile)
	{
		va_list argptr;
 
		va_start(argptr,str);

		vfprintf(g_pfLogFile,str,argptr); /* diagnostic message to file */

		va_end(argptr);
	}

#endif 
}

/*****************************************************************************/
/************************** Generic utility functions ************************/
/*****************************************************************************/

/* Note the following function is only called when we already have the device lock */
void UpdateSPFreeCounters()
{
	IMG_UINT32	ui32RegStat;

	ui32RegStat = M24VA_READREG(M24VAREG_BUF_STATE);
		
	/* Calculate free space in DWORD units */
	g_M24VAState.sCMDSlavePort.iu32SPFree	= ((M24VA_CMD_FIFO_SIZE - ((ui32RegStat & M24VA_BUFSTATE_COM_COUNT_MASK)  >> M24VA_BUFSTATE_COM_COUNT_SHIFT)) * 2);
	g_M24VAState.sIDCTSlavePort.iu32SPFree	= ((M24VA_IDCT_FIFO_SIZE - ((ui32RegStat & M24VA_BUFSTATE_IDCT_COUNT_MASK) >> M24VA_BUFSTATE_IDCT_COUNT_SHIFT)) * 2);
	g_M24VAState.sIZZSlavePort.iu32SPFree	= ((M24VA_IZZ_FIFO_SIZE - ((ui32RegStat & M24VA_BUFSTATE_IZZ_COUNT_MASK) >> M24VA_BUFSTATE_IZZ_COUNT_SHIFT)) * 2);

}

/*****************************************************************************/
/**************** Internel functions (WinCE drivers) *************************/
/*****************************************************************************/

/*****************************************************************************
 FUNCTION	: M24VA_ReadReg
    
 PURPOSE	: Wrapper for hardware register access

 PARAMETERS	: 
			  
 RETURNS	: nothing

 Notes		: 
*****************************************************************************/

static DWORD M24VA_ReadReg(DWORD dwAddr)
{
#ifndef INIFINTELY_FAST_HW
	return(g_M24VAState.pRegisters[dwAddr / sizeof(IMG_UINT32)]);
#else
	return 0;
#endif
}


/*****************************************************************************
 FUNCTION	: M24VA_WriteReg
    
 PURPOSE	: Wrapper for hardware register access

 PARAMETERS	: 
			  
 RETURNS	: nothing

 Notes		: Registers take effect immediately
*****************************************************************************/

static void M24VA_WriteReg(DWORD dwAddr, DWORD dwData)
{
	DEBUG_MODE_ONLY(g_M24VAState.ui32RegAccessCount++);

	M24VA_PDUMP(("WRW :REG:%08X %08X\n",dwAddr,dwData));

#ifndef INIFINTELY_FAST_HW
	g_M24VAState.pRegisters[dwAddr / sizeof(IMG_UINT32)] = dwData;
#endif
}

/*****************************************************************************
 FUNCTION	: FrameAllocate
    
 PURPOSE	: Allocate frame memory via the display driver

 PARAMETERS	: 
			  
 RETURNS	: nothing

 Notes		: 
*****************************************************************************/

#define ROUND_STRIDE(x)			((x + 31) & 0xFFFFFFE0)
#define ALLOCATION_ALIGNMENT	(4096)

static PINT_SM_HANDLE FrameAllocate(DWORD dwWidth, DWORD dwHeight, 
									M24VA_SURF_FORMAT eFormat)
{
	PINT_SM_HANDLE	pSurface;
	IMG_UINT32		ui32Size, ui32Stride;

	/*********************************************** Allocate surface handle */

	if((pSurface = (PINT_SM_HANDLE) malloc(sizeof(INT_SM_HANDLE))) == NULL)
	{
		return(NULL);
	}
	
	/************************************************** Calculate frame size */

	switch(eFormat)
	{
		case M24VA_SURF_FORMAT_420:
			ui32Stride  = (dwWidth + ((MBX1_TSPPL2_TEXADDRALIGNSIZE * 2) - 1))
								& ~((MBX1_TSPPL2_TEXADDRALIGNSIZE * 2) - 1);
							
			ui32Size	= (dwHeight * ui32Stride * 3) / 2;
			break;

		case M24VA_SURF_FORMAT_422:
			ui32Stride  = ROUND_STRIDE(dwWidth * 2);
			ui32Size	= dwHeight * ui32Stride;
			break;
		
		case M24VA_SURF_FORMAT_RGB24:
			ui32Stride  = ROUND_STRIDE(dwWidth * 3);
			ui32Size	= dwHeight * ui32Stride;
			break;

		default:						
			free(pSurface); 
			return(NULL);
	}

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

	if(PVRSRVAllocDeviceMem(&g_M24VAState.sM24VADevData, PVRSRV_MEMFLG_SAVERESTORE, ui32Size, ALLOCATION_ALIGNMENT, &pSurface->psMemInfo) != PVRSRV_OK)
	{
		free(pSurface);			/* Unable to allocate memory */
		return(NULL);
	}

	/********************************** Initialise surface control structure */

	pSurface->pui8LinAddress= pSurface->psMemInfo->pvLinAddr;
	pSurface->eFormat		= eFormat;
	pSurface->ui32Width		= dwWidth;
	pSurface->ui32Height	= dwHeight;
	pSurface->ui32Stride	= ui32Stride;
	pSurface->ui32FBOffset	= pSurface->psMemInfo->uiDevAddr.uiAddr;

	/* Assume DirectDraw is not in use. */
	pSurface->bDirectDrawActive = IMG_FALSE;
	pSurface->pDDSurface = NULL;

	return(pSurface);
}

/*****************************************************************************
 FUNCTION	: FrameFree
    
 PURPOSE	: Free frame memory

 PARAMETERS	: 
			  
 RETURNS	: M24VAError

 Notes		: 
*****************************************************************************/

static M24VAError FrameFree(PINT_SM_HANDLE pSurface)
{
	/* Return error if application is using DirectDraw */
	if (pSurface->bDirectDrawActive)
	{
		return M24VAError_IllegalFunctionCall;
	}

	if(pSurface->psMemInfo)
	{
		if(PVRSRVFreeDeviceMem(&g_M24VAState.sM24VADevData, pSurface->psMemInfo) != PVRSRV_OK)
		{
			return(M24VAError_GenericError);
		}

		pSurface->psMemInfo = NULL;
		free(pSurface);
	}

	return(M24VAError_OK);
}


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