INT CmDevice_RT::SetCapsInternal(CM_DEVICE_CAP_NAME capName, size_t capValueSize,
void *pCapValue)
{
CM_RETURN_CODE hr = CM_SUCCESS;
DXVA_CM_SET_CAPS setCaps;
UINT maxValue;
size_t size = sizeof(maxValue);
CmSafeMemSet(&setCaps, 0, sizeof(setCaps));
switch (capName) {
case CAP_HW_THREAD_COUNT:
if (capValueSize != sizeof(UINT)) {
CM_ASSERT(0);
return CM_INVALID_HARDWARE_THREAD_NUMBER;
}
if (*(UINT *) pCapValue <= 0) {
CM_ASSERT(0);
return CM_INVALID_HARDWARE_THREAD_NUMBER;
}
GetCaps(CAP_HW_THREAD_COUNT, size, &maxValue);
if (*(UINT *) pCapValue > maxValue) {
CM_ASSERT(0);
return CM_INVALID_HARDWARE_THREAD_NUMBER;
}
setCaps.Type = DXVA_CM_MAX_HW_THREADS;
setCaps.MaxValue = *(UINT *) pCapValue;
break;
case CAP_L3_CONFIG:
if (capValueSize != sizeof(L3_CONFIG_REGISTER_VALUES)){
CM_ASSERT(0);
return CM_INVALIDE_L3_CONFIGURATION;
}
else {
L3_CONFIG_REGISTER_VALUES *l3_c = (L3_CONFIG_REGISTER_VALUES *)pCapValue;
setCaps.L3_SQCREG1 = l3_c->SQCREG1_VALUE;
setCaps.L3_CNTLREG2 = l3_c->CNTLREG2_VALUE;
setCaps.L3_CNTLREG3 = l3_c->CNTLREG3_VALUE;
setCaps.L3_CNTLREG = l3_c->CNTLREG_VALUE;
setCaps.Type = DXVA_CM_MAX_HW_L3_CONFIG;
}
break;
default:
return CM_FAILURE;
}
PCM_CONTEXT pCmData = (PCM_CONTEXT) this->GetAccelData();
CHK_GENOSSTATUS_RETURN_CMERROR(pCmData->pCmHalState->
pfnSetCaps(pCmData->pCmHalState,
(PCM_HAL_MAX_SET_CAPS_PARAM)
& setCaps));
finish:
return hr;
}
CM_RT_API INT
CmDevice_RT::GetSurface2DInfo(UINT width, UINT height,
CM_SURFACE_FORMAT format, UINT & pitch,
UINT & physicalSize)
{
CM_RETURN_CODE hr = CM_SUCCESS;
CM_HAL_SURFACE2D_UP_PARAM inParam;
PCM_CONTEXT pCmData;
PCM_HAL_STATE pCmHalState;
CMCHK_HR(m_pSurfaceMgr->Surface2DSanityCheck(width, height, format));
CmSafeMemSet(&inParam, 0, sizeof(CM_HAL_SURFACE2D_UP_PARAM));
inParam.iWidth = width;
inParam.iHeight = height;
inParam.format = m_pSurfaceMgr->CmFmtToGenHwFmt(format);
pCmData = (PCM_CONTEXT) GetAccelData();
pCmHalState = pCmData->pCmHalState;
CHK_GENOSSTATUS_RETURN_CMERROR(pCmHalState->pfnGetSurface2DPitchAndSize
(pCmHalState, &inParam));
pitch = inParam.iPitch;
physicalSize = inParam.iPhysicalSize;
finish:
return hr;
}
INT CmDevice_RT::CreateAuxDevice(CmDriverContext * pDriverContext)
{
INT hr = CM_SUCCESS;
PCM_HAL_STATE pCmHalState;
PCM_CONTEXT pCmCtx;
PGENOS_CONTEXT pOsContext;
pOsContext =
(PGENOS_CONTEXT) GENOS_AllocAndZeroMemory(sizeof(GENOS_CONTEXT));
CMCHK_NULL(pOsContext);
if (pDriverContext) {
pOsContext->wDeviceID = pDriverContext->deviceid;
pOsContext->wRevision = pDriverContext->device_rev;
pOsContext->bufmgr = pDriverContext->bufmgr;
}
m_pUmdContext = pOsContext;
CHK_GENOSSTATUS_RETURN_CMERROR(HalCm_Create
(pOsContext, &m_DevCreateOption,
&pCmHalState));
CHK_GENOSSTATUS_RETURN_CMERROR(pCmHalState->pfnCmAllocate(pCmHalState));
pCmCtx = (PCM_CONTEXT) GENOS_AllocAndZeroMemory(sizeof(CM_CONTEXT));
CMCHK_NULL(pCmCtx);
pCmCtx->GenHwDrvCtx = *pOsContext;
pCmCtx->pCmHalState = pCmHalState;
m_pAccelData = (PVOID) pCmCtx;
CMCHK_HR_MESSAGE(GetMaxValueFromCaps(m_HalMaxValues, m_HalMaxValuesEx),
"Failed to get Max values.");
CMCHK_HR_MESSAGE(GetGenPlatform(m_Platform), "Failed to get GPU type.");
m_DDIVersion = VA_CM_VERSION;
finish:
return hr;
}
INT CmEvent::Query(void)
{
CM_RETURN_CODE hr = CM_SUCCESS;
if ((m_Status != CM_STATUS_FLUSHED) && (m_Status != CM_STATUS_STARTED)) {
return CM_FAILURE;
}
CM_ASSERT(m_TaskDriverId > -1);
CM_HAL_QUERY_TASK_PARAM param;
param.iTaskId = m_TaskDriverId;
PCM_CONTEXT pCmData = (PCM_CONTEXT) m_pDevice->GetAccelData();
CHK_GENOSSTATUS_RETURN_CMERROR(pCmData->pCmHalState->
pfnQueryTask(pCmData->pCmHalState,
¶m));
if (param.status == CM_TASK_FINISHED) {
CmQueue *pQueue = NULL;
m_Time = param.iTaskDuration;
m_Status = CM_STATUS_FINISHED;
m_GlobalCMSubmitTime = param.iTaskGlobalCMSubmitTime;
m_CMSubmitTimeStamp = param.iTaskCMSubmitTimeStamp;
m_HWStartTimeStamp = param.iTaskHWStartTimeStamp;
m_HWEndTimeStamp = param.iTaskHWEndTimeStamp;
m_CompleteTime = param.iTaskCompleteTime;
m_pDevice->GetQueue(pQueue);
if (!pQueue) {
CM_ASSERT(0);
return CM_FAILURE;
}
if (m_OsData) {
drm_intel_bo_unreference((drm_intel_bo *) m_OsData);
}
m_GlobalCMSubmitTime = param.iTaskGlobalCMSubmitTime;
m_CMSubmitTimeStamp = param.iTaskCMSubmitTimeStamp;
m_HWStartTimeStamp = param.iTaskHWStartTimeStamp;
m_HWEndTimeStamp = param.iTaskHWEndTimeStamp;
m_CompleteTime = param.iTaskCompleteTime;
} else if (param.status == CM_TASK_IN_PROGRESS) {
m_Status = CM_STATUS_STARTED;
}
finish:
return hr;
}
INT CmSurfaceManager::FreeSurface2D(UINT handle)
{
CM_RETURN_CODE hr = CM_SUCCESS;
PCM_CONTEXT pCmData = (PCM_CONTEXT) m_pCmDevice->GetAccelData();
CHK_GENOSSTATUS_RETURN_CMERROR(pCmData->
pCmHalState->pfnFreeSurface2D(pCmData->
pCmHalState,
handle));
finish:
return hr;
}
INT CmSurfaceManager::UpdateBuffer(CmBuffer_RT * pSurface1D, UINT size)
{
CM_RETURN_CODE hr = CM_SUCCESS;
UINT handle = 0;
pSurface1D->GetHandle(handle);
pSurface1D->SetSize(size);
PCM_CONTEXT pCmData = (PCM_CONTEXT) m_pCmDevice->GetAccelData();
CHK_GENOSSTATUS_RETURN_CMERROR(pCmData->
pCmHalState->pfnUpdateBuffer(pCmData->
pCmHalState,
(DWORD)
handle,
size));
finish:
return hr;
}
INT CmSurfaceManager::AllocateSurface2D(UINT width, UINT height,
CM_SURFACE_FORMAT format, UINT & handle,
UINT & pitch)
{
CM_RETURN_CODE hr = CM_SUCCESS;
GENOS_STATUS genos_status = GENOS_STATUS_SUCCESS;
PCM_CONTEXT pCmData = (PCM_CONTEXT) m_pCmDevice->GetAccelData();
CM_HAL_SURFACE2D_PARAM inParam;
CmSafeMemSet(&inParam, 0, sizeof(CM_HAL_SURFACE2D_PARAM));
inParam.iWidth = width;
inParam.iHeight = height;
inParam.format = CmFmtToGenHwFmt(format);
inParam.pData = NULL;
inParam.isAllocatedbyCmrtUmd = TRUE;
genos_status =
pCmData->pCmHalState->pfnAllocateSurface2D(pCmData->pCmHalState,
&inParam);
while (genos_status == GENOS_STATUS_NO_SPACE) {
if (!TouchSurfaceInPoolForDestroy()) {
CM_ASSERT(0);
return CM_SURFACE_ALLOCATION_FAILURE;
}
genos_status =
pCmData->pCmHalState->pfnAllocateSurface2D(pCmData->
pCmHalState,
&inParam);
}
GENOSSTATUS2CM_AND_CHECK(genos_status, hr);
handle = inParam.dwHandle;
CHK_GENOSSTATUS_RETURN_CMERROR(pCmData->
pCmHalState->pfnGetSurface2DTileYPitch
(pCmData->pCmHalState, &inParam));
pitch = inParam.iPitch;
finish:
return hr;
}
INT CmSurfaceManager::UpdateSurface2D(CmSurface2D * pSurface2D, UINT width,
UINT height, CM_SURFACE_FORMAT format)
{
CM_RETURN_CODE hr = CM_SUCCESS;
UINT handle = 0;
pSurface2D->GetHandle(handle);
pSurface2D->SetSurfaceProperties(width, height, format);
PCM_CONTEXT pCmData = (PCM_CONTEXT) m_pCmDevice->GetAccelData();
CHK_GENOSSTATUS_RETURN_CMERROR(pCmData->
pCmHalState->pfnUpdateSurface2D(pCmData->
pCmHalState,
(DWORD)
handle,
width,
height));
finish:
return hr;
}
INT CmDevice_RT::GetCapsInternal(PVOID pCaps, PUINT puSize)
{
PDXVA_CM_QUERY_CAPS pQueryCaps;
PCM_CONTEXT pCmData;
PCM_HAL_STATE pCmHalState;
CM_RETURN_CODE hr = CM_SUCCESS;
if ((!puSize) || (!pCaps) || (*puSize < sizeof(DXVA_CM_QUERY_CAPS))) {
CM_ASSERTMESSAGE("Invalid Arguments.");
hr = CM_FAILURE;
goto finish;
}
pQueryCaps = (PDXVA_CM_QUERY_CAPS) pCaps;
*puSize = sizeof(DXVA_CM_QUERY_CAPS);
if (pQueryCaps->Type == DXVA_CM_QUERY_VERSION) {
pQueryCaps->iVersion = DXVA_CM_VERSION;
hr = CM_SUCCESS;
goto finish;
}
pCmData = (PCM_CONTEXT) GetAccelData();
CMCHK_NULL(pCmData);
pCmHalState = pCmData->pCmHalState;
CMCHK_NULL(pCmHalState);
switch (pQueryCaps->Type) {
case DXVA_CM_QUERY_REG_HANDLE:
pQueryCaps->hRegistration =
(HANDLE *) & pCmHalState->SurfaceRegTable;
break;
case DXVA_CM_MAX_VALUES:
CHK_GENOSSTATUS_RETURN_CMERROR(pCmHalState->pfnGetMaxValues
(pCmHalState,
&pQueryCaps->MaxValues));
break;
case DXVA_CM_MAX_VALUES_EX:
CHK_GENOSSTATUS_RETURN_CMERROR(pCmHalState->pfnGetMaxValuesEx
(pCmHalState,
&pQueryCaps->MaxValuesEx));
break;
case DXVA_CM_QUERY_GPU:
pQueryCaps->genCore =
pCmHalState->pHwInterface->Platform.eRenderCoreFamily;
break;
case DXVA_CM_QUERY_GT:
if (GFX_IS_PRODUCT
(pCmHalState->pHwInterface->Platform, IGFX_CHERRYVIEW)) {
pQueryCaps->genGT = PLATFORM_INTEL_GTCHV;
} else if (pCmHalState->pHwInterface->Platform.GtType ==
GTTYPE_GT1) {
pQueryCaps->genGT = PLATFORM_INTEL_GT1;
} else if (pCmHalState->pHwInterface->Platform.GtType ==
GTTYPE_GT2) {
pQueryCaps->genGT = PLATFORM_INTEL_GT2;
} else if (pCmHalState->pHwInterface->Platform.GtType ==
GTTYPE_GT3) {
pQueryCaps->genGT = PLATFORM_INTEL_GT3;
}
break;
case DXVA_CM_QUERY_STEP:
pQueryCaps->genStepId = pCmHalState->Platform.usRevId;
break;
case DXVA_CM_QUERY_GPU_FREQ:
CHK_GENOSSTATUS_RETURN_CMERROR
(pCmHalState->pfnGetGPUCurrentFrequency
(pCmHalState, &pQueryCaps->GPUCurrentFreq));
break;
case DXVA_CM_QUERY_SURFACE2D_FORMAT_COUNT:
pQueryCaps->Surface2DCount =
CM_MAX_SURFACE2D_FORMAT_COUNT_INTERNAL;
break;
case DXVA_CM_QUERY_SURFACE2D_FORMATS:
if (pQueryCaps->pSurface2DFormats) {
CM_SURFACE_FORMAT
formats[CM_MAX_SURFACE2D_FORMAT_COUNT_INTERNAL] = {
CM_SURFACE_FORMAT_X8R8G8B8,
CM_SURFACE_FORMAT_A8R8G8B8,
CM_SURFACE_FORMAT_R32F,
CM_SURFACE_FORMAT_V8U8,
CM_SURFACE_FORMAT_P8,
CM_SURFACE_FORMAT_YUY2,
CM_SURFACE_FORMAT_A8,
CM_SURFACE_FORMAT_NV12,
CM_SURFACE_FORMAT_UYVY,
CM_SURFACE_FORMAT_R8_UINT,
CM_SURFACE_FORMAT_R16_UINT,
CM_SURFACE_FORMAT_411P,
CM_SURFACE_FORMAT_422H,
CM_SURFACE_FORMAT_444P,
CM_SURFACE_FORMAT_IMC3,
CM_SURFACE_FORMAT_422V,
CM_SURFACE_FORMAT_YV12,};
CmSafeMemCopy(pQueryCaps->pSurface2DFormats, formats,
CM_MAX_SURFACE2D_FORMAT_COUNT_INTERNAL *
sizeof(CM_SURFACE_FORMAT));
break;
} else {
hr = CM_FAILURE;
goto finish;
}
default:
hr = CM_FAILURE;
goto finish;
}
finish:
return hr;
}
INT CmQueue::FlushEnqueueWithHintsTask(CmTaskInternal * pTask)
{
CM_RETURN_CODE hr = CM_SUCCESS;
CM_HAL_EXEC_HINTS_TASK_PARAM param;
PCM_CONTEXT pCmData = NULL;
CmKernelData *pKernelData = NULL;
UINT kernelDataSize = 0;
UINT count = 0;
CmEvent *pEvent = NULL;
PCM_HAL_KERNEL_PARAM pTempData = NULL;
CmSafeMemSet(¶m, 0, sizeof(CM_HAL_EXEC_HINTS_TASK_PARAM));
pTask->GetKernelCount(count);
param.iNumKernels = count;
param.pKernels = new(std::nothrow) PCM_HAL_KERNEL_PARAM[count];
param.piKernelSizes = new(std::nothrow) UINT[count];
param.piKernelCurbeOffset = new(std::nothrow) UINT[count];
CMCHK_NULL(param.pKernels);
CMCHK_NULL(param.piKernelSizes);
CMCHK_NULL(param.piKernelCurbeOffset);
pTask->GetHints(param.iHints);
pTask->GetNumTasksGenerated(param.iNumTasksGenerated);
pTask->GetLastTask(param.isLastTask);
for (UINT i = 0; i < count; i++) {
pTask->GetKernelData(i, pKernelData);
CMCHK_NULL(pKernelData);
pTask->GetKernelDataSize(i, kernelDataSize);
if (kernelDataSize == 0) {
CM_ASSERT(0);
hr = CM_FAILURE;
goto finish;
}
pTempData = pKernelData->GetHalCmKernelData();
param.pKernels[i] = pTempData;
param.piKernelSizes[i] = kernelDataSize;
param.piKernelCurbeOffset[i] = pTask->GetKernelCurbeOffset(i);
}
pCmData = (PCM_CONTEXT) m_pDevice->GetAccelData();
CMCHK_NULL(pCmData);
CHK_GENOSSTATUS_RETURN_CMERROR(pCmData->pCmHalState->
pfnSetPowerOption(pCmData->pCmHalState,
pTask->GetPowerOption
()));
CHK_GENOSSTATUS_RETURN_CMERROR(pCmData->pCmHalState->pfnExecuteHintsTask
(pCmData->pCmHalState, ¶m));
if (param.iTaskIdOut < 0) {
CM_ASSERT(0);
hr = CM_FAILURE;
goto finish;
}
pTask->GetTaskEvent(pEvent);
CMCHK_NULL(pEvent);
CMCHK_HR(pEvent->SetTaskDriverId(param.iTaskIdOut));
CMCHK_HR(pEvent->SetTaskOsData(param.OsData));
CMCHK_HR(pTask->ReleaseKernel());
finish:
CmSafeDeleteArray(param.pKernels);
CmSafeDeleteArray(param.piKernelSizes);
CmSafeDeleteArray(param.piKernelCurbeOffset);
return hr;
}
INT CmQueue::FlushGroupTask(CmTaskInternal * pTask)
{
CM_RETURN_CODE hr = CM_SUCCESS;
CM_HAL_EXEC_TASK_GROUP_PARAM param;
CmKernelData *pKernelData = NULL;
UINT kernelDataSize = 0;
UINT count = 0;
PCM_CONTEXT pCmData = NULL;
CmEvent *pEvent = NULL;
PCM_HAL_KERNEL_PARAM pTempData = NULL;
CmSafeMemSet(¶m, 0, sizeof(CM_HAL_EXEC_TASK_GROUP_PARAM));
pTask->GetKernelCount(count);
param.iNumKernels = count;
param.pKernels = new(std::nothrow) PCM_HAL_KERNEL_PARAM[count];
param.piKernelSizes = new(std::nothrow) UINT[count];
param.piKernelCurbeOffset = new(std::nothrow) UINT[count];
param.iPreemptionMode = pTask->GetPreemptionMode();
CMCHK_NULL(param.pKernels);
CMCHK_NULL(param.piKernelSizes);
CMCHK_NULL(param.piKernelCurbeOffset);
for (UINT i = 0; i < count; i++) {
pTask->GetKernelData(i, pKernelData);
CMCHK_NULL(pKernelData);
pTask->GetKernelDataSize(i, kernelDataSize);
if (kernelDataSize == 0) {
CM_ASSERT(0);
hr = CM_FAILURE;
goto finish;
}
pTempData = pKernelData->GetHalCmKernelData();
param.pKernels[i] = pTempData;
param.piKernelSizes[i] = kernelDataSize;
param.piKernelCurbeOffset[i] = pTask->GetKernelCurbeOffset(i);
param.bGlobalSurfaceUsed |= pTempData->bGlobalSurfaceUsed;
param.bKernelDebugEnabled |= pTempData->bKernelDebugEnabled;
}
pTask->GetSLMSize(param.iSLMSize);
if (param.iSLMSize > MAX_SLM_SIZE_PER_GROUP_IN_1K) {
CM_ASSERT(0);
hr = CM_EXCEED_MAX_SLM_SIZE;
goto finish;
}
if (pTask->IsThreadGroupSpaceCreated()) {
pTask->GetThreadGroupSpaceSize(param.threadSpaceWidth,
param.threadSpaceHeight,
param.groupSpaceWidth,
param.groupSpaceHeight);
}
param.uiSyncBitmap = pTask->GetSyncBitmap();
pCmData = (PCM_CONTEXT) m_pDevice->GetAccelData();
CHK_GENOSSTATUS_RETURN_CMERROR(pCmData->pCmHalState->pfnExecuteGroupTask
(pCmData->pCmHalState, ¶m));
if (param.iTaskIdOut < 0) {
CM_ASSERT(0);
hr = CM_FAILURE;
goto finish;
}
pTask->GetTaskEvent(pEvent);
CMCHK_NULL(pEvent);
CMCHK_HR(pEvent->SetTaskDriverId(param.iTaskIdOut));
CMCHK_HR(pEvent->SetTaskOsData(param.OsData));
CMCHK_HR(pTask->ReleaseKernel());
finish:
CmSafeDeleteArray(param.pKernels);
CmSafeDeleteArray(param.piKernelSizes);
CmSafeDeleteArray(param.piKernelCurbeOffset);
return hr;
}
INT CmQueue::FlushGeneralTask(CmTaskInternal * pTask)
{
CM_RETURN_CODE hr = CM_SUCCESS;
CM_HAL_EXEC_TASK_PARAM param;
CmKernelData *pKernelData = NULL;
UINT kernelDataSize = 0;
PCM_CONTEXT pCmData = NULL;
CmEvent *pEvent = NULL;
UINT totalThreadCount = 0;
UINT count = 0;
PCM_HAL_KERNEL_PARAM pTempData = NULL;
CmSafeMemSet(¶m, 0, sizeof(CM_HAL_EXEC_TASK_PARAM));
pTask->GetKernelCount(count);
param.iNumKernels = count;
param.pKernels = new(std::nothrow) PCM_HAL_KERNEL_PARAM[count];
param.piKernelSizes = new(std::nothrow) UINT[count];
param.piKernelCurbeOffset = new(std::nothrow) UINT[count];
CMCHK_NULL_RETURN(param.pKernels, CM_OUT_OF_HOST_MEMORY);
CMCHK_NULL_RETURN(param.piKernelSizes, CM_OUT_OF_HOST_MEMORY);
CMCHK_NULL_RETURN(param.piKernelCurbeOffset, CM_OUT_OF_HOST_MEMORY);
for (UINT i = 0; i < count; i++) {
pTask->GetKernelData(i, pKernelData);
CMCHK_NULL(pKernelData);
pTask->GetKernelDataSize(i, kernelDataSize);
if (kernelDataSize == 0) {
CM_ASSERT(0);
hr = CM_FAILURE;
goto finish;
}
pTempData = pKernelData->GetHalCmKernelData();
param.pKernels[i] = pTempData;
param.piKernelSizes[i] = kernelDataSize;
param.piKernelCurbeOffset[i] = pTask->GetKernelCurbeOffset(i);
param.bGlobalSurfaceUsed |= pTempData->bGlobalSurfaceUsed;
param.bKernelDebugEnabled |= pTempData->bKernelDebugEnabled;
}
pTask->GetTotalThreadCount(totalThreadCount);
param.threadSpaceWidth =
(totalThreadCount >
CM_MAX_THREADSPACE_WIDTH) ? CM_MAX_THREADSPACE_WIDTH :
totalThreadCount;
if (totalThreadCount % CM_MAX_THREADSPACE_WIDTH) {
param.threadSpaceHeight =
totalThreadCount / CM_MAX_THREADSPACE_WIDTH + 1;
} else {
param.threadSpaceHeight =
totalThreadCount / CM_MAX_THREADSPACE_WIDTH;
}
param.DependencyPattern = CM_DEPENDENCY_NONE;
if (pTask->IsThreadSpaceCreated()) {
if (pTask->IsThreadCoordinatesExisted()) {
param.ppThreadCoordinates =
new(std::nothrow) PCM_HAL_SCOREBOARD_XY[count];
param.ppDependencyMasks =
new(std::nothrow) PCM_HAL_MASK_AND_RESET[count];
CMCHK_NULL_RETURN(param.ppThreadCoordinates,
CM_OUT_OF_HOST_MEMORY);
CMCHK_NULL_RETURN(param.ppDependencyMasks,
CM_OUT_OF_HOST_MEMORY);
for (UINT i = 0; i < count; i++) {
void *pKernelCoordinates = NULL;
void *pDependencyMasks = NULL;
pTask->GetKernelCoordinates(i,
pKernelCoordinates);
pTask->GetKernelDependencyMasks(i,
pDependencyMasks);
param.ppThreadCoordinates[i] =
(PCM_HAL_SCOREBOARD_XY) pKernelCoordinates;
param.ppDependencyMasks[i] =
(PCM_HAL_MASK_AND_RESET) pDependencyMasks;
}
} else {
param.ppThreadCoordinates = NULL;
}
pTask->GetDependencyPattern(param.DependencyPattern);
pTask->GetThreadSpaceSize(param.threadSpaceWidth,
param.threadSpaceHeight);
pTask->GetWalkingPattern(param.WalkingPattern);
if (pTask->CheckWalkingParametersSet()) {
param.walkingParamsValid = 1;
CMCHK_HR(pTask->GetWalkingParameters
(param.walkingParams));
} else {
param.walkingParamsValid = 0;
}
if (pTask->CheckDependencyVectorsSet()) {
param.dependencyVectorsValid = 1;
CMCHK_HR(pTask->GetDependencyVectors
(param.dependencyVectors));
} else {
param.dependencyVectorsValid = 0;
}
}
pTask->GetColorCountMinusOne(param.ColorCountMinusOne);
param.uiSyncBitmap = pTask->GetSyncBitmap();
pCmData = (PCM_CONTEXT) m_pDevice->GetAccelData();
CHK_GENOSSTATUS_RETURN_CMERROR(pCmData->pCmHalState->
pfnSetPowerOption(pCmData->pCmHalState,
pTask->GetPowerOption
()));
CHK_GENOSSTATUS_RETURN_CMERROR(pCmData->pCmHalState->
pfnExecuteTask(pCmData->pCmHalState,
¶m));
if (param.iTaskIdOut < 0) {
CM_ASSERT(0);
hr = CM_FAILURE;
goto finish;
}
pTask->GetTaskEvent(pEvent);
CMCHK_NULL(pEvent);
CMCHK_HR(pEvent->SetTaskDriverId(param.iTaskIdOut));
CMCHK_HR(pEvent->SetTaskOsData(param.OsData));
CMCHK_HR(pTask->ReleaseKernel());
finish:
CmSafeDeleteArray(param.pKernels);
CmSafeDeleteArray(param.piKernelSizes);
CmSafeDeleteArray(param.ppThreadCoordinates);
CmSafeDeleteArray(param.ppDependencyMasks);
CmSafeDeleteArray(param.piKernelCurbeOffset);
return hr;
}
