/*
* Copyright (c) 2022, Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
//!
//! \file mos_utilities_usersetting.cpp
//! \brief This module implements the MOS wrapper functions
//!
#include "mos_os.h"
#include "mos_util_user_interface.h"
#include "media_user_settings_mgr.h"
#define __MAX_MULTI_STRING_COUNT 128
char s_xmlFilePath[MOS_USER_CONTROL_MAX_DATA_SIZE] = {};
/*****************************************************************************
|
| USER FEATURE Functions
|
*****************************************************************************/
void MosUtilities::MosFreeUserFeatureValueString(PMOS_USER_FEATURE_VALUE_STRING pUserString)
{
if (pUserString != nullptr)
{
if (pUserString->uSize > 0)
{
if (pUserString->pStringData)
{
MOS_FreeMemAndSetNull(pUserString->pStringData);
MosAtomicDecrement(m_mosMemAllocFakeCounter);
}
pUserString->uSize = 0;
}
}
}
MOS_STATUS MosUtilities::MosWriteOneUserFeatureKeyToXML(PMOS_USER_FEATURE_VALUE pUserFeature)
{
char sOutBuf[MOS_USER_CONTROL_MAX_DATA_SIZE];
char ValueType[MAX_USER_FEATURE_FIELD_LENGTH];
char KeyPath[MOS_USER_CONTROL_MAX_DATA_SIZE];
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
MOS_OS_CHK_NULL_RETURN(pUserFeature);
switch (pUserFeature->Type)
{
case MOS_USER_FEATURE_TYPE_USER:
MosSecureStringPrint(
KeyPath,
sizeof(KeyPath),
sizeof(KeyPath),
"UFINT\\%s",
pUserFeature->pcPath);
break;
case MOS_USER_FEATURE_TYPE_SYSTEM:
MosSecureStringPrint(
KeyPath,
sizeof(KeyPath),
sizeof(KeyPath),
"UFEXT\\%s",
pUserFeature->pcPath);
break;
default:
MosSecureStringPrint(
KeyPath,
sizeof(KeyPath),
sizeof(KeyPath),
"%s",pUserFeature->pcPath);
break;
}
switch (pUserFeature->ValueType)
{
case MOS_USER_FEATURE_VALUE_TYPE_BOOL:
MosSecureStringPrint(
ValueType,
sizeof(ValueType),
sizeof(ValueType),
"bool");
break;
case MOS_USER_FEATURE_VALUE_TYPE_FLOAT:
case MOS_USER_FEATURE_VALUE_TYPE_UINT32:
case MOS_USER_FEATURE_VALUE_TYPE_INT32:
MosSecureStringPrint(
ValueType,
sizeof(ValueType),
sizeof(ValueType),
"dword");
break;
case MOS_USER_FEATURE_VALUE_TYPE_UINT64:
case MOS_USER_FEATURE_VALUE_TYPE_INT64:
MosSecureStringPrint(
ValueType,
sizeof(ValueType),
sizeof(ValueType),
"qword");
break;
case MOS_USER_FEATURE_VALUE_TYPE_MULTI_STRING:
case MOS_USER_FEATURE_VALUE_TYPE_STRING:
MosSecureStringPrint(
ValueType,
sizeof(ValueType),
sizeof(ValueType),
"string");
break;
default:
MosSecureStringPrint(
ValueType,
sizeof(ValueType),
sizeof(ValueType),
"unknown");
break;
}
MosZeroMemory(sOutBuf, sizeof(sOutBuf));
MosSecureStringPrint(
sOutBuf,
sizeof(sOutBuf),
sizeof(sOutBuf),
" \n",
pUserFeature->pValueName,
ValueType,
KeyPath,
pUserFeature->DefaultValue,
pUserFeature->pcDescription);
MosAppendFileFromPtr(
s_xmlFilePath,
sOutBuf,
(uint32_t)strlen(sOutBuf));
return eStatus;
}
MOS_STATUS MosUtilities::MosWriteOneUserFeatureGroupToXML(MOS_USER_FEATURE_VALUE UserFeatureFilter)
{
char sOutBuf[MAX_USER_FEATURE_FIELD_LENGTH];
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
// Group Header Start
MosZeroMemory(sOutBuf, sizeof(sOutBuf));
MosSecureStringPrint(
sOutBuf,
sizeof(sOutBuf),
sizeof(sOutBuf),
" \n",
UserFeatureFilter.pcGroup);
eStatus = MosAppendFileFromPtr(
s_xmlFilePath,
sOutBuf,
(uint32_t)strlen(sOutBuf));
// Group User Feature Keys
eStatus = MosGetItemFromMosUserFeatureDescField(
m_mosUserFeatureDescFields,
__MOS_USER_FEATURE_KEY_MAX_ID,
__MOS_USER_FEATURE_KEY_MAX_ID,
&MosWriteOneUserFeatureKeyToXML,
&UserFeatureFilter);
// Group Header End
MosZeroMemory(sOutBuf, sizeof(sOutBuf));
MosSecureStringPrint(
sOutBuf,
sizeof(sOutBuf),
sizeof(sOutBuf),
" \n");
eStatus = MosAppendFileFromPtr(
s_xmlFilePath,
sOutBuf,
(uint32_t)strlen(sOutBuf));
return eStatus;
}
MOS_STATUS MosUtilities::MosGenerateUserFeatureKeyXML(MOS_CONTEXT_HANDLE mosCtx)
{
char sOutBuf[MAX_USER_FEATURE_FIELD_LENGTH];
uint32_t uiIndex=0;
MOS_USER_FEATURE_VALUE UserFeatureFilter = __NULL_USER_FEATURE_VALUE__;
MOS_USER_FEATURE_VALUE_DATA UserFeatureData;
const char * const FilterGroups[] = { "Codec", "Decode", "Encode", "CP", "General", "MOS",
"Report", "VP", "Media", "Secure HEVC Encode", "MDF"};
uint32_t FilterGroupsCount = sizeof(FilterGroups) / sizeof(FilterGroups[0]);
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
// Check if XML dump is enabled by User Feature Key
MosZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
eStatus = MosUserFeatureReadValueID(
nullptr,
__MOS_USER_FEATURE_KEY_XML_AUTOGEN_ID,
&UserFeatureData,
mosCtx);
if (UserFeatureData.u32Data == 0)
{
eStatus = MOS_STATUS_INVALID_PARAMETER;
return eStatus;
}
MosZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
UserFeatureData.StringData.pStringData = s_xmlFilePath;
eStatus = MosUserFeatureReadValueID(
nullptr,
__MOS_USER_FEATURE_KEY_XML_FILEPATH_ID,
&UserFeatureData,
mosCtx);
// User Feature Key Header Start
MosZeroMemory(sOutBuf, sizeof(sOutBuf));
MosSecureStringPrint(
sOutBuf,
sizeof(sOutBuf),
sizeof(sOutBuf),
"\n");
eStatus = MosWriteFileFromPtr(
UserFeatureData.StringData.pStringData,
sOutBuf,
(uint32_t)strlen(sOutBuf));
// User Feature Key Groups
for (uiIndex = 0; uiIndex < FilterGroupsCount; uiIndex++)
{
UserFeatureFilter.pcGroup = FilterGroups[uiIndex];
eStatus = MosWriteOneUserFeatureGroupToXML(UserFeatureFilter);
if (eStatus!= MOS_STATUS_SUCCESS)
{
MOS_OS_ASSERTMESSAGE("Failed to Write One User FeatureGroup To XML");
}
}
// User Feature Key Header End
MosZeroMemory(sOutBuf, sizeof(sOutBuf));
MosSecureStringPrint(
sOutBuf,
sizeof(sOutBuf),
sizeof(sOutBuf),
"\n");
eStatus = MosAppendFileFromPtr(
UserFeatureData.StringData.pStringData,
sOutBuf,
(uint32_t)strlen(sOutBuf));
return eStatus;
}
MOS_STATUS MosUtilities::MosUserFeatureSetMultiStringValue(
PMOS_USER_FEATURE_VALUE_DATA pFeatureData,
uint32_t dwSize)
{
PMOS_USER_FEATURE_VALUE_STRING pStrings;
uint32_t uiNumStrings;
uint32_t ui;
char *pData;
char *pCurData;
uint32_t dwLen;
uint32_t dwPos;
MOS_OS_CHK_NULL_RETURN(pFeatureData);
MOS_OS_ASSERT(dwSize);
pStrings = pFeatureData->MultiStringData.pStrings;
pData = pFeatureData->MultiStringData.pMultStringData;
dwPos = 0;
uiNumStrings = 0;
MOS_OS_ASSERT(pStrings);
MOS_OS_ASSERT(pData);
// Find number of strings in the multi string array
do
{
pCurData = pData + dwPos;
dwLen = (uint32_t)strlen(pCurData);
if (dwLen == 0)
{
MOS_OS_NORMALMESSAGE("Invalid user feature key entry.");
return MOS_STATUS_INVALID_PARAMETER;
}
uiNumStrings++;
dwPos += dwLen + 1;
if (dwPos >= (dwSize - 1))
{
// last entry
break;
}
} while (true);
// Check the size of MultiStringData
if (pFeatureData->MultiStringData.uCount < uiNumStrings)
{
MOS_OS_NORMALMESSAGE("pFeatureValue->MultiStringData.uCount is smaller than the actual necessary number.");
return MOS_STATUS_UNKNOWN;
}
// Populate Array
dwPos = 0;
for (ui = 0; ui < uiNumStrings; ui++)
{
pCurData = pData + dwPos;
dwLen = (uint32_t)strlen(pCurData);
MOS_OS_ASSERT(dwLen > 0);
pStrings[ui].pStringData = pCurData;
pStrings[ui].uSize = dwLen;
dwPos += dwLen + 1;
}
pFeatureData->MultiStringData.uCount = uiNumStrings;
pFeatureData->MultiStringData.uSize = dwPos;
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosUtilities::MosCopyUserFeatureValueData(
PMOS_USER_FEATURE_VALUE_DATA pSrcData,
PMOS_USER_FEATURE_VALUE_DATA pDstData,
MOS_USER_FEATURE_VALUE_TYPE ValueType)
{
uint32_t ui;
PMOS_USER_FEATURE_VALUE_STRING pSrcString = nullptr;
PMOS_USER_FEATURE_VALUE_STRING pDstString = nullptr;
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
//------------------------------
MOS_OS_ASSERT(pSrcData);
MOS_OS_ASSERT(pDstData);
MOS_OS_ASSERT(ValueType != MOS_USER_FEATURE_VALUE_TYPE_INVALID);
//------------------------------
switch(ValueType)
{
case MOS_USER_FEATURE_VALUE_TYPE_BOOL:
pDstData->bData = pSrcData->bData;
break;
case MOS_USER_FEATURE_VALUE_TYPE_INT32:
pDstData->i32Data = pSrcData->i32Data;
break;
case MOS_USER_FEATURE_VALUE_TYPE_INT64:
pDstData->i64Data = pSrcData->i64Data;
break;
case MOS_USER_FEATURE_VALUE_TYPE_UINT32:
pDstData->u32Data = pSrcData->u32Data;
break;
case MOS_USER_FEATURE_VALUE_TYPE_UINT64:
pDstData->u64Data = pSrcData->u64Data;
break;
case MOS_USER_FEATURE_VALUE_TYPE_FLOAT:
pDstData->fData = pSrcData->fData;
break;
case MOS_USER_FEATURE_VALUE_TYPE_STRING:
if ((pSrcData->StringData.pStringData != nullptr) && (strlen(pSrcData->StringData.pStringData) != 0))
{
pDstData->StringData.uMaxSize = pSrcData->StringData.uMaxSize;
pDstData->StringData.uSize = pSrcData->StringData.uSize;
if (pDstData->StringData.pStringData == nullptr)
{
MOS_OS_ASSERTMESSAGE("Failed to allocate memory.");
return MOS_STATUS_NULL_POINTER;
}
eStatus = MosSecureMemcpy(
pDstData->StringData.pStringData,
pDstData->StringData.uSize,
pSrcData->StringData.pStringData,
pSrcData->StringData.uSize);
}
break;
case MOS_USER_FEATURE_VALUE_TYPE_MULTI_STRING:
if ((pSrcData->MultiStringData.pMultStringData != nullptr) && (strlen(pSrcData->MultiStringData.pMultStringData) != 0))
{
pDstData->MultiStringData.uCount = pSrcData->MultiStringData.uCount;
pDstData->MultiStringData.uMaxSize = pSrcData->MultiStringData.uMaxSize;
pDstData->MultiStringData.uSize = pSrcData->MultiStringData.uSize;
if (pDstData->MultiStringData.pMultStringData != nullptr)
{
eStatus = MosSecureMemcpy(
pDstData->MultiStringData.pMultStringData,
pDstData->MultiStringData.uSize,
pSrcData->MultiStringData.pMultStringData,
pSrcData->MultiStringData.uSize);
for (ui = 0; ui < pSrcData->MultiStringData.uCount; ui++)
{
pSrcString = &pSrcData->MultiStringData.pStrings[ui];
pDstString = &pDstData->MultiStringData.pStrings[ui];
MOS_OS_CHK_NULL(pSrcString);
MOS_OS_CHK_NULL(pDstString);
pDstString->uMaxSize = pSrcString->uMaxSize;
pDstString->uSize = pSrcString->uSize;
if (pDstString->pStringData != nullptr)
{
eStatus = MosSecureMemcpy(
pDstString->pStringData,
pDstString->uSize+1,
pSrcString->pStringData,
pSrcString->uSize+1);
}// if
}// for
}
}// if
break;
default:
break;
}
finish:
return eStatus;
}
MOS_STATUS MosUtilities::MosAssignUserFeatureValueData(
PMOS_USER_FEATURE_VALUE_DATA pDstData,
const char *pData,
MOS_USER_FEATURE_VALUE_TYPE ValueType
)
{
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
uint32_t dwUFSize = 0;
//------------------------------
MOS_OS_ASSERT(pData);
MOS_OS_ASSERT(pDstData);
MOS_OS_ASSERT(ValueType != MOS_USER_FEATURE_VALUE_TYPE_INVALID);
//------------------------------
switch(ValueType)
{
case MOS_USER_FEATURE_VALUE_TYPE_BOOL:
pDstData->bData = atoi(pData);
break;
case MOS_USER_FEATURE_VALUE_TYPE_INT32:
pDstData->i32Data = atoi(pData);
break;
case MOS_USER_FEATURE_VALUE_TYPE_INT64:
pDstData->i64Data = atol(pData);
break;
case MOS_USER_FEATURE_VALUE_TYPE_UINT32:
pDstData->u32Data = atoi(pData);
break;
case MOS_USER_FEATURE_VALUE_TYPE_UINT64:
pDstData->u64Data = atol(pData);
break;
case MOS_USER_FEATURE_VALUE_TYPE_FLOAT:
pDstData->fData = (float)atol(pData);
break;
case MOS_USER_FEATURE_VALUE_TYPE_STRING:
pDstData->StringData.uMaxSize = MOS_USER_CONTROL_MAX_DATA_SIZE;
if ((pData != nullptr) && (strlen(pData) != 0))
{
pDstData->StringData.uSize = (uint32_t)strlen(pData) + 1;
if (pDstData->StringData.uSize > pDstData->StringData.uMaxSize)
{
pDstData->StringData.uSize = pDstData->StringData.uMaxSize;
}
pDstData->StringData.pStringData = (char *)MOS_AllocAndZeroMemory(strlen(pData) + 1);
if (pDstData->StringData.pStringData == nullptr)
{
MOS_OS_ASSERTMESSAGE("Failed to allocate memory.");
return MOS_STATUS_NULL_POINTER;
}
MosAtomicIncrement(m_mosMemAllocFakeCounter);
eStatus = MosSecureStrcpy(
pDstData->StringData.pStringData,
pDstData->StringData.uSize,
(char *)pData);
}
break;
case MOS_USER_FEATURE_VALUE_TYPE_MULTI_STRING:
pDstData->MultiStringData.uCount = MOS_USER_MAX_STRING_COUNT;
pDstData->MultiStringData.uMaxSize = MOS_USER_CONTROL_MAX_DATA_SIZE;
pDstData->MultiStringData.pStrings = (PMOS_USER_FEATURE_VALUE_STRING)MOS_AllocAndZeroMemory(sizeof(MOS_USER_FEATURE_VALUE_STRING) * __MAX_MULTI_STRING_COUNT);
if (pDstData->MultiStringData.pStrings == nullptr)
{
MOS_OS_ASSERTMESSAGE("Failed to allocate memory.");
pDstData->MultiStringData.pMultStringData = nullptr;
pDstData->MultiStringData.uSize = 0;
pDstData->MultiStringData.uCount = 0;
return MOS_STATUS_NULL_POINTER;
}
MosAtomicIncrement(m_mosMemAllocFakeCounter);
if ((pData != nullptr) && (strlen(pData) != 0))
{
if (!pDstData->MultiStringData.pMultStringData)
{
MosAtomicIncrement(m_mosMemAllocFakeCounter);
}
MOS_SafeFreeMemory(pDstData->MultiStringData.pMultStringData);
pDstData->MultiStringData.pMultStringData = (char *)MOS_AllocAndZeroMemory(strlen(pData) + 1);
if (pDstData->MultiStringData.pMultStringData == nullptr)
{
MOS_OS_ASSERTMESSAGE("Failed to allocate memory.");
return MOS_STATUS_NULL_POINTER;
}
eStatus = MosSecureMemcpy(
pDstData->MultiStringData.pMultStringData,
strlen(pData),
(char *)pData,
strlen(pData));
if ((eStatus = MosUserFeatureSetMultiStringValue(
pDstData,
dwUFSize)) != MOS_STATUS_SUCCESS)
{
MOS_OS_ASSERTMESSAGE("Failed to set multi string value.");
return eStatus;
}
}
break;
default:
break;
}
return eStatus;
}
MOS_STATUS MosUtilities::MosUserFeatureSetDefaultValues(
PMOS_USER_FEATURE_VALUE_WRITE_DATA pWriteValues,
uint32_t uiNumOfValues)
{
uint32_t ui;
PMOS_USER_FEATURE_VALUE pUserFeature = nullptr;
uint32_t ValueID = __MOS_USER_FEATURE_KEY_INVALID_ID;
MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
//--------------------------------------------------
MOS_OS_CHK_NULL_RETURN(pWriteValues);
//--------------------------------------------------
for (ui = 0; ui < uiNumOfValues; ui++)
{
ValueID = pWriteValues[ui].ValueID;
pUserFeature = MosUtilUserInterface::GetValue(ValueID);
MOS_OS_CHK_NULL_RETURN(pUserFeature);
// Copy the write data into corresponding user feature value
MosCopyUserFeatureValueData(
&pWriteValues[ui].Value,
&pUserFeature->Value,
pUserFeature->ValueType);
}
eStatus = MOS_STATUS_SUCCESS;
return eStatus;
}
MOS_STATUS MosUtilities::MosDeclareUserFeatureKey(PMOS_USER_FEATURE_VALUE pUserFeatureKey)
{
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
//------------------------------
MOS_OS_CHK_NULL_RETURN(pUserFeatureKey);
//------------------------------
eStatus = MosAssignUserFeatureValueData(
&pUserFeatureKey->Value,
pUserFeatureKey->DefaultValue,
pUserFeatureKey->ValueType);
if (eStatus == MOS_STATUS_SUCCESS)
{
MosUtilUserInterface::AddEntry(pUserFeatureKey->ValueID, pUserFeatureKey);
}
return eStatus;
}
MOS_STATUS MosUtilities::MosDestroyUserFeatureData(PMOS_USER_FEATURE_VALUE_DATA pData,MOS_USER_FEATURE_VALUE_TYPE ValueType)
{
uint32_t ui;
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
//------------------------------
if (pData == nullptr)
{
return eStatus;
}
//------------------------------
switch (ValueType)
{
case MOS_USER_FEATURE_VALUE_TYPE_STRING:
MosFreeUserFeatureValueString(&pData->StringData);
break;
case MOS_USER_FEATURE_VALUE_TYPE_MULTI_STRING:
for (ui = 0; ui < pData->MultiStringData.uCount; ui++)
{
MosFreeUserFeatureValueString(&pData->MultiStringData.pStrings[ui]);
}
MOS_SafeFreeMemory(pData->MultiStringData.pStrings);
MosAtomicDecrement(m_mosMemAllocFakeCounter);
pData->MultiStringData.pStrings = nullptr;
pData->MultiStringData.pMultStringData = nullptr;
pData->MultiStringData.uSize = 0;
pData->MultiStringData.uCount = 0;
break;
default:
break;
}
return eStatus;
}
MOS_STATUS MosUtilities::MosDestroyUserFeatureKey(PMOS_USER_FEATURE_VALUE pUserFeatureKey)
{
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
//------------------------------
MOS_OS_CHK_NULL_RETURN(pUserFeatureKey);
//------------------------------
MosUtilUserInterface::DelEntry(pUserFeatureKey->ValueID);
eStatus = MosDestroyUserFeatureData(
&pUserFeatureKey->Value,
pUserFeatureKey->ValueType);
return eStatus;
}
MOS_STATUS MosUtilities::MosIsCorrectDefaultValueType(
const char *pData,
MOS_USER_FEATURE_VALUE_TYPE ValueType)
{
uint32_t dwLen;
uint32_t ui;
int32_t IntVal;
MOS_STATUS eStatus = MOS_STATUS_INVALID_PARAMETER;
dwLen = (uint32_t)strlen(pData);
//------------------------------
MOS_OS_ASSERT(pData);
MOS_OS_ASSERT(ValueType != MOS_USER_FEATURE_VALUE_TYPE_INVALID);
//------------------------------
switch (ValueType)
{
case MOS_USER_FEATURE_VALUE_TYPE_BOOL:
if ((!strcmp(pData, "0")) || (!strcmp(pData, "1")))
{
eStatus = MOS_STATUS_SUCCESS;
}
break;
case MOS_USER_FEATURE_VALUE_TYPE_INT32:
case MOS_USER_FEATURE_VALUE_TYPE_INT64:
case MOS_USER_FEATURE_VALUE_TYPE_UINT32:
case MOS_USER_FEATURE_VALUE_TYPE_UINT64:
case MOS_USER_FEATURE_VALUE_TYPE_FLOAT:
eStatus = MOS_STATUS_SUCCESS;
for (ui = 0; ui IntVal) || (9 < IntVal))
{
if ((((ui == 0)&&(pData[ui] - '-') != 0)) && ((pData[ui] - '.') != 0))
{
eStatus = MOS_STATUS_INVALID_PARAMETER;
break;
}
}
}
break;
case MOS_USER_FEATURE_VALUE_TYPE_STRING:
eStatus = MOS_STATUS_SUCCESS;
break;
case MOS_USER_FEATURE_VALUE_TYPE_MULTI_STRING:
eStatus = MOS_STATUS_SUCCESS;
break;
default:
break;
}
return eStatus;
}
MOS_STATUS MosUtilities::MosIsCorrectUserFeatureDescField(PMOS_USER_FEATURE_VALUE pUserFeatureKey, uint32_t maxKeyID)
{
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
MOS_OS_CHK_NULL_RETURN(pUserFeatureKey);
if ((pUserFeatureKey->ValueID <= __MOS_USER_FEATURE_KEY_INVALID_ID) ||
(pUserFeatureKey->ValueID >= maxKeyID))
{
eStatus = MOS_STATUS_INVALID_PARAMETER;
return eStatus;
}
MOS_OS_CHK_NULL_RETURN(pUserFeatureKey->pValueName);
MOS_OS_CHK_NULL_RETURN(pUserFeatureKey->pcPath);
MOS_OS_CHK_NULL_RETURN(pUserFeatureKey->pcWritePath);
MOS_OS_CHK_NULL_RETURN(pUserFeatureKey->pcGroup);
if ((pUserFeatureKey->pcDescription != nullptr) &&
(strlen(pUserFeatureKey->pcDescription) > MAX_USER_FEATURE_FIELD_LENGTH))
{
eStatus = MOS_STATUS_INVALID_PARAMETER;
return eStatus;
}
eStatus = MosIsCorrectDefaultValueType(
pUserFeatureKey->DefaultValue,
pUserFeatureKey->ValueType);
return eStatus;
}
MOS_STATUS MosUtilities::MosGetItemFromMosUserFeatureDescField(
MOS_USER_FEATURE_VALUE *descTable,
uint32_t numOfItems,
uint32_t maxId,
MOS_STATUS (*CallbackFunc)(PMOS_USER_FEATURE_VALUE),
PMOS_USER_FEATURE_VALUE pUserFeatureKeyFilter)
{
uint32_t uiIndex = 0;
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
//------------------------------
MOS_OS_CHK_NULL_RETURN(CallbackFunc);
MOS_OS_CHK_NULL_RETURN(pUserFeatureKeyFilter);
MOS_OS_CHK_NULL_RETURN(descTable);
//------------------------------
for (uiIndex = __MOS_USER_FEATURE_KEY_INVALID_ID; uiIndex < numOfItems; uiIndex++)
{
if (MosIsCorrectUserFeatureDescField(&descTable[uiIndex], maxId) != MOS_STATUS_SUCCESS)
{
continue;
}
if ((pUserFeatureKeyFilter->ValueID != __MOS_USER_FEATURE_KEY_INVALID_ID) && (pUserFeatureKeyFilter->ValueID != descTable[uiIndex].ValueID))
{
continue;
}
if ((pUserFeatureKeyFilter->pValueName != nullptr) && (strcmp(pUserFeatureKeyFilter->pValueName, descTable[uiIndex].pValueName) != 0))
{
continue;
}
if ((pUserFeatureKeyFilter->pcPath != nullptr) && (strcmp(pUserFeatureKeyFilter->pcPath, descTable[uiIndex].pcPath) != 0))
{
continue;
}
if ((pUserFeatureKeyFilter->pcWritePath != nullptr) && (strcmp(pUserFeatureKeyFilter->pcWritePath, descTable[uiIndex].pcWritePath) != 0))
{
continue;
}
if ((pUserFeatureKeyFilter->pcGroup != nullptr) && (strcmp(pUserFeatureKeyFilter->pcGroup, descTable[uiIndex].pcGroup) != 0))
{
continue;
}
if ((pUserFeatureKeyFilter->Type != MOS_USER_FEATURE_TYPE_INVALID) && (pUserFeatureKeyFilter->Type != descTable[uiIndex].Type))
{
continue;
}
if ((pUserFeatureKeyFilter->ValueType != MOS_USER_FEATURE_VALUE_TYPE_INVALID) && (pUserFeatureKeyFilter->ValueType != descTable[uiIndex].ValueType))
{
continue;
}
eStatus = (*CallbackFunc)(&descTable[uiIndex]);
}
return eStatus;
}
MOS_STATUS MosUtilities::MosDeclareUserFeatureKeysFromDescFields(
MOS_USER_FEATURE_VALUE *descTable,
uint32_t numOfItems,
uint32_t maxId)
{
MOS_USER_FEATURE_VALUE UserFeatureKeyFilter = __NULL_USER_FEATURE_VALUE__;
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
eStatus = MosGetItemFromMosUserFeatureDescField(
descTable,
numOfItems,
maxId,
&MosDeclareUserFeatureKey,
&UserFeatureKeyFilter);
return eStatus;
}
MOS_STATUS MosUtilities::MosDeclareUserFeatureKeysForAllDescFields()
{
MOS_OS_CHK_STATUS_RETURN(MosDeclareUserFeatureKeysFromDescFields(
m_mosUserFeatureDescFields,
__MOS_USER_FEATURE_KEY_MAX_ID,
__MOS_USER_FEATURE_KEY_MAX_ID));
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosUtilities::MosDestroyUserFeatureKeysFromDescFields(
MOS_USER_FEATURE_VALUE *descTable,
uint32_t numOfItems,
uint32_t maxId)
{
MOS_USER_FEATURE_VALUE UserFeatureKeyFilter = __NULL_USER_FEATURE_VALUE__;
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
eStatus = MosGetItemFromMosUserFeatureDescField(
descTable,
numOfItems,
maxId,
&MosDestroyUserFeatureKey,
&UserFeatureKeyFilter);
return eStatus;
}
MOS_STATUS MosUtilities::MosDestroyUserFeatureKeysForAllDescFields()
{
MOS_USER_FEATURE_VALUE UserFeatureKeyFilter = __NULL_USER_FEATURE_VALUE__;
MOS_OS_CHK_STATUS_RETURN(MosDestroyUserFeatureKeysFromDescFields(
m_mosUserFeatureDescFields,
__MOS_USER_FEATURE_KEY_MAX_ID,
__MOS_USER_FEATURE_KEY_MAX_ID));
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosUtilities::MosUserFeatureReadValueInit(uint32_t uiNumValues)
{
// Check if memory is allocated
if (uiNumValues == 0)
{
MOS_OS_ASSERTMESSAGE("pUserFeature->uiNumValues is 0.");
return MOS_STATUS_UNKNOWN;
}
return MOS_STATUS_SUCCESS;
}
void MosUtilities::MosUserFeatureCallback(
PTP_CALLBACK_INSTANCE Instance,
void *pvParameter,
PTP_WAIT Wait,
TP_WAIT_RESULT WaitResult)
{
PMOS_USER_FEATURE_NOTIFY_DATA pNotifyData;
MOS_UNUSED(Instance);
MOS_UNUSED(Wait);
MOS_UNUSED(WaitResult);
MOS_OS_ASSERT(pvParameter);
pNotifyData = (PMOS_USER_FEATURE_NOTIFY_DATA)pvParameter;
pNotifyData->bTriggered = true;
}
MOS_STATUS MosUtilities::MosUserFeatureReadValueBinary(
void *UFKey,
PMOS_USER_FEATURE_VALUE pFeatureValue)
{
MOS_STATUS eStatus;
void *pvData;
uint32_t dwUFSize;
MOS_OS_ASSERT(UFKey);
MOS_OS_ASSERT(pFeatureValue);
MOS_OS_ASSERT(pFeatureValue->pValueName);
MOS_OS_ASSERT(pFeatureValue->ValueType == MOS_USER_FEATURE_VALUE_TYPE_BINARY);
pvData = pFeatureValue->Value.BinaryData.pBinaryData;
if (!pvData)
{
MOS_OS_ASSERTMESSAGE("pFeatureValue->BinaryData.pBinaryData is NULL.");
return MOS_STATUS_NULL_POINTER;
}
dwUFSize = pFeatureValue->Value.BinaryData.uMaxSize;
if (dwUFSize == 0)
{
MOS_OS_ASSERTMESSAGE("pFeatureValue->BinaryData.uMaxSize is 0.");
return MOS_STATUS_UNKNOWN;
}
eStatus = MosUserFeatureGetValue(
UFKey,
nullptr,
pFeatureValue->pValueName,
RRF_RT_UF_BINARY,
nullptr,
pvData,
&dwUFSize);
if (eStatus != MOS_STATUS_SUCCESS)
{
if (dwUFSize > pFeatureValue->Value.BinaryData.uMaxSize) // Buffer size is not enough
{
MOS_OS_NORMALMESSAGE("Size %d exceeds max %d.", dwUFSize, pFeatureValue->Value.BinaryData.uMaxSize);
return MOS_STATUS_UNKNOWN;
}
else // This error case can be hit if the user feature key does not exist.
{
MOS_OS_NORMALMESSAGE("Failed to read binary user feature value '%s'.", pFeatureValue->pValueName);
return MOS_STATUS_USER_FEATURE_KEY_READ_FAILED;
}
}
pFeatureValue->Value.BinaryData.uSize = dwUFSize;
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosUtilities::MosUserFeatureReadValueString(
void *UFKey,
PMOS_USER_FEATURE_VALUE pFeatureValue)
{
MOS_STATUS eStatus;
uint32_t dwUFSize;
char pcTmpStr[MOS_USER_CONTROL_MAX_DATA_SIZE];
//--------------------------------------------------
MOS_OS_ASSERT(UFKey);
MOS_OS_ASSERT(pFeatureValue);
MOS_OS_ASSERT(pFeatureValue->pValueName);
MOS_OS_ASSERT(pFeatureValue->ValueType == MOS_USER_FEATURE_VALUE_TYPE_STRING);
//--------------------------------------------------
MosZeroMemory(pcTmpStr, MOS_USER_CONTROL_MAX_DATA_SIZE);
dwUFSize = pFeatureValue->Value.StringData.uMaxSize;
if (dwUFSize == 0)
{
MOS_OS_ASSERTMESSAGE("pFeatureValue->StringData.uMaxSize is 0.");
return MOS_STATUS_UNKNOWN;
}
eStatus = MosUserFeatureGetValue(
UFKey,
nullptr,
pFeatureValue->pValueName,
RRF_RT_UF_SZ,
nullptr,
pcTmpStr,
&dwUFSize);
if (eStatus != MOS_STATUS_SUCCESS)
{
if (dwUFSize > pFeatureValue->Value.StringData.uMaxSize) // Buffer size is not enough
{
MOS_OS_NORMALMESSAGE("Size %d exceeds max %d.", dwUFSize, pFeatureValue->Value.StringData.uMaxSize);
return MOS_STATUS_UNKNOWN;
}
else // This error case can be hit if the user feature key does not exist.
{
MOS_OS_NORMALMESSAGE("Failed to read single string user feature value '%s'.", pFeatureValue->pValueName);
return MOS_STATUS_USER_FEATURE_KEY_READ_FAILED;
}
}
if (strlen(pcTmpStr) > 0)
{
if (!pFeatureValue->Value.StringData.pStringData)
{
MosAtomicIncrement(m_mosMemAllocFakeCounter);
}
if (pFeatureValue->Value.StringData.uSize < strlen(pcTmpStr) + 1)
{
pFeatureValue->Value.StringData.pStringData =
(char *)MOS_ReallocMemory(pFeatureValue->Value.StringData.pStringData, strlen(pcTmpStr) + 1);
pFeatureValue->Value.StringData.uSize = strlen(pcTmpStr) + 1;
}
MOS_OS_CHK_NULL_RETURN(pFeatureValue->Value.StringData.pStringData);
MosZeroMemory(pFeatureValue->Value.StringData.pStringData, pFeatureValue->Value.StringData.uSize);
MosSecureMemcpy(pFeatureValue->Value.StringData.pStringData, pFeatureValue->Value.StringData.uSize, pcTmpStr, strlen(pcTmpStr));
}
return eStatus;
}
MOS_STATUS MosUtilities::MosUserFeatureReadValueMultiString(
void *UFKey,
PMOS_USER_FEATURE_VALUE pFeatureValue)
{
MOS_STATUS eStatus;
uint32_t dwUFSize;
char pcTmpStr[MOS_USER_CONTROL_MAX_DATA_SIZE];
MOS_OS_ASSERT(UFKey);
MOS_OS_ASSERT(pFeatureValue);
MOS_OS_ASSERT(pFeatureValue->pValueName);
MOS_OS_ASSERT(pFeatureValue->ValueType == MOS_USER_FEATURE_VALUE_TYPE_MULTI_STRING);
if (!pFeatureValue->Value.MultiStringData.pStrings)
{
MOS_OS_ASSERTMESSAGE("pFeatureValue->MultiStringData.pStrings is NULL.");
return MOS_STATUS_NULL_POINTER;
}
MosZeroMemory(pcTmpStr, MOS_USER_CONTROL_MAX_DATA_SIZE);
dwUFSize = pFeatureValue->Value.MultiStringData.uMaxSize;
if (dwUFSize == 0)
{
MOS_OS_ASSERTMESSAGE("pFeatureValue->MultiStringData.uMaxSize is 0.");
return MOS_STATUS_UNKNOWN;
}
eStatus = MosUserFeatureGetValue(
UFKey,
nullptr,
pFeatureValue->pValueName,
RRF_RT_UF_MULTI_SZ,
nullptr,
pcTmpStr,
&dwUFSize);
if (eStatus != MOS_STATUS_SUCCESS)
{
if (dwUFSize > pFeatureValue->Value.MultiStringData.uMaxSize) // Buffer size is not enough
{
MOS_OS_NORMALMESSAGE("Size %d exceeds max %d.", dwUFSize, pFeatureValue->Value.MultiStringData.uMaxSize);
return MOS_STATUS_UNKNOWN;
}
else // This error case can be hit if the user feature key does not exist.
{
MOS_OS_NORMALMESSAGE("Failed to read single string user feature value '%s'.", pFeatureValue->pValueName);
return MOS_STATUS_USER_FEATURE_KEY_READ_FAILED;
}
}
if (strlen(pcTmpStr) > 0)
{
if (!pFeatureValue->Value.MultiStringData.pMultStringData)
{
MosAtomicIncrement(m_mosMemAllocFakeCounter);
}
MOS_SafeFreeMemory(pFeatureValue->Value.MultiStringData.pMultStringData);
pFeatureValue->Value.MultiStringData.pMultStringData = (char *)MOS_AllocAndZeroMemory(strlen(pcTmpStr) + 1);
if (pFeatureValue->Value.MultiStringData.pMultStringData == nullptr)
{
MOS_OS_ASSERTMESSAGE("Failed to allocate memory.");
return MOS_STATUS_NULL_POINTER;
}
MosSecureMemcpy(
pFeatureValue->Value.MultiStringData.pMultStringData,
strlen(pcTmpStr),
pcTmpStr,
strlen(pcTmpStr));
if((eStatus = MosUserFeatureSetMultiStringValue(
&pFeatureValue->Value,
dwUFSize)) != MOS_STATUS_SUCCESS)
{
MOS_OS_ASSERTMESSAGE("Failed to set multi string value.");
return eStatus;
}
}
return MOS_STATUS_SUCCESS;
}
MOS_STATUS MosUtilities::MosUserFeatureReadValuePrimitive(
void *UFKey,
PMOS_USER_FEATURE_VALUE pFeatureValue)
{
MOS_STATUS eStatus;
uint32_t dwUFType = 0;
uint32_t dwUFSize;
void *pvData = nullptr;
MOS_OS_ASSERT(UFKey);
MOS_OS_ASSERT(pFeatureValue);
MOS_OS_ASSERT(pFeatureValue->pValueName);
MOS_OS_ASSERT(pFeatureValue->ValueType != MOS_USER_FEATURE_VALUE_TYPE_INVALID);
switch(pFeatureValue->ValueType)
{
case MOS_USER_FEATURE_VALUE_TYPE_BOOL:
case MOS_USER_FEATURE_VALUE_TYPE_INT32:
case MOS_USER_FEATURE_VALUE_TYPE_UINT32:
case MOS_USER_FEATURE_VALUE_TYPE_FLOAT:
dwUFType = RRF_RT_UF_DWORD;
dwUFSize = sizeof(uint32_t);
pvData = &pFeatureValue->Value.fData;
break;
case MOS_USER_FEATURE_VALUE_TYPE_INT64:
case MOS_USER_FEATURE_VALUE_TYPE_UINT64:
dwUFType = RRF_RT_UF_QWORD;
dwUFSize = sizeof(uint64_t);
pvData = &pFeatureValue->Value.u64Data;
break;
default:
MOS_OS_ASSERTMESSAGE("Invalid primitive value type.");
return MOS_STATUS_UNKNOWN;
}
eStatus = MosUserFeatureGetValue(
UFKey,
nullptr,
pFeatureValue->pValueName,
dwUFType,
nullptr,
pvData,
&dwUFSize);
if (eStatus != MOS_STATUS_SUCCESS)
{
// This error case can be hit if the user feature key does not exist.
MOS_OS_NORMALMESSAGE("Failed to read primitive user feature value \"%s\".", pFeatureValue->pValueName);
return MOS_STATUS_USER_FEATURE_KEY_READ_FAILED;
}
return eStatus;
}
MOS_STATUS MosUtilities::MosUserFeatureWriteValueString(
void *UFKey,
PMOS_USER_FEATURE_VALUE pFeatureValue,
PMOS_USER_FEATURE_VALUE_DATA pDataValue)
{
MOS_STATUS eStatus;
MOS_OS_ASSERT(UFKey);
MOS_OS_ASSERT(pFeatureValue);
MOS_OS_ASSERT(pFeatureValue->pValueName);
MOS_OS_ASSERT(pFeatureValue->ValueType == MOS_USER_FEATURE_VALUE_TYPE_STRING);
MOS_OS_ASSERT(pDataValue);
if((eStatus = MosUserFeatureSetValueEx(
UFKey,
pFeatureValue->pValueName,
0,
UF_SZ,
(uint8_t*)pDataValue->StringData.pStringData,
pDataValue->StringData.uSize)) != MOS_STATUS_SUCCESS)
{
MOS_OS_ASSERTMESSAGE("Failed to write string user feature value.");
}
return eStatus;
}
MOS_STATUS MosUtilities::MosUserFeatureWriteValueMultiString(
void *UFKey,
PMOS_USER_FEATURE_VALUE pFeatureValue,
PMOS_USER_FEATURE_VALUE_DATA pDataValue)
{
PMOS_USER_FEATURE_VALUE_STRING pStringData;
uint8_t *pData;
uint8_t *pCurData;
uint32_t dwDataSize;
uint32_t dwAvailableSize;
uint32_t ui;
MOS_STATUS eStatus;
MOS_OS_ASSERT(UFKey);
MOS_OS_ASSERT(pFeatureValue);
MOS_OS_ASSERT(pFeatureValue->pValueName);
MOS_OS_ASSERT(pFeatureValue->ValueType == MOS_USER_FEATURE_VALUE_TYPE_MULTI_STRING);
MOS_OS_ASSERT(pDataValue);
MOS_OS_ASSERT(pDataValue->MultiStringData.uCount > 0);
pData = nullptr;
dwDataSize = 0;
for (ui = 0; ui < pDataValue->MultiStringData.uCount; ui++)
{
pStringData = &pDataValue->MultiStringData.pStrings[ui];
dwDataSize += pStringData->uSize;
dwDataSize += 1; // for \0
}
dwDataSize += 1; // for \0 at the very end (see MULTI_SZ spec)
// Allocate memory to store data
pData = (uint8_t*)MOS_AllocAndZeroMemory(dwDataSize);
if(pData == nullptr)
{
MOS_OS_ASSERTMESSAGE("Failed to allocate memory.");
return MOS_STATUS_NO_SPACE;
}
// Copy data from original string array
pCurData = pData;
dwAvailableSize = dwDataSize;
for (ui = 0; ui < pDataValue->MultiStringData.uCount; ui++)
{
pStringData = &pDataValue->MultiStringData.pStrings[ui];
eStatus = MosSecureMemcpy(pCurData, dwAvailableSize, pStringData->pStringData, pStringData->uSize);
if(eStatus != MOS_STATUS_SUCCESS)
{
MOS_OS_ASSERTMESSAGE("Failed to copy memory.");
goto finish;
}
pCurData += pStringData->uSize;
pCurData++; // \0 is already added since we zeroed the memory
// Very last \0 is already added since we zeroed the memory
dwAvailableSize -= pStringData->uSize + 1;
}
// Write the user feature MULTI_SZ entry
if((eStatus = MosUserFeatureSetValueEx(
UFKey,
pFeatureValue->pValueName,
0,
UF_MULTI_SZ,
pData,
dwDataSize)) != MOS_STATUS_SUCCESS)
{
MOS_OS_ASSERTMESSAGE("Failed to write multi string user feature value.");
}
finish:
MOS_FreeMemory(pData);
return eStatus;
}
MOS_STATUS MosUtilities::MosUserFeatureWriteValueBinary(
void *UFKey,
PMOS_USER_FEATURE_VALUE pFeatureValue,
PMOS_USER_FEATURE_VALUE_DATA pDataValue)
{
MOS_STATUS eStatus;
MOS_OS_ASSERT(UFKey);
MOS_OS_ASSERT(pFeatureValue);
MOS_OS_ASSERT(pFeatureValue->pValueName);
MOS_OS_ASSERT(pFeatureValue->ValueType == MOS_USER_FEATURE_VALUE_TYPE_BINARY);
MOS_OS_ASSERT(pDataValue);
if((eStatus = MosUserFeatureSetValueEx(
UFKey,
pFeatureValue->pValueName,
0,
UF_BINARY,
(uint8_t*)pDataValue->BinaryData.pBinaryData,
pDataValue->BinaryData.uSize)) != MOS_STATUS_SUCCESS)
{
MOS_OS_ASSERTMESSAGE("Failed to write binary user feature value.");
}
return eStatus;
}
MOS_STATUS MosUtilities::MosUserFeatureWriteValuePrimitive(
void *UFKey,
PMOS_USER_FEATURE_VALUE pFeatureValue,
PMOS_USER_FEATURE_VALUE_DATA pDataValue)
{
MOS_STATUS eStatus;
uint32_t dwUFType = UF_NONE;
uint32_t dwUFSize = 0;
void *pvData = nullptr;
MOS_OS_ASSERT(UFKey);
MOS_OS_ASSERT(pFeatureValue);
MOS_OS_ASSERT(pFeatureValue->pValueName);
MOS_OS_ASSERT(pFeatureValue->ValueType != MOS_USER_FEATURE_VALUE_TYPE_INVALID);
MOS_OS_ASSERT(pDataValue);
switch(pFeatureValue->ValueType)
{
case MOS_USER_FEATURE_VALUE_TYPE_BOOL:
case MOS_USER_FEATURE_VALUE_TYPE_INT32:
case MOS_USER_FEATURE_VALUE_TYPE_UINT32:
case MOS_USER_FEATURE_VALUE_TYPE_FLOAT:
dwUFType = UF_DWORD;
dwUFSize = sizeof(uint32_t);
pvData = &pDataValue->fData;
break;
case MOS_USER_FEATURE_VALUE_TYPE_INT64:
case MOS_USER_FEATURE_VALUE_TYPE_UINT64:
dwUFType = UF_QWORD;
dwUFSize = sizeof(uint64_t);
pvData = &pDataValue->u64Data;
break;
default:
MOS_OS_ASSERTMESSAGE("Invalid primitive value type.");
return MOS_STATUS_UNKNOWN;
}
if((eStatus = MosUserFeatureSetValueEx(
UFKey,
pFeatureValue->pValueName,
0,
dwUFType,
(uint8_t*)pvData,
dwUFSize)) != MOS_STATUS_SUCCESS)
{
MOS_OS_ASSERTMESSAGE("Failed to write primitive user feature value.");
}
return eStatus;
}
MOS_STATUS MosUtilities::MosUserFeatureReadValueFromMapID(
uint32_t ValueID,
PMOS_USER_FEATURE_VALUE_DATA pValueData,
MOS_USER_FEATURE_KEY_PATH_INFO *ufInfo)
{
void *ufKey = nullptr;
PMOS_USER_FEATURE_VALUE pUserFeature = nullptr;
int32_t iDataFlag = MOS_USER_FEATURE_VALUE_DATA_FLAG_NONE_CUSTOM_DEFAULT_VALUE_TYPE;
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
//--------------------------------------------------
MOS_OS_ASSERT(pValueData);
MOS_OS_ASSERT(ValueID != __MOS_USER_FEATURE_KEY_INVALID_ID);
//--------------------------------------------------
iDataFlag = pValueData->i32DataFlag;
pUserFeature = MosUtilUserInterface::GetValue(ValueID);
if (nullptr == pUserFeature)
{
MOS_OS_NORMALMESSAGE("Cannot found the user feature key.");
return MOS_STATUS_NULL_POINTER;
}
// Open the user feature
// Assigned the pUserFeature to ufKey for future reading
ufKey = pUserFeature;
if((eStatus = MosUserFeatureOpen(
pUserFeature->Type,
pUserFeature->pcPath,
KEY_READ,
&ufKey,
ufInfo)) != MOS_STATUS_SUCCESS)
{
MOS_OS_NORMALMESSAGE("Failed to open user feature for concurrency.");
if ((eStatus = MosUserFeatureOpen(
pUserFeature->Type,
pUserFeature->pcPath,
KEY_READ,
&ufKey,
ufInfo)) != MOS_STATUS_SUCCESS)
{
MOS_OS_NORMALMESSAGE("Failed to open user feature for reading eStatus:%d.", eStatus);
eStatus = MOS_STATUS_USER_FEATURE_KEY_OPEN_FAILED;
goto finish;
}
}
// Initialize Read Value
if((eStatus = MosUserFeatureReadValueInit(pUserFeature->uiNumOfValues)) != MOS_STATUS_SUCCESS)
{
MOS_OS_ASSERTMESSAGE("Failed to initialize user feature read value eStatus:%d.",eStatus);
eStatus = MOS_STATUS_UNKNOWN;
goto finish;
}
#if !(_DEBUG || _RELEASE_INTERNAL)
// For release build, don't read debug only keys, but return default directly
if (pUserFeature->EffctiveRange == MOS_USER_FEATURE_EFFECT_DEBUGONLY)
{
eStatus = MOS_STATUS_USER_FEATURE_KEY_READ_FAILED;
goto finish;
}
#endif
// Read the Values from user feature
switch(pUserFeature->ValueType)
{
case MOS_USER_FEATURE_VALUE_TYPE_BINARY:
eStatus = MosUserFeatureReadValueBinary(ufKey, pUserFeature);
break;
case MOS_USER_FEATURE_VALUE_TYPE_STRING:
eStatus = MosUserFeatureReadValueString(ufKey, pUserFeature);
break;
case MOS_USER_FEATURE_VALUE_TYPE_MULTI_STRING:
eStatus = MosUserFeatureReadValueMultiString(ufKey, pUserFeature);
break;
default:
eStatus = MosUserFeatureReadValuePrimitive(ufKey, pUserFeature);
break;
}
if(eStatus != MOS_STATUS_SUCCESS)
{
MOS_OS_NORMALMESSAGE("Failed to read value from user feature eStatus:%d.", eStatus);
eStatus = MOS_STATUS_USER_FEATURE_KEY_READ_FAILED;
}
finish:
if ((pUserFeature != nullptr) &&
((eStatus == MOS_STATUS_SUCCESS) ||
(iDataFlag != MOS_USER_FEATURE_VALUE_DATA_FLAG_CUSTOM_DEFAULT_VALUE_TYPE)))
{
// Use the User Feature Value or default value in corresponding user feature key Desc Fields
// when User Feature Key read successfully or no input custom default value
MosCopyUserFeatureValueData(
&pUserFeature->Value,
pValueData,
pUserFeature->ValueType);
}
MosUserFeatureCloseKey(ufKey); // Closes the key if not nullptr
return eStatus;
}
MOS_STATUS MosUtilities::MosUserFeatureReadValueID(
PMOS_USER_FEATURE_INTERFACE pOsUserFeatureInterface,
uint32_t ValueID,
PMOS_USER_FEATURE_VALUE_DATA pValueData,
MOS_CONTEXT_HANDLE mosCtx)
{
MOS_USER_FEATURE_KEY_PATH_INFO *ufInfo = Mos_GetDeviceUfPathInfo((PMOS_CONTEXT)mosCtx);
return MosUserFeatureReadValueFromMapID(
ValueID,
pValueData,
ufInfo);
}
MOS_STATUS MosUtilities::MosUserFeatureReadValueID(
PMOS_USER_FEATURE_INTERFACE pOsUserFeatureInterface,
uint32_t ValueID,
PMOS_USER_FEATURE_VALUE_DATA pValueData,
MOS_USER_FEATURE_KEY_PATH_INFO *ufInfo)
{
return MosUserFeatureReadValueFromMapID(
ValueID,
pValueData,
ufInfo);
}
const char* MosUtilities::MosUserFeatureLookupValueName(uint32_t ValueID)
{
MOS_OS_ASSERT(ValueID != __MOS_USER_FEATURE_KEY_INVALID_ID);
PMOS_USER_FEATURE_VALUE pUserFeature = MosUtilUserInterface::GetValue(ValueID);
if (pUserFeature)
{
return pUserFeature->pValueName;
}
else
{
return nullptr;
}
}
const char *MosUtilities::MosUserFeatureLookupReadPath(uint32_t ValueID)
{
MOS_OS_ASSERT(ValueID != __MOS_USER_FEATURE_KEY_INVALID_ID);
PMOS_USER_FEATURE_VALUE pUserFeature = MosUtilUserInterface::GetValue(ValueID);
if (pUserFeature)
{
return pUserFeature->pcPath;
}
else
{
return nullptr;
}
}
const char *MosUtilities::MosUserFeatureLookupWritePath(uint32_t ValueID)
{
MOS_OS_ASSERT(ValueID != __MOS_USER_FEATURE_KEY_INVALID_ID);
PMOS_USER_FEATURE_VALUE pUserFeature = MosUtilUserInterface::GetValue(ValueID);
if (pUserFeature)
{
return pUserFeature->pcWritePath;
}
else
{
return nullptr;
}
}
MOS_STATUS MosUtilities::MosUserFeatureWriteValuesTblID(
PMOS_USER_FEATURE_VALUE_WRITE_DATA pWriteValues,
uint32_t uiNumOfValues,
MOS_USER_FEATURE_KEY_PATH_INFO *ufInfo)
{
uint32_t ui;
PMOS_USER_FEATURE_VALUE pFeatureValue = nullptr;
void *UFKey = nullptr;
PMOS_USER_FEATURE_VALUE_WRITE_DATA pUserWriteData = nullptr;
PMOS_USER_FEATURE_VALUE pUserFeature = nullptr;
uint32_t ValueID = __MOS_USER_FEATURE_KEY_INVALID_ID;
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
char WritePathWithPID[MAX_PATH];
int32_t pid;
uint64_t ulTraceData = 0;
bool isValid = false;
//--------------------------------------------------
MOS_OS_CHK_NULL_RETURN(pWriteValues);
//--------------------------------------------------
MosZeroMemory(WritePathWithPID, MAX_PATH);
pid = MosGetPid();
for (ui = 0; ui < uiNumOfValues; ui++)
{
ValueID = pWriteValues[ui].ValueID;
pUserFeature = MosUtilUserInterface::GetValue(ValueID);
MOS_OS_CHK_NULL_RETURN(pUserFeature);
// Open the user feature
// Assigned the pUserFeature to UFKey for future reading
UFKey = pUserFeature;
//append write path with pid
sprintf_s(WritePathWithPID, MAX_PATH, "%s\\%d", pUserFeature->pcWritePath, pid);
// Trace data in case opening user feature for write fails
switch (pUserFeature->ValueType)
{
case MOS_USER_FEATURE_VALUE_TYPE_BOOL:
case MOS_USER_FEATURE_VALUE_TYPE_INT32:
case MOS_USER_FEATURE_VALUE_TYPE_UINT32:
case MOS_USER_FEATURE_VALUE_TYPE_FLOAT:
ulTraceData = pWriteValues[ui].Value.u32Data;
isValid = true;
break;
case MOS_USER_FEATURE_VALUE_TYPE_INT64:
case MOS_USER_FEATURE_VALUE_TYPE_UINT64:
ulTraceData = pWriteValues[ui].Value.u64Data;
isValid = true;
break;
default:
MOS_OS_NORMALMESSAGE("Unknown value type %d", pUserFeature->ValueType);
}
if (isValid)
{
MosTraceDataDictionary(pUserFeature->pValueName, &ulTraceData, sizeof(ulTraceData));
}
//try to open Write path with pid first
if ((eStatus = MosUserFeatureOpen(
pUserFeature->Type,
WritePathWithPID,
KEY_WRITE,
&UFKey,
ufInfo)) != MOS_STATUS_SUCCESS)
{
MOS_OS_NORMALMESSAGE("Failed to open user feature for concurrency.");
if ((eStatus = MosUserFeatureOpen(
pUserFeature->Type,
pUserFeature->pcWritePath,
KEY_WRITE,
&UFKey,
ufInfo)) != MOS_STATUS_SUCCESS)
{
MOS_OS_NORMALMESSAGE("Failed to open user feature for writing.");
eStatus = MOS_STATUS_USER_FEATURE_KEY_OPEN_FAILED;
goto finish;
}
}
//------------------------------------
MOS_OS_ASSERT(pUserFeature->ValueType != MOS_USER_FEATURE_VALUE_TYPE_INVALID);
//------------------------------------
switch(pUserFeature->ValueType)
{
case MOS_USER_FEATURE_VALUE_TYPE_BINARY:
if ((eStatus = MosUserFeatureWriteValueBinary(UFKey, pUserFeature, &(pWriteValues[ui].Value))) != MOS_STATUS_SUCCESS)
{
MOS_OS_ASSERTMESSAGE("Failed to write binary value to user feature.");
eStatus = MOS_STATUS_USER_FEATURE_KEY_WRITE_FAILED;
goto finish;
}
break;
case MOS_USER_FEATURE_VALUE_TYPE_STRING:
if ((eStatus = MosUserFeatureWriteValueString(UFKey, pUserFeature, &(pWriteValues[ui].Value))) != MOS_STATUS_SUCCESS)
{
MOS_OS_ASSERTMESSAGE("Failed to write string value to user feature.");
eStatus = MOS_STATUS_USER_FEATURE_KEY_WRITE_FAILED;
goto finish;
}
break;
case MOS_USER_FEATURE_VALUE_TYPE_MULTI_STRING:
if ((eStatus = MosUserFeatureWriteValueMultiString(UFKey, pUserFeature, &(pWriteValues[ui].Value))) != MOS_STATUS_SUCCESS)
{
MOS_OS_ASSERTMESSAGE("Failed to write multi string value to user feature.");
eStatus = MOS_STATUS_USER_FEATURE_KEY_WRITE_FAILED;
goto finish;
}
break;
default:
if ((eStatus = MosUserFeatureWriteValuePrimitive(UFKey, pUserFeature, &(pWriteValues[ui].Value))) != MOS_STATUS_SUCCESS)
{
MOS_OS_ASSERTMESSAGE("Failed to write primitive data value to user feature.");
eStatus = MOS_STATUS_USER_FEATURE_KEY_WRITE_FAILED;
goto finish;
}
}
MosUserFeatureCloseKey(UFKey); // Closes the key if not nullptr
}
finish:
if (eStatus != MOS_STATUS_SUCCESS)
{
MosUserFeatureCloseKey(UFKey); // Closes the key if not nullptr
}
return eStatus;
}
MOS_STATUS MosUtilities::MosUserFeatureWriteValuesID(
PMOS_USER_FEATURE_INTERFACE pOsUserFeatureInterface,
PMOS_USER_FEATURE_VALUE_WRITE_DATA pWriteValues,
uint32_t uiNumOfValues,
MOS_CONTEXT_HANDLE mosCtx)
{
MOS_USER_FEATURE_KEY_PATH_INFO *ufInfo = Mos_GetDeviceUfPathInfo((PMOS_CONTEXT)mosCtx);
return MosUserFeatureWriteValuesTblID(
pWriteValues,
uiNumOfValues,
ufInfo);
}
MOS_STATUS MosUtilities::MosUserFeatureWriteValuesID(
PMOS_USER_FEATURE_INTERFACE pOsUserFeatureInterface,
PMOS_USER_FEATURE_VALUE_WRITE_DATA pWriteValues,
uint32_t uiNumOfValues,
MOS_USER_FEATURE_KEY_PATH_INFO * ufInfo)
{
return MosUserFeatureWriteValuesTblID(
pWriteValues,
uiNumOfValues,
ufInfo);
}