📄 post.cpp
字号:
BOOL PostClockOn(BOOL bOnOff)
{
// Post Processor clock
if (!bOnOff)
s2450PWR->HCLKCON &= ~(1<<8); // Post clock disable
else
s2450PWR->HCLKCON |= (1<<8); // Post clock enable
RETAILMSG(POST_MSG,(_T("PostClockOn = %d\r\n"), bOnOff));
Delay(500);
return TRUE;
}
DWORD PST_Init(DWORD dwContext)
{
// 1. Virtual Alloc
Virtual_Alloc();
RETAILMSG(POST_DEBUG, (TEXT("PST::Virtual_Alloc \r\n")));
PostClockOn(TRUE);
if (!InitInterruptThread())
{
RETAILMSG(POST_DEBUG,(TEXT("Fail to initialize Post interrupt event\r\n")));
return FALSE;
}
m_Dx = (_CEDEVICE_POWER_STATE)D0;
DevicePowerNotify(_T("PST1:"),(_CEDEVICE_POWER_STATE)D0, POWER_NAME);
RETAILMSG(POST_MSG, (TEXT("PST::POST_Init() \r\n")));
return TRUE;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
BOOL PST_IOControl(DWORD hOpenContext,
DWORD dwCode,
PBYTE pBufIn,
DWORD dwLenIn,
PBYTE pBufOut,
DWORD dwLenOut,
PDWORD pdwActualOut)
{
BOOL RetVal = TRUE;
DWORD dwErr = ERROR_SUCCESS;
PPVOID temp;
static unsigned int time=0,old_time=0;
switch (dwCode)
{
//-----------------------------------------------------------------------------------------
case IOCTL_POWER_CAPABILITIES:
{
PPOWER_CAPABILITIES ppc;
RETAILMSG(PM_MSG, (TEXT("PST: IOCTL_POWER_CAPABILITIES\r\n")));
if ( !pdwActualOut || !pBufOut || (dwLenOut < sizeof(POWER_CAPABILITIES)) ) {
RetVal = FALSE;
dwErr = ERROR_INVALID_PARAMETER;
break;
}
ppc = (PPOWER_CAPABILITIES)pBufOut;
memset(ppc, 0, sizeof(POWER_CAPABILITIES));
// support D0, D4
ppc->DeviceDx = 0x11;
// Report our power consumption in uAmps rather than mWatts.
ppc->Flags = POWER_CAP_PREFIX_MICRO | POWER_CAP_UNIT_AMPS;
// 25 m = 25000 uA
// TODO: find out a more accurate value
ppc->Power[D0] = 15000;
*pdwActualOut = sizeof(POWER_CAPABILITIES);
} break;
case IOCTL_POWER_SET:
{
CEDEVICE_POWER_STATE NewDx;
RETAILMSG(PM_MSG,(_T("==================IOCTL_POWER_SET======================\r\n")));
if ( !pdwActualOut || !pBufOut || (dwLenOut < sizeof(CEDEVICE_POWER_STATE)) ) {
RetVal = FALSE;
dwErr = ERROR_INVALID_PARAMETER;
break;
}
NewDx = *(PCEDEVICE_POWER_STATE)pBufOut;
if ( VALID_DX(NewDx) ) {
switch ( NewDx ) {
case D0:
if (m_Dx != D0) {
PST_PowerUp(hOpenContext);
m_Dx = D0;
}
break;
default:
if (m_Dx != (_CEDEVICE_POWER_STATE)D4) {
PST_PowerDown(hOpenContext);
m_Dx = (_CEDEVICE_POWER_STATE)D4;
}
break;
}
// return our state
*(PCEDEVICE_POWER_STATE)pBufOut = m_Dx;
RETAILMSG(PM_MSG, (TEXT("POST: IOCTL_POWER_SET: D%u \r\n"), NewDx));
*pdwActualOut = sizeof(CEDEVICE_POWER_STATE);
} else {
RetVal = FALSE;
dwErr = ERROR_INVALID_PARAMETER;
}
} break;
case IOCTL_POWER_GET:
if ( !pdwActualOut || !pBufOut || (dwLenOut < sizeof(CEDEVICE_POWER_STATE)) ) {
RetVal = FALSE;
dwErr = ERROR_INVALID_PARAMETER;
break;
}
*(PCEDEVICE_POWER_STATE)pBufOut = m_Dx;
RETAILMSG(PM_MSG, (TEXT("POST: IOCTL_POWER_GET: D%u \r\n"), m_Dx));
*pdwActualOut = sizeof(CEDEVICE_POWER_STATE);
break;
//-----------------------------------------------------------------------------------------
case IOCTL_POST_INIT :
if (bIdlePwrDown == TRUE)
{
RETAILMSG(POST_DEBUG, (_T("[POST] IOControl POST_INIT(%x)\r\n"),dwLenIn));
PostProcessor_PowerUp();
bIdlePwrDown = FALSE;
}
dwPostProcessTimeout = POST_THREAD_TIMEOUT;
PostInit((POSTINFO*)pBufIn);
break;
case IOCTL_POST_RUN:
#if (BSP_TYPE == BSP_SMDK2443)
s2450INT->INTMSK &= ~(1<<IRQ_CAM);
#elif (BSP_TYPE == BSP_SMDK2450)
s2450INT->INTMSK1 &= ~(1<<IRQ_CAM);
#endif
s2450INT->INTSUBMSK &= ~(1<<IRQ_SUB_CAM_P);
PostProcessOn(pBufIn, pBufOut);
RETAILMSG(POST_DEBUG,(TEXT("POST:IOCTL_POST_RUN\r\n")));
break;
case IOCTL_POST_STOP :
RETAILMSG(POST_DEBUG,(TEXT("POST:IOCTL_POST_STOP\r\n")));
// Disable POST interrupt
#if (BSP_TYPE == BSP_SMDK2443)
s2450INT->INTMSK |= (1<<IRQ_CAM);
#elif (BSP_TYPE == BSP_SMDK2450)
s2450INT->INTMSK1 |= (1<<IRQ_CAM);
#endif
s2450INT->INTSUBMSK |= (1<<IRQ_SUB_CAM_P);
if(s2450INT->SUBSRCPND & (1<<IRQ_SUB_CAM_P)) s2450INT->SUBSRCPND = (1<<IRQ_SUB_CAM_P);
#if (BSP_TYPE == BSP_SMDK2443)
if(s2450INT->SRCPND & (1<<IRQ_CAM)) s2450INT->SRCPND = (1<<IRQ_CAM);
if(s2450INT->INTPND & (1<<IRQ_CAM)) s2450INT->INTPND = (1<<IRQ_CAM);
#elif (BSP_TYPE == BSP_SMDK2450)
if(s2450INT->SRCPND1 & (1<<IRQ_CAM)) s2450INT->SRCPND1 = (1<<IRQ_CAM);
if(s2450INT->INTPND1 & (1<<IRQ_CAM)) s2450INT->INTPND1 = (1<<IRQ_CAM);
#endif
break;
case IOCTL_POST_GETINPUTBUFFER:
temp = (PPVOID)pBufOut;
*temp = (PVOID)(pVirtSrcAddr);
RETAILMSG(1,(TEXT("0x%08X\n"), (BYTE*)(pVirtSrcAddr)));
break;
case IOCTL_POST_GETOUTPUTBUFFER:
temp = (PPVOID)pBufOut;
*temp = (PVOID)(pVirtDstAddr);
RETAILMSG(1,(TEXT("0x%08X\n"), (BYTE*)(pVirtDstAddr)));
break;
default :
RETAILMSG(POST_MSG,(TEXT("POST:Ioctl code = 0x%x\r\n"), dwCode));
return FALSE;
}
return TRUE;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
DWORD PST_Open(DWORD hDeviceContext, DWORD AccessCode, DWORD ShareMode)
{
RETAILMSG(PM_MSG,(TEXT("POST: PST_Open\r\n")));
bAppOpenFlag = TRUE;
return TRUE;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
BOOL PST_Close(DWORD hOpenContext)
{
RETAILMSG(POST_MSG,(TEXT("POST: PST_Close\r\n")));
bAppOpenFlag = FALSE;
return TRUE;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void PST_PowerDown(DWORD hDeviceContext)
{
RETAILMSG(POST_MSG,(TEXT("POST: PST_PowerDown\r\n")));
m_Dx = (_CEDEVICE_POWER_STATE)D4;
bIdlePwrDown = TRUE;
PostProcessor_PowerDown();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void PST_PowerUp(DWORD hDeviceContext)
{
RETAILMSG(POST_MSG,(TEXT("POST: POST_PowerUp\r\n")));
m_Dx = (_CEDEVICE_POWER_STATE)D0;
if(bAppOpenFlag == FALSE)
PostClockOn(FALSE);
else
PostProcessor_PowerUp();
RETAILMSG(POST_MSG,(TEXT("POST: PST_PowerUp, m_Dx = D%u\r\n"), m_Dx));
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
DWORD PST_Read(DWORD hOpenContext, LPVOID pBuffer, DWORD Count)
{
RETAILMSG(POST_MSG,(TEXT("POST: PST_Read\r\n")));
return TRUE;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
DWORD PST_Seek(DWORD hOpenContext, long Amount, DWORD Type)
{
RETAILMSG(POST_MSG,(TEXT("POST: PST_Seek\r\n")));
return 0;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
DWORD PST_Write(DWORD hOpenContext, LPCVOID pSourceBytes, DWORD NumberOfBytes)
{
RETAILMSG(POST_MSG,(TEXT("POST: PST_Write\r\n")));
return 0;
}
void Post_CalculatePrescaler(U32 SrcSize, U32 DstSize, U32 *ratio,U32 *shift)
{
RETAILMSG(POST_MSG, (TEXT("[POST] Caculate Prescaler..\r\n")));
if (SrcSize>=64*DstSize)
{
RETAILMSG(POST_MSG,(TEXT("ERROR: out of the prescaler range: SrcSize/DstSize = %d(< 64)\n"),SrcSize/DstSize));
while(1);
}
else if (SrcSize>=32*DstSize)
{
*ratio = 32;
*shift = 5;
}
else if (SrcSize>=16*DstSize)
{
*ratio = 16;
*shift = 4;
}
else if (SrcSize>=8*DstSize)
{
*ratio = 8;
*shift = 3;
}
else if (SrcSize>=4*DstSize)
{
*ratio = 4;
*shift = 2;
}
else if (SrcSize>=2*DstSize)
{
*ratio = 2;
*shift = 1;
}
else
{
*ratio = 1;
*shift = 0;
}
}
void CalculateBurstSize(unsigned int hSize,unsigned int *mainBurstSize,unsigned int *remainedBurstSize)
{
unsigned int tmp;
tmp=(hSize/4)%16;
switch(tmp) {
case 0:
*mainBurstSize=16;
*remainedBurstSize=16;
break;
case 4:
*mainBurstSize=16;
*remainedBurstSize=4;
break;
case 8:
*mainBurstSize=16;
*remainedBurstSize=8;
break;
default:
tmp=(hSize/4)%8;
switch(tmp) {
case 0:
*mainBurstSize=8;
*remainedBurstSize=8;
break;
case 4:
*mainBurstSize=8;
*remainedBurstSize=4;
default:
*mainBurstSize=4;
tmp=(hSize/4)%4;
*remainedBurstSize= (tmp) ? tmp: 4;
break;
}
break;
}
}
void PostInit(POSTINFO *pBufIn)
{
U32 ScaleUp_H_Pr, ScaleUp_V_Pr,MainHorRatio, MainVerRatio;
U32 H_Shift, V_Shift, PreHorRatio, PreVerRatio;
U32 MainBurstSizeRGB, RemainedBurstSizeRGB;
// U32 WinOfsEn=0;
// U32 WinHorOffset1=0,WinVerOffset1=0,WinHorOffset2=0,WinVerOffset2=0;
U32 inmultiplier, outmultiplier;
U32 OffsetY, OffsetC;
U32 ADDRStartY, ADDREndY, ADDRStartCb, ADDREndCb, ADDRStartCr, ADDREndCr;
memset(&sPOSTINFO, 0, sizeof(sPOSTINFO));
memcpy(&sPOSTINFO, pBufIn, sizeof(sPOSTINFO));
RETAILMSG(POST_DEBUG,(TEXT("[POST] Post Processor Init for Run!!\r\n")));
#if USE_RESERVED_BUFFER==1
Post_input_yuv = (unsigned char *)POST_INPUT_BUFFER;
Post_output_rgb = (unsigned char *)POST_OUTPUT_BUFFER;
#else
Post_input_yuv = (unsigned char *)g_PhysSrcAddr.LowPart;
Post_output_rgb = (unsigned char *)g_PhysDstAddr.LowPart;
#endif
/*
if(sPOSTINFO.nSrcWidth != sPOSTINFO.nOrgSrcWidth || sPOSTINFO.nSrcHeight != sPOSTINFO.nOrgSrcHeight)
{
WinOfsEn=1;
WinHorOffset1 = sPOSTINFO.nSrcStartX;
WinVerOffset1 = sPOSTINFO.nSrcStartY;
WinHorOffset2 = sPOSTINFO.nOrgSrcWidth - WinHorOffset1 - sPOSTINFO.nSrcWidth;
WinVerOffset2 = sPOSTINFO.nOrgSrcHeight - WinVerOffset1 - sPOSTINFO.nSrcHeight;
}
s2450CAM->CIWDOFST = (1<<30)|(0xf<<12); // clear overflow
s2450CAM->CIWDOFST = 0;
s2450CAM->CIWDOFST=(WinOfsEn<<31)|(WinHorOffset1<<16)|(WinVerOffset1);
s2450CAM->CIDOWSFT2=(WinHorOffset2<<16)|(WinVerOffset2);*/
if(sPOSTINFO.nSrcWidth >= sPOSTINFO.nDestWidth) ScaleUp_H_Pr=0; //down
else ScaleUp_H_Pr=1; //up
if(sPOSTINFO.nSrcHeight >= sPOSTINFO.nDestHeight ) ScaleUp_V_Pr=0;
else ScaleUp_V_Pr=1;
Post_CalculatePrescaler(sPOSTINFO.nSrcWidth, sPOSTINFO.nDestWidth, &PreHorRatio, &H_Shift);
Post_CalculatePrescaler(sPOSTINFO.nSrcHeight, sPOSTINFO.nDestHeight, &PreVerRatio, &V_Shift);
MainHorRatio=(sPOSTINFO.nSrcWidth<<8)/(sPOSTINFO.nDestWidth<<H_Shift);
MainVerRatio=(sPOSTINFO.nSrcHeight<<8)/(sPOSTINFO.nDestHeight<<V_Shift);
CalculateBurstSize(sPOSTINFO.nDestWidth*2, &MainBurstSizeRGB, &RemainedBurstSizeRGB);
s2450CAM->CIPRTRGFMT=(2<<30)|(sPOSTINFO.nDestWidth<<16)|(sPOSTINFO.nDestHeight);
s2450CAM->CIPRCTRL=(MainBurstSizeRGB<<19)|(RemainedBurstSizeRGB<<14);
s2450CAM->CIPRSCPRERATIO=((10-H_Shift-V_Shift)<<28)|(PreHorRatio<<16)|(PreVerRatio);
s2450CAM->CIPRSCPREDST=((sPOSTINFO.nSrcWidth/PreHorRatio)<<16)|(sPOSTINFO.nSrcHeight/PreVerRatio);
s2450CAM->CIPRSCCTRL=(1<<31)|(0/*16bit RGB*/<<30)|(ScaleUp_H_Pr<<29)|(ScaleUp_V_Pr<<28)|(MainHorRatio<<16)|(1<<15)|(MainVerRatio);
s2450CAM->CIPRCLRSA1=(U32)(Post_output_rgb/*g_PhysDstAddr.LowPart*/);
s2450CAM->CIPRCLRSA2=(U32)(Post_output_rgb/*g_PhysDstAddr.LowPart*/);
s2450CAM->CIPRCLRSA3=(U32)(Post_output_rgb/*g_PhysDstAddr.LowPart*/);
s2450CAM->CIPRCLRSA4=(U32)(Post_output_rgb/*g_PhysDstAddr.LowPart*/);
s2450CAM->CIPRTAREA = sPOSTINFO.nDestWidth*sPOSTINFO.nDestHeight;
inmultiplier=1;
outmultiplier=2;
OffsetY = (sPOSTINFO.nOrgSrcWidth-sPOSTINFO.nSrcWidth)*inmultiplier;
OffsetC = (sPOSTINFO.nOrgSrcWidth-sPOSTINFO.nSrcWidth)*inmultiplier/2;
ADDRStartY = (U32)(Post_input_yuv)+(sPOSTINFO.nOrgSrcWidth*sPOSTINFO.nSrcStartY+sPOSTINFO.nSrcStartX)*inmultiplier;
ADDREndY = ADDRStartY+sPOSTINFO.nSrcWidth*sPOSTINFO.nSrcHeight*inmultiplier + OffsetY*(sPOSTINFO.nSrcHeight-1);
ADDRStartCb = (U32)(Post_input_yuv)+(sPOSTINFO.nOrgSrcWidth*sPOSTINFO.nOrgSrcHeight)*inmultiplier+(sPOSTINFO.nOrgSrcWidth/2*sPOSTINFO.nSrcStartY/2+sPOSTINFO.nSrcStartX/2)*inmultiplier;
ADDREndCb = ADDRStartCb+(sPOSTINFO.nSrcWidth/2*sPOSTINFO.nSrcHeight/2)*inmultiplier+OffsetC*(sPOSTINFO.nSrcHeight/2-1);
ADDRStartCr = (U32)(Post_input_yuv)+(sPOSTINFO.nOrgSrcWidth*sPOSTINFO.nOrgSrcHeight+(sPOSTINFO.nOrgSrcWidth/2*sPOSTINFO.nOrgSrcHeight/2))*inmultiplier+(sPOSTINFO.nOrgSrcWidth/2*sPOSTINFO.nSrcStartY/2+sPOSTINFO.nSrcStartX/2)*inmultiplier;
ADDREndCr = ADDRStartCr+(sPOSTINFO.nSrcWidth/2*sPOSTINFO.nSrcHeight/2)*inmultiplier+OffsetC*(sPOSTINFO.nSrcHeight/2-1);
s2450CAM->CIMSYSA = ADDRStartY;
s2450CAM->CIMSCBSA = ADDRStartCb;
s2450CAM->CIMSCRSA = ADDRStartCr;
s2450CAM->CIMSYEND = ADDREndY;
s2450CAM->CIMSCBEND= ADDREndCb;
s2450CAM->CIMSCREND= ADDREndCr;
s2450CAM->CIMSYOFF = OffsetY;
s2450CAM->CIMSCBOFF = OffsetC;
s2450CAM->CIMSCROFF = OffsetC;
s2450CAM->CIMSWIDTH = sPOSTINFO.nSrcWidth;
}
#if USE_RESERVED_BUFFER == 1
void PostProcessOn(U8 *pBufIn, U8 *pBufOut)
{
s2450CAM->CIMSCTRL &= ~(0x3f);
s2450CAM->CIMSCTRL |= (0<<5|1<<2|1<<1);
s2450CAM->CIPRSCCTRL |=(1<<15);
s2450CAM->CIIMGCPT |=(1<<31)|(1<<29);
s2450CAM->CIMSCTRL |= (1<<0);
WaitForSingleObject(PostDoneEvent, INFINITE);
}
#else
void PostProcessOn(U8 *pBufIn, U8 *pBufOut)
{
memcpy((BYTE*)(g_PhysSrcAddr.LowPart + VIRTUAL_ADDR_OFFSET), pBufIn, sPOSTINFO.nOrgSrcWidth*sPOSTINFO.nOrgSrcHeight*3/2);
s2450CAM->CIMSCTRL &= ~(0x3f);
s2450CAM->CIMSCTRL |= (0<<5|1<<2|1<<1);
s2450CAM->CIPRSCCTRL |=(1<<15);
s2450CAM->CIIMGCPT |=(1<<31)|(1<<29);
s2450CAM->CIMSCTRL |= (1<<0);
WaitForSingleObject(PostDoneEvent, INFINITE);
memcpy(pBufOut, (BYTE*)(g_PhysDstAddr.LowPart + VIRTUAL_ADDR_OFFSET), sPOSTINFO.nDestWidth*sPOSTINFO.nDestHeight*2);
}
#endif
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -