1 /*
2 * Copyright (c) 2022, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file mos_utilities_usersetting.cpp
24 //! \brief This module implements the MOS wrapper functions
25 //!
26
27 #include "mos_os.h"
28 #include "mos_util_user_interface.h"
29 #include "media_user_settings_mgr.h"
30
31 #define __MAX_MULTI_STRING_COUNT 128
32
33 char s_xmlFilePath[MOS_USER_CONTROL_MAX_DATA_SIZE] = {};
34
35 /*****************************************************************************
36 |
37 | USER FEATURE Functions
38 |
39 *****************************************************************************/
MosFreeUserFeatureValueString(PMOS_USER_FEATURE_VALUE_STRING pUserString)40 void MosUtilities::MosFreeUserFeatureValueString(PMOS_USER_FEATURE_VALUE_STRING pUserString)
41 {
42 if (pUserString != nullptr)
43 {
44 if (pUserString->uSize > 0)
45 {
46 if (pUserString->pStringData)
47 {
48 MOS_FreeMemAndSetNull(pUserString->pStringData);
49 MosAtomicDecrement(m_mosMemAllocFakeCounter);
50 }
51 pUserString->uSize = 0;
52 }
53 }
54 }
55
MosWriteOneUserFeatureKeyToXML(PMOS_USER_FEATURE_VALUE pUserFeature)56 MOS_STATUS MosUtilities::MosWriteOneUserFeatureKeyToXML(PMOS_USER_FEATURE_VALUE pUserFeature)
57 {
58 char sOutBuf[MOS_USER_CONTROL_MAX_DATA_SIZE];
59 char ValueType[MAX_USER_FEATURE_FIELD_LENGTH];
60 char KeyPath[MOS_USER_CONTROL_MAX_DATA_SIZE];
61 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
62
63 MOS_OS_CHK_NULL_RETURN(pUserFeature);
64
65 switch (pUserFeature->Type)
66 {
67 case MOS_USER_FEATURE_TYPE_USER:
68 MosSecureStringPrint(
69 KeyPath,
70 sizeof(KeyPath),
71 sizeof(KeyPath),
72 "UFINT\\%s",
73 pUserFeature->pcPath);
74 break;
75 case MOS_USER_FEATURE_TYPE_SYSTEM:
76 MosSecureStringPrint(
77 KeyPath,
78 sizeof(KeyPath),
79 sizeof(KeyPath),
80 "UFEXT\\%s",
81 pUserFeature->pcPath);
82 break;
83 default:
84 MosSecureStringPrint(
85 KeyPath,
86 sizeof(KeyPath),
87 sizeof(KeyPath),
88 "%s",pUserFeature->pcPath);
89 break;
90 }
91
92 switch (pUserFeature->ValueType)
93 {
94 case MOS_USER_FEATURE_VALUE_TYPE_BOOL:
95 MosSecureStringPrint(
96 ValueType,
97 sizeof(ValueType),
98 sizeof(ValueType),
99 "bool");
100 break;
101 case MOS_USER_FEATURE_VALUE_TYPE_FLOAT:
102 case MOS_USER_FEATURE_VALUE_TYPE_UINT32:
103 case MOS_USER_FEATURE_VALUE_TYPE_INT32:
104 MosSecureStringPrint(
105 ValueType,
106 sizeof(ValueType),
107 sizeof(ValueType),
108 "dword");
109 break;
110 case MOS_USER_FEATURE_VALUE_TYPE_UINT64:
111 case MOS_USER_FEATURE_VALUE_TYPE_INT64:
112 MosSecureStringPrint(
113 ValueType,
114 sizeof(ValueType),
115 sizeof(ValueType),
116 "qword");
117 break;
118 case MOS_USER_FEATURE_VALUE_TYPE_MULTI_STRING:
119 case MOS_USER_FEATURE_VALUE_TYPE_STRING:
120 MosSecureStringPrint(
121 ValueType,
122 sizeof(ValueType),
123 sizeof(ValueType),
124 "string");
125 break;
126 default:
127 MosSecureStringPrint(
128 ValueType,
129 sizeof(ValueType),
130 sizeof(ValueType),
131 "unknown");
132 break;
133 }
134
135 MosZeroMemory(sOutBuf, sizeof(sOutBuf));
136 MosSecureStringPrint(
137 sOutBuf,
138 sizeof(sOutBuf),
139 sizeof(sOutBuf),
140 " <Key name=\"%s\" type=\"%s\" location=\"%s\" defaultval=\"%s\" description=\"%s\" />\n",
141 pUserFeature->pValueName,
142 ValueType,
143 KeyPath,
144 pUserFeature->DefaultValue,
145 pUserFeature->pcDescription);
146 MosAppendFileFromPtr(
147 s_xmlFilePath,
148 sOutBuf,
149 (uint32_t)strlen(sOutBuf));
150 return eStatus;
151 }
152
MosWriteOneUserFeatureGroupToXML(MOS_USER_FEATURE_VALUE UserFeatureFilter)153 MOS_STATUS MosUtilities::MosWriteOneUserFeatureGroupToXML(MOS_USER_FEATURE_VALUE UserFeatureFilter)
154 {
155 char sOutBuf[MAX_USER_FEATURE_FIELD_LENGTH];
156 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
157
158 // Group Header Start
159 MosZeroMemory(sOutBuf, sizeof(sOutBuf));
160 MosSecureStringPrint(
161 sOutBuf,
162 sizeof(sOutBuf),
163 sizeof(sOutBuf),
164 " <Group name=\"%s\">\n",
165 UserFeatureFilter.pcGroup);
166 eStatus = MosAppendFileFromPtr(
167 s_xmlFilePath,
168 sOutBuf,
169 (uint32_t)strlen(sOutBuf));
170
171 // Group User Feature Keys
172 eStatus = MosGetItemFromMosUserFeatureDescField(
173 m_mosUserFeatureDescFields,
174 __MOS_USER_FEATURE_KEY_MAX_ID,
175 __MOS_USER_FEATURE_KEY_MAX_ID,
176 &MosWriteOneUserFeatureKeyToXML,
177 &UserFeatureFilter);
178
179 // Group Header End
180 MosZeroMemory(sOutBuf, sizeof(sOutBuf));
181 MosSecureStringPrint(
182 sOutBuf,
183 sizeof(sOutBuf),
184 sizeof(sOutBuf),
185 " </Group>\n");
186 eStatus = MosAppendFileFromPtr(
187 s_xmlFilePath,
188 sOutBuf,
189 (uint32_t)strlen(sOutBuf));
190 return eStatus;
191 }
192
MosGenerateUserFeatureKeyXML(MOS_CONTEXT_HANDLE mosCtx)193 MOS_STATUS MosUtilities::MosGenerateUserFeatureKeyXML(MOS_CONTEXT_HANDLE mosCtx)
194 {
195 char sOutBuf[MAX_USER_FEATURE_FIELD_LENGTH];
196 uint32_t uiIndex=0;
197 MOS_USER_FEATURE_VALUE UserFeatureFilter = __NULL_USER_FEATURE_VALUE__;
198 MOS_USER_FEATURE_VALUE_DATA UserFeatureData;
199 const char * const FilterGroups[] = { "Codec", "Decode", "Encode", "CP", "General", "MOS",
200 "Report", "VP", "Media", "Secure HEVC Encode", "MDF"};
201 uint32_t FilterGroupsCount = sizeof(FilterGroups) / sizeof(FilterGroups[0]);
202 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
203 // Check if XML dump is enabled by User Feature Key
204 MosZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
205 eStatus = MosUserFeatureReadValueID(
206 nullptr,
207 __MOS_USER_FEATURE_KEY_XML_AUTOGEN_ID,
208 &UserFeatureData,
209 mosCtx);
210 if (UserFeatureData.u32Data == 0)
211 {
212 eStatus = MOS_STATUS_INVALID_PARAMETER;
213 return eStatus;
214 }
215 MosZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
216 UserFeatureData.StringData.pStringData = s_xmlFilePath;
217 eStatus = MosUserFeatureReadValueID(
218 nullptr,
219 __MOS_USER_FEATURE_KEY_XML_FILEPATH_ID,
220 &UserFeatureData,
221 mosCtx);
222 // User Feature Key Header Start
223 MosZeroMemory(sOutBuf, sizeof(sOutBuf));
224 MosSecureStringPrint(
225 sOutBuf,
226 sizeof(sOutBuf),
227 sizeof(sOutBuf),
228 "<UserFeatureKeys>\n");
229 eStatus = MosWriteFileFromPtr(
230 UserFeatureData.StringData.pStringData,
231 sOutBuf,
232 (uint32_t)strlen(sOutBuf));
233 // User Feature Key Groups
234 for (uiIndex = 0; uiIndex < FilterGroupsCount; uiIndex++)
235 {
236 UserFeatureFilter.pcGroup = FilterGroups[uiIndex];
237 eStatus = MosWriteOneUserFeatureGroupToXML(UserFeatureFilter);
238 if (eStatus!= MOS_STATUS_SUCCESS)
239 {
240 MOS_OS_ASSERTMESSAGE("Failed to Write One User FeatureGroup To XML");
241 }
242 }
243
244 // User Feature Key Header End
245 MosZeroMemory(sOutBuf, sizeof(sOutBuf));
246 MosSecureStringPrint(
247 sOutBuf,
248 sizeof(sOutBuf),
249 sizeof(sOutBuf),
250 "</UserFeatureKeys>\n");
251 eStatus = MosAppendFileFromPtr(
252 UserFeatureData.StringData.pStringData,
253 sOutBuf,
254 (uint32_t)strlen(sOutBuf));
255 return eStatus;
256 }
257
MosUserFeatureSetMultiStringValue(PMOS_USER_FEATURE_VALUE_DATA pFeatureData,uint32_t dwSize)258 MOS_STATUS MosUtilities::MosUserFeatureSetMultiStringValue(
259 PMOS_USER_FEATURE_VALUE_DATA pFeatureData,
260 uint32_t dwSize)
261 {
262 PMOS_USER_FEATURE_VALUE_STRING pStrings;
263 uint32_t uiNumStrings;
264 uint32_t ui;
265 char *pData;
266 char *pCurData;
267 uint32_t dwLen;
268 uint32_t dwPos;
269
270 MOS_OS_CHK_NULL_RETURN(pFeatureData);
271 MOS_OS_ASSERT(dwSize);
272
273 pStrings = pFeatureData->MultiStringData.pStrings;
274 pData = pFeatureData->MultiStringData.pMultStringData;
275 dwPos = 0;
276 uiNumStrings = 0;
277
278 MOS_OS_ASSERT(pStrings);
279 MOS_OS_ASSERT(pData);
280
281 // Find number of strings in the multi string array
282 do
283 {
284 pCurData = pData + dwPos;
285 dwLen = (uint32_t)strlen(pCurData);
286 if (dwLen == 0)
287 {
288 MOS_OS_NORMALMESSAGE("Invalid user feature key entry.");
289 return MOS_STATUS_INVALID_PARAMETER;
290 }
291 uiNumStrings++;
292 dwPos += dwLen + 1;
293
294 if (dwPos >= (dwSize - 1))
295 {
296 // last entry
297 break;
298 }
299 } while (true);
300
301 // Check the size of MultiStringData
302 if (pFeatureData->MultiStringData.uCount < uiNumStrings)
303 {
304 MOS_OS_NORMALMESSAGE("pFeatureValue->MultiStringData.uCount is smaller than the actual necessary number.");
305 return MOS_STATUS_UNKNOWN;
306 }
307
308 // Populate Array
309 dwPos = 0;
310 for (ui = 0; ui < uiNumStrings; ui++)
311 {
312 pCurData = pData + dwPos;
313 dwLen = (uint32_t)strlen(pCurData);
314 MOS_OS_ASSERT(dwLen > 0);
315 pStrings[ui].pStringData = pCurData;
316 pStrings[ui].uSize = dwLen;
317
318 dwPos += dwLen + 1;
319 }
320
321 pFeatureData->MultiStringData.uCount = uiNumStrings;
322 pFeatureData->MultiStringData.uSize = dwPos;
323
324 return MOS_STATUS_SUCCESS;
325 }
326
MosCopyUserFeatureValueData(PMOS_USER_FEATURE_VALUE_DATA pSrcData,PMOS_USER_FEATURE_VALUE_DATA pDstData,MOS_USER_FEATURE_VALUE_TYPE ValueType)327 MOS_STATUS MosUtilities::MosCopyUserFeatureValueData(
328 PMOS_USER_FEATURE_VALUE_DATA pSrcData,
329 PMOS_USER_FEATURE_VALUE_DATA pDstData,
330 MOS_USER_FEATURE_VALUE_TYPE ValueType)
331 {
332 uint32_t ui;
333 PMOS_USER_FEATURE_VALUE_STRING pSrcString = nullptr;
334 PMOS_USER_FEATURE_VALUE_STRING pDstString = nullptr;
335 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
336
337 //------------------------------
338 MOS_OS_ASSERT(pSrcData);
339 MOS_OS_ASSERT(pDstData);
340 MOS_OS_ASSERT(ValueType != MOS_USER_FEATURE_VALUE_TYPE_INVALID);
341 //------------------------------
342
343 switch(ValueType)
344 {
345 case MOS_USER_FEATURE_VALUE_TYPE_BOOL:
346 pDstData->bData = pSrcData->bData;
347 break;
348 case MOS_USER_FEATURE_VALUE_TYPE_INT32:
349 pDstData->i32Data = pSrcData->i32Data;
350 break;
351 case MOS_USER_FEATURE_VALUE_TYPE_INT64:
352 pDstData->i64Data = pSrcData->i64Data;
353 break;
354 case MOS_USER_FEATURE_VALUE_TYPE_UINT32:
355 pDstData->u32Data = pSrcData->u32Data;
356 break;
357 case MOS_USER_FEATURE_VALUE_TYPE_UINT64:
358 pDstData->u64Data = pSrcData->u64Data;
359 break;
360 case MOS_USER_FEATURE_VALUE_TYPE_FLOAT:
361 pDstData->fData = pSrcData->fData;
362 break;
363 case MOS_USER_FEATURE_VALUE_TYPE_STRING:
364 if ((pSrcData->StringData.pStringData != nullptr) && (strlen(pSrcData->StringData.pStringData) != 0))
365 {
366 pDstData->StringData.uMaxSize = pSrcData->StringData.uMaxSize;
367 pDstData->StringData.uSize = pSrcData->StringData.uSize;
368 if (pDstData->StringData.pStringData == nullptr)
369 {
370 MOS_OS_ASSERTMESSAGE("Failed to allocate memory.");
371 return MOS_STATUS_NULL_POINTER;
372 }
373 eStatus = MosSecureMemcpy(
374 pDstData->StringData.pStringData,
375 pDstData->StringData.uSize,
376 pSrcData->StringData.pStringData,
377 pSrcData->StringData.uSize);
378 }
379 break;
380 case MOS_USER_FEATURE_VALUE_TYPE_MULTI_STRING:
381 if ((pSrcData->MultiStringData.pMultStringData != nullptr) && (strlen(pSrcData->MultiStringData.pMultStringData) != 0))
382 {
383 pDstData->MultiStringData.uCount = pSrcData->MultiStringData.uCount;
384 pDstData->MultiStringData.uMaxSize = pSrcData->MultiStringData.uMaxSize;
385 pDstData->MultiStringData.uSize = pSrcData->MultiStringData.uSize;
386 if (pDstData->MultiStringData.pMultStringData != nullptr)
387 {
388 eStatus = MosSecureMemcpy(
389 pDstData->MultiStringData.pMultStringData,
390 pDstData->MultiStringData.uSize,
391 pSrcData->MultiStringData.pMultStringData,
392 pSrcData->MultiStringData.uSize);
393
394 for (ui = 0; ui < pSrcData->MultiStringData.uCount; ui++)
395 {
396 pSrcString = &pSrcData->MultiStringData.pStrings[ui];
397 pDstString = &pDstData->MultiStringData.pStrings[ui];
398
399 MOS_OS_CHK_NULL(pSrcString);
400 MOS_OS_CHK_NULL(pDstString);
401 pDstString->uMaxSize = pSrcString->uMaxSize;
402 pDstString->uSize = pSrcString->uSize;
403 if (pDstString->pStringData != nullptr)
404 {
405 eStatus = MosSecureMemcpy(
406 pDstString->pStringData,
407 pDstString->uSize+1,
408 pSrcString->pStringData,
409 pSrcString->uSize+1);
410 }// if
411 }// for
412 }
413 }// if
414 break;
415 default:
416 break;
417 }
418 finish:
419 return eStatus;
420 }
421
MosAssignUserFeatureValueData(PMOS_USER_FEATURE_VALUE_DATA pDstData,const char * pData,MOS_USER_FEATURE_VALUE_TYPE ValueType)422 MOS_STATUS MosUtilities::MosAssignUserFeatureValueData(
423 PMOS_USER_FEATURE_VALUE_DATA pDstData,
424 const char *pData,
425 MOS_USER_FEATURE_VALUE_TYPE ValueType
426 )
427 {
428 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
429 uint32_t dwUFSize = 0;
430
431 //------------------------------
432 MOS_OS_ASSERT(pData);
433 MOS_OS_ASSERT(pDstData);
434 MOS_OS_ASSERT(ValueType != MOS_USER_FEATURE_VALUE_TYPE_INVALID);
435 //------------------------------
436
437 switch(ValueType)
438 {
439 case MOS_USER_FEATURE_VALUE_TYPE_BOOL:
440 pDstData->bData = atoi(pData);
441 break;
442 case MOS_USER_FEATURE_VALUE_TYPE_INT32:
443 pDstData->i32Data = atoi(pData);
444 break;
445 case MOS_USER_FEATURE_VALUE_TYPE_INT64:
446 pDstData->i64Data = atol(pData);
447 break;
448 case MOS_USER_FEATURE_VALUE_TYPE_UINT32:
449 pDstData->u32Data = atoi(pData);
450 break;
451 case MOS_USER_FEATURE_VALUE_TYPE_UINT64:
452 pDstData->u64Data = atol(pData);
453 break;
454 case MOS_USER_FEATURE_VALUE_TYPE_FLOAT:
455 pDstData->fData = (float)atol(pData);
456 break;
457 case MOS_USER_FEATURE_VALUE_TYPE_STRING:
458 pDstData->StringData.uMaxSize = MOS_USER_CONTROL_MAX_DATA_SIZE;
459 if ((pData != nullptr) && (strlen(pData) != 0))
460 {
461 pDstData->StringData.uSize = (uint32_t)strlen(pData) + 1;
462 if (pDstData->StringData.uSize > pDstData->StringData.uMaxSize)
463 {
464 pDstData->StringData.uSize = pDstData->StringData.uMaxSize;
465 }
466 pDstData->StringData.pStringData = (char *)MOS_AllocAndZeroMemory(strlen(pData) + 1);
467 if (pDstData->StringData.pStringData == nullptr)
468 {
469 MOS_OS_ASSERTMESSAGE("Failed to allocate memory.");
470 return MOS_STATUS_NULL_POINTER;
471 }
472 MosAtomicIncrement(m_mosMemAllocFakeCounter);
473 eStatus = MosSecureStrcpy(
474 pDstData->StringData.pStringData,
475 pDstData->StringData.uSize,
476 (char *)pData);
477 }
478 break;
479 case MOS_USER_FEATURE_VALUE_TYPE_MULTI_STRING:
480
481 pDstData->MultiStringData.uCount = MOS_USER_MAX_STRING_COUNT;
482 pDstData->MultiStringData.uMaxSize = MOS_USER_CONTROL_MAX_DATA_SIZE;
483 pDstData->MultiStringData.pStrings = (PMOS_USER_FEATURE_VALUE_STRING)MOS_AllocAndZeroMemory(sizeof(MOS_USER_FEATURE_VALUE_STRING) * __MAX_MULTI_STRING_COUNT);
484 if (pDstData->MultiStringData.pStrings == nullptr)
485 {
486 MOS_OS_ASSERTMESSAGE("Failed to allocate memory.");
487 pDstData->MultiStringData.pMultStringData = nullptr;
488 pDstData->MultiStringData.uSize = 0;
489 pDstData->MultiStringData.uCount = 0;
490 return MOS_STATUS_NULL_POINTER;
491 }
492 MosAtomicIncrement(m_mosMemAllocFakeCounter);
493 if ((pData != nullptr) && (strlen(pData) != 0))
494 {
495 if (!pDstData->MultiStringData.pMultStringData)
496 {
497 MosAtomicIncrement(m_mosMemAllocFakeCounter);
498 }
499 MOS_SafeFreeMemory(pDstData->MultiStringData.pMultStringData);
500 pDstData->MultiStringData.pMultStringData = (char *)MOS_AllocAndZeroMemory(strlen(pData) + 1);
501 if (pDstData->MultiStringData.pMultStringData == nullptr)
502 {
503 MOS_OS_ASSERTMESSAGE("Failed to allocate memory.");
504 return MOS_STATUS_NULL_POINTER;
505 }
506 eStatus = MosSecureMemcpy(
507 pDstData->MultiStringData.pMultStringData,
508 strlen(pData),
509 (char *)pData,
510 strlen(pData));
511 if ((eStatus = MosUserFeatureSetMultiStringValue(
512 pDstData,
513 dwUFSize)) != MOS_STATUS_SUCCESS)
514 {
515 MOS_OS_ASSERTMESSAGE("Failed to set multi string value.");
516 return eStatus;
517 }
518 }
519 break;
520 default:
521 break;
522 }
523 return eStatus;
524 }
MosUserFeatureSetDefaultValues(PMOS_USER_FEATURE_VALUE_WRITE_DATA pWriteValues,uint32_t uiNumOfValues)525 MOS_STATUS MosUtilities::MosUserFeatureSetDefaultValues(
526 PMOS_USER_FEATURE_VALUE_WRITE_DATA pWriteValues,
527 uint32_t uiNumOfValues)
528 {
529 uint32_t ui;
530 PMOS_USER_FEATURE_VALUE pUserFeature = nullptr;
531 uint32_t ValueID = __MOS_USER_FEATURE_KEY_INVALID_ID;
532 MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
533
534 //--------------------------------------------------
535 MOS_OS_CHK_NULL_RETURN(pWriteValues);
536 //--------------------------------------------------
537 for (ui = 0; ui < uiNumOfValues; ui++)
538 {
539 ValueID = pWriteValues[ui].ValueID;
540 pUserFeature = MosUtilUserInterface::GetValue(ValueID);
541 MOS_OS_CHK_NULL_RETURN(pUserFeature);
542 // Copy the write data into corresponding user feature value
543 MosCopyUserFeatureValueData(
544 &pWriteValues[ui].Value,
545 &pUserFeature->Value,
546 pUserFeature->ValueType);
547 }
548 eStatus = MOS_STATUS_SUCCESS;
549 return eStatus;
550 }
551
MosDeclareUserFeatureKey(PMOS_USER_FEATURE_VALUE pUserFeatureKey)552 MOS_STATUS MosUtilities::MosDeclareUserFeatureKey(PMOS_USER_FEATURE_VALUE pUserFeatureKey)
553 {
554 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
555 //------------------------------
556 MOS_OS_CHK_NULL_RETURN(pUserFeatureKey);
557 //------------------------------
558
559 eStatus = MosAssignUserFeatureValueData(
560 &pUserFeatureKey->Value,
561 pUserFeatureKey->DefaultValue,
562 pUserFeatureKey->ValueType);
563
564 if (eStatus == MOS_STATUS_SUCCESS)
565 {
566 MosUtilUserInterface::AddEntry(pUserFeatureKey->ValueID, pUserFeatureKey);
567 }
568 return eStatus;
569 }
570
MosDestroyUserFeatureData(PMOS_USER_FEATURE_VALUE_DATA pData,MOS_USER_FEATURE_VALUE_TYPE ValueType)571 MOS_STATUS MosUtilities::MosDestroyUserFeatureData(PMOS_USER_FEATURE_VALUE_DATA pData,MOS_USER_FEATURE_VALUE_TYPE ValueType)
572 {
573 uint32_t ui;
574 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
575 //------------------------------
576 if (pData == nullptr)
577 {
578 return eStatus;
579 }
580 //------------------------------
581
582 switch (ValueType)
583 {
584 case MOS_USER_FEATURE_VALUE_TYPE_STRING:
585 MosFreeUserFeatureValueString(&pData->StringData);
586 break;
587 case MOS_USER_FEATURE_VALUE_TYPE_MULTI_STRING:
588 for (ui = 0; ui < pData->MultiStringData.uCount; ui++)
589 {
590 MosFreeUserFeatureValueString(&pData->MultiStringData.pStrings[ui]);
591 }
592 MOS_SafeFreeMemory(pData->MultiStringData.pStrings);
593 MosAtomicDecrement(m_mosMemAllocFakeCounter);
594 pData->MultiStringData.pStrings = nullptr;
595 pData->MultiStringData.pMultStringData = nullptr;
596 pData->MultiStringData.uSize = 0;
597 pData->MultiStringData.uCount = 0;
598 break;
599 default:
600 break;
601 }
602
603 return eStatus;
604 }
605
MosDestroyUserFeatureKey(PMOS_USER_FEATURE_VALUE pUserFeatureKey)606 MOS_STATUS MosUtilities::MosDestroyUserFeatureKey(PMOS_USER_FEATURE_VALUE pUserFeatureKey)
607 {
608 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
609
610 //------------------------------
611 MOS_OS_CHK_NULL_RETURN(pUserFeatureKey);
612 //------------------------------
613
614 MosUtilUserInterface::DelEntry(pUserFeatureKey->ValueID);
615 eStatus = MosDestroyUserFeatureData(
616 &pUserFeatureKey->Value,
617 pUserFeatureKey->ValueType);
618
619 return eStatus;
620 }
621
MosIsCorrectDefaultValueType(const char * pData,MOS_USER_FEATURE_VALUE_TYPE ValueType)622 MOS_STATUS MosUtilities::MosIsCorrectDefaultValueType(
623 const char *pData,
624 MOS_USER_FEATURE_VALUE_TYPE ValueType)
625 {
626 uint32_t dwLen;
627 uint32_t ui;
628 int32_t IntVal;
629 MOS_STATUS eStatus = MOS_STATUS_INVALID_PARAMETER;
630
631 dwLen = (uint32_t)strlen(pData);
632 //------------------------------
633 MOS_OS_ASSERT(pData);
634 MOS_OS_ASSERT(ValueType != MOS_USER_FEATURE_VALUE_TYPE_INVALID);
635 //------------------------------
636 switch (ValueType)
637 {
638 case MOS_USER_FEATURE_VALUE_TYPE_BOOL:
639 if ((!strcmp(pData, "0")) || (!strcmp(pData, "1")))
640 {
641 eStatus = MOS_STATUS_SUCCESS;
642 }
643 break;
644 case MOS_USER_FEATURE_VALUE_TYPE_INT32:
645 case MOS_USER_FEATURE_VALUE_TYPE_INT64:
646 case MOS_USER_FEATURE_VALUE_TYPE_UINT32:
647 case MOS_USER_FEATURE_VALUE_TYPE_UINT64:
648 case MOS_USER_FEATURE_VALUE_TYPE_FLOAT:
649 eStatus = MOS_STATUS_SUCCESS;
650 for (ui = 0; ui<dwLen; ui++)
651 {
652 IntVal = pData[ui] - '0';
653 if ((0 > IntVal) || (9 < IntVal))
654 {
655 if ((((ui == 0)&&(pData[ui] - '-') != 0)) && ((pData[ui] - '.') != 0))
656 {
657 eStatus = MOS_STATUS_INVALID_PARAMETER;
658 break;
659 }
660 }
661 }
662 break;
663 case MOS_USER_FEATURE_VALUE_TYPE_STRING:
664 eStatus = MOS_STATUS_SUCCESS;
665 break;
666 case MOS_USER_FEATURE_VALUE_TYPE_MULTI_STRING:
667 eStatus = MOS_STATUS_SUCCESS;
668 break;
669 default:
670 break;
671 }
672 return eStatus;
673 }
674
MosIsCorrectUserFeatureDescField(PMOS_USER_FEATURE_VALUE pUserFeatureKey,uint32_t maxKeyID)675 MOS_STATUS MosUtilities::MosIsCorrectUserFeatureDescField(PMOS_USER_FEATURE_VALUE pUserFeatureKey, uint32_t maxKeyID)
676 {
677 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
678 MOS_OS_CHK_NULL_RETURN(pUserFeatureKey);
679 if ((pUserFeatureKey->ValueID <= __MOS_USER_FEATURE_KEY_INVALID_ID) ||
680 (pUserFeatureKey->ValueID >= maxKeyID))
681 {
682 eStatus = MOS_STATUS_INVALID_PARAMETER;
683 return eStatus;
684 }
685 MOS_OS_CHK_NULL_RETURN(pUserFeatureKey->pValueName);
686 MOS_OS_CHK_NULL_RETURN(pUserFeatureKey->pcPath);
687 MOS_OS_CHK_NULL_RETURN(pUserFeatureKey->pcWritePath);
688 MOS_OS_CHK_NULL_RETURN(pUserFeatureKey->pcGroup);
689
690 if ((pUserFeatureKey->pcDescription != nullptr) &&
691 (strlen(pUserFeatureKey->pcDescription) > MAX_USER_FEATURE_FIELD_LENGTH))
692 {
693 eStatus = MOS_STATUS_INVALID_PARAMETER;
694 return eStatus;
695 }
696 eStatus = MosIsCorrectDefaultValueType(
697 pUserFeatureKey->DefaultValue,
698 pUserFeatureKey->ValueType);
699 return eStatus;
700 }
701
MosGetItemFromMosUserFeatureDescField(MOS_USER_FEATURE_VALUE * descTable,uint32_t numOfItems,uint32_t maxId,MOS_STATUS (* CallbackFunc)(PMOS_USER_FEATURE_VALUE),PMOS_USER_FEATURE_VALUE pUserFeatureKeyFilter)702 MOS_STATUS MosUtilities::MosGetItemFromMosUserFeatureDescField(
703 MOS_USER_FEATURE_VALUE *descTable,
704 uint32_t numOfItems,
705 uint32_t maxId,
706 MOS_STATUS (*CallbackFunc)(PMOS_USER_FEATURE_VALUE),
707 PMOS_USER_FEATURE_VALUE pUserFeatureKeyFilter)
708 {
709 uint32_t uiIndex = 0;
710 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
711 //------------------------------
712 MOS_OS_CHK_NULL_RETURN(CallbackFunc);
713 MOS_OS_CHK_NULL_RETURN(pUserFeatureKeyFilter);
714 MOS_OS_CHK_NULL_RETURN(descTable);
715 //------------------------------
716
717 for (uiIndex = __MOS_USER_FEATURE_KEY_INVALID_ID; uiIndex < numOfItems; uiIndex++)
718 {
719 if (MosIsCorrectUserFeatureDescField(&descTable[uiIndex], maxId) != MOS_STATUS_SUCCESS)
720 {
721 continue;
722 }
723
724 if ((pUserFeatureKeyFilter->ValueID != __MOS_USER_FEATURE_KEY_INVALID_ID) && (pUserFeatureKeyFilter->ValueID != descTable[uiIndex].ValueID))
725 {
726 continue;
727 }
728 if ((pUserFeatureKeyFilter->pValueName != nullptr) && (strcmp(pUserFeatureKeyFilter->pValueName, descTable[uiIndex].pValueName) != 0))
729 {
730 continue;
731 }
732 if ((pUserFeatureKeyFilter->pcPath != nullptr) && (strcmp(pUserFeatureKeyFilter->pcPath, descTable[uiIndex].pcPath) != 0))
733 {
734 continue;
735 }
736 if ((pUserFeatureKeyFilter->pcWritePath != nullptr) && (strcmp(pUserFeatureKeyFilter->pcWritePath, descTable[uiIndex].pcWritePath) != 0))
737 {
738 continue;
739 }
740 if ((pUserFeatureKeyFilter->pcGroup != nullptr) && (strcmp(pUserFeatureKeyFilter->pcGroup, descTable[uiIndex].pcGroup) != 0))
741 {
742 continue;
743 }
744 if ((pUserFeatureKeyFilter->Type != MOS_USER_FEATURE_TYPE_INVALID) && (pUserFeatureKeyFilter->Type != descTable[uiIndex].Type))
745 {
746 continue;
747 }
748 if ((pUserFeatureKeyFilter->ValueType != MOS_USER_FEATURE_VALUE_TYPE_INVALID) && (pUserFeatureKeyFilter->ValueType != descTable[uiIndex].ValueType))
749 {
750 continue;
751 }
752 eStatus = (*CallbackFunc)(&descTable[uiIndex]);
753
754 }
755 return eStatus;
756 }
757
MosDeclareUserFeatureKeysFromDescFields(MOS_USER_FEATURE_VALUE * descTable,uint32_t numOfItems,uint32_t maxId)758 MOS_STATUS MosUtilities::MosDeclareUserFeatureKeysFromDescFields(
759 MOS_USER_FEATURE_VALUE *descTable,
760 uint32_t numOfItems,
761 uint32_t maxId)
762 {
763 MOS_USER_FEATURE_VALUE UserFeatureKeyFilter = __NULL_USER_FEATURE_VALUE__;
764 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
765
766 eStatus = MosGetItemFromMosUserFeatureDescField(
767 descTable,
768 numOfItems,
769 maxId,
770 &MosDeclareUserFeatureKey,
771 &UserFeatureKeyFilter);
772 return eStatus;
773 }
774
MosDeclareUserFeatureKeysForAllDescFields()775 MOS_STATUS MosUtilities::MosDeclareUserFeatureKeysForAllDescFields()
776 {
777 MOS_OS_CHK_STATUS_RETURN(MosDeclareUserFeatureKeysFromDescFields(
778 m_mosUserFeatureDescFields,
779 __MOS_USER_FEATURE_KEY_MAX_ID,
780 __MOS_USER_FEATURE_KEY_MAX_ID));
781 return MOS_STATUS_SUCCESS;
782 }
783
MosDestroyUserFeatureKeysFromDescFields(MOS_USER_FEATURE_VALUE * descTable,uint32_t numOfItems,uint32_t maxId)784 MOS_STATUS MosUtilities::MosDestroyUserFeatureKeysFromDescFields(
785 MOS_USER_FEATURE_VALUE *descTable,
786 uint32_t numOfItems,
787 uint32_t maxId)
788 {
789 MOS_USER_FEATURE_VALUE UserFeatureKeyFilter = __NULL_USER_FEATURE_VALUE__;
790 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
791
792 eStatus = MosGetItemFromMosUserFeatureDescField(
793 descTable,
794 numOfItems,
795 maxId,
796 &MosDestroyUserFeatureKey,
797 &UserFeatureKeyFilter);
798 return eStatus;
799 }
800
MosDestroyUserFeatureKeysForAllDescFields()801 MOS_STATUS MosUtilities::MosDestroyUserFeatureKeysForAllDescFields()
802 {
803 MOS_USER_FEATURE_VALUE UserFeatureKeyFilter = __NULL_USER_FEATURE_VALUE__;
804
805 MOS_OS_CHK_STATUS_RETURN(MosDestroyUserFeatureKeysFromDescFields(
806 m_mosUserFeatureDescFields,
807 __MOS_USER_FEATURE_KEY_MAX_ID,
808 __MOS_USER_FEATURE_KEY_MAX_ID));
809
810 return MOS_STATUS_SUCCESS;
811 }
812
MosUserFeatureReadValueInit(uint32_t uiNumValues)813 MOS_STATUS MosUtilities::MosUserFeatureReadValueInit(uint32_t uiNumValues)
814 {
815 // Check if memory is allocated
816 if (uiNumValues == 0)
817 {
818 MOS_OS_ASSERTMESSAGE("pUserFeature->uiNumValues is 0.");
819 return MOS_STATUS_UNKNOWN;
820 }
821
822 return MOS_STATUS_SUCCESS;
823 }
824
MosUserFeatureCallback(PTP_CALLBACK_INSTANCE Instance,void * pvParameter,PTP_WAIT Wait,TP_WAIT_RESULT WaitResult)825 void MosUtilities::MosUserFeatureCallback(
826 PTP_CALLBACK_INSTANCE Instance,
827 void *pvParameter,
828 PTP_WAIT Wait,
829 TP_WAIT_RESULT WaitResult)
830 {
831 PMOS_USER_FEATURE_NOTIFY_DATA pNotifyData;
832 MOS_UNUSED(Instance);
833 MOS_UNUSED(Wait);
834 MOS_UNUSED(WaitResult);
835
836 MOS_OS_ASSERT(pvParameter);
837
838 pNotifyData = (PMOS_USER_FEATURE_NOTIFY_DATA)pvParameter;
839 pNotifyData->bTriggered = true;
840 }
MosUserFeatureReadValueBinary(void * UFKey,PMOS_USER_FEATURE_VALUE pFeatureValue)841 MOS_STATUS MosUtilities::MosUserFeatureReadValueBinary(
842 void *UFKey,
843 PMOS_USER_FEATURE_VALUE pFeatureValue)
844 {
845 MOS_STATUS eStatus;
846 void *pvData;
847 uint32_t dwUFSize;
848
849 MOS_OS_ASSERT(UFKey);
850 MOS_OS_ASSERT(pFeatureValue);
851 MOS_OS_ASSERT(pFeatureValue->pValueName);
852 MOS_OS_ASSERT(pFeatureValue->ValueType == MOS_USER_FEATURE_VALUE_TYPE_BINARY);
853
854 pvData = pFeatureValue->Value.BinaryData.pBinaryData;
855 if (!pvData)
856 {
857 MOS_OS_ASSERTMESSAGE("pFeatureValue->BinaryData.pBinaryData is NULL.");
858 return MOS_STATUS_NULL_POINTER;
859 }
860
861 dwUFSize = pFeatureValue->Value.BinaryData.uMaxSize;
862 if (dwUFSize == 0)
863 {
864 MOS_OS_ASSERTMESSAGE("pFeatureValue->BinaryData.uMaxSize is 0.");
865 return MOS_STATUS_UNKNOWN;
866 }
867
868 eStatus = MosUserFeatureGetValue(
869 UFKey,
870 nullptr,
871 pFeatureValue->pValueName,
872 RRF_RT_UF_BINARY,
873 nullptr,
874 pvData,
875 &dwUFSize);
876
877 if (eStatus != MOS_STATUS_SUCCESS)
878 {
879 if (dwUFSize > pFeatureValue->Value.BinaryData.uMaxSize) // Buffer size is not enough
880 {
881 MOS_OS_NORMALMESSAGE("Size %d exceeds max %d.", dwUFSize, pFeatureValue->Value.BinaryData.uMaxSize);
882 return MOS_STATUS_UNKNOWN;
883 }
884 else // This error case can be hit if the user feature key does not exist.
885 {
886 MOS_OS_NORMALMESSAGE("Failed to read binary user feature value '%s'.", pFeatureValue->pValueName);
887 return MOS_STATUS_USER_FEATURE_KEY_READ_FAILED;
888 }
889 }
890
891 pFeatureValue->Value.BinaryData.uSize = dwUFSize;
892
893 return MOS_STATUS_SUCCESS;
894 }
895
MosUserFeatureReadValueString(void * UFKey,PMOS_USER_FEATURE_VALUE pFeatureValue)896 MOS_STATUS MosUtilities::MosUserFeatureReadValueString(
897 void *UFKey,
898 PMOS_USER_FEATURE_VALUE pFeatureValue)
899 {
900 MOS_STATUS eStatus;
901 uint32_t dwUFSize;
902 char pcTmpStr[MOS_USER_CONTROL_MAX_DATA_SIZE];
903
904 //--------------------------------------------------
905 MOS_OS_ASSERT(UFKey);
906 MOS_OS_ASSERT(pFeatureValue);
907 MOS_OS_ASSERT(pFeatureValue->pValueName);
908 MOS_OS_ASSERT(pFeatureValue->ValueType == MOS_USER_FEATURE_VALUE_TYPE_STRING);
909 //--------------------------------------------------
910
911 MosZeroMemory(pcTmpStr, MOS_USER_CONTROL_MAX_DATA_SIZE);
912 dwUFSize = pFeatureValue->Value.StringData.uMaxSize;
913 if (dwUFSize == 0)
914 {
915 MOS_OS_ASSERTMESSAGE("pFeatureValue->StringData.uMaxSize is 0.");
916 return MOS_STATUS_UNKNOWN;
917 }
918
919 eStatus = MosUserFeatureGetValue(
920 UFKey,
921 nullptr,
922 pFeatureValue->pValueName,
923 RRF_RT_UF_SZ,
924 nullptr,
925 pcTmpStr,
926 &dwUFSize);
927
928 if (eStatus != MOS_STATUS_SUCCESS)
929 {
930 if (dwUFSize > pFeatureValue->Value.StringData.uMaxSize) // Buffer size is not enough
931 {
932 MOS_OS_NORMALMESSAGE("Size %d exceeds max %d.", dwUFSize, pFeatureValue->Value.StringData.uMaxSize);
933 return MOS_STATUS_UNKNOWN;
934 }
935 else // This error case can be hit if the user feature key does not exist.
936 {
937 MOS_OS_NORMALMESSAGE("Failed to read single string user feature value '%s'.", pFeatureValue->pValueName);
938 return MOS_STATUS_USER_FEATURE_KEY_READ_FAILED;
939 }
940 }
941 if (strlen(pcTmpStr) > 0)
942 {
943 if (!pFeatureValue->Value.StringData.pStringData)
944 {
945 MosAtomicIncrement(m_mosMemAllocFakeCounter);
946 }
947
948 if (pFeatureValue->Value.StringData.uSize < strlen(pcTmpStr) + 1)
949 {
950 pFeatureValue->Value.StringData.pStringData =
951 (char *)MOS_ReallocMemory(pFeatureValue->Value.StringData.pStringData, strlen(pcTmpStr) + 1);
952 pFeatureValue->Value.StringData.uSize = strlen(pcTmpStr) + 1;
953 }
954
955 MOS_OS_CHK_NULL_RETURN(pFeatureValue->Value.StringData.pStringData);
956
957 MosZeroMemory(pFeatureValue->Value.StringData.pStringData, pFeatureValue->Value.StringData.uSize);
958
959 MosSecureMemcpy(pFeatureValue->Value.StringData.pStringData, pFeatureValue->Value.StringData.uSize, pcTmpStr, strlen(pcTmpStr));
960 }
961 return eStatus;
962 }
963
MosUserFeatureReadValueMultiString(void * UFKey,PMOS_USER_FEATURE_VALUE pFeatureValue)964 MOS_STATUS MosUtilities::MosUserFeatureReadValueMultiString(
965 void *UFKey,
966 PMOS_USER_FEATURE_VALUE pFeatureValue)
967 {
968 MOS_STATUS eStatus;
969 uint32_t dwUFSize;
970 char pcTmpStr[MOS_USER_CONTROL_MAX_DATA_SIZE];
971
972 MOS_OS_ASSERT(UFKey);
973 MOS_OS_ASSERT(pFeatureValue);
974 MOS_OS_ASSERT(pFeatureValue->pValueName);
975 MOS_OS_ASSERT(pFeatureValue->ValueType == MOS_USER_FEATURE_VALUE_TYPE_MULTI_STRING);
976
977 if (!pFeatureValue->Value.MultiStringData.pStrings)
978 {
979 MOS_OS_ASSERTMESSAGE("pFeatureValue->MultiStringData.pStrings is NULL.");
980 return MOS_STATUS_NULL_POINTER;
981 }
982 MosZeroMemory(pcTmpStr, MOS_USER_CONTROL_MAX_DATA_SIZE);
983 dwUFSize = pFeatureValue->Value.MultiStringData.uMaxSize;
984 if (dwUFSize == 0)
985 {
986 MOS_OS_ASSERTMESSAGE("pFeatureValue->MultiStringData.uMaxSize is 0.");
987 return MOS_STATUS_UNKNOWN;
988 }
989
990 eStatus = MosUserFeatureGetValue(
991 UFKey,
992 nullptr,
993 pFeatureValue->pValueName,
994 RRF_RT_UF_MULTI_SZ,
995 nullptr,
996 pcTmpStr,
997 &dwUFSize);
998
999 if (eStatus != MOS_STATUS_SUCCESS)
1000 {
1001 if (dwUFSize > pFeatureValue->Value.MultiStringData.uMaxSize) // Buffer size is not enough
1002 {
1003 MOS_OS_NORMALMESSAGE("Size %d exceeds max %d.", dwUFSize, pFeatureValue->Value.MultiStringData.uMaxSize);
1004 return MOS_STATUS_UNKNOWN;
1005 }
1006 else // This error case can be hit if the user feature key does not exist.
1007 {
1008 MOS_OS_NORMALMESSAGE("Failed to read single string user feature value '%s'.", pFeatureValue->pValueName);
1009 return MOS_STATUS_USER_FEATURE_KEY_READ_FAILED;
1010 }
1011 }
1012
1013 if (strlen(pcTmpStr) > 0)
1014 {
1015 if (!pFeatureValue->Value.MultiStringData.pMultStringData)
1016 {
1017 MosAtomicIncrement(m_mosMemAllocFakeCounter);
1018 }
1019 MOS_SafeFreeMemory(pFeatureValue->Value.MultiStringData.pMultStringData);
1020 pFeatureValue->Value.MultiStringData.pMultStringData = (char *)MOS_AllocAndZeroMemory(strlen(pcTmpStr) + 1);
1021 if (pFeatureValue->Value.MultiStringData.pMultStringData == nullptr)
1022 {
1023 MOS_OS_ASSERTMESSAGE("Failed to allocate memory.");
1024 return MOS_STATUS_NULL_POINTER;
1025 }
1026 MosSecureMemcpy(
1027 pFeatureValue->Value.MultiStringData.pMultStringData,
1028 strlen(pcTmpStr),
1029 pcTmpStr,
1030 strlen(pcTmpStr));
1031
1032 if((eStatus = MosUserFeatureSetMultiStringValue(
1033 &pFeatureValue->Value,
1034 dwUFSize)) != MOS_STATUS_SUCCESS)
1035 {
1036 MOS_OS_ASSERTMESSAGE("Failed to set multi string value.");
1037 return eStatus;
1038 }
1039 }
1040
1041 return MOS_STATUS_SUCCESS;
1042 }
1043
MosUserFeatureReadValuePrimitive(void * UFKey,PMOS_USER_FEATURE_VALUE pFeatureValue)1044 MOS_STATUS MosUtilities::MosUserFeatureReadValuePrimitive(
1045 void *UFKey,
1046 PMOS_USER_FEATURE_VALUE pFeatureValue)
1047 {
1048 MOS_STATUS eStatus;
1049 uint32_t dwUFType = 0;
1050 uint32_t dwUFSize;
1051 void *pvData = nullptr;
1052
1053 MOS_OS_ASSERT(UFKey);
1054 MOS_OS_ASSERT(pFeatureValue);
1055 MOS_OS_ASSERT(pFeatureValue->pValueName);
1056 MOS_OS_ASSERT(pFeatureValue->ValueType != MOS_USER_FEATURE_VALUE_TYPE_INVALID);
1057
1058 switch(pFeatureValue->ValueType)
1059 {
1060 case MOS_USER_FEATURE_VALUE_TYPE_BOOL:
1061 case MOS_USER_FEATURE_VALUE_TYPE_INT32:
1062 case MOS_USER_FEATURE_VALUE_TYPE_UINT32:
1063 case MOS_USER_FEATURE_VALUE_TYPE_FLOAT:
1064 dwUFType = RRF_RT_UF_DWORD;
1065 dwUFSize = sizeof(uint32_t);
1066 pvData = &pFeatureValue->Value.fData;
1067 break;
1068
1069 case MOS_USER_FEATURE_VALUE_TYPE_INT64:
1070 case MOS_USER_FEATURE_VALUE_TYPE_UINT64:
1071 dwUFType = RRF_RT_UF_QWORD;
1072 dwUFSize = sizeof(uint64_t);
1073 pvData = &pFeatureValue->Value.u64Data;
1074 break;
1075
1076 default:
1077 MOS_OS_ASSERTMESSAGE("Invalid primitive value type.");
1078 return MOS_STATUS_UNKNOWN;
1079 }
1080
1081 eStatus = MosUserFeatureGetValue(
1082 UFKey,
1083 nullptr,
1084 pFeatureValue->pValueName,
1085 dwUFType,
1086 nullptr,
1087 pvData,
1088 &dwUFSize);
1089
1090 if (eStatus != MOS_STATUS_SUCCESS)
1091 {
1092 // This error case can be hit if the user feature key does not exist.
1093 MOS_OS_NORMALMESSAGE("Failed to read primitive user feature value \"%s\".", pFeatureValue->pValueName);
1094 return MOS_STATUS_USER_FEATURE_KEY_READ_FAILED;
1095 }
1096
1097 return eStatus;
1098 }
1099
MosUserFeatureWriteValueString(void * UFKey,PMOS_USER_FEATURE_VALUE pFeatureValue,PMOS_USER_FEATURE_VALUE_DATA pDataValue)1100 MOS_STATUS MosUtilities::MosUserFeatureWriteValueString(
1101 void *UFKey,
1102 PMOS_USER_FEATURE_VALUE pFeatureValue,
1103 PMOS_USER_FEATURE_VALUE_DATA pDataValue)
1104 {
1105 MOS_STATUS eStatus;
1106
1107 MOS_OS_ASSERT(UFKey);
1108 MOS_OS_ASSERT(pFeatureValue);
1109 MOS_OS_ASSERT(pFeatureValue->pValueName);
1110 MOS_OS_ASSERT(pFeatureValue->ValueType == MOS_USER_FEATURE_VALUE_TYPE_STRING);
1111 MOS_OS_ASSERT(pDataValue);
1112
1113 if((eStatus = MosUserFeatureSetValueEx(
1114 UFKey,
1115 pFeatureValue->pValueName,
1116 0,
1117 UF_SZ,
1118 (uint8_t*)pDataValue->StringData.pStringData,
1119 pDataValue->StringData.uSize)) != MOS_STATUS_SUCCESS)
1120 {
1121 MOS_OS_ASSERTMESSAGE("Failed to write string user feature value.");
1122 }
1123
1124 return eStatus;
1125 }
1126
MosUserFeatureWriteValueMultiString(void * UFKey,PMOS_USER_FEATURE_VALUE pFeatureValue,PMOS_USER_FEATURE_VALUE_DATA pDataValue)1127 MOS_STATUS MosUtilities::MosUserFeatureWriteValueMultiString(
1128 void *UFKey,
1129 PMOS_USER_FEATURE_VALUE pFeatureValue,
1130 PMOS_USER_FEATURE_VALUE_DATA pDataValue)
1131 {
1132 PMOS_USER_FEATURE_VALUE_STRING pStringData;
1133 uint8_t *pData;
1134 uint8_t *pCurData;
1135 uint32_t dwDataSize;
1136 uint32_t dwAvailableSize;
1137 uint32_t ui;
1138 MOS_STATUS eStatus;
1139
1140 MOS_OS_ASSERT(UFKey);
1141 MOS_OS_ASSERT(pFeatureValue);
1142 MOS_OS_ASSERT(pFeatureValue->pValueName);
1143 MOS_OS_ASSERT(pFeatureValue->ValueType == MOS_USER_FEATURE_VALUE_TYPE_MULTI_STRING);
1144 MOS_OS_ASSERT(pDataValue);
1145 MOS_OS_ASSERT(pDataValue->MultiStringData.uCount > 0);
1146
1147 pData = nullptr;
1148 dwDataSize = 0;
1149
1150 for (ui = 0; ui < pDataValue->MultiStringData.uCount; ui++)
1151 {
1152 pStringData = &pDataValue->MultiStringData.pStrings[ui];
1153 dwDataSize += pStringData->uSize;
1154 dwDataSize += 1; // for \0
1155 }
1156 dwDataSize += 1; // for \0 at the very end (see MULTI_SZ spec)
1157
1158 // Allocate memory to store data
1159 pData = (uint8_t*)MOS_AllocAndZeroMemory(dwDataSize);
1160 if(pData == nullptr)
1161 {
1162 MOS_OS_ASSERTMESSAGE("Failed to allocate memory.");
1163 return MOS_STATUS_NO_SPACE;
1164 }
1165
1166 // Copy data from original string array
1167 pCurData = pData;
1168 dwAvailableSize = dwDataSize;
1169 for (ui = 0; ui < pDataValue->MultiStringData.uCount; ui++)
1170 {
1171 pStringData = &pDataValue->MultiStringData.pStrings[ui];
1172 eStatus = MosSecureMemcpy(pCurData, dwAvailableSize, pStringData->pStringData, pStringData->uSize);
1173 if(eStatus != MOS_STATUS_SUCCESS)
1174 {
1175 MOS_OS_ASSERTMESSAGE("Failed to copy memory.");
1176 goto finish;
1177 }
1178 pCurData += pStringData->uSize;
1179 pCurData++; // \0 is already added since we zeroed the memory
1180 // Very last \0 is already added since we zeroed the memory
1181 dwAvailableSize -= pStringData->uSize + 1;
1182 }
1183 // Write the user feature MULTI_SZ entry
1184 if((eStatus = MosUserFeatureSetValueEx(
1185 UFKey,
1186 pFeatureValue->pValueName,
1187 0,
1188 UF_MULTI_SZ,
1189 pData,
1190 dwDataSize)) != MOS_STATUS_SUCCESS)
1191 {
1192 MOS_OS_ASSERTMESSAGE("Failed to write multi string user feature value.");
1193 }
1194
1195 finish:
1196 MOS_FreeMemory(pData);
1197 return eStatus;
1198 }
1199
MosUserFeatureWriteValueBinary(void * UFKey,PMOS_USER_FEATURE_VALUE pFeatureValue,PMOS_USER_FEATURE_VALUE_DATA pDataValue)1200 MOS_STATUS MosUtilities::MosUserFeatureWriteValueBinary(
1201 void *UFKey,
1202 PMOS_USER_FEATURE_VALUE pFeatureValue,
1203 PMOS_USER_FEATURE_VALUE_DATA pDataValue)
1204 {
1205 MOS_STATUS eStatus;
1206
1207 MOS_OS_ASSERT(UFKey);
1208 MOS_OS_ASSERT(pFeatureValue);
1209 MOS_OS_ASSERT(pFeatureValue->pValueName);
1210 MOS_OS_ASSERT(pFeatureValue->ValueType == MOS_USER_FEATURE_VALUE_TYPE_BINARY);
1211 MOS_OS_ASSERT(pDataValue);
1212
1213 if((eStatus = MosUserFeatureSetValueEx(
1214 UFKey,
1215 pFeatureValue->pValueName,
1216 0,
1217 UF_BINARY,
1218 (uint8_t*)pDataValue->BinaryData.pBinaryData,
1219 pDataValue->BinaryData.uSize)) != MOS_STATUS_SUCCESS)
1220 {
1221 MOS_OS_ASSERTMESSAGE("Failed to write binary user feature value.");
1222 }
1223
1224 return eStatus;
1225 }
1226
MosUserFeatureWriteValuePrimitive(void * UFKey,PMOS_USER_FEATURE_VALUE pFeatureValue,PMOS_USER_FEATURE_VALUE_DATA pDataValue)1227 MOS_STATUS MosUtilities::MosUserFeatureWriteValuePrimitive(
1228 void *UFKey,
1229 PMOS_USER_FEATURE_VALUE pFeatureValue,
1230 PMOS_USER_FEATURE_VALUE_DATA pDataValue)
1231 {
1232 MOS_STATUS eStatus;
1233 uint32_t dwUFType = UF_NONE;
1234 uint32_t dwUFSize = 0;
1235 void *pvData = nullptr;
1236
1237 MOS_OS_ASSERT(UFKey);
1238 MOS_OS_ASSERT(pFeatureValue);
1239 MOS_OS_ASSERT(pFeatureValue->pValueName);
1240 MOS_OS_ASSERT(pFeatureValue->ValueType != MOS_USER_FEATURE_VALUE_TYPE_INVALID);
1241 MOS_OS_ASSERT(pDataValue);
1242
1243 switch(pFeatureValue->ValueType)
1244 {
1245 case MOS_USER_FEATURE_VALUE_TYPE_BOOL:
1246 case MOS_USER_FEATURE_VALUE_TYPE_INT32:
1247 case MOS_USER_FEATURE_VALUE_TYPE_UINT32:
1248 case MOS_USER_FEATURE_VALUE_TYPE_FLOAT:
1249 dwUFType = UF_DWORD;
1250 dwUFSize = sizeof(uint32_t);
1251 pvData = &pDataValue->fData;
1252 break;
1253
1254 case MOS_USER_FEATURE_VALUE_TYPE_INT64:
1255 case MOS_USER_FEATURE_VALUE_TYPE_UINT64:
1256 dwUFType = UF_QWORD;
1257 dwUFSize = sizeof(uint64_t);
1258 pvData = &pDataValue->u64Data;
1259 break;
1260
1261 default:
1262 MOS_OS_ASSERTMESSAGE("Invalid primitive value type.");
1263 return MOS_STATUS_UNKNOWN;
1264 }
1265
1266 if((eStatus = MosUserFeatureSetValueEx(
1267 UFKey,
1268 pFeatureValue->pValueName,
1269 0,
1270 dwUFType,
1271 (uint8_t*)pvData,
1272 dwUFSize)) != MOS_STATUS_SUCCESS)
1273 {
1274 MOS_OS_ASSERTMESSAGE("Failed to write primitive user feature value.");
1275 }
1276
1277 return eStatus;
1278 }
1279
MosUserFeatureReadValueFromMapID(uint32_t ValueID,PMOS_USER_FEATURE_VALUE_DATA pValueData,MOS_USER_FEATURE_KEY_PATH_INFO * ufInfo)1280 MOS_STATUS MosUtilities::MosUserFeatureReadValueFromMapID(
1281 uint32_t ValueID,
1282 PMOS_USER_FEATURE_VALUE_DATA pValueData,
1283 MOS_USER_FEATURE_KEY_PATH_INFO *ufInfo)
1284 {
1285 void *ufKey = nullptr;
1286 PMOS_USER_FEATURE_VALUE pUserFeature = nullptr;
1287 int32_t iDataFlag = MOS_USER_FEATURE_VALUE_DATA_FLAG_NONE_CUSTOM_DEFAULT_VALUE_TYPE;
1288 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1289
1290 //--------------------------------------------------
1291 MOS_OS_ASSERT(pValueData);
1292 MOS_OS_ASSERT(ValueID != __MOS_USER_FEATURE_KEY_INVALID_ID);
1293 //--------------------------------------------------
1294 iDataFlag = pValueData->i32DataFlag;
1295
1296 pUserFeature = MosUtilUserInterface::GetValue(ValueID);
1297 if (nullptr == pUserFeature)
1298 {
1299 MOS_OS_NORMALMESSAGE("Cannot found the user feature key.");
1300 return MOS_STATUS_NULL_POINTER;
1301 }
1302
1303 // Open the user feature
1304 // Assigned the pUserFeature to ufKey for future reading
1305 ufKey = pUserFeature;
1306 if((eStatus = MosUserFeatureOpen(
1307 pUserFeature->Type,
1308 pUserFeature->pcPath,
1309 KEY_READ,
1310 &ufKey,
1311 ufInfo)) != MOS_STATUS_SUCCESS)
1312 {
1313 MOS_OS_NORMALMESSAGE("Failed to open user feature for concurrency.");
1314 if ((eStatus = MosUserFeatureOpen(
1315 pUserFeature->Type,
1316 pUserFeature->pcPath,
1317 KEY_READ,
1318 &ufKey,
1319 ufInfo)) != MOS_STATUS_SUCCESS)
1320 {
1321 MOS_OS_NORMALMESSAGE("Failed to open user feature for reading eStatus:%d.", eStatus);
1322 eStatus = MOS_STATUS_USER_FEATURE_KEY_OPEN_FAILED;
1323 goto finish;
1324 }
1325 }
1326
1327 // Initialize Read Value
1328 if((eStatus = MosUserFeatureReadValueInit(pUserFeature->uiNumOfValues)) != MOS_STATUS_SUCCESS)
1329 {
1330 MOS_OS_ASSERTMESSAGE("Failed to initialize user feature read value eStatus:%d.",eStatus);
1331 eStatus = MOS_STATUS_UNKNOWN;
1332 goto finish;
1333 }
1334
1335 #if !(_DEBUG || _RELEASE_INTERNAL)
1336 // For release build, don't read debug only keys, but return default directly
1337 if (pUserFeature->EffctiveRange == MOS_USER_FEATURE_EFFECT_DEBUGONLY)
1338 {
1339 eStatus = MOS_STATUS_USER_FEATURE_KEY_READ_FAILED;
1340 goto finish;
1341 }
1342 #endif
1343
1344 // Read the Values from user feature
1345 switch(pUserFeature->ValueType)
1346 {
1347 case MOS_USER_FEATURE_VALUE_TYPE_BINARY:
1348 eStatus = MosUserFeatureReadValueBinary(ufKey, pUserFeature);
1349 break;
1350 case MOS_USER_FEATURE_VALUE_TYPE_STRING:
1351 eStatus = MosUserFeatureReadValueString(ufKey, pUserFeature);
1352 break;
1353 case MOS_USER_FEATURE_VALUE_TYPE_MULTI_STRING:
1354 eStatus = MosUserFeatureReadValueMultiString(ufKey, pUserFeature);
1355 break;
1356 default:
1357 eStatus = MosUserFeatureReadValuePrimitive(ufKey, pUserFeature);
1358 break;
1359 }
1360
1361 if(eStatus != MOS_STATUS_SUCCESS)
1362 {
1363 MOS_OS_NORMALMESSAGE("Failed to read value from user feature eStatus:%d.", eStatus);
1364 eStatus = MOS_STATUS_USER_FEATURE_KEY_READ_FAILED;
1365 }
1366 finish:
1367 if ((pUserFeature != nullptr) &&
1368 ((eStatus == MOS_STATUS_SUCCESS) ||
1369 (iDataFlag != MOS_USER_FEATURE_VALUE_DATA_FLAG_CUSTOM_DEFAULT_VALUE_TYPE)))
1370 {
1371 // Use the User Feature Value or default value in corresponding user feature key Desc Fields
1372 // when User Feature Key read successfully or no input custom default value
1373 MosCopyUserFeatureValueData(
1374 &pUserFeature->Value,
1375 pValueData,
1376 pUserFeature->ValueType);
1377 }
1378 MosUserFeatureCloseKey(ufKey); // Closes the key if not nullptr
1379 return eStatus;
1380 }
1381
MosUserFeatureReadValueID(PMOS_USER_FEATURE_INTERFACE pOsUserFeatureInterface,uint32_t ValueID,PMOS_USER_FEATURE_VALUE_DATA pValueData,MOS_CONTEXT_HANDLE mosCtx)1382 MOS_STATUS MosUtilities::MosUserFeatureReadValueID(
1383 PMOS_USER_FEATURE_INTERFACE pOsUserFeatureInterface,
1384 uint32_t ValueID,
1385 PMOS_USER_FEATURE_VALUE_DATA pValueData,
1386 MOS_CONTEXT_HANDLE mosCtx)
1387 {
1388 MOS_USER_FEATURE_KEY_PATH_INFO *ufInfo = Mos_GetDeviceUfPathInfo((PMOS_CONTEXT)mosCtx);
1389 return MosUserFeatureReadValueFromMapID(
1390 ValueID,
1391 pValueData,
1392 ufInfo);
1393 }
MosUserFeatureReadValueID(PMOS_USER_FEATURE_INTERFACE pOsUserFeatureInterface,uint32_t ValueID,PMOS_USER_FEATURE_VALUE_DATA pValueData,MOS_USER_FEATURE_KEY_PATH_INFO * ufInfo)1394 MOS_STATUS MosUtilities::MosUserFeatureReadValueID(
1395 PMOS_USER_FEATURE_INTERFACE pOsUserFeatureInterface,
1396 uint32_t ValueID,
1397 PMOS_USER_FEATURE_VALUE_DATA pValueData,
1398 MOS_USER_FEATURE_KEY_PATH_INFO *ufInfo)
1399 {
1400 return MosUserFeatureReadValueFromMapID(
1401 ValueID,
1402 pValueData,
1403 ufInfo);
1404 }
1405
MosUserFeatureLookupValueName(uint32_t ValueID)1406 const char* MosUtilities::MosUserFeatureLookupValueName(uint32_t ValueID)
1407 {
1408 MOS_OS_ASSERT(ValueID != __MOS_USER_FEATURE_KEY_INVALID_ID);
1409
1410 PMOS_USER_FEATURE_VALUE pUserFeature = MosUtilUserInterface::GetValue(ValueID);
1411 if (pUserFeature)
1412 {
1413 return pUserFeature->pValueName;
1414 }
1415 else
1416 {
1417 return nullptr;
1418 }
1419 }
1420
MosUserFeatureLookupReadPath(uint32_t ValueID)1421 const char *MosUtilities::MosUserFeatureLookupReadPath(uint32_t ValueID)
1422 {
1423 MOS_OS_ASSERT(ValueID != __MOS_USER_FEATURE_KEY_INVALID_ID);
1424
1425 PMOS_USER_FEATURE_VALUE pUserFeature = MosUtilUserInterface::GetValue(ValueID);
1426 if (pUserFeature)
1427 {
1428 return pUserFeature->pcPath;
1429 }
1430 else
1431 {
1432 return nullptr;
1433 }
1434 }
1435
MosUserFeatureLookupWritePath(uint32_t ValueID)1436 const char *MosUtilities::MosUserFeatureLookupWritePath(uint32_t ValueID)
1437 {
1438 MOS_OS_ASSERT(ValueID != __MOS_USER_FEATURE_KEY_INVALID_ID);
1439
1440 PMOS_USER_FEATURE_VALUE pUserFeature = MosUtilUserInterface::GetValue(ValueID);
1441 if (pUserFeature)
1442 {
1443 return pUserFeature->pcWritePath;
1444 }
1445 else
1446 {
1447 return nullptr;
1448 }
1449 }
1450
MosUserFeatureWriteValuesTblID(PMOS_USER_FEATURE_VALUE_WRITE_DATA pWriteValues,uint32_t uiNumOfValues,MOS_USER_FEATURE_KEY_PATH_INFO * ufInfo)1451 MOS_STATUS MosUtilities::MosUserFeatureWriteValuesTblID(
1452 PMOS_USER_FEATURE_VALUE_WRITE_DATA pWriteValues,
1453 uint32_t uiNumOfValues,
1454 MOS_USER_FEATURE_KEY_PATH_INFO *ufInfo)
1455 {
1456 uint32_t ui;
1457 PMOS_USER_FEATURE_VALUE pFeatureValue = nullptr;
1458 void *UFKey = nullptr;
1459 PMOS_USER_FEATURE_VALUE_WRITE_DATA pUserWriteData = nullptr;
1460 PMOS_USER_FEATURE_VALUE pUserFeature = nullptr;
1461 uint32_t ValueID = __MOS_USER_FEATURE_KEY_INVALID_ID;
1462 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1463 char WritePathWithPID[MAX_PATH];
1464 int32_t pid;
1465 uint64_t ulTraceData = 0;
1466 bool isValid = false;
1467
1468 //--------------------------------------------------
1469 MOS_OS_CHK_NULL_RETURN(pWriteValues);
1470 //--------------------------------------------------
1471
1472 MosZeroMemory(WritePathWithPID, MAX_PATH);
1473
1474 pid = MosGetPid();
1475
1476 for (ui = 0; ui < uiNumOfValues; ui++)
1477 {
1478 ValueID = pWriteValues[ui].ValueID;
1479
1480 pUserFeature = MosUtilUserInterface::GetValue(ValueID);
1481
1482 MOS_OS_CHK_NULL_RETURN(pUserFeature);
1483 // Open the user feature
1484 // Assigned the pUserFeature to UFKey for future reading
1485 UFKey = pUserFeature;
1486
1487 //append write path with pid
1488 sprintf_s(WritePathWithPID, MAX_PATH, "%s\\%d", pUserFeature->pcWritePath, pid);
1489
1490 // Trace data in case opening user feature for write fails
1491 switch (pUserFeature->ValueType)
1492 {
1493 case MOS_USER_FEATURE_VALUE_TYPE_BOOL:
1494 case MOS_USER_FEATURE_VALUE_TYPE_INT32:
1495 case MOS_USER_FEATURE_VALUE_TYPE_UINT32:
1496 case MOS_USER_FEATURE_VALUE_TYPE_FLOAT:
1497 ulTraceData = pWriteValues[ui].Value.u32Data;
1498 isValid = true;
1499 break;
1500 case MOS_USER_FEATURE_VALUE_TYPE_INT64:
1501 case MOS_USER_FEATURE_VALUE_TYPE_UINT64:
1502 ulTraceData = pWriteValues[ui].Value.u64Data;
1503 isValid = true;
1504 break;
1505 default:
1506 MOS_OS_NORMALMESSAGE("Unknown value type %d", pUserFeature->ValueType);
1507 }
1508
1509 if (isValid)
1510 {
1511 MosTraceDataDictionary(pUserFeature->pValueName, &ulTraceData, sizeof(ulTraceData));
1512 }
1513
1514 //try to open Write path with pid first
1515 if ((eStatus = MosUserFeatureOpen(
1516 pUserFeature->Type,
1517 WritePathWithPID,
1518 KEY_WRITE,
1519 &UFKey,
1520 ufInfo)) != MOS_STATUS_SUCCESS)
1521 {
1522 MOS_OS_NORMALMESSAGE("Failed to open user feature for concurrency.");
1523 if ((eStatus = MosUserFeatureOpen(
1524 pUserFeature->Type,
1525 pUserFeature->pcWritePath,
1526 KEY_WRITE,
1527 &UFKey,
1528 ufInfo)) != MOS_STATUS_SUCCESS)
1529 {
1530 MOS_OS_NORMALMESSAGE("Failed to open user feature for writing.");
1531 eStatus = MOS_STATUS_USER_FEATURE_KEY_OPEN_FAILED;
1532 goto finish;
1533 }
1534 }
1535
1536 //------------------------------------
1537 MOS_OS_ASSERT(pUserFeature->ValueType != MOS_USER_FEATURE_VALUE_TYPE_INVALID);
1538 //------------------------------------
1539 switch(pUserFeature->ValueType)
1540 {
1541 case MOS_USER_FEATURE_VALUE_TYPE_BINARY:
1542 if ((eStatus = MosUserFeatureWriteValueBinary(UFKey, pUserFeature, &(pWriteValues[ui].Value))) != MOS_STATUS_SUCCESS)
1543 {
1544 MOS_OS_ASSERTMESSAGE("Failed to write binary value to user feature.");
1545 eStatus = MOS_STATUS_USER_FEATURE_KEY_WRITE_FAILED;
1546 goto finish;
1547 }
1548 break;
1549 case MOS_USER_FEATURE_VALUE_TYPE_STRING:
1550 if ((eStatus = MosUserFeatureWriteValueString(UFKey, pUserFeature, &(pWriteValues[ui].Value))) != MOS_STATUS_SUCCESS)
1551 {
1552 MOS_OS_ASSERTMESSAGE("Failed to write string value to user feature.");
1553 eStatus = MOS_STATUS_USER_FEATURE_KEY_WRITE_FAILED;
1554 goto finish;
1555 }
1556 break;
1557 case MOS_USER_FEATURE_VALUE_TYPE_MULTI_STRING:
1558 if ((eStatus = MosUserFeatureWriteValueMultiString(UFKey, pUserFeature, &(pWriteValues[ui].Value))) != MOS_STATUS_SUCCESS)
1559 {
1560 MOS_OS_ASSERTMESSAGE("Failed to write multi string value to user feature.");
1561 eStatus = MOS_STATUS_USER_FEATURE_KEY_WRITE_FAILED;
1562 goto finish;
1563 }
1564 break;
1565 default:
1566 if ((eStatus = MosUserFeatureWriteValuePrimitive(UFKey, pUserFeature, &(pWriteValues[ui].Value))) != MOS_STATUS_SUCCESS)
1567 {
1568 MOS_OS_ASSERTMESSAGE("Failed to write primitive data value to user feature.");
1569 eStatus = MOS_STATUS_USER_FEATURE_KEY_WRITE_FAILED;
1570 goto finish;
1571 }
1572 }
1573 MosUserFeatureCloseKey(UFKey); // Closes the key if not nullptr
1574 }
1575
1576 finish:
1577 if (eStatus != MOS_STATUS_SUCCESS)
1578 {
1579 MosUserFeatureCloseKey(UFKey); // Closes the key if not nullptr
1580 }
1581 return eStatus;
1582 }
1583
MosUserFeatureWriteValuesID(PMOS_USER_FEATURE_INTERFACE pOsUserFeatureInterface,PMOS_USER_FEATURE_VALUE_WRITE_DATA pWriteValues,uint32_t uiNumOfValues,MOS_CONTEXT_HANDLE mosCtx)1584 MOS_STATUS MosUtilities::MosUserFeatureWriteValuesID(
1585 PMOS_USER_FEATURE_INTERFACE pOsUserFeatureInterface,
1586 PMOS_USER_FEATURE_VALUE_WRITE_DATA pWriteValues,
1587 uint32_t uiNumOfValues,
1588 MOS_CONTEXT_HANDLE mosCtx)
1589 {
1590 MOS_USER_FEATURE_KEY_PATH_INFO *ufInfo = Mos_GetDeviceUfPathInfo((PMOS_CONTEXT)mosCtx);
1591
1592 return MosUserFeatureWriteValuesTblID(
1593 pWriteValues,
1594 uiNumOfValues,
1595 ufInfo);
1596 }
1597
MosUserFeatureWriteValuesID(PMOS_USER_FEATURE_INTERFACE pOsUserFeatureInterface,PMOS_USER_FEATURE_VALUE_WRITE_DATA pWriteValues,uint32_t uiNumOfValues,MOS_USER_FEATURE_KEY_PATH_INFO * ufInfo)1598 MOS_STATUS MosUtilities::MosUserFeatureWriteValuesID(
1599 PMOS_USER_FEATURE_INTERFACE pOsUserFeatureInterface,
1600 PMOS_USER_FEATURE_VALUE_WRITE_DATA pWriteValues,
1601 uint32_t uiNumOfValues,
1602 MOS_USER_FEATURE_KEY_PATH_INFO * ufInfo)
1603 {
1604 return MosUserFeatureWriteValuesTblID(
1605 pWriteValues,
1606 uiNumOfValues,
1607 ufInfo);
1608 }
1609
1610