1 /* 2 * Copyright (C) 2021 Intel Corporation 3 * 4 * SPDX-License-Identifier: MIT 5 * 6 */ 7 8 // This is a generated file - please don't modify directly 9 #pragma once 10 #include "wsl_compute_helper_types_tokens.h" 11 12 template <TOK StrT> 13 struct Demarshaller; 14 15 template <> 16 struct Demarshaller<TOK_S_GT_SUBSLICE_INFO> { 17 template <typename GT_SUBSLICE_INFOT> 18 static bool demarshall(GT_SUBSLICE_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 19 const TokenHeader *tok = srcTokensBeg; 20 while (tok < srcTokensEnd) { 21 if (false == tok->flags.flag4IsVariableLength) { 22 switch (tok->id) { 23 default: 24 if (tok->flags.flag3IsMandatory) { 25 return false; 26 } 27 break; 28 case TOK_FBB_GT_SUBSLICE_INFO__ENABLED: { 29 dst.Enabled = readTokValue<decltype(dst.Enabled)>(*tok); 30 } break; 31 case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_COUNT: { 32 dst.EuEnabledCount = readTokValue<decltype(dst.EuEnabledCount)>(*tok); 33 } break; 34 case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_MASK: { 35 dst.EuEnabledMask = readTokValue<decltype(dst.EuEnabledMask)>(*tok); 36 } break; 37 }; 38 tok = tok + 1 + tok->valueDwordCount; 39 } else { 40 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 41 switch (tok->id) { 42 default: 43 if (tok->flags.flag3IsMandatory) { 44 return false; 45 } 46 break; 47 case TOK_S_GT_SUBSLICE_INFO: 48 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 49 return false; 50 } 51 break; 52 }; 53 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 54 } 55 } 56 WCH_ASSERT(tok == srcTokensEnd); 57 return true; 58 } 59 }; 60 61 template <> 62 struct Demarshaller<TOK_S_GT_DUALSUBSLICE_INFO> { 63 template <typename GT_DUALSUBSLICE_INFOT> 64 static bool demarshall(GT_DUALSUBSLICE_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 65 const TokenHeader *tok = srcTokensBeg; 66 while (tok < srcTokensEnd) { 67 if (false == tok->flags.flag4IsVariableLength) { 68 switch (tok->id) { 69 default: 70 if (tok->flags.flag3IsMandatory) { 71 return false; 72 } 73 break; 74 case TOK_FBB_GT_DUALSUBSLICE_INFO__ENABLED: { 75 dst.Enabled = readTokValue<decltype(dst.Enabled)>(*tok); 76 } break; 77 }; 78 tok = tok + 1 + tok->valueDwordCount; 79 } else { 80 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 81 switch (tok->id) { 82 default: 83 if (tok->flags.flag3IsMandatory) { 84 return false; 85 } 86 break; 87 case TOK_S_GT_DUALSUBSLICE_INFO: 88 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 89 return false; 90 } 91 break; 92 case TOK_FS_GT_DUALSUBSLICE_INFO__SUB_SLICE: { 93 uint32_t arrayElementIdSubSlice = varLen->arrayElementId; 94 const TokenHeader *tokSubSlice = varLen->getValue<TokenHeader>(); 95 const TokenHeader *tokSubSliceEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 96 while (tokSubSlice < tokSubSliceEnd) { 97 if (false == tokSubSlice->flags.flag4IsVariableLength) { 98 switch (tokSubSlice->id) { 99 default: 100 if (tokSubSlice->flags.flag3IsMandatory) { 101 return false; 102 } 103 break; 104 case TOK_FBB_GT_SUBSLICE_INFO__ENABLED: { 105 dst.SubSlice[arrayElementIdSubSlice].Enabled = readTokValue<decltype(dst.SubSlice[arrayElementIdSubSlice].Enabled)>(*tokSubSlice); 106 } break; 107 case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_COUNT: { 108 dst.SubSlice[arrayElementIdSubSlice].EuEnabledCount = readTokValue<decltype(dst.SubSlice[arrayElementIdSubSlice].EuEnabledCount)>(*tokSubSlice); 109 } break; 110 case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_MASK: { 111 dst.SubSlice[arrayElementIdSubSlice].EuEnabledMask = readTokValue<decltype(dst.SubSlice[arrayElementIdSubSlice].EuEnabledMask)>(*tokSubSlice); 112 } break; 113 }; 114 tokSubSlice = tokSubSlice + 1 + tokSubSlice->valueDwordCount; 115 } else { 116 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSubSlice); 117 if (tokSubSlice->flags.flag3IsMandatory) { 118 return false; 119 } 120 tokSubSlice = tokSubSlice + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 121 } 122 } 123 WCH_ASSERT(tokSubSlice == tokSubSliceEnd); 124 } break; 125 }; 126 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 127 } 128 } 129 WCH_ASSERT(tok == srcTokensEnd); 130 return true; 131 } 132 }; 133 134 template <> 135 struct Demarshaller<TOK_S_GT_SLICE_INFO> { 136 template <typename GT_SLICE_INFOT> 137 static bool demarshall(GT_SLICE_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 138 const TokenHeader *tok = srcTokensBeg; 139 while (tok < srcTokensEnd) { 140 if (false == tok->flags.flag4IsVariableLength) { 141 switch (tok->id) { 142 default: 143 if (tok->flags.flag3IsMandatory) { 144 return false; 145 } 146 break; 147 case TOK_FBB_GT_SLICE_INFO__ENABLED: { 148 dst.Enabled = readTokValue<decltype(dst.Enabled)>(*tok); 149 } break; 150 case TOK_FBD_GT_SLICE_INFO__SUB_SLICE_ENABLED_COUNT: { 151 dst.SubSliceEnabledCount = readTokValue<decltype(dst.SubSliceEnabledCount)>(*tok); 152 } break; 153 case TOK_FBD_GT_SLICE_INFO__DUAL_SUB_SLICE_ENABLED_COUNT: { 154 dst.DualSubSliceEnabledCount = readTokValue<decltype(dst.DualSubSliceEnabledCount)>(*tok); 155 } break; 156 }; 157 tok = tok + 1 + tok->valueDwordCount; 158 } else { 159 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 160 switch (tok->id) { 161 default: 162 if (tok->flags.flag3IsMandatory) { 163 return false; 164 } 165 break; 166 case TOK_S_GT_SLICE_INFO: 167 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 168 return false; 169 } 170 break; 171 case TOK_FS_GT_SLICE_INFO__SUB_SLICE_INFO: { 172 uint32_t arrayElementIdSubSliceInfo = varLen->arrayElementId; 173 const TokenHeader *tokSubSliceInfo = varLen->getValue<TokenHeader>(); 174 const TokenHeader *tokSubSliceInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 175 while (tokSubSliceInfo < tokSubSliceInfoEnd) { 176 if (false == tokSubSliceInfo->flags.flag4IsVariableLength) { 177 switch (tokSubSliceInfo->id) { 178 default: 179 if (tokSubSliceInfo->flags.flag3IsMandatory) { 180 return false; 181 } 182 break; 183 case TOK_FBB_GT_SUBSLICE_INFO__ENABLED: { 184 dst.SubSliceInfo[arrayElementIdSubSliceInfo].Enabled = readTokValue<decltype(dst.SubSliceInfo[arrayElementIdSubSliceInfo].Enabled)>(*tokSubSliceInfo); 185 } break; 186 case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_COUNT: { 187 dst.SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledCount = readTokValue<decltype(dst.SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledCount)>(*tokSubSliceInfo); 188 } break; 189 case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_MASK: { 190 dst.SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledMask = readTokValue<decltype(dst.SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledMask)>(*tokSubSliceInfo); 191 } break; 192 }; 193 tokSubSliceInfo = tokSubSliceInfo + 1 + tokSubSliceInfo->valueDwordCount; 194 } else { 195 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSubSliceInfo); 196 if (tokSubSliceInfo->flags.flag3IsMandatory) { 197 return false; 198 } 199 tokSubSliceInfo = tokSubSliceInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 200 } 201 } 202 WCH_ASSERT(tokSubSliceInfo == tokSubSliceInfoEnd); 203 } break; 204 case TOK_FS_GT_SLICE_INFO__DSSINFO: { 205 uint32_t arrayElementIdDSSInfo = varLen->arrayElementId; 206 const TokenHeader *tokDSSInfo = varLen->getValue<TokenHeader>(); 207 const TokenHeader *tokDSSInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 208 while (tokDSSInfo < tokDSSInfoEnd) { 209 if (false == tokDSSInfo->flags.flag4IsVariableLength) { 210 switch (tokDSSInfo->id) { 211 default: 212 if (tokDSSInfo->flags.flag3IsMandatory) { 213 return false; 214 } 215 break; 216 case TOK_FBB_GT_DUALSUBSLICE_INFO__ENABLED: { 217 dst.DSSInfo[arrayElementIdDSSInfo].Enabled = readTokValue<decltype(dst.DSSInfo[arrayElementIdDSSInfo].Enabled)>(*tokDSSInfo); 218 } break; 219 }; 220 tokDSSInfo = tokDSSInfo + 1 + tokDSSInfo->valueDwordCount; 221 } else { 222 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokDSSInfo); 223 switch (tokDSSInfo->id) { 224 default: 225 if (tokDSSInfo->flags.flag3IsMandatory) { 226 return false; 227 } 228 break; 229 case TOK_FS_GT_DUALSUBSLICE_INFO__SUB_SLICE: { 230 uint32_t arrayElementIdSubSlice = varLen->arrayElementId; 231 const TokenHeader *tokSubSlice = varLen->getValue<TokenHeader>(); 232 const TokenHeader *tokSubSliceEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 233 while (tokSubSlice < tokSubSliceEnd) { 234 if (false == tokSubSlice->flags.flag4IsVariableLength) { 235 switch (tokSubSlice->id) { 236 default: 237 if (tokSubSlice->flags.flag3IsMandatory) { 238 return false; 239 } 240 break; 241 case TOK_FBB_GT_SUBSLICE_INFO__ENABLED: { 242 dst.DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].Enabled = readTokValue<decltype(dst.DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].Enabled)>(*tokSubSlice); 243 } break; 244 case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_COUNT: { 245 dst.DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledCount = readTokValue<decltype(dst.DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledCount)>(*tokSubSlice); 246 } break; 247 case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_MASK: { 248 dst.DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledMask = readTokValue<decltype(dst.DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledMask)>(*tokSubSlice); 249 } break; 250 }; 251 tokSubSlice = tokSubSlice + 1 + tokSubSlice->valueDwordCount; 252 } else { 253 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSubSlice); 254 if (tokSubSlice->flags.flag3IsMandatory) { 255 return false; 256 } 257 tokSubSlice = tokSubSlice + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 258 } 259 } 260 WCH_ASSERT(tokSubSlice == tokSubSliceEnd); 261 } break; 262 }; 263 tokDSSInfo = tokDSSInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 264 } 265 } 266 WCH_ASSERT(tokDSSInfo == tokDSSInfoEnd); 267 } break; 268 }; 269 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 270 } 271 } 272 WCH_ASSERT(tok == srcTokensEnd); 273 return true; 274 } 275 }; 276 277 template <> 278 struct Demarshaller<TOK_S_GT_VEBOX_INFO> { 279 template <typename GT_VEBOX_INFOT> 280 static bool demarshall(GT_VEBOX_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 281 const TokenHeader *tok = srcTokensBeg; 282 while (tok < srcTokensEnd) { 283 if (false == tok->flags.flag4IsVariableLength) { 284 switch (tok->id) { 285 default: 286 if (tok->flags.flag3IsMandatory) { 287 return false; 288 } 289 break; 290 case TOK_FBD_GT_VEBOX_INFO__NUMBER_OF_VEBOX_ENABLED: { 291 dst.NumberOfVEBoxEnabled = readTokValue<decltype(dst.NumberOfVEBoxEnabled)>(*tok); 292 } break; 293 case TOK_FBB_GT_VEBOX_INFO__IS_VALID: { 294 dst.IsValid = readTokValue<decltype(dst.IsValid)>(*tok); 295 } break; 296 }; 297 tok = tok + 1 + tok->valueDwordCount; 298 } else { 299 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 300 switch (tok->id) { 301 default: 302 if (tok->flags.flag3IsMandatory) { 303 return false; 304 } 305 break; 306 case TOK_S_GT_VEBOX_INFO: 307 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 308 return false; 309 } 310 break; 311 case TOK_FS_GT_VEBOX_INFO__INSTANCES: { 312 const TokenHeader *tokInstances = varLen->getValue<TokenHeader>(); 313 const TokenHeader *tokInstancesEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 314 while (tokInstances < tokInstancesEnd) { 315 if (false == tokInstances->flags.flag4IsVariableLength) { 316 switch (tokInstances->id) { 317 default: 318 if (tokInstances->flags.flag3IsMandatory) { 319 return false; 320 } 321 break; 322 case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBOX_ENABLE_MASK: { 323 dst.Instances.VEBoxEnableMask = readTokValue<decltype(dst.Instances.VEBoxEnableMask)>(*tokInstances); 324 } break; 325 }; 326 tokInstances = tokInstances + 1 + tokInstances->valueDwordCount; 327 } else { 328 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInstances); 329 switch (tokInstances->id) { 330 default: 331 if (tokInstances->flags.flag3IsMandatory) { 332 return false; 333 } 334 break; 335 case TOK_FS_GT_VEBOX_INFO__VEBOX_INSTANCES__BITS: { 336 const TokenHeader *tokBits = varLen->getValue<TokenHeader>(); 337 const TokenHeader *tokBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 338 while (tokBits < tokBitsEnd) { 339 if (false == tokBits->flags.flag4IsVariableLength) { 340 switch (tokBits->id) { 341 default: 342 if (tokBits->flags.flag3IsMandatory) { 343 return false; 344 } 345 break; 346 case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX0ENABLED: { 347 dst.Instances.Bits.VEBox0Enabled = readTokValue<decltype(dst.Instances.Bits.VEBox0Enabled)>(*tokBits); 348 } break; 349 case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX1ENABLED: { 350 dst.Instances.Bits.VEBox1Enabled = readTokValue<decltype(dst.Instances.Bits.VEBox1Enabled)>(*tokBits); 351 } break; 352 case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX2ENABLED: { 353 dst.Instances.Bits.VEBox2Enabled = readTokValue<decltype(dst.Instances.Bits.VEBox2Enabled)>(*tokBits); 354 } break; 355 case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX3ENABLED: { 356 dst.Instances.Bits.VEBox3Enabled = readTokValue<decltype(dst.Instances.Bits.VEBox3Enabled)>(*tokBits); 357 } break; 358 }; 359 tokBits = tokBits + 1 + tokBits->valueDwordCount; 360 } else { 361 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokBits); 362 if (tokBits->flags.flag3IsMandatory) { 363 return false; 364 } 365 tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 366 } 367 } 368 WCH_ASSERT(tokBits == tokBitsEnd); 369 } break; 370 }; 371 tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 372 } 373 } 374 WCH_ASSERT(tokInstances == tokInstancesEnd); 375 } break; 376 case TOK_FS_GT_VEBOX_INFO__SFCSUPPORT: { 377 const TokenHeader *tokSFCSupport = varLen->getValue<TokenHeader>(); 378 const TokenHeader *tokSFCSupportEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 379 while (tokSFCSupport < tokSFCSupportEnd) { 380 if (false == tokSFCSupport->flags.flag4IsVariableLength) { 381 switch (tokSFCSupport->id) { 382 default: 383 if (tokSFCSupport->flags.flag3IsMandatory) { 384 return false; 385 } 386 break; 387 case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__VALUE: { 388 dst.SFCSupport.Value = readTokValue<decltype(dst.SFCSupport.Value)>(*tokSFCSupport); 389 } break; 390 }; 391 tokSFCSupport = tokSFCSupport + 1 + tokSFCSupport->valueDwordCount; 392 } else { 393 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSFCSupport); 394 switch (tokSFCSupport->id) { 395 default: 396 if (tokSFCSupport->flags.flag3IsMandatory) { 397 return false; 398 } 399 break; 400 case TOK_FS_GT_VEBOX_INFO__ANONYMOUS3862__SFC_SUPPORTED_BITS: { 401 const TokenHeader *tokSfcSupportedBits = varLen->getValue<TokenHeader>(); 402 const TokenHeader *tokSfcSupportedBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 403 while (tokSfcSupportedBits < tokSfcSupportedBitsEnd) { 404 if (false == tokSfcSupportedBits->flags.flag4IsVariableLength) { 405 switch (tokSfcSupportedBits->id) { 406 default: 407 if (tokSfcSupportedBits->flags.flag3IsMandatory) { 408 return false; 409 } 410 break; 411 case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX0: { 412 dst.SFCSupport.SfcSupportedBits.VEBox0 = readTokValue<decltype(dst.SFCSupport.SfcSupportedBits.VEBox0)>(*tokSfcSupportedBits); 413 } break; 414 case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX1: { 415 dst.SFCSupport.SfcSupportedBits.VEBox1 = readTokValue<decltype(dst.SFCSupport.SfcSupportedBits.VEBox1)>(*tokSfcSupportedBits); 416 } break; 417 case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX2: { 418 dst.SFCSupport.SfcSupportedBits.VEBox2 = readTokValue<decltype(dst.SFCSupport.SfcSupportedBits.VEBox2)>(*tokSfcSupportedBits); 419 } break; 420 case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX3: { 421 dst.SFCSupport.SfcSupportedBits.VEBox3 = readTokValue<decltype(dst.SFCSupport.SfcSupportedBits.VEBox3)>(*tokSfcSupportedBits); 422 } break; 423 }; 424 tokSfcSupportedBits = tokSfcSupportedBits + 1 + tokSfcSupportedBits->valueDwordCount; 425 } else { 426 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSfcSupportedBits); 427 if (tokSfcSupportedBits->flags.flag3IsMandatory) { 428 return false; 429 } 430 tokSfcSupportedBits = tokSfcSupportedBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 431 } 432 } 433 WCH_ASSERT(tokSfcSupportedBits == tokSfcSupportedBitsEnd); 434 } break; 435 }; 436 tokSFCSupport = tokSFCSupport + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 437 } 438 } 439 WCH_ASSERT(tokSFCSupport == tokSFCSupportEnd); 440 } break; 441 }; 442 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 443 } 444 } 445 WCH_ASSERT(tok == srcTokensEnd); 446 return true; 447 } 448 }; 449 450 template <> 451 struct Demarshaller<TOK_S_GT_VDBOX_INFO> { 452 template <typename GT_VDBOX_INFOT> 453 static bool demarshall(GT_VDBOX_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 454 const TokenHeader *tok = srcTokensBeg; 455 while (tok < srcTokensEnd) { 456 if (false == tok->flags.flag4IsVariableLength) { 457 switch (tok->id) { 458 default: 459 if (tok->flags.flag3IsMandatory) { 460 return false; 461 } 462 break; 463 case TOK_FBD_GT_VDBOX_INFO__NUMBER_OF_VDBOX_ENABLED: { 464 dst.NumberOfVDBoxEnabled = readTokValue<decltype(dst.NumberOfVDBoxEnabled)>(*tok); 465 } break; 466 case TOK_FBB_GT_VDBOX_INFO__IS_VALID: { 467 dst.IsValid = readTokValue<decltype(dst.IsValid)>(*tok); 468 } break; 469 }; 470 tok = tok + 1 + tok->valueDwordCount; 471 } else { 472 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 473 switch (tok->id) { 474 default: 475 if (tok->flags.flag3IsMandatory) { 476 return false; 477 } 478 break; 479 case TOK_S_GT_VDBOX_INFO: 480 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 481 return false; 482 } 483 break; 484 case TOK_FS_GT_VDBOX_INFO__INSTANCES: { 485 const TokenHeader *tokInstances = varLen->getValue<TokenHeader>(); 486 const TokenHeader *tokInstancesEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 487 while (tokInstances < tokInstancesEnd) { 488 if (false == tokInstances->flags.flag4IsVariableLength) { 489 switch (tokInstances->id) { 490 default: 491 if (tokInstances->flags.flag3IsMandatory) { 492 return false; 493 } 494 break; 495 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBOX_ENABLE_MASK: { 496 dst.Instances.VDBoxEnableMask = readTokValue<decltype(dst.Instances.VDBoxEnableMask)>(*tokInstances); 497 } break; 498 }; 499 tokInstances = tokInstances + 1 + tokInstances->valueDwordCount; 500 } else { 501 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInstances); 502 switch (tokInstances->id) { 503 default: 504 if (tokInstances->flags.flag3IsMandatory) { 505 return false; 506 } 507 break; 508 case TOK_FS_GT_VDBOX_INFO__VDBOX_INSTANCES__BITS: { 509 const TokenHeader *tokBits = varLen->getValue<TokenHeader>(); 510 const TokenHeader *tokBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 511 while (tokBits < tokBitsEnd) { 512 if (false == tokBits->flags.flag4IsVariableLength) { 513 switch (tokBits->id) { 514 default: 515 if (tokBits->flags.flag3IsMandatory) { 516 return false; 517 } 518 break; 519 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX0ENABLED: { 520 dst.Instances.Bits.VDBox0Enabled = readTokValue<decltype(dst.Instances.Bits.VDBox0Enabled)>(*tokBits); 521 } break; 522 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX1ENABLED: { 523 dst.Instances.Bits.VDBox1Enabled = readTokValue<decltype(dst.Instances.Bits.VDBox1Enabled)>(*tokBits); 524 } break; 525 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX2ENABLED: { 526 dst.Instances.Bits.VDBox2Enabled = readTokValue<decltype(dst.Instances.Bits.VDBox2Enabled)>(*tokBits); 527 } break; 528 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX3ENABLED: { 529 dst.Instances.Bits.VDBox3Enabled = readTokValue<decltype(dst.Instances.Bits.VDBox3Enabled)>(*tokBits); 530 } break; 531 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX4ENABLED: { 532 dst.Instances.Bits.VDBox4Enabled = readTokValue<decltype(dst.Instances.Bits.VDBox4Enabled)>(*tokBits); 533 } break; 534 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX5ENABLED: { 535 dst.Instances.Bits.VDBox5Enabled = readTokValue<decltype(dst.Instances.Bits.VDBox5Enabled)>(*tokBits); 536 } break; 537 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX6ENABLED: { 538 dst.Instances.Bits.VDBox6Enabled = readTokValue<decltype(dst.Instances.Bits.VDBox6Enabled)>(*tokBits); 539 } break; 540 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX7ENABLED: { 541 dst.Instances.Bits.VDBox7Enabled = readTokValue<decltype(dst.Instances.Bits.VDBox7Enabled)>(*tokBits); 542 } break; 543 }; 544 tokBits = tokBits + 1 + tokBits->valueDwordCount; 545 } else { 546 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokBits); 547 if (tokBits->flags.flag3IsMandatory) { 548 return false; 549 } 550 tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 551 } 552 } 553 WCH_ASSERT(tokBits == tokBitsEnd); 554 } break; 555 }; 556 tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 557 } 558 } 559 WCH_ASSERT(tokInstances == tokInstancesEnd); 560 } break; 561 case TOK_FS_GT_VDBOX_INFO__SFCSUPPORT: { 562 const TokenHeader *tokSFCSupport = varLen->getValue<TokenHeader>(); 563 const TokenHeader *tokSFCSupportEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 564 while (tokSFCSupport < tokSFCSupportEnd) { 565 if (false == tokSFCSupport->flags.flag4IsVariableLength) { 566 switch (tokSFCSupport->id) { 567 default: 568 if (tokSFCSupport->flags.flag3IsMandatory) { 569 return false; 570 } 571 break; 572 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__VALUE: { 573 dst.SFCSupport.Value = readTokValue<decltype(dst.SFCSupport.Value)>(*tokSFCSupport); 574 } break; 575 }; 576 tokSFCSupport = tokSFCSupport + 1 + tokSFCSupport->valueDwordCount; 577 } else { 578 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSFCSupport); 579 switch (tokSFCSupport->id) { 580 default: 581 if (tokSFCSupport->flags.flag3IsMandatory) { 582 return false; 583 } 584 break; 585 case TOK_FS_GT_VDBOX_INFO__ANONYMOUS5662__SFC_SUPPORTED_BITS: { 586 const TokenHeader *tokSfcSupportedBits = varLen->getValue<TokenHeader>(); 587 const TokenHeader *tokSfcSupportedBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 588 while (tokSfcSupportedBits < tokSfcSupportedBitsEnd) { 589 if (false == tokSfcSupportedBits->flags.flag4IsVariableLength) { 590 switch (tokSfcSupportedBits->id) { 591 default: 592 if (tokSfcSupportedBits->flags.flag3IsMandatory) { 593 return false; 594 } 595 break; 596 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX0: { 597 dst.SFCSupport.SfcSupportedBits.VDBox0 = readTokValue<decltype(dst.SFCSupport.SfcSupportedBits.VDBox0)>(*tokSfcSupportedBits); 598 } break; 599 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX1: { 600 dst.SFCSupport.SfcSupportedBits.VDBox1 = readTokValue<decltype(dst.SFCSupport.SfcSupportedBits.VDBox1)>(*tokSfcSupportedBits); 601 } break; 602 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX2: { 603 dst.SFCSupport.SfcSupportedBits.VDBox2 = readTokValue<decltype(dst.SFCSupport.SfcSupportedBits.VDBox2)>(*tokSfcSupportedBits); 604 } break; 605 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX3: { 606 dst.SFCSupport.SfcSupportedBits.VDBox3 = readTokValue<decltype(dst.SFCSupport.SfcSupportedBits.VDBox3)>(*tokSfcSupportedBits); 607 } break; 608 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX4: { 609 dst.SFCSupport.SfcSupportedBits.VDBox4 = readTokValue<decltype(dst.SFCSupport.SfcSupportedBits.VDBox4)>(*tokSfcSupportedBits); 610 } break; 611 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX5: { 612 dst.SFCSupport.SfcSupportedBits.VDBox5 = readTokValue<decltype(dst.SFCSupport.SfcSupportedBits.VDBox5)>(*tokSfcSupportedBits); 613 } break; 614 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX6: { 615 dst.SFCSupport.SfcSupportedBits.VDBox6 = readTokValue<decltype(dst.SFCSupport.SfcSupportedBits.VDBox6)>(*tokSfcSupportedBits); 616 } break; 617 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX7: { 618 dst.SFCSupport.SfcSupportedBits.VDBox7 = readTokValue<decltype(dst.SFCSupport.SfcSupportedBits.VDBox7)>(*tokSfcSupportedBits); 619 } break; 620 }; 621 tokSfcSupportedBits = tokSfcSupportedBits + 1 + tokSfcSupportedBits->valueDwordCount; 622 } else { 623 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSfcSupportedBits); 624 if (tokSfcSupportedBits->flags.flag3IsMandatory) { 625 return false; 626 } 627 tokSfcSupportedBits = tokSfcSupportedBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 628 } 629 } 630 WCH_ASSERT(tokSfcSupportedBits == tokSfcSupportedBitsEnd); 631 } break; 632 }; 633 tokSFCSupport = tokSFCSupport + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 634 } 635 } 636 WCH_ASSERT(tokSFCSupport == tokSFCSupportEnd); 637 } break; 638 }; 639 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 640 } 641 } 642 WCH_ASSERT(tok == srcTokensEnd); 643 return true; 644 } 645 }; 646 647 template <> 648 struct Demarshaller<TOK_S_GT_CCS_INFO> { 649 template <typename GT_CCS_INFOT> 650 static bool demarshall(GT_CCS_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 651 const TokenHeader *tok = srcTokensBeg; 652 while (tok < srcTokensEnd) { 653 if (false == tok->flags.flag4IsVariableLength) { 654 switch (tok->id) { 655 default: 656 if (tok->flags.flag3IsMandatory) { 657 return false; 658 } 659 break; 660 case TOK_FBD_GT_CCS_INFO__NUMBER_OF_CCSENABLED: { 661 dst.NumberOfCCSEnabled = readTokValue<decltype(dst.NumberOfCCSEnabled)>(*tok); 662 } break; 663 case TOK_FBB_GT_CCS_INFO__IS_VALID: { 664 dst.IsValid = readTokValue<decltype(dst.IsValid)>(*tok); 665 } break; 666 }; 667 tok = tok + 1 + tok->valueDwordCount; 668 } else { 669 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 670 switch (tok->id) { 671 default: 672 if (tok->flags.flag3IsMandatory) { 673 return false; 674 } 675 break; 676 case TOK_S_GT_CCS_INFO: 677 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 678 return false; 679 } 680 break; 681 case TOK_FS_GT_CCS_INFO__INSTANCES: { 682 const TokenHeader *tokInstances = varLen->getValue<TokenHeader>(); 683 const TokenHeader *tokInstancesEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 684 while (tokInstances < tokInstancesEnd) { 685 if (false == tokInstances->flags.flag4IsVariableLength) { 686 switch (tokInstances->id) { 687 default: 688 if (tokInstances->flags.flag3IsMandatory) { 689 return false; 690 } 691 break; 692 case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSENABLE_MASK: { 693 dst.Instances.CCSEnableMask = readTokValue<decltype(dst.Instances.CCSEnableMask)>(*tokInstances); 694 } break; 695 }; 696 tokInstances = tokInstances + 1 + tokInstances->valueDwordCount; 697 } else { 698 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInstances); 699 switch (tokInstances->id) { 700 default: 701 if (tokInstances->flags.flag3IsMandatory) { 702 return false; 703 } 704 break; 705 case TOK_FS_GT_CCS_INFO__CCSINSTANCES__BITS: { 706 const TokenHeader *tokBits = varLen->getValue<TokenHeader>(); 707 const TokenHeader *tokBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 708 while (tokBits < tokBitsEnd) { 709 if (false == tokBits->flags.flag4IsVariableLength) { 710 switch (tokBits->id) { 711 default: 712 if (tokBits->flags.flag3IsMandatory) { 713 return false; 714 } 715 break; 716 case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS0ENABLED: { 717 dst.Instances.Bits.CCS0Enabled = readTokValue<decltype(dst.Instances.Bits.CCS0Enabled)>(*tokBits); 718 } break; 719 case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS1ENABLED: { 720 dst.Instances.Bits.CCS1Enabled = readTokValue<decltype(dst.Instances.Bits.CCS1Enabled)>(*tokBits); 721 } break; 722 case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS2ENABLED: { 723 dst.Instances.Bits.CCS2Enabled = readTokValue<decltype(dst.Instances.Bits.CCS2Enabled)>(*tokBits); 724 } break; 725 case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS3ENABLED: { 726 dst.Instances.Bits.CCS3Enabled = readTokValue<decltype(dst.Instances.Bits.CCS3Enabled)>(*tokBits); 727 } break; 728 }; 729 tokBits = tokBits + 1 + tokBits->valueDwordCount; 730 } else { 731 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokBits); 732 if (tokBits->flags.flag3IsMandatory) { 733 return false; 734 } 735 tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 736 } 737 } 738 WCH_ASSERT(tokBits == tokBitsEnd); 739 } break; 740 }; 741 tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 742 } 743 } 744 WCH_ASSERT(tokInstances == tokInstancesEnd); 745 } break; 746 }; 747 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 748 } 749 } 750 WCH_ASSERT(tok == srcTokensEnd); 751 return true; 752 } 753 }; 754 755 template <> 756 struct Demarshaller<TOK_S_GT_MULTI_TILE_ARCH_INFO> { 757 template <typename GT_MULTI_TILE_ARCH_INFOT> 758 static bool demarshall(GT_MULTI_TILE_ARCH_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 759 const TokenHeader *tok = srcTokensBeg; 760 while (tok < srcTokensEnd) { 761 if (false == tok->flags.flag4IsVariableLength) { 762 switch (tok->id) { 763 default: 764 if (tok->flags.flag3IsMandatory) { 765 return false; 766 } 767 break; 768 case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__TILE_COUNT: { 769 dst.TileCount = readTokValue<decltype(dst.TileCount)>(*tok); 770 } break; 771 case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE0: { 772 dst.Tile0 = readTokValue<decltype(dst.Tile0)>(*tok); 773 } break; 774 case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE1: { 775 dst.Tile1 = readTokValue<decltype(dst.Tile1)>(*tok); 776 } break; 777 case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE2: { 778 dst.Tile2 = readTokValue<decltype(dst.Tile2)>(*tok); 779 } break; 780 case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE3: { 781 dst.Tile3 = readTokValue<decltype(dst.Tile3)>(*tok); 782 } break; 783 case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__TILE_MASK: { 784 dst.TileMask = readTokValue<decltype(dst.TileMask)>(*tok); 785 } break; 786 case TOK_FBB_GT_MULTI_TILE_ARCH_INFO__IS_VALID: { 787 dst.IsValid = readTokValue<decltype(dst.IsValid)>(*tok); 788 } break; 789 }; 790 tok = tok + 1 + tok->valueDwordCount; 791 } else { 792 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 793 switch (tok->id) { 794 default: 795 if (tok->flags.flag3IsMandatory) { 796 return false; 797 } 798 break; 799 case TOK_S_GT_MULTI_TILE_ARCH_INFO: 800 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 801 return false; 802 } 803 break; 804 }; 805 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 806 } 807 } 808 WCH_ASSERT(tok == srcTokensEnd); 809 return true; 810 } 811 }; 812 813 template <> 814 struct Demarshaller<TOK_S_GT_SQIDI_INFO> { 815 template <typename GT_SQIDI_INFOT> 816 static bool demarshall(GT_SQIDI_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 817 const TokenHeader *tok = srcTokensBeg; 818 while (tok < srcTokensEnd) { 819 if (false == tok->flags.flag4IsVariableLength) { 820 switch (tok->id) { 821 default: 822 if (tok->flags.flag3IsMandatory) { 823 return false; 824 } 825 break; 826 case TOK_FBD_GT_SQIDI_INFO__NUMBEROF_SQIDI: { 827 dst.NumberofSQIDI = readTokValue<decltype(dst.NumberofSQIDI)>(*tok); 828 } break; 829 case TOK_FBD_GT_SQIDI_INFO__NUMBEROF_DOORBELL_PER_SQIDI: { 830 dst.NumberofDoorbellPerSQIDI = readTokValue<decltype(dst.NumberofDoorbellPerSQIDI)>(*tok); 831 } break; 832 }; 833 tok = tok + 1 + tok->valueDwordCount; 834 } else { 835 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 836 switch (tok->id) { 837 default: 838 if (tok->flags.flag3IsMandatory) { 839 return false; 840 } 841 break; 842 case TOK_S_GT_SQIDI_INFO: 843 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 844 return false; 845 } 846 break; 847 }; 848 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 849 } 850 } 851 WCH_ASSERT(tok == srcTokensEnd); 852 return true; 853 } 854 }; 855 856 template <> 857 struct Demarshaller<TOK_S_GT_CACHE_TYPES> { 858 template <typename _GT_CACHE_TYPEST> 859 static bool demarshall(_GT_CACHE_TYPEST &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 860 const TokenHeader *tok = srcTokensBeg; 861 while (tok < srcTokensEnd) { 862 if (false == tok->flags.flag4IsVariableLength) { 863 switch (tok->id) { 864 default: 865 if (tok->flags.flag3IsMandatory) { 866 return false; 867 } 868 break; 869 case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__L3: { 870 dst.L3 = readTokValue<decltype(dst.L3)>(*tok); 871 } break; 872 case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__LLC: { 873 dst.LLC = readTokValue<decltype(dst.LLC)>(*tok); 874 } break; 875 case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__E_DRAM: { 876 dst.eDRAM = readTokValue<decltype(dst.eDRAM)>(*tok); 877 } break; 878 case TOK_FBD_GT_CACHE_TYPES__CACHE_TYPE_MASK: { 879 dst.CacheTypeMask = readTokValue<decltype(dst.CacheTypeMask)>(*tok); 880 } break; 881 }; 882 tok = tok + 1 + tok->valueDwordCount; 883 } else { 884 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 885 switch (tok->id) { 886 default: 887 if (tok->flags.flag3IsMandatory) { 888 return false; 889 } 890 break; 891 case TOK_S_GT_CACHE_TYPES: 892 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 893 return false; 894 } 895 break; 896 }; 897 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 898 } 899 } 900 WCH_ASSERT(tok == srcTokensEnd); 901 return true; 902 } 903 }; 904 905 template <> 906 struct Demarshaller<TOK_S_GT_SYSTEM_INFO> { 907 template <typename GT_SYSTEM_INFOT> 908 static bool demarshall(GT_SYSTEM_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 909 const TokenHeader *tok = srcTokensBeg; 910 while (tok < srcTokensEnd) { 911 if (false == tok->flags.flag4IsVariableLength) { 912 switch (tok->id) { 913 default: 914 if (tok->flags.flag3IsMandatory) { 915 return false; 916 } 917 break; 918 case TOK_FBD_GT_SYSTEM_INFO__EUCOUNT: { 919 dst.EUCount = readTokValue<decltype(dst.EUCount)>(*tok); 920 } break; 921 case TOK_FBD_GT_SYSTEM_INFO__THREAD_COUNT: { 922 dst.ThreadCount = readTokValue<decltype(dst.ThreadCount)>(*tok); 923 } break; 924 case TOK_FBD_GT_SYSTEM_INFO__SLICE_COUNT: { 925 dst.SliceCount = readTokValue<decltype(dst.SliceCount)>(*tok); 926 } break; 927 case TOK_FBD_GT_SYSTEM_INFO__SUB_SLICE_COUNT: { 928 dst.SubSliceCount = readTokValue<decltype(dst.SubSliceCount)>(*tok); 929 } break; 930 case TOK_FBD_GT_SYSTEM_INFO__DUAL_SUB_SLICE_COUNT: { 931 dst.DualSubSliceCount = readTokValue<decltype(dst.DualSubSliceCount)>(*tok); 932 } break; 933 case TOK_FBQ_GT_SYSTEM_INFO__L3CACHE_SIZE_IN_KB: { 934 dst.L3CacheSizeInKb = readTokValue<decltype(dst.L3CacheSizeInKb)>(*tok); 935 } break; 936 case TOK_FBQ_GT_SYSTEM_INFO__LLCCACHE_SIZE_IN_KB: { 937 dst.LLCCacheSizeInKb = readTokValue<decltype(dst.LLCCacheSizeInKb)>(*tok); 938 } break; 939 case TOK_FBQ_GT_SYSTEM_INFO__EDRAM_SIZE_IN_KB: { 940 dst.EdramSizeInKb = readTokValue<decltype(dst.EdramSizeInKb)>(*tok); 941 } break; 942 case TOK_FBD_GT_SYSTEM_INFO__L3BANK_COUNT: { 943 dst.L3BankCount = readTokValue<decltype(dst.L3BankCount)>(*tok); 944 } break; 945 case TOK_FBD_GT_SYSTEM_INFO__MAX_FILL_RATE: { 946 dst.MaxFillRate = readTokValue<decltype(dst.MaxFillRate)>(*tok); 947 } break; 948 case TOK_FBD_GT_SYSTEM_INFO__EU_COUNT_PER_POOL_MAX: { 949 dst.EuCountPerPoolMax = readTokValue<decltype(dst.EuCountPerPoolMax)>(*tok); 950 } break; 951 case TOK_FBD_GT_SYSTEM_INFO__EU_COUNT_PER_POOL_MIN: { 952 dst.EuCountPerPoolMin = readTokValue<decltype(dst.EuCountPerPoolMin)>(*tok); 953 } break; 954 case TOK_FBD_GT_SYSTEM_INFO__TOTAL_VS_THREADS: { 955 dst.TotalVsThreads = readTokValue<decltype(dst.TotalVsThreads)>(*tok); 956 } break; 957 case TOK_FBD_GT_SYSTEM_INFO__TOTAL_HS_THREADS: { 958 dst.TotalHsThreads = readTokValue<decltype(dst.TotalHsThreads)>(*tok); 959 } break; 960 case TOK_FBD_GT_SYSTEM_INFO__TOTAL_DS_THREADS: { 961 dst.TotalDsThreads = readTokValue<decltype(dst.TotalDsThreads)>(*tok); 962 } break; 963 case TOK_FBD_GT_SYSTEM_INFO__TOTAL_GS_THREADS: { 964 dst.TotalGsThreads = readTokValue<decltype(dst.TotalGsThreads)>(*tok); 965 } break; 966 case TOK_FBD_GT_SYSTEM_INFO__TOTAL_PS_THREADS_WINDOWER_RANGE: { 967 dst.TotalPsThreadsWindowerRange = readTokValue<decltype(dst.TotalPsThreadsWindowerRange)>(*tok); 968 } break; 969 case TOK_FBD_GT_SYSTEM_INFO__TOTAL_VS_THREADS_POCS: { 970 dst.TotalVsThreads_Pocs = readTokValue<decltype(dst.TotalVsThreads_Pocs)>(*tok); 971 } break; 972 case TOK_FBD_GT_SYSTEM_INFO__CSR_SIZE_IN_MB: { 973 dst.CsrSizeInMb = readTokValue<decltype(dst.CsrSizeInMb)>(*tok); 974 } break; 975 case TOK_FBD_GT_SYSTEM_INFO__MAX_EU_PER_SUB_SLICE: { 976 dst.MaxEuPerSubSlice = readTokValue<decltype(dst.MaxEuPerSubSlice)>(*tok); 977 } break; 978 case TOK_FBD_GT_SYSTEM_INFO__MAX_SLICES_SUPPORTED: { 979 dst.MaxSlicesSupported = readTokValue<decltype(dst.MaxSlicesSupported)>(*tok); 980 } break; 981 case TOK_FBD_GT_SYSTEM_INFO__MAX_SUB_SLICES_SUPPORTED: { 982 dst.MaxSubSlicesSupported = readTokValue<decltype(dst.MaxSubSlicesSupported)>(*tok); 983 } break; 984 case TOK_FBD_GT_SYSTEM_INFO__MAX_DUAL_SUB_SLICES_SUPPORTED: { 985 dst.MaxDualSubSlicesSupported = readTokValue<decltype(dst.MaxDualSubSlicesSupported)>(*tok); 986 } break; 987 case TOK_FBB_GT_SYSTEM_INFO__IS_L3HASH_MODE_ENABLED: { 988 dst.IsL3HashModeEnabled = readTokValue<decltype(dst.IsL3HashModeEnabled)>(*tok); 989 } break; 990 case TOK_FBB_GT_SYSTEM_INFO__IS_DYNAMICALLY_POPULATED: { 991 dst.IsDynamicallyPopulated = readTokValue<decltype(dst.IsDynamicallyPopulated)>(*tok); 992 } break; 993 case TOK_FBD_GT_SYSTEM_INFO__RESERVED_CCSWAYS: { 994 dst.ReservedCCSWays = readTokValue<decltype(dst.ReservedCCSWays)>(*tok); 995 } break; 996 case TOK_FBD_GT_SYSTEM_INFO__NUM_THREADS_PER_EU: { 997 dst.NumThreadsPerEu = readTokValue<decltype(dst.NumThreadsPerEu)>(*tok); 998 } break; 999 case TOK_FBD_GT_SYSTEM_INFO__MAX_VECS: { 1000 dst.MaxVECS = readTokValue<decltype(dst.MaxVECS)>(*tok); 1001 } break; 1002 }; 1003 tok = tok + 1 + tok->valueDwordCount; 1004 } else { 1005 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 1006 switch (tok->id) { 1007 default: 1008 if (tok->flags.flag3IsMandatory) { 1009 return false; 1010 } 1011 break; 1012 case TOK_S_GT_SYSTEM_INFO: 1013 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 1014 return false; 1015 } 1016 break; 1017 case TOK_FS_GT_SYSTEM_INFO__SLICE_INFO: { 1018 uint32_t arrayElementIdSliceInfo = varLen->arrayElementId; 1019 const TokenHeader *tokSliceInfo = varLen->getValue<TokenHeader>(); 1020 const TokenHeader *tokSliceInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 1021 static constexpr auto maxDstSlicesInfo = sizeof(dst.SystemInfo.SliceInfo) / sizeof(dst.SystemInfo.SliceInfo[0]); 1022 if (arrayElementIdSliceInfo >= maxDstSlicesInfo) { 1023 tokSliceInfo = tokSliceInfoEnd; 1024 } 1025 while (tokSliceInfo < tokSliceInfoEnd) { 1026 if (false == tokSliceInfo->flags.flag4IsVariableLength) { 1027 switch (tokSliceInfo->id) { 1028 default: 1029 if (tokSliceInfo->flags.flag3IsMandatory) { 1030 return false; 1031 } 1032 break; 1033 case TOK_FBB_GT_SLICE_INFO__ENABLED: { 1034 dst.SliceInfo[arrayElementIdSliceInfo].Enabled = readTokValue<decltype(dst.SliceInfo[arrayElementIdSliceInfo].Enabled)>(*tokSliceInfo); 1035 } break; 1036 case TOK_FBD_GT_SLICE_INFO__SUB_SLICE_ENABLED_COUNT: { 1037 dst.SliceInfo[arrayElementIdSliceInfo].SubSliceEnabledCount = readTokValue<decltype(dst.SliceInfo[arrayElementIdSliceInfo].SubSliceEnabledCount)>(*tokSliceInfo); 1038 } break; 1039 case TOK_FBD_GT_SLICE_INFO__DUAL_SUB_SLICE_ENABLED_COUNT: { 1040 dst.SliceInfo[arrayElementIdSliceInfo].DualSubSliceEnabledCount = readTokValue<decltype(dst.SliceInfo[arrayElementIdSliceInfo].DualSubSliceEnabledCount)>(*tokSliceInfo); 1041 } break; 1042 }; 1043 tokSliceInfo = tokSliceInfo + 1 + tokSliceInfo->valueDwordCount; 1044 } else { 1045 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSliceInfo); 1046 switch (tokSliceInfo->id) { 1047 default: 1048 if (tokSliceInfo->flags.flag3IsMandatory) { 1049 return false; 1050 } 1051 break; 1052 case TOK_FS_GT_SLICE_INFO__SUB_SLICE_INFO: { 1053 uint32_t arrayElementIdSubSliceInfo = varLen->arrayElementId; 1054 const TokenHeader *tokSubSliceInfo = varLen->getValue<TokenHeader>(); 1055 const TokenHeader *tokSubSliceInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 1056 while (tokSubSliceInfo < tokSubSliceInfoEnd) { 1057 if (false == tokSubSliceInfo->flags.flag4IsVariableLength) { 1058 switch (tokSubSliceInfo->id) { 1059 default: 1060 if (tokSubSliceInfo->flags.flag3IsMandatory) { 1061 return false; 1062 } 1063 break; 1064 case TOK_FBB_GT_SUBSLICE_INFO__ENABLED: { 1065 dst.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].Enabled = readTokValue<decltype(dst.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].Enabled)>(*tokSubSliceInfo); 1066 } break; 1067 case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_COUNT: { 1068 dst.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledCount = readTokValue<decltype(dst.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledCount)>(*tokSubSliceInfo); 1069 } break; 1070 case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_MASK: { 1071 dst.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledMask = readTokValue<decltype(dst.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledMask)>(*tokSubSliceInfo); 1072 } break; 1073 }; 1074 tokSubSliceInfo = tokSubSliceInfo + 1 + tokSubSliceInfo->valueDwordCount; 1075 } else { 1076 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSubSliceInfo); 1077 if (tokSubSliceInfo->flags.flag3IsMandatory) { 1078 return false; 1079 } 1080 tokSubSliceInfo = tokSubSliceInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 1081 } 1082 } 1083 WCH_ASSERT(tokSubSliceInfo == tokSubSliceInfoEnd); 1084 } break; 1085 case TOK_FS_GT_SLICE_INFO__DSSINFO: { 1086 uint32_t arrayElementIdDSSInfo = varLen->arrayElementId; 1087 const TokenHeader *tokDSSInfo = varLen->getValue<TokenHeader>(); 1088 const TokenHeader *tokDSSInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 1089 while (tokDSSInfo < tokDSSInfoEnd) { 1090 if (false == tokDSSInfo->flags.flag4IsVariableLength) { 1091 switch (tokDSSInfo->id) { 1092 default: 1093 if (tokDSSInfo->flags.flag3IsMandatory) { 1094 return false; 1095 } 1096 break; 1097 case TOK_FBB_GT_DUALSUBSLICE_INFO__ENABLED: { 1098 dst.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].Enabled = readTokValue<decltype(dst.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].Enabled)>(*tokDSSInfo); 1099 } break; 1100 }; 1101 tokDSSInfo = tokDSSInfo + 1 + tokDSSInfo->valueDwordCount; 1102 } else { 1103 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokDSSInfo); 1104 switch (tokDSSInfo->id) { 1105 default: 1106 if (tokDSSInfo->flags.flag3IsMandatory) { 1107 return false; 1108 } 1109 break; 1110 case TOK_FS_GT_DUALSUBSLICE_INFO__SUB_SLICE: { 1111 uint32_t arrayElementIdSubSlice = varLen->arrayElementId; 1112 const TokenHeader *tokSubSlice = varLen->getValue<TokenHeader>(); 1113 const TokenHeader *tokSubSliceEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 1114 while (tokSubSlice < tokSubSliceEnd) { 1115 if (false == tokSubSlice->flags.flag4IsVariableLength) { 1116 switch (tokSubSlice->id) { 1117 default: 1118 if (tokSubSlice->flags.flag3IsMandatory) { 1119 return false; 1120 } 1121 break; 1122 case TOK_FBB_GT_SUBSLICE_INFO__ENABLED: { 1123 dst.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].Enabled = readTokValue<decltype(dst.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].Enabled)>(*tokSubSlice); 1124 } break; 1125 case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_COUNT: { 1126 dst.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledCount = readTokValue<decltype(dst.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledCount)>(*tokSubSlice); 1127 } break; 1128 case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_MASK: { 1129 dst.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledMask = readTokValue<decltype(dst.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledMask)>(*tokSubSlice); 1130 } break; 1131 }; 1132 tokSubSlice = tokSubSlice + 1 + tokSubSlice->valueDwordCount; 1133 } else { 1134 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSubSlice); 1135 if (tokSubSlice->flags.flag3IsMandatory) { 1136 return false; 1137 } 1138 tokSubSlice = tokSubSlice + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 1139 } 1140 } 1141 WCH_ASSERT(tokSubSlice == tokSubSliceEnd); 1142 } break; 1143 }; 1144 tokDSSInfo = tokDSSInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 1145 } 1146 } 1147 WCH_ASSERT(tokDSSInfo == tokDSSInfoEnd); 1148 } break; 1149 }; 1150 tokSliceInfo = tokSliceInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 1151 } 1152 } 1153 WCH_ASSERT(tokSliceInfo == tokSliceInfoEnd); 1154 } break; 1155 case TOK_FS_GT_SYSTEM_INFO__SQIDI_INFO: { 1156 const TokenHeader *tokSqidiInfo = varLen->getValue<TokenHeader>(); 1157 const TokenHeader *tokSqidiInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 1158 while (tokSqidiInfo < tokSqidiInfoEnd) { 1159 if (false == tokSqidiInfo->flags.flag4IsVariableLength) { 1160 switch (tokSqidiInfo->id) { 1161 default: 1162 if (tokSqidiInfo->flags.flag3IsMandatory) { 1163 return false; 1164 } 1165 break; 1166 case TOK_FBD_GT_SQIDI_INFO__NUMBEROF_SQIDI: { 1167 dst.SqidiInfo.NumberofSQIDI = readTokValue<decltype(dst.SqidiInfo.NumberofSQIDI)>(*tokSqidiInfo); 1168 } break; 1169 case TOK_FBD_GT_SQIDI_INFO__NUMBEROF_DOORBELL_PER_SQIDI: { 1170 dst.SqidiInfo.NumberofDoorbellPerSQIDI = readTokValue<decltype(dst.SqidiInfo.NumberofDoorbellPerSQIDI)>(*tokSqidiInfo); 1171 } break; 1172 }; 1173 tokSqidiInfo = tokSqidiInfo + 1 + tokSqidiInfo->valueDwordCount; 1174 } else { 1175 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSqidiInfo); 1176 if (tokSqidiInfo->flags.flag3IsMandatory) { 1177 return false; 1178 } 1179 tokSqidiInfo = tokSqidiInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 1180 } 1181 } 1182 WCH_ASSERT(tokSqidiInfo == tokSqidiInfoEnd); 1183 } break; 1184 case TOK_FS_GT_SYSTEM_INFO__CCSINFO: { 1185 const TokenHeader *tokCCSInfo = varLen->getValue<TokenHeader>(); 1186 const TokenHeader *tokCCSInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 1187 while (tokCCSInfo < tokCCSInfoEnd) { 1188 if (false == tokCCSInfo->flags.flag4IsVariableLength) { 1189 switch (tokCCSInfo->id) { 1190 default: 1191 if (tokCCSInfo->flags.flag3IsMandatory) { 1192 return false; 1193 } 1194 break; 1195 case TOK_FBD_GT_CCS_INFO__NUMBER_OF_CCSENABLED: { 1196 dst.CCSInfo.NumberOfCCSEnabled = readTokValue<decltype(dst.CCSInfo.NumberOfCCSEnabled)>(*tokCCSInfo); 1197 } break; 1198 case TOK_FBB_GT_CCS_INFO__IS_VALID: { 1199 dst.CCSInfo.IsValid = readTokValue<decltype(dst.CCSInfo.IsValid)>(*tokCCSInfo); 1200 } break; 1201 }; 1202 tokCCSInfo = tokCCSInfo + 1 + tokCCSInfo->valueDwordCount; 1203 } else { 1204 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCCSInfo); 1205 switch (tokCCSInfo->id) { 1206 default: 1207 if (tokCCSInfo->flags.flag3IsMandatory) { 1208 return false; 1209 } 1210 break; 1211 case TOK_FS_GT_CCS_INFO__INSTANCES: { 1212 const TokenHeader *tokInstances = varLen->getValue<TokenHeader>(); 1213 const TokenHeader *tokInstancesEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 1214 while (tokInstances < tokInstancesEnd) { 1215 if (false == tokInstances->flags.flag4IsVariableLength) { 1216 switch (tokInstances->id) { 1217 default: 1218 if (tokInstances->flags.flag3IsMandatory) { 1219 return false; 1220 } 1221 break; 1222 case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSENABLE_MASK: { 1223 dst.CCSInfo.Instances.CCSEnableMask = readTokValue<decltype(dst.CCSInfo.Instances.CCSEnableMask)>(*tokInstances); 1224 } break; 1225 }; 1226 tokInstances = tokInstances + 1 + tokInstances->valueDwordCount; 1227 } else { 1228 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInstances); 1229 switch (tokInstances->id) { 1230 default: 1231 if (tokInstances->flags.flag3IsMandatory) { 1232 return false; 1233 } 1234 break; 1235 case TOK_FS_GT_CCS_INFO__CCSINSTANCES__BITS: { 1236 const TokenHeader *tokBits = varLen->getValue<TokenHeader>(); 1237 const TokenHeader *tokBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 1238 while (tokBits < tokBitsEnd) { 1239 if (false == tokBits->flags.flag4IsVariableLength) { 1240 switch (tokBits->id) { 1241 default: 1242 if (tokBits->flags.flag3IsMandatory) { 1243 return false; 1244 } 1245 break; 1246 case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS0ENABLED: { 1247 dst.CCSInfo.Instances.Bits.CCS0Enabled = readTokValue<decltype(dst.CCSInfo.Instances.Bits.CCS0Enabled)>(*tokBits); 1248 } break; 1249 case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS1ENABLED: { 1250 dst.CCSInfo.Instances.Bits.CCS1Enabled = readTokValue<decltype(dst.CCSInfo.Instances.Bits.CCS1Enabled)>(*tokBits); 1251 } break; 1252 case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS2ENABLED: { 1253 dst.CCSInfo.Instances.Bits.CCS2Enabled = readTokValue<decltype(dst.CCSInfo.Instances.Bits.CCS2Enabled)>(*tokBits); 1254 } break; 1255 case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS3ENABLED: { 1256 dst.CCSInfo.Instances.Bits.CCS3Enabled = readTokValue<decltype(dst.CCSInfo.Instances.Bits.CCS3Enabled)>(*tokBits); 1257 } break; 1258 }; 1259 tokBits = tokBits + 1 + tokBits->valueDwordCount; 1260 } else { 1261 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokBits); 1262 if (tokBits->flags.flag3IsMandatory) { 1263 return false; 1264 } 1265 tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 1266 } 1267 } 1268 WCH_ASSERT(tokBits == tokBitsEnd); 1269 } break; 1270 }; 1271 tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 1272 } 1273 } 1274 WCH_ASSERT(tokInstances == tokInstancesEnd); 1275 } break; 1276 }; 1277 tokCCSInfo = tokCCSInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 1278 } 1279 } 1280 WCH_ASSERT(tokCCSInfo == tokCCSInfoEnd); 1281 } break; 1282 case TOK_FS_GT_SYSTEM_INFO__MULTI_TILE_ARCH_INFO: { 1283 const TokenHeader *tokMultiTileArchInfo = varLen->getValue<TokenHeader>(); 1284 const TokenHeader *tokMultiTileArchInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 1285 while (tokMultiTileArchInfo < tokMultiTileArchInfoEnd) { 1286 if (false == tokMultiTileArchInfo->flags.flag4IsVariableLength) { 1287 switch (tokMultiTileArchInfo->id) { 1288 default: 1289 if (tokMultiTileArchInfo->flags.flag3IsMandatory) { 1290 return false; 1291 } 1292 break; 1293 case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__TILE_COUNT: { 1294 dst.MultiTileArchInfo.TileCount = readTokValue<decltype(dst.MultiTileArchInfo.TileCount)>(*tokMultiTileArchInfo); 1295 } break; 1296 case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE0: { 1297 dst.MultiTileArchInfo.Tile0 = readTokValue<decltype(dst.MultiTileArchInfo.Tile0)>(*tokMultiTileArchInfo); 1298 } break; 1299 case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE1: { 1300 dst.MultiTileArchInfo.Tile1 = readTokValue<decltype(dst.MultiTileArchInfo.Tile1)>(*tokMultiTileArchInfo); 1301 } break; 1302 case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE2: { 1303 dst.MultiTileArchInfo.Tile2 = readTokValue<decltype(dst.MultiTileArchInfo.Tile2)>(*tokMultiTileArchInfo); 1304 } break; 1305 case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE3: { 1306 dst.MultiTileArchInfo.Tile3 = readTokValue<decltype(dst.MultiTileArchInfo.Tile3)>(*tokMultiTileArchInfo); 1307 } break; 1308 case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__TILE_MASK: { 1309 dst.MultiTileArchInfo.TileMask = readTokValue<decltype(dst.MultiTileArchInfo.TileMask)>(*tokMultiTileArchInfo); 1310 } break; 1311 case TOK_FBB_GT_MULTI_TILE_ARCH_INFO__IS_VALID: { 1312 dst.MultiTileArchInfo.IsValid = readTokValue<decltype(dst.MultiTileArchInfo.IsValid)>(*tokMultiTileArchInfo); 1313 } break; 1314 }; 1315 tokMultiTileArchInfo = tokMultiTileArchInfo + 1 + tokMultiTileArchInfo->valueDwordCount; 1316 } else { 1317 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokMultiTileArchInfo); 1318 if (tokMultiTileArchInfo->flags.flag3IsMandatory) { 1319 return false; 1320 } 1321 tokMultiTileArchInfo = tokMultiTileArchInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 1322 } 1323 } 1324 WCH_ASSERT(tokMultiTileArchInfo == tokMultiTileArchInfoEnd); 1325 } break; 1326 case TOK_FS_GT_SYSTEM_INFO__VDBOX_INFO: { 1327 const TokenHeader *tokVDBoxInfo = varLen->getValue<TokenHeader>(); 1328 const TokenHeader *tokVDBoxInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 1329 while (tokVDBoxInfo < tokVDBoxInfoEnd) { 1330 if (false == tokVDBoxInfo->flags.flag4IsVariableLength) { 1331 switch (tokVDBoxInfo->id) { 1332 default: 1333 if (tokVDBoxInfo->flags.flag3IsMandatory) { 1334 return false; 1335 } 1336 break; 1337 case TOK_FBD_GT_VDBOX_INFO__NUMBER_OF_VDBOX_ENABLED: { 1338 dst.VDBoxInfo.NumberOfVDBoxEnabled = readTokValue<decltype(dst.VDBoxInfo.NumberOfVDBoxEnabled)>(*tokVDBoxInfo); 1339 } break; 1340 case TOK_FBB_GT_VDBOX_INFO__IS_VALID: { 1341 dst.VDBoxInfo.IsValid = readTokValue<decltype(dst.VDBoxInfo.IsValid)>(*tokVDBoxInfo); 1342 } break; 1343 }; 1344 tokVDBoxInfo = tokVDBoxInfo + 1 + tokVDBoxInfo->valueDwordCount; 1345 } else { 1346 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokVDBoxInfo); 1347 switch (tokVDBoxInfo->id) { 1348 default: 1349 if (tokVDBoxInfo->flags.flag3IsMandatory) { 1350 return false; 1351 } 1352 break; 1353 case TOK_FS_GT_VDBOX_INFO__INSTANCES: { 1354 const TokenHeader *tokInstances = varLen->getValue<TokenHeader>(); 1355 const TokenHeader *tokInstancesEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 1356 while (tokInstances < tokInstancesEnd) { 1357 if (false == tokInstances->flags.flag4IsVariableLength) { 1358 switch (tokInstances->id) { 1359 default: 1360 if (tokInstances->flags.flag3IsMandatory) { 1361 return false; 1362 } 1363 break; 1364 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBOX_ENABLE_MASK: { 1365 dst.VDBoxInfo.Instances.VDBoxEnableMask = readTokValue<decltype(dst.VDBoxInfo.Instances.VDBoxEnableMask)>(*tokInstances); 1366 } break; 1367 }; 1368 tokInstances = tokInstances + 1 + tokInstances->valueDwordCount; 1369 } else { 1370 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInstances); 1371 switch (tokInstances->id) { 1372 default: 1373 if (tokInstances->flags.flag3IsMandatory) { 1374 return false; 1375 } 1376 break; 1377 case TOK_FS_GT_VDBOX_INFO__VDBOX_INSTANCES__BITS: { 1378 const TokenHeader *tokBits = varLen->getValue<TokenHeader>(); 1379 const TokenHeader *tokBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 1380 while (tokBits < tokBitsEnd) { 1381 if (false == tokBits->flags.flag4IsVariableLength) { 1382 switch (tokBits->id) { 1383 default: 1384 if (tokBits->flags.flag3IsMandatory) { 1385 return false; 1386 } 1387 break; 1388 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX0ENABLED: { 1389 dst.VDBoxInfo.Instances.Bits.VDBox0Enabled = readTokValue<decltype(dst.VDBoxInfo.Instances.Bits.VDBox0Enabled)>(*tokBits); 1390 } break; 1391 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX1ENABLED: { 1392 dst.VDBoxInfo.Instances.Bits.VDBox1Enabled = readTokValue<decltype(dst.VDBoxInfo.Instances.Bits.VDBox1Enabled)>(*tokBits); 1393 } break; 1394 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX2ENABLED: { 1395 dst.VDBoxInfo.Instances.Bits.VDBox2Enabled = readTokValue<decltype(dst.VDBoxInfo.Instances.Bits.VDBox2Enabled)>(*tokBits); 1396 } break; 1397 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX3ENABLED: { 1398 dst.VDBoxInfo.Instances.Bits.VDBox3Enabled = readTokValue<decltype(dst.VDBoxInfo.Instances.Bits.VDBox3Enabled)>(*tokBits); 1399 } break; 1400 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX4ENABLED: { 1401 dst.VDBoxInfo.Instances.Bits.VDBox4Enabled = readTokValue<decltype(dst.VDBoxInfo.Instances.Bits.VDBox4Enabled)>(*tokBits); 1402 } break; 1403 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX5ENABLED: { 1404 dst.VDBoxInfo.Instances.Bits.VDBox5Enabled = readTokValue<decltype(dst.VDBoxInfo.Instances.Bits.VDBox5Enabled)>(*tokBits); 1405 } break; 1406 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX6ENABLED: { 1407 dst.VDBoxInfo.Instances.Bits.VDBox6Enabled = readTokValue<decltype(dst.VDBoxInfo.Instances.Bits.VDBox6Enabled)>(*tokBits); 1408 } break; 1409 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX7ENABLED: { 1410 dst.VDBoxInfo.Instances.Bits.VDBox7Enabled = readTokValue<decltype(dst.VDBoxInfo.Instances.Bits.VDBox7Enabled)>(*tokBits); 1411 } break; 1412 }; 1413 tokBits = tokBits + 1 + tokBits->valueDwordCount; 1414 } else { 1415 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokBits); 1416 if (tokBits->flags.flag3IsMandatory) { 1417 return false; 1418 } 1419 tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 1420 } 1421 } 1422 WCH_ASSERT(tokBits == tokBitsEnd); 1423 } break; 1424 }; 1425 tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 1426 } 1427 } 1428 WCH_ASSERT(tokInstances == tokInstancesEnd); 1429 } break; 1430 case TOK_FS_GT_VDBOX_INFO__SFCSUPPORT: { 1431 const TokenHeader *tokSFCSupport = varLen->getValue<TokenHeader>(); 1432 const TokenHeader *tokSFCSupportEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 1433 while (tokSFCSupport < tokSFCSupportEnd) { 1434 if (false == tokSFCSupport->flags.flag4IsVariableLength) { 1435 switch (tokSFCSupport->id) { 1436 default: 1437 if (tokSFCSupport->flags.flag3IsMandatory) { 1438 return false; 1439 } 1440 break; 1441 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__VALUE: { 1442 dst.VDBoxInfo.SFCSupport.Value = readTokValue<decltype(dst.VDBoxInfo.SFCSupport.Value)>(*tokSFCSupport); 1443 } break; 1444 }; 1445 tokSFCSupport = tokSFCSupport + 1 + tokSFCSupport->valueDwordCount; 1446 } else { 1447 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSFCSupport); 1448 switch (tokSFCSupport->id) { 1449 default: 1450 if (tokSFCSupport->flags.flag3IsMandatory) { 1451 return false; 1452 } 1453 break; 1454 case TOK_FS_GT_VDBOX_INFO__ANONYMOUS5662__SFC_SUPPORTED_BITS: { 1455 const TokenHeader *tokSfcSupportedBits = varLen->getValue<TokenHeader>(); 1456 const TokenHeader *tokSfcSupportedBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 1457 while (tokSfcSupportedBits < tokSfcSupportedBitsEnd) { 1458 if (false == tokSfcSupportedBits->flags.flag4IsVariableLength) { 1459 switch (tokSfcSupportedBits->id) { 1460 default: 1461 if (tokSfcSupportedBits->flags.flag3IsMandatory) { 1462 return false; 1463 } 1464 break; 1465 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX0: { 1466 dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox0 = readTokValue<decltype(dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox0)>(*tokSfcSupportedBits); 1467 } break; 1468 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX1: { 1469 dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox1 = readTokValue<decltype(dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox1)>(*tokSfcSupportedBits); 1470 } break; 1471 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX2: { 1472 dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox2 = readTokValue<decltype(dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox2)>(*tokSfcSupportedBits); 1473 } break; 1474 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX3: { 1475 dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox3 = readTokValue<decltype(dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox3)>(*tokSfcSupportedBits); 1476 } break; 1477 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX4: { 1478 dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox4 = readTokValue<decltype(dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox4)>(*tokSfcSupportedBits); 1479 } break; 1480 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX5: { 1481 dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox5 = readTokValue<decltype(dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox5)>(*tokSfcSupportedBits); 1482 } break; 1483 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX6: { 1484 dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox6 = readTokValue<decltype(dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox6)>(*tokSfcSupportedBits); 1485 } break; 1486 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX7: { 1487 dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox7 = readTokValue<decltype(dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox7)>(*tokSfcSupportedBits); 1488 } break; 1489 }; 1490 tokSfcSupportedBits = tokSfcSupportedBits + 1 + tokSfcSupportedBits->valueDwordCount; 1491 } else { 1492 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSfcSupportedBits); 1493 if (tokSfcSupportedBits->flags.flag3IsMandatory) { 1494 return false; 1495 } 1496 tokSfcSupportedBits = tokSfcSupportedBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 1497 } 1498 } 1499 WCH_ASSERT(tokSfcSupportedBits == tokSfcSupportedBitsEnd); 1500 } break; 1501 }; 1502 tokSFCSupport = tokSFCSupport + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 1503 } 1504 } 1505 WCH_ASSERT(tokSFCSupport == tokSFCSupportEnd); 1506 } break; 1507 }; 1508 tokVDBoxInfo = tokVDBoxInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 1509 } 1510 } 1511 WCH_ASSERT(tokVDBoxInfo == tokVDBoxInfoEnd); 1512 } break; 1513 case TOK_FS_GT_SYSTEM_INFO__VEBOX_INFO: { 1514 const TokenHeader *tokVEBoxInfo = varLen->getValue<TokenHeader>(); 1515 const TokenHeader *tokVEBoxInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 1516 while (tokVEBoxInfo < tokVEBoxInfoEnd) { 1517 if (false == tokVEBoxInfo->flags.flag4IsVariableLength) { 1518 switch (tokVEBoxInfo->id) { 1519 default: 1520 if (tokVEBoxInfo->flags.flag3IsMandatory) { 1521 return false; 1522 } 1523 break; 1524 case TOK_FBD_GT_VEBOX_INFO__NUMBER_OF_VEBOX_ENABLED: { 1525 dst.VEBoxInfo.NumberOfVEBoxEnabled = readTokValue<decltype(dst.VEBoxInfo.NumberOfVEBoxEnabled)>(*tokVEBoxInfo); 1526 } break; 1527 case TOK_FBB_GT_VEBOX_INFO__IS_VALID: { 1528 dst.VEBoxInfo.IsValid = readTokValue<decltype(dst.VEBoxInfo.IsValid)>(*tokVEBoxInfo); 1529 } break; 1530 }; 1531 tokVEBoxInfo = tokVEBoxInfo + 1 + tokVEBoxInfo->valueDwordCount; 1532 } else { 1533 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokVEBoxInfo); 1534 switch (tokVEBoxInfo->id) { 1535 default: 1536 if (tokVEBoxInfo->flags.flag3IsMandatory) { 1537 return false; 1538 } 1539 break; 1540 case TOK_FS_GT_VEBOX_INFO__INSTANCES: { 1541 const TokenHeader *tokInstances = varLen->getValue<TokenHeader>(); 1542 const TokenHeader *tokInstancesEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 1543 while (tokInstances < tokInstancesEnd) { 1544 if (false == tokInstances->flags.flag4IsVariableLength) { 1545 switch (tokInstances->id) { 1546 default: 1547 if (tokInstances->flags.flag3IsMandatory) { 1548 return false; 1549 } 1550 break; 1551 case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBOX_ENABLE_MASK: { 1552 dst.VEBoxInfo.Instances.VEBoxEnableMask = readTokValue<decltype(dst.VEBoxInfo.Instances.VEBoxEnableMask)>(*tokInstances); 1553 } break; 1554 }; 1555 tokInstances = tokInstances + 1 + tokInstances->valueDwordCount; 1556 } else { 1557 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInstances); 1558 switch (tokInstances->id) { 1559 default: 1560 if (tokInstances->flags.flag3IsMandatory) { 1561 return false; 1562 } 1563 break; 1564 case TOK_FS_GT_VEBOX_INFO__VEBOX_INSTANCES__BITS: { 1565 const TokenHeader *tokBits = varLen->getValue<TokenHeader>(); 1566 const TokenHeader *tokBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 1567 while (tokBits < tokBitsEnd) { 1568 if (false == tokBits->flags.flag4IsVariableLength) { 1569 switch (tokBits->id) { 1570 default: 1571 if (tokBits->flags.flag3IsMandatory) { 1572 return false; 1573 } 1574 break; 1575 case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX0ENABLED: { 1576 dst.VEBoxInfo.Instances.Bits.VEBox0Enabled = readTokValue<decltype(dst.VEBoxInfo.Instances.Bits.VEBox0Enabled)>(*tokBits); 1577 } break; 1578 case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX1ENABLED: { 1579 dst.VEBoxInfo.Instances.Bits.VEBox1Enabled = readTokValue<decltype(dst.VEBoxInfo.Instances.Bits.VEBox1Enabled)>(*tokBits); 1580 } break; 1581 case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX2ENABLED: { 1582 dst.VEBoxInfo.Instances.Bits.VEBox2Enabled = readTokValue<decltype(dst.VEBoxInfo.Instances.Bits.VEBox2Enabled)>(*tokBits); 1583 } break; 1584 case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX3ENABLED: { 1585 dst.VEBoxInfo.Instances.Bits.VEBox3Enabled = readTokValue<decltype(dst.VEBoxInfo.Instances.Bits.VEBox3Enabled)>(*tokBits); 1586 } break; 1587 }; 1588 tokBits = tokBits + 1 + tokBits->valueDwordCount; 1589 } else { 1590 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokBits); 1591 if (tokBits->flags.flag3IsMandatory) { 1592 return false; 1593 } 1594 tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 1595 } 1596 } 1597 WCH_ASSERT(tokBits == tokBitsEnd); 1598 } break; 1599 }; 1600 tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 1601 } 1602 } 1603 WCH_ASSERT(tokInstances == tokInstancesEnd); 1604 } break; 1605 case TOK_FS_GT_VEBOX_INFO__SFCSUPPORT: { 1606 const TokenHeader *tokSFCSupport = varLen->getValue<TokenHeader>(); 1607 const TokenHeader *tokSFCSupportEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 1608 while (tokSFCSupport < tokSFCSupportEnd) { 1609 if (false == tokSFCSupport->flags.flag4IsVariableLength) { 1610 switch (tokSFCSupport->id) { 1611 default: 1612 if (tokSFCSupport->flags.flag3IsMandatory) { 1613 return false; 1614 } 1615 break; 1616 case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__VALUE: { 1617 dst.VEBoxInfo.SFCSupport.Value = readTokValue<decltype(dst.VEBoxInfo.SFCSupport.Value)>(*tokSFCSupport); 1618 } break; 1619 }; 1620 tokSFCSupport = tokSFCSupport + 1 + tokSFCSupport->valueDwordCount; 1621 } else { 1622 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSFCSupport); 1623 switch (tokSFCSupport->id) { 1624 default: 1625 if (tokSFCSupport->flags.flag3IsMandatory) { 1626 return false; 1627 } 1628 break; 1629 case TOK_FS_GT_VEBOX_INFO__ANONYMOUS3862__SFC_SUPPORTED_BITS: { 1630 const TokenHeader *tokSfcSupportedBits = varLen->getValue<TokenHeader>(); 1631 const TokenHeader *tokSfcSupportedBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 1632 while (tokSfcSupportedBits < tokSfcSupportedBitsEnd) { 1633 if (false == tokSfcSupportedBits->flags.flag4IsVariableLength) { 1634 switch (tokSfcSupportedBits->id) { 1635 default: 1636 if (tokSfcSupportedBits->flags.flag3IsMandatory) { 1637 return false; 1638 } 1639 break; 1640 case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX0: { 1641 dst.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox0 = readTokValue<decltype(dst.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox0)>(*tokSfcSupportedBits); 1642 } break; 1643 case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX1: { 1644 dst.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox1 = readTokValue<decltype(dst.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox1)>(*tokSfcSupportedBits); 1645 } break; 1646 case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX2: { 1647 dst.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox2 = readTokValue<decltype(dst.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox2)>(*tokSfcSupportedBits); 1648 } break; 1649 case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX3: { 1650 dst.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox3 = readTokValue<decltype(dst.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox3)>(*tokSfcSupportedBits); 1651 } break; 1652 }; 1653 tokSfcSupportedBits = tokSfcSupportedBits + 1 + tokSfcSupportedBits->valueDwordCount; 1654 } else { 1655 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSfcSupportedBits); 1656 if (tokSfcSupportedBits->flags.flag3IsMandatory) { 1657 return false; 1658 } 1659 tokSfcSupportedBits = tokSfcSupportedBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 1660 } 1661 } 1662 WCH_ASSERT(tokSfcSupportedBits == tokSfcSupportedBitsEnd); 1663 } break; 1664 }; 1665 tokSFCSupport = tokSFCSupport + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 1666 } 1667 } 1668 WCH_ASSERT(tokSFCSupport == tokSFCSupportEnd); 1669 } break; 1670 }; 1671 tokVEBoxInfo = tokVEBoxInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 1672 } 1673 } 1674 WCH_ASSERT(tokVEBoxInfo == tokVEBoxInfoEnd); 1675 } break; 1676 case TOK_FS_GT_SYSTEM_INFO__CACHE_TYPES: { 1677 const TokenHeader *tokCacheTypes = varLen->getValue<TokenHeader>(); 1678 const TokenHeader *tokCacheTypesEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 1679 while (tokCacheTypes < tokCacheTypesEnd) { 1680 if (false == tokCacheTypes->flags.flag4IsVariableLength) { 1681 switch (tokCacheTypes->id) { 1682 default: 1683 if (tokCacheTypes->flags.flag3IsMandatory) { 1684 return false; 1685 } 1686 break; 1687 case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__L3: { 1688 dst.CacheTypes.L3 = readTokValue<decltype(dst.CacheTypes.L3)>(*tokCacheTypes); 1689 } break; 1690 case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__LLC: { 1691 dst.CacheTypes.LLC = readTokValue<decltype(dst.CacheTypes.LLC)>(*tokCacheTypes); 1692 } break; 1693 case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__E_DRAM: { 1694 dst.CacheTypes.eDRAM = readTokValue<decltype(dst.CacheTypes.eDRAM)>(*tokCacheTypes); 1695 } break; 1696 case TOK_FBD_GT_CACHE_TYPES__CACHE_TYPE_MASK: { 1697 dst.CacheTypes.CacheTypeMask = readTokValue<decltype(dst.CacheTypes.CacheTypeMask)>(*tokCacheTypes); 1698 } break; 1699 }; 1700 tokCacheTypes = tokCacheTypes + 1 + tokCacheTypes->valueDwordCount; 1701 } else { 1702 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCacheTypes); 1703 if (tokCacheTypes->flags.flag3IsMandatory) { 1704 return false; 1705 } 1706 tokCacheTypes = tokCacheTypes + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 1707 } 1708 } 1709 WCH_ASSERT(tokCacheTypes == tokCacheTypesEnd); 1710 } break; 1711 }; 1712 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 1713 } 1714 } 1715 WCH_ASSERT(tok == srcTokensEnd); 1716 return true; 1717 } 1718 }; 1719 1720 template <> 1721 struct Demarshaller<TOK_S_SKU_FEATURE_TABLE> { 1722 template <typename _SKU_FEATURE_TABLET> 1723 static bool demarshall(_SKU_FEATURE_TABLET &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 1724 const TokenHeader *tok = srcTokensBeg; 1725 while (tok < srcTokensEnd) { 1726 if (false == tok->flags.flag4IsVariableLength) { 1727 switch (tok->id) { 1728 default: 1729 if (tok->flags.flag3IsMandatory) { 1730 return false; 1731 } 1732 break; 1733 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_DESKTOP: { 1734 dst.FtrDesktop = readTokValue<decltype(dst.FtrDesktop)>(*tok); 1735 } break; 1736 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_VERING: { 1737 dst.FtrVERing = readTokValue<decltype(dst.FtrVERing)>(*tok); 1738 } break; 1739 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_VCS2: { 1740 dst.FtrVcs2 = readTokValue<decltype(dst.FtrVcs2)>(*tok); 1741 } break; 1742 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_BIG_DIE: { 1743 dst.FtrGtBigDie = readTokValue<decltype(dst.FtrGtBigDie)>(*tok); 1744 } break; 1745 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_MEDIUM_DIE: { 1746 dst.FtrGtMediumDie = readTokValue<decltype(dst.FtrGtMediumDie)>(*tok); 1747 } break; 1748 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_SMALL_DIE: { 1749 dst.FtrGtSmallDie = readTokValue<decltype(dst.FtrGtSmallDie)>(*tok); 1750 } break; 1751 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT1: { 1752 dst.FtrGT1 = readTokValue<decltype(dst.FtrGT1)>(*tok); 1753 } break; 1754 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT1_5: { 1755 dst.FtrGT1_5 = readTokValue<decltype(dst.FtrGT1_5)>(*tok); 1756 } break; 1757 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT2: { 1758 dst.FtrGT2 = readTokValue<decltype(dst.FtrGT2)>(*tok); 1759 } break; 1760 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT2_5: { 1761 dst.FtrGT2_5 = readTokValue<decltype(dst.FtrGT2_5)>(*tok); 1762 } break; 1763 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT3: { 1764 dst.FtrGT3 = readTokValue<decltype(dst.FtrGT3)>(*tok); 1765 } break; 1766 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT4: { 1767 dst.FtrGT4 = readTokValue<decltype(dst.FtrGT4)>(*tok); 1768 } break; 1769 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_ULT: { 1770 dst.FtrULT = readTokValue<decltype(dst.FtrULT)>(*tok); 1771 } break; 1772 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_IVBM0M1PLATFORM: { 1773 dst.FtrIVBM0M1Platform = readTokValue<decltype(dst.FtrIVBM0M1Platform)>(*tok); 1774 } break; 1775 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CHANNEL_SWIZZLING_XORENABLED: { 1776 dst.FtrChannelSwizzlingXOREnabled = readTokValue<decltype(dst.FtrChannelSwizzlingXOREnabled)>(*tok); 1777 } break; 1778 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTA: { 1779 dst.FtrGTA = readTokValue<decltype(dst.FtrGTA)>(*tok); 1780 } break; 1781 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTC: { 1782 dst.FtrGTC = readTokValue<decltype(dst.FtrGTC)>(*tok); 1783 } break; 1784 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTX: { 1785 dst.FtrGTX = readTokValue<decltype(dst.FtrGTX)>(*tok); 1786 } break; 1787 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR5SLICE: { 1788 dst.Ftr5Slice = readTokValue<decltype(dst.Ftr5Slice)>(*tok); 1789 } break; 1790 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_LCIA: { 1791 dst.FtrLCIA = readTokValue<decltype(dst.FtrLCIA)>(*tok); 1792 } break; 1793 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_RESOURCE_STREAMER: { 1794 dst.FtrResourceStreamer = readTokValue<decltype(dst.FtrResourceStreamer)>(*tok); 1795 } break; 1796 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSRING: { 1797 dst.FtrCCSRing = readTokValue<decltype(dst.FtrCCSRing)>(*tok); 1798 } break; 1799 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSNODE: { 1800 dst.FtrCCSNode = readTokValue<decltype(dst.FtrCCSNode)>(*tok); 1801 } break; 1802 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSMULTI_INSTANCE: { 1803 dst.FtrCCSMultiInstance = readTokValue<decltype(dst.FtrCCSMultiInstance)>(*tok); 1804 } break; 1805 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_DISPLAY_DISABLED: { 1806 dst.FtrDisplayDisabled = readTokValue<decltype(dst.FtrDisplayDisabled)>(*tok); 1807 } break; 1808 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_SGTPVSKUSTRAP_PRESENT: { 1809 dst.FtrSGTPVSKUStrapPresent = readTokValue<decltype(dst.FtrSGTPVSKUStrapPresent)>(*tok); 1810 } break; 1811 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21584__FTR_POOLED_EU_ENABLED: { 1812 dst.FtrPooledEuEnabled = readTokValue<decltype(dst.FtrPooledEuEnabled)>(*tok); 1813 } break; 1814 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_MID_BATCH_PREEMPT: { 1815 dst.FtrGpGpuMidBatchPreempt = readTokValue<decltype(dst.FtrGpGpuMidBatchPreempt)>(*tok); 1816 } break; 1817 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_THREAD_GROUP_LEVEL_PREEMPT: { 1818 dst.FtrGpGpuThreadGroupLevelPreempt = readTokValue<decltype(dst.FtrGpGpuThreadGroupLevelPreempt)>(*tok); 1819 } break; 1820 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_MID_THREAD_LEVEL_PREEMPT: { 1821 dst.FtrGpGpuMidThreadLevelPreempt = readTokValue<decltype(dst.FtrGpGpuMidThreadLevelPreempt)>(*tok); 1822 } break; 1823 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR3D_MID_BATCH_PREEMPT: { 1824 dst.Ftr3dMidBatchPreempt = readTokValue<decltype(dst.Ftr3dMidBatchPreempt)>(*tok); 1825 } break; 1826 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR3D_OBJECT_LEVEL_PREEMPT: { 1827 dst.Ftr3dObjectLevelPreempt = readTokValue<decltype(dst.Ftr3dObjectLevelPreempt)>(*tok); 1828 } break; 1829 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PER_CTXT_PREEMPTION_GRANULARITY_CONTROL: { 1830 dst.FtrPerCtxtPreemptionGranularityControl = readTokValue<decltype(dst.FtrPerCtxtPreemptionGranularityControl)>(*tok); 1831 } break; 1832 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PPGTT: { 1833 dst.FtrPPGTT = readTokValue<decltype(dst.FtrPPGTT)>(*tok); 1834 } break; 1835 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_IA32E_GFX_PTES: { 1836 dst.FtrIA32eGfxPTEs = readTokValue<decltype(dst.FtrIA32eGfxPTEs)>(*tok); 1837 } break; 1838 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_MEM_TYPE_MOCS_DEFER_PAT: { 1839 dst.FtrMemTypeMocsDeferPAT = readTokValue<decltype(dst.FtrMemTypeMocsDeferPAT)>(*tok); 1840 } break; 1841 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PML4SUPPORT: { 1842 dst.FtrPml4Support = readTokValue<decltype(dst.FtrPml4Support)>(*tok); 1843 } break; 1844 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_SVM: { 1845 dst.FtrSVM = readTokValue<decltype(dst.FtrSVM)>(*tok); 1846 } break; 1847 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TILE_MAPPED_RESOURCE: { 1848 dst.FtrTileMappedResource = readTokValue<decltype(dst.FtrTileMappedResource)>(*tok); 1849 } break; 1850 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TRANSLATION_TABLE: { 1851 dst.FtrTranslationTable = readTokValue<decltype(dst.FtrTranslationTable)>(*tok); 1852 } break; 1853 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_USER_MODE_TRANSLATION_TABLE: { 1854 dst.FtrUserModeTranslationTable = readTokValue<decltype(dst.FtrUserModeTranslationTable)>(*tok); 1855 } break; 1856 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_NULL_PAGES: { 1857 dst.FtrNullPages = readTokValue<decltype(dst.FtrNullPages)>(*tok); 1858 } break; 1859 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_L3IACOHERENCY: { 1860 dst.FtrL3IACoherency = readTokValue<decltype(dst.FtrL3IACoherency)>(*tok); 1861 } break; 1862 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_EDRAM: { 1863 dst.FtrEDram = readTokValue<decltype(dst.FtrEDram)>(*tok); 1864 } break; 1865 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LLCBYPASS: { 1866 dst.FtrLLCBypass = readTokValue<decltype(dst.FtrLLCBypass)>(*tok); 1867 } break; 1868 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CRYSTALWELL: { 1869 dst.FtrCrystalwell = readTokValue<decltype(dst.FtrCrystalwell)>(*tok); 1870 } break; 1871 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CENTRAL_CACHE_POLICY: { 1872 dst.FtrCentralCachePolicy = readTokValue<decltype(dst.FtrCentralCachePolicy)>(*tok); 1873 } break; 1874 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_IO_MMU_PAGE_FAULTING: { 1875 dst.FtrIoMmuPageFaulting = readTokValue<decltype(dst.FtrIoMmuPageFaulting)>(*tok); 1876 } break; 1877 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2GPU_MMU: { 1878 dst.FtrWddm2GpuMmu = readTokValue<decltype(dst.FtrWddm2GpuMmu)>(*tok); 1879 } break; 1880 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2SVM: { 1881 dst.FtrWddm2Svm = readTokValue<decltype(dst.FtrWddm2Svm)>(*tok); 1882 } break; 1883 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_STANDARD_MIP_TAIL_FORMAT: { 1884 dst.FtrStandardMipTailFormat = readTokValue<decltype(dst.FtrStandardMipTailFormat)>(*tok); 1885 } break; 1886 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2_1_64KB_PAGES: { 1887 dst.FtrWddm2_1_64kbPages = readTokValue<decltype(dst.FtrWddm2_1_64kbPages)>(*tok); 1888 } break; 1889 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GTT_CACHE_INVALIDATION: { 1890 dst.FtrGttCacheInvalidation = readTokValue<decltype(dst.FtrGttCacheInvalidation)>(*tok); 1891 } break; 1892 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_E2ECOMPRESSION: { 1893 dst.FtrE2ECompression = readTokValue<decltype(dst.FtrE2ECompression)>(*tok); 1894 } break; 1895 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LINEAR_CCS: { 1896 dst.FtrLinearCCS = readTokValue<decltype(dst.FtrLinearCCS)>(*tok); 1897 } break; 1898 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LOCAL_MEMORY: { 1899 dst.FtrLocalMemory = readTokValue<decltype(dst.FtrLocalMemory)>(*tok); 1900 } break; 1901 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PPGTT64KBWALK_OPTIMIZATION: { 1902 dst.FtrPpgtt64KBWalkOptimization = readTokValue<decltype(dst.FtrPpgtt64KBWalkOptimization)>(*tok); 1903 } break; 1904 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TILE_Y: { 1905 dst.FtrTileY = readTokValue<decltype(dst.FtrTileY)>(*tok); 1906 } break; 1907 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_FLAT_PHYS_CCS: { 1908 dst.FtrFlatPhysCCS = readTokValue<decltype(dst.FtrFlatPhysCCS)>(*tok); 1909 } break; 1910 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_MULTI_TILE_ARCH: { 1911 dst.FtrMultiTileArch = readTokValue<decltype(dst.FtrMultiTileArch)>(*tok); 1912 } break; 1913 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LOCAL_MEMORY_ALLOWS4KB: { 1914 dst.FtrLocalMemoryAllows4KB = readTokValue<decltype(dst.FtrLocalMemoryAllows4KB)>(*tok); 1915 } break; 1916 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_DISPLAY_XTILING: { 1917 dst.FtrDisplayXTiling = readTokValue<decltype(dst.FtrDisplayXTiling)>(*tok); 1918 } break; 1919 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CAMERA_CAPTURE_CACHING: { 1920 dst.FtrCameraCaptureCaching = readTokValue<decltype(dst.FtrCameraCaptureCaching)>(*tok); 1921 } break; 1922 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_KMD_DAF: { 1923 dst.FtrKmdDaf = readTokValue<decltype(dst.FtrKmdDaf)>(*tok); 1924 } break; 1925 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_FRAME_BUFFER_LLC: { 1926 dst.FtrFrameBufferLLC = readTokValue<decltype(dst.FtrFrameBufferLLC)>(*tok); 1927 } break; 1928 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_DRIVER_FLR: { 1929 dst.FtrDriverFLR = readTokValue<decltype(dst.FtrDriverFLR)>(*tok); 1930 } break; 1931 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC_LDR2D: { 1932 dst.FtrAstcLdr2D = readTokValue<decltype(dst.FtrAstcLdr2D)>(*tok); 1933 } break; 1934 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC_HDR2D: { 1935 dst.FtrAstcHdr2D = readTokValue<decltype(dst.FtrAstcHdr2D)>(*tok); 1936 } break; 1937 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC3D: { 1938 dst.FtrAstc3D = readTokValue<decltype(dst.FtrAstc3D)>(*tok); 1939 } break; 1940 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC: { 1941 dst.FtrFbc = readTokValue<decltype(dst.FtrFbc)>(*tok); 1942 } break; 1943 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC2ADDRESS_TRANSLATION: { 1944 dst.FtrFbc2AddressTranslation = readTokValue<decltype(dst.FtrFbc2AddressTranslation)>(*tok); 1945 } break; 1946 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC_BLITTER_TRACKING: { 1947 dst.FtrFbcBlitterTracking = readTokValue<decltype(dst.FtrFbcBlitterTracking)>(*tok); 1948 } break; 1949 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC_CPU_TRACKING: { 1950 dst.FtrFbcCpuTracking = readTokValue<decltype(dst.FtrFbcCpuTracking)>(*tok); 1951 } break; 1952 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_VEBOX: { 1953 dst.FtrVEBOX = readTokValue<decltype(dst.FtrVEBOX)>(*tok); 1954 } break; 1955 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS54736__FTR_REND_COMP: { 1956 dst.FtrRendComp = readTokValue<decltype(dst.FtrRendComp)>(*tok); 1957 } break; 1958 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS54736__FTR_DISPLAY_YTILING: { 1959 dst.FtrDisplayYTiling = readTokValue<decltype(dst.FtrDisplayYTiling)>(*tok); 1960 } break; 1961 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_S3D: { 1962 dst.FtrS3D = readTokValue<decltype(dst.FtrS3D)>(*tok); 1963 } break; 1964 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_DISPLAY_ENGINE_S3D: { 1965 dst.FtrDisplayEngineS3d = readTokValue<decltype(dst.FtrDisplayEngineS3d)>(*tok); 1966 } break; 1967 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_SINGLE_VEBOX_SLICE: { 1968 dst.FtrSingleVeboxSlice = readTokValue<decltype(dst.FtrSingleVeboxSlice)>(*tok); 1969 } break; 1970 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_SIMULATION_MODE: { 1971 dst.FtrSimulationMode = readTokValue<decltype(dst.FtrSimulationMode)>(*tok); 1972 } break; 1973 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS88095__FTR_ENABLE_GU_C: { 1974 dst.FtrEnableGuC = readTokValue<decltype(dst.FtrEnableGuC)>(*tok); 1975 } break; 1976 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS89755__FTR_VGT: { 1977 dst.FtrVgt = readTokValue<decltype(dst.FtrVgt)>(*tok); 1978 } break; 1979 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS91822__FTR_ASSIGNED_GPU_TILE: { 1980 dst.FtrAssignedGpuTile = readTokValue<decltype(dst.FtrAssignedGpuTile)>(*tok); 1981 } break; 1982 }; 1983 tok = tok + 1 + tok->valueDwordCount; 1984 } else { 1985 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 1986 switch (tok->id) { 1987 default: 1988 if (tok->flags.flag3IsMandatory) { 1989 return false; 1990 } 1991 break; 1992 case TOK_S_SKU_FEATURE_TABLE: 1993 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 1994 return false; 1995 } 1996 break; 1997 }; 1998 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 1999 } 2000 } 2001 WCH_ASSERT(tok == srcTokensEnd); 2002 return true; 2003 } 2004 }; 2005 2006 template <> 2007 struct Demarshaller<TOK_S_WA_TABLE> { 2008 template <typename _WA_TABLET> 2009 static bool demarshall(_WA_TABLET &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 2010 const TokenHeader *tok = srcTokensBeg; 2011 while (tok < srcTokensEnd) { 2012 if (false == tok->flags.flag4IsVariableLength) { 2013 switch (tok->id) { 2014 default: 2015 if (tok->flags.flag3IsMandatory) { 2016 return false; 2017 } 2018 break; 2019 case TOK_FBD_WA_TABLE__WA_DO_NOT_USE_MIREPORT_PERF_COUNT: { 2020 dst.WaDoNotUseMIReportPerfCount = readTokValue<decltype(dst.WaDoNotUseMIReportPerfCount)>(*tok); 2021 } break; 2022 case TOK_FBD_WA_TABLE__WA_ALIGN_INDEX_BUFFER: { 2023 dst.WaAlignIndexBuffer = readTokValue<decltype(dst.WaAlignIndexBuffer)>(*tok); 2024 } break; 2025 case TOK_FBD_WA_TABLE__WA_SEND_MIFLUSHBEFORE_VFE: { 2026 dst.WaSendMIFLUSHBeforeVFE = readTokValue<decltype(dst.WaSendMIFLUSHBeforeVFE)>(*tok); 2027 } break; 2028 case TOK_FBD_WA_TABLE__WA_DISABLE_PER_CTXT_PREEMPTION_GRANULARITY_CONTROL: { 2029 dst.WaDisablePerCtxtPreemptionGranularityControl = readTokValue<decltype(dst.WaDisablePerCtxtPreemptionGranularityControl)>(*tok); 2030 } break; 2031 case TOK_FBD_WA_TABLE__WA_ENABLE_PREEMPTION_GRANULARITY_CONTROL_BY_UMD: { 2032 dst.WaEnablePreemptionGranularityControlByUMD = readTokValue<decltype(dst.WaEnablePreemptionGranularityControlByUMD)>(*tok); 2033 } break; 2034 case TOK_FBD_WA_TABLE__WA_DISABLE_LSQCROPERFFOR_OCL: { 2035 dst.WaDisableLSQCROPERFforOCL = readTokValue<decltype(dst.WaDisableLSQCROPERFforOCL)>(*tok); 2036 } break; 2037 case TOK_FBD_WA_TABLE__WA_VALIGN2FOR96BPP_FORMATS: { 2038 dst.WaValign2For96bppFormats = readTokValue<decltype(dst.WaValign2For96bppFormats)>(*tok); 2039 } break; 2040 case TOK_FBD_WA_TABLE__WA_VALIGN2FOR_R8G8B8UINTFORMAT: { 2041 dst.WaValign2ForR8G8B8UINTFormat = readTokValue<decltype(dst.WaValign2ForR8G8B8UINTFormat)>(*tok); 2042 } break; 2043 case TOK_FBD_WA_TABLE__WA_REPORT_PERF_COUNT_USE_GLOBAL_CONTEXT_ID: { 2044 dst.WaReportPerfCountUseGlobalContextID = readTokValue<decltype(dst.WaReportPerfCountUseGlobalContextID)>(*tok); 2045 } break; 2046 case TOK_FBD_WA_TABLE__WA_FORCE_PC_BB_FULL_CFG_RESTORE: { 2047 dst.WaForcePcBbFullCfgRestore = readTokValue<decltype(dst.WaForcePcBbFullCfgRestore)>(*tok); 2048 } break; 2049 case TOK_FBD_WA_TABLE__WA_CSRUNCACHABLE: { 2050 dst.WaCSRUncachable = readTokValue<decltype(dst.WaCSRUncachable)>(*tok); 2051 } break; 2052 case TOK_FBD_WA_TABLE__WA_DISABLE_FUSED_THREAD_SCHEDULING: { 2053 dst.WaDisableFusedThreadScheduling = readTokValue<decltype(dst.WaDisableFusedThreadScheduling)>(*tok); 2054 } break; 2055 case TOK_FBD_WA_TABLE__WA_MODIFY_VFESTATE_AFTER_GPGPUPREEMPTION: { 2056 dst.WaModifyVFEStateAfterGPGPUPreemption = readTokValue<decltype(dst.WaModifyVFEStateAfterGPGPUPreemption)>(*tok); 2057 } break; 2058 case TOK_FBD_WA_TABLE__WA_CURSOR16K: { 2059 dst.WaCursor16K = readTokValue<decltype(dst.WaCursor16K)>(*tok); 2060 } break; 2061 case TOK_FBD_WA_TABLE__WA8K_ALIGNFOR_ASYNC_FLIP: { 2062 dst.Wa8kAlignforAsyncFlip = readTokValue<decltype(dst.Wa8kAlignforAsyncFlip)>(*tok); 2063 } break; 2064 case TOK_FBD_WA_TABLE__WA29BIT_DISPLAY_ADDR_LIMIT: { 2065 dst.Wa29BitDisplayAddrLimit = readTokValue<decltype(dst.Wa29BitDisplayAddrLimit)>(*tok); 2066 } break; 2067 case TOK_FBD_WA_TABLE__WA_ALIGN_CONTEXT_IMAGE: { 2068 dst.WaAlignContextImage = readTokValue<decltype(dst.WaAlignContextImage)>(*tok); 2069 } break; 2070 case TOK_FBD_WA_TABLE__WA_FORCE_GLOBAL_GTT: { 2071 dst.WaForceGlobalGTT = readTokValue<decltype(dst.WaForceGlobalGTT)>(*tok); 2072 } break; 2073 case TOK_FBD_WA_TABLE__WA_REPORT_PERF_COUNT_FORCE_GLOBAL_GTT: { 2074 dst.WaReportPerfCountForceGlobalGTT = readTokValue<decltype(dst.WaReportPerfCountForceGlobalGTT)>(*tok); 2075 } break; 2076 case TOK_FBD_WA_TABLE__WA_OA_ADDRESS_TRANSLATION: { 2077 dst.WaOaAddressTranslation = readTokValue<decltype(dst.WaOaAddressTranslation)>(*tok); 2078 } break; 2079 case TOK_FBD_WA_TABLE__WA2ROW_VERTICAL_ALIGNMENT: { 2080 dst.Wa2RowVerticalAlignment = readTokValue<decltype(dst.Wa2RowVerticalAlignment)>(*tok); 2081 } break; 2082 case TOK_FBD_WA_TABLE__WA_PPGTT_ALIAS_GLOBAL_GTT_SPACE: { 2083 dst.WaPpgttAliasGlobalGttSpace = readTokValue<decltype(dst.WaPpgttAliasGlobalGttSpace)>(*tok); 2084 } break; 2085 case TOK_FBD_WA_TABLE__WA_CLEAR_FENCE_REGISTERS_AT_DRIVER_INIT: { 2086 dst.WaClearFenceRegistersAtDriverInit = readTokValue<decltype(dst.WaClearFenceRegistersAtDriverInit)>(*tok); 2087 } break; 2088 case TOK_FBD_WA_TABLE__WA_RESTRICT_PITCH128KB: { 2089 dst.WaRestrictPitch128KB = readTokValue<decltype(dst.WaRestrictPitch128KB)>(*tok); 2090 } break; 2091 case TOK_FBD_WA_TABLE__WA_AVOID_LLC: { 2092 dst.WaAvoidLLC = readTokValue<decltype(dst.WaAvoidLLC)>(*tok); 2093 } break; 2094 case TOK_FBD_WA_TABLE__WA_AVOID_L3: { 2095 dst.WaAvoidL3 = readTokValue<decltype(dst.WaAvoidL3)>(*tok); 2096 } break; 2097 case TOK_FBD_WA_TABLE__WA16TILE_FENCES_ONLY: { 2098 dst.Wa16TileFencesOnly = readTokValue<decltype(dst.Wa16TileFencesOnly)>(*tok); 2099 } break; 2100 case TOK_FBD_WA_TABLE__WA16MBOABUFFER_ALIGNMENT: { 2101 dst.Wa16MBOABufferAlignment = readTokValue<decltype(dst.Wa16MBOABufferAlignment)>(*tok); 2102 } break; 2103 case TOK_FBD_WA_TABLE__WA_TRANSLATION_TABLE_UNAVAILABLE: { 2104 dst.WaTranslationTableUnavailable = readTokValue<decltype(dst.WaTranslationTableUnavailable)>(*tok); 2105 } break; 2106 case TOK_FBD_WA_TABLE__WA_NO_MINIMIZED_TRIVIAL_SURFACE_PADDING: { 2107 dst.WaNoMinimizedTrivialSurfacePadding = readTokValue<decltype(dst.WaNoMinimizedTrivialSurfacePadding)>(*tok); 2108 } break; 2109 case TOK_FBD_WA_TABLE__WA_NO_BUFFER_SAMPLER_PADDING: { 2110 dst.WaNoBufferSamplerPadding = readTokValue<decltype(dst.WaNoBufferSamplerPadding)>(*tok); 2111 } break; 2112 case TOK_FBD_WA_TABLE__WA_SURFACE_STATE_PLANAR_YOFFSET_ALIGN_BY2: { 2113 dst.WaSurfaceStatePlanarYOffsetAlignBy2 = readTokValue<decltype(dst.WaSurfaceStatePlanarYOffsetAlignBy2)>(*tok); 2114 } break; 2115 case TOK_FBD_WA_TABLE__WA_GTT_CACHING_OFF_BY_DEFAULT: { 2116 dst.WaGttCachingOffByDefault = readTokValue<decltype(dst.WaGttCachingOffByDefault)>(*tok); 2117 } break; 2118 case TOK_FBD_WA_TABLE__WA_TOUCH_ALL_SVM_MEMORY: { 2119 dst.WaTouchAllSvmMemory = readTokValue<decltype(dst.WaTouchAllSvmMemory)>(*tok); 2120 } break; 2121 case TOK_FBD_WA_TABLE__WA_IOBADDRESS_MUST_BE_VALID_IN_HW_CONTEXT: { 2122 dst.WaIOBAddressMustBeValidInHwContext = readTokValue<decltype(dst.WaIOBAddressMustBeValidInHwContext)>(*tok); 2123 } break; 2124 case TOK_FBD_WA_TABLE__WA_FLUSH_TLB_AFTER_CPU_GGTT_WRITES: { 2125 dst.WaFlushTlbAfterCpuGgttWrites = readTokValue<decltype(dst.WaFlushTlbAfterCpuGgttWrites)>(*tok); 2126 } break; 2127 case TOK_FBD_WA_TABLE__WA_MSAA8X_TILE_YDEPTH_PITCH_ALIGNMENT: { 2128 dst.WaMsaa8xTileYDepthPitchAlignment = readTokValue<decltype(dst.WaMsaa8xTileYDepthPitchAlignment)>(*tok); 2129 } break; 2130 case TOK_FBD_WA_TABLE__WA_DISABLE_NULL_PAGE_AS_DUMMY: { 2131 dst.WaDisableNullPageAsDummy = readTokValue<decltype(dst.WaDisableNullPageAsDummy)>(*tok); 2132 } break; 2133 case TOK_FBD_WA_TABLE__WA_USE_VALIGN16ON_TILE_XYBPP816: { 2134 dst.WaUseVAlign16OnTileXYBpp816 = readTokValue<decltype(dst.WaUseVAlign16OnTileXYBpp816)>(*tok); 2135 } break; 2136 case TOK_FBD_WA_TABLE__WA_GTT_PAT0: { 2137 dst.WaGttPat0 = readTokValue<decltype(dst.WaGttPat0)>(*tok); 2138 } break; 2139 case TOK_FBD_WA_TABLE__WA_GTT_PAT0WB: { 2140 dst.WaGttPat0WB = readTokValue<decltype(dst.WaGttPat0WB)>(*tok); 2141 } break; 2142 case TOK_FBD_WA_TABLE__WA_MEM_TYPE_IS_MAX_OF_PAT_AND_MOCS: { 2143 dst.WaMemTypeIsMaxOfPatAndMocs = readTokValue<decltype(dst.WaMemTypeIsMaxOfPatAndMocs)>(*tok); 2144 } break; 2145 case TOK_FBD_WA_TABLE__WA_GTT_PAT0GTT_WB_OVER_OS_IOMMU_ELLC_ONLY: { 2146 dst.WaGttPat0GttWbOverOsIommuEllcOnly = readTokValue<decltype(dst.WaGttPat0GttWbOverOsIommuEllcOnly)>(*tok); 2147 } break; 2148 case TOK_FBD_WA_TABLE__WA_ADD_DUMMY_PAGE_FOR_DISPLAY_PREFETCH: { 2149 dst.WaAddDummyPageForDisplayPrefetch = readTokValue<decltype(dst.WaAddDummyPageForDisplayPrefetch)>(*tok); 2150 } break; 2151 case TOK_FBD_WA_TABLE__WA_DEFAULT_TILE4: { 2152 dst.WaDefaultTile4 = readTokValue<decltype(dst.WaDefaultTile4)>(*tok); 2153 } break; 2154 case TOK_FBD_WA_TABLE__WA_LLCCACHING_UNSUPPORTED: { 2155 dst.WaLLCCachingUnsupported = readTokValue<decltype(dst.WaLLCCachingUnsupported)>(*tok); 2156 } break; 2157 case TOK_FBD_WA_TABLE__WA_DOUBLE_FAST_CLEAR_WIDTH_ALIGNMENT: { 2158 dst.WaDoubleFastClearWidthAlignment = readTokValue<decltype(dst.WaDoubleFastClearWidthAlignment)>(*tok); 2159 } break; 2160 case TOK_FBD_WA_TABLE__WA_COMPRESSED_RESOURCE_REQUIRES_CONST_VA21: { 2161 dst.WaCompressedResourceRequiresConstVA21 = readTokValue<decltype(dst.WaCompressedResourceRequiresConstVA21)>(*tok); 2162 } break; 2163 case TOK_FBD_WA_TABLE__WA_DISREGARD_PLATFORM_CHECKS: { 2164 dst.WaDisregardPlatformChecks = readTokValue<decltype(dst.WaDisregardPlatformChecks)>(*tok); 2165 } break; 2166 case TOK_FBD_WA_TABLE__WA_LOSSLESS_COMPRESSION_SURFACE_STRIDE: { 2167 dst.WaLosslessCompressionSurfaceStride = readTokValue<decltype(dst.WaLosslessCompressionSurfaceStride)>(*tok); 2168 } break; 2169 case TOK_FBD_WA_TABLE__WA_FBC_LINEAR_SURFACE_STRIDE: { 2170 dst.WaFbcLinearSurfaceStride = readTokValue<decltype(dst.WaFbcLinearSurfaceStride)>(*tok); 2171 } break; 2172 case TOK_FBD_WA_TABLE__WA4K_ALIGN_UVOFFSET_NV12LINEAR_SURFACE: { 2173 dst.Wa4kAlignUVOffsetNV12LinearSurface = readTokValue<decltype(dst.Wa4kAlignUVOffsetNV12LinearSurface)>(*tok); 2174 } break; 2175 case TOK_FBD_WA_TABLE__WA_ASTC_CORRUPTION_FOR_ODD_COMPRESSED_BLOCK_SIZE_X: { 2176 dst.WaAstcCorruptionForOddCompressedBlockSizeX = readTokValue<decltype(dst.WaAstcCorruptionForOddCompressedBlockSizeX)>(*tok); 2177 } break; 2178 case TOK_FBD_WA_TABLE__WA_AUX_TABLE16KGRANULAR: { 2179 dst.WaAuxTable16KGranular = readTokValue<decltype(dst.WaAuxTable16KGranular)>(*tok); 2180 } break; 2181 case TOK_FBD_WA_TABLE__WA_ENCRYPTED_EDRAM_ONLY_PARTIALS: { 2182 dst.WaEncryptedEdramOnlyPartials = readTokValue<decltype(dst.WaEncryptedEdramOnlyPartials)>(*tok); 2183 } break; 2184 case TOK_FBD_WA_TABLE__WA_DISABLE_EDRAM_FOR_DISPLAY_RT: { 2185 dst.WaDisableEdramForDisplayRT = readTokValue<decltype(dst.WaDisableEdramForDisplayRT)>(*tok); 2186 } break; 2187 case TOK_FBD_WA_TABLE__WA_LIMIT128BMEDIA_COMPR: { 2188 dst.WaLimit128BMediaCompr = readTokValue<decltype(dst.WaLimit128BMediaCompr)>(*tok); 2189 } break; 2190 case TOK_FBD_WA_TABLE__WA_UNTYPED_BUFFER_COMPRESSION: { 2191 dst.WaUntypedBufferCompression = readTokValue<decltype(dst.WaUntypedBufferCompression)>(*tok); 2192 } break; 2193 case TOK_FBD_WA_TABLE__WA_SAMPLER_CACHE_FLUSH_BETWEEN_REDESCRIBED_SURFACE_READS: { 2194 dst.WaSamplerCacheFlushBetweenRedescribedSurfaceReads = readTokValue<decltype(dst.WaSamplerCacheFlushBetweenRedescribedSurfaceReads)>(*tok); 2195 } break; 2196 case TOK_FBD_WA_TABLE__WA_ALIGN_YUVRESOURCE_TO_LCU: { 2197 dst.WaAlignYUVResourceToLCU = readTokValue<decltype(dst.WaAlignYUVResourceToLCU)>(*tok); 2198 } break; 2199 case TOK_FBD_WA_TABLE__WA32BPP_TILE_Y2DCOLOR_NO_HALIGN4: { 2200 dst.Wa32bppTileY2DColorNoHAlign4 = readTokValue<decltype(dst.Wa32bppTileY2DColorNoHAlign4)>(*tok); 2201 } break; 2202 }; 2203 tok = tok + 1 + tok->valueDwordCount; 2204 } else { 2205 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 2206 switch (tok->id) { 2207 default: 2208 if (tok->flags.flag3IsMandatory) { 2209 return false; 2210 } 2211 break; 2212 case TOK_S_WA_TABLE: 2213 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 2214 return false; 2215 } 2216 break; 2217 }; 2218 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 2219 } 2220 } 2221 WCH_ASSERT(tok == srcTokensEnd); 2222 return true; 2223 } 2224 }; 2225 2226 template <> 2227 struct Demarshaller<TOK_S_PLATFORM_STR> { 2228 template <typename PLATFORM_STRT> 2229 static bool demarshall(PLATFORM_STRT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 2230 const TokenHeader *tok = srcTokensBeg; 2231 while (tok < srcTokensEnd) { 2232 if (false == tok->flags.flag4IsVariableLength) { 2233 switch (tok->id) { 2234 default: 2235 if (tok->flags.flag3IsMandatory) { 2236 return false; 2237 } 2238 break; 2239 case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { 2240 dst.eProductFamily = readTokValue<decltype(dst.eProductFamily)>(*tok); 2241 } break; 2242 case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { 2243 dst.ePCHProductFamily = readTokValue<decltype(dst.ePCHProductFamily)>(*tok); 2244 } break; 2245 case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { 2246 dst.eDisplayCoreFamily = readTokValue<decltype(dst.eDisplayCoreFamily)>(*tok); 2247 } break; 2248 case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { 2249 dst.eRenderCoreFamily = readTokValue<decltype(dst.eRenderCoreFamily)>(*tok); 2250 } break; 2251 case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { 2252 dst.ePlatformType = readTokValue<decltype(dst.ePlatformType)>(*tok); 2253 } break; 2254 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { 2255 dst.usDeviceID = readTokValue<decltype(dst.usDeviceID)>(*tok); 2256 } break; 2257 case TOK_FBW_PLATFORM_STR__US_REV_ID: { 2258 dst.usRevId = readTokValue<decltype(dst.usRevId)>(*tok); 2259 } break; 2260 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { 2261 dst.usDeviceID_PCH = readTokValue<decltype(dst.usDeviceID_PCH)>(*tok); 2262 } break; 2263 case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { 2264 dst.usRevId_PCH = readTokValue<decltype(dst.usRevId_PCH)>(*tok); 2265 } break; 2266 case TOK_FE_PLATFORM_STR__E_GTTYPE: { 2267 dst.eGTType = readTokValue<decltype(dst.eGTType)>(*tok); 2268 } break; 2269 }; 2270 tok = tok + 1 + tok->valueDwordCount; 2271 } else { 2272 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 2273 switch (tok->id) { 2274 default: 2275 if (tok->flags.flag3IsMandatory) { 2276 return false; 2277 } 2278 break; 2279 case TOK_S_PLATFORM_STR: 2280 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 2281 return false; 2282 } 2283 break; 2284 }; 2285 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 2286 } 2287 } 2288 WCH_ASSERT(tok == srcTokensEnd); 2289 return true; 2290 } 2291 }; 2292 2293 template <> 2294 struct Demarshaller<TOK_S_KMD_CAPS_INFO> { 2295 template <typename __KMD_CAPS_INFOT> 2296 static bool demarshall(__KMD_CAPS_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 2297 const TokenHeader *tok = srcTokensBeg; 2298 while (tok < srcTokensEnd) { 2299 if (false == tok->flags.flag4IsVariableLength) { 2300 switch (tok->id) { 2301 default: 2302 if (tok->flags.flag3IsMandatory) { 2303 return false; 2304 } 2305 break; 2306 case TOK_FBD_KMD_CAPS_INFO__GAMMA_RGB256X3X16: { 2307 dst.Gamma_Rgb256x3x16 = readTokValue<decltype(dst.Gamma_Rgb256x3x16)>(*tok); 2308 } break; 2309 case TOK_FBD_KMD_CAPS_INFO__GDIACCELERATION: { 2310 dst.GDIAcceleration = readTokValue<decltype(dst.GDIAcceleration)>(*tok); 2311 } break; 2312 case TOK_FBD_KMD_CAPS_INFO__OS_MANAGED_HW_CONTEXT: { 2313 dst.OsManagedHwContext = readTokValue<decltype(dst.OsManagedHwContext)>(*tok); 2314 } break; 2315 case TOK_FBD_KMD_CAPS_INFO__GRAPHICS_PREEMPTION_GRANULARITY: { 2316 dst.GraphicsPreemptionGranularity = readTokValue<decltype(dst.GraphicsPreemptionGranularity)>(*tok); 2317 } break; 2318 case TOK_FBD_KMD_CAPS_INFO__COMPUTE_PREEMPTION_GRANULARITY: { 2319 dst.ComputePreemptionGranularity = readTokValue<decltype(dst.ComputePreemptionGranularity)>(*tok); 2320 } break; 2321 case TOK_FBD_KMD_CAPS_INFO__INSTRUMENTATION_IS_ENABLED: { 2322 dst.InstrumentationIsEnabled = readTokValue<decltype(dst.InstrumentationIsEnabled)>(*tok); 2323 } break; 2324 case TOK_FBD_KMD_CAPS_INFO__DRIVER_STORE_ENABLED: { 2325 dst.DriverStoreEnabled = readTokValue<decltype(dst.DriverStoreEnabled)>(*tok); 2326 } break; 2327 }; 2328 tok = tok + 1 + tok->valueDwordCount; 2329 } else { 2330 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 2331 switch (tok->id) { 2332 default: 2333 if (tok->flags.flag3IsMandatory) { 2334 return false; 2335 } 2336 break; 2337 case TOK_S_KMD_CAPS_INFO: 2338 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 2339 return false; 2340 } 2341 break; 2342 }; 2343 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 2344 } 2345 } 2346 WCH_ASSERT(tok == srcTokensEnd); 2347 return true; 2348 } 2349 }; 2350 2351 template <> 2352 struct Demarshaller<TOK_S_KMD_OVERLAY_OVERRIDE> { 2353 template <typename __KMD_OVERLAY_OVERRIDET> 2354 static bool demarshall(__KMD_OVERLAY_OVERRIDET &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 2355 const TokenHeader *tok = srcTokensBeg; 2356 while (tok < srcTokensEnd) { 2357 if (false == tok->flags.flag4IsVariableLength) { 2358 switch (tok->id) { 2359 default: 2360 if (tok->flags.flag3IsMandatory) { 2361 return false; 2362 } 2363 break; 2364 case TOK_FBD_KMD_OVERLAY_OVERRIDE__OVERRIDE_OVERLAY_CAPS: { 2365 dst.OverrideOverlayCaps = readTokValue<decltype(dst.OverrideOverlayCaps)>(*tok); 2366 } break; 2367 case TOK_FBD_KMD_OVERLAY_OVERRIDE__RGBOVERLAY: { 2368 dst.RGBOverlay = readTokValue<decltype(dst.RGBOverlay)>(*tok); 2369 } break; 2370 case TOK_FBD_KMD_OVERLAY_OVERRIDE__YUY2OVERLAY: { 2371 dst.YUY2Overlay = readTokValue<decltype(dst.YUY2Overlay)>(*tok); 2372 } break; 2373 }; 2374 tok = tok + 1 + tok->valueDwordCount; 2375 } else { 2376 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 2377 switch (tok->id) { 2378 default: 2379 if (tok->flags.flag3IsMandatory) { 2380 return false; 2381 } 2382 break; 2383 case TOK_S_KMD_OVERLAY_OVERRIDE: 2384 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 2385 return false; 2386 } 2387 break; 2388 }; 2389 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 2390 } 2391 } 2392 WCH_ASSERT(tok == srcTokensEnd); 2393 return true; 2394 } 2395 }; 2396 2397 template <> 2398 struct Demarshaller<TOK_S_KMD_OVERLAY_CAPS_INFO> { 2399 template <typename __KMD_OVERLAY_CAPS_INFOT> 2400 static bool demarshall(__KMD_OVERLAY_CAPS_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 2401 const TokenHeader *tok = srcTokensBeg; 2402 while (tok < srcTokensEnd) { 2403 if (false == tok->flags.flag4IsVariableLength) { 2404 switch (tok->id) { 2405 default: 2406 if (tok->flags.flag3IsMandatory) { 2407 return false; 2408 } 2409 break; 2410 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__CAPS_VALUE: { 2411 dst.CapsValue = readTokValue<decltype(dst.CapsValue)>(*tok); 2412 } break; 2413 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__MAX_OVERLAY_DISPLAY_WIDTH: { 2414 dst.MaxOverlayDisplayWidth = readTokValue<decltype(dst.MaxOverlayDisplayWidth)>(*tok); 2415 } break; 2416 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__MAX_OVERLAY_DISPLAY_HEIGHT: { 2417 dst.MaxOverlayDisplayHeight = readTokValue<decltype(dst.MaxOverlayDisplayHeight)>(*tok); 2418 } break; 2419 case TOK_FBC_KMD_OVERLAY_CAPS_INFO__HWSCALER_EXISTS: { 2420 dst.HWScalerExists = readTokValue<decltype(dst.HWScalerExists)>(*tok); 2421 } break; 2422 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__MAX_HWSCALER_STRIDE: { 2423 dst.MaxHWScalerStride = readTokValue<decltype(dst.MaxHWScalerStride)>(*tok); 2424 } break; 2425 }; 2426 tok = tok + 1 + tok->valueDwordCount; 2427 } else { 2428 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 2429 switch (tok->id) { 2430 default: 2431 if (tok->flags.flag3IsMandatory) { 2432 return false; 2433 } 2434 break; 2435 case TOK_S_KMD_OVERLAY_CAPS_INFO: 2436 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 2437 return false; 2438 } 2439 break; 2440 case TOK_FS_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__CAPS: { 2441 const TokenHeader *tokCaps = varLen->getValue<TokenHeader>(); 2442 const TokenHeader *tokCapsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 2443 while (tokCaps < tokCapsEnd) { 2444 if (false == tokCaps->flags.flag4IsVariableLength) { 2445 switch (tokCaps->id) { 2446 default: 2447 if (tokCaps->flags.flag3IsMandatory) { 2448 return false; 2449 } 2450 break; 2451 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__FULL_RANGE_RGB: { 2452 dst.Caps.FullRangeRGB = readTokValue<decltype(dst.Caps.FullRangeRGB)>(*tokCaps); 2453 } break; 2454 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__LIMITED_RANGE_RGB: { 2455 dst.Caps.LimitedRangeRGB = readTokValue<decltype(dst.Caps.LimitedRangeRGB)>(*tokCaps); 2456 } break; 2457 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT601: { 2458 dst.Caps.YCbCr_BT601 = readTokValue<decltype(dst.Caps.YCbCr_BT601)>(*tokCaps); 2459 } break; 2460 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT709: { 2461 dst.Caps.YCbCr_BT709 = readTokValue<decltype(dst.Caps.YCbCr_BT709)>(*tokCaps); 2462 } break; 2463 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT601_XV_YCC: { 2464 dst.Caps.YCbCr_BT601_xvYCC = readTokValue<decltype(dst.Caps.YCbCr_BT601_xvYCC)>(*tokCaps); 2465 } break; 2466 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT709_XV_YCC: { 2467 dst.Caps.YCbCr_BT709_xvYCC = readTokValue<decltype(dst.Caps.YCbCr_BT709_xvYCC)>(*tokCaps); 2468 } break; 2469 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__STRETCH_X: { 2470 dst.Caps.StretchX = readTokValue<decltype(dst.Caps.StretchX)>(*tokCaps); 2471 } break; 2472 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__STRETCH_Y: { 2473 dst.Caps.StretchY = readTokValue<decltype(dst.Caps.StretchY)>(*tokCaps); 2474 } break; 2475 }; 2476 tokCaps = tokCaps + 1 + tokCaps->valueDwordCount; 2477 } else { 2478 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCaps); 2479 if (tokCaps->flags.flag3IsMandatory) { 2480 return false; 2481 } 2482 tokCaps = tokCaps + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 2483 } 2484 } 2485 WCH_ASSERT(tokCaps == tokCapsEnd); 2486 } break; 2487 case TOK_FS_KMD_OVERLAY_CAPS_INFO__OVOVERRIDE: { 2488 const TokenHeader *tokOVOverride = varLen->getValue<TokenHeader>(); 2489 const TokenHeader *tokOVOverrideEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 2490 while (tokOVOverride < tokOVOverrideEnd) { 2491 if (false == tokOVOverride->flags.flag4IsVariableLength) { 2492 switch (tokOVOverride->id) { 2493 default: 2494 if (tokOVOverride->flags.flag3IsMandatory) { 2495 return false; 2496 } 2497 break; 2498 case TOK_FBD_KMD_OVERLAY_OVERRIDE__OVERRIDE_OVERLAY_CAPS: { 2499 dst.OVOverride.OverrideOverlayCaps = readTokValue<decltype(dst.OVOverride.OverrideOverlayCaps)>(*tokOVOverride); 2500 } break; 2501 case TOK_FBD_KMD_OVERLAY_OVERRIDE__RGBOVERLAY: { 2502 dst.OVOverride.RGBOverlay = readTokValue<decltype(dst.OVOverride.RGBOverlay)>(*tokOVOverride); 2503 } break; 2504 case TOK_FBD_KMD_OVERLAY_OVERRIDE__YUY2OVERLAY: { 2505 dst.OVOverride.YUY2Overlay = readTokValue<decltype(dst.OVOverride.YUY2Overlay)>(*tokOVOverride); 2506 } break; 2507 }; 2508 tokOVOverride = tokOVOverride + 1 + tokOVOverride->valueDwordCount; 2509 } else { 2510 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokOVOverride); 2511 if (tokOVOverride->flags.flag3IsMandatory) { 2512 return false; 2513 } 2514 tokOVOverride = tokOVOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 2515 } 2516 } 2517 WCH_ASSERT(tokOVOverride == tokOVOverrideEnd); 2518 } break; 2519 }; 2520 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 2521 } 2522 } 2523 WCH_ASSERT(tok == srcTokensEnd); 2524 return true; 2525 } 2526 }; 2527 2528 template <> 2529 struct Demarshaller<TOK_S_FRAME_RATE> { 2530 template <typename FRAME_RATET> 2531 static bool demarshall(FRAME_RATET &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 2532 const TokenHeader *tok = srcTokensBeg; 2533 while (tok < srcTokensEnd) { 2534 if (false == tok->flags.flag4IsVariableLength) { 2535 switch (tok->id) { 2536 default: 2537 if (tok->flags.flag3IsMandatory) { 2538 return false; 2539 } 2540 break; 2541 case TOK_FBD_FRAME_RATE__UI_NUMERATOR: { 2542 dst.uiNumerator = readTokValue<decltype(dst.uiNumerator)>(*tok); 2543 } break; 2544 case TOK_FBD_FRAME_RATE__UI_DENOMINATOR: { 2545 dst.uiDenominator = readTokValue<decltype(dst.uiDenominator)>(*tok); 2546 } break; 2547 }; 2548 tok = tok + 1 + tok->valueDwordCount; 2549 } else { 2550 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 2551 switch (tok->id) { 2552 default: 2553 if (tok->flags.flag3IsMandatory) { 2554 return false; 2555 } 2556 break; 2557 case TOK_S_FRAME_RATE: 2558 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 2559 return false; 2560 } 2561 break; 2562 }; 2563 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 2564 } 2565 } 2566 WCH_ASSERT(tok == srcTokensEnd); 2567 return true; 2568 } 2569 }; 2570 2571 template <> 2572 struct Demarshaller<TOK_S_KM_DEFERRED_WAIT_INFO> { 2573 template <typename _KM_DEFERRED_WAIT_INFOT> 2574 static bool demarshall(_KM_DEFERRED_WAIT_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 2575 const TokenHeader *tok = srcTokensBeg; 2576 while (tok < srcTokensEnd) { 2577 if (false == tok->flags.flag4IsVariableLength) { 2578 switch (tok->id) { 2579 default: 2580 if (tok->flags.flag3IsMandatory) { 2581 return false; 2582 } 2583 break; 2584 case TOK_FBD_KM_DEFERRED_WAIT_INFO__FEATURE_SUPPORTED: { 2585 dst.FeatureSupported = readTokValue<decltype(dst.FeatureSupported)>(*tok); 2586 } break; 2587 case TOK_FBD_KM_DEFERRED_WAIT_INFO__ACTIVE_DISPLAY: { 2588 dst.ActiveDisplay = readTokValue<decltype(dst.ActiveDisplay)>(*tok); 2589 } break; 2590 }; 2591 tok = tok + 1 + tok->valueDwordCount; 2592 } else { 2593 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 2594 switch (tok->id) { 2595 default: 2596 if (tok->flags.flag3IsMandatory) { 2597 return false; 2598 } 2599 break; 2600 case TOK_S_KM_DEFERRED_WAIT_INFO: 2601 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 2602 return false; 2603 } 2604 break; 2605 }; 2606 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 2607 } 2608 } 2609 WCH_ASSERT(tok == srcTokensEnd); 2610 return true; 2611 } 2612 }; 2613 2614 template <> 2615 struct Demarshaller<TOK_S_GMM_GFX_PARTITIONING> { 2616 template <typename __GMM_GFX_PARTITIONINGT> 2617 static bool demarshall(__GMM_GFX_PARTITIONINGT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 2618 const TokenHeader *tok = srcTokensBeg; 2619 while (tok < srcTokensEnd) { 2620 if (false == tok->flags.flag4IsVariableLength) { 2621 if (tok->flags.flag3IsMandatory) { 2622 return false; 2623 } 2624 tok = tok + 1 + tok->valueDwordCount; 2625 } else { 2626 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 2627 switch (tok->id) { 2628 default: 2629 if (tok->flags.flag3IsMandatory) { 2630 return false; 2631 } 2632 break; 2633 case TOK_S_GMM_GFX_PARTITIONING: 2634 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 2635 return false; 2636 } 2637 break; 2638 case TOK_FS_GMM_GFX_PARTITIONING__STANDARD: { 2639 const TokenHeader *tokStandard = varLen->getValue<TokenHeader>(); 2640 const TokenHeader *tokStandardEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 2641 while (tokStandard < tokStandardEnd) { 2642 if (false == tokStandard->flags.flag4IsVariableLength) { 2643 switch (tokStandard->id) { 2644 default: 2645 if (tokStandard->flags.flag3IsMandatory) { 2646 return false; 2647 } 2648 break; 2649 case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__BASE: { 2650 dst.Standard.Base = readTokValue<decltype(dst.Standard.Base)>(*tokStandard); 2651 } break; 2652 case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__LIMIT: { 2653 dst.Standard.Limit = readTokValue<decltype(dst.Standard.Limit)>(*tokStandard); 2654 } break; 2655 }; 2656 tokStandard = tokStandard + 1 + tokStandard->valueDwordCount; 2657 } else { 2658 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokStandard); 2659 if (tokStandard->flags.flag3IsMandatory) { 2660 return false; 2661 } 2662 tokStandard = tokStandard + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 2663 } 2664 } 2665 WCH_ASSERT(tokStandard == tokStandardEnd); 2666 } break; 2667 case TOK_FS_GMM_GFX_PARTITIONING__STANDARD64KB: { 2668 const TokenHeader *tokStandard64KB = varLen->getValue<TokenHeader>(); 2669 const TokenHeader *tokStandard64KBEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 2670 while (tokStandard64KB < tokStandard64KBEnd) { 2671 if (false == tokStandard64KB->flags.flag4IsVariableLength) { 2672 switch (tokStandard64KB->id) { 2673 default: 2674 if (tokStandard64KB->flags.flag3IsMandatory) { 2675 return false; 2676 } 2677 break; 2678 case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__BASE: { 2679 dst.Standard64KB.Base = readTokValue<decltype(dst.Standard64KB.Base)>(*tokStandard64KB); 2680 } break; 2681 case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__LIMIT: { 2682 dst.Standard64KB.Limit = readTokValue<decltype(dst.Standard64KB.Limit)>(*tokStandard64KB); 2683 } break; 2684 }; 2685 tokStandard64KB = tokStandard64KB + 1 + tokStandard64KB->valueDwordCount; 2686 } else { 2687 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokStandard64KB); 2688 if (tokStandard64KB->flags.flag3IsMandatory) { 2689 return false; 2690 } 2691 tokStandard64KB = tokStandard64KB + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 2692 } 2693 } 2694 WCH_ASSERT(tokStandard64KB == tokStandard64KBEnd); 2695 } break; 2696 case TOK_FS_GMM_GFX_PARTITIONING__SVM: { 2697 const TokenHeader *tokSVM = varLen->getValue<TokenHeader>(); 2698 const TokenHeader *tokSVMEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 2699 while (tokSVM < tokSVMEnd) { 2700 if (false == tokSVM->flags.flag4IsVariableLength) { 2701 switch (tokSVM->id) { 2702 default: 2703 if (tokSVM->flags.flag3IsMandatory) { 2704 return false; 2705 } 2706 break; 2707 case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__BASE: { 2708 dst.SVM.Base = readTokValue<decltype(dst.SVM.Base)>(*tokSVM); 2709 } break; 2710 case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__LIMIT: { 2711 dst.SVM.Limit = readTokValue<decltype(dst.SVM.Limit)>(*tokSVM); 2712 } break; 2713 }; 2714 tokSVM = tokSVM + 1 + tokSVM->valueDwordCount; 2715 } else { 2716 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSVM); 2717 if (tokSVM->flags.flag3IsMandatory) { 2718 return false; 2719 } 2720 tokSVM = tokSVM + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 2721 } 2722 } 2723 WCH_ASSERT(tokSVM == tokSVMEnd); 2724 } break; 2725 case TOK_FS_GMM_GFX_PARTITIONING__HEAP32: { 2726 uint32_t arrayElementIdHeap32 = varLen->arrayElementId; 2727 const TokenHeader *tokHeap32 = varLen->getValue<TokenHeader>(); 2728 const TokenHeader *tokHeap32End = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 2729 while (tokHeap32 < tokHeap32End) { 2730 if (false == tokHeap32->flags.flag4IsVariableLength) { 2731 switch (tokHeap32->id) { 2732 default: 2733 if (tokHeap32->flags.flag3IsMandatory) { 2734 return false; 2735 } 2736 break; 2737 case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__BASE: { 2738 dst.Heap32[arrayElementIdHeap32].Base = readTokValue<decltype(dst.Heap32[arrayElementIdHeap32].Base)>(*tokHeap32); 2739 } break; 2740 case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__LIMIT: { 2741 dst.Heap32[arrayElementIdHeap32].Limit = readTokValue<decltype(dst.Heap32[arrayElementIdHeap32].Limit)>(*tokHeap32); 2742 } break; 2743 }; 2744 tokHeap32 = tokHeap32 + 1 + tokHeap32->valueDwordCount; 2745 } else { 2746 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokHeap32); 2747 if (tokHeap32->flags.flag3IsMandatory) { 2748 return false; 2749 } 2750 tokHeap32 = tokHeap32 + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 2751 } 2752 } 2753 WCH_ASSERT(tokHeap32 == tokHeap32End); 2754 } break; 2755 }; 2756 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 2757 } 2758 } 2759 WCH_ASSERT(tok == srcTokensEnd); 2760 return true; 2761 } 2762 }; 2763 2764 template <> 2765 struct Demarshaller<TOK_S_ADAPTER_BDF> { 2766 template <typename _ADAPTER_BDF_T> 2767 static bool demarshall(_ADAPTER_BDF_T &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 2768 const TokenHeader *tok = srcTokensBeg; 2769 while (tok < srcTokensEnd) { 2770 if (false == tok->flags.flag4IsVariableLength) { 2771 switch (tok->id) { 2772 default: 2773 if (tok->flags.flag3IsMandatory) { 2774 return false; 2775 } 2776 break; 2777 case TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__BUS: { 2778 dst.Bus = readTokValue<decltype(dst.Bus)>(*tok); 2779 } break; 2780 case TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__DEVICE: { 2781 dst.Device = readTokValue<decltype(dst.Device)>(*tok); 2782 } break; 2783 case TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__FUNCTION: { 2784 dst.Function = readTokValue<decltype(dst.Function)>(*tok); 2785 } break; 2786 case TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__DATA: { 2787 dst.Data = readTokValue<decltype(dst.Data)>(*tok); 2788 } break; 2789 }; 2790 tok = tok + 1 + tok->valueDwordCount; 2791 } else { 2792 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 2793 switch (tok->id) { 2794 default: 2795 if (tok->flags.flag3IsMandatory) { 2796 return false; 2797 } 2798 break; 2799 case TOK_S_ADAPTER_BDF: 2800 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 2801 return false; 2802 } 2803 break; 2804 }; 2805 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 2806 } 2807 } 2808 WCH_ASSERT(tok == srcTokensEnd); 2809 return true; 2810 } 2811 }; 2812 2813 template <> 2814 struct Demarshaller<TOK_S_ADAPTER_INFO> { 2815 template <typename _ADAPTER_INFOT> 2816 static bool demarshall(_ADAPTER_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 2817 const TokenHeader *tok = srcTokensBeg; 2818 while (tok < srcTokensEnd) { 2819 if (false == tok->flags.flag4IsVariableLength) { 2820 switch (tok->id) { 2821 default: 2822 if (tok->flags.flag3IsMandatory) { 2823 return false; 2824 } 2825 break; 2826 case TOK_FBD_ADAPTER_INFO__KMD_VERSION_INFO: { 2827 dst.KmdVersionInfo = readTokValue<decltype(dst.KmdVersionInfo)>(*tok); 2828 } break; 2829 case TOK_FBC_ADAPTER_INFO__DEVICE_REGISTRY_PATH: { 2830 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tok).getValue<char>(); 2831 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tok).getValueSizeInBytes(); 2832 if (srcSize < sizeof(dst.DeviceRegistryPath)) { 2833 return false; 2834 } 2835 WCH_SAFE_COPY(dst.DeviceRegistryPath, sizeof(dst.DeviceRegistryPath), srcData, sizeof(dst.DeviceRegistryPath)); 2836 } break; 2837 case TOK_FBD_ADAPTER_INFO__GFX_TIME_STAMP_FREQ: { 2838 dst.GfxTimeStampFreq = readTokValue<decltype(dst.GfxTimeStampFreq)>(*tok); 2839 } break; 2840 case TOK_FBD_ADAPTER_INFO__GFX_CORE_FREQUENCY: { 2841 dst.GfxCoreFrequency = readTokValue<decltype(dst.GfxCoreFrequency)>(*tok); 2842 } break; 2843 case TOK_FBD_ADAPTER_INFO__FSBFREQUENCY: { 2844 dst.FSBFrequency = readTokValue<decltype(dst.FSBFrequency)>(*tok); 2845 } break; 2846 case TOK_FBD_ADAPTER_INFO__MIN_RENDER_FREQ: { 2847 dst.MinRenderFreq = readTokValue<decltype(dst.MinRenderFreq)>(*tok); 2848 } break; 2849 case TOK_FBD_ADAPTER_INFO__MAX_RENDER_FREQ: { 2850 dst.MaxRenderFreq = readTokValue<decltype(dst.MaxRenderFreq)>(*tok); 2851 } break; 2852 case TOK_FBD_ADAPTER_INFO__PACKAGE_TDP: { 2853 dst.PackageTdp = readTokValue<decltype(dst.PackageTdp)>(*tok); 2854 } break; 2855 case TOK_FBD_ADAPTER_INFO__MAX_FILL_RATE: { 2856 dst.MaxFillRate = readTokValue<decltype(dst.MaxFillRate)>(*tok); 2857 } break; 2858 case TOK_FBD_ADAPTER_INFO__NUMBER_OF_EUS: { 2859 dst.NumberOfEUs = readTokValue<decltype(dst.NumberOfEUs)>(*tok); 2860 } break; 2861 case TOK_FBD_ADAPTER_INFO__DW_RELEASE_TARGET: { 2862 dst.dwReleaseTarget = readTokValue<decltype(dst.dwReleaseTarget)>(*tok); 2863 } break; 2864 case TOK_FBD_ADAPTER_INFO__SIZE_OF_DMA_BUFFER: { 2865 dst.SizeOfDmaBuffer = readTokValue<decltype(dst.SizeOfDmaBuffer)>(*tok); 2866 } break; 2867 case TOK_FBD_ADAPTER_INFO__PATCH_LOCATION_LIST_SIZE: { 2868 dst.PatchLocationListSize = readTokValue<decltype(dst.PatchLocationListSize)>(*tok); 2869 } break; 2870 case TOK_FBD_ADAPTER_INFO__ALLOCATION_LIST_SIZE: { 2871 dst.AllocationListSize = readTokValue<decltype(dst.AllocationListSize)>(*tok); 2872 } break; 2873 case TOK_FBD_ADAPTER_INFO__SMALL_PATCH_LOCATION_LIST_SIZE: { 2874 dst.SmallPatchLocationListSize = readTokValue<decltype(dst.SmallPatchLocationListSize)>(*tok); 2875 } break; 2876 case TOK_FBD_ADAPTER_INFO__DEFAULT_CMD_BUFFER_SIZE: { 2877 dst.DefaultCmdBufferSize = readTokValue<decltype(dst.DefaultCmdBufferSize)>(*tok); 2878 } break; 2879 case TOK_FBQ_ADAPTER_INFO__GFX_MEMORY_SIZE: { 2880 dst.GfxMemorySize = readTokValue<decltype(dst.GfxMemorySize)>(*tok); 2881 } break; 2882 case TOK_FBD_ADAPTER_INFO__SYSTEM_MEMORY_SIZE: { 2883 dst.SystemMemorySize = readTokValue<decltype(dst.SystemMemorySize)>(*tok); 2884 } break; 2885 case TOK_FBD_ADAPTER_INFO__CACHE_LINE_SIZE: { 2886 dst.CacheLineSize = readTokValue<decltype(dst.CacheLineSize)>(*tok); 2887 } break; 2888 case TOK_FE_ADAPTER_INFO__PROCESSOR_FAMILY: { 2889 dst.ProcessorFamily = readTokValue<decltype(dst.ProcessorFamily)>(*tok); 2890 } break; 2891 case TOK_FBC_ADAPTER_INFO__IS_HTSUPPORTED: { 2892 dst.IsHTSupported = readTokValue<decltype(dst.IsHTSupported)>(*tok); 2893 } break; 2894 case TOK_FBC_ADAPTER_INFO__IS_MUTI_CORE_CPU: { 2895 dst.IsMutiCoreCpu = readTokValue<decltype(dst.IsMutiCoreCpu)>(*tok); 2896 } break; 2897 case TOK_FBC_ADAPTER_INFO__IS_VTDSUPPORTED: { 2898 dst.IsVTDSupported = readTokValue<decltype(dst.IsVTDSupported)>(*tok); 2899 } break; 2900 case TOK_FBD_ADAPTER_INFO__REGISTRY_PATH_LENGTH: { 2901 dst.RegistryPathLength = readTokValue<decltype(dst.RegistryPathLength)>(*tok); 2902 } break; 2903 case TOK_FBQ_ADAPTER_INFO__DEDICATED_VIDEO_MEMORY: { 2904 dst.DedicatedVideoMemory = readTokValue<decltype(dst.DedicatedVideoMemory)>(*tok); 2905 } break; 2906 case TOK_FBQ_ADAPTER_INFO__SYSTEM_SHARED_MEMORY: { 2907 dst.SystemSharedMemory = readTokValue<decltype(dst.SystemSharedMemory)>(*tok); 2908 } break; 2909 case TOK_FBQ_ADAPTER_INFO__SYSTEM_VIDEO_MEMORY: { 2910 dst.SystemVideoMemory = readTokValue<decltype(dst.SystemVideoMemory)>(*tok); 2911 } break; 2912 }; 2913 tok = tok + 1 + tok->valueDwordCount; 2914 } else { 2915 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 2916 switch (tok->id) { 2917 default: 2918 if (tok->flags.flag3IsMandatory) { 2919 return false; 2920 } 2921 break; 2922 case TOK_S_ADAPTER_INFO: 2923 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 2924 return false; 2925 } 2926 break; 2927 case TOK_FS_ADAPTER_INFO__GFX_PLATFORM: { 2928 const TokenHeader *tokGfxPlatform = varLen->getValue<TokenHeader>(); 2929 const TokenHeader *tokGfxPlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 2930 while (tokGfxPlatform < tokGfxPlatformEnd) { 2931 if (false == tokGfxPlatform->flags.flag4IsVariableLength) { 2932 switch (tokGfxPlatform->id) { 2933 default: 2934 if (tokGfxPlatform->flags.flag3IsMandatory) { 2935 return false; 2936 } 2937 break; 2938 case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { 2939 dst.GfxPlatform.eProductFamily = readTokValue<decltype(dst.GfxPlatform.eProductFamily)>(*tokGfxPlatform); 2940 } break; 2941 case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { 2942 dst.GfxPlatform.ePCHProductFamily = readTokValue<decltype(dst.GfxPlatform.ePCHProductFamily)>(*tokGfxPlatform); 2943 } break; 2944 case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { 2945 dst.GfxPlatform.eDisplayCoreFamily = readTokValue<decltype(dst.GfxPlatform.eDisplayCoreFamily)>(*tokGfxPlatform); 2946 } break; 2947 case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { 2948 dst.GfxPlatform.eRenderCoreFamily = readTokValue<decltype(dst.GfxPlatform.eRenderCoreFamily)>(*tokGfxPlatform); 2949 } break; 2950 case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { 2951 dst.GfxPlatform.ePlatformType = readTokValue<decltype(dst.GfxPlatform.ePlatformType)>(*tokGfxPlatform); 2952 } break; 2953 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { 2954 dst.GfxPlatform.usDeviceID = readTokValue<decltype(dst.GfxPlatform.usDeviceID)>(*tokGfxPlatform); 2955 } break; 2956 case TOK_FBW_PLATFORM_STR__US_REV_ID: { 2957 dst.GfxPlatform.usRevId = readTokValue<decltype(dst.GfxPlatform.usRevId)>(*tokGfxPlatform); 2958 } break; 2959 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { 2960 dst.GfxPlatform.usDeviceID_PCH = readTokValue<decltype(dst.GfxPlatform.usDeviceID_PCH)>(*tokGfxPlatform); 2961 } break; 2962 case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { 2963 dst.GfxPlatform.usRevId_PCH = readTokValue<decltype(dst.GfxPlatform.usRevId_PCH)>(*tokGfxPlatform); 2964 } break; 2965 case TOK_FE_PLATFORM_STR__E_GTTYPE: { 2966 dst.GfxPlatform.eGTType = readTokValue<decltype(dst.GfxPlatform.eGTType)>(*tokGfxPlatform); 2967 } break; 2968 }; 2969 tokGfxPlatform = tokGfxPlatform + 1 + tokGfxPlatform->valueDwordCount; 2970 } else { 2971 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokGfxPlatform); 2972 if (tokGfxPlatform->flags.flag3IsMandatory) { 2973 return false; 2974 } 2975 tokGfxPlatform = tokGfxPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 2976 } 2977 } 2978 WCH_ASSERT(tokGfxPlatform == tokGfxPlatformEnd); 2979 } break; 2980 case TOK_FS_ADAPTER_INFO__SKU_TABLE: { 2981 const TokenHeader *tokSkuTable = varLen->getValue<TokenHeader>(); 2982 const TokenHeader *tokSkuTableEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 2983 while (tokSkuTable < tokSkuTableEnd) { 2984 if (false == tokSkuTable->flags.flag4IsVariableLength) { 2985 switch (tokSkuTable->id) { 2986 default: 2987 if (tokSkuTable->flags.flag3IsMandatory) { 2988 return false; 2989 } 2990 break; 2991 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_DESKTOP: { 2992 dst.SkuTable.FtrDesktop = readTokValue<decltype(dst.SkuTable.FtrDesktop)>(*tokSkuTable); 2993 } break; 2994 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_VERING: { 2995 dst.SkuTable.FtrVERing = readTokValue<decltype(dst.SkuTable.FtrVERing)>(*tokSkuTable); 2996 } break; 2997 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_VCS2: { 2998 dst.SkuTable.FtrVcs2 = readTokValue<decltype(dst.SkuTable.FtrVcs2)>(*tokSkuTable); 2999 } break; 3000 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_BIG_DIE: { 3001 dst.SkuTable.FtrGtBigDie = readTokValue<decltype(dst.SkuTable.FtrGtBigDie)>(*tokSkuTable); 3002 } break; 3003 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_MEDIUM_DIE: { 3004 dst.SkuTable.FtrGtMediumDie = readTokValue<decltype(dst.SkuTable.FtrGtMediumDie)>(*tokSkuTable); 3005 } break; 3006 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_SMALL_DIE: { 3007 dst.SkuTable.FtrGtSmallDie = readTokValue<decltype(dst.SkuTable.FtrGtSmallDie)>(*tokSkuTable); 3008 } break; 3009 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT1: { 3010 dst.SkuTable.FtrGT1 = readTokValue<decltype(dst.SkuTable.FtrGT1)>(*tokSkuTable); 3011 } break; 3012 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT1_5: { 3013 dst.SkuTable.FtrGT1_5 = readTokValue<decltype(dst.SkuTable.FtrGT1_5)>(*tokSkuTable); 3014 } break; 3015 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT2: { 3016 dst.SkuTable.FtrGT2 = readTokValue<decltype(dst.SkuTable.FtrGT2)>(*tokSkuTable); 3017 } break; 3018 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT2_5: { 3019 dst.SkuTable.FtrGT2_5 = readTokValue<decltype(dst.SkuTable.FtrGT2_5)>(*tokSkuTable); 3020 } break; 3021 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT3: { 3022 dst.SkuTable.FtrGT3 = readTokValue<decltype(dst.SkuTable.FtrGT3)>(*tokSkuTable); 3023 } break; 3024 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT4: { 3025 dst.SkuTable.FtrGT4 = readTokValue<decltype(dst.SkuTable.FtrGT4)>(*tokSkuTable); 3026 } break; 3027 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_ULT: { 3028 dst.SkuTable.FtrULT = readTokValue<decltype(dst.SkuTable.FtrULT)>(*tokSkuTable); 3029 } break; 3030 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_IVBM0M1PLATFORM: { 3031 dst.SkuTable.FtrIVBM0M1Platform = readTokValue<decltype(dst.SkuTable.FtrIVBM0M1Platform)>(*tokSkuTable); 3032 } break; 3033 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CHANNEL_SWIZZLING_XORENABLED: { 3034 dst.SkuTable.FtrChannelSwizzlingXOREnabled = readTokValue<decltype(dst.SkuTable.FtrChannelSwizzlingXOREnabled)>(*tokSkuTable); 3035 } break; 3036 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTA: { 3037 dst.SkuTable.FtrGTA = readTokValue<decltype(dst.SkuTable.FtrGTA)>(*tokSkuTable); 3038 } break; 3039 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTC: { 3040 dst.SkuTable.FtrGTC = readTokValue<decltype(dst.SkuTable.FtrGTC)>(*tokSkuTable); 3041 } break; 3042 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTX: { 3043 dst.SkuTable.FtrGTX = readTokValue<decltype(dst.SkuTable.FtrGTX)>(*tokSkuTable); 3044 } break; 3045 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR5SLICE: { 3046 dst.SkuTable.Ftr5Slice = readTokValue<decltype(dst.SkuTable.Ftr5Slice)>(*tokSkuTable); 3047 } break; 3048 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_LCIA: { 3049 dst.SkuTable.FtrLCIA = readTokValue<decltype(dst.SkuTable.FtrLCIA)>(*tokSkuTable); 3050 } break; 3051 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_RESOURCE_STREAMER: { 3052 dst.SkuTable.FtrResourceStreamer = readTokValue<decltype(dst.SkuTable.FtrResourceStreamer)>(*tokSkuTable); 3053 } break; 3054 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSRING: { 3055 dst.SkuTable.FtrCCSRing = readTokValue<decltype(dst.SkuTable.FtrCCSRing)>(*tokSkuTable); 3056 } break; 3057 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSNODE: { 3058 dst.SkuTable.FtrCCSNode = readTokValue<decltype(dst.SkuTable.FtrCCSNode)>(*tokSkuTable); 3059 } break; 3060 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSMULTI_INSTANCE: { 3061 dst.SkuTable.FtrCCSMultiInstance = readTokValue<decltype(dst.SkuTable.FtrCCSMultiInstance)>(*tokSkuTable); 3062 } break; 3063 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_DISPLAY_DISABLED: { 3064 dst.SkuTable.FtrDisplayDisabled = readTokValue<decltype(dst.SkuTable.FtrDisplayDisabled)>(*tokSkuTable); 3065 } break; 3066 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_SGTPVSKUSTRAP_PRESENT: { 3067 dst.SkuTable.FtrSGTPVSKUStrapPresent = readTokValue<decltype(dst.SkuTable.FtrSGTPVSKUStrapPresent)>(*tokSkuTable); 3068 } break; 3069 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21584__FTR_POOLED_EU_ENABLED: { 3070 dst.SkuTable.FtrPooledEuEnabled = readTokValue<decltype(dst.SkuTable.FtrPooledEuEnabled)>(*tokSkuTable); 3071 } break; 3072 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_MID_BATCH_PREEMPT: { 3073 dst.SkuTable.FtrGpGpuMidBatchPreempt = readTokValue<decltype(dst.SkuTable.FtrGpGpuMidBatchPreempt)>(*tokSkuTable); 3074 } break; 3075 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_THREAD_GROUP_LEVEL_PREEMPT: { 3076 dst.SkuTable.FtrGpGpuThreadGroupLevelPreempt = readTokValue<decltype(dst.SkuTable.FtrGpGpuThreadGroupLevelPreempt)>(*tokSkuTable); 3077 } break; 3078 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_MID_THREAD_LEVEL_PREEMPT: { 3079 dst.SkuTable.FtrGpGpuMidThreadLevelPreempt = readTokValue<decltype(dst.SkuTable.FtrGpGpuMidThreadLevelPreempt)>(*tokSkuTable); 3080 } break; 3081 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR3D_MID_BATCH_PREEMPT: { 3082 dst.SkuTable.Ftr3dMidBatchPreempt = readTokValue<decltype(dst.SkuTable.Ftr3dMidBatchPreempt)>(*tokSkuTable); 3083 } break; 3084 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR3D_OBJECT_LEVEL_PREEMPT: { 3085 dst.SkuTable.Ftr3dObjectLevelPreempt = readTokValue<decltype(dst.SkuTable.Ftr3dObjectLevelPreempt)>(*tokSkuTable); 3086 } break; 3087 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PER_CTXT_PREEMPTION_GRANULARITY_CONTROL: { 3088 dst.SkuTable.FtrPerCtxtPreemptionGranularityControl = readTokValue<decltype(dst.SkuTable.FtrPerCtxtPreemptionGranularityControl)>(*tokSkuTable); 3089 } break; 3090 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PPGTT: { 3091 dst.SkuTable.FtrPPGTT = readTokValue<decltype(dst.SkuTable.FtrPPGTT)>(*tokSkuTable); 3092 } break; 3093 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_IA32E_GFX_PTES: { 3094 dst.SkuTable.FtrIA32eGfxPTEs = readTokValue<decltype(dst.SkuTable.FtrIA32eGfxPTEs)>(*tokSkuTable); 3095 } break; 3096 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_MEM_TYPE_MOCS_DEFER_PAT: { 3097 dst.SkuTable.FtrMemTypeMocsDeferPAT = readTokValue<decltype(dst.SkuTable.FtrMemTypeMocsDeferPAT)>(*tokSkuTable); 3098 } break; 3099 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PML4SUPPORT: { 3100 dst.SkuTable.FtrPml4Support = readTokValue<decltype(dst.SkuTable.FtrPml4Support)>(*tokSkuTable); 3101 } break; 3102 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_SVM: { 3103 dst.SkuTable.FtrSVM = readTokValue<decltype(dst.SkuTable.FtrSVM)>(*tokSkuTable); 3104 } break; 3105 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TILE_MAPPED_RESOURCE: { 3106 dst.SkuTable.FtrTileMappedResource = readTokValue<decltype(dst.SkuTable.FtrTileMappedResource)>(*tokSkuTable); 3107 } break; 3108 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TRANSLATION_TABLE: { 3109 dst.SkuTable.FtrTranslationTable = readTokValue<decltype(dst.SkuTable.FtrTranslationTable)>(*tokSkuTable); 3110 } break; 3111 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_USER_MODE_TRANSLATION_TABLE: { 3112 dst.SkuTable.FtrUserModeTranslationTable = readTokValue<decltype(dst.SkuTable.FtrUserModeTranslationTable)>(*tokSkuTable); 3113 } break; 3114 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_NULL_PAGES: { 3115 dst.SkuTable.FtrNullPages = readTokValue<decltype(dst.SkuTable.FtrNullPages)>(*tokSkuTable); 3116 } break; 3117 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_L3IACOHERENCY: { 3118 dst.SkuTable.FtrL3IACoherency = readTokValue<decltype(dst.SkuTable.FtrL3IACoherency)>(*tokSkuTable); 3119 } break; 3120 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_EDRAM: { 3121 dst.SkuTable.FtrEDram = readTokValue<decltype(dst.SkuTable.FtrEDram)>(*tokSkuTable); 3122 } break; 3123 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LLCBYPASS: { 3124 dst.SkuTable.FtrLLCBypass = readTokValue<decltype(dst.SkuTable.FtrLLCBypass)>(*tokSkuTable); 3125 } break; 3126 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CRYSTALWELL: { 3127 dst.SkuTable.FtrCrystalwell = readTokValue<decltype(dst.SkuTable.FtrCrystalwell)>(*tokSkuTable); 3128 } break; 3129 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CENTRAL_CACHE_POLICY: { 3130 dst.SkuTable.FtrCentralCachePolicy = readTokValue<decltype(dst.SkuTable.FtrCentralCachePolicy)>(*tokSkuTable); 3131 } break; 3132 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_IO_MMU_PAGE_FAULTING: { 3133 dst.SkuTable.FtrIoMmuPageFaulting = readTokValue<decltype(dst.SkuTable.FtrIoMmuPageFaulting)>(*tokSkuTable); 3134 } break; 3135 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2GPU_MMU: { 3136 dst.SkuTable.FtrWddm2GpuMmu = readTokValue<decltype(dst.SkuTable.FtrWddm2GpuMmu)>(*tokSkuTable); 3137 } break; 3138 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2SVM: { 3139 dst.SkuTable.FtrWddm2Svm = readTokValue<decltype(dst.SkuTable.FtrWddm2Svm)>(*tokSkuTable); 3140 } break; 3141 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_STANDARD_MIP_TAIL_FORMAT: { 3142 dst.SkuTable.FtrStandardMipTailFormat = readTokValue<decltype(dst.SkuTable.FtrStandardMipTailFormat)>(*tokSkuTable); 3143 } break; 3144 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2_1_64KB_PAGES: { 3145 dst.SkuTable.FtrWddm2_1_64kbPages = readTokValue<decltype(dst.SkuTable.FtrWddm2_1_64kbPages)>(*tokSkuTable); 3146 } break; 3147 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GTT_CACHE_INVALIDATION: { 3148 dst.SkuTable.FtrGttCacheInvalidation = readTokValue<decltype(dst.SkuTable.FtrGttCacheInvalidation)>(*tokSkuTable); 3149 } break; 3150 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_E2ECOMPRESSION: { 3151 dst.SkuTable.FtrE2ECompression = readTokValue<decltype(dst.SkuTable.FtrE2ECompression)>(*tokSkuTable); 3152 } break; 3153 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LINEAR_CCS: { 3154 dst.SkuTable.FtrLinearCCS = readTokValue<decltype(dst.SkuTable.FtrLinearCCS)>(*tokSkuTable); 3155 } break; 3156 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LOCAL_MEMORY: { 3157 dst.SkuTable.FtrLocalMemory = readTokValue<decltype(dst.SkuTable.FtrLocalMemory)>(*tokSkuTable); 3158 } break; 3159 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PPGTT64KBWALK_OPTIMIZATION: { 3160 dst.SkuTable.FtrPpgtt64KBWalkOptimization = readTokValue<decltype(dst.SkuTable.FtrPpgtt64KBWalkOptimization)>(*tokSkuTable); 3161 } break; 3162 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TILE_Y: { 3163 dst.SkuTable.FtrTileY = readTokValue<decltype(dst.SkuTable.FtrTileY)>(*tokSkuTable); 3164 } break; 3165 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_FLAT_PHYS_CCS: { 3166 dst.SkuTable.FtrFlatPhysCCS = readTokValue<decltype(dst.SkuTable.FtrFlatPhysCCS)>(*tokSkuTable); 3167 } break; 3168 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_MULTI_TILE_ARCH: { 3169 dst.SkuTable.FtrMultiTileArch = readTokValue<decltype(dst.SkuTable.FtrMultiTileArch)>(*tokSkuTable); 3170 } break; 3171 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LOCAL_MEMORY_ALLOWS4KB: { 3172 dst.SkuTable.FtrLocalMemoryAllows4KB = readTokValue<decltype(dst.SkuTable.FtrLocalMemoryAllows4KB)>(*tokSkuTable); 3173 } break; 3174 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_DISPLAY_XTILING: { 3175 dst.SkuTable.FtrDisplayXTiling = readTokValue<decltype(dst.SkuTable.FtrDisplayXTiling)>(*tokSkuTable); 3176 } break; 3177 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CAMERA_CAPTURE_CACHING: { 3178 dst.SkuTable.FtrCameraCaptureCaching = readTokValue<decltype(dst.SkuTable.FtrCameraCaptureCaching)>(*tokSkuTable); 3179 } break; 3180 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_KMD_DAF: { 3181 dst.SkuTable.FtrKmdDaf = readTokValue<decltype(dst.SkuTable.FtrKmdDaf)>(*tokSkuTable); 3182 } break; 3183 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_FRAME_BUFFER_LLC: { 3184 dst.SkuTable.FtrFrameBufferLLC = readTokValue<decltype(dst.SkuTable.FtrFrameBufferLLC)>(*tokSkuTable); 3185 } break; 3186 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_DRIVER_FLR: { 3187 dst.SkuTable.FtrDriverFLR = readTokValue<decltype(dst.SkuTable.FtrDriverFLR)>(*tokSkuTable); 3188 } break; 3189 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC_LDR2D: { 3190 dst.SkuTable.FtrAstcLdr2D = readTokValue<decltype(dst.SkuTable.FtrAstcLdr2D)>(*tokSkuTable); 3191 } break; 3192 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC_HDR2D: { 3193 dst.SkuTable.FtrAstcHdr2D = readTokValue<decltype(dst.SkuTable.FtrAstcHdr2D)>(*tokSkuTable); 3194 } break; 3195 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC3D: { 3196 dst.SkuTable.FtrAstc3D = readTokValue<decltype(dst.SkuTable.FtrAstc3D)>(*tokSkuTable); 3197 } break; 3198 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC: { 3199 dst.SkuTable.FtrFbc = readTokValue<decltype(dst.SkuTable.FtrFbc)>(*tokSkuTable); 3200 } break; 3201 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC2ADDRESS_TRANSLATION: { 3202 dst.SkuTable.FtrFbc2AddressTranslation = readTokValue<decltype(dst.SkuTable.FtrFbc2AddressTranslation)>(*tokSkuTable); 3203 } break; 3204 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC_BLITTER_TRACKING: { 3205 dst.SkuTable.FtrFbcBlitterTracking = readTokValue<decltype(dst.SkuTable.FtrFbcBlitterTracking)>(*tokSkuTable); 3206 } break; 3207 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC_CPU_TRACKING: { 3208 dst.SkuTable.FtrFbcCpuTracking = readTokValue<decltype(dst.SkuTable.FtrFbcCpuTracking)>(*tokSkuTable); 3209 } break; 3210 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_VEBOX: { 3211 dst.SkuTable.FtrVEBOX = readTokValue<decltype(dst.SkuTable.FtrVEBOX)>(*tokSkuTable); 3212 } break; 3213 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS54736__FTR_REND_COMP: { 3214 dst.SkuTable.FtrRendComp = readTokValue<decltype(dst.SkuTable.FtrRendComp)>(*tokSkuTable); 3215 } break; 3216 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS54736__FTR_DISPLAY_YTILING: { 3217 dst.SkuTable.FtrDisplayYTiling = readTokValue<decltype(dst.SkuTable.FtrDisplayYTiling)>(*tokSkuTable); 3218 } break; 3219 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_S3D: { 3220 dst.SkuTable.FtrS3D = readTokValue<decltype(dst.SkuTable.FtrS3D)>(*tokSkuTable); 3221 } break; 3222 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_DISPLAY_ENGINE_S3D: { 3223 dst.SkuTable.FtrDisplayEngineS3d = readTokValue<decltype(dst.SkuTable.FtrDisplayEngineS3d)>(*tokSkuTable); 3224 } break; 3225 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_SINGLE_VEBOX_SLICE: { 3226 dst.SkuTable.FtrSingleVeboxSlice = readTokValue<decltype(dst.SkuTable.FtrSingleVeboxSlice)>(*tokSkuTable); 3227 } break; 3228 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_SIMULATION_MODE: { 3229 dst.SkuTable.FtrSimulationMode = readTokValue<decltype(dst.SkuTable.FtrSimulationMode)>(*tokSkuTable); 3230 } break; 3231 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS88095__FTR_ENABLE_GU_C: { 3232 dst.SkuTable.FtrEnableGuC = readTokValue<decltype(dst.SkuTable.FtrEnableGuC)>(*tokSkuTable); 3233 } break; 3234 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS89755__FTR_VGT: { 3235 dst.SkuTable.FtrVgt = readTokValue<decltype(dst.SkuTable.FtrVgt)>(*tokSkuTable); 3236 } break; 3237 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS91822__FTR_ASSIGNED_GPU_TILE: { 3238 dst.SkuTable.FtrAssignedGpuTile = readTokValue<decltype(dst.SkuTable.FtrAssignedGpuTile)>(*tokSkuTable); 3239 } break; 3240 }; 3241 tokSkuTable = tokSkuTable + 1 + tokSkuTable->valueDwordCount; 3242 } else { 3243 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSkuTable); 3244 if (tokSkuTable->flags.flag3IsMandatory) { 3245 return false; 3246 } 3247 tokSkuTable = tokSkuTable + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 3248 } 3249 } 3250 WCH_ASSERT(tokSkuTable == tokSkuTableEnd); 3251 } break; 3252 case TOK_FS_ADAPTER_INFO__WA_TABLE: { 3253 const TokenHeader *tokWaTable = varLen->getValue<TokenHeader>(); 3254 const TokenHeader *tokWaTableEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 3255 while (tokWaTable < tokWaTableEnd) { 3256 if (false == tokWaTable->flags.flag4IsVariableLength) { 3257 switch (tokWaTable->id) { 3258 default: 3259 if (tokWaTable->flags.flag3IsMandatory) { 3260 return false; 3261 } 3262 break; 3263 case TOK_FBD_WA_TABLE__WA_DO_NOT_USE_MIREPORT_PERF_COUNT: { 3264 dst.WaTable.WaDoNotUseMIReportPerfCount = readTokValue<decltype(dst.WaTable.WaDoNotUseMIReportPerfCount)>(*tokWaTable); 3265 } break; 3266 case TOK_FBD_WA_TABLE__WA_ALIGN_INDEX_BUFFER: { 3267 dst.WaTable.WaAlignIndexBuffer = readTokValue<decltype(dst.WaTable.WaAlignIndexBuffer)>(*tokWaTable); 3268 } break; 3269 case TOK_FBD_WA_TABLE__WA_SEND_MIFLUSHBEFORE_VFE: { 3270 dst.WaTable.WaSendMIFLUSHBeforeVFE = readTokValue<decltype(dst.WaTable.WaSendMIFLUSHBeforeVFE)>(*tokWaTable); 3271 } break; 3272 case TOK_FBD_WA_TABLE__WA_DISABLE_PER_CTXT_PREEMPTION_GRANULARITY_CONTROL: { 3273 dst.WaTable.WaDisablePerCtxtPreemptionGranularityControl = readTokValue<decltype(dst.WaTable.WaDisablePerCtxtPreemptionGranularityControl)>(*tokWaTable); 3274 } break; 3275 case TOK_FBD_WA_TABLE__WA_ENABLE_PREEMPTION_GRANULARITY_CONTROL_BY_UMD: { 3276 dst.WaTable.WaEnablePreemptionGranularityControlByUMD = readTokValue<decltype(dst.WaTable.WaEnablePreemptionGranularityControlByUMD)>(*tokWaTable); 3277 } break; 3278 case TOK_FBD_WA_TABLE__WA_DISABLE_LSQCROPERFFOR_OCL: { 3279 dst.WaTable.WaDisableLSQCROPERFforOCL = readTokValue<decltype(dst.WaTable.WaDisableLSQCROPERFforOCL)>(*tokWaTable); 3280 } break; 3281 case TOK_FBD_WA_TABLE__WA_VALIGN2FOR96BPP_FORMATS: { 3282 dst.WaTable.WaValign2For96bppFormats = readTokValue<decltype(dst.WaTable.WaValign2For96bppFormats)>(*tokWaTable); 3283 } break; 3284 case TOK_FBD_WA_TABLE__WA_VALIGN2FOR_R8G8B8UINTFORMAT: { 3285 dst.WaTable.WaValign2ForR8G8B8UINTFormat = readTokValue<decltype(dst.WaTable.WaValign2ForR8G8B8UINTFormat)>(*tokWaTable); 3286 } break; 3287 case TOK_FBD_WA_TABLE__WA_REPORT_PERF_COUNT_USE_GLOBAL_CONTEXT_ID: { 3288 dst.WaTable.WaReportPerfCountUseGlobalContextID = readTokValue<decltype(dst.WaTable.WaReportPerfCountUseGlobalContextID)>(*tokWaTable); 3289 } break; 3290 case TOK_FBD_WA_TABLE__WA_FORCE_PC_BB_FULL_CFG_RESTORE: { 3291 dst.WaTable.WaForcePcBbFullCfgRestore = readTokValue<decltype(dst.WaTable.WaForcePcBbFullCfgRestore)>(*tokWaTable); 3292 } break; 3293 case TOK_FBD_WA_TABLE__WA_CSRUNCACHABLE: { 3294 dst.WaTable.WaCSRUncachable = readTokValue<decltype(dst.WaTable.WaCSRUncachable)>(*tokWaTable); 3295 } break; 3296 case TOK_FBD_WA_TABLE__WA_DISABLE_FUSED_THREAD_SCHEDULING: { 3297 dst.WaTable.WaDisableFusedThreadScheduling = readTokValue<decltype(dst.WaTable.WaDisableFusedThreadScheduling)>(*tokWaTable); 3298 } break; 3299 case TOK_FBD_WA_TABLE__WA_MODIFY_VFESTATE_AFTER_GPGPUPREEMPTION: { 3300 dst.WaTable.WaModifyVFEStateAfterGPGPUPreemption = readTokValue<decltype(dst.WaTable.WaModifyVFEStateAfterGPGPUPreemption)>(*tokWaTable); 3301 } break; 3302 case TOK_FBD_WA_TABLE__WA_CURSOR16K: { 3303 dst.WaTable.WaCursor16K = readTokValue<decltype(dst.WaTable.WaCursor16K)>(*tokWaTable); 3304 } break; 3305 case TOK_FBD_WA_TABLE__WA8K_ALIGNFOR_ASYNC_FLIP: { 3306 dst.WaTable.Wa8kAlignforAsyncFlip = readTokValue<decltype(dst.WaTable.Wa8kAlignforAsyncFlip)>(*tokWaTable); 3307 } break; 3308 case TOK_FBD_WA_TABLE__WA29BIT_DISPLAY_ADDR_LIMIT: { 3309 dst.WaTable.Wa29BitDisplayAddrLimit = readTokValue<decltype(dst.WaTable.Wa29BitDisplayAddrLimit)>(*tokWaTable); 3310 } break; 3311 case TOK_FBD_WA_TABLE__WA_ALIGN_CONTEXT_IMAGE: { 3312 dst.WaTable.WaAlignContextImage = readTokValue<decltype(dst.WaTable.WaAlignContextImage)>(*tokWaTable); 3313 } break; 3314 case TOK_FBD_WA_TABLE__WA_FORCE_GLOBAL_GTT: { 3315 dst.WaTable.WaForceGlobalGTT = readTokValue<decltype(dst.WaTable.WaForceGlobalGTT)>(*tokWaTable); 3316 } break; 3317 case TOK_FBD_WA_TABLE__WA_REPORT_PERF_COUNT_FORCE_GLOBAL_GTT: { 3318 dst.WaTable.WaReportPerfCountForceGlobalGTT = readTokValue<decltype(dst.WaTable.WaReportPerfCountForceGlobalGTT)>(*tokWaTable); 3319 } break; 3320 case TOK_FBD_WA_TABLE__WA_OA_ADDRESS_TRANSLATION: { 3321 dst.WaTable.WaOaAddressTranslation = readTokValue<decltype(dst.WaTable.WaOaAddressTranslation)>(*tokWaTable); 3322 } break; 3323 case TOK_FBD_WA_TABLE__WA2ROW_VERTICAL_ALIGNMENT: { 3324 dst.WaTable.Wa2RowVerticalAlignment = readTokValue<decltype(dst.WaTable.Wa2RowVerticalAlignment)>(*tokWaTable); 3325 } break; 3326 case TOK_FBD_WA_TABLE__WA_PPGTT_ALIAS_GLOBAL_GTT_SPACE: { 3327 dst.WaTable.WaPpgttAliasGlobalGttSpace = readTokValue<decltype(dst.WaTable.WaPpgttAliasGlobalGttSpace)>(*tokWaTable); 3328 } break; 3329 case TOK_FBD_WA_TABLE__WA_CLEAR_FENCE_REGISTERS_AT_DRIVER_INIT: { 3330 dst.WaTable.WaClearFenceRegistersAtDriverInit = readTokValue<decltype(dst.WaTable.WaClearFenceRegistersAtDriverInit)>(*tokWaTable); 3331 } break; 3332 case TOK_FBD_WA_TABLE__WA_RESTRICT_PITCH128KB: { 3333 dst.WaTable.WaRestrictPitch128KB = readTokValue<decltype(dst.WaTable.WaRestrictPitch128KB)>(*tokWaTable); 3334 } break; 3335 case TOK_FBD_WA_TABLE__WA_AVOID_LLC: { 3336 dst.WaTable.WaAvoidLLC = readTokValue<decltype(dst.WaTable.WaAvoidLLC)>(*tokWaTable); 3337 } break; 3338 case TOK_FBD_WA_TABLE__WA_AVOID_L3: { 3339 dst.WaTable.WaAvoidL3 = readTokValue<decltype(dst.WaTable.WaAvoidL3)>(*tokWaTable); 3340 } break; 3341 case TOK_FBD_WA_TABLE__WA16TILE_FENCES_ONLY: { 3342 dst.WaTable.Wa16TileFencesOnly = readTokValue<decltype(dst.WaTable.Wa16TileFencesOnly)>(*tokWaTable); 3343 } break; 3344 case TOK_FBD_WA_TABLE__WA16MBOABUFFER_ALIGNMENT: { 3345 dst.WaTable.Wa16MBOABufferAlignment = readTokValue<decltype(dst.WaTable.Wa16MBOABufferAlignment)>(*tokWaTable); 3346 } break; 3347 case TOK_FBD_WA_TABLE__WA_TRANSLATION_TABLE_UNAVAILABLE: { 3348 dst.WaTable.WaTranslationTableUnavailable = readTokValue<decltype(dst.WaTable.WaTranslationTableUnavailable)>(*tokWaTable); 3349 } break; 3350 case TOK_FBD_WA_TABLE__WA_NO_MINIMIZED_TRIVIAL_SURFACE_PADDING: { 3351 dst.WaTable.WaNoMinimizedTrivialSurfacePadding = readTokValue<decltype(dst.WaTable.WaNoMinimizedTrivialSurfacePadding)>(*tokWaTable); 3352 } break; 3353 case TOK_FBD_WA_TABLE__WA_NO_BUFFER_SAMPLER_PADDING: { 3354 dst.WaTable.WaNoBufferSamplerPadding = readTokValue<decltype(dst.WaTable.WaNoBufferSamplerPadding)>(*tokWaTable); 3355 } break; 3356 case TOK_FBD_WA_TABLE__WA_SURFACE_STATE_PLANAR_YOFFSET_ALIGN_BY2: { 3357 dst.WaTable.WaSurfaceStatePlanarYOffsetAlignBy2 = readTokValue<decltype(dst.WaTable.WaSurfaceStatePlanarYOffsetAlignBy2)>(*tokWaTable); 3358 } break; 3359 case TOK_FBD_WA_TABLE__WA_GTT_CACHING_OFF_BY_DEFAULT: { 3360 dst.WaTable.WaGttCachingOffByDefault = readTokValue<decltype(dst.WaTable.WaGttCachingOffByDefault)>(*tokWaTable); 3361 } break; 3362 case TOK_FBD_WA_TABLE__WA_TOUCH_ALL_SVM_MEMORY: { 3363 dst.WaTable.WaTouchAllSvmMemory = readTokValue<decltype(dst.WaTable.WaTouchAllSvmMemory)>(*tokWaTable); 3364 } break; 3365 case TOK_FBD_WA_TABLE__WA_IOBADDRESS_MUST_BE_VALID_IN_HW_CONTEXT: { 3366 dst.WaTable.WaIOBAddressMustBeValidInHwContext = readTokValue<decltype(dst.WaTable.WaIOBAddressMustBeValidInHwContext)>(*tokWaTable); 3367 } break; 3368 case TOK_FBD_WA_TABLE__WA_FLUSH_TLB_AFTER_CPU_GGTT_WRITES: { 3369 dst.WaTable.WaFlushTlbAfterCpuGgttWrites = readTokValue<decltype(dst.WaTable.WaFlushTlbAfterCpuGgttWrites)>(*tokWaTable); 3370 } break; 3371 case TOK_FBD_WA_TABLE__WA_MSAA8X_TILE_YDEPTH_PITCH_ALIGNMENT: { 3372 dst.WaTable.WaMsaa8xTileYDepthPitchAlignment = readTokValue<decltype(dst.WaTable.WaMsaa8xTileYDepthPitchAlignment)>(*tokWaTable); 3373 } break; 3374 case TOK_FBD_WA_TABLE__WA_DISABLE_NULL_PAGE_AS_DUMMY: { 3375 dst.WaTable.WaDisableNullPageAsDummy = readTokValue<decltype(dst.WaTable.WaDisableNullPageAsDummy)>(*tokWaTable); 3376 } break; 3377 case TOK_FBD_WA_TABLE__WA_USE_VALIGN16ON_TILE_XYBPP816: { 3378 dst.WaTable.WaUseVAlign16OnTileXYBpp816 = readTokValue<decltype(dst.WaTable.WaUseVAlign16OnTileXYBpp816)>(*tokWaTable); 3379 } break; 3380 case TOK_FBD_WA_TABLE__WA_GTT_PAT0: { 3381 dst.WaTable.WaGttPat0 = readTokValue<decltype(dst.WaTable.WaGttPat0)>(*tokWaTable); 3382 } break; 3383 case TOK_FBD_WA_TABLE__WA_GTT_PAT0WB: { 3384 dst.WaTable.WaGttPat0WB = readTokValue<decltype(dst.WaTable.WaGttPat0WB)>(*tokWaTable); 3385 } break; 3386 case TOK_FBD_WA_TABLE__WA_MEM_TYPE_IS_MAX_OF_PAT_AND_MOCS: { 3387 dst.WaTable.WaMemTypeIsMaxOfPatAndMocs = readTokValue<decltype(dst.WaTable.WaMemTypeIsMaxOfPatAndMocs)>(*tokWaTable); 3388 } break; 3389 case TOK_FBD_WA_TABLE__WA_GTT_PAT0GTT_WB_OVER_OS_IOMMU_ELLC_ONLY: { 3390 dst.WaTable.WaGttPat0GttWbOverOsIommuEllcOnly = readTokValue<decltype(dst.WaTable.WaGttPat0GttWbOverOsIommuEllcOnly)>(*tokWaTable); 3391 } break; 3392 case TOK_FBD_WA_TABLE__WA_ADD_DUMMY_PAGE_FOR_DISPLAY_PREFETCH: { 3393 dst.WaTable.WaAddDummyPageForDisplayPrefetch = readTokValue<decltype(dst.WaTable.WaAddDummyPageForDisplayPrefetch)>(*tokWaTable); 3394 } break; 3395 case TOK_FBD_WA_TABLE__WA_DEFAULT_TILE4: { 3396 dst.WaTable.WaDefaultTile4 = readTokValue<decltype(dst.WaTable.WaDefaultTile4)>(*tokWaTable); 3397 } break; 3398 case TOK_FBD_WA_TABLE__WA_LLCCACHING_UNSUPPORTED: { 3399 dst.WaTable.WaLLCCachingUnsupported = readTokValue<decltype(dst.WaTable.WaLLCCachingUnsupported)>(*tokWaTable); 3400 } break; 3401 case TOK_FBD_WA_TABLE__WA_DOUBLE_FAST_CLEAR_WIDTH_ALIGNMENT: { 3402 dst.WaTable.WaDoubleFastClearWidthAlignment = readTokValue<decltype(dst.WaTable.WaDoubleFastClearWidthAlignment)>(*tokWaTable); 3403 } break; 3404 case TOK_FBD_WA_TABLE__WA_COMPRESSED_RESOURCE_REQUIRES_CONST_VA21: { 3405 dst.WaTable.WaCompressedResourceRequiresConstVA21 = readTokValue<decltype(dst.WaTable.WaCompressedResourceRequiresConstVA21)>(*tokWaTable); 3406 } break; 3407 case TOK_FBD_WA_TABLE__WA_DISREGARD_PLATFORM_CHECKS: { 3408 dst.WaTable.WaDisregardPlatformChecks = readTokValue<decltype(dst.WaTable.WaDisregardPlatformChecks)>(*tokWaTable); 3409 } break; 3410 case TOK_FBD_WA_TABLE__WA_LOSSLESS_COMPRESSION_SURFACE_STRIDE: { 3411 dst.WaTable.WaLosslessCompressionSurfaceStride = readTokValue<decltype(dst.WaTable.WaLosslessCompressionSurfaceStride)>(*tokWaTable); 3412 } break; 3413 case TOK_FBD_WA_TABLE__WA_FBC_LINEAR_SURFACE_STRIDE: { 3414 dst.WaTable.WaFbcLinearSurfaceStride = readTokValue<decltype(dst.WaTable.WaFbcLinearSurfaceStride)>(*tokWaTable); 3415 } break; 3416 case TOK_FBD_WA_TABLE__WA4K_ALIGN_UVOFFSET_NV12LINEAR_SURFACE: { 3417 dst.WaTable.Wa4kAlignUVOffsetNV12LinearSurface = readTokValue<decltype(dst.WaTable.Wa4kAlignUVOffsetNV12LinearSurface)>(*tokWaTable); 3418 } break; 3419 case TOK_FBD_WA_TABLE__WA_ASTC_CORRUPTION_FOR_ODD_COMPRESSED_BLOCK_SIZE_X: { 3420 dst.WaTable.WaAstcCorruptionForOddCompressedBlockSizeX = readTokValue<decltype(dst.WaTable.WaAstcCorruptionForOddCompressedBlockSizeX)>(*tokWaTable); 3421 } break; 3422 case TOK_FBD_WA_TABLE__WA_AUX_TABLE16KGRANULAR: { 3423 dst.WaTable.WaAuxTable16KGranular = readTokValue<decltype(dst.WaTable.WaAuxTable16KGranular)>(*tokWaTable); 3424 } break; 3425 case TOK_FBD_WA_TABLE__WA_ENCRYPTED_EDRAM_ONLY_PARTIALS: { 3426 dst.WaTable.WaEncryptedEdramOnlyPartials = readTokValue<decltype(dst.WaTable.WaEncryptedEdramOnlyPartials)>(*tokWaTable); 3427 } break; 3428 case TOK_FBD_WA_TABLE__WA_DISABLE_EDRAM_FOR_DISPLAY_RT: { 3429 dst.WaTable.WaDisableEdramForDisplayRT = readTokValue<decltype(dst.WaTable.WaDisableEdramForDisplayRT)>(*tokWaTable); 3430 } break; 3431 case TOK_FBD_WA_TABLE__WA_LIMIT128BMEDIA_COMPR: { 3432 dst.WaTable.WaLimit128BMediaCompr = readTokValue<decltype(dst.WaTable.WaLimit128BMediaCompr)>(*tokWaTable); 3433 } break; 3434 case TOK_FBD_WA_TABLE__WA_UNTYPED_BUFFER_COMPRESSION: { 3435 dst.WaTable.WaUntypedBufferCompression = readTokValue<decltype(dst.WaTable.WaUntypedBufferCompression)>(*tokWaTable); 3436 } break; 3437 case TOK_FBD_WA_TABLE__WA_SAMPLER_CACHE_FLUSH_BETWEEN_REDESCRIBED_SURFACE_READS: { 3438 dst.WaTable.WaSamplerCacheFlushBetweenRedescribedSurfaceReads = readTokValue<decltype(dst.WaTable.WaSamplerCacheFlushBetweenRedescribedSurfaceReads)>(*tokWaTable); 3439 } break; 3440 case TOK_FBD_WA_TABLE__WA_ALIGN_YUVRESOURCE_TO_LCU: { 3441 dst.WaTable.WaAlignYUVResourceToLCU = readTokValue<decltype(dst.WaTable.WaAlignYUVResourceToLCU)>(*tokWaTable); 3442 } break; 3443 case TOK_FBD_WA_TABLE__WA32BPP_TILE_Y2DCOLOR_NO_HALIGN4: { 3444 dst.WaTable.Wa32bppTileY2DColorNoHAlign4 = readTokValue<decltype(dst.WaTable.Wa32bppTileY2DColorNoHAlign4)>(*tokWaTable); 3445 } break; 3446 }; 3447 tokWaTable = tokWaTable + 1 + tokWaTable->valueDwordCount; 3448 } else { 3449 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokWaTable); 3450 if (tokWaTable->flags.flag3IsMandatory) { 3451 return false; 3452 } 3453 tokWaTable = tokWaTable + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 3454 } 3455 } 3456 WCH_ASSERT(tokWaTable == tokWaTableEnd); 3457 } break; 3458 case TOK_FS_ADAPTER_INFO__OUTPUT_FRAME_RATE: { 3459 const TokenHeader *tokOutputFrameRate = varLen->getValue<TokenHeader>(); 3460 const TokenHeader *tokOutputFrameRateEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 3461 while (tokOutputFrameRate < tokOutputFrameRateEnd) { 3462 if (false == tokOutputFrameRate->flags.flag4IsVariableLength) { 3463 switch (tokOutputFrameRate->id) { 3464 default: 3465 if (tokOutputFrameRate->flags.flag3IsMandatory) { 3466 return false; 3467 } 3468 break; 3469 case TOK_FBD_FRAME_RATE__UI_NUMERATOR: { 3470 dst.OutputFrameRate.uiNumerator = readTokValue<decltype(dst.OutputFrameRate.uiNumerator)>(*tokOutputFrameRate); 3471 } break; 3472 case TOK_FBD_FRAME_RATE__UI_DENOMINATOR: { 3473 dst.OutputFrameRate.uiDenominator = readTokValue<decltype(dst.OutputFrameRate.uiDenominator)>(*tokOutputFrameRate); 3474 } break; 3475 }; 3476 tokOutputFrameRate = tokOutputFrameRate + 1 + tokOutputFrameRate->valueDwordCount; 3477 } else { 3478 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokOutputFrameRate); 3479 if (tokOutputFrameRate->flags.flag3IsMandatory) { 3480 return false; 3481 } 3482 tokOutputFrameRate = tokOutputFrameRate + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 3483 } 3484 } 3485 WCH_ASSERT(tokOutputFrameRate == tokOutputFrameRateEnd); 3486 } break; 3487 case TOK_FS_ADAPTER_INFO__INPUT_FRAME_RATE: { 3488 const TokenHeader *tokInputFrameRate = varLen->getValue<TokenHeader>(); 3489 const TokenHeader *tokInputFrameRateEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 3490 while (tokInputFrameRate < tokInputFrameRateEnd) { 3491 if (false == tokInputFrameRate->flags.flag4IsVariableLength) { 3492 switch (tokInputFrameRate->id) { 3493 default: 3494 if (tokInputFrameRate->flags.flag3IsMandatory) { 3495 return false; 3496 } 3497 break; 3498 case TOK_FBD_FRAME_RATE__UI_NUMERATOR: { 3499 dst.InputFrameRate.uiNumerator = readTokValue<decltype(dst.InputFrameRate.uiNumerator)>(*tokInputFrameRate); 3500 } break; 3501 case TOK_FBD_FRAME_RATE__UI_DENOMINATOR: { 3502 dst.InputFrameRate.uiDenominator = readTokValue<decltype(dst.InputFrameRate.uiDenominator)>(*tokInputFrameRate); 3503 } break; 3504 }; 3505 tokInputFrameRate = tokInputFrameRate + 1 + tokInputFrameRate->valueDwordCount; 3506 } else { 3507 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInputFrameRate); 3508 if (tokInputFrameRate->flags.flag3IsMandatory) { 3509 return false; 3510 } 3511 tokInputFrameRate = tokInputFrameRate + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 3512 } 3513 } 3514 WCH_ASSERT(tokInputFrameRate == tokInputFrameRateEnd); 3515 } break; 3516 case TOK_FS_ADAPTER_INFO__CAPS: { 3517 const TokenHeader *tokCaps = varLen->getValue<TokenHeader>(); 3518 const TokenHeader *tokCapsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 3519 while (tokCaps < tokCapsEnd) { 3520 if (false == tokCaps->flags.flag4IsVariableLength) { 3521 switch (tokCaps->id) { 3522 default: 3523 if (tokCaps->flags.flag3IsMandatory) { 3524 return false; 3525 } 3526 break; 3527 case TOK_FBD_KMD_CAPS_INFO__GAMMA_RGB256X3X16: { 3528 dst.Caps.Gamma_Rgb256x3x16 = readTokValue<decltype(dst.Caps.Gamma_Rgb256x3x16)>(*tokCaps); 3529 } break; 3530 case TOK_FBD_KMD_CAPS_INFO__GDIACCELERATION: { 3531 dst.Caps.GDIAcceleration = readTokValue<decltype(dst.Caps.GDIAcceleration)>(*tokCaps); 3532 } break; 3533 case TOK_FBD_KMD_CAPS_INFO__OS_MANAGED_HW_CONTEXT: { 3534 dst.Caps.OsManagedHwContext = readTokValue<decltype(dst.Caps.OsManagedHwContext)>(*tokCaps); 3535 } break; 3536 case TOK_FBD_KMD_CAPS_INFO__GRAPHICS_PREEMPTION_GRANULARITY: { 3537 dst.Caps.GraphicsPreemptionGranularity = readTokValue<decltype(dst.Caps.GraphicsPreemptionGranularity)>(*tokCaps); 3538 } break; 3539 case TOK_FBD_KMD_CAPS_INFO__COMPUTE_PREEMPTION_GRANULARITY: { 3540 dst.Caps.ComputePreemptionGranularity = readTokValue<decltype(dst.Caps.ComputePreemptionGranularity)>(*tokCaps); 3541 } break; 3542 case TOK_FBD_KMD_CAPS_INFO__INSTRUMENTATION_IS_ENABLED: { 3543 dst.Caps.InstrumentationIsEnabled = readTokValue<decltype(dst.Caps.InstrumentationIsEnabled)>(*tokCaps); 3544 } break; 3545 case TOK_FBD_KMD_CAPS_INFO__DRIVER_STORE_ENABLED: { 3546 dst.Caps.DriverStoreEnabled = readTokValue<decltype(dst.Caps.DriverStoreEnabled)>(*tokCaps); 3547 } break; 3548 }; 3549 tokCaps = tokCaps + 1 + tokCaps->valueDwordCount; 3550 } else { 3551 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCaps); 3552 if (tokCaps->flags.flag3IsMandatory) { 3553 return false; 3554 } 3555 tokCaps = tokCaps + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 3556 } 3557 } 3558 WCH_ASSERT(tokCaps == tokCapsEnd); 3559 } break; 3560 case TOK_FS_ADAPTER_INFO__OVERLAY_CAPS: { 3561 const TokenHeader *tokOverlayCaps = varLen->getValue<TokenHeader>(); 3562 const TokenHeader *tokOverlayCapsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 3563 while (tokOverlayCaps < tokOverlayCapsEnd) { 3564 if (false == tokOverlayCaps->flags.flag4IsVariableLength) { 3565 switch (tokOverlayCaps->id) { 3566 default: 3567 if (tokOverlayCaps->flags.flag3IsMandatory) { 3568 return false; 3569 } 3570 break; 3571 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__CAPS_VALUE: { 3572 dst.OverlayCaps.CapsValue = readTokValue<decltype(dst.OverlayCaps.CapsValue)>(*tokOverlayCaps); 3573 } break; 3574 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__MAX_OVERLAY_DISPLAY_WIDTH: { 3575 dst.OverlayCaps.MaxOverlayDisplayWidth = readTokValue<decltype(dst.OverlayCaps.MaxOverlayDisplayWidth)>(*tokOverlayCaps); 3576 } break; 3577 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__MAX_OVERLAY_DISPLAY_HEIGHT: { 3578 dst.OverlayCaps.MaxOverlayDisplayHeight = readTokValue<decltype(dst.OverlayCaps.MaxOverlayDisplayHeight)>(*tokOverlayCaps); 3579 } break; 3580 case TOK_FBC_KMD_OVERLAY_CAPS_INFO__HWSCALER_EXISTS: { 3581 dst.OverlayCaps.HWScalerExists = readTokValue<decltype(dst.OverlayCaps.HWScalerExists)>(*tokOverlayCaps); 3582 } break; 3583 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__MAX_HWSCALER_STRIDE: { 3584 dst.OverlayCaps.MaxHWScalerStride = readTokValue<decltype(dst.OverlayCaps.MaxHWScalerStride)>(*tokOverlayCaps); 3585 } break; 3586 }; 3587 tokOverlayCaps = tokOverlayCaps + 1 + tokOverlayCaps->valueDwordCount; 3588 } else { 3589 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokOverlayCaps); 3590 switch (tokOverlayCaps->id) { 3591 default: 3592 if (tokOverlayCaps->flags.flag3IsMandatory) { 3593 return false; 3594 } 3595 break; 3596 case TOK_FS_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__CAPS: { 3597 const TokenHeader *tokCaps = varLen->getValue<TokenHeader>(); 3598 const TokenHeader *tokCapsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 3599 while (tokCaps < tokCapsEnd) { 3600 if (false == tokCaps->flags.flag4IsVariableLength) { 3601 switch (tokCaps->id) { 3602 default: 3603 if (tokCaps->flags.flag3IsMandatory) { 3604 return false; 3605 } 3606 break; 3607 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__FULL_RANGE_RGB: { 3608 dst.OverlayCaps.Caps.FullRangeRGB = readTokValue<decltype(dst.OverlayCaps.Caps.FullRangeRGB)>(*tokCaps); 3609 } break; 3610 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__LIMITED_RANGE_RGB: { 3611 dst.OverlayCaps.Caps.LimitedRangeRGB = readTokValue<decltype(dst.OverlayCaps.Caps.LimitedRangeRGB)>(*tokCaps); 3612 } break; 3613 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT601: { 3614 dst.OverlayCaps.Caps.YCbCr_BT601 = readTokValue<decltype(dst.OverlayCaps.Caps.YCbCr_BT601)>(*tokCaps); 3615 } break; 3616 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT709: { 3617 dst.OverlayCaps.Caps.YCbCr_BT709 = readTokValue<decltype(dst.OverlayCaps.Caps.YCbCr_BT709)>(*tokCaps); 3618 } break; 3619 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT601_XV_YCC: { 3620 dst.OverlayCaps.Caps.YCbCr_BT601_xvYCC = readTokValue<decltype(dst.OverlayCaps.Caps.YCbCr_BT601_xvYCC)>(*tokCaps); 3621 } break; 3622 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT709_XV_YCC: { 3623 dst.OverlayCaps.Caps.YCbCr_BT709_xvYCC = readTokValue<decltype(dst.OverlayCaps.Caps.YCbCr_BT709_xvYCC)>(*tokCaps); 3624 } break; 3625 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__STRETCH_X: { 3626 dst.OverlayCaps.Caps.StretchX = readTokValue<decltype(dst.OverlayCaps.Caps.StretchX)>(*tokCaps); 3627 } break; 3628 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__STRETCH_Y: { 3629 dst.OverlayCaps.Caps.StretchY = readTokValue<decltype(dst.OverlayCaps.Caps.StretchY)>(*tokCaps); 3630 } break; 3631 }; 3632 tokCaps = tokCaps + 1 + tokCaps->valueDwordCount; 3633 } else { 3634 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCaps); 3635 if (tokCaps->flags.flag3IsMandatory) { 3636 return false; 3637 } 3638 tokCaps = tokCaps + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 3639 } 3640 } 3641 WCH_ASSERT(tokCaps == tokCapsEnd); 3642 } break; 3643 case TOK_FS_KMD_OVERLAY_CAPS_INFO__OVOVERRIDE: { 3644 const TokenHeader *tokOVOverride = varLen->getValue<TokenHeader>(); 3645 const TokenHeader *tokOVOverrideEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 3646 while (tokOVOverride < tokOVOverrideEnd) { 3647 if (false == tokOVOverride->flags.flag4IsVariableLength) { 3648 switch (tokOVOverride->id) { 3649 default: 3650 if (tokOVOverride->flags.flag3IsMandatory) { 3651 return false; 3652 } 3653 break; 3654 case TOK_FBD_KMD_OVERLAY_OVERRIDE__OVERRIDE_OVERLAY_CAPS: { 3655 dst.OverlayCaps.OVOverride.OverrideOverlayCaps = readTokValue<decltype(dst.OverlayCaps.OVOverride.OverrideOverlayCaps)>(*tokOVOverride); 3656 } break; 3657 case TOK_FBD_KMD_OVERLAY_OVERRIDE__RGBOVERLAY: { 3658 dst.OverlayCaps.OVOverride.RGBOverlay = readTokValue<decltype(dst.OverlayCaps.OVOverride.RGBOverlay)>(*tokOVOverride); 3659 } break; 3660 case TOK_FBD_KMD_OVERLAY_OVERRIDE__YUY2OVERLAY: { 3661 dst.OverlayCaps.OVOverride.YUY2Overlay = readTokValue<decltype(dst.OverlayCaps.OVOverride.YUY2Overlay)>(*tokOVOverride); 3662 } break; 3663 }; 3664 tokOVOverride = tokOVOverride + 1 + tokOVOverride->valueDwordCount; 3665 } else { 3666 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokOVOverride); 3667 if (tokOVOverride->flags.flag3IsMandatory) { 3668 return false; 3669 } 3670 tokOVOverride = tokOVOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 3671 } 3672 } 3673 WCH_ASSERT(tokOVOverride == tokOVOverrideEnd); 3674 } break; 3675 }; 3676 tokOverlayCaps = tokOverlayCaps + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 3677 } 3678 } 3679 WCH_ASSERT(tokOverlayCaps == tokOverlayCapsEnd); 3680 } break; 3681 case TOK_FS_ADAPTER_INFO__SYSTEM_INFO: { 3682 const TokenHeader *tokSystemInfo = varLen->getValue<TokenHeader>(); 3683 const TokenHeader *tokSystemInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 3684 while (tokSystemInfo < tokSystemInfoEnd) { 3685 if (false == tokSystemInfo->flags.flag4IsVariableLength) { 3686 switch (tokSystemInfo->id) { 3687 default: 3688 if (tokSystemInfo->flags.flag3IsMandatory) { 3689 return false; 3690 } 3691 break; 3692 case TOK_FBD_GT_SYSTEM_INFO__EUCOUNT: { 3693 dst.SystemInfo.EUCount = readTokValue<decltype(dst.SystemInfo.EUCount)>(*tokSystemInfo); 3694 } break; 3695 case TOK_FBD_GT_SYSTEM_INFO__THREAD_COUNT: { 3696 dst.SystemInfo.ThreadCount = readTokValue<decltype(dst.SystemInfo.ThreadCount)>(*tokSystemInfo); 3697 } break; 3698 case TOK_FBD_GT_SYSTEM_INFO__SLICE_COUNT: { 3699 dst.SystemInfo.SliceCount = readTokValue<decltype(dst.SystemInfo.SliceCount)>(*tokSystemInfo); 3700 } break; 3701 case TOK_FBD_GT_SYSTEM_INFO__SUB_SLICE_COUNT: { 3702 dst.SystemInfo.SubSliceCount = readTokValue<decltype(dst.SystemInfo.SubSliceCount)>(*tokSystemInfo); 3703 } break; 3704 case TOK_FBD_GT_SYSTEM_INFO__DUAL_SUB_SLICE_COUNT: { 3705 dst.SystemInfo.DualSubSliceCount = readTokValue<decltype(dst.SystemInfo.DualSubSliceCount)>(*tokSystemInfo); 3706 } break; 3707 case TOK_FBQ_GT_SYSTEM_INFO__L3CACHE_SIZE_IN_KB: { 3708 dst.SystemInfo.L3CacheSizeInKb = readTokValue<decltype(dst.SystemInfo.L3CacheSizeInKb)>(*tokSystemInfo); 3709 } break; 3710 case TOK_FBQ_GT_SYSTEM_INFO__LLCCACHE_SIZE_IN_KB: { 3711 dst.SystemInfo.LLCCacheSizeInKb = readTokValue<decltype(dst.SystemInfo.LLCCacheSizeInKb)>(*tokSystemInfo); 3712 } break; 3713 case TOK_FBQ_GT_SYSTEM_INFO__EDRAM_SIZE_IN_KB: { 3714 dst.SystemInfo.EdramSizeInKb = readTokValue<decltype(dst.SystemInfo.EdramSizeInKb)>(*tokSystemInfo); 3715 } break; 3716 case TOK_FBD_GT_SYSTEM_INFO__L3BANK_COUNT: { 3717 dst.SystemInfo.L3BankCount = readTokValue<decltype(dst.SystemInfo.L3BankCount)>(*tokSystemInfo); 3718 } break; 3719 case TOK_FBD_GT_SYSTEM_INFO__MAX_FILL_RATE: { 3720 dst.SystemInfo.MaxFillRate = readTokValue<decltype(dst.SystemInfo.MaxFillRate)>(*tokSystemInfo); 3721 } break; 3722 case TOK_FBD_GT_SYSTEM_INFO__EU_COUNT_PER_POOL_MAX: { 3723 dst.SystemInfo.EuCountPerPoolMax = readTokValue<decltype(dst.SystemInfo.EuCountPerPoolMax)>(*tokSystemInfo); 3724 } break; 3725 case TOK_FBD_GT_SYSTEM_INFO__EU_COUNT_PER_POOL_MIN: { 3726 dst.SystemInfo.EuCountPerPoolMin = readTokValue<decltype(dst.SystemInfo.EuCountPerPoolMin)>(*tokSystemInfo); 3727 } break; 3728 case TOK_FBD_GT_SYSTEM_INFO__TOTAL_VS_THREADS: { 3729 dst.SystemInfo.TotalVsThreads = readTokValue<decltype(dst.SystemInfo.TotalVsThreads)>(*tokSystemInfo); 3730 } break; 3731 case TOK_FBD_GT_SYSTEM_INFO__TOTAL_HS_THREADS: { 3732 dst.SystemInfo.TotalHsThreads = readTokValue<decltype(dst.SystemInfo.TotalHsThreads)>(*tokSystemInfo); 3733 } break; 3734 case TOK_FBD_GT_SYSTEM_INFO__TOTAL_DS_THREADS: { 3735 dst.SystemInfo.TotalDsThreads = readTokValue<decltype(dst.SystemInfo.TotalDsThreads)>(*tokSystemInfo); 3736 } break; 3737 case TOK_FBD_GT_SYSTEM_INFO__TOTAL_GS_THREADS: { 3738 dst.SystemInfo.TotalGsThreads = readTokValue<decltype(dst.SystemInfo.TotalGsThreads)>(*tokSystemInfo); 3739 } break; 3740 case TOK_FBD_GT_SYSTEM_INFO__TOTAL_PS_THREADS_WINDOWER_RANGE: { 3741 dst.SystemInfo.TotalPsThreadsWindowerRange = readTokValue<decltype(dst.SystemInfo.TotalPsThreadsWindowerRange)>(*tokSystemInfo); 3742 } break; 3743 case TOK_FBD_GT_SYSTEM_INFO__TOTAL_VS_THREADS_POCS: { 3744 dst.SystemInfo.TotalVsThreads_Pocs = readTokValue<decltype(dst.SystemInfo.TotalVsThreads_Pocs)>(*tokSystemInfo); 3745 } break; 3746 case TOK_FBD_GT_SYSTEM_INFO__CSR_SIZE_IN_MB: { 3747 dst.SystemInfo.CsrSizeInMb = readTokValue<decltype(dst.SystemInfo.CsrSizeInMb)>(*tokSystemInfo); 3748 } break; 3749 case TOK_FBD_GT_SYSTEM_INFO__MAX_EU_PER_SUB_SLICE: { 3750 dst.SystemInfo.MaxEuPerSubSlice = readTokValue<decltype(dst.SystemInfo.MaxEuPerSubSlice)>(*tokSystemInfo); 3751 } break; 3752 case TOK_FBD_GT_SYSTEM_INFO__MAX_SLICES_SUPPORTED: { 3753 dst.SystemInfo.MaxSlicesSupported = readTokValue<decltype(dst.SystemInfo.MaxSlicesSupported)>(*tokSystemInfo); 3754 } break; 3755 case TOK_FBD_GT_SYSTEM_INFO__MAX_SUB_SLICES_SUPPORTED: { 3756 dst.SystemInfo.MaxSubSlicesSupported = readTokValue<decltype(dst.SystemInfo.MaxSubSlicesSupported)>(*tokSystemInfo); 3757 } break; 3758 case TOK_FBD_GT_SYSTEM_INFO__MAX_DUAL_SUB_SLICES_SUPPORTED: { 3759 dst.SystemInfo.MaxDualSubSlicesSupported = readTokValue<decltype(dst.SystemInfo.MaxDualSubSlicesSupported)>(*tokSystemInfo); 3760 } break; 3761 case TOK_FBB_GT_SYSTEM_INFO__IS_L3HASH_MODE_ENABLED: { 3762 dst.SystemInfo.IsL3HashModeEnabled = readTokValue<decltype(dst.SystemInfo.IsL3HashModeEnabled)>(*tokSystemInfo); 3763 } break; 3764 case TOK_FBB_GT_SYSTEM_INFO__IS_DYNAMICALLY_POPULATED: { 3765 dst.SystemInfo.IsDynamicallyPopulated = readTokValue<decltype(dst.SystemInfo.IsDynamicallyPopulated)>(*tokSystemInfo); 3766 } break; 3767 case TOK_FBD_GT_SYSTEM_INFO__RESERVED_CCSWAYS: { 3768 dst.SystemInfo.ReservedCCSWays = readTokValue<decltype(dst.SystemInfo.ReservedCCSWays)>(*tokSystemInfo); 3769 } break; 3770 case TOK_FBD_GT_SYSTEM_INFO__NUM_THREADS_PER_EU: { 3771 dst.SystemInfo.NumThreadsPerEu = readTokValue<decltype(dst.SystemInfo.NumThreadsPerEu)>(*tokSystemInfo); 3772 } break; 3773 case TOK_FBD_GT_SYSTEM_INFO__MAX_VECS: { 3774 dst.SystemInfo.MaxVECS = readTokValue<decltype(dst.SystemInfo.MaxVECS)>(*tokSystemInfo); 3775 } break; 3776 }; 3777 tokSystemInfo = tokSystemInfo + 1 + tokSystemInfo->valueDwordCount; 3778 } else { 3779 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSystemInfo); 3780 switch (tokSystemInfo->id) { 3781 default: 3782 if (tokSystemInfo->flags.flag3IsMandatory) { 3783 return false; 3784 } 3785 break; 3786 case TOK_FS_GT_SYSTEM_INFO__SLICE_INFO: { 3787 uint32_t arrayElementIdSliceInfo = varLen->arrayElementId; 3788 const TokenHeader *tokSliceInfo = varLen->getValue<TokenHeader>(); 3789 const TokenHeader *tokSliceInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 3790 static constexpr auto maxDstSlicesInfo = sizeof(dst.SystemInfo.SliceInfo) / sizeof(dst.SystemInfo.SliceInfo[0]); 3791 if (arrayElementIdSliceInfo >= maxDstSlicesInfo) { 3792 tokSliceInfo = tokSliceInfoEnd; 3793 } 3794 while (tokSliceInfo < tokSliceInfoEnd) { 3795 if (false == tokSliceInfo->flags.flag4IsVariableLength) { 3796 switch (tokSliceInfo->id) { 3797 default: 3798 if (tokSliceInfo->flags.flag3IsMandatory) { 3799 return false; 3800 } 3801 break; 3802 case TOK_FBB_GT_SLICE_INFO__ENABLED: { 3803 dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].Enabled = readTokValue<decltype(dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].Enabled)>(*tokSliceInfo); 3804 } break; 3805 case TOK_FBD_GT_SLICE_INFO__SUB_SLICE_ENABLED_COUNT: { 3806 dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].SubSliceEnabledCount = readTokValue<decltype(dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].SubSliceEnabledCount)>(*tokSliceInfo); 3807 } break; 3808 case TOK_FBD_GT_SLICE_INFO__DUAL_SUB_SLICE_ENABLED_COUNT: { 3809 dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].DualSubSliceEnabledCount = readTokValue<decltype(dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].DualSubSliceEnabledCount)>(*tokSliceInfo); 3810 } break; 3811 }; 3812 tokSliceInfo = tokSliceInfo + 1 + tokSliceInfo->valueDwordCount; 3813 } else { 3814 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSliceInfo); 3815 switch (tokSliceInfo->id) { 3816 default: 3817 if (tokSliceInfo->flags.flag3IsMandatory) { 3818 return false; 3819 } 3820 break; 3821 case TOK_FS_GT_SLICE_INFO__SUB_SLICE_INFO: { 3822 uint32_t arrayElementIdSubSliceInfo = varLen->arrayElementId; 3823 const TokenHeader *tokSubSliceInfo = varLen->getValue<TokenHeader>(); 3824 const TokenHeader *tokSubSliceInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 3825 while (tokSubSliceInfo < tokSubSliceInfoEnd) { 3826 if (false == tokSubSliceInfo->flags.flag4IsVariableLength) { 3827 switch (tokSubSliceInfo->id) { 3828 default: 3829 if (tokSubSliceInfo->flags.flag3IsMandatory) { 3830 return false; 3831 } 3832 break; 3833 case TOK_FBB_GT_SUBSLICE_INFO__ENABLED: { 3834 dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].Enabled = readTokValue<decltype(dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].Enabled)>(*tokSubSliceInfo); 3835 } break; 3836 case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_COUNT: { 3837 dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledCount = readTokValue<decltype(dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledCount)>(*tokSubSliceInfo); 3838 } break; 3839 case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_MASK: { 3840 dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledMask = readTokValue<decltype(dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledMask)>(*tokSubSliceInfo); 3841 } break; 3842 }; 3843 tokSubSliceInfo = tokSubSliceInfo + 1 + tokSubSliceInfo->valueDwordCount; 3844 } else { 3845 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSubSliceInfo); 3846 if (tokSubSliceInfo->flags.flag3IsMandatory) { 3847 return false; 3848 } 3849 tokSubSliceInfo = tokSubSliceInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 3850 } 3851 } 3852 WCH_ASSERT(tokSubSliceInfo == tokSubSliceInfoEnd); 3853 } break; 3854 case TOK_FS_GT_SLICE_INFO__DSSINFO: { 3855 uint32_t arrayElementIdDSSInfo = varLen->arrayElementId; 3856 const TokenHeader *tokDSSInfo = varLen->getValue<TokenHeader>(); 3857 const TokenHeader *tokDSSInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 3858 while (tokDSSInfo < tokDSSInfoEnd) { 3859 if (false == tokDSSInfo->flags.flag4IsVariableLength) { 3860 switch (tokDSSInfo->id) { 3861 default: 3862 if (tokDSSInfo->flags.flag3IsMandatory) { 3863 return false; 3864 } 3865 break; 3866 case TOK_FBB_GT_DUALSUBSLICE_INFO__ENABLED: { 3867 dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].Enabled = readTokValue<decltype(dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].Enabled)>(*tokDSSInfo); 3868 } break; 3869 }; 3870 tokDSSInfo = tokDSSInfo + 1 + tokDSSInfo->valueDwordCount; 3871 } else { 3872 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokDSSInfo); 3873 switch (tokDSSInfo->id) { 3874 default: 3875 if (tokDSSInfo->flags.flag3IsMandatory) { 3876 return false; 3877 } 3878 break; 3879 case TOK_FS_GT_DUALSUBSLICE_INFO__SUB_SLICE: { 3880 uint32_t arrayElementIdSubSlice = varLen->arrayElementId; 3881 const TokenHeader *tokSubSlice = varLen->getValue<TokenHeader>(); 3882 const TokenHeader *tokSubSliceEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 3883 while (tokSubSlice < tokSubSliceEnd) { 3884 if (false == tokSubSlice->flags.flag4IsVariableLength) { 3885 switch (tokSubSlice->id) { 3886 default: 3887 if (tokSubSlice->flags.flag3IsMandatory) { 3888 return false; 3889 } 3890 break; 3891 case TOK_FBB_GT_SUBSLICE_INFO__ENABLED: { 3892 dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].Enabled = readTokValue<decltype(dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].Enabled)>(*tokSubSlice); 3893 } break; 3894 case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_COUNT: { 3895 dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledCount = readTokValue<decltype(dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledCount)>(*tokSubSlice); 3896 } break; 3897 case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_MASK: { 3898 dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledMask = readTokValue<decltype(dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledMask)>(*tokSubSlice); 3899 } break; 3900 }; 3901 tokSubSlice = tokSubSlice + 1 + tokSubSlice->valueDwordCount; 3902 } else { 3903 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSubSlice); 3904 if (tokSubSlice->flags.flag3IsMandatory) { 3905 return false; 3906 } 3907 tokSubSlice = tokSubSlice + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 3908 } 3909 } 3910 WCH_ASSERT(tokSubSlice == tokSubSliceEnd); 3911 } break; 3912 }; 3913 tokDSSInfo = tokDSSInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 3914 } 3915 } 3916 WCH_ASSERT(tokDSSInfo == tokDSSInfoEnd); 3917 } break; 3918 }; 3919 tokSliceInfo = tokSliceInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 3920 } 3921 } 3922 WCH_ASSERT(tokSliceInfo == tokSliceInfoEnd); 3923 } break; 3924 case TOK_FS_GT_SYSTEM_INFO__SQIDI_INFO: { 3925 const TokenHeader *tokSqidiInfo = varLen->getValue<TokenHeader>(); 3926 const TokenHeader *tokSqidiInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 3927 while (tokSqidiInfo < tokSqidiInfoEnd) { 3928 if (false == tokSqidiInfo->flags.flag4IsVariableLength) { 3929 switch (tokSqidiInfo->id) { 3930 default: 3931 if (tokSqidiInfo->flags.flag3IsMandatory) { 3932 return false; 3933 } 3934 break; 3935 case TOK_FBD_GT_SQIDI_INFO__NUMBEROF_SQIDI: { 3936 dst.SystemInfo.SqidiInfo.NumberofSQIDI = readTokValue<decltype(dst.SystemInfo.SqidiInfo.NumberofSQIDI)>(*tokSqidiInfo); 3937 } break; 3938 case TOK_FBD_GT_SQIDI_INFO__NUMBEROF_DOORBELL_PER_SQIDI: { 3939 dst.SystemInfo.SqidiInfo.NumberofDoorbellPerSQIDI = readTokValue<decltype(dst.SystemInfo.SqidiInfo.NumberofDoorbellPerSQIDI)>(*tokSqidiInfo); 3940 } break; 3941 }; 3942 tokSqidiInfo = tokSqidiInfo + 1 + tokSqidiInfo->valueDwordCount; 3943 } else { 3944 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSqidiInfo); 3945 if (tokSqidiInfo->flags.flag3IsMandatory) { 3946 return false; 3947 } 3948 tokSqidiInfo = tokSqidiInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 3949 } 3950 } 3951 WCH_ASSERT(tokSqidiInfo == tokSqidiInfoEnd); 3952 } break; 3953 case TOK_FS_GT_SYSTEM_INFO__CCSINFO: { 3954 const TokenHeader *tokCCSInfo = varLen->getValue<TokenHeader>(); 3955 const TokenHeader *tokCCSInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 3956 while (tokCCSInfo < tokCCSInfoEnd) { 3957 if (false == tokCCSInfo->flags.flag4IsVariableLength) { 3958 switch (tokCCSInfo->id) { 3959 default: 3960 if (tokCCSInfo->flags.flag3IsMandatory) { 3961 return false; 3962 } 3963 break; 3964 case TOK_FBD_GT_CCS_INFO__NUMBER_OF_CCSENABLED: { 3965 dst.SystemInfo.CCSInfo.NumberOfCCSEnabled = readTokValue<decltype(dst.SystemInfo.CCSInfo.NumberOfCCSEnabled)>(*tokCCSInfo); 3966 } break; 3967 case TOK_FBB_GT_CCS_INFO__IS_VALID: { 3968 dst.SystemInfo.CCSInfo.IsValid = readTokValue<decltype(dst.SystemInfo.CCSInfo.IsValid)>(*tokCCSInfo); 3969 } break; 3970 }; 3971 tokCCSInfo = tokCCSInfo + 1 + tokCCSInfo->valueDwordCount; 3972 } else { 3973 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCCSInfo); 3974 switch (tokCCSInfo->id) { 3975 default: 3976 if (tokCCSInfo->flags.flag3IsMandatory) { 3977 return false; 3978 } 3979 break; 3980 case TOK_FS_GT_CCS_INFO__INSTANCES: { 3981 const TokenHeader *tokInstances = varLen->getValue<TokenHeader>(); 3982 const TokenHeader *tokInstancesEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 3983 while (tokInstances < tokInstancesEnd) { 3984 if (false == tokInstances->flags.flag4IsVariableLength) { 3985 switch (tokInstances->id) { 3986 default: 3987 if (tokInstances->flags.flag3IsMandatory) { 3988 return false; 3989 } 3990 break; 3991 case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSENABLE_MASK: { 3992 dst.SystemInfo.CCSInfo.Instances.CCSEnableMask = readTokValue<decltype(dst.SystemInfo.CCSInfo.Instances.CCSEnableMask)>(*tokInstances); 3993 } break; 3994 }; 3995 tokInstances = tokInstances + 1 + tokInstances->valueDwordCount; 3996 } else { 3997 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInstances); 3998 switch (tokInstances->id) { 3999 default: 4000 if (tokInstances->flags.flag3IsMandatory) { 4001 return false; 4002 } 4003 break; 4004 case TOK_FS_GT_CCS_INFO__CCSINSTANCES__BITS: { 4005 const TokenHeader *tokBits = varLen->getValue<TokenHeader>(); 4006 const TokenHeader *tokBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 4007 while (tokBits < tokBitsEnd) { 4008 if (false == tokBits->flags.flag4IsVariableLength) { 4009 switch (tokBits->id) { 4010 default: 4011 if (tokBits->flags.flag3IsMandatory) { 4012 return false; 4013 } 4014 break; 4015 case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS0ENABLED: { 4016 dst.SystemInfo.CCSInfo.Instances.Bits.CCS0Enabled = readTokValue<decltype(dst.SystemInfo.CCSInfo.Instances.Bits.CCS0Enabled)>(*tokBits); 4017 } break; 4018 case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS1ENABLED: { 4019 dst.SystemInfo.CCSInfo.Instances.Bits.CCS1Enabled = readTokValue<decltype(dst.SystemInfo.CCSInfo.Instances.Bits.CCS1Enabled)>(*tokBits); 4020 } break; 4021 case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS2ENABLED: { 4022 dst.SystemInfo.CCSInfo.Instances.Bits.CCS2Enabled = readTokValue<decltype(dst.SystemInfo.CCSInfo.Instances.Bits.CCS2Enabled)>(*tokBits); 4023 } break; 4024 case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS3ENABLED: { 4025 dst.SystemInfo.CCSInfo.Instances.Bits.CCS3Enabled = readTokValue<decltype(dst.SystemInfo.CCSInfo.Instances.Bits.CCS3Enabled)>(*tokBits); 4026 } break; 4027 }; 4028 tokBits = tokBits + 1 + tokBits->valueDwordCount; 4029 } else { 4030 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokBits); 4031 if (tokBits->flags.flag3IsMandatory) { 4032 return false; 4033 } 4034 tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 4035 } 4036 } 4037 WCH_ASSERT(tokBits == tokBitsEnd); 4038 } break; 4039 }; 4040 tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 4041 } 4042 } 4043 WCH_ASSERT(tokInstances == tokInstancesEnd); 4044 } break; 4045 }; 4046 tokCCSInfo = tokCCSInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 4047 } 4048 } 4049 WCH_ASSERT(tokCCSInfo == tokCCSInfoEnd); 4050 } break; 4051 case TOK_FS_GT_SYSTEM_INFO__MULTI_TILE_ARCH_INFO: { 4052 const TokenHeader *tokMultiTileArchInfo = varLen->getValue<TokenHeader>(); 4053 const TokenHeader *tokMultiTileArchInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 4054 while (tokMultiTileArchInfo < tokMultiTileArchInfoEnd) { 4055 if (false == tokMultiTileArchInfo->flags.flag4IsVariableLength) { 4056 switch (tokMultiTileArchInfo->id) { 4057 default: 4058 if (tokMultiTileArchInfo->flags.flag3IsMandatory) { 4059 return false; 4060 } 4061 break; 4062 case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__TILE_COUNT: { 4063 dst.SystemInfo.MultiTileArchInfo.TileCount = readTokValue<decltype(dst.SystemInfo.MultiTileArchInfo.TileCount)>(*tokMultiTileArchInfo); 4064 } break; 4065 case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE0: { 4066 dst.SystemInfo.MultiTileArchInfo.Tile0 = readTokValue<decltype(dst.SystemInfo.MultiTileArchInfo.Tile0)>(*tokMultiTileArchInfo); 4067 } break; 4068 case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE1: { 4069 dst.SystemInfo.MultiTileArchInfo.Tile1 = readTokValue<decltype(dst.SystemInfo.MultiTileArchInfo.Tile1)>(*tokMultiTileArchInfo); 4070 } break; 4071 case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE2: { 4072 dst.SystemInfo.MultiTileArchInfo.Tile2 = readTokValue<decltype(dst.SystemInfo.MultiTileArchInfo.Tile2)>(*tokMultiTileArchInfo); 4073 } break; 4074 case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE3: { 4075 dst.SystemInfo.MultiTileArchInfo.Tile3 = readTokValue<decltype(dst.SystemInfo.MultiTileArchInfo.Tile3)>(*tokMultiTileArchInfo); 4076 } break; 4077 case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__TILE_MASK: { 4078 dst.SystemInfo.MultiTileArchInfo.TileMask = readTokValue<decltype(dst.SystemInfo.MultiTileArchInfo.TileMask)>(*tokMultiTileArchInfo); 4079 } break; 4080 case TOK_FBB_GT_MULTI_TILE_ARCH_INFO__IS_VALID: { 4081 dst.SystemInfo.MultiTileArchInfo.IsValid = readTokValue<decltype(dst.SystemInfo.MultiTileArchInfo.IsValid)>(*tokMultiTileArchInfo); 4082 } break; 4083 }; 4084 tokMultiTileArchInfo = tokMultiTileArchInfo + 1 + tokMultiTileArchInfo->valueDwordCount; 4085 } else { 4086 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokMultiTileArchInfo); 4087 if (tokMultiTileArchInfo->flags.flag3IsMandatory) { 4088 return false; 4089 } 4090 tokMultiTileArchInfo = tokMultiTileArchInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 4091 } 4092 } 4093 WCH_ASSERT(tokMultiTileArchInfo == tokMultiTileArchInfoEnd); 4094 } break; 4095 case TOK_FS_GT_SYSTEM_INFO__VDBOX_INFO: { 4096 const TokenHeader *tokVDBoxInfo = varLen->getValue<TokenHeader>(); 4097 const TokenHeader *tokVDBoxInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 4098 while (tokVDBoxInfo < tokVDBoxInfoEnd) { 4099 if (false == tokVDBoxInfo->flags.flag4IsVariableLength) { 4100 switch (tokVDBoxInfo->id) { 4101 default: 4102 if (tokVDBoxInfo->flags.flag3IsMandatory) { 4103 return false; 4104 } 4105 break; 4106 case TOK_FBD_GT_VDBOX_INFO__NUMBER_OF_VDBOX_ENABLED: { 4107 dst.SystemInfo.VDBoxInfo.NumberOfVDBoxEnabled = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.NumberOfVDBoxEnabled)>(*tokVDBoxInfo); 4108 } break; 4109 case TOK_FBB_GT_VDBOX_INFO__IS_VALID: { 4110 dst.SystemInfo.VDBoxInfo.IsValid = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.IsValid)>(*tokVDBoxInfo); 4111 } break; 4112 }; 4113 tokVDBoxInfo = tokVDBoxInfo + 1 + tokVDBoxInfo->valueDwordCount; 4114 } else { 4115 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokVDBoxInfo); 4116 switch (tokVDBoxInfo->id) { 4117 default: 4118 if (tokVDBoxInfo->flags.flag3IsMandatory) { 4119 return false; 4120 } 4121 break; 4122 case TOK_FS_GT_VDBOX_INFO__INSTANCES: { 4123 const TokenHeader *tokInstances = varLen->getValue<TokenHeader>(); 4124 const TokenHeader *tokInstancesEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 4125 while (tokInstances < tokInstancesEnd) { 4126 if (false == tokInstances->flags.flag4IsVariableLength) { 4127 switch (tokInstances->id) { 4128 default: 4129 if (tokInstances->flags.flag3IsMandatory) { 4130 return false; 4131 } 4132 break; 4133 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBOX_ENABLE_MASK: { 4134 dst.SystemInfo.VDBoxInfo.Instances.VDBoxEnableMask = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.Instances.VDBoxEnableMask)>(*tokInstances); 4135 } break; 4136 }; 4137 tokInstances = tokInstances + 1 + tokInstances->valueDwordCount; 4138 } else { 4139 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInstances); 4140 switch (tokInstances->id) { 4141 default: 4142 if (tokInstances->flags.flag3IsMandatory) { 4143 return false; 4144 } 4145 break; 4146 case TOK_FS_GT_VDBOX_INFO__VDBOX_INSTANCES__BITS: { 4147 const TokenHeader *tokBits = varLen->getValue<TokenHeader>(); 4148 const TokenHeader *tokBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 4149 while (tokBits < tokBitsEnd) { 4150 if (false == tokBits->flags.flag4IsVariableLength) { 4151 switch (tokBits->id) { 4152 default: 4153 if (tokBits->flags.flag3IsMandatory) { 4154 return false; 4155 } 4156 break; 4157 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX0ENABLED: { 4158 dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox0Enabled = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox0Enabled)>(*tokBits); 4159 } break; 4160 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX1ENABLED: { 4161 dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox1Enabled = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox1Enabled)>(*tokBits); 4162 } break; 4163 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX2ENABLED: { 4164 dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox2Enabled = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox2Enabled)>(*tokBits); 4165 } break; 4166 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX3ENABLED: { 4167 dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox3Enabled = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox3Enabled)>(*tokBits); 4168 } break; 4169 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX4ENABLED: { 4170 dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox4Enabled = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox4Enabled)>(*tokBits); 4171 } break; 4172 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX5ENABLED: { 4173 dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox5Enabled = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox5Enabled)>(*tokBits); 4174 } break; 4175 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX6ENABLED: { 4176 dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox6Enabled = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox6Enabled)>(*tokBits); 4177 } break; 4178 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX7ENABLED: { 4179 dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox7Enabled = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox7Enabled)>(*tokBits); 4180 } break; 4181 }; 4182 tokBits = tokBits + 1 + tokBits->valueDwordCount; 4183 } else { 4184 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokBits); 4185 if (tokBits->flags.flag3IsMandatory) { 4186 return false; 4187 } 4188 tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 4189 } 4190 } 4191 WCH_ASSERT(tokBits == tokBitsEnd); 4192 } break; 4193 }; 4194 tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 4195 } 4196 } 4197 WCH_ASSERT(tokInstances == tokInstancesEnd); 4198 } break; 4199 case TOK_FS_GT_VDBOX_INFO__SFCSUPPORT: { 4200 const TokenHeader *tokSFCSupport = varLen->getValue<TokenHeader>(); 4201 const TokenHeader *tokSFCSupportEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 4202 while (tokSFCSupport < tokSFCSupportEnd) { 4203 if (false == tokSFCSupport->flags.flag4IsVariableLength) { 4204 switch (tokSFCSupport->id) { 4205 default: 4206 if (tokSFCSupport->flags.flag3IsMandatory) { 4207 return false; 4208 } 4209 break; 4210 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__VALUE: { 4211 dst.SystemInfo.VDBoxInfo.SFCSupport.Value = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.SFCSupport.Value)>(*tokSFCSupport); 4212 } break; 4213 }; 4214 tokSFCSupport = tokSFCSupport + 1 + tokSFCSupport->valueDwordCount; 4215 } else { 4216 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSFCSupport); 4217 switch (tokSFCSupport->id) { 4218 default: 4219 if (tokSFCSupport->flags.flag3IsMandatory) { 4220 return false; 4221 } 4222 break; 4223 case TOK_FS_GT_VDBOX_INFO__ANONYMOUS5662__SFC_SUPPORTED_BITS: { 4224 const TokenHeader *tokSfcSupportedBits = varLen->getValue<TokenHeader>(); 4225 const TokenHeader *tokSfcSupportedBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 4226 while (tokSfcSupportedBits < tokSfcSupportedBitsEnd) { 4227 if (false == tokSfcSupportedBits->flags.flag4IsVariableLength) { 4228 switch (tokSfcSupportedBits->id) { 4229 default: 4230 if (tokSfcSupportedBits->flags.flag3IsMandatory) { 4231 return false; 4232 } 4233 break; 4234 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX0: { 4235 dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox0 = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox0)>(*tokSfcSupportedBits); 4236 } break; 4237 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX1: { 4238 dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox1 = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox1)>(*tokSfcSupportedBits); 4239 } break; 4240 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX2: { 4241 dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox2 = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox2)>(*tokSfcSupportedBits); 4242 } break; 4243 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX3: { 4244 dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox3 = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox3)>(*tokSfcSupportedBits); 4245 } break; 4246 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX4: { 4247 dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox4 = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox4)>(*tokSfcSupportedBits); 4248 } break; 4249 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX5: { 4250 dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox5 = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox5)>(*tokSfcSupportedBits); 4251 } break; 4252 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX6: { 4253 dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox6 = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox6)>(*tokSfcSupportedBits); 4254 } break; 4255 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX7: { 4256 dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox7 = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox7)>(*tokSfcSupportedBits); 4257 } break; 4258 }; 4259 tokSfcSupportedBits = tokSfcSupportedBits + 1 + tokSfcSupportedBits->valueDwordCount; 4260 } else { 4261 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSfcSupportedBits); 4262 if (tokSfcSupportedBits->flags.flag3IsMandatory) { 4263 return false; 4264 } 4265 tokSfcSupportedBits = tokSfcSupportedBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 4266 } 4267 } 4268 WCH_ASSERT(tokSfcSupportedBits == tokSfcSupportedBitsEnd); 4269 } break; 4270 }; 4271 tokSFCSupport = tokSFCSupport + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 4272 } 4273 } 4274 WCH_ASSERT(tokSFCSupport == tokSFCSupportEnd); 4275 } break; 4276 }; 4277 tokVDBoxInfo = tokVDBoxInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 4278 } 4279 } 4280 WCH_ASSERT(tokVDBoxInfo == tokVDBoxInfoEnd); 4281 } break; 4282 case TOK_FS_GT_SYSTEM_INFO__VEBOX_INFO: { 4283 const TokenHeader *tokVEBoxInfo = varLen->getValue<TokenHeader>(); 4284 const TokenHeader *tokVEBoxInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 4285 while (tokVEBoxInfo < tokVEBoxInfoEnd) { 4286 if (false == tokVEBoxInfo->flags.flag4IsVariableLength) { 4287 switch (tokVEBoxInfo->id) { 4288 default: 4289 if (tokVEBoxInfo->flags.flag3IsMandatory) { 4290 return false; 4291 } 4292 break; 4293 case TOK_FBD_GT_VEBOX_INFO__NUMBER_OF_VEBOX_ENABLED: { 4294 dst.SystemInfo.VEBoxInfo.NumberOfVEBoxEnabled = readTokValue<decltype(dst.SystemInfo.VEBoxInfo.NumberOfVEBoxEnabled)>(*tokVEBoxInfo); 4295 } break; 4296 case TOK_FBB_GT_VEBOX_INFO__IS_VALID: { 4297 dst.SystemInfo.VEBoxInfo.IsValid = readTokValue<decltype(dst.SystemInfo.VEBoxInfo.IsValid)>(*tokVEBoxInfo); 4298 } break; 4299 }; 4300 tokVEBoxInfo = tokVEBoxInfo + 1 + tokVEBoxInfo->valueDwordCount; 4301 } else { 4302 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokVEBoxInfo); 4303 switch (tokVEBoxInfo->id) { 4304 default: 4305 if (tokVEBoxInfo->flags.flag3IsMandatory) { 4306 return false; 4307 } 4308 break; 4309 case TOK_FS_GT_VEBOX_INFO__INSTANCES: { 4310 const TokenHeader *tokInstances = varLen->getValue<TokenHeader>(); 4311 const TokenHeader *tokInstancesEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 4312 while (tokInstances < tokInstancesEnd) { 4313 if (false == tokInstances->flags.flag4IsVariableLength) { 4314 switch (tokInstances->id) { 4315 default: 4316 if (tokInstances->flags.flag3IsMandatory) { 4317 return false; 4318 } 4319 break; 4320 case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBOX_ENABLE_MASK: { 4321 dst.SystemInfo.VEBoxInfo.Instances.VEBoxEnableMask = readTokValue<decltype(dst.SystemInfo.VEBoxInfo.Instances.VEBoxEnableMask)>(*tokInstances); 4322 } break; 4323 }; 4324 tokInstances = tokInstances + 1 + tokInstances->valueDwordCount; 4325 } else { 4326 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInstances); 4327 switch (tokInstances->id) { 4328 default: 4329 if (tokInstances->flags.flag3IsMandatory) { 4330 return false; 4331 } 4332 break; 4333 case TOK_FS_GT_VEBOX_INFO__VEBOX_INSTANCES__BITS: { 4334 const TokenHeader *tokBits = varLen->getValue<TokenHeader>(); 4335 const TokenHeader *tokBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 4336 while (tokBits < tokBitsEnd) { 4337 if (false == tokBits->flags.flag4IsVariableLength) { 4338 switch (tokBits->id) { 4339 default: 4340 if (tokBits->flags.flag3IsMandatory) { 4341 return false; 4342 } 4343 break; 4344 case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX0ENABLED: { 4345 dst.SystemInfo.VEBoxInfo.Instances.Bits.VEBox0Enabled = readTokValue<decltype(dst.SystemInfo.VEBoxInfo.Instances.Bits.VEBox0Enabled)>(*tokBits); 4346 } break; 4347 case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX1ENABLED: { 4348 dst.SystemInfo.VEBoxInfo.Instances.Bits.VEBox1Enabled = readTokValue<decltype(dst.SystemInfo.VEBoxInfo.Instances.Bits.VEBox1Enabled)>(*tokBits); 4349 } break; 4350 case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX2ENABLED: { 4351 dst.SystemInfo.VEBoxInfo.Instances.Bits.VEBox2Enabled = readTokValue<decltype(dst.SystemInfo.VEBoxInfo.Instances.Bits.VEBox2Enabled)>(*tokBits); 4352 } break; 4353 case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX3ENABLED: { 4354 dst.SystemInfo.VEBoxInfo.Instances.Bits.VEBox3Enabled = readTokValue<decltype(dst.SystemInfo.VEBoxInfo.Instances.Bits.VEBox3Enabled)>(*tokBits); 4355 } break; 4356 }; 4357 tokBits = tokBits + 1 + tokBits->valueDwordCount; 4358 } else { 4359 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokBits); 4360 if (tokBits->flags.flag3IsMandatory) { 4361 return false; 4362 } 4363 tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 4364 } 4365 } 4366 WCH_ASSERT(tokBits == tokBitsEnd); 4367 } break; 4368 }; 4369 tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 4370 } 4371 } 4372 WCH_ASSERT(tokInstances == tokInstancesEnd); 4373 } break; 4374 case TOK_FS_GT_VEBOX_INFO__SFCSUPPORT: { 4375 const TokenHeader *tokSFCSupport = varLen->getValue<TokenHeader>(); 4376 const TokenHeader *tokSFCSupportEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 4377 while (tokSFCSupport < tokSFCSupportEnd) { 4378 if (false == tokSFCSupport->flags.flag4IsVariableLength) { 4379 switch (tokSFCSupport->id) { 4380 default: 4381 if (tokSFCSupport->flags.flag3IsMandatory) { 4382 return false; 4383 } 4384 break; 4385 case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__VALUE: { 4386 dst.SystemInfo.VEBoxInfo.SFCSupport.Value = readTokValue<decltype(dst.SystemInfo.VEBoxInfo.SFCSupport.Value)>(*tokSFCSupport); 4387 } break; 4388 }; 4389 tokSFCSupport = tokSFCSupport + 1 + tokSFCSupport->valueDwordCount; 4390 } else { 4391 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSFCSupport); 4392 switch (tokSFCSupport->id) { 4393 default: 4394 if (tokSFCSupport->flags.flag3IsMandatory) { 4395 return false; 4396 } 4397 break; 4398 case TOK_FS_GT_VEBOX_INFO__ANONYMOUS3862__SFC_SUPPORTED_BITS: { 4399 const TokenHeader *tokSfcSupportedBits = varLen->getValue<TokenHeader>(); 4400 const TokenHeader *tokSfcSupportedBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 4401 while (tokSfcSupportedBits < tokSfcSupportedBitsEnd) { 4402 if (false == tokSfcSupportedBits->flags.flag4IsVariableLength) { 4403 switch (tokSfcSupportedBits->id) { 4404 default: 4405 if (tokSfcSupportedBits->flags.flag3IsMandatory) { 4406 return false; 4407 } 4408 break; 4409 case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX0: { 4410 dst.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox0 = readTokValue<decltype(dst.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox0)>(*tokSfcSupportedBits); 4411 } break; 4412 case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX1: { 4413 dst.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox1 = readTokValue<decltype(dst.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox1)>(*tokSfcSupportedBits); 4414 } break; 4415 case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX2: { 4416 dst.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox2 = readTokValue<decltype(dst.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox2)>(*tokSfcSupportedBits); 4417 } break; 4418 case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX3: { 4419 dst.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox3 = readTokValue<decltype(dst.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox3)>(*tokSfcSupportedBits); 4420 } break; 4421 }; 4422 tokSfcSupportedBits = tokSfcSupportedBits + 1 + tokSfcSupportedBits->valueDwordCount; 4423 } else { 4424 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSfcSupportedBits); 4425 if (tokSfcSupportedBits->flags.flag3IsMandatory) { 4426 return false; 4427 } 4428 tokSfcSupportedBits = tokSfcSupportedBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 4429 } 4430 } 4431 WCH_ASSERT(tokSfcSupportedBits == tokSfcSupportedBitsEnd); 4432 } break; 4433 }; 4434 tokSFCSupport = tokSFCSupport + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 4435 } 4436 } 4437 WCH_ASSERT(tokSFCSupport == tokSFCSupportEnd); 4438 } break; 4439 }; 4440 tokVEBoxInfo = tokVEBoxInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 4441 } 4442 } 4443 WCH_ASSERT(tokVEBoxInfo == tokVEBoxInfoEnd); 4444 } break; 4445 case TOK_FS_GT_SYSTEM_INFO__CACHE_TYPES: { 4446 const TokenHeader *tokCacheTypes = varLen->getValue<TokenHeader>(); 4447 const TokenHeader *tokCacheTypesEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 4448 while (tokCacheTypes < tokCacheTypesEnd) { 4449 if (false == tokCacheTypes->flags.flag4IsVariableLength) { 4450 switch (tokCacheTypes->id) { 4451 default: 4452 if (tokCacheTypes->flags.flag3IsMandatory) { 4453 return false; 4454 } 4455 break; 4456 case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__L3: { 4457 dst.SystemInfo.CacheTypes.L3 = readTokValue<decltype(dst.SystemInfo.CacheTypes.L3)>(*tokCacheTypes); 4458 } break; 4459 case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__LLC: { 4460 dst.SystemInfo.CacheTypes.LLC = readTokValue<decltype(dst.SystemInfo.CacheTypes.LLC)>(*tokCacheTypes); 4461 } break; 4462 case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__E_DRAM: { 4463 dst.SystemInfo.CacheTypes.eDRAM = readTokValue<decltype(dst.SystemInfo.CacheTypes.eDRAM)>(*tokCacheTypes); 4464 } break; 4465 case TOK_FBD_GT_CACHE_TYPES__CACHE_TYPE_MASK: { 4466 dst.SystemInfo.CacheTypes.CacheTypeMask = readTokValue<decltype(dst.SystemInfo.CacheTypes.CacheTypeMask)>(*tokCacheTypes); 4467 } break; 4468 }; 4469 tokCacheTypes = tokCacheTypes + 1 + tokCacheTypes->valueDwordCount; 4470 } else { 4471 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCacheTypes); 4472 if (tokCacheTypes->flags.flag3IsMandatory) { 4473 return false; 4474 } 4475 tokCacheTypes = tokCacheTypes + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 4476 } 4477 } 4478 WCH_ASSERT(tokCacheTypes == tokCacheTypesEnd); 4479 } break; 4480 }; 4481 tokSystemInfo = tokSystemInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 4482 } 4483 } 4484 WCH_ASSERT(tokSystemInfo == tokSystemInfoEnd); 4485 } break; 4486 case TOK_FS_ADAPTER_INFO__DEFERRED_WAIT_INFO: { 4487 const TokenHeader *tokDeferredWaitInfo = varLen->getValue<TokenHeader>(); 4488 const TokenHeader *tokDeferredWaitInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 4489 while (tokDeferredWaitInfo < tokDeferredWaitInfoEnd) { 4490 if (false == tokDeferredWaitInfo->flags.flag4IsVariableLength) { 4491 switch (tokDeferredWaitInfo->id) { 4492 default: 4493 if (tokDeferredWaitInfo->flags.flag3IsMandatory) { 4494 return false; 4495 } 4496 break; 4497 case TOK_FBD_KM_DEFERRED_WAIT_INFO__FEATURE_SUPPORTED: { 4498 dst.DeferredWaitInfo.FeatureSupported = readTokValue<decltype(dst.DeferredWaitInfo.FeatureSupported)>(*tokDeferredWaitInfo); 4499 } break; 4500 case TOK_FBD_KM_DEFERRED_WAIT_INFO__ACTIVE_DISPLAY: { 4501 dst.DeferredWaitInfo.ActiveDisplay = readTokValue<decltype(dst.DeferredWaitInfo.ActiveDisplay)>(*tokDeferredWaitInfo); 4502 } break; 4503 }; 4504 tokDeferredWaitInfo = tokDeferredWaitInfo + 1 + tokDeferredWaitInfo->valueDwordCount; 4505 } else { 4506 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokDeferredWaitInfo); 4507 if (tokDeferredWaitInfo->flags.flag3IsMandatory) { 4508 return false; 4509 } 4510 tokDeferredWaitInfo = tokDeferredWaitInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 4511 } 4512 } 4513 WCH_ASSERT(tokDeferredWaitInfo == tokDeferredWaitInfoEnd); 4514 } break; 4515 case TOK_FS_ADAPTER_INFO__GFX_PARTITION: { 4516 const TokenHeader *tokGfxPartition = varLen->getValue<TokenHeader>(); 4517 const TokenHeader *tokGfxPartitionEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 4518 while (tokGfxPartition < tokGfxPartitionEnd) { 4519 if (false == tokGfxPartition->flags.flag4IsVariableLength) { 4520 if (tokGfxPartition->flags.flag3IsMandatory) { 4521 return false; 4522 } 4523 tokGfxPartition = tokGfxPartition + 1 + tokGfxPartition->valueDwordCount; 4524 } else { 4525 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokGfxPartition); 4526 switch (tokGfxPartition->id) { 4527 default: 4528 if (tokGfxPartition->flags.flag3IsMandatory) { 4529 return false; 4530 } 4531 break; 4532 case TOK_FS_GMM_GFX_PARTITIONING__STANDARD: { 4533 const TokenHeader *tokStandard = varLen->getValue<TokenHeader>(); 4534 const TokenHeader *tokStandardEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 4535 while (tokStandard < tokStandardEnd) { 4536 if (false == tokStandard->flags.flag4IsVariableLength) { 4537 switch (tokStandard->id) { 4538 default: 4539 if (tokStandard->flags.flag3IsMandatory) { 4540 return false; 4541 } 4542 break; 4543 case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__BASE: { 4544 dst.GfxPartition.Standard.Base = readTokValue<decltype(dst.GfxPartition.Standard.Base)>(*tokStandard); 4545 } break; 4546 case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__LIMIT: { 4547 dst.GfxPartition.Standard.Limit = readTokValue<decltype(dst.GfxPartition.Standard.Limit)>(*tokStandard); 4548 } break; 4549 }; 4550 tokStandard = tokStandard + 1 + tokStandard->valueDwordCount; 4551 } else { 4552 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokStandard); 4553 if (tokStandard->flags.flag3IsMandatory) { 4554 return false; 4555 } 4556 tokStandard = tokStandard + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 4557 } 4558 } 4559 WCH_ASSERT(tokStandard == tokStandardEnd); 4560 } break; 4561 case TOK_FS_GMM_GFX_PARTITIONING__STANDARD64KB: { 4562 const TokenHeader *tokStandard64KB = varLen->getValue<TokenHeader>(); 4563 const TokenHeader *tokStandard64KBEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 4564 while (tokStandard64KB < tokStandard64KBEnd) { 4565 if (false == tokStandard64KB->flags.flag4IsVariableLength) { 4566 switch (tokStandard64KB->id) { 4567 default: 4568 if (tokStandard64KB->flags.flag3IsMandatory) { 4569 return false; 4570 } 4571 break; 4572 case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__BASE: { 4573 dst.GfxPartition.Standard64KB.Base = readTokValue<decltype(dst.GfxPartition.Standard64KB.Base)>(*tokStandard64KB); 4574 } break; 4575 case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__LIMIT: { 4576 dst.GfxPartition.Standard64KB.Limit = readTokValue<decltype(dst.GfxPartition.Standard64KB.Limit)>(*tokStandard64KB); 4577 } break; 4578 }; 4579 tokStandard64KB = tokStandard64KB + 1 + tokStandard64KB->valueDwordCount; 4580 } else { 4581 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokStandard64KB); 4582 if (tokStandard64KB->flags.flag3IsMandatory) { 4583 return false; 4584 } 4585 tokStandard64KB = tokStandard64KB + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 4586 } 4587 } 4588 WCH_ASSERT(tokStandard64KB == tokStandard64KBEnd); 4589 } break; 4590 case TOK_FS_GMM_GFX_PARTITIONING__SVM: { 4591 const TokenHeader *tokSVM = varLen->getValue<TokenHeader>(); 4592 const TokenHeader *tokSVMEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 4593 while (tokSVM < tokSVMEnd) { 4594 if (false == tokSVM->flags.flag4IsVariableLength) { 4595 switch (tokSVM->id) { 4596 default: 4597 if (tokSVM->flags.flag3IsMandatory) { 4598 return false; 4599 } 4600 break; 4601 case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__BASE: { 4602 dst.GfxPartition.SVM.Base = readTokValue<decltype(dst.GfxPartition.SVM.Base)>(*tokSVM); 4603 } break; 4604 case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__LIMIT: { 4605 dst.GfxPartition.SVM.Limit = readTokValue<decltype(dst.GfxPartition.SVM.Limit)>(*tokSVM); 4606 } break; 4607 }; 4608 tokSVM = tokSVM + 1 + tokSVM->valueDwordCount; 4609 } else { 4610 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSVM); 4611 if (tokSVM->flags.flag3IsMandatory) { 4612 return false; 4613 } 4614 tokSVM = tokSVM + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 4615 } 4616 } 4617 WCH_ASSERT(tokSVM == tokSVMEnd); 4618 } break; 4619 case TOK_FS_GMM_GFX_PARTITIONING__HEAP32: { 4620 uint32_t arrayElementIdHeap32 = varLen->arrayElementId; 4621 const TokenHeader *tokHeap32 = varLen->getValue<TokenHeader>(); 4622 const TokenHeader *tokHeap32End = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 4623 while (tokHeap32 < tokHeap32End) { 4624 if (false == tokHeap32->flags.flag4IsVariableLength) { 4625 switch (tokHeap32->id) { 4626 default: 4627 if (tokHeap32->flags.flag3IsMandatory) { 4628 return false; 4629 } 4630 break; 4631 case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__BASE: { 4632 dst.GfxPartition.Heap32[arrayElementIdHeap32].Base = readTokValue<decltype(dst.GfxPartition.Heap32[arrayElementIdHeap32].Base)>(*tokHeap32); 4633 } break; 4634 case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__LIMIT: { 4635 dst.GfxPartition.Heap32[arrayElementIdHeap32].Limit = readTokValue<decltype(dst.GfxPartition.Heap32[arrayElementIdHeap32].Limit)>(*tokHeap32); 4636 } break; 4637 }; 4638 tokHeap32 = tokHeap32 + 1 + tokHeap32->valueDwordCount; 4639 } else { 4640 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokHeap32); 4641 if (tokHeap32->flags.flag3IsMandatory) { 4642 return false; 4643 } 4644 tokHeap32 = tokHeap32 + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 4645 } 4646 } 4647 WCH_ASSERT(tokHeap32 == tokHeap32End); 4648 } break; 4649 }; 4650 tokGfxPartition = tokGfxPartition + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 4651 } 4652 } 4653 WCH_ASSERT(tokGfxPartition == tokGfxPartitionEnd); 4654 } break; 4655 case TOK_FS_ADAPTER_INFO__ST_ADAPTER_BDF: { 4656 const TokenHeader *tokStAdapterBDF = varLen->getValue<TokenHeader>(); 4657 const TokenHeader *tokStAdapterBDFEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 4658 while (tokStAdapterBDF < tokStAdapterBDFEnd) { 4659 if (false == tokStAdapterBDF->flags.flag4IsVariableLength) { 4660 switch (tokStAdapterBDF->id) { 4661 default: 4662 if (tokStAdapterBDF->flags.flag3IsMandatory) { 4663 return false; 4664 } 4665 break; 4666 case TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__BUS: { 4667 dst.stAdapterBDF.Bus = readTokValue<decltype(dst.stAdapterBDF.Bus)>(*tokStAdapterBDF); 4668 } break; 4669 case TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__DEVICE: { 4670 dst.stAdapterBDF.Device = readTokValue<decltype(dst.stAdapterBDF.Device)>(*tokStAdapterBDF); 4671 } break; 4672 case TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__FUNCTION: { 4673 dst.stAdapterBDF.Function = readTokValue<decltype(dst.stAdapterBDF.Function)>(*tokStAdapterBDF); 4674 } break; 4675 case TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__DATA: { 4676 dst.stAdapterBDF.Data = readTokValue<decltype(dst.stAdapterBDF.Data)>(*tokStAdapterBDF); 4677 } break; 4678 }; 4679 tokStAdapterBDF = tokStAdapterBDF + 1 + tokStAdapterBDF->valueDwordCount; 4680 } else { 4681 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokStAdapterBDF); 4682 if (tokStAdapterBDF->flags.flag3IsMandatory) { 4683 return false; 4684 } 4685 tokStAdapterBDF = tokStAdapterBDF + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 4686 } 4687 } 4688 WCH_ASSERT(tokStAdapterBDF == tokStAdapterBDFEnd); 4689 } break; 4690 }; 4691 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 4692 } 4693 } 4694 WCH_ASSERT(tok == srcTokensEnd); 4695 return true; 4696 } 4697 }; 4698 4699 template <> 4700 struct Demarshaller<TOK_S_CREATECONTEXT_PVTDATA> { 4701 template <typename _CREATECONTEXT_PVTDATAT> 4702 static bool demarshall(_CREATECONTEXT_PVTDATAT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 4703 const TokenHeader *tok = srcTokensBeg; 4704 while (tok < srcTokensEnd) { 4705 if (false == tok->flags.flag4IsVariableLength) { 4706 switch (tok->id) { 4707 default: 4708 if (tok->flags.flag3IsMandatory) { 4709 return false; 4710 } 4711 break; 4712 case TOK_PBQ_CREATECONTEXT_PVTDATA__ANONYMOUS18449__P_HW_CONTEXT_ID: { 4713 dst.pHwContextId = readTokValue<decltype(dst.pHwContextId)>(*tok); 4714 } break; 4715 case TOK_FBD_CREATECONTEXT_PVTDATA__NUMBER_OF_HW_CONTEXT_IDS: { 4716 dst.NumberOfHwContextIds = readTokValue<decltype(dst.NumberOfHwContextIds)>(*tok); 4717 } break; 4718 case TOK_FBD_CREATECONTEXT_PVTDATA__PROCESS_ID: { 4719 dst.ProcessID = readTokValue<decltype(dst.ProcessID)>(*tok); 4720 } break; 4721 case TOK_FBC_CREATECONTEXT_PVTDATA__IS_PROTECTED_PROCESS: { 4722 dst.IsProtectedProcess = readTokValue<decltype(dst.IsProtectedProcess)>(*tok); 4723 } break; 4724 case TOK_FBC_CREATECONTEXT_PVTDATA__IS_DWM: { 4725 dst.IsDwm = readTokValue<decltype(dst.IsDwm)>(*tok); 4726 } break; 4727 case TOK_FBC_CREATECONTEXT_PVTDATA__IS_MEDIA_USAGE: { 4728 dst.IsMediaUsage = readTokValue<decltype(dst.IsMediaUsage)>(*tok); 4729 } break; 4730 case TOK_FBC_CREATECONTEXT_PVTDATA__GPU_VACONTEXT: { 4731 dst.GpuVAContext = readTokValue<decltype(dst.GpuVAContext)>(*tok); 4732 } break; 4733 case TOK_FBC_CREATECONTEXT_PVTDATA__NO_RING_FLUSHES: { 4734 dst.NoRingFlushes = readTokValue<decltype(dst.NoRingFlushes)>(*tok); 4735 } break; 4736 }; 4737 tok = tok + 1 + tok->valueDwordCount; 4738 } else { 4739 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 4740 switch (tok->id) { 4741 default: 4742 if (tok->flags.flag3IsMandatory) { 4743 return false; 4744 } 4745 break; 4746 case TOK_S_CREATECONTEXT_PVTDATA: 4747 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 4748 return false; 4749 } 4750 break; 4751 }; 4752 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 4753 } 4754 } 4755 WCH_ASSERT(tok == srcTokensEnd); 4756 return true; 4757 } 4758 }; 4759 4760 template <> 4761 struct Demarshaller<TOK_S_COMMAND_BUFFER_HEADER_REC> { 4762 template <typename COMMAND_BUFFER_HEADER_RECT> 4763 static bool demarshall(COMMAND_BUFFER_HEADER_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 4764 const TokenHeader *tok = srcTokensBeg; 4765 while (tok < srcTokensEnd) { 4766 if (false == tok->flags.flag4IsVariableLength) { 4767 switch (tok->id) { 4768 default: 4769 if (tok->flags.flag3IsMandatory) { 4770 return false; 4771 } 4772 break; 4773 case TOK_FBD_COMMAND_BUFFER_HEADER_REC__UMD_CONTEXT_TYPE: { 4774 dst.UmdContextType = readTokValue<decltype(dst.UmdContextType)>(*tok); 4775 } break; 4776 case TOK_FBD_COMMAND_BUFFER_HEADER_REC__UMD_PATCH_LIST: { 4777 dst.UmdPatchList = readTokValue<decltype(dst.UmdPatchList)>(*tok); 4778 } break; 4779 case TOK_FBD_COMMAND_BUFFER_HEADER_REC__UMD_REQUESTED_SLICE_STATE: { 4780 dst.UmdRequestedSliceState = readTokValue<decltype(dst.UmdRequestedSliceState)>(*tok); 4781 } break; 4782 case TOK_FBD_COMMAND_BUFFER_HEADER_REC__UMD_REQUESTED_SUBSLICE_COUNT: { 4783 dst.UmdRequestedSubsliceCount = readTokValue<decltype(dst.UmdRequestedSubsliceCount)>(*tok); 4784 } break; 4785 case TOK_FBD_COMMAND_BUFFER_HEADER_REC__UMD_REQUESTED_EUCOUNT: { 4786 dst.UmdRequestedEUCount = readTokValue<decltype(dst.UmdRequestedEUCount)>(*tok); 4787 } break; 4788 case TOK_FBD_COMMAND_BUFFER_HEADER_REC__USES_RESOURCE_STREAMER: { 4789 dst.UsesResourceStreamer = readTokValue<decltype(dst.UsesResourceStreamer)>(*tok); 4790 } break; 4791 case TOK_FBD_COMMAND_BUFFER_HEADER_REC__NEEDS_MID_BATCH_PRE_EMPTION_SUPPORT: { 4792 dst.NeedsMidBatchPreEmptionSupport = readTokValue<decltype(dst.NeedsMidBatchPreEmptionSupport)>(*tok); 4793 } break; 4794 case TOK_FBD_COMMAND_BUFFER_HEADER_REC__USES_GPGPUPIPELINE: { 4795 dst.UsesGPGPUPipeline = readTokValue<decltype(dst.UsesGPGPUPipeline)>(*tok); 4796 } break; 4797 case TOK_FBD_COMMAND_BUFFER_HEADER_REC__REQUIRES_COHERENCY: { 4798 dst.RequiresCoherency = readTokValue<decltype(dst.RequiresCoherency)>(*tok); 4799 } break; 4800 case TOK_FBD_COMMAND_BUFFER_HEADER_REC__PERF_TAG: { 4801 dst.PerfTag = readTokValue<decltype(dst.PerfTag)>(*tok); 4802 } break; 4803 case TOK_FBQ_COMMAND_BUFFER_HEADER_REC__MONITOR_FENCE_VA: { 4804 dst.MonitorFenceVA = readTokValue<decltype(dst.MonitorFenceVA)>(*tok); 4805 } break; 4806 case TOK_FBQ_COMMAND_BUFFER_HEADER_REC__MONITOR_FENCE_VALUE: { 4807 dst.MonitorFenceValue = readTokValue<decltype(dst.MonitorFenceValue)>(*tok); 4808 } break; 4809 }; 4810 tok = tok + 1 + tok->valueDwordCount; 4811 } else { 4812 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 4813 switch (tok->id) { 4814 default: 4815 if (tok->flags.flag3IsMandatory) { 4816 return false; 4817 } 4818 break; 4819 case TOK_S_COMMAND_BUFFER_HEADER_REC: 4820 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 4821 return false; 4822 } 4823 break; 4824 }; 4825 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 4826 } 4827 } 4828 WCH_ASSERT(tok == srcTokensEnd); 4829 return true; 4830 } 4831 }; 4832 4833 template <> 4834 struct Demarshaller<TOK_S_GMM_RESOURCE_FLAG_REC> { 4835 template <typename GMM_RESOURCE_FLAG_RECT> 4836 static bool demarshall(GMM_RESOURCE_FLAG_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 4837 const TokenHeader *tok = srcTokensBeg; 4838 while (tok < srcTokensEnd) { 4839 if (false == tok->flags.flag4IsVariableLength) { 4840 if (tok->flags.flag3IsMandatory) { 4841 return false; 4842 } 4843 tok = tok + 1 + tok->valueDwordCount; 4844 } else { 4845 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 4846 switch (tok->id) { 4847 default: 4848 if (tok->flags.flag3IsMandatory) { 4849 return false; 4850 } 4851 break; 4852 case TOK_S_GMM_RESOURCE_FLAG_REC: 4853 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 4854 return false; 4855 } 4856 break; 4857 case TOK_FS_GMM_RESOURCE_FLAG_REC__GPU: { 4858 const TokenHeader *tokGpu = varLen->getValue<TokenHeader>(); 4859 const TokenHeader *tokGpuEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 4860 while (tokGpu < tokGpuEnd) { 4861 if (false == tokGpu->flags.flag4IsVariableLength) { 4862 switch (tokGpu->id) { 4863 default: 4864 if (tokGpu->flags.flag3IsMandatory) { 4865 return false; 4866 } 4867 break; 4868 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CAMERA_CAPTURE: { 4869 dst.Gpu.CameraCapture = readTokValue<decltype(dst.Gpu.CameraCapture)>(*tokGpu); 4870 } break; 4871 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CCS: { 4872 dst.Gpu.CCS = readTokValue<decltype(dst.Gpu.CCS)>(*tokGpu); 4873 } break; 4874 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_DISCARD: { 4875 dst.Gpu.ColorDiscard = readTokValue<decltype(dst.Gpu.ColorDiscard)>(*tokGpu); 4876 } break; 4877 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION: { 4878 dst.Gpu.ColorSeparation = readTokValue<decltype(dst.Gpu.ColorSeparation)>(*tokGpu); 4879 } break; 4880 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION_RGBX: { 4881 dst.Gpu.ColorSeparationRGBX = readTokValue<decltype(dst.Gpu.ColorSeparationRGBX)>(*tokGpu); 4882 } break; 4883 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CONSTANT: { 4884 dst.Gpu.Constant = readTokValue<decltype(dst.Gpu.Constant)>(*tokGpu); 4885 } break; 4886 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__DEPTH: { 4887 dst.Gpu.Depth = readTokValue<decltype(dst.Gpu.Depth)>(*tokGpu); 4888 } break; 4889 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN: { 4890 dst.Gpu.FlipChain = readTokValue<decltype(dst.Gpu.FlipChain)>(*tokGpu); 4891 } break; 4892 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN_PREFERRED: { 4893 dst.Gpu.FlipChainPreferred = readTokValue<decltype(dst.Gpu.FlipChainPreferred)>(*tokGpu); 4894 } break; 4895 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HISTORY_BUFFER: { 4896 dst.Gpu.HistoryBuffer = readTokValue<decltype(dst.Gpu.HistoryBuffer)>(*tokGpu); 4897 } break; 4898 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HI_Z: { 4899 dst.Gpu.HiZ = readTokValue<decltype(dst.Gpu.HiZ)>(*tokGpu); 4900 } break; 4901 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDEX: { 4902 dst.Gpu.Index = readTokValue<decltype(dst.Gpu.Index)>(*tokGpu); 4903 } break; 4904 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDIRECT_CLEAR_COLOR: { 4905 dst.Gpu.IndirectClearColor = readTokValue<decltype(dst.Gpu.IndirectClearColor)>(*tokGpu); 4906 } break; 4907 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INSTRUCTION_FLAT: { 4908 dst.Gpu.InstructionFlat = readTokValue<decltype(dst.Gpu.InstructionFlat)>(*tokGpu); 4909 } break; 4910 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INTERLACED_SCAN: { 4911 dst.Gpu.InterlacedScan = readTokValue<decltype(dst.Gpu.InterlacedScan)>(*tokGpu); 4912 } break; 4913 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MCS: { 4914 dst.Gpu.MCS = readTokValue<decltype(dst.Gpu.MCS)>(*tokGpu); 4915 } break; 4916 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MMC: { 4917 dst.Gpu.MMC = readTokValue<decltype(dst.Gpu.MMC)>(*tokGpu); 4918 } break; 4919 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MOTION_COMP: { 4920 dst.Gpu.MotionComp = readTokValue<decltype(dst.Gpu.MotionComp)>(*tokGpu); 4921 } break; 4922 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__NO_RESTRICTION: { 4923 dst.Gpu.NoRestriction = readTokValue<decltype(dst.Gpu.NoRestriction)>(*tokGpu); 4924 } break; 4925 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__OVERLAY: { 4926 dst.Gpu.Overlay = readTokValue<decltype(dst.Gpu.Overlay)>(*tokGpu); 4927 } break; 4928 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PRESENTABLE: { 4929 dst.Gpu.Presentable = readTokValue<decltype(dst.Gpu.Presentable)>(*tokGpu); 4930 } break; 4931 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PROCEDURAL_TEXTURE: { 4932 dst.Gpu.ProceduralTexture = readTokValue<decltype(dst.Gpu.ProceduralTexture)>(*tokGpu); 4933 } break; 4934 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__QUERY: { 4935 dst.Gpu.Query = readTokValue<decltype(dst.Gpu.Query)>(*tokGpu); 4936 } break; 4937 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__RENDER_TARGET: { 4938 dst.Gpu.RenderTarget = readTokValue<decltype(dst.Gpu.RenderTarget)>(*tokGpu); 4939 } break; 4940 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D: { 4941 dst.Gpu.S3d = readTokValue<decltype(dst.Gpu.S3d)>(*tokGpu); 4942 } break; 4943 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D_DX: { 4944 dst.Gpu.S3dDx = readTokValue<decltype(dst.Gpu.S3dDx)>(*tokGpu); 4945 } break; 4946 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_NON_PACKED: { 4947 dst.Gpu.__S3dNonPacked = readTokValue<decltype(dst.Gpu.__S3dNonPacked)>(*tokGpu); 4948 } break; 4949 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_WIDI: { 4950 dst.Gpu.__S3dWidi = readTokValue<decltype(dst.Gpu.__S3dWidi)>(*tokGpu); 4951 } break; 4952 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SCRATCH_FLAT: { 4953 dst.Gpu.ScratchFlat = readTokValue<decltype(dst.Gpu.ScratchFlat)>(*tokGpu); 4954 } break; 4955 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SEPARATE_STENCIL: { 4956 dst.Gpu.SeparateStencil = readTokValue<decltype(dst.Gpu.SeparateStencil)>(*tokGpu); 4957 } break; 4958 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE: { 4959 dst.Gpu.State = readTokValue<decltype(dst.Gpu.State)>(*tokGpu); 4960 } break; 4961 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE_DX9CONSTANT_BUFFER: { 4962 dst.Gpu.StateDx9ConstantBuffer = readTokValue<decltype(dst.Gpu.StateDx9ConstantBuffer)>(*tokGpu); 4963 } break; 4964 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STREAM: { 4965 dst.Gpu.Stream = readTokValue<decltype(dst.Gpu.Stream)>(*tokGpu); 4966 } break; 4967 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXT_API: { 4968 dst.Gpu.TextApi = readTokValue<decltype(dst.Gpu.TextApi)>(*tokGpu); 4969 } break; 4970 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXTURE: { 4971 dst.Gpu.Texture = readTokValue<decltype(dst.Gpu.Texture)>(*tokGpu); 4972 } break; 4973 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILED_RESOURCE: { 4974 dst.Gpu.TiledResource = readTokValue<decltype(dst.Gpu.TiledResource)>(*tokGpu); 4975 } break; 4976 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILE_POOL: { 4977 dst.Gpu.TilePool = readTokValue<decltype(dst.Gpu.TilePool)>(*tokGpu); 4978 } break; 4979 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__UNIFIED_AUX_SURFACE: { 4980 dst.Gpu.UnifiedAuxSurface = readTokValue<decltype(dst.Gpu.UnifiedAuxSurface)>(*tokGpu); 4981 } break; 4982 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VERTEX: { 4983 dst.Gpu.Vertex = readTokValue<decltype(dst.Gpu.Vertex)>(*tokGpu); 4984 } break; 4985 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VIDEO: { 4986 dst.Gpu.Video = readTokValue<decltype(dst.Gpu.Video)>(*tokGpu); 4987 } break; 4988 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_XCCS: { 4989 dst.Gpu.__NonMsaaTileXCcs = readTokValue<decltype(dst.Gpu.__NonMsaaTileXCcs)>(*tokGpu); 4990 } break; 4991 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_YCCS: { 4992 dst.Gpu.__NonMsaaTileYCcs = readTokValue<decltype(dst.Gpu.__NonMsaaTileYCcs)>(*tokGpu); 4993 } break; 4994 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____MSAA_TILE_MCS: { 4995 dst.Gpu.__MsaaTileMcs = readTokValue<decltype(dst.Gpu.__MsaaTileMcs)>(*tokGpu); 4996 } break; 4997 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_LINEAR_CCS: { 4998 dst.Gpu.__NonMsaaLinearCCS = readTokValue<decltype(dst.Gpu.__NonMsaaLinearCCS)>(*tokGpu); 4999 } break; 5000 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____REMAINING: { 5001 dst.Gpu.__Remaining = readTokValue<decltype(dst.Gpu.__Remaining)>(*tokGpu); 5002 } break; 5003 }; 5004 tokGpu = tokGpu + 1 + tokGpu->valueDwordCount; 5005 } else { 5006 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokGpu); 5007 if (tokGpu->flags.flag3IsMandatory) { 5008 return false; 5009 } 5010 tokGpu = tokGpu + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 5011 } 5012 } 5013 WCH_ASSERT(tokGpu == tokGpuEnd); 5014 } break; 5015 case TOK_FS_GMM_RESOURCE_FLAG_REC__INFO: { 5016 const TokenHeader *tokInfo = varLen->getValue<TokenHeader>(); 5017 const TokenHeader *tokInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 5018 while (tokInfo < tokInfoEnd) { 5019 if (false == tokInfo->flags.flag4IsVariableLength) { 5020 switch (tokInfo->id) { 5021 default: 5022 if (tokInfo->flags.flag3IsMandatory) { 5023 return false; 5024 } 5025 break; 5026 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ALLOW_VIRTUAL_PADDING: { 5027 dst.Info.AllowVirtualPadding = readTokValue<decltype(dst.Info.AllowVirtualPadding)>(*tokInfo); 5028 } break; 5029 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__BIG_PAGE: { 5030 dst.Info.BigPage = readTokValue<decltype(dst.Info.BigPage)>(*tokInfo); 5031 } break; 5032 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CACHEABLE: { 5033 dst.Info.Cacheable = readTokValue<decltype(dst.Info.Cacheable)>(*tokInfo); 5034 } break; 5035 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CONTIG_PHYS_MEMORY_FORI_DART: { 5036 dst.Info.ContigPhysMemoryForiDART = readTokValue<decltype(dst.Info.ContigPhysMemoryForiDART)>(*tokInfo); 5037 } break; 5038 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CORNER_TEXEL_MODE: { 5039 dst.Info.CornerTexelMode = readTokValue<decltype(dst.Info.CornerTexelMode)>(*tokInfo); 5040 } break; 5041 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__EXISTING_SYS_MEM: { 5042 dst.Info.ExistingSysMem = readTokValue<decltype(dst.Info.ExistingSysMem)>(*tokInfo); 5043 } break; 5044 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__FORCE_RESIDENCY: { 5045 dst.Info.ForceResidency = readTokValue<decltype(dst.Info.ForceResidency)>(*tokInfo); 5046 } break; 5047 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GFDT: { 5048 dst.Info.Gfdt = readTokValue<decltype(dst.Info.Gfdt)>(*tokInfo); 5049 } break; 5050 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GTT_MAP_TYPE: { 5051 dst.Info.GttMapType = readTokValue<decltype(dst.Info.GttMapType)>(*tokInfo); 5052 } break; 5053 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__HARDWARE_PROTECTED: { 5054 dst.Info.HardwareProtected = readTokValue<decltype(dst.Info.HardwareProtected)>(*tokInfo); 5055 } break; 5056 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__KERNEL_MODE_MAPPED: { 5057 dst.Info.KernelModeMapped = readTokValue<decltype(dst.Info.KernelModeMapped)>(*tokInfo); 5058 } break; 5059 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_BELOW: { 5060 dst.Info.LayoutBelow = readTokValue<decltype(dst.Info.LayoutBelow)>(*tokInfo); 5061 } break; 5062 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_MONO: { 5063 dst.Info.LayoutMono = readTokValue<decltype(dst.Info.LayoutMono)>(*tokInfo); 5064 } break; 5065 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_RIGHT: { 5066 dst.Info.LayoutRight = readTokValue<decltype(dst.Info.LayoutRight)>(*tokInfo); 5067 } break; 5068 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LOCAL_ONLY: { 5069 dst.Info.LocalOnly = readTokValue<decltype(dst.Info.LocalOnly)>(*tokInfo); 5070 } break; 5071 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LINEAR: { 5072 dst.Info.Linear = readTokValue<decltype(dst.Info.Linear)>(*tokInfo); 5073 } break; 5074 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__MEDIA_COMPRESSED: { 5075 dst.Info.MediaCompressed = readTokValue<decltype(dst.Info.MediaCompressed)>(*tokInfo); 5076 } break; 5077 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_OPTIMIZATION_PADDING: { 5078 dst.Info.NoOptimizationPadding = readTokValue<decltype(dst.Info.NoOptimizationPadding)>(*tokInfo); 5079 } break; 5080 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_PHYS_MEMORY: { 5081 dst.Info.NoPhysMemory = readTokValue<decltype(dst.Info.NoPhysMemory)>(*tokInfo); 5082 } break; 5083 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NOT_LOCKABLE: { 5084 dst.Info.NotLockable = readTokValue<decltype(dst.Info.NotLockable)>(*tokInfo); 5085 } break; 5086 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NON_LOCAL_ONLY: { 5087 dst.Info.NonLocalOnly = readTokValue<decltype(dst.Info.NonLocalOnly)>(*tokInfo); 5088 } break; 5089 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__STD_SWIZZLE: { 5090 dst.Info.StdSwizzle = readTokValue<decltype(dst.Info.StdSwizzle)>(*tokInfo); 5091 } break; 5092 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__PSEUDO_STD_SWIZZLE: { 5093 dst.Info.PseudoStdSwizzle = readTokValue<decltype(dst.Info.PseudoStdSwizzle)>(*tokInfo); 5094 } break; 5095 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__UNDEFINED64KBSWIZZLE: { 5096 dst.Info.Undefined64KBSwizzle = readTokValue<decltype(dst.Info.Undefined64KBSwizzle)>(*tokInfo); 5097 } break; 5098 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__REDECRIBED_PLANES: { 5099 dst.Info.RedecribedPlanes = readTokValue<decltype(dst.Info.RedecribedPlanes)>(*tokInfo); 5100 } break; 5101 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__RENDER_COMPRESSED: { 5102 dst.Info.RenderCompressed = readTokValue<decltype(dst.Info.RenderCompressed)>(*tokInfo); 5103 } break; 5104 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ROTATED: { 5105 dst.Info.Rotated = readTokValue<decltype(dst.Info.Rotated)>(*tokInfo); 5106 } break; 5107 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SHARED: { 5108 dst.Info.Shared = readTokValue<decltype(dst.Info.Shared)>(*tokInfo); 5109 } break; 5110 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SOFTWARE_PROTECTED: { 5111 dst.Info.SoftwareProtected = readTokValue<decltype(dst.Info.SoftwareProtected)>(*tokInfo); 5112 } break; 5113 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SVM: { 5114 dst.Info.SVM = readTokValue<decltype(dst.Info.SVM)>(*tokInfo); 5115 } break; 5116 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE4: { 5117 dst.Info.Tile4 = readTokValue<decltype(dst.Info.Tile4)>(*tokInfo); 5118 } break; 5119 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE64: { 5120 dst.Info.Tile64 = readTokValue<decltype(dst.Info.Tile64)>(*tokInfo); 5121 } break; 5122 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_W: { 5123 dst.Info.TiledW = readTokValue<decltype(dst.Info.TiledW)>(*tokInfo); 5124 } break; 5125 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_X: { 5126 dst.Info.TiledX = readTokValue<decltype(dst.Info.TiledX)>(*tokInfo); 5127 } break; 5128 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_Y: { 5129 dst.Info.TiledY = readTokValue<decltype(dst.Info.TiledY)>(*tokInfo); 5130 } break; 5131 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YF: { 5132 dst.Info.TiledYf = readTokValue<decltype(dst.Info.TiledYf)>(*tokInfo); 5133 } break; 5134 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YS: { 5135 dst.Info.TiledYs = readTokValue<decltype(dst.Info.TiledYs)>(*tokInfo); 5136 } break; 5137 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__WDDM_PROTECTED: { 5138 dst.Info.WddmProtected = readTokValue<decltype(dst.Info.WddmProtected)>(*tokInfo); 5139 } break; 5140 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__XADAPTER: { 5141 dst.Info.XAdapter = readTokValue<decltype(dst.Info.XAdapter)>(*tokInfo); 5142 } break; 5143 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PREALLOCATED_RES_INFO: { 5144 dst.Info.__PreallocatedResInfo = readTokValue<decltype(dst.Info.__PreallocatedResInfo)>(*tokInfo); 5145 } break; 5146 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PRE_WDDM2SVM: { 5147 dst.Info.__PreWddm2SVM = readTokValue<decltype(dst.Info.__PreWddm2SVM)>(*tokInfo); 5148 } break; 5149 }; 5150 tokInfo = tokInfo + 1 + tokInfo->valueDwordCount; 5151 } else { 5152 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInfo); 5153 if (tokInfo->flags.flag3IsMandatory) { 5154 return false; 5155 } 5156 tokInfo = tokInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 5157 } 5158 } 5159 WCH_ASSERT(tokInfo == tokInfoEnd); 5160 } break; 5161 case TOK_FS_GMM_RESOURCE_FLAG_REC__WA: { 5162 const TokenHeader *tokWa = varLen->getValue<TokenHeader>(); 5163 const TokenHeader *tokWaEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 5164 while (tokWa < tokWaEnd) { 5165 if (false == tokWa->flags.flag4IsVariableLength) { 5166 switch (tokWa->id) { 5167 default: 5168 if (tokWa->flags.flag3IsMandatory) { 5169 return false; 5170 } 5171 break; 5172 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__GTMFX2ND_LEVEL_BATCH_RING_SIZE_ALIGN: { 5173 dst.Wa.GTMfx2ndLevelBatchRingSizeAlign = readTokValue<decltype(dst.Wa.GTMfx2ndLevelBatchRingSizeAlign)>(*tokWa); 5174 } break; 5175 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_MPR_ROW_STORE32KALIGN: { 5176 dst.Wa.ILKNeedAvcMprRowStore32KAlign = readTokValue<decltype(dst.Wa.ILKNeedAvcMprRowStore32KAlign)>(*tokWa); 5177 } break; 5178 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_DMV_BUFFER32KALIGN: { 5179 dst.Wa.ILKNeedAvcDmvBuffer32KAlign = readTokValue<decltype(dst.Wa.ILKNeedAvcDmvBuffer32KAlign)>(*tokWa); 5180 } break; 5181 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_BUFFER_SAMPLER_PADDING: { 5182 dst.Wa.NoBufferSamplerPadding = readTokValue<decltype(dst.Wa.NoBufferSamplerPadding)>(*tokWa); 5183 } break; 5184 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_LEGACY_PLANAR_LINEAR_VIDEO_RESTRICTIONS: { 5185 dst.Wa.NoLegacyPlanarLinearVideoRestrictions = readTokValue<decltype(dst.Wa.NoLegacyPlanarLinearVideoRestrictions)>(*tokWa); 5186 } break; 5187 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__CHVASTC_SKIP_VIRTUAL_MIPS: { 5188 dst.Wa.CHVAstcSkipVirtualMips = readTokValue<decltype(dst.Wa.CHVAstcSkipVirtualMips)>(*tokWa); 5189 } break; 5190 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_PACKED_MIP_TAIL: { 5191 dst.Wa.DisablePackedMipTail = readTokValue<decltype(dst.Wa.DisablePackedMipTail)>(*tokWa); 5192 } break; 5193 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521____FORCE_OTHER_HVALIGN4: { 5194 dst.Wa.__ForceOtherHVALIGN4 = readTokValue<decltype(dst.Wa.__ForceOtherHVALIGN4)>(*tokWa); 5195 } break; 5196 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR: { 5197 dst.Wa.DisableDisplayCcsClearColor = readTokValue<decltype(dst.Wa.DisableDisplayCcsClearColor)>(*tokWa); 5198 } break; 5199 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION: { 5200 dst.Wa.DisableDisplayCcsCompression = readTokValue<decltype(dst.Wa.DisableDisplayCcsCompression)>(*tokWa); 5201 } break; 5202 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: { 5203 dst.Wa.PreGen12FastClearOnly = readTokValue<decltype(dst.Wa.PreGen12FastClearOnly)>(*tokWa); 5204 } break; 5205 }; 5206 tokWa = tokWa + 1 + tokWa->valueDwordCount; 5207 } else { 5208 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokWa); 5209 if (tokWa->flags.flag3IsMandatory) { 5210 return false; 5211 } 5212 tokWa = tokWa + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 5213 } 5214 } 5215 WCH_ASSERT(tokWa == tokWaEnd); 5216 } break; 5217 }; 5218 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 5219 } 5220 } 5221 WCH_ASSERT(tok == srcTokensEnd); 5222 return true; 5223 } 5224 }; 5225 5226 template <> 5227 struct Demarshaller<TOK_S_GMM_RESOURCE_MSAA_INFO_REC> { 5228 template <typename GMM_RESOURCE_MSAA_INFO_RECT> 5229 static bool demarshall(GMM_RESOURCE_MSAA_INFO_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 5230 const TokenHeader *tok = srcTokensBeg; 5231 while (tok < srcTokensEnd) { 5232 if (false == tok->flags.flag4IsVariableLength) { 5233 switch (tok->id) { 5234 default: 5235 if (tok->flags.flag3IsMandatory) { 5236 return false; 5237 } 5238 break; 5239 case TOK_FE_GMM_RESOURCE_MSAA_INFO_REC__SAMPLE_PATTERN: { 5240 dst.SamplePattern = readTokValue<decltype(dst.SamplePattern)>(*tok); 5241 } break; 5242 case TOK_FBD_GMM_RESOURCE_MSAA_INFO_REC__NUM_SAMPLES: { 5243 dst.NumSamples = readTokValue<decltype(dst.NumSamples)>(*tok); 5244 } break; 5245 }; 5246 tok = tok + 1 + tok->valueDwordCount; 5247 } else { 5248 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 5249 switch (tok->id) { 5250 default: 5251 if (tok->flags.flag3IsMandatory) { 5252 return false; 5253 } 5254 break; 5255 case TOK_S_GMM_RESOURCE_MSAA_INFO_REC: 5256 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 5257 return false; 5258 } 5259 break; 5260 }; 5261 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 5262 } 5263 } 5264 WCH_ASSERT(tok == srcTokensEnd); 5265 return true; 5266 } 5267 }; 5268 5269 template <> 5270 struct Demarshaller<TOK_S_GMM_RESOURCE_ALIGNMENT_REC> { 5271 template <typename GMM_RESOURCE_ALIGNMENT_RECT> 5272 static bool demarshall(GMM_RESOURCE_ALIGNMENT_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 5273 const TokenHeader *tok = srcTokensBeg; 5274 while (tok < srcTokensEnd) { 5275 if (false == tok->flags.flag4IsVariableLength) { 5276 switch (tok->id) { 5277 default: 5278 if (tok->flags.flag3IsMandatory) { 5279 return false; 5280 } 5281 break; 5282 case TOK_FBC_GMM_RESOURCE_ALIGNMENT_REC__ARRAY_SPACING_SINGLE_LOD: { 5283 dst.ArraySpacingSingleLod = readTokValue<decltype(dst.ArraySpacingSingleLod)>(*tok); 5284 } break; 5285 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__BASE_ALIGNMENT: { 5286 dst.BaseAlignment = readTokValue<decltype(dst.BaseAlignment)>(*tok); 5287 } break; 5288 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__HALIGN: { 5289 dst.HAlign = readTokValue<decltype(dst.HAlign)>(*tok); 5290 } break; 5291 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__VALIGN: { 5292 dst.VAlign = readTokValue<decltype(dst.VAlign)>(*tok); 5293 } break; 5294 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__DALIGN: { 5295 dst.DAlign = readTokValue<decltype(dst.DAlign)>(*tok); 5296 } break; 5297 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__MIP_TAIL_START_LOD: { 5298 dst.MipTailStartLod = readTokValue<decltype(dst.MipTailStartLod)>(*tok); 5299 } break; 5300 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_START_LOD: { 5301 dst.PackedMipStartLod = readTokValue<decltype(dst.PackedMipStartLod)>(*tok); 5302 } break; 5303 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_WIDTH: { 5304 dst.PackedMipWidth = readTokValue<decltype(dst.PackedMipWidth)>(*tok); 5305 } break; 5306 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_HEIGHT: { 5307 dst.PackedMipHeight = readTokValue<decltype(dst.PackedMipHeight)>(*tok); 5308 } break; 5309 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__QPITCH: { 5310 dst.QPitch = readTokValue<decltype(dst.QPitch)>(*tok); 5311 } break; 5312 }; 5313 tok = tok + 1 + tok->valueDwordCount; 5314 } else { 5315 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 5316 switch (tok->id) { 5317 default: 5318 if (tok->flags.flag3IsMandatory) { 5319 return false; 5320 } 5321 break; 5322 case TOK_S_GMM_RESOURCE_ALIGNMENT_REC: 5323 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 5324 return false; 5325 } 5326 break; 5327 }; 5328 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 5329 } 5330 } 5331 WCH_ASSERT(tok == srcTokensEnd); 5332 return true; 5333 } 5334 }; 5335 5336 template <> 5337 struct Demarshaller<TOK_S_GMM_S3D_INFO_REC> { 5338 template <typename GMM_S3D_INFO_RECT> 5339 static bool demarshall(GMM_S3D_INFO_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 5340 const TokenHeader *tok = srcTokensBeg; 5341 while (tok < srcTokensEnd) { 5342 if (false == tok->flags.flag4IsVariableLength) { 5343 switch (tok->id) { 5344 default: 5345 if (tok->flags.flag3IsMandatory) { 5346 return false; 5347 } 5348 break; 5349 case TOK_FBD_GMM_S3D_INFO_REC__DISPLAY_MODE_HEIGHT: { 5350 dst.DisplayModeHeight = readTokValue<decltype(dst.DisplayModeHeight)>(*tok); 5351 } break; 5352 case TOK_FBD_GMM_S3D_INFO_REC__NUM_BLANK_ACTIVE_LINES: { 5353 dst.NumBlankActiveLines = readTokValue<decltype(dst.NumBlankActiveLines)>(*tok); 5354 } break; 5355 case TOK_FBD_GMM_S3D_INFO_REC__RFRAME_OFFSET: { 5356 dst.RFrameOffset = readTokValue<decltype(dst.RFrameOffset)>(*tok); 5357 } break; 5358 case TOK_FBD_GMM_S3D_INFO_REC__BLANK_AREA_OFFSET: { 5359 dst.BlankAreaOffset = readTokValue<decltype(dst.BlankAreaOffset)>(*tok); 5360 } break; 5361 case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_HEIGHT: { 5362 dst.TallBufferHeight = readTokValue<decltype(dst.TallBufferHeight)>(*tok); 5363 } break; 5364 case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_SIZE: { 5365 dst.TallBufferSize = readTokValue<decltype(dst.TallBufferSize)>(*tok); 5366 } break; 5367 case TOK_FBC_GMM_S3D_INFO_REC__IS_RFRAME: { 5368 dst.IsRFrame = readTokValue<decltype(dst.IsRFrame)>(*tok); 5369 } break; 5370 }; 5371 tok = tok + 1 + tok->valueDwordCount; 5372 } else { 5373 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 5374 switch (tok->id) { 5375 default: 5376 if (tok->flags.flag3IsMandatory) { 5377 return false; 5378 } 5379 break; 5380 case TOK_S_GMM_S3D_INFO_REC: 5381 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 5382 return false; 5383 } 5384 break; 5385 }; 5386 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 5387 } 5388 } 5389 WCH_ASSERT(tok == srcTokensEnd); 5390 return true; 5391 } 5392 }; 5393 5394 template <> 5395 struct Demarshaller<TOK_S_GMM_MULTI_TILE_ARCH_REC> { 5396 template <typename GMM_MULTI_TILE_ARCH_RECT> 5397 static bool demarshall(GMM_MULTI_TILE_ARCH_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 5398 const TokenHeader *tok = srcTokensBeg; 5399 while (tok < srcTokensEnd) { 5400 if (false == tok->flags.flag4IsVariableLength) { 5401 switch (tok->id) { 5402 default: 5403 if (tok->flags.flag3IsMandatory) { 5404 return false; 5405 } 5406 break; 5407 case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__ENABLE: { 5408 dst.Enable = readTokValue<decltype(dst.Enable)>(*tok); 5409 } break; 5410 case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__TILE_INSTANCED: { 5411 dst.TileInstanced = readTokValue<decltype(dst.TileInstanced)>(*tok); 5412 } break; 5413 case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__GPU_VA_MAPPING_SET: { 5414 dst.GpuVaMappingSet = readTokValue<decltype(dst.GpuVaMappingSet)>(*tok); 5415 } break; 5416 case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__LOCAL_MEM_ELIGIBILITY_SET: { 5417 dst.LocalMemEligibilitySet = readTokValue<decltype(dst.LocalMemEligibilitySet)>(*tok); 5418 } break; 5419 case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__LOCAL_MEM_PREFERRED_SET: { 5420 dst.LocalMemPreferredSet = readTokValue<decltype(dst.LocalMemPreferredSet)>(*tok); 5421 } break; 5422 }; 5423 tok = tok + 1 + tok->valueDwordCount; 5424 } else { 5425 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 5426 switch (tok->id) { 5427 default: 5428 if (tok->flags.flag3IsMandatory) { 5429 return false; 5430 } 5431 break; 5432 case TOK_S_GMM_MULTI_TILE_ARCH_REC: 5433 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 5434 return false; 5435 } 5436 break; 5437 }; 5438 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 5439 } 5440 } 5441 WCH_ASSERT(tok == srcTokensEnd); 5442 return true; 5443 } 5444 }; 5445 5446 template <> 5447 struct Demarshaller<TOK_S_GMM_PLANAR_OFFSET_INFO_REC> { 5448 template <typename GMM_PLANAR_OFFSET_INFO_RECT> 5449 static bool demarshall(GMM_PLANAR_OFFSET_INFO_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 5450 const TokenHeader *tok = srcTokensBeg; 5451 while (tok < srcTokensEnd) { 5452 if (false == tok->flags.flag4IsVariableLength) { 5453 switch (tok->id) { 5454 default: 5455 if (tok->flags.flag3IsMandatory) { 5456 return false; 5457 } 5458 break; 5459 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: { 5460 dst.ArrayQPitch = readTokValue<decltype(dst.ArrayQPitch)>(*tok); 5461 } break; 5462 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: { 5463 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tok).getValue<char>(); 5464 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tok).getValueSizeInBytes(); 5465 if (srcSize < sizeof(dst.X)) { 5466 return false; 5467 } 5468 WCH_SAFE_COPY(dst.X, sizeof(dst.X), srcData, sizeof(dst.X)); 5469 } break; 5470 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: { 5471 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tok).getValue<char>(); 5472 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tok).getValueSizeInBytes(); 5473 if (srcSize < sizeof(dst.Y)) { 5474 return false; 5475 } 5476 WCH_SAFE_COPY(dst.Y, sizeof(dst.Y), srcData, sizeof(dst.Y)); 5477 } break; 5478 case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: { 5479 dst.NoOfPlanes = readTokValue<decltype(dst.NoOfPlanes)>(*tok); 5480 } break; 5481 case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: { 5482 dst.IsTileAlignedPlanes = readTokValue<decltype(dst.IsTileAlignedPlanes)>(*tok); 5483 } break; 5484 }; 5485 tok = tok + 1 + tok->valueDwordCount; 5486 } else { 5487 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 5488 switch (tok->id) { 5489 default: 5490 if (tok->flags.flag3IsMandatory) { 5491 return false; 5492 } 5493 break; 5494 case TOK_S_GMM_PLANAR_OFFSET_INFO_REC: 5495 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 5496 return false; 5497 } 5498 break; 5499 case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: { 5500 const TokenHeader *tokUnAligned = varLen->getValue<TokenHeader>(); 5501 const TokenHeader *tokUnAlignedEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 5502 while (tokUnAligned < tokUnAlignedEnd) { 5503 if (false == tokUnAligned->flags.flag4IsVariableLength) { 5504 switch (tokUnAligned->id) { 5505 default: 5506 if (tokUnAligned->flags.flag3IsMandatory) { 5507 return false; 5508 } 5509 break; 5510 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: { 5511 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValue<char>(); 5512 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValueSizeInBytes(); 5513 if (srcSize < sizeof(dst.UnAligned.Height)) { 5514 return false; 5515 } 5516 WCH_SAFE_COPY(dst.UnAligned.Height, sizeof(dst.UnAligned.Height), srcData, sizeof(dst.UnAligned.Height)); 5517 } break; 5518 }; 5519 tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount; 5520 } else { 5521 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokUnAligned); 5522 if (tokUnAligned->flags.flag3IsMandatory) { 5523 return false; 5524 } 5525 tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 5526 } 5527 } 5528 WCH_ASSERT(tokUnAligned == tokUnAlignedEnd); 5529 } break; 5530 }; 5531 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 5532 } 5533 } 5534 WCH_ASSERT(tok == srcTokensEnd); 5535 return true; 5536 } 5537 }; 5538 5539 template <> 5540 struct Demarshaller<TOK_S_GMM_2D_TEXTURE_OFFSET_INFO_REC> { 5541 template <typename GMM_2D_TEXTURE_OFFSET_INFO_RECT> 5542 static bool demarshall(GMM_2D_TEXTURE_OFFSET_INFO_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 5543 const TokenHeader *tok = srcTokensBeg; 5544 while (tok < srcTokensEnd) { 5545 if (false == tok->flags.flag4IsVariableLength) { 5546 switch (tok->id) { 5547 default: 5548 if (tok->flags.flag3IsMandatory) { 5549 return false; 5550 } 5551 break; 5552 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: { 5553 dst.ArrayQPitchLock = readTokValue<decltype(dst.ArrayQPitchLock)>(*tok); 5554 } break; 5555 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: { 5556 dst.ArrayQPitchRender = readTokValue<decltype(dst.ArrayQPitchRender)>(*tok); 5557 } break; 5558 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: { 5559 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tok).getValue<char>(); 5560 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tok).getValueSizeInBytes(); 5561 if (srcSize < sizeof(dst.Offset)) { 5562 return false; 5563 } 5564 WCH_SAFE_COPY(dst.Offset, sizeof(dst.Offset), srcData, sizeof(dst.Offset)); 5565 } break; 5566 }; 5567 tok = tok + 1 + tok->valueDwordCount; 5568 } else { 5569 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 5570 switch (tok->id) { 5571 default: 5572 if (tok->flags.flag3IsMandatory) { 5573 return false; 5574 } 5575 break; 5576 case TOK_S_GMM_2D_TEXTURE_OFFSET_INFO_REC: 5577 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 5578 return false; 5579 } 5580 break; 5581 }; 5582 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 5583 } 5584 } 5585 WCH_ASSERT(tok == srcTokensEnd); 5586 return true; 5587 } 5588 }; 5589 5590 template <> 5591 struct Demarshaller<TOK_S_GMM_3D_TEXTURE_OFFSET_INFO_REC> { 5592 template <typename GMM_3D_TEXTURE_OFFSET_INFO_RECT> 5593 static bool demarshall(GMM_3D_TEXTURE_OFFSET_INFO_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 5594 const TokenHeader *tok = srcTokensBeg; 5595 while (tok < srcTokensEnd) { 5596 if (false == tok->flags.flag4IsVariableLength) { 5597 switch (tok->id) { 5598 default: 5599 if (tok->flags.flag3IsMandatory) { 5600 return false; 5601 } 5602 break; 5603 case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: { 5604 dst.Mip0SlicePitch = readTokValue<decltype(dst.Mip0SlicePitch)>(*tok); 5605 } break; 5606 case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: { 5607 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tok).getValue<char>(); 5608 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tok).getValueSizeInBytes(); 5609 if (srcSize < sizeof(dst.Offset)) { 5610 return false; 5611 } 5612 WCH_SAFE_COPY(dst.Offset, sizeof(dst.Offset), srcData, sizeof(dst.Offset)); 5613 } break; 5614 }; 5615 tok = tok + 1 + tok->valueDwordCount; 5616 } else { 5617 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 5618 switch (tok->id) { 5619 default: 5620 if (tok->flags.flag3IsMandatory) { 5621 return false; 5622 } 5623 break; 5624 case TOK_S_GMM_3D_TEXTURE_OFFSET_INFO_REC: 5625 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 5626 return false; 5627 } 5628 break; 5629 }; 5630 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 5631 } 5632 } 5633 WCH_ASSERT(tok == srcTokensEnd); 5634 return true; 5635 } 5636 }; 5637 5638 template <> 5639 struct Demarshaller<TOK_S_GMM_OFFSET_INFO_REC> { 5640 template <typename GMM_OFFSET_INFO_RECT> 5641 static bool demarshall(GMM_OFFSET_INFO_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 5642 const TokenHeader *tok = srcTokensBeg; 5643 while (tok < srcTokensEnd) { 5644 if (false == tok->flags.flag4IsVariableLength) { 5645 if (tok->flags.flag3IsMandatory) { 5646 return false; 5647 } 5648 tok = tok + 1 + tok->valueDwordCount; 5649 } else { 5650 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 5651 switch (tok->id) { 5652 default: 5653 if (tok->flags.flag3IsMandatory) { 5654 return false; 5655 } 5656 break; 5657 case TOK_S_GMM_OFFSET_INFO_REC: 5658 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 5659 return false; 5660 } 5661 break; 5662 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO: { 5663 const TokenHeader *tokTexture3DOffsetInfo = varLen->getValue<TokenHeader>(); 5664 const TokenHeader *tokTexture3DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 5665 while (tokTexture3DOffsetInfo < tokTexture3DOffsetInfoEnd) { 5666 if (false == tokTexture3DOffsetInfo->flags.flag4IsVariableLength) { 5667 switch (tokTexture3DOffsetInfo->id) { 5668 default: 5669 if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { 5670 return false; 5671 } 5672 break; 5673 case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: { 5674 dst.Texture3DOffsetInfo.Mip0SlicePitch = readTokValue<decltype(dst.Texture3DOffsetInfo.Mip0SlicePitch)>(*tokTexture3DOffsetInfo); 5675 } break; 5676 case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: { 5677 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValue<char>(); 5678 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValueSizeInBytes(); 5679 if (srcSize < sizeof(dst.Texture3DOffsetInfo.Offset)) { 5680 return false; 5681 } 5682 WCH_SAFE_COPY(dst.Texture3DOffsetInfo.Offset, sizeof(dst.Texture3DOffsetInfo.Offset), srcData, sizeof(dst.Texture3DOffsetInfo.Offset)); 5683 } break; 5684 }; 5685 tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + 1 + tokTexture3DOffsetInfo->valueDwordCount; 5686 } else { 5687 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture3DOffsetInfo); 5688 if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { 5689 return false; 5690 } 5691 tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 5692 } 5693 } 5694 WCH_ASSERT(tokTexture3DOffsetInfo == tokTexture3DOffsetInfoEnd); 5695 } break; 5696 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO: { 5697 const TokenHeader *tokTexture2DOffsetInfo = varLen->getValue<TokenHeader>(); 5698 const TokenHeader *tokTexture2DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 5699 while (tokTexture2DOffsetInfo < tokTexture2DOffsetInfoEnd) { 5700 if (false == tokTexture2DOffsetInfo->flags.flag4IsVariableLength) { 5701 switch (tokTexture2DOffsetInfo->id) { 5702 default: 5703 if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { 5704 return false; 5705 } 5706 break; 5707 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: { 5708 dst.Texture2DOffsetInfo.ArrayQPitchLock = readTokValue<decltype(dst.Texture2DOffsetInfo.ArrayQPitchLock)>(*tokTexture2DOffsetInfo); 5709 } break; 5710 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: { 5711 dst.Texture2DOffsetInfo.ArrayQPitchRender = readTokValue<decltype(dst.Texture2DOffsetInfo.ArrayQPitchRender)>(*tokTexture2DOffsetInfo); 5712 } break; 5713 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: { 5714 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValue<char>(); 5715 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValueSizeInBytes(); 5716 if (srcSize < sizeof(dst.Texture2DOffsetInfo.Offset)) { 5717 return false; 5718 } 5719 WCH_SAFE_COPY(dst.Texture2DOffsetInfo.Offset, sizeof(dst.Texture2DOffsetInfo.Offset), srcData, sizeof(dst.Texture2DOffsetInfo.Offset)); 5720 } break; 5721 }; 5722 tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + 1 + tokTexture2DOffsetInfo->valueDwordCount; 5723 } else { 5724 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture2DOffsetInfo); 5725 if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { 5726 return false; 5727 } 5728 tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 5729 } 5730 } 5731 WCH_ASSERT(tokTexture2DOffsetInfo == tokTexture2DOffsetInfoEnd); 5732 } break; 5733 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE: { 5734 const TokenHeader *tokPlane = varLen->getValue<TokenHeader>(); 5735 const TokenHeader *tokPlaneEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 5736 while (tokPlane < tokPlaneEnd) { 5737 if (false == tokPlane->flags.flag4IsVariableLength) { 5738 switch (tokPlane->id) { 5739 default: 5740 if (tokPlane->flags.flag3IsMandatory) { 5741 return false; 5742 } 5743 break; 5744 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: { 5745 dst.Plane.ArrayQPitch = readTokValue<decltype(dst.Plane.ArrayQPitch)>(*tokPlane); 5746 } break; 5747 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: { 5748 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>(); 5749 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes(); 5750 if (srcSize < sizeof(dst.Plane.X)) { 5751 return false; 5752 } 5753 WCH_SAFE_COPY(dst.Plane.X, sizeof(dst.Plane.X), srcData, sizeof(dst.Plane.X)); 5754 } break; 5755 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: { 5756 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>(); 5757 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes(); 5758 if (srcSize < sizeof(dst.Plane.Y)) { 5759 return false; 5760 } 5761 WCH_SAFE_COPY(dst.Plane.Y, sizeof(dst.Plane.Y), srcData, sizeof(dst.Plane.Y)); 5762 } break; 5763 case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: { 5764 dst.Plane.NoOfPlanes = readTokValue<decltype(dst.Plane.NoOfPlanes)>(*tokPlane); 5765 } break; 5766 case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: { 5767 dst.Plane.IsTileAlignedPlanes = readTokValue<decltype(dst.Plane.IsTileAlignedPlanes)>(*tokPlane); 5768 } break; 5769 }; 5770 tokPlane = tokPlane + 1 + tokPlane->valueDwordCount; 5771 } else { 5772 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlane); 5773 switch (tokPlane->id) { 5774 default: 5775 if (tokPlane->flags.flag3IsMandatory) { 5776 return false; 5777 } 5778 break; 5779 case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: { 5780 const TokenHeader *tokUnAligned = varLen->getValue<TokenHeader>(); 5781 const TokenHeader *tokUnAlignedEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 5782 while (tokUnAligned < tokUnAlignedEnd) { 5783 if (false == tokUnAligned->flags.flag4IsVariableLength) { 5784 switch (tokUnAligned->id) { 5785 default: 5786 if (tokUnAligned->flags.flag3IsMandatory) { 5787 return false; 5788 } 5789 break; 5790 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: { 5791 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValue<char>(); 5792 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValueSizeInBytes(); 5793 if (srcSize < sizeof(dst.Plane.UnAligned.Height)) { 5794 return false; 5795 } 5796 WCH_SAFE_COPY(dst.Plane.UnAligned.Height, sizeof(dst.Plane.UnAligned.Height), srcData, sizeof(dst.Plane.UnAligned.Height)); 5797 } break; 5798 }; 5799 tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount; 5800 } else { 5801 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokUnAligned); 5802 if (tokUnAligned->flags.flag3IsMandatory) { 5803 return false; 5804 } 5805 tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 5806 } 5807 } 5808 WCH_ASSERT(tokUnAligned == tokUnAlignedEnd); 5809 } break; 5810 }; 5811 tokPlane = tokPlane + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 5812 } 5813 } 5814 WCH_ASSERT(tokPlane == tokPlaneEnd); 5815 } break; 5816 }; 5817 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 5818 } 5819 } 5820 WCH_ASSERT(tok == srcTokensEnd); 5821 return true; 5822 } 5823 }; 5824 5825 template <> 5826 struct Demarshaller<TOK_S_GMM_TEXTURE_INFO_REC> { 5827 template <typename GMM_TEXTURE_INFO_RECT> 5828 static bool demarshall(GMM_TEXTURE_INFO_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 5829 const TokenHeader *tok = srcTokensBeg; 5830 while (tok < srcTokensEnd) { 5831 if (false == tok->flags.flag4IsVariableLength) { 5832 switch (tok->id) { 5833 default: 5834 if (tok->flags.flag3IsMandatory) { 5835 return false; 5836 } 5837 break; 5838 case TOK_FE_GMM_TEXTURE_INFO_REC__TYPE: { 5839 dst.Type = readTokValue<decltype(dst.Type)>(*tok); 5840 } break; 5841 case TOK_FE_GMM_TEXTURE_INFO_REC__FORMAT: { 5842 dst.Format = readTokValue<decltype(dst.Format)>(*tok); 5843 } break; 5844 case TOK_FBD_GMM_TEXTURE_INFO_REC__BITS_PER_PIXEL: { 5845 dst.BitsPerPixel = readTokValue<decltype(dst.BitsPerPixel)>(*tok); 5846 } break; 5847 case TOK_FBQ_GMM_TEXTURE_INFO_REC__BASE_WIDTH: { 5848 dst.BaseWidth = readTokValue<decltype(dst.BaseWidth)>(*tok); 5849 } break; 5850 case TOK_FBD_GMM_TEXTURE_INFO_REC__BASE_HEIGHT: { 5851 dst.BaseHeight = readTokValue<decltype(dst.BaseHeight)>(*tok); 5852 } break; 5853 case TOK_FBD_GMM_TEXTURE_INFO_REC__DEPTH: { 5854 dst.Depth = readTokValue<decltype(dst.Depth)>(*tok); 5855 } break; 5856 case TOK_FBD_GMM_TEXTURE_INFO_REC__MAX_LOD: { 5857 dst.MaxLod = readTokValue<decltype(dst.MaxLod)>(*tok); 5858 } break; 5859 case TOK_FBD_GMM_TEXTURE_INFO_REC__ARRAY_SIZE: { 5860 dst.ArraySize = readTokValue<decltype(dst.ArraySize)>(*tok); 5861 } break; 5862 case TOK_FBD_GMM_TEXTURE_INFO_REC__CP_TAG: { 5863 dst.CpTag = readTokValue<decltype(dst.CpTag)>(*tok); 5864 } break; 5865 case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_MODE: { 5866 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tok).getValue<char>(); 5867 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tok).getValueSizeInBytes(); 5868 if (srcSize < sizeof(dst.MmcMode)) { 5869 return false; 5870 } 5871 WCH_SAFE_COPY(dst.MmcMode, sizeof(dst.MmcMode), srcData, sizeof(dst.MmcMode)); 5872 } break; 5873 case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_HINT: { 5874 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tok).getValue<char>(); 5875 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tok).getValueSizeInBytes(); 5876 if (srcSize < sizeof(dst.MmcHint)) { 5877 return false; 5878 } 5879 WCH_SAFE_COPY(dst.MmcHint, sizeof(dst.MmcHint), srcData, sizeof(dst.MmcHint)); 5880 } break; 5881 case TOK_FBQ_GMM_TEXTURE_INFO_REC__PITCH: { 5882 dst.Pitch = readTokValue<decltype(dst.Pitch)>(*tok); 5883 } break; 5884 case TOK_FBQ_GMM_TEXTURE_INFO_REC__OVERRIDE_PITCH: { 5885 dst.OverridePitch = readTokValue<decltype(dst.OverridePitch)>(*tok); 5886 } break; 5887 case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE: { 5888 dst.Size = readTokValue<decltype(dst.Size)>(*tok); 5889 } break; 5890 case TOK_FBQ_GMM_TEXTURE_INFO_REC__CCSIZE: { 5891 dst.CCSize = readTokValue<decltype(dst.CCSize)>(*tok); 5892 } break; 5893 case TOK_FBQ_GMM_TEXTURE_INFO_REC__UNPADDED_SIZE: { 5894 dst.UnpaddedSize = readTokValue<decltype(dst.UnpaddedSize)>(*tok); 5895 } break; 5896 case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE_REPORT_TO_OS: { 5897 dst.SizeReportToOS = readTokValue<decltype(dst.SizeReportToOS)>(*tok); 5898 } break; 5899 case TOK_FE_GMM_TEXTURE_INFO_REC__TILE_MODE: { 5900 dst.TileMode = readTokValue<decltype(dst.TileMode)>(*tok); 5901 } break; 5902 case TOK_FBD_GMM_TEXTURE_INFO_REC__CCSMODE_ALIGN: { 5903 dst.CCSModeAlign = readTokValue<decltype(dst.CCSModeAlign)>(*tok); 5904 } break; 5905 case TOK_FBD_GMM_TEXTURE_INFO_REC__LEGACY_FLAGS: { 5906 dst.LegacyFlags = readTokValue<decltype(dst.LegacyFlags)>(*tok); 5907 } break; 5908 case TOK_FBD_GMM_TEXTURE_INFO_REC__MAXIMUM_RENAMING_LIST_LENGTH: { 5909 dst.MaximumRenamingListLength = readTokValue<decltype(dst.MaximumRenamingListLength)>(*tok); 5910 } break; 5911 }; 5912 tok = tok + 1 + tok->valueDwordCount; 5913 } else { 5914 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 5915 switch (tok->id) { 5916 default: 5917 if (tok->flags.flag3IsMandatory) { 5918 return false; 5919 } 5920 break; 5921 case TOK_S_GMM_TEXTURE_INFO_REC: 5922 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 5923 return false; 5924 } 5925 break; 5926 case TOK_FS_GMM_TEXTURE_INFO_REC__FLAGS: { 5927 const TokenHeader *tokFlags = varLen->getValue<TokenHeader>(); 5928 const TokenHeader *tokFlagsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 5929 while (tokFlags < tokFlagsEnd) { 5930 if (false == tokFlags->flags.flag4IsVariableLength) { 5931 if (tokFlags->flags.flag3IsMandatory) { 5932 return false; 5933 } 5934 tokFlags = tokFlags + 1 + tokFlags->valueDwordCount; 5935 } else { 5936 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokFlags); 5937 switch (tokFlags->id) { 5938 default: 5939 if (tokFlags->flags.flag3IsMandatory) { 5940 return false; 5941 } 5942 break; 5943 case TOK_FS_GMM_RESOURCE_FLAG_REC__GPU: { 5944 const TokenHeader *tokGpu = varLen->getValue<TokenHeader>(); 5945 const TokenHeader *tokGpuEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 5946 while (tokGpu < tokGpuEnd) { 5947 if (false == tokGpu->flags.flag4IsVariableLength) { 5948 switch (tokGpu->id) { 5949 default: 5950 if (tokGpu->flags.flag3IsMandatory) { 5951 return false; 5952 } 5953 break; 5954 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CAMERA_CAPTURE: { 5955 dst.Flags.Gpu.CameraCapture = readTokValue<decltype(dst.Flags.Gpu.CameraCapture)>(*tokGpu); 5956 } break; 5957 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CCS: { 5958 dst.Flags.Gpu.CCS = readTokValue<decltype(dst.Flags.Gpu.CCS)>(*tokGpu); 5959 } break; 5960 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_DISCARD: { 5961 dst.Flags.Gpu.ColorDiscard = readTokValue<decltype(dst.Flags.Gpu.ColorDiscard)>(*tokGpu); 5962 } break; 5963 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION: { 5964 dst.Flags.Gpu.ColorSeparation = readTokValue<decltype(dst.Flags.Gpu.ColorSeparation)>(*tokGpu); 5965 } break; 5966 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION_RGBX: { 5967 dst.Flags.Gpu.ColorSeparationRGBX = readTokValue<decltype(dst.Flags.Gpu.ColorSeparationRGBX)>(*tokGpu); 5968 } break; 5969 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CONSTANT: { 5970 dst.Flags.Gpu.Constant = readTokValue<decltype(dst.Flags.Gpu.Constant)>(*tokGpu); 5971 } break; 5972 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__DEPTH: { 5973 dst.Flags.Gpu.Depth = readTokValue<decltype(dst.Flags.Gpu.Depth)>(*tokGpu); 5974 } break; 5975 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN: { 5976 dst.Flags.Gpu.FlipChain = readTokValue<decltype(dst.Flags.Gpu.FlipChain)>(*tokGpu); 5977 } break; 5978 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN_PREFERRED: { 5979 dst.Flags.Gpu.FlipChainPreferred = readTokValue<decltype(dst.Flags.Gpu.FlipChainPreferred)>(*tokGpu); 5980 } break; 5981 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HISTORY_BUFFER: { 5982 dst.Flags.Gpu.HistoryBuffer = readTokValue<decltype(dst.Flags.Gpu.HistoryBuffer)>(*tokGpu); 5983 } break; 5984 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HI_Z: { 5985 dst.Flags.Gpu.HiZ = readTokValue<decltype(dst.Flags.Gpu.HiZ)>(*tokGpu); 5986 } break; 5987 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDEX: { 5988 dst.Flags.Gpu.Index = readTokValue<decltype(dst.Flags.Gpu.Index)>(*tokGpu); 5989 } break; 5990 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDIRECT_CLEAR_COLOR: { 5991 dst.Flags.Gpu.IndirectClearColor = readTokValue<decltype(dst.Flags.Gpu.IndirectClearColor)>(*tokGpu); 5992 } break; 5993 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INSTRUCTION_FLAT: { 5994 dst.Flags.Gpu.InstructionFlat = readTokValue<decltype(dst.Flags.Gpu.InstructionFlat)>(*tokGpu); 5995 } break; 5996 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INTERLACED_SCAN: { 5997 dst.Flags.Gpu.InterlacedScan = readTokValue<decltype(dst.Flags.Gpu.InterlacedScan)>(*tokGpu); 5998 } break; 5999 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MCS: { 6000 dst.Flags.Gpu.MCS = readTokValue<decltype(dst.Flags.Gpu.MCS)>(*tokGpu); 6001 } break; 6002 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MMC: { 6003 dst.Flags.Gpu.MMC = readTokValue<decltype(dst.Flags.Gpu.MMC)>(*tokGpu); 6004 } break; 6005 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MOTION_COMP: { 6006 dst.Flags.Gpu.MotionComp = readTokValue<decltype(dst.Flags.Gpu.MotionComp)>(*tokGpu); 6007 } break; 6008 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__NO_RESTRICTION: { 6009 dst.Flags.Gpu.NoRestriction = readTokValue<decltype(dst.Flags.Gpu.NoRestriction)>(*tokGpu); 6010 } break; 6011 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__OVERLAY: { 6012 dst.Flags.Gpu.Overlay = readTokValue<decltype(dst.Flags.Gpu.Overlay)>(*tokGpu); 6013 } break; 6014 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PRESENTABLE: { 6015 dst.Flags.Gpu.Presentable = readTokValue<decltype(dst.Flags.Gpu.Presentable)>(*tokGpu); 6016 } break; 6017 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PROCEDURAL_TEXTURE: { 6018 dst.Flags.Gpu.ProceduralTexture = readTokValue<decltype(dst.Flags.Gpu.ProceduralTexture)>(*tokGpu); 6019 } break; 6020 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__QUERY: { 6021 dst.Flags.Gpu.Query = readTokValue<decltype(dst.Flags.Gpu.Query)>(*tokGpu); 6022 } break; 6023 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__RENDER_TARGET: { 6024 dst.Flags.Gpu.RenderTarget = readTokValue<decltype(dst.Flags.Gpu.RenderTarget)>(*tokGpu); 6025 } break; 6026 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D: { 6027 dst.Flags.Gpu.S3d = readTokValue<decltype(dst.Flags.Gpu.S3d)>(*tokGpu); 6028 } break; 6029 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D_DX: { 6030 dst.Flags.Gpu.S3dDx = readTokValue<decltype(dst.Flags.Gpu.S3dDx)>(*tokGpu); 6031 } break; 6032 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_NON_PACKED: { 6033 dst.Flags.Gpu.__S3dNonPacked = readTokValue<decltype(dst.Flags.Gpu.__S3dNonPacked)>(*tokGpu); 6034 } break; 6035 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_WIDI: { 6036 dst.Flags.Gpu.__S3dWidi = readTokValue<decltype(dst.Flags.Gpu.__S3dWidi)>(*tokGpu); 6037 } break; 6038 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SCRATCH_FLAT: { 6039 dst.Flags.Gpu.ScratchFlat = readTokValue<decltype(dst.Flags.Gpu.ScratchFlat)>(*tokGpu); 6040 } break; 6041 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SEPARATE_STENCIL: { 6042 dst.Flags.Gpu.SeparateStencil = readTokValue<decltype(dst.Flags.Gpu.SeparateStencil)>(*tokGpu); 6043 } break; 6044 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE: { 6045 dst.Flags.Gpu.State = readTokValue<decltype(dst.Flags.Gpu.State)>(*tokGpu); 6046 } break; 6047 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE_DX9CONSTANT_BUFFER: { 6048 dst.Flags.Gpu.StateDx9ConstantBuffer = readTokValue<decltype(dst.Flags.Gpu.StateDx9ConstantBuffer)>(*tokGpu); 6049 } break; 6050 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STREAM: { 6051 dst.Flags.Gpu.Stream = readTokValue<decltype(dst.Flags.Gpu.Stream)>(*tokGpu); 6052 } break; 6053 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXT_API: { 6054 dst.Flags.Gpu.TextApi = readTokValue<decltype(dst.Flags.Gpu.TextApi)>(*tokGpu); 6055 } break; 6056 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXTURE: { 6057 dst.Flags.Gpu.Texture = readTokValue<decltype(dst.Flags.Gpu.Texture)>(*tokGpu); 6058 } break; 6059 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILED_RESOURCE: { 6060 dst.Flags.Gpu.TiledResource = readTokValue<decltype(dst.Flags.Gpu.TiledResource)>(*tokGpu); 6061 } break; 6062 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILE_POOL: { 6063 dst.Flags.Gpu.TilePool = readTokValue<decltype(dst.Flags.Gpu.TilePool)>(*tokGpu); 6064 } break; 6065 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__UNIFIED_AUX_SURFACE: { 6066 dst.Flags.Gpu.UnifiedAuxSurface = readTokValue<decltype(dst.Flags.Gpu.UnifiedAuxSurface)>(*tokGpu); 6067 } break; 6068 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VERTEX: { 6069 dst.Flags.Gpu.Vertex = readTokValue<decltype(dst.Flags.Gpu.Vertex)>(*tokGpu); 6070 } break; 6071 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VIDEO: { 6072 dst.Flags.Gpu.Video = readTokValue<decltype(dst.Flags.Gpu.Video)>(*tokGpu); 6073 } break; 6074 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_XCCS: { 6075 dst.Flags.Gpu.__NonMsaaTileXCcs = readTokValue<decltype(dst.Flags.Gpu.__NonMsaaTileXCcs)>(*tokGpu); 6076 } break; 6077 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_YCCS: { 6078 dst.Flags.Gpu.__NonMsaaTileYCcs = readTokValue<decltype(dst.Flags.Gpu.__NonMsaaTileYCcs)>(*tokGpu); 6079 } break; 6080 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____MSAA_TILE_MCS: { 6081 dst.Flags.Gpu.__MsaaTileMcs = readTokValue<decltype(dst.Flags.Gpu.__MsaaTileMcs)>(*tokGpu); 6082 } break; 6083 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_LINEAR_CCS: { 6084 dst.Flags.Gpu.__NonMsaaLinearCCS = readTokValue<decltype(dst.Flags.Gpu.__NonMsaaLinearCCS)>(*tokGpu); 6085 } break; 6086 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____REMAINING: { 6087 dst.Flags.Gpu.__Remaining = readTokValue<decltype(dst.Flags.Gpu.__Remaining)>(*tokGpu); 6088 } break; 6089 }; 6090 tokGpu = tokGpu + 1 + tokGpu->valueDwordCount; 6091 } else { 6092 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokGpu); 6093 if (tokGpu->flags.flag3IsMandatory) { 6094 return false; 6095 } 6096 tokGpu = tokGpu + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 6097 } 6098 } 6099 WCH_ASSERT(tokGpu == tokGpuEnd); 6100 } break; 6101 case TOK_FS_GMM_RESOURCE_FLAG_REC__INFO: { 6102 const TokenHeader *tokInfo = varLen->getValue<TokenHeader>(); 6103 const TokenHeader *tokInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 6104 while (tokInfo < tokInfoEnd) { 6105 if (false == tokInfo->flags.flag4IsVariableLength) { 6106 switch (tokInfo->id) { 6107 default: 6108 if (tokInfo->flags.flag3IsMandatory) { 6109 return false; 6110 } 6111 break; 6112 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ALLOW_VIRTUAL_PADDING: { 6113 dst.Flags.Info.AllowVirtualPadding = readTokValue<decltype(dst.Flags.Info.AllowVirtualPadding)>(*tokInfo); 6114 } break; 6115 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__BIG_PAGE: { 6116 dst.Flags.Info.BigPage = readTokValue<decltype(dst.Flags.Info.BigPage)>(*tokInfo); 6117 } break; 6118 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CACHEABLE: { 6119 dst.Flags.Info.Cacheable = readTokValue<decltype(dst.Flags.Info.Cacheable)>(*tokInfo); 6120 } break; 6121 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CONTIG_PHYS_MEMORY_FORI_DART: { 6122 dst.Flags.Info.ContigPhysMemoryForiDART = readTokValue<decltype(dst.Flags.Info.ContigPhysMemoryForiDART)>(*tokInfo); 6123 } break; 6124 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CORNER_TEXEL_MODE: { 6125 dst.Flags.Info.CornerTexelMode = readTokValue<decltype(dst.Flags.Info.CornerTexelMode)>(*tokInfo); 6126 } break; 6127 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__EXISTING_SYS_MEM: { 6128 dst.Flags.Info.ExistingSysMem = readTokValue<decltype(dst.Flags.Info.ExistingSysMem)>(*tokInfo); 6129 } break; 6130 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__FORCE_RESIDENCY: { 6131 dst.Flags.Info.ForceResidency = readTokValue<decltype(dst.Flags.Info.ForceResidency)>(*tokInfo); 6132 } break; 6133 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GFDT: { 6134 dst.Flags.Info.Gfdt = readTokValue<decltype(dst.Flags.Info.Gfdt)>(*tokInfo); 6135 } break; 6136 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GTT_MAP_TYPE: { 6137 dst.Flags.Info.GttMapType = readTokValue<decltype(dst.Flags.Info.GttMapType)>(*tokInfo); 6138 } break; 6139 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__HARDWARE_PROTECTED: { 6140 dst.Flags.Info.HardwareProtected = readTokValue<decltype(dst.Flags.Info.HardwareProtected)>(*tokInfo); 6141 } break; 6142 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__KERNEL_MODE_MAPPED: { 6143 dst.Flags.Info.KernelModeMapped = readTokValue<decltype(dst.Flags.Info.KernelModeMapped)>(*tokInfo); 6144 } break; 6145 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_BELOW: { 6146 dst.Flags.Info.LayoutBelow = readTokValue<decltype(dst.Flags.Info.LayoutBelow)>(*tokInfo); 6147 } break; 6148 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_MONO: { 6149 dst.Flags.Info.LayoutMono = readTokValue<decltype(dst.Flags.Info.LayoutMono)>(*tokInfo); 6150 } break; 6151 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_RIGHT: { 6152 dst.Flags.Info.LayoutRight = readTokValue<decltype(dst.Flags.Info.LayoutRight)>(*tokInfo); 6153 } break; 6154 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LOCAL_ONLY: { 6155 dst.Flags.Info.LocalOnly = readTokValue<decltype(dst.Flags.Info.LocalOnly)>(*tokInfo); 6156 } break; 6157 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LINEAR: { 6158 dst.Flags.Info.Linear = readTokValue<decltype(dst.Flags.Info.Linear)>(*tokInfo); 6159 } break; 6160 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__MEDIA_COMPRESSED: { 6161 dst.Flags.Info.MediaCompressed = readTokValue<decltype(dst.Flags.Info.MediaCompressed)>(*tokInfo); 6162 } break; 6163 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_OPTIMIZATION_PADDING: { 6164 dst.Flags.Info.NoOptimizationPadding = readTokValue<decltype(dst.Flags.Info.NoOptimizationPadding)>(*tokInfo); 6165 } break; 6166 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_PHYS_MEMORY: { 6167 dst.Flags.Info.NoPhysMemory = readTokValue<decltype(dst.Flags.Info.NoPhysMemory)>(*tokInfo); 6168 } break; 6169 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NOT_LOCKABLE: { 6170 dst.Flags.Info.NotLockable = readTokValue<decltype(dst.Flags.Info.NotLockable)>(*tokInfo); 6171 } break; 6172 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NON_LOCAL_ONLY: { 6173 dst.Flags.Info.NonLocalOnly = readTokValue<decltype(dst.Flags.Info.NonLocalOnly)>(*tokInfo); 6174 } break; 6175 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__STD_SWIZZLE: { 6176 dst.Flags.Info.StdSwizzle = readTokValue<decltype(dst.Flags.Info.StdSwizzle)>(*tokInfo); 6177 } break; 6178 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__PSEUDO_STD_SWIZZLE: { 6179 dst.Flags.Info.PseudoStdSwizzle = readTokValue<decltype(dst.Flags.Info.PseudoStdSwizzle)>(*tokInfo); 6180 } break; 6181 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__UNDEFINED64KBSWIZZLE: { 6182 dst.Flags.Info.Undefined64KBSwizzle = readTokValue<decltype(dst.Flags.Info.Undefined64KBSwizzle)>(*tokInfo); 6183 } break; 6184 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__REDECRIBED_PLANES: { 6185 dst.Flags.Info.RedecribedPlanes = readTokValue<decltype(dst.Flags.Info.RedecribedPlanes)>(*tokInfo); 6186 } break; 6187 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__RENDER_COMPRESSED: { 6188 dst.Flags.Info.RenderCompressed = readTokValue<decltype(dst.Flags.Info.RenderCompressed)>(*tokInfo); 6189 } break; 6190 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ROTATED: { 6191 dst.Flags.Info.Rotated = readTokValue<decltype(dst.Flags.Info.Rotated)>(*tokInfo); 6192 } break; 6193 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SHARED: { 6194 dst.Flags.Info.Shared = readTokValue<decltype(dst.Flags.Info.Shared)>(*tokInfo); 6195 } break; 6196 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SOFTWARE_PROTECTED: { 6197 dst.Flags.Info.SoftwareProtected = readTokValue<decltype(dst.Flags.Info.SoftwareProtected)>(*tokInfo); 6198 } break; 6199 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SVM: { 6200 dst.Flags.Info.SVM = readTokValue<decltype(dst.Flags.Info.SVM)>(*tokInfo); 6201 } break; 6202 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE4: { 6203 dst.Flags.Info.Tile4 = readTokValue<decltype(dst.Flags.Info.Tile4)>(*tokInfo); 6204 } break; 6205 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE64: { 6206 dst.Flags.Info.Tile64 = readTokValue<decltype(dst.Flags.Info.Tile64)>(*tokInfo); 6207 } break; 6208 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_W: { 6209 dst.Flags.Info.TiledW = readTokValue<decltype(dst.Flags.Info.TiledW)>(*tokInfo); 6210 } break; 6211 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_X: { 6212 dst.Flags.Info.TiledX = readTokValue<decltype(dst.Flags.Info.TiledX)>(*tokInfo); 6213 } break; 6214 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_Y: { 6215 dst.Flags.Info.TiledY = readTokValue<decltype(dst.Flags.Info.TiledY)>(*tokInfo); 6216 } break; 6217 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YF: { 6218 dst.Flags.Info.TiledYf = readTokValue<decltype(dst.Flags.Info.TiledYf)>(*tokInfo); 6219 } break; 6220 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YS: { 6221 dst.Flags.Info.TiledYs = readTokValue<decltype(dst.Flags.Info.TiledYs)>(*tokInfo); 6222 } break; 6223 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__WDDM_PROTECTED: { 6224 dst.Flags.Info.WddmProtected = readTokValue<decltype(dst.Flags.Info.WddmProtected)>(*tokInfo); 6225 } break; 6226 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__XADAPTER: { 6227 dst.Flags.Info.XAdapter = readTokValue<decltype(dst.Flags.Info.XAdapter)>(*tokInfo); 6228 } break; 6229 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PREALLOCATED_RES_INFO: { 6230 dst.Flags.Info.__PreallocatedResInfo = readTokValue<decltype(dst.Flags.Info.__PreallocatedResInfo)>(*tokInfo); 6231 } break; 6232 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PRE_WDDM2SVM: { 6233 dst.Flags.Info.__PreWddm2SVM = readTokValue<decltype(dst.Flags.Info.__PreWddm2SVM)>(*tokInfo); 6234 } break; 6235 }; 6236 tokInfo = tokInfo + 1 + tokInfo->valueDwordCount; 6237 } else { 6238 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInfo); 6239 if (tokInfo->flags.flag3IsMandatory) { 6240 return false; 6241 } 6242 tokInfo = tokInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 6243 } 6244 } 6245 WCH_ASSERT(tokInfo == tokInfoEnd); 6246 } break; 6247 case TOK_FS_GMM_RESOURCE_FLAG_REC__WA: { 6248 const TokenHeader *tokWa = varLen->getValue<TokenHeader>(); 6249 const TokenHeader *tokWaEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 6250 while (tokWa < tokWaEnd) { 6251 if (false == tokWa->flags.flag4IsVariableLength) { 6252 switch (tokWa->id) { 6253 default: 6254 if (tokWa->flags.flag3IsMandatory) { 6255 return false; 6256 } 6257 break; 6258 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__GTMFX2ND_LEVEL_BATCH_RING_SIZE_ALIGN: { 6259 dst.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign = readTokValue<decltype(dst.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign)>(*tokWa); 6260 } break; 6261 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_MPR_ROW_STORE32KALIGN: { 6262 dst.Flags.Wa.ILKNeedAvcMprRowStore32KAlign = readTokValue<decltype(dst.Flags.Wa.ILKNeedAvcMprRowStore32KAlign)>(*tokWa); 6263 } break; 6264 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_DMV_BUFFER32KALIGN: { 6265 dst.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign = readTokValue<decltype(dst.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign)>(*tokWa); 6266 } break; 6267 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_BUFFER_SAMPLER_PADDING: { 6268 dst.Flags.Wa.NoBufferSamplerPadding = readTokValue<decltype(dst.Flags.Wa.NoBufferSamplerPadding)>(*tokWa); 6269 } break; 6270 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_LEGACY_PLANAR_LINEAR_VIDEO_RESTRICTIONS: { 6271 dst.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions = readTokValue<decltype(dst.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions)>(*tokWa); 6272 } break; 6273 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__CHVASTC_SKIP_VIRTUAL_MIPS: { 6274 dst.Flags.Wa.CHVAstcSkipVirtualMips = readTokValue<decltype(dst.Flags.Wa.CHVAstcSkipVirtualMips)>(*tokWa); 6275 } break; 6276 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_PACKED_MIP_TAIL: { 6277 dst.Flags.Wa.DisablePackedMipTail = readTokValue<decltype(dst.Flags.Wa.DisablePackedMipTail)>(*tokWa); 6278 } break; 6279 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521____FORCE_OTHER_HVALIGN4: { 6280 dst.Flags.Wa.__ForceOtherHVALIGN4 = readTokValue<decltype(dst.Flags.Wa.__ForceOtherHVALIGN4)>(*tokWa); 6281 } break; 6282 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR: { 6283 dst.Flags.Wa.DisableDisplayCcsClearColor = readTokValue<decltype(dst.Flags.Wa.DisableDisplayCcsClearColor)>(*tokWa); 6284 } break; 6285 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION: { 6286 dst.Flags.Wa.DisableDisplayCcsCompression = readTokValue<decltype(dst.Flags.Wa.DisableDisplayCcsCompression)>(*tokWa); 6287 } break; 6288 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: { 6289 dst.Flags.Wa.PreGen12FastClearOnly = readTokValue<decltype(dst.Flags.Wa.PreGen12FastClearOnly)>(*tokWa); 6290 } break; 6291 }; 6292 tokWa = tokWa + 1 + tokWa->valueDwordCount; 6293 } else { 6294 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokWa); 6295 if (tokWa->flags.flag3IsMandatory) { 6296 return false; 6297 } 6298 tokWa = tokWa + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 6299 } 6300 } 6301 WCH_ASSERT(tokWa == tokWaEnd); 6302 } break; 6303 }; 6304 tokFlags = tokFlags + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 6305 } 6306 } 6307 WCH_ASSERT(tokFlags == tokFlagsEnd); 6308 } break; 6309 case TOK_FS_GMM_TEXTURE_INFO_REC__CACHE_POLICY: { 6310 const TokenHeader *tokCachePolicy = varLen->getValue<TokenHeader>(); 6311 const TokenHeader *tokCachePolicyEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 6312 while (tokCachePolicy < tokCachePolicyEnd) { 6313 if (false == tokCachePolicy->flags.flag4IsVariableLength) { 6314 switch (tokCachePolicy->id) { 6315 default: 6316 if (tokCachePolicy->flags.flag3IsMandatory) { 6317 return false; 6318 } 6319 break; 6320 case TOK_FE_GMM_TEXTURE_INFO_REC__ANONYMOUS4927__USAGE: { 6321 dst.CachePolicy.Usage = readTokValue<decltype(dst.CachePolicy.Usage)>(*tokCachePolicy); 6322 } break; 6323 }; 6324 tokCachePolicy = tokCachePolicy + 1 + tokCachePolicy->valueDwordCount; 6325 } else { 6326 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCachePolicy); 6327 if (tokCachePolicy->flags.flag3IsMandatory) { 6328 return false; 6329 } 6330 tokCachePolicy = tokCachePolicy + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 6331 } 6332 } 6333 WCH_ASSERT(tokCachePolicy == tokCachePolicyEnd); 6334 } break; 6335 case TOK_FS_GMM_TEXTURE_INFO_REC__MSAA: { 6336 const TokenHeader *tokMSAA = varLen->getValue<TokenHeader>(); 6337 const TokenHeader *tokMSAAEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 6338 while (tokMSAA < tokMSAAEnd) { 6339 if (false == tokMSAA->flags.flag4IsVariableLength) { 6340 switch (tokMSAA->id) { 6341 default: 6342 if (tokMSAA->flags.flag3IsMandatory) { 6343 return false; 6344 } 6345 break; 6346 case TOK_FE_GMM_RESOURCE_MSAA_INFO_REC__SAMPLE_PATTERN: { 6347 dst.MSAA.SamplePattern = readTokValue<decltype(dst.MSAA.SamplePattern)>(*tokMSAA); 6348 } break; 6349 case TOK_FBD_GMM_RESOURCE_MSAA_INFO_REC__NUM_SAMPLES: { 6350 dst.MSAA.NumSamples = readTokValue<decltype(dst.MSAA.NumSamples)>(*tokMSAA); 6351 } break; 6352 }; 6353 tokMSAA = tokMSAA + 1 + tokMSAA->valueDwordCount; 6354 } else { 6355 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokMSAA); 6356 if (tokMSAA->flags.flag3IsMandatory) { 6357 return false; 6358 } 6359 tokMSAA = tokMSAA + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 6360 } 6361 } 6362 WCH_ASSERT(tokMSAA == tokMSAAEnd); 6363 } break; 6364 case TOK_FS_GMM_TEXTURE_INFO_REC__ALIGNMENT: { 6365 const TokenHeader *tokAlignment = varLen->getValue<TokenHeader>(); 6366 const TokenHeader *tokAlignmentEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 6367 while (tokAlignment < tokAlignmentEnd) { 6368 if (false == tokAlignment->flags.flag4IsVariableLength) { 6369 switch (tokAlignment->id) { 6370 default: 6371 if (tokAlignment->flags.flag3IsMandatory) { 6372 return false; 6373 } 6374 break; 6375 case TOK_FBC_GMM_RESOURCE_ALIGNMENT_REC__ARRAY_SPACING_SINGLE_LOD: { 6376 dst.Alignment.ArraySpacingSingleLod = readTokValue<decltype(dst.Alignment.ArraySpacingSingleLod)>(*tokAlignment); 6377 } break; 6378 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__BASE_ALIGNMENT: { 6379 dst.Alignment.BaseAlignment = readTokValue<decltype(dst.Alignment.BaseAlignment)>(*tokAlignment); 6380 } break; 6381 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__HALIGN: { 6382 dst.Alignment.HAlign = readTokValue<decltype(dst.Alignment.HAlign)>(*tokAlignment); 6383 } break; 6384 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__VALIGN: { 6385 dst.Alignment.VAlign = readTokValue<decltype(dst.Alignment.VAlign)>(*tokAlignment); 6386 } break; 6387 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__DALIGN: { 6388 dst.Alignment.DAlign = readTokValue<decltype(dst.Alignment.DAlign)>(*tokAlignment); 6389 } break; 6390 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__MIP_TAIL_START_LOD: { 6391 dst.Alignment.MipTailStartLod = readTokValue<decltype(dst.Alignment.MipTailStartLod)>(*tokAlignment); 6392 } break; 6393 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_START_LOD: { 6394 dst.Alignment.PackedMipStartLod = readTokValue<decltype(dst.Alignment.PackedMipStartLod)>(*tokAlignment); 6395 } break; 6396 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_WIDTH: { 6397 dst.Alignment.PackedMipWidth = readTokValue<decltype(dst.Alignment.PackedMipWidth)>(*tokAlignment); 6398 } break; 6399 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_HEIGHT: { 6400 dst.Alignment.PackedMipHeight = readTokValue<decltype(dst.Alignment.PackedMipHeight)>(*tokAlignment); 6401 } break; 6402 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__QPITCH: { 6403 dst.Alignment.QPitch = readTokValue<decltype(dst.Alignment.QPitch)>(*tokAlignment); 6404 } break; 6405 }; 6406 tokAlignment = tokAlignment + 1 + tokAlignment->valueDwordCount; 6407 } else { 6408 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokAlignment); 6409 if (tokAlignment->flags.flag3IsMandatory) { 6410 return false; 6411 } 6412 tokAlignment = tokAlignment + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 6413 } 6414 } 6415 WCH_ASSERT(tokAlignment == tokAlignmentEnd); 6416 } break; 6417 case TOK_FS_GMM_TEXTURE_INFO_REC__OFFSET_INFO: { 6418 const TokenHeader *tokOffsetInfo = varLen->getValue<TokenHeader>(); 6419 const TokenHeader *tokOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 6420 while (tokOffsetInfo < tokOffsetInfoEnd) { 6421 if (false == tokOffsetInfo->flags.flag4IsVariableLength) { 6422 if (tokOffsetInfo->flags.flag3IsMandatory) { 6423 return false; 6424 } 6425 tokOffsetInfo = tokOffsetInfo + 1 + tokOffsetInfo->valueDwordCount; 6426 } else { 6427 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokOffsetInfo); 6428 switch (tokOffsetInfo->id) { 6429 default: 6430 if (tokOffsetInfo->flags.flag3IsMandatory) { 6431 return false; 6432 } 6433 break; 6434 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO: { 6435 const TokenHeader *tokTexture3DOffsetInfo = varLen->getValue<TokenHeader>(); 6436 const TokenHeader *tokTexture3DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 6437 while (tokTexture3DOffsetInfo < tokTexture3DOffsetInfoEnd) { 6438 if (false == tokTexture3DOffsetInfo->flags.flag4IsVariableLength) { 6439 switch (tokTexture3DOffsetInfo->id) { 6440 default: 6441 if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { 6442 return false; 6443 } 6444 break; 6445 case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: { 6446 dst.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch = readTokValue<decltype(dst.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch)>(*tokTexture3DOffsetInfo); 6447 } break; 6448 case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: { 6449 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValue<char>(); 6450 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValueSizeInBytes(); 6451 if (srcSize < sizeof(dst.OffsetInfo.Texture3DOffsetInfo.Offset)) { 6452 return false; 6453 } 6454 WCH_SAFE_COPY(dst.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(dst.OffsetInfo.Texture3DOffsetInfo.Offset), srcData, sizeof(dst.OffsetInfo.Texture3DOffsetInfo.Offset)); 6455 } break; 6456 }; 6457 tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + 1 + tokTexture3DOffsetInfo->valueDwordCount; 6458 } else { 6459 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture3DOffsetInfo); 6460 if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { 6461 return false; 6462 } 6463 tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 6464 } 6465 } 6466 WCH_ASSERT(tokTexture3DOffsetInfo == tokTexture3DOffsetInfoEnd); 6467 } break; 6468 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO: { 6469 const TokenHeader *tokTexture2DOffsetInfo = varLen->getValue<TokenHeader>(); 6470 const TokenHeader *tokTexture2DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 6471 while (tokTexture2DOffsetInfo < tokTexture2DOffsetInfoEnd) { 6472 if (false == tokTexture2DOffsetInfo->flags.flag4IsVariableLength) { 6473 switch (tokTexture2DOffsetInfo->id) { 6474 default: 6475 if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { 6476 return false; 6477 } 6478 break; 6479 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: { 6480 dst.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock = readTokValue<decltype(dst.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock)>(*tokTexture2DOffsetInfo); 6481 } break; 6482 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: { 6483 dst.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender = readTokValue<decltype(dst.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender)>(*tokTexture2DOffsetInfo); 6484 } break; 6485 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: { 6486 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValue<char>(); 6487 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValueSizeInBytes(); 6488 if (srcSize < sizeof(dst.OffsetInfo.Texture2DOffsetInfo.Offset)) { 6489 return false; 6490 } 6491 WCH_SAFE_COPY(dst.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(dst.OffsetInfo.Texture2DOffsetInfo.Offset), srcData, sizeof(dst.OffsetInfo.Texture2DOffsetInfo.Offset)); 6492 } break; 6493 }; 6494 tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + 1 + tokTexture2DOffsetInfo->valueDwordCount; 6495 } else { 6496 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture2DOffsetInfo); 6497 if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { 6498 return false; 6499 } 6500 tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 6501 } 6502 } 6503 WCH_ASSERT(tokTexture2DOffsetInfo == tokTexture2DOffsetInfoEnd); 6504 } break; 6505 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE: { 6506 const TokenHeader *tokPlane = varLen->getValue<TokenHeader>(); 6507 const TokenHeader *tokPlaneEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 6508 while (tokPlane < tokPlaneEnd) { 6509 if (false == tokPlane->flags.flag4IsVariableLength) { 6510 switch (tokPlane->id) { 6511 default: 6512 if (tokPlane->flags.flag3IsMandatory) { 6513 return false; 6514 } 6515 break; 6516 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: { 6517 dst.OffsetInfo.Plane.ArrayQPitch = readTokValue<decltype(dst.OffsetInfo.Plane.ArrayQPitch)>(*tokPlane); 6518 } break; 6519 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: { 6520 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>(); 6521 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes(); 6522 if (srcSize < sizeof(dst.OffsetInfo.Plane.X)) { 6523 return false; 6524 } 6525 WCH_SAFE_COPY(dst.OffsetInfo.Plane.X, sizeof(dst.OffsetInfo.Plane.X), srcData, sizeof(dst.OffsetInfo.Plane.X)); 6526 } break; 6527 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: { 6528 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>(); 6529 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes(); 6530 if (srcSize < sizeof(dst.OffsetInfo.Plane.Y)) { 6531 return false; 6532 } 6533 WCH_SAFE_COPY(dst.OffsetInfo.Plane.Y, sizeof(dst.OffsetInfo.Plane.Y), srcData, sizeof(dst.OffsetInfo.Plane.Y)); 6534 } break; 6535 case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: { 6536 dst.OffsetInfo.Plane.NoOfPlanes = readTokValue<decltype(dst.OffsetInfo.Plane.NoOfPlanes)>(*tokPlane); 6537 } break; 6538 case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: { 6539 dst.OffsetInfo.Plane.IsTileAlignedPlanes = readTokValue<decltype(dst.OffsetInfo.Plane.IsTileAlignedPlanes)>(*tokPlane); 6540 } break; 6541 }; 6542 tokPlane = tokPlane + 1 + tokPlane->valueDwordCount; 6543 } else { 6544 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlane); 6545 switch (tokPlane->id) { 6546 default: 6547 if (tokPlane->flags.flag3IsMandatory) { 6548 return false; 6549 } 6550 break; 6551 case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: { 6552 const TokenHeader *tokUnAligned = varLen->getValue<TokenHeader>(); 6553 const TokenHeader *tokUnAlignedEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 6554 while (tokUnAligned < tokUnAlignedEnd) { 6555 if (false == tokUnAligned->flags.flag4IsVariableLength) { 6556 switch (tokUnAligned->id) { 6557 default: 6558 if (tokUnAligned->flags.flag3IsMandatory) { 6559 return false; 6560 } 6561 break; 6562 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: { 6563 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValue<char>(); 6564 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValueSizeInBytes(); 6565 if (srcSize < sizeof(dst.OffsetInfo.Plane.UnAligned.Height)) { 6566 return false; 6567 } 6568 WCH_SAFE_COPY(dst.OffsetInfo.Plane.UnAligned.Height, sizeof(dst.OffsetInfo.Plane.UnAligned.Height), srcData, sizeof(dst.OffsetInfo.Plane.UnAligned.Height)); 6569 } break; 6570 }; 6571 tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount; 6572 } else { 6573 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokUnAligned); 6574 if (tokUnAligned->flags.flag3IsMandatory) { 6575 return false; 6576 } 6577 tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 6578 } 6579 } 6580 WCH_ASSERT(tokUnAligned == tokUnAlignedEnd); 6581 } break; 6582 }; 6583 tokPlane = tokPlane + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 6584 } 6585 } 6586 WCH_ASSERT(tokPlane == tokPlaneEnd); 6587 } break; 6588 }; 6589 tokOffsetInfo = tokOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 6590 } 6591 } 6592 WCH_ASSERT(tokOffsetInfo == tokOffsetInfoEnd); 6593 } break; 6594 case TOK_FS_GMM_TEXTURE_INFO_REC__S3D: { 6595 const TokenHeader *tokS3d = varLen->getValue<TokenHeader>(); 6596 const TokenHeader *tokS3dEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 6597 while (tokS3d < tokS3dEnd) { 6598 if (false == tokS3d->flags.flag4IsVariableLength) { 6599 switch (tokS3d->id) { 6600 default: 6601 if (tokS3d->flags.flag3IsMandatory) { 6602 return false; 6603 } 6604 break; 6605 case TOK_FBD_GMM_S3D_INFO_REC__DISPLAY_MODE_HEIGHT: { 6606 dst.S3d.DisplayModeHeight = readTokValue<decltype(dst.S3d.DisplayModeHeight)>(*tokS3d); 6607 } break; 6608 case TOK_FBD_GMM_S3D_INFO_REC__NUM_BLANK_ACTIVE_LINES: { 6609 dst.S3d.NumBlankActiveLines = readTokValue<decltype(dst.S3d.NumBlankActiveLines)>(*tokS3d); 6610 } break; 6611 case TOK_FBD_GMM_S3D_INFO_REC__RFRAME_OFFSET: { 6612 dst.S3d.RFrameOffset = readTokValue<decltype(dst.S3d.RFrameOffset)>(*tokS3d); 6613 } break; 6614 case TOK_FBD_GMM_S3D_INFO_REC__BLANK_AREA_OFFSET: { 6615 dst.S3d.BlankAreaOffset = readTokValue<decltype(dst.S3d.BlankAreaOffset)>(*tokS3d); 6616 } break; 6617 case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_HEIGHT: { 6618 dst.S3d.TallBufferHeight = readTokValue<decltype(dst.S3d.TallBufferHeight)>(*tokS3d); 6619 } break; 6620 case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_SIZE: { 6621 dst.S3d.TallBufferSize = readTokValue<decltype(dst.S3d.TallBufferSize)>(*tokS3d); 6622 } break; 6623 case TOK_FBC_GMM_S3D_INFO_REC__IS_RFRAME: { 6624 dst.S3d.IsRFrame = readTokValue<decltype(dst.S3d.IsRFrame)>(*tokS3d); 6625 } break; 6626 }; 6627 tokS3d = tokS3d + 1 + tokS3d->valueDwordCount; 6628 } else { 6629 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokS3d); 6630 if (tokS3d->flags.flag3IsMandatory) { 6631 return false; 6632 } 6633 tokS3d = tokS3d + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 6634 } 6635 } 6636 WCH_ASSERT(tokS3d == tokS3dEnd); 6637 } break; 6638 case TOK_FS_GMM_TEXTURE_INFO_REC__SEGMENT_OVERRIDE: { 6639 const TokenHeader *tokSegmentOverride = varLen->getValue<TokenHeader>(); 6640 const TokenHeader *tokSegmentOverrideEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 6641 while (tokSegmentOverride < tokSegmentOverrideEnd) { 6642 if (false == tokSegmentOverride->flags.flag4IsVariableLength) { 6643 switch (tokSegmentOverride->id) { 6644 default: 6645 if (tokSegmentOverride->flags.flag3IsMandatory) { 6646 return false; 6647 } 6648 break; 6649 case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__SEG1: { 6650 dst.SegmentOverride.Seg1 = readTokValue<decltype(dst.SegmentOverride.Seg1)>(*tokSegmentOverride); 6651 } break; 6652 case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__EVICT: { 6653 dst.SegmentOverride.Evict = readTokValue<decltype(dst.SegmentOverride.Evict)>(*tokSegmentOverride); 6654 } break; 6655 }; 6656 tokSegmentOverride = tokSegmentOverride + 1 + tokSegmentOverride->valueDwordCount; 6657 } else { 6658 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSegmentOverride); 6659 if (tokSegmentOverride->flags.flag3IsMandatory) { 6660 return false; 6661 } 6662 tokSegmentOverride = tokSegmentOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 6663 } 6664 } 6665 WCH_ASSERT(tokSegmentOverride == tokSegmentOverrideEnd); 6666 } break; 6667 case TOK_FS_GMM_TEXTURE_INFO_REC__PLATFORM: { 6668 #if _DEBUG || _RELEASE_INTERNAL 6669 const TokenHeader *tokPlatform = varLen->getValue<TokenHeader>(); 6670 const TokenHeader *tokPlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 6671 while (tokPlatform < tokPlatformEnd) { 6672 if (false == tokPlatform->flags.flag4IsVariableLength) { 6673 switch (tokPlatform->id) { 6674 default: 6675 if (tokPlatform->flags.flag3IsMandatory) { 6676 return false; 6677 } 6678 break; 6679 case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { 6680 dst.Platform.eProductFamily = readTokValue<decltype(dst.Platform.eProductFamily)>(*tokPlatform); 6681 } break; 6682 case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { 6683 dst.Platform.ePCHProductFamily = readTokValue<decltype(dst.Platform.ePCHProductFamily)>(*tokPlatform); 6684 } break; 6685 case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { 6686 dst.Platform.eDisplayCoreFamily = readTokValue<decltype(dst.Platform.eDisplayCoreFamily)>(*tokPlatform); 6687 } break; 6688 case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { 6689 dst.Platform.eRenderCoreFamily = readTokValue<decltype(dst.Platform.eRenderCoreFamily)>(*tokPlatform); 6690 } break; 6691 case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { 6692 dst.Platform.ePlatformType = readTokValue<decltype(dst.Platform.ePlatformType)>(*tokPlatform); 6693 } break; 6694 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { 6695 dst.Platform.usDeviceID = readTokValue<decltype(dst.Platform.usDeviceID)>(*tokPlatform); 6696 } break; 6697 case TOK_FBW_PLATFORM_STR__US_REV_ID: { 6698 dst.Platform.usRevId = readTokValue<decltype(dst.Platform.usRevId)>(*tokPlatform); 6699 } break; 6700 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { 6701 dst.Platform.usDeviceID_PCH = readTokValue<decltype(dst.Platform.usDeviceID_PCH)>(*tokPlatform); 6702 } break; 6703 case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { 6704 dst.Platform.usRevId_PCH = readTokValue<decltype(dst.Platform.usRevId_PCH)>(*tokPlatform); 6705 } break; 6706 case TOK_FE_PLATFORM_STR__E_GTTYPE: { 6707 dst.Platform.eGTType = readTokValue<decltype(dst.Platform.eGTType)>(*tokPlatform); 6708 } break; 6709 }; 6710 tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount; 6711 } else { 6712 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlatform); 6713 if (tokPlatform->flags.flag3IsMandatory) { 6714 return false; 6715 } 6716 tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 6717 } 6718 } 6719 WCH_ASSERT(tokPlatform == tokPlatformEnd); 6720 #endif 6721 } break; 6722 case TOK_FS_GMM_TEXTURE_INFO_REC__EXISTING_SYS_MEM: { 6723 const TokenHeader *tokExistingSysMem = varLen->getValue<TokenHeader>(); 6724 const TokenHeader *tokExistingSysMemEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 6725 while (tokExistingSysMem < tokExistingSysMemEnd) { 6726 if (false == tokExistingSysMem->flags.flag4IsVariableLength) { 6727 switch (tokExistingSysMem->id) { 6728 default: 6729 if (tokExistingSysMem->flags.flag3IsMandatory) { 6730 return false; 6731 } 6732 break; 6733 case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_GMM_ALLOCATED: { 6734 dst.ExistingSysMem.IsGmmAllocated = readTokValue<decltype(dst.ExistingSysMem.IsGmmAllocated)>(*tokExistingSysMem); 6735 } break; 6736 case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_PAGE_ALIGNED: { 6737 dst.ExistingSysMem.IsPageAligned = readTokValue<decltype(dst.ExistingSysMem.IsPageAligned)>(*tokExistingSysMem); 6738 } break; 6739 }; 6740 tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount; 6741 } else { 6742 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokExistingSysMem); 6743 if (tokExistingSysMem->flags.flag3IsMandatory) { 6744 return false; 6745 } 6746 tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 6747 } 6748 } 6749 WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd); 6750 } break; 6751 case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: { 6752 #if !(_DEBUG || _RELEASE_INTERNAL) 6753 const TokenHeader *tok__Platform = varLen->getValue<TokenHeader>(); 6754 const TokenHeader *tok__PlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 6755 while (tok__Platform < tok__PlatformEnd) { 6756 if (false == tok__Platform->flags.flag4IsVariableLength) { 6757 switch (tok__Platform->id) { 6758 default: 6759 if (tok__Platform->flags.flag3IsMandatory) { 6760 return false; 6761 } 6762 break; 6763 case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { 6764 dst.__Platform.eProductFamily = readTokValue<decltype(dst.__Platform.eProductFamily)>(*tok__Platform); 6765 } break; 6766 case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { 6767 dst.__Platform.ePCHProductFamily = readTokValue<decltype(dst.__Platform.ePCHProductFamily)>(*tok__Platform); 6768 } break; 6769 case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { 6770 dst.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.__Platform.eDisplayCoreFamily)>(*tok__Platform); 6771 } break; 6772 case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { 6773 dst.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.__Platform.eRenderCoreFamily)>(*tok__Platform); 6774 } break; 6775 case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { 6776 dst.__Platform.ePlatformType = readTokValue<decltype(dst.__Platform.ePlatformType)>(*tok__Platform); 6777 } break; 6778 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { 6779 dst.__Platform.usDeviceID = readTokValue<decltype(dst.__Platform.usDeviceID)>(*tok__Platform); 6780 } break; 6781 case TOK_FBW_PLATFORM_STR__US_REV_ID: { 6782 dst.__Platform.usRevId = readTokValue<decltype(dst.__Platform.usRevId)>(*tok__Platform); 6783 } break; 6784 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { 6785 dst.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.__Platform.usDeviceID_PCH)>(*tok__Platform); 6786 } break; 6787 case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { 6788 dst.__Platform.usRevId_PCH = readTokValue<decltype(dst.__Platform.usRevId_PCH)>(*tok__Platform); 6789 } break; 6790 case TOK_FE_PLATFORM_STR__E_GTTYPE: { 6791 dst.__Platform.eGTType = readTokValue<decltype(dst.__Platform.eGTType)>(*tok__Platform); 6792 } break; 6793 }; 6794 tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount; 6795 } else { 6796 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok__Platform); 6797 if (tok__Platform->flags.flag3IsMandatory) { 6798 return false; 6799 } 6800 tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 6801 } 6802 } 6803 WCH_ASSERT(tok__Platform == tok__PlatformEnd); 6804 #endif 6805 } break; 6806 }; 6807 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 6808 } 6809 } 6810 WCH_ASSERT(tok == srcTokensEnd); 6811 return true; 6812 } 6813 }; 6814 6815 template <> 6816 struct Demarshaller<TOK_S_GMM_EXISTING_SYS_MEM_REC> { 6817 template <typename GMM_EXISTING_SYS_MEM_RECT> 6818 static bool demarshall(GMM_EXISTING_SYS_MEM_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 6819 const TokenHeader *tok = srcTokensBeg; 6820 while (tok < srcTokensEnd) { 6821 if (false == tok->flags.flag4IsVariableLength) { 6822 switch (tok->id) { 6823 default: 6824 if (tok->flags.flag3IsMandatory) { 6825 return false; 6826 } 6827 break; 6828 case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_EXISTING_SYS_MEM: { 6829 dst.pExistingSysMem = readTokValue<decltype(dst.pExistingSysMem)>(*tok); 6830 } break; 6831 case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_VIRT_ADDRESS: { 6832 dst.pVirtAddress = readTokValue<decltype(dst.pVirtAddress)>(*tok); 6833 } break; 6834 case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_GFX_ALIGNED_VIRT_ADDRESS: { 6835 dst.pGfxAlignedVirtAddress = readTokValue<decltype(dst.pGfxAlignedVirtAddress)>(*tok); 6836 } break; 6837 case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__SIZE: { 6838 dst.Size = readTokValue<decltype(dst.Size)>(*tok); 6839 } break; 6840 case TOK_FBC_GMM_EXISTING_SYS_MEM_REC__IS_GMM_ALLOCATED: { 6841 dst.IsGmmAllocated = readTokValue<decltype(dst.IsGmmAllocated)>(*tok); 6842 } break; 6843 }; 6844 tok = tok + 1 + tok->valueDwordCount; 6845 } else { 6846 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 6847 switch (tok->id) { 6848 default: 6849 if (tok->flags.flag3IsMandatory) { 6850 return false; 6851 } 6852 break; 6853 case TOK_S_GMM_EXISTING_SYS_MEM_REC: 6854 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 6855 return false; 6856 } 6857 break; 6858 }; 6859 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 6860 } 6861 } 6862 WCH_ASSERT(tok == srcTokensEnd); 6863 return true; 6864 } 6865 }; 6866 6867 template <> 6868 struct Demarshaller<TOK_S_GMM_RESOURCE_INFO_COMMON_STRUCT> { 6869 template <typename GmmResourceInfoCommonStructT> 6870 static bool demarshall(GmmResourceInfoCommonStructT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 6871 const TokenHeader *tok = srcTokensBeg; 6872 while (tok < srcTokensEnd) { 6873 if (false == tok->flags.flag4IsVariableLength) { 6874 switch (tok->id) { 6875 default: 6876 if (tok->flags.flag3IsMandatory) { 6877 return false; 6878 } 6879 break; 6880 case TOK_FE_GMM_RESOURCE_INFO_COMMON_STRUCT__CLIENT_TYPE: { 6881 dst.ClientType = readTokValue<decltype(dst.ClientType)>(*tok); 6882 } break; 6883 case TOK_FBD_GMM_RESOURCE_INFO_COMMON_STRUCT__ROTATE_INFO: { 6884 dst.RotateInfo = readTokValue<decltype(dst.RotateInfo)>(*tok); 6885 } break; 6886 case TOK_FBQ_GMM_RESOURCE_INFO_COMMON_STRUCT__SVM_ADDRESS: { 6887 dst.SvmAddress = readTokValue<decltype(dst.SvmAddress)>(*tok); 6888 } break; 6889 case TOK_FBQ_GMM_RESOURCE_INFO_COMMON_STRUCT__P_PRIVATE_DATA: { 6890 dst.pPrivateData = readTokValue<decltype(dst.pPrivateData)>(*tok); 6891 } break; 6892 }; 6893 tok = tok + 1 + tok->valueDwordCount; 6894 } else { 6895 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 6896 switch (tok->id) { 6897 default: 6898 if (tok->flags.flag3IsMandatory) { 6899 return false; 6900 } 6901 break; 6902 case TOK_S_GMM_RESOURCE_INFO_COMMON_STRUCT: 6903 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 6904 return false; 6905 } 6906 break; 6907 case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__SURF: { 6908 const TokenHeader *tokSurf = varLen->getValue<TokenHeader>(); 6909 const TokenHeader *tokSurfEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 6910 while (tokSurf < tokSurfEnd) { 6911 if (false == tokSurf->flags.flag4IsVariableLength) { 6912 switch (tokSurf->id) { 6913 default: 6914 if (tokSurf->flags.flag3IsMandatory) { 6915 return false; 6916 } 6917 break; 6918 case TOK_FE_GMM_TEXTURE_INFO_REC__TYPE: { 6919 dst.Surf.Type = readTokValue<decltype(dst.Surf.Type)>(*tokSurf); 6920 } break; 6921 case TOK_FE_GMM_TEXTURE_INFO_REC__FORMAT: { 6922 dst.Surf.Format = readTokValue<decltype(dst.Surf.Format)>(*tokSurf); 6923 } break; 6924 case TOK_FBD_GMM_TEXTURE_INFO_REC__BITS_PER_PIXEL: { 6925 dst.Surf.BitsPerPixel = readTokValue<decltype(dst.Surf.BitsPerPixel)>(*tokSurf); 6926 } break; 6927 case TOK_FBQ_GMM_TEXTURE_INFO_REC__BASE_WIDTH: { 6928 dst.Surf.BaseWidth = readTokValue<decltype(dst.Surf.BaseWidth)>(*tokSurf); 6929 } break; 6930 case TOK_FBD_GMM_TEXTURE_INFO_REC__BASE_HEIGHT: { 6931 dst.Surf.BaseHeight = readTokValue<decltype(dst.Surf.BaseHeight)>(*tokSurf); 6932 } break; 6933 case TOK_FBD_GMM_TEXTURE_INFO_REC__DEPTH: { 6934 dst.Surf.Depth = readTokValue<decltype(dst.Surf.Depth)>(*tokSurf); 6935 } break; 6936 case TOK_FBD_GMM_TEXTURE_INFO_REC__MAX_LOD: { 6937 dst.Surf.MaxLod = readTokValue<decltype(dst.Surf.MaxLod)>(*tokSurf); 6938 } break; 6939 case TOK_FBD_GMM_TEXTURE_INFO_REC__ARRAY_SIZE: { 6940 dst.Surf.ArraySize = readTokValue<decltype(dst.Surf.ArraySize)>(*tokSurf); 6941 } break; 6942 case TOK_FBD_GMM_TEXTURE_INFO_REC__CP_TAG: { 6943 dst.Surf.CpTag = readTokValue<decltype(dst.Surf.CpTag)>(*tokSurf); 6944 } break; 6945 case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_MODE: { 6946 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokSurf).getValue<char>(); 6947 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokSurf).getValueSizeInBytes(); 6948 if (srcSize < sizeof(dst.Surf.MmcMode)) { 6949 return false; 6950 } 6951 WCH_SAFE_COPY(dst.Surf.MmcMode, sizeof(dst.Surf.MmcMode), srcData, sizeof(dst.Surf.MmcMode)); 6952 } break; 6953 case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_HINT: { 6954 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokSurf).getValue<char>(); 6955 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokSurf).getValueSizeInBytes(); 6956 if (srcSize < sizeof(dst.Surf.MmcHint)) { 6957 return false; 6958 } 6959 WCH_SAFE_COPY(dst.Surf.MmcHint, sizeof(dst.Surf.MmcHint), srcData, sizeof(dst.Surf.MmcHint)); 6960 } break; 6961 case TOK_FBQ_GMM_TEXTURE_INFO_REC__PITCH: { 6962 dst.Surf.Pitch = readTokValue<decltype(dst.Surf.Pitch)>(*tokSurf); 6963 } break; 6964 case TOK_FBQ_GMM_TEXTURE_INFO_REC__OVERRIDE_PITCH: { 6965 dst.Surf.OverridePitch = readTokValue<decltype(dst.Surf.OverridePitch)>(*tokSurf); 6966 } break; 6967 case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE: { 6968 dst.Surf.Size = readTokValue<decltype(dst.Surf.Size)>(*tokSurf); 6969 } break; 6970 case TOK_FBQ_GMM_TEXTURE_INFO_REC__CCSIZE: { 6971 dst.Surf.CCSize = readTokValue<decltype(dst.Surf.CCSize)>(*tokSurf); 6972 } break; 6973 case TOK_FBQ_GMM_TEXTURE_INFO_REC__UNPADDED_SIZE: { 6974 dst.Surf.UnpaddedSize = readTokValue<decltype(dst.Surf.UnpaddedSize)>(*tokSurf); 6975 } break; 6976 case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE_REPORT_TO_OS: { 6977 dst.Surf.SizeReportToOS = readTokValue<decltype(dst.Surf.SizeReportToOS)>(*tokSurf); 6978 } break; 6979 case TOK_FE_GMM_TEXTURE_INFO_REC__TILE_MODE: { 6980 dst.Surf.TileMode = readTokValue<decltype(dst.Surf.TileMode)>(*tokSurf); 6981 } break; 6982 case TOK_FBD_GMM_TEXTURE_INFO_REC__CCSMODE_ALIGN: { 6983 dst.Surf.CCSModeAlign = readTokValue<decltype(dst.Surf.CCSModeAlign)>(*tokSurf); 6984 } break; 6985 case TOK_FBD_GMM_TEXTURE_INFO_REC__LEGACY_FLAGS: { 6986 dst.Surf.LegacyFlags = readTokValue<decltype(dst.Surf.LegacyFlags)>(*tokSurf); 6987 } break; 6988 case TOK_FBD_GMM_TEXTURE_INFO_REC__MAXIMUM_RENAMING_LIST_LENGTH: { 6989 dst.Surf.MaximumRenamingListLength = readTokValue<decltype(dst.Surf.MaximumRenamingListLength)>(*tokSurf); 6990 } break; 6991 }; 6992 tokSurf = tokSurf + 1 + tokSurf->valueDwordCount; 6993 } else { 6994 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSurf); 6995 switch (tokSurf->id) { 6996 default: 6997 if (tokSurf->flags.flag3IsMandatory) { 6998 return false; 6999 } 7000 break; 7001 case TOK_FS_GMM_TEXTURE_INFO_REC__FLAGS: { 7002 const TokenHeader *tokFlags = varLen->getValue<TokenHeader>(); 7003 const TokenHeader *tokFlagsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 7004 while (tokFlags < tokFlagsEnd) { 7005 if (false == tokFlags->flags.flag4IsVariableLength) { 7006 if (tokFlags->flags.flag3IsMandatory) { 7007 return false; 7008 } 7009 tokFlags = tokFlags + 1 + tokFlags->valueDwordCount; 7010 } else { 7011 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokFlags); 7012 switch (tokFlags->id) { 7013 default: 7014 if (tokFlags->flags.flag3IsMandatory) { 7015 return false; 7016 } 7017 break; 7018 case TOK_FS_GMM_RESOURCE_FLAG_REC__GPU: { 7019 const TokenHeader *tokGpu = varLen->getValue<TokenHeader>(); 7020 const TokenHeader *tokGpuEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 7021 while (tokGpu < tokGpuEnd) { 7022 if (false == tokGpu->flags.flag4IsVariableLength) { 7023 switch (tokGpu->id) { 7024 default: 7025 if (tokGpu->flags.flag3IsMandatory) { 7026 return false; 7027 } 7028 break; 7029 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CAMERA_CAPTURE: { 7030 dst.Surf.Flags.Gpu.CameraCapture = readTokValue<decltype(dst.Surf.Flags.Gpu.CameraCapture)>(*tokGpu); 7031 } break; 7032 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CCS: { 7033 dst.Surf.Flags.Gpu.CCS = readTokValue<decltype(dst.Surf.Flags.Gpu.CCS)>(*tokGpu); 7034 } break; 7035 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_DISCARD: { 7036 dst.Surf.Flags.Gpu.ColorDiscard = readTokValue<decltype(dst.Surf.Flags.Gpu.ColorDiscard)>(*tokGpu); 7037 } break; 7038 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION: { 7039 dst.Surf.Flags.Gpu.ColorSeparation = readTokValue<decltype(dst.Surf.Flags.Gpu.ColorSeparation)>(*tokGpu); 7040 } break; 7041 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION_RGBX: { 7042 dst.Surf.Flags.Gpu.ColorSeparationRGBX = readTokValue<decltype(dst.Surf.Flags.Gpu.ColorSeparationRGBX)>(*tokGpu); 7043 } break; 7044 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CONSTANT: { 7045 dst.Surf.Flags.Gpu.Constant = readTokValue<decltype(dst.Surf.Flags.Gpu.Constant)>(*tokGpu); 7046 } break; 7047 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__DEPTH: { 7048 dst.Surf.Flags.Gpu.Depth = readTokValue<decltype(dst.Surf.Flags.Gpu.Depth)>(*tokGpu); 7049 } break; 7050 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN: { 7051 dst.Surf.Flags.Gpu.FlipChain = readTokValue<decltype(dst.Surf.Flags.Gpu.FlipChain)>(*tokGpu); 7052 } break; 7053 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN_PREFERRED: { 7054 dst.Surf.Flags.Gpu.FlipChainPreferred = readTokValue<decltype(dst.Surf.Flags.Gpu.FlipChainPreferred)>(*tokGpu); 7055 } break; 7056 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HISTORY_BUFFER: { 7057 dst.Surf.Flags.Gpu.HistoryBuffer = readTokValue<decltype(dst.Surf.Flags.Gpu.HistoryBuffer)>(*tokGpu); 7058 } break; 7059 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HI_Z: { 7060 dst.Surf.Flags.Gpu.HiZ = readTokValue<decltype(dst.Surf.Flags.Gpu.HiZ)>(*tokGpu); 7061 } break; 7062 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDEX: { 7063 dst.Surf.Flags.Gpu.Index = readTokValue<decltype(dst.Surf.Flags.Gpu.Index)>(*tokGpu); 7064 } break; 7065 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDIRECT_CLEAR_COLOR: { 7066 dst.Surf.Flags.Gpu.IndirectClearColor = readTokValue<decltype(dst.Surf.Flags.Gpu.IndirectClearColor)>(*tokGpu); 7067 } break; 7068 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INSTRUCTION_FLAT: { 7069 dst.Surf.Flags.Gpu.InstructionFlat = readTokValue<decltype(dst.Surf.Flags.Gpu.InstructionFlat)>(*tokGpu); 7070 } break; 7071 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INTERLACED_SCAN: { 7072 dst.Surf.Flags.Gpu.InterlacedScan = readTokValue<decltype(dst.Surf.Flags.Gpu.InterlacedScan)>(*tokGpu); 7073 } break; 7074 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MCS: { 7075 dst.Surf.Flags.Gpu.MCS = readTokValue<decltype(dst.Surf.Flags.Gpu.MCS)>(*tokGpu); 7076 } break; 7077 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MMC: { 7078 dst.Surf.Flags.Gpu.MMC = readTokValue<decltype(dst.Surf.Flags.Gpu.MMC)>(*tokGpu); 7079 } break; 7080 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MOTION_COMP: { 7081 dst.Surf.Flags.Gpu.MotionComp = readTokValue<decltype(dst.Surf.Flags.Gpu.MotionComp)>(*tokGpu); 7082 } break; 7083 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__NO_RESTRICTION: { 7084 dst.Surf.Flags.Gpu.NoRestriction = readTokValue<decltype(dst.Surf.Flags.Gpu.NoRestriction)>(*tokGpu); 7085 } break; 7086 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__OVERLAY: { 7087 dst.Surf.Flags.Gpu.Overlay = readTokValue<decltype(dst.Surf.Flags.Gpu.Overlay)>(*tokGpu); 7088 } break; 7089 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PRESENTABLE: { 7090 dst.Surf.Flags.Gpu.Presentable = readTokValue<decltype(dst.Surf.Flags.Gpu.Presentable)>(*tokGpu); 7091 } break; 7092 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PROCEDURAL_TEXTURE: { 7093 dst.Surf.Flags.Gpu.ProceduralTexture = readTokValue<decltype(dst.Surf.Flags.Gpu.ProceduralTexture)>(*tokGpu); 7094 } break; 7095 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__QUERY: { 7096 dst.Surf.Flags.Gpu.Query = readTokValue<decltype(dst.Surf.Flags.Gpu.Query)>(*tokGpu); 7097 } break; 7098 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__RENDER_TARGET: { 7099 dst.Surf.Flags.Gpu.RenderTarget = readTokValue<decltype(dst.Surf.Flags.Gpu.RenderTarget)>(*tokGpu); 7100 } break; 7101 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D: { 7102 dst.Surf.Flags.Gpu.S3d = readTokValue<decltype(dst.Surf.Flags.Gpu.S3d)>(*tokGpu); 7103 } break; 7104 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D_DX: { 7105 dst.Surf.Flags.Gpu.S3dDx = readTokValue<decltype(dst.Surf.Flags.Gpu.S3dDx)>(*tokGpu); 7106 } break; 7107 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_NON_PACKED: { 7108 dst.Surf.Flags.Gpu.__S3dNonPacked = readTokValue<decltype(dst.Surf.Flags.Gpu.__S3dNonPacked)>(*tokGpu); 7109 } break; 7110 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_WIDI: { 7111 dst.Surf.Flags.Gpu.__S3dWidi = readTokValue<decltype(dst.Surf.Flags.Gpu.__S3dWidi)>(*tokGpu); 7112 } break; 7113 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SCRATCH_FLAT: { 7114 dst.Surf.Flags.Gpu.ScratchFlat = readTokValue<decltype(dst.Surf.Flags.Gpu.ScratchFlat)>(*tokGpu); 7115 } break; 7116 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SEPARATE_STENCIL: { 7117 dst.Surf.Flags.Gpu.SeparateStencil = readTokValue<decltype(dst.Surf.Flags.Gpu.SeparateStencil)>(*tokGpu); 7118 } break; 7119 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE: { 7120 dst.Surf.Flags.Gpu.State = readTokValue<decltype(dst.Surf.Flags.Gpu.State)>(*tokGpu); 7121 } break; 7122 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE_DX9CONSTANT_BUFFER: { 7123 dst.Surf.Flags.Gpu.StateDx9ConstantBuffer = readTokValue<decltype(dst.Surf.Flags.Gpu.StateDx9ConstantBuffer)>(*tokGpu); 7124 } break; 7125 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STREAM: { 7126 dst.Surf.Flags.Gpu.Stream = readTokValue<decltype(dst.Surf.Flags.Gpu.Stream)>(*tokGpu); 7127 } break; 7128 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXT_API: { 7129 dst.Surf.Flags.Gpu.TextApi = readTokValue<decltype(dst.Surf.Flags.Gpu.TextApi)>(*tokGpu); 7130 } break; 7131 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXTURE: { 7132 dst.Surf.Flags.Gpu.Texture = readTokValue<decltype(dst.Surf.Flags.Gpu.Texture)>(*tokGpu); 7133 } break; 7134 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILED_RESOURCE: { 7135 dst.Surf.Flags.Gpu.TiledResource = readTokValue<decltype(dst.Surf.Flags.Gpu.TiledResource)>(*tokGpu); 7136 } break; 7137 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILE_POOL: { 7138 dst.Surf.Flags.Gpu.TilePool = readTokValue<decltype(dst.Surf.Flags.Gpu.TilePool)>(*tokGpu); 7139 } break; 7140 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__UNIFIED_AUX_SURFACE: { 7141 dst.Surf.Flags.Gpu.UnifiedAuxSurface = readTokValue<decltype(dst.Surf.Flags.Gpu.UnifiedAuxSurface)>(*tokGpu); 7142 } break; 7143 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VERTEX: { 7144 dst.Surf.Flags.Gpu.Vertex = readTokValue<decltype(dst.Surf.Flags.Gpu.Vertex)>(*tokGpu); 7145 } break; 7146 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VIDEO: { 7147 dst.Surf.Flags.Gpu.Video = readTokValue<decltype(dst.Surf.Flags.Gpu.Video)>(*tokGpu); 7148 } break; 7149 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_XCCS: { 7150 dst.Surf.Flags.Gpu.__NonMsaaTileXCcs = readTokValue<decltype(dst.Surf.Flags.Gpu.__NonMsaaTileXCcs)>(*tokGpu); 7151 } break; 7152 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_YCCS: { 7153 dst.Surf.Flags.Gpu.__NonMsaaTileYCcs = readTokValue<decltype(dst.Surf.Flags.Gpu.__NonMsaaTileYCcs)>(*tokGpu); 7154 } break; 7155 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____MSAA_TILE_MCS: { 7156 dst.Surf.Flags.Gpu.__MsaaTileMcs = readTokValue<decltype(dst.Surf.Flags.Gpu.__MsaaTileMcs)>(*tokGpu); 7157 } break; 7158 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_LINEAR_CCS: { 7159 dst.Surf.Flags.Gpu.__NonMsaaLinearCCS = readTokValue<decltype(dst.Surf.Flags.Gpu.__NonMsaaLinearCCS)>(*tokGpu); 7160 } break; 7161 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____REMAINING: { 7162 dst.Surf.Flags.Gpu.__Remaining = readTokValue<decltype(dst.Surf.Flags.Gpu.__Remaining)>(*tokGpu); 7163 } break; 7164 }; 7165 tokGpu = tokGpu + 1 + tokGpu->valueDwordCount; 7166 } else { 7167 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokGpu); 7168 if (tokGpu->flags.flag3IsMandatory) { 7169 return false; 7170 } 7171 tokGpu = tokGpu + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 7172 } 7173 } 7174 WCH_ASSERT(tokGpu == tokGpuEnd); 7175 } break; 7176 case TOK_FS_GMM_RESOURCE_FLAG_REC__INFO: { 7177 const TokenHeader *tokInfo = varLen->getValue<TokenHeader>(); 7178 const TokenHeader *tokInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 7179 while (tokInfo < tokInfoEnd) { 7180 if (false == tokInfo->flags.flag4IsVariableLength) { 7181 switch (tokInfo->id) { 7182 default: 7183 if (tokInfo->flags.flag3IsMandatory) { 7184 return false; 7185 } 7186 break; 7187 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ALLOW_VIRTUAL_PADDING: { 7188 dst.Surf.Flags.Info.AllowVirtualPadding = readTokValue<decltype(dst.Surf.Flags.Info.AllowVirtualPadding)>(*tokInfo); 7189 } break; 7190 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__BIG_PAGE: { 7191 dst.Surf.Flags.Info.BigPage = readTokValue<decltype(dst.Surf.Flags.Info.BigPage)>(*tokInfo); 7192 } break; 7193 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CACHEABLE: { 7194 dst.Surf.Flags.Info.Cacheable = readTokValue<decltype(dst.Surf.Flags.Info.Cacheable)>(*tokInfo); 7195 } break; 7196 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CONTIG_PHYS_MEMORY_FORI_DART: { 7197 dst.Surf.Flags.Info.ContigPhysMemoryForiDART = readTokValue<decltype(dst.Surf.Flags.Info.ContigPhysMemoryForiDART)>(*tokInfo); 7198 } break; 7199 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CORNER_TEXEL_MODE: { 7200 dst.Surf.Flags.Info.CornerTexelMode = readTokValue<decltype(dst.Surf.Flags.Info.CornerTexelMode)>(*tokInfo); 7201 } break; 7202 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__EXISTING_SYS_MEM: { 7203 dst.Surf.Flags.Info.ExistingSysMem = readTokValue<decltype(dst.Surf.Flags.Info.ExistingSysMem)>(*tokInfo); 7204 } break; 7205 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__FORCE_RESIDENCY: { 7206 dst.Surf.Flags.Info.ForceResidency = readTokValue<decltype(dst.Surf.Flags.Info.ForceResidency)>(*tokInfo); 7207 } break; 7208 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GFDT: { 7209 dst.Surf.Flags.Info.Gfdt = readTokValue<decltype(dst.Surf.Flags.Info.Gfdt)>(*tokInfo); 7210 } break; 7211 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GTT_MAP_TYPE: { 7212 dst.Surf.Flags.Info.GttMapType = readTokValue<decltype(dst.Surf.Flags.Info.GttMapType)>(*tokInfo); 7213 } break; 7214 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__HARDWARE_PROTECTED: { 7215 dst.Surf.Flags.Info.HardwareProtected = readTokValue<decltype(dst.Surf.Flags.Info.HardwareProtected)>(*tokInfo); 7216 } break; 7217 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__KERNEL_MODE_MAPPED: { 7218 dst.Surf.Flags.Info.KernelModeMapped = readTokValue<decltype(dst.Surf.Flags.Info.KernelModeMapped)>(*tokInfo); 7219 } break; 7220 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_BELOW: { 7221 dst.Surf.Flags.Info.LayoutBelow = readTokValue<decltype(dst.Surf.Flags.Info.LayoutBelow)>(*tokInfo); 7222 } break; 7223 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_MONO: { 7224 dst.Surf.Flags.Info.LayoutMono = readTokValue<decltype(dst.Surf.Flags.Info.LayoutMono)>(*tokInfo); 7225 } break; 7226 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_RIGHT: { 7227 dst.Surf.Flags.Info.LayoutRight = readTokValue<decltype(dst.Surf.Flags.Info.LayoutRight)>(*tokInfo); 7228 } break; 7229 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LOCAL_ONLY: { 7230 dst.Surf.Flags.Info.LocalOnly = readTokValue<decltype(dst.Surf.Flags.Info.LocalOnly)>(*tokInfo); 7231 } break; 7232 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LINEAR: { 7233 dst.Surf.Flags.Info.Linear = readTokValue<decltype(dst.Surf.Flags.Info.Linear)>(*tokInfo); 7234 } break; 7235 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__MEDIA_COMPRESSED: { 7236 dst.Surf.Flags.Info.MediaCompressed = readTokValue<decltype(dst.Surf.Flags.Info.MediaCompressed)>(*tokInfo); 7237 } break; 7238 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_OPTIMIZATION_PADDING: { 7239 dst.Surf.Flags.Info.NoOptimizationPadding = readTokValue<decltype(dst.Surf.Flags.Info.NoOptimizationPadding)>(*tokInfo); 7240 } break; 7241 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_PHYS_MEMORY: { 7242 dst.Surf.Flags.Info.NoPhysMemory = readTokValue<decltype(dst.Surf.Flags.Info.NoPhysMemory)>(*tokInfo); 7243 } break; 7244 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NOT_LOCKABLE: { 7245 dst.Surf.Flags.Info.NotLockable = readTokValue<decltype(dst.Surf.Flags.Info.NotLockable)>(*tokInfo); 7246 } break; 7247 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NON_LOCAL_ONLY: { 7248 dst.Surf.Flags.Info.NonLocalOnly = readTokValue<decltype(dst.Surf.Flags.Info.NonLocalOnly)>(*tokInfo); 7249 } break; 7250 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__STD_SWIZZLE: { 7251 dst.Surf.Flags.Info.StdSwizzle = readTokValue<decltype(dst.Surf.Flags.Info.StdSwizzle)>(*tokInfo); 7252 } break; 7253 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__PSEUDO_STD_SWIZZLE: { 7254 dst.Surf.Flags.Info.PseudoStdSwizzle = readTokValue<decltype(dst.Surf.Flags.Info.PseudoStdSwizzle)>(*tokInfo); 7255 } break; 7256 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__UNDEFINED64KBSWIZZLE: { 7257 dst.Surf.Flags.Info.Undefined64KBSwizzle = readTokValue<decltype(dst.Surf.Flags.Info.Undefined64KBSwizzle)>(*tokInfo); 7258 } break; 7259 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__REDECRIBED_PLANES: { 7260 dst.Surf.Flags.Info.RedecribedPlanes = readTokValue<decltype(dst.Surf.Flags.Info.RedecribedPlanes)>(*tokInfo); 7261 } break; 7262 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__RENDER_COMPRESSED: { 7263 dst.Surf.Flags.Info.RenderCompressed = readTokValue<decltype(dst.Surf.Flags.Info.RenderCompressed)>(*tokInfo); 7264 } break; 7265 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ROTATED: { 7266 dst.Surf.Flags.Info.Rotated = readTokValue<decltype(dst.Surf.Flags.Info.Rotated)>(*tokInfo); 7267 } break; 7268 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SHARED: { 7269 dst.Surf.Flags.Info.Shared = readTokValue<decltype(dst.Surf.Flags.Info.Shared)>(*tokInfo); 7270 } break; 7271 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SOFTWARE_PROTECTED: { 7272 dst.Surf.Flags.Info.SoftwareProtected = readTokValue<decltype(dst.Surf.Flags.Info.SoftwareProtected)>(*tokInfo); 7273 } break; 7274 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SVM: { 7275 dst.Surf.Flags.Info.SVM = readTokValue<decltype(dst.Surf.Flags.Info.SVM)>(*tokInfo); 7276 } break; 7277 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE4: { 7278 dst.Surf.Flags.Info.Tile4 = readTokValue<decltype(dst.Surf.Flags.Info.Tile4)>(*tokInfo); 7279 } break; 7280 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE64: { 7281 dst.Surf.Flags.Info.Tile64 = readTokValue<decltype(dst.Surf.Flags.Info.Tile64)>(*tokInfo); 7282 } break; 7283 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_W: { 7284 dst.Surf.Flags.Info.TiledW = readTokValue<decltype(dst.Surf.Flags.Info.TiledW)>(*tokInfo); 7285 } break; 7286 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_X: { 7287 dst.Surf.Flags.Info.TiledX = readTokValue<decltype(dst.Surf.Flags.Info.TiledX)>(*tokInfo); 7288 } break; 7289 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_Y: { 7290 dst.Surf.Flags.Info.TiledY = readTokValue<decltype(dst.Surf.Flags.Info.TiledY)>(*tokInfo); 7291 } break; 7292 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YF: { 7293 dst.Surf.Flags.Info.TiledYf = readTokValue<decltype(dst.Surf.Flags.Info.TiledYf)>(*tokInfo); 7294 } break; 7295 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YS: { 7296 dst.Surf.Flags.Info.TiledYs = readTokValue<decltype(dst.Surf.Flags.Info.TiledYs)>(*tokInfo); 7297 } break; 7298 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__WDDM_PROTECTED: { 7299 dst.Surf.Flags.Info.WddmProtected = readTokValue<decltype(dst.Surf.Flags.Info.WddmProtected)>(*tokInfo); 7300 } break; 7301 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__XADAPTER: { 7302 dst.Surf.Flags.Info.XAdapter = readTokValue<decltype(dst.Surf.Flags.Info.XAdapter)>(*tokInfo); 7303 } break; 7304 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PREALLOCATED_RES_INFO: { 7305 dst.Surf.Flags.Info.__PreallocatedResInfo = readTokValue<decltype(dst.Surf.Flags.Info.__PreallocatedResInfo)>(*tokInfo); 7306 } break; 7307 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PRE_WDDM2SVM: { 7308 dst.Surf.Flags.Info.__PreWddm2SVM = readTokValue<decltype(dst.Surf.Flags.Info.__PreWddm2SVM)>(*tokInfo); 7309 } break; 7310 }; 7311 tokInfo = tokInfo + 1 + tokInfo->valueDwordCount; 7312 } else { 7313 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInfo); 7314 if (tokInfo->flags.flag3IsMandatory) { 7315 return false; 7316 } 7317 tokInfo = tokInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 7318 } 7319 } 7320 WCH_ASSERT(tokInfo == tokInfoEnd); 7321 } break; 7322 case TOK_FS_GMM_RESOURCE_FLAG_REC__WA: { 7323 const TokenHeader *tokWa = varLen->getValue<TokenHeader>(); 7324 const TokenHeader *tokWaEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 7325 while (tokWa < tokWaEnd) { 7326 if (false == tokWa->flags.flag4IsVariableLength) { 7327 switch (tokWa->id) { 7328 default: 7329 if (tokWa->flags.flag3IsMandatory) { 7330 return false; 7331 } 7332 break; 7333 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__GTMFX2ND_LEVEL_BATCH_RING_SIZE_ALIGN: { 7334 dst.Surf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign = readTokValue<decltype(dst.Surf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign)>(*tokWa); 7335 } break; 7336 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_MPR_ROW_STORE32KALIGN: { 7337 dst.Surf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign = readTokValue<decltype(dst.Surf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign)>(*tokWa); 7338 } break; 7339 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_DMV_BUFFER32KALIGN: { 7340 dst.Surf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign = readTokValue<decltype(dst.Surf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign)>(*tokWa); 7341 } break; 7342 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_BUFFER_SAMPLER_PADDING: { 7343 dst.Surf.Flags.Wa.NoBufferSamplerPadding = readTokValue<decltype(dst.Surf.Flags.Wa.NoBufferSamplerPadding)>(*tokWa); 7344 } break; 7345 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_LEGACY_PLANAR_LINEAR_VIDEO_RESTRICTIONS: { 7346 dst.Surf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions = readTokValue<decltype(dst.Surf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions)>(*tokWa); 7347 } break; 7348 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__CHVASTC_SKIP_VIRTUAL_MIPS: { 7349 dst.Surf.Flags.Wa.CHVAstcSkipVirtualMips = readTokValue<decltype(dst.Surf.Flags.Wa.CHVAstcSkipVirtualMips)>(*tokWa); 7350 } break; 7351 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_PACKED_MIP_TAIL: { 7352 dst.Surf.Flags.Wa.DisablePackedMipTail = readTokValue<decltype(dst.Surf.Flags.Wa.DisablePackedMipTail)>(*tokWa); 7353 } break; 7354 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521____FORCE_OTHER_HVALIGN4: { 7355 dst.Surf.Flags.Wa.__ForceOtherHVALIGN4 = readTokValue<decltype(dst.Surf.Flags.Wa.__ForceOtherHVALIGN4)>(*tokWa); 7356 } break; 7357 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR: { 7358 dst.Surf.Flags.Wa.DisableDisplayCcsClearColor = readTokValue<decltype(dst.Surf.Flags.Wa.DisableDisplayCcsClearColor)>(*tokWa); 7359 } break; 7360 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION: { 7361 dst.Surf.Flags.Wa.DisableDisplayCcsCompression = readTokValue<decltype(dst.Surf.Flags.Wa.DisableDisplayCcsCompression)>(*tokWa); 7362 } break; 7363 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: { 7364 dst.Surf.Flags.Wa.PreGen12FastClearOnly = readTokValue<decltype(dst.Surf.Flags.Wa.PreGen12FastClearOnly)>(*tokWa); 7365 } break; 7366 }; 7367 tokWa = tokWa + 1 + tokWa->valueDwordCount; 7368 } else { 7369 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokWa); 7370 if (tokWa->flags.flag3IsMandatory) { 7371 return false; 7372 } 7373 tokWa = tokWa + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 7374 } 7375 } 7376 WCH_ASSERT(tokWa == tokWaEnd); 7377 } break; 7378 }; 7379 tokFlags = tokFlags + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 7380 } 7381 } 7382 WCH_ASSERT(tokFlags == tokFlagsEnd); 7383 } break; 7384 case TOK_FS_GMM_TEXTURE_INFO_REC__CACHE_POLICY: { 7385 const TokenHeader *tokCachePolicy = varLen->getValue<TokenHeader>(); 7386 const TokenHeader *tokCachePolicyEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 7387 while (tokCachePolicy < tokCachePolicyEnd) { 7388 if (false == tokCachePolicy->flags.flag4IsVariableLength) { 7389 switch (tokCachePolicy->id) { 7390 default: 7391 if (tokCachePolicy->flags.flag3IsMandatory) { 7392 return false; 7393 } 7394 break; 7395 case TOK_FE_GMM_TEXTURE_INFO_REC__ANONYMOUS4927__USAGE: { 7396 dst.Surf.CachePolicy.Usage = readTokValue<decltype(dst.Surf.CachePolicy.Usage)>(*tokCachePolicy); 7397 } break; 7398 }; 7399 tokCachePolicy = tokCachePolicy + 1 + tokCachePolicy->valueDwordCount; 7400 } else { 7401 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCachePolicy); 7402 if (tokCachePolicy->flags.flag3IsMandatory) { 7403 return false; 7404 } 7405 tokCachePolicy = tokCachePolicy + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 7406 } 7407 } 7408 WCH_ASSERT(tokCachePolicy == tokCachePolicyEnd); 7409 } break; 7410 case TOK_FS_GMM_TEXTURE_INFO_REC__MSAA: { 7411 const TokenHeader *tokMSAA = varLen->getValue<TokenHeader>(); 7412 const TokenHeader *tokMSAAEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 7413 while (tokMSAA < tokMSAAEnd) { 7414 if (false == tokMSAA->flags.flag4IsVariableLength) { 7415 switch (tokMSAA->id) { 7416 default: 7417 if (tokMSAA->flags.flag3IsMandatory) { 7418 return false; 7419 } 7420 break; 7421 case TOK_FE_GMM_RESOURCE_MSAA_INFO_REC__SAMPLE_PATTERN: { 7422 dst.Surf.MSAA.SamplePattern = readTokValue<decltype(dst.Surf.MSAA.SamplePattern)>(*tokMSAA); 7423 } break; 7424 case TOK_FBD_GMM_RESOURCE_MSAA_INFO_REC__NUM_SAMPLES: { 7425 dst.Surf.MSAA.NumSamples = readTokValue<decltype(dst.Surf.MSAA.NumSamples)>(*tokMSAA); 7426 } break; 7427 }; 7428 tokMSAA = tokMSAA + 1 + tokMSAA->valueDwordCount; 7429 } else { 7430 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokMSAA); 7431 if (tokMSAA->flags.flag3IsMandatory) { 7432 return false; 7433 } 7434 tokMSAA = tokMSAA + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 7435 } 7436 } 7437 WCH_ASSERT(tokMSAA == tokMSAAEnd); 7438 } break; 7439 case TOK_FS_GMM_TEXTURE_INFO_REC__ALIGNMENT: { 7440 const TokenHeader *tokAlignment = varLen->getValue<TokenHeader>(); 7441 const TokenHeader *tokAlignmentEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 7442 while (tokAlignment < tokAlignmentEnd) { 7443 if (false == tokAlignment->flags.flag4IsVariableLength) { 7444 switch (tokAlignment->id) { 7445 default: 7446 if (tokAlignment->flags.flag3IsMandatory) { 7447 return false; 7448 } 7449 break; 7450 case TOK_FBC_GMM_RESOURCE_ALIGNMENT_REC__ARRAY_SPACING_SINGLE_LOD: { 7451 dst.Surf.Alignment.ArraySpacingSingleLod = readTokValue<decltype(dst.Surf.Alignment.ArraySpacingSingleLod)>(*tokAlignment); 7452 } break; 7453 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__BASE_ALIGNMENT: { 7454 dst.Surf.Alignment.BaseAlignment = readTokValue<decltype(dst.Surf.Alignment.BaseAlignment)>(*tokAlignment); 7455 } break; 7456 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__HALIGN: { 7457 dst.Surf.Alignment.HAlign = readTokValue<decltype(dst.Surf.Alignment.HAlign)>(*tokAlignment); 7458 } break; 7459 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__VALIGN: { 7460 dst.Surf.Alignment.VAlign = readTokValue<decltype(dst.Surf.Alignment.VAlign)>(*tokAlignment); 7461 } break; 7462 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__DALIGN: { 7463 dst.Surf.Alignment.DAlign = readTokValue<decltype(dst.Surf.Alignment.DAlign)>(*tokAlignment); 7464 } break; 7465 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__MIP_TAIL_START_LOD: { 7466 dst.Surf.Alignment.MipTailStartLod = readTokValue<decltype(dst.Surf.Alignment.MipTailStartLod)>(*tokAlignment); 7467 } break; 7468 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_START_LOD: { 7469 dst.Surf.Alignment.PackedMipStartLod = readTokValue<decltype(dst.Surf.Alignment.PackedMipStartLod)>(*tokAlignment); 7470 } break; 7471 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_WIDTH: { 7472 dst.Surf.Alignment.PackedMipWidth = readTokValue<decltype(dst.Surf.Alignment.PackedMipWidth)>(*tokAlignment); 7473 } break; 7474 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_HEIGHT: { 7475 dst.Surf.Alignment.PackedMipHeight = readTokValue<decltype(dst.Surf.Alignment.PackedMipHeight)>(*tokAlignment); 7476 } break; 7477 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__QPITCH: { 7478 dst.Surf.Alignment.QPitch = readTokValue<decltype(dst.Surf.Alignment.QPitch)>(*tokAlignment); 7479 } break; 7480 }; 7481 tokAlignment = tokAlignment + 1 + tokAlignment->valueDwordCount; 7482 } else { 7483 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokAlignment); 7484 if (tokAlignment->flags.flag3IsMandatory) { 7485 return false; 7486 } 7487 tokAlignment = tokAlignment + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 7488 } 7489 } 7490 WCH_ASSERT(tokAlignment == tokAlignmentEnd); 7491 } break; 7492 case TOK_FS_GMM_TEXTURE_INFO_REC__OFFSET_INFO: { 7493 const TokenHeader *tokOffsetInfo = varLen->getValue<TokenHeader>(); 7494 const TokenHeader *tokOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 7495 while (tokOffsetInfo < tokOffsetInfoEnd) { 7496 if (false == tokOffsetInfo->flags.flag4IsVariableLength) { 7497 if (tokOffsetInfo->flags.flag3IsMandatory) { 7498 return false; 7499 } 7500 tokOffsetInfo = tokOffsetInfo + 1 + tokOffsetInfo->valueDwordCount; 7501 } else { 7502 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokOffsetInfo); 7503 switch (tokOffsetInfo->id) { 7504 default: 7505 if (tokOffsetInfo->flags.flag3IsMandatory) { 7506 return false; 7507 } 7508 break; 7509 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO: { 7510 const TokenHeader *tokTexture3DOffsetInfo = varLen->getValue<TokenHeader>(); 7511 const TokenHeader *tokTexture3DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 7512 while (tokTexture3DOffsetInfo < tokTexture3DOffsetInfoEnd) { 7513 if (false == tokTexture3DOffsetInfo->flags.flag4IsVariableLength) { 7514 switch (tokTexture3DOffsetInfo->id) { 7515 default: 7516 if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { 7517 return false; 7518 } 7519 break; 7520 case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: { 7521 dst.Surf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch = readTokValue<decltype(dst.Surf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch)>(*tokTexture3DOffsetInfo); 7522 } break; 7523 case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: { 7524 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValue<char>(); 7525 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValueSizeInBytes(); 7526 if (srcSize < sizeof(dst.Surf.OffsetInfo.Texture3DOffsetInfo.Offset)) { 7527 return false; 7528 } 7529 WCH_SAFE_COPY(dst.Surf.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(dst.Surf.OffsetInfo.Texture3DOffsetInfo.Offset), srcData, sizeof(dst.Surf.OffsetInfo.Texture3DOffsetInfo.Offset)); 7530 } break; 7531 }; 7532 tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + 1 + tokTexture3DOffsetInfo->valueDwordCount; 7533 } else { 7534 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture3DOffsetInfo); 7535 if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { 7536 return false; 7537 } 7538 tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 7539 } 7540 } 7541 WCH_ASSERT(tokTexture3DOffsetInfo == tokTexture3DOffsetInfoEnd); 7542 } break; 7543 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO: { 7544 const TokenHeader *tokTexture2DOffsetInfo = varLen->getValue<TokenHeader>(); 7545 const TokenHeader *tokTexture2DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 7546 while (tokTexture2DOffsetInfo < tokTexture2DOffsetInfoEnd) { 7547 if (false == tokTexture2DOffsetInfo->flags.flag4IsVariableLength) { 7548 switch (tokTexture2DOffsetInfo->id) { 7549 default: 7550 if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { 7551 return false; 7552 } 7553 break; 7554 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: { 7555 dst.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock = readTokValue<decltype(dst.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock)>(*tokTexture2DOffsetInfo); 7556 } break; 7557 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: { 7558 dst.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender = readTokValue<decltype(dst.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender)>(*tokTexture2DOffsetInfo); 7559 } break; 7560 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: { 7561 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValue<char>(); 7562 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValueSizeInBytes(); 7563 if (srcSize < sizeof(dst.Surf.OffsetInfo.Texture2DOffsetInfo.Offset)) { 7564 return false; 7565 } 7566 WCH_SAFE_COPY(dst.Surf.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(dst.Surf.OffsetInfo.Texture2DOffsetInfo.Offset), srcData, sizeof(dst.Surf.OffsetInfo.Texture2DOffsetInfo.Offset)); 7567 } break; 7568 }; 7569 tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + 1 + tokTexture2DOffsetInfo->valueDwordCount; 7570 } else { 7571 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture2DOffsetInfo); 7572 if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { 7573 return false; 7574 } 7575 tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 7576 } 7577 } 7578 WCH_ASSERT(tokTexture2DOffsetInfo == tokTexture2DOffsetInfoEnd); 7579 } break; 7580 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE: { 7581 const TokenHeader *tokPlane = varLen->getValue<TokenHeader>(); 7582 const TokenHeader *tokPlaneEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 7583 while (tokPlane < tokPlaneEnd) { 7584 if (false == tokPlane->flags.flag4IsVariableLength) { 7585 switch (tokPlane->id) { 7586 default: 7587 if (tokPlane->flags.flag3IsMandatory) { 7588 return false; 7589 } 7590 break; 7591 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: { 7592 dst.Surf.OffsetInfo.Plane.ArrayQPitch = readTokValue<decltype(dst.Surf.OffsetInfo.Plane.ArrayQPitch)>(*tokPlane); 7593 } break; 7594 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: { 7595 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>(); 7596 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes(); 7597 if (srcSize < sizeof(dst.Surf.OffsetInfo.Plane.X)) { 7598 return false; 7599 } 7600 WCH_SAFE_COPY(dst.Surf.OffsetInfo.Plane.X, sizeof(dst.Surf.OffsetInfo.Plane.X), srcData, sizeof(dst.Surf.OffsetInfo.Plane.X)); 7601 } break; 7602 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: { 7603 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>(); 7604 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes(); 7605 if (srcSize < sizeof(dst.Surf.OffsetInfo.Plane.Y)) { 7606 return false; 7607 } 7608 WCH_SAFE_COPY(dst.Surf.OffsetInfo.Plane.Y, sizeof(dst.Surf.OffsetInfo.Plane.Y), srcData, sizeof(dst.Surf.OffsetInfo.Plane.Y)); 7609 } break; 7610 case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: { 7611 dst.Surf.OffsetInfo.Plane.NoOfPlanes = readTokValue<decltype(dst.Surf.OffsetInfo.Plane.NoOfPlanes)>(*tokPlane); 7612 } break; 7613 case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: { 7614 dst.Surf.OffsetInfo.Plane.IsTileAlignedPlanes = readTokValue<decltype(dst.Surf.OffsetInfo.Plane.IsTileAlignedPlanes)>(*tokPlane); 7615 } break; 7616 }; 7617 tokPlane = tokPlane + 1 + tokPlane->valueDwordCount; 7618 } else { 7619 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlane); 7620 switch (tokPlane->id) { 7621 default: 7622 if (tokPlane->flags.flag3IsMandatory) { 7623 return false; 7624 } 7625 break; 7626 case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: { 7627 const TokenHeader *tokUnAligned = varLen->getValue<TokenHeader>(); 7628 const TokenHeader *tokUnAlignedEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 7629 while (tokUnAligned < tokUnAlignedEnd) { 7630 if (false == tokUnAligned->flags.flag4IsVariableLength) { 7631 switch (tokUnAligned->id) { 7632 default: 7633 if (tokUnAligned->flags.flag3IsMandatory) { 7634 return false; 7635 } 7636 break; 7637 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: { 7638 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValue<char>(); 7639 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValueSizeInBytes(); 7640 if (srcSize < sizeof(dst.Surf.OffsetInfo.Plane.UnAligned.Height)) { 7641 return false; 7642 } 7643 WCH_SAFE_COPY(dst.Surf.OffsetInfo.Plane.UnAligned.Height, sizeof(dst.Surf.OffsetInfo.Plane.UnAligned.Height), srcData, sizeof(dst.Surf.OffsetInfo.Plane.UnAligned.Height)); 7644 } break; 7645 }; 7646 tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount; 7647 } else { 7648 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokUnAligned); 7649 if (tokUnAligned->flags.flag3IsMandatory) { 7650 return false; 7651 } 7652 tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 7653 } 7654 } 7655 WCH_ASSERT(tokUnAligned == tokUnAlignedEnd); 7656 } break; 7657 }; 7658 tokPlane = tokPlane + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 7659 } 7660 } 7661 WCH_ASSERT(tokPlane == tokPlaneEnd); 7662 } break; 7663 }; 7664 tokOffsetInfo = tokOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 7665 } 7666 } 7667 WCH_ASSERT(tokOffsetInfo == tokOffsetInfoEnd); 7668 } break; 7669 case TOK_FS_GMM_TEXTURE_INFO_REC__S3D: { 7670 const TokenHeader *tokS3d = varLen->getValue<TokenHeader>(); 7671 const TokenHeader *tokS3dEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 7672 while (tokS3d < tokS3dEnd) { 7673 if (false == tokS3d->flags.flag4IsVariableLength) { 7674 switch (tokS3d->id) { 7675 default: 7676 if (tokS3d->flags.flag3IsMandatory) { 7677 return false; 7678 } 7679 break; 7680 case TOK_FBD_GMM_S3D_INFO_REC__DISPLAY_MODE_HEIGHT: { 7681 dst.Surf.S3d.DisplayModeHeight = readTokValue<decltype(dst.Surf.S3d.DisplayModeHeight)>(*tokS3d); 7682 } break; 7683 case TOK_FBD_GMM_S3D_INFO_REC__NUM_BLANK_ACTIVE_LINES: { 7684 dst.Surf.S3d.NumBlankActiveLines = readTokValue<decltype(dst.Surf.S3d.NumBlankActiveLines)>(*tokS3d); 7685 } break; 7686 case TOK_FBD_GMM_S3D_INFO_REC__RFRAME_OFFSET: { 7687 dst.Surf.S3d.RFrameOffset = readTokValue<decltype(dst.Surf.S3d.RFrameOffset)>(*tokS3d); 7688 } break; 7689 case TOK_FBD_GMM_S3D_INFO_REC__BLANK_AREA_OFFSET: { 7690 dst.Surf.S3d.BlankAreaOffset = readTokValue<decltype(dst.Surf.S3d.BlankAreaOffset)>(*tokS3d); 7691 } break; 7692 case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_HEIGHT: { 7693 dst.Surf.S3d.TallBufferHeight = readTokValue<decltype(dst.Surf.S3d.TallBufferHeight)>(*tokS3d); 7694 } break; 7695 case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_SIZE: { 7696 dst.Surf.S3d.TallBufferSize = readTokValue<decltype(dst.Surf.S3d.TallBufferSize)>(*tokS3d); 7697 } break; 7698 case TOK_FBC_GMM_S3D_INFO_REC__IS_RFRAME: { 7699 dst.Surf.S3d.IsRFrame = readTokValue<decltype(dst.Surf.S3d.IsRFrame)>(*tokS3d); 7700 } break; 7701 }; 7702 tokS3d = tokS3d + 1 + tokS3d->valueDwordCount; 7703 } else { 7704 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokS3d); 7705 if (tokS3d->flags.flag3IsMandatory) { 7706 return false; 7707 } 7708 tokS3d = tokS3d + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 7709 } 7710 } 7711 WCH_ASSERT(tokS3d == tokS3dEnd); 7712 } break; 7713 case TOK_FS_GMM_TEXTURE_INFO_REC__SEGMENT_OVERRIDE: { 7714 const TokenHeader *tokSegmentOverride = varLen->getValue<TokenHeader>(); 7715 const TokenHeader *tokSegmentOverrideEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 7716 while (tokSegmentOverride < tokSegmentOverrideEnd) { 7717 if (false == tokSegmentOverride->flags.flag4IsVariableLength) { 7718 switch (tokSegmentOverride->id) { 7719 default: 7720 if (tokSegmentOverride->flags.flag3IsMandatory) { 7721 return false; 7722 } 7723 break; 7724 case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__SEG1: { 7725 dst.Surf.SegmentOverride.Seg1 = readTokValue<decltype(dst.Surf.SegmentOverride.Seg1)>(*tokSegmentOverride); 7726 } break; 7727 case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__EVICT: { 7728 dst.Surf.SegmentOverride.Evict = readTokValue<decltype(dst.Surf.SegmentOverride.Evict)>(*tokSegmentOverride); 7729 } break; 7730 }; 7731 tokSegmentOverride = tokSegmentOverride + 1 + tokSegmentOverride->valueDwordCount; 7732 } else { 7733 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSegmentOverride); 7734 if (tokSegmentOverride->flags.flag3IsMandatory) { 7735 return false; 7736 } 7737 tokSegmentOverride = tokSegmentOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 7738 } 7739 } 7740 WCH_ASSERT(tokSegmentOverride == tokSegmentOverrideEnd); 7741 } break; 7742 case TOK_FS_GMM_TEXTURE_INFO_REC__PLATFORM: { 7743 #if _DEBUG || _RELEASE_INTERNAL 7744 const TokenHeader *tokPlatform = varLen->getValue<TokenHeader>(); 7745 const TokenHeader *tokPlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 7746 while (tokPlatform < tokPlatformEnd) { 7747 if (false == tokPlatform->flags.flag4IsVariableLength) { 7748 switch (tokPlatform->id) { 7749 default: 7750 if (tokPlatform->flags.flag3IsMandatory) { 7751 return false; 7752 } 7753 break; 7754 case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { 7755 dst.Surf.Platform.eProductFamily = readTokValue<decltype(dst.Surf.Platform.eProductFamily)>(*tokPlatform); 7756 } break; 7757 case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { 7758 dst.Surf.Platform.ePCHProductFamily = readTokValue<decltype(dst.Surf.Platform.ePCHProductFamily)>(*tokPlatform); 7759 } break; 7760 case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { 7761 dst.Surf.Platform.eDisplayCoreFamily = readTokValue<decltype(dst.Surf.Platform.eDisplayCoreFamily)>(*tokPlatform); 7762 } break; 7763 case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { 7764 dst.Surf.Platform.eRenderCoreFamily = readTokValue<decltype(dst.Surf.Platform.eRenderCoreFamily)>(*tokPlatform); 7765 } break; 7766 case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { 7767 dst.Surf.Platform.ePlatformType = readTokValue<decltype(dst.Surf.Platform.ePlatformType)>(*tokPlatform); 7768 } break; 7769 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { 7770 dst.Surf.Platform.usDeviceID = readTokValue<decltype(dst.Surf.Platform.usDeviceID)>(*tokPlatform); 7771 } break; 7772 case TOK_FBW_PLATFORM_STR__US_REV_ID: { 7773 dst.Surf.Platform.usRevId = readTokValue<decltype(dst.Surf.Platform.usRevId)>(*tokPlatform); 7774 } break; 7775 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { 7776 dst.Surf.Platform.usDeviceID_PCH = readTokValue<decltype(dst.Surf.Platform.usDeviceID_PCH)>(*tokPlatform); 7777 } break; 7778 case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { 7779 dst.Surf.Platform.usRevId_PCH = readTokValue<decltype(dst.Surf.Platform.usRevId_PCH)>(*tokPlatform); 7780 } break; 7781 case TOK_FE_PLATFORM_STR__E_GTTYPE: { 7782 dst.Surf.Platform.eGTType = readTokValue<decltype(dst.Surf.Platform.eGTType)>(*tokPlatform); 7783 } break; 7784 }; 7785 tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount; 7786 } else { 7787 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlatform); 7788 if (tokPlatform->flags.flag3IsMandatory) { 7789 return false; 7790 } 7791 tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 7792 } 7793 } 7794 WCH_ASSERT(tokPlatform == tokPlatformEnd); 7795 #endif 7796 } break; 7797 case TOK_FS_GMM_TEXTURE_INFO_REC__EXISTING_SYS_MEM: { 7798 const TokenHeader *tokExistingSysMem = varLen->getValue<TokenHeader>(); 7799 const TokenHeader *tokExistingSysMemEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 7800 while (tokExistingSysMem < tokExistingSysMemEnd) { 7801 if (false == tokExistingSysMem->flags.flag4IsVariableLength) { 7802 switch (tokExistingSysMem->id) { 7803 default: 7804 if (tokExistingSysMem->flags.flag3IsMandatory) { 7805 return false; 7806 } 7807 break; 7808 case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_GMM_ALLOCATED: { 7809 dst.Surf.ExistingSysMem.IsGmmAllocated = readTokValue<decltype(dst.Surf.ExistingSysMem.IsGmmAllocated)>(*tokExistingSysMem); 7810 } break; 7811 case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_PAGE_ALIGNED: { 7812 dst.Surf.ExistingSysMem.IsPageAligned = readTokValue<decltype(dst.Surf.ExistingSysMem.IsPageAligned)>(*tokExistingSysMem); 7813 } break; 7814 }; 7815 tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount; 7816 } else { 7817 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokExistingSysMem); 7818 if (tokExistingSysMem->flags.flag3IsMandatory) { 7819 return false; 7820 } 7821 tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 7822 } 7823 } 7824 WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd); 7825 } break; 7826 case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: { 7827 #if !(_DEBUG || _RELEASE_INTERNAL) 7828 const TokenHeader *tok__Platform = varLen->getValue<TokenHeader>(); 7829 const TokenHeader *tok__PlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 7830 while (tok__Platform < tok__PlatformEnd) { 7831 if (false == tok__Platform->flags.flag4IsVariableLength) { 7832 switch (tok__Platform->id) { 7833 default: 7834 if (tok__Platform->flags.flag3IsMandatory) { 7835 return false; 7836 } 7837 break; 7838 case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { 7839 dst.Surf.__Platform.eProductFamily = readTokValue<decltype(dst.Surf.__Platform.eProductFamily)>(*tok__Platform); 7840 } break; 7841 case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { 7842 dst.Surf.__Platform.ePCHProductFamily = readTokValue<decltype(dst.Surf.__Platform.ePCHProductFamily)>(*tok__Platform); 7843 } break; 7844 case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { 7845 dst.Surf.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.Surf.__Platform.eDisplayCoreFamily)>(*tok__Platform); 7846 } break; 7847 case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { 7848 dst.Surf.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.Surf.__Platform.eRenderCoreFamily)>(*tok__Platform); 7849 } break; 7850 case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { 7851 dst.Surf.__Platform.ePlatformType = readTokValue<decltype(dst.Surf.__Platform.ePlatformType)>(*tok__Platform); 7852 } break; 7853 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { 7854 dst.Surf.__Platform.usDeviceID = readTokValue<decltype(dst.Surf.__Platform.usDeviceID)>(*tok__Platform); 7855 } break; 7856 case TOK_FBW_PLATFORM_STR__US_REV_ID: { 7857 dst.Surf.__Platform.usRevId = readTokValue<decltype(dst.Surf.__Platform.usRevId)>(*tok__Platform); 7858 } break; 7859 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { 7860 dst.Surf.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.Surf.__Platform.usDeviceID_PCH)>(*tok__Platform); 7861 } break; 7862 case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { 7863 dst.Surf.__Platform.usRevId_PCH = readTokValue<decltype(dst.Surf.__Platform.usRevId_PCH)>(*tok__Platform); 7864 } break; 7865 case TOK_FE_PLATFORM_STR__E_GTTYPE: { 7866 dst.Surf.__Platform.eGTType = readTokValue<decltype(dst.Surf.__Platform.eGTType)>(*tok__Platform); 7867 } break; 7868 }; 7869 tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount; 7870 } else { 7871 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok__Platform); 7872 if (tok__Platform->flags.flag3IsMandatory) { 7873 return false; 7874 } 7875 tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 7876 } 7877 } 7878 WCH_ASSERT(tok__Platform == tok__PlatformEnd); 7879 #endif 7880 } break; 7881 }; 7882 tokSurf = tokSurf + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 7883 } 7884 } 7885 WCH_ASSERT(tokSurf == tokSurfEnd); 7886 } break; 7887 case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__AUX_SURF: { 7888 const TokenHeader *tokAuxSurf = varLen->getValue<TokenHeader>(); 7889 const TokenHeader *tokAuxSurfEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 7890 while (tokAuxSurf < tokAuxSurfEnd) { 7891 if (false == tokAuxSurf->flags.flag4IsVariableLength) { 7892 switch (tokAuxSurf->id) { 7893 default: 7894 if (tokAuxSurf->flags.flag3IsMandatory) { 7895 return false; 7896 } 7897 break; 7898 case TOK_FE_GMM_TEXTURE_INFO_REC__TYPE: { 7899 dst.AuxSurf.Type = readTokValue<decltype(dst.AuxSurf.Type)>(*tokAuxSurf); 7900 } break; 7901 case TOK_FE_GMM_TEXTURE_INFO_REC__FORMAT: { 7902 dst.AuxSurf.Format = readTokValue<decltype(dst.AuxSurf.Format)>(*tokAuxSurf); 7903 } break; 7904 case TOK_FBD_GMM_TEXTURE_INFO_REC__BITS_PER_PIXEL: { 7905 dst.AuxSurf.BitsPerPixel = readTokValue<decltype(dst.AuxSurf.BitsPerPixel)>(*tokAuxSurf); 7906 } break; 7907 case TOK_FBQ_GMM_TEXTURE_INFO_REC__BASE_WIDTH: { 7908 dst.AuxSurf.BaseWidth = readTokValue<decltype(dst.AuxSurf.BaseWidth)>(*tokAuxSurf); 7909 } break; 7910 case TOK_FBD_GMM_TEXTURE_INFO_REC__BASE_HEIGHT: { 7911 dst.AuxSurf.BaseHeight = readTokValue<decltype(dst.AuxSurf.BaseHeight)>(*tokAuxSurf); 7912 } break; 7913 case TOK_FBD_GMM_TEXTURE_INFO_REC__DEPTH: { 7914 dst.AuxSurf.Depth = readTokValue<decltype(dst.AuxSurf.Depth)>(*tokAuxSurf); 7915 } break; 7916 case TOK_FBD_GMM_TEXTURE_INFO_REC__MAX_LOD: { 7917 dst.AuxSurf.MaxLod = readTokValue<decltype(dst.AuxSurf.MaxLod)>(*tokAuxSurf); 7918 } break; 7919 case TOK_FBD_GMM_TEXTURE_INFO_REC__ARRAY_SIZE: { 7920 dst.AuxSurf.ArraySize = readTokValue<decltype(dst.AuxSurf.ArraySize)>(*tokAuxSurf); 7921 } break; 7922 case TOK_FBD_GMM_TEXTURE_INFO_REC__CP_TAG: { 7923 dst.AuxSurf.CpTag = readTokValue<decltype(dst.AuxSurf.CpTag)>(*tokAuxSurf); 7924 } break; 7925 case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_MODE: { 7926 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokAuxSurf).getValue<char>(); 7927 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokAuxSurf).getValueSizeInBytes(); 7928 if (srcSize < sizeof(dst.AuxSurf.MmcMode)) { 7929 return false; 7930 } 7931 WCH_SAFE_COPY(dst.AuxSurf.MmcMode, sizeof(dst.AuxSurf.MmcMode), srcData, sizeof(dst.AuxSurf.MmcMode)); 7932 } break; 7933 case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_HINT: { 7934 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokAuxSurf).getValue<char>(); 7935 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokAuxSurf).getValueSizeInBytes(); 7936 if (srcSize < sizeof(dst.AuxSurf.MmcHint)) { 7937 return false; 7938 } 7939 WCH_SAFE_COPY(dst.AuxSurf.MmcHint, sizeof(dst.AuxSurf.MmcHint), srcData, sizeof(dst.AuxSurf.MmcHint)); 7940 } break; 7941 case TOK_FBQ_GMM_TEXTURE_INFO_REC__PITCH: { 7942 dst.AuxSurf.Pitch = readTokValue<decltype(dst.AuxSurf.Pitch)>(*tokAuxSurf); 7943 } break; 7944 case TOK_FBQ_GMM_TEXTURE_INFO_REC__OVERRIDE_PITCH: { 7945 dst.AuxSurf.OverridePitch = readTokValue<decltype(dst.AuxSurf.OverridePitch)>(*tokAuxSurf); 7946 } break; 7947 case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE: { 7948 dst.AuxSurf.Size = readTokValue<decltype(dst.AuxSurf.Size)>(*tokAuxSurf); 7949 } break; 7950 case TOK_FBQ_GMM_TEXTURE_INFO_REC__CCSIZE: { 7951 dst.AuxSurf.CCSize = readTokValue<decltype(dst.AuxSurf.CCSize)>(*tokAuxSurf); 7952 } break; 7953 case TOK_FBQ_GMM_TEXTURE_INFO_REC__UNPADDED_SIZE: { 7954 dst.AuxSurf.UnpaddedSize = readTokValue<decltype(dst.AuxSurf.UnpaddedSize)>(*tokAuxSurf); 7955 } break; 7956 case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE_REPORT_TO_OS: { 7957 dst.AuxSurf.SizeReportToOS = readTokValue<decltype(dst.AuxSurf.SizeReportToOS)>(*tokAuxSurf); 7958 } break; 7959 case TOK_FE_GMM_TEXTURE_INFO_REC__TILE_MODE: { 7960 dst.AuxSurf.TileMode = readTokValue<decltype(dst.AuxSurf.TileMode)>(*tokAuxSurf); 7961 } break; 7962 case TOK_FBD_GMM_TEXTURE_INFO_REC__CCSMODE_ALIGN: { 7963 dst.AuxSurf.CCSModeAlign = readTokValue<decltype(dst.AuxSurf.CCSModeAlign)>(*tokAuxSurf); 7964 } break; 7965 case TOK_FBD_GMM_TEXTURE_INFO_REC__LEGACY_FLAGS: { 7966 dst.AuxSurf.LegacyFlags = readTokValue<decltype(dst.AuxSurf.LegacyFlags)>(*tokAuxSurf); 7967 } break; 7968 case TOK_FBD_GMM_TEXTURE_INFO_REC__MAXIMUM_RENAMING_LIST_LENGTH: { 7969 dst.AuxSurf.MaximumRenamingListLength = readTokValue<decltype(dst.AuxSurf.MaximumRenamingListLength)>(*tokAuxSurf); 7970 } break; 7971 }; 7972 tokAuxSurf = tokAuxSurf + 1 + tokAuxSurf->valueDwordCount; 7973 } else { 7974 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokAuxSurf); 7975 switch (tokAuxSurf->id) { 7976 default: 7977 if (tokAuxSurf->flags.flag3IsMandatory) { 7978 return false; 7979 } 7980 break; 7981 case TOK_FS_GMM_TEXTURE_INFO_REC__FLAGS: { 7982 const TokenHeader *tokFlags = varLen->getValue<TokenHeader>(); 7983 const TokenHeader *tokFlagsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 7984 while (tokFlags < tokFlagsEnd) { 7985 if (false == tokFlags->flags.flag4IsVariableLength) { 7986 if (tokFlags->flags.flag3IsMandatory) { 7987 return false; 7988 } 7989 tokFlags = tokFlags + 1 + tokFlags->valueDwordCount; 7990 } else { 7991 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokFlags); 7992 switch (tokFlags->id) { 7993 default: 7994 if (tokFlags->flags.flag3IsMandatory) { 7995 return false; 7996 } 7997 break; 7998 case TOK_FS_GMM_RESOURCE_FLAG_REC__GPU: { 7999 const TokenHeader *tokGpu = varLen->getValue<TokenHeader>(); 8000 const TokenHeader *tokGpuEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 8001 while (tokGpu < tokGpuEnd) { 8002 if (false == tokGpu->flags.flag4IsVariableLength) { 8003 switch (tokGpu->id) { 8004 default: 8005 if (tokGpu->flags.flag3IsMandatory) { 8006 return false; 8007 } 8008 break; 8009 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CAMERA_CAPTURE: { 8010 dst.AuxSurf.Flags.Gpu.CameraCapture = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.CameraCapture)>(*tokGpu); 8011 } break; 8012 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CCS: { 8013 dst.AuxSurf.Flags.Gpu.CCS = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.CCS)>(*tokGpu); 8014 } break; 8015 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_DISCARD: { 8016 dst.AuxSurf.Flags.Gpu.ColorDiscard = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.ColorDiscard)>(*tokGpu); 8017 } break; 8018 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION: { 8019 dst.AuxSurf.Flags.Gpu.ColorSeparation = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.ColorSeparation)>(*tokGpu); 8020 } break; 8021 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION_RGBX: { 8022 dst.AuxSurf.Flags.Gpu.ColorSeparationRGBX = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.ColorSeparationRGBX)>(*tokGpu); 8023 } break; 8024 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CONSTANT: { 8025 dst.AuxSurf.Flags.Gpu.Constant = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.Constant)>(*tokGpu); 8026 } break; 8027 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__DEPTH: { 8028 dst.AuxSurf.Flags.Gpu.Depth = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.Depth)>(*tokGpu); 8029 } break; 8030 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN: { 8031 dst.AuxSurf.Flags.Gpu.FlipChain = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.FlipChain)>(*tokGpu); 8032 } break; 8033 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN_PREFERRED: { 8034 dst.AuxSurf.Flags.Gpu.FlipChainPreferred = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.FlipChainPreferred)>(*tokGpu); 8035 } break; 8036 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HISTORY_BUFFER: { 8037 dst.AuxSurf.Flags.Gpu.HistoryBuffer = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.HistoryBuffer)>(*tokGpu); 8038 } break; 8039 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HI_Z: { 8040 dst.AuxSurf.Flags.Gpu.HiZ = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.HiZ)>(*tokGpu); 8041 } break; 8042 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDEX: { 8043 dst.AuxSurf.Flags.Gpu.Index = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.Index)>(*tokGpu); 8044 } break; 8045 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDIRECT_CLEAR_COLOR: { 8046 dst.AuxSurf.Flags.Gpu.IndirectClearColor = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.IndirectClearColor)>(*tokGpu); 8047 } break; 8048 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INSTRUCTION_FLAT: { 8049 dst.AuxSurf.Flags.Gpu.InstructionFlat = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.InstructionFlat)>(*tokGpu); 8050 } break; 8051 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INTERLACED_SCAN: { 8052 dst.AuxSurf.Flags.Gpu.InterlacedScan = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.InterlacedScan)>(*tokGpu); 8053 } break; 8054 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MCS: { 8055 dst.AuxSurf.Flags.Gpu.MCS = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.MCS)>(*tokGpu); 8056 } break; 8057 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MMC: { 8058 dst.AuxSurf.Flags.Gpu.MMC = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.MMC)>(*tokGpu); 8059 } break; 8060 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MOTION_COMP: { 8061 dst.AuxSurf.Flags.Gpu.MotionComp = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.MotionComp)>(*tokGpu); 8062 } break; 8063 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__NO_RESTRICTION: { 8064 dst.AuxSurf.Flags.Gpu.NoRestriction = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.NoRestriction)>(*tokGpu); 8065 } break; 8066 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__OVERLAY: { 8067 dst.AuxSurf.Flags.Gpu.Overlay = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.Overlay)>(*tokGpu); 8068 } break; 8069 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PRESENTABLE: { 8070 dst.AuxSurf.Flags.Gpu.Presentable = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.Presentable)>(*tokGpu); 8071 } break; 8072 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PROCEDURAL_TEXTURE: { 8073 dst.AuxSurf.Flags.Gpu.ProceduralTexture = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.ProceduralTexture)>(*tokGpu); 8074 } break; 8075 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__QUERY: { 8076 dst.AuxSurf.Flags.Gpu.Query = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.Query)>(*tokGpu); 8077 } break; 8078 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__RENDER_TARGET: { 8079 dst.AuxSurf.Flags.Gpu.RenderTarget = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.RenderTarget)>(*tokGpu); 8080 } break; 8081 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D: { 8082 dst.AuxSurf.Flags.Gpu.S3d = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.S3d)>(*tokGpu); 8083 } break; 8084 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D_DX: { 8085 dst.AuxSurf.Flags.Gpu.S3dDx = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.S3dDx)>(*tokGpu); 8086 } break; 8087 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_NON_PACKED: { 8088 dst.AuxSurf.Flags.Gpu.__S3dNonPacked = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.__S3dNonPacked)>(*tokGpu); 8089 } break; 8090 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_WIDI: { 8091 dst.AuxSurf.Flags.Gpu.__S3dWidi = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.__S3dWidi)>(*tokGpu); 8092 } break; 8093 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SCRATCH_FLAT: { 8094 dst.AuxSurf.Flags.Gpu.ScratchFlat = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.ScratchFlat)>(*tokGpu); 8095 } break; 8096 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SEPARATE_STENCIL: { 8097 dst.AuxSurf.Flags.Gpu.SeparateStencil = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.SeparateStencil)>(*tokGpu); 8098 } break; 8099 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE: { 8100 dst.AuxSurf.Flags.Gpu.State = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.State)>(*tokGpu); 8101 } break; 8102 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE_DX9CONSTANT_BUFFER: { 8103 dst.AuxSurf.Flags.Gpu.StateDx9ConstantBuffer = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.StateDx9ConstantBuffer)>(*tokGpu); 8104 } break; 8105 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STREAM: { 8106 dst.AuxSurf.Flags.Gpu.Stream = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.Stream)>(*tokGpu); 8107 } break; 8108 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXT_API: { 8109 dst.AuxSurf.Flags.Gpu.TextApi = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.TextApi)>(*tokGpu); 8110 } break; 8111 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXTURE: { 8112 dst.AuxSurf.Flags.Gpu.Texture = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.Texture)>(*tokGpu); 8113 } break; 8114 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILED_RESOURCE: { 8115 dst.AuxSurf.Flags.Gpu.TiledResource = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.TiledResource)>(*tokGpu); 8116 } break; 8117 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILE_POOL: { 8118 dst.AuxSurf.Flags.Gpu.TilePool = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.TilePool)>(*tokGpu); 8119 } break; 8120 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__UNIFIED_AUX_SURFACE: { 8121 dst.AuxSurf.Flags.Gpu.UnifiedAuxSurface = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.UnifiedAuxSurface)>(*tokGpu); 8122 } break; 8123 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VERTEX: { 8124 dst.AuxSurf.Flags.Gpu.Vertex = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.Vertex)>(*tokGpu); 8125 } break; 8126 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VIDEO: { 8127 dst.AuxSurf.Flags.Gpu.Video = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.Video)>(*tokGpu); 8128 } break; 8129 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_XCCS: { 8130 dst.AuxSurf.Flags.Gpu.__NonMsaaTileXCcs = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.__NonMsaaTileXCcs)>(*tokGpu); 8131 } break; 8132 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_YCCS: { 8133 dst.AuxSurf.Flags.Gpu.__NonMsaaTileYCcs = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.__NonMsaaTileYCcs)>(*tokGpu); 8134 } break; 8135 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____MSAA_TILE_MCS: { 8136 dst.AuxSurf.Flags.Gpu.__MsaaTileMcs = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.__MsaaTileMcs)>(*tokGpu); 8137 } break; 8138 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_LINEAR_CCS: { 8139 dst.AuxSurf.Flags.Gpu.__NonMsaaLinearCCS = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.__NonMsaaLinearCCS)>(*tokGpu); 8140 } break; 8141 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____REMAINING: { 8142 dst.AuxSurf.Flags.Gpu.__Remaining = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.__Remaining)>(*tokGpu); 8143 } break; 8144 }; 8145 tokGpu = tokGpu + 1 + tokGpu->valueDwordCount; 8146 } else { 8147 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokGpu); 8148 if (tokGpu->flags.flag3IsMandatory) { 8149 return false; 8150 } 8151 tokGpu = tokGpu + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 8152 } 8153 } 8154 WCH_ASSERT(tokGpu == tokGpuEnd); 8155 } break; 8156 case TOK_FS_GMM_RESOURCE_FLAG_REC__INFO: { 8157 const TokenHeader *tokInfo = varLen->getValue<TokenHeader>(); 8158 const TokenHeader *tokInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 8159 while (tokInfo < tokInfoEnd) { 8160 if (false == tokInfo->flags.flag4IsVariableLength) { 8161 switch (tokInfo->id) { 8162 default: 8163 if (tokInfo->flags.flag3IsMandatory) { 8164 return false; 8165 } 8166 break; 8167 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ALLOW_VIRTUAL_PADDING: { 8168 dst.AuxSurf.Flags.Info.AllowVirtualPadding = readTokValue<decltype(dst.AuxSurf.Flags.Info.AllowVirtualPadding)>(*tokInfo); 8169 } break; 8170 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__BIG_PAGE: { 8171 dst.AuxSurf.Flags.Info.BigPage = readTokValue<decltype(dst.AuxSurf.Flags.Info.BigPage)>(*tokInfo); 8172 } break; 8173 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CACHEABLE: { 8174 dst.AuxSurf.Flags.Info.Cacheable = readTokValue<decltype(dst.AuxSurf.Flags.Info.Cacheable)>(*tokInfo); 8175 } break; 8176 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CONTIG_PHYS_MEMORY_FORI_DART: { 8177 dst.AuxSurf.Flags.Info.ContigPhysMemoryForiDART = readTokValue<decltype(dst.AuxSurf.Flags.Info.ContigPhysMemoryForiDART)>(*tokInfo); 8178 } break; 8179 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CORNER_TEXEL_MODE: { 8180 dst.AuxSurf.Flags.Info.CornerTexelMode = readTokValue<decltype(dst.AuxSurf.Flags.Info.CornerTexelMode)>(*tokInfo); 8181 } break; 8182 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__EXISTING_SYS_MEM: { 8183 dst.AuxSurf.Flags.Info.ExistingSysMem = readTokValue<decltype(dst.AuxSurf.Flags.Info.ExistingSysMem)>(*tokInfo); 8184 } break; 8185 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__FORCE_RESIDENCY: { 8186 dst.AuxSurf.Flags.Info.ForceResidency = readTokValue<decltype(dst.AuxSurf.Flags.Info.ForceResidency)>(*tokInfo); 8187 } break; 8188 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GFDT: { 8189 dst.AuxSurf.Flags.Info.Gfdt = readTokValue<decltype(dst.AuxSurf.Flags.Info.Gfdt)>(*tokInfo); 8190 } break; 8191 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GTT_MAP_TYPE: { 8192 dst.AuxSurf.Flags.Info.GttMapType = readTokValue<decltype(dst.AuxSurf.Flags.Info.GttMapType)>(*tokInfo); 8193 } break; 8194 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__HARDWARE_PROTECTED: { 8195 dst.AuxSurf.Flags.Info.HardwareProtected = readTokValue<decltype(dst.AuxSurf.Flags.Info.HardwareProtected)>(*tokInfo); 8196 } break; 8197 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__KERNEL_MODE_MAPPED: { 8198 dst.AuxSurf.Flags.Info.KernelModeMapped = readTokValue<decltype(dst.AuxSurf.Flags.Info.KernelModeMapped)>(*tokInfo); 8199 } break; 8200 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_BELOW: { 8201 dst.AuxSurf.Flags.Info.LayoutBelow = readTokValue<decltype(dst.AuxSurf.Flags.Info.LayoutBelow)>(*tokInfo); 8202 } break; 8203 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_MONO: { 8204 dst.AuxSurf.Flags.Info.LayoutMono = readTokValue<decltype(dst.AuxSurf.Flags.Info.LayoutMono)>(*tokInfo); 8205 } break; 8206 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_RIGHT: { 8207 dst.AuxSurf.Flags.Info.LayoutRight = readTokValue<decltype(dst.AuxSurf.Flags.Info.LayoutRight)>(*tokInfo); 8208 } break; 8209 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LOCAL_ONLY: { 8210 dst.AuxSurf.Flags.Info.LocalOnly = readTokValue<decltype(dst.AuxSurf.Flags.Info.LocalOnly)>(*tokInfo); 8211 } break; 8212 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LINEAR: { 8213 dst.AuxSurf.Flags.Info.Linear = readTokValue<decltype(dst.AuxSurf.Flags.Info.Linear)>(*tokInfo); 8214 } break; 8215 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__MEDIA_COMPRESSED: { 8216 dst.AuxSurf.Flags.Info.MediaCompressed = readTokValue<decltype(dst.AuxSurf.Flags.Info.MediaCompressed)>(*tokInfo); 8217 } break; 8218 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_OPTIMIZATION_PADDING: { 8219 dst.AuxSurf.Flags.Info.NoOptimizationPadding = readTokValue<decltype(dst.AuxSurf.Flags.Info.NoOptimizationPadding)>(*tokInfo); 8220 } break; 8221 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_PHYS_MEMORY: { 8222 dst.AuxSurf.Flags.Info.NoPhysMemory = readTokValue<decltype(dst.AuxSurf.Flags.Info.NoPhysMemory)>(*tokInfo); 8223 } break; 8224 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NOT_LOCKABLE: { 8225 dst.AuxSurf.Flags.Info.NotLockable = readTokValue<decltype(dst.AuxSurf.Flags.Info.NotLockable)>(*tokInfo); 8226 } break; 8227 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NON_LOCAL_ONLY: { 8228 dst.AuxSurf.Flags.Info.NonLocalOnly = readTokValue<decltype(dst.AuxSurf.Flags.Info.NonLocalOnly)>(*tokInfo); 8229 } break; 8230 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__STD_SWIZZLE: { 8231 dst.AuxSurf.Flags.Info.StdSwizzle = readTokValue<decltype(dst.AuxSurf.Flags.Info.StdSwizzle)>(*tokInfo); 8232 } break; 8233 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__PSEUDO_STD_SWIZZLE: { 8234 dst.AuxSurf.Flags.Info.PseudoStdSwizzle = readTokValue<decltype(dst.AuxSurf.Flags.Info.PseudoStdSwizzle)>(*tokInfo); 8235 } break; 8236 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__UNDEFINED64KBSWIZZLE: { 8237 dst.AuxSurf.Flags.Info.Undefined64KBSwizzle = readTokValue<decltype(dst.AuxSurf.Flags.Info.Undefined64KBSwizzle)>(*tokInfo); 8238 } break; 8239 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__REDECRIBED_PLANES: { 8240 dst.AuxSurf.Flags.Info.RedecribedPlanes = readTokValue<decltype(dst.AuxSurf.Flags.Info.RedecribedPlanes)>(*tokInfo); 8241 } break; 8242 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__RENDER_COMPRESSED: { 8243 dst.AuxSurf.Flags.Info.RenderCompressed = readTokValue<decltype(dst.AuxSurf.Flags.Info.RenderCompressed)>(*tokInfo); 8244 } break; 8245 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ROTATED: { 8246 dst.AuxSurf.Flags.Info.Rotated = readTokValue<decltype(dst.AuxSurf.Flags.Info.Rotated)>(*tokInfo); 8247 } break; 8248 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SHARED: { 8249 dst.AuxSurf.Flags.Info.Shared = readTokValue<decltype(dst.AuxSurf.Flags.Info.Shared)>(*tokInfo); 8250 } break; 8251 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SOFTWARE_PROTECTED: { 8252 dst.AuxSurf.Flags.Info.SoftwareProtected = readTokValue<decltype(dst.AuxSurf.Flags.Info.SoftwareProtected)>(*tokInfo); 8253 } break; 8254 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SVM: { 8255 dst.AuxSurf.Flags.Info.SVM = readTokValue<decltype(dst.AuxSurf.Flags.Info.SVM)>(*tokInfo); 8256 } break; 8257 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE4: { 8258 dst.AuxSurf.Flags.Info.Tile4 = readTokValue<decltype(dst.AuxSurf.Flags.Info.Tile4)>(*tokInfo); 8259 } break; 8260 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE64: { 8261 dst.AuxSurf.Flags.Info.Tile64 = readTokValue<decltype(dst.AuxSurf.Flags.Info.Tile64)>(*tokInfo); 8262 } break; 8263 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_W: { 8264 dst.AuxSurf.Flags.Info.TiledW = readTokValue<decltype(dst.AuxSurf.Flags.Info.TiledW)>(*tokInfo); 8265 } break; 8266 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_X: { 8267 dst.AuxSurf.Flags.Info.TiledX = readTokValue<decltype(dst.AuxSurf.Flags.Info.TiledX)>(*tokInfo); 8268 } break; 8269 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_Y: { 8270 dst.AuxSurf.Flags.Info.TiledY = readTokValue<decltype(dst.AuxSurf.Flags.Info.TiledY)>(*tokInfo); 8271 } break; 8272 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YF: { 8273 dst.AuxSurf.Flags.Info.TiledYf = readTokValue<decltype(dst.AuxSurf.Flags.Info.TiledYf)>(*tokInfo); 8274 } break; 8275 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YS: { 8276 dst.AuxSurf.Flags.Info.TiledYs = readTokValue<decltype(dst.AuxSurf.Flags.Info.TiledYs)>(*tokInfo); 8277 } break; 8278 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__WDDM_PROTECTED: { 8279 dst.AuxSurf.Flags.Info.WddmProtected = readTokValue<decltype(dst.AuxSurf.Flags.Info.WddmProtected)>(*tokInfo); 8280 } break; 8281 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__XADAPTER: { 8282 dst.AuxSurf.Flags.Info.XAdapter = readTokValue<decltype(dst.AuxSurf.Flags.Info.XAdapter)>(*tokInfo); 8283 } break; 8284 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PREALLOCATED_RES_INFO: { 8285 dst.AuxSurf.Flags.Info.__PreallocatedResInfo = readTokValue<decltype(dst.AuxSurf.Flags.Info.__PreallocatedResInfo)>(*tokInfo); 8286 } break; 8287 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PRE_WDDM2SVM: { 8288 dst.AuxSurf.Flags.Info.__PreWddm2SVM = readTokValue<decltype(dst.AuxSurf.Flags.Info.__PreWddm2SVM)>(*tokInfo); 8289 } break; 8290 }; 8291 tokInfo = tokInfo + 1 + tokInfo->valueDwordCount; 8292 } else { 8293 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInfo); 8294 if (tokInfo->flags.flag3IsMandatory) { 8295 return false; 8296 } 8297 tokInfo = tokInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 8298 } 8299 } 8300 WCH_ASSERT(tokInfo == tokInfoEnd); 8301 } break; 8302 case TOK_FS_GMM_RESOURCE_FLAG_REC__WA: { 8303 const TokenHeader *tokWa = varLen->getValue<TokenHeader>(); 8304 const TokenHeader *tokWaEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 8305 while (tokWa < tokWaEnd) { 8306 if (false == tokWa->flags.flag4IsVariableLength) { 8307 switch (tokWa->id) { 8308 default: 8309 if (tokWa->flags.flag3IsMandatory) { 8310 return false; 8311 } 8312 break; 8313 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__GTMFX2ND_LEVEL_BATCH_RING_SIZE_ALIGN: { 8314 dst.AuxSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign = readTokValue<decltype(dst.AuxSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign)>(*tokWa); 8315 } break; 8316 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_MPR_ROW_STORE32KALIGN: { 8317 dst.AuxSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign = readTokValue<decltype(dst.AuxSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign)>(*tokWa); 8318 } break; 8319 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_DMV_BUFFER32KALIGN: { 8320 dst.AuxSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign = readTokValue<decltype(dst.AuxSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign)>(*tokWa); 8321 } break; 8322 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_BUFFER_SAMPLER_PADDING: { 8323 dst.AuxSurf.Flags.Wa.NoBufferSamplerPadding = readTokValue<decltype(dst.AuxSurf.Flags.Wa.NoBufferSamplerPadding)>(*tokWa); 8324 } break; 8325 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_LEGACY_PLANAR_LINEAR_VIDEO_RESTRICTIONS: { 8326 dst.AuxSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions = readTokValue<decltype(dst.AuxSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions)>(*tokWa); 8327 } break; 8328 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__CHVASTC_SKIP_VIRTUAL_MIPS: { 8329 dst.AuxSurf.Flags.Wa.CHVAstcSkipVirtualMips = readTokValue<decltype(dst.AuxSurf.Flags.Wa.CHVAstcSkipVirtualMips)>(*tokWa); 8330 } break; 8331 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_PACKED_MIP_TAIL: { 8332 dst.AuxSurf.Flags.Wa.DisablePackedMipTail = readTokValue<decltype(dst.AuxSurf.Flags.Wa.DisablePackedMipTail)>(*tokWa); 8333 } break; 8334 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521____FORCE_OTHER_HVALIGN4: { 8335 dst.AuxSurf.Flags.Wa.__ForceOtherHVALIGN4 = readTokValue<decltype(dst.AuxSurf.Flags.Wa.__ForceOtherHVALIGN4)>(*tokWa); 8336 } break; 8337 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR: { 8338 dst.AuxSurf.Flags.Wa.DisableDisplayCcsClearColor = readTokValue<decltype(dst.AuxSurf.Flags.Wa.DisableDisplayCcsClearColor)>(*tokWa); 8339 } break; 8340 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION: { 8341 dst.AuxSurf.Flags.Wa.DisableDisplayCcsCompression = readTokValue<decltype(dst.AuxSurf.Flags.Wa.DisableDisplayCcsCompression)>(*tokWa); 8342 } break; 8343 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: { 8344 dst.AuxSurf.Flags.Wa.PreGen12FastClearOnly = readTokValue<decltype(dst.AuxSurf.Flags.Wa.PreGen12FastClearOnly)>(*tokWa); 8345 } break; 8346 }; 8347 tokWa = tokWa + 1 + tokWa->valueDwordCount; 8348 } else { 8349 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokWa); 8350 if (tokWa->flags.flag3IsMandatory) { 8351 return false; 8352 } 8353 tokWa = tokWa + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 8354 } 8355 } 8356 WCH_ASSERT(tokWa == tokWaEnd); 8357 } break; 8358 }; 8359 tokFlags = tokFlags + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 8360 } 8361 } 8362 WCH_ASSERT(tokFlags == tokFlagsEnd); 8363 } break; 8364 case TOK_FS_GMM_TEXTURE_INFO_REC__CACHE_POLICY: { 8365 const TokenHeader *tokCachePolicy = varLen->getValue<TokenHeader>(); 8366 const TokenHeader *tokCachePolicyEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 8367 while (tokCachePolicy < tokCachePolicyEnd) { 8368 if (false == tokCachePolicy->flags.flag4IsVariableLength) { 8369 switch (tokCachePolicy->id) { 8370 default: 8371 if (tokCachePolicy->flags.flag3IsMandatory) { 8372 return false; 8373 } 8374 break; 8375 case TOK_FE_GMM_TEXTURE_INFO_REC__ANONYMOUS4927__USAGE: { 8376 dst.AuxSurf.CachePolicy.Usage = readTokValue<decltype(dst.AuxSurf.CachePolicy.Usage)>(*tokCachePolicy); 8377 } break; 8378 }; 8379 tokCachePolicy = tokCachePolicy + 1 + tokCachePolicy->valueDwordCount; 8380 } else { 8381 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCachePolicy); 8382 if (tokCachePolicy->flags.flag3IsMandatory) { 8383 return false; 8384 } 8385 tokCachePolicy = tokCachePolicy + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 8386 } 8387 } 8388 WCH_ASSERT(tokCachePolicy == tokCachePolicyEnd); 8389 } break; 8390 case TOK_FS_GMM_TEXTURE_INFO_REC__MSAA: { 8391 const TokenHeader *tokMSAA = varLen->getValue<TokenHeader>(); 8392 const TokenHeader *tokMSAAEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 8393 while (tokMSAA < tokMSAAEnd) { 8394 if (false == tokMSAA->flags.flag4IsVariableLength) { 8395 switch (tokMSAA->id) { 8396 default: 8397 if (tokMSAA->flags.flag3IsMandatory) { 8398 return false; 8399 } 8400 break; 8401 case TOK_FE_GMM_RESOURCE_MSAA_INFO_REC__SAMPLE_PATTERN: { 8402 dst.AuxSurf.MSAA.SamplePattern = readTokValue<decltype(dst.AuxSurf.MSAA.SamplePattern)>(*tokMSAA); 8403 } break; 8404 case TOK_FBD_GMM_RESOURCE_MSAA_INFO_REC__NUM_SAMPLES: { 8405 dst.AuxSurf.MSAA.NumSamples = readTokValue<decltype(dst.AuxSurf.MSAA.NumSamples)>(*tokMSAA); 8406 } break; 8407 }; 8408 tokMSAA = tokMSAA + 1 + tokMSAA->valueDwordCount; 8409 } else { 8410 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokMSAA); 8411 if (tokMSAA->flags.flag3IsMandatory) { 8412 return false; 8413 } 8414 tokMSAA = tokMSAA + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 8415 } 8416 } 8417 WCH_ASSERT(tokMSAA == tokMSAAEnd); 8418 } break; 8419 case TOK_FS_GMM_TEXTURE_INFO_REC__ALIGNMENT: { 8420 const TokenHeader *tokAlignment = varLen->getValue<TokenHeader>(); 8421 const TokenHeader *tokAlignmentEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 8422 while (tokAlignment < tokAlignmentEnd) { 8423 if (false == tokAlignment->flags.flag4IsVariableLength) { 8424 switch (tokAlignment->id) { 8425 default: 8426 if (tokAlignment->flags.flag3IsMandatory) { 8427 return false; 8428 } 8429 break; 8430 case TOK_FBC_GMM_RESOURCE_ALIGNMENT_REC__ARRAY_SPACING_SINGLE_LOD: { 8431 dst.AuxSurf.Alignment.ArraySpacingSingleLod = readTokValue<decltype(dst.AuxSurf.Alignment.ArraySpacingSingleLod)>(*tokAlignment); 8432 } break; 8433 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__BASE_ALIGNMENT: { 8434 dst.AuxSurf.Alignment.BaseAlignment = readTokValue<decltype(dst.AuxSurf.Alignment.BaseAlignment)>(*tokAlignment); 8435 } break; 8436 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__HALIGN: { 8437 dst.AuxSurf.Alignment.HAlign = readTokValue<decltype(dst.AuxSurf.Alignment.HAlign)>(*tokAlignment); 8438 } break; 8439 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__VALIGN: { 8440 dst.AuxSurf.Alignment.VAlign = readTokValue<decltype(dst.AuxSurf.Alignment.VAlign)>(*tokAlignment); 8441 } break; 8442 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__DALIGN: { 8443 dst.AuxSurf.Alignment.DAlign = readTokValue<decltype(dst.AuxSurf.Alignment.DAlign)>(*tokAlignment); 8444 } break; 8445 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__MIP_TAIL_START_LOD: { 8446 dst.AuxSurf.Alignment.MipTailStartLod = readTokValue<decltype(dst.AuxSurf.Alignment.MipTailStartLod)>(*tokAlignment); 8447 } break; 8448 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_START_LOD: { 8449 dst.AuxSurf.Alignment.PackedMipStartLod = readTokValue<decltype(dst.AuxSurf.Alignment.PackedMipStartLod)>(*tokAlignment); 8450 } break; 8451 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_WIDTH: { 8452 dst.AuxSurf.Alignment.PackedMipWidth = readTokValue<decltype(dst.AuxSurf.Alignment.PackedMipWidth)>(*tokAlignment); 8453 } break; 8454 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_HEIGHT: { 8455 dst.AuxSurf.Alignment.PackedMipHeight = readTokValue<decltype(dst.AuxSurf.Alignment.PackedMipHeight)>(*tokAlignment); 8456 } break; 8457 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__QPITCH: { 8458 dst.AuxSurf.Alignment.QPitch = readTokValue<decltype(dst.AuxSurf.Alignment.QPitch)>(*tokAlignment); 8459 } break; 8460 }; 8461 tokAlignment = tokAlignment + 1 + tokAlignment->valueDwordCount; 8462 } else { 8463 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokAlignment); 8464 if (tokAlignment->flags.flag3IsMandatory) { 8465 return false; 8466 } 8467 tokAlignment = tokAlignment + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 8468 } 8469 } 8470 WCH_ASSERT(tokAlignment == tokAlignmentEnd); 8471 } break; 8472 case TOK_FS_GMM_TEXTURE_INFO_REC__OFFSET_INFO: { 8473 const TokenHeader *tokOffsetInfo = varLen->getValue<TokenHeader>(); 8474 const TokenHeader *tokOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 8475 while (tokOffsetInfo < tokOffsetInfoEnd) { 8476 if (false == tokOffsetInfo->flags.flag4IsVariableLength) { 8477 if (tokOffsetInfo->flags.flag3IsMandatory) { 8478 return false; 8479 } 8480 tokOffsetInfo = tokOffsetInfo + 1 + tokOffsetInfo->valueDwordCount; 8481 } else { 8482 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokOffsetInfo); 8483 switch (tokOffsetInfo->id) { 8484 default: 8485 if (tokOffsetInfo->flags.flag3IsMandatory) { 8486 return false; 8487 } 8488 break; 8489 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO: { 8490 const TokenHeader *tokTexture3DOffsetInfo = varLen->getValue<TokenHeader>(); 8491 const TokenHeader *tokTexture3DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 8492 while (tokTexture3DOffsetInfo < tokTexture3DOffsetInfoEnd) { 8493 if (false == tokTexture3DOffsetInfo->flags.flag4IsVariableLength) { 8494 switch (tokTexture3DOffsetInfo->id) { 8495 default: 8496 if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { 8497 return false; 8498 } 8499 break; 8500 case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: { 8501 dst.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch = readTokValue<decltype(dst.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch)>(*tokTexture3DOffsetInfo); 8502 } break; 8503 case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: { 8504 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValue<char>(); 8505 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValueSizeInBytes(); 8506 if (srcSize < sizeof(dst.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset)) { 8507 return false; 8508 } 8509 WCH_SAFE_COPY(dst.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(dst.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset), srcData, sizeof(dst.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset)); 8510 } break; 8511 }; 8512 tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + 1 + tokTexture3DOffsetInfo->valueDwordCount; 8513 } else { 8514 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture3DOffsetInfo); 8515 if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { 8516 return false; 8517 } 8518 tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 8519 } 8520 } 8521 WCH_ASSERT(tokTexture3DOffsetInfo == tokTexture3DOffsetInfoEnd); 8522 } break; 8523 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO: { 8524 const TokenHeader *tokTexture2DOffsetInfo = varLen->getValue<TokenHeader>(); 8525 const TokenHeader *tokTexture2DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 8526 while (tokTexture2DOffsetInfo < tokTexture2DOffsetInfoEnd) { 8527 if (false == tokTexture2DOffsetInfo->flags.flag4IsVariableLength) { 8528 switch (tokTexture2DOffsetInfo->id) { 8529 default: 8530 if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { 8531 return false; 8532 } 8533 break; 8534 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: { 8535 dst.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock = readTokValue<decltype(dst.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock)>(*tokTexture2DOffsetInfo); 8536 } break; 8537 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: { 8538 dst.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender = readTokValue<decltype(dst.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender)>(*tokTexture2DOffsetInfo); 8539 } break; 8540 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: { 8541 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValue<char>(); 8542 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValueSizeInBytes(); 8543 if (srcSize < sizeof(dst.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset)) { 8544 return false; 8545 } 8546 WCH_SAFE_COPY(dst.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(dst.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset), srcData, sizeof(dst.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset)); 8547 } break; 8548 }; 8549 tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + 1 + tokTexture2DOffsetInfo->valueDwordCount; 8550 } else { 8551 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture2DOffsetInfo); 8552 if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { 8553 return false; 8554 } 8555 tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 8556 } 8557 } 8558 WCH_ASSERT(tokTexture2DOffsetInfo == tokTexture2DOffsetInfoEnd); 8559 } break; 8560 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE: { 8561 const TokenHeader *tokPlane = varLen->getValue<TokenHeader>(); 8562 const TokenHeader *tokPlaneEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 8563 while (tokPlane < tokPlaneEnd) { 8564 if (false == tokPlane->flags.flag4IsVariableLength) { 8565 switch (tokPlane->id) { 8566 default: 8567 if (tokPlane->flags.flag3IsMandatory) { 8568 return false; 8569 } 8570 break; 8571 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: { 8572 dst.AuxSurf.OffsetInfo.Plane.ArrayQPitch = readTokValue<decltype(dst.AuxSurf.OffsetInfo.Plane.ArrayQPitch)>(*tokPlane); 8573 } break; 8574 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: { 8575 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>(); 8576 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes(); 8577 if (srcSize < sizeof(dst.AuxSurf.OffsetInfo.Plane.X)) { 8578 return false; 8579 } 8580 WCH_SAFE_COPY(dst.AuxSurf.OffsetInfo.Plane.X, sizeof(dst.AuxSurf.OffsetInfo.Plane.X), srcData, sizeof(dst.AuxSurf.OffsetInfo.Plane.X)); 8581 } break; 8582 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: { 8583 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>(); 8584 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes(); 8585 if (srcSize < sizeof(dst.AuxSurf.OffsetInfo.Plane.Y)) { 8586 return false; 8587 } 8588 WCH_SAFE_COPY(dst.AuxSurf.OffsetInfo.Plane.Y, sizeof(dst.AuxSurf.OffsetInfo.Plane.Y), srcData, sizeof(dst.AuxSurf.OffsetInfo.Plane.Y)); 8589 } break; 8590 case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: { 8591 dst.AuxSurf.OffsetInfo.Plane.NoOfPlanes = readTokValue<decltype(dst.AuxSurf.OffsetInfo.Plane.NoOfPlanes)>(*tokPlane); 8592 } break; 8593 case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: { 8594 dst.AuxSurf.OffsetInfo.Plane.IsTileAlignedPlanes = readTokValue<decltype(dst.AuxSurf.OffsetInfo.Plane.IsTileAlignedPlanes)>(*tokPlane); 8595 } break; 8596 }; 8597 tokPlane = tokPlane + 1 + tokPlane->valueDwordCount; 8598 } else { 8599 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlane); 8600 switch (tokPlane->id) { 8601 default: 8602 if (tokPlane->flags.flag3IsMandatory) { 8603 return false; 8604 } 8605 break; 8606 case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: { 8607 const TokenHeader *tokUnAligned = varLen->getValue<TokenHeader>(); 8608 const TokenHeader *tokUnAlignedEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 8609 while (tokUnAligned < tokUnAlignedEnd) { 8610 if (false == tokUnAligned->flags.flag4IsVariableLength) { 8611 switch (tokUnAligned->id) { 8612 default: 8613 if (tokUnAligned->flags.flag3IsMandatory) { 8614 return false; 8615 } 8616 break; 8617 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: { 8618 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValue<char>(); 8619 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValueSizeInBytes(); 8620 if (srcSize < sizeof(dst.AuxSurf.OffsetInfo.Plane.UnAligned.Height)) { 8621 return false; 8622 } 8623 WCH_SAFE_COPY(dst.AuxSurf.OffsetInfo.Plane.UnAligned.Height, sizeof(dst.AuxSurf.OffsetInfo.Plane.UnAligned.Height), srcData, sizeof(dst.AuxSurf.OffsetInfo.Plane.UnAligned.Height)); 8624 } break; 8625 }; 8626 tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount; 8627 } else { 8628 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokUnAligned); 8629 if (tokUnAligned->flags.flag3IsMandatory) { 8630 return false; 8631 } 8632 tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 8633 } 8634 } 8635 WCH_ASSERT(tokUnAligned == tokUnAlignedEnd); 8636 } break; 8637 }; 8638 tokPlane = tokPlane + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 8639 } 8640 } 8641 WCH_ASSERT(tokPlane == tokPlaneEnd); 8642 } break; 8643 }; 8644 tokOffsetInfo = tokOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 8645 } 8646 } 8647 WCH_ASSERT(tokOffsetInfo == tokOffsetInfoEnd); 8648 } break; 8649 case TOK_FS_GMM_TEXTURE_INFO_REC__S3D: { 8650 const TokenHeader *tokS3d = varLen->getValue<TokenHeader>(); 8651 const TokenHeader *tokS3dEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 8652 while (tokS3d < tokS3dEnd) { 8653 if (false == tokS3d->flags.flag4IsVariableLength) { 8654 switch (tokS3d->id) { 8655 default: 8656 if (tokS3d->flags.flag3IsMandatory) { 8657 return false; 8658 } 8659 break; 8660 case TOK_FBD_GMM_S3D_INFO_REC__DISPLAY_MODE_HEIGHT: { 8661 dst.AuxSurf.S3d.DisplayModeHeight = readTokValue<decltype(dst.AuxSurf.S3d.DisplayModeHeight)>(*tokS3d); 8662 } break; 8663 case TOK_FBD_GMM_S3D_INFO_REC__NUM_BLANK_ACTIVE_LINES: { 8664 dst.AuxSurf.S3d.NumBlankActiveLines = readTokValue<decltype(dst.AuxSurf.S3d.NumBlankActiveLines)>(*tokS3d); 8665 } break; 8666 case TOK_FBD_GMM_S3D_INFO_REC__RFRAME_OFFSET: { 8667 dst.AuxSurf.S3d.RFrameOffset = readTokValue<decltype(dst.AuxSurf.S3d.RFrameOffset)>(*tokS3d); 8668 } break; 8669 case TOK_FBD_GMM_S3D_INFO_REC__BLANK_AREA_OFFSET: { 8670 dst.AuxSurf.S3d.BlankAreaOffset = readTokValue<decltype(dst.AuxSurf.S3d.BlankAreaOffset)>(*tokS3d); 8671 } break; 8672 case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_HEIGHT: { 8673 dst.AuxSurf.S3d.TallBufferHeight = readTokValue<decltype(dst.AuxSurf.S3d.TallBufferHeight)>(*tokS3d); 8674 } break; 8675 case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_SIZE: { 8676 dst.AuxSurf.S3d.TallBufferSize = readTokValue<decltype(dst.AuxSurf.S3d.TallBufferSize)>(*tokS3d); 8677 } break; 8678 case TOK_FBC_GMM_S3D_INFO_REC__IS_RFRAME: { 8679 dst.AuxSurf.S3d.IsRFrame = readTokValue<decltype(dst.AuxSurf.S3d.IsRFrame)>(*tokS3d); 8680 } break; 8681 }; 8682 tokS3d = tokS3d + 1 + tokS3d->valueDwordCount; 8683 } else { 8684 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokS3d); 8685 if (tokS3d->flags.flag3IsMandatory) { 8686 return false; 8687 } 8688 tokS3d = tokS3d + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 8689 } 8690 } 8691 WCH_ASSERT(tokS3d == tokS3dEnd); 8692 } break; 8693 case TOK_FS_GMM_TEXTURE_INFO_REC__SEGMENT_OVERRIDE: { 8694 const TokenHeader *tokSegmentOverride = varLen->getValue<TokenHeader>(); 8695 const TokenHeader *tokSegmentOverrideEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 8696 while (tokSegmentOverride < tokSegmentOverrideEnd) { 8697 if (false == tokSegmentOverride->flags.flag4IsVariableLength) { 8698 switch (tokSegmentOverride->id) { 8699 default: 8700 if (tokSegmentOverride->flags.flag3IsMandatory) { 8701 return false; 8702 } 8703 break; 8704 case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__SEG1: { 8705 dst.AuxSurf.SegmentOverride.Seg1 = readTokValue<decltype(dst.AuxSurf.SegmentOverride.Seg1)>(*tokSegmentOverride); 8706 } break; 8707 case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__EVICT: { 8708 dst.AuxSurf.SegmentOverride.Evict = readTokValue<decltype(dst.AuxSurf.SegmentOverride.Evict)>(*tokSegmentOverride); 8709 } break; 8710 }; 8711 tokSegmentOverride = tokSegmentOverride + 1 + tokSegmentOverride->valueDwordCount; 8712 } else { 8713 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSegmentOverride); 8714 if (tokSegmentOverride->flags.flag3IsMandatory) { 8715 return false; 8716 } 8717 tokSegmentOverride = tokSegmentOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 8718 } 8719 } 8720 WCH_ASSERT(tokSegmentOverride == tokSegmentOverrideEnd); 8721 } break; 8722 case TOK_FS_GMM_TEXTURE_INFO_REC__PLATFORM: { 8723 #if _DEBUG || _RELEASE_INTERNAL 8724 const TokenHeader *tokPlatform = varLen->getValue<TokenHeader>(); 8725 const TokenHeader *tokPlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 8726 while (tokPlatform < tokPlatformEnd) { 8727 if (false == tokPlatform->flags.flag4IsVariableLength) { 8728 switch (tokPlatform->id) { 8729 default: 8730 if (tokPlatform->flags.flag3IsMandatory) { 8731 return false; 8732 } 8733 break; 8734 case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { 8735 dst.AuxSurf.Platform.eProductFamily = readTokValue<decltype(dst.AuxSurf.Platform.eProductFamily)>(*tokPlatform); 8736 } break; 8737 case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { 8738 dst.AuxSurf.Platform.ePCHProductFamily = readTokValue<decltype(dst.AuxSurf.Platform.ePCHProductFamily)>(*tokPlatform); 8739 } break; 8740 case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { 8741 dst.AuxSurf.Platform.eDisplayCoreFamily = readTokValue<decltype(dst.AuxSurf.Platform.eDisplayCoreFamily)>(*tokPlatform); 8742 } break; 8743 case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { 8744 dst.AuxSurf.Platform.eRenderCoreFamily = readTokValue<decltype(dst.AuxSurf.Platform.eRenderCoreFamily)>(*tokPlatform); 8745 } break; 8746 case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { 8747 dst.AuxSurf.Platform.ePlatformType = readTokValue<decltype(dst.AuxSurf.Platform.ePlatformType)>(*tokPlatform); 8748 } break; 8749 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { 8750 dst.AuxSurf.Platform.usDeviceID = readTokValue<decltype(dst.AuxSurf.Platform.usDeviceID)>(*tokPlatform); 8751 } break; 8752 case TOK_FBW_PLATFORM_STR__US_REV_ID: { 8753 dst.AuxSurf.Platform.usRevId = readTokValue<decltype(dst.AuxSurf.Platform.usRevId)>(*tokPlatform); 8754 } break; 8755 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { 8756 dst.AuxSurf.Platform.usDeviceID_PCH = readTokValue<decltype(dst.AuxSurf.Platform.usDeviceID_PCH)>(*tokPlatform); 8757 } break; 8758 case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { 8759 dst.AuxSurf.Platform.usRevId_PCH = readTokValue<decltype(dst.AuxSurf.Platform.usRevId_PCH)>(*tokPlatform); 8760 } break; 8761 case TOK_FE_PLATFORM_STR__E_GTTYPE: { 8762 dst.AuxSurf.Platform.eGTType = readTokValue<decltype(dst.AuxSurf.Platform.eGTType)>(*tokPlatform); 8763 } break; 8764 }; 8765 tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount; 8766 } else { 8767 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlatform); 8768 if (tokPlatform->flags.flag3IsMandatory) { 8769 return false; 8770 } 8771 tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 8772 } 8773 } 8774 WCH_ASSERT(tokPlatform == tokPlatformEnd); 8775 #endif 8776 } break; 8777 case TOK_FS_GMM_TEXTURE_INFO_REC__EXISTING_SYS_MEM: { 8778 const TokenHeader *tokExistingSysMem = varLen->getValue<TokenHeader>(); 8779 const TokenHeader *tokExistingSysMemEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 8780 while (tokExistingSysMem < tokExistingSysMemEnd) { 8781 if (false == tokExistingSysMem->flags.flag4IsVariableLength) { 8782 switch (tokExistingSysMem->id) { 8783 default: 8784 if (tokExistingSysMem->flags.flag3IsMandatory) { 8785 return false; 8786 } 8787 break; 8788 case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_GMM_ALLOCATED: { 8789 dst.AuxSurf.ExistingSysMem.IsGmmAllocated = readTokValue<decltype(dst.AuxSurf.ExistingSysMem.IsGmmAllocated)>(*tokExistingSysMem); 8790 } break; 8791 case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_PAGE_ALIGNED: { 8792 dst.AuxSurf.ExistingSysMem.IsPageAligned = readTokValue<decltype(dst.AuxSurf.ExistingSysMem.IsPageAligned)>(*tokExistingSysMem); 8793 } break; 8794 }; 8795 tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount; 8796 } else { 8797 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokExistingSysMem); 8798 if (tokExistingSysMem->flags.flag3IsMandatory) { 8799 return false; 8800 } 8801 tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 8802 } 8803 } 8804 WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd); 8805 } break; 8806 case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: { 8807 #if !(_DEBUG || _RELEASE_INTERNAL) 8808 const TokenHeader *tok__Platform = varLen->getValue<TokenHeader>(); 8809 const TokenHeader *tok__PlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 8810 while (tok__Platform < tok__PlatformEnd) { 8811 if (false == tok__Platform->flags.flag4IsVariableLength) { 8812 switch (tok__Platform->id) { 8813 default: 8814 if (tok__Platform->flags.flag3IsMandatory) { 8815 return false; 8816 } 8817 break; 8818 case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { 8819 dst.AuxSurf.__Platform.eProductFamily = readTokValue<decltype(dst.AuxSurf.__Platform.eProductFamily)>(*tok__Platform); 8820 } break; 8821 case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { 8822 dst.AuxSurf.__Platform.ePCHProductFamily = readTokValue<decltype(dst.AuxSurf.__Platform.ePCHProductFamily)>(*tok__Platform); 8823 } break; 8824 case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { 8825 dst.AuxSurf.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.AuxSurf.__Platform.eDisplayCoreFamily)>(*tok__Platform); 8826 } break; 8827 case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { 8828 dst.AuxSurf.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.AuxSurf.__Platform.eRenderCoreFamily)>(*tok__Platform); 8829 } break; 8830 case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { 8831 dst.AuxSurf.__Platform.ePlatformType = readTokValue<decltype(dst.AuxSurf.__Platform.ePlatformType)>(*tok__Platform); 8832 } break; 8833 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { 8834 dst.AuxSurf.__Platform.usDeviceID = readTokValue<decltype(dst.AuxSurf.__Platform.usDeviceID)>(*tok__Platform); 8835 } break; 8836 case TOK_FBW_PLATFORM_STR__US_REV_ID: { 8837 dst.AuxSurf.__Platform.usRevId = readTokValue<decltype(dst.AuxSurf.__Platform.usRevId)>(*tok__Platform); 8838 } break; 8839 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { 8840 dst.AuxSurf.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.AuxSurf.__Platform.usDeviceID_PCH)>(*tok__Platform); 8841 } break; 8842 case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { 8843 dst.AuxSurf.__Platform.usRevId_PCH = readTokValue<decltype(dst.AuxSurf.__Platform.usRevId_PCH)>(*tok__Platform); 8844 } break; 8845 case TOK_FE_PLATFORM_STR__E_GTTYPE: { 8846 dst.AuxSurf.__Platform.eGTType = readTokValue<decltype(dst.AuxSurf.__Platform.eGTType)>(*tok__Platform); 8847 } break; 8848 }; 8849 tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount; 8850 } else { 8851 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok__Platform); 8852 if (tok__Platform->flags.flag3IsMandatory) { 8853 return false; 8854 } 8855 tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 8856 } 8857 } 8858 WCH_ASSERT(tok__Platform == tok__PlatformEnd); 8859 #endif 8860 } break; 8861 }; 8862 tokAuxSurf = tokAuxSurf + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 8863 } 8864 } 8865 WCH_ASSERT(tokAuxSurf == tokAuxSurfEnd); 8866 } break; 8867 case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__AUX_SEC_SURF: { 8868 const TokenHeader *tokAuxSecSurf = varLen->getValue<TokenHeader>(); 8869 const TokenHeader *tokAuxSecSurfEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 8870 while (tokAuxSecSurf < tokAuxSecSurfEnd) { 8871 if (false == tokAuxSecSurf->flags.flag4IsVariableLength) { 8872 switch (tokAuxSecSurf->id) { 8873 default: 8874 if (tokAuxSecSurf->flags.flag3IsMandatory) { 8875 return false; 8876 } 8877 break; 8878 case TOK_FE_GMM_TEXTURE_INFO_REC__TYPE: { 8879 dst.AuxSecSurf.Type = readTokValue<decltype(dst.AuxSecSurf.Type)>(*tokAuxSecSurf); 8880 } break; 8881 case TOK_FE_GMM_TEXTURE_INFO_REC__FORMAT: { 8882 dst.AuxSecSurf.Format = readTokValue<decltype(dst.AuxSecSurf.Format)>(*tokAuxSecSurf); 8883 } break; 8884 case TOK_FBD_GMM_TEXTURE_INFO_REC__BITS_PER_PIXEL: { 8885 dst.AuxSecSurf.BitsPerPixel = readTokValue<decltype(dst.AuxSecSurf.BitsPerPixel)>(*tokAuxSecSurf); 8886 } break; 8887 case TOK_FBQ_GMM_TEXTURE_INFO_REC__BASE_WIDTH: { 8888 dst.AuxSecSurf.BaseWidth = readTokValue<decltype(dst.AuxSecSurf.BaseWidth)>(*tokAuxSecSurf); 8889 } break; 8890 case TOK_FBD_GMM_TEXTURE_INFO_REC__BASE_HEIGHT: { 8891 dst.AuxSecSurf.BaseHeight = readTokValue<decltype(dst.AuxSecSurf.BaseHeight)>(*tokAuxSecSurf); 8892 } break; 8893 case TOK_FBD_GMM_TEXTURE_INFO_REC__DEPTH: { 8894 dst.AuxSecSurf.Depth = readTokValue<decltype(dst.AuxSecSurf.Depth)>(*tokAuxSecSurf); 8895 } break; 8896 case TOK_FBD_GMM_TEXTURE_INFO_REC__MAX_LOD: { 8897 dst.AuxSecSurf.MaxLod = readTokValue<decltype(dst.AuxSecSurf.MaxLod)>(*tokAuxSecSurf); 8898 } break; 8899 case TOK_FBD_GMM_TEXTURE_INFO_REC__ARRAY_SIZE: { 8900 dst.AuxSecSurf.ArraySize = readTokValue<decltype(dst.AuxSecSurf.ArraySize)>(*tokAuxSecSurf); 8901 } break; 8902 case TOK_FBD_GMM_TEXTURE_INFO_REC__CP_TAG: { 8903 dst.AuxSecSurf.CpTag = readTokValue<decltype(dst.AuxSecSurf.CpTag)>(*tokAuxSecSurf); 8904 } break; 8905 case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_MODE: { 8906 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokAuxSecSurf).getValue<char>(); 8907 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokAuxSecSurf).getValueSizeInBytes(); 8908 if (srcSize < sizeof(dst.AuxSecSurf.MmcMode)) { 8909 return false; 8910 } 8911 WCH_SAFE_COPY(dst.AuxSecSurf.MmcMode, sizeof(dst.AuxSecSurf.MmcMode), srcData, sizeof(dst.AuxSecSurf.MmcMode)); 8912 } break; 8913 case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_HINT: { 8914 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokAuxSecSurf).getValue<char>(); 8915 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokAuxSecSurf).getValueSizeInBytes(); 8916 if (srcSize < sizeof(dst.AuxSecSurf.MmcHint)) { 8917 return false; 8918 } 8919 WCH_SAFE_COPY(dst.AuxSecSurf.MmcHint, sizeof(dst.AuxSecSurf.MmcHint), srcData, sizeof(dst.AuxSecSurf.MmcHint)); 8920 } break; 8921 case TOK_FBQ_GMM_TEXTURE_INFO_REC__PITCH: { 8922 dst.AuxSecSurf.Pitch = readTokValue<decltype(dst.AuxSecSurf.Pitch)>(*tokAuxSecSurf); 8923 } break; 8924 case TOK_FBQ_GMM_TEXTURE_INFO_REC__OVERRIDE_PITCH: { 8925 dst.AuxSecSurf.OverridePitch = readTokValue<decltype(dst.AuxSecSurf.OverridePitch)>(*tokAuxSecSurf); 8926 } break; 8927 case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE: { 8928 dst.AuxSecSurf.Size = readTokValue<decltype(dst.AuxSecSurf.Size)>(*tokAuxSecSurf); 8929 } break; 8930 case TOK_FBQ_GMM_TEXTURE_INFO_REC__CCSIZE: { 8931 dst.AuxSecSurf.CCSize = readTokValue<decltype(dst.AuxSecSurf.CCSize)>(*tokAuxSecSurf); 8932 } break; 8933 case TOK_FBQ_GMM_TEXTURE_INFO_REC__UNPADDED_SIZE: { 8934 dst.AuxSecSurf.UnpaddedSize = readTokValue<decltype(dst.AuxSecSurf.UnpaddedSize)>(*tokAuxSecSurf); 8935 } break; 8936 case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE_REPORT_TO_OS: { 8937 dst.AuxSecSurf.SizeReportToOS = readTokValue<decltype(dst.AuxSecSurf.SizeReportToOS)>(*tokAuxSecSurf); 8938 } break; 8939 case TOK_FE_GMM_TEXTURE_INFO_REC__TILE_MODE: { 8940 dst.AuxSecSurf.TileMode = readTokValue<decltype(dst.AuxSecSurf.TileMode)>(*tokAuxSecSurf); 8941 } break; 8942 case TOK_FBD_GMM_TEXTURE_INFO_REC__CCSMODE_ALIGN: { 8943 dst.AuxSecSurf.CCSModeAlign = readTokValue<decltype(dst.AuxSecSurf.CCSModeAlign)>(*tokAuxSecSurf); 8944 } break; 8945 case TOK_FBD_GMM_TEXTURE_INFO_REC__LEGACY_FLAGS: { 8946 dst.AuxSecSurf.LegacyFlags = readTokValue<decltype(dst.AuxSecSurf.LegacyFlags)>(*tokAuxSecSurf); 8947 } break; 8948 case TOK_FBD_GMM_TEXTURE_INFO_REC__MAXIMUM_RENAMING_LIST_LENGTH: { 8949 dst.AuxSecSurf.MaximumRenamingListLength = readTokValue<decltype(dst.AuxSecSurf.MaximumRenamingListLength)>(*tokAuxSecSurf); 8950 } break; 8951 }; 8952 tokAuxSecSurf = tokAuxSecSurf + 1 + tokAuxSecSurf->valueDwordCount; 8953 } else { 8954 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokAuxSecSurf); 8955 switch (tokAuxSecSurf->id) { 8956 default: 8957 if (tokAuxSecSurf->flags.flag3IsMandatory) { 8958 return false; 8959 } 8960 break; 8961 case TOK_FS_GMM_TEXTURE_INFO_REC__FLAGS: { 8962 const TokenHeader *tokFlags = varLen->getValue<TokenHeader>(); 8963 const TokenHeader *tokFlagsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 8964 while (tokFlags < tokFlagsEnd) { 8965 if (false == tokFlags->flags.flag4IsVariableLength) { 8966 if (tokFlags->flags.flag3IsMandatory) { 8967 return false; 8968 } 8969 tokFlags = tokFlags + 1 + tokFlags->valueDwordCount; 8970 } else { 8971 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokFlags); 8972 switch (tokFlags->id) { 8973 default: 8974 if (tokFlags->flags.flag3IsMandatory) { 8975 return false; 8976 } 8977 break; 8978 case TOK_FS_GMM_RESOURCE_FLAG_REC__GPU: { 8979 const TokenHeader *tokGpu = varLen->getValue<TokenHeader>(); 8980 const TokenHeader *tokGpuEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 8981 while (tokGpu < tokGpuEnd) { 8982 if (false == tokGpu->flags.flag4IsVariableLength) { 8983 switch (tokGpu->id) { 8984 default: 8985 if (tokGpu->flags.flag3IsMandatory) { 8986 return false; 8987 } 8988 break; 8989 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CAMERA_CAPTURE: { 8990 dst.AuxSecSurf.Flags.Gpu.CameraCapture = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.CameraCapture)>(*tokGpu); 8991 } break; 8992 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CCS: { 8993 dst.AuxSecSurf.Flags.Gpu.CCS = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.CCS)>(*tokGpu); 8994 } break; 8995 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_DISCARD: { 8996 dst.AuxSecSurf.Flags.Gpu.ColorDiscard = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.ColorDiscard)>(*tokGpu); 8997 } break; 8998 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION: { 8999 dst.AuxSecSurf.Flags.Gpu.ColorSeparation = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.ColorSeparation)>(*tokGpu); 9000 } break; 9001 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION_RGBX: { 9002 dst.AuxSecSurf.Flags.Gpu.ColorSeparationRGBX = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.ColorSeparationRGBX)>(*tokGpu); 9003 } break; 9004 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CONSTANT: { 9005 dst.AuxSecSurf.Flags.Gpu.Constant = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.Constant)>(*tokGpu); 9006 } break; 9007 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__DEPTH: { 9008 dst.AuxSecSurf.Flags.Gpu.Depth = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.Depth)>(*tokGpu); 9009 } break; 9010 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN: { 9011 dst.AuxSecSurf.Flags.Gpu.FlipChain = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.FlipChain)>(*tokGpu); 9012 } break; 9013 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN_PREFERRED: { 9014 dst.AuxSecSurf.Flags.Gpu.FlipChainPreferred = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.FlipChainPreferred)>(*tokGpu); 9015 } break; 9016 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HISTORY_BUFFER: { 9017 dst.AuxSecSurf.Flags.Gpu.HistoryBuffer = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.HistoryBuffer)>(*tokGpu); 9018 } break; 9019 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HI_Z: { 9020 dst.AuxSecSurf.Flags.Gpu.HiZ = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.HiZ)>(*tokGpu); 9021 } break; 9022 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDEX: { 9023 dst.AuxSecSurf.Flags.Gpu.Index = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.Index)>(*tokGpu); 9024 } break; 9025 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDIRECT_CLEAR_COLOR: { 9026 dst.AuxSecSurf.Flags.Gpu.IndirectClearColor = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.IndirectClearColor)>(*tokGpu); 9027 } break; 9028 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INSTRUCTION_FLAT: { 9029 dst.AuxSecSurf.Flags.Gpu.InstructionFlat = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.InstructionFlat)>(*tokGpu); 9030 } break; 9031 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INTERLACED_SCAN: { 9032 dst.AuxSecSurf.Flags.Gpu.InterlacedScan = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.InterlacedScan)>(*tokGpu); 9033 } break; 9034 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MCS: { 9035 dst.AuxSecSurf.Flags.Gpu.MCS = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.MCS)>(*tokGpu); 9036 } break; 9037 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MMC: { 9038 dst.AuxSecSurf.Flags.Gpu.MMC = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.MMC)>(*tokGpu); 9039 } break; 9040 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MOTION_COMP: { 9041 dst.AuxSecSurf.Flags.Gpu.MotionComp = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.MotionComp)>(*tokGpu); 9042 } break; 9043 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__NO_RESTRICTION: { 9044 dst.AuxSecSurf.Flags.Gpu.NoRestriction = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.NoRestriction)>(*tokGpu); 9045 } break; 9046 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__OVERLAY: { 9047 dst.AuxSecSurf.Flags.Gpu.Overlay = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.Overlay)>(*tokGpu); 9048 } break; 9049 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PRESENTABLE: { 9050 dst.AuxSecSurf.Flags.Gpu.Presentable = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.Presentable)>(*tokGpu); 9051 } break; 9052 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PROCEDURAL_TEXTURE: { 9053 dst.AuxSecSurf.Flags.Gpu.ProceduralTexture = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.ProceduralTexture)>(*tokGpu); 9054 } break; 9055 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__QUERY: { 9056 dst.AuxSecSurf.Flags.Gpu.Query = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.Query)>(*tokGpu); 9057 } break; 9058 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__RENDER_TARGET: { 9059 dst.AuxSecSurf.Flags.Gpu.RenderTarget = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.RenderTarget)>(*tokGpu); 9060 } break; 9061 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D: { 9062 dst.AuxSecSurf.Flags.Gpu.S3d = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.S3d)>(*tokGpu); 9063 } break; 9064 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D_DX: { 9065 dst.AuxSecSurf.Flags.Gpu.S3dDx = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.S3dDx)>(*tokGpu); 9066 } break; 9067 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_NON_PACKED: { 9068 dst.AuxSecSurf.Flags.Gpu.__S3dNonPacked = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.__S3dNonPacked)>(*tokGpu); 9069 } break; 9070 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_WIDI: { 9071 dst.AuxSecSurf.Flags.Gpu.__S3dWidi = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.__S3dWidi)>(*tokGpu); 9072 } break; 9073 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SCRATCH_FLAT: { 9074 dst.AuxSecSurf.Flags.Gpu.ScratchFlat = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.ScratchFlat)>(*tokGpu); 9075 } break; 9076 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SEPARATE_STENCIL: { 9077 dst.AuxSecSurf.Flags.Gpu.SeparateStencil = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.SeparateStencil)>(*tokGpu); 9078 } break; 9079 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE: { 9080 dst.AuxSecSurf.Flags.Gpu.State = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.State)>(*tokGpu); 9081 } break; 9082 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE_DX9CONSTANT_BUFFER: { 9083 dst.AuxSecSurf.Flags.Gpu.StateDx9ConstantBuffer = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.StateDx9ConstantBuffer)>(*tokGpu); 9084 } break; 9085 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STREAM: { 9086 dst.AuxSecSurf.Flags.Gpu.Stream = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.Stream)>(*tokGpu); 9087 } break; 9088 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXT_API: { 9089 dst.AuxSecSurf.Flags.Gpu.TextApi = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.TextApi)>(*tokGpu); 9090 } break; 9091 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXTURE: { 9092 dst.AuxSecSurf.Flags.Gpu.Texture = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.Texture)>(*tokGpu); 9093 } break; 9094 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILED_RESOURCE: { 9095 dst.AuxSecSurf.Flags.Gpu.TiledResource = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.TiledResource)>(*tokGpu); 9096 } break; 9097 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILE_POOL: { 9098 dst.AuxSecSurf.Flags.Gpu.TilePool = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.TilePool)>(*tokGpu); 9099 } break; 9100 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__UNIFIED_AUX_SURFACE: { 9101 dst.AuxSecSurf.Flags.Gpu.UnifiedAuxSurface = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.UnifiedAuxSurface)>(*tokGpu); 9102 } break; 9103 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VERTEX: { 9104 dst.AuxSecSurf.Flags.Gpu.Vertex = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.Vertex)>(*tokGpu); 9105 } break; 9106 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VIDEO: { 9107 dst.AuxSecSurf.Flags.Gpu.Video = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.Video)>(*tokGpu); 9108 } break; 9109 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_XCCS: { 9110 dst.AuxSecSurf.Flags.Gpu.__NonMsaaTileXCcs = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.__NonMsaaTileXCcs)>(*tokGpu); 9111 } break; 9112 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_YCCS: { 9113 dst.AuxSecSurf.Flags.Gpu.__NonMsaaTileYCcs = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.__NonMsaaTileYCcs)>(*tokGpu); 9114 } break; 9115 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____MSAA_TILE_MCS: { 9116 dst.AuxSecSurf.Flags.Gpu.__MsaaTileMcs = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.__MsaaTileMcs)>(*tokGpu); 9117 } break; 9118 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_LINEAR_CCS: { 9119 dst.AuxSecSurf.Flags.Gpu.__NonMsaaLinearCCS = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.__NonMsaaLinearCCS)>(*tokGpu); 9120 } break; 9121 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____REMAINING: { 9122 dst.AuxSecSurf.Flags.Gpu.__Remaining = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.__Remaining)>(*tokGpu); 9123 } break; 9124 }; 9125 tokGpu = tokGpu + 1 + tokGpu->valueDwordCount; 9126 } else { 9127 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokGpu); 9128 if (tokGpu->flags.flag3IsMandatory) { 9129 return false; 9130 } 9131 tokGpu = tokGpu + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 9132 } 9133 } 9134 WCH_ASSERT(tokGpu == tokGpuEnd); 9135 } break; 9136 case TOK_FS_GMM_RESOURCE_FLAG_REC__INFO: { 9137 const TokenHeader *tokInfo = varLen->getValue<TokenHeader>(); 9138 const TokenHeader *tokInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 9139 while (tokInfo < tokInfoEnd) { 9140 if (false == tokInfo->flags.flag4IsVariableLength) { 9141 switch (tokInfo->id) { 9142 default: 9143 if (tokInfo->flags.flag3IsMandatory) { 9144 return false; 9145 } 9146 break; 9147 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ALLOW_VIRTUAL_PADDING: { 9148 dst.AuxSecSurf.Flags.Info.AllowVirtualPadding = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.AllowVirtualPadding)>(*tokInfo); 9149 } break; 9150 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__BIG_PAGE: { 9151 dst.AuxSecSurf.Flags.Info.BigPage = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.BigPage)>(*tokInfo); 9152 } break; 9153 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CACHEABLE: { 9154 dst.AuxSecSurf.Flags.Info.Cacheable = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.Cacheable)>(*tokInfo); 9155 } break; 9156 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CONTIG_PHYS_MEMORY_FORI_DART: { 9157 dst.AuxSecSurf.Flags.Info.ContigPhysMemoryForiDART = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.ContigPhysMemoryForiDART)>(*tokInfo); 9158 } break; 9159 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CORNER_TEXEL_MODE: { 9160 dst.AuxSecSurf.Flags.Info.CornerTexelMode = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.CornerTexelMode)>(*tokInfo); 9161 } break; 9162 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__EXISTING_SYS_MEM: { 9163 dst.AuxSecSurf.Flags.Info.ExistingSysMem = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.ExistingSysMem)>(*tokInfo); 9164 } break; 9165 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__FORCE_RESIDENCY: { 9166 dst.AuxSecSurf.Flags.Info.ForceResidency = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.ForceResidency)>(*tokInfo); 9167 } break; 9168 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GFDT: { 9169 dst.AuxSecSurf.Flags.Info.Gfdt = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.Gfdt)>(*tokInfo); 9170 } break; 9171 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GTT_MAP_TYPE: { 9172 dst.AuxSecSurf.Flags.Info.GttMapType = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.GttMapType)>(*tokInfo); 9173 } break; 9174 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__HARDWARE_PROTECTED: { 9175 dst.AuxSecSurf.Flags.Info.HardwareProtected = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.HardwareProtected)>(*tokInfo); 9176 } break; 9177 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__KERNEL_MODE_MAPPED: { 9178 dst.AuxSecSurf.Flags.Info.KernelModeMapped = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.KernelModeMapped)>(*tokInfo); 9179 } break; 9180 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_BELOW: { 9181 dst.AuxSecSurf.Flags.Info.LayoutBelow = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.LayoutBelow)>(*tokInfo); 9182 } break; 9183 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_MONO: { 9184 dst.AuxSecSurf.Flags.Info.LayoutMono = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.LayoutMono)>(*tokInfo); 9185 } break; 9186 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_RIGHT: { 9187 dst.AuxSecSurf.Flags.Info.LayoutRight = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.LayoutRight)>(*tokInfo); 9188 } break; 9189 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LOCAL_ONLY: { 9190 dst.AuxSecSurf.Flags.Info.LocalOnly = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.LocalOnly)>(*tokInfo); 9191 } break; 9192 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LINEAR: { 9193 dst.AuxSecSurf.Flags.Info.Linear = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.Linear)>(*tokInfo); 9194 } break; 9195 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__MEDIA_COMPRESSED: { 9196 dst.AuxSecSurf.Flags.Info.MediaCompressed = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.MediaCompressed)>(*tokInfo); 9197 } break; 9198 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_OPTIMIZATION_PADDING: { 9199 dst.AuxSecSurf.Flags.Info.NoOptimizationPadding = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.NoOptimizationPadding)>(*tokInfo); 9200 } break; 9201 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_PHYS_MEMORY: { 9202 dst.AuxSecSurf.Flags.Info.NoPhysMemory = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.NoPhysMemory)>(*tokInfo); 9203 } break; 9204 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NOT_LOCKABLE: { 9205 dst.AuxSecSurf.Flags.Info.NotLockable = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.NotLockable)>(*tokInfo); 9206 } break; 9207 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NON_LOCAL_ONLY: { 9208 dst.AuxSecSurf.Flags.Info.NonLocalOnly = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.NonLocalOnly)>(*tokInfo); 9209 } break; 9210 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__STD_SWIZZLE: { 9211 dst.AuxSecSurf.Flags.Info.StdSwizzle = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.StdSwizzle)>(*tokInfo); 9212 } break; 9213 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__PSEUDO_STD_SWIZZLE: { 9214 dst.AuxSecSurf.Flags.Info.PseudoStdSwizzle = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.PseudoStdSwizzle)>(*tokInfo); 9215 } break; 9216 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__UNDEFINED64KBSWIZZLE: { 9217 dst.AuxSecSurf.Flags.Info.Undefined64KBSwizzle = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.Undefined64KBSwizzle)>(*tokInfo); 9218 } break; 9219 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__REDECRIBED_PLANES: { 9220 dst.AuxSecSurf.Flags.Info.RedecribedPlanes = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.RedecribedPlanes)>(*tokInfo); 9221 } break; 9222 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__RENDER_COMPRESSED: { 9223 dst.AuxSecSurf.Flags.Info.RenderCompressed = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.RenderCompressed)>(*tokInfo); 9224 } break; 9225 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ROTATED: { 9226 dst.AuxSecSurf.Flags.Info.Rotated = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.Rotated)>(*tokInfo); 9227 } break; 9228 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SHARED: { 9229 dst.AuxSecSurf.Flags.Info.Shared = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.Shared)>(*tokInfo); 9230 } break; 9231 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SOFTWARE_PROTECTED: { 9232 dst.AuxSecSurf.Flags.Info.SoftwareProtected = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.SoftwareProtected)>(*tokInfo); 9233 } break; 9234 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SVM: { 9235 dst.AuxSecSurf.Flags.Info.SVM = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.SVM)>(*tokInfo); 9236 } break; 9237 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE4: { 9238 dst.AuxSecSurf.Flags.Info.Tile4 = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.Tile4)>(*tokInfo); 9239 } break; 9240 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE64: { 9241 dst.AuxSecSurf.Flags.Info.Tile64 = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.Tile64)>(*tokInfo); 9242 } break; 9243 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_W: { 9244 dst.AuxSecSurf.Flags.Info.TiledW = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.TiledW)>(*tokInfo); 9245 } break; 9246 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_X: { 9247 dst.AuxSecSurf.Flags.Info.TiledX = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.TiledX)>(*tokInfo); 9248 } break; 9249 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_Y: { 9250 dst.AuxSecSurf.Flags.Info.TiledY = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.TiledY)>(*tokInfo); 9251 } break; 9252 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YF: { 9253 dst.AuxSecSurf.Flags.Info.TiledYf = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.TiledYf)>(*tokInfo); 9254 } break; 9255 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YS: { 9256 dst.AuxSecSurf.Flags.Info.TiledYs = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.TiledYs)>(*tokInfo); 9257 } break; 9258 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__WDDM_PROTECTED: { 9259 dst.AuxSecSurf.Flags.Info.WddmProtected = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.WddmProtected)>(*tokInfo); 9260 } break; 9261 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__XADAPTER: { 9262 dst.AuxSecSurf.Flags.Info.XAdapter = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.XAdapter)>(*tokInfo); 9263 } break; 9264 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PREALLOCATED_RES_INFO: { 9265 dst.AuxSecSurf.Flags.Info.__PreallocatedResInfo = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.__PreallocatedResInfo)>(*tokInfo); 9266 } break; 9267 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PRE_WDDM2SVM: { 9268 dst.AuxSecSurf.Flags.Info.__PreWddm2SVM = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.__PreWddm2SVM)>(*tokInfo); 9269 } break; 9270 }; 9271 tokInfo = tokInfo + 1 + tokInfo->valueDwordCount; 9272 } else { 9273 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInfo); 9274 if (tokInfo->flags.flag3IsMandatory) { 9275 return false; 9276 } 9277 tokInfo = tokInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 9278 } 9279 } 9280 WCH_ASSERT(tokInfo == tokInfoEnd); 9281 } break; 9282 case TOK_FS_GMM_RESOURCE_FLAG_REC__WA: { 9283 const TokenHeader *tokWa = varLen->getValue<TokenHeader>(); 9284 const TokenHeader *tokWaEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 9285 while (tokWa < tokWaEnd) { 9286 if (false == tokWa->flags.flag4IsVariableLength) { 9287 switch (tokWa->id) { 9288 default: 9289 if (tokWa->flags.flag3IsMandatory) { 9290 return false; 9291 } 9292 break; 9293 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__GTMFX2ND_LEVEL_BATCH_RING_SIZE_ALIGN: { 9294 dst.AuxSecSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign = readTokValue<decltype(dst.AuxSecSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign)>(*tokWa); 9295 } break; 9296 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_MPR_ROW_STORE32KALIGN: { 9297 dst.AuxSecSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign = readTokValue<decltype(dst.AuxSecSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign)>(*tokWa); 9298 } break; 9299 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_DMV_BUFFER32KALIGN: { 9300 dst.AuxSecSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign = readTokValue<decltype(dst.AuxSecSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign)>(*tokWa); 9301 } break; 9302 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_BUFFER_SAMPLER_PADDING: { 9303 dst.AuxSecSurf.Flags.Wa.NoBufferSamplerPadding = readTokValue<decltype(dst.AuxSecSurf.Flags.Wa.NoBufferSamplerPadding)>(*tokWa); 9304 } break; 9305 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_LEGACY_PLANAR_LINEAR_VIDEO_RESTRICTIONS: { 9306 dst.AuxSecSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions = readTokValue<decltype(dst.AuxSecSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions)>(*tokWa); 9307 } break; 9308 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__CHVASTC_SKIP_VIRTUAL_MIPS: { 9309 dst.AuxSecSurf.Flags.Wa.CHVAstcSkipVirtualMips = readTokValue<decltype(dst.AuxSecSurf.Flags.Wa.CHVAstcSkipVirtualMips)>(*tokWa); 9310 } break; 9311 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_PACKED_MIP_TAIL: { 9312 dst.AuxSecSurf.Flags.Wa.DisablePackedMipTail = readTokValue<decltype(dst.AuxSecSurf.Flags.Wa.DisablePackedMipTail)>(*tokWa); 9313 } break; 9314 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521____FORCE_OTHER_HVALIGN4: { 9315 dst.AuxSecSurf.Flags.Wa.__ForceOtherHVALIGN4 = readTokValue<decltype(dst.AuxSecSurf.Flags.Wa.__ForceOtherHVALIGN4)>(*tokWa); 9316 } break; 9317 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR: { 9318 dst.AuxSecSurf.Flags.Wa.DisableDisplayCcsClearColor = readTokValue<decltype(dst.AuxSecSurf.Flags.Wa.DisableDisplayCcsClearColor)>(*tokWa); 9319 } break; 9320 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION: { 9321 dst.AuxSecSurf.Flags.Wa.DisableDisplayCcsCompression = readTokValue<decltype(dst.AuxSecSurf.Flags.Wa.DisableDisplayCcsCompression)>(*tokWa); 9322 } break; 9323 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: { 9324 dst.AuxSecSurf.Flags.Wa.PreGen12FastClearOnly = readTokValue<decltype(dst.AuxSecSurf.Flags.Wa.PreGen12FastClearOnly)>(*tokWa); 9325 } break; 9326 }; 9327 tokWa = tokWa + 1 + tokWa->valueDwordCount; 9328 } else { 9329 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokWa); 9330 if (tokWa->flags.flag3IsMandatory) { 9331 return false; 9332 } 9333 tokWa = tokWa + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 9334 } 9335 } 9336 WCH_ASSERT(tokWa == tokWaEnd); 9337 } break; 9338 }; 9339 tokFlags = tokFlags + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 9340 } 9341 } 9342 WCH_ASSERT(tokFlags == tokFlagsEnd); 9343 } break; 9344 case TOK_FS_GMM_TEXTURE_INFO_REC__CACHE_POLICY: { 9345 const TokenHeader *tokCachePolicy = varLen->getValue<TokenHeader>(); 9346 const TokenHeader *tokCachePolicyEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 9347 while (tokCachePolicy < tokCachePolicyEnd) { 9348 if (false == tokCachePolicy->flags.flag4IsVariableLength) { 9349 switch (tokCachePolicy->id) { 9350 default: 9351 if (tokCachePolicy->flags.flag3IsMandatory) { 9352 return false; 9353 } 9354 break; 9355 case TOK_FE_GMM_TEXTURE_INFO_REC__ANONYMOUS4927__USAGE: { 9356 dst.AuxSecSurf.CachePolicy.Usage = readTokValue<decltype(dst.AuxSecSurf.CachePolicy.Usage)>(*tokCachePolicy); 9357 } break; 9358 }; 9359 tokCachePolicy = tokCachePolicy + 1 + tokCachePolicy->valueDwordCount; 9360 } else { 9361 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCachePolicy); 9362 if (tokCachePolicy->flags.flag3IsMandatory) { 9363 return false; 9364 } 9365 tokCachePolicy = tokCachePolicy + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 9366 } 9367 } 9368 WCH_ASSERT(tokCachePolicy == tokCachePolicyEnd); 9369 } break; 9370 case TOK_FS_GMM_TEXTURE_INFO_REC__MSAA: { 9371 const TokenHeader *tokMSAA = varLen->getValue<TokenHeader>(); 9372 const TokenHeader *tokMSAAEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 9373 while (tokMSAA < tokMSAAEnd) { 9374 if (false == tokMSAA->flags.flag4IsVariableLength) { 9375 switch (tokMSAA->id) { 9376 default: 9377 if (tokMSAA->flags.flag3IsMandatory) { 9378 return false; 9379 } 9380 break; 9381 case TOK_FE_GMM_RESOURCE_MSAA_INFO_REC__SAMPLE_PATTERN: { 9382 dst.AuxSecSurf.MSAA.SamplePattern = readTokValue<decltype(dst.AuxSecSurf.MSAA.SamplePattern)>(*tokMSAA); 9383 } break; 9384 case TOK_FBD_GMM_RESOURCE_MSAA_INFO_REC__NUM_SAMPLES: { 9385 dst.AuxSecSurf.MSAA.NumSamples = readTokValue<decltype(dst.AuxSecSurf.MSAA.NumSamples)>(*tokMSAA); 9386 } break; 9387 }; 9388 tokMSAA = tokMSAA + 1 + tokMSAA->valueDwordCount; 9389 } else { 9390 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokMSAA); 9391 if (tokMSAA->flags.flag3IsMandatory) { 9392 return false; 9393 } 9394 tokMSAA = tokMSAA + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 9395 } 9396 } 9397 WCH_ASSERT(tokMSAA == tokMSAAEnd); 9398 } break; 9399 case TOK_FS_GMM_TEXTURE_INFO_REC__ALIGNMENT: { 9400 const TokenHeader *tokAlignment = varLen->getValue<TokenHeader>(); 9401 const TokenHeader *tokAlignmentEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 9402 while (tokAlignment < tokAlignmentEnd) { 9403 if (false == tokAlignment->flags.flag4IsVariableLength) { 9404 switch (tokAlignment->id) { 9405 default: 9406 if (tokAlignment->flags.flag3IsMandatory) { 9407 return false; 9408 } 9409 break; 9410 case TOK_FBC_GMM_RESOURCE_ALIGNMENT_REC__ARRAY_SPACING_SINGLE_LOD: { 9411 dst.AuxSecSurf.Alignment.ArraySpacingSingleLod = readTokValue<decltype(dst.AuxSecSurf.Alignment.ArraySpacingSingleLod)>(*tokAlignment); 9412 } break; 9413 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__BASE_ALIGNMENT: { 9414 dst.AuxSecSurf.Alignment.BaseAlignment = readTokValue<decltype(dst.AuxSecSurf.Alignment.BaseAlignment)>(*tokAlignment); 9415 } break; 9416 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__HALIGN: { 9417 dst.AuxSecSurf.Alignment.HAlign = readTokValue<decltype(dst.AuxSecSurf.Alignment.HAlign)>(*tokAlignment); 9418 } break; 9419 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__VALIGN: { 9420 dst.AuxSecSurf.Alignment.VAlign = readTokValue<decltype(dst.AuxSecSurf.Alignment.VAlign)>(*tokAlignment); 9421 } break; 9422 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__DALIGN: { 9423 dst.AuxSecSurf.Alignment.DAlign = readTokValue<decltype(dst.AuxSecSurf.Alignment.DAlign)>(*tokAlignment); 9424 } break; 9425 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__MIP_TAIL_START_LOD: { 9426 dst.AuxSecSurf.Alignment.MipTailStartLod = readTokValue<decltype(dst.AuxSecSurf.Alignment.MipTailStartLod)>(*tokAlignment); 9427 } break; 9428 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_START_LOD: { 9429 dst.AuxSecSurf.Alignment.PackedMipStartLod = readTokValue<decltype(dst.AuxSecSurf.Alignment.PackedMipStartLod)>(*tokAlignment); 9430 } break; 9431 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_WIDTH: { 9432 dst.AuxSecSurf.Alignment.PackedMipWidth = readTokValue<decltype(dst.AuxSecSurf.Alignment.PackedMipWidth)>(*tokAlignment); 9433 } break; 9434 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_HEIGHT: { 9435 dst.AuxSecSurf.Alignment.PackedMipHeight = readTokValue<decltype(dst.AuxSecSurf.Alignment.PackedMipHeight)>(*tokAlignment); 9436 } break; 9437 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__QPITCH: { 9438 dst.AuxSecSurf.Alignment.QPitch = readTokValue<decltype(dst.AuxSecSurf.Alignment.QPitch)>(*tokAlignment); 9439 } break; 9440 }; 9441 tokAlignment = tokAlignment + 1 + tokAlignment->valueDwordCount; 9442 } else { 9443 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokAlignment); 9444 if (tokAlignment->flags.flag3IsMandatory) { 9445 return false; 9446 } 9447 tokAlignment = tokAlignment + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 9448 } 9449 } 9450 WCH_ASSERT(tokAlignment == tokAlignmentEnd); 9451 } break; 9452 case TOK_FS_GMM_TEXTURE_INFO_REC__OFFSET_INFO: { 9453 const TokenHeader *tokOffsetInfo = varLen->getValue<TokenHeader>(); 9454 const TokenHeader *tokOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 9455 while (tokOffsetInfo < tokOffsetInfoEnd) { 9456 if (false == tokOffsetInfo->flags.flag4IsVariableLength) { 9457 if (tokOffsetInfo->flags.flag3IsMandatory) { 9458 return false; 9459 } 9460 tokOffsetInfo = tokOffsetInfo + 1 + tokOffsetInfo->valueDwordCount; 9461 } else { 9462 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokOffsetInfo); 9463 switch (tokOffsetInfo->id) { 9464 default: 9465 if (tokOffsetInfo->flags.flag3IsMandatory) { 9466 return false; 9467 } 9468 break; 9469 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO: { 9470 const TokenHeader *tokTexture3DOffsetInfo = varLen->getValue<TokenHeader>(); 9471 const TokenHeader *tokTexture3DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 9472 while (tokTexture3DOffsetInfo < tokTexture3DOffsetInfoEnd) { 9473 if (false == tokTexture3DOffsetInfo->flags.flag4IsVariableLength) { 9474 switch (tokTexture3DOffsetInfo->id) { 9475 default: 9476 if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { 9477 return false; 9478 } 9479 break; 9480 case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: { 9481 dst.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch = readTokValue<decltype(dst.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch)>(*tokTexture3DOffsetInfo); 9482 } break; 9483 case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: { 9484 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValue<char>(); 9485 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValueSizeInBytes(); 9486 if (srcSize < sizeof(dst.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset)) { 9487 return false; 9488 } 9489 WCH_SAFE_COPY(dst.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(dst.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset), srcData, sizeof(dst.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset)); 9490 } break; 9491 }; 9492 tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + 1 + tokTexture3DOffsetInfo->valueDwordCount; 9493 } else { 9494 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture3DOffsetInfo); 9495 if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { 9496 return false; 9497 } 9498 tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 9499 } 9500 } 9501 WCH_ASSERT(tokTexture3DOffsetInfo == tokTexture3DOffsetInfoEnd); 9502 } break; 9503 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO: { 9504 const TokenHeader *tokTexture2DOffsetInfo = varLen->getValue<TokenHeader>(); 9505 const TokenHeader *tokTexture2DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 9506 while (tokTexture2DOffsetInfo < tokTexture2DOffsetInfoEnd) { 9507 if (false == tokTexture2DOffsetInfo->flags.flag4IsVariableLength) { 9508 switch (tokTexture2DOffsetInfo->id) { 9509 default: 9510 if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { 9511 return false; 9512 } 9513 break; 9514 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: { 9515 dst.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock = readTokValue<decltype(dst.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock)>(*tokTexture2DOffsetInfo); 9516 } break; 9517 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: { 9518 dst.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender = readTokValue<decltype(dst.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender)>(*tokTexture2DOffsetInfo); 9519 } break; 9520 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: { 9521 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValue<char>(); 9522 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValueSizeInBytes(); 9523 if (srcSize < sizeof(dst.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset)) { 9524 return false; 9525 } 9526 WCH_SAFE_COPY(dst.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(dst.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset), srcData, sizeof(dst.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset)); 9527 } break; 9528 }; 9529 tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + 1 + tokTexture2DOffsetInfo->valueDwordCount; 9530 } else { 9531 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture2DOffsetInfo); 9532 if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { 9533 return false; 9534 } 9535 tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 9536 } 9537 } 9538 WCH_ASSERT(tokTexture2DOffsetInfo == tokTexture2DOffsetInfoEnd); 9539 } break; 9540 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE: { 9541 const TokenHeader *tokPlane = varLen->getValue<TokenHeader>(); 9542 const TokenHeader *tokPlaneEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 9543 while (tokPlane < tokPlaneEnd) { 9544 if (false == tokPlane->flags.flag4IsVariableLength) { 9545 switch (tokPlane->id) { 9546 default: 9547 if (tokPlane->flags.flag3IsMandatory) { 9548 return false; 9549 } 9550 break; 9551 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: { 9552 dst.AuxSecSurf.OffsetInfo.Plane.ArrayQPitch = readTokValue<decltype(dst.AuxSecSurf.OffsetInfo.Plane.ArrayQPitch)>(*tokPlane); 9553 } break; 9554 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: { 9555 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>(); 9556 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes(); 9557 if (srcSize < sizeof(dst.AuxSecSurf.OffsetInfo.Plane.X)) { 9558 return false; 9559 } 9560 WCH_SAFE_COPY(dst.AuxSecSurf.OffsetInfo.Plane.X, sizeof(dst.AuxSecSurf.OffsetInfo.Plane.X), srcData, sizeof(dst.AuxSecSurf.OffsetInfo.Plane.X)); 9561 } break; 9562 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: { 9563 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>(); 9564 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes(); 9565 if (srcSize < sizeof(dst.AuxSecSurf.OffsetInfo.Plane.Y)) { 9566 return false; 9567 } 9568 WCH_SAFE_COPY(dst.AuxSecSurf.OffsetInfo.Plane.Y, sizeof(dst.AuxSecSurf.OffsetInfo.Plane.Y), srcData, sizeof(dst.AuxSecSurf.OffsetInfo.Plane.Y)); 9569 } break; 9570 case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: { 9571 dst.AuxSecSurf.OffsetInfo.Plane.NoOfPlanes = readTokValue<decltype(dst.AuxSecSurf.OffsetInfo.Plane.NoOfPlanes)>(*tokPlane); 9572 } break; 9573 case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: { 9574 dst.AuxSecSurf.OffsetInfo.Plane.IsTileAlignedPlanes = readTokValue<decltype(dst.AuxSecSurf.OffsetInfo.Plane.IsTileAlignedPlanes)>(*tokPlane); 9575 } break; 9576 }; 9577 tokPlane = tokPlane + 1 + tokPlane->valueDwordCount; 9578 } else { 9579 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlane); 9580 switch (tokPlane->id) { 9581 default: 9582 if (tokPlane->flags.flag3IsMandatory) { 9583 return false; 9584 } 9585 break; 9586 case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: { 9587 const TokenHeader *tokUnAligned = varLen->getValue<TokenHeader>(); 9588 const TokenHeader *tokUnAlignedEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 9589 while (tokUnAligned < tokUnAlignedEnd) { 9590 if (false == tokUnAligned->flags.flag4IsVariableLength) { 9591 switch (tokUnAligned->id) { 9592 default: 9593 if (tokUnAligned->flags.flag3IsMandatory) { 9594 return false; 9595 } 9596 break; 9597 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: { 9598 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValue<char>(); 9599 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValueSizeInBytes(); 9600 if (srcSize < sizeof(dst.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height)) { 9601 return false; 9602 } 9603 WCH_SAFE_COPY(dst.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height, sizeof(dst.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height), srcData, sizeof(dst.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height)); 9604 } break; 9605 }; 9606 tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount; 9607 } else { 9608 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokUnAligned); 9609 if (tokUnAligned->flags.flag3IsMandatory) { 9610 return false; 9611 } 9612 tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 9613 } 9614 } 9615 WCH_ASSERT(tokUnAligned == tokUnAlignedEnd); 9616 } break; 9617 }; 9618 tokPlane = tokPlane + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 9619 } 9620 } 9621 WCH_ASSERT(tokPlane == tokPlaneEnd); 9622 } break; 9623 }; 9624 tokOffsetInfo = tokOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 9625 } 9626 } 9627 WCH_ASSERT(tokOffsetInfo == tokOffsetInfoEnd); 9628 } break; 9629 case TOK_FS_GMM_TEXTURE_INFO_REC__S3D: { 9630 const TokenHeader *tokS3d = varLen->getValue<TokenHeader>(); 9631 const TokenHeader *tokS3dEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 9632 while (tokS3d < tokS3dEnd) { 9633 if (false == tokS3d->flags.flag4IsVariableLength) { 9634 switch (tokS3d->id) { 9635 default: 9636 if (tokS3d->flags.flag3IsMandatory) { 9637 return false; 9638 } 9639 break; 9640 case TOK_FBD_GMM_S3D_INFO_REC__DISPLAY_MODE_HEIGHT: { 9641 dst.AuxSecSurf.S3d.DisplayModeHeight = readTokValue<decltype(dst.AuxSecSurf.S3d.DisplayModeHeight)>(*tokS3d); 9642 } break; 9643 case TOK_FBD_GMM_S3D_INFO_REC__NUM_BLANK_ACTIVE_LINES: { 9644 dst.AuxSecSurf.S3d.NumBlankActiveLines = readTokValue<decltype(dst.AuxSecSurf.S3d.NumBlankActiveLines)>(*tokS3d); 9645 } break; 9646 case TOK_FBD_GMM_S3D_INFO_REC__RFRAME_OFFSET: { 9647 dst.AuxSecSurf.S3d.RFrameOffset = readTokValue<decltype(dst.AuxSecSurf.S3d.RFrameOffset)>(*tokS3d); 9648 } break; 9649 case TOK_FBD_GMM_S3D_INFO_REC__BLANK_AREA_OFFSET: { 9650 dst.AuxSecSurf.S3d.BlankAreaOffset = readTokValue<decltype(dst.AuxSecSurf.S3d.BlankAreaOffset)>(*tokS3d); 9651 } break; 9652 case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_HEIGHT: { 9653 dst.AuxSecSurf.S3d.TallBufferHeight = readTokValue<decltype(dst.AuxSecSurf.S3d.TallBufferHeight)>(*tokS3d); 9654 } break; 9655 case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_SIZE: { 9656 dst.AuxSecSurf.S3d.TallBufferSize = readTokValue<decltype(dst.AuxSecSurf.S3d.TallBufferSize)>(*tokS3d); 9657 } break; 9658 case TOK_FBC_GMM_S3D_INFO_REC__IS_RFRAME: { 9659 dst.AuxSecSurf.S3d.IsRFrame = readTokValue<decltype(dst.AuxSecSurf.S3d.IsRFrame)>(*tokS3d); 9660 } break; 9661 }; 9662 tokS3d = tokS3d + 1 + tokS3d->valueDwordCount; 9663 } else { 9664 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokS3d); 9665 if (tokS3d->flags.flag3IsMandatory) { 9666 return false; 9667 } 9668 tokS3d = tokS3d + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 9669 } 9670 } 9671 WCH_ASSERT(tokS3d == tokS3dEnd); 9672 } break; 9673 case TOK_FS_GMM_TEXTURE_INFO_REC__SEGMENT_OVERRIDE: { 9674 const TokenHeader *tokSegmentOverride = varLen->getValue<TokenHeader>(); 9675 const TokenHeader *tokSegmentOverrideEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 9676 while (tokSegmentOverride < tokSegmentOverrideEnd) { 9677 if (false == tokSegmentOverride->flags.flag4IsVariableLength) { 9678 switch (tokSegmentOverride->id) { 9679 default: 9680 if (tokSegmentOverride->flags.flag3IsMandatory) { 9681 return false; 9682 } 9683 break; 9684 case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__SEG1: { 9685 dst.AuxSecSurf.SegmentOverride.Seg1 = readTokValue<decltype(dst.AuxSecSurf.SegmentOverride.Seg1)>(*tokSegmentOverride); 9686 } break; 9687 case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__EVICT: { 9688 dst.AuxSecSurf.SegmentOverride.Evict = readTokValue<decltype(dst.AuxSecSurf.SegmentOverride.Evict)>(*tokSegmentOverride); 9689 } break; 9690 }; 9691 tokSegmentOverride = tokSegmentOverride + 1 + tokSegmentOverride->valueDwordCount; 9692 } else { 9693 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSegmentOverride); 9694 if (tokSegmentOverride->flags.flag3IsMandatory) { 9695 return false; 9696 } 9697 tokSegmentOverride = tokSegmentOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 9698 } 9699 } 9700 WCH_ASSERT(tokSegmentOverride == tokSegmentOverrideEnd); 9701 } break; 9702 case TOK_FS_GMM_TEXTURE_INFO_REC__PLATFORM: { 9703 #if _DEBUG || _RELEASE_INTERNAL 9704 const TokenHeader *tokPlatform = varLen->getValue<TokenHeader>(); 9705 const TokenHeader *tokPlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 9706 while (tokPlatform < tokPlatformEnd) { 9707 if (false == tokPlatform->flags.flag4IsVariableLength) { 9708 switch (tokPlatform->id) { 9709 default: 9710 if (tokPlatform->flags.flag3IsMandatory) { 9711 return false; 9712 } 9713 break; 9714 case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { 9715 dst.AuxSecSurf.Platform.eProductFamily = readTokValue<decltype(dst.AuxSecSurf.Platform.eProductFamily)>(*tokPlatform); 9716 } break; 9717 case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { 9718 dst.AuxSecSurf.Platform.ePCHProductFamily = readTokValue<decltype(dst.AuxSecSurf.Platform.ePCHProductFamily)>(*tokPlatform); 9719 } break; 9720 case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { 9721 dst.AuxSecSurf.Platform.eDisplayCoreFamily = readTokValue<decltype(dst.AuxSecSurf.Platform.eDisplayCoreFamily)>(*tokPlatform); 9722 } break; 9723 case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { 9724 dst.AuxSecSurf.Platform.eRenderCoreFamily = readTokValue<decltype(dst.AuxSecSurf.Platform.eRenderCoreFamily)>(*tokPlatform); 9725 } break; 9726 case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { 9727 dst.AuxSecSurf.Platform.ePlatformType = readTokValue<decltype(dst.AuxSecSurf.Platform.ePlatformType)>(*tokPlatform); 9728 } break; 9729 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { 9730 dst.AuxSecSurf.Platform.usDeviceID = readTokValue<decltype(dst.AuxSecSurf.Platform.usDeviceID)>(*tokPlatform); 9731 } break; 9732 case TOK_FBW_PLATFORM_STR__US_REV_ID: { 9733 dst.AuxSecSurf.Platform.usRevId = readTokValue<decltype(dst.AuxSecSurf.Platform.usRevId)>(*tokPlatform); 9734 } break; 9735 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { 9736 dst.AuxSecSurf.Platform.usDeviceID_PCH = readTokValue<decltype(dst.AuxSecSurf.Platform.usDeviceID_PCH)>(*tokPlatform); 9737 } break; 9738 case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { 9739 dst.AuxSecSurf.Platform.usRevId_PCH = readTokValue<decltype(dst.AuxSecSurf.Platform.usRevId_PCH)>(*tokPlatform); 9740 } break; 9741 case TOK_FE_PLATFORM_STR__E_GTTYPE: { 9742 dst.AuxSecSurf.Platform.eGTType = readTokValue<decltype(dst.AuxSecSurf.Platform.eGTType)>(*tokPlatform); 9743 } break; 9744 }; 9745 tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount; 9746 } else { 9747 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlatform); 9748 if (tokPlatform->flags.flag3IsMandatory) { 9749 return false; 9750 } 9751 tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 9752 } 9753 } 9754 WCH_ASSERT(tokPlatform == tokPlatformEnd); 9755 #endif 9756 } break; 9757 case TOK_FS_GMM_TEXTURE_INFO_REC__EXISTING_SYS_MEM: { 9758 const TokenHeader *tokExistingSysMem = varLen->getValue<TokenHeader>(); 9759 const TokenHeader *tokExistingSysMemEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 9760 while (tokExistingSysMem < tokExistingSysMemEnd) { 9761 if (false == tokExistingSysMem->flags.flag4IsVariableLength) { 9762 switch (tokExistingSysMem->id) { 9763 default: 9764 if (tokExistingSysMem->flags.flag3IsMandatory) { 9765 return false; 9766 } 9767 break; 9768 case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_GMM_ALLOCATED: { 9769 dst.AuxSecSurf.ExistingSysMem.IsGmmAllocated = readTokValue<decltype(dst.AuxSecSurf.ExistingSysMem.IsGmmAllocated)>(*tokExistingSysMem); 9770 } break; 9771 case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_PAGE_ALIGNED: { 9772 dst.AuxSecSurf.ExistingSysMem.IsPageAligned = readTokValue<decltype(dst.AuxSecSurf.ExistingSysMem.IsPageAligned)>(*tokExistingSysMem); 9773 } break; 9774 }; 9775 tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount; 9776 } else { 9777 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokExistingSysMem); 9778 if (tokExistingSysMem->flags.flag3IsMandatory) { 9779 return false; 9780 } 9781 tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 9782 } 9783 } 9784 WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd); 9785 } break; 9786 case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: { 9787 #if !(_DEBUG || _RELEASE_INTERNAL) 9788 const TokenHeader *tok__Platform = varLen->getValue<TokenHeader>(); 9789 const TokenHeader *tok__PlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 9790 while (tok__Platform < tok__PlatformEnd) { 9791 if (false == tok__Platform->flags.flag4IsVariableLength) { 9792 switch (tok__Platform->id) { 9793 default: 9794 if (tok__Platform->flags.flag3IsMandatory) { 9795 return false; 9796 } 9797 break; 9798 case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { 9799 dst.AuxSecSurf.__Platform.eProductFamily = readTokValue<decltype(dst.AuxSecSurf.__Platform.eProductFamily)>(*tok__Platform); 9800 } break; 9801 case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { 9802 dst.AuxSecSurf.__Platform.ePCHProductFamily = readTokValue<decltype(dst.AuxSecSurf.__Platform.ePCHProductFamily)>(*tok__Platform); 9803 } break; 9804 case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { 9805 dst.AuxSecSurf.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.AuxSecSurf.__Platform.eDisplayCoreFamily)>(*tok__Platform); 9806 } break; 9807 case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { 9808 dst.AuxSecSurf.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.AuxSecSurf.__Platform.eRenderCoreFamily)>(*tok__Platform); 9809 } break; 9810 case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { 9811 dst.AuxSecSurf.__Platform.ePlatformType = readTokValue<decltype(dst.AuxSecSurf.__Platform.ePlatformType)>(*tok__Platform); 9812 } break; 9813 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { 9814 dst.AuxSecSurf.__Platform.usDeviceID = readTokValue<decltype(dst.AuxSecSurf.__Platform.usDeviceID)>(*tok__Platform); 9815 } break; 9816 case TOK_FBW_PLATFORM_STR__US_REV_ID: { 9817 dst.AuxSecSurf.__Platform.usRevId = readTokValue<decltype(dst.AuxSecSurf.__Platform.usRevId)>(*tok__Platform); 9818 } break; 9819 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { 9820 dst.AuxSecSurf.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.AuxSecSurf.__Platform.usDeviceID_PCH)>(*tok__Platform); 9821 } break; 9822 case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { 9823 dst.AuxSecSurf.__Platform.usRevId_PCH = readTokValue<decltype(dst.AuxSecSurf.__Platform.usRevId_PCH)>(*tok__Platform); 9824 } break; 9825 case TOK_FE_PLATFORM_STR__E_GTTYPE: { 9826 dst.AuxSecSurf.__Platform.eGTType = readTokValue<decltype(dst.AuxSecSurf.__Platform.eGTType)>(*tok__Platform); 9827 } break; 9828 }; 9829 tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount; 9830 } else { 9831 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok__Platform); 9832 if (tok__Platform->flags.flag3IsMandatory) { 9833 return false; 9834 } 9835 tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 9836 } 9837 } 9838 WCH_ASSERT(tok__Platform == tok__PlatformEnd); 9839 #endif 9840 } break; 9841 }; 9842 tokAuxSecSurf = tokAuxSecSurf + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 9843 } 9844 } 9845 WCH_ASSERT(tokAuxSecSurf == tokAuxSecSurfEnd); 9846 } break; 9847 case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__EXISTING_SYS_MEM: { 9848 const TokenHeader *tokExistingSysMem = varLen->getValue<TokenHeader>(); 9849 const TokenHeader *tokExistingSysMemEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 9850 while (tokExistingSysMem < tokExistingSysMemEnd) { 9851 if (false == tokExistingSysMem->flags.flag4IsVariableLength) { 9852 switch (tokExistingSysMem->id) { 9853 default: 9854 if (tokExistingSysMem->flags.flag3IsMandatory) { 9855 return false; 9856 } 9857 break; 9858 case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_EXISTING_SYS_MEM: { 9859 dst.ExistingSysMem.pExistingSysMem = readTokValue<decltype(dst.ExistingSysMem.pExistingSysMem)>(*tokExistingSysMem); 9860 } break; 9861 case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_VIRT_ADDRESS: { 9862 dst.ExistingSysMem.pVirtAddress = readTokValue<decltype(dst.ExistingSysMem.pVirtAddress)>(*tokExistingSysMem); 9863 } break; 9864 case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_GFX_ALIGNED_VIRT_ADDRESS: { 9865 dst.ExistingSysMem.pGfxAlignedVirtAddress = readTokValue<decltype(dst.ExistingSysMem.pGfxAlignedVirtAddress)>(*tokExistingSysMem); 9866 } break; 9867 case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__SIZE: { 9868 dst.ExistingSysMem.Size = readTokValue<decltype(dst.ExistingSysMem.Size)>(*tokExistingSysMem); 9869 } break; 9870 case TOK_FBC_GMM_EXISTING_SYS_MEM_REC__IS_GMM_ALLOCATED: { 9871 dst.ExistingSysMem.IsGmmAllocated = readTokValue<decltype(dst.ExistingSysMem.IsGmmAllocated)>(*tokExistingSysMem); 9872 } break; 9873 }; 9874 tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount; 9875 } else { 9876 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokExistingSysMem); 9877 if (tokExistingSysMem->flags.flag3IsMandatory) { 9878 return false; 9879 } 9880 tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 9881 } 9882 } 9883 WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd); 9884 } break; 9885 case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__MULTI_TILE_ARCH: { 9886 const TokenHeader *tokMultiTileArch = varLen->getValue<TokenHeader>(); 9887 const TokenHeader *tokMultiTileArchEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 9888 while (tokMultiTileArch < tokMultiTileArchEnd) { 9889 if (false == tokMultiTileArch->flags.flag4IsVariableLength) { 9890 switch (tokMultiTileArch->id) { 9891 default: 9892 if (tokMultiTileArch->flags.flag3IsMandatory) { 9893 return false; 9894 } 9895 break; 9896 case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__ENABLE: { 9897 dst.MultiTileArch.Enable = readTokValue<decltype(dst.MultiTileArch.Enable)>(*tokMultiTileArch); 9898 } break; 9899 case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__TILE_INSTANCED: { 9900 dst.MultiTileArch.TileInstanced = readTokValue<decltype(dst.MultiTileArch.TileInstanced)>(*tokMultiTileArch); 9901 } break; 9902 case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__GPU_VA_MAPPING_SET: { 9903 dst.MultiTileArch.GpuVaMappingSet = readTokValue<decltype(dst.MultiTileArch.GpuVaMappingSet)>(*tokMultiTileArch); 9904 } break; 9905 case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__LOCAL_MEM_ELIGIBILITY_SET: { 9906 dst.MultiTileArch.LocalMemEligibilitySet = readTokValue<decltype(dst.MultiTileArch.LocalMemEligibilitySet)>(*tokMultiTileArch); 9907 } break; 9908 case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__LOCAL_MEM_PREFERRED_SET: { 9909 dst.MultiTileArch.LocalMemPreferredSet = readTokValue<decltype(dst.MultiTileArch.LocalMemPreferredSet)>(*tokMultiTileArch); 9910 } break; 9911 }; 9912 tokMultiTileArch = tokMultiTileArch + 1 + tokMultiTileArch->valueDwordCount; 9913 } else { 9914 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokMultiTileArch); 9915 if (tokMultiTileArch->flags.flag3IsMandatory) { 9916 return false; 9917 } 9918 tokMultiTileArch = tokMultiTileArch + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 9919 } 9920 } 9921 WCH_ASSERT(tokMultiTileArch == tokMultiTileArchEnd); 9922 } break; 9923 }; 9924 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 9925 } 9926 } 9927 WCH_ASSERT(tok == srcTokensEnd); 9928 return true; 9929 } 9930 }; 9931 9932 template <> 9933 struct Demarshaller<TOK_S_GMM_RESOURCE_INFO_WIN_STRUCT> { 9934 template <typename GmmResourceInfoWinStructT> 9935 static bool demarshall(GmmResourceInfoWinStructT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 9936 const TokenHeader *tok = srcTokensBeg; 9937 while (tok < srcTokensEnd) { 9938 if (false == tok->flags.flag4IsVariableLength) { 9939 if (tok->flags.flag3IsMandatory) { 9940 return false; 9941 } 9942 tok = tok + 1 + tok->valueDwordCount; 9943 } else { 9944 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 9945 switch (tok->id) { 9946 default: 9947 if (tok->flags.flag3IsMandatory) { 9948 return false; 9949 } 9950 break; 9951 case TOK_S_GMM_RESOURCE_INFO_WIN_STRUCT: 9952 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 9953 return false; 9954 } 9955 break; 9956 case TOK_FS_GMM_RESOURCE_INFO_WIN_STRUCT__GMM_RESOURCE_INFO_COMMON: { 9957 const TokenHeader *tokGmmResourceInfoCommon = varLen->getValue<TokenHeader>(); 9958 const TokenHeader *tokGmmResourceInfoCommonEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 9959 while (tokGmmResourceInfoCommon < tokGmmResourceInfoCommonEnd) { 9960 if (false == tokGmmResourceInfoCommon->flags.flag4IsVariableLength) { 9961 switch (tokGmmResourceInfoCommon->id) { 9962 default: 9963 if (tokGmmResourceInfoCommon->flags.flag3IsMandatory) { 9964 return false; 9965 } 9966 break; 9967 case TOK_FE_GMM_RESOURCE_INFO_COMMON_STRUCT__CLIENT_TYPE: { 9968 dst.GmmResourceInfoCommon.ClientType = readTokValue<decltype(dst.GmmResourceInfoCommon.ClientType)>(*tokGmmResourceInfoCommon); 9969 } break; 9970 case TOK_FBD_GMM_RESOURCE_INFO_COMMON_STRUCT__ROTATE_INFO: { 9971 dst.GmmResourceInfoCommon.RotateInfo = readTokValue<decltype(dst.GmmResourceInfoCommon.RotateInfo)>(*tokGmmResourceInfoCommon); 9972 } break; 9973 case TOK_FBQ_GMM_RESOURCE_INFO_COMMON_STRUCT__SVM_ADDRESS: { 9974 dst.GmmResourceInfoCommon.SvmAddress = readTokValue<decltype(dst.GmmResourceInfoCommon.SvmAddress)>(*tokGmmResourceInfoCommon); 9975 } break; 9976 case TOK_FBQ_GMM_RESOURCE_INFO_COMMON_STRUCT__P_PRIVATE_DATA: { 9977 dst.GmmResourceInfoCommon.pPrivateData = readTokValue<decltype(dst.GmmResourceInfoCommon.pPrivateData)>(*tokGmmResourceInfoCommon); 9978 } break; 9979 }; 9980 tokGmmResourceInfoCommon = tokGmmResourceInfoCommon + 1 + tokGmmResourceInfoCommon->valueDwordCount; 9981 } else { 9982 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokGmmResourceInfoCommon); 9983 switch (tokGmmResourceInfoCommon->id) { 9984 default: 9985 if (tokGmmResourceInfoCommon->flags.flag3IsMandatory) { 9986 return false; 9987 } 9988 break; 9989 case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__SURF: { 9990 const TokenHeader *tokSurf = varLen->getValue<TokenHeader>(); 9991 const TokenHeader *tokSurfEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 9992 while (tokSurf < tokSurfEnd) { 9993 if (false == tokSurf->flags.flag4IsVariableLength) { 9994 switch (tokSurf->id) { 9995 default: 9996 if (tokSurf->flags.flag3IsMandatory) { 9997 return false; 9998 } 9999 break; 10000 case TOK_FE_GMM_TEXTURE_INFO_REC__TYPE: { 10001 dst.GmmResourceInfoCommon.Surf.Type = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Type)>(*tokSurf); 10002 } break; 10003 case TOK_FE_GMM_TEXTURE_INFO_REC__FORMAT: { 10004 dst.GmmResourceInfoCommon.Surf.Format = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Format)>(*tokSurf); 10005 } break; 10006 case TOK_FBD_GMM_TEXTURE_INFO_REC__BITS_PER_PIXEL: { 10007 dst.GmmResourceInfoCommon.Surf.BitsPerPixel = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.BitsPerPixel)>(*tokSurf); 10008 } break; 10009 case TOK_FBQ_GMM_TEXTURE_INFO_REC__BASE_WIDTH: { 10010 dst.GmmResourceInfoCommon.Surf.BaseWidth = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.BaseWidth)>(*tokSurf); 10011 } break; 10012 case TOK_FBD_GMM_TEXTURE_INFO_REC__BASE_HEIGHT: { 10013 dst.GmmResourceInfoCommon.Surf.BaseHeight = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.BaseHeight)>(*tokSurf); 10014 } break; 10015 case TOK_FBD_GMM_TEXTURE_INFO_REC__DEPTH: { 10016 dst.GmmResourceInfoCommon.Surf.Depth = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Depth)>(*tokSurf); 10017 } break; 10018 case TOK_FBD_GMM_TEXTURE_INFO_REC__MAX_LOD: { 10019 dst.GmmResourceInfoCommon.Surf.MaxLod = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.MaxLod)>(*tokSurf); 10020 } break; 10021 case TOK_FBD_GMM_TEXTURE_INFO_REC__ARRAY_SIZE: { 10022 dst.GmmResourceInfoCommon.Surf.ArraySize = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.ArraySize)>(*tokSurf); 10023 } break; 10024 case TOK_FBD_GMM_TEXTURE_INFO_REC__CP_TAG: { 10025 dst.GmmResourceInfoCommon.Surf.CpTag = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.CpTag)>(*tokSurf); 10026 } break; 10027 case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_MODE: { 10028 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokSurf).getValue<char>(); 10029 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokSurf).getValueSizeInBytes(); 10030 if (srcSize < sizeof(dst.GmmResourceInfoCommon.Surf.MmcMode)) { 10031 return false; 10032 } 10033 WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.MmcMode, sizeof(dst.GmmResourceInfoCommon.Surf.MmcMode), srcData, sizeof(dst.GmmResourceInfoCommon.Surf.MmcMode)); 10034 } break; 10035 case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_HINT: { 10036 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokSurf).getValue<char>(); 10037 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokSurf).getValueSizeInBytes(); 10038 if (srcSize < sizeof(dst.GmmResourceInfoCommon.Surf.MmcHint)) { 10039 return false; 10040 } 10041 WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.MmcHint, sizeof(dst.GmmResourceInfoCommon.Surf.MmcHint), srcData, sizeof(dst.GmmResourceInfoCommon.Surf.MmcHint)); 10042 } break; 10043 case TOK_FBQ_GMM_TEXTURE_INFO_REC__PITCH: { 10044 dst.GmmResourceInfoCommon.Surf.Pitch = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Pitch)>(*tokSurf); 10045 } break; 10046 case TOK_FBQ_GMM_TEXTURE_INFO_REC__OVERRIDE_PITCH: { 10047 dst.GmmResourceInfoCommon.Surf.OverridePitch = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.OverridePitch)>(*tokSurf); 10048 } break; 10049 case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE: { 10050 dst.GmmResourceInfoCommon.Surf.Size = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Size)>(*tokSurf); 10051 } break; 10052 case TOK_FBQ_GMM_TEXTURE_INFO_REC__CCSIZE: { 10053 dst.GmmResourceInfoCommon.Surf.CCSize = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.CCSize)>(*tokSurf); 10054 } break; 10055 case TOK_FBQ_GMM_TEXTURE_INFO_REC__UNPADDED_SIZE: { 10056 dst.GmmResourceInfoCommon.Surf.UnpaddedSize = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.UnpaddedSize)>(*tokSurf); 10057 } break; 10058 case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE_REPORT_TO_OS: { 10059 dst.GmmResourceInfoCommon.Surf.SizeReportToOS = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.SizeReportToOS)>(*tokSurf); 10060 } break; 10061 case TOK_FE_GMM_TEXTURE_INFO_REC__TILE_MODE: { 10062 dst.GmmResourceInfoCommon.Surf.TileMode = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.TileMode)>(*tokSurf); 10063 } break; 10064 case TOK_FBD_GMM_TEXTURE_INFO_REC__CCSMODE_ALIGN: { 10065 dst.GmmResourceInfoCommon.Surf.CCSModeAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.CCSModeAlign)>(*tokSurf); 10066 } break; 10067 case TOK_FBD_GMM_TEXTURE_INFO_REC__LEGACY_FLAGS: { 10068 dst.GmmResourceInfoCommon.Surf.LegacyFlags = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.LegacyFlags)>(*tokSurf); 10069 } break; 10070 case TOK_FBD_GMM_TEXTURE_INFO_REC__MAXIMUM_RENAMING_LIST_LENGTH: { 10071 dst.GmmResourceInfoCommon.Surf.MaximumRenamingListLength = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.MaximumRenamingListLength)>(*tokSurf); 10072 } break; 10073 }; 10074 tokSurf = tokSurf + 1 + tokSurf->valueDwordCount; 10075 } else { 10076 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSurf); 10077 switch (tokSurf->id) { 10078 default: 10079 if (tokSurf->flags.flag3IsMandatory) { 10080 return false; 10081 } 10082 break; 10083 case TOK_FS_GMM_TEXTURE_INFO_REC__FLAGS: { 10084 const TokenHeader *tokFlags = varLen->getValue<TokenHeader>(); 10085 const TokenHeader *tokFlagsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 10086 while (tokFlags < tokFlagsEnd) { 10087 if (false == tokFlags->flags.flag4IsVariableLength) { 10088 if (tokFlags->flags.flag3IsMandatory) { 10089 return false; 10090 } 10091 tokFlags = tokFlags + 1 + tokFlags->valueDwordCount; 10092 } else { 10093 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokFlags); 10094 switch (tokFlags->id) { 10095 default: 10096 if (tokFlags->flags.flag3IsMandatory) { 10097 return false; 10098 } 10099 break; 10100 case TOK_FS_GMM_RESOURCE_FLAG_REC__GPU: { 10101 const TokenHeader *tokGpu = varLen->getValue<TokenHeader>(); 10102 const TokenHeader *tokGpuEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 10103 while (tokGpu < tokGpuEnd) { 10104 if (false == tokGpu->flags.flag4IsVariableLength) { 10105 switch (tokGpu->id) { 10106 default: 10107 if (tokGpu->flags.flag3IsMandatory) { 10108 return false; 10109 } 10110 break; 10111 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CAMERA_CAPTURE: { 10112 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.CameraCapture = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.CameraCapture)>(*tokGpu); 10113 } break; 10114 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CCS: { 10115 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.CCS = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.CCS)>(*tokGpu); 10116 } break; 10117 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_DISCARD: { 10118 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ColorDiscard = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ColorDiscard)>(*tokGpu); 10119 } break; 10120 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION: { 10121 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ColorSeparation = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ColorSeparation)>(*tokGpu); 10122 } break; 10123 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION_RGBX: { 10124 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ColorSeparationRGBX = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ColorSeparationRGBX)>(*tokGpu); 10125 } break; 10126 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CONSTANT: { 10127 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Constant = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Constant)>(*tokGpu); 10128 } break; 10129 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__DEPTH: { 10130 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Depth = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Depth)>(*tokGpu); 10131 } break; 10132 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN: { 10133 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.FlipChain = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.FlipChain)>(*tokGpu); 10134 } break; 10135 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN_PREFERRED: { 10136 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.FlipChainPreferred = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.FlipChainPreferred)>(*tokGpu); 10137 } break; 10138 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HISTORY_BUFFER: { 10139 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.HistoryBuffer = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.HistoryBuffer)>(*tokGpu); 10140 } break; 10141 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HI_Z: { 10142 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.HiZ = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.HiZ)>(*tokGpu); 10143 } break; 10144 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDEX: { 10145 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Index = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Index)>(*tokGpu); 10146 } break; 10147 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDIRECT_CLEAR_COLOR: { 10148 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.IndirectClearColor = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.IndirectClearColor)>(*tokGpu); 10149 } break; 10150 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INSTRUCTION_FLAT: { 10151 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.InstructionFlat = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.InstructionFlat)>(*tokGpu); 10152 } break; 10153 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INTERLACED_SCAN: { 10154 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.InterlacedScan = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.InterlacedScan)>(*tokGpu); 10155 } break; 10156 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MCS: { 10157 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.MCS = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.MCS)>(*tokGpu); 10158 } break; 10159 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MMC: { 10160 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.MMC = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.MMC)>(*tokGpu); 10161 } break; 10162 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MOTION_COMP: { 10163 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.MotionComp = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.MotionComp)>(*tokGpu); 10164 } break; 10165 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__NO_RESTRICTION: { 10166 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.NoRestriction = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.NoRestriction)>(*tokGpu); 10167 } break; 10168 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__OVERLAY: { 10169 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Overlay = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Overlay)>(*tokGpu); 10170 } break; 10171 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PRESENTABLE: { 10172 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Presentable = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Presentable)>(*tokGpu); 10173 } break; 10174 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PROCEDURAL_TEXTURE: { 10175 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ProceduralTexture = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ProceduralTexture)>(*tokGpu); 10176 } break; 10177 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__QUERY: { 10178 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Query = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Query)>(*tokGpu); 10179 } break; 10180 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__RENDER_TARGET: { 10181 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.RenderTarget = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.RenderTarget)>(*tokGpu); 10182 } break; 10183 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D: { 10184 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.S3d = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.S3d)>(*tokGpu); 10185 } break; 10186 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D_DX: { 10187 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.S3dDx = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.S3dDx)>(*tokGpu); 10188 } break; 10189 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_NON_PACKED: { 10190 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__S3dNonPacked = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__S3dNonPacked)>(*tokGpu); 10191 } break; 10192 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_WIDI: { 10193 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__S3dWidi = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__S3dWidi)>(*tokGpu); 10194 } break; 10195 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SCRATCH_FLAT: { 10196 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ScratchFlat = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ScratchFlat)>(*tokGpu); 10197 } break; 10198 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SEPARATE_STENCIL: { 10199 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.SeparateStencil = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.SeparateStencil)>(*tokGpu); 10200 } break; 10201 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE: { 10202 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.State = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.State)>(*tokGpu); 10203 } break; 10204 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE_DX9CONSTANT_BUFFER: { 10205 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.StateDx9ConstantBuffer = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.StateDx9ConstantBuffer)>(*tokGpu); 10206 } break; 10207 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STREAM: { 10208 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Stream = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Stream)>(*tokGpu); 10209 } break; 10210 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXT_API: { 10211 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.TextApi = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.TextApi)>(*tokGpu); 10212 } break; 10213 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXTURE: { 10214 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Texture = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Texture)>(*tokGpu); 10215 } break; 10216 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILED_RESOURCE: { 10217 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.TiledResource = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.TiledResource)>(*tokGpu); 10218 } break; 10219 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILE_POOL: { 10220 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.TilePool = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.TilePool)>(*tokGpu); 10221 } break; 10222 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__UNIFIED_AUX_SURFACE: { 10223 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.UnifiedAuxSurface = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.UnifiedAuxSurface)>(*tokGpu); 10224 } break; 10225 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VERTEX: { 10226 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Vertex = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Vertex)>(*tokGpu); 10227 } break; 10228 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VIDEO: { 10229 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Video = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Video)>(*tokGpu); 10230 } break; 10231 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_XCCS: { 10232 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__NonMsaaTileXCcs = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__NonMsaaTileXCcs)>(*tokGpu); 10233 } break; 10234 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_YCCS: { 10235 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__NonMsaaTileYCcs = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__NonMsaaTileYCcs)>(*tokGpu); 10236 } break; 10237 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____MSAA_TILE_MCS: { 10238 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__MsaaTileMcs = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__MsaaTileMcs)>(*tokGpu); 10239 } break; 10240 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_LINEAR_CCS: { 10241 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__NonMsaaLinearCCS = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__NonMsaaLinearCCS)>(*tokGpu); 10242 } break; 10243 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____REMAINING: { 10244 dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__Remaining = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__Remaining)>(*tokGpu); 10245 } break; 10246 }; 10247 tokGpu = tokGpu + 1 + tokGpu->valueDwordCount; 10248 } else { 10249 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokGpu); 10250 if (tokGpu->flags.flag3IsMandatory) { 10251 return false; 10252 } 10253 tokGpu = tokGpu + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 10254 } 10255 } 10256 WCH_ASSERT(tokGpu == tokGpuEnd); 10257 } break; 10258 case TOK_FS_GMM_RESOURCE_FLAG_REC__INFO: { 10259 const TokenHeader *tokInfo = varLen->getValue<TokenHeader>(); 10260 const TokenHeader *tokInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 10261 while (tokInfo < tokInfoEnd) { 10262 if (false == tokInfo->flags.flag4IsVariableLength) { 10263 switch (tokInfo->id) { 10264 default: 10265 if (tokInfo->flags.flag3IsMandatory) { 10266 return false; 10267 } 10268 break; 10269 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ALLOW_VIRTUAL_PADDING: { 10270 dst.GmmResourceInfoCommon.Surf.Flags.Info.AllowVirtualPadding = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.AllowVirtualPadding)>(*tokInfo); 10271 } break; 10272 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__BIG_PAGE: { 10273 dst.GmmResourceInfoCommon.Surf.Flags.Info.BigPage = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.BigPage)>(*tokInfo); 10274 } break; 10275 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CACHEABLE: { 10276 dst.GmmResourceInfoCommon.Surf.Flags.Info.Cacheable = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.Cacheable)>(*tokInfo); 10277 } break; 10278 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CONTIG_PHYS_MEMORY_FORI_DART: { 10279 dst.GmmResourceInfoCommon.Surf.Flags.Info.ContigPhysMemoryForiDART = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.ContigPhysMemoryForiDART)>(*tokInfo); 10280 } break; 10281 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CORNER_TEXEL_MODE: { 10282 dst.GmmResourceInfoCommon.Surf.Flags.Info.CornerTexelMode = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.CornerTexelMode)>(*tokInfo); 10283 } break; 10284 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__EXISTING_SYS_MEM: { 10285 dst.GmmResourceInfoCommon.Surf.Flags.Info.ExistingSysMem = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.ExistingSysMem)>(*tokInfo); 10286 } break; 10287 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__FORCE_RESIDENCY: { 10288 dst.GmmResourceInfoCommon.Surf.Flags.Info.ForceResidency = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.ForceResidency)>(*tokInfo); 10289 } break; 10290 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GFDT: { 10291 dst.GmmResourceInfoCommon.Surf.Flags.Info.Gfdt = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.Gfdt)>(*tokInfo); 10292 } break; 10293 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GTT_MAP_TYPE: { 10294 dst.GmmResourceInfoCommon.Surf.Flags.Info.GttMapType = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.GttMapType)>(*tokInfo); 10295 } break; 10296 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__HARDWARE_PROTECTED: { 10297 dst.GmmResourceInfoCommon.Surf.Flags.Info.HardwareProtected = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.HardwareProtected)>(*tokInfo); 10298 } break; 10299 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__KERNEL_MODE_MAPPED: { 10300 dst.GmmResourceInfoCommon.Surf.Flags.Info.KernelModeMapped = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.KernelModeMapped)>(*tokInfo); 10301 } break; 10302 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_BELOW: { 10303 dst.GmmResourceInfoCommon.Surf.Flags.Info.LayoutBelow = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.LayoutBelow)>(*tokInfo); 10304 } break; 10305 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_MONO: { 10306 dst.GmmResourceInfoCommon.Surf.Flags.Info.LayoutMono = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.LayoutMono)>(*tokInfo); 10307 } break; 10308 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_RIGHT: { 10309 dst.GmmResourceInfoCommon.Surf.Flags.Info.LayoutRight = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.LayoutRight)>(*tokInfo); 10310 } break; 10311 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LOCAL_ONLY: { 10312 dst.GmmResourceInfoCommon.Surf.Flags.Info.LocalOnly = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.LocalOnly)>(*tokInfo); 10313 } break; 10314 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LINEAR: { 10315 dst.GmmResourceInfoCommon.Surf.Flags.Info.Linear = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.Linear)>(*tokInfo); 10316 } break; 10317 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__MEDIA_COMPRESSED: { 10318 dst.GmmResourceInfoCommon.Surf.Flags.Info.MediaCompressed = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.MediaCompressed)>(*tokInfo); 10319 } break; 10320 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_OPTIMIZATION_PADDING: { 10321 dst.GmmResourceInfoCommon.Surf.Flags.Info.NoOptimizationPadding = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.NoOptimizationPadding)>(*tokInfo); 10322 } break; 10323 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_PHYS_MEMORY: { 10324 dst.GmmResourceInfoCommon.Surf.Flags.Info.NoPhysMemory = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.NoPhysMemory)>(*tokInfo); 10325 } break; 10326 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NOT_LOCKABLE: { 10327 dst.GmmResourceInfoCommon.Surf.Flags.Info.NotLockable = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.NotLockable)>(*tokInfo); 10328 } break; 10329 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NON_LOCAL_ONLY: { 10330 dst.GmmResourceInfoCommon.Surf.Flags.Info.NonLocalOnly = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.NonLocalOnly)>(*tokInfo); 10331 } break; 10332 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__STD_SWIZZLE: { 10333 dst.GmmResourceInfoCommon.Surf.Flags.Info.StdSwizzle = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.StdSwizzle)>(*tokInfo); 10334 } break; 10335 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__PSEUDO_STD_SWIZZLE: { 10336 dst.GmmResourceInfoCommon.Surf.Flags.Info.PseudoStdSwizzle = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.PseudoStdSwizzle)>(*tokInfo); 10337 } break; 10338 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__UNDEFINED64KBSWIZZLE: { 10339 dst.GmmResourceInfoCommon.Surf.Flags.Info.Undefined64KBSwizzle = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.Undefined64KBSwizzle)>(*tokInfo); 10340 } break; 10341 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__REDECRIBED_PLANES: { 10342 dst.GmmResourceInfoCommon.Surf.Flags.Info.RedecribedPlanes = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.RedecribedPlanes)>(*tokInfo); 10343 } break; 10344 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__RENDER_COMPRESSED: { 10345 dst.GmmResourceInfoCommon.Surf.Flags.Info.RenderCompressed = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.RenderCompressed)>(*tokInfo); 10346 } break; 10347 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ROTATED: { 10348 dst.GmmResourceInfoCommon.Surf.Flags.Info.Rotated = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.Rotated)>(*tokInfo); 10349 } break; 10350 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SHARED: { 10351 dst.GmmResourceInfoCommon.Surf.Flags.Info.Shared = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.Shared)>(*tokInfo); 10352 } break; 10353 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SOFTWARE_PROTECTED: { 10354 dst.GmmResourceInfoCommon.Surf.Flags.Info.SoftwareProtected = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.SoftwareProtected)>(*tokInfo); 10355 } break; 10356 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SVM: { 10357 dst.GmmResourceInfoCommon.Surf.Flags.Info.SVM = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.SVM)>(*tokInfo); 10358 } break; 10359 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE4: { 10360 dst.GmmResourceInfoCommon.Surf.Flags.Info.Tile4 = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.Tile4)>(*tokInfo); 10361 } break; 10362 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE64: { 10363 dst.GmmResourceInfoCommon.Surf.Flags.Info.Tile64 = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.Tile64)>(*tokInfo); 10364 } break; 10365 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_W: { 10366 dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledW = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledW)>(*tokInfo); 10367 } break; 10368 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_X: { 10369 dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledX = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledX)>(*tokInfo); 10370 } break; 10371 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_Y: { 10372 dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledY = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledY)>(*tokInfo); 10373 } break; 10374 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YF: { 10375 dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledYf = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledYf)>(*tokInfo); 10376 } break; 10377 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YS: { 10378 dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledYs = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledYs)>(*tokInfo); 10379 } break; 10380 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__WDDM_PROTECTED: { 10381 dst.GmmResourceInfoCommon.Surf.Flags.Info.WddmProtected = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.WddmProtected)>(*tokInfo); 10382 } break; 10383 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__XADAPTER: { 10384 dst.GmmResourceInfoCommon.Surf.Flags.Info.XAdapter = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.XAdapter)>(*tokInfo); 10385 } break; 10386 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PREALLOCATED_RES_INFO: { 10387 dst.GmmResourceInfoCommon.Surf.Flags.Info.__PreallocatedResInfo = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.__PreallocatedResInfo)>(*tokInfo); 10388 } break; 10389 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PRE_WDDM2SVM: { 10390 dst.GmmResourceInfoCommon.Surf.Flags.Info.__PreWddm2SVM = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.__PreWddm2SVM)>(*tokInfo); 10391 } break; 10392 }; 10393 tokInfo = tokInfo + 1 + tokInfo->valueDwordCount; 10394 } else { 10395 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInfo); 10396 if (tokInfo->flags.flag3IsMandatory) { 10397 return false; 10398 } 10399 tokInfo = tokInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 10400 } 10401 } 10402 WCH_ASSERT(tokInfo == tokInfoEnd); 10403 } break; 10404 case TOK_FS_GMM_RESOURCE_FLAG_REC__WA: { 10405 const TokenHeader *tokWa = varLen->getValue<TokenHeader>(); 10406 const TokenHeader *tokWaEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 10407 while (tokWa < tokWaEnd) { 10408 if (false == tokWa->flags.flag4IsVariableLength) { 10409 switch (tokWa->id) { 10410 default: 10411 if (tokWa->flags.flag3IsMandatory) { 10412 return false; 10413 } 10414 break; 10415 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__GTMFX2ND_LEVEL_BATCH_RING_SIZE_ALIGN: { 10416 dst.GmmResourceInfoCommon.Surf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign)>(*tokWa); 10417 } break; 10418 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_MPR_ROW_STORE32KALIGN: { 10419 dst.GmmResourceInfoCommon.Surf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign)>(*tokWa); 10420 } break; 10421 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_DMV_BUFFER32KALIGN: { 10422 dst.GmmResourceInfoCommon.Surf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign)>(*tokWa); 10423 } break; 10424 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_BUFFER_SAMPLER_PADDING: { 10425 dst.GmmResourceInfoCommon.Surf.Flags.Wa.NoBufferSamplerPadding = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Wa.NoBufferSamplerPadding)>(*tokWa); 10426 } break; 10427 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_LEGACY_PLANAR_LINEAR_VIDEO_RESTRICTIONS: { 10428 dst.GmmResourceInfoCommon.Surf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions)>(*tokWa); 10429 } break; 10430 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__CHVASTC_SKIP_VIRTUAL_MIPS: { 10431 dst.GmmResourceInfoCommon.Surf.Flags.Wa.CHVAstcSkipVirtualMips = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Wa.CHVAstcSkipVirtualMips)>(*tokWa); 10432 } break; 10433 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_PACKED_MIP_TAIL: { 10434 dst.GmmResourceInfoCommon.Surf.Flags.Wa.DisablePackedMipTail = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Wa.DisablePackedMipTail)>(*tokWa); 10435 } break; 10436 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521____FORCE_OTHER_HVALIGN4: { 10437 dst.GmmResourceInfoCommon.Surf.Flags.Wa.__ForceOtherHVALIGN4 = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Wa.__ForceOtherHVALIGN4)>(*tokWa); 10438 } break; 10439 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR: { 10440 dst.GmmResourceInfoCommon.Surf.Flags.Wa.DisableDisplayCcsClearColor = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Wa.DisableDisplayCcsClearColor)>(*tokWa); 10441 } break; 10442 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION: { 10443 dst.GmmResourceInfoCommon.Surf.Flags.Wa.DisableDisplayCcsCompression = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Wa.DisableDisplayCcsCompression)>(*tokWa); 10444 } break; 10445 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: { 10446 dst.GmmResourceInfoCommon.Surf.Flags.Wa.PreGen12FastClearOnly = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Wa.PreGen12FastClearOnly)>(*tokWa); 10447 } break; 10448 }; 10449 tokWa = tokWa + 1 + tokWa->valueDwordCount; 10450 } else { 10451 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokWa); 10452 if (tokWa->flags.flag3IsMandatory) { 10453 return false; 10454 } 10455 tokWa = tokWa + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 10456 } 10457 } 10458 WCH_ASSERT(tokWa == tokWaEnd); 10459 } break; 10460 }; 10461 tokFlags = tokFlags + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 10462 } 10463 } 10464 WCH_ASSERT(tokFlags == tokFlagsEnd); 10465 } break; 10466 case TOK_FS_GMM_TEXTURE_INFO_REC__CACHE_POLICY: { 10467 const TokenHeader *tokCachePolicy = varLen->getValue<TokenHeader>(); 10468 const TokenHeader *tokCachePolicyEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 10469 while (tokCachePolicy < tokCachePolicyEnd) { 10470 if (false == tokCachePolicy->flags.flag4IsVariableLength) { 10471 switch (tokCachePolicy->id) { 10472 default: 10473 if (tokCachePolicy->flags.flag3IsMandatory) { 10474 return false; 10475 } 10476 break; 10477 case TOK_FE_GMM_TEXTURE_INFO_REC__ANONYMOUS4927__USAGE: { 10478 dst.GmmResourceInfoCommon.Surf.CachePolicy.Usage = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.CachePolicy.Usage)>(*tokCachePolicy); 10479 } break; 10480 }; 10481 tokCachePolicy = tokCachePolicy + 1 + tokCachePolicy->valueDwordCount; 10482 } else { 10483 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCachePolicy); 10484 if (tokCachePolicy->flags.flag3IsMandatory) { 10485 return false; 10486 } 10487 tokCachePolicy = tokCachePolicy + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 10488 } 10489 } 10490 WCH_ASSERT(tokCachePolicy == tokCachePolicyEnd); 10491 } break; 10492 case TOK_FS_GMM_TEXTURE_INFO_REC__MSAA: { 10493 const TokenHeader *tokMSAA = varLen->getValue<TokenHeader>(); 10494 const TokenHeader *tokMSAAEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 10495 while (tokMSAA < tokMSAAEnd) { 10496 if (false == tokMSAA->flags.flag4IsVariableLength) { 10497 switch (tokMSAA->id) { 10498 default: 10499 if (tokMSAA->flags.flag3IsMandatory) { 10500 return false; 10501 } 10502 break; 10503 case TOK_FE_GMM_RESOURCE_MSAA_INFO_REC__SAMPLE_PATTERN: { 10504 dst.GmmResourceInfoCommon.Surf.MSAA.SamplePattern = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.MSAA.SamplePattern)>(*tokMSAA); 10505 } break; 10506 case TOK_FBD_GMM_RESOURCE_MSAA_INFO_REC__NUM_SAMPLES: { 10507 dst.GmmResourceInfoCommon.Surf.MSAA.NumSamples = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.MSAA.NumSamples)>(*tokMSAA); 10508 } break; 10509 }; 10510 tokMSAA = tokMSAA + 1 + tokMSAA->valueDwordCount; 10511 } else { 10512 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokMSAA); 10513 if (tokMSAA->flags.flag3IsMandatory) { 10514 return false; 10515 } 10516 tokMSAA = tokMSAA + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 10517 } 10518 } 10519 WCH_ASSERT(tokMSAA == tokMSAAEnd); 10520 } break; 10521 case TOK_FS_GMM_TEXTURE_INFO_REC__ALIGNMENT: { 10522 const TokenHeader *tokAlignment = varLen->getValue<TokenHeader>(); 10523 const TokenHeader *tokAlignmentEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 10524 while (tokAlignment < tokAlignmentEnd) { 10525 if (false == tokAlignment->flags.flag4IsVariableLength) { 10526 switch (tokAlignment->id) { 10527 default: 10528 if (tokAlignment->flags.flag3IsMandatory) { 10529 return false; 10530 } 10531 break; 10532 case TOK_FBC_GMM_RESOURCE_ALIGNMENT_REC__ARRAY_SPACING_SINGLE_LOD: { 10533 dst.GmmResourceInfoCommon.Surf.Alignment.ArraySpacingSingleLod = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Alignment.ArraySpacingSingleLod)>(*tokAlignment); 10534 } break; 10535 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__BASE_ALIGNMENT: { 10536 dst.GmmResourceInfoCommon.Surf.Alignment.BaseAlignment = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Alignment.BaseAlignment)>(*tokAlignment); 10537 } break; 10538 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__HALIGN: { 10539 dst.GmmResourceInfoCommon.Surf.Alignment.HAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Alignment.HAlign)>(*tokAlignment); 10540 } break; 10541 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__VALIGN: { 10542 dst.GmmResourceInfoCommon.Surf.Alignment.VAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Alignment.VAlign)>(*tokAlignment); 10543 } break; 10544 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__DALIGN: { 10545 dst.GmmResourceInfoCommon.Surf.Alignment.DAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Alignment.DAlign)>(*tokAlignment); 10546 } break; 10547 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__MIP_TAIL_START_LOD: { 10548 dst.GmmResourceInfoCommon.Surf.Alignment.MipTailStartLod = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Alignment.MipTailStartLod)>(*tokAlignment); 10549 } break; 10550 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_START_LOD: { 10551 dst.GmmResourceInfoCommon.Surf.Alignment.PackedMipStartLod = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Alignment.PackedMipStartLod)>(*tokAlignment); 10552 } break; 10553 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_WIDTH: { 10554 dst.GmmResourceInfoCommon.Surf.Alignment.PackedMipWidth = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Alignment.PackedMipWidth)>(*tokAlignment); 10555 } break; 10556 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_HEIGHT: { 10557 dst.GmmResourceInfoCommon.Surf.Alignment.PackedMipHeight = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Alignment.PackedMipHeight)>(*tokAlignment); 10558 } break; 10559 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__QPITCH: { 10560 dst.GmmResourceInfoCommon.Surf.Alignment.QPitch = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Alignment.QPitch)>(*tokAlignment); 10561 } break; 10562 }; 10563 tokAlignment = tokAlignment + 1 + tokAlignment->valueDwordCount; 10564 } else { 10565 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokAlignment); 10566 if (tokAlignment->flags.flag3IsMandatory) { 10567 return false; 10568 } 10569 tokAlignment = tokAlignment + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 10570 } 10571 } 10572 WCH_ASSERT(tokAlignment == tokAlignmentEnd); 10573 } break; 10574 case TOK_FS_GMM_TEXTURE_INFO_REC__OFFSET_INFO: { 10575 const TokenHeader *tokOffsetInfo = varLen->getValue<TokenHeader>(); 10576 const TokenHeader *tokOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 10577 while (tokOffsetInfo < tokOffsetInfoEnd) { 10578 if (false == tokOffsetInfo->flags.flag4IsVariableLength) { 10579 if (tokOffsetInfo->flags.flag3IsMandatory) { 10580 return false; 10581 } 10582 tokOffsetInfo = tokOffsetInfo + 1 + tokOffsetInfo->valueDwordCount; 10583 } else { 10584 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokOffsetInfo); 10585 switch (tokOffsetInfo->id) { 10586 default: 10587 if (tokOffsetInfo->flags.flag3IsMandatory) { 10588 return false; 10589 } 10590 break; 10591 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO: { 10592 const TokenHeader *tokTexture3DOffsetInfo = varLen->getValue<TokenHeader>(); 10593 const TokenHeader *tokTexture3DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 10594 while (tokTexture3DOffsetInfo < tokTexture3DOffsetInfoEnd) { 10595 if (false == tokTexture3DOffsetInfo->flags.flag4IsVariableLength) { 10596 switch (tokTexture3DOffsetInfo->id) { 10597 default: 10598 if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { 10599 return false; 10600 } 10601 break; 10602 case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: { 10603 dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch)>(*tokTexture3DOffsetInfo); 10604 } break; 10605 case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: { 10606 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValue<char>(); 10607 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValueSizeInBytes(); 10608 if (srcSize < sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture3DOffsetInfo.Offset)) { 10609 return false; 10610 } 10611 WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture3DOffsetInfo.Offset), srcData, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture3DOffsetInfo.Offset)); 10612 } break; 10613 }; 10614 tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + 1 + tokTexture3DOffsetInfo->valueDwordCount; 10615 } else { 10616 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture3DOffsetInfo); 10617 if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { 10618 return false; 10619 } 10620 tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 10621 } 10622 } 10623 WCH_ASSERT(tokTexture3DOffsetInfo == tokTexture3DOffsetInfoEnd); 10624 } break; 10625 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO: { 10626 const TokenHeader *tokTexture2DOffsetInfo = varLen->getValue<TokenHeader>(); 10627 const TokenHeader *tokTexture2DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 10628 while (tokTexture2DOffsetInfo < tokTexture2DOffsetInfoEnd) { 10629 if (false == tokTexture2DOffsetInfo->flags.flag4IsVariableLength) { 10630 switch (tokTexture2DOffsetInfo->id) { 10631 default: 10632 if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { 10633 return false; 10634 } 10635 break; 10636 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: { 10637 dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock)>(*tokTexture2DOffsetInfo); 10638 } break; 10639 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: { 10640 dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender)>(*tokTexture2DOffsetInfo); 10641 } break; 10642 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: { 10643 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValue<char>(); 10644 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValueSizeInBytes(); 10645 if (srcSize < sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.Offset)) { 10646 return false; 10647 } 10648 WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.Offset), srcData, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.Offset)); 10649 } break; 10650 }; 10651 tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + 1 + tokTexture2DOffsetInfo->valueDwordCount; 10652 } else { 10653 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture2DOffsetInfo); 10654 if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { 10655 return false; 10656 } 10657 tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 10658 } 10659 } 10660 WCH_ASSERT(tokTexture2DOffsetInfo == tokTexture2DOffsetInfoEnd); 10661 } break; 10662 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE: { 10663 const TokenHeader *tokPlane = varLen->getValue<TokenHeader>(); 10664 const TokenHeader *tokPlaneEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 10665 while (tokPlane < tokPlaneEnd) { 10666 if (false == tokPlane->flags.flag4IsVariableLength) { 10667 switch (tokPlane->id) { 10668 default: 10669 if (tokPlane->flags.flag3IsMandatory) { 10670 return false; 10671 } 10672 break; 10673 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: { 10674 dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.ArrayQPitch = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.ArrayQPitch)>(*tokPlane); 10675 } break; 10676 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: { 10677 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>(); 10678 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes(); 10679 if (srcSize < sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.X)) { 10680 return false; 10681 } 10682 WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.X, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.X), srcData, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.X)); 10683 } break; 10684 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: { 10685 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>(); 10686 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes(); 10687 if (srcSize < sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.Y)) { 10688 return false; 10689 } 10690 WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.Y, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.Y), srcData, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.Y)); 10691 } break; 10692 case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: { 10693 dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.NoOfPlanes = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.NoOfPlanes)>(*tokPlane); 10694 } break; 10695 case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: { 10696 dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.IsTileAlignedPlanes = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.IsTileAlignedPlanes)>(*tokPlane); 10697 } break; 10698 }; 10699 tokPlane = tokPlane + 1 + tokPlane->valueDwordCount; 10700 } else { 10701 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlane); 10702 switch (tokPlane->id) { 10703 default: 10704 if (tokPlane->flags.flag3IsMandatory) { 10705 return false; 10706 } 10707 break; 10708 case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: { 10709 const TokenHeader *tokUnAligned = varLen->getValue<TokenHeader>(); 10710 const TokenHeader *tokUnAlignedEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 10711 while (tokUnAligned < tokUnAlignedEnd) { 10712 if (false == tokUnAligned->flags.flag4IsVariableLength) { 10713 switch (tokUnAligned->id) { 10714 default: 10715 if (tokUnAligned->flags.flag3IsMandatory) { 10716 return false; 10717 } 10718 break; 10719 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: { 10720 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValue<char>(); 10721 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValueSizeInBytes(); 10722 if (srcSize < sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.UnAligned.Height)) { 10723 return false; 10724 } 10725 WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.UnAligned.Height, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.UnAligned.Height), srcData, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.UnAligned.Height)); 10726 } break; 10727 }; 10728 tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount; 10729 } else { 10730 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokUnAligned); 10731 if (tokUnAligned->flags.flag3IsMandatory) { 10732 return false; 10733 } 10734 tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 10735 } 10736 } 10737 WCH_ASSERT(tokUnAligned == tokUnAlignedEnd); 10738 } break; 10739 }; 10740 tokPlane = tokPlane + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 10741 } 10742 } 10743 WCH_ASSERT(tokPlane == tokPlaneEnd); 10744 } break; 10745 }; 10746 tokOffsetInfo = tokOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 10747 } 10748 } 10749 WCH_ASSERT(tokOffsetInfo == tokOffsetInfoEnd); 10750 } break; 10751 case TOK_FS_GMM_TEXTURE_INFO_REC__S3D: { 10752 const TokenHeader *tokS3d = varLen->getValue<TokenHeader>(); 10753 const TokenHeader *tokS3dEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 10754 while (tokS3d < tokS3dEnd) { 10755 if (false == tokS3d->flags.flag4IsVariableLength) { 10756 switch (tokS3d->id) { 10757 default: 10758 if (tokS3d->flags.flag3IsMandatory) { 10759 return false; 10760 } 10761 break; 10762 case TOK_FBD_GMM_S3D_INFO_REC__DISPLAY_MODE_HEIGHT: { 10763 dst.GmmResourceInfoCommon.Surf.S3d.DisplayModeHeight = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.S3d.DisplayModeHeight)>(*tokS3d); 10764 } break; 10765 case TOK_FBD_GMM_S3D_INFO_REC__NUM_BLANK_ACTIVE_LINES: { 10766 dst.GmmResourceInfoCommon.Surf.S3d.NumBlankActiveLines = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.S3d.NumBlankActiveLines)>(*tokS3d); 10767 } break; 10768 case TOK_FBD_GMM_S3D_INFO_REC__RFRAME_OFFSET: { 10769 dst.GmmResourceInfoCommon.Surf.S3d.RFrameOffset = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.S3d.RFrameOffset)>(*tokS3d); 10770 } break; 10771 case TOK_FBD_GMM_S3D_INFO_REC__BLANK_AREA_OFFSET: { 10772 dst.GmmResourceInfoCommon.Surf.S3d.BlankAreaOffset = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.S3d.BlankAreaOffset)>(*tokS3d); 10773 } break; 10774 case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_HEIGHT: { 10775 dst.GmmResourceInfoCommon.Surf.S3d.TallBufferHeight = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.S3d.TallBufferHeight)>(*tokS3d); 10776 } break; 10777 case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_SIZE: { 10778 dst.GmmResourceInfoCommon.Surf.S3d.TallBufferSize = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.S3d.TallBufferSize)>(*tokS3d); 10779 } break; 10780 case TOK_FBC_GMM_S3D_INFO_REC__IS_RFRAME: { 10781 dst.GmmResourceInfoCommon.Surf.S3d.IsRFrame = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.S3d.IsRFrame)>(*tokS3d); 10782 } break; 10783 }; 10784 tokS3d = tokS3d + 1 + tokS3d->valueDwordCount; 10785 } else { 10786 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokS3d); 10787 if (tokS3d->flags.flag3IsMandatory) { 10788 return false; 10789 } 10790 tokS3d = tokS3d + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 10791 } 10792 } 10793 WCH_ASSERT(tokS3d == tokS3dEnd); 10794 } break; 10795 case TOK_FS_GMM_TEXTURE_INFO_REC__SEGMENT_OVERRIDE: { 10796 const TokenHeader *tokSegmentOverride = varLen->getValue<TokenHeader>(); 10797 const TokenHeader *tokSegmentOverrideEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 10798 while (tokSegmentOverride < tokSegmentOverrideEnd) { 10799 if (false == tokSegmentOverride->flags.flag4IsVariableLength) { 10800 switch (tokSegmentOverride->id) { 10801 default: 10802 if (tokSegmentOverride->flags.flag3IsMandatory) { 10803 return false; 10804 } 10805 break; 10806 case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__SEG1: { 10807 dst.GmmResourceInfoCommon.Surf.SegmentOverride.Seg1 = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.SegmentOverride.Seg1)>(*tokSegmentOverride); 10808 } break; 10809 case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__EVICT: { 10810 dst.GmmResourceInfoCommon.Surf.SegmentOverride.Evict = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.SegmentOverride.Evict)>(*tokSegmentOverride); 10811 } break; 10812 }; 10813 tokSegmentOverride = tokSegmentOverride + 1 + tokSegmentOverride->valueDwordCount; 10814 } else { 10815 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSegmentOverride); 10816 if (tokSegmentOverride->flags.flag3IsMandatory) { 10817 return false; 10818 } 10819 tokSegmentOverride = tokSegmentOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 10820 } 10821 } 10822 WCH_ASSERT(tokSegmentOverride == tokSegmentOverrideEnd); 10823 } break; 10824 case TOK_FS_GMM_TEXTURE_INFO_REC__PLATFORM: { 10825 #if _DEBUG || _RELEASE_INTERNAL 10826 const TokenHeader *tokPlatform = varLen->getValue<TokenHeader>(); 10827 const TokenHeader *tokPlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 10828 while (tokPlatform < tokPlatformEnd) { 10829 if (false == tokPlatform->flags.flag4IsVariableLength) { 10830 switch (tokPlatform->id) { 10831 default: 10832 if (tokPlatform->flags.flag3IsMandatory) { 10833 return false; 10834 } 10835 break; 10836 case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { 10837 dst.GmmResourceInfoCommon.Surf.Platform.eProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Platform.eProductFamily)>(*tokPlatform); 10838 } break; 10839 case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { 10840 dst.GmmResourceInfoCommon.Surf.Platform.ePCHProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Platform.ePCHProductFamily)>(*tokPlatform); 10841 } break; 10842 case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { 10843 dst.GmmResourceInfoCommon.Surf.Platform.eDisplayCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Platform.eDisplayCoreFamily)>(*tokPlatform); 10844 } break; 10845 case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { 10846 dst.GmmResourceInfoCommon.Surf.Platform.eRenderCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Platform.eRenderCoreFamily)>(*tokPlatform); 10847 } break; 10848 case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { 10849 dst.GmmResourceInfoCommon.Surf.Platform.ePlatformType = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Platform.ePlatformType)>(*tokPlatform); 10850 } break; 10851 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { 10852 dst.GmmResourceInfoCommon.Surf.Platform.usDeviceID = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Platform.usDeviceID)>(*tokPlatform); 10853 } break; 10854 case TOK_FBW_PLATFORM_STR__US_REV_ID: { 10855 dst.GmmResourceInfoCommon.Surf.Platform.usRevId = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Platform.usRevId)>(*tokPlatform); 10856 } break; 10857 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { 10858 dst.GmmResourceInfoCommon.Surf.Platform.usDeviceID_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Platform.usDeviceID_PCH)>(*tokPlatform); 10859 } break; 10860 case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { 10861 dst.GmmResourceInfoCommon.Surf.Platform.usRevId_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Platform.usRevId_PCH)>(*tokPlatform); 10862 } break; 10863 case TOK_FE_PLATFORM_STR__E_GTTYPE: { 10864 dst.GmmResourceInfoCommon.Surf.Platform.eGTType = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Platform.eGTType)>(*tokPlatform); 10865 } break; 10866 }; 10867 tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount; 10868 } else { 10869 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlatform); 10870 if (tokPlatform->flags.flag3IsMandatory) { 10871 return false; 10872 } 10873 tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 10874 } 10875 } 10876 WCH_ASSERT(tokPlatform == tokPlatformEnd); 10877 #endif 10878 } break; 10879 case TOK_FS_GMM_TEXTURE_INFO_REC__EXISTING_SYS_MEM: { 10880 const TokenHeader *tokExistingSysMem = varLen->getValue<TokenHeader>(); 10881 const TokenHeader *tokExistingSysMemEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 10882 while (tokExistingSysMem < tokExistingSysMemEnd) { 10883 if (false == tokExistingSysMem->flags.flag4IsVariableLength) { 10884 switch (tokExistingSysMem->id) { 10885 default: 10886 if (tokExistingSysMem->flags.flag3IsMandatory) { 10887 return false; 10888 } 10889 break; 10890 case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_GMM_ALLOCATED: { 10891 dst.GmmResourceInfoCommon.Surf.ExistingSysMem.IsGmmAllocated = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.ExistingSysMem.IsGmmAllocated)>(*tokExistingSysMem); 10892 } break; 10893 case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_PAGE_ALIGNED: { 10894 dst.GmmResourceInfoCommon.Surf.ExistingSysMem.IsPageAligned = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.ExistingSysMem.IsPageAligned)>(*tokExistingSysMem); 10895 } break; 10896 }; 10897 tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount; 10898 } else { 10899 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokExistingSysMem); 10900 if (tokExistingSysMem->flags.flag3IsMandatory) { 10901 return false; 10902 } 10903 tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 10904 } 10905 } 10906 WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd); 10907 } break; 10908 case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: { 10909 #if !(_DEBUG || _RELEASE_INTERNAL) 10910 const TokenHeader *tok__Platform = varLen->getValue<TokenHeader>(); 10911 const TokenHeader *tok__PlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 10912 while (tok__Platform < tok__PlatformEnd) { 10913 if (false == tok__Platform->flags.flag4IsVariableLength) { 10914 switch (tok__Platform->id) { 10915 default: 10916 if (tok__Platform->flags.flag3IsMandatory) { 10917 return false; 10918 } 10919 break; 10920 case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { 10921 dst.GmmResourceInfoCommon.Surf.__Platform.eProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.eProductFamily)>(*tok__Platform); 10922 } break; 10923 case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { 10924 dst.GmmResourceInfoCommon.Surf.__Platform.ePCHProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.ePCHProductFamily)>(*tok__Platform); 10925 } break; 10926 case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { 10927 dst.GmmResourceInfoCommon.Surf.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.eDisplayCoreFamily)>(*tok__Platform); 10928 } break; 10929 case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { 10930 dst.GmmResourceInfoCommon.Surf.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.eRenderCoreFamily)>(*tok__Platform); 10931 } break; 10932 case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { 10933 dst.GmmResourceInfoCommon.Surf.__Platform.ePlatformType = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.ePlatformType)>(*tok__Platform); 10934 } break; 10935 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { 10936 dst.GmmResourceInfoCommon.Surf.__Platform.usDeviceID = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.usDeviceID)>(*tok__Platform); 10937 } break; 10938 case TOK_FBW_PLATFORM_STR__US_REV_ID: { 10939 dst.GmmResourceInfoCommon.Surf.__Platform.usRevId = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.usRevId)>(*tok__Platform); 10940 } break; 10941 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { 10942 dst.GmmResourceInfoCommon.Surf.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.usDeviceID_PCH)>(*tok__Platform); 10943 } break; 10944 case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { 10945 dst.GmmResourceInfoCommon.Surf.__Platform.usRevId_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.usRevId_PCH)>(*tok__Platform); 10946 } break; 10947 case TOK_FE_PLATFORM_STR__E_GTTYPE: { 10948 dst.GmmResourceInfoCommon.Surf.__Platform.eGTType = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.eGTType)>(*tok__Platform); 10949 } break; 10950 }; 10951 tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount; 10952 } else { 10953 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok__Platform); 10954 if (tok__Platform->flags.flag3IsMandatory) { 10955 return false; 10956 } 10957 tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 10958 } 10959 } 10960 WCH_ASSERT(tok__Platform == tok__PlatformEnd); 10961 #endif 10962 } break; 10963 }; 10964 tokSurf = tokSurf + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 10965 } 10966 } 10967 WCH_ASSERT(tokSurf == tokSurfEnd); 10968 } break; 10969 case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__AUX_SURF: { 10970 const TokenHeader *tokAuxSurf = varLen->getValue<TokenHeader>(); 10971 const TokenHeader *tokAuxSurfEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 10972 while (tokAuxSurf < tokAuxSurfEnd) { 10973 if (false == tokAuxSurf->flags.flag4IsVariableLength) { 10974 switch (tokAuxSurf->id) { 10975 default: 10976 if (tokAuxSurf->flags.flag3IsMandatory) { 10977 return false; 10978 } 10979 break; 10980 case TOK_FE_GMM_TEXTURE_INFO_REC__TYPE: { 10981 dst.GmmResourceInfoCommon.AuxSurf.Type = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Type)>(*tokAuxSurf); 10982 } break; 10983 case TOK_FE_GMM_TEXTURE_INFO_REC__FORMAT: { 10984 dst.GmmResourceInfoCommon.AuxSurf.Format = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Format)>(*tokAuxSurf); 10985 } break; 10986 case TOK_FBD_GMM_TEXTURE_INFO_REC__BITS_PER_PIXEL: { 10987 dst.GmmResourceInfoCommon.AuxSurf.BitsPerPixel = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.BitsPerPixel)>(*tokAuxSurf); 10988 } break; 10989 case TOK_FBQ_GMM_TEXTURE_INFO_REC__BASE_WIDTH: { 10990 dst.GmmResourceInfoCommon.AuxSurf.BaseWidth = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.BaseWidth)>(*tokAuxSurf); 10991 } break; 10992 case TOK_FBD_GMM_TEXTURE_INFO_REC__BASE_HEIGHT: { 10993 dst.GmmResourceInfoCommon.AuxSurf.BaseHeight = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.BaseHeight)>(*tokAuxSurf); 10994 } break; 10995 case TOK_FBD_GMM_TEXTURE_INFO_REC__DEPTH: { 10996 dst.GmmResourceInfoCommon.AuxSurf.Depth = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Depth)>(*tokAuxSurf); 10997 } break; 10998 case TOK_FBD_GMM_TEXTURE_INFO_REC__MAX_LOD: { 10999 dst.GmmResourceInfoCommon.AuxSurf.MaxLod = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.MaxLod)>(*tokAuxSurf); 11000 } break; 11001 case TOK_FBD_GMM_TEXTURE_INFO_REC__ARRAY_SIZE: { 11002 dst.GmmResourceInfoCommon.AuxSurf.ArraySize = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.ArraySize)>(*tokAuxSurf); 11003 } break; 11004 case TOK_FBD_GMM_TEXTURE_INFO_REC__CP_TAG: { 11005 dst.GmmResourceInfoCommon.AuxSurf.CpTag = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.CpTag)>(*tokAuxSurf); 11006 } break; 11007 case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_MODE: { 11008 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokAuxSurf).getValue<char>(); 11009 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokAuxSurf).getValueSizeInBytes(); 11010 if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSurf.MmcMode)) { 11011 return false; 11012 } 11013 WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.MmcMode, sizeof(dst.GmmResourceInfoCommon.AuxSurf.MmcMode), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSurf.MmcMode)); 11014 } break; 11015 case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_HINT: { 11016 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokAuxSurf).getValue<char>(); 11017 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokAuxSurf).getValueSizeInBytes(); 11018 if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSurf.MmcHint)) { 11019 return false; 11020 } 11021 WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.MmcHint, sizeof(dst.GmmResourceInfoCommon.AuxSurf.MmcHint), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSurf.MmcHint)); 11022 } break; 11023 case TOK_FBQ_GMM_TEXTURE_INFO_REC__PITCH: { 11024 dst.GmmResourceInfoCommon.AuxSurf.Pitch = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Pitch)>(*tokAuxSurf); 11025 } break; 11026 case TOK_FBQ_GMM_TEXTURE_INFO_REC__OVERRIDE_PITCH: { 11027 dst.GmmResourceInfoCommon.AuxSurf.OverridePitch = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.OverridePitch)>(*tokAuxSurf); 11028 } break; 11029 case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE: { 11030 dst.GmmResourceInfoCommon.AuxSurf.Size = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Size)>(*tokAuxSurf); 11031 } break; 11032 case TOK_FBQ_GMM_TEXTURE_INFO_REC__CCSIZE: { 11033 dst.GmmResourceInfoCommon.AuxSurf.CCSize = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.CCSize)>(*tokAuxSurf); 11034 } break; 11035 case TOK_FBQ_GMM_TEXTURE_INFO_REC__UNPADDED_SIZE: { 11036 dst.GmmResourceInfoCommon.AuxSurf.UnpaddedSize = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.UnpaddedSize)>(*tokAuxSurf); 11037 } break; 11038 case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE_REPORT_TO_OS: { 11039 dst.GmmResourceInfoCommon.AuxSurf.SizeReportToOS = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.SizeReportToOS)>(*tokAuxSurf); 11040 } break; 11041 case TOK_FE_GMM_TEXTURE_INFO_REC__TILE_MODE: { 11042 dst.GmmResourceInfoCommon.AuxSurf.TileMode = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.TileMode)>(*tokAuxSurf); 11043 } break; 11044 case TOK_FBD_GMM_TEXTURE_INFO_REC__CCSMODE_ALIGN: { 11045 dst.GmmResourceInfoCommon.AuxSurf.CCSModeAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.CCSModeAlign)>(*tokAuxSurf); 11046 } break; 11047 case TOK_FBD_GMM_TEXTURE_INFO_REC__LEGACY_FLAGS: { 11048 dst.GmmResourceInfoCommon.AuxSurf.LegacyFlags = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.LegacyFlags)>(*tokAuxSurf); 11049 } break; 11050 case TOK_FBD_GMM_TEXTURE_INFO_REC__MAXIMUM_RENAMING_LIST_LENGTH: { 11051 dst.GmmResourceInfoCommon.AuxSurf.MaximumRenamingListLength = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.MaximumRenamingListLength)>(*tokAuxSurf); 11052 } break; 11053 }; 11054 tokAuxSurf = tokAuxSurf + 1 + tokAuxSurf->valueDwordCount; 11055 } else { 11056 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokAuxSurf); 11057 switch (tokAuxSurf->id) { 11058 default: 11059 if (tokAuxSurf->flags.flag3IsMandatory) { 11060 return false; 11061 } 11062 break; 11063 case TOK_FS_GMM_TEXTURE_INFO_REC__FLAGS: { 11064 const TokenHeader *tokFlags = varLen->getValue<TokenHeader>(); 11065 const TokenHeader *tokFlagsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 11066 while (tokFlags < tokFlagsEnd) { 11067 if (false == tokFlags->flags.flag4IsVariableLength) { 11068 if (tokFlags->flags.flag3IsMandatory) { 11069 return false; 11070 } 11071 tokFlags = tokFlags + 1 + tokFlags->valueDwordCount; 11072 } else { 11073 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokFlags); 11074 switch (tokFlags->id) { 11075 default: 11076 if (tokFlags->flags.flag3IsMandatory) { 11077 return false; 11078 } 11079 break; 11080 case TOK_FS_GMM_RESOURCE_FLAG_REC__GPU: { 11081 const TokenHeader *tokGpu = varLen->getValue<TokenHeader>(); 11082 const TokenHeader *tokGpuEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 11083 while (tokGpu < tokGpuEnd) { 11084 if (false == tokGpu->flags.flag4IsVariableLength) { 11085 switch (tokGpu->id) { 11086 default: 11087 if (tokGpu->flags.flag3IsMandatory) { 11088 return false; 11089 } 11090 break; 11091 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CAMERA_CAPTURE: { 11092 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.CameraCapture = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.CameraCapture)>(*tokGpu); 11093 } break; 11094 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CCS: { 11095 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.CCS = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.CCS)>(*tokGpu); 11096 } break; 11097 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_DISCARD: { 11098 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ColorDiscard = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ColorDiscard)>(*tokGpu); 11099 } break; 11100 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION: { 11101 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ColorSeparation = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ColorSeparation)>(*tokGpu); 11102 } break; 11103 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION_RGBX: { 11104 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ColorSeparationRGBX = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ColorSeparationRGBX)>(*tokGpu); 11105 } break; 11106 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CONSTANT: { 11107 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Constant = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Constant)>(*tokGpu); 11108 } break; 11109 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__DEPTH: { 11110 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Depth = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Depth)>(*tokGpu); 11111 } break; 11112 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN: { 11113 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.FlipChain = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.FlipChain)>(*tokGpu); 11114 } break; 11115 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN_PREFERRED: { 11116 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.FlipChainPreferred = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.FlipChainPreferred)>(*tokGpu); 11117 } break; 11118 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HISTORY_BUFFER: { 11119 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.HistoryBuffer = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.HistoryBuffer)>(*tokGpu); 11120 } break; 11121 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HI_Z: { 11122 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.HiZ = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.HiZ)>(*tokGpu); 11123 } break; 11124 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDEX: { 11125 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Index = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Index)>(*tokGpu); 11126 } break; 11127 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDIRECT_CLEAR_COLOR: { 11128 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.IndirectClearColor = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.IndirectClearColor)>(*tokGpu); 11129 } break; 11130 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INSTRUCTION_FLAT: { 11131 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.InstructionFlat = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.InstructionFlat)>(*tokGpu); 11132 } break; 11133 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INTERLACED_SCAN: { 11134 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.InterlacedScan = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.InterlacedScan)>(*tokGpu); 11135 } break; 11136 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MCS: { 11137 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.MCS = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.MCS)>(*tokGpu); 11138 } break; 11139 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MMC: { 11140 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.MMC = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.MMC)>(*tokGpu); 11141 } break; 11142 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MOTION_COMP: { 11143 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.MotionComp = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.MotionComp)>(*tokGpu); 11144 } break; 11145 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__NO_RESTRICTION: { 11146 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.NoRestriction = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.NoRestriction)>(*tokGpu); 11147 } break; 11148 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__OVERLAY: { 11149 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Overlay = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Overlay)>(*tokGpu); 11150 } break; 11151 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PRESENTABLE: { 11152 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Presentable = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Presentable)>(*tokGpu); 11153 } break; 11154 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PROCEDURAL_TEXTURE: { 11155 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ProceduralTexture = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ProceduralTexture)>(*tokGpu); 11156 } break; 11157 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__QUERY: { 11158 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Query = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Query)>(*tokGpu); 11159 } break; 11160 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__RENDER_TARGET: { 11161 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.RenderTarget = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.RenderTarget)>(*tokGpu); 11162 } break; 11163 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D: { 11164 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.S3d = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.S3d)>(*tokGpu); 11165 } break; 11166 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D_DX: { 11167 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.S3dDx = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.S3dDx)>(*tokGpu); 11168 } break; 11169 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_NON_PACKED: { 11170 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__S3dNonPacked = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__S3dNonPacked)>(*tokGpu); 11171 } break; 11172 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_WIDI: { 11173 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__S3dWidi = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__S3dWidi)>(*tokGpu); 11174 } break; 11175 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SCRATCH_FLAT: { 11176 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ScratchFlat = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ScratchFlat)>(*tokGpu); 11177 } break; 11178 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SEPARATE_STENCIL: { 11179 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.SeparateStencil = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.SeparateStencil)>(*tokGpu); 11180 } break; 11181 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE: { 11182 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.State = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.State)>(*tokGpu); 11183 } break; 11184 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE_DX9CONSTANT_BUFFER: { 11185 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.StateDx9ConstantBuffer = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.StateDx9ConstantBuffer)>(*tokGpu); 11186 } break; 11187 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STREAM: { 11188 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Stream = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Stream)>(*tokGpu); 11189 } break; 11190 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXT_API: { 11191 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.TextApi = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.TextApi)>(*tokGpu); 11192 } break; 11193 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXTURE: { 11194 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Texture = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Texture)>(*tokGpu); 11195 } break; 11196 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILED_RESOURCE: { 11197 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.TiledResource = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.TiledResource)>(*tokGpu); 11198 } break; 11199 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILE_POOL: { 11200 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.TilePool = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.TilePool)>(*tokGpu); 11201 } break; 11202 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__UNIFIED_AUX_SURFACE: { 11203 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.UnifiedAuxSurface = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.UnifiedAuxSurface)>(*tokGpu); 11204 } break; 11205 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VERTEX: { 11206 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Vertex = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Vertex)>(*tokGpu); 11207 } break; 11208 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VIDEO: { 11209 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Video = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Video)>(*tokGpu); 11210 } break; 11211 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_XCCS: { 11212 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__NonMsaaTileXCcs = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__NonMsaaTileXCcs)>(*tokGpu); 11213 } break; 11214 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_YCCS: { 11215 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__NonMsaaTileYCcs = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__NonMsaaTileYCcs)>(*tokGpu); 11216 } break; 11217 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____MSAA_TILE_MCS: { 11218 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__MsaaTileMcs = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__MsaaTileMcs)>(*tokGpu); 11219 } break; 11220 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_LINEAR_CCS: { 11221 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__NonMsaaLinearCCS = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__NonMsaaLinearCCS)>(*tokGpu); 11222 } break; 11223 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____REMAINING: { 11224 dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__Remaining = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__Remaining)>(*tokGpu); 11225 } break; 11226 }; 11227 tokGpu = tokGpu + 1 + tokGpu->valueDwordCount; 11228 } else { 11229 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokGpu); 11230 if (tokGpu->flags.flag3IsMandatory) { 11231 return false; 11232 } 11233 tokGpu = tokGpu + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 11234 } 11235 } 11236 WCH_ASSERT(tokGpu == tokGpuEnd); 11237 } break; 11238 case TOK_FS_GMM_RESOURCE_FLAG_REC__INFO: { 11239 const TokenHeader *tokInfo = varLen->getValue<TokenHeader>(); 11240 const TokenHeader *tokInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 11241 while (tokInfo < tokInfoEnd) { 11242 if (false == tokInfo->flags.flag4IsVariableLength) { 11243 switch (tokInfo->id) { 11244 default: 11245 if (tokInfo->flags.flag3IsMandatory) { 11246 return false; 11247 } 11248 break; 11249 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ALLOW_VIRTUAL_PADDING: { 11250 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.AllowVirtualPadding = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.AllowVirtualPadding)>(*tokInfo); 11251 } break; 11252 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__BIG_PAGE: { 11253 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.BigPage = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.BigPage)>(*tokInfo); 11254 } break; 11255 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CACHEABLE: { 11256 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Cacheable = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Cacheable)>(*tokInfo); 11257 } break; 11258 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CONTIG_PHYS_MEMORY_FORI_DART: { 11259 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.ContigPhysMemoryForiDART = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.ContigPhysMemoryForiDART)>(*tokInfo); 11260 } break; 11261 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CORNER_TEXEL_MODE: { 11262 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.CornerTexelMode = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.CornerTexelMode)>(*tokInfo); 11263 } break; 11264 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__EXISTING_SYS_MEM: { 11265 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.ExistingSysMem = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.ExistingSysMem)>(*tokInfo); 11266 } break; 11267 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__FORCE_RESIDENCY: { 11268 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.ForceResidency = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.ForceResidency)>(*tokInfo); 11269 } break; 11270 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GFDT: { 11271 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Gfdt = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Gfdt)>(*tokInfo); 11272 } break; 11273 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GTT_MAP_TYPE: { 11274 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.GttMapType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.GttMapType)>(*tokInfo); 11275 } break; 11276 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__HARDWARE_PROTECTED: { 11277 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.HardwareProtected = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.HardwareProtected)>(*tokInfo); 11278 } break; 11279 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__KERNEL_MODE_MAPPED: { 11280 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.KernelModeMapped = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.KernelModeMapped)>(*tokInfo); 11281 } break; 11282 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_BELOW: { 11283 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.LayoutBelow = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.LayoutBelow)>(*tokInfo); 11284 } break; 11285 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_MONO: { 11286 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.LayoutMono = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.LayoutMono)>(*tokInfo); 11287 } break; 11288 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_RIGHT: { 11289 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.LayoutRight = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.LayoutRight)>(*tokInfo); 11290 } break; 11291 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LOCAL_ONLY: { 11292 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.LocalOnly = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.LocalOnly)>(*tokInfo); 11293 } break; 11294 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LINEAR: { 11295 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Linear = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Linear)>(*tokInfo); 11296 } break; 11297 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__MEDIA_COMPRESSED: { 11298 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.MediaCompressed = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.MediaCompressed)>(*tokInfo); 11299 } break; 11300 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_OPTIMIZATION_PADDING: { 11301 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.NoOptimizationPadding = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.NoOptimizationPadding)>(*tokInfo); 11302 } break; 11303 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_PHYS_MEMORY: { 11304 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.NoPhysMemory = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.NoPhysMemory)>(*tokInfo); 11305 } break; 11306 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NOT_LOCKABLE: { 11307 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.NotLockable = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.NotLockable)>(*tokInfo); 11308 } break; 11309 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NON_LOCAL_ONLY: { 11310 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.NonLocalOnly = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.NonLocalOnly)>(*tokInfo); 11311 } break; 11312 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__STD_SWIZZLE: { 11313 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.StdSwizzle = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.StdSwizzle)>(*tokInfo); 11314 } break; 11315 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__PSEUDO_STD_SWIZZLE: { 11316 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.PseudoStdSwizzle = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.PseudoStdSwizzle)>(*tokInfo); 11317 } break; 11318 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__UNDEFINED64KBSWIZZLE: { 11319 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Undefined64KBSwizzle = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Undefined64KBSwizzle)>(*tokInfo); 11320 } break; 11321 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__REDECRIBED_PLANES: { 11322 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.RedecribedPlanes = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.RedecribedPlanes)>(*tokInfo); 11323 } break; 11324 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__RENDER_COMPRESSED: { 11325 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.RenderCompressed = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.RenderCompressed)>(*tokInfo); 11326 } break; 11327 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ROTATED: { 11328 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Rotated = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Rotated)>(*tokInfo); 11329 } break; 11330 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SHARED: { 11331 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Shared = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Shared)>(*tokInfo); 11332 } break; 11333 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SOFTWARE_PROTECTED: { 11334 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.SoftwareProtected = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.SoftwareProtected)>(*tokInfo); 11335 } break; 11336 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SVM: { 11337 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.SVM = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.SVM)>(*tokInfo); 11338 } break; 11339 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE4: { 11340 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Tile4 = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Tile4)>(*tokInfo); 11341 } break; 11342 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE64: { 11343 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Tile64 = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Tile64)>(*tokInfo); 11344 } break; 11345 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_W: { 11346 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledW = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledW)>(*tokInfo); 11347 } break; 11348 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_X: { 11349 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledX = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledX)>(*tokInfo); 11350 } break; 11351 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_Y: { 11352 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledY = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledY)>(*tokInfo); 11353 } break; 11354 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YF: { 11355 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledYf = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledYf)>(*tokInfo); 11356 } break; 11357 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YS: { 11358 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledYs = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledYs)>(*tokInfo); 11359 } break; 11360 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__WDDM_PROTECTED: { 11361 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.WddmProtected = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.WddmProtected)>(*tokInfo); 11362 } break; 11363 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__XADAPTER: { 11364 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.XAdapter = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.XAdapter)>(*tokInfo); 11365 } break; 11366 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PREALLOCATED_RES_INFO: { 11367 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.__PreallocatedResInfo = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.__PreallocatedResInfo)>(*tokInfo); 11368 } break; 11369 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PRE_WDDM2SVM: { 11370 dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.__PreWddm2SVM = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.__PreWddm2SVM)>(*tokInfo); 11371 } break; 11372 }; 11373 tokInfo = tokInfo + 1 + tokInfo->valueDwordCount; 11374 } else { 11375 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInfo); 11376 if (tokInfo->flags.flag3IsMandatory) { 11377 return false; 11378 } 11379 tokInfo = tokInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 11380 } 11381 } 11382 WCH_ASSERT(tokInfo == tokInfoEnd); 11383 } break; 11384 case TOK_FS_GMM_RESOURCE_FLAG_REC__WA: { 11385 const TokenHeader *tokWa = varLen->getValue<TokenHeader>(); 11386 const TokenHeader *tokWaEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 11387 while (tokWa < tokWaEnd) { 11388 if (false == tokWa->flags.flag4IsVariableLength) { 11389 switch (tokWa->id) { 11390 default: 11391 if (tokWa->flags.flag3IsMandatory) { 11392 return false; 11393 } 11394 break; 11395 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__GTMFX2ND_LEVEL_BATCH_RING_SIZE_ALIGN: { 11396 dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign)>(*tokWa); 11397 } break; 11398 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_MPR_ROW_STORE32KALIGN: { 11399 dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign)>(*tokWa); 11400 } break; 11401 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_DMV_BUFFER32KALIGN: { 11402 dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign)>(*tokWa); 11403 } break; 11404 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_BUFFER_SAMPLER_PADDING: { 11405 dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.NoBufferSamplerPadding = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.NoBufferSamplerPadding)>(*tokWa); 11406 } break; 11407 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_LEGACY_PLANAR_LINEAR_VIDEO_RESTRICTIONS: { 11408 dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions)>(*tokWa); 11409 } break; 11410 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__CHVASTC_SKIP_VIRTUAL_MIPS: { 11411 dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.CHVAstcSkipVirtualMips = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.CHVAstcSkipVirtualMips)>(*tokWa); 11412 } break; 11413 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_PACKED_MIP_TAIL: { 11414 dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DisablePackedMipTail = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DisablePackedMipTail)>(*tokWa); 11415 } break; 11416 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521____FORCE_OTHER_HVALIGN4: { 11417 dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.__ForceOtherHVALIGN4 = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.__ForceOtherHVALIGN4)>(*tokWa); 11418 } break; 11419 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR: { 11420 dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DisableDisplayCcsClearColor = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DisableDisplayCcsClearColor)>(*tokWa); 11421 } break; 11422 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION: { 11423 dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DisableDisplayCcsCompression = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DisableDisplayCcsCompression)>(*tokWa); 11424 } break; 11425 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: { 11426 dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.PreGen12FastClearOnly = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.PreGen12FastClearOnly)>(*tokWa); 11427 } break; 11428 }; 11429 tokWa = tokWa + 1 + tokWa->valueDwordCount; 11430 } else { 11431 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokWa); 11432 if (tokWa->flags.flag3IsMandatory) { 11433 return false; 11434 } 11435 tokWa = tokWa + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 11436 } 11437 } 11438 WCH_ASSERT(tokWa == tokWaEnd); 11439 } break; 11440 }; 11441 tokFlags = tokFlags + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 11442 } 11443 } 11444 WCH_ASSERT(tokFlags == tokFlagsEnd); 11445 } break; 11446 case TOK_FS_GMM_TEXTURE_INFO_REC__CACHE_POLICY: { 11447 const TokenHeader *tokCachePolicy = varLen->getValue<TokenHeader>(); 11448 const TokenHeader *tokCachePolicyEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 11449 while (tokCachePolicy < tokCachePolicyEnd) { 11450 if (false == tokCachePolicy->flags.flag4IsVariableLength) { 11451 switch (tokCachePolicy->id) { 11452 default: 11453 if (tokCachePolicy->flags.flag3IsMandatory) { 11454 return false; 11455 } 11456 break; 11457 case TOK_FE_GMM_TEXTURE_INFO_REC__ANONYMOUS4927__USAGE: { 11458 dst.GmmResourceInfoCommon.AuxSurf.CachePolicy.Usage = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.CachePolicy.Usage)>(*tokCachePolicy); 11459 } break; 11460 }; 11461 tokCachePolicy = tokCachePolicy + 1 + tokCachePolicy->valueDwordCount; 11462 } else { 11463 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCachePolicy); 11464 if (tokCachePolicy->flags.flag3IsMandatory) { 11465 return false; 11466 } 11467 tokCachePolicy = tokCachePolicy + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 11468 } 11469 } 11470 WCH_ASSERT(tokCachePolicy == tokCachePolicyEnd); 11471 } break; 11472 case TOK_FS_GMM_TEXTURE_INFO_REC__MSAA: { 11473 const TokenHeader *tokMSAA = varLen->getValue<TokenHeader>(); 11474 const TokenHeader *tokMSAAEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 11475 while (tokMSAA < tokMSAAEnd) { 11476 if (false == tokMSAA->flags.flag4IsVariableLength) { 11477 switch (tokMSAA->id) { 11478 default: 11479 if (tokMSAA->flags.flag3IsMandatory) { 11480 return false; 11481 } 11482 break; 11483 case TOK_FE_GMM_RESOURCE_MSAA_INFO_REC__SAMPLE_PATTERN: { 11484 dst.GmmResourceInfoCommon.AuxSurf.MSAA.SamplePattern = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.MSAA.SamplePattern)>(*tokMSAA); 11485 } break; 11486 case TOK_FBD_GMM_RESOURCE_MSAA_INFO_REC__NUM_SAMPLES: { 11487 dst.GmmResourceInfoCommon.AuxSurf.MSAA.NumSamples = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.MSAA.NumSamples)>(*tokMSAA); 11488 } break; 11489 }; 11490 tokMSAA = tokMSAA + 1 + tokMSAA->valueDwordCount; 11491 } else { 11492 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokMSAA); 11493 if (tokMSAA->flags.flag3IsMandatory) { 11494 return false; 11495 } 11496 tokMSAA = tokMSAA + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 11497 } 11498 } 11499 WCH_ASSERT(tokMSAA == tokMSAAEnd); 11500 } break; 11501 case TOK_FS_GMM_TEXTURE_INFO_REC__ALIGNMENT: { 11502 const TokenHeader *tokAlignment = varLen->getValue<TokenHeader>(); 11503 const TokenHeader *tokAlignmentEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 11504 while (tokAlignment < tokAlignmentEnd) { 11505 if (false == tokAlignment->flags.flag4IsVariableLength) { 11506 switch (tokAlignment->id) { 11507 default: 11508 if (tokAlignment->flags.flag3IsMandatory) { 11509 return false; 11510 } 11511 break; 11512 case TOK_FBC_GMM_RESOURCE_ALIGNMENT_REC__ARRAY_SPACING_SINGLE_LOD: { 11513 dst.GmmResourceInfoCommon.AuxSurf.Alignment.ArraySpacingSingleLod = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Alignment.ArraySpacingSingleLod)>(*tokAlignment); 11514 } break; 11515 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__BASE_ALIGNMENT: { 11516 dst.GmmResourceInfoCommon.AuxSurf.Alignment.BaseAlignment = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Alignment.BaseAlignment)>(*tokAlignment); 11517 } break; 11518 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__HALIGN: { 11519 dst.GmmResourceInfoCommon.AuxSurf.Alignment.HAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Alignment.HAlign)>(*tokAlignment); 11520 } break; 11521 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__VALIGN: { 11522 dst.GmmResourceInfoCommon.AuxSurf.Alignment.VAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Alignment.VAlign)>(*tokAlignment); 11523 } break; 11524 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__DALIGN: { 11525 dst.GmmResourceInfoCommon.AuxSurf.Alignment.DAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Alignment.DAlign)>(*tokAlignment); 11526 } break; 11527 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__MIP_TAIL_START_LOD: { 11528 dst.GmmResourceInfoCommon.AuxSurf.Alignment.MipTailStartLod = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Alignment.MipTailStartLod)>(*tokAlignment); 11529 } break; 11530 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_START_LOD: { 11531 dst.GmmResourceInfoCommon.AuxSurf.Alignment.PackedMipStartLod = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Alignment.PackedMipStartLod)>(*tokAlignment); 11532 } break; 11533 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_WIDTH: { 11534 dst.GmmResourceInfoCommon.AuxSurf.Alignment.PackedMipWidth = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Alignment.PackedMipWidth)>(*tokAlignment); 11535 } break; 11536 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_HEIGHT: { 11537 dst.GmmResourceInfoCommon.AuxSurf.Alignment.PackedMipHeight = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Alignment.PackedMipHeight)>(*tokAlignment); 11538 } break; 11539 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__QPITCH: { 11540 dst.GmmResourceInfoCommon.AuxSurf.Alignment.QPitch = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Alignment.QPitch)>(*tokAlignment); 11541 } break; 11542 }; 11543 tokAlignment = tokAlignment + 1 + tokAlignment->valueDwordCount; 11544 } else { 11545 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokAlignment); 11546 if (tokAlignment->flags.flag3IsMandatory) { 11547 return false; 11548 } 11549 tokAlignment = tokAlignment + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 11550 } 11551 } 11552 WCH_ASSERT(tokAlignment == tokAlignmentEnd); 11553 } break; 11554 case TOK_FS_GMM_TEXTURE_INFO_REC__OFFSET_INFO: { 11555 const TokenHeader *tokOffsetInfo = varLen->getValue<TokenHeader>(); 11556 const TokenHeader *tokOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 11557 while (tokOffsetInfo < tokOffsetInfoEnd) { 11558 if (false == tokOffsetInfo->flags.flag4IsVariableLength) { 11559 if (tokOffsetInfo->flags.flag3IsMandatory) { 11560 return false; 11561 } 11562 tokOffsetInfo = tokOffsetInfo + 1 + tokOffsetInfo->valueDwordCount; 11563 } else { 11564 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokOffsetInfo); 11565 switch (tokOffsetInfo->id) { 11566 default: 11567 if (tokOffsetInfo->flags.flag3IsMandatory) { 11568 return false; 11569 } 11570 break; 11571 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO: { 11572 const TokenHeader *tokTexture3DOffsetInfo = varLen->getValue<TokenHeader>(); 11573 const TokenHeader *tokTexture3DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 11574 while (tokTexture3DOffsetInfo < tokTexture3DOffsetInfoEnd) { 11575 if (false == tokTexture3DOffsetInfo->flags.flag4IsVariableLength) { 11576 switch (tokTexture3DOffsetInfo->id) { 11577 default: 11578 if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { 11579 return false; 11580 } 11581 break; 11582 case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: { 11583 dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch)>(*tokTexture3DOffsetInfo); 11584 } break; 11585 case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: { 11586 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValue<char>(); 11587 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValueSizeInBytes(); 11588 if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset)) { 11589 return false; 11590 } 11591 WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset)); 11592 } break; 11593 }; 11594 tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + 1 + tokTexture3DOffsetInfo->valueDwordCount; 11595 } else { 11596 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture3DOffsetInfo); 11597 if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { 11598 return false; 11599 } 11600 tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 11601 } 11602 } 11603 WCH_ASSERT(tokTexture3DOffsetInfo == tokTexture3DOffsetInfoEnd); 11604 } break; 11605 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO: { 11606 const TokenHeader *tokTexture2DOffsetInfo = varLen->getValue<TokenHeader>(); 11607 const TokenHeader *tokTexture2DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 11608 while (tokTexture2DOffsetInfo < tokTexture2DOffsetInfoEnd) { 11609 if (false == tokTexture2DOffsetInfo->flags.flag4IsVariableLength) { 11610 switch (tokTexture2DOffsetInfo->id) { 11611 default: 11612 if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { 11613 return false; 11614 } 11615 break; 11616 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: { 11617 dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock)>(*tokTexture2DOffsetInfo); 11618 } break; 11619 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: { 11620 dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender)>(*tokTexture2DOffsetInfo); 11621 } break; 11622 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: { 11623 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValue<char>(); 11624 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValueSizeInBytes(); 11625 if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset)) { 11626 return false; 11627 } 11628 WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset)); 11629 } break; 11630 }; 11631 tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + 1 + tokTexture2DOffsetInfo->valueDwordCount; 11632 } else { 11633 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture2DOffsetInfo); 11634 if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { 11635 return false; 11636 } 11637 tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 11638 } 11639 } 11640 WCH_ASSERT(tokTexture2DOffsetInfo == tokTexture2DOffsetInfoEnd); 11641 } break; 11642 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE: { 11643 const TokenHeader *tokPlane = varLen->getValue<TokenHeader>(); 11644 const TokenHeader *tokPlaneEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 11645 while (tokPlane < tokPlaneEnd) { 11646 if (false == tokPlane->flags.flag4IsVariableLength) { 11647 switch (tokPlane->id) { 11648 default: 11649 if (tokPlane->flags.flag3IsMandatory) { 11650 return false; 11651 } 11652 break; 11653 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: { 11654 dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.ArrayQPitch = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.ArrayQPitch)>(*tokPlane); 11655 } break; 11656 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: { 11657 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>(); 11658 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes(); 11659 if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.X)) { 11660 return false; 11661 } 11662 WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.X, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.X), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.X)); 11663 } break; 11664 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: { 11665 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>(); 11666 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes(); 11667 if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.Y)) { 11668 return false; 11669 } 11670 WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.Y, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.Y), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.Y)); 11671 } break; 11672 case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: { 11673 dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.NoOfPlanes = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.NoOfPlanes)>(*tokPlane); 11674 } break; 11675 case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: { 11676 dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.IsTileAlignedPlanes = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.IsTileAlignedPlanes)>(*tokPlane); 11677 } break; 11678 }; 11679 tokPlane = tokPlane + 1 + tokPlane->valueDwordCount; 11680 } else { 11681 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlane); 11682 switch (tokPlane->id) { 11683 default: 11684 if (tokPlane->flags.flag3IsMandatory) { 11685 return false; 11686 } 11687 break; 11688 case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: { 11689 const TokenHeader *tokUnAligned = varLen->getValue<TokenHeader>(); 11690 const TokenHeader *tokUnAlignedEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 11691 while (tokUnAligned < tokUnAlignedEnd) { 11692 if (false == tokUnAligned->flags.flag4IsVariableLength) { 11693 switch (tokUnAligned->id) { 11694 default: 11695 if (tokUnAligned->flags.flag3IsMandatory) { 11696 return false; 11697 } 11698 break; 11699 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: { 11700 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValue<char>(); 11701 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValueSizeInBytes(); 11702 if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.UnAligned.Height)) { 11703 return false; 11704 } 11705 WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.UnAligned.Height, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.UnAligned.Height), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.UnAligned.Height)); 11706 } break; 11707 }; 11708 tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount; 11709 } else { 11710 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokUnAligned); 11711 if (tokUnAligned->flags.flag3IsMandatory) { 11712 return false; 11713 } 11714 tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 11715 } 11716 } 11717 WCH_ASSERT(tokUnAligned == tokUnAlignedEnd); 11718 } break; 11719 }; 11720 tokPlane = tokPlane + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 11721 } 11722 } 11723 WCH_ASSERT(tokPlane == tokPlaneEnd); 11724 } break; 11725 }; 11726 tokOffsetInfo = tokOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 11727 } 11728 } 11729 WCH_ASSERT(tokOffsetInfo == tokOffsetInfoEnd); 11730 } break; 11731 case TOK_FS_GMM_TEXTURE_INFO_REC__S3D: { 11732 const TokenHeader *tokS3d = varLen->getValue<TokenHeader>(); 11733 const TokenHeader *tokS3dEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 11734 while (tokS3d < tokS3dEnd) { 11735 if (false == tokS3d->flags.flag4IsVariableLength) { 11736 switch (tokS3d->id) { 11737 default: 11738 if (tokS3d->flags.flag3IsMandatory) { 11739 return false; 11740 } 11741 break; 11742 case TOK_FBD_GMM_S3D_INFO_REC__DISPLAY_MODE_HEIGHT: { 11743 dst.GmmResourceInfoCommon.AuxSurf.S3d.DisplayModeHeight = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.S3d.DisplayModeHeight)>(*tokS3d); 11744 } break; 11745 case TOK_FBD_GMM_S3D_INFO_REC__NUM_BLANK_ACTIVE_LINES: { 11746 dst.GmmResourceInfoCommon.AuxSurf.S3d.NumBlankActiveLines = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.S3d.NumBlankActiveLines)>(*tokS3d); 11747 } break; 11748 case TOK_FBD_GMM_S3D_INFO_REC__RFRAME_OFFSET: { 11749 dst.GmmResourceInfoCommon.AuxSurf.S3d.RFrameOffset = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.S3d.RFrameOffset)>(*tokS3d); 11750 } break; 11751 case TOK_FBD_GMM_S3D_INFO_REC__BLANK_AREA_OFFSET: { 11752 dst.GmmResourceInfoCommon.AuxSurf.S3d.BlankAreaOffset = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.S3d.BlankAreaOffset)>(*tokS3d); 11753 } break; 11754 case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_HEIGHT: { 11755 dst.GmmResourceInfoCommon.AuxSurf.S3d.TallBufferHeight = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.S3d.TallBufferHeight)>(*tokS3d); 11756 } break; 11757 case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_SIZE: { 11758 dst.GmmResourceInfoCommon.AuxSurf.S3d.TallBufferSize = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.S3d.TallBufferSize)>(*tokS3d); 11759 } break; 11760 case TOK_FBC_GMM_S3D_INFO_REC__IS_RFRAME: { 11761 dst.GmmResourceInfoCommon.AuxSurf.S3d.IsRFrame = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.S3d.IsRFrame)>(*tokS3d); 11762 } break; 11763 }; 11764 tokS3d = tokS3d + 1 + tokS3d->valueDwordCount; 11765 } else { 11766 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokS3d); 11767 if (tokS3d->flags.flag3IsMandatory) { 11768 return false; 11769 } 11770 tokS3d = tokS3d + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 11771 } 11772 } 11773 WCH_ASSERT(tokS3d == tokS3dEnd); 11774 } break; 11775 case TOK_FS_GMM_TEXTURE_INFO_REC__SEGMENT_OVERRIDE: { 11776 const TokenHeader *tokSegmentOverride = varLen->getValue<TokenHeader>(); 11777 const TokenHeader *tokSegmentOverrideEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 11778 while (tokSegmentOverride < tokSegmentOverrideEnd) { 11779 if (false == tokSegmentOverride->flags.flag4IsVariableLength) { 11780 switch (tokSegmentOverride->id) { 11781 default: 11782 if (tokSegmentOverride->flags.flag3IsMandatory) { 11783 return false; 11784 } 11785 break; 11786 case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__SEG1: { 11787 dst.GmmResourceInfoCommon.AuxSurf.SegmentOverride.Seg1 = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.SegmentOverride.Seg1)>(*tokSegmentOverride); 11788 } break; 11789 case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__EVICT: { 11790 dst.GmmResourceInfoCommon.AuxSurf.SegmentOverride.Evict = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.SegmentOverride.Evict)>(*tokSegmentOverride); 11791 } break; 11792 }; 11793 tokSegmentOverride = tokSegmentOverride + 1 + tokSegmentOverride->valueDwordCount; 11794 } else { 11795 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSegmentOverride); 11796 if (tokSegmentOverride->flags.flag3IsMandatory) { 11797 return false; 11798 } 11799 tokSegmentOverride = tokSegmentOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 11800 } 11801 } 11802 WCH_ASSERT(tokSegmentOverride == tokSegmentOverrideEnd); 11803 } break; 11804 case TOK_FS_GMM_TEXTURE_INFO_REC__PLATFORM: { 11805 #if _DEBUG || _RELEASE_INTERNAL 11806 const TokenHeader *tokPlatform = varLen->getValue<TokenHeader>(); 11807 const TokenHeader *tokPlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 11808 while (tokPlatform < tokPlatformEnd) { 11809 if (false == tokPlatform->flags.flag4IsVariableLength) { 11810 switch (tokPlatform->id) { 11811 default: 11812 if (tokPlatform->flags.flag3IsMandatory) { 11813 return false; 11814 } 11815 break; 11816 case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { 11817 dst.GmmResourceInfoCommon.AuxSurf.Platform.eProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Platform.eProductFamily)>(*tokPlatform); 11818 } break; 11819 case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { 11820 dst.GmmResourceInfoCommon.AuxSurf.Platform.ePCHProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Platform.ePCHProductFamily)>(*tokPlatform); 11821 } break; 11822 case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { 11823 dst.GmmResourceInfoCommon.AuxSurf.Platform.eDisplayCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Platform.eDisplayCoreFamily)>(*tokPlatform); 11824 } break; 11825 case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { 11826 dst.GmmResourceInfoCommon.AuxSurf.Platform.eRenderCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Platform.eRenderCoreFamily)>(*tokPlatform); 11827 } break; 11828 case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { 11829 dst.GmmResourceInfoCommon.AuxSurf.Platform.ePlatformType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Platform.ePlatformType)>(*tokPlatform); 11830 } break; 11831 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { 11832 dst.GmmResourceInfoCommon.AuxSurf.Platform.usDeviceID = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Platform.usDeviceID)>(*tokPlatform); 11833 } break; 11834 case TOK_FBW_PLATFORM_STR__US_REV_ID: { 11835 dst.GmmResourceInfoCommon.AuxSurf.Platform.usRevId = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Platform.usRevId)>(*tokPlatform); 11836 } break; 11837 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { 11838 dst.GmmResourceInfoCommon.AuxSurf.Platform.usDeviceID_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Platform.usDeviceID_PCH)>(*tokPlatform); 11839 } break; 11840 case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { 11841 dst.GmmResourceInfoCommon.AuxSurf.Platform.usRevId_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Platform.usRevId_PCH)>(*tokPlatform); 11842 } break; 11843 case TOK_FE_PLATFORM_STR__E_GTTYPE: { 11844 dst.GmmResourceInfoCommon.AuxSurf.Platform.eGTType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Platform.eGTType)>(*tokPlatform); 11845 } break; 11846 }; 11847 tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount; 11848 } else { 11849 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlatform); 11850 if (tokPlatform->flags.flag3IsMandatory) { 11851 return false; 11852 } 11853 tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 11854 } 11855 } 11856 WCH_ASSERT(tokPlatform == tokPlatformEnd); 11857 #endif 11858 } break; 11859 case TOK_FS_GMM_TEXTURE_INFO_REC__EXISTING_SYS_MEM: { 11860 const TokenHeader *tokExistingSysMem = varLen->getValue<TokenHeader>(); 11861 const TokenHeader *tokExistingSysMemEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 11862 while (tokExistingSysMem < tokExistingSysMemEnd) { 11863 if (false == tokExistingSysMem->flags.flag4IsVariableLength) { 11864 switch (tokExistingSysMem->id) { 11865 default: 11866 if (tokExistingSysMem->flags.flag3IsMandatory) { 11867 return false; 11868 } 11869 break; 11870 case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_GMM_ALLOCATED: { 11871 dst.GmmResourceInfoCommon.AuxSurf.ExistingSysMem.IsGmmAllocated = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.ExistingSysMem.IsGmmAllocated)>(*tokExistingSysMem); 11872 } break; 11873 case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_PAGE_ALIGNED: { 11874 dst.GmmResourceInfoCommon.AuxSurf.ExistingSysMem.IsPageAligned = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.ExistingSysMem.IsPageAligned)>(*tokExistingSysMem); 11875 } break; 11876 }; 11877 tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount; 11878 } else { 11879 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokExistingSysMem); 11880 if (tokExistingSysMem->flags.flag3IsMandatory) { 11881 return false; 11882 } 11883 tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 11884 } 11885 } 11886 WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd); 11887 } break; 11888 case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: { 11889 #if !(_DEBUG || _RELEASE_INTERNAL) 11890 const TokenHeader *tok__Platform = varLen->getValue<TokenHeader>(); 11891 const TokenHeader *tok__PlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 11892 while (tok__Platform < tok__PlatformEnd) { 11893 if (false == tok__Platform->flags.flag4IsVariableLength) { 11894 switch (tok__Platform->id) { 11895 default: 11896 if (tok__Platform->flags.flag3IsMandatory) { 11897 return false; 11898 } 11899 break; 11900 case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { 11901 dst.GmmResourceInfoCommon.AuxSurf.__Platform.eProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.eProductFamily)>(*tok__Platform); 11902 } break; 11903 case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { 11904 dst.GmmResourceInfoCommon.AuxSurf.__Platform.ePCHProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.ePCHProductFamily)>(*tok__Platform); 11905 } break; 11906 case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { 11907 dst.GmmResourceInfoCommon.AuxSurf.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.eDisplayCoreFamily)>(*tok__Platform); 11908 } break; 11909 case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { 11910 dst.GmmResourceInfoCommon.AuxSurf.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.eRenderCoreFamily)>(*tok__Platform); 11911 } break; 11912 case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { 11913 dst.GmmResourceInfoCommon.AuxSurf.__Platform.ePlatformType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.ePlatformType)>(*tok__Platform); 11914 } break; 11915 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { 11916 dst.GmmResourceInfoCommon.AuxSurf.__Platform.usDeviceID = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.usDeviceID)>(*tok__Platform); 11917 } break; 11918 case TOK_FBW_PLATFORM_STR__US_REV_ID: { 11919 dst.GmmResourceInfoCommon.AuxSurf.__Platform.usRevId = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.usRevId)>(*tok__Platform); 11920 } break; 11921 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { 11922 dst.GmmResourceInfoCommon.AuxSurf.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.usDeviceID_PCH)>(*tok__Platform); 11923 } break; 11924 case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { 11925 dst.GmmResourceInfoCommon.AuxSurf.__Platform.usRevId_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.usRevId_PCH)>(*tok__Platform); 11926 } break; 11927 case TOK_FE_PLATFORM_STR__E_GTTYPE: { 11928 dst.GmmResourceInfoCommon.AuxSurf.__Platform.eGTType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.eGTType)>(*tok__Platform); 11929 } break; 11930 }; 11931 tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount; 11932 } else { 11933 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok__Platform); 11934 if (tok__Platform->flags.flag3IsMandatory) { 11935 return false; 11936 } 11937 tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 11938 } 11939 } 11940 WCH_ASSERT(tok__Platform == tok__PlatformEnd); 11941 #endif 11942 } break; 11943 }; 11944 tokAuxSurf = tokAuxSurf + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 11945 } 11946 } 11947 WCH_ASSERT(tokAuxSurf == tokAuxSurfEnd); 11948 } break; 11949 case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__AUX_SEC_SURF: { 11950 const TokenHeader *tokAuxSecSurf = varLen->getValue<TokenHeader>(); 11951 const TokenHeader *tokAuxSecSurfEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 11952 while (tokAuxSecSurf < tokAuxSecSurfEnd) { 11953 if (false == tokAuxSecSurf->flags.flag4IsVariableLength) { 11954 switch (tokAuxSecSurf->id) { 11955 default: 11956 if (tokAuxSecSurf->flags.flag3IsMandatory) { 11957 return false; 11958 } 11959 break; 11960 case TOK_FE_GMM_TEXTURE_INFO_REC__TYPE: { 11961 dst.GmmResourceInfoCommon.AuxSecSurf.Type = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Type)>(*tokAuxSecSurf); 11962 } break; 11963 case TOK_FE_GMM_TEXTURE_INFO_REC__FORMAT: { 11964 dst.GmmResourceInfoCommon.AuxSecSurf.Format = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Format)>(*tokAuxSecSurf); 11965 } break; 11966 case TOK_FBD_GMM_TEXTURE_INFO_REC__BITS_PER_PIXEL: { 11967 dst.GmmResourceInfoCommon.AuxSecSurf.BitsPerPixel = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.BitsPerPixel)>(*tokAuxSecSurf); 11968 } break; 11969 case TOK_FBQ_GMM_TEXTURE_INFO_REC__BASE_WIDTH: { 11970 dst.GmmResourceInfoCommon.AuxSecSurf.BaseWidth = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.BaseWidth)>(*tokAuxSecSurf); 11971 } break; 11972 case TOK_FBD_GMM_TEXTURE_INFO_REC__BASE_HEIGHT: { 11973 dst.GmmResourceInfoCommon.AuxSecSurf.BaseHeight = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.BaseHeight)>(*tokAuxSecSurf); 11974 } break; 11975 case TOK_FBD_GMM_TEXTURE_INFO_REC__DEPTH: { 11976 dst.GmmResourceInfoCommon.AuxSecSurf.Depth = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Depth)>(*tokAuxSecSurf); 11977 } break; 11978 case TOK_FBD_GMM_TEXTURE_INFO_REC__MAX_LOD: { 11979 dst.GmmResourceInfoCommon.AuxSecSurf.MaxLod = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.MaxLod)>(*tokAuxSecSurf); 11980 } break; 11981 case TOK_FBD_GMM_TEXTURE_INFO_REC__ARRAY_SIZE: { 11982 dst.GmmResourceInfoCommon.AuxSecSurf.ArraySize = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.ArraySize)>(*tokAuxSecSurf); 11983 } break; 11984 case TOK_FBD_GMM_TEXTURE_INFO_REC__CP_TAG: { 11985 dst.GmmResourceInfoCommon.AuxSecSurf.CpTag = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.CpTag)>(*tokAuxSecSurf); 11986 } break; 11987 case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_MODE: { 11988 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokAuxSecSurf).getValue<char>(); 11989 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokAuxSecSurf).getValueSizeInBytes(); 11990 if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.MmcMode)) { 11991 return false; 11992 } 11993 WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.MmcMode, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.MmcMode), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.MmcMode)); 11994 } break; 11995 case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_HINT: { 11996 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokAuxSecSurf).getValue<char>(); 11997 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokAuxSecSurf).getValueSizeInBytes(); 11998 if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.MmcHint)) { 11999 return false; 12000 } 12001 WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.MmcHint, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.MmcHint), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.MmcHint)); 12002 } break; 12003 case TOK_FBQ_GMM_TEXTURE_INFO_REC__PITCH: { 12004 dst.GmmResourceInfoCommon.AuxSecSurf.Pitch = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Pitch)>(*tokAuxSecSurf); 12005 } break; 12006 case TOK_FBQ_GMM_TEXTURE_INFO_REC__OVERRIDE_PITCH: { 12007 dst.GmmResourceInfoCommon.AuxSecSurf.OverridePitch = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.OverridePitch)>(*tokAuxSecSurf); 12008 } break; 12009 case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE: { 12010 dst.GmmResourceInfoCommon.AuxSecSurf.Size = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Size)>(*tokAuxSecSurf); 12011 } break; 12012 case TOK_FBQ_GMM_TEXTURE_INFO_REC__CCSIZE: { 12013 dst.GmmResourceInfoCommon.AuxSecSurf.CCSize = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.CCSize)>(*tokAuxSecSurf); 12014 } break; 12015 case TOK_FBQ_GMM_TEXTURE_INFO_REC__UNPADDED_SIZE: { 12016 dst.GmmResourceInfoCommon.AuxSecSurf.UnpaddedSize = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.UnpaddedSize)>(*tokAuxSecSurf); 12017 } break; 12018 case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE_REPORT_TO_OS: { 12019 dst.GmmResourceInfoCommon.AuxSecSurf.SizeReportToOS = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.SizeReportToOS)>(*tokAuxSecSurf); 12020 } break; 12021 case TOK_FE_GMM_TEXTURE_INFO_REC__TILE_MODE: { 12022 dst.GmmResourceInfoCommon.AuxSecSurf.TileMode = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.TileMode)>(*tokAuxSecSurf); 12023 } break; 12024 case TOK_FBD_GMM_TEXTURE_INFO_REC__CCSMODE_ALIGN: { 12025 dst.GmmResourceInfoCommon.AuxSecSurf.CCSModeAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.CCSModeAlign)>(*tokAuxSecSurf); 12026 } break; 12027 case TOK_FBD_GMM_TEXTURE_INFO_REC__LEGACY_FLAGS: { 12028 dst.GmmResourceInfoCommon.AuxSecSurf.LegacyFlags = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.LegacyFlags)>(*tokAuxSecSurf); 12029 } break; 12030 case TOK_FBD_GMM_TEXTURE_INFO_REC__MAXIMUM_RENAMING_LIST_LENGTH: { 12031 dst.GmmResourceInfoCommon.AuxSecSurf.MaximumRenamingListLength = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.MaximumRenamingListLength)>(*tokAuxSecSurf); 12032 } break; 12033 }; 12034 tokAuxSecSurf = tokAuxSecSurf + 1 + tokAuxSecSurf->valueDwordCount; 12035 } else { 12036 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokAuxSecSurf); 12037 switch (tokAuxSecSurf->id) { 12038 default: 12039 if (tokAuxSecSurf->flags.flag3IsMandatory) { 12040 return false; 12041 } 12042 break; 12043 case TOK_FS_GMM_TEXTURE_INFO_REC__FLAGS: { 12044 const TokenHeader *tokFlags = varLen->getValue<TokenHeader>(); 12045 const TokenHeader *tokFlagsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 12046 while (tokFlags < tokFlagsEnd) { 12047 if (false == tokFlags->flags.flag4IsVariableLength) { 12048 if (tokFlags->flags.flag3IsMandatory) { 12049 return false; 12050 } 12051 tokFlags = tokFlags + 1 + tokFlags->valueDwordCount; 12052 } else { 12053 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokFlags); 12054 switch (tokFlags->id) { 12055 default: 12056 if (tokFlags->flags.flag3IsMandatory) { 12057 return false; 12058 } 12059 break; 12060 case TOK_FS_GMM_RESOURCE_FLAG_REC__GPU: { 12061 const TokenHeader *tokGpu = varLen->getValue<TokenHeader>(); 12062 const TokenHeader *tokGpuEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 12063 while (tokGpu < tokGpuEnd) { 12064 if (false == tokGpu->flags.flag4IsVariableLength) { 12065 switch (tokGpu->id) { 12066 default: 12067 if (tokGpu->flags.flag3IsMandatory) { 12068 return false; 12069 } 12070 break; 12071 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CAMERA_CAPTURE: { 12072 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.CameraCapture = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.CameraCapture)>(*tokGpu); 12073 } break; 12074 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CCS: { 12075 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.CCS = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.CCS)>(*tokGpu); 12076 } break; 12077 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_DISCARD: { 12078 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ColorDiscard = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ColorDiscard)>(*tokGpu); 12079 } break; 12080 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION: { 12081 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ColorSeparation = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ColorSeparation)>(*tokGpu); 12082 } break; 12083 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION_RGBX: { 12084 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ColorSeparationRGBX = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ColorSeparationRGBX)>(*tokGpu); 12085 } break; 12086 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CONSTANT: { 12087 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Constant = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Constant)>(*tokGpu); 12088 } break; 12089 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__DEPTH: { 12090 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Depth = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Depth)>(*tokGpu); 12091 } break; 12092 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN: { 12093 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.FlipChain = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.FlipChain)>(*tokGpu); 12094 } break; 12095 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN_PREFERRED: { 12096 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.FlipChainPreferred = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.FlipChainPreferred)>(*tokGpu); 12097 } break; 12098 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HISTORY_BUFFER: { 12099 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.HistoryBuffer = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.HistoryBuffer)>(*tokGpu); 12100 } break; 12101 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HI_Z: { 12102 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.HiZ = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.HiZ)>(*tokGpu); 12103 } break; 12104 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDEX: { 12105 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Index = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Index)>(*tokGpu); 12106 } break; 12107 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDIRECT_CLEAR_COLOR: { 12108 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.IndirectClearColor = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.IndirectClearColor)>(*tokGpu); 12109 } break; 12110 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INSTRUCTION_FLAT: { 12111 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.InstructionFlat = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.InstructionFlat)>(*tokGpu); 12112 } break; 12113 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INTERLACED_SCAN: { 12114 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.InterlacedScan = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.InterlacedScan)>(*tokGpu); 12115 } break; 12116 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MCS: { 12117 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.MCS = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.MCS)>(*tokGpu); 12118 } break; 12119 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MMC: { 12120 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.MMC = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.MMC)>(*tokGpu); 12121 } break; 12122 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MOTION_COMP: { 12123 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.MotionComp = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.MotionComp)>(*tokGpu); 12124 } break; 12125 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__NO_RESTRICTION: { 12126 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.NoRestriction = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.NoRestriction)>(*tokGpu); 12127 } break; 12128 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__OVERLAY: { 12129 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Overlay = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Overlay)>(*tokGpu); 12130 } break; 12131 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PRESENTABLE: { 12132 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Presentable = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Presentable)>(*tokGpu); 12133 } break; 12134 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PROCEDURAL_TEXTURE: { 12135 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ProceduralTexture = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ProceduralTexture)>(*tokGpu); 12136 } break; 12137 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__QUERY: { 12138 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Query = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Query)>(*tokGpu); 12139 } break; 12140 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__RENDER_TARGET: { 12141 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.RenderTarget = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.RenderTarget)>(*tokGpu); 12142 } break; 12143 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D: { 12144 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.S3d = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.S3d)>(*tokGpu); 12145 } break; 12146 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D_DX: { 12147 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.S3dDx = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.S3dDx)>(*tokGpu); 12148 } break; 12149 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_NON_PACKED: { 12150 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__S3dNonPacked = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__S3dNonPacked)>(*tokGpu); 12151 } break; 12152 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_WIDI: { 12153 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__S3dWidi = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__S3dWidi)>(*tokGpu); 12154 } break; 12155 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SCRATCH_FLAT: { 12156 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ScratchFlat = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ScratchFlat)>(*tokGpu); 12157 } break; 12158 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SEPARATE_STENCIL: { 12159 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.SeparateStencil = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.SeparateStencil)>(*tokGpu); 12160 } break; 12161 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE: { 12162 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.State = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.State)>(*tokGpu); 12163 } break; 12164 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE_DX9CONSTANT_BUFFER: { 12165 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.StateDx9ConstantBuffer = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.StateDx9ConstantBuffer)>(*tokGpu); 12166 } break; 12167 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STREAM: { 12168 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Stream = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Stream)>(*tokGpu); 12169 } break; 12170 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXT_API: { 12171 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.TextApi = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.TextApi)>(*tokGpu); 12172 } break; 12173 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXTURE: { 12174 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Texture = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Texture)>(*tokGpu); 12175 } break; 12176 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILED_RESOURCE: { 12177 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.TiledResource = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.TiledResource)>(*tokGpu); 12178 } break; 12179 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILE_POOL: { 12180 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.TilePool = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.TilePool)>(*tokGpu); 12181 } break; 12182 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__UNIFIED_AUX_SURFACE: { 12183 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.UnifiedAuxSurface = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.UnifiedAuxSurface)>(*tokGpu); 12184 } break; 12185 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VERTEX: { 12186 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Vertex = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Vertex)>(*tokGpu); 12187 } break; 12188 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VIDEO: { 12189 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Video = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Video)>(*tokGpu); 12190 } break; 12191 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_XCCS: { 12192 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__NonMsaaTileXCcs = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__NonMsaaTileXCcs)>(*tokGpu); 12193 } break; 12194 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_YCCS: { 12195 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__NonMsaaTileYCcs = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__NonMsaaTileYCcs)>(*tokGpu); 12196 } break; 12197 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____MSAA_TILE_MCS: { 12198 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__MsaaTileMcs = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__MsaaTileMcs)>(*tokGpu); 12199 } break; 12200 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_LINEAR_CCS: { 12201 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__NonMsaaLinearCCS = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__NonMsaaLinearCCS)>(*tokGpu); 12202 } break; 12203 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____REMAINING: { 12204 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__Remaining = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__Remaining)>(*tokGpu); 12205 } break; 12206 }; 12207 tokGpu = tokGpu + 1 + tokGpu->valueDwordCount; 12208 } else { 12209 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokGpu); 12210 if (tokGpu->flags.flag3IsMandatory) { 12211 return false; 12212 } 12213 tokGpu = tokGpu + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 12214 } 12215 } 12216 WCH_ASSERT(tokGpu == tokGpuEnd); 12217 } break; 12218 case TOK_FS_GMM_RESOURCE_FLAG_REC__INFO: { 12219 const TokenHeader *tokInfo = varLen->getValue<TokenHeader>(); 12220 const TokenHeader *tokInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 12221 while (tokInfo < tokInfoEnd) { 12222 if (false == tokInfo->flags.flag4IsVariableLength) { 12223 switch (tokInfo->id) { 12224 default: 12225 if (tokInfo->flags.flag3IsMandatory) { 12226 return false; 12227 } 12228 break; 12229 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ALLOW_VIRTUAL_PADDING: { 12230 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.AllowVirtualPadding = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.AllowVirtualPadding)>(*tokInfo); 12231 } break; 12232 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__BIG_PAGE: { 12233 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.BigPage = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.BigPage)>(*tokInfo); 12234 } break; 12235 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CACHEABLE: { 12236 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Cacheable = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Cacheable)>(*tokInfo); 12237 } break; 12238 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CONTIG_PHYS_MEMORY_FORI_DART: { 12239 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.ContigPhysMemoryForiDART = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.ContigPhysMemoryForiDART)>(*tokInfo); 12240 } break; 12241 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CORNER_TEXEL_MODE: { 12242 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.CornerTexelMode = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.CornerTexelMode)>(*tokInfo); 12243 } break; 12244 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__EXISTING_SYS_MEM: { 12245 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.ExistingSysMem = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.ExistingSysMem)>(*tokInfo); 12246 } break; 12247 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__FORCE_RESIDENCY: { 12248 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.ForceResidency = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.ForceResidency)>(*tokInfo); 12249 } break; 12250 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GFDT: { 12251 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Gfdt = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Gfdt)>(*tokInfo); 12252 } break; 12253 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GTT_MAP_TYPE: { 12254 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.GttMapType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.GttMapType)>(*tokInfo); 12255 } break; 12256 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__HARDWARE_PROTECTED: { 12257 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.HardwareProtected = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.HardwareProtected)>(*tokInfo); 12258 } break; 12259 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__KERNEL_MODE_MAPPED: { 12260 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.KernelModeMapped = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.KernelModeMapped)>(*tokInfo); 12261 } break; 12262 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_BELOW: { 12263 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LayoutBelow = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LayoutBelow)>(*tokInfo); 12264 } break; 12265 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_MONO: { 12266 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LayoutMono = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LayoutMono)>(*tokInfo); 12267 } break; 12268 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_RIGHT: { 12269 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LayoutRight = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LayoutRight)>(*tokInfo); 12270 } break; 12271 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LOCAL_ONLY: { 12272 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LocalOnly = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LocalOnly)>(*tokInfo); 12273 } break; 12274 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LINEAR: { 12275 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Linear = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Linear)>(*tokInfo); 12276 } break; 12277 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__MEDIA_COMPRESSED: { 12278 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.MediaCompressed = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.MediaCompressed)>(*tokInfo); 12279 } break; 12280 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_OPTIMIZATION_PADDING: { 12281 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NoOptimizationPadding = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NoOptimizationPadding)>(*tokInfo); 12282 } break; 12283 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_PHYS_MEMORY: { 12284 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NoPhysMemory = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NoPhysMemory)>(*tokInfo); 12285 } break; 12286 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NOT_LOCKABLE: { 12287 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NotLockable = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NotLockable)>(*tokInfo); 12288 } break; 12289 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NON_LOCAL_ONLY: { 12290 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NonLocalOnly = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NonLocalOnly)>(*tokInfo); 12291 } break; 12292 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__STD_SWIZZLE: { 12293 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.StdSwizzle = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.StdSwizzle)>(*tokInfo); 12294 } break; 12295 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__PSEUDO_STD_SWIZZLE: { 12296 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.PseudoStdSwizzle = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.PseudoStdSwizzle)>(*tokInfo); 12297 } break; 12298 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__UNDEFINED64KBSWIZZLE: { 12299 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Undefined64KBSwizzle = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Undefined64KBSwizzle)>(*tokInfo); 12300 } break; 12301 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__REDECRIBED_PLANES: { 12302 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.RedecribedPlanes = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.RedecribedPlanes)>(*tokInfo); 12303 } break; 12304 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__RENDER_COMPRESSED: { 12305 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.RenderCompressed = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.RenderCompressed)>(*tokInfo); 12306 } break; 12307 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ROTATED: { 12308 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Rotated = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Rotated)>(*tokInfo); 12309 } break; 12310 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SHARED: { 12311 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Shared = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Shared)>(*tokInfo); 12312 } break; 12313 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SOFTWARE_PROTECTED: { 12314 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.SoftwareProtected = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.SoftwareProtected)>(*tokInfo); 12315 } break; 12316 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SVM: { 12317 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.SVM = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.SVM)>(*tokInfo); 12318 } break; 12319 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE4: { 12320 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Tile4 = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Tile4)>(*tokInfo); 12321 } break; 12322 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE64: { 12323 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Tile64 = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Tile64)>(*tokInfo); 12324 } break; 12325 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_W: { 12326 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledW = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledW)>(*tokInfo); 12327 } break; 12328 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_X: { 12329 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledX = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledX)>(*tokInfo); 12330 } break; 12331 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_Y: { 12332 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledY = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledY)>(*tokInfo); 12333 } break; 12334 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YF: { 12335 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledYf = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledYf)>(*tokInfo); 12336 } break; 12337 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YS: { 12338 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledYs = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledYs)>(*tokInfo); 12339 } break; 12340 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__WDDM_PROTECTED: { 12341 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.WddmProtected = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.WddmProtected)>(*tokInfo); 12342 } break; 12343 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__XADAPTER: { 12344 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.XAdapter = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.XAdapter)>(*tokInfo); 12345 } break; 12346 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PREALLOCATED_RES_INFO: { 12347 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.__PreallocatedResInfo = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.__PreallocatedResInfo)>(*tokInfo); 12348 } break; 12349 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PRE_WDDM2SVM: { 12350 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.__PreWddm2SVM = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.__PreWddm2SVM)>(*tokInfo); 12351 } break; 12352 }; 12353 tokInfo = tokInfo + 1 + tokInfo->valueDwordCount; 12354 } else { 12355 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInfo); 12356 if (tokInfo->flags.flag3IsMandatory) { 12357 return false; 12358 } 12359 tokInfo = tokInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 12360 } 12361 } 12362 WCH_ASSERT(tokInfo == tokInfoEnd); 12363 } break; 12364 case TOK_FS_GMM_RESOURCE_FLAG_REC__WA: { 12365 const TokenHeader *tokWa = varLen->getValue<TokenHeader>(); 12366 const TokenHeader *tokWaEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 12367 while (tokWa < tokWaEnd) { 12368 if (false == tokWa->flags.flag4IsVariableLength) { 12369 switch (tokWa->id) { 12370 default: 12371 if (tokWa->flags.flag3IsMandatory) { 12372 return false; 12373 } 12374 break; 12375 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__GTMFX2ND_LEVEL_BATCH_RING_SIZE_ALIGN: { 12376 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign)>(*tokWa); 12377 } break; 12378 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_MPR_ROW_STORE32KALIGN: { 12379 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign)>(*tokWa); 12380 } break; 12381 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_DMV_BUFFER32KALIGN: { 12382 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign)>(*tokWa); 12383 } break; 12384 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_BUFFER_SAMPLER_PADDING: { 12385 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.NoBufferSamplerPadding = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.NoBufferSamplerPadding)>(*tokWa); 12386 } break; 12387 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_LEGACY_PLANAR_LINEAR_VIDEO_RESTRICTIONS: { 12388 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions)>(*tokWa); 12389 } break; 12390 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__CHVASTC_SKIP_VIRTUAL_MIPS: { 12391 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.CHVAstcSkipVirtualMips = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.CHVAstcSkipVirtualMips)>(*tokWa); 12392 } break; 12393 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_PACKED_MIP_TAIL: { 12394 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DisablePackedMipTail = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DisablePackedMipTail)>(*tokWa); 12395 } break; 12396 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521____FORCE_OTHER_HVALIGN4: { 12397 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.__ForceOtherHVALIGN4 = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.__ForceOtherHVALIGN4)>(*tokWa); 12398 } break; 12399 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR: { 12400 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DisableDisplayCcsClearColor = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DisableDisplayCcsClearColor)>(*tokWa); 12401 } break; 12402 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION: { 12403 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DisableDisplayCcsCompression = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DisableDisplayCcsCompression)>(*tokWa); 12404 } break; 12405 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: { 12406 dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.PreGen12FastClearOnly = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.PreGen12FastClearOnly)>(*tokWa); 12407 } break; 12408 }; 12409 tokWa = tokWa + 1 + tokWa->valueDwordCount; 12410 } else { 12411 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokWa); 12412 if (tokWa->flags.flag3IsMandatory) { 12413 return false; 12414 } 12415 tokWa = tokWa + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 12416 } 12417 } 12418 WCH_ASSERT(tokWa == tokWaEnd); 12419 } break; 12420 }; 12421 tokFlags = tokFlags + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 12422 } 12423 } 12424 WCH_ASSERT(tokFlags == tokFlagsEnd); 12425 } break; 12426 case TOK_FS_GMM_TEXTURE_INFO_REC__CACHE_POLICY: { 12427 const TokenHeader *tokCachePolicy = varLen->getValue<TokenHeader>(); 12428 const TokenHeader *tokCachePolicyEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 12429 while (tokCachePolicy < tokCachePolicyEnd) { 12430 if (false == tokCachePolicy->flags.flag4IsVariableLength) { 12431 switch (tokCachePolicy->id) { 12432 default: 12433 if (tokCachePolicy->flags.flag3IsMandatory) { 12434 return false; 12435 } 12436 break; 12437 case TOK_FE_GMM_TEXTURE_INFO_REC__ANONYMOUS4927__USAGE: { 12438 dst.GmmResourceInfoCommon.AuxSecSurf.CachePolicy.Usage = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.CachePolicy.Usage)>(*tokCachePolicy); 12439 } break; 12440 }; 12441 tokCachePolicy = tokCachePolicy + 1 + tokCachePolicy->valueDwordCount; 12442 } else { 12443 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCachePolicy); 12444 if (tokCachePolicy->flags.flag3IsMandatory) { 12445 return false; 12446 } 12447 tokCachePolicy = tokCachePolicy + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 12448 } 12449 } 12450 WCH_ASSERT(tokCachePolicy == tokCachePolicyEnd); 12451 } break; 12452 case TOK_FS_GMM_TEXTURE_INFO_REC__MSAA: { 12453 const TokenHeader *tokMSAA = varLen->getValue<TokenHeader>(); 12454 const TokenHeader *tokMSAAEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 12455 while (tokMSAA < tokMSAAEnd) { 12456 if (false == tokMSAA->flags.flag4IsVariableLength) { 12457 switch (tokMSAA->id) { 12458 default: 12459 if (tokMSAA->flags.flag3IsMandatory) { 12460 return false; 12461 } 12462 break; 12463 case TOK_FE_GMM_RESOURCE_MSAA_INFO_REC__SAMPLE_PATTERN: { 12464 dst.GmmResourceInfoCommon.AuxSecSurf.MSAA.SamplePattern = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.MSAA.SamplePattern)>(*tokMSAA); 12465 } break; 12466 case TOK_FBD_GMM_RESOURCE_MSAA_INFO_REC__NUM_SAMPLES: { 12467 dst.GmmResourceInfoCommon.AuxSecSurf.MSAA.NumSamples = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.MSAA.NumSamples)>(*tokMSAA); 12468 } break; 12469 }; 12470 tokMSAA = tokMSAA + 1 + tokMSAA->valueDwordCount; 12471 } else { 12472 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokMSAA); 12473 if (tokMSAA->flags.flag3IsMandatory) { 12474 return false; 12475 } 12476 tokMSAA = tokMSAA + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 12477 } 12478 } 12479 WCH_ASSERT(tokMSAA == tokMSAAEnd); 12480 } break; 12481 case TOK_FS_GMM_TEXTURE_INFO_REC__ALIGNMENT: { 12482 const TokenHeader *tokAlignment = varLen->getValue<TokenHeader>(); 12483 const TokenHeader *tokAlignmentEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 12484 while (tokAlignment < tokAlignmentEnd) { 12485 if (false == tokAlignment->flags.flag4IsVariableLength) { 12486 switch (tokAlignment->id) { 12487 default: 12488 if (tokAlignment->flags.flag3IsMandatory) { 12489 return false; 12490 } 12491 break; 12492 case TOK_FBC_GMM_RESOURCE_ALIGNMENT_REC__ARRAY_SPACING_SINGLE_LOD: { 12493 dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.ArraySpacingSingleLod = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.ArraySpacingSingleLod)>(*tokAlignment); 12494 } break; 12495 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__BASE_ALIGNMENT: { 12496 dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.BaseAlignment = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.BaseAlignment)>(*tokAlignment); 12497 } break; 12498 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__HALIGN: { 12499 dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.HAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.HAlign)>(*tokAlignment); 12500 } break; 12501 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__VALIGN: { 12502 dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.VAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.VAlign)>(*tokAlignment); 12503 } break; 12504 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__DALIGN: { 12505 dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.DAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.DAlign)>(*tokAlignment); 12506 } break; 12507 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__MIP_TAIL_START_LOD: { 12508 dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.MipTailStartLod = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.MipTailStartLod)>(*tokAlignment); 12509 } break; 12510 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_START_LOD: { 12511 dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.PackedMipStartLod = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.PackedMipStartLod)>(*tokAlignment); 12512 } break; 12513 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_WIDTH: { 12514 dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.PackedMipWidth = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.PackedMipWidth)>(*tokAlignment); 12515 } break; 12516 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_HEIGHT: { 12517 dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.PackedMipHeight = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.PackedMipHeight)>(*tokAlignment); 12518 } break; 12519 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__QPITCH: { 12520 dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.QPitch = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.QPitch)>(*tokAlignment); 12521 } break; 12522 }; 12523 tokAlignment = tokAlignment + 1 + tokAlignment->valueDwordCount; 12524 } else { 12525 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokAlignment); 12526 if (tokAlignment->flags.flag3IsMandatory) { 12527 return false; 12528 } 12529 tokAlignment = tokAlignment + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 12530 } 12531 } 12532 WCH_ASSERT(tokAlignment == tokAlignmentEnd); 12533 } break; 12534 case TOK_FS_GMM_TEXTURE_INFO_REC__OFFSET_INFO: { 12535 const TokenHeader *tokOffsetInfo = varLen->getValue<TokenHeader>(); 12536 const TokenHeader *tokOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 12537 while (tokOffsetInfo < tokOffsetInfoEnd) { 12538 if (false == tokOffsetInfo->flags.flag4IsVariableLength) { 12539 if (tokOffsetInfo->flags.flag3IsMandatory) { 12540 return false; 12541 } 12542 tokOffsetInfo = tokOffsetInfo + 1 + tokOffsetInfo->valueDwordCount; 12543 } else { 12544 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokOffsetInfo); 12545 switch (tokOffsetInfo->id) { 12546 default: 12547 if (tokOffsetInfo->flags.flag3IsMandatory) { 12548 return false; 12549 } 12550 break; 12551 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO: { 12552 const TokenHeader *tokTexture3DOffsetInfo = varLen->getValue<TokenHeader>(); 12553 const TokenHeader *tokTexture3DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 12554 while (tokTexture3DOffsetInfo < tokTexture3DOffsetInfoEnd) { 12555 if (false == tokTexture3DOffsetInfo->flags.flag4IsVariableLength) { 12556 switch (tokTexture3DOffsetInfo->id) { 12557 default: 12558 if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { 12559 return false; 12560 } 12561 break; 12562 case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: { 12563 dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch)>(*tokTexture3DOffsetInfo); 12564 } break; 12565 case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: { 12566 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValue<char>(); 12567 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValueSizeInBytes(); 12568 if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset)) { 12569 return false; 12570 } 12571 WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset)); 12572 } break; 12573 }; 12574 tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + 1 + tokTexture3DOffsetInfo->valueDwordCount; 12575 } else { 12576 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture3DOffsetInfo); 12577 if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { 12578 return false; 12579 } 12580 tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 12581 } 12582 } 12583 WCH_ASSERT(tokTexture3DOffsetInfo == tokTexture3DOffsetInfoEnd); 12584 } break; 12585 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO: { 12586 const TokenHeader *tokTexture2DOffsetInfo = varLen->getValue<TokenHeader>(); 12587 const TokenHeader *tokTexture2DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 12588 while (tokTexture2DOffsetInfo < tokTexture2DOffsetInfoEnd) { 12589 if (false == tokTexture2DOffsetInfo->flags.flag4IsVariableLength) { 12590 switch (tokTexture2DOffsetInfo->id) { 12591 default: 12592 if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { 12593 return false; 12594 } 12595 break; 12596 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: { 12597 dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock)>(*tokTexture2DOffsetInfo); 12598 } break; 12599 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: { 12600 dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender)>(*tokTexture2DOffsetInfo); 12601 } break; 12602 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: { 12603 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValue<char>(); 12604 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValueSizeInBytes(); 12605 if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset)) { 12606 return false; 12607 } 12608 WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset)); 12609 } break; 12610 }; 12611 tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + 1 + tokTexture2DOffsetInfo->valueDwordCount; 12612 } else { 12613 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture2DOffsetInfo); 12614 if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { 12615 return false; 12616 } 12617 tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 12618 } 12619 } 12620 WCH_ASSERT(tokTexture2DOffsetInfo == tokTexture2DOffsetInfoEnd); 12621 } break; 12622 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE: { 12623 const TokenHeader *tokPlane = varLen->getValue<TokenHeader>(); 12624 const TokenHeader *tokPlaneEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 12625 while (tokPlane < tokPlaneEnd) { 12626 if (false == tokPlane->flags.flag4IsVariableLength) { 12627 switch (tokPlane->id) { 12628 default: 12629 if (tokPlane->flags.flag3IsMandatory) { 12630 return false; 12631 } 12632 break; 12633 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: { 12634 dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.ArrayQPitch = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.ArrayQPitch)>(*tokPlane); 12635 } break; 12636 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: { 12637 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>(); 12638 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes(); 12639 if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.X)) { 12640 return false; 12641 } 12642 WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.X, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.X), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.X)); 12643 } break; 12644 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: { 12645 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>(); 12646 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes(); 12647 if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.Y)) { 12648 return false; 12649 } 12650 WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.Y, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.Y), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.Y)); 12651 } break; 12652 case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: { 12653 dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.NoOfPlanes = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.NoOfPlanes)>(*tokPlane); 12654 } break; 12655 case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: { 12656 dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.IsTileAlignedPlanes = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.IsTileAlignedPlanes)>(*tokPlane); 12657 } break; 12658 }; 12659 tokPlane = tokPlane + 1 + tokPlane->valueDwordCount; 12660 } else { 12661 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlane); 12662 switch (tokPlane->id) { 12663 default: 12664 if (tokPlane->flags.flag3IsMandatory) { 12665 return false; 12666 } 12667 break; 12668 case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: { 12669 const TokenHeader *tokUnAligned = varLen->getValue<TokenHeader>(); 12670 const TokenHeader *tokUnAlignedEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 12671 while (tokUnAligned < tokUnAlignedEnd) { 12672 if (false == tokUnAligned->flags.flag4IsVariableLength) { 12673 switch (tokUnAligned->id) { 12674 default: 12675 if (tokUnAligned->flags.flag3IsMandatory) { 12676 return false; 12677 } 12678 break; 12679 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: { 12680 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValue<char>(); 12681 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValueSizeInBytes(); 12682 if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height)) { 12683 return false; 12684 } 12685 WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height)); 12686 } break; 12687 }; 12688 tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount; 12689 } else { 12690 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokUnAligned); 12691 if (tokUnAligned->flags.flag3IsMandatory) { 12692 return false; 12693 } 12694 tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 12695 } 12696 } 12697 WCH_ASSERT(tokUnAligned == tokUnAlignedEnd); 12698 } break; 12699 }; 12700 tokPlane = tokPlane + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 12701 } 12702 } 12703 WCH_ASSERT(tokPlane == tokPlaneEnd); 12704 } break; 12705 }; 12706 tokOffsetInfo = tokOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 12707 } 12708 } 12709 WCH_ASSERT(tokOffsetInfo == tokOffsetInfoEnd); 12710 } break; 12711 case TOK_FS_GMM_TEXTURE_INFO_REC__S3D: { 12712 const TokenHeader *tokS3d = varLen->getValue<TokenHeader>(); 12713 const TokenHeader *tokS3dEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 12714 while (tokS3d < tokS3dEnd) { 12715 if (false == tokS3d->flags.flag4IsVariableLength) { 12716 switch (tokS3d->id) { 12717 default: 12718 if (tokS3d->flags.flag3IsMandatory) { 12719 return false; 12720 } 12721 break; 12722 case TOK_FBD_GMM_S3D_INFO_REC__DISPLAY_MODE_HEIGHT: { 12723 dst.GmmResourceInfoCommon.AuxSecSurf.S3d.DisplayModeHeight = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.S3d.DisplayModeHeight)>(*tokS3d); 12724 } break; 12725 case TOK_FBD_GMM_S3D_INFO_REC__NUM_BLANK_ACTIVE_LINES: { 12726 dst.GmmResourceInfoCommon.AuxSecSurf.S3d.NumBlankActiveLines = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.S3d.NumBlankActiveLines)>(*tokS3d); 12727 } break; 12728 case TOK_FBD_GMM_S3D_INFO_REC__RFRAME_OFFSET: { 12729 dst.GmmResourceInfoCommon.AuxSecSurf.S3d.RFrameOffset = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.S3d.RFrameOffset)>(*tokS3d); 12730 } break; 12731 case TOK_FBD_GMM_S3D_INFO_REC__BLANK_AREA_OFFSET: { 12732 dst.GmmResourceInfoCommon.AuxSecSurf.S3d.BlankAreaOffset = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.S3d.BlankAreaOffset)>(*tokS3d); 12733 } break; 12734 case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_HEIGHT: { 12735 dst.GmmResourceInfoCommon.AuxSecSurf.S3d.TallBufferHeight = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.S3d.TallBufferHeight)>(*tokS3d); 12736 } break; 12737 case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_SIZE: { 12738 dst.GmmResourceInfoCommon.AuxSecSurf.S3d.TallBufferSize = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.S3d.TallBufferSize)>(*tokS3d); 12739 } break; 12740 case TOK_FBC_GMM_S3D_INFO_REC__IS_RFRAME: { 12741 dst.GmmResourceInfoCommon.AuxSecSurf.S3d.IsRFrame = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.S3d.IsRFrame)>(*tokS3d); 12742 } break; 12743 }; 12744 tokS3d = tokS3d + 1 + tokS3d->valueDwordCount; 12745 } else { 12746 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokS3d); 12747 if (tokS3d->flags.flag3IsMandatory) { 12748 return false; 12749 } 12750 tokS3d = tokS3d + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 12751 } 12752 } 12753 WCH_ASSERT(tokS3d == tokS3dEnd); 12754 } break; 12755 case TOK_FS_GMM_TEXTURE_INFO_REC__SEGMENT_OVERRIDE: { 12756 const TokenHeader *tokSegmentOverride = varLen->getValue<TokenHeader>(); 12757 const TokenHeader *tokSegmentOverrideEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 12758 while (tokSegmentOverride < tokSegmentOverrideEnd) { 12759 if (false == tokSegmentOverride->flags.flag4IsVariableLength) { 12760 switch (tokSegmentOverride->id) { 12761 default: 12762 if (tokSegmentOverride->flags.flag3IsMandatory) { 12763 return false; 12764 } 12765 break; 12766 case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__SEG1: { 12767 dst.GmmResourceInfoCommon.AuxSecSurf.SegmentOverride.Seg1 = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.SegmentOverride.Seg1)>(*tokSegmentOverride); 12768 } break; 12769 case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__EVICT: { 12770 dst.GmmResourceInfoCommon.AuxSecSurf.SegmentOverride.Evict = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.SegmentOverride.Evict)>(*tokSegmentOverride); 12771 } break; 12772 }; 12773 tokSegmentOverride = tokSegmentOverride + 1 + tokSegmentOverride->valueDwordCount; 12774 } else { 12775 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSegmentOverride); 12776 if (tokSegmentOverride->flags.flag3IsMandatory) { 12777 return false; 12778 } 12779 tokSegmentOverride = tokSegmentOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 12780 } 12781 } 12782 WCH_ASSERT(tokSegmentOverride == tokSegmentOverrideEnd); 12783 } break; 12784 case TOK_FS_GMM_TEXTURE_INFO_REC__PLATFORM: { 12785 #if _DEBUG || _RELEASE_INTERNAL 12786 const TokenHeader *tokPlatform = varLen->getValue<TokenHeader>(); 12787 const TokenHeader *tokPlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 12788 while (tokPlatform < tokPlatformEnd) { 12789 if (false == tokPlatform->flags.flag4IsVariableLength) { 12790 switch (tokPlatform->id) { 12791 default: 12792 if (tokPlatform->flags.flag3IsMandatory) { 12793 return false; 12794 } 12795 break; 12796 case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { 12797 dst.GmmResourceInfoCommon.AuxSecSurf.Platform.eProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Platform.eProductFamily)>(*tokPlatform); 12798 } break; 12799 case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { 12800 dst.GmmResourceInfoCommon.AuxSecSurf.Platform.ePCHProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Platform.ePCHProductFamily)>(*tokPlatform); 12801 } break; 12802 case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { 12803 dst.GmmResourceInfoCommon.AuxSecSurf.Platform.eDisplayCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Platform.eDisplayCoreFamily)>(*tokPlatform); 12804 } break; 12805 case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { 12806 dst.GmmResourceInfoCommon.AuxSecSurf.Platform.eRenderCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Platform.eRenderCoreFamily)>(*tokPlatform); 12807 } break; 12808 case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { 12809 dst.GmmResourceInfoCommon.AuxSecSurf.Platform.ePlatformType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Platform.ePlatformType)>(*tokPlatform); 12810 } break; 12811 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { 12812 dst.GmmResourceInfoCommon.AuxSecSurf.Platform.usDeviceID = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Platform.usDeviceID)>(*tokPlatform); 12813 } break; 12814 case TOK_FBW_PLATFORM_STR__US_REV_ID: { 12815 dst.GmmResourceInfoCommon.AuxSecSurf.Platform.usRevId = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Platform.usRevId)>(*tokPlatform); 12816 } break; 12817 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { 12818 dst.GmmResourceInfoCommon.AuxSecSurf.Platform.usDeviceID_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Platform.usDeviceID_PCH)>(*tokPlatform); 12819 } break; 12820 case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { 12821 dst.GmmResourceInfoCommon.AuxSecSurf.Platform.usRevId_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Platform.usRevId_PCH)>(*tokPlatform); 12822 } break; 12823 case TOK_FE_PLATFORM_STR__E_GTTYPE: { 12824 dst.GmmResourceInfoCommon.AuxSecSurf.Platform.eGTType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Platform.eGTType)>(*tokPlatform); 12825 } break; 12826 }; 12827 tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount; 12828 } else { 12829 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlatform); 12830 if (tokPlatform->flags.flag3IsMandatory) { 12831 return false; 12832 } 12833 tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 12834 } 12835 } 12836 WCH_ASSERT(tokPlatform == tokPlatformEnd); 12837 #endif 12838 } break; 12839 case TOK_FS_GMM_TEXTURE_INFO_REC__EXISTING_SYS_MEM: { 12840 const TokenHeader *tokExistingSysMem = varLen->getValue<TokenHeader>(); 12841 const TokenHeader *tokExistingSysMemEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 12842 while (tokExistingSysMem < tokExistingSysMemEnd) { 12843 if (false == tokExistingSysMem->flags.flag4IsVariableLength) { 12844 switch (tokExistingSysMem->id) { 12845 default: 12846 if (tokExistingSysMem->flags.flag3IsMandatory) { 12847 return false; 12848 } 12849 break; 12850 case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_GMM_ALLOCATED: { 12851 dst.GmmResourceInfoCommon.AuxSecSurf.ExistingSysMem.IsGmmAllocated = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.ExistingSysMem.IsGmmAllocated)>(*tokExistingSysMem); 12852 } break; 12853 case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_PAGE_ALIGNED: { 12854 dst.GmmResourceInfoCommon.AuxSecSurf.ExistingSysMem.IsPageAligned = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.ExistingSysMem.IsPageAligned)>(*tokExistingSysMem); 12855 } break; 12856 }; 12857 tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount; 12858 } else { 12859 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokExistingSysMem); 12860 if (tokExistingSysMem->flags.flag3IsMandatory) { 12861 return false; 12862 } 12863 tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 12864 } 12865 } 12866 WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd); 12867 } break; 12868 case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: { 12869 #if !(_DEBUG || _RELEASE_INTERNAL) 12870 const TokenHeader *tok__Platform = varLen->getValue<TokenHeader>(); 12871 const TokenHeader *tok__PlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 12872 while (tok__Platform < tok__PlatformEnd) { 12873 if (false == tok__Platform->flags.flag4IsVariableLength) { 12874 switch (tok__Platform->id) { 12875 default: 12876 if (tok__Platform->flags.flag3IsMandatory) { 12877 return false; 12878 } 12879 break; 12880 case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { 12881 dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eProductFamily)>(*tok__Platform); 12882 } break; 12883 case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { 12884 dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.ePCHProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.ePCHProductFamily)>(*tok__Platform); 12885 } break; 12886 case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { 12887 dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eDisplayCoreFamily)>(*tok__Platform); 12888 } break; 12889 case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { 12890 dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eRenderCoreFamily)>(*tok__Platform); 12891 } break; 12892 case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { 12893 dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.ePlatformType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.ePlatformType)>(*tok__Platform); 12894 } break; 12895 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { 12896 dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usDeviceID = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usDeviceID)>(*tok__Platform); 12897 } break; 12898 case TOK_FBW_PLATFORM_STR__US_REV_ID: { 12899 dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usRevId = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usRevId)>(*tok__Platform); 12900 } break; 12901 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { 12902 dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usDeviceID_PCH)>(*tok__Platform); 12903 } break; 12904 case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { 12905 dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usRevId_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usRevId_PCH)>(*tok__Platform); 12906 } break; 12907 case TOK_FE_PLATFORM_STR__E_GTTYPE: { 12908 dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eGTType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eGTType)>(*tok__Platform); 12909 } break; 12910 }; 12911 tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount; 12912 } else { 12913 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok__Platform); 12914 if (tok__Platform->flags.flag3IsMandatory) { 12915 return false; 12916 } 12917 tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 12918 } 12919 } 12920 WCH_ASSERT(tok__Platform == tok__PlatformEnd); 12921 #endif 12922 } break; 12923 }; 12924 tokAuxSecSurf = tokAuxSecSurf + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 12925 } 12926 } 12927 WCH_ASSERT(tokAuxSecSurf == tokAuxSecSurfEnd); 12928 } break; 12929 case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__EXISTING_SYS_MEM: { 12930 const TokenHeader *tokExistingSysMem = varLen->getValue<TokenHeader>(); 12931 const TokenHeader *tokExistingSysMemEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 12932 while (tokExistingSysMem < tokExistingSysMemEnd) { 12933 if (false == tokExistingSysMem->flags.flag4IsVariableLength) { 12934 switch (tokExistingSysMem->id) { 12935 default: 12936 if (tokExistingSysMem->flags.flag3IsMandatory) { 12937 return false; 12938 } 12939 break; 12940 case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_EXISTING_SYS_MEM: { 12941 dst.GmmResourceInfoCommon.ExistingSysMem.pExistingSysMem = readTokValue<decltype(dst.GmmResourceInfoCommon.ExistingSysMem.pExistingSysMem)>(*tokExistingSysMem); 12942 } break; 12943 case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_VIRT_ADDRESS: { 12944 dst.GmmResourceInfoCommon.ExistingSysMem.pVirtAddress = readTokValue<decltype(dst.GmmResourceInfoCommon.ExistingSysMem.pVirtAddress)>(*tokExistingSysMem); 12945 } break; 12946 case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_GFX_ALIGNED_VIRT_ADDRESS: { 12947 dst.GmmResourceInfoCommon.ExistingSysMem.pGfxAlignedVirtAddress = readTokValue<decltype(dst.GmmResourceInfoCommon.ExistingSysMem.pGfxAlignedVirtAddress)>(*tokExistingSysMem); 12948 } break; 12949 case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__SIZE: { 12950 dst.GmmResourceInfoCommon.ExistingSysMem.Size = readTokValue<decltype(dst.GmmResourceInfoCommon.ExistingSysMem.Size)>(*tokExistingSysMem); 12951 } break; 12952 case TOK_FBC_GMM_EXISTING_SYS_MEM_REC__IS_GMM_ALLOCATED: { 12953 dst.GmmResourceInfoCommon.ExistingSysMem.IsGmmAllocated = readTokValue<decltype(dst.GmmResourceInfoCommon.ExistingSysMem.IsGmmAllocated)>(*tokExistingSysMem); 12954 } break; 12955 }; 12956 tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount; 12957 } else { 12958 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokExistingSysMem); 12959 if (tokExistingSysMem->flags.flag3IsMandatory) { 12960 return false; 12961 } 12962 tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 12963 } 12964 } 12965 WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd); 12966 } break; 12967 case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__MULTI_TILE_ARCH: { 12968 const TokenHeader *tokMultiTileArch = varLen->getValue<TokenHeader>(); 12969 const TokenHeader *tokMultiTileArchEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 12970 while (tokMultiTileArch < tokMultiTileArchEnd) { 12971 if (false == tokMultiTileArch->flags.flag4IsVariableLength) { 12972 switch (tokMultiTileArch->id) { 12973 default: 12974 if (tokMultiTileArch->flags.flag3IsMandatory) { 12975 return false; 12976 } 12977 break; 12978 case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__ENABLE: { 12979 dst.GmmResourceInfoCommon.MultiTileArch.Enable = readTokValue<decltype(dst.GmmResourceInfoCommon.MultiTileArch.Enable)>(*tokMultiTileArch); 12980 } break; 12981 case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__TILE_INSTANCED: { 12982 dst.GmmResourceInfoCommon.MultiTileArch.TileInstanced = readTokValue<decltype(dst.GmmResourceInfoCommon.MultiTileArch.TileInstanced)>(*tokMultiTileArch); 12983 } break; 12984 case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__GPU_VA_MAPPING_SET: { 12985 dst.GmmResourceInfoCommon.MultiTileArch.GpuVaMappingSet = readTokValue<decltype(dst.GmmResourceInfoCommon.MultiTileArch.GpuVaMappingSet)>(*tokMultiTileArch); 12986 } break; 12987 case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__LOCAL_MEM_ELIGIBILITY_SET: { 12988 dst.GmmResourceInfoCommon.MultiTileArch.LocalMemEligibilitySet = readTokValue<decltype(dst.GmmResourceInfoCommon.MultiTileArch.LocalMemEligibilitySet)>(*tokMultiTileArch); 12989 } break; 12990 case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__LOCAL_MEM_PREFERRED_SET: { 12991 dst.GmmResourceInfoCommon.MultiTileArch.LocalMemPreferredSet = readTokValue<decltype(dst.GmmResourceInfoCommon.MultiTileArch.LocalMemPreferredSet)>(*tokMultiTileArch); 12992 } break; 12993 }; 12994 tokMultiTileArch = tokMultiTileArch + 1 + tokMultiTileArch->valueDwordCount; 12995 } else { 12996 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokMultiTileArch); 12997 if (tokMultiTileArch->flags.flag3IsMandatory) { 12998 return false; 12999 } 13000 tokMultiTileArch = tokMultiTileArch + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 13001 } 13002 } 13003 WCH_ASSERT(tokMultiTileArch == tokMultiTileArchEnd); 13004 } break; 13005 }; 13006 tokGmmResourceInfoCommon = tokGmmResourceInfoCommon + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 13007 } 13008 } 13009 WCH_ASSERT(tokGmmResourceInfoCommon == tokGmmResourceInfoCommonEnd); 13010 } break; 13011 }; 13012 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 13013 } 13014 } 13015 WCH_ASSERT(tok == srcTokensEnd); 13016 return true; 13017 } 13018 }; 13019 13020 template <> 13021 struct Demarshaller<TOK_S_GFX_ESCAPE_HEADER> { 13022 template <typename GFX_ESCAPE_HEADERT> 13023 static bool demarshall(GFX_ESCAPE_HEADERT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 13024 const TokenHeader *tok = srcTokensBeg; 13025 while (tok < srcTokensEnd) { 13026 if (false == tok->flags.flag4IsVariableLength) { 13027 switch (tok->id) { 13028 default: 13029 if (tok->flags.flag3IsMandatory) { 13030 return false; 13031 } 13032 break; 13033 case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__SIZE: { 13034 dst.Size = readTokValue<decltype(dst.Size)>(*tok); 13035 } break; 13036 case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__CHECK_SUM: { 13037 dst.CheckSum = readTokValue<decltype(dst.CheckSum)>(*tok); 13038 } break; 13039 case TOK_FE_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__ESCAPE_CODE: { 13040 dst.EscapeCode = readTokValue<decltype(dst.EscapeCode)>(*tok); 13041 } break; 13042 case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__UL_RESERVED: { 13043 dst.ulReserved = readTokValue<decltype(dst.ulReserved)>(*tok); 13044 } break; 13045 case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UL_RESERVED1: { 13046 dst.ulReserved1 = readTokValue<decltype(dst.ulReserved1)>(*tok); 13047 } break; 13048 case TOK_FBW_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__US_ESCAPE_VERSION: { 13049 dst.usEscapeVersion = readTokValue<decltype(dst.usEscapeVersion)>(*tok); 13050 } break; 13051 case TOK_FBW_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__US_FILE_VERSION: { 13052 dst.usFileVersion = readTokValue<decltype(dst.usFileVersion)>(*tok); 13053 } break; 13054 case TOK_FE_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UL_MAJOR_ESCAPE_CODE: { 13055 dst.ulMajorEscapeCode = readTokValue<decltype(dst.ulMajorEscapeCode)>(*tok); 13056 } break; 13057 case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UI_MINOR_ESCAPE_CODE: { 13058 dst.uiMinorEscapeCode = readTokValue<decltype(dst.uiMinorEscapeCode)>(*tok); 13059 } break; 13060 }; 13061 tok = tok + 1 + tok->valueDwordCount; 13062 } else { 13063 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 13064 switch (tok->id) { 13065 default: 13066 if (tok->flags.flag3IsMandatory) { 13067 return false; 13068 } 13069 break; 13070 case TOK_S_GFX_ESCAPE_HEADER: 13071 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 13072 return false; 13073 } 13074 break; 13075 }; 13076 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 13077 } 13078 } 13079 WCH_ASSERT(tok == srcTokensEnd); 13080 return true; 13081 } 13082 }; 13083 13084 template <> 13085 struct Demarshaller<TOK_S_GTDIBASE_IN_STRUCT> { 13086 template <typename GTDIBaseInStructT> 13087 static bool demarshall(GTDIBaseInStructT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 13088 const TokenHeader *tok = srcTokensBeg; 13089 while (tok < srcTokensEnd) { 13090 if (false == tok->flags.flag4IsVariableLength) { 13091 switch (tok->id) { 13092 default: 13093 if (tok->flags.flag3IsMandatory) { 13094 return false; 13095 } 13096 break; 13097 case TOK_FE_GTDIBASE_IN_STRUCT__FUNCTION: { 13098 dst.Function = readTokValue<decltype(dst.Function)>(*tok); 13099 } break; 13100 }; 13101 tok = tok + 1 + tok->valueDwordCount; 13102 } else { 13103 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 13104 switch (tok->id) { 13105 default: 13106 if (tok->flags.flag3IsMandatory) { 13107 return false; 13108 } 13109 break; 13110 case TOK_S_GTDIBASE_IN_STRUCT: 13111 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 13112 return false; 13113 } 13114 break; 13115 }; 13116 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 13117 } 13118 } 13119 WCH_ASSERT(tok == srcTokensEnd); 13120 return true; 13121 } 13122 }; 13123 13124 template <> 13125 struct Demarshaller<TOK_S_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT> { 13126 template <typename GTDIGetGpuCpuTimestampsOutStructT> 13127 static bool demarshall(GTDIGetGpuCpuTimestampsOutStructT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 13128 const TokenHeader *tok = srcTokensBeg; 13129 while (tok < srcTokensEnd) { 13130 if (false == tok->flags.flag4IsVariableLength) { 13131 switch (tok->id) { 13132 default: 13133 if (tok->flags.flag3IsMandatory) { 13134 return false; 13135 } 13136 break; 13137 case TOK_FE_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__RET_CODE: { 13138 dst.RetCode = readTokValue<decltype(dst.RetCode)>(*tok); 13139 } break; 13140 case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__GPU_PERF_TICKS: { 13141 dst.gpuPerfTicks = readTokValue<decltype(dst.gpuPerfTicks)>(*tok); 13142 } break; 13143 case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__CPU_PERF_TICKS: { 13144 dst.cpuPerfTicks = readTokValue<decltype(dst.cpuPerfTicks)>(*tok); 13145 } break; 13146 case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__GPU_PERF_FREQ: { 13147 dst.gpuPerfFreq = readTokValue<decltype(dst.gpuPerfFreq)>(*tok); 13148 } break; 13149 case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__CPU_PERF_FREQ: { 13150 dst.cpuPerfFreq = readTokValue<decltype(dst.cpuPerfFreq)>(*tok); 13151 } break; 13152 }; 13153 tok = tok + 1 + tok->valueDwordCount; 13154 } else { 13155 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 13156 switch (tok->id) { 13157 default: 13158 if (tok->flags.flag3IsMandatory) { 13159 return false; 13160 } 13161 break; 13162 case TOK_S_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT: 13163 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 13164 return false; 13165 } 13166 break; 13167 }; 13168 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 13169 } 13170 } 13171 WCH_ASSERT(tok == srcTokensEnd); 13172 return true; 13173 } 13174 }; 13175 13176 template <> 13177 struct Demarshaller<TOK_S_TIME_STAMP_DATA_HEADER> { 13178 template <typename TimeStampDataHeaderT> 13179 static bool demarshall(TimeStampDataHeaderT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { 13180 const TokenHeader *tok = srcTokensBeg; 13181 while (tok < srcTokensEnd) { 13182 if (false == tok->flags.flag4IsVariableLength) { 13183 if (tok->flags.flag3IsMandatory) { 13184 return false; 13185 } 13186 tok = tok + 1 + tok->valueDwordCount; 13187 } else { 13188 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok); 13189 switch (tok->id) { 13190 default: 13191 if (tok->flags.flag3IsMandatory) { 13192 return false; 13193 } 13194 break; 13195 case TOK_S_TIME_STAMP_DATA_HEADER: 13196 if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { 13197 return false; 13198 } 13199 break; 13200 case TOK_FS_TIME_STAMP_DATA_HEADER__M_HEADER: { 13201 const TokenHeader *tokM_Header = varLen->getValue<TokenHeader>(); 13202 const TokenHeader *tokM_HeaderEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 13203 while (tokM_Header < tokM_HeaderEnd) { 13204 if (false == tokM_Header->flags.flag4IsVariableLength) { 13205 switch (tokM_Header->id) { 13206 default: 13207 if (tokM_Header->flags.flag3IsMandatory) { 13208 return false; 13209 } 13210 break; 13211 case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__SIZE: { 13212 dst.m_Header.Size = readTokValue<decltype(dst.m_Header.Size)>(*tokM_Header); 13213 } break; 13214 case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__CHECK_SUM: { 13215 dst.m_Header.CheckSum = readTokValue<decltype(dst.m_Header.CheckSum)>(*tokM_Header); 13216 } break; 13217 case TOK_FE_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__ESCAPE_CODE: { 13218 dst.m_Header.EscapeCode = readTokValue<decltype(dst.m_Header.EscapeCode)>(*tokM_Header); 13219 } break; 13220 case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__UL_RESERVED: { 13221 dst.m_Header.ulReserved = readTokValue<decltype(dst.m_Header.ulReserved)>(*tokM_Header); 13222 } break; 13223 case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UL_RESERVED1: { 13224 dst.m_Header.ulReserved1 = readTokValue<decltype(dst.m_Header.ulReserved1)>(*tokM_Header); 13225 } break; 13226 case TOK_FBW_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__US_ESCAPE_VERSION: { 13227 dst.m_Header.usEscapeVersion = readTokValue<decltype(dst.m_Header.usEscapeVersion)>(*tokM_Header); 13228 } break; 13229 case TOK_FBW_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__US_FILE_VERSION: { 13230 dst.m_Header.usFileVersion = readTokValue<decltype(dst.m_Header.usFileVersion)>(*tokM_Header); 13231 } break; 13232 case TOK_FE_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UL_MAJOR_ESCAPE_CODE: { 13233 dst.m_Header.ulMajorEscapeCode = readTokValue<decltype(dst.m_Header.ulMajorEscapeCode)>(*tokM_Header); 13234 } break; 13235 case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UI_MINOR_ESCAPE_CODE: { 13236 dst.m_Header.uiMinorEscapeCode = readTokValue<decltype(dst.m_Header.uiMinorEscapeCode)>(*tokM_Header); 13237 } break; 13238 }; 13239 tokM_Header = tokM_Header + 1 + tokM_Header->valueDwordCount; 13240 } else { 13241 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokM_Header); 13242 if (tokM_Header->flags.flag3IsMandatory) { 13243 return false; 13244 } 13245 tokM_Header = tokM_Header + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 13246 } 13247 } 13248 WCH_ASSERT(tokM_Header == tokM_HeaderEnd); 13249 } break; 13250 case TOK_FS_TIME_STAMP_DATA_HEADER__M_DATA: { 13251 const TokenHeader *tokM_Data = varLen->getValue<TokenHeader>(); 13252 const TokenHeader *tokM_DataEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 13253 while (tokM_Data < tokM_DataEnd) { 13254 if (false == tokM_Data->flags.flag4IsVariableLength) { 13255 if (tokM_Data->flags.flag3IsMandatory) { 13256 return false; 13257 } 13258 tokM_Data = tokM_Data + 1 + tokM_Data->valueDwordCount; 13259 } else { 13260 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokM_Data); 13261 switch (tokM_Data->id) { 13262 default: 13263 if (tokM_Data->flags.flag3IsMandatory) { 13264 return false; 13265 } 13266 break; 13267 case TOK_FXS_TIME_STAMP_DATA_HEADER__ANONYMOUS2466__M_IN: { 13268 const TokenHeader *tokM_In = varLen->getValue<TokenHeader>(); 13269 const TokenHeader *tokM_InEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 13270 while (tokM_In < tokM_InEnd) { 13271 if (false == tokM_In->flags.flag4IsVariableLength) { 13272 switch (tokM_In->id) { 13273 default: 13274 if (tokM_In->flags.flag3IsMandatory) { 13275 return false; 13276 } 13277 break; 13278 case TOK_FE_GTDIBASE_IN_STRUCT__FUNCTION: { 13279 dst.m_Data.m_In.Function = readTokValue<decltype(dst.m_Data.m_In.Function)>(*tokM_In); 13280 } break; 13281 }; 13282 tokM_In = tokM_In + 1 + tokM_In->valueDwordCount; 13283 } else { 13284 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokM_In); 13285 if (tokM_In->flags.flag3IsMandatory) { 13286 return false; 13287 } 13288 tokM_In = tokM_In + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 13289 } 13290 } 13291 WCH_ASSERT(tokM_In == tokM_InEnd); 13292 } break; 13293 case TOK_FS_TIME_STAMP_DATA_HEADER__ANONYMOUS2466__M_OUT: { 13294 const TokenHeader *tokM_Out = varLen->getValue<TokenHeader>(); 13295 const TokenHeader *tokM_OutEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader); 13296 while (tokM_Out < tokM_OutEnd) { 13297 if (false == tokM_Out->flags.flag4IsVariableLength) { 13298 switch (tokM_Out->id) { 13299 default: 13300 if (tokM_Out->flags.flag3IsMandatory) { 13301 return false; 13302 } 13303 break; 13304 case TOK_FE_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__RET_CODE: { 13305 dst.m_Data.m_Out.RetCode = readTokValue<decltype(dst.m_Data.m_Out.RetCode)>(*tokM_Out); 13306 } break; 13307 case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__GPU_PERF_TICKS: { 13308 dst.m_Data.m_Out.gpuPerfTicks = readTokValue<decltype(dst.m_Data.m_Out.gpuPerfTicks)>(*tokM_Out); 13309 } break; 13310 case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__CPU_PERF_TICKS: { 13311 dst.m_Data.m_Out.cpuPerfTicks = readTokValue<decltype(dst.m_Data.m_Out.cpuPerfTicks)>(*tokM_Out); 13312 } break; 13313 case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__GPU_PERF_FREQ: { 13314 dst.m_Data.m_Out.gpuPerfFreq = readTokValue<decltype(dst.m_Data.m_Out.gpuPerfFreq)>(*tokM_Out); 13315 } break; 13316 case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__CPU_PERF_FREQ: { 13317 dst.m_Data.m_Out.cpuPerfFreq = readTokValue<decltype(dst.m_Data.m_Out.cpuPerfFreq)>(*tokM_Out); 13318 } break; 13319 }; 13320 tokM_Out = tokM_Out + 1 + tokM_Out->valueDwordCount; 13321 } else { 13322 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokM_Out); 13323 if (tokM_Out->flags.flag3IsMandatory) { 13324 return false; 13325 } 13326 tokM_Out = tokM_Out + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 13327 } 13328 } 13329 WCH_ASSERT(tokM_Out == tokM_OutEnd); 13330 } break; 13331 }; 13332 tokM_Data = tokM_Data + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 13333 } 13334 } 13335 WCH_ASSERT(tokM_Data == tokM_DataEnd); 13336 } break; 13337 }; 13338 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; 13339 } 13340 } 13341 WCH_ASSERT(tok == srcTokensEnd); 13342 return true; 13343 } 13344 }; 13345