?? rprombw.c
字號:
ULONG ulBPP, ULONG ulRefRate, ULONG ulMemIPC, LPFIXEDPOINT lpEff)
{
ULONG ulHalfKByteRate;
// MEM_BYTEWIDTH = 64/8 = 8, 0.4k = 2^4
ulHalfKByteRate = ((((ulDispWidth * ulDispHeight) >> 3) * ulBPP) >> 4) * ulRefRate;
// Divided by MEM_IPC (= 1 or 2)
ulHalfKByteRate >>= ulMemIPC - 1;
// Divided by 2^8 before multiply with Efficiency
lpBandWidth->Fractional = (ulHalfKByteRate & 0x000000FF);
lpBandWidth->Integral = ulHalfKByteRate >> 8;
vMultiplyFixed(lpBandWidth, lpEff);
// round fractional
if (lpBandWidth->Fractional >= 128)
lpBandWidth->Integral++;
// Divided by 2^8 to get MBytes per second
lpBandWidth->Fractional = (lpBandWidth->Integral & 0x000000FF);
lpBandWidth->Integral >>= 8;
}
/****************************Private*Routine*******************************\
*
* vMBW_GetBWforCI()
*
* Calculate Scaler / Overlay Bandwidth in MBytes per Second
*
* Note:
*
*
\**************************************************************************/
VOID vMBW_GetBWforCI(LPFIXEDPOINT lpBandWidth, ULONG ulDispWidth, ULONG ulDispHeight,
ULONG ulBPP, ULONG ulRefRate, ULONG ulMemIPC, LPFIXEDPOINT lpEff)
{
ULONG ulHalfKByteRate;
// MEM_BYTEWIDTH = 64/8 = 8, 0.4k = 2^4
ulHalfKByteRate = ((ulDispWidth * ulDispHeight * ulBPP) >> 7) * ulRefRate;
// Divided by MEM_IPC (= 1 or 2)
ulHalfKByteRate >>= ulMemIPC - 1;
// Divided by 2^8 before multiply with Efficiency
lpBandWidth->Fractional = (ulHalfKByteRate & 0x000000FF);
lpBandWidth->Integral = ulHalfKByteRate >> 8;
vMultiplyFixed(lpBandWidth, lpEff);
// round fractional
if (lpBandWidth->Fractional >= 128)
lpBandWidth->Integral++;
// Divided by 2^8 to get MBytes per second
lpBandWidth->Fractional = (lpBandWidth->Integral & 0x000000FF);
lpBandWidth->Integral >>= 8;
}
/****************************Private*Routine*******************************\
*
* vMBW_GetSclBW()
*
* Calculate Scaler / Overlay Bandwidth in MBytes per Second
*
* Note:
*
*
\**************************************************************************/
VOID vMBW_GetSclBW(LPFIXEDPOINT lpSclBandWidth, ULONG ulSclBurst, ULONG ulSclMode,
LPDEVMODE_INFO lpModeInfo, ULONG ulMemIPC)
{
FIXEDPOINT sSclEff;
if (ulSclMode == MBW_SCL_PLANAR_MODE)
// YUV plannar mode
vMBW_GetSclEff(&sSclEff, ulSclBurst, ulMemIPC);
else if (ulSclMode == MBW_SCL_PACKED_MODE)
// YUV packed mode - assume page size of 256*64 bits
vMBW_GetSclEff(&sSclEff, 256, ulMemIPC);
vMBW_GetBW(lpSclBandWidth, lpModeInfo->ulPelsWidth, lpModeInfo->ulPelsHeight,
lpModeInfo->ulBitsPerPixel, lpModeInfo->ulDisplayFrequency,
ulMemIPC, &sSclEff);
}
/****************************Private*Routine*******************************\
*
* vMBW_GetVidBW()
*
* Calculate Video Capture Bandwidth in MBytes per Second
*
* Note:
*
*
\**************************************************************************/
VOID vMBW_GetVidBW(LPFIXEDPOINT lpVidBW, ULONG ulVidFlush, ULONG ulVidWidth, ULONG ulMemIPC)
{
FIXEDPOINT sFactor;
vMBW_GetVidEff(&sFactor, ulVidFlush, ulMemIPC);
lpVidBW->Integral = MBW_VID_CLK;
lpVidBW->Fractional = 0;
// VID_BW = VID_CLK / VID_EFF
vMultiplyFixed(lpVidBW, &sFactor);
if(ulVidWidth >= 640)
{
// do nothing
}
else if (ulVidWidth >= 320)
{
// VID_BW / 2
sFactor.Integral = 2;
sFactor.Fractional = 0;
vDivideFixed(lpVidBW, &sFactor);
}
else if (ulVidWidth >= 240)
{
// VID_BW * 3 / 8
sFactor.Integral = 0;
sFactor.Fractional = MBW_GetFractional(3, 8);
vMultiplyFixed(lpVidBW, &sFactor);
}
else if (ulVidWidth > 0)
{
// VID_BW / 4
sFactor.Integral = 4;
sFactor.Fractional = 0;
vDivideFixed(lpVidBW, &sFactor);
}
else
{
// VID_BW = 0
lpVidBW->Integral = 0;
lpVidBW->Fractional = 0;
}
}
/****************************Private*Routine*******************************\
*
* vMBW_GetSubBW()
*
* Calculate DVD Subpicture Bandwidth in MBytes per Second
*
* Note:
*
*
\**************************************************************************/
VOID vMBW_GetSubBW(LPFIXEDPOINT lpSubBW, ULONG ulSubBurst, ULONG ulSubHGT, ULONG ulSubRate,
ULONG ulMemIPC)
{
FIXEDPOINT sSubEff;
vMBW_GetSubEff(&sSubEff, ulSubBurst, ulMemIPC);
// tricking GetBW() - use the burst size instead of the width as and the bus
// width instead of bpp
// this has the same effect to calculate the overall bit width for the given
// line as the subpicture only has one burst per line.
vMBW_GetBW(lpSubBW, ulSubBurst, ulSubHGT, 64, ulSubRate, ulMemIPC, &sSubEff);
}
/****************************Private*Routine*******************************\
*
* vMBW_GetHFBBW()
*
* Calculate DSTN Half Frame Buffer Bandwidth in MBytes per Second
*
* Note:
*
*
\**************************************************************************/
VOID vMBW_GetHFBBW(LPFIXEDPOINT lpHalfBW, ULONG ulHalfFIFO,
LPDEVMODE_INFO lpModeInfo, ULONG ulMemIPC)
{
FIXEDPOINT sHalfEff;
FIXEDPOINT sFactor;
vMBW_GetBurstEff(&sHalfEff, ulHalfFIFO, ulMemIPC);
vMBW_GetBW(lpHalfBW, lpModeInfo->ulPelsWidth, lpModeInfo->ulPelsHeight,
MBW_HFB_BPP, lpModeInfo->ulDisplayFrequency,
ulMemIPC, &sHalfEff);
sFactor.Integral = 2;
sFactor.Fractional = 0;
vMultiplyFixed(lpHalfBW, &sFactor);
}
/****************************Private*Routine*******************************\
*
* ULONG MBW_GetDispBW()
*
* Calculate Frame Display Bandwidth in MBytes per Second
*
* Note: lpDispBandwidth with returned fixed-point value
* function return ULONG value
*
\**************************************************************************/
ULONG MBW_GetDispBW(LPFIXEDPOINT lpDispBandwidth, ULONG ulDispFIFO, ULONG ulHWCur_Size,
ULONG ulHWIcon_Size, ULONG ulMemIPC, LPDEVMODE_INFO lpModeInfo)
{
FIXEDPOINT sEff;
FIXEDPOINT sHWCI_BW;
ULONG ulHWCI_Size;
// calculate DISP bandwidth
vMBW_GetBurstEff(&sEff, ulDispFIFO, ulMemIPC);
vMBW_GetBW(lpDispBandwidth, lpModeInfo->ulPelsWidth, lpModeInfo->ulPelsHeight,
lpModeInfo->ulBitsPerPixel, lpModeInfo->ulDisplayFrequency,
ulMemIPC, &sEff);
// calculate Cursor and Icon efficiency
ulHWCI_Size = ulHWCur_Size + ulHWIcon_Size;
vMBW_GetBurstEff(&sEff, ulHWCI_Size, ulMemIPC);
// calculate Cursor bandwidth
vMBW_GetBWforCI(&sHWCI_BW, ulHWCur_Size, MBW_HW_CUR_HIGHT, 64, lpModeInfo->ulDisplayFrequency,
ulMemIPC, &sEff);
// DISP_BW + CURSOR_BW
vAddFixed(lpDispBandwidth, &sHWCI_BW);
// calculate Icon bandwidth
vMBW_GetBWforCI(&sHWCI_BW, ulHWIcon_Size, MBW_HW_ICON_HIGHT, 64, lpModeInfo->ulDisplayFrequency,
ulMemIPC, &sEff);
// DISP_BW + CURSOR_BW + ICON_BW
vAddFixed(lpDispBandwidth, &sHWCI_BW);
if (lpDispBandwidth->Fractional >= 128)
return lpDispBandwidth->Integral + 1;
else
return lpDispBandwidth->Integral;
}
/****************************Public*Routine*******************************\
*
* ULONG MBW_RequiredBW()
*
* Calculate Required Bandwidth in MBytes per Second
*
* Note: lpReqBandwidth with returned fixed-point value
* function return ULONG value
*
\**************************************************************************/
ULONG MBW_RequiredBW(LPFIXEDPOINT lpReqBandwidth, ULONG ulMemIPC)
{
FIXEDPOINT sTemp;
ULONG ulDisp1FIFO = 32; // hard code
ULONG ulDisp2FIFO = 32; // hard code
DEVMODE_INFO sModeInfo1 = {0, 1024, 768, 32}; // hard code
DEVMODE_INFO sModeInfo2 = {0, 1024, 768, 32}; // hard code
ULONG ulVidFlush = 12; // hard code
ULONG ulVidWidth = 720; // hard code
ULONG ulHalfFIFO = 64; // hard code
DEVMODE_INFO sHalfMode = {0, 1024, 768, 32}; // hard code
ULONG ulSubBurst = 16; // hard code
ULONG ulSubHGT = 480; // hard code
ULONG ulSubRate = 60; // hard code
ULONG ulSclMode = MBW_SCL_PLANAR_MODE; // hard code
ULONG ulSclBurst = 16; // hard code
DEVMODE_INFO sSclMode = {0, 720, 480, 32}; // hard code
#define HWCUR1_SIZE 2
#define HWICON1_SIZE 4
#define HWCUR2_SIZE 2
#define HWICON2_SIZE 4
// TOTAL_BW = DISP1_BW
MBW_GetDispBW(lpReqBandwidth, ulDisp1FIFO, HWCUR1_SIZE,
HWICON1_SIZE, ulMemIPC, &sModeInfo1);
MBW_GetDispBW(&sTemp, ulDisp2FIFO, HWCUR2_SIZE,
HWICON2_SIZE, ulMemIPC, &sModeInfo2);
// TOTAL_BW += DISP2_BW
vAddFixed(lpReqBandwidth, &sTemp);
vMBW_GetVidBW(&sTemp, ulVidFlush, ulVidWidth, ulMemIPC);
// TOTAL_BW += VID_BW
vAddFixed(lpReqBandwidth, &sTemp);
vMBW_GetHFBBW(&sTemp, ulHalfFIFO, &sHalfMode, ulMemIPC);
// TOTAL_BW += HFB_BW
vAddFixed(lpReqBandwidth, &sTemp);
vMBW_GetSubBW(&sTemp, ulSubBurst, ulSubHGT, ulSubRate, ulMemIPC);
// TOTAL_BW += SUB_BW
vAddFixed(lpReqBandwidth, &sTemp);
vMBW_GetSclBW(&sTemp, ulSclBurst, ulSclMode, &sSclMode, ulMemIPC);
// TOTAL_BW += SCL_BW
vAddFixed(lpReqBandwidth, &sTemp);
// return TOTAL_BW
if (lpReqBandwidth->Fractional >= 128)
return lpReqBandwidth->Integral + 1;
else
return lpReqBandwidth->Integral;
}
/****************************Private*Routine*******************************\
*
* vMBW_AvailHActiveTime()
*
* Calculate Available Active Time in Micro Second
*
* Note: lpActiveTime with output fixed-point value
* function return ULONG value
*
\**************************************************************************/
VOID vMBW_AvailHActiveTime(HGCO hGCO, LPFIXEDPOINT lpActiveTime, LPDEVMODE_INFO lpModeInfo,
LPFIXEDPOINT lpPixelClock, ULONG ulHBlankFactor)
{
LPHW_RAGEPROCRTC_EXTENSION lpHwCrtc = (LPHW_RAGEPROCRTC_EXTENSION)hGCO;
FIXEDPOINT sTemp;
lpActiveTime->Integral = 1;
lpActiveTime->Fractional = ulHBlankFactor;
sTemp.Integral = lpModeInfo->ulPelsWidth;
sTemp.Fractional = 0;
vMultiplyFixed(lpActiveTime, &sTemp);
vDivideFixed(lpActiveTime, lpPixelClock);
}
/****************************Private*Routine*******************************\
*
* vMBW_GetDispHActiveTime()
*
* Calculate Display Horizontal Active Time in Micro Second
*
* Note:
*
*
\**************************************************************************/
ULONG vMBW_GetDispHActiveTime(LPFIXEDPOINT lpHActiveTime, ULONG ulDispFIFO,
ULONG ulHWCI_Size, ULONG ulDispWid,
ULONG ulBPP, ULONG ulMemClock, ULONG ulMemIPC)
{
FIXEDPOINT sDispEff;
FIXEDPOINT sHWCIEff;
FIXEDPOINT sTemp;
vMBW_GetBurstEff(&sDispEff, ulDispFIFO, ulMemIPC);
vMBW_GetBurstEff(&sHWCIEff, ulHWCI_Size, ulMemIPC);
// DISP_QW_WID = DISP_WID * DISP_BPP / 64
lpHActiveTime->Integral = ulDispWid * ulBPP >> 6;
lpHActiveTime->Fractional = 0;
// (1 / DISP_EFF) * DISP_QW_WID
vMultiplyFixed(lpHActiveTime, &sDispEff);
sTemp.Integral = ulHWCI_Size;
sTemp.Fractional = 0;
// (1 / HWCI_EFF) * HWCI_SIZE
vMultiplyFixed(&sTemp, &sHWCIEff);
// (1/DISP_EFF)*DISP_QW_WID+(1/HWCI_EFF)*HWCI_SIZE
vAddFixed(lpHActiveTime, &sTemp);
sTemp.Integral = ulMemClock;
sTemp.Fractional = 0;
// Divided by MEM_CLK
vDivideFixed(lpHActiveTime, &sTemp);
if (lpHActiveTime->Fractional >= 128)
return lpHActiveTime->Integral + 1;
else
return lpHActiveTime->Integral;
}
/****************************Private*Routine*******************************\
*
* vMBW_GetVidHActiveTime()
*
* Calculate Video Capture Horizontal Active Time in Micro Second
*
* Note:
*
*
\**************************************************************************/
VOID vMBW_GetVidHActiveTime(LPFIXEDPOINT lpHActiveTime, ULONG ulVidFlush,
ULONG ulVidWid, LPFIXEDPOINT lpHTotalTime,
ULONG ulMemClock, ULONG ulMemIPC)
{
FIXEDPOINT sTemp;
FIXEDPOINT sMemBw;
if (!ulMemIPC)
return;
// VID_BW
vMBW_GetVidBW(&sTemp, ulVidFlush, ulVidWid, ulMemIPC);
// MEM_BW = MEM_CLK * 8 / MEM_IPC
sMemBw.Integral = (ulMemClock << 3) / ulMemIPC;
sMemBw.Fractional = 0;
// VID_PORTION = VID_BW / MEM_BW
vDivideFixed(&sTemp, &sMemBw);
*lpHActiveTime = *lpHTotalTime;
// VID_PORTION * HTOT_TIME
vMultiplyFixed(lpHActiveTime, &sTemp);
}
VOID vMBW_GetHActiveTime(LPFIXEDPOINT lpHActiveTime, ULONG ulBurstSize,
ULONG ulWidth, ULONG ulBPP, ULONG ulMemClock,
ULONG ulMemIPC)
{
FIXEDPOINT sEff;
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -