📄 dalmm.c
字号:
if ( ( lpHDE->aControllers[0].lpHWED->aControllerCaps[0]
& DAL_CONTROLLER_CAPS_AMC16BIT_PORT )
== DAL_CONTROLLER_CAPS_AMC16BIT_PORT )
// capability must be declared by GCO before allocation
{
if (lpHDE->ulMultiMediaInfo & DAL_MULTIMEDIA_AMC_16BIT_PORT)
{
// Port is already allocated
ulReturn = CWDDEMM_ERR_NOTAVAILABLE;
}
else
{
lpHDE->ulMultiMediaInfo |= DAL_MULTIMEDIA_AMC_16BIT_PORT;
ulHandle = DAL_MULTIMEDIA_AMC_16BIT_PORT;
}
}
else
{
// Port is not supported
ulReturn = CWDDEMM_ERR_UNSUPPORTED;
}
}
else
{
ulReturn = CWDDEMM_ERR_BADINPUT;
}
lpMMUlong = (MM_ULONG FAR *) lpOutput;
lpMMUlong->ulSize = sizeof(MM_ULONG);
lpMMUlong->ulValue = ulHandle;
}
}
*lpInfoSize = sizeof(MM_ULONG);
break;
case CWDDEMM_AllocMemBandwidth:
{
MM_ALLOCBANDWIDTH FAR *lpMMAllocAmcPort;
MM_ULONG FAR *lpMMUlong;
LPDEVGCO lpController = NULL;
FIXEDPOINT sReqBandwidth;
FIXEDPOINT sReqPeakBandwidth;
BOOL bValid;
ULONG i;
ULONG ulEngineIndex;
ULONG ulMappedControllerIndex;
*lpInfoSize = sizeof(MM_ULONG);
lpMMUlong = (MM_ULONG FAR *) lpOutput;
lpMMUlong->ulSize = sizeof(MM_ULONG);
lpMMUlong->ulValue = 0; // zero initialize the handle in case of failure
ZEROMEMORY(&sReqBandwidth, sizeof(FIXEDPOINT));
ZEROMEMORY(&sReqPeakBandwidth, sizeof(FIXEDPOINT));
// check for input size
if (ulInputSize < sizeof(CWDDEMMCMD) + sizeof(MM_ALLOCBANDWIDTH))
{
// input size is less than expected
ulReturn = CWDDE_ERR_BADINPUTSIZE;
break;
}
if (ulOutputSize < sizeof(MM_ULONG))
{
// cannot return the version because there is insufficient room in
// the output buffer for a OUTPUTULONG.
ulReturn = CWDDEMM_ERR_BADOUTPUTSIZE;
break;
}
lpMMAllocAmcPort = (MM_ALLOCBANDWIDTH FAR *) (lpMmCmd + 1);
// validate engine ID
if (!bDetermineVCEngineIndex(lpMMAllocAmcPort->ulCaptureEngine, &ulEngineIndex))
{
// input size is less than expected
ulReturn = CWDDE_ERR_BADINPUT;
break;
}
// verify that the engine is free
if (lpHDE->aCaptureEngine[ulEngineIndex].bEnabled)
{
ulReturn = CWDDEMM_ERR_NOTAVAILABLE;
break;
}
// looking for a mapped controller
for (i = 0; i < lpHDE->ulControllersCount; i++)
{
if (lpHDE->aControllerMap[lpMmCmd->ulDriverReserved] & VECTORFROMINDEX(i))
{
lpController = (LPDEVGCO) &lpHDE->aControllers[i];
ulMappedControllerIndex = i;
break; // found it
}
}
if (!lpController)
{
// Can't find controller
ulReturn = CWDDE_ERR_BADINPUT;
break; // out of the switch statement
}
// Validate memory bandwidth for video capture
bValid = FALSE;
if (lpController->lpHWED->ulFunctionHooks & GCO_CALCULATE_MEMORY_BANDWIDTH)
{
DEVMODE_INFO sVideoMode;
sVideoMode.ulPelsWidth = lpMMAllocAmcPort->ulVideoWidth;
sVideoMode.ulDisplayFrequency = lpMMAllocAmcPort->ulFrameRate;
sVideoMode.ulPelsHeight = 0; // not used
sVideoMode.ulBitsPerPixel = 0; // not used
(*lpController->lpHWED->pfnCalculateVideoBandwidth)(lpController->hGCO,
(LPDEVMODE_INFO)&sVideoMode,
(LPFIXEDPOINT)&sReqBandwidth);
// if it's enough bandwidth for video
bValid = bCompareFixed(&lpController->lpHWED->sAvailBandwidth, (LPFIXEDPOINT)&sReqBandwidth);
if ((lpController->lpHWED->ulFunctionHooks & GCO_CALCULATE_PEAK_MEMORY_BANDWIDTH) && bValid)
{
(*lpController->lpHWED->pfnCalculatePeakVideoBandwidth)(lpController->hGCO,
(LPDEVMODE_INFO)&sVideoMode,
(LPFIXEDPOINT)&sReqPeakBandwidth);
// if it's enough peak bandwidth for video
bValid = bCompareFixed(&lpController->lpHWED->sAvailPeakBandwidth,
(LPFIXEDPOINT)&sReqPeakBandwidth );
}
// check if memory bandwidth is disable
bValid |= !(lpHDE->bEnableBandwidthTest);
if (!bValid)
{
// fail memory bandwidth test
ulReturn = CWDDEMM_ERR_OUTOFRANGE;
break; // out of the switch statement
}
}
// validate HTime for video capture
if (lpController->lpHWED->ulFunctionHooks & GCO_CALCULATE_HORIZONTAL_TIME)
{
LPDEVGCO lpActiveController;
HORIZONTAL_TIME aTotalHTime[MAX_NUMBER_CONTROLLERS];
PRIO_ELEM aPrioTable[MAX_PRIO_ELEM];
DEVMODE_INFO aModeInfo[MAX_NUMBER_CONTROLLERS];
ULONG aDisplaysType[MAX_NUMBER_CONTROLLERS];
ZEROMEMORY((LPVOID)aTotalHTime, (MAX_NUMBER_CONTROLLERS * sizeof(HORIZONTAL_TIME)));
// get priority table
MOVEMEMORY((LPVOID)aPrioTable, (LPVOID)lpHDE->aPrioTable, MAX_PRIO_ELEM * sizeof(PRIO_ELEM));
for (i = 0; i < lpHDE->ulControllersCount; i++)
{
lpActiveController = (LPDEVGCO)&lpHDE->aControllers[i];
if (lpActiveController->ulFlags & GCO_ACTIVE)
{
// get total HTime
(*lpActiveController->lpHWED->pfnGetTotalHTime)(lpActiveController->hGCO,
(LPHORIZONTAL_TIME)&aTotalHTime[i],
&lpActiveController->sModeInfo,
lpActiveController->ulDisplayTypes);
aModeInfo[i] = lpActiveController->sModeInfo;
aDisplaysType[i] = lpHDE->aControllers[i].ulDisplayTypes;
}
}
// find pointer to mapped controller for video capture
lpActiveController = (LPDEVGCO) &lpHDE->aControllers[ulMappedControllerIndex];
if (lpActiveController->ulFlags & GCO_ACTIVE)
{
// fill video capture HTime in priority table
aPrioTable[3].bEnabled = TRUE;
aPrioTable[3].ulMappedController = ulMappedControllerIndex;
(*lpActiveController->lpHWED->pfnCalculateVideoHorizontalTime)
(lpActiveController->hGCO,
&lpActiveController->sModeInfo,
(LPHORIZONTAL_TIME)&aPrioTable[3].sHTime);
bValid = bValidateHTime(lpActiveController,
(LPPRIO_ELEM)aPrioTable,
(LPHORIZONTAL_TIME)aTotalHTime,
lpHDE->ulControllersCount,
(LPDEVMODE_INFO)aModeInfo,
(LPULONG)aDisplaysType);
bValid |= !(lpHDE->bEnableHTimeTest);
if (bValid)
{
// save priority table (allocate hTime)
MOVEMEMORY((LPVOID)&lpHDE->aPrioTable[3], (LPVOID)&aPrioTable[3], sizeof(PRIO_ELEM));
}
else
{
ulReturn = CWDDEMM_ERR_OUTOFRANGE;
}
}
}
if (bValid)
{
// decrement available bandwidths
vDecrementBandwidth(&lpController->lpHWED->sAvailBandwidth, (LPFIXEDPOINT)&sReqBandwidth);
vDecrementBandwidth(&lpController->lpHWED->sAvailPeakBandwidth, (LPFIXEDPOINT)&sReqPeakBandwidth);
// save bandwidth allocation information.
lpHDE->aCaptureEngine[ulEngineIndex].bEnabled = TRUE;
lpHDE->aCaptureEngine[ulEngineIndex].ulFrameRate = lpMMAllocAmcPort->ulFrameRate;
lpHDE->aCaptureEngine[ulEngineIndex].ulVBIWidth = lpMMAllocAmcPort->ulVBIWidth;
lpHDE->aCaptureEngine[ulEngineIndex].ulVBIHeight = lpMMAllocAmcPort->ulVBIHeight;
lpHDE->aCaptureEngine[ulEngineIndex].ulVideoWidth = lpMMAllocAmcPort->ulVideoWidth;
lpHDE->aCaptureEngine[ulEngineIndex].ulVideoHeight = lpMMAllocAmcPort->ulVideoHeight;
MOVEMEMORY((LPVOID)&lpHDE->aCaptureEngine[ulEngineIndex].sAveBWAllocated,
(LPVOID)&sReqBandwidth, sizeof(FIXEDPOINT));
MOVEMEMORY((LPVOID)&lpHDE->aCaptureEngine[ulEngineIndex].sPeakBWAllocated,
(LPVOID)&sReqPeakBandwidth, sizeof(FIXEDPOINT));
lpMMUlong->ulValue = lpMMAllocAmcPort->ulCaptureEngine; // return value to the caller
}
}
break;
case CWDDEMM_ConfigureBandwidthTest:
{
MM_CONFIGTEST FAR* lpMm_ConfigTest;
if (ulInputSize < sizeof(CWDDEMMCMD) + sizeof(MM_CONFIGTEST))
{
// input size is less than expected
ulReturn = CWDDE_ERR_BADINPUTSIZE;
}
else if (0)
{
// output size is less than expected
ulReturn = CWDDE_ERR_BADOUTPUTSIZE;
}
else
{
lpMm_ConfigTest = (MM_CONFIGTEST FAR*) (lpMmCmd + 1);
lpHDE->bEnableBandwidthTest = (BOOL)(lpMm_ConfigTest->ulEnableBandwidthCheck & DAL_ENABLE_BANDWIDTH_CHECK);
lpHDE->bEnableHTimeTest = (BOOL)(lpMm_ConfigTest->ulEnableBandwidthCheck & DAL_ENABLE_HTIME_CHECK);
}
}
*lpInfoSize = 0;
break;
case CWDDEMM_FreeAMCPort:
{
if (ulInputSize < sizeof(CWDDEMMCMD))
{
// input size is less than expected
ulReturn = CWDDE_ERR_BADINPUTSIZE;
}
else if ( (lpMmCmd->ulHandle & DAL_MULTIMEDIA_AMC_16BIT_PORT)
== DAL_MULTIMEDIA_AMC_16BIT_PORT )
{
if ( (lpHDE->ulMultiMediaInfo & DAL_MULTIMEDIA_AMC_16BIT_PORT)
== DAL_MULTIMEDIA_AMC_16BIT_PORT )
{
lpHDE->ulMultiMediaInfo &= ~lpMmCmd->ulHandle;
}
else
{
// 16-bit VIP port has not be allocated. Bad input.
ulReturn = CWDDE_ERR_BADINPUT;
}
}
else if (lpMmCmd->ulHandle & DAL_MULTIMEDIA_AMC_8BIT_PORT1)
{
if ( (lpHDE->ulMultiMediaInfo & DAL_MULTIMEDIA_AMC_8BIT_PORT1)
&& ((lpHDE->ulMultiMediaInfo & DAL_MULTIMEDIA_AMC_16BIT_PORT)
!= DAL_MULTIMEDIA_AMC_16BIT_PORT ))
{
// to free port 1 successfully:
// 1. port 1 must be allocated
// 2. VIP 16bit must not be allocated.
lpHDE->ulMultiMediaInfo &= ~lpMmCmd->ulHandle;
}
else
{
ulReturn = CWDDE_ERR_BADINPUT;
}
}
else if (lpMmCmd->ulHandle & DAL_MULTIMEDIA_AMC_8BIT_PORT2)
{
if ( (lpHDE->ulMultiMediaInfo & DAL_MULTIMEDIA_AMC_8BIT_PORT2)
&& ((lpHDE->ulMultiMediaInfo & DAL_MULTIMEDIA_AMC_16BIT_PORT)
!= DAL_MULTIMEDIA_AMC_16BIT_PORT ))
{
// to free port 2 successfully:
// 1. port 2 must be allocated
// 2. VIP 16bit must not be allocated.
lpHDE->ulMultiMediaInfo &= ~lpMmCmd->ulHandle;
}
else
{
// The bit set is not one of the AMC port bits so return badinput
ulReturn = CWDDE_ERR_BADINPUT;
}
}
else
{
// The bit set is not one of the AMC port bits so return badinput
ulReturn = CWDDE_ERR_BADINPUT;
}
}
*lpInfoSize = 0;
break;
case CWDDEMM_FreeMemBandwidth:
{
ULONG ulEngineIndex;
*lpInfoSize = 0;
if (ulInputSize < sizeof(CWDDEMMCMD))
{
// input size is less than expected
ulReturn = CWDDE_ERR_BADINPUTSIZE;
break;
}
// Determine engine index
if (!bDetermineVCEngineIndex(lpMmCmd->ulHandle, &ulEngineIndex))
{
// input size is less than expected
ulReturn = CWDDE_ERR_BADINPUT;
break;
}
// Determine if engine is allocated
if (!lpHDE->aCaptureEngine[ulEngineIndex].bEnabled)
{
ulReturn = (ULONG)CWDDEMM_ERR_BADINPUT;
break;
}
// NOTE: HTime only support one capture engine currently. Do we have 2 engines
// run at one time??????
ZEROMEMORY((LPVOID)&lpHDE->aPrioTable[3], sizeof(PRIO_ELEM));
// assume controller 1 always get initialized before.
vIncrementBandwidth(&lpHDE->aControllers[0].lpHWED->sAvailBandwidth,
&lpHDE->aCaptureEngine[ulEngineIndex].sAveBWAllocated);
vIncrementBandwidth(&lpHDE->aControllers[0].lpHWED->sAvailPeakBandwidth,
&lpHDE->aCaptureEngine[ulEngineIndex].sPeakBWAllocated);
ZEROMEMORY((LPVOID)&lpHDE->aCaptureEngine[ulEngineIndex], sizeof(CAPTURE_ENGINE));
}
break;
case CWDDEMM_GetAsicId:
{
MM_ASICID FAR *lpMMAsicId;
if (ulOutputSize < sizeof(MM_ASICID))
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -