From b80a51e5bf4be958a0c0b1d17ac77ecab7b8577f Mon Sep 17 00:00:00 2001 From: Jaroslaw Chodor Date: Sat, 5 Jun 2021 12:09:29 +0200 Subject: [PATCH] Adding wsl_compute_helper Signed-off-by: Jaroslaw Chodor --- CMakeLists.txt | 2 +- level_zero/CMakeLists.txt | 7 + .../core/test/unit_tests/CMakeLists.txt | 7 + .../test/unit_tests/CMakeLists.txt | 8 + .../tools/test/unit_tests/CMakeLists.txt | 6 + opencl/test/unit_test/CMakeLists.txt | 6 + .../test/unit_test/aub_tests/CMakeLists.txt | 6 + .../unit_test/gen12lp/linux/CMakeLists.txt | 14 + .../linux/hw_info_config_tests_gen12lp.cpp | 30 + opencl/test/unit_test/linux/CMakeLists.txt | 6 + .../test/unit_test/linux/main_linux_dll.cpp | 6 + opencl/test/unit_test/mt_tests/CMakeLists.txt | 5 + .../linux/hw_info_config_linux_tests.cpp | 14 - .../unit_test/os_interface/linux/options.cpp | 2 + .../test/unit_test/test_files/igdrcl.config | 3 +- shared/source/CMakeLists.txt | 1 + .../debug_settings/debug_variables_base.inl | 1 + .../create_direct_submission_hw.inl | 15 + .../create_direct_submission_hw.inl | 20 + .../create_direct_submission_hw.inl | 15 + .../direct_submission_hw.inl | 2 + .../linux/drm_direct_submission.inl | 5 - .../windows/wddm_direct_submission.h | 6 +- .../windows/wddm_direct_submission.inl | 5 - .../gen12lp/linux/hw_info_config_gen12lp.cpp | 39 + .../create_os_time_drm_or_wddm.cpp | 2 +- .../os_interface/windows/CMakeLists.txt | 3 +- .../os_interface/windows/device_time_wddm.cpp | 2 +- .../os_interface/windows/device_time_wddm.h | 4 +- .../os_interface/windows/gfx_escape_wrapper.h | 36 + .../os_interface/windows/sharedata_wrapper.h | 208 + .../wddm/create_um_km_data_translator.cpp | 212 +- .../windows/wddm/um_km_data_translator.cpp | 2 +- .../windows/wddm/um_km_data_translator.h | 7 +- .../source/os_interface/windows/wddm/wddm.cpp | 11 +- .../operations/windows/sku_info_receiver.cpp | 4 +- .../operations/windows/sku_info_receiver.h | 12 +- shared/test/unit_test/CMakeLists.txt | 6 + .../windows/um_km_data_translator_tests.cpp | 196 +- shared/wsl_compute_helper/CMakeLists.txt | 5 + .../wsl_compute_helper/source/CMakeLists.txt | 24 + .../source/gmm_resource_info_accessor.h | 60 + .../source/gmm_resource_info_struct.h | 69 + .../source/wsl_compute_helper.h | 36 + .../wsl_compute_helper_types_demarshall.cpp | 9 + .../wsl_compute_helper_types_demarshall.h | 13336 ++++++++++++++++ .../wsl_compute_helper_types_marshall.cpp | 9 + .../wsl_compute_helper_types_marshall.h | 4140 +++++ .../source/wsl_compute_helper_types_tokens.h | 896 ++ .../wsl_compute_helper_types_tokens_structs.h | 1864 +++ 50 files changed, 21331 insertions(+), 53 deletions(-) create mode 100644 opencl/test/unit_test/gen12lp/linux/CMakeLists.txt create mode 100644 opencl/test/unit_test/gen12lp/linux/hw_info_config_tests_gen12lp.cpp create mode 100644 shared/source/direct_submission/create_direct_submission_drm/create_direct_submission_hw.inl create mode 100644 shared/source/direct_submission/create_direct_submission_drm_or_wddm/create_direct_submission_hw.inl create mode 100644 shared/source/direct_submission/create_direct_submission_wddm/create_direct_submission_hw.inl create mode 100644 shared/source/os_interface/windows/gfx_escape_wrapper.h create mode 100644 shared/source/os_interface/windows/sharedata_wrapper.h create mode 100644 shared/wsl_compute_helper/CMakeLists.txt create mode 100644 shared/wsl_compute_helper/source/CMakeLists.txt create mode 100644 shared/wsl_compute_helper/source/gmm_resource_info_accessor.h create mode 100644 shared/wsl_compute_helper/source/gmm_resource_info_struct.h create mode 100644 shared/wsl_compute_helper/source/wsl_compute_helper.h create mode 100644 shared/wsl_compute_helper/source/wsl_compute_helper_types_demarshall.cpp create mode 100644 shared/wsl_compute_helper/source/wsl_compute_helper_types_demarshall.h create mode 100644 shared/wsl_compute_helper/source/wsl_compute_helper_types_marshall.cpp create mode 100644 shared/wsl_compute_helper/source/wsl_compute_helper_types_marshall.h create mode 100644 shared/wsl_compute_helper/source/wsl_compute_helper_types_tokens.h create mode 100644 shared/wsl_compute_helper/source/wsl_compute_helper_types_tokens_structs.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 5c2eced94f..94e15420fb 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -123,7 +123,7 @@ if(WIN32 OR NOT DISABLE_WDDM_LINUX) add_definitions(-D_CRT_SECURE_NO_WARNINGS -DWDDM_VERSION_NUMBER=23 -DNOMINMAX) add_definitions(-DLEGACY_D3DAPI_VERSION=20) if(NOT WIN32) - add_definitions(-DWDDM_LINUX=1 -DLHDM=1 -DDXGKDDI_INTERFACE_VERSION_WDDM2_0=1) + add_definitions(-DWDDM_LINUX=1 -DDXGKDDI_INTERFACE_VERSION_WDDM2_0=1) endif() endif() diff --git a/level_zero/CMakeLists.txt b/level_zero/CMakeLists.txt index d52ba648be..cd16ed9d94 100644 --- a/level_zero/CMakeLists.txt +++ b/level_zero/CMakeLists.txt @@ -270,6 +270,13 @@ if(BUILD_WITH_L0) ${COMPUTE_RUNTIME_DIR}/opencl/source/dll/linux/options_linux.cpp ${COMPUTE_RUNTIME_DIR}/opencl/source/dll/linux/os_interface.cpp ) + if(NOT DISABLE_WDDM_LINUX) + target_sources(${TARGET_NAME_L0} + PRIVATE + ${NEO_SHARED_DIRECTORY}/gmm_helper/windows/gmm_memory.cpp + ${NEO_SHARED_DIRECTORY}/os_interface/windows/wddm/wddm_create.cpp + ) + endif() endif() if(DEFINED AUB_STREAM_PROJECT_NAME) diff --git a/level_zero/core/test/unit_tests/CMakeLists.txt b/level_zero/core/test/unit_tests/CMakeLists.txt index 93f3459894..7d79635601 100644 --- a/level_zero/core/test/unit_tests/CMakeLists.txt +++ b/level_zero/core/test/unit_tests/CMakeLists.txt @@ -60,6 +60,13 @@ if(UNIX) ${COMPUTE_RUNTIME_DIR}/opencl/test/unit_test/os_interface/linux/options.cpp ${COMPUTE_RUNTIME_DIR}/opencl/test/unit_test/os_interface/linux/sys_calls_linux_ult.cpp ) + if(NOT DISABLE_WDDM_LINUX) + target_sources(${TARGET_NAME} PRIVATE + ${NEO_SHARED_DIRECTORY}/gmm_helper/windows/gmm_memory.cpp + ${NEO_SHARED_DIRECTORY}/os_interface/windows/wddm/wddm_create.cpp + ) + + endif() else() target_sources(${TARGET_NAME} PRIVATE ${COMPUTE_RUNTIME_DIR}/opencl/test/unit_test/os_interface/windows/create_wddm_memory_manager.cpp diff --git a/level_zero/experimental/test/unit_tests/CMakeLists.txt b/level_zero/experimental/test/unit_tests/CMakeLists.txt index 6f0f1bd12c..cefc97ca95 100644 --- a/level_zero/experimental/test/unit_tests/CMakeLists.txt +++ b/level_zero/experimental/test/unit_tests/CMakeLists.txt @@ -69,6 +69,14 @@ if(UNIX) ${COMPUTE_RUNTIME_DIR}/opencl/test/unit_test/os_interface/linux/options.cpp ${COMPUTE_RUNTIME_DIR}/opencl/test/unit_test/os_interface/linux/sys_calls_linux_ult.cpp ) + if(NOT DISABLE_WDDM_LINUX) + target_sources( + ${TARGET_NAME} + PRIVATE + ${NEO_SHARED_DIRECTORY}/gmm_helper/windows/gmm_memory.cpp + ${NEO_SHARED_DIRECTORY}/os_interface/windows/wddm/wddm_create.cpp + ) + endif() else() target_sources( ${TARGET_NAME} diff --git a/level_zero/tools/test/unit_tests/CMakeLists.txt b/level_zero/tools/test/unit_tests/CMakeLists.txt index a07e8e76ad..5890a893c8 100644 --- a/level_zero/tools/test/unit_tests/CMakeLists.txt +++ b/level_zero/tools/test/unit_tests/CMakeLists.txt @@ -57,6 +57,12 @@ if(UNIX) ${COMPUTE_RUNTIME_DIR}/opencl/test/unit_test/os_interface/linux/options.cpp ${COMPUTE_RUNTIME_DIR}/opencl/test/unit_test/os_interface/linux/sys_calls_linux_ult.cpp ) + if(NOT DISABLE_WDDM_LINUX) + target_sources(${TARGET_NAME} PRIVATE + ${NEO_SHARED_DIRECTORY}/gmm_helper/windows/gmm_memory.cpp + ${NEO_SHARED_DIRECTORY}/os_interface/windows/wddm/wddm_create.cpp + ) + endif() else() target_sources(${TARGET_NAME} PRIVATE ${COMPUTE_RUNTIME_DIR}/opencl/test/unit_test/os_interface/windows/create_wddm_memory_manager.cpp diff --git a/opencl/test/unit_test/CMakeLists.txt b/opencl/test/unit_test/CMakeLists.txt index 042c6d2009..26942a1e00 100644 --- a/opencl/test/unit_test/CMakeLists.txt +++ b/opencl/test/unit_test/CMakeLists.txt @@ -54,6 +54,12 @@ set(IGDRCL_SRCS_tests_local if(WIN32) list(APPEND IGDRCL_SRCS_tests_local ${NEO_SOURCE_DIR}/opencl/test/unit_test/os_interface/windows/wddm_create.cpp) +else() + if(NOT DISABLE_WDDM_LINUX) + list(APPEND IGDRCL_SRCS_tests_local ${NEO_SHARED_DIRECTORY}/gmm_helper/windows/gmm_memory.cpp + ${NEO_SHARED_DIRECTORY}/os_interface/windows/wddm/wddm_create.cpp + ) + endif() endif() add_subdirectory(libult) diff --git a/opencl/test/unit_test/aub_tests/CMakeLists.txt b/opencl/test/unit_test/aub_tests/CMakeLists.txt index 152cb75de0..87336960aa 100644 --- a/opencl/test/unit_test/aub_tests/CMakeLists.txt +++ b/opencl/test/unit_test/aub_tests/CMakeLists.txt @@ -72,6 +72,12 @@ else() ${NEO_SHARED_DIRECTORY}/os_interface/linux/gmm_interface_linux.cpp ${NEO_SOURCE_DIR}/opencl/test/unit_test/os_interface/linux/drm_neo_create.cpp ) + if(NOT DISABLE_WDDM_LINUX) + target_sources(igdrcl_aub_tests PRIVATE + ${NEO_SHARED_DIRECTORY}/gmm_helper/windows/gmm_memory.cpp + ${NEO_SHARED_DIRECTORY}/os_interface/windows/wddm/wddm_create.cpp + ) + endif() endif() copy_gmm_dll_for(igdrcl_aub_tests) diff --git a/opencl/test/unit_test/gen12lp/linux/CMakeLists.txt b/opencl/test/unit_test/gen12lp/linux/CMakeLists.txt new file mode 100644 index 0000000000..12c8a26cb0 --- /dev/null +++ b/opencl/test/unit_test/gen12lp/linux/CMakeLists.txt @@ -0,0 +1,14 @@ +# +# Copyright (C) 2021 Intel Corporation +# +# SPDX-License-Identifier: MIT +# + +set(IGDRCL_SRCS_tests_gen12lp_linux + ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt + ${CMAKE_CURRENT_SOURCE_DIR}/hw_info_config_tests_gen12lp.cpp +) +if(NOT WIN32) + target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen12lp_linux}) + add_subdirectories() +endif() diff --git a/opencl/test/unit_test/gen12lp/linux/hw_info_config_tests_gen12lp.cpp b/opencl/test/unit_test/gen12lp/linux/hw_info_config_tests_gen12lp.cpp new file mode 100644 index 0000000000..f282e62987 --- /dev/null +++ b/opencl/test/unit_test/gen12lp/linux/hw_info_config_tests_gen12lp.cpp @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2021 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "shared/source/helpers/hw_helper.h" +#include "shared/source/os_interface/os_interface.h" +#include "shared/test/common/helpers/debug_manager_state_restore.h" +#include "shared/test/common/helpers/default_hw_info.h" + +#include "opencl/extensions/public/cl_ext_private.h" +#include "opencl/test/unit_test/os_interface/linux/hw_info_config_linux_tests.h" + +using namespace NEO; + +using HwInfoConfigTestWindowsGen12lp = HwInfoConfigTestLinux; + +GEN12LPTEST_F(HwInfoConfigTestWindowsGen12lp, givenGen12LpProductWhenAdjustPlatformForProductFamilyCalledThenOverrideWithCorrectFamily) { + auto hwInfoConfig = HwInfoConfig::get(productFamily); + + PLATFORM *testPlatform = &outHwInfo.platform; + testPlatform->eDisplayCoreFamily = IGFX_GEN11_CORE; + testPlatform->eRenderCoreFamily = IGFX_GEN11_CORE; + hwInfoConfig->adjustPlatformForProductFamily(&outHwInfo); + + EXPECT_EQ(IGFX_GEN12LP_CORE, testPlatform->eRenderCoreFamily); + EXPECT_EQ(IGFX_GEN12LP_CORE, testPlatform->eDisplayCoreFamily); +} diff --git a/opencl/test/unit_test/linux/CMakeLists.txt b/opencl/test/unit_test/linux/CMakeLists.txt index 3cba562acf..40ae634ff0 100644 --- a/opencl/test/unit_test/linux/CMakeLists.txt +++ b/opencl/test/unit_test/linux/CMakeLists.txt @@ -35,6 +35,12 @@ if(NEO__LIBVA_FOUND) target_sources(igdrcl_${target_name} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/va_tests.cpp) endif() +if(NOT DISABLE_WDDM_LINUX) + target_sources(igdrcl_${target_name} PRIVATE ${NEO_SHARED_DIRECTORY}/os_interface/windows/wddm/wddm_create.cpp + ${NEO_SHARED_DIRECTORY}/gmm_helper/windows/gmm_memory.cpp + ) +endif() + target_link_libraries(igdrcl_${target_name} ${NEO_STATICALLY_LINKED_LIBRARIES_MOCKABLE} igdrcl_mocks ${NEO_STATICALLY_LINKED_LIBRARIES_MOCKABLE} ${IGDRCL_EXTRA_LIBS} gmock-gtest) set_property(TARGET igdrcl_${target_name} APPEND_STRING PROPERTY COMPILE_FLAGS ${ASAN_FLAGS}) diff --git a/opencl/test/unit_test/linux/main_linux_dll.cpp b/opencl/test/unit_test/linux/main_linux_dll.cpp index ffefebdb59..a7ab1c0c5b 100644 --- a/opencl/test/unit_test/linux/main_linux_dll.cpp +++ b/opencl/test/unit_test/linux/main_linux_dll.cpp @@ -27,9 +27,14 @@ #include "gmock/gmock.h" #include "gtest/gtest.h" +#include "os_inc.h" #include +namespace Os { +extern const char *dxcoreDllName; +} + namespace NEO { void __attribute__((destructor)) platformsDestructor(); } @@ -693,6 +698,7 @@ int main(int argc, char **argv) { initializeTestedDevice(); + Os::dxcoreDllName = ""; auto retVal = RUN_ALL_TESTS(); return retVal; diff --git a/opencl/test/unit_test/mt_tests/CMakeLists.txt b/opencl/test/unit_test/mt_tests/CMakeLists.txt index b2d56ba8f2..b9be0ca633 100644 --- a/opencl/test/unit_test/mt_tests/CMakeLists.txt +++ b/opencl/test/unit_test/mt_tests/CMakeLists.txt @@ -53,6 +53,11 @@ else() target_sources(igdrcl_mt_tests PRIVATE ${NEO_SOURCE_DIR}/opencl/test/unit_test/os_interface/linux/drm_neo_create.cpp ) + if(NOT DISABLE_WDDM_LINUX) + target_sources(igdrcl_mt_tests PRIVATE + ${NEO_SHARED_DIRECTORY}/os_interface/windows/wddm/wddm_create.cpp + ) + endif() endif() if(WIN32) diff --git a/opencl/test/unit_test/os_interface/linux/hw_info_config_linux_tests.cpp b/opencl/test/unit_test/os_interface/linux/hw_info_config_linux_tests.cpp index dfd85ac916..51e93d2f1b 100644 --- a/opencl/test/unit_test/os_interface/linux/hw_info_config_linux_tests.cpp +++ b/opencl/test/unit_test/os_interface/linux/hw_info_config_linux_tests.cpp @@ -539,20 +539,6 @@ TEST_F(HwInfoConfigTestLinuxDummy, givenFailingGttSizeIoctlWhenInitializingHwInf EXPECT_EQ(pInHwInfo.capabilityTable.gpuAddressSpace, outHwInfo.capabilityTable.gpuAddressSpace); } -TEST(HwInfoConfigLinuxTest, whenAdjustPlatformForProductFamilyCalledThenDoNothing) { - HardwareInfo localHwInfo = *defaultHwInfo; - - auto hwInfoConfig = HwInfoConfig::get(localHwInfo.platform.eProductFamily); - - localHwInfo.platform.eDisplayCoreFamily = GFXCORE_FAMILY::IGFX_UNKNOWN_CORE; - localHwInfo.platform.eRenderCoreFamily = GFXCORE_FAMILY::IGFX_UNKNOWN_CORE; - - hwInfoConfig->adjustPlatformForProductFamily(&localHwInfo); - - EXPECT_EQ(GFXCORE_FAMILY::IGFX_UNKNOWN_CORE, localHwInfo.platform.eRenderCoreFamily); - EXPECT_EQ(GFXCORE_FAMILY::IGFX_UNKNOWN_CORE, localHwInfo.platform.eDisplayCoreFamily); -} - using HwConfigLinux = ::testing::Test; HWTEST2_F(HwConfigLinux, GivenDifferentValuesFromTopologyQueryWhenConfiguringHwInfoThenMaxSlicesSupportedSetToAvailableCountInGtSystemInfo, MatchAny) { diff --git a/opencl/test/unit_test/os_interface/linux/options.cpp b/opencl/test/unit_test/os_interface/linux/options.cpp index 3ca596f1fd..afca65f8b4 100644 --- a/opencl/test/unit_test/os_interface/linux/options.cpp +++ b/opencl/test/unit_test/os_interface/linux/options.cpp @@ -24,6 +24,8 @@ const char *gmmDllName = "libmock_gmm.so"; const char *gmmInitFuncName = "initMockGmm"; const char *gmmDestroyFuncName = "destroyMockGmm"; const char *metricsLibraryDllName = ""; +const char *gdiDllName = ""; +const char *dxcoreDllName = ""; #endif const char *sysFsPciPathPrefix = "./test_files/linux/devices/"; const char *pciDevicesDirectory = "./test_files/linux/by-path"; diff --git a/opencl/test/unit_test/test_files/igdrcl.config b/opencl/test/unit_test/test_files/igdrcl.config index 43080b545b..fd48ffe877 100644 --- a/opencl/test/unit_test/test_files/igdrcl.config +++ b/opencl/test/unit_test/test_files/igdrcl.config @@ -245,4 +245,5 @@ OverrideTimestampPacketSize = -1 ClDeviceGlobalMemSizeAvailablePercent = -1 DebugApiUsed = 0 ForceHostPointerImport = -1 -OverrideMaxWorkGroupCount = -1 \ No newline at end of file +OverrideMaxWorkGroupCount = -1 +UseUmKmDataTranslator = 0 diff --git a/shared/source/CMakeLists.txt b/shared/source/CMakeLists.txt index c678ddb38f..a04399161c 100644 --- a/shared/source/CMakeLists.txt +++ b/shared/source/CMakeLists.txt @@ -39,6 +39,7 @@ function(generate_shared_lib LIB_NAME MOCKABLE) ${NEO__IGC_INCLUDE_DIR} ${KHRONOS_HEADERS_DIR} ${SOURCE_LEVEL_DEBUGGER_HEADERS_DIR} + ${CMAKE_CURRENT_SOURCE_DIR}/direct_submission/create_direct_submission_${DRIVER_MODEL} ) if(WIN32 OR NOT DISABLE_WDDM_LINUX) diff --git a/shared/source/debug_settings/debug_variables_base.inl b/shared/source/debug_settings/debug_variables_base.inl index 32b9611f6e..853a8aea83 100644 --- a/shared/source/debug_settings/debug_variables_base.inl +++ b/shared/source/debug_settings/debug_variables_base.inl @@ -264,3 +264,4 @@ DECLARE_DEBUG_VARIABLE(bool, ForcePerDssBackedBufferProgramming, false, "Always DECLARE_DEBUG_VARIABLE(bool, DisableAtomicForPostSyncs, false, "When enabled, post syncs are not tracked with atomics") DECLARE_DEBUG_VARIABLE(bool, UseCommandBufferHeaderSizeForWddmQueueSubmission, true, "0: Page size (4096), 1: sizeof(COMMAND_BUFFER_HEADER)") DECLARE_DEBUG_VARIABLE(bool, DisableDeepBind, false, "Disable passing RTLD_DEEPBIND flag to all dlopen calls.") +DECLARE_DEBUG_VARIABLE(bool, UseUmKmDataTranslator, false, "Use helper library for UMD<->KMD (WDDM) struct layout compatibility") diff --git a/shared/source/direct_submission/create_direct_submission_drm/create_direct_submission_hw.inl b/shared/source/direct_submission/create_direct_submission_drm/create_direct_submission_hw.inl new file mode 100644 index 0000000000..4852a472c0 --- /dev/null +++ b/shared/source/direct_submission/create_direct_submission_drm/create_direct_submission_hw.inl @@ -0,0 +1,15 @@ +/* + * Copyright (C) 2021 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "shared/source/direct_submission/linux/drm_direct_submission.h" + +namespace NEO { +template +inline std::unique_ptr> DirectSubmissionHw::create(Device &device, OsContext &osContext) { + return std::make_unique>(device, osContext); +} +} // namespace NEO diff --git a/shared/source/direct_submission/create_direct_submission_drm_or_wddm/create_direct_submission_hw.inl b/shared/source/direct_submission/create_direct_submission_drm_or_wddm/create_direct_submission_hw.inl new file mode 100644 index 0000000000..24bb81087c --- /dev/null +++ b/shared/source/direct_submission/create_direct_submission_drm_or_wddm/create_direct_submission_hw.inl @@ -0,0 +1,20 @@ +/* + * Copyright (C) 2021 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "shared/source/direct_submission/linux/drm_direct_submission.h" +#include "shared/source/direct_submission/windows/wddm_direct_submission.h" + +namespace NEO { +template +inline std::unique_ptr> DirectSubmissionHw::create(Device &device, OsContext &osContext) { + if (device.getRootDeviceEnvironment().osInterface->getDriverModel()->getDriverModelType() == DriverModelType::DRM) { + return std::make_unique>(device, osContext); + } else { + return std::make_unique>(device, osContext); + } +} +} // namespace NEO diff --git a/shared/source/direct_submission/create_direct_submission_wddm/create_direct_submission_hw.inl b/shared/source/direct_submission/create_direct_submission_wddm/create_direct_submission_hw.inl new file mode 100644 index 0000000000..a89629f31e --- /dev/null +++ b/shared/source/direct_submission/create_direct_submission_wddm/create_direct_submission_hw.inl @@ -0,0 +1,15 @@ +/* + * Copyright (C) 2021 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "shared/source/direct_submission/windows/wddm_direct_submission.h" + +namespace NEO { +template +inline std::unique_ptr> DirectSubmissionHw::create(Device &device, OsContext &osContext) { + return std::make_unique>(device, osContext); +} +} // namespace NEO diff --git a/shared/source/direct_submission/direct_submission_hw.inl b/shared/source/direct_submission/direct_submission_hw.inl index 927e13f158..52c54123db 100644 --- a/shared/source/direct_submission/direct_submission_hw.inl +++ b/shared/source/direct_submission/direct_submission_hw.inl @@ -21,6 +21,8 @@ #include "shared/source/utilities/cpu_info.h" #include "shared/source/utilities/cpuintrinsics.h" +#include "create_direct_submission_hw.inl" + #include namespace NEO { diff --git a/shared/source/direct_submission/linux/drm_direct_submission.inl b/shared/source/direct_submission/linux/drm_direct_submission.inl index 361ddf7104..befe326b3e 100644 --- a/shared/source/direct_submission/linux/drm_direct_submission.inl +++ b/shared/source/direct_submission/linux/drm_direct_submission.inl @@ -16,11 +16,6 @@ namespace NEO { -template -inline std::unique_ptr> DirectSubmissionHw::create(Device &device, OsContext &osContext) { - return std::make_unique>(device, osContext); -} - template DrmDirectSubmission::DrmDirectSubmission(Device &device, OsContext &osContext) diff --git a/shared/source/direct_submission/windows/wddm_direct_submission.h b/shared/source/direct_submission/windows/wddm_direct_submission.h index 5117b90230..c2301703a5 100644 --- a/shared/source/direct_submission/windows/wddm_direct_submission.h +++ b/shared/source/direct_submission/windows/wddm_direct_submission.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020 Intel Corporation + * Copyright (C) 2020-2021 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -8,8 +8,8 @@ #pragma once #include "shared/source/direct_submission/direct_submission_hw.h" #include "shared/source/os_interface/windows/windows_defs.h" - struct COMMAND_BUFFER_HEADER_REC; +typedef struct COMMAND_BUFFER_HEADER_REC COMMAND_BUFFER_HEADER; namespace NEO { @@ -37,6 +37,6 @@ class WddmDirectSubmission : public DirectSubmissionHw { OsContextWin *osContextWin; Wddm *wddm; MonitoredFence ringFence; - std::unique_ptr commandBufferHeader; + std::unique_ptr commandBufferHeader; }; } // namespace NEO diff --git a/shared/source/direct_submission/windows/wddm_direct_submission.inl b/shared/source/direct_submission/windows/wddm_direct_submission.inl index e5ee3f18e9..a2dc3f7ca2 100644 --- a/shared/source/direct_submission/windows/wddm_direct_submission.inl +++ b/shared/source/direct_submission/windows/wddm_direct_submission.inl @@ -21,11 +21,6 @@ namespace NEO { // Initialize COMMAND_BUFFER_HEADER Type PatchList Streamer Perf Tag DECLARE_COMMAND_BUFFER(CommandBufferHeader, UMD_OCL, FALSE, FALSE, PERFTAG_OCL); -template -inline std::unique_ptr> DirectSubmissionHw::create(Device &device, OsContext &osContext) { - return std::make_unique>(device, osContext); -} - template WddmDirectSubmission::WddmDirectSubmission(Device &device, OsContext &osContext) diff --git a/shared/source/gen12lp/linux/hw_info_config_gen12lp.cpp b/shared/source/gen12lp/linux/hw_info_config_gen12lp.cpp index 4d32a626e5..3e6adb6604 100644 --- a/shared/source/gen12lp/linux/hw_info_config_gen12lp.cpp +++ b/shared/source/gen12lp/linux/hw_info_config_gen12lp.cpp @@ -8,15 +8,54 @@ #include "shared/source/os_interface/hw_info_config.inl" #include "shared/source/os_interface/hw_info_config_bdw_plus.inl" +namespace NEO { +namespace Gen12LPCommonFunctions { +inline void adjustPlatformForProductFamily(PLATFORM &platform, GFXCORE_FAMILY newCoreFamily) { + platform.eRenderCoreFamily = IGFX_GEN12LP_CORE; + platform.eDisplayCoreFamily = IGFX_GEN12LP_CORE; +} + +} // namespace Gen12LPCommonFunctions + +} // namespace NEO + #ifdef SUPPORT_TGLLP +namespace NEO { +template <> +void HwInfoConfigHw::adjustPlatformForProductFamily(HardwareInfo *hwInfo) { + Gen12LPCommonFunctions::adjustPlatformForProductFamily(hwInfo->platform, GFXCORE_FAMILY::IGFX_GEN12LP_CORE); +} +} // namespace NEO + #include "hw_info_config_tgllp.inl" #endif #ifdef SUPPORT_DG1 +namespace NEO { +template <> +void HwInfoConfigHw::adjustPlatformForProductFamily(HardwareInfo *hwInfo) { + Gen12LPCommonFunctions::adjustPlatformForProductFamily(hwInfo->platform, GFXCORE_FAMILY::IGFX_GEN12LP_CORE); +} +} // namespace NEO + #include "hw_info_config_dg1.inl" #endif #ifdef SUPPORT_RKL +namespace NEO { +template <> +void HwInfoConfigHw::adjustPlatformForProductFamily(HardwareInfo *hwInfo) { + Gen12LPCommonFunctions::adjustPlatformForProductFamily(hwInfo->platform, GFXCORE_FAMILY::IGFX_GEN12LP_CORE); +} +} // namespace NEO + #include "hw_info_config_rkl.inl" #endif #ifdef SUPPORT_ADLS +namespace NEO { +template <> +void HwInfoConfigHw::adjustPlatformForProductFamily(HardwareInfo *hwInfo) { + Gen12LPCommonFunctions::adjustPlatformForProductFamily(hwInfo->platform, GFXCORE_FAMILY::IGFX_GEN12LP_CORE); +} +} // namespace NEO + #include "hw_info_config_adls.inl" #endif \ No newline at end of file diff --git a/shared/source/os_interface/create_os_time_drm_or_wddm.cpp b/shared/source/os_interface/create_os_time_drm_or_wddm.cpp index 7071e77560..2df2939dc3 100644 --- a/shared/source/os_interface/create_os_time_drm_or_wddm.cpp +++ b/shared/source/os_interface/create_os_time_drm_or_wddm.cpp @@ -14,7 +14,7 @@ namespace NEO { std::unique_ptr OSTime::create(OSInterface *osInterface) { - if (osInterface->getDriverModel()->getDriverModelType() == DriverModelType::DRM) { + if ((nullptr == osInterface) || (osInterface->getDriverModel()->getDriverModelType() == DriverModelType::DRM)) { return OSTimeLinux::create(osInterface, std::make_unique(osInterface)); } else { auto wddm = osInterface->getDriverModel()->as(); diff --git a/shared/source/os_interface/windows/CMakeLists.txt b/shared/source/os_interface/windows/CMakeLists.txt index 3f2a3b2dc8..14dabd3a5f 100644 --- a/shared/source/os_interface/windows/CMakeLists.txt +++ b/shared/source/os_interface/windows/CMakeLists.txt @@ -63,6 +63,7 @@ set(NEO_CORE_OS_INTERFACE_WDDM ${CMAKE_CURRENT_SOURCE_DIR}/os_context_win.h ${CMAKE_CURRENT_SOURCE_DIR}/os_environment_win.cpp ${CMAKE_CURRENT_SOURCE_DIR}/os_environment_win.h + ${CMAKE_CURRENT_SOURCE_DIR}/sharedata_wrapper.h ${CMAKE_CURRENT_SOURCE_DIR}/sys_calls.h ${CMAKE_CURRENT_SOURCE_DIR}/thk_wrapper.h ${CMAKE_CURRENT_SOURCE_DIR}/wddm/adapter_info.cpp @@ -82,7 +83,7 @@ set(NEO_CORE_OS_INTERFACE_WDDM ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/wddm_memory_manager_allocate_in_device_pool.cpp ${CMAKE_CURRENT_SOURCE_DIR}/wddm/um_km_data_translator.cpp ${CMAKE_CURRENT_SOURCE_DIR}/wddm/um_km_data_translator.h - ${CMAKE_CURRENT_SOURCE_DIR}/wddm${BRANCH_DIR_SUFFIX}/create_um_km_data_translator.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/wddm/create_um_km_data_translator.cpp ${CMAKE_CURRENT_SOURCE_DIR}/wddm/wddm_interface.cpp ${CMAKE_CURRENT_SOURCE_DIR}/wddm/wddm_interface.h ${CMAKE_CURRENT_SOURCE_DIR}/wddm_allocation.h diff --git a/shared/source/os_interface/windows/device_time_wddm.cpp b/shared/source/os_interface/windows/device_time_wddm.cpp index de8c12279d..cc4a613103 100644 --- a/shared/source/os_interface/windows/device_time_wddm.cpp +++ b/shared/source/os_interface/windows/device_time_wddm.cpp @@ -26,7 +26,7 @@ bool runEscape(Wddm *wddm, TimeStampDataHeader &escapeInfo) { GTDIGetGpuCpuTimestampsIn in = {GTDI_FNC_GET_GPU_CPU_TIMESTAMPS}; uint32_t outSize = sizeof(GTDIGetGpuCpuTimestampsOut); - escapeInfo.m_Header.EscapeCode = GFX_ESCAPE_IGPA_INSTRUMENTATION_CONTROL; + escapeInfo.m_Header.EscapeCode = static_cast(GFX_ESCAPE_IGPA_INSTRUMENTATION_CONTROL); escapeInfo.m_Header.Size = outSize; escapeInfo.m_Data.m_In = in; diff --git a/shared/source/os_interface/windows/device_time_wddm.h b/shared/source/os_interface/windows/device_time_wddm.h index 9a22bfeaf5..33ca111f88 100644 --- a/shared/source/os_interface/windows/device_time_wddm.h +++ b/shared/source/os_interface/windows/device_time_wddm.h @@ -7,9 +7,9 @@ #pragma once #include "shared/source/os_interface/os_time.h" -#include "shared/source/os_interface/windows/windows_wrapper.h" +#include "shared/source/os_interface/windows/gfx_escape_wrapper.h" -#include "gfxEscape.h" +#define GFX_ESCAPE_IGPA_INSTRUMENTATION_CONTROL 12 namespace NEO { class Wddm; diff --git a/shared/source/os_interface/windows/gfx_escape_wrapper.h b/shared/source/os_interface/windows/gfx_escape_wrapper.h new file mode 100644 index 0000000000..35c28758c6 --- /dev/null +++ b/shared/source/os_interface/windows/gfx_escape_wrapper.h @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2021 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#pragma once + +#include "shared/source/os_interface/windows/windows_wrapper.h" + +#ifdef _WIN32 +#include "gfxEscape.h" +#else // !_WIN32 +typedef struct GFX_ESCAPE_HEADER { + union { + struct + { + unsigned int Size; + unsigned int CheckSum; + unsigned int EscapeCode; + + unsigned int ulReserved; + }; + struct + { + unsigned int ulReserved1; + unsigned short usEscapeVersion; + unsigned short usFileVersion; + unsigned int ulMajorEscapeCode; + + unsigned int uiMinorEscapeCode; + }; + }; +} GFX_ESCAPE_HEADER_T; +#endif diff --git a/shared/source/os_interface/windows/sharedata_wrapper.h b/shared/source/os_interface/windows/sharedata_wrapper.h new file mode 100644 index 0000000000..a03bae1ece --- /dev/null +++ b/shared/source/os_interface/windows/sharedata_wrapper.h @@ -0,0 +1,208 @@ +/* + * Copyright (C) 2021 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#pragma once + +#include "shared/source/os_interface/windows/windows_wrapper.h" + +#include "umKmInc/sharedata.h" + +using SKU_FEATURE_TABLE_GMM = SKU_FEATURE_TABLE; +using WA_TABLE_GMM = WA_TABLE; +using ADAPTER_INFO_GMM = ADAPTER_INFO; + +#if !defined(WDDM_LINUX) +using SKU_FEATURE_TABLE_KMD = SKU_FEATURE_TABLE_GMM; +using WA_TABLE_KMD = WA_TABLE_GMM; +using ADAPTER_INFO_KMD = ADAPTER_INFO_GMM; + +inline void propagateData(ADAPTER_INFO_KMD &) { +} +#else +struct SKU_FEATURE_TABLE_KMD : SKU_FEATURE_TABLE_GMM { + bool FtrDesktop : 1; + bool FtrChannelSwizzlingXOREnabled : 1; + + bool FtrGtBigDie : 1; + bool FtrGtMediumDie : 1; + bool FtrGtSmallDie : 1; + + bool FtrGT1 : 1; + bool FtrGT1_5 : 1; + bool FtrGT2 : 1; + bool FtrGT2_5 : 1; + bool FtrGT3 : 1; + bool FtrGT4 : 1; + + bool FtrIVBM0M1Platform : 1; + bool FtrSGTPVSKUStrapPresent : 1; + bool FtrGTA : 1; + bool FtrGTC : 1; + bool FtrGTX : 1; + bool Ftr5Slice : 1; + + bool FtrGpGpuMidBatchPreempt : 1; + bool FtrGpGpuThreadGroupLevelPreempt : 1; + bool FtrGpGpuMidThreadLevelPreempt : 1; + + bool FtrIoMmuPageFaulting : 1; + bool FtrWddm2Svm : 1; + bool FtrPooledEuEnabled : 1; + + bool FtrResourceStreamer : 1; + + bool FtrPPGTT : 1; + bool FtrSVM : 1; + bool FtrEDram : 1; + bool FtrL3IACoherency : 1; + bool FtrIA32eGfxPTEs : 1; + + bool Ftr3dMidBatchPreempt : 1; + bool Ftr3dObjectLevelPreempt : 1; + bool FtrPerCtxtPreemptionGranularityControl : 1; + + bool FtrTileY : 1; + bool FtrDisplayYTiling : 1; + bool FtrTranslationTable : 1; + bool FtrUserModeTranslationTable : 1; + + bool FtrEnableGuC : 1; + + bool FtrFbc : 1; + bool FtrFbc2AddressTranslation : 1; + bool FtrFbcBlitterTracking : 1; + bool FtrFbcCpuTracking : 1; + + bool FtrVcs2 : 1; + bool FtrVEBOX : 1; + bool FtrSingleVeboxSlice : 1; + bool FtrULT : 1; + bool FtrLCIA : 1; + bool FtrGttCacheInvalidation : 1; + bool FtrTileMappedResource : 1; + bool FtrAstcHdr2D : 1; + bool FtrAstcLdr2D : 1; + + bool FtrStandardMipTailFormat : 1; + bool FtrFrameBufferLLC : 1; + bool FtrCrystalwell : 1; + bool FtrLLCBypass : 1; + bool FtrDisplayEngineS3d : 1; + bool FtrVERing : 1; + bool FtrWddm2GpuMmu : 1; + bool FtrWddm2_1_64kbPages : 1; + bool FtrWddmHwQueues : 1; + bool FtrMemTypeMocsDeferPAT : 1; + + bool FtrKmdDaf : 1; + bool FtrSimulationMode : 1; + + bool FtrE2ECompression : 1; + bool FtrLinearCCS : 1; + bool FtrCCSRing : 1; + bool FtrCCSNode : 1; + bool FtrRcsNode : 1; + bool FtrLocalMemory : 1; + bool FtrLocalMemoryAllows4KB : 1; +}; + +struct WA_TABLE_KMD : WA_TABLE_GMM { + bool WaDoNotUseMIReportPerfCount = false; + + bool WaEnablePreemptionGranularityControlByUMD = false; + bool WaSendMIFLUSHBeforeVFE = false; + bool WaReportPerfCountUseGlobalContextID = false; + bool WaDisableLSQCROPERFforOCL = false; + bool WaMsaa8xTileYDepthPitchAlignment = false; + bool WaLosslessCompressionSurfaceStride = false; + bool WaFbcLinearSurfaceStride = false; + bool Wa4kAlignUVOffsetNV12LinearSurface = false; + bool WaEncryptedEdramOnlyPartials = false; + bool WaDisableEdramForDisplayRT = false; + bool WaForcePcBbFullCfgRestore = false; + bool WaCompressedResourceRequiresConstVA21 = false; + bool WaDisablePerCtxtPreemptionGranularityControl = false; + bool WaLLCCachingUnsupported = false; + bool WaUseVAlign16OnTileXYBpp816 = false; + bool WaModifyVFEStateAfterGPGPUPreemption = false; + bool WaCSRUncachable = false; + bool WaSamplerCacheFlushBetweenRedescribedSurfaceReads = false; + bool WaRestrictPitch128KB = false; + bool WaLimit128BMediaCompr = false; + bool WaUntypedBufferCompression = false; + bool WaAuxTable16KGranular = false; + bool WaDisableFusedThreadScheduling = false; +}; + +typedef struct COMMAND_BUFFER_HEADER_REC { + uint32_t UmdContextType : 4; + uint32_t UmdPatchList : 1; + + uint32_t UmdRequestedSliceState : 3; + uint32_t UmdRequestedSubsliceCount : 3; + uint32_t UmdRequestedEUCount : 5; + + uint32_t UsesResourceStreamer : 1; + uint32_t NeedsMidBatchPreEmptionSupport : 1; + uint32_t UsesGPGPUPipeline : 1; + uint32_t RequiresCoherency : 1; + + uint32_t PerfTag; + uint64_t MonitorFenceVA; + uint64_t MonitorFenceValue; +} COMMAND_BUFFER_HEADER; + +typedef struct __GMM_GFX_PARTITIONING { + struct + { + uint64_t Base, Limit; + } Standard, + Standard64KB, + SVM, + Heap32[4]; +} GMM_GFX_PARTITIONING; + +struct CREATECONTEXT_PVTDATA { + unsigned long *pHwContextId; + uint32_t NumberOfHwContextIds; + + uint32_t ProcessID; + uint8_t IsProtectedProcess; + uint8_t IsDwm; + uint8_t IsMediaUsage; + uint8_t GpuVAContext; + BOOLEAN NoRingFlushes; +}; + +struct ADAPTER_INFO_KMD : ADAPTER_INFO_GMM { + SKU_FEATURE_TABLE_KMD SkuTable; + WA_TABLE_KMD WaTable; + GMM_GFX_PARTITIONING GfxPartition; + ADAPTER_BDF stAdapterBDF; +}; + +static constexpr COMMAND_BUFFER_HEADER initCommandBufferHeader(uint32_t umdContextType, uint32_t umdPatchList, uint32_t usesResourceStreamer, uint32_t perfTag) { + COMMAND_BUFFER_HEADER ret = {}; + ret.UmdContextType = umdContextType; + ret.UmdPatchList = umdPatchList; + ret.UsesResourceStreamer = usesResourceStreamer; + ret.PerfTag = perfTag; + return ret; +} + +#ifdef DECLARE_COMMAND_BUFFER +#undef DECLARE_COMMAND_BUFFER +#endif +#define DECLARE_COMMAND_BUFFER(VARNAME, CONTEXTTYPE, PATCHLIST, STREAMER, PERFTAG) \ + static constexpr COMMAND_BUFFER_HEADER VARNAME = initCommandBufferHeader(CONTEXTTYPE, PATCHLIST, STREAMER, PERFTAG); + +inline void propagateData(ADAPTER_INFO_KMD &adapterInfo) { + ADAPTER_INFO &base = static_cast(adapterInfo); + base.SkuTable = adapterInfo.SkuTable; + base.WaTable = adapterInfo.WaTable; +} +#endif diff --git a/shared/source/os_interface/windows/wddm/create_um_km_data_translator.cpp b/shared/source/os_interface/windows/wddm/create_um_km_data_translator.cpp index f0c77517d3..4fa2bb18d9 100644 --- a/shared/source/os_interface/windows/wddm/create_um_km_data_translator.cpp +++ b/shared/source/os_interface/windows/wddm/create_um_km_data_translator.cpp @@ -5,12 +5,222 @@ * */ +#include "shared/source/debug_settings/debug_settings_manager.h" +#include "shared/source/helpers/debug_helpers.h" +#include "shared/source/helpers/string.h" +#include "shared/source/os_interface/os_inc_base.h" +#include "shared/source/os_interface/os_library.h" +#include "shared/source/os_interface/windows/wddm/adapter_info.h" #include "shared/source/os_interface/windows/wddm/um_km_data_translator.h" +#include "shared/wsl_compute_helper/source/gmm_resource_info_accessor.h" +#include "shared/wsl_compute_helper/source/wsl_compute_helper.h" +#include "shared/wsl_compute_helper/source/wsl_compute_helper_types_demarshall.h" +#include "shared/wsl_compute_helper/source/wsl_compute_helper_types_marshall.h" +#include "shared/wsl_compute_helper/source/wsl_compute_helper_types_tokens.h" + +#include +#include namespace NEO { +extern const char *wslComputeHelperLibNameToLoad; +const char *wslComputeHelperLibNameToLoad = wslComputeHelperLibName; + +class WslComputeHelperUmKmDataTranslator; + +class WslComputeHelperGmmHandleAllocator : public GmmHandleAllocator { + public: + WslComputeHelperGmmHandleAllocator(WslComputeHelperUmKmDataTranslator *translator); + + void *createHandle(const GMM_RESOURCE_INFO *gmmResourceInfo) override; + + void destroyHandle(void *handle) override; + + size_t getHandleSize() override { + return handleSize; + } + + protected: + WslComputeHelperUmKmDataTranslator *translator = nullptr; + size_t handleSize = 0U; +}; + +class WslComputeHelperUmKmDataTranslator : public UmKmDataTranslator { + public: + WslComputeHelperUmKmDataTranslator(std::unique_ptr wslComputeHelperLibrary) + : wslComputeHelperLibrary(std::move(wslComputeHelperLibrary)) { + UNRECOVERABLE_IF(nullptr == this->wslComputeHelperLibrary); + + auto procAddr = this->wslComputeHelperLibrary->getProcAddress(getSizeRequiredForStructName); + UNRECOVERABLE_IF(nullptr == procAddr); + auto getStructSizeFn = reinterpret_cast(procAddr); + adapterInfoStructSize = getStructSizeFn(TOK_S_ADAPTER_INFO); + createContextDataStructSize = getStructSizeFn(TOK_S_CREATECONTEXT_PVTDATA); + commandBufferHeaderStructSize = getStructSizeFn(TOK_S_COMMAND_BUFFER_HEADER_REC); + gmmResourceInfoStructSize = getStructSizeFn(TOK_S_GMM_RESOURCE_INFO_WIN_STRUCT); + + procAddr = this->wslComputeHelperLibrary->getProcAddress(getSizeRequiredForTokensName); + UNRECOVERABLE_IF(nullptr == procAddr); + auto getTokensSizeFn = reinterpret_cast(procAddr); + adapterInfoTokensSize = getTokensSizeFn(TOK_S_ADAPTER_INFO); + gmmResourceInfoTokensSize = getTokensSizeFn(TOK_S_GMM_RESOURCE_INFO_WIN_STRUCT); + + procAddr = this->wslComputeHelperLibrary->getProcAddress(structToTokensName); + UNRECOVERABLE_IF(nullptr == procAddr); + structToTokensFn = reinterpret_cast(procAddr); + + procAddr = this->wslComputeHelperLibrary->getProcAddress(tokensToStructName); + UNRECOVERABLE_IF(nullptr == procAddr); + tokensToStructFn = reinterpret_cast(procAddr); + + procAddr = this->wslComputeHelperLibrary->getProcAddress(destroyStructRepresentationName); + UNRECOVERABLE_IF(nullptr == procAddr); + destroyStructFn = reinterpret_cast(procAddr); + + this->isEnabled = true; + } + + ~WslComputeHelperUmKmDataTranslator() = default; + + size_t getSizeForAdapterInfoInternalRepresentation() override { + return adapterInfoStructSize; + } + + size_t getSizeForCreateContextDataInternalRepresentation() override { + return createContextDataStructSize; + } + + size_t getSizeForCommandBufferHeaderDataInternalRepresentation() override { + return commandBufferHeaderStructSize; + } + + size_t getSizeForGmmResourceInfoInternalRepresentation() { + return gmmResourceInfoStructSize; + } + + bool translateAdapterInfoFromInternalRepresentation(ADAPTER_INFO_KMD &dst, const void *src, size_t srcSize) override { + std::vector tokData(adapterInfoTokensSize); + TokenHeader *tok = reinterpret_cast(tokData.data()); + if (false == structToTokensFn(TOK_S_ADAPTER_INFO, tok, adapterInfoTokensSize, src, srcSize)) { + return false; + } + bool success = Demarshaller::demarshall(dst, tok, tok + adapterInfoTokensSize / sizeof(TokenHeader)); + if (IGFX_TIGERLAKE_LP != 33) { + auto prod = static_cast(dst.GfxPlatform.eProductFamily); + switch (prod) { + default: + break; + case 28: + prod = IGFX_ICELAKE; + break; + case 29: + prod = IGFX_ICELAKE_LP; + break; + case 30: + prod = IGFX_LAKEFIELD; + break; + case 31: + prod = IGFX_JASPERLAKE; + break; + case 33: + prod = IGFX_TIGERLAKE_LP; + break; + case 35: + prod = IGFX_ROCKETLAKE; + break; + case 36: + prod = IGFX_ALDERLAKE_S; + break; + case 37: + prod = IGFX_ALDERLAKE_P; + break; + } + dst.GfxPlatform.eProductFamily = static_cast(prod); + } + propagateData(dst); + return success; + } + + bool translateCreateContextDataToInternalRepresentation(void *dst, size_t dstSize, const CREATECONTEXT_PVTDATA &src) override { + auto marshalled = Marshaller::marshall(src); + return tokensToStructFn(TOK_S_CREATECONTEXT_PVTDATA, dst, dstSize, &marshalled.base.header, reinterpret_cast(&marshalled + 1)); + } + + bool tranlateCommandBufferHeaderDataToInternalRepresentation(void *dst, size_t dstSize, const COMMAND_BUFFER_HEADER &src) override { + auto marshalled = Marshaller::marshall(src); + return tokensToStructFn(TOK_S_COMMAND_BUFFER_HEADER_REC, dst, dstSize, &marshalled.base.header, reinterpret_cast(&marshalled + 1)); + } + + bool translateGmmResourceInfoToInternalRepresentation(void *dst, size_t dstSize, const GMM_RESOURCE_INFO &src) { + GmmResourceInfoWinStruct resInfoPodStruct = {}; + static_cast(&src)->get(resInfoPodStruct); + auto marshalled = Marshaller::marshall(resInfoPodStruct); + return tokensToStructFn(TOK_S_GMM_RESOURCE_INFO_WIN_STRUCT, dst, dstSize, &marshalled.base.header, reinterpret_cast(&marshalled + 1)); + } + + void destroyGmmResourceInfo(void *src, size_t size) { + destroyStructFn(TOK_S_GMM_RESOURCE_INFO_WIN_STRUCT, src, size); + } + + std::unique_ptr createGmmHandleAllocator() override { + return std::make_unique(this); + } + + protected: + std::unique_ptr wslComputeHelperLibrary; + + structToTokensFPT structToTokensFn = nullptr; + tokensToStructFPT tokensToStructFn = nullptr; + destroyStructRepresentationFPT destroyStructFn = nullptr; + + size_t adapterInfoStructSize = 0U; + size_t adapterInfoTokensSize = 0U; + size_t createContextDataStructSize = 0U; + size_t commandBufferHeaderStructSize = 0U; + size_t gmmResourceInfoStructSize = 0U; + size_t gmmResourceInfoTokensSize = 0U; +}; + +WslComputeHelperGmmHandleAllocator::WslComputeHelperGmmHandleAllocator(WslComputeHelperUmKmDataTranslator *translator) + : translator(translator) { + UNRECOVERABLE_IF(nullptr == translator); + this->handleSize = translator->getSizeForGmmResourceInfoInternalRepresentation(); +} + +void *WslComputeHelperGmmHandleAllocator::createHandle(const GMM_RESOURCE_INFO *gmmResourceInfo) { + size_t sizeU64 = (translator->getSizeForGmmResourceInfoInternalRepresentation() + sizeof(uint64_t) - 1) / sizeof(uint64_t); + std::unique_ptr ret{new uint64_t[sizeU64]}; + memset(ret.get(), 0, sizeU64 * sizeof(uint64_t)); + translator->translateGmmResourceInfoToInternalRepresentation(ret.get(), sizeU64 * sizeof(uint64_t), *gmmResourceInfo); + + return ret.release(); +} + +void WslComputeHelperGmmHandleAllocator::destroyHandle(void *handle) { + translator->destroyGmmResourceInfo(handle, translator->getSizeForGmmResourceInfoInternalRepresentation()); + delete[] reinterpret_cast(handle); +} + std::unique_ptr createUmKmDataTranslator(const Gdi &gdi, D3DKMT_HANDLE adapter) { - return std::make_unique(); + bool requiresWslComputeHelper = false; +#if !defined(_WIN32) + requiresWslComputeHelper = true; +#endif + if (requiresWslComputeHelper || NEO::DebugManager.flags.UseUmKmDataTranslator.get()) { + auto wpath = queryAdapterDriverStorePath(gdi, adapter); + std::string path; + if (strlen(wslComputeHelperLibNameToLoad)) { + path.reserve(wpath.size() + 1 + strlen(wslComputeHelperLibName)); + for (wchar_t wc : wpath) { + path += static_cast(wc); + } + path.append(Os::fileSeparator); + path.append(wslComputeHelperLibNameToLoad); + } + return std::make_unique(std::unique_ptr(OsLibrary::load(path))); + } else { + return std::make_unique(); + } } } // namespace NEO diff --git a/shared/source/os_interface/windows/wddm/um_km_data_translator.cpp b/shared/source/os_interface/windows/wddm/um_km_data_translator.cpp index 7bf1127157..2cdf274758 100644 --- a/shared/source/os_interface/windows/wddm/um_km_data_translator.cpp +++ b/shared/source/os_interface/windows/wddm/um_km_data_translator.cpp @@ -15,7 +15,7 @@ size_t UmKmDataTranslator::getSizeForAdapterInfoInternalRepresentation() { return sizeof(ADAPTER_INFO); } -bool UmKmDataTranslator::translateAdapterInfoFromInternalRepresentation(ADAPTER_INFO &dst, const void *src, size_t srcSize) { +bool UmKmDataTranslator::translateAdapterInfoFromInternalRepresentation(ADAPTER_INFO_KMD &dst, const void *src, size_t srcSize) { return (0 == memcpy_s(&dst, sizeof(ADAPTER_INFO), src, srcSize)); } diff --git a/shared/source/os_interface/windows/wddm/um_km_data_translator.h b/shared/source/os_interface/windows/wddm/um_km_data_translator.h index 67f9841104..02d8d6b3a3 100644 --- a/shared/source/os_interface/windows/wddm/um_km_data_translator.h +++ b/shared/source/os_interface/windows/wddm/um_km_data_translator.h @@ -8,10 +8,9 @@ #pragma once #include "shared/source/gmm_helper/client_context/gmm_handle_allocator.h" +#include "shared/source/os_interface/windows/sharedata_wrapper.h" #include "shared/source/utilities/stackvec.h" -#include "umKmInc/sharedata.h" - #include typedef unsigned int D3DKMT_HANDLE; @@ -26,7 +25,7 @@ class UmKmDataTranslator { virtual ~UmKmDataTranslator() = default; virtual size_t getSizeForAdapterInfoInternalRepresentation(); - virtual bool translateAdapterInfoFromInternalRepresentation(ADAPTER_INFO &dst, const void *src, size_t srcSize); + virtual bool translateAdapterInfoFromInternalRepresentation(ADAPTER_INFO_KMD &dst, const void *src, size_t srcSize); virtual size_t getSizeForCreateContextDataInternalRepresentation(); virtual bool translateCreateContextDataToInternalRepresentation(void *dst, size_t dstSize, const CREATECONTEXT_PVTDATA &src); @@ -57,8 +56,10 @@ struct UmKmDataTempStorageBase { } void resize(size_t dynSize) { + auto oldSize = storage.size() * sizeof(uint64_t); storage.resize((dynSize + sizeof(uint64_t) - 1) / sizeof(uint64_t)); requestedSize = dynSize; + memset(reinterpret_cast(data()) + oldSize, 0, storage.size() * sizeof(uint64_t) - oldSize); } size_t size() const { diff --git a/shared/source/os_interface/windows/wddm/wddm.cpp b/shared/source/os_interface/windows/wddm/wddm.cpp index 5f0173479c..a0f90fade7 100644 --- a/shared/source/os_interface/windows/wddm/wddm.cpp +++ b/shared/source/os_interface/windows/wddm/wddm.cpp @@ -26,6 +26,7 @@ #include "shared/source/os_interface/windows/kmdaf_listener.h" #include "shared/source/os_interface/windows/os_context_win.h" #include "shared/source/os_interface/windows/os_environment_win.h" +#include "shared/source/os_interface/windows/sharedata_wrapper.h" #include "shared/source/os_interface/windows/wddm/adapter_factory.h" #include "shared/source/os_interface/windows/wddm/adapter_info.h" #include "shared/source/os_interface/windows/wddm/um_km_data_translator.h" @@ -132,13 +133,13 @@ bool Wddm::init() { bool Wddm::queryAdapterInfo() { NTSTATUS status = STATUS_UNSUCCESSFUL; - ADAPTER_INFO adapterInfo = {0}; + ADAPTER_INFO_KMD adapterInfo = {0}; D3DKMT_QUERYADAPTERINFO QueryAdapterInfo = {0}; QueryAdapterInfo.hAdapter = getAdapter(); QueryAdapterInfo.Type = KMTQAITYPE_UMDRIVERPRIVATE; if (hwDeviceId->getUmKmDataTranslator()->enabled()) { - UmKmDataTempStorage internalRepresentation(hwDeviceId->getUmKmDataTranslator()->getSizeForAdapterInfoInternalRepresentation()); + UmKmDataTempStorage internalRepresentation(hwDeviceId->getUmKmDataTranslator()->getSizeForAdapterInfoInternalRepresentation()); QueryAdapterInfo.pPrivateDriverData = internalRepresentation.data(); QueryAdapterInfo.PrivateDriverDataSize = static_cast(internalRepresentation.size()); @@ -151,7 +152,7 @@ bool Wddm::queryAdapterInfo() { } } else { QueryAdapterInfo.pPrivateDriverData = &adapterInfo; - QueryAdapterInfo.PrivateDriverDataSize = sizeof(ADAPTER_INFO); + QueryAdapterInfo.PrivateDriverDataSize = sizeof(ADAPTER_INFO_KMD); status = getGdi()->queryAdapterInfo(&QueryAdapterInfo); DEBUG_BREAK_IF(status != STATUS_SUCCESS); @@ -242,11 +243,11 @@ bool Wddm::destroyDevice() { bool validDriverStorePath(OsEnvironmentWin &osEnvironment, D3DKMT_HANDLE adapter) { D3DKMT_QUERYADAPTERINFO QueryAdapterInfo = {0}; - ADAPTER_INFO adapterInfo = {0}; + ADAPTER_INFO_KMD adapterInfo = {0}; QueryAdapterInfo.hAdapter = adapter; QueryAdapterInfo.Type = KMTQAITYPE_UMDRIVERPRIVATE; QueryAdapterInfo.pPrivateDriverData = &adapterInfo; - QueryAdapterInfo.PrivateDriverDataSize = sizeof(ADAPTER_INFO); + QueryAdapterInfo.PrivateDriverDataSize = sizeof(ADAPTER_INFO_KMD); auto status = osEnvironment.gdi->queryAdapterInfo(&QueryAdapterInfo); diff --git a/shared/source/sku_info/operations/windows/sku_info_receiver.cpp b/shared/source/sku_info/operations/windows/sku_info_receiver.cpp index bfa66a57a4..51a840b2e2 100644 --- a/shared/source/sku_info/operations/windows/sku_info_receiver.cpp +++ b/shared/source/sku_info/operations/windows/sku_info_receiver.cpp @@ -8,11 +8,11 @@ #include "shared/source/sku_info/operations/windows/sku_info_receiver.h" namespace NEO { -void SkuInfoReceiver::receiveFtrTableFromAdapterInfo(FeatureTable *ftrTable, _ADAPTER_INFO *adapterInfo) { +void SkuInfoReceiver::receiveFtrTableFromAdapterInfo(FeatureTable *ftrTable, ADAPTER_INFO_KMD *adapterInfo) { receiveFtrTableFromAdapterInfoBase(ftrTable, adapterInfo); } -void SkuInfoReceiver::receiveWaTableFromAdapterInfo(WorkaroundTable *workaroundTable, _ADAPTER_INFO *adapterInfo) { +void SkuInfoReceiver::receiveWaTableFromAdapterInfo(WorkaroundTable *workaroundTable, ADAPTER_INFO_KMD *adapterInfo) { receiveWaTableFromAdapterInfoBase(workaroundTable, adapterInfo); } } // namespace NEO diff --git a/shared/source/sku_info/operations/windows/sku_info_receiver.h b/shared/source/sku_info/operations/windows/sku_info_receiver.h index b310ea37ff..253924e8f2 100644 --- a/shared/source/sku_info/operations/windows/sku_info_receiver.h +++ b/shared/source/sku_info/operations/windows/sku_info_receiver.h @@ -1,24 +1,24 @@ /* - * Copyright (C) 2018-2020 Intel Corporation + * Copyright (C) 2018-2021 Intel Corporation * * SPDX-License-Identifier: MIT * */ #pragma once +#include "shared/source/os_interface/windows/sharedata_wrapper.h" #include "shared/source/os_interface/windows/windows_wrapper.h" #include "sku_info.h" -#include "umKmInc/sharedata.h" namespace NEO { class SkuInfoReceiver { public: - static void receiveFtrTableFromAdapterInfo(FeatureTable *ftrTable, _ADAPTER_INFO *adapterInfo); - static void receiveWaTableFromAdapterInfo(WorkaroundTable *workaroundTable, _ADAPTER_INFO *adapterInfo); + static void receiveFtrTableFromAdapterInfo(FeatureTable *ftrTable, ADAPTER_INFO_KMD *adapterInfo); + static void receiveWaTableFromAdapterInfo(WorkaroundTable *workaroundTable, ADAPTER_INFO_KMD *adapterInfo); protected: - static void receiveFtrTableFromAdapterInfoBase(FeatureTable *ftrTable, _ADAPTER_INFO *adapterInfo) { + static void receiveFtrTableFromAdapterInfoBase(FeatureTable *ftrTable, ADAPTER_INFO_KMD *adapterInfo) { #define RECEIVE_FTR(VAL_NAME) ftrTable->ftr##VAL_NAME = adapterInfo->SkuTable.Ftr##VAL_NAME RECEIVE_FTR(Desktop); RECEIVE_FTR(ChannelSwizzlingXOREnabled); @@ -106,7 +106,7 @@ class SkuInfoReceiver { #undef RECEIVE_FTR } - static void receiveWaTableFromAdapterInfoBase(WorkaroundTable *workaroundTable, _ADAPTER_INFO *adapterInfo) { + static void receiveWaTableFromAdapterInfoBase(WorkaroundTable *workaroundTable, ADAPTER_INFO_KMD *adapterInfo) { #define RECEIVE_WA(VAL_NAME) workaroundTable->wa##VAL_NAME = adapterInfo->WaTable.Wa##VAL_NAME RECEIVE_WA(DoNotUseMIReportPerfCount); diff --git a/shared/test/unit_test/CMakeLists.txt b/shared/test/unit_test/CMakeLists.txt index 4f1a87eb9e..e0885fc205 100644 --- a/shared/test/unit_test/CMakeLists.txt +++ b/shared/test/unit_test/CMakeLists.txt @@ -78,6 +78,12 @@ if(NOT SKIP_UNIT_TESTS) ${NEO_SOURCE_DIR}/shared/test/common/mocks/linux/mock_drm_memory_manager.cpp ${NEO_SOURCE_DIR}/shared/test/common/mocks/linux/mock_drm_memory_manager.h ) + if(NOT DISABLE_WDDM_LINUX) + target_sources(${TARGET_NAME} PRIVATE + ${NEO_SHARED_DIRECTORY}/gmm_helper/windows/gmm_memory.cpp + ${NEO_SHARED_DIRECTORY}/os_interface/windows/wddm/wddm_create.cpp + ) + endif() else() target_sources(${TARGET_NAME} PRIVATE ${NEO_SOURCE_DIR}/opencl/test/unit_test/os_interface/windows/create_wddm_memory_manager.cpp diff --git a/shared/test/unit_test/os_interface/windows/um_km_data_translator_tests.cpp b/shared/test/unit_test/os_interface/windows/um_km_data_translator_tests.cpp index 08654023c7..774c4c57df 100644 --- a/shared/test/unit_test/os_interface/windows/um_km_data_translator_tests.cpp +++ b/shared/test/unit_test/os_interface/windows/um_km_data_translator_tests.cpp @@ -1,15 +1,152 @@ /* - * Copyright (C) 2021 Intel Corporation + * Copyright (C) 2018-2021 Intel Corporation * * SPDX-License-Identifier: MIT * */ +#include "shared/source/debug_settings/debug_settings_manager.h" #include "shared/source/os_interface/windows/gdi_interface.h" #include "shared/source/os_interface/windows/wddm/um_km_data_translator.h" +#include "shared/test/common/helpers/debug_manager_state_restore.h" +#include "shared/test/unit_test/os_interface/windows/adapter_info_tests.h" +#include "shared/wsl_compute_helper/source/gmm_resource_info_accessor.h" +#include "shared/wsl_compute_helper/source/wsl_compute_helper.h" +#include "shared/wsl_compute_helper/source/wsl_compute_helper_types_tokens_structs.h" #include "test.h" +#ifdef _WIN32 +#define EXPORT __declspec(dllexport) +#else +#define EXPORT __attribute__((__visibility__("default"))) +#endif + +namespace NEO { +extern const char *wslComputeHelperLibNameToLoad; +} + +static const char *mockTokToStrAdapterString = "MOCK_ADAPTER_TOK_TO_STR"; +static const uint16_t mockTokToStrDriverBuildNumber = 0xabcd; +static const uint32_t mockTokToStrProcessID = 0xabcdefbc; + +static const char *mockStrToTokAdapterString = "MOCK_ADAPTER_STR_TO_TOK"; +static const uint16_t mockStrToTokDriverBuildNumber = 0xbadc; +static const uint32_t mockStrToTokProcessID = 0xcdbaebfc; + +extern "C" { +EXPORT size_t CCONV getSizeRequiredForStruct(TOK structId) { + switch (structId) { + default: + return 0; + case TOK_S_ADAPTER_INFO: + return sizeof(ADAPTER_INFO); + case TOK_S_COMMAND_BUFFER_HEADER_REC: + return sizeof(COMMAND_BUFFER_HEADER); + case TOK_S_CREATECONTEXT_PVTDATA: + return sizeof(CREATECONTEXT_PVTDATA); + case TOK_S_GMM_RESOURCE_INFO_WIN_STRUCT: + return sizeof(GmmResourceInfoWinStruct); + } + return 0; +} + +EXPORT bool CCONV tokensToStruct(TOK structId, void *dst, size_t dstSizeInBytes, const TokenHeader *begin, const TokenHeader *end) { + if (dstSizeInBytes < getSizeRequiredForStruct(structId)) { + return false; + } + switch (structId) { + default: + return false; + case TOK_S_ADAPTER_INFO: { + auto adapterInfo = new (dst) ADAPTER_INFO{}; + return (0 == memcpy_s(adapterInfo->AdapterString, sizeof(adapterInfo->AdapterString), mockTokToStrAdapterString, strlen(mockTokToStrAdapterString) + 1)); + } break; + case TOK_S_COMMAND_BUFFER_HEADER_REC: { + auto cmdBufferHeader = new (dst) COMMAND_BUFFER_HEADER{}; + cmdBufferHeader->DriverBuildNumber = mockTokToStrDriverBuildNumber; + return true; + } break; + case TOK_S_CREATECONTEXT_PVTDATA: { + auto createCtxData = new (dst) CREATECONTEXT_PVTDATA{}; + createCtxData->ProcessID = mockTokToStrProcessID; + return true; + } break; + case TOK_S_GMM_RESOURCE_INFO_WIN_STRUCT: { + auto gmmResourceInfo = new (dst) GmmResourceInfoWinStruct{}; + gmmResourceInfo->GmmResourceInfoCommon.pPrivateData = mockTokToStrDriverBuildNumber; + return true; + } break; + } + return true; +} + +EXPORT size_t CCONV getSizeRequiredForTokens(TOK structId) { + switch (structId) { + default: + return 0; + case TOK_S_ADAPTER_INFO: + return sizeof(TOKSTR__ADAPTER_INFO); + case TOK_S_COMMAND_BUFFER_HEADER_REC: + return sizeof(TOKSTR_COMMAND_BUFFER_HEADER_REC); + case TOK_S_CREATECONTEXT_PVTDATA: + return sizeof(TOKSTR__CREATECONTEXT_PVTDATA); + case TOK_S_GMM_RESOURCE_INFO_WIN_STRUCT: + return sizeof(TOKSTR_GmmResourceInfoWinStruct); + } + return 0; +} + +EXPORT bool CCONV structToTokens(TOK structId, TokenHeader *dst, size_t dstSizeInBytes, const void *src, size_t srcSizeInBytes) { + if (dstSizeInBytes < getSizeRequiredForTokens(structId)) { + return false; + } + + switch (structId) { + default: + return false; + case TOK_S_ADAPTER_INFO: { + auto adapterInfo = new (dst) TOKSTR__ADAPTER_INFO{}; + return (0 == memcpy_s(adapterInfo->DeviceRegistryPath.getValue(), adapterInfo->DeviceRegistryPath.getValueSizeInBytes(), mockStrToTokAdapterString, strlen(mockStrToTokAdapterString) + 1)); + } break; + case TOK_S_COMMAND_BUFFER_HEADER_REC: { + auto cmdBufferHeader = new (dst) TOKSTR_COMMAND_BUFFER_HEADER_REC{}; + cmdBufferHeader->MonitorFenceValue.setValue(mockStrToTokDriverBuildNumber); + return true; + } break; + case TOK_S_CREATECONTEXT_PVTDATA: { + auto createCtxData = new (dst) TOKSTR__CREATECONTEXT_PVTDATA{}; + createCtxData->ProcessID.setValue(mockStrToTokProcessID); + return true; + } break; + case TOK_S_GMM_RESOURCE_INFO_WIN_STRUCT: { + auto gmmResourceInfo = new (dst) TOKSTR_GmmResourceInfoWinStruct{}; + gmmResourceInfo->GmmResourceInfoCommon.pPrivateData.setValue(mockStrToTokDriverBuildNumber); + return true; + } break; + } + return false; +} + +EXPORT void CCONV destroyStructRepresentation(TOK structId, void *src, size_t srcSizeInBytes) { + if (srcSizeInBytes < getSizeRequiredForStruct(structId)) { + assert(false); + return; + } + switch (structId) { + default: + return; + case TOK_S_GMM_RESOURCE_INFO_WIN_STRUCT: + reinterpret_cast(src)->~GmmResourceInfoWinStruct(); + break; + } +} + +EXPORT uint64_t CCONV getVersion() { + return 0; +} +} + TEST(UmKmDataTranslator, whenCreatingDefaultTranslatorThenTranslationIsDisabled) { NEO::Gdi gdi; auto translator = NEO::createUmKmDataTranslator(gdi, 0); @@ -42,3 +179,60 @@ TEST(UmKmDataTranslator, whenUsingDefaultTranslatorThenTranslationIsDisabled) { EXPECT_TRUE(ret); EXPECT_EQ(0, memcmp(&dstCreateContextPvtData, &srcCreateContextPvtData, sizeof(CREATECONTEXT_PVTDATA))); } + +TEST(UmKmDataTranslator, givenToggledDebugKeyWhenCreatingDefaultTranslatorThenTranslationIsEnabled) { + DebugManagerStateRestore debugSettingsRestore; + + NEO::DebugManager.flags.UseUmKmDataTranslator.set(true); + NEO::wslComputeHelperLibNameToLoad = ""; + NEO::Gdi gdi; + auto handle = validHandle; + gdi.queryAdapterInfo.mFunc = QueryAdapterInfoMock::queryadapterinfo; + + auto translator = NEO::createUmKmDataTranslator(gdi, handle); + EXPECT_TRUE(translator->enabled()); +} + +TEST(WslUmKmDataTranslator, whenQueryingForTranslationThenQueryIsForwardedToWslComputeHelper) { + DebugManagerStateRestore debugSettingsRestore; + + NEO::DebugManager.flags.UseUmKmDataTranslator.set(true); + NEO::wslComputeHelperLibNameToLoad = ""; + NEO::Gdi gdi; + auto handle = validHandle; + gdi.queryAdapterInfo.mFunc = QueryAdapterInfoMock::queryadapterinfo; + + auto translator = NEO::createUmKmDataTranslator(gdi, handle); + + EXPECT_EQ(sizeof(ADAPTER_INFO), translator->getSizeForAdapterInfoInternalRepresentation()); + EXPECT_EQ(sizeof(COMMAND_BUFFER_HEADER), translator->getSizeForCommandBufferHeaderDataInternalRepresentation()); + EXPECT_EQ(sizeof(CREATECONTEXT_PVTDATA), translator->getSizeForCreateContextDataInternalRepresentation()); + + ADAPTER_INFO srcAdapterInfo, dstAdapterInfo; + memset(&srcAdapterInfo, 7, sizeof(srcAdapterInfo)); + auto ret = translator->translateAdapterInfoFromInternalRepresentation(dstAdapterInfo, &srcAdapterInfo, sizeof(ADAPTER_INFO)); + EXPECT_TRUE(ret); + EXPECT_EQ(0, memcmp(dstAdapterInfo.DeviceRegistryPath, mockStrToTokAdapterString, strlen(mockStrToTokAdapterString) + 1)); + + COMMAND_BUFFER_HEADER srcCmdBufferHeader, dstCmdBufferHeader; + memset(&srcCmdBufferHeader, 7, sizeof(srcCmdBufferHeader)); + ret = translator->tranlateCommandBufferHeaderDataToInternalRepresentation(&dstCmdBufferHeader, sizeof(COMMAND_BUFFER_HEADER), srcCmdBufferHeader); + EXPECT_TRUE(ret); + EXPECT_EQ(mockTokToStrDriverBuildNumber, dstCmdBufferHeader.DriverBuildNumber); + + CREATECONTEXT_PVTDATA srcCreateContextPvtData, dstCreateContextPvtData; + memset(&srcCreateContextPvtData, 7, sizeof(srcCreateContextPvtData)); + ret = translator->translateCreateContextDataToInternalRepresentation(&dstCreateContextPvtData, sizeof(CREATECONTEXT_PVTDATA), srcCreateContextPvtData); + EXPECT_TRUE(ret); + EXPECT_EQ(mockTokToStrProcessID, dstCreateContextPvtData.ProcessID); + + auto gmmHandleAllocator = translator->createGmmHandleAllocator(); + ASSERT_NE(nullptr, gmmHandleAllocator); + gmmHandleAllocator->getHandleSize(); + UmKmDataTempStorage gmmResInfo; + EXPECT_EQ(sizeof(GmmResourceInfoWinStruct), gmmHandleAllocator->getHandleSize()); + auto gmmResourceInfoHandle = gmmHandleAllocator->createHandle(reinterpret_cast(gmmResInfo.data())); + ASSERT_NE(nullptr, gmmResourceInfoHandle); + EXPECT_EQ(mockTokToStrDriverBuildNumber, reinterpret_cast(gmmResourceInfoHandle)->GmmResourceInfoCommon.pPrivateData); + gmmHandleAllocator->destroyHandle(gmmResourceInfoHandle); +} diff --git a/shared/wsl_compute_helper/CMakeLists.txt b/shared/wsl_compute_helper/CMakeLists.txt new file mode 100644 index 0000000000..605e83a56b --- /dev/null +++ b/shared/wsl_compute_helper/CMakeLists.txt @@ -0,0 +1,5 @@ +# +# Copyright (C) 2021 Intel Corporation +# +# SPDX-License-Identifier: MIT +# diff --git a/shared/wsl_compute_helper/source/CMakeLists.txt b/shared/wsl_compute_helper/source/CMakeLists.txt new file mode 100644 index 0000000000..b1db5dcbc8 --- /dev/null +++ b/shared/wsl_compute_helper/source/CMakeLists.txt @@ -0,0 +1,24 @@ +# +# Copyright (C) 2021 Intel Corporation +# +# SPDX-License-Identifier: MIT +# + +if(WDDM_LINUX) + include_directories(${NEO__GMM_INCLUDE_DIR} ${WDK_INCLUDE_PATHS}) + add_definitions(-DLHDM=1) + add_definitions(-DWDDM_LINUX=1) + set(CMAKE_CXX_VISIBILITY_PRESET hidden) + add_library(wsl_compute_helper SHARED + wsl_compute_helper.cpp + wsl_compute_helper.h + wsl_compute_helper_types_demarshall.cpp + wsl_compute_helper_types_demarshall.h + wsl_compute_helper_types_marshall.cpp + wsl_compute_helper_types_marshall.h + wsl_compute_helper_types_tokens.h + wsl_compute_helper_types_tokens_structs.h + gmm_resource_info_struct.h + gmm_resource_info_accessor.h + ) +endif() diff --git a/shared/wsl_compute_helper/source/gmm_resource_info_accessor.h b/shared/wsl_compute_helper/source/gmm_resource_info_accessor.h new file mode 100644 index 0000000000..3e6db2614f --- /dev/null +++ b/shared/wsl_compute_helper/source/gmm_resource_info_accessor.h @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2021 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#pragma once + +#include "gmm_resource_info_struct.h" + +using GmmAccessorBase = GmmLib::GmmResourceInfo; + +class GmmResourceInfoWinAccessor : public GmmAccessorBase { + public: + GmmResourceInfoWinAccessor() { + } + GmmAccessorBase &operator=(const GmmAccessorBase &rhs) { + GmmAccessorBase::operator=(rhs); + return *this; + } + + void set(const GmmResourceInfoCommonStruct &src) { + this->ClientType = src.ClientType; + this->Surf = src.Surf; + this->AuxSurf = src.AuxSurf; + this->AuxSecSurf = src.AuxSecSurf; + + this->RotateInfo = src.RotateInfo; + this->ExistingSysMem = src.ExistingSysMem; + this->SvmAddress = src.SvmAddress; + + this->pPrivateData = src.pPrivateData; + + this->MultiTileArch = src.MultiTileArch; + } + + void set(const GmmResourceInfoWinStruct &src) { + this->set(src.GmmResourceInfoCommon); + } + + void get(GmmResourceInfoCommonStruct &dst) const { + dst.ClientType = this->ClientType; + dst.Surf = this->Surf; + dst.AuxSurf = this->AuxSurf; + dst.AuxSecSurf = this->AuxSecSurf; + + dst.RotateInfo = this->RotateInfo; + dst.ExistingSysMem = this->ExistingSysMem; + dst.SvmAddress = this->SvmAddress; + + dst.pPrivateData = this->pPrivateData; + + dst.MultiTileArch = this->MultiTileArch; + } + + void get(GmmResourceInfoWinStruct &dst) const { + this->get(dst.GmmResourceInfoCommon); + } +}; diff --git a/shared/wsl_compute_helper/source/gmm_resource_info_struct.h b/shared/wsl_compute_helper/source/gmm_resource_info_struct.h new file mode 100644 index 0000000000..323011e502 --- /dev/null +++ b/shared/wsl_compute_helper/source/gmm_resource_info_struct.h @@ -0,0 +1,69 @@ +/* + * Copyright (C) 2021 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#pragma once + +// gmm enforces include order +// clang-format off +#ifndef WDDM_LINUX +# include +# include "d3dkmthk.h" +#else +# include "shared/source/os_interface/windows/windows_wrapper.h" +# include "umKmInc/sharedata.h" +# undef LHDM +# undef WDDM_LINUX +# define RESTORE_WDDM_LINUX +# define UFO_PORTABLE_COMPILER_H +# define UFO_PORTABLE_WINDEF_H +#endif +#include "umKmInc/sharedata.h" + +#include "External/Common/GmmCommonExt.h" +#include "External/Common/GmmUtil.h" +#include "External/Common/GmmResourceFlags.h" +#include "External/Common/GmmCachePolicy.h" +#include "External/Common/GmmCachePolicyExt.h" +#include "External/Common/GmmResourceInfoExt.h" +#include "External/Common/GmmPlatformExt.h" +#include "External/Common/GmmTextureExt.h" +#include "External/Common/GmmInfoExt.h" +#include "External/Common/GmmResourceInfo.h" +// clang-format on + +#ifdef RESTORE_WDDM_LINUX +#define LHDM 1 +#define WDDM_LINUX 1 +#ifndef GMM_ESCAPE_HANDLE +#define GMM_ESCAPE_HANDLE D3DKMT_HANDLE +#endif +#ifndef GMM_ESCAPE_FUNC_TYPE +#define GMM_ESCAPE_FUNC_TYPE PFND3DKMT_ESCAPE +#endif +#ifndef GMM_HANDLE +#define GMM_HANDLE D3DKMT_HANDLE +#endif +#endif + +struct GmmResourceInfoCommonStruct { + GMM_CLIENT ClientType; + GMM_TEXTURE_INFO Surf; + GMM_TEXTURE_INFO AuxSurf; + GMM_TEXTURE_INFO AuxSecSurf; + + uint32_t RotateInfo; + GMM_EXISTING_SYS_MEM ExistingSysMem; + GMM_GFX_ADDRESS SvmAddress; + + uint64_t pPrivateData; + + GMM_MULTI_TILE_ARCH MultiTileArch; +}; + +struct GmmResourceInfoWinStruct { + struct GmmResourceInfoCommonStruct GmmResourceInfoCommon; +}; diff --git a/shared/wsl_compute_helper/source/wsl_compute_helper.h b/shared/wsl_compute_helper/source/wsl_compute_helper.h new file mode 100644 index 0000000000..fc5d26fcc7 --- /dev/null +++ b/shared/wsl_compute_helper/source/wsl_compute_helper.h @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2021 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#pragma once + +#include "wsl_compute_helper_types_tokens.h" + +#ifdef _WIN32 +#define CCONV __cdecl +static const char *wslComputeHelperLibName = "wsl_compute_helper.dll"; +#else +#define CCONV +static const char *wslComputeHelperLibName = "libwsl_compute_helper.so"; +#endif + +typedef size_t(CCONV *getSizeRequiredForStructFPT)(TOK structId); +static const char *const getSizeRequiredForStructName = "getSizeRequiredForStruct"; + +typedef bool(CCONV *tokensToStructFPT)(TOK structId, void *dst, size_t dstSizeInBytes, const TokenHeader *begin, const TokenHeader *end); +static const char *const tokensToStructName = "tokensToStruct"; + +typedef size_t(CCONV *getSizeRequiredForTokensFPT)(TOK structId); +static const char *const getSizeRequiredForTokensName = "getSizeRequiredForTokens"; + +typedef bool(CCONV *structToTokensFPT)(TOK structId, TokenHeader *dst, size_t dstSizeInBytes, const void *src, size_t srcSizeInBytes); +static const char *const structToTokensName = "structToTokens"; + +typedef void(CCONV *destroyStructRepresentationFPT)(TOK structId, void *src, size_t srcSizeInBytes); +static const char *const destroyStructRepresentationName = "destroyStructRepresentation"; + +typedef uint64_t(CCONV *getVersionFPT)(); +static const char *const getVersionName = "getVersion"; diff --git a/shared/wsl_compute_helper/source/wsl_compute_helper_types_demarshall.cpp b/shared/wsl_compute_helper/source/wsl_compute_helper_types_demarshall.cpp new file mode 100644 index 0000000000..f3693c34cf --- /dev/null +++ b/shared/wsl_compute_helper/source/wsl_compute_helper_types_demarshall.cpp @@ -0,0 +1,9 @@ +/* + * Copyright (C) 2021 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +// This is a generated file - please don't modify directly +#include "wsl_compute_helper_types_demarshall.h" diff --git a/shared/wsl_compute_helper/source/wsl_compute_helper_types_demarshall.h b/shared/wsl_compute_helper/source/wsl_compute_helper_types_demarshall.h new file mode 100644 index 0000000000..1ecc3c68a8 --- /dev/null +++ b/shared/wsl_compute_helper/source/wsl_compute_helper_types_demarshall.h @@ -0,0 +1,13336 @@ +/* + * Copyright (C) 2021 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +// This is a generated file - please don't modify directly +#pragma once +#include "wsl_compute_helper_types_tokens.h" + +template +struct Demarshaller; + +template <> +struct Demarshaller { + template + static bool demarshall(GT_SUBSLICE_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBB_GT_SUBSLICE_INFO__ENABLED: { + dst.Enabled = readTokValue(*tok); + } break; + case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_COUNT: { + dst.EuEnabledCount = readTokValue(*tok); + } break; + case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_MASK: { + dst.EuEnabledMask = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GT_SUBSLICE_INFO: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(GT_DUALSUBSLICE_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBB_GT_DUALSUBSLICE_INFO__ENABLED: { + dst.Enabled = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GT_DUALSUBSLICE_INFO: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + case TOK_FS_GT_DUALSUBSLICE_INFO__SUB_SLICE: { + uint32_t arrayElementIdSubSlice = varLen->arrayElementId; + const TokenHeader *tokSubSlice = varLen->getValue(); + const TokenHeader *tokSubSliceEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSubSlice < tokSubSliceEnd) { + if (false == tokSubSlice->flags.flag4IsVariableLength) { + switch (tokSubSlice->id) { + default: + if (tokSubSlice->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBB_GT_SUBSLICE_INFO__ENABLED: { + dst.SubSlice[arrayElementIdSubSlice].Enabled = readTokValue(*tokSubSlice); + } break; + case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_COUNT: { + dst.SubSlice[arrayElementIdSubSlice].EuEnabledCount = readTokValue(*tokSubSlice); + } break; + case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_MASK: { + dst.SubSlice[arrayElementIdSubSlice].EuEnabledMask = readTokValue(*tokSubSlice); + } break; + }; + tokSubSlice = tokSubSlice + 1 + tokSubSlice->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSubSlice); + if (tokSubSlice->flags.flag3IsMandatory) { + return false; + } + tokSubSlice = tokSubSlice + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSubSlice == tokSubSliceEnd); + } break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(GT_SLICE_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBB_GT_SLICE_INFO__ENABLED: { + dst.Enabled = readTokValue(*tok); + } break; + case TOK_FBD_GT_SLICE_INFO__SUB_SLICE_ENABLED_COUNT: { + dst.SubSliceEnabledCount = readTokValue(*tok); + } break; + case TOK_FBD_GT_SLICE_INFO__DUAL_SUB_SLICE_ENABLED_COUNT: { + dst.DualSubSliceEnabledCount = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GT_SLICE_INFO: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + case TOK_FS_GT_SLICE_INFO__SUB_SLICE_INFO: { + uint32_t arrayElementIdSubSliceInfo = varLen->arrayElementId; + const TokenHeader *tokSubSliceInfo = varLen->getValue(); + const TokenHeader *tokSubSliceInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSubSliceInfo < tokSubSliceInfoEnd) { + if (false == tokSubSliceInfo->flags.flag4IsVariableLength) { + switch (tokSubSliceInfo->id) { + default: + if (tokSubSliceInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBB_GT_SUBSLICE_INFO__ENABLED: { + dst.SubSliceInfo[arrayElementIdSubSliceInfo].Enabled = readTokValue(*tokSubSliceInfo); + } break; + case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_COUNT: { + dst.SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledCount = readTokValue(*tokSubSliceInfo); + } break; + case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_MASK: { + dst.SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledMask = readTokValue(*tokSubSliceInfo); + } break; + }; + tokSubSliceInfo = tokSubSliceInfo + 1 + tokSubSliceInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSubSliceInfo); + if (tokSubSliceInfo->flags.flag3IsMandatory) { + return false; + } + tokSubSliceInfo = tokSubSliceInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSubSliceInfo == tokSubSliceInfoEnd); + } break; + case TOK_FS_GT_SLICE_INFO__DSSINFO: { + uint32_t arrayElementIdDSSInfo = varLen->arrayElementId; + const TokenHeader *tokDSSInfo = varLen->getValue(); + const TokenHeader *tokDSSInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokDSSInfo < tokDSSInfoEnd) { + if (false == tokDSSInfo->flags.flag4IsVariableLength) { + switch (tokDSSInfo->id) { + default: + if (tokDSSInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBB_GT_DUALSUBSLICE_INFO__ENABLED: { + dst.DSSInfo[arrayElementIdDSSInfo].Enabled = readTokValue(*tokDSSInfo); + } break; + }; + tokDSSInfo = tokDSSInfo + 1 + tokDSSInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokDSSInfo); + switch (tokDSSInfo->id) { + default: + if (tokDSSInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_DUALSUBSLICE_INFO__SUB_SLICE: { + uint32_t arrayElementIdSubSlice = varLen->arrayElementId; + const TokenHeader *tokSubSlice = varLen->getValue(); + const TokenHeader *tokSubSliceEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSubSlice < tokSubSliceEnd) { + if (false == tokSubSlice->flags.flag4IsVariableLength) { + switch (tokSubSlice->id) { + default: + if (tokSubSlice->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBB_GT_SUBSLICE_INFO__ENABLED: { + dst.DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].Enabled = readTokValue(*tokSubSlice); + } break; + case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_COUNT: { + dst.DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledCount = readTokValue(*tokSubSlice); + } break; + case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_MASK: { + dst.DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledMask = readTokValue(*tokSubSlice); + } break; + }; + tokSubSlice = tokSubSlice + 1 + tokSubSlice->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSubSlice); + if (tokSubSlice->flags.flag3IsMandatory) { + return false; + } + tokSubSlice = tokSubSlice + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSubSlice == tokSubSliceEnd); + } break; + }; + tokDSSInfo = tokDSSInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokDSSInfo == tokDSSInfoEnd); + } break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(GT_VEBOX_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VEBOX_INFO__NUMBER_OF_VEBOX_ENABLED: { + dst.NumberOfVEBoxEnabled = readTokValue(*tok); + } break; + case TOK_FBB_GT_VEBOX_INFO__IS_VALID: { + dst.IsValid = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GT_VEBOX_INFO: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + case TOK_FS_GT_VEBOX_INFO__INSTANCES: { + const TokenHeader *tokInstances = varLen->getValue(); + const TokenHeader *tokInstancesEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokInstances < tokInstancesEnd) { + if (false == tokInstances->flags.flag4IsVariableLength) { + switch (tokInstances->id) { + default: + if (tokInstances->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBOX_ENABLE_MASK: { + dst.Instances.VEBoxEnableMask = readTokValue(*tokInstances); + } break; + }; + tokInstances = tokInstances + 1 + tokInstances->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokInstances); + switch (tokInstances->id) { + default: + if (tokInstances->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_VEBOX_INFO__VEBOX_INSTANCES__BITS: { + const TokenHeader *tokBits = varLen->getValue(); + const TokenHeader *tokBitsEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokBits < tokBitsEnd) { + if (false == tokBits->flags.flag4IsVariableLength) { + switch (tokBits->id) { + default: + if (tokBits->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX0ENABLED: { + dst.Instances.Bits.VEBox0Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX1ENABLED: { + dst.Instances.Bits.VEBox1Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX2ENABLED: { + dst.Instances.Bits.VEBox2Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX3ENABLED: { + dst.Instances.Bits.VEBox3Enabled = readTokValue(*tokBits); + } break; + }; + tokBits = tokBits + 1 + tokBits->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokBits); + if (tokBits->flags.flag3IsMandatory) { + return false; + } + tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokBits == tokBitsEnd); + } break; + }; + tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokInstances == tokInstancesEnd); + } break; + case TOK_FS_GT_VEBOX_INFO__SFCSUPPORT: { + const TokenHeader *tokSFCSupport = varLen->getValue(); + const TokenHeader *tokSFCSupportEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSFCSupport < tokSFCSupportEnd) { + if (false == tokSFCSupport->flags.flag4IsVariableLength) { + switch (tokSFCSupport->id) { + default: + if (tokSFCSupport->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__VALUE: { + dst.SFCSupport.Value = readTokValue(*tokSFCSupport); + } break; + }; + tokSFCSupport = tokSFCSupport + 1 + tokSFCSupport->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSFCSupport); + switch (tokSFCSupport->id) { + default: + if (tokSFCSupport->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_VEBOX_INFO__ANONYMOUS3862__SFC_SUPPORTED_BITS: { + const TokenHeader *tokSfcSupportedBits = varLen->getValue(); + const TokenHeader *tokSfcSupportedBitsEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSfcSupportedBits < tokSfcSupportedBitsEnd) { + if (false == tokSfcSupportedBits->flags.flag4IsVariableLength) { + switch (tokSfcSupportedBits->id) { + default: + if (tokSfcSupportedBits->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX0: { + dst.SFCSupport.SfcSupportedBits.VEBox0 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX1: { + dst.SFCSupport.SfcSupportedBits.VEBox1 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX2: { + dst.SFCSupport.SfcSupportedBits.VEBox2 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX3: { + dst.SFCSupport.SfcSupportedBits.VEBox3 = readTokValue(*tokSfcSupportedBits); + } break; + }; + tokSfcSupportedBits = tokSfcSupportedBits + 1 + tokSfcSupportedBits->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSfcSupportedBits); + if (tokSfcSupportedBits->flags.flag3IsMandatory) { + return false; + } + tokSfcSupportedBits = tokSfcSupportedBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSfcSupportedBits == tokSfcSupportedBitsEnd); + } break; + }; + tokSFCSupport = tokSFCSupport + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSFCSupport == tokSFCSupportEnd); + } break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(GT_VDBOX_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VDBOX_INFO__NUMBER_OF_VDBOX_ENABLED: { + dst.NumberOfVDBoxEnabled = readTokValue(*tok); + } break; + case TOK_FBB_GT_VDBOX_INFO__IS_VALID: { + dst.IsValid = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GT_VDBOX_INFO: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + case TOK_FS_GT_VDBOX_INFO__INSTANCES: { + const TokenHeader *tokInstances = varLen->getValue(); + const TokenHeader *tokInstancesEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokInstances < tokInstancesEnd) { + if (false == tokInstances->flags.flag4IsVariableLength) { + switch (tokInstances->id) { + default: + if (tokInstances->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBOX_ENABLE_MASK: { + dst.Instances.VDBoxEnableMask = readTokValue(*tokInstances); + } break; + }; + tokInstances = tokInstances + 1 + tokInstances->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokInstances); + switch (tokInstances->id) { + default: + if (tokInstances->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_VDBOX_INFO__VDBOX_INSTANCES__BITS: { + const TokenHeader *tokBits = varLen->getValue(); + const TokenHeader *tokBitsEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokBits < tokBitsEnd) { + if (false == tokBits->flags.flag4IsVariableLength) { + switch (tokBits->id) { + default: + if (tokBits->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX0ENABLED: { + dst.Instances.Bits.VDBox0Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX1ENABLED: { + dst.Instances.Bits.VDBox1Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX2ENABLED: { + dst.Instances.Bits.VDBox2Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX3ENABLED: { + dst.Instances.Bits.VDBox3Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX4ENABLED: { + dst.Instances.Bits.VDBox4Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX5ENABLED: { + dst.Instances.Bits.VDBox5Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX6ENABLED: { + dst.Instances.Bits.VDBox6Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX7ENABLED: { + dst.Instances.Bits.VDBox7Enabled = readTokValue(*tokBits); + } break; + }; + tokBits = tokBits + 1 + tokBits->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokBits); + if (tokBits->flags.flag3IsMandatory) { + return false; + } + tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokBits == tokBitsEnd); + } break; + }; + tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokInstances == tokInstancesEnd); + } break; + case TOK_FS_GT_VDBOX_INFO__SFCSUPPORT: { + const TokenHeader *tokSFCSupport = varLen->getValue(); + const TokenHeader *tokSFCSupportEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSFCSupport < tokSFCSupportEnd) { + if (false == tokSFCSupport->flags.flag4IsVariableLength) { + switch (tokSFCSupport->id) { + default: + if (tokSFCSupport->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__VALUE: { + dst.SFCSupport.Value = readTokValue(*tokSFCSupport); + } break; + }; + tokSFCSupport = tokSFCSupport + 1 + tokSFCSupport->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSFCSupport); + switch (tokSFCSupport->id) { + default: + if (tokSFCSupport->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_VDBOX_INFO__ANONYMOUS5662__SFC_SUPPORTED_BITS: { + const TokenHeader *tokSfcSupportedBits = varLen->getValue(); + const TokenHeader *tokSfcSupportedBitsEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSfcSupportedBits < tokSfcSupportedBitsEnd) { + if (false == tokSfcSupportedBits->flags.flag4IsVariableLength) { + switch (tokSfcSupportedBits->id) { + default: + if (tokSfcSupportedBits->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX0: { + dst.SFCSupport.SfcSupportedBits.VDBox0 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX1: { + dst.SFCSupport.SfcSupportedBits.VDBox1 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX2: { + dst.SFCSupport.SfcSupportedBits.VDBox2 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX3: { + dst.SFCSupport.SfcSupportedBits.VDBox3 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX4: { + dst.SFCSupport.SfcSupportedBits.VDBox4 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX5: { + dst.SFCSupport.SfcSupportedBits.VDBox5 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX6: { + dst.SFCSupport.SfcSupportedBits.VDBox6 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX7: { + dst.SFCSupport.SfcSupportedBits.VDBox7 = readTokValue(*tokSfcSupportedBits); + } break; + }; + tokSfcSupportedBits = tokSfcSupportedBits + 1 + tokSfcSupportedBits->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSfcSupportedBits); + if (tokSfcSupportedBits->flags.flag3IsMandatory) { + return false; + } + tokSfcSupportedBits = tokSfcSupportedBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSfcSupportedBits == tokSfcSupportedBitsEnd); + } break; + }; + tokSFCSupport = tokSFCSupport + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSFCSupport == tokSFCSupportEnd); + } break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(GT_CCS_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_CCS_INFO__NUMBER_OF_CCSENABLED: { + dst.NumberOfCCSEnabled = readTokValue(*tok); + } break; + case TOK_FBB_GT_CCS_INFO__IS_VALID: { + dst.IsValid = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GT_CCS_INFO: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + case TOK_FS_GT_CCS_INFO__INSTANCES: { + const TokenHeader *tokInstances = varLen->getValue(); + const TokenHeader *tokInstancesEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokInstances < tokInstancesEnd) { + if (false == tokInstances->flags.flag4IsVariableLength) { + switch (tokInstances->id) { + default: + if (tokInstances->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSENABLE_MASK: { + dst.Instances.CCSEnableMask = readTokValue(*tokInstances); + } break; + }; + tokInstances = tokInstances + 1 + tokInstances->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokInstances); + switch (tokInstances->id) { + default: + if (tokInstances->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_CCS_INFO__CCSINSTANCES__BITS: { + const TokenHeader *tokBits = varLen->getValue(); + const TokenHeader *tokBitsEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokBits < tokBitsEnd) { + if (false == tokBits->flags.flag4IsVariableLength) { + switch (tokBits->id) { + default: + if (tokBits->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS0ENABLED: { + dst.Instances.Bits.CCS0Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS1ENABLED: { + dst.Instances.Bits.CCS1Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS2ENABLED: { + dst.Instances.Bits.CCS2Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS3ENABLED: { + dst.Instances.Bits.CCS3Enabled = readTokValue(*tokBits); + } break; + }; + tokBits = tokBits + 1 + tokBits->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokBits); + if (tokBits->flags.flag3IsMandatory) { + return false; + } + tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokBits == tokBitsEnd); + } break; + }; + tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokInstances == tokInstancesEnd); + } break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(GT_MULTI_TILE_ARCH_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__TILE_COUNT: { + dst.TileCount = readTokValue(*tok); + } break; + case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE0: { + dst.Tile0 = readTokValue(*tok); + } break; + case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE1: { + dst.Tile1 = readTokValue(*tok); + } break; + case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE2: { + dst.Tile2 = readTokValue(*tok); + } break; + case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE3: { + dst.Tile3 = readTokValue(*tok); + } break; + case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__TILE_MASK: { + dst.TileMask = readTokValue(*tok); + } break; + case TOK_FBB_GT_MULTI_TILE_ARCH_INFO__IS_VALID: { + dst.IsValid = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GT_MULTI_TILE_ARCH_INFO: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(GT_SQIDI_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_SQIDI_INFO__NUMBEROF_SQIDI: { + dst.NumberofSQIDI = readTokValue(*tok); + } break; + case TOK_FBD_GT_SQIDI_INFO__NUMBEROF_DOORBELL_PER_SQIDI: { + dst.NumberofDoorbellPerSQIDI = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GT_SQIDI_INFO: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(_GT_CACHE_TYPEST &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__L3: { + dst.L3 = readTokValue(*tok); + } break; + case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__LLC: { + dst.LLC = readTokValue(*tok); + } break; + case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__E_DRAM: { + dst.eDRAM = readTokValue(*tok); + } break; + case TOK_FBD_GT_CACHE_TYPES__CACHE_TYPE_MASK: { + dst.CacheTypeMask = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GT_CACHE_TYPES: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(GT_SYSTEM_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_SYSTEM_INFO__EUCOUNT: { + dst.EUCount = readTokValue(*tok); + } break; + case TOK_FBD_GT_SYSTEM_INFO__THREAD_COUNT: { + dst.ThreadCount = readTokValue(*tok); + } break; + case TOK_FBD_GT_SYSTEM_INFO__SLICE_COUNT: { + dst.SliceCount = readTokValue(*tok); + } break; + case TOK_FBD_GT_SYSTEM_INFO__SUB_SLICE_COUNT: { + dst.SubSliceCount = readTokValue(*tok); + } break; + case TOK_FBD_GT_SYSTEM_INFO__DUAL_SUB_SLICE_COUNT: { + dst.DualSubSliceCount = readTokValue(*tok); + } break; + case TOK_FBQ_GT_SYSTEM_INFO__L3CACHE_SIZE_IN_KB: { + dst.L3CacheSizeInKb = readTokValue(*tok); + } break; + case TOK_FBQ_GT_SYSTEM_INFO__LLCCACHE_SIZE_IN_KB: { + dst.LLCCacheSizeInKb = readTokValue(*tok); + } break; + case TOK_FBQ_GT_SYSTEM_INFO__EDRAM_SIZE_IN_KB: { + dst.EdramSizeInKb = readTokValue(*tok); + } break; + case TOK_FBD_GT_SYSTEM_INFO__L3BANK_COUNT: { + dst.L3BankCount = readTokValue(*tok); + } break; + case TOK_FBD_GT_SYSTEM_INFO__MAX_FILL_RATE: { + dst.MaxFillRate = readTokValue(*tok); + } break; + case TOK_FBD_GT_SYSTEM_INFO__EU_COUNT_PER_POOL_MAX: { + dst.EuCountPerPoolMax = readTokValue(*tok); + } break; + case TOK_FBD_GT_SYSTEM_INFO__EU_COUNT_PER_POOL_MIN: { + dst.EuCountPerPoolMin = readTokValue(*tok); + } break; + case TOK_FBD_GT_SYSTEM_INFO__TOTAL_VS_THREADS: { + dst.TotalVsThreads = readTokValue(*tok); + } break; + case TOK_FBD_GT_SYSTEM_INFO__TOTAL_HS_THREADS: { + dst.TotalHsThreads = readTokValue(*tok); + } break; + case TOK_FBD_GT_SYSTEM_INFO__TOTAL_DS_THREADS: { + dst.TotalDsThreads = readTokValue(*tok); + } break; + case TOK_FBD_GT_SYSTEM_INFO__TOTAL_GS_THREADS: { + dst.TotalGsThreads = readTokValue(*tok); + } break; + case TOK_FBD_GT_SYSTEM_INFO__TOTAL_PS_THREADS_WINDOWER_RANGE: { + dst.TotalPsThreadsWindowerRange = readTokValue(*tok); + } break; + case TOK_FBD_GT_SYSTEM_INFO__TOTAL_VS_THREADS_POCS: { + dst.TotalVsThreads_Pocs = readTokValue(*tok); + } break; + case TOK_FBD_GT_SYSTEM_INFO__CSR_SIZE_IN_MB: { + dst.CsrSizeInMb = readTokValue(*tok); + } break; + case TOK_FBD_GT_SYSTEM_INFO__MAX_EU_PER_SUB_SLICE: { + dst.MaxEuPerSubSlice = readTokValue(*tok); + } break; + case TOK_FBD_GT_SYSTEM_INFO__MAX_SLICES_SUPPORTED: { + dst.MaxSlicesSupported = readTokValue(*tok); + } break; + case TOK_FBD_GT_SYSTEM_INFO__MAX_SUB_SLICES_SUPPORTED: { + dst.MaxSubSlicesSupported = readTokValue(*tok); + } break; + case TOK_FBD_GT_SYSTEM_INFO__MAX_DUAL_SUB_SLICES_SUPPORTED: { + dst.MaxDualSubSlicesSupported = readTokValue(*tok); + } break; + case TOK_FBB_GT_SYSTEM_INFO__IS_L3HASH_MODE_ENABLED: { + dst.IsL3HashModeEnabled = readTokValue(*tok); + } break; + case TOK_FBB_GT_SYSTEM_INFO__IS_DYNAMICALLY_POPULATED: { + dst.IsDynamicallyPopulated = readTokValue(*tok); + } break; + case TOK_FBD_GT_SYSTEM_INFO__RESERVED_CCSWAYS: { + dst.ReservedCCSWays = readTokValue(*tok); + } break; + case TOK_FBD_GT_SYSTEM_INFO__NUM_THREADS_PER_EU: { + dst.NumThreadsPerEu = readTokValue(*tok); + } break; + case TOK_FBD_GT_SYSTEM_INFO__MAX_VECS: { + dst.MaxVECS = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GT_SYSTEM_INFO: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + case TOK_FS_GT_SYSTEM_INFO__SLICE_INFO: { + uint32_t arrayElementIdSliceInfo = varLen->arrayElementId; + const TokenHeader *tokSliceInfo = varLen->getValue(); + const TokenHeader *tokSliceInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSliceInfo < tokSliceInfoEnd) { + if (false == tokSliceInfo->flags.flag4IsVariableLength) { + switch (tokSliceInfo->id) { + default: + if (tokSliceInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBB_GT_SLICE_INFO__ENABLED: { + dst.SliceInfo[arrayElementIdSliceInfo].Enabled = readTokValue(*tokSliceInfo); + } break; + case TOK_FBD_GT_SLICE_INFO__SUB_SLICE_ENABLED_COUNT: { + dst.SliceInfo[arrayElementIdSliceInfo].SubSliceEnabledCount = readTokValue(*tokSliceInfo); + } break; + case TOK_FBD_GT_SLICE_INFO__DUAL_SUB_SLICE_ENABLED_COUNT: { + dst.SliceInfo[arrayElementIdSliceInfo].DualSubSliceEnabledCount = readTokValue(*tokSliceInfo); + } break; + }; + tokSliceInfo = tokSliceInfo + 1 + tokSliceInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSliceInfo); + switch (tokSliceInfo->id) { + default: + if (tokSliceInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_SLICE_INFO__SUB_SLICE_INFO: { + uint32_t arrayElementIdSubSliceInfo = varLen->arrayElementId; + const TokenHeader *tokSubSliceInfo = varLen->getValue(); + const TokenHeader *tokSubSliceInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSubSliceInfo < tokSubSliceInfoEnd) { + if (false == tokSubSliceInfo->flags.flag4IsVariableLength) { + switch (tokSubSliceInfo->id) { + default: + if (tokSubSliceInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBB_GT_SUBSLICE_INFO__ENABLED: { + dst.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].Enabled = readTokValue(*tokSubSliceInfo); + } break; + case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_COUNT: { + dst.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledCount = readTokValue(*tokSubSliceInfo); + } break; + case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_MASK: { + dst.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledMask = readTokValue(*tokSubSliceInfo); + } break; + }; + tokSubSliceInfo = tokSubSliceInfo + 1 + tokSubSliceInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSubSliceInfo); + if (tokSubSliceInfo->flags.flag3IsMandatory) { + return false; + } + tokSubSliceInfo = tokSubSliceInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSubSliceInfo == tokSubSliceInfoEnd); + } break; + case TOK_FS_GT_SLICE_INFO__DSSINFO: { + uint32_t arrayElementIdDSSInfo = varLen->arrayElementId; + const TokenHeader *tokDSSInfo = varLen->getValue(); + const TokenHeader *tokDSSInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokDSSInfo < tokDSSInfoEnd) { + if (false == tokDSSInfo->flags.flag4IsVariableLength) { + switch (tokDSSInfo->id) { + default: + if (tokDSSInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBB_GT_DUALSUBSLICE_INFO__ENABLED: { + dst.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].Enabled = readTokValue(*tokDSSInfo); + } break; + }; + tokDSSInfo = tokDSSInfo + 1 + tokDSSInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokDSSInfo); + switch (tokDSSInfo->id) { + default: + if (tokDSSInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_DUALSUBSLICE_INFO__SUB_SLICE: { + uint32_t arrayElementIdSubSlice = varLen->arrayElementId; + const TokenHeader *tokSubSlice = varLen->getValue(); + const TokenHeader *tokSubSliceEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSubSlice < tokSubSliceEnd) { + if (false == tokSubSlice->flags.flag4IsVariableLength) { + switch (tokSubSlice->id) { + default: + if (tokSubSlice->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBB_GT_SUBSLICE_INFO__ENABLED: { + dst.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].Enabled = readTokValue(*tokSubSlice); + } break; + case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_COUNT: { + dst.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledCount = readTokValue(*tokSubSlice); + } break; + case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_MASK: { + dst.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledMask = readTokValue(*tokSubSlice); + } break; + }; + tokSubSlice = tokSubSlice + 1 + tokSubSlice->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSubSlice); + if (tokSubSlice->flags.flag3IsMandatory) { + return false; + } + tokSubSlice = tokSubSlice + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSubSlice == tokSubSliceEnd); + } break; + }; + tokDSSInfo = tokDSSInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokDSSInfo == tokDSSInfoEnd); + } break; + }; + tokSliceInfo = tokSliceInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSliceInfo == tokSliceInfoEnd); + } break; + case TOK_FS_GT_SYSTEM_INFO__SQIDI_INFO: { + const TokenHeader *tokSqidiInfo = varLen->getValue(); + const TokenHeader *tokSqidiInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSqidiInfo < tokSqidiInfoEnd) { + if (false == tokSqidiInfo->flags.flag4IsVariableLength) { + switch (tokSqidiInfo->id) { + default: + if (tokSqidiInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_SQIDI_INFO__NUMBEROF_SQIDI: { + dst.SqidiInfo.NumberofSQIDI = readTokValue(*tokSqidiInfo); + } break; + case TOK_FBD_GT_SQIDI_INFO__NUMBEROF_DOORBELL_PER_SQIDI: { + dst.SqidiInfo.NumberofDoorbellPerSQIDI = readTokValue(*tokSqidiInfo); + } break; + }; + tokSqidiInfo = tokSqidiInfo + 1 + tokSqidiInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSqidiInfo); + if (tokSqidiInfo->flags.flag3IsMandatory) { + return false; + } + tokSqidiInfo = tokSqidiInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSqidiInfo == tokSqidiInfoEnd); + } break; + case TOK_FS_GT_SYSTEM_INFO__CCSINFO: { + const TokenHeader *tokCCSInfo = varLen->getValue(); + const TokenHeader *tokCCSInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokCCSInfo < tokCCSInfoEnd) { + if (false == tokCCSInfo->flags.flag4IsVariableLength) { + switch (tokCCSInfo->id) { + default: + if (tokCCSInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_CCS_INFO__NUMBER_OF_CCSENABLED: { + dst.CCSInfo.NumberOfCCSEnabled = readTokValue(*tokCCSInfo); + } break; + case TOK_FBB_GT_CCS_INFO__IS_VALID: { + dst.CCSInfo.IsValid = readTokValue(*tokCCSInfo); + } break; + }; + tokCCSInfo = tokCCSInfo + 1 + tokCCSInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokCCSInfo); + switch (tokCCSInfo->id) { + default: + if (tokCCSInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_CCS_INFO__INSTANCES: { + const TokenHeader *tokInstances = varLen->getValue(); + const TokenHeader *tokInstancesEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokInstances < tokInstancesEnd) { + if (false == tokInstances->flags.flag4IsVariableLength) { + switch (tokInstances->id) { + default: + if (tokInstances->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSENABLE_MASK: { + dst.CCSInfo.Instances.CCSEnableMask = readTokValue(*tokInstances); + } break; + }; + tokInstances = tokInstances + 1 + tokInstances->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokInstances); + switch (tokInstances->id) { + default: + if (tokInstances->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_CCS_INFO__CCSINSTANCES__BITS: { + const TokenHeader *tokBits = varLen->getValue(); + const TokenHeader *tokBitsEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokBits < tokBitsEnd) { + if (false == tokBits->flags.flag4IsVariableLength) { + switch (tokBits->id) { + default: + if (tokBits->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS0ENABLED: { + dst.CCSInfo.Instances.Bits.CCS0Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS1ENABLED: { + dst.CCSInfo.Instances.Bits.CCS1Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS2ENABLED: { + dst.CCSInfo.Instances.Bits.CCS2Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS3ENABLED: { + dst.CCSInfo.Instances.Bits.CCS3Enabled = readTokValue(*tokBits); + } break; + }; + tokBits = tokBits + 1 + tokBits->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokBits); + if (tokBits->flags.flag3IsMandatory) { + return false; + } + tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokBits == tokBitsEnd); + } break; + }; + tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokInstances == tokInstancesEnd); + } break; + }; + tokCCSInfo = tokCCSInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokCCSInfo == tokCCSInfoEnd); + } break; + case TOK_FS_GT_SYSTEM_INFO__MULTI_TILE_ARCH_INFO: { + const TokenHeader *tokMultiTileArchInfo = varLen->getValue(); + const TokenHeader *tokMultiTileArchInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokMultiTileArchInfo < tokMultiTileArchInfoEnd) { + if (false == tokMultiTileArchInfo->flags.flag4IsVariableLength) { + switch (tokMultiTileArchInfo->id) { + default: + if (tokMultiTileArchInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__TILE_COUNT: { + dst.MultiTileArchInfo.TileCount = readTokValue(*tokMultiTileArchInfo); + } break; + case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE0: { + dst.MultiTileArchInfo.Tile0 = readTokValue(*tokMultiTileArchInfo); + } break; + case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE1: { + dst.MultiTileArchInfo.Tile1 = readTokValue(*tokMultiTileArchInfo); + } break; + case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE2: { + dst.MultiTileArchInfo.Tile2 = readTokValue(*tokMultiTileArchInfo); + } break; + case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE3: { + dst.MultiTileArchInfo.Tile3 = readTokValue(*tokMultiTileArchInfo); + } break; + case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__TILE_MASK: { + dst.MultiTileArchInfo.TileMask = readTokValue(*tokMultiTileArchInfo); + } break; + case TOK_FBB_GT_MULTI_TILE_ARCH_INFO__IS_VALID: { + dst.MultiTileArchInfo.IsValid = readTokValue(*tokMultiTileArchInfo); + } break; + }; + tokMultiTileArchInfo = tokMultiTileArchInfo + 1 + tokMultiTileArchInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokMultiTileArchInfo); + if (tokMultiTileArchInfo->flags.flag3IsMandatory) { + return false; + } + tokMultiTileArchInfo = tokMultiTileArchInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokMultiTileArchInfo == tokMultiTileArchInfoEnd); + } break; + case TOK_FS_GT_SYSTEM_INFO__VDBOX_INFO: { + const TokenHeader *tokVDBoxInfo = varLen->getValue(); + const TokenHeader *tokVDBoxInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokVDBoxInfo < tokVDBoxInfoEnd) { + if (false == tokVDBoxInfo->flags.flag4IsVariableLength) { + switch (tokVDBoxInfo->id) { + default: + if (tokVDBoxInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VDBOX_INFO__NUMBER_OF_VDBOX_ENABLED: { + dst.VDBoxInfo.NumberOfVDBoxEnabled = readTokValue(*tokVDBoxInfo); + } break; + case TOK_FBB_GT_VDBOX_INFO__IS_VALID: { + dst.VDBoxInfo.IsValid = readTokValue(*tokVDBoxInfo); + } break; + }; + tokVDBoxInfo = tokVDBoxInfo + 1 + tokVDBoxInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokVDBoxInfo); + switch (tokVDBoxInfo->id) { + default: + if (tokVDBoxInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_VDBOX_INFO__INSTANCES: { + const TokenHeader *tokInstances = varLen->getValue(); + const TokenHeader *tokInstancesEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokInstances < tokInstancesEnd) { + if (false == tokInstances->flags.flag4IsVariableLength) { + switch (tokInstances->id) { + default: + if (tokInstances->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBOX_ENABLE_MASK: { + dst.VDBoxInfo.Instances.VDBoxEnableMask = readTokValue(*tokInstances); + } break; + }; + tokInstances = tokInstances + 1 + tokInstances->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokInstances); + switch (tokInstances->id) { + default: + if (tokInstances->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_VDBOX_INFO__VDBOX_INSTANCES__BITS: { + const TokenHeader *tokBits = varLen->getValue(); + const TokenHeader *tokBitsEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokBits < tokBitsEnd) { + if (false == tokBits->flags.flag4IsVariableLength) { + switch (tokBits->id) { + default: + if (tokBits->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX0ENABLED: { + dst.VDBoxInfo.Instances.Bits.VDBox0Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX1ENABLED: { + dst.VDBoxInfo.Instances.Bits.VDBox1Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX2ENABLED: { + dst.VDBoxInfo.Instances.Bits.VDBox2Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX3ENABLED: { + dst.VDBoxInfo.Instances.Bits.VDBox3Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX4ENABLED: { + dst.VDBoxInfo.Instances.Bits.VDBox4Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX5ENABLED: { + dst.VDBoxInfo.Instances.Bits.VDBox5Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX6ENABLED: { + dst.VDBoxInfo.Instances.Bits.VDBox6Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX7ENABLED: { + dst.VDBoxInfo.Instances.Bits.VDBox7Enabled = readTokValue(*tokBits); + } break; + }; + tokBits = tokBits + 1 + tokBits->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokBits); + if (tokBits->flags.flag3IsMandatory) { + return false; + } + tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokBits == tokBitsEnd); + } break; + }; + tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokInstances == tokInstancesEnd); + } break; + case TOK_FS_GT_VDBOX_INFO__SFCSUPPORT: { + const TokenHeader *tokSFCSupport = varLen->getValue(); + const TokenHeader *tokSFCSupportEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSFCSupport < tokSFCSupportEnd) { + if (false == tokSFCSupport->flags.flag4IsVariableLength) { + switch (tokSFCSupport->id) { + default: + if (tokSFCSupport->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__VALUE: { + dst.VDBoxInfo.SFCSupport.Value = readTokValue(*tokSFCSupport); + } break; + }; + tokSFCSupport = tokSFCSupport + 1 + tokSFCSupport->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSFCSupport); + switch (tokSFCSupport->id) { + default: + if (tokSFCSupport->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_VDBOX_INFO__ANONYMOUS5662__SFC_SUPPORTED_BITS: { + const TokenHeader *tokSfcSupportedBits = varLen->getValue(); + const TokenHeader *tokSfcSupportedBitsEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSfcSupportedBits < tokSfcSupportedBitsEnd) { + if (false == tokSfcSupportedBits->flags.flag4IsVariableLength) { + switch (tokSfcSupportedBits->id) { + default: + if (tokSfcSupportedBits->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX0: { + dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox0 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX1: { + dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox1 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX2: { + dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox2 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX3: { + dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox3 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX4: { + dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox4 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX5: { + dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox5 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX6: { + dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox6 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX7: { + dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox7 = readTokValue(*tokSfcSupportedBits); + } break; + }; + tokSfcSupportedBits = tokSfcSupportedBits + 1 + tokSfcSupportedBits->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSfcSupportedBits); + if (tokSfcSupportedBits->flags.flag3IsMandatory) { + return false; + } + tokSfcSupportedBits = tokSfcSupportedBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSfcSupportedBits == tokSfcSupportedBitsEnd); + } break; + }; + tokSFCSupport = tokSFCSupport + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSFCSupport == tokSFCSupportEnd); + } break; + }; + tokVDBoxInfo = tokVDBoxInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokVDBoxInfo == tokVDBoxInfoEnd); + } break; + case TOK_FS_GT_SYSTEM_INFO__VEBOX_INFO: { + const TokenHeader *tokVEBoxInfo = varLen->getValue(); + const TokenHeader *tokVEBoxInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokVEBoxInfo < tokVEBoxInfoEnd) { + if (false == tokVEBoxInfo->flags.flag4IsVariableLength) { + switch (tokVEBoxInfo->id) { + default: + if (tokVEBoxInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VEBOX_INFO__NUMBER_OF_VEBOX_ENABLED: { + dst.VEBoxInfo.NumberOfVEBoxEnabled = readTokValue(*tokVEBoxInfo); + } break; + case TOK_FBB_GT_VEBOX_INFO__IS_VALID: { + dst.VEBoxInfo.IsValid = readTokValue(*tokVEBoxInfo); + } break; + }; + tokVEBoxInfo = tokVEBoxInfo + 1 + tokVEBoxInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokVEBoxInfo); + switch (tokVEBoxInfo->id) { + default: + if (tokVEBoxInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_VEBOX_INFO__INSTANCES: { + const TokenHeader *tokInstances = varLen->getValue(); + const TokenHeader *tokInstancesEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokInstances < tokInstancesEnd) { + if (false == tokInstances->flags.flag4IsVariableLength) { + switch (tokInstances->id) { + default: + if (tokInstances->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBOX_ENABLE_MASK: { + dst.VEBoxInfo.Instances.VEBoxEnableMask = readTokValue(*tokInstances); + } break; + }; + tokInstances = tokInstances + 1 + tokInstances->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokInstances); + switch (tokInstances->id) { + default: + if (tokInstances->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_VEBOX_INFO__VEBOX_INSTANCES__BITS: { + const TokenHeader *tokBits = varLen->getValue(); + const TokenHeader *tokBitsEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokBits < tokBitsEnd) { + if (false == tokBits->flags.flag4IsVariableLength) { + switch (tokBits->id) { + default: + if (tokBits->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX0ENABLED: { + dst.VEBoxInfo.Instances.Bits.VEBox0Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX1ENABLED: { + dst.VEBoxInfo.Instances.Bits.VEBox1Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX2ENABLED: { + dst.VEBoxInfo.Instances.Bits.VEBox2Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX3ENABLED: { + dst.VEBoxInfo.Instances.Bits.VEBox3Enabled = readTokValue(*tokBits); + } break; + }; + tokBits = tokBits + 1 + tokBits->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokBits); + if (tokBits->flags.flag3IsMandatory) { + return false; + } + tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokBits == tokBitsEnd); + } break; + }; + tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokInstances == tokInstancesEnd); + } break; + case TOK_FS_GT_VEBOX_INFO__SFCSUPPORT: { + const TokenHeader *tokSFCSupport = varLen->getValue(); + const TokenHeader *tokSFCSupportEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSFCSupport < tokSFCSupportEnd) { + if (false == tokSFCSupport->flags.flag4IsVariableLength) { + switch (tokSFCSupport->id) { + default: + if (tokSFCSupport->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__VALUE: { + dst.VEBoxInfo.SFCSupport.Value = readTokValue(*tokSFCSupport); + } break; + }; + tokSFCSupport = tokSFCSupport + 1 + tokSFCSupport->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSFCSupport); + switch (tokSFCSupport->id) { + default: + if (tokSFCSupport->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_VEBOX_INFO__ANONYMOUS3862__SFC_SUPPORTED_BITS: { + const TokenHeader *tokSfcSupportedBits = varLen->getValue(); + const TokenHeader *tokSfcSupportedBitsEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSfcSupportedBits < tokSfcSupportedBitsEnd) { + if (false == tokSfcSupportedBits->flags.flag4IsVariableLength) { + switch (tokSfcSupportedBits->id) { + default: + if (tokSfcSupportedBits->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX0: { + dst.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox0 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX1: { + dst.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox1 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX2: { + dst.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox2 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX3: { + dst.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox3 = readTokValue(*tokSfcSupportedBits); + } break; + }; + tokSfcSupportedBits = tokSfcSupportedBits + 1 + tokSfcSupportedBits->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSfcSupportedBits); + if (tokSfcSupportedBits->flags.flag3IsMandatory) { + return false; + } + tokSfcSupportedBits = tokSfcSupportedBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSfcSupportedBits == tokSfcSupportedBitsEnd); + } break; + }; + tokSFCSupport = tokSFCSupport + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSFCSupport == tokSFCSupportEnd); + } break; + }; + tokVEBoxInfo = tokVEBoxInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokVEBoxInfo == tokVEBoxInfoEnd); + } break; + case TOK_FS_GT_SYSTEM_INFO__CACHE_TYPES: { + const TokenHeader *tokCacheTypes = varLen->getValue(); + const TokenHeader *tokCacheTypesEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokCacheTypes < tokCacheTypesEnd) { + if (false == tokCacheTypes->flags.flag4IsVariableLength) { + switch (tokCacheTypes->id) { + default: + if (tokCacheTypes->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__L3: { + dst.CacheTypes.L3 = readTokValue(*tokCacheTypes); + } break; + case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__LLC: { + dst.CacheTypes.LLC = readTokValue(*tokCacheTypes); + } break; + case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__E_DRAM: { + dst.CacheTypes.eDRAM = readTokValue(*tokCacheTypes); + } break; + case TOK_FBD_GT_CACHE_TYPES__CACHE_TYPE_MASK: { + dst.CacheTypes.CacheTypeMask = readTokValue(*tokCacheTypes); + } break; + }; + tokCacheTypes = tokCacheTypes + 1 + tokCacheTypes->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokCacheTypes); + if (tokCacheTypes->flags.flag3IsMandatory) { + return false; + } + tokCacheTypes = tokCacheTypes + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokCacheTypes == tokCacheTypesEnd); + } break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(_SKU_FEATURE_TABLET &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_DESKTOP: { + dst.FtrDesktop = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_VERING: { + dst.FtrVERing = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_VCS2: { + dst.FtrVcs2 = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_BIG_DIE: { + dst.FtrGtBigDie = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_MEDIUM_DIE: { + dst.FtrGtMediumDie = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_SMALL_DIE: { + dst.FtrGtSmallDie = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT1: { + dst.FtrGT1 = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT1_5: { + dst.FtrGT1_5 = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT2: { + dst.FtrGT2 = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT2_5: { + dst.FtrGT2_5 = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT3: { + dst.FtrGT3 = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT4: { + dst.FtrGT4 = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_ULT: { + dst.FtrULT = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_IVBM0M1PLATFORM: { + dst.FtrIVBM0M1Platform = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CHANNEL_SWIZZLING_XORENABLED: { + dst.FtrChannelSwizzlingXOREnabled = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTA: { + dst.FtrGTA = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTC: { + dst.FtrGTC = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTX: { + dst.FtrGTX = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR5SLICE: { + dst.Ftr5Slice = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_LCIA: { + dst.FtrLCIA = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_RESOURCE_STREAMER: { + dst.FtrResourceStreamer = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSRING: { + dst.FtrCCSRing = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSNODE: { + dst.FtrCCSNode = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSMULTI_INSTANCE: { + dst.FtrCCSMultiInstance = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_DISPLAY_DISABLED: { + dst.FtrDisplayDisabled = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_SGTPVSKUSTRAP_PRESENT: { + dst.FtrSGTPVSKUStrapPresent = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21584__FTR_POOLED_EU_ENABLED: { + dst.FtrPooledEuEnabled = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_MID_BATCH_PREEMPT: { + dst.FtrGpGpuMidBatchPreempt = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_THREAD_GROUP_LEVEL_PREEMPT: { + dst.FtrGpGpuThreadGroupLevelPreempt = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_MID_THREAD_LEVEL_PREEMPT: { + dst.FtrGpGpuMidThreadLevelPreempt = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR3D_MID_BATCH_PREEMPT: { + dst.Ftr3dMidBatchPreempt = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR3D_OBJECT_LEVEL_PREEMPT: { + dst.Ftr3dObjectLevelPreempt = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PER_CTXT_PREEMPTION_GRANULARITY_CONTROL: { + dst.FtrPerCtxtPreemptionGranularityControl = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PPGTT: { + dst.FtrPPGTT = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_IA32E_GFX_PTES: { + dst.FtrIA32eGfxPTEs = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_MEM_TYPE_MOCS_DEFER_PAT: { + dst.FtrMemTypeMocsDeferPAT = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PML4SUPPORT: { + dst.FtrPml4Support = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_SVM: { + dst.FtrSVM = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TILE_MAPPED_RESOURCE: { + dst.FtrTileMappedResource = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TRANSLATION_TABLE: { + dst.FtrTranslationTable = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_USER_MODE_TRANSLATION_TABLE: { + dst.FtrUserModeTranslationTable = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_NULL_PAGES: { + dst.FtrNullPages = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_L3IACOHERENCY: { + dst.FtrL3IACoherency = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_EDRAM: { + dst.FtrEDram = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LLCBYPASS: { + dst.FtrLLCBypass = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CRYSTALWELL: { + dst.FtrCrystalwell = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CENTRAL_CACHE_POLICY: { + dst.FtrCentralCachePolicy = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_IO_MMU_PAGE_FAULTING: { + dst.FtrIoMmuPageFaulting = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2GPU_MMU: { + dst.FtrWddm2GpuMmu = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2SVM: { + dst.FtrWddm2Svm = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_STANDARD_MIP_TAIL_FORMAT: { + dst.FtrStandardMipTailFormat = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2_1_64KB_PAGES: { + dst.FtrWddm2_1_64kbPages = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GTT_CACHE_INVALIDATION: { + dst.FtrGttCacheInvalidation = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_E2ECOMPRESSION: { + dst.FtrE2ECompression = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LINEAR_CCS: { + dst.FtrLinearCCS = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LOCAL_MEMORY: { + dst.FtrLocalMemory = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PPGTT64KBWALK_OPTIMIZATION: { + dst.FtrPpgtt64KBWalkOptimization = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TILE_Y: { + dst.FtrTileY = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_FLAT_PHYS_CCS: { + dst.FtrFlatPhysCCS = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_MULTI_TILE_ARCH: { + dst.FtrMultiTileArch = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LOCAL_MEMORY_ALLOWS4KB: { + dst.FtrLocalMemoryAllows4KB = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_DISPLAY_XTILING: { + dst.FtrDisplayXTiling = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CAMERA_CAPTURE_CACHING: { + dst.FtrCameraCaptureCaching = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_KMD_DAF: { + dst.FtrKmdDaf = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_FRAME_BUFFER_LLC: { + dst.FtrFrameBufferLLC = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_DRIVER_FLR: { + dst.FtrDriverFLR = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC_LDR2D: { + dst.FtrAstcLdr2D = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC_HDR2D: { + dst.FtrAstcHdr2D = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC3D: { + dst.FtrAstc3D = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC: { + dst.FtrFbc = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC2ADDRESS_TRANSLATION: { + dst.FtrFbc2AddressTranslation = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC_BLITTER_TRACKING: { + dst.FtrFbcBlitterTracking = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC_CPU_TRACKING: { + dst.FtrFbcCpuTracking = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_VEBOX: { + dst.FtrVEBOX = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS54736__FTR_REND_COMP: { + dst.FtrRendComp = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS54736__FTR_DISPLAY_YTILING: { + dst.FtrDisplayYTiling = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_S3D: { + dst.FtrS3D = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_DISPLAY_ENGINE_S3D: { + dst.FtrDisplayEngineS3d = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_SINGLE_VEBOX_SLICE: { + dst.FtrSingleVeboxSlice = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_SIMULATION_MODE: { + dst.FtrSimulationMode = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS88095__FTR_ENABLE_GU_C: { + dst.FtrEnableGuC = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS89755__FTR_VGT: { + dst.FtrVgt = readTokValue(*tok); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS91822__FTR_ASSIGNED_GPU_TILE: { + dst.FtrAssignedGpuTile = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_SKU_FEATURE_TABLE: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(_WA_TABLET &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_WA_TABLE__WA_DO_NOT_USE_MIREPORT_PERF_COUNT: { + dst.WaDoNotUseMIReportPerfCount = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_ALIGN_INDEX_BUFFER: { + dst.WaAlignIndexBuffer = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_SEND_MIFLUSHBEFORE_VFE: { + dst.WaSendMIFLUSHBeforeVFE = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_DISABLE_PER_CTXT_PREEMPTION_GRANULARITY_CONTROL: { + dst.WaDisablePerCtxtPreemptionGranularityControl = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_ENABLE_PREEMPTION_GRANULARITY_CONTROL_BY_UMD: { + dst.WaEnablePreemptionGranularityControlByUMD = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_DISABLE_LSQCROPERFFOR_OCL: { + dst.WaDisableLSQCROPERFforOCL = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_VALIGN2FOR96BPP_FORMATS: { + dst.WaValign2For96bppFormats = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_VALIGN2FOR_R8G8B8UINTFORMAT: { + dst.WaValign2ForR8G8B8UINTFormat = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_REPORT_PERF_COUNT_USE_GLOBAL_CONTEXT_ID: { + dst.WaReportPerfCountUseGlobalContextID = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_FORCE_PC_BB_FULL_CFG_RESTORE: { + dst.WaForcePcBbFullCfgRestore = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_CSRUNCACHABLE: { + dst.WaCSRUncachable = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_DISABLE_FUSED_THREAD_SCHEDULING: { + dst.WaDisableFusedThreadScheduling = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_MODIFY_VFESTATE_AFTER_GPGPUPREEMPTION: { + dst.WaModifyVFEStateAfterGPGPUPreemption = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_CURSOR16K: { + dst.WaCursor16K = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA8K_ALIGNFOR_ASYNC_FLIP: { + dst.Wa8kAlignforAsyncFlip = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA29BIT_DISPLAY_ADDR_LIMIT: { + dst.Wa29BitDisplayAddrLimit = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_ALIGN_CONTEXT_IMAGE: { + dst.WaAlignContextImage = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_FORCE_GLOBAL_GTT: { + dst.WaForceGlobalGTT = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_REPORT_PERF_COUNT_FORCE_GLOBAL_GTT: { + dst.WaReportPerfCountForceGlobalGTT = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_OA_ADDRESS_TRANSLATION: { + dst.WaOaAddressTranslation = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA2ROW_VERTICAL_ALIGNMENT: { + dst.Wa2RowVerticalAlignment = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_PPGTT_ALIAS_GLOBAL_GTT_SPACE: { + dst.WaPpgttAliasGlobalGttSpace = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_CLEAR_FENCE_REGISTERS_AT_DRIVER_INIT: { + dst.WaClearFenceRegistersAtDriverInit = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_RESTRICT_PITCH128KB: { + dst.WaRestrictPitch128KB = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_AVOID_LLC: { + dst.WaAvoidLLC = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_AVOID_L3: { + dst.WaAvoidL3 = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA16TILE_FENCES_ONLY: { + dst.Wa16TileFencesOnly = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA16MBOABUFFER_ALIGNMENT: { + dst.Wa16MBOABufferAlignment = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_TRANSLATION_TABLE_UNAVAILABLE: { + dst.WaTranslationTableUnavailable = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_NO_MINIMIZED_TRIVIAL_SURFACE_PADDING: { + dst.WaNoMinimizedTrivialSurfacePadding = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_NO_BUFFER_SAMPLER_PADDING: { + dst.WaNoBufferSamplerPadding = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_SURFACE_STATE_PLANAR_YOFFSET_ALIGN_BY2: { + dst.WaSurfaceStatePlanarYOffsetAlignBy2 = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_GTT_CACHING_OFF_BY_DEFAULT: { + dst.WaGttCachingOffByDefault = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_TOUCH_ALL_SVM_MEMORY: { + dst.WaTouchAllSvmMemory = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_IOBADDRESS_MUST_BE_VALID_IN_HW_CONTEXT: { + dst.WaIOBAddressMustBeValidInHwContext = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_FLUSH_TLB_AFTER_CPU_GGTT_WRITES: { + dst.WaFlushTlbAfterCpuGgttWrites = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_MSAA8X_TILE_YDEPTH_PITCH_ALIGNMENT: { + dst.WaMsaa8xTileYDepthPitchAlignment = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_DISABLE_NULL_PAGE_AS_DUMMY: { + dst.WaDisableNullPageAsDummy = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_USE_VALIGN16ON_TILE_XYBPP816: { + dst.WaUseVAlign16OnTileXYBpp816 = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_GTT_PAT0: { + dst.WaGttPat0 = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_GTT_PAT0WB: { + dst.WaGttPat0WB = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_MEM_TYPE_IS_MAX_OF_PAT_AND_MOCS: { + dst.WaMemTypeIsMaxOfPatAndMocs = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_GTT_PAT0GTT_WB_OVER_OS_IOMMU_ELLC_ONLY: { + dst.WaGttPat0GttWbOverOsIommuEllcOnly = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_ADD_DUMMY_PAGE_FOR_DISPLAY_PREFETCH: { + dst.WaAddDummyPageForDisplayPrefetch = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_DEFAULT_TILE4: { + dst.WaDefaultTile4 = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_LLCCACHING_UNSUPPORTED: { + dst.WaLLCCachingUnsupported = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_DOUBLE_FAST_CLEAR_WIDTH_ALIGNMENT: { + dst.WaDoubleFastClearWidthAlignment = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_COMPRESSED_RESOURCE_REQUIRES_CONST_VA21: { + dst.WaCompressedResourceRequiresConstVA21 = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_DISREGARD_PLATFORM_CHECKS: { + dst.WaDisregardPlatformChecks = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_LOSSLESS_COMPRESSION_SURFACE_STRIDE: { + dst.WaLosslessCompressionSurfaceStride = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_FBC_LINEAR_SURFACE_STRIDE: { + dst.WaFbcLinearSurfaceStride = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA4K_ALIGN_UVOFFSET_NV12LINEAR_SURFACE: { + dst.Wa4kAlignUVOffsetNV12LinearSurface = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_ASTC_CORRUPTION_FOR_ODD_COMPRESSED_BLOCK_SIZE_X: { + dst.WaAstcCorruptionForOddCompressedBlockSizeX = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_AUX_TABLE16KGRANULAR: { + dst.WaAuxTable16KGranular = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_ENCRYPTED_EDRAM_ONLY_PARTIALS: { + dst.WaEncryptedEdramOnlyPartials = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_DISABLE_EDRAM_FOR_DISPLAY_RT: { + dst.WaDisableEdramForDisplayRT = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_LIMIT128BMEDIA_COMPR: { + dst.WaLimit128BMediaCompr = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_UNTYPED_BUFFER_COMPRESSION: { + dst.WaUntypedBufferCompression = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_SAMPLER_CACHE_FLUSH_BETWEEN_REDESCRIBED_SURFACE_READS: { + dst.WaSamplerCacheFlushBetweenRedescribedSurfaceReads = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA_ALIGN_YUVRESOURCE_TO_LCU: { + dst.WaAlignYUVResourceToLCU = readTokValue(*tok); + } break; + case TOK_FBD_WA_TABLE__WA32BPP_TILE_Y2DCOLOR_NO_HALIGN4: { + dst.Wa32bppTileY2DColorNoHAlign4 = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_WA_TABLE: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(PLATFORM_STRT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { + dst.eProductFamily = readTokValue(*tok); + } break; + case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { + dst.ePCHProductFamily = readTokValue(*tok); + } break; + case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { + dst.eDisplayCoreFamily = readTokValue(*tok); + } break; + case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { + dst.eRenderCoreFamily = readTokValue(*tok); + } break; + case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { + dst.ePlatformType = readTokValue(*tok); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { + dst.usDeviceID = readTokValue(*tok); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID: { + dst.usRevId = readTokValue(*tok); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { + dst.usDeviceID_PCH = readTokValue(*tok); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { + dst.usRevId_PCH = readTokValue(*tok); + } break; + case TOK_FE_PLATFORM_STR__E_GTTYPE: { + dst.eGTType = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_PLATFORM_STR: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(__KMD_CAPS_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_KMD_CAPS_INFO__GAMMA_RGB256X3X16: { + dst.Gamma_Rgb256x3x16 = readTokValue(*tok); + } break; + case TOK_FBD_KMD_CAPS_INFO__GDIACCELERATION: { + dst.GDIAcceleration = readTokValue(*tok); + } break; + case TOK_FBD_KMD_CAPS_INFO__OS_MANAGED_HW_CONTEXT: { + dst.OsManagedHwContext = readTokValue(*tok); + } break; + case TOK_FBD_KMD_CAPS_INFO__GRAPHICS_PREEMPTION_GRANULARITY: { + dst.GraphicsPreemptionGranularity = readTokValue(*tok); + } break; + case TOK_FBD_KMD_CAPS_INFO__COMPUTE_PREEMPTION_GRANULARITY: { + dst.ComputePreemptionGranularity = readTokValue(*tok); + } break; + case TOK_FBD_KMD_CAPS_INFO__INSTRUMENTATION_IS_ENABLED: { + dst.InstrumentationIsEnabled = readTokValue(*tok); + } break; + case TOK_FBD_KMD_CAPS_INFO__DRIVER_STORE_ENABLED: { + dst.DriverStoreEnabled = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_KMD_CAPS_INFO: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(__KMD_OVERLAY_OVERRIDET &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_KMD_OVERLAY_OVERRIDE__OVERRIDE_OVERLAY_CAPS: { + dst.OverrideOverlayCaps = readTokValue(*tok); + } break; + case TOK_FBD_KMD_OVERLAY_OVERRIDE__RGBOVERLAY: { + dst.RGBOverlay = readTokValue(*tok); + } break; + case TOK_FBD_KMD_OVERLAY_OVERRIDE__YUY2OVERLAY: { + dst.YUY2Overlay = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_KMD_OVERLAY_OVERRIDE: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(__KMD_OVERLAY_CAPS_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__CAPS_VALUE: { + dst.CapsValue = readTokValue(*tok); + } break; + case TOK_FBD_KMD_OVERLAY_CAPS_INFO__MAX_OVERLAY_DISPLAY_WIDTH: { + dst.MaxOverlayDisplayWidth = readTokValue(*tok); + } break; + case TOK_FBD_KMD_OVERLAY_CAPS_INFO__MAX_OVERLAY_DISPLAY_HEIGHT: { + dst.MaxOverlayDisplayHeight = readTokValue(*tok); + } break; + case TOK_FBC_KMD_OVERLAY_CAPS_INFO__HWSCALER_EXISTS: { + dst.HWScalerExists = readTokValue(*tok); + } break; + case TOK_FBD_KMD_OVERLAY_CAPS_INFO__MAX_HWSCALER_STRIDE: { + dst.MaxHWScalerStride = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_KMD_OVERLAY_CAPS_INFO: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + case TOK_FS_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__CAPS: { + const TokenHeader *tokCaps = varLen->getValue(); + const TokenHeader *tokCapsEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokCaps < tokCapsEnd) { + if (false == tokCaps->flags.flag4IsVariableLength) { + switch (tokCaps->id) { + default: + if (tokCaps->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__FULL_RANGE_RGB: { + dst.Caps.FullRangeRGB = readTokValue(*tokCaps); + } break; + case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__LIMITED_RANGE_RGB: { + dst.Caps.LimitedRangeRGB = readTokValue(*tokCaps); + } break; + case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT601: { + dst.Caps.YCbCr_BT601 = readTokValue(*tokCaps); + } break; + case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT709: { + dst.Caps.YCbCr_BT709 = readTokValue(*tokCaps); + } break; + case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT601_XV_YCC: { + dst.Caps.YCbCr_BT601_xvYCC = readTokValue(*tokCaps); + } break; + case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT709_XV_YCC: { + dst.Caps.YCbCr_BT709_xvYCC = readTokValue(*tokCaps); + } break; + case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__STRETCH_X: { + dst.Caps.StretchX = readTokValue(*tokCaps); + } break; + case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__STRETCH_Y: { + dst.Caps.StretchY = readTokValue(*tokCaps); + } break; + }; + tokCaps = tokCaps + 1 + tokCaps->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokCaps); + if (tokCaps->flags.flag3IsMandatory) { + return false; + } + tokCaps = tokCaps + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokCaps == tokCapsEnd); + } break; + case TOK_FS_KMD_OVERLAY_CAPS_INFO__OVOVERRIDE: { + const TokenHeader *tokOVOverride = varLen->getValue(); + const TokenHeader *tokOVOverrideEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokOVOverride < tokOVOverrideEnd) { + if (false == tokOVOverride->flags.flag4IsVariableLength) { + switch (tokOVOverride->id) { + default: + if (tokOVOverride->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_KMD_OVERLAY_OVERRIDE__OVERRIDE_OVERLAY_CAPS: { + dst.OVOverride.OverrideOverlayCaps = readTokValue(*tokOVOverride); + } break; + case TOK_FBD_KMD_OVERLAY_OVERRIDE__RGBOVERLAY: { + dst.OVOverride.RGBOverlay = readTokValue(*tokOVOverride); + } break; + case TOK_FBD_KMD_OVERLAY_OVERRIDE__YUY2OVERLAY: { + dst.OVOverride.YUY2Overlay = readTokValue(*tokOVOverride); + } break; + }; + tokOVOverride = tokOVOverride + 1 + tokOVOverride->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokOVOverride); + if (tokOVOverride->flags.flag3IsMandatory) { + return false; + } + tokOVOverride = tokOVOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokOVOverride == tokOVOverrideEnd); + } break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(FRAME_RATET &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_FRAME_RATE__UI_NUMERATOR: { + dst.uiNumerator = readTokValue(*tok); + } break; + case TOK_FBD_FRAME_RATE__UI_DENOMINATOR: { + dst.uiDenominator = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_FRAME_RATE: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(_KM_DEFERRED_WAIT_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_KM_DEFERRED_WAIT_INFO__FEATURE_SUPPORTED: { + dst.FeatureSupported = readTokValue(*tok); + } break; + case TOK_FBD_KM_DEFERRED_WAIT_INFO__ACTIVE_DISPLAY: { + dst.ActiveDisplay = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_KM_DEFERRED_WAIT_INFO: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(__GMM_GFX_PARTITIONINGT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + if (tok->flags.flag3IsMandatory) { + return false; + } + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GMM_GFX_PARTITIONING: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + case TOK_FS_GMM_GFX_PARTITIONING__STANDARD: { + const TokenHeader *tokStandard = varLen->getValue(); + const TokenHeader *tokStandardEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokStandard < tokStandardEnd) { + if (false == tokStandard->flags.flag4IsVariableLength) { + switch (tokStandard->id) { + default: + if (tokStandard->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__BASE: { + dst.Standard.Base = readTokValue(*tokStandard); + } break; + case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__LIMIT: { + dst.Standard.Limit = readTokValue(*tokStandard); + } break; + }; + tokStandard = tokStandard + 1 + tokStandard->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokStandard); + if (tokStandard->flags.flag3IsMandatory) { + return false; + } + tokStandard = tokStandard + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokStandard == tokStandardEnd); + } break; + case TOK_FS_GMM_GFX_PARTITIONING__STANDARD64KB: { + const TokenHeader *tokStandard64KB = varLen->getValue(); + const TokenHeader *tokStandard64KBEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokStandard64KB < tokStandard64KBEnd) { + if (false == tokStandard64KB->flags.flag4IsVariableLength) { + switch (tokStandard64KB->id) { + default: + if (tokStandard64KB->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__BASE: { + dst.Standard64KB.Base = readTokValue(*tokStandard64KB); + } break; + case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__LIMIT: { + dst.Standard64KB.Limit = readTokValue(*tokStandard64KB); + } break; + }; + tokStandard64KB = tokStandard64KB + 1 + tokStandard64KB->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokStandard64KB); + if (tokStandard64KB->flags.flag3IsMandatory) { + return false; + } + tokStandard64KB = tokStandard64KB + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokStandard64KB == tokStandard64KBEnd); + } break; + case TOK_FS_GMM_GFX_PARTITIONING__SVM: { + const TokenHeader *tokSVM = varLen->getValue(); + const TokenHeader *tokSVMEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSVM < tokSVMEnd) { + if (false == tokSVM->flags.flag4IsVariableLength) { + switch (tokSVM->id) { + default: + if (tokSVM->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__BASE: { + dst.SVM.Base = readTokValue(*tokSVM); + } break; + case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__LIMIT: { + dst.SVM.Limit = readTokValue(*tokSVM); + } break; + }; + tokSVM = tokSVM + 1 + tokSVM->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSVM); + if (tokSVM->flags.flag3IsMandatory) { + return false; + } + tokSVM = tokSVM + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSVM == tokSVMEnd); + } break; + case TOK_FS_GMM_GFX_PARTITIONING__HEAP32: { + uint32_t arrayElementIdHeap32 = varLen->arrayElementId; + const TokenHeader *tokHeap32 = varLen->getValue(); + const TokenHeader *tokHeap32End = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokHeap32 < tokHeap32End) { + if (false == tokHeap32->flags.flag4IsVariableLength) { + switch (tokHeap32->id) { + default: + if (tokHeap32->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__BASE: { + dst.Heap32[arrayElementIdHeap32].Base = readTokValue(*tokHeap32); + } break; + case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__LIMIT: { + dst.Heap32[arrayElementIdHeap32].Limit = readTokValue(*tokHeap32); + } break; + }; + tokHeap32 = tokHeap32 + 1 + tokHeap32->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokHeap32); + if (tokHeap32->flags.flag3IsMandatory) { + return false; + } + tokHeap32 = tokHeap32 + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokHeap32 == tokHeap32End); + } break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(_ADAPTER_BDF_T &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__BUS: { + dst.Bus = readTokValue(*tok); + } break; + case TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__DEVICE: { + dst.Device = readTokValue(*tok); + } break; + case TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__FUNCTION: { + dst.Function = readTokValue(*tok); + } break; + case TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__DATA: { + dst.Data = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_ADAPTER_BDF: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(_ADAPTER_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_ADAPTER_INFO__KMD_VERSION_INFO: { + dst.KmdVersionInfo = readTokValue(*tok); + } break; + case TOK_FBC_ADAPTER_INFO__DEVICE_REGISTRY_PATH: { + auto srcData = reinterpret_cast &>(*tok).getValue(); + auto srcSize = reinterpret_cast &>(*tok).getValueSizeInBytes(); + if (srcSize < sizeof(dst.DeviceRegistryPath)) { + return false; + } + WCH_SAFE_COPY(dst.DeviceRegistryPath, sizeof(dst.DeviceRegistryPath), srcData, sizeof(dst.DeviceRegistryPath)); + } break; + case TOK_FBD_ADAPTER_INFO__GFX_TIME_STAMP_FREQ: { + dst.GfxTimeStampFreq = readTokValue(*tok); + } break; + case TOK_FBD_ADAPTER_INFO__GFX_CORE_FREQUENCY: { + dst.GfxCoreFrequency = readTokValue(*tok); + } break; + case TOK_FBD_ADAPTER_INFO__FSBFREQUENCY: { + dst.FSBFrequency = readTokValue(*tok); + } break; + case TOK_FBD_ADAPTER_INFO__MIN_RENDER_FREQ: { + dst.MinRenderFreq = readTokValue(*tok); + } break; + case TOK_FBD_ADAPTER_INFO__MAX_RENDER_FREQ: { + dst.MaxRenderFreq = readTokValue(*tok); + } break; + case TOK_FBD_ADAPTER_INFO__PACKAGE_TDP: { + dst.PackageTdp = readTokValue(*tok); + } break; + case TOK_FBD_ADAPTER_INFO__MAX_FILL_RATE: { + dst.MaxFillRate = readTokValue(*tok); + } break; + case TOK_FBD_ADAPTER_INFO__NUMBER_OF_EUS: { + dst.NumberOfEUs = readTokValue(*tok); + } break; + case TOK_FBD_ADAPTER_INFO__DW_RELEASE_TARGET: { + dst.dwReleaseTarget = readTokValue(*tok); + } break; + case TOK_FBD_ADAPTER_INFO__SIZE_OF_DMA_BUFFER: { + dst.SizeOfDmaBuffer = readTokValue(*tok); + } break; + case TOK_FBD_ADAPTER_INFO__PATCH_LOCATION_LIST_SIZE: { + dst.PatchLocationListSize = readTokValue(*tok); + } break; + case TOK_FBD_ADAPTER_INFO__ALLOCATION_LIST_SIZE: { + dst.AllocationListSize = readTokValue(*tok); + } break; + case TOK_FBD_ADAPTER_INFO__SMALL_PATCH_LOCATION_LIST_SIZE: { + dst.SmallPatchLocationListSize = readTokValue(*tok); + } break; + case TOK_FBD_ADAPTER_INFO__DEFAULT_CMD_BUFFER_SIZE: { + dst.DefaultCmdBufferSize = readTokValue(*tok); + } break; + case TOK_FBQ_ADAPTER_INFO__GFX_MEMORY_SIZE: { + dst.GfxMemorySize = readTokValue(*tok); + } break; + case TOK_FBD_ADAPTER_INFO__SYSTEM_MEMORY_SIZE: { + dst.SystemMemorySize = readTokValue(*tok); + } break; + case TOK_FBD_ADAPTER_INFO__CACHE_LINE_SIZE: { + dst.CacheLineSize = readTokValue(*tok); + } break; + case TOK_FE_ADAPTER_INFO__PROCESSOR_FAMILY: { + dst.ProcessorFamily = readTokValue(*tok); + } break; + case TOK_FBC_ADAPTER_INFO__IS_HTSUPPORTED: { + dst.IsHTSupported = readTokValue(*tok); + } break; + case TOK_FBC_ADAPTER_INFO__IS_MUTI_CORE_CPU: { + dst.IsMutiCoreCpu = readTokValue(*tok); + } break; + case TOK_FBC_ADAPTER_INFO__IS_VTDSUPPORTED: { + dst.IsVTDSupported = readTokValue(*tok); + } break; + case TOK_FBD_ADAPTER_INFO__REGISTRY_PATH_LENGTH: { + dst.RegistryPathLength = readTokValue(*tok); + } break; + case TOK_FBQ_ADAPTER_INFO__DEDICATED_VIDEO_MEMORY: { + dst.DedicatedVideoMemory = readTokValue(*tok); + } break; + case TOK_FBQ_ADAPTER_INFO__SYSTEM_SHARED_MEMORY: { + dst.SystemSharedMemory = readTokValue(*tok); + } break; + case TOK_FBQ_ADAPTER_INFO__SYSTEM_VIDEO_MEMORY: { + dst.SystemVideoMemory = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_ADAPTER_INFO: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + case TOK_FS_ADAPTER_INFO__GFX_PLATFORM: { + const TokenHeader *tokGfxPlatform = varLen->getValue(); + const TokenHeader *tokGfxPlatformEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokGfxPlatform < tokGfxPlatformEnd) { + if (false == tokGfxPlatform->flags.flag4IsVariableLength) { + switch (tokGfxPlatform->id) { + default: + if (tokGfxPlatform->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { + dst.GfxPlatform.eProductFamily = readTokValue(*tokGfxPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { + dst.GfxPlatform.ePCHProductFamily = readTokValue(*tokGfxPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { + dst.GfxPlatform.eDisplayCoreFamily = readTokValue(*tokGfxPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { + dst.GfxPlatform.eRenderCoreFamily = readTokValue(*tokGfxPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { + dst.GfxPlatform.ePlatformType = readTokValue(*tokGfxPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { + dst.GfxPlatform.usDeviceID = readTokValue(*tokGfxPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID: { + dst.GfxPlatform.usRevId = readTokValue(*tokGfxPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { + dst.GfxPlatform.usDeviceID_PCH = readTokValue(*tokGfxPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { + dst.GfxPlatform.usRevId_PCH = readTokValue(*tokGfxPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_GTTYPE: { + dst.GfxPlatform.eGTType = readTokValue(*tokGfxPlatform); + } break; + }; + tokGfxPlatform = tokGfxPlatform + 1 + tokGfxPlatform->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokGfxPlatform); + if (tokGfxPlatform->flags.flag3IsMandatory) { + return false; + } + tokGfxPlatform = tokGfxPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokGfxPlatform == tokGfxPlatformEnd); + } break; + case TOK_FS_ADAPTER_INFO__SKU_TABLE: { + const TokenHeader *tokSkuTable = varLen->getValue(); + const TokenHeader *tokSkuTableEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSkuTable < tokSkuTableEnd) { + if (false == tokSkuTable->flags.flag4IsVariableLength) { + switch (tokSkuTable->id) { + default: + if (tokSkuTable->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_DESKTOP: { + dst.SkuTable.FtrDesktop = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_VERING: { + dst.SkuTable.FtrVERing = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_VCS2: { + dst.SkuTable.FtrVcs2 = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_BIG_DIE: { + dst.SkuTable.FtrGtBigDie = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_MEDIUM_DIE: { + dst.SkuTable.FtrGtMediumDie = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_SMALL_DIE: { + dst.SkuTable.FtrGtSmallDie = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT1: { + dst.SkuTable.FtrGT1 = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT1_5: { + dst.SkuTable.FtrGT1_5 = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT2: { + dst.SkuTable.FtrGT2 = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT2_5: { + dst.SkuTable.FtrGT2_5 = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT3: { + dst.SkuTable.FtrGT3 = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT4: { + dst.SkuTable.FtrGT4 = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_ULT: { + dst.SkuTable.FtrULT = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_IVBM0M1PLATFORM: { + dst.SkuTable.FtrIVBM0M1Platform = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CHANNEL_SWIZZLING_XORENABLED: { + dst.SkuTable.FtrChannelSwizzlingXOREnabled = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTA: { + dst.SkuTable.FtrGTA = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTC: { + dst.SkuTable.FtrGTC = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTX: { + dst.SkuTable.FtrGTX = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR5SLICE: { + dst.SkuTable.Ftr5Slice = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_LCIA: { + dst.SkuTable.FtrLCIA = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_RESOURCE_STREAMER: { + dst.SkuTable.FtrResourceStreamer = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSRING: { + dst.SkuTable.FtrCCSRing = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSNODE: { + dst.SkuTable.FtrCCSNode = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSMULTI_INSTANCE: { + dst.SkuTable.FtrCCSMultiInstance = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_DISPLAY_DISABLED: { + dst.SkuTable.FtrDisplayDisabled = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_SGTPVSKUSTRAP_PRESENT: { + dst.SkuTable.FtrSGTPVSKUStrapPresent = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21584__FTR_POOLED_EU_ENABLED: { + dst.SkuTable.FtrPooledEuEnabled = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_MID_BATCH_PREEMPT: { + dst.SkuTable.FtrGpGpuMidBatchPreempt = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_THREAD_GROUP_LEVEL_PREEMPT: { + dst.SkuTable.FtrGpGpuThreadGroupLevelPreempt = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_MID_THREAD_LEVEL_PREEMPT: { + dst.SkuTable.FtrGpGpuMidThreadLevelPreempt = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR3D_MID_BATCH_PREEMPT: { + dst.SkuTable.Ftr3dMidBatchPreempt = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR3D_OBJECT_LEVEL_PREEMPT: { + dst.SkuTable.Ftr3dObjectLevelPreempt = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PER_CTXT_PREEMPTION_GRANULARITY_CONTROL: { + dst.SkuTable.FtrPerCtxtPreemptionGranularityControl = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PPGTT: { + dst.SkuTable.FtrPPGTT = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_IA32E_GFX_PTES: { + dst.SkuTable.FtrIA32eGfxPTEs = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_MEM_TYPE_MOCS_DEFER_PAT: { + dst.SkuTable.FtrMemTypeMocsDeferPAT = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PML4SUPPORT: { + dst.SkuTable.FtrPml4Support = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_SVM: { + dst.SkuTable.FtrSVM = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TILE_MAPPED_RESOURCE: { + dst.SkuTable.FtrTileMappedResource = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TRANSLATION_TABLE: { + dst.SkuTable.FtrTranslationTable = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_USER_MODE_TRANSLATION_TABLE: { + dst.SkuTable.FtrUserModeTranslationTable = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_NULL_PAGES: { + dst.SkuTable.FtrNullPages = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_L3IACOHERENCY: { + dst.SkuTable.FtrL3IACoherency = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_EDRAM: { + dst.SkuTable.FtrEDram = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LLCBYPASS: { + dst.SkuTable.FtrLLCBypass = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CRYSTALWELL: { + dst.SkuTable.FtrCrystalwell = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CENTRAL_CACHE_POLICY: { + dst.SkuTable.FtrCentralCachePolicy = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_IO_MMU_PAGE_FAULTING: { + dst.SkuTable.FtrIoMmuPageFaulting = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2GPU_MMU: { + dst.SkuTable.FtrWddm2GpuMmu = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2SVM: { + dst.SkuTable.FtrWddm2Svm = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_STANDARD_MIP_TAIL_FORMAT: { + dst.SkuTable.FtrStandardMipTailFormat = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2_1_64KB_PAGES: { + dst.SkuTable.FtrWddm2_1_64kbPages = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GTT_CACHE_INVALIDATION: { + dst.SkuTable.FtrGttCacheInvalidation = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_E2ECOMPRESSION: { + dst.SkuTable.FtrE2ECompression = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LINEAR_CCS: { + dst.SkuTable.FtrLinearCCS = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LOCAL_MEMORY: { + dst.SkuTable.FtrLocalMemory = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PPGTT64KBWALK_OPTIMIZATION: { + dst.SkuTable.FtrPpgtt64KBWalkOptimization = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TILE_Y: { + dst.SkuTable.FtrTileY = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_FLAT_PHYS_CCS: { + dst.SkuTable.FtrFlatPhysCCS = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_MULTI_TILE_ARCH: { + dst.SkuTable.FtrMultiTileArch = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LOCAL_MEMORY_ALLOWS4KB: { + dst.SkuTable.FtrLocalMemoryAllows4KB = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_DISPLAY_XTILING: { + dst.SkuTable.FtrDisplayXTiling = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CAMERA_CAPTURE_CACHING: { + dst.SkuTable.FtrCameraCaptureCaching = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_KMD_DAF: { + dst.SkuTable.FtrKmdDaf = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_FRAME_BUFFER_LLC: { + dst.SkuTable.FtrFrameBufferLLC = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_DRIVER_FLR: { + dst.SkuTable.FtrDriverFLR = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC_LDR2D: { + dst.SkuTable.FtrAstcLdr2D = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC_HDR2D: { + dst.SkuTable.FtrAstcHdr2D = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC3D: { + dst.SkuTable.FtrAstc3D = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC: { + dst.SkuTable.FtrFbc = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC2ADDRESS_TRANSLATION: { + dst.SkuTable.FtrFbc2AddressTranslation = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC_BLITTER_TRACKING: { + dst.SkuTable.FtrFbcBlitterTracking = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC_CPU_TRACKING: { + dst.SkuTable.FtrFbcCpuTracking = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_VEBOX: { + dst.SkuTable.FtrVEBOX = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS54736__FTR_REND_COMP: { + dst.SkuTable.FtrRendComp = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS54736__FTR_DISPLAY_YTILING: { + dst.SkuTable.FtrDisplayYTiling = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_S3D: { + dst.SkuTable.FtrS3D = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_DISPLAY_ENGINE_S3D: { + dst.SkuTable.FtrDisplayEngineS3d = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_SINGLE_VEBOX_SLICE: { + dst.SkuTable.FtrSingleVeboxSlice = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_SIMULATION_MODE: { + dst.SkuTable.FtrSimulationMode = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS88095__FTR_ENABLE_GU_C: { + dst.SkuTable.FtrEnableGuC = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS89755__FTR_VGT: { + dst.SkuTable.FtrVgt = readTokValue(*tokSkuTable); + } break; + case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS91822__FTR_ASSIGNED_GPU_TILE: { + dst.SkuTable.FtrAssignedGpuTile = readTokValue(*tokSkuTable); + } break; + }; + tokSkuTable = tokSkuTable + 1 + tokSkuTable->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSkuTable); + if (tokSkuTable->flags.flag3IsMandatory) { + return false; + } + tokSkuTable = tokSkuTable + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSkuTable == tokSkuTableEnd); + } break; + case TOK_FS_ADAPTER_INFO__WA_TABLE: { + const TokenHeader *tokWaTable = varLen->getValue(); + const TokenHeader *tokWaTableEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokWaTable < tokWaTableEnd) { + if (false == tokWaTable->flags.flag4IsVariableLength) { + switch (tokWaTable->id) { + default: + if (tokWaTable->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_WA_TABLE__WA_DO_NOT_USE_MIREPORT_PERF_COUNT: { + dst.WaTable.WaDoNotUseMIReportPerfCount = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_ALIGN_INDEX_BUFFER: { + dst.WaTable.WaAlignIndexBuffer = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_SEND_MIFLUSHBEFORE_VFE: { + dst.WaTable.WaSendMIFLUSHBeforeVFE = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_DISABLE_PER_CTXT_PREEMPTION_GRANULARITY_CONTROL: { + dst.WaTable.WaDisablePerCtxtPreemptionGranularityControl = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_ENABLE_PREEMPTION_GRANULARITY_CONTROL_BY_UMD: { + dst.WaTable.WaEnablePreemptionGranularityControlByUMD = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_DISABLE_LSQCROPERFFOR_OCL: { + dst.WaTable.WaDisableLSQCROPERFforOCL = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_VALIGN2FOR96BPP_FORMATS: { + dst.WaTable.WaValign2For96bppFormats = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_VALIGN2FOR_R8G8B8UINTFORMAT: { + dst.WaTable.WaValign2ForR8G8B8UINTFormat = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_REPORT_PERF_COUNT_USE_GLOBAL_CONTEXT_ID: { + dst.WaTable.WaReportPerfCountUseGlobalContextID = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_FORCE_PC_BB_FULL_CFG_RESTORE: { + dst.WaTable.WaForcePcBbFullCfgRestore = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_CSRUNCACHABLE: { + dst.WaTable.WaCSRUncachable = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_DISABLE_FUSED_THREAD_SCHEDULING: { + dst.WaTable.WaDisableFusedThreadScheduling = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_MODIFY_VFESTATE_AFTER_GPGPUPREEMPTION: { + dst.WaTable.WaModifyVFEStateAfterGPGPUPreemption = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_CURSOR16K: { + dst.WaTable.WaCursor16K = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA8K_ALIGNFOR_ASYNC_FLIP: { + dst.WaTable.Wa8kAlignforAsyncFlip = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA29BIT_DISPLAY_ADDR_LIMIT: { + dst.WaTable.Wa29BitDisplayAddrLimit = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_ALIGN_CONTEXT_IMAGE: { + dst.WaTable.WaAlignContextImage = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_FORCE_GLOBAL_GTT: { + dst.WaTable.WaForceGlobalGTT = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_REPORT_PERF_COUNT_FORCE_GLOBAL_GTT: { + dst.WaTable.WaReportPerfCountForceGlobalGTT = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_OA_ADDRESS_TRANSLATION: { + dst.WaTable.WaOaAddressTranslation = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA2ROW_VERTICAL_ALIGNMENT: { + dst.WaTable.Wa2RowVerticalAlignment = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_PPGTT_ALIAS_GLOBAL_GTT_SPACE: { + dst.WaTable.WaPpgttAliasGlobalGttSpace = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_CLEAR_FENCE_REGISTERS_AT_DRIVER_INIT: { + dst.WaTable.WaClearFenceRegistersAtDriverInit = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_RESTRICT_PITCH128KB: { + dst.WaTable.WaRestrictPitch128KB = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_AVOID_LLC: { + dst.WaTable.WaAvoidLLC = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_AVOID_L3: { + dst.WaTable.WaAvoidL3 = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA16TILE_FENCES_ONLY: { + dst.WaTable.Wa16TileFencesOnly = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA16MBOABUFFER_ALIGNMENT: { + dst.WaTable.Wa16MBOABufferAlignment = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_TRANSLATION_TABLE_UNAVAILABLE: { + dst.WaTable.WaTranslationTableUnavailable = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_NO_MINIMIZED_TRIVIAL_SURFACE_PADDING: { + dst.WaTable.WaNoMinimizedTrivialSurfacePadding = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_NO_BUFFER_SAMPLER_PADDING: { + dst.WaTable.WaNoBufferSamplerPadding = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_SURFACE_STATE_PLANAR_YOFFSET_ALIGN_BY2: { + dst.WaTable.WaSurfaceStatePlanarYOffsetAlignBy2 = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_GTT_CACHING_OFF_BY_DEFAULT: { + dst.WaTable.WaGttCachingOffByDefault = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_TOUCH_ALL_SVM_MEMORY: { + dst.WaTable.WaTouchAllSvmMemory = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_IOBADDRESS_MUST_BE_VALID_IN_HW_CONTEXT: { + dst.WaTable.WaIOBAddressMustBeValidInHwContext = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_FLUSH_TLB_AFTER_CPU_GGTT_WRITES: { + dst.WaTable.WaFlushTlbAfterCpuGgttWrites = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_MSAA8X_TILE_YDEPTH_PITCH_ALIGNMENT: { + dst.WaTable.WaMsaa8xTileYDepthPitchAlignment = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_DISABLE_NULL_PAGE_AS_DUMMY: { + dst.WaTable.WaDisableNullPageAsDummy = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_USE_VALIGN16ON_TILE_XYBPP816: { + dst.WaTable.WaUseVAlign16OnTileXYBpp816 = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_GTT_PAT0: { + dst.WaTable.WaGttPat0 = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_GTT_PAT0WB: { + dst.WaTable.WaGttPat0WB = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_MEM_TYPE_IS_MAX_OF_PAT_AND_MOCS: { + dst.WaTable.WaMemTypeIsMaxOfPatAndMocs = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_GTT_PAT0GTT_WB_OVER_OS_IOMMU_ELLC_ONLY: { + dst.WaTable.WaGttPat0GttWbOverOsIommuEllcOnly = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_ADD_DUMMY_PAGE_FOR_DISPLAY_PREFETCH: { + dst.WaTable.WaAddDummyPageForDisplayPrefetch = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_DEFAULT_TILE4: { + dst.WaTable.WaDefaultTile4 = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_LLCCACHING_UNSUPPORTED: { + dst.WaTable.WaLLCCachingUnsupported = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_DOUBLE_FAST_CLEAR_WIDTH_ALIGNMENT: { + dst.WaTable.WaDoubleFastClearWidthAlignment = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_COMPRESSED_RESOURCE_REQUIRES_CONST_VA21: { + dst.WaTable.WaCompressedResourceRequiresConstVA21 = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_DISREGARD_PLATFORM_CHECKS: { + dst.WaTable.WaDisregardPlatformChecks = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_LOSSLESS_COMPRESSION_SURFACE_STRIDE: { + dst.WaTable.WaLosslessCompressionSurfaceStride = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_FBC_LINEAR_SURFACE_STRIDE: { + dst.WaTable.WaFbcLinearSurfaceStride = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA4K_ALIGN_UVOFFSET_NV12LINEAR_SURFACE: { + dst.WaTable.Wa4kAlignUVOffsetNV12LinearSurface = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_ASTC_CORRUPTION_FOR_ODD_COMPRESSED_BLOCK_SIZE_X: { + dst.WaTable.WaAstcCorruptionForOddCompressedBlockSizeX = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_AUX_TABLE16KGRANULAR: { + dst.WaTable.WaAuxTable16KGranular = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_ENCRYPTED_EDRAM_ONLY_PARTIALS: { + dst.WaTable.WaEncryptedEdramOnlyPartials = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_DISABLE_EDRAM_FOR_DISPLAY_RT: { + dst.WaTable.WaDisableEdramForDisplayRT = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_LIMIT128BMEDIA_COMPR: { + dst.WaTable.WaLimit128BMediaCompr = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_UNTYPED_BUFFER_COMPRESSION: { + dst.WaTable.WaUntypedBufferCompression = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_SAMPLER_CACHE_FLUSH_BETWEEN_REDESCRIBED_SURFACE_READS: { + dst.WaTable.WaSamplerCacheFlushBetweenRedescribedSurfaceReads = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA_ALIGN_YUVRESOURCE_TO_LCU: { + dst.WaTable.WaAlignYUVResourceToLCU = readTokValue(*tokWaTable); + } break; + case TOK_FBD_WA_TABLE__WA32BPP_TILE_Y2DCOLOR_NO_HALIGN4: { + dst.WaTable.Wa32bppTileY2DColorNoHAlign4 = readTokValue(*tokWaTable); + } break; + }; + tokWaTable = tokWaTable + 1 + tokWaTable->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokWaTable); + if (tokWaTable->flags.flag3IsMandatory) { + return false; + } + tokWaTable = tokWaTable + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokWaTable == tokWaTableEnd); + } break; + case TOK_FS_ADAPTER_INFO__OUTPUT_FRAME_RATE: { + const TokenHeader *tokOutputFrameRate = varLen->getValue(); + const TokenHeader *tokOutputFrameRateEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokOutputFrameRate < tokOutputFrameRateEnd) { + if (false == tokOutputFrameRate->flags.flag4IsVariableLength) { + switch (tokOutputFrameRate->id) { + default: + if (tokOutputFrameRate->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_FRAME_RATE__UI_NUMERATOR: { + dst.OutputFrameRate.uiNumerator = readTokValue(*tokOutputFrameRate); + } break; + case TOK_FBD_FRAME_RATE__UI_DENOMINATOR: { + dst.OutputFrameRate.uiDenominator = readTokValue(*tokOutputFrameRate); + } break; + }; + tokOutputFrameRate = tokOutputFrameRate + 1 + tokOutputFrameRate->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokOutputFrameRate); + if (tokOutputFrameRate->flags.flag3IsMandatory) { + return false; + } + tokOutputFrameRate = tokOutputFrameRate + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokOutputFrameRate == tokOutputFrameRateEnd); + } break; + case TOK_FS_ADAPTER_INFO__INPUT_FRAME_RATE: { + const TokenHeader *tokInputFrameRate = varLen->getValue(); + const TokenHeader *tokInputFrameRateEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokInputFrameRate < tokInputFrameRateEnd) { + if (false == tokInputFrameRate->flags.flag4IsVariableLength) { + switch (tokInputFrameRate->id) { + default: + if (tokInputFrameRate->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_FRAME_RATE__UI_NUMERATOR: { + dst.InputFrameRate.uiNumerator = readTokValue(*tokInputFrameRate); + } break; + case TOK_FBD_FRAME_RATE__UI_DENOMINATOR: { + dst.InputFrameRate.uiDenominator = readTokValue(*tokInputFrameRate); + } break; + }; + tokInputFrameRate = tokInputFrameRate + 1 + tokInputFrameRate->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokInputFrameRate); + if (tokInputFrameRate->flags.flag3IsMandatory) { + return false; + } + tokInputFrameRate = tokInputFrameRate + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokInputFrameRate == tokInputFrameRateEnd); + } break; + case TOK_FS_ADAPTER_INFO__CAPS: { + const TokenHeader *tokCaps = varLen->getValue(); + const TokenHeader *tokCapsEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokCaps < tokCapsEnd) { + if (false == tokCaps->flags.flag4IsVariableLength) { + switch (tokCaps->id) { + default: + if (tokCaps->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_KMD_CAPS_INFO__GAMMA_RGB256X3X16: { + dst.Caps.Gamma_Rgb256x3x16 = readTokValue(*tokCaps); + } break; + case TOK_FBD_KMD_CAPS_INFO__GDIACCELERATION: { + dst.Caps.GDIAcceleration = readTokValue(*tokCaps); + } break; + case TOK_FBD_KMD_CAPS_INFO__OS_MANAGED_HW_CONTEXT: { + dst.Caps.OsManagedHwContext = readTokValue(*tokCaps); + } break; + case TOK_FBD_KMD_CAPS_INFO__GRAPHICS_PREEMPTION_GRANULARITY: { + dst.Caps.GraphicsPreemptionGranularity = readTokValue(*tokCaps); + } break; + case TOK_FBD_KMD_CAPS_INFO__COMPUTE_PREEMPTION_GRANULARITY: { + dst.Caps.ComputePreemptionGranularity = readTokValue(*tokCaps); + } break; + case TOK_FBD_KMD_CAPS_INFO__INSTRUMENTATION_IS_ENABLED: { + dst.Caps.InstrumentationIsEnabled = readTokValue(*tokCaps); + } break; + case TOK_FBD_KMD_CAPS_INFO__DRIVER_STORE_ENABLED: { + dst.Caps.DriverStoreEnabled = readTokValue(*tokCaps); + } break; + }; + tokCaps = tokCaps + 1 + tokCaps->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokCaps); + if (tokCaps->flags.flag3IsMandatory) { + return false; + } + tokCaps = tokCaps + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokCaps == tokCapsEnd); + } break; + case TOK_FS_ADAPTER_INFO__OVERLAY_CAPS: { + const TokenHeader *tokOverlayCaps = varLen->getValue(); + const TokenHeader *tokOverlayCapsEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokOverlayCaps < tokOverlayCapsEnd) { + if (false == tokOverlayCaps->flags.flag4IsVariableLength) { + switch (tokOverlayCaps->id) { + default: + if (tokOverlayCaps->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__CAPS_VALUE: { + dst.OverlayCaps.CapsValue = readTokValue(*tokOverlayCaps); + } break; + case TOK_FBD_KMD_OVERLAY_CAPS_INFO__MAX_OVERLAY_DISPLAY_WIDTH: { + dst.OverlayCaps.MaxOverlayDisplayWidth = readTokValue(*tokOverlayCaps); + } break; + case TOK_FBD_KMD_OVERLAY_CAPS_INFO__MAX_OVERLAY_DISPLAY_HEIGHT: { + dst.OverlayCaps.MaxOverlayDisplayHeight = readTokValue(*tokOverlayCaps); + } break; + case TOK_FBC_KMD_OVERLAY_CAPS_INFO__HWSCALER_EXISTS: { + dst.OverlayCaps.HWScalerExists = readTokValue(*tokOverlayCaps); + } break; + case TOK_FBD_KMD_OVERLAY_CAPS_INFO__MAX_HWSCALER_STRIDE: { + dst.OverlayCaps.MaxHWScalerStride = readTokValue(*tokOverlayCaps); + } break; + }; + tokOverlayCaps = tokOverlayCaps + 1 + tokOverlayCaps->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokOverlayCaps); + switch (tokOverlayCaps->id) { + default: + if (tokOverlayCaps->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__CAPS: { + const TokenHeader *tokCaps = varLen->getValue(); + const TokenHeader *tokCapsEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokCaps < tokCapsEnd) { + if (false == tokCaps->flags.flag4IsVariableLength) { + switch (tokCaps->id) { + default: + if (tokCaps->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__FULL_RANGE_RGB: { + dst.OverlayCaps.Caps.FullRangeRGB = readTokValue(*tokCaps); + } break; + case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__LIMITED_RANGE_RGB: { + dst.OverlayCaps.Caps.LimitedRangeRGB = readTokValue(*tokCaps); + } break; + case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT601: { + dst.OverlayCaps.Caps.YCbCr_BT601 = readTokValue(*tokCaps); + } break; + case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT709: { + dst.OverlayCaps.Caps.YCbCr_BT709 = readTokValue(*tokCaps); + } break; + case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT601_XV_YCC: { + dst.OverlayCaps.Caps.YCbCr_BT601_xvYCC = readTokValue(*tokCaps); + } break; + case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT709_XV_YCC: { + dst.OverlayCaps.Caps.YCbCr_BT709_xvYCC = readTokValue(*tokCaps); + } break; + case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__STRETCH_X: { + dst.OverlayCaps.Caps.StretchX = readTokValue(*tokCaps); + } break; + case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__STRETCH_Y: { + dst.OverlayCaps.Caps.StretchY = readTokValue(*tokCaps); + } break; + }; + tokCaps = tokCaps + 1 + tokCaps->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokCaps); + if (tokCaps->flags.flag3IsMandatory) { + return false; + } + tokCaps = tokCaps + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokCaps == tokCapsEnd); + } break; + case TOK_FS_KMD_OVERLAY_CAPS_INFO__OVOVERRIDE: { + const TokenHeader *tokOVOverride = varLen->getValue(); + const TokenHeader *tokOVOverrideEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokOVOverride < tokOVOverrideEnd) { + if (false == tokOVOverride->flags.flag4IsVariableLength) { + switch (tokOVOverride->id) { + default: + if (tokOVOverride->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_KMD_OVERLAY_OVERRIDE__OVERRIDE_OVERLAY_CAPS: { + dst.OverlayCaps.OVOverride.OverrideOverlayCaps = readTokValue(*tokOVOverride); + } break; + case TOK_FBD_KMD_OVERLAY_OVERRIDE__RGBOVERLAY: { + dst.OverlayCaps.OVOverride.RGBOverlay = readTokValue(*tokOVOverride); + } break; + case TOK_FBD_KMD_OVERLAY_OVERRIDE__YUY2OVERLAY: { + dst.OverlayCaps.OVOverride.YUY2Overlay = readTokValue(*tokOVOverride); + } break; + }; + tokOVOverride = tokOVOverride + 1 + tokOVOverride->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokOVOverride); + if (tokOVOverride->flags.flag3IsMandatory) { + return false; + } + tokOVOverride = tokOVOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokOVOverride == tokOVOverrideEnd); + } break; + }; + tokOverlayCaps = tokOverlayCaps + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokOverlayCaps == tokOverlayCapsEnd); + } break; + case TOK_FS_ADAPTER_INFO__SYSTEM_INFO: { + const TokenHeader *tokSystemInfo = varLen->getValue(); + const TokenHeader *tokSystemInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSystemInfo < tokSystemInfoEnd) { + if (false == tokSystemInfo->flags.flag4IsVariableLength) { + switch (tokSystemInfo->id) { + default: + if (tokSystemInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_SYSTEM_INFO__EUCOUNT: { + dst.SystemInfo.EUCount = readTokValue(*tokSystemInfo); + } break; + case TOK_FBD_GT_SYSTEM_INFO__THREAD_COUNT: { + dst.SystemInfo.ThreadCount = readTokValue(*tokSystemInfo); + } break; + case TOK_FBD_GT_SYSTEM_INFO__SLICE_COUNT: { + dst.SystemInfo.SliceCount = readTokValue(*tokSystemInfo); + } break; + case TOK_FBD_GT_SYSTEM_INFO__SUB_SLICE_COUNT: { + dst.SystemInfo.SubSliceCount = readTokValue(*tokSystemInfo); + } break; + case TOK_FBD_GT_SYSTEM_INFO__DUAL_SUB_SLICE_COUNT: { + dst.SystemInfo.DualSubSliceCount = readTokValue(*tokSystemInfo); + } break; + case TOK_FBQ_GT_SYSTEM_INFO__L3CACHE_SIZE_IN_KB: { + dst.SystemInfo.L3CacheSizeInKb = readTokValue(*tokSystemInfo); + } break; + case TOK_FBQ_GT_SYSTEM_INFO__LLCCACHE_SIZE_IN_KB: { + dst.SystemInfo.LLCCacheSizeInKb = readTokValue(*tokSystemInfo); + } break; + case TOK_FBQ_GT_SYSTEM_INFO__EDRAM_SIZE_IN_KB: { + dst.SystemInfo.EdramSizeInKb = readTokValue(*tokSystemInfo); + } break; + case TOK_FBD_GT_SYSTEM_INFO__L3BANK_COUNT: { + dst.SystemInfo.L3BankCount = readTokValue(*tokSystemInfo); + } break; + case TOK_FBD_GT_SYSTEM_INFO__MAX_FILL_RATE: { + dst.SystemInfo.MaxFillRate = readTokValue(*tokSystemInfo); + } break; + case TOK_FBD_GT_SYSTEM_INFO__EU_COUNT_PER_POOL_MAX: { + dst.SystemInfo.EuCountPerPoolMax = readTokValue(*tokSystemInfo); + } break; + case TOK_FBD_GT_SYSTEM_INFO__EU_COUNT_PER_POOL_MIN: { + dst.SystemInfo.EuCountPerPoolMin = readTokValue(*tokSystemInfo); + } break; + case TOK_FBD_GT_SYSTEM_INFO__TOTAL_VS_THREADS: { + dst.SystemInfo.TotalVsThreads = readTokValue(*tokSystemInfo); + } break; + case TOK_FBD_GT_SYSTEM_INFO__TOTAL_HS_THREADS: { + dst.SystemInfo.TotalHsThreads = readTokValue(*tokSystemInfo); + } break; + case TOK_FBD_GT_SYSTEM_INFO__TOTAL_DS_THREADS: { + dst.SystemInfo.TotalDsThreads = readTokValue(*tokSystemInfo); + } break; + case TOK_FBD_GT_SYSTEM_INFO__TOTAL_GS_THREADS: { + dst.SystemInfo.TotalGsThreads = readTokValue(*tokSystemInfo); + } break; + case TOK_FBD_GT_SYSTEM_INFO__TOTAL_PS_THREADS_WINDOWER_RANGE: { + dst.SystemInfo.TotalPsThreadsWindowerRange = readTokValue(*tokSystemInfo); + } break; + case TOK_FBD_GT_SYSTEM_INFO__TOTAL_VS_THREADS_POCS: { + dst.SystemInfo.TotalVsThreads_Pocs = readTokValue(*tokSystemInfo); + } break; + case TOK_FBD_GT_SYSTEM_INFO__CSR_SIZE_IN_MB: { + dst.SystemInfo.CsrSizeInMb = readTokValue(*tokSystemInfo); + } break; + case TOK_FBD_GT_SYSTEM_INFO__MAX_EU_PER_SUB_SLICE: { + dst.SystemInfo.MaxEuPerSubSlice = readTokValue(*tokSystemInfo); + } break; + case TOK_FBD_GT_SYSTEM_INFO__MAX_SLICES_SUPPORTED: { + dst.SystemInfo.MaxSlicesSupported = readTokValue(*tokSystemInfo); + } break; + case TOK_FBD_GT_SYSTEM_INFO__MAX_SUB_SLICES_SUPPORTED: { + dst.SystemInfo.MaxSubSlicesSupported = readTokValue(*tokSystemInfo); + } break; + case TOK_FBD_GT_SYSTEM_INFO__MAX_DUAL_SUB_SLICES_SUPPORTED: { + dst.SystemInfo.MaxDualSubSlicesSupported = readTokValue(*tokSystemInfo); + } break; + case TOK_FBB_GT_SYSTEM_INFO__IS_L3HASH_MODE_ENABLED: { + dst.SystemInfo.IsL3HashModeEnabled = readTokValue(*tokSystemInfo); + } break; + case TOK_FBB_GT_SYSTEM_INFO__IS_DYNAMICALLY_POPULATED: { + dst.SystemInfo.IsDynamicallyPopulated = readTokValue(*tokSystemInfo); + } break; + case TOK_FBD_GT_SYSTEM_INFO__RESERVED_CCSWAYS: { + dst.SystemInfo.ReservedCCSWays = readTokValue(*tokSystemInfo); + } break; + case TOK_FBD_GT_SYSTEM_INFO__NUM_THREADS_PER_EU: { + dst.SystemInfo.NumThreadsPerEu = readTokValue(*tokSystemInfo); + } break; + case TOK_FBD_GT_SYSTEM_INFO__MAX_VECS: { + dst.SystemInfo.MaxVECS = readTokValue(*tokSystemInfo); + } break; + }; + tokSystemInfo = tokSystemInfo + 1 + tokSystemInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSystemInfo); + switch (tokSystemInfo->id) { + default: + if (tokSystemInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_SYSTEM_INFO__SLICE_INFO: { + uint32_t arrayElementIdSliceInfo = varLen->arrayElementId; + const TokenHeader *tokSliceInfo = varLen->getValue(); + const TokenHeader *tokSliceInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSliceInfo < tokSliceInfoEnd) { + if (false == tokSliceInfo->flags.flag4IsVariableLength) { + switch (tokSliceInfo->id) { + default: + if (tokSliceInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBB_GT_SLICE_INFO__ENABLED: { + dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].Enabled = readTokValue(*tokSliceInfo); + } break; + case TOK_FBD_GT_SLICE_INFO__SUB_SLICE_ENABLED_COUNT: { + dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].SubSliceEnabledCount = readTokValue(*tokSliceInfo); + } break; + case TOK_FBD_GT_SLICE_INFO__DUAL_SUB_SLICE_ENABLED_COUNT: { + dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].DualSubSliceEnabledCount = readTokValue(*tokSliceInfo); + } break; + }; + tokSliceInfo = tokSliceInfo + 1 + tokSliceInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSliceInfo); + switch (tokSliceInfo->id) { + default: + if (tokSliceInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_SLICE_INFO__SUB_SLICE_INFO: { + uint32_t arrayElementIdSubSliceInfo = varLen->arrayElementId; + const TokenHeader *tokSubSliceInfo = varLen->getValue(); + const TokenHeader *tokSubSliceInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSubSliceInfo < tokSubSliceInfoEnd) { + if (false == tokSubSliceInfo->flags.flag4IsVariableLength) { + switch (tokSubSliceInfo->id) { + default: + if (tokSubSliceInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBB_GT_SUBSLICE_INFO__ENABLED: { + dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].Enabled = readTokValue(*tokSubSliceInfo); + } break; + case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_COUNT: { + dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledCount = readTokValue(*tokSubSliceInfo); + } break; + case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_MASK: { + dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledMask = readTokValue(*tokSubSliceInfo); + } break; + }; + tokSubSliceInfo = tokSubSliceInfo + 1 + tokSubSliceInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSubSliceInfo); + if (tokSubSliceInfo->flags.flag3IsMandatory) { + return false; + } + tokSubSliceInfo = tokSubSliceInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSubSliceInfo == tokSubSliceInfoEnd); + } break; + case TOK_FS_GT_SLICE_INFO__DSSINFO: { + uint32_t arrayElementIdDSSInfo = varLen->arrayElementId; + const TokenHeader *tokDSSInfo = varLen->getValue(); + const TokenHeader *tokDSSInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokDSSInfo < tokDSSInfoEnd) { + if (false == tokDSSInfo->flags.flag4IsVariableLength) { + switch (tokDSSInfo->id) { + default: + if (tokDSSInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBB_GT_DUALSUBSLICE_INFO__ENABLED: { + dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].Enabled = readTokValue(*tokDSSInfo); + } break; + }; + tokDSSInfo = tokDSSInfo + 1 + tokDSSInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokDSSInfo); + switch (tokDSSInfo->id) { + default: + if (tokDSSInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_DUALSUBSLICE_INFO__SUB_SLICE: { + uint32_t arrayElementIdSubSlice = varLen->arrayElementId; + const TokenHeader *tokSubSlice = varLen->getValue(); + const TokenHeader *tokSubSliceEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSubSlice < tokSubSliceEnd) { + if (false == tokSubSlice->flags.flag4IsVariableLength) { + switch (tokSubSlice->id) { + default: + if (tokSubSlice->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBB_GT_SUBSLICE_INFO__ENABLED: { + dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].Enabled = readTokValue(*tokSubSlice); + } break; + case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_COUNT: { + dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledCount = readTokValue(*tokSubSlice); + } break; + case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_MASK: { + dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledMask = readTokValue(*tokSubSlice); + } break; + }; + tokSubSlice = tokSubSlice + 1 + tokSubSlice->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSubSlice); + if (tokSubSlice->flags.flag3IsMandatory) { + return false; + } + tokSubSlice = tokSubSlice + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSubSlice == tokSubSliceEnd); + } break; + }; + tokDSSInfo = tokDSSInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokDSSInfo == tokDSSInfoEnd); + } break; + }; + tokSliceInfo = tokSliceInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSliceInfo == tokSliceInfoEnd); + } break; + case TOK_FS_GT_SYSTEM_INFO__SQIDI_INFO: { + const TokenHeader *tokSqidiInfo = varLen->getValue(); + const TokenHeader *tokSqidiInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSqidiInfo < tokSqidiInfoEnd) { + if (false == tokSqidiInfo->flags.flag4IsVariableLength) { + switch (tokSqidiInfo->id) { + default: + if (tokSqidiInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_SQIDI_INFO__NUMBEROF_SQIDI: { + dst.SystemInfo.SqidiInfo.NumberofSQIDI = readTokValue(*tokSqidiInfo); + } break; + case TOK_FBD_GT_SQIDI_INFO__NUMBEROF_DOORBELL_PER_SQIDI: { + dst.SystemInfo.SqidiInfo.NumberofDoorbellPerSQIDI = readTokValue(*tokSqidiInfo); + } break; + }; + tokSqidiInfo = tokSqidiInfo + 1 + tokSqidiInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSqidiInfo); + if (tokSqidiInfo->flags.flag3IsMandatory) { + return false; + } + tokSqidiInfo = tokSqidiInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSqidiInfo == tokSqidiInfoEnd); + } break; + case TOK_FS_GT_SYSTEM_INFO__CCSINFO: { + const TokenHeader *tokCCSInfo = varLen->getValue(); + const TokenHeader *tokCCSInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokCCSInfo < tokCCSInfoEnd) { + if (false == tokCCSInfo->flags.flag4IsVariableLength) { + switch (tokCCSInfo->id) { + default: + if (tokCCSInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_CCS_INFO__NUMBER_OF_CCSENABLED: { + dst.SystemInfo.CCSInfo.NumberOfCCSEnabled = readTokValue(*tokCCSInfo); + } break; + case TOK_FBB_GT_CCS_INFO__IS_VALID: { + dst.SystemInfo.CCSInfo.IsValid = readTokValue(*tokCCSInfo); + } break; + }; + tokCCSInfo = tokCCSInfo + 1 + tokCCSInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokCCSInfo); + switch (tokCCSInfo->id) { + default: + if (tokCCSInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_CCS_INFO__INSTANCES: { + const TokenHeader *tokInstances = varLen->getValue(); + const TokenHeader *tokInstancesEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokInstances < tokInstancesEnd) { + if (false == tokInstances->flags.flag4IsVariableLength) { + switch (tokInstances->id) { + default: + if (tokInstances->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSENABLE_MASK: { + dst.SystemInfo.CCSInfo.Instances.CCSEnableMask = readTokValue(*tokInstances); + } break; + }; + tokInstances = tokInstances + 1 + tokInstances->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokInstances); + switch (tokInstances->id) { + default: + if (tokInstances->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_CCS_INFO__CCSINSTANCES__BITS: { + const TokenHeader *tokBits = varLen->getValue(); + const TokenHeader *tokBitsEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokBits < tokBitsEnd) { + if (false == tokBits->flags.flag4IsVariableLength) { + switch (tokBits->id) { + default: + if (tokBits->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS0ENABLED: { + dst.SystemInfo.CCSInfo.Instances.Bits.CCS0Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS1ENABLED: { + dst.SystemInfo.CCSInfo.Instances.Bits.CCS1Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS2ENABLED: { + dst.SystemInfo.CCSInfo.Instances.Bits.CCS2Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS3ENABLED: { + dst.SystemInfo.CCSInfo.Instances.Bits.CCS3Enabled = readTokValue(*tokBits); + } break; + }; + tokBits = tokBits + 1 + tokBits->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokBits); + if (tokBits->flags.flag3IsMandatory) { + return false; + } + tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokBits == tokBitsEnd); + } break; + }; + tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokInstances == tokInstancesEnd); + } break; + }; + tokCCSInfo = tokCCSInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokCCSInfo == tokCCSInfoEnd); + } break; + case TOK_FS_GT_SYSTEM_INFO__MULTI_TILE_ARCH_INFO: { + const TokenHeader *tokMultiTileArchInfo = varLen->getValue(); + const TokenHeader *tokMultiTileArchInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokMultiTileArchInfo < tokMultiTileArchInfoEnd) { + if (false == tokMultiTileArchInfo->flags.flag4IsVariableLength) { + switch (tokMultiTileArchInfo->id) { + default: + if (tokMultiTileArchInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__TILE_COUNT: { + dst.SystemInfo.MultiTileArchInfo.TileCount = readTokValue(*tokMultiTileArchInfo); + } break; + case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE0: { + dst.SystemInfo.MultiTileArchInfo.Tile0 = readTokValue(*tokMultiTileArchInfo); + } break; + case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE1: { + dst.SystemInfo.MultiTileArchInfo.Tile1 = readTokValue(*tokMultiTileArchInfo); + } break; + case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE2: { + dst.SystemInfo.MultiTileArchInfo.Tile2 = readTokValue(*tokMultiTileArchInfo); + } break; + case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE3: { + dst.SystemInfo.MultiTileArchInfo.Tile3 = readTokValue(*tokMultiTileArchInfo); + } break; + case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__TILE_MASK: { + dst.SystemInfo.MultiTileArchInfo.TileMask = readTokValue(*tokMultiTileArchInfo); + } break; + case TOK_FBB_GT_MULTI_TILE_ARCH_INFO__IS_VALID: { + dst.SystemInfo.MultiTileArchInfo.IsValid = readTokValue(*tokMultiTileArchInfo); + } break; + }; + tokMultiTileArchInfo = tokMultiTileArchInfo + 1 + tokMultiTileArchInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokMultiTileArchInfo); + if (tokMultiTileArchInfo->flags.flag3IsMandatory) { + return false; + } + tokMultiTileArchInfo = tokMultiTileArchInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokMultiTileArchInfo == tokMultiTileArchInfoEnd); + } break; + case TOK_FS_GT_SYSTEM_INFO__VDBOX_INFO: { + const TokenHeader *tokVDBoxInfo = varLen->getValue(); + const TokenHeader *tokVDBoxInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokVDBoxInfo < tokVDBoxInfoEnd) { + if (false == tokVDBoxInfo->flags.flag4IsVariableLength) { + switch (tokVDBoxInfo->id) { + default: + if (tokVDBoxInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VDBOX_INFO__NUMBER_OF_VDBOX_ENABLED: { + dst.SystemInfo.VDBoxInfo.NumberOfVDBoxEnabled = readTokValue(*tokVDBoxInfo); + } break; + case TOK_FBB_GT_VDBOX_INFO__IS_VALID: { + dst.SystemInfo.VDBoxInfo.IsValid = readTokValue(*tokVDBoxInfo); + } break; + }; + tokVDBoxInfo = tokVDBoxInfo + 1 + tokVDBoxInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokVDBoxInfo); + switch (tokVDBoxInfo->id) { + default: + if (tokVDBoxInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_VDBOX_INFO__INSTANCES: { + const TokenHeader *tokInstances = varLen->getValue(); + const TokenHeader *tokInstancesEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokInstances < tokInstancesEnd) { + if (false == tokInstances->flags.flag4IsVariableLength) { + switch (tokInstances->id) { + default: + if (tokInstances->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBOX_ENABLE_MASK: { + dst.SystemInfo.VDBoxInfo.Instances.VDBoxEnableMask = readTokValue(*tokInstances); + } break; + }; + tokInstances = tokInstances + 1 + tokInstances->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokInstances); + switch (tokInstances->id) { + default: + if (tokInstances->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_VDBOX_INFO__VDBOX_INSTANCES__BITS: { + const TokenHeader *tokBits = varLen->getValue(); + const TokenHeader *tokBitsEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokBits < tokBitsEnd) { + if (false == tokBits->flags.flag4IsVariableLength) { + switch (tokBits->id) { + default: + if (tokBits->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX0ENABLED: { + dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox0Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX1ENABLED: { + dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox1Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX2ENABLED: { + dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox2Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX3ENABLED: { + dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox3Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX4ENABLED: { + dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox4Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX5ENABLED: { + dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox5Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX6ENABLED: { + dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox6Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX7ENABLED: { + dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox7Enabled = readTokValue(*tokBits); + } break; + }; + tokBits = tokBits + 1 + tokBits->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokBits); + if (tokBits->flags.flag3IsMandatory) { + return false; + } + tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokBits == tokBitsEnd); + } break; + }; + tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokInstances == tokInstancesEnd); + } break; + case TOK_FS_GT_VDBOX_INFO__SFCSUPPORT: { + const TokenHeader *tokSFCSupport = varLen->getValue(); + const TokenHeader *tokSFCSupportEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSFCSupport < tokSFCSupportEnd) { + if (false == tokSFCSupport->flags.flag4IsVariableLength) { + switch (tokSFCSupport->id) { + default: + if (tokSFCSupport->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__VALUE: { + dst.SystemInfo.VDBoxInfo.SFCSupport.Value = readTokValue(*tokSFCSupport); + } break; + }; + tokSFCSupport = tokSFCSupport + 1 + tokSFCSupport->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSFCSupport); + switch (tokSFCSupport->id) { + default: + if (tokSFCSupport->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_VDBOX_INFO__ANONYMOUS5662__SFC_SUPPORTED_BITS: { + const TokenHeader *tokSfcSupportedBits = varLen->getValue(); + const TokenHeader *tokSfcSupportedBitsEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSfcSupportedBits < tokSfcSupportedBitsEnd) { + if (false == tokSfcSupportedBits->flags.flag4IsVariableLength) { + switch (tokSfcSupportedBits->id) { + default: + if (tokSfcSupportedBits->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX0: { + dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox0 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX1: { + dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox1 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX2: { + dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox2 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX3: { + dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox3 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX4: { + dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox4 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX5: { + dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox5 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX6: { + dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox6 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX7: { + dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox7 = readTokValue(*tokSfcSupportedBits); + } break; + }; + tokSfcSupportedBits = tokSfcSupportedBits + 1 + tokSfcSupportedBits->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSfcSupportedBits); + if (tokSfcSupportedBits->flags.flag3IsMandatory) { + return false; + } + tokSfcSupportedBits = tokSfcSupportedBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSfcSupportedBits == tokSfcSupportedBitsEnd); + } break; + }; + tokSFCSupport = tokSFCSupport + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSFCSupport == tokSFCSupportEnd); + } break; + }; + tokVDBoxInfo = tokVDBoxInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokVDBoxInfo == tokVDBoxInfoEnd); + } break; + case TOK_FS_GT_SYSTEM_INFO__VEBOX_INFO: { + const TokenHeader *tokVEBoxInfo = varLen->getValue(); + const TokenHeader *tokVEBoxInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokVEBoxInfo < tokVEBoxInfoEnd) { + if (false == tokVEBoxInfo->flags.flag4IsVariableLength) { + switch (tokVEBoxInfo->id) { + default: + if (tokVEBoxInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VEBOX_INFO__NUMBER_OF_VEBOX_ENABLED: { + dst.SystemInfo.VEBoxInfo.NumberOfVEBoxEnabled = readTokValue(*tokVEBoxInfo); + } break; + case TOK_FBB_GT_VEBOX_INFO__IS_VALID: { + dst.SystemInfo.VEBoxInfo.IsValid = readTokValue(*tokVEBoxInfo); + } break; + }; + tokVEBoxInfo = tokVEBoxInfo + 1 + tokVEBoxInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokVEBoxInfo); + switch (tokVEBoxInfo->id) { + default: + if (tokVEBoxInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_VEBOX_INFO__INSTANCES: { + const TokenHeader *tokInstances = varLen->getValue(); + const TokenHeader *tokInstancesEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokInstances < tokInstancesEnd) { + if (false == tokInstances->flags.flag4IsVariableLength) { + switch (tokInstances->id) { + default: + if (tokInstances->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBOX_ENABLE_MASK: { + dst.SystemInfo.VEBoxInfo.Instances.VEBoxEnableMask = readTokValue(*tokInstances); + } break; + }; + tokInstances = tokInstances + 1 + tokInstances->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokInstances); + switch (tokInstances->id) { + default: + if (tokInstances->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_VEBOX_INFO__VEBOX_INSTANCES__BITS: { + const TokenHeader *tokBits = varLen->getValue(); + const TokenHeader *tokBitsEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokBits < tokBitsEnd) { + if (false == tokBits->flags.flag4IsVariableLength) { + switch (tokBits->id) { + default: + if (tokBits->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX0ENABLED: { + dst.SystemInfo.VEBoxInfo.Instances.Bits.VEBox0Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX1ENABLED: { + dst.SystemInfo.VEBoxInfo.Instances.Bits.VEBox1Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX2ENABLED: { + dst.SystemInfo.VEBoxInfo.Instances.Bits.VEBox2Enabled = readTokValue(*tokBits); + } break; + case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX3ENABLED: { + dst.SystemInfo.VEBoxInfo.Instances.Bits.VEBox3Enabled = readTokValue(*tokBits); + } break; + }; + tokBits = tokBits + 1 + tokBits->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokBits); + if (tokBits->flags.flag3IsMandatory) { + return false; + } + tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokBits == tokBitsEnd); + } break; + }; + tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokInstances == tokInstancesEnd); + } break; + case TOK_FS_GT_VEBOX_INFO__SFCSUPPORT: { + const TokenHeader *tokSFCSupport = varLen->getValue(); + const TokenHeader *tokSFCSupportEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSFCSupport < tokSFCSupportEnd) { + if (false == tokSFCSupport->flags.flag4IsVariableLength) { + switch (tokSFCSupport->id) { + default: + if (tokSFCSupport->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__VALUE: { + dst.SystemInfo.VEBoxInfo.SFCSupport.Value = readTokValue(*tokSFCSupport); + } break; + }; + tokSFCSupport = tokSFCSupport + 1 + tokSFCSupport->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSFCSupport); + switch (tokSFCSupport->id) { + default: + if (tokSFCSupport->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GT_VEBOX_INFO__ANONYMOUS3862__SFC_SUPPORTED_BITS: { + const TokenHeader *tokSfcSupportedBits = varLen->getValue(); + const TokenHeader *tokSfcSupportedBitsEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSfcSupportedBits < tokSfcSupportedBitsEnd) { + if (false == tokSfcSupportedBits->flags.flag4IsVariableLength) { + switch (tokSfcSupportedBits->id) { + default: + if (tokSfcSupportedBits->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX0: { + dst.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox0 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX1: { + dst.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox1 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX2: { + dst.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox2 = readTokValue(*tokSfcSupportedBits); + } break; + case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX3: { + dst.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox3 = readTokValue(*tokSfcSupportedBits); + } break; + }; + tokSfcSupportedBits = tokSfcSupportedBits + 1 + tokSfcSupportedBits->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSfcSupportedBits); + if (tokSfcSupportedBits->flags.flag3IsMandatory) { + return false; + } + tokSfcSupportedBits = tokSfcSupportedBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSfcSupportedBits == tokSfcSupportedBitsEnd); + } break; + }; + tokSFCSupport = tokSFCSupport + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSFCSupport == tokSFCSupportEnd); + } break; + }; + tokVEBoxInfo = tokVEBoxInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokVEBoxInfo == tokVEBoxInfoEnd); + } break; + case TOK_FS_GT_SYSTEM_INFO__CACHE_TYPES: { + const TokenHeader *tokCacheTypes = varLen->getValue(); + const TokenHeader *tokCacheTypesEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokCacheTypes < tokCacheTypesEnd) { + if (false == tokCacheTypes->flags.flag4IsVariableLength) { + switch (tokCacheTypes->id) { + default: + if (tokCacheTypes->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__L3: { + dst.SystemInfo.CacheTypes.L3 = readTokValue(*tokCacheTypes); + } break; + case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__LLC: { + dst.SystemInfo.CacheTypes.LLC = readTokValue(*tokCacheTypes); + } break; + case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__E_DRAM: { + dst.SystemInfo.CacheTypes.eDRAM = readTokValue(*tokCacheTypes); + } break; + case TOK_FBD_GT_CACHE_TYPES__CACHE_TYPE_MASK: { + dst.SystemInfo.CacheTypes.CacheTypeMask = readTokValue(*tokCacheTypes); + } break; + }; + tokCacheTypes = tokCacheTypes + 1 + tokCacheTypes->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokCacheTypes); + if (tokCacheTypes->flags.flag3IsMandatory) { + return false; + } + tokCacheTypes = tokCacheTypes + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokCacheTypes == tokCacheTypesEnd); + } break; + }; + tokSystemInfo = tokSystemInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSystemInfo == tokSystemInfoEnd); + } break; + case TOK_FS_ADAPTER_INFO__DEFERRED_WAIT_INFO: { + const TokenHeader *tokDeferredWaitInfo = varLen->getValue(); + const TokenHeader *tokDeferredWaitInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokDeferredWaitInfo < tokDeferredWaitInfoEnd) { + if (false == tokDeferredWaitInfo->flags.flag4IsVariableLength) { + switch (tokDeferredWaitInfo->id) { + default: + if (tokDeferredWaitInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_KM_DEFERRED_WAIT_INFO__FEATURE_SUPPORTED: { + dst.DeferredWaitInfo.FeatureSupported = readTokValue(*tokDeferredWaitInfo); + } break; + case TOK_FBD_KM_DEFERRED_WAIT_INFO__ACTIVE_DISPLAY: { + dst.DeferredWaitInfo.ActiveDisplay = readTokValue(*tokDeferredWaitInfo); + } break; + }; + tokDeferredWaitInfo = tokDeferredWaitInfo + 1 + tokDeferredWaitInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokDeferredWaitInfo); + if (tokDeferredWaitInfo->flags.flag3IsMandatory) { + return false; + } + tokDeferredWaitInfo = tokDeferredWaitInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokDeferredWaitInfo == tokDeferredWaitInfoEnd); + } break; + case TOK_FS_ADAPTER_INFO__GFX_PARTITION: { + const TokenHeader *tokGfxPartition = varLen->getValue(); + const TokenHeader *tokGfxPartitionEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokGfxPartition < tokGfxPartitionEnd) { + if (false == tokGfxPartition->flags.flag4IsVariableLength) { + if (tokGfxPartition->flags.flag3IsMandatory) { + return false; + } + tokGfxPartition = tokGfxPartition + 1 + tokGfxPartition->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokGfxPartition); + switch (tokGfxPartition->id) { + default: + if (tokGfxPartition->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_GFX_PARTITIONING__STANDARD: { + const TokenHeader *tokStandard = varLen->getValue(); + const TokenHeader *tokStandardEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokStandard < tokStandardEnd) { + if (false == tokStandard->flags.flag4IsVariableLength) { + switch (tokStandard->id) { + default: + if (tokStandard->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__BASE: { + dst.GfxPartition.Standard.Base = readTokValue(*tokStandard); + } break; + case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__LIMIT: { + dst.GfxPartition.Standard.Limit = readTokValue(*tokStandard); + } break; + }; + tokStandard = tokStandard + 1 + tokStandard->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokStandard); + if (tokStandard->flags.flag3IsMandatory) { + return false; + } + tokStandard = tokStandard + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokStandard == tokStandardEnd); + } break; + case TOK_FS_GMM_GFX_PARTITIONING__STANDARD64KB: { + const TokenHeader *tokStandard64KB = varLen->getValue(); + const TokenHeader *tokStandard64KBEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokStandard64KB < tokStandard64KBEnd) { + if (false == tokStandard64KB->flags.flag4IsVariableLength) { + switch (tokStandard64KB->id) { + default: + if (tokStandard64KB->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__BASE: { + dst.GfxPartition.Standard64KB.Base = readTokValue(*tokStandard64KB); + } break; + case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__LIMIT: { + dst.GfxPartition.Standard64KB.Limit = readTokValue(*tokStandard64KB); + } break; + }; + tokStandard64KB = tokStandard64KB + 1 + tokStandard64KB->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokStandard64KB); + if (tokStandard64KB->flags.flag3IsMandatory) { + return false; + } + tokStandard64KB = tokStandard64KB + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokStandard64KB == tokStandard64KBEnd); + } break; + case TOK_FS_GMM_GFX_PARTITIONING__SVM: { + const TokenHeader *tokSVM = varLen->getValue(); + const TokenHeader *tokSVMEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSVM < tokSVMEnd) { + if (false == tokSVM->flags.flag4IsVariableLength) { + switch (tokSVM->id) { + default: + if (tokSVM->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__BASE: { + dst.GfxPartition.SVM.Base = readTokValue(*tokSVM); + } break; + case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__LIMIT: { + dst.GfxPartition.SVM.Limit = readTokValue(*tokSVM); + } break; + }; + tokSVM = tokSVM + 1 + tokSVM->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSVM); + if (tokSVM->flags.flag3IsMandatory) { + return false; + } + tokSVM = tokSVM + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSVM == tokSVMEnd); + } break; + case TOK_FS_GMM_GFX_PARTITIONING__HEAP32: { + uint32_t arrayElementIdHeap32 = varLen->arrayElementId; + const TokenHeader *tokHeap32 = varLen->getValue(); + const TokenHeader *tokHeap32End = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokHeap32 < tokHeap32End) { + if (false == tokHeap32->flags.flag4IsVariableLength) { + switch (tokHeap32->id) { + default: + if (tokHeap32->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__BASE: { + dst.GfxPartition.Heap32[arrayElementIdHeap32].Base = readTokValue(*tokHeap32); + } break; + case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__LIMIT: { + dst.GfxPartition.Heap32[arrayElementIdHeap32].Limit = readTokValue(*tokHeap32); + } break; + }; + tokHeap32 = tokHeap32 + 1 + tokHeap32->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokHeap32); + if (tokHeap32->flags.flag3IsMandatory) { + return false; + } + tokHeap32 = tokHeap32 + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokHeap32 == tokHeap32End); + } break; + }; + tokGfxPartition = tokGfxPartition + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokGfxPartition == tokGfxPartitionEnd); + } break; + case TOK_FS_ADAPTER_INFO__ST_ADAPTER_BDF: { + const TokenHeader *tokStAdapterBDF = varLen->getValue(); + const TokenHeader *tokStAdapterBDFEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokStAdapterBDF < tokStAdapterBDFEnd) { + if (false == tokStAdapterBDF->flags.flag4IsVariableLength) { + switch (tokStAdapterBDF->id) { + default: + if (tokStAdapterBDF->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__BUS: { + dst.stAdapterBDF.Bus = readTokValue(*tokStAdapterBDF); + } break; + case TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__DEVICE: { + dst.stAdapterBDF.Device = readTokValue(*tokStAdapterBDF); + } break; + case TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__FUNCTION: { + dst.stAdapterBDF.Function = readTokValue(*tokStAdapterBDF); + } break; + case TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__DATA: { + dst.stAdapterBDF.Data = readTokValue(*tokStAdapterBDF); + } break; + }; + tokStAdapterBDF = tokStAdapterBDF + 1 + tokStAdapterBDF->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokStAdapterBDF); + if (tokStAdapterBDF->flags.flag3IsMandatory) { + return false; + } + tokStAdapterBDF = tokStAdapterBDF + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokStAdapterBDF == tokStAdapterBDFEnd); + } break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(_CREATECONTEXT_PVTDATAT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_PBQ_CREATECONTEXT_PVTDATA__ANONYMOUS18449__P_HW_CONTEXT_ID: { + dst.pHwContextId = readTokValue(*tok); + } break; + case TOK_FBD_CREATECONTEXT_PVTDATA__NUMBER_OF_HW_CONTEXT_IDS: { + dst.NumberOfHwContextIds = readTokValue(*tok); + } break; + case TOK_FBD_CREATECONTEXT_PVTDATA__PROCESS_ID: { + dst.ProcessID = readTokValue(*tok); + } break; + case TOK_FBC_CREATECONTEXT_PVTDATA__IS_PROTECTED_PROCESS: { + dst.IsProtectedProcess = readTokValue(*tok); + } break; + case TOK_FBC_CREATECONTEXT_PVTDATA__IS_DWM: { + dst.IsDwm = readTokValue(*tok); + } break; + case TOK_FBC_CREATECONTEXT_PVTDATA__IS_MEDIA_USAGE: { + dst.IsMediaUsage = readTokValue(*tok); + } break; + case TOK_FBC_CREATECONTEXT_PVTDATA__GPU_VACONTEXT: { + dst.GpuVAContext = readTokValue(*tok); + } break; + case TOK_FBC_CREATECONTEXT_PVTDATA__NO_RING_FLUSHES: { + dst.NoRingFlushes = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_CREATECONTEXT_PVTDATA: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(COMMAND_BUFFER_HEADER_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_COMMAND_BUFFER_HEADER_REC__UMD_CONTEXT_TYPE: { + dst.UmdContextType = readTokValue(*tok); + } break; + case TOK_FBD_COMMAND_BUFFER_HEADER_REC__UMD_PATCH_LIST: { + dst.UmdPatchList = readTokValue(*tok); + } break; + case TOK_FBD_COMMAND_BUFFER_HEADER_REC__UMD_REQUESTED_SLICE_STATE: { + dst.UmdRequestedSliceState = readTokValue(*tok); + } break; + case TOK_FBD_COMMAND_BUFFER_HEADER_REC__UMD_REQUESTED_SUBSLICE_COUNT: { + dst.UmdRequestedSubsliceCount = readTokValue(*tok); + } break; + case TOK_FBD_COMMAND_BUFFER_HEADER_REC__UMD_REQUESTED_EUCOUNT: { + dst.UmdRequestedEUCount = readTokValue(*tok); + } break; + case TOK_FBD_COMMAND_BUFFER_HEADER_REC__USES_RESOURCE_STREAMER: { + dst.UsesResourceStreamer = readTokValue(*tok); + } break; + case TOK_FBD_COMMAND_BUFFER_HEADER_REC__NEEDS_MID_BATCH_PRE_EMPTION_SUPPORT: { + dst.NeedsMidBatchPreEmptionSupport = readTokValue(*tok); + } break; + case TOK_FBD_COMMAND_BUFFER_HEADER_REC__USES_GPGPUPIPELINE: { + dst.UsesGPGPUPipeline = readTokValue(*tok); + } break; + case TOK_FBD_COMMAND_BUFFER_HEADER_REC__REQUIRES_COHERENCY: { + dst.RequiresCoherency = readTokValue(*tok); + } break; + case TOK_FBD_COMMAND_BUFFER_HEADER_REC__PERF_TAG: { + dst.PerfTag = readTokValue(*tok); + } break; + case TOK_FBQ_COMMAND_BUFFER_HEADER_REC__MONITOR_FENCE_VA: { + dst.MonitorFenceVA = readTokValue(*tok); + } break; + case TOK_FBQ_COMMAND_BUFFER_HEADER_REC__MONITOR_FENCE_VALUE: { + dst.MonitorFenceValue = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_COMMAND_BUFFER_HEADER_REC: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(GMM_RESOURCE_FLAG_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + if (tok->flags.flag3IsMandatory) { + return false; + } + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GMM_RESOURCE_FLAG_REC: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + case TOK_FS_GMM_RESOURCE_FLAG_REC__GPU: { + const TokenHeader *tokGpu = varLen->getValue(); + const TokenHeader *tokGpuEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokGpu < tokGpuEnd) { + if (false == tokGpu->flags.flag4IsVariableLength) { + switch (tokGpu->id) { + default: + if (tokGpu->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CAMERA_CAPTURE: { + dst.Gpu.CameraCapture = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CCS: { + dst.Gpu.CCS = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_DISCARD: { + dst.Gpu.ColorDiscard = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION: { + dst.Gpu.ColorSeparation = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION_RGBX: { + dst.Gpu.ColorSeparationRGBX = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CONSTANT: { + dst.Gpu.Constant = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__DEPTH: { + dst.Gpu.Depth = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN: { + dst.Gpu.FlipChain = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN_PREFERRED: { + dst.Gpu.FlipChainPreferred = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HISTORY_BUFFER: { + dst.Gpu.HistoryBuffer = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HI_Z: { + dst.Gpu.HiZ = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDEX: { + dst.Gpu.Index = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDIRECT_CLEAR_COLOR: { + dst.Gpu.IndirectClearColor = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INSTRUCTION_FLAT: { + dst.Gpu.InstructionFlat = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INTERLACED_SCAN: { + dst.Gpu.InterlacedScan = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MCS: { + dst.Gpu.MCS = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MMC: { + dst.Gpu.MMC = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MOTION_COMP: { + dst.Gpu.MotionComp = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__NO_RESTRICTION: { + dst.Gpu.NoRestriction = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__OVERLAY: { + dst.Gpu.Overlay = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PRESENTABLE: { + dst.Gpu.Presentable = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PROCEDURAL_TEXTURE: { + dst.Gpu.ProceduralTexture = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__QUERY: { + dst.Gpu.Query = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__RENDER_TARGET: { + dst.Gpu.RenderTarget = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D: { + dst.Gpu.S3d = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D_DX: { + dst.Gpu.S3dDx = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_NON_PACKED: { + dst.Gpu.__S3dNonPacked = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_WIDI: { + dst.Gpu.__S3dWidi = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SCRATCH_FLAT: { + dst.Gpu.ScratchFlat = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SEPARATE_STENCIL: { + dst.Gpu.SeparateStencil = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE: { + dst.Gpu.State = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE_DX9CONSTANT_BUFFER: { + dst.Gpu.StateDx9ConstantBuffer = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STREAM: { + dst.Gpu.Stream = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXT_API: { + dst.Gpu.TextApi = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXTURE: { + dst.Gpu.Texture = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILED_RESOURCE: { + dst.Gpu.TiledResource = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILE_POOL: { + dst.Gpu.TilePool = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__UNIFIED_AUX_SURFACE: { + dst.Gpu.UnifiedAuxSurface = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VERTEX: { + dst.Gpu.Vertex = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VIDEO: { + dst.Gpu.Video = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_XCCS: { + dst.Gpu.__NonMsaaTileXCcs = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_YCCS: { + dst.Gpu.__NonMsaaTileYCcs = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____MSAA_TILE_MCS: { + dst.Gpu.__MsaaTileMcs = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_LINEAR_CCS: { + dst.Gpu.__NonMsaaLinearCCS = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____REMAINING: { + dst.Gpu.__Remaining = readTokValue(*tokGpu); + } break; + }; + tokGpu = tokGpu + 1 + tokGpu->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokGpu); + if (tokGpu->flags.flag3IsMandatory) { + return false; + } + tokGpu = tokGpu + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokGpu == tokGpuEnd); + } break; + case TOK_FS_GMM_RESOURCE_FLAG_REC__INFO: { + const TokenHeader *tokInfo = varLen->getValue(); + const TokenHeader *tokInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokInfo < tokInfoEnd) { + if (false == tokInfo->flags.flag4IsVariableLength) { + switch (tokInfo->id) { + default: + if (tokInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ALLOW_VIRTUAL_PADDING: { + dst.Info.AllowVirtualPadding = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__BIG_PAGE: { + dst.Info.BigPage = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CACHEABLE: { + dst.Info.Cacheable = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CONTIG_PHYS_MEMORY_FORI_DART: { + dst.Info.ContigPhysMemoryForiDART = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CORNER_TEXEL_MODE: { + dst.Info.CornerTexelMode = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__EXISTING_SYS_MEM: { + dst.Info.ExistingSysMem = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__FORCE_RESIDENCY: { + dst.Info.ForceResidency = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GFDT: { + dst.Info.Gfdt = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GTT_MAP_TYPE: { + dst.Info.GttMapType = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__HARDWARE_PROTECTED: { + dst.Info.HardwareProtected = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__KERNEL_MODE_MAPPED: { + dst.Info.KernelModeMapped = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_BELOW: { + dst.Info.LayoutBelow = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_MONO: { + dst.Info.LayoutMono = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_RIGHT: { + dst.Info.LayoutRight = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LOCAL_ONLY: { + dst.Info.LocalOnly = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LINEAR: { + dst.Info.Linear = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__MEDIA_COMPRESSED: { + dst.Info.MediaCompressed = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_OPTIMIZATION_PADDING: { + dst.Info.NoOptimizationPadding = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_PHYS_MEMORY: { + dst.Info.NoPhysMemory = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NOT_LOCKABLE: { + dst.Info.NotLockable = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NON_LOCAL_ONLY: { + dst.Info.NonLocalOnly = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__STD_SWIZZLE: { + dst.Info.StdSwizzle = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__PSEUDO_STD_SWIZZLE: { + dst.Info.PseudoStdSwizzle = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__UNDEFINED64KBSWIZZLE: { + dst.Info.Undefined64KBSwizzle = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__REDECRIBED_PLANES: { + dst.Info.RedecribedPlanes = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__RENDER_COMPRESSED: { + dst.Info.RenderCompressed = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ROTATED: { + dst.Info.Rotated = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SHARED: { + dst.Info.Shared = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SOFTWARE_PROTECTED: { + dst.Info.SoftwareProtected = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SVM: { + dst.Info.SVM = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE4: { + dst.Info.Tile4 = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE64: { + dst.Info.Tile64 = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_W: { + dst.Info.TiledW = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_X: { + dst.Info.TiledX = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_Y: { + dst.Info.TiledY = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YF: { + dst.Info.TiledYf = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YS: { + dst.Info.TiledYs = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__WDDM_PROTECTED: { + dst.Info.WddmProtected = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__XADAPTER: { + dst.Info.XAdapter = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PREALLOCATED_RES_INFO: { + dst.Info.__PreallocatedResInfo = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PRE_WDDM2SVM: { + dst.Info.__PreWddm2SVM = readTokValue(*tokInfo); + } break; + }; + tokInfo = tokInfo + 1 + tokInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokInfo); + if (tokInfo->flags.flag3IsMandatory) { + return false; + } + tokInfo = tokInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokInfo == tokInfoEnd); + } break; + case TOK_FS_GMM_RESOURCE_FLAG_REC__WA: { + const TokenHeader *tokWa = varLen->getValue(); + const TokenHeader *tokWaEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokWa < tokWaEnd) { + if (false == tokWa->flags.flag4IsVariableLength) { + switch (tokWa->id) { + default: + if (tokWa->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__GTMFX2ND_LEVEL_BATCH_RING_SIZE_ALIGN: { + dst.Wa.GTMfx2ndLevelBatchRingSizeAlign = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_MPR_ROW_STORE32KALIGN: { + dst.Wa.ILKNeedAvcMprRowStore32KAlign = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_DMV_BUFFER32KALIGN: { + dst.Wa.ILKNeedAvcDmvBuffer32KAlign = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_BUFFER_SAMPLER_PADDING: { + dst.Wa.NoBufferSamplerPadding = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_LEGACY_PLANAR_LINEAR_VIDEO_RESTRICTIONS: { + dst.Wa.NoLegacyPlanarLinearVideoRestrictions = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__CHVASTC_SKIP_VIRTUAL_MIPS: { + dst.Wa.CHVAstcSkipVirtualMips = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_PACKED_MIP_TAIL: { + dst.Wa.DisablePackedMipTail = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521____FORCE_OTHER_HVALIGN4: { + dst.Wa.__ForceOtherHVALIGN4 = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR: { + dst.Wa.DisableDisplayCcsClearColor = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION: { + dst.Wa.DisableDisplayCcsCompression = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: { + dst.Wa.PreGen12FastClearOnly = readTokValue(*tokWa); + } break; + }; + tokWa = tokWa + 1 + tokWa->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokWa); + if (tokWa->flags.flag3IsMandatory) { + return false; + } + tokWa = tokWa + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokWa == tokWaEnd); + } break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(GMM_RESOURCE_MSAA_INFO_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GMM_RESOURCE_MSAA_INFO_REC__SAMPLE_PATTERN: { + dst.SamplePattern = readTokValue(*tok); + } break; + case TOK_FBD_GMM_RESOURCE_MSAA_INFO_REC__NUM_SAMPLES: { + dst.NumSamples = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GMM_RESOURCE_MSAA_INFO_REC: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(GMM_RESOURCE_ALIGNMENT_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBC_GMM_RESOURCE_ALIGNMENT_REC__ARRAY_SPACING_SINGLE_LOD: { + dst.ArraySpacingSingleLod = readTokValue(*tok); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__BASE_ALIGNMENT: { + dst.BaseAlignment = readTokValue(*tok); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__HALIGN: { + dst.HAlign = readTokValue(*tok); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__VALIGN: { + dst.VAlign = readTokValue(*tok); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__DALIGN: { + dst.DAlign = readTokValue(*tok); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__MIP_TAIL_START_LOD: { + dst.MipTailStartLod = readTokValue(*tok); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_START_LOD: { + dst.PackedMipStartLod = readTokValue(*tok); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_WIDTH: { + dst.PackedMipWidth = readTokValue(*tok); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_HEIGHT: { + dst.PackedMipHeight = readTokValue(*tok); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__QPITCH: { + dst.QPitch = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GMM_RESOURCE_ALIGNMENT_REC: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(GMM_S3D_INFO_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_S3D_INFO_REC__DISPLAY_MODE_HEIGHT: { + dst.DisplayModeHeight = readTokValue(*tok); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__NUM_BLANK_ACTIVE_LINES: { + dst.NumBlankActiveLines = readTokValue(*tok); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__RFRAME_OFFSET: { + dst.RFrameOffset = readTokValue(*tok); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__BLANK_AREA_OFFSET: { + dst.BlankAreaOffset = readTokValue(*tok); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_HEIGHT: { + dst.TallBufferHeight = readTokValue(*tok); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_SIZE: { + dst.TallBufferSize = readTokValue(*tok); + } break; + case TOK_FBC_GMM_S3D_INFO_REC__IS_RFRAME: { + dst.IsRFrame = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GMM_S3D_INFO_REC: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(GMM_MULTI_TILE_ARCH_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__ENABLE: { + dst.Enable = readTokValue(*tok); + } break; + case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__TILE_INSTANCED: { + dst.TileInstanced = readTokValue(*tok); + } break; + case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__GPU_VA_MAPPING_SET: { + dst.GpuVaMappingSet = readTokValue(*tok); + } break; + case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__LOCAL_MEM_ELIGIBILITY_SET: { + dst.LocalMemEligibilitySet = readTokValue(*tok); + } break; + case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__LOCAL_MEM_PREFERRED_SET: { + dst.LocalMemPreferredSet = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GMM_MULTI_TILE_ARCH_REC: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(GMM_PLANAR_OFFSET_INFO_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: { + dst.ArrayQPitch = readTokValue(*tok); + } break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: { + auto srcData = reinterpret_cast &>(*tok).getValue(); + auto srcSize = reinterpret_cast &>(*tok).getValueSizeInBytes(); + if (srcSize < sizeof(dst.X)) { + return false; + } + WCH_SAFE_COPY(dst.X, sizeof(dst.X), srcData, sizeof(dst.X)); + } break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: { + auto srcData = reinterpret_cast &>(*tok).getValue(); + auto srcSize = reinterpret_cast &>(*tok).getValueSizeInBytes(); + if (srcSize < sizeof(dst.Y)) { + return false; + } + WCH_SAFE_COPY(dst.Y, sizeof(dst.Y), srcData, sizeof(dst.Y)); + } break; + case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: { + dst.NoOfPlanes = readTokValue(*tok); + } break; + case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: { + dst.IsTileAlignedPlanes = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GMM_PLANAR_OFFSET_INFO_REC: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: { + const TokenHeader *tokUnAligned = varLen->getValue(); + const TokenHeader *tokUnAlignedEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokUnAligned < tokUnAlignedEnd) { + if (false == tokUnAligned->flags.flag4IsVariableLength) { + switch (tokUnAligned->id) { + default: + if (tokUnAligned->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: { + auto srcData = reinterpret_cast &>(*tokUnAligned).getValue(); + auto srcSize = reinterpret_cast &>(*tokUnAligned).getValueSizeInBytes(); + if (srcSize < sizeof(dst.UnAligned.Height)) { + return false; + } + WCH_SAFE_COPY(dst.UnAligned.Height, sizeof(dst.UnAligned.Height), srcData, sizeof(dst.UnAligned.Height)); + } break; + }; + tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokUnAligned); + if (tokUnAligned->flags.flag3IsMandatory) { + return false; + } + tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokUnAligned == tokUnAlignedEnd); + } break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(GMM_2D_TEXTURE_OFFSET_INFO_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: { + dst.ArrayQPitchLock = readTokValue(*tok); + } break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: { + dst.ArrayQPitchRender = readTokValue(*tok); + } break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: { + auto srcData = reinterpret_cast &>(*tok).getValue(); + auto srcSize = reinterpret_cast &>(*tok).getValueSizeInBytes(); + if (srcSize < sizeof(dst.Offset)) { + return false; + } + WCH_SAFE_COPY(dst.Offset, sizeof(dst.Offset), srcData, sizeof(dst.Offset)); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GMM_2D_TEXTURE_OFFSET_INFO_REC: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(GMM_3D_TEXTURE_OFFSET_INFO_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: { + dst.Mip0SlicePitch = readTokValue(*tok); + } break; + case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: { + auto srcData = reinterpret_cast &>(*tok).getValue(); + auto srcSize = reinterpret_cast &>(*tok).getValueSizeInBytes(); + if (srcSize < sizeof(dst.Offset)) { + return false; + } + WCH_SAFE_COPY(dst.Offset, sizeof(dst.Offset), srcData, sizeof(dst.Offset)); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GMM_3D_TEXTURE_OFFSET_INFO_REC: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(GMM_OFFSET_INFO_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + if (tok->flags.flag3IsMandatory) { + return false; + } + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GMM_OFFSET_INFO_REC: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO: { + const TokenHeader *tokTexture3DOffsetInfo = varLen->getValue(); + const TokenHeader *tokTexture3DOffsetInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokTexture3DOffsetInfo < tokTexture3DOffsetInfoEnd) { + if (false == tokTexture3DOffsetInfo->flags.flag4IsVariableLength) { + switch (tokTexture3DOffsetInfo->id) { + default: + if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: { + dst.Texture3DOffsetInfo.Mip0SlicePitch = readTokValue(*tokTexture3DOffsetInfo); + } break; + case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: { + auto srcData = reinterpret_cast &>(*tokTexture3DOffsetInfo).getValue(); + auto srcSize = reinterpret_cast &>(*tokTexture3DOffsetInfo).getValueSizeInBytes(); + if (srcSize < sizeof(dst.Texture3DOffsetInfo.Offset)) { + return false; + } + WCH_SAFE_COPY(dst.Texture3DOffsetInfo.Offset, sizeof(dst.Texture3DOffsetInfo.Offset), srcData, sizeof(dst.Texture3DOffsetInfo.Offset)); + } break; + }; + tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + 1 + tokTexture3DOffsetInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokTexture3DOffsetInfo); + if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokTexture3DOffsetInfo == tokTexture3DOffsetInfoEnd); + } break; + case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO: { + const TokenHeader *tokTexture2DOffsetInfo = varLen->getValue(); + const TokenHeader *tokTexture2DOffsetInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokTexture2DOffsetInfo < tokTexture2DOffsetInfoEnd) { + if (false == tokTexture2DOffsetInfo->flags.flag4IsVariableLength) { + switch (tokTexture2DOffsetInfo->id) { + default: + if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: { + dst.Texture2DOffsetInfo.ArrayQPitchLock = readTokValue(*tokTexture2DOffsetInfo); + } break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: { + dst.Texture2DOffsetInfo.ArrayQPitchRender = readTokValue(*tokTexture2DOffsetInfo); + } break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: { + auto srcData = reinterpret_cast &>(*tokTexture2DOffsetInfo).getValue(); + auto srcSize = reinterpret_cast &>(*tokTexture2DOffsetInfo).getValueSizeInBytes(); + if (srcSize < sizeof(dst.Texture2DOffsetInfo.Offset)) { + return false; + } + WCH_SAFE_COPY(dst.Texture2DOffsetInfo.Offset, sizeof(dst.Texture2DOffsetInfo.Offset), srcData, sizeof(dst.Texture2DOffsetInfo.Offset)); + } break; + }; + tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + 1 + tokTexture2DOffsetInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokTexture2DOffsetInfo); + if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokTexture2DOffsetInfo == tokTexture2DOffsetInfoEnd); + } break; + case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE: { + const TokenHeader *tokPlane = varLen->getValue(); + const TokenHeader *tokPlaneEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokPlane < tokPlaneEnd) { + if (false == tokPlane->flags.flag4IsVariableLength) { + switch (tokPlane->id) { + default: + if (tokPlane->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: { + dst.Plane.ArrayQPitch = readTokValue(*tokPlane); + } break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: { + auto srcData = reinterpret_cast &>(*tokPlane).getValue(); + auto srcSize = reinterpret_cast &>(*tokPlane).getValueSizeInBytes(); + if (srcSize < sizeof(dst.Plane.X)) { + return false; + } + WCH_SAFE_COPY(dst.Plane.X, sizeof(dst.Plane.X), srcData, sizeof(dst.Plane.X)); + } break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: { + auto srcData = reinterpret_cast &>(*tokPlane).getValue(); + auto srcSize = reinterpret_cast &>(*tokPlane).getValueSizeInBytes(); + if (srcSize < sizeof(dst.Plane.Y)) { + return false; + } + WCH_SAFE_COPY(dst.Plane.Y, sizeof(dst.Plane.Y), srcData, sizeof(dst.Plane.Y)); + } break; + case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: { + dst.Plane.NoOfPlanes = readTokValue(*tokPlane); + } break; + case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: { + dst.Plane.IsTileAlignedPlanes = readTokValue(*tokPlane); + } break; + }; + tokPlane = tokPlane + 1 + tokPlane->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokPlane); + switch (tokPlane->id) { + default: + if (tokPlane->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: { + const TokenHeader *tokUnAligned = varLen->getValue(); + const TokenHeader *tokUnAlignedEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokUnAligned < tokUnAlignedEnd) { + if (false == tokUnAligned->flags.flag4IsVariableLength) { + switch (tokUnAligned->id) { + default: + if (tokUnAligned->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: { + auto srcData = reinterpret_cast &>(*tokUnAligned).getValue(); + auto srcSize = reinterpret_cast &>(*tokUnAligned).getValueSizeInBytes(); + if (srcSize < sizeof(dst.Plane.UnAligned.Height)) { + return false; + } + WCH_SAFE_COPY(dst.Plane.UnAligned.Height, sizeof(dst.Plane.UnAligned.Height), srcData, sizeof(dst.Plane.UnAligned.Height)); + } break; + }; + tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokUnAligned); + if (tokUnAligned->flags.flag3IsMandatory) { + return false; + } + tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokUnAligned == tokUnAlignedEnd); + } break; + }; + tokPlane = tokPlane + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokPlane == tokPlaneEnd); + } break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(GMM_TEXTURE_INFO_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GMM_TEXTURE_INFO_REC__TYPE: { + dst.Type = readTokValue(*tok); + } break; + case TOK_FE_GMM_TEXTURE_INFO_REC__FORMAT: { + dst.Format = readTokValue(*tok); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__BITS_PER_PIXEL: { + dst.BitsPerPixel = readTokValue(*tok); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__BASE_WIDTH: { + dst.BaseWidth = readTokValue(*tok); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__BASE_HEIGHT: { + dst.BaseHeight = readTokValue(*tok); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__DEPTH: { + dst.Depth = readTokValue(*tok); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__MAX_LOD: { + dst.MaxLod = readTokValue(*tok); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__ARRAY_SIZE: { + dst.ArraySize = readTokValue(*tok); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__CP_TAG: { + dst.CpTag = readTokValue(*tok); + } break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_MODE: { + auto srcData = reinterpret_cast &>(*tok).getValue(); + auto srcSize = reinterpret_cast &>(*tok).getValueSizeInBytes(); + if (srcSize < sizeof(dst.MmcMode)) { + return false; + } + WCH_SAFE_COPY(dst.MmcMode, sizeof(dst.MmcMode), srcData, sizeof(dst.MmcMode)); + } break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_HINT: { + auto srcData = reinterpret_cast &>(*tok).getValue(); + auto srcSize = reinterpret_cast &>(*tok).getValueSizeInBytes(); + if (srcSize < sizeof(dst.MmcHint)) { + return false; + } + WCH_SAFE_COPY(dst.MmcHint, sizeof(dst.MmcHint), srcData, sizeof(dst.MmcHint)); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__PITCH: { + dst.Pitch = readTokValue(*tok); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__OVERRIDE_PITCH: { + dst.OverridePitch = readTokValue(*tok); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE: { + dst.Size = readTokValue(*tok); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__CCSIZE: { + dst.CCSize = readTokValue(*tok); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__UNPADDED_SIZE: { + dst.UnpaddedSize = readTokValue(*tok); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE_REPORT_TO_OS: { + dst.SizeReportToOS = readTokValue(*tok); + } break; + case TOK_FE_GMM_TEXTURE_INFO_REC__TILE_MODE: { + dst.TileMode = readTokValue(*tok); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__CCSMODE_ALIGN: { + dst.CCSModeAlign = readTokValue(*tok); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__LEGACY_FLAGS: { + dst.LegacyFlags = readTokValue(*tok); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__MAXIMUM_RENAMING_LIST_LENGTH: { + dst.MaximumRenamingListLength = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GMM_TEXTURE_INFO_REC: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + case TOK_FS_GMM_TEXTURE_INFO_REC__FLAGS: { + const TokenHeader *tokFlags = varLen->getValue(); + const TokenHeader *tokFlagsEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokFlags < tokFlagsEnd) { + if (false == tokFlags->flags.flag4IsVariableLength) { + if (tokFlags->flags.flag3IsMandatory) { + return false; + } + tokFlags = tokFlags + 1 + tokFlags->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokFlags); + switch (tokFlags->id) { + default: + if (tokFlags->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_RESOURCE_FLAG_REC__GPU: { + const TokenHeader *tokGpu = varLen->getValue(); + const TokenHeader *tokGpuEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokGpu < tokGpuEnd) { + if (false == tokGpu->flags.flag4IsVariableLength) { + switch (tokGpu->id) { + default: + if (tokGpu->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CAMERA_CAPTURE: { + dst.Flags.Gpu.CameraCapture = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CCS: { + dst.Flags.Gpu.CCS = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_DISCARD: { + dst.Flags.Gpu.ColorDiscard = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION: { + dst.Flags.Gpu.ColorSeparation = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION_RGBX: { + dst.Flags.Gpu.ColorSeparationRGBX = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CONSTANT: { + dst.Flags.Gpu.Constant = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__DEPTH: { + dst.Flags.Gpu.Depth = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN: { + dst.Flags.Gpu.FlipChain = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN_PREFERRED: { + dst.Flags.Gpu.FlipChainPreferred = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HISTORY_BUFFER: { + dst.Flags.Gpu.HistoryBuffer = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HI_Z: { + dst.Flags.Gpu.HiZ = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDEX: { + dst.Flags.Gpu.Index = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDIRECT_CLEAR_COLOR: { + dst.Flags.Gpu.IndirectClearColor = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INSTRUCTION_FLAT: { + dst.Flags.Gpu.InstructionFlat = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INTERLACED_SCAN: { + dst.Flags.Gpu.InterlacedScan = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MCS: { + dst.Flags.Gpu.MCS = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MMC: { + dst.Flags.Gpu.MMC = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MOTION_COMP: { + dst.Flags.Gpu.MotionComp = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__NO_RESTRICTION: { + dst.Flags.Gpu.NoRestriction = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__OVERLAY: { + dst.Flags.Gpu.Overlay = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PRESENTABLE: { + dst.Flags.Gpu.Presentable = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PROCEDURAL_TEXTURE: { + dst.Flags.Gpu.ProceduralTexture = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__QUERY: { + dst.Flags.Gpu.Query = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__RENDER_TARGET: { + dst.Flags.Gpu.RenderTarget = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D: { + dst.Flags.Gpu.S3d = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D_DX: { + dst.Flags.Gpu.S3dDx = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_NON_PACKED: { + dst.Flags.Gpu.__S3dNonPacked = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_WIDI: { + dst.Flags.Gpu.__S3dWidi = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SCRATCH_FLAT: { + dst.Flags.Gpu.ScratchFlat = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SEPARATE_STENCIL: { + dst.Flags.Gpu.SeparateStencil = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE: { + dst.Flags.Gpu.State = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE_DX9CONSTANT_BUFFER: { + dst.Flags.Gpu.StateDx9ConstantBuffer = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STREAM: { + dst.Flags.Gpu.Stream = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXT_API: { + dst.Flags.Gpu.TextApi = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXTURE: { + dst.Flags.Gpu.Texture = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILED_RESOURCE: { + dst.Flags.Gpu.TiledResource = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILE_POOL: { + dst.Flags.Gpu.TilePool = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__UNIFIED_AUX_SURFACE: { + dst.Flags.Gpu.UnifiedAuxSurface = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VERTEX: { + dst.Flags.Gpu.Vertex = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VIDEO: { + dst.Flags.Gpu.Video = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_XCCS: { + dst.Flags.Gpu.__NonMsaaTileXCcs = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_YCCS: { + dst.Flags.Gpu.__NonMsaaTileYCcs = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____MSAA_TILE_MCS: { + dst.Flags.Gpu.__MsaaTileMcs = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_LINEAR_CCS: { + dst.Flags.Gpu.__NonMsaaLinearCCS = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____REMAINING: { + dst.Flags.Gpu.__Remaining = readTokValue(*tokGpu); + } break; + }; + tokGpu = tokGpu + 1 + tokGpu->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokGpu); + if (tokGpu->flags.flag3IsMandatory) { + return false; + } + tokGpu = tokGpu + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokGpu == tokGpuEnd); + } break; + case TOK_FS_GMM_RESOURCE_FLAG_REC__INFO: { + const TokenHeader *tokInfo = varLen->getValue(); + const TokenHeader *tokInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokInfo < tokInfoEnd) { + if (false == tokInfo->flags.flag4IsVariableLength) { + switch (tokInfo->id) { + default: + if (tokInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ALLOW_VIRTUAL_PADDING: { + dst.Flags.Info.AllowVirtualPadding = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__BIG_PAGE: { + dst.Flags.Info.BigPage = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CACHEABLE: { + dst.Flags.Info.Cacheable = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CONTIG_PHYS_MEMORY_FORI_DART: { + dst.Flags.Info.ContigPhysMemoryForiDART = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CORNER_TEXEL_MODE: { + dst.Flags.Info.CornerTexelMode = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__EXISTING_SYS_MEM: { + dst.Flags.Info.ExistingSysMem = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__FORCE_RESIDENCY: { + dst.Flags.Info.ForceResidency = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GFDT: { + dst.Flags.Info.Gfdt = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GTT_MAP_TYPE: { + dst.Flags.Info.GttMapType = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__HARDWARE_PROTECTED: { + dst.Flags.Info.HardwareProtected = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__KERNEL_MODE_MAPPED: { + dst.Flags.Info.KernelModeMapped = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_BELOW: { + dst.Flags.Info.LayoutBelow = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_MONO: { + dst.Flags.Info.LayoutMono = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_RIGHT: { + dst.Flags.Info.LayoutRight = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LOCAL_ONLY: { + dst.Flags.Info.LocalOnly = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LINEAR: { + dst.Flags.Info.Linear = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__MEDIA_COMPRESSED: { + dst.Flags.Info.MediaCompressed = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_OPTIMIZATION_PADDING: { + dst.Flags.Info.NoOptimizationPadding = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_PHYS_MEMORY: { + dst.Flags.Info.NoPhysMemory = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NOT_LOCKABLE: { + dst.Flags.Info.NotLockable = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NON_LOCAL_ONLY: { + dst.Flags.Info.NonLocalOnly = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__STD_SWIZZLE: { + dst.Flags.Info.StdSwizzle = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__PSEUDO_STD_SWIZZLE: { + dst.Flags.Info.PseudoStdSwizzle = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__UNDEFINED64KBSWIZZLE: { + dst.Flags.Info.Undefined64KBSwizzle = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__REDECRIBED_PLANES: { + dst.Flags.Info.RedecribedPlanes = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__RENDER_COMPRESSED: { + dst.Flags.Info.RenderCompressed = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ROTATED: { + dst.Flags.Info.Rotated = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SHARED: { + dst.Flags.Info.Shared = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SOFTWARE_PROTECTED: { + dst.Flags.Info.SoftwareProtected = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SVM: { + dst.Flags.Info.SVM = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE4: { + dst.Flags.Info.Tile4 = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE64: { + dst.Flags.Info.Tile64 = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_W: { + dst.Flags.Info.TiledW = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_X: { + dst.Flags.Info.TiledX = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_Y: { + dst.Flags.Info.TiledY = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YF: { + dst.Flags.Info.TiledYf = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YS: { + dst.Flags.Info.TiledYs = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__WDDM_PROTECTED: { + dst.Flags.Info.WddmProtected = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__XADAPTER: { + dst.Flags.Info.XAdapter = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PREALLOCATED_RES_INFO: { + dst.Flags.Info.__PreallocatedResInfo = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PRE_WDDM2SVM: { + dst.Flags.Info.__PreWddm2SVM = readTokValue(*tokInfo); + } break; + }; + tokInfo = tokInfo + 1 + tokInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokInfo); + if (tokInfo->flags.flag3IsMandatory) { + return false; + } + tokInfo = tokInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokInfo == tokInfoEnd); + } break; + case TOK_FS_GMM_RESOURCE_FLAG_REC__WA: { + const TokenHeader *tokWa = varLen->getValue(); + const TokenHeader *tokWaEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokWa < tokWaEnd) { + if (false == tokWa->flags.flag4IsVariableLength) { + switch (tokWa->id) { + default: + if (tokWa->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__GTMFX2ND_LEVEL_BATCH_RING_SIZE_ALIGN: { + dst.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_MPR_ROW_STORE32KALIGN: { + dst.Flags.Wa.ILKNeedAvcMprRowStore32KAlign = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_DMV_BUFFER32KALIGN: { + dst.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_BUFFER_SAMPLER_PADDING: { + dst.Flags.Wa.NoBufferSamplerPadding = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_LEGACY_PLANAR_LINEAR_VIDEO_RESTRICTIONS: { + dst.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__CHVASTC_SKIP_VIRTUAL_MIPS: { + dst.Flags.Wa.CHVAstcSkipVirtualMips = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_PACKED_MIP_TAIL: { + dst.Flags.Wa.DisablePackedMipTail = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521____FORCE_OTHER_HVALIGN4: { + dst.Flags.Wa.__ForceOtherHVALIGN4 = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR: { + dst.Flags.Wa.DisableDisplayCcsClearColor = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION: { + dst.Flags.Wa.DisableDisplayCcsCompression = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: { + dst.Flags.Wa.PreGen12FastClearOnly = readTokValue(*tokWa); + } break; + }; + tokWa = tokWa + 1 + tokWa->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokWa); + if (tokWa->flags.flag3IsMandatory) { + return false; + } + tokWa = tokWa + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokWa == tokWaEnd); + } break; + }; + tokFlags = tokFlags + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokFlags == tokFlagsEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__CACHE_POLICY: { + const TokenHeader *tokCachePolicy = varLen->getValue(); + const TokenHeader *tokCachePolicyEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokCachePolicy < tokCachePolicyEnd) { + if (false == tokCachePolicy->flags.flag4IsVariableLength) { + switch (tokCachePolicy->id) { + default: + if (tokCachePolicy->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GMM_TEXTURE_INFO_REC__ANONYMOUS4927__USAGE: { + dst.CachePolicy.Usage = readTokValue(*tokCachePolicy); + } break; + }; + tokCachePolicy = tokCachePolicy + 1 + tokCachePolicy->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokCachePolicy); + if (tokCachePolicy->flags.flag3IsMandatory) { + return false; + } + tokCachePolicy = tokCachePolicy + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokCachePolicy == tokCachePolicyEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__MSAA: { + const TokenHeader *tokMSAA = varLen->getValue(); + const TokenHeader *tokMSAAEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokMSAA < tokMSAAEnd) { + if (false == tokMSAA->flags.flag4IsVariableLength) { + switch (tokMSAA->id) { + default: + if (tokMSAA->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GMM_RESOURCE_MSAA_INFO_REC__SAMPLE_PATTERN: { + dst.MSAA.SamplePattern = readTokValue(*tokMSAA); + } break; + case TOK_FBD_GMM_RESOURCE_MSAA_INFO_REC__NUM_SAMPLES: { + dst.MSAA.NumSamples = readTokValue(*tokMSAA); + } break; + }; + tokMSAA = tokMSAA + 1 + tokMSAA->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokMSAA); + if (tokMSAA->flags.flag3IsMandatory) { + return false; + } + tokMSAA = tokMSAA + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokMSAA == tokMSAAEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__ALIGNMENT: { + const TokenHeader *tokAlignment = varLen->getValue(); + const TokenHeader *tokAlignmentEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokAlignment < tokAlignmentEnd) { + if (false == tokAlignment->flags.flag4IsVariableLength) { + switch (tokAlignment->id) { + default: + if (tokAlignment->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBC_GMM_RESOURCE_ALIGNMENT_REC__ARRAY_SPACING_SINGLE_LOD: { + dst.Alignment.ArraySpacingSingleLod = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__BASE_ALIGNMENT: { + dst.Alignment.BaseAlignment = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__HALIGN: { + dst.Alignment.HAlign = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__VALIGN: { + dst.Alignment.VAlign = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__DALIGN: { + dst.Alignment.DAlign = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__MIP_TAIL_START_LOD: { + dst.Alignment.MipTailStartLod = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_START_LOD: { + dst.Alignment.PackedMipStartLod = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_WIDTH: { + dst.Alignment.PackedMipWidth = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_HEIGHT: { + dst.Alignment.PackedMipHeight = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__QPITCH: { + dst.Alignment.QPitch = readTokValue(*tokAlignment); + } break; + }; + tokAlignment = tokAlignment + 1 + tokAlignment->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokAlignment); + if (tokAlignment->flags.flag3IsMandatory) { + return false; + } + tokAlignment = tokAlignment + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokAlignment == tokAlignmentEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__OFFSET_INFO: { + const TokenHeader *tokOffsetInfo = varLen->getValue(); + const TokenHeader *tokOffsetInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokOffsetInfo < tokOffsetInfoEnd) { + if (false == tokOffsetInfo->flags.flag4IsVariableLength) { + if (tokOffsetInfo->flags.flag3IsMandatory) { + return false; + } + tokOffsetInfo = tokOffsetInfo + 1 + tokOffsetInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokOffsetInfo); + switch (tokOffsetInfo->id) { + default: + if (tokOffsetInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO: { + const TokenHeader *tokTexture3DOffsetInfo = varLen->getValue(); + const TokenHeader *tokTexture3DOffsetInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokTexture3DOffsetInfo < tokTexture3DOffsetInfoEnd) { + if (false == tokTexture3DOffsetInfo->flags.flag4IsVariableLength) { + switch (tokTexture3DOffsetInfo->id) { + default: + if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: { + dst.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch = readTokValue(*tokTexture3DOffsetInfo); + } break; + case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: { + auto srcData = reinterpret_cast &>(*tokTexture3DOffsetInfo).getValue(); + auto srcSize = reinterpret_cast &>(*tokTexture3DOffsetInfo).getValueSizeInBytes(); + if (srcSize < sizeof(dst.OffsetInfo.Texture3DOffsetInfo.Offset)) { + return false; + } + WCH_SAFE_COPY(dst.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(dst.OffsetInfo.Texture3DOffsetInfo.Offset), srcData, sizeof(dst.OffsetInfo.Texture3DOffsetInfo.Offset)); + } break; + }; + tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + 1 + tokTexture3DOffsetInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokTexture3DOffsetInfo); + if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokTexture3DOffsetInfo == tokTexture3DOffsetInfoEnd); + } break; + case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO: { + const TokenHeader *tokTexture2DOffsetInfo = varLen->getValue(); + const TokenHeader *tokTexture2DOffsetInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokTexture2DOffsetInfo < tokTexture2DOffsetInfoEnd) { + if (false == tokTexture2DOffsetInfo->flags.flag4IsVariableLength) { + switch (tokTexture2DOffsetInfo->id) { + default: + if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: { + dst.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock = readTokValue(*tokTexture2DOffsetInfo); + } break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: { + dst.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender = readTokValue(*tokTexture2DOffsetInfo); + } break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: { + auto srcData = reinterpret_cast &>(*tokTexture2DOffsetInfo).getValue(); + auto srcSize = reinterpret_cast &>(*tokTexture2DOffsetInfo).getValueSizeInBytes(); + if (srcSize < sizeof(dst.OffsetInfo.Texture2DOffsetInfo.Offset)) { + return false; + } + WCH_SAFE_COPY(dst.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(dst.OffsetInfo.Texture2DOffsetInfo.Offset), srcData, sizeof(dst.OffsetInfo.Texture2DOffsetInfo.Offset)); + } break; + }; + tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + 1 + tokTexture2DOffsetInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokTexture2DOffsetInfo); + if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokTexture2DOffsetInfo == tokTexture2DOffsetInfoEnd); + } break; + case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE: { + const TokenHeader *tokPlane = varLen->getValue(); + const TokenHeader *tokPlaneEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokPlane < tokPlaneEnd) { + if (false == tokPlane->flags.flag4IsVariableLength) { + switch (tokPlane->id) { + default: + if (tokPlane->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: { + dst.OffsetInfo.Plane.ArrayQPitch = readTokValue(*tokPlane); + } break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: { + auto srcData = reinterpret_cast &>(*tokPlane).getValue(); + auto srcSize = reinterpret_cast &>(*tokPlane).getValueSizeInBytes(); + if (srcSize < sizeof(dst.OffsetInfo.Plane.X)) { + return false; + } + WCH_SAFE_COPY(dst.OffsetInfo.Plane.X, sizeof(dst.OffsetInfo.Plane.X), srcData, sizeof(dst.OffsetInfo.Plane.X)); + } break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: { + auto srcData = reinterpret_cast &>(*tokPlane).getValue(); + auto srcSize = reinterpret_cast &>(*tokPlane).getValueSizeInBytes(); + if (srcSize < sizeof(dst.OffsetInfo.Plane.Y)) { + return false; + } + WCH_SAFE_COPY(dst.OffsetInfo.Plane.Y, sizeof(dst.OffsetInfo.Plane.Y), srcData, sizeof(dst.OffsetInfo.Plane.Y)); + } break; + case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: { + dst.OffsetInfo.Plane.NoOfPlanes = readTokValue(*tokPlane); + } break; + case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: { + dst.OffsetInfo.Plane.IsTileAlignedPlanes = readTokValue(*tokPlane); + } break; + }; + tokPlane = tokPlane + 1 + tokPlane->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokPlane); + switch (tokPlane->id) { + default: + if (tokPlane->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: { + const TokenHeader *tokUnAligned = varLen->getValue(); + const TokenHeader *tokUnAlignedEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokUnAligned < tokUnAlignedEnd) { + if (false == tokUnAligned->flags.flag4IsVariableLength) { + switch (tokUnAligned->id) { + default: + if (tokUnAligned->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: { + auto srcData = reinterpret_cast &>(*tokUnAligned).getValue(); + auto srcSize = reinterpret_cast &>(*tokUnAligned).getValueSizeInBytes(); + if (srcSize < sizeof(dst.OffsetInfo.Plane.UnAligned.Height)) { + return false; + } + WCH_SAFE_COPY(dst.OffsetInfo.Plane.UnAligned.Height, sizeof(dst.OffsetInfo.Plane.UnAligned.Height), srcData, sizeof(dst.OffsetInfo.Plane.UnAligned.Height)); + } break; + }; + tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokUnAligned); + if (tokUnAligned->flags.flag3IsMandatory) { + return false; + } + tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokUnAligned == tokUnAlignedEnd); + } break; + }; + tokPlane = tokPlane + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokPlane == tokPlaneEnd); + } break; + }; + tokOffsetInfo = tokOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokOffsetInfo == tokOffsetInfoEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__S3D: { + const TokenHeader *tokS3d = varLen->getValue(); + const TokenHeader *tokS3dEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokS3d < tokS3dEnd) { + if (false == tokS3d->flags.flag4IsVariableLength) { + switch (tokS3d->id) { + default: + if (tokS3d->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_S3D_INFO_REC__DISPLAY_MODE_HEIGHT: { + dst.S3d.DisplayModeHeight = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__NUM_BLANK_ACTIVE_LINES: { + dst.S3d.NumBlankActiveLines = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__RFRAME_OFFSET: { + dst.S3d.RFrameOffset = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__BLANK_AREA_OFFSET: { + dst.S3d.BlankAreaOffset = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_HEIGHT: { + dst.S3d.TallBufferHeight = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_SIZE: { + dst.S3d.TallBufferSize = readTokValue(*tokS3d); + } break; + case TOK_FBC_GMM_S3D_INFO_REC__IS_RFRAME: { + dst.S3d.IsRFrame = readTokValue(*tokS3d); + } break; + }; + tokS3d = tokS3d + 1 + tokS3d->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokS3d); + if (tokS3d->flags.flag3IsMandatory) { + return false; + } + tokS3d = tokS3d + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokS3d == tokS3dEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__SEGMENT_OVERRIDE: { + const TokenHeader *tokSegmentOverride = varLen->getValue(); + const TokenHeader *tokSegmentOverrideEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSegmentOverride < tokSegmentOverrideEnd) { + if (false == tokSegmentOverride->flags.flag4IsVariableLength) { + switch (tokSegmentOverride->id) { + default: + if (tokSegmentOverride->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__SEG1: { + dst.SegmentOverride.Seg1 = readTokValue(*tokSegmentOverride); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__EVICT: { + dst.SegmentOverride.Evict = readTokValue(*tokSegmentOverride); + } break; + }; + tokSegmentOverride = tokSegmentOverride + 1 + tokSegmentOverride->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSegmentOverride); + if (tokSegmentOverride->flags.flag3IsMandatory) { + return false; + } + tokSegmentOverride = tokSegmentOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSegmentOverride == tokSegmentOverrideEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__PLATFORM: { +#if _DEBUG || _RELEASE_INTERNAL + const TokenHeader *tokPlatform = varLen->getValue(); + const TokenHeader *tokPlatformEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokPlatform < tokPlatformEnd) { + if (false == tokPlatform->flags.flag4IsVariableLength) { + switch (tokPlatform->id) { + default: + if (tokPlatform->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { + dst.Platform.eProductFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { + dst.Platform.ePCHProductFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { + dst.Platform.eDisplayCoreFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { + dst.Platform.eRenderCoreFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { + dst.Platform.ePlatformType = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { + dst.Platform.usDeviceID = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID: { + dst.Platform.usRevId = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { + dst.Platform.usDeviceID_PCH = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { + dst.Platform.usRevId_PCH = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_GTTYPE: { + dst.Platform.eGTType = readTokValue(*tokPlatform); + } break; + }; + tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokPlatform); + if (tokPlatform->flags.flag3IsMandatory) { + return false; + } + tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokPlatform == tokPlatformEnd); +#endif + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__EXISTING_SYS_MEM: { + const TokenHeader *tokExistingSysMem = varLen->getValue(); + const TokenHeader *tokExistingSysMemEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokExistingSysMem < tokExistingSysMemEnd) { + if (false == tokExistingSysMem->flags.flag4IsVariableLength) { + switch (tokExistingSysMem->id) { + default: + if (tokExistingSysMem->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_GMM_ALLOCATED: { + dst.ExistingSysMem.IsGmmAllocated = readTokValue(*tokExistingSysMem); + } break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_PAGE_ALIGNED: { + dst.ExistingSysMem.IsPageAligned = readTokValue(*tokExistingSysMem); + } break; + }; + tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokExistingSysMem); + if (tokExistingSysMem->flags.flag3IsMandatory) { + return false; + } + tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: { +#if !(_DEBUG || _RELEASE_INTERNAL) + const TokenHeader *tok__Platform = varLen->getValue(); + const TokenHeader *tok__PlatformEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tok__Platform < tok__PlatformEnd) { + if (false == tok__Platform->flags.flag4IsVariableLength) { + switch (tok__Platform->id) { + default: + if (tok__Platform->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { + dst.__Platform.eProductFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { + dst.__Platform.ePCHProductFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { + dst.__Platform.eDisplayCoreFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { + dst.__Platform.eRenderCoreFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { + dst.__Platform.ePlatformType = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { + dst.__Platform.usDeviceID = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID: { + dst.__Platform.usRevId = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { + dst.__Platform.usDeviceID_PCH = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { + dst.__Platform.usRevId_PCH = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_GTTYPE: { + dst.__Platform.eGTType = readTokValue(*tok__Platform); + } break; + }; + tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok__Platform); + if (tok__Platform->flags.flag3IsMandatory) { + return false; + } + tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok__Platform == tok__PlatformEnd); +#endif + } break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(GMM_EXISTING_SYS_MEM_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_EXISTING_SYS_MEM: { + dst.pExistingSysMem = readTokValue(*tok); + } break; + case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_VIRT_ADDRESS: { + dst.pVirtAddress = readTokValue(*tok); + } break; + case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_GFX_ALIGNED_VIRT_ADDRESS: { + dst.pGfxAlignedVirtAddress = readTokValue(*tok); + } break; + case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__SIZE: { + dst.Size = readTokValue(*tok); + } break; + case TOK_FBC_GMM_EXISTING_SYS_MEM_REC__IS_GMM_ALLOCATED: { + dst.IsGmmAllocated = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GMM_EXISTING_SYS_MEM_REC: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(GmmResourceInfoCommonStructT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GMM_RESOURCE_INFO_COMMON_STRUCT__CLIENT_TYPE: { + dst.ClientType = readTokValue(*tok); + } break; + case TOK_FBD_GMM_RESOURCE_INFO_COMMON_STRUCT__ROTATE_INFO: { + dst.RotateInfo = readTokValue(*tok); + } break; + case TOK_FBQ_GMM_RESOURCE_INFO_COMMON_STRUCT__SVM_ADDRESS: { + dst.SvmAddress = readTokValue(*tok); + } break; + case TOK_FBQ_GMM_RESOURCE_INFO_COMMON_STRUCT__P_PRIVATE_DATA: { + dst.pPrivateData = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GMM_RESOURCE_INFO_COMMON_STRUCT: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__SURF: { + const TokenHeader *tokSurf = varLen->getValue(); + const TokenHeader *tokSurfEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSurf < tokSurfEnd) { + if (false == tokSurf->flags.flag4IsVariableLength) { + switch (tokSurf->id) { + default: + if (tokSurf->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GMM_TEXTURE_INFO_REC__TYPE: { + dst.Surf.Type = readTokValue(*tokSurf); + } break; + case TOK_FE_GMM_TEXTURE_INFO_REC__FORMAT: { + dst.Surf.Format = readTokValue(*tokSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__BITS_PER_PIXEL: { + dst.Surf.BitsPerPixel = readTokValue(*tokSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__BASE_WIDTH: { + dst.Surf.BaseWidth = readTokValue(*tokSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__BASE_HEIGHT: { + dst.Surf.BaseHeight = readTokValue(*tokSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__DEPTH: { + dst.Surf.Depth = readTokValue(*tokSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__MAX_LOD: { + dst.Surf.MaxLod = readTokValue(*tokSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__ARRAY_SIZE: { + dst.Surf.ArraySize = readTokValue(*tokSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__CP_TAG: { + dst.Surf.CpTag = readTokValue(*tokSurf); + } break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_MODE: { + auto srcData = reinterpret_cast &>(*tokSurf).getValue(); + auto srcSize = reinterpret_cast &>(*tokSurf).getValueSizeInBytes(); + if (srcSize < sizeof(dst.Surf.MmcMode)) { + return false; + } + WCH_SAFE_COPY(dst.Surf.MmcMode, sizeof(dst.Surf.MmcMode), srcData, sizeof(dst.Surf.MmcMode)); + } break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_HINT: { + auto srcData = reinterpret_cast &>(*tokSurf).getValue(); + auto srcSize = reinterpret_cast &>(*tokSurf).getValueSizeInBytes(); + if (srcSize < sizeof(dst.Surf.MmcHint)) { + return false; + } + WCH_SAFE_COPY(dst.Surf.MmcHint, sizeof(dst.Surf.MmcHint), srcData, sizeof(dst.Surf.MmcHint)); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__PITCH: { + dst.Surf.Pitch = readTokValue(*tokSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__OVERRIDE_PITCH: { + dst.Surf.OverridePitch = readTokValue(*tokSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE: { + dst.Surf.Size = readTokValue(*tokSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__CCSIZE: { + dst.Surf.CCSize = readTokValue(*tokSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__UNPADDED_SIZE: { + dst.Surf.UnpaddedSize = readTokValue(*tokSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE_REPORT_TO_OS: { + dst.Surf.SizeReportToOS = readTokValue(*tokSurf); + } break; + case TOK_FE_GMM_TEXTURE_INFO_REC__TILE_MODE: { + dst.Surf.TileMode = readTokValue(*tokSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__CCSMODE_ALIGN: { + dst.Surf.CCSModeAlign = readTokValue(*tokSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__LEGACY_FLAGS: { + dst.Surf.LegacyFlags = readTokValue(*tokSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__MAXIMUM_RENAMING_LIST_LENGTH: { + dst.Surf.MaximumRenamingListLength = readTokValue(*tokSurf); + } break; + }; + tokSurf = tokSurf + 1 + tokSurf->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSurf); + switch (tokSurf->id) { + default: + if (tokSurf->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_TEXTURE_INFO_REC__FLAGS: { + const TokenHeader *tokFlags = varLen->getValue(); + const TokenHeader *tokFlagsEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokFlags < tokFlagsEnd) { + if (false == tokFlags->flags.flag4IsVariableLength) { + if (tokFlags->flags.flag3IsMandatory) { + return false; + } + tokFlags = tokFlags + 1 + tokFlags->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokFlags); + switch (tokFlags->id) { + default: + if (tokFlags->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_RESOURCE_FLAG_REC__GPU: { + const TokenHeader *tokGpu = varLen->getValue(); + const TokenHeader *tokGpuEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokGpu < tokGpuEnd) { + if (false == tokGpu->flags.flag4IsVariableLength) { + switch (tokGpu->id) { + default: + if (tokGpu->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CAMERA_CAPTURE: { + dst.Surf.Flags.Gpu.CameraCapture = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CCS: { + dst.Surf.Flags.Gpu.CCS = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_DISCARD: { + dst.Surf.Flags.Gpu.ColorDiscard = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION: { + dst.Surf.Flags.Gpu.ColorSeparation = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION_RGBX: { + dst.Surf.Flags.Gpu.ColorSeparationRGBX = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CONSTANT: { + dst.Surf.Flags.Gpu.Constant = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__DEPTH: { + dst.Surf.Flags.Gpu.Depth = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN: { + dst.Surf.Flags.Gpu.FlipChain = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN_PREFERRED: { + dst.Surf.Flags.Gpu.FlipChainPreferred = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HISTORY_BUFFER: { + dst.Surf.Flags.Gpu.HistoryBuffer = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HI_Z: { + dst.Surf.Flags.Gpu.HiZ = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDEX: { + dst.Surf.Flags.Gpu.Index = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDIRECT_CLEAR_COLOR: { + dst.Surf.Flags.Gpu.IndirectClearColor = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INSTRUCTION_FLAT: { + dst.Surf.Flags.Gpu.InstructionFlat = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INTERLACED_SCAN: { + dst.Surf.Flags.Gpu.InterlacedScan = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MCS: { + dst.Surf.Flags.Gpu.MCS = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MMC: { + dst.Surf.Flags.Gpu.MMC = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MOTION_COMP: { + dst.Surf.Flags.Gpu.MotionComp = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__NO_RESTRICTION: { + dst.Surf.Flags.Gpu.NoRestriction = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__OVERLAY: { + dst.Surf.Flags.Gpu.Overlay = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PRESENTABLE: { + dst.Surf.Flags.Gpu.Presentable = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PROCEDURAL_TEXTURE: { + dst.Surf.Flags.Gpu.ProceduralTexture = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__QUERY: { + dst.Surf.Flags.Gpu.Query = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__RENDER_TARGET: { + dst.Surf.Flags.Gpu.RenderTarget = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D: { + dst.Surf.Flags.Gpu.S3d = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D_DX: { + dst.Surf.Flags.Gpu.S3dDx = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_NON_PACKED: { + dst.Surf.Flags.Gpu.__S3dNonPacked = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_WIDI: { + dst.Surf.Flags.Gpu.__S3dWidi = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SCRATCH_FLAT: { + dst.Surf.Flags.Gpu.ScratchFlat = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SEPARATE_STENCIL: { + dst.Surf.Flags.Gpu.SeparateStencil = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE: { + dst.Surf.Flags.Gpu.State = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE_DX9CONSTANT_BUFFER: { + dst.Surf.Flags.Gpu.StateDx9ConstantBuffer = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STREAM: { + dst.Surf.Flags.Gpu.Stream = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXT_API: { + dst.Surf.Flags.Gpu.TextApi = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXTURE: { + dst.Surf.Flags.Gpu.Texture = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILED_RESOURCE: { + dst.Surf.Flags.Gpu.TiledResource = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILE_POOL: { + dst.Surf.Flags.Gpu.TilePool = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__UNIFIED_AUX_SURFACE: { + dst.Surf.Flags.Gpu.UnifiedAuxSurface = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VERTEX: { + dst.Surf.Flags.Gpu.Vertex = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VIDEO: { + dst.Surf.Flags.Gpu.Video = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_XCCS: { + dst.Surf.Flags.Gpu.__NonMsaaTileXCcs = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_YCCS: { + dst.Surf.Flags.Gpu.__NonMsaaTileYCcs = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____MSAA_TILE_MCS: { + dst.Surf.Flags.Gpu.__MsaaTileMcs = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_LINEAR_CCS: { + dst.Surf.Flags.Gpu.__NonMsaaLinearCCS = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____REMAINING: { + dst.Surf.Flags.Gpu.__Remaining = readTokValue(*tokGpu); + } break; + }; + tokGpu = tokGpu + 1 + tokGpu->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokGpu); + if (tokGpu->flags.flag3IsMandatory) { + return false; + } + tokGpu = tokGpu + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokGpu == tokGpuEnd); + } break; + case TOK_FS_GMM_RESOURCE_FLAG_REC__INFO: { + const TokenHeader *tokInfo = varLen->getValue(); + const TokenHeader *tokInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokInfo < tokInfoEnd) { + if (false == tokInfo->flags.flag4IsVariableLength) { + switch (tokInfo->id) { + default: + if (tokInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ALLOW_VIRTUAL_PADDING: { + dst.Surf.Flags.Info.AllowVirtualPadding = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__BIG_PAGE: { + dst.Surf.Flags.Info.BigPage = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CACHEABLE: { + dst.Surf.Flags.Info.Cacheable = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CONTIG_PHYS_MEMORY_FORI_DART: { + dst.Surf.Flags.Info.ContigPhysMemoryForiDART = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CORNER_TEXEL_MODE: { + dst.Surf.Flags.Info.CornerTexelMode = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__EXISTING_SYS_MEM: { + dst.Surf.Flags.Info.ExistingSysMem = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__FORCE_RESIDENCY: { + dst.Surf.Flags.Info.ForceResidency = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GFDT: { + dst.Surf.Flags.Info.Gfdt = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GTT_MAP_TYPE: { + dst.Surf.Flags.Info.GttMapType = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__HARDWARE_PROTECTED: { + dst.Surf.Flags.Info.HardwareProtected = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__KERNEL_MODE_MAPPED: { + dst.Surf.Flags.Info.KernelModeMapped = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_BELOW: { + dst.Surf.Flags.Info.LayoutBelow = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_MONO: { + dst.Surf.Flags.Info.LayoutMono = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_RIGHT: { + dst.Surf.Flags.Info.LayoutRight = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LOCAL_ONLY: { + dst.Surf.Flags.Info.LocalOnly = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LINEAR: { + dst.Surf.Flags.Info.Linear = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__MEDIA_COMPRESSED: { + dst.Surf.Flags.Info.MediaCompressed = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_OPTIMIZATION_PADDING: { + dst.Surf.Flags.Info.NoOptimizationPadding = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_PHYS_MEMORY: { + dst.Surf.Flags.Info.NoPhysMemory = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NOT_LOCKABLE: { + dst.Surf.Flags.Info.NotLockable = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NON_LOCAL_ONLY: { + dst.Surf.Flags.Info.NonLocalOnly = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__STD_SWIZZLE: { + dst.Surf.Flags.Info.StdSwizzle = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__PSEUDO_STD_SWIZZLE: { + dst.Surf.Flags.Info.PseudoStdSwizzle = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__UNDEFINED64KBSWIZZLE: { + dst.Surf.Flags.Info.Undefined64KBSwizzle = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__REDECRIBED_PLANES: { + dst.Surf.Flags.Info.RedecribedPlanes = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__RENDER_COMPRESSED: { + dst.Surf.Flags.Info.RenderCompressed = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ROTATED: { + dst.Surf.Flags.Info.Rotated = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SHARED: { + dst.Surf.Flags.Info.Shared = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SOFTWARE_PROTECTED: { + dst.Surf.Flags.Info.SoftwareProtected = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SVM: { + dst.Surf.Flags.Info.SVM = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE4: { + dst.Surf.Flags.Info.Tile4 = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE64: { + dst.Surf.Flags.Info.Tile64 = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_W: { + dst.Surf.Flags.Info.TiledW = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_X: { + dst.Surf.Flags.Info.TiledX = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_Y: { + dst.Surf.Flags.Info.TiledY = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YF: { + dst.Surf.Flags.Info.TiledYf = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YS: { + dst.Surf.Flags.Info.TiledYs = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__WDDM_PROTECTED: { + dst.Surf.Flags.Info.WddmProtected = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__XADAPTER: { + dst.Surf.Flags.Info.XAdapter = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PREALLOCATED_RES_INFO: { + dst.Surf.Flags.Info.__PreallocatedResInfo = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PRE_WDDM2SVM: { + dst.Surf.Flags.Info.__PreWddm2SVM = readTokValue(*tokInfo); + } break; + }; + tokInfo = tokInfo + 1 + tokInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokInfo); + if (tokInfo->flags.flag3IsMandatory) { + return false; + } + tokInfo = tokInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokInfo == tokInfoEnd); + } break; + case TOK_FS_GMM_RESOURCE_FLAG_REC__WA: { + const TokenHeader *tokWa = varLen->getValue(); + const TokenHeader *tokWaEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokWa < tokWaEnd) { + if (false == tokWa->flags.flag4IsVariableLength) { + switch (tokWa->id) { + default: + if (tokWa->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__GTMFX2ND_LEVEL_BATCH_RING_SIZE_ALIGN: { + dst.Surf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_MPR_ROW_STORE32KALIGN: { + dst.Surf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_DMV_BUFFER32KALIGN: { + dst.Surf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_BUFFER_SAMPLER_PADDING: { + dst.Surf.Flags.Wa.NoBufferSamplerPadding = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_LEGACY_PLANAR_LINEAR_VIDEO_RESTRICTIONS: { + dst.Surf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__CHVASTC_SKIP_VIRTUAL_MIPS: { + dst.Surf.Flags.Wa.CHVAstcSkipVirtualMips = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_PACKED_MIP_TAIL: { + dst.Surf.Flags.Wa.DisablePackedMipTail = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521____FORCE_OTHER_HVALIGN4: { + dst.Surf.Flags.Wa.__ForceOtherHVALIGN4 = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR: { + dst.Surf.Flags.Wa.DisableDisplayCcsClearColor = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION: { + dst.Surf.Flags.Wa.DisableDisplayCcsCompression = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: { + dst.Surf.Flags.Wa.PreGen12FastClearOnly = readTokValue(*tokWa); + } break; + }; + tokWa = tokWa + 1 + tokWa->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokWa); + if (tokWa->flags.flag3IsMandatory) { + return false; + } + tokWa = tokWa + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokWa == tokWaEnd); + } break; + }; + tokFlags = tokFlags + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokFlags == tokFlagsEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__CACHE_POLICY: { + const TokenHeader *tokCachePolicy = varLen->getValue(); + const TokenHeader *tokCachePolicyEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokCachePolicy < tokCachePolicyEnd) { + if (false == tokCachePolicy->flags.flag4IsVariableLength) { + switch (tokCachePolicy->id) { + default: + if (tokCachePolicy->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GMM_TEXTURE_INFO_REC__ANONYMOUS4927__USAGE: { + dst.Surf.CachePolicy.Usage = readTokValue(*tokCachePolicy); + } break; + }; + tokCachePolicy = tokCachePolicy + 1 + tokCachePolicy->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokCachePolicy); + if (tokCachePolicy->flags.flag3IsMandatory) { + return false; + } + tokCachePolicy = tokCachePolicy + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokCachePolicy == tokCachePolicyEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__MSAA: { + const TokenHeader *tokMSAA = varLen->getValue(); + const TokenHeader *tokMSAAEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokMSAA < tokMSAAEnd) { + if (false == tokMSAA->flags.flag4IsVariableLength) { + switch (tokMSAA->id) { + default: + if (tokMSAA->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GMM_RESOURCE_MSAA_INFO_REC__SAMPLE_PATTERN: { + dst.Surf.MSAA.SamplePattern = readTokValue(*tokMSAA); + } break; + case TOK_FBD_GMM_RESOURCE_MSAA_INFO_REC__NUM_SAMPLES: { + dst.Surf.MSAA.NumSamples = readTokValue(*tokMSAA); + } break; + }; + tokMSAA = tokMSAA + 1 + tokMSAA->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokMSAA); + if (tokMSAA->flags.flag3IsMandatory) { + return false; + } + tokMSAA = tokMSAA + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokMSAA == tokMSAAEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__ALIGNMENT: { + const TokenHeader *tokAlignment = varLen->getValue(); + const TokenHeader *tokAlignmentEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokAlignment < tokAlignmentEnd) { + if (false == tokAlignment->flags.flag4IsVariableLength) { + switch (tokAlignment->id) { + default: + if (tokAlignment->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBC_GMM_RESOURCE_ALIGNMENT_REC__ARRAY_SPACING_SINGLE_LOD: { + dst.Surf.Alignment.ArraySpacingSingleLod = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__BASE_ALIGNMENT: { + dst.Surf.Alignment.BaseAlignment = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__HALIGN: { + dst.Surf.Alignment.HAlign = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__VALIGN: { + dst.Surf.Alignment.VAlign = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__DALIGN: { + dst.Surf.Alignment.DAlign = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__MIP_TAIL_START_LOD: { + dst.Surf.Alignment.MipTailStartLod = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_START_LOD: { + dst.Surf.Alignment.PackedMipStartLod = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_WIDTH: { + dst.Surf.Alignment.PackedMipWidth = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_HEIGHT: { + dst.Surf.Alignment.PackedMipHeight = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__QPITCH: { + dst.Surf.Alignment.QPitch = readTokValue(*tokAlignment); + } break; + }; + tokAlignment = tokAlignment + 1 + tokAlignment->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokAlignment); + if (tokAlignment->flags.flag3IsMandatory) { + return false; + } + tokAlignment = tokAlignment + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokAlignment == tokAlignmentEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__OFFSET_INFO: { + const TokenHeader *tokOffsetInfo = varLen->getValue(); + const TokenHeader *tokOffsetInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokOffsetInfo < tokOffsetInfoEnd) { + if (false == tokOffsetInfo->flags.flag4IsVariableLength) { + if (tokOffsetInfo->flags.flag3IsMandatory) { + return false; + } + tokOffsetInfo = tokOffsetInfo + 1 + tokOffsetInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokOffsetInfo); + switch (tokOffsetInfo->id) { + default: + if (tokOffsetInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO: { + const TokenHeader *tokTexture3DOffsetInfo = varLen->getValue(); + const TokenHeader *tokTexture3DOffsetInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokTexture3DOffsetInfo < tokTexture3DOffsetInfoEnd) { + if (false == tokTexture3DOffsetInfo->flags.flag4IsVariableLength) { + switch (tokTexture3DOffsetInfo->id) { + default: + if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: { + dst.Surf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch = readTokValue(*tokTexture3DOffsetInfo); + } break; + case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: { + auto srcData = reinterpret_cast &>(*tokTexture3DOffsetInfo).getValue(); + auto srcSize = reinterpret_cast &>(*tokTexture3DOffsetInfo).getValueSizeInBytes(); + if (srcSize < sizeof(dst.Surf.OffsetInfo.Texture3DOffsetInfo.Offset)) { + return false; + } + WCH_SAFE_COPY(dst.Surf.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(dst.Surf.OffsetInfo.Texture3DOffsetInfo.Offset), srcData, sizeof(dst.Surf.OffsetInfo.Texture3DOffsetInfo.Offset)); + } break; + }; + tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + 1 + tokTexture3DOffsetInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokTexture3DOffsetInfo); + if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokTexture3DOffsetInfo == tokTexture3DOffsetInfoEnd); + } break; + case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO: { + const TokenHeader *tokTexture2DOffsetInfo = varLen->getValue(); + const TokenHeader *tokTexture2DOffsetInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokTexture2DOffsetInfo < tokTexture2DOffsetInfoEnd) { + if (false == tokTexture2DOffsetInfo->flags.flag4IsVariableLength) { + switch (tokTexture2DOffsetInfo->id) { + default: + if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: { + dst.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock = readTokValue(*tokTexture2DOffsetInfo); + } break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: { + dst.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender = readTokValue(*tokTexture2DOffsetInfo); + } break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: { + auto srcData = reinterpret_cast &>(*tokTexture2DOffsetInfo).getValue(); + auto srcSize = reinterpret_cast &>(*tokTexture2DOffsetInfo).getValueSizeInBytes(); + if (srcSize < sizeof(dst.Surf.OffsetInfo.Texture2DOffsetInfo.Offset)) { + return false; + } + WCH_SAFE_COPY(dst.Surf.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(dst.Surf.OffsetInfo.Texture2DOffsetInfo.Offset), srcData, sizeof(dst.Surf.OffsetInfo.Texture2DOffsetInfo.Offset)); + } break; + }; + tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + 1 + tokTexture2DOffsetInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokTexture2DOffsetInfo); + if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokTexture2DOffsetInfo == tokTexture2DOffsetInfoEnd); + } break; + case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE: { + const TokenHeader *tokPlane = varLen->getValue(); + const TokenHeader *tokPlaneEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokPlane < tokPlaneEnd) { + if (false == tokPlane->flags.flag4IsVariableLength) { + switch (tokPlane->id) { + default: + if (tokPlane->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: { + dst.Surf.OffsetInfo.Plane.ArrayQPitch = readTokValue(*tokPlane); + } break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: { + auto srcData = reinterpret_cast &>(*tokPlane).getValue(); + auto srcSize = reinterpret_cast &>(*tokPlane).getValueSizeInBytes(); + if (srcSize < sizeof(dst.Surf.OffsetInfo.Plane.X)) { + return false; + } + WCH_SAFE_COPY(dst.Surf.OffsetInfo.Plane.X, sizeof(dst.Surf.OffsetInfo.Plane.X), srcData, sizeof(dst.Surf.OffsetInfo.Plane.X)); + } break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: { + auto srcData = reinterpret_cast &>(*tokPlane).getValue(); + auto srcSize = reinterpret_cast &>(*tokPlane).getValueSizeInBytes(); + if (srcSize < sizeof(dst.Surf.OffsetInfo.Plane.Y)) { + return false; + } + WCH_SAFE_COPY(dst.Surf.OffsetInfo.Plane.Y, sizeof(dst.Surf.OffsetInfo.Plane.Y), srcData, sizeof(dst.Surf.OffsetInfo.Plane.Y)); + } break; + case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: { + dst.Surf.OffsetInfo.Plane.NoOfPlanes = readTokValue(*tokPlane); + } break; + case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: { + dst.Surf.OffsetInfo.Plane.IsTileAlignedPlanes = readTokValue(*tokPlane); + } break; + }; + tokPlane = tokPlane + 1 + tokPlane->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokPlane); + switch (tokPlane->id) { + default: + if (tokPlane->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: { + const TokenHeader *tokUnAligned = varLen->getValue(); + const TokenHeader *tokUnAlignedEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokUnAligned < tokUnAlignedEnd) { + if (false == tokUnAligned->flags.flag4IsVariableLength) { + switch (tokUnAligned->id) { + default: + if (tokUnAligned->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: { + auto srcData = reinterpret_cast &>(*tokUnAligned).getValue(); + auto srcSize = reinterpret_cast &>(*tokUnAligned).getValueSizeInBytes(); + if (srcSize < sizeof(dst.Surf.OffsetInfo.Plane.UnAligned.Height)) { + return false; + } + WCH_SAFE_COPY(dst.Surf.OffsetInfo.Plane.UnAligned.Height, sizeof(dst.Surf.OffsetInfo.Plane.UnAligned.Height), srcData, sizeof(dst.Surf.OffsetInfo.Plane.UnAligned.Height)); + } break; + }; + tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokUnAligned); + if (tokUnAligned->flags.flag3IsMandatory) { + return false; + } + tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokUnAligned == tokUnAlignedEnd); + } break; + }; + tokPlane = tokPlane + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokPlane == tokPlaneEnd); + } break; + }; + tokOffsetInfo = tokOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokOffsetInfo == tokOffsetInfoEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__S3D: { + const TokenHeader *tokS3d = varLen->getValue(); + const TokenHeader *tokS3dEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokS3d < tokS3dEnd) { + if (false == tokS3d->flags.flag4IsVariableLength) { + switch (tokS3d->id) { + default: + if (tokS3d->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_S3D_INFO_REC__DISPLAY_MODE_HEIGHT: { + dst.Surf.S3d.DisplayModeHeight = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__NUM_BLANK_ACTIVE_LINES: { + dst.Surf.S3d.NumBlankActiveLines = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__RFRAME_OFFSET: { + dst.Surf.S3d.RFrameOffset = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__BLANK_AREA_OFFSET: { + dst.Surf.S3d.BlankAreaOffset = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_HEIGHT: { + dst.Surf.S3d.TallBufferHeight = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_SIZE: { + dst.Surf.S3d.TallBufferSize = readTokValue(*tokS3d); + } break; + case TOK_FBC_GMM_S3D_INFO_REC__IS_RFRAME: { + dst.Surf.S3d.IsRFrame = readTokValue(*tokS3d); + } break; + }; + tokS3d = tokS3d + 1 + tokS3d->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokS3d); + if (tokS3d->flags.flag3IsMandatory) { + return false; + } + tokS3d = tokS3d + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokS3d == tokS3dEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__SEGMENT_OVERRIDE: { + const TokenHeader *tokSegmentOverride = varLen->getValue(); + const TokenHeader *tokSegmentOverrideEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSegmentOverride < tokSegmentOverrideEnd) { + if (false == tokSegmentOverride->flags.flag4IsVariableLength) { + switch (tokSegmentOverride->id) { + default: + if (tokSegmentOverride->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__SEG1: { + dst.Surf.SegmentOverride.Seg1 = readTokValue(*tokSegmentOverride); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__EVICT: { + dst.Surf.SegmentOverride.Evict = readTokValue(*tokSegmentOverride); + } break; + }; + tokSegmentOverride = tokSegmentOverride + 1 + tokSegmentOverride->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSegmentOverride); + if (tokSegmentOverride->flags.flag3IsMandatory) { + return false; + } + tokSegmentOverride = tokSegmentOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSegmentOverride == tokSegmentOverrideEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__PLATFORM: { +#if _DEBUG || _RELEASE_INTERNAL + const TokenHeader *tokPlatform = varLen->getValue(); + const TokenHeader *tokPlatformEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokPlatform < tokPlatformEnd) { + if (false == tokPlatform->flags.flag4IsVariableLength) { + switch (tokPlatform->id) { + default: + if (tokPlatform->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { + dst.Surf.Platform.eProductFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { + dst.Surf.Platform.ePCHProductFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { + dst.Surf.Platform.eDisplayCoreFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { + dst.Surf.Platform.eRenderCoreFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { + dst.Surf.Platform.ePlatformType = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { + dst.Surf.Platform.usDeviceID = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID: { + dst.Surf.Platform.usRevId = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { + dst.Surf.Platform.usDeviceID_PCH = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { + dst.Surf.Platform.usRevId_PCH = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_GTTYPE: { + dst.Surf.Platform.eGTType = readTokValue(*tokPlatform); + } break; + }; + tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokPlatform); + if (tokPlatform->flags.flag3IsMandatory) { + return false; + } + tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokPlatform == tokPlatformEnd); +#endif + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__EXISTING_SYS_MEM: { + const TokenHeader *tokExistingSysMem = varLen->getValue(); + const TokenHeader *tokExistingSysMemEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokExistingSysMem < tokExistingSysMemEnd) { + if (false == tokExistingSysMem->flags.flag4IsVariableLength) { + switch (tokExistingSysMem->id) { + default: + if (tokExistingSysMem->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_GMM_ALLOCATED: { + dst.Surf.ExistingSysMem.IsGmmAllocated = readTokValue(*tokExistingSysMem); + } break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_PAGE_ALIGNED: { + dst.Surf.ExistingSysMem.IsPageAligned = readTokValue(*tokExistingSysMem); + } break; + }; + tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokExistingSysMem); + if (tokExistingSysMem->flags.flag3IsMandatory) { + return false; + } + tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: { +#if !(_DEBUG || _RELEASE_INTERNAL) + const TokenHeader *tok__Platform = varLen->getValue(); + const TokenHeader *tok__PlatformEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tok__Platform < tok__PlatformEnd) { + if (false == tok__Platform->flags.flag4IsVariableLength) { + switch (tok__Platform->id) { + default: + if (tok__Platform->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { + dst.Surf.__Platform.eProductFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { + dst.Surf.__Platform.ePCHProductFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { + dst.Surf.__Platform.eDisplayCoreFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { + dst.Surf.__Platform.eRenderCoreFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { + dst.Surf.__Platform.ePlatformType = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { + dst.Surf.__Platform.usDeviceID = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID: { + dst.Surf.__Platform.usRevId = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { + dst.Surf.__Platform.usDeviceID_PCH = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { + dst.Surf.__Platform.usRevId_PCH = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_GTTYPE: { + dst.Surf.__Platform.eGTType = readTokValue(*tok__Platform); + } break; + }; + tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok__Platform); + if (tok__Platform->flags.flag3IsMandatory) { + return false; + } + tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok__Platform == tok__PlatformEnd); +#endif + } break; + }; + tokSurf = tokSurf + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSurf == tokSurfEnd); + } break; + case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__AUX_SURF: { + const TokenHeader *tokAuxSurf = varLen->getValue(); + const TokenHeader *tokAuxSurfEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokAuxSurf < tokAuxSurfEnd) { + if (false == tokAuxSurf->flags.flag4IsVariableLength) { + switch (tokAuxSurf->id) { + default: + if (tokAuxSurf->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GMM_TEXTURE_INFO_REC__TYPE: { + dst.AuxSurf.Type = readTokValue(*tokAuxSurf); + } break; + case TOK_FE_GMM_TEXTURE_INFO_REC__FORMAT: { + dst.AuxSurf.Format = readTokValue(*tokAuxSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__BITS_PER_PIXEL: { + dst.AuxSurf.BitsPerPixel = readTokValue(*tokAuxSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__BASE_WIDTH: { + dst.AuxSurf.BaseWidth = readTokValue(*tokAuxSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__BASE_HEIGHT: { + dst.AuxSurf.BaseHeight = readTokValue(*tokAuxSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__DEPTH: { + dst.AuxSurf.Depth = readTokValue(*tokAuxSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__MAX_LOD: { + dst.AuxSurf.MaxLod = readTokValue(*tokAuxSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__ARRAY_SIZE: { + dst.AuxSurf.ArraySize = readTokValue(*tokAuxSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__CP_TAG: { + dst.AuxSurf.CpTag = readTokValue(*tokAuxSurf); + } break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_MODE: { + auto srcData = reinterpret_cast &>(*tokAuxSurf).getValue(); + auto srcSize = reinterpret_cast &>(*tokAuxSurf).getValueSizeInBytes(); + if (srcSize < sizeof(dst.AuxSurf.MmcMode)) { + return false; + } + WCH_SAFE_COPY(dst.AuxSurf.MmcMode, sizeof(dst.AuxSurf.MmcMode), srcData, sizeof(dst.AuxSurf.MmcMode)); + } break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_HINT: { + auto srcData = reinterpret_cast &>(*tokAuxSurf).getValue(); + auto srcSize = reinterpret_cast &>(*tokAuxSurf).getValueSizeInBytes(); + if (srcSize < sizeof(dst.AuxSurf.MmcHint)) { + return false; + } + WCH_SAFE_COPY(dst.AuxSurf.MmcHint, sizeof(dst.AuxSurf.MmcHint), srcData, sizeof(dst.AuxSurf.MmcHint)); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__PITCH: { + dst.AuxSurf.Pitch = readTokValue(*tokAuxSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__OVERRIDE_PITCH: { + dst.AuxSurf.OverridePitch = readTokValue(*tokAuxSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE: { + dst.AuxSurf.Size = readTokValue(*tokAuxSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__CCSIZE: { + dst.AuxSurf.CCSize = readTokValue(*tokAuxSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__UNPADDED_SIZE: { + dst.AuxSurf.UnpaddedSize = readTokValue(*tokAuxSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE_REPORT_TO_OS: { + dst.AuxSurf.SizeReportToOS = readTokValue(*tokAuxSurf); + } break; + case TOK_FE_GMM_TEXTURE_INFO_REC__TILE_MODE: { + dst.AuxSurf.TileMode = readTokValue(*tokAuxSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__CCSMODE_ALIGN: { + dst.AuxSurf.CCSModeAlign = readTokValue(*tokAuxSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__LEGACY_FLAGS: { + dst.AuxSurf.LegacyFlags = readTokValue(*tokAuxSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__MAXIMUM_RENAMING_LIST_LENGTH: { + dst.AuxSurf.MaximumRenamingListLength = readTokValue(*tokAuxSurf); + } break; + }; + tokAuxSurf = tokAuxSurf + 1 + tokAuxSurf->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokAuxSurf); + switch (tokAuxSurf->id) { + default: + if (tokAuxSurf->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_TEXTURE_INFO_REC__FLAGS: { + const TokenHeader *tokFlags = varLen->getValue(); + const TokenHeader *tokFlagsEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokFlags < tokFlagsEnd) { + if (false == tokFlags->flags.flag4IsVariableLength) { + if (tokFlags->flags.flag3IsMandatory) { + return false; + } + tokFlags = tokFlags + 1 + tokFlags->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokFlags); + switch (tokFlags->id) { + default: + if (tokFlags->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_RESOURCE_FLAG_REC__GPU: { + const TokenHeader *tokGpu = varLen->getValue(); + const TokenHeader *tokGpuEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokGpu < tokGpuEnd) { + if (false == tokGpu->flags.flag4IsVariableLength) { + switch (tokGpu->id) { + default: + if (tokGpu->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CAMERA_CAPTURE: { + dst.AuxSurf.Flags.Gpu.CameraCapture = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CCS: { + dst.AuxSurf.Flags.Gpu.CCS = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_DISCARD: { + dst.AuxSurf.Flags.Gpu.ColorDiscard = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION: { + dst.AuxSurf.Flags.Gpu.ColorSeparation = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION_RGBX: { + dst.AuxSurf.Flags.Gpu.ColorSeparationRGBX = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CONSTANT: { + dst.AuxSurf.Flags.Gpu.Constant = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__DEPTH: { + dst.AuxSurf.Flags.Gpu.Depth = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN: { + dst.AuxSurf.Flags.Gpu.FlipChain = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN_PREFERRED: { + dst.AuxSurf.Flags.Gpu.FlipChainPreferred = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HISTORY_BUFFER: { + dst.AuxSurf.Flags.Gpu.HistoryBuffer = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HI_Z: { + dst.AuxSurf.Flags.Gpu.HiZ = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDEX: { + dst.AuxSurf.Flags.Gpu.Index = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDIRECT_CLEAR_COLOR: { + dst.AuxSurf.Flags.Gpu.IndirectClearColor = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INSTRUCTION_FLAT: { + dst.AuxSurf.Flags.Gpu.InstructionFlat = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INTERLACED_SCAN: { + dst.AuxSurf.Flags.Gpu.InterlacedScan = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MCS: { + dst.AuxSurf.Flags.Gpu.MCS = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MMC: { + dst.AuxSurf.Flags.Gpu.MMC = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MOTION_COMP: { + dst.AuxSurf.Flags.Gpu.MotionComp = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__NO_RESTRICTION: { + dst.AuxSurf.Flags.Gpu.NoRestriction = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__OVERLAY: { + dst.AuxSurf.Flags.Gpu.Overlay = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PRESENTABLE: { + dst.AuxSurf.Flags.Gpu.Presentable = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PROCEDURAL_TEXTURE: { + dst.AuxSurf.Flags.Gpu.ProceduralTexture = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__QUERY: { + dst.AuxSurf.Flags.Gpu.Query = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__RENDER_TARGET: { + dst.AuxSurf.Flags.Gpu.RenderTarget = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D: { + dst.AuxSurf.Flags.Gpu.S3d = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D_DX: { + dst.AuxSurf.Flags.Gpu.S3dDx = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_NON_PACKED: { + dst.AuxSurf.Flags.Gpu.__S3dNonPacked = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_WIDI: { + dst.AuxSurf.Flags.Gpu.__S3dWidi = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SCRATCH_FLAT: { + dst.AuxSurf.Flags.Gpu.ScratchFlat = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SEPARATE_STENCIL: { + dst.AuxSurf.Flags.Gpu.SeparateStencil = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE: { + dst.AuxSurf.Flags.Gpu.State = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE_DX9CONSTANT_BUFFER: { + dst.AuxSurf.Flags.Gpu.StateDx9ConstantBuffer = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STREAM: { + dst.AuxSurf.Flags.Gpu.Stream = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXT_API: { + dst.AuxSurf.Flags.Gpu.TextApi = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXTURE: { + dst.AuxSurf.Flags.Gpu.Texture = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILED_RESOURCE: { + dst.AuxSurf.Flags.Gpu.TiledResource = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILE_POOL: { + dst.AuxSurf.Flags.Gpu.TilePool = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__UNIFIED_AUX_SURFACE: { + dst.AuxSurf.Flags.Gpu.UnifiedAuxSurface = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VERTEX: { + dst.AuxSurf.Flags.Gpu.Vertex = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VIDEO: { + dst.AuxSurf.Flags.Gpu.Video = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_XCCS: { + dst.AuxSurf.Flags.Gpu.__NonMsaaTileXCcs = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_YCCS: { + dst.AuxSurf.Flags.Gpu.__NonMsaaTileYCcs = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____MSAA_TILE_MCS: { + dst.AuxSurf.Flags.Gpu.__MsaaTileMcs = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_LINEAR_CCS: { + dst.AuxSurf.Flags.Gpu.__NonMsaaLinearCCS = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____REMAINING: { + dst.AuxSurf.Flags.Gpu.__Remaining = readTokValue(*tokGpu); + } break; + }; + tokGpu = tokGpu + 1 + tokGpu->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokGpu); + if (tokGpu->flags.flag3IsMandatory) { + return false; + } + tokGpu = tokGpu + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokGpu == tokGpuEnd); + } break; + case TOK_FS_GMM_RESOURCE_FLAG_REC__INFO: { + const TokenHeader *tokInfo = varLen->getValue(); + const TokenHeader *tokInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokInfo < tokInfoEnd) { + if (false == tokInfo->flags.flag4IsVariableLength) { + switch (tokInfo->id) { + default: + if (tokInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ALLOW_VIRTUAL_PADDING: { + dst.AuxSurf.Flags.Info.AllowVirtualPadding = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__BIG_PAGE: { + dst.AuxSurf.Flags.Info.BigPage = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CACHEABLE: { + dst.AuxSurf.Flags.Info.Cacheable = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CONTIG_PHYS_MEMORY_FORI_DART: { + dst.AuxSurf.Flags.Info.ContigPhysMemoryForiDART = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CORNER_TEXEL_MODE: { + dst.AuxSurf.Flags.Info.CornerTexelMode = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__EXISTING_SYS_MEM: { + dst.AuxSurf.Flags.Info.ExistingSysMem = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__FORCE_RESIDENCY: { + dst.AuxSurf.Flags.Info.ForceResidency = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GFDT: { + dst.AuxSurf.Flags.Info.Gfdt = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GTT_MAP_TYPE: { + dst.AuxSurf.Flags.Info.GttMapType = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__HARDWARE_PROTECTED: { + dst.AuxSurf.Flags.Info.HardwareProtected = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__KERNEL_MODE_MAPPED: { + dst.AuxSurf.Flags.Info.KernelModeMapped = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_BELOW: { + dst.AuxSurf.Flags.Info.LayoutBelow = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_MONO: { + dst.AuxSurf.Flags.Info.LayoutMono = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_RIGHT: { + dst.AuxSurf.Flags.Info.LayoutRight = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LOCAL_ONLY: { + dst.AuxSurf.Flags.Info.LocalOnly = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LINEAR: { + dst.AuxSurf.Flags.Info.Linear = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__MEDIA_COMPRESSED: { + dst.AuxSurf.Flags.Info.MediaCompressed = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_OPTIMIZATION_PADDING: { + dst.AuxSurf.Flags.Info.NoOptimizationPadding = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_PHYS_MEMORY: { + dst.AuxSurf.Flags.Info.NoPhysMemory = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NOT_LOCKABLE: { + dst.AuxSurf.Flags.Info.NotLockable = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NON_LOCAL_ONLY: { + dst.AuxSurf.Flags.Info.NonLocalOnly = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__STD_SWIZZLE: { + dst.AuxSurf.Flags.Info.StdSwizzle = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__PSEUDO_STD_SWIZZLE: { + dst.AuxSurf.Flags.Info.PseudoStdSwizzle = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__UNDEFINED64KBSWIZZLE: { + dst.AuxSurf.Flags.Info.Undefined64KBSwizzle = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__REDECRIBED_PLANES: { + dst.AuxSurf.Flags.Info.RedecribedPlanes = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__RENDER_COMPRESSED: { + dst.AuxSurf.Flags.Info.RenderCompressed = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ROTATED: { + dst.AuxSurf.Flags.Info.Rotated = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SHARED: { + dst.AuxSurf.Flags.Info.Shared = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SOFTWARE_PROTECTED: { + dst.AuxSurf.Flags.Info.SoftwareProtected = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SVM: { + dst.AuxSurf.Flags.Info.SVM = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE4: { + dst.AuxSurf.Flags.Info.Tile4 = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE64: { + dst.AuxSurf.Flags.Info.Tile64 = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_W: { + dst.AuxSurf.Flags.Info.TiledW = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_X: { + dst.AuxSurf.Flags.Info.TiledX = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_Y: { + dst.AuxSurf.Flags.Info.TiledY = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YF: { + dst.AuxSurf.Flags.Info.TiledYf = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YS: { + dst.AuxSurf.Flags.Info.TiledYs = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__WDDM_PROTECTED: { + dst.AuxSurf.Flags.Info.WddmProtected = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__XADAPTER: { + dst.AuxSurf.Flags.Info.XAdapter = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PREALLOCATED_RES_INFO: { + dst.AuxSurf.Flags.Info.__PreallocatedResInfo = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PRE_WDDM2SVM: { + dst.AuxSurf.Flags.Info.__PreWddm2SVM = readTokValue(*tokInfo); + } break; + }; + tokInfo = tokInfo + 1 + tokInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokInfo); + if (tokInfo->flags.flag3IsMandatory) { + return false; + } + tokInfo = tokInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokInfo == tokInfoEnd); + } break; + case TOK_FS_GMM_RESOURCE_FLAG_REC__WA: { + const TokenHeader *tokWa = varLen->getValue(); + const TokenHeader *tokWaEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokWa < tokWaEnd) { + if (false == tokWa->flags.flag4IsVariableLength) { + switch (tokWa->id) { + default: + if (tokWa->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__GTMFX2ND_LEVEL_BATCH_RING_SIZE_ALIGN: { + dst.AuxSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_MPR_ROW_STORE32KALIGN: { + dst.AuxSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_DMV_BUFFER32KALIGN: { + dst.AuxSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_BUFFER_SAMPLER_PADDING: { + dst.AuxSurf.Flags.Wa.NoBufferSamplerPadding = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_LEGACY_PLANAR_LINEAR_VIDEO_RESTRICTIONS: { + dst.AuxSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__CHVASTC_SKIP_VIRTUAL_MIPS: { + dst.AuxSurf.Flags.Wa.CHVAstcSkipVirtualMips = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_PACKED_MIP_TAIL: { + dst.AuxSurf.Flags.Wa.DisablePackedMipTail = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521____FORCE_OTHER_HVALIGN4: { + dst.AuxSurf.Flags.Wa.__ForceOtherHVALIGN4 = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR: { + dst.AuxSurf.Flags.Wa.DisableDisplayCcsClearColor = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION: { + dst.AuxSurf.Flags.Wa.DisableDisplayCcsCompression = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: { + dst.AuxSurf.Flags.Wa.PreGen12FastClearOnly = readTokValue(*tokWa); + } break; + }; + tokWa = tokWa + 1 + tokWa->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokWa); + if (tokWa->flags.flag3IsMandatory) { + return false; + } + tokWa = tokWa + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokWa == tokWaEnd); + } break; + }; + tokFlags = tokFlags + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokFlags == tokFlagsEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__CACHE_POLICY: { + const TokenHeader *tokCachePolicy = varLen->getValue(); + const TokenHeader *tokCachePolicyEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokCachePolicy < tokCachePolicyEnd) { + if (false == tokCachePolicy->flags.flag4IsVariableLength) { + switch (tokCachePolicy->id) { + default: + if (tokCachePolicy->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GMM_TEXTURE_INFO_REC__ANONYMOUS4927__USAGE: { + dst.AuxSurf.CachePolicy.Usage = readTokValue(*tokCachePolicy); + } break; + }; + tokCachePolicy = tokCachePolicy + 1 + tokCachePolicy->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokCachePolicy); + if (tokCachePolicy->flags.flag3IsMandatory) { + return false; + } + tokCachePolicy = tokCachePolicy + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokCachePolicy == tokCachePolicyEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__MSAA: { + const TokenHeader *tokMSAA = varLen->getValue(); + const TokenHeader *tokMSAAEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokMSAA < tokMSAAEnd) { + if (false == tokMSAA->flags.flag4IsVariableLength) { + switch (tokMSAA->id) { + default: + if (tokMSAA->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GMM_RESOURCE_MSAA_INFO_REC__SAMPLE_PATTERN: { + dst.AuxSurf.MSAA.SamplePattern = readTokValue(*tokMSAA); + } break; + case TOK_FBD_GMM_RESOURCE_MSAA_INFO_REC__NUM_SAMPLES: { + dst.AuxSurf.MSAA.NumSamples = readTokValue(*tokMSAA); + } break; + }; + tokMSAA = tokMSAA + 1 + tokMSAA->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokMSAA); + if (tokMSAA->flags.flag3IsMandatory) { + return false; + } + tokMSAA = tokMSAA + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokMSAA == tokMSAAEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__ALIGNMENT: { + const TokenHeader *tokAlignment = varLen->getValue(); + const TokenHeader *tokAlignmentEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokAlignment < tokAlignmentEnd) { + if (false == tokAlignment->flags.flag4IsVariableLength) { + switch (tokAlignment->id) { + default: + if (tokAlignment->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBC_GMM_RESOURCE_ALIGNMENT_REC__ARRAY_SPACING_SINGLE_LOD: { + dst.AuxSurf.Alignment.ArraySpacingSingleLod = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__BASE_ALIGNMENT: { + dst.AuxSurf.Alignment.BaseAlignment = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__HALIGN: { + dst.AuxSurf.Alignment.HAlign = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__VALIGN: { + dst.AuxSurf.Alignment.VAlign = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__DALIGN: { + dst.AuxSurf.Alignment.DAlign = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__MIP_TAIL_START_LOD: { + dst.AuxSurf.Alignment.MipTailStartLod = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_START_LOD: { + dst.AuxSurf.Alignment.PackedMipStartLod = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_WIDTH: { + dst.AuxSurf.Alignment.PackedMipWidth = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_HEIGHT: { + dst.AuxSurf.Alignment.PackedMipHeight = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__QPITCH: { + dst.AuxSurf.Alignment.QPitch = readTokValue(*tokAlignment); + } break; + }; + tokAlignment = tokAlignment + 1 + tokAlignment->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokAlignment); + if (tokAlignment->flags.flag3IsMandatory) { + return false; + } + tokAlignment = tokAlignment + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokAlignment == tokAlignmentEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__OFFSET_INFO: { + const TokenHeader *tokOffsetInfo = varLen->getValue(); + const TokenHeader *tokOffsetInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokOffsetInfo < tokOffsetInfoEnd) { + if (false == tokOffsetInfo->flags.flag4IsVariableLength) { + if (tokOffsetInfo->flags.flag3IsMandatory) { + return false; + } + tokOffsetInfo = tokOffsetInfo + 1 + tokOffsetInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokOffsetInfo); + switch (tokOffsetInfo->id) { + default: + if (tokOffsetInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO: { + const TokenHeader *tokTexture3DOffsetInfo = varLen->getValue(); + const TokenHeader *tokTexture3DOffsetInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokTexture3DOffsetInfo < tokTexture3DOffsetInfoEnd) { + if (false == tokTexture3DOffsetInfo->flags.flag4IsVariableLength) { + switch (tokTexture3DOffsetInfo->id) { + default: + if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: { + dst.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch = readTokValue(*tokTexture3DOffsetInfo); + } break; + case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: { + auto srcData = reinterpret_cast &>(*tokTexture3DOffsetInfo).getValue(); + auto srcSize = reinterpret_cast &>(*tokTexture3DOffsetInfo).getValueSizeInBytes(); + if (srcSize < sizeof(dst.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset)) { + return false; + } + WCH_SAFE_COPY(dst.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(dst.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset), srcData, sizeof(dst.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset)); + } break; + }; + tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + 1 + tokTexture3DOffsetInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokTexture3DOffsetInfo); + if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokTexture3DOffsetInfo == tokTexture3DOffsetInfoEnd); + } break; + case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO: { + const TokenHeader *tokTexture2DOffsetInfo = varLen->getValue(); + const TokenHeader *tokTexture2DOffsetInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokTexture2DOffsetInfo < tokTexture2DOffsetInfoEnd) { + if (false == tokTexture2DOffsetInfo->flags.flag4IsVariableLength) { + switch (tokTexture2DOffsetInfo->id) { + default: + if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: { + dst.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock = readTokValue(*tokTexture2DOffsetInfo); + } break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: { + dst.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender = readTokValue(*tokTexture2DOffsetInfo); + } break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: { + auto srcData = reinterpret_cast &>(*tokTexture2DOffsetInfo).getValue(); + auto srcSize = reinterpret_cast &>(*tokTexture2DOffsetInfo).getValueSizeInBytes(); + if (srcSize < sizeof(dst.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset)) { + return false; + } + WCH_SAFE_COPY(dst.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(dst.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset), srcData, sizeof(dst.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset)); + } break; + }; + tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + 1 + tokTexture2DOffsetInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokTexture2DOffsetInfo); + if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokTexture2DOffsetInfo == tokTexture2DOffsetInfoEnd); + } break; + case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE: { + const TokenHeader *tokPlane = varLen->getValue(); + const TokenHeader *tokPlaneEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokPlane < tokPlaneEnd) { + if (false == tokPlane->flags.flag4IsVariableLength) { + switch (tokPlane->id) { + default: + if (tokPlane->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: { + dst.AuxSurf.OffsetInfo.Plane.ArrayQPitch = readTokValue(*tokPlane); + } break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: { + auto srcData = reinterpret_cast &>(*tokPlane).getValue(); + auto srcSize = reinterpret_cast &>(*tokPlane).getValueSizeInBytes(); + if (srcSize < sizeof(dst.AuxSurf.OffsetInfo.Plane.X)) { + return false; + } + WCH_SAFE_COPY(dst.AuxSurf.OffsetInfo.Plane.X, sizeof(dst.AuxSurf.OffsetInfo.Plane.X), srcData, sizeof(dst.AuxSurf.OffsetInfo.Plane.X)); + } break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: { + auto srcData = reinterpret_cast &>(*tokPlane).getValue(); + auto srcSize = reinterpret_cast &>(*tokPlane).getValueSizeInBytes(); + if (srcSize < sizeof(dst.AuxSurf.OffsetInfo.Plane.Y)) { + return false; + } + WCH_SAFE_COPY(dst.AuxSurf.OffsetInfo.Plane.Y, sizeof(dst.AuxSurf.OffsetInfo.Plane.Y), srcData, sizeof(dst.AuxSurf.OffsetInfo.Plane.Y)); + } break; + case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: { + dst.AuxSurf.OffsetInfo.Plane.NoOfPlanes = readTokValue(*tokPlane); + } break; + case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: { + dst.AuxSurf.OffsetInfo.Plane.IsTileAlignedPlanes = readTokValue(*tokPlane); + } break; + }; + tokPlane = tokPlane + 1 + tokPlane->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokPlane); + switch (tokPlane->id) { + default: + if (tokPlane->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: { + const TokenHeader *tokUnAligned = varLen->getValue(); + const TokenHeader *tokUnAlignedEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokUnAligned < tokUnAlignedEnd) { + if (false == tokUnAligned->flags.flag4IsVariableLength) { + switch (tokUnAligned->id) { + default: + if (tokUnAligned->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: { + auto srcData = reinterpret_cast &>(*tokUnAligned).getValue(); + auto srcSize = reinterpret_cast &>(*tokUnAligned).getValueSizeInBytes(); + if (srcSize < sizeof(dst.AuxSurf.OffsetInfo.Plane.UnAligned.Height)) { + return false; + } + WCH_SAFE_COPY(dst.AuxSurf.OffsetInfo.Plane.UnAligned.Height, sizeof(dst.AuxSurf.OffsetInfo.Plane.UnAligned.Height), srcData, sizeof(dst.AuxSurf.OffsetInfo.Plane.UnAligned.Height)); + } break; + }; + tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokUnAligned); + if (tokUnAligned->flags.flag3IsMandatory) { + return false; + } + tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokUnAligned == tokUnAlignedEnd); + } break; + }; + tokPlane = tokPlane + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokPlane == tokPlaneEnd); + } break; + }; + tokOffsetInfo = tokOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokOffsetInfo == tokOffsetInfoEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__S3D: { + const TokenHeader *tokS3d = varLen->getValue(); + const TokenHeader *tokS3dEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokS3d < tokS3dEnd) { + if (false == tokS3d->flags.flag4IsVariableLength) { + switch (tokS3d->id) { + default: + if (tokS3d->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_S3D_INFO_REC__DISPLAY_MODE_HEIGHT: { + dst.AuxSurf.S3d.DisplayModeHeight = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__NUM_BLANK_ACTIVE_LINES: { + dst.AuxSurf.S3d.NumBlankActiveLines = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__RFRAME_OFFSET: { + dst.AuxSurf.S3d.RFrameOffset = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__BLANK_AREA_OFFSET: { + dst.AuxSurf.S3d.BlankAreaOffset = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_HEIGHT: { + dst.AuxSurf.S3d.TallBufferHeight = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_SIZE: { + dst.AuxSurf.S3d.TallBufferSize = readTokValue(*tokS3d); + } break; + case TOK_FBC_GMM_S3D_INFO_REC__IS_RFRAME: { + dst.AuxSurf.S3d.IsRFrame = readTokValue(*tokS3d); + } break; + }; + tokS3d = tokS3d + 1 + tokS3d->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokS3d); + if (tokS3d->flags.flag3IsMandatory) { + return false; + } + tokS3d = tokS3d + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokS3d == tokS3dEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__SEGMENT_OVERRIDE: { + const TokenHeader *tokSegmentOverride = varLen->getValue(); + const TokenHeader *tokSegmentOverrideEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSegmentOverride < tokSegmentOverrideEnd) { + if (false == tokSegmentOverride->flags.flag4IsVariableLength) { + switch (tokSegmentOverride->id) { + default: + if (tokSegmentOverride->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__SEG1: { + dst.AuxSurf.SegmentOverride.Seg1 = readTokValue(*tokSegmentOverride); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__EVICT: { + dst.AuxSurf.SegmentOverride.Evict = readTokValue(*tokSegmentOverride); + } break; + }; + tokSegmentOverride = tokSegmentOverride + 1 + tokSegmentOverride->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSegmentOverride); + if (tokSegmentOverride->flags.flag3IsMandatory) { + return false; + } + tokSegmentOverride = tokSegmentOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSegmentOverride == tokSegmentOverrideEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__PLATFORM: { +#if _DEBUG || _RELEASE_INTERNAL + const TokenHeader *tokPlatform = varLen->getValue(); + const TokenHeader *tokPlatformEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokPlatform < tokPlatformEnd) { + if (false == tokPlatform->flags.flag4IsVariableLength) { + switch (tokPlatform->id) { + default: + if (tokPlatform->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { + dst.AuxSurf.Platform.eProductFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { + dst.AuxSurf.Platform.ePCHProductFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { + dst.AuxSurf.Platform.eDisplayCoreFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { + dst.AuxSurf.Platform.eRenderCoreFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { + dst.AuxSurf.Platform.ePlatformType = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { + dst.AuxSurf.Platform.usDeviceID = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID: { + dst.AuxSurf.Platform.usRevId = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { + dst.AuxSurf.Platform.usDeviceID_PCH = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { + dst.AuxSurf.Platform.usRevId_PCH = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_GTTYPE: { + dst.AuxSurf.Platform.eGTType = readTokValue(*tokPlatform); + } break; + }; + tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokPlatform); + if (tokPlatform->flags.flag3IsMandatory) { + return false; + } + tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokPlatform == tokPlatformEnd); +#endif + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__EXISTING_SYS_MEM: { + const TokenHeader *tokExistingSysMem = varLen->getValue(); + const TokenHeader *tokExistingSysMemEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokExistingSysMem < tokExistingSysMemEnd) { + if (false == tokExistingSysMem->flags.flag4IsVariableLength) { + switch (tokExistingSysMem->id) { + default: + if (tokExistingSysMem->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_GMM_ALLOCATED: { + dst.AuxSurf.ExistingSysMem.IsGmmAllocated = readTokValue(*tokExistingSysMem); + } break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_PAGE_ALIGNED: { + dst.AuxSurf.ExistingSysMem.IsPageAligned = readTokValue(*tokExistingSysMem); + } break; + }; + tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokExistingSysMem); + if (tokExistingSysMem->flags.flag3IsMandatory) { + return false; + } + tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: { +#if !(_DEBUG || _RELEASE_INTERNAL) + const TokenHeader *tok__Platform = varLen->getValue(); + const TokenHeader *tok__PlatformEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tok__Platform < tok__PlatformEnd) { + if (false == tok__Platform->flags.flag4IsVariableLength) { + switch (tok__Platform->id) { + default: + if (tok__Platform->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { + dst.AuxSurf.__Platform.eProductFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { + dst.AuxSurf.__Platform.ePCHProductFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { + dst.AuxSurf.__Platform.eDisplayCoreFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { + dst.AuxSurf.__Platform.eRenderCoreFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { + dst.AuxSurf.__Platform.ePlatformType = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { + dst.AuxSurf.__Platform.usDeviceID = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID: { + dst.AuxSurf.__Platform.usRevId = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { + dst.AuxSurf.__Platform.usDeviceID_PCH = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { + dst.AuxSurf.__Platform.usRevId_PCH = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_GTTYPE: { + dst.AuxSurf.__Platform.eGTType = readTokValue(*tok__Platform); + } break; + }; + tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok__Platform); + if (tok__Platform->flags.flag3IsMandatory) { + return false; + } + tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok__Platform == tok__PlatformEnd); +#endif + } break; + }; + tokAuxSurf = tokAuxSurf + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokAuxSurf == tokAuxSurfEnd); + } break; + case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__AUX_SEC_SURF: { + const TokenHeader *tokAuxSecSurf = varLen->getValue(); + const TokenHeader *tokAuxSecSurfEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokAuxSecSurf < tokAuxSecSurfEnd) { + if (false == tokAuxSecSurf->flags.flag4IsVariableLength) { + switch (tokAuxSecSurf->id) { + default: + if (tokAuxSecSurf->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GMM_TEXTURE_INFO_REC__TYPE: { + dst.AuxSecSurf.Type = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FE_GMM_TEXTURE_INFO_REC__FORMAT: { + dst.AuxSecSurf.Format = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__BITS_PER_PIXEL: { + dst.AuxSecSurf.BitsPerPixel = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__BASE_WIDTH: { + dst.AuxSecSurf.BaseWidth = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__BASE_HEIGHT: { + dst.AuxSecSurf.BaseHeight = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__DEPTH: { + dst.AuxSecSurf.Depth = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__MAX_LOD: { + dst.AuxSecSurf.MaxLod = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__ARRAY_SIZE: { + dst.AuxSecSurf.ArraySize = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__CP_TAG: { + dst.AuxSecSurf.CpTag = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_MODE: { + auto srcData = reinterpret_cast &>(*tokAuxSecSurf).getValue(); + auto srcSize = reinterpret_cast &>(*tokAuxSecSurf).getValueSizeInBytes(); + if (srcSize < sizeof(dst.AuxSecSurf.MmcMode)) { + return false; + } + WCH_SAFE_COPY(dst.AuxSecSurf.MmcMode, sizeof(dst.AuxSecSurf.MmcMode), srcData, sizeof(dst.AuxSecSurf.MmcMode)); + } break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_HINT: { + auto srcData = reinterpret_cast &>(*tokAuxSecSurf).getValue(); + auto srcSize = reinterpret_cast &>(*tokAuxSecSurf).getValueSizeInBytes(); + if (srcSize < sizeof(dst.AuxSecSurf.MmcHint)) { + return false; + } + WCH_SAFE_COPY(dst.AuxSecSurf.MmcHint, sizeof(dst.AuxSecSurf.MmcHint), srcData, sizeof(dst.AuxSecSurf.MmcHint)); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__PITCH: { + dst.AuxSecSurf.Pitch = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__OVERRIDE_PITCH: { + dst.AuxSecSurf.OverridePitch = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE: { + dst.AuxSecSurf.Size = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__CCSIZE: { + dst.AuxSecSurf.CCSize = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__UNPADDED_SIZE: { + dst.AuxSecSurf.UnpaddedSize = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE_REPORT_TO_OS: { + dst.AuxSecSurf.SizeReportToOS = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FE_GMM_TEXTURE_INFO_REC__TILE_MODE: { + dst.AuxSecSurf.TileMode = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__CCSMODE_ALIGN: { + dst.AuxSecSurf.CCSModeAlign = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__LEGACY_FLAGS: { + dst.AuxSecSurf.LegacyFlags = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__MAXIMUM_RENAMING_LIST_LENGTH: { + dst.AuxSecSurf.MaximumRenamingListLength = readTokValue(*tokAuxSecSurf); + } break; + }; + tokAuxSecSurf = tokAuxSecSurf + 1 + tokAuxSecSurf->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokAuxSecSurf); + switch (tokAuxSecSurf->id) { + default: + if (tokAuxSecSurf->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_TEXTURE_INFO_REC__FLAGS: { + const TokenHeader *tokFlags = varLen->getValue(); + const TokenHeader *tokFlagsEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokFlags < tokFlagsEnd) { + if (false == tokFlags->flags.flag4IsVariableLength) { + if (tokFlags->flags.flag3IsMandatory) { + return false; + } + tokFlags = tokFlags + 1 + tokFlags->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokFlags); + switch (tokFlags->id) { + default: + if (tokFlags->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_RESOURCE_FLAG_REC__GPU: { + const TokenHeader *tokGpu = varLen->getValue(); + const TokenHeader *tokGpuEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokGpu < tokGpuEnd) { + if (false == tokGpu->flags.flag4IsVariableLength) { + switch (tokGpu->id) { + default: + if (tokGpu->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CAMERA_CAPTURE: { + dst.AuxSecSurf.Flags.Gpu.CameraCapture = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CCS: { + dst.AuxSecSurf.Flags.Gpu.CCS = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_DISCARD: { + dst.AuxSecSurf.Flags.Gpu.ColorDiscard = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION: { + dst.AuxSecSurf.Flags.Gpu.ColorSeparation = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION_RGBX: { + dst.AuxSecSurf.Flags.Gpu.ColorSeparationRGBX = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CONSTANT: { + dst.AuxSecSurf.Flags.Gpu.Constant = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__DEPTH: { + dst.AuxSecSurf.Flags.Gpu.Depth = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN: { + dst.AuxSecSurf.Flags.Gpu.FlipChain = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN_PREFERRED: { + dst.AuxSecSurf.Flags.Gpu.FlipChainPreferred = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HISTORY_BUFFER: { + dst.AuxSecSurf.Flags.Gpu.HistoryBuffer = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HI_Z: { + dst.AuxSecSurf.Flags.Gpu.HiZ = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDEX: { + dst.AuxSecSurf.Flags.Gpu.Index = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDIRECT_CLEAR_COLOR: { + dst.AuxSecSurf.Flags.Gpu.IndirectClearColor = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INSTRUCTION_FLAT: { + dst.AuxSecSurf.Flags.Gpu.InstructionFlat = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INTERLACED_SCAN: { + dst.AuxSecSurf.Flags.Gpu.InterlacedScan = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MCS: { + dst.AuxSecSurf.Flags.Gpu.MCS = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MMC: { + dst.AuxSecSurf.Flags.Gpu.MMC = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MOTION_COMP: { + dst.AuxSecSurf.Flags.Gpu.MotionComp = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__NO_RESTRICTION: { + dst.AuxSecSurf.Flags.Gpu.NoRestriction = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__OVERLAY: { + dst.AuxSecSurf.Flags.Gpu.Overlay = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PRESENTABLE: { + dst.AuxSecSurf.Flags.Gpu.Presentable = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PROCEDURAL_TEXTURE: { + dst.AuxSecSurf.Flags.Gpu.ProceduralTexture = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__QUERY: { + dst.AuxSecSurf.Flags.Gpu.Query = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__RENDER_TARGET: { + dst.AuxSecSurf.Flags.Gpu.RenderTarget = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D: { + dst.AuxSecSurf.Flags.Gpu.S3d = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D_DX: { + dst.AuxSecSurf.Flags.Gpu.S3dDx = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_NON_PACKED: { + dst.AuxSecSurf.Flags.Gpu.__S3dNonPacked = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_WIDI: { + dst.AuxSecSurf.Flags.Gpu.__S3dWidi = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SCRATCH_FLAT: { + dst.AuxSecSurf.Flags.Gpu.ScratchFlat = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SEPARATE_STENCIL: { + dst.AuxSecSurf.Flags.Gpu.SeparateStencil = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE: { + dst.AuxSecSurf.Flags.Gpu.State = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE_DX9CONSTANT_BUFFER: { + dst.AuxSecSurf.Flags.Gpu.StateDx9ConstantBuffer = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STREAM: { + dst.AuxSecSurf.Flags.Gpu.Stream = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXT_API: { + dst.AuxSecSurf.Flags.Gpu.TextApi = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXTURE: { + dst.AuxSecSurf.Flags.Gpu.Texture = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILED_RESOURCE: { + dst.AuxSecSurf.Flags.Gpu.TiledResource = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILE_POOL: { + dst.AuxSecSurf.Flags.Gpu.TilePool = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__UNIFIED_AUX_SURFACE: { + dst.AuxSecSurf.Flags.Gpu.UnifiedAuxSurface = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VERTEX: { + dst.AuxSecSurf.Flags.Gpu.Vertex = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VIDEO: { + dst.AuxSecSurf.Flags.Gpu.Video = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_XCCS: { + dst.AuxSecSurf.Flags.Gpu.__NonMsaaTileXCcs = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_YCCS: { + dst.AuxSecSurf.Flags.Gpu.__NonMsaaTileYCcs = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____MSAA_TILE_MCS: { + dst.AuxSecSurf.Flags.Gpu.__MsaaTileMcs = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_LINEAR_CCS: { + dst.AuxSecSurf.Flags.Gpu.__NonMsaaLinearCCS = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____REMAINING: { + dst.AuxSecSurf.Flags.Gpu.__Remaining = readTokValue(*tokGpu); + } break; + }; + tokGpu = tokGpu + 1 + tokGpu->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokGpu); + if (tokGpu->flags.flag3IsMandatory) { + return false; + } + tokGpu = tokGpu + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokGpu == tokGpuEnd); + } break; + case TOK_FS_GMM_RESOURCE_FLAG_REC__INFO: { + const TokenHeader *tokInfo = varLen->getValue(); + const TokenHeader *tokInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokInfo < tokInfoEnd) { + if (false == tokInfo->flags.flag4IsVariableLength) { + switch (tokInfo->id) { + default: + if (tokInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ALLOW_VIRTUAL_PADDING: { + dst.AuxSecSurf.Flags.Info.AllowVirtualPadding = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__BIG_PAGE: { + dst.AuxSecSurf.Flags.Info.BigPage = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CACHEABLE: { + dst.AuxSecSurf.Flags.Info.Cacheable = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CONTIG_PHYS_MEMORY_FORI_DART: { + dst.AuxSecSurf.Flags.Info.ContigPhysMemoryForiDART = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CORNER_TEXEL_MODE: { + dst.AuxSecSurf.Flags.Info.CornerTexelMode = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__EXISTING_SYS_MEM: { + dst.AuxSecSurf.Flags.Info.ExistingSysMem = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__FORCE_RESIDENCY: { + dst.AuxSecSurf.Flags.Info.ForceResidency = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GFDT: { + dst.AuxSecSurf.Flags.Info.Gfdt = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GTT_MAP_TYPE: { + dst.AuxSecSurf.Flags.Info.GttMapType = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__HARDWARE_PROTECTED: { + dst.AuxSecSurf.Flags.Info.HardwareProtected = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__KERNEL_MODE_MAPPED: { + dst.AuxSecSurf.Flags.Info.KernelModeMapped = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_BELOW: { + dst.AuxSecSurf.Flags.Info.LayoutBelow = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_MONO: { + dst.AuxSecSurf.Flags.Info.LayoutMono = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_RIGHT: { + dst.AuxSecSurf.Flags.Info.LayoutRight = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LOCAL_ONLY: { + dst.AuxSecSurf.Flags.Info.LocalOnly = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LINEAR: { + dst.AuxSecSurf.Flags.Info.Linear = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__MEDIA_COMPRESSED: { + dst.AuxSecSurf.Flags.Info.MediaCompressed = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_OPTIMIZATION_PADDING: { + dst.AuxSecSurf.Flags.Info.NoOptimizationPadding = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_PHYS_MEMORY: { + dst.AuxSecSurf.Flags.Info.NoPhysMemory = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NOT_LOCKABLE: { + dst.AuxSecSurf.Flags.Info.NotLockable = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NON_LOCAL_ONLY: { + dst.AuxSecSurf.Flags.Info.NonLocalOnly = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__STD_SWIZZLE: { + dst.AuxSecSurf.Flags.Info.StdSwizzle = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__PSEUDO_STD_SWIZZLE: { + dst.AuxSecSurf.Flags.Info.PseudoStdSwizzle = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__UNDEFINED64KBSWIZZLE: { + dst.AuxSecSurf.Flags.Info.Undefined64KBSwizzle = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__REDECRIBED_PLANES: { + dst.AuxSecSurf.Flags.Info.RedecribedPlanes = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__RENDER_COMPRESSED: { + dst.AuxSecSurf.Flags.Info.RenderCompressed = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ROTATED: { + dst.AuxSecSurf.Flags.Info.Rotated = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SHARED: { + dst.AuxSecSurf.Flags.Info.Shared = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SOFTWARE_PROTECTED: { + dst.AuxSecSurf.Flags.Info.SoftwareProtected = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SVM: { + dst.AuxSecSurf.Flags.Info.SVM = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE4: { + dst.AuxSecSurf.Flags.Info.Tile4 = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE64: { + dst.AuxSecSurf.Flags.Info.Tile64 = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_W: { + dst.AuxSecSurf.Flags.Info.TiledW = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_X: { + dst.AuxSecSurf.Flags.Info.TiledX = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_Y: { + dst.AuxSecSurf.Flags.Info.TiledY = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YF: { + dst.AuxSecSurf.Flags.Info.TiledYf = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YS: { + dst.AuxSecSurf.Flags.Info.TiledYs = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__WDDM_PROTECTED: { + dst.AuxSecSurf.Flags.Info.WddmProtected = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__XADAPTER: { + dst.AuxSecSurf.Flags.Info.XAdapter = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PREALLOCATED_RES_INFO: { + dst.AuxSecSurf.Flags.Info.__PreallocatedResInfo = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PRE_WDDM2SVM: { + dst.AuxSecSurf.Flags.Info.__PreWddm2SVM = readTokValue(*tokInfo); + } break; + }; + tokInfo = tokInfo + 1 + tokInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokInfo); + if (tokInfo->flags.flag3IsMandatory) { + return false; + } + tokInfo = tokInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokInfo == tokInfoEnd); + } break; + case TOK_FS_GMM_RESOURCE_FLAG_REC__WA: { + const TokenHeader *tokWa = varLen->getValue(); + const TokenHeader *tokWaEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokWa < tokWaEnd) { + if (false == tokWa->flags.flag4IsVariableLength) { + switch (tokWa->id) { + default: + if (tokWa->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__GTMFX2ND_LEVEL_BATCH_RING_SIZE_ALIGN: { + dst.AuxSecSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_MPR_ROW_STORE32KALIGN: { + dst.AuxSecSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_DMV_BUFFER32KALIGN: { + dst.AuxSecSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_BUFFER_SAMPLER_PADDING: { + dst.AuxSecSurf.Flags.Wa.NoBufferSamplerPadding = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_LEGACY_PLANAR_LINEAR_VIDEO_RESTRICTIONS: { + dst.AuxSecSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__CHVASTC_SKIP_VIRTUAL_MIPS: { + dst.AuxSecSurf.Flags.Wa.CHVAstcSkipVirtualMips = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_PACKED_MIP_TAIL: { + dst.AuxSecSurf.Flags.Wa.DisablePackedMipTail = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521____FORCE_OTHER_HVALIGN4: { + dst.AuxSecSurf.Flags.Wa.__ForceOtherHVALIGN4 = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR: { + dst.AuxSecSurf.Flags.Wa.DisableDisplayCcsClearColor = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION: { + dst.AuxSecSurf.Flags.Wa.DisableDisplayCcsCompression = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: { + dst.AuxSecSurf.Flags.Wa.PreGen12FastClearOnly = readTokValue(*tokWa); + } break; + }; + tokWa = tokWa + 1 + tokWa->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokWa); + if (tokWa->flags.flag3IsMandatory) { + return false; + } + tokWa = tokWa + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokWa == tokWaEnd); + } break; + }; + tokFlags = tokFlags + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokFlags == tokFlagsEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__CACHE_POLICY: { + const TokenHeader *tokCachePolicy = varLen->getValue(); + const TokenHeader *tokCachePolicyEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokCachePolicy < tokCachePolicyEnd) { + if (false == tokCachePolicy->flags.flag4IsVariableLength) { + switch (tokCachePolicy->id) { + default: + if (tokCachePolicy->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GMM_TEXTURE_INFO_REC__ANONYMOUS4927__USAGE: { + dst.AuxSecSurf.CachePolicy.Usage = readTokValue(*tokCachePolicy); + } break; + }; + tokCachePolicy = tokCachePolicy + 1 + tokCachePolicy->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokCachePolicy); + if (tokCachePolicy->flags.flag3IsMandatory) { + return false; + } + tokCachePolicy = tokCachePolicy + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokCachePolicy == tokCachePolicyEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__MSAA: { + const TokenHeader *tokMSAA = varLen->getValue(); + const TokenHeader *tokMSAAEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokMSAA < tokMSAAEnd) { + if (false == tokMSAA->flags.flag4IsVariableLength) { + switch (tokMSAA->id) { + default: + if (tokMSAA->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GMM_RESOURCE_MSAA_INFO_REC__SAMPLE_PATTERN: { + dst.AuxSecSurf.MSAA.SamplePattern = readTokValue(*tokMSAA); + } break; + case TOK_FBD_GMM_RESOURCE_MSAA_INFO_REC__NUM_SAMPLES: { + dst.AuxSecSurf.MSAA.NumSamples = readTokValue(*tokMSAA); + } break; + }; + tokMSAA = tokMSAA + 1 + tokMSAA->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokMSAA); + if (tokMSAA->flags.flag3IsMandatory) { + return false; + } + tokMSAA = tokMSAA + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokMSAA == tokMSAAEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__ALIGNMENT: { + const TokenHeader *tokAlignment = varLen->getValue(); + const TokenHeader *tokAlignmentEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokAlignment < tokAlignmentEnd) { + if (false == tokAlignment->flags.flag4IsVariableLength) { + switch (tokAlignment->id) { + default: + if (tokAlignment->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBC_GMM_RESOURCE_ALIGNMENT_REC__ARRAY_SPACING_SINGLE_LOD: { + dst.AuxSecSurf.Alignment.ArraySpacingSingleLod = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__BASE_ALIGNMENT: { + dst.AuxSecSurf.Alignment.BaseAlignment = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__HALIGN: { + dst.AuxSecSurf.Alignment.HAlign = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__VALIGN: { + dst.AuxSecSurf.Alignment.VAlign = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__DALIGN: { + dst.AuxSecSurf.Alignment.DAlign = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__MIP_TAIL_START_LOD: { + dst.AuxSecSurf.Alignment.MipTailStartLod = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_START_LOD: { + dst.AuxSecSurf.Alignment.PackedMipStartLod = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_WIDTH: { + dst.AuxSecSurf.Alignment.PackedMipWidth = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_HEIGHT: { + dst.AuxSecSurf.Alignment.PackedMipHeight = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__QPITCH: { + dst.AuxSecSurf.Alignment.QPitch = readTokValue(*tokAlignment); + } break; + }; + tokAlignment = tokAlignment + 1 + tokAlignment->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokAlignment); + if (tokAlignment->flags.flag3IsMandatory) { + return false; + } + tokAlignment = tokAlignment + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokAlignment == tokAlignmentEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__OFFSET_INFO: { + const TokenHeader *tokOffsetInfo = varLen->getValue(); + const TokenHeader *tokOffsetInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokOffsetInfo < tokOffsetInfoEnd) { + if (false == tokOffsetInfo->flags.flag4IsVariableLength) { + if (tokOffsetInfo->flags.flag3IsMandatory) { + return false; + } + tokOffsetInfo = tokOffsetInfo + 1 + tokOffsetInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokOffsetInfo); + switch (tokOffsetInfo->id) { + default: + if (tokOffsetInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO: { + const TokenHeader *tokTexture3DOffsetInfo = varLen->getValue(); + const TokenHeader *tokTexture3DOffsetInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokTexture3DOffsetInfo < tokTexture3DOffsetInfoEnd) { + if (false == tokTexture3DOffsetInfo->flags.flag4IsVariableLength) { + switch (tokTexture3DOffsetInfo->id) { + default: + if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: { + dst.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch = readTokValue(*tokTexture3DOffsetInfo); + } break; + case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: { + auto srcData = reinterpret_cast &>(*tokTexture3DOffsetInfo).getValue(); + auto srcSize = reinterpret_cast &>(*tokTexture3DOffsetInfo).getValueSizeInBytes(); + if (srcSize < sizeof(dst.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset)) { + return false; + } + WCH_SAFE_COPY(dst.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(dst.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset), srcData, sizeof(dst.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset)); + } break; + }; + tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + 1 + tokTexture3DOffsetInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokTexture3DOffsetInfo); + if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokTexture3DOffsetInfo == tokTexture3DOffsetInfoEnd); + } break; + case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO: { + const TokenHeader *tokTexture2DOffsetInfo = varLen->getValue(); + const TokenHeader *tokTexture2DOffsetInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokTexture2DOffsetInfo < tokTexture2DOffsetInfoEnd) { + if (false == tokTexture2DOffsetInfo->flags.flag4IsVariableLength) { + switch (tokTexture2DOffsetInfo->id) { + default: + if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: { + dst.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock = readTokValue(*tokTexture2DOffsetInfo); + } break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: { + dst.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender = readTokValue(*tokTexture2DOffsetInfo); + } break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: { + auto srcData = reinterpret_cast &>(*tokTexture2DOffsetInfo).getValue(); + auto srcSize = reinterpret_cast &>(*tokTexture2DOffsetInfo).getValueSizeInBytes(); + if (srcSize < sizeof(dst.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset)) { + return false; + } + WCH_SAFE_COPY(dst.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(dst.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset), srcData, sizeof(dst.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset)); + } break; + }; + tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + 1 + tokTexture2DOffsetInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokTexture2DOffsetInfo); + if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokTexture2DOffsetInfo == tokTexture2DOffsetInfoEnd); + } break; + case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE: { + const TokenHeader *tokPlane = varLen->getValue(); + const TokenHeader *tokPlaneEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokPlane < tokPlaneEnd) { + if (false == tokPlane->flags.flag4IsVariableLength) { + switch (tokPlane->id) { + default: + if (tokPlane->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: { + dst.AuxSecSurf.OffsetInfo.Plane.ArrayQPitch = readTokValue(*tokPlane); + } break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: { + auto srcData = reinterpret_cast &>(*tokPlane).getValue(); + auto srcSize = reinterpret_cast &>(*tokPlane).getValueSizeInBytes(); + if (srcSize < sizeof(dst.AuxSecSurf.OffsetInfo.Plane.X)) { + return false; + } + WCH_SAFE_COPY(dst.AuxSecSurf.OffsetInfo.Plane.X, sizeof(dst.AuxSecSurf.OffsetInfo.Plane.X), srcData, sizeof(dst.AuxSecSurf.OffsetInfo.Plane.X)); + } break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: { + auto srcData = reinterpret_cast &>(*tokPlane).getValue(); + auto srcSize = reinterpret_cast &>(*tokPlane).getValueSizeInBytes(); + if (srcSize < sizeof(dst.AuxSecSurf.OffsetInfo.Plane.Y)) { + return false; + } + WCH_SAFE_COPY(dst.AuxSecSurf.OffsetInfo.Plane.Y, sizeof(dst.AuxSecSurf.OffsetInfo.Plane.Y), srcData, sizeof(dst.AuxSecSurf.OffsetInfo.Plane.Y)); + } break; + case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: { + dst.AuxSecSurf.OffsetInfo.Plane.NoOfPlanes = readTokValue(*tokPlane); + } break; + case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: { + dst.AuxSecSurf.OffsetInfo.Plane.IsTileAlignedPlanes = readTokValue(*tokPlane); + } break; + }; + tokPlane = tokPlane + 1 + tokPlane->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokPlane); + switch (tokPlane->id) { + default: + if (tokPlane->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: { + const TokenHeader *tokUnAligned = varLen->getValue(); + const TokenHeader *tokUnAlignedEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokUnAligned < tokUnAlignedEnd) { + if (false == tokUnAligned->flags.flag4IsVariableLength) { + switch (tokUnAligned->id) { + default: + if (tokUnAligned->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: { + auto srcData = reinterpret_cast &>(*tokUnAligned).getValue(); + auto srcSize = reinterpret_cast &>(*tokUnAligned).getValueSizeInBytes(); + if (srcSize < sizeof(dst.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height)) { + return false; + } + WCH_SAFE_COPY(dst.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height, sizeof(dst.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height), srcData, sizeof(dst.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height)); + } break; + }; + tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokUnAligned); + if (tokUnAligned->flags.flag3IsMandatory) { + return false; + } + tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokUnAligned == tokUnAlignedEnd); + } break; + }; + tokPlane = tokPlane + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokPlane == tokPlaneEnd); + } break; + }; + tokOffsetInfo = tokOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokOffsetInfo == tokOffsetInfoEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__S3D: { + const TokenHeader *tokS3d = varLen->getValue(); + const TokenHeader *tokS3dEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokS3d < tokS3dEnd) { + if (false == tokS3d->flags.flag4IsVariableLength) { + switch (tokS3d->id) { + default: + if (tokS3d->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_S3D_INFO_REC__DISPLAY_MODE_HEIGHT: { + dst.AuxSecSurf.S3d.DisplayModeHeight = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__NUM_BLANK_ACTIVE_LINES: { + dst.AuxSecSurf.S3d.NumBlankActiveLines = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__RFRAME_OFFSET: { + dst.AuxSecSurf.S3d.RFrameOffset = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__BLANK_AREA_OFFSET: { + dst.AuxSecSurf.S3d.BlankAreaOffset = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_HEIGHT: { + dst.AuxSecSurf.S3d.TallBufferHeight = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_SIZE: { + dst.AuxSecSurf.S3d.TallBufferSize = readTokValue(*tokS3d); + } break; + case TOK_FBC_GMM_S3D_INFO_REC__IS_RFRAME: { + dst.AuxSecSurf.S3d.IsRFrame = readTokValue(*tokS3d); + } break; + }; + tokS3d = tokS3d + 1 + tokS3d->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokS3d); + if (tokS3d->flags.flag3IsMandatory) { + return false; + } + tokS3d = tokS3d + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokS3d == tokS3dEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__SEGMENT_OVERRIDE: { + const TokenHeader *tokSegmentOverride = varLen->getValue(); + const TokenHeader *tokSegmentOverrideEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSegmentOverride < tokSegmentOverrideEnd) { + if (false == tokSegmentOverride->flags.flag4IsVariableLength) { + switch (tokSegmentOverride->id) { + default: + if (tokSegmentOverride->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__SEG1: { + dst.AuxSecSurf.SegmentOverride.Seg1 = readTokValue(*tokSegmentOverride); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__EVICT: { + dst.AuxSecSurf.SegmentOverride.Evict = readTokValue(*tokSegmentOverride); + } break; + }; + tokSegmentOverride = tokSegmentOverride + 1 + tokSegmentOverride->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSegmentOverride); + if (tokSegmentOverride->flags.flag3IsMandatory) { + return false; + } + tokSegmentOverride = tokSegmentOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSegmentOverride == tokSegmentOverrideEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__PLATFORM: { +#if _DEBUG || _RELEASE_INTERNAL + const TokenHeader *tokPlatform = varLen->getValue(); + const TokenHeader *tokPlatformEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokPlatform < tokPlatformEnd) { + if (false == tokPlatform->flags.flag4IsVariableLength) { + switch (tokPlatform->id) { + default: + if (tokPlatform->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { + dst.AuxSecSurf.Platform.eProductFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { + dst.AuxSecSurf.Platform.ePCHProductFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { + dst.AuxSecSurf.Platform.eDisplayCoreFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { + dst.AuxSecSurf.Platform.eRenderCoreFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { + dst.AuxSecSurf.Platform.ePlatformType = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { + dst.AuxSecSurf.Platform.usDeviceID = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID: { + dst.AuxSecSurf.Platform.usRevId = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { + dst.AuxSecSurf.Platform.usDeviceID_PCH = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { + dst.AuxSecSurf.Platform.usRevId_PCH = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_GTTYPE: { + dst.AuxSecSurf.Platform.eGTType = readTokValue(*tokPlatform); + } break; + }; + tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokPlatform); + if (tokPlatform->flags.flag3IsMandatory) { + return false; + } + tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokPlatform == tokPlatformEnd); +#endif + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__EXISTING_SYS_MEM: { + const TokenHeader *tokExistingSysMem = varLen->getValue(); + const TokenHeader *tokExistingSysMemEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokExistingSysMem < tokExistingSysMemEnd) { + if (false == tokExistingSysMem->flags.flag4IsVariableLength) { + switch (tokExistingSysMem->id) { + default: + if (tokExistingSysMem->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_GMM_ALLOCATED: { + dst.AuxSecSurf.ExistingSysMem.IsGmmAllocated = readTokValue(*tokExistingSysMem); + } break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_PAGE_ALIGNED: { + dst.AuxSecSurf.ExistingSysMem.IsPageAligned = readTokValue(*tokExistingSysMem); + } break; + }; + tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokExistingSysMem); + if (tokExistingSysMem->flags.flag3IsMandatory) { + return false; + } + tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: { +#if !(_DEBUG || _RELEASE_INTERNAL) + const TokenHeader *tok__Platform = varLen->getValue(); + const TokenHeader *tok__PlatformEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tok__Platform < tok__PlatformEnd) { + if (false == tok__Platform->flags.flag4IsVariableLength) { + switch (tok__Platform->id) { + default: + if (tok__Platform->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { + dst.AuxSecSurf.__Platform.eProductFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { + dst.AuxSecSurf.__Platform.ePCHProductFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { + dst.AuxSecSurf.__Platform.eDisplayCoreFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { + dst.AuxSecSurf.__Platform.eRenderCoreFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { + dst.AuxSecSurf.__Platform.ePlatformType = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { + dst.AuxSecSurf.__Platform.usDeviceID = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID: { + dst.AuxSecSurf.__Platform.usRevId = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { + dst.AuxSecSurf.__Platform.usDeviceID_PCH = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { + dst.AuxSecSurf.__Platform.usRevId_PCH = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_GTTYPE: { + dst.AuxSecSurf.__Platform.eGTType = readTokValue(*tok__Platform); + } break; + }; + tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok__Platform); + if (tok__Platform->flags.flag3IsMandatory) { + return false; + } + tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok__Platform == tok__PlatformEnd); +#endif + } break; + }; + tokAuxSecSurf = tokAuxSecSurf + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokAuxSecSurf == tokAuxSecSurfEnd); + } break; + case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__EXISTING_SYS_MEM: { + const TokenHeader *tokExistingSysMem = varLen->getValue(); + const TokenHeader *tokExistingSysMemEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokExistingSysMem < tokExistingSysMemEnd) { + if (false == tokExistingSysMem->flags.flag4IsVariableLength) { + switch (tokExistingSysMem->id) { + default: + if (tokExistingSysMem->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_EXISTING_SYS_MEM: { + dst.ExistingSysMem.pExistingSysMem = readTokValue(*tokExistingSysMem); + } break; + case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_VIRT_ADDRESS: { + dst.ExistingSysMem.pVirtAddress = readTokValue(*tokExistingSysMem); + } break; + case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_GFX_ALIGNED_VIRT_ADDRESS: { + dst.ExistingSysMem.pGfxAlignedVirtAddress = readTokValue(*tokExistingSysMem); + } break; + case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__SIZE: { + dst.ExistingSysMem.Size = readTokValue(*tokExistingSysMem); + } break; + case TOK_FBC_GMM_EXISTING_SYS_MEM_REC__IS_GMM_ALLOCATED: { + dst.ExistingSysMem.IsGmmAllocated = readTokValue(*tokExistingSysMem); + } break; + }; + tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokExistingSysMem); + if (tokExistingSysMem->flags.flag3IsMandatory) { + return false; + } + tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd); + } break; + case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__MULTI_TILE_ARCH: { + const TokenHeader *tokMultiTileArch = varLen->getValue(); + const TokenHeader *tokMultiTileArchEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokMultiTileArch < tokMultiTileArchEnd) { + if (false == tokMultiTileArch->flags.flag4IsVariableLength) { + switch (tokMultiTileArch->id) { + default: + if (tokMultiTileArch->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__ENABLE: { + dst.MultiTileArch.Enable = readTokValue(*tokMultiTileArch); + } break; + case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__TILE_INSTANCED: { + dst.MultiTileArch.TileInstanced = readTokValue(*tokMultiTileArch); + } break; + case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__GPU_VA_MAPPING_SET: { + dst.MultiTileArch.GpuVaMappingSet = readTokValue(*tokMultiTileArch); + } break; + case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__LOCAL_MEM_ELIGIBILITY_SET: { + dst.MultiTileArch.LocalMemEligibilitySet = readTokValue(*tokMultiTileArch); + } break; + case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__LOCAL_MEM_PREFERRED_SET: { + dst.MultiTileArch.LocalMemPreferredSet = readTokValue(*tokMultiTileArch); + } break; + }; + tokMultiTileArch = tokMultiTileArch + 1 + tokMultiTileArch->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokMultiTileArch); + if (tokMultiTileArch->flags.flag3IsMandatory) { + return false; + } + tokMultiTileArch = tokMultiTileArch + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokMultiTileArch == tokMultiTileArchEnd); + } break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(GmmResourceInfoWinStructT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + if (tok->flags.flag3IsMandatory) { + return false; + } + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GMM_RESOURCE_INFO_WIN_STRUCT: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + case TOK_FS_GMM_RESOURCE_INFO_WIN_STRUCT__GMM_RESOURCE_INFO_COMMON: { + const TokenHeader *tokGmmResourceInfoCommon = varLen->getValue(); + const TokenHeader *tokGmmResourceInfoCommonEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokGmmResourceInfoCommon < tokGmmResourceInfoCommonEnd) { + if (false == tokGmmResourceInfoCommon->flags.flag4IsVariableLength) { + switch (tokGmmResourceInfoCommon->id) { + default: + if (tokGmmResourceInfoCommon->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GMM_RESOURCE_INFO_COMMON_STRUCT__CLIENT_TYPE: { + dst.GmmResourceInfoCommon.ClientType = readTokValue(*tokGmmResourceInfoCommon); + } break; + case TOK_FBD_GMM_RESOURCE_INFO_COMMON_STRUCT__ROTATE_INFO: { + dst.GmmResourceInfoCommon.RotateInfo = readTokValue(*tokGmmResourceInfoCommon); + } break; + case TOK_FBQ_GMM_RESOURCE_INFO_COMMON_STRUCT__SVM_ADDRESS: { + dst.GmmResourceInfoCommon.SvmAddress = readTokValue(*tokGmmResourceInfoCommon); + } break; + case TOK_FBQ_GMM_RESOURCE_INFO_COMMON_STRUCT__P_PRIVATE_DATA: { + dst.GmmResourceInfoCommon.pPrivateData = readTokValue(*tokGmmResourceInfoCommon); + } break; + }; + tokGmmResourceInfoCommon = tokGmmResourceInfoCommon + 1 + tokGmmResourceInfoCommon->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokGmmResourceInfoCommon); + switch (tokGmmResourceInfoCommon->id) { + default: + if (tokGmmResourceInfoCommon->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__SURF: { + const TokenHeader *tokSurf = varLen->getValue(); + const TokenHeader *tokSurfEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSurf < tokSurfEnd) { + if (false == tokSurf->flags.flag4IsVariableLength) { + switch (tokSurf->id) { + default: + if (tokSurf->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GMM_TEXTURE_INFO_REC__TYPE: { + dst.GmmResourceInfoCommon.Surf.Type = readTokValue(*tokSurf); + } break; + case TOK_FE_GMM_TEXTURE_INFO_REC__FORMAT: { + dst.GmmResourceInfoCommon.Surf.Format = readTokValue(*tokSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__BITS_PER_PIXEL: { + dst.GmmResourceInfoCommon.Surf.BitsPerPixel = readTokValue(*tokSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__BASE_WIDTH: { + dst.GmmResourceInfoCommon.Surf.BaseWidth = readTokValue(*tokSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__BASE_HEIGHT: { + dst.GmmResourceInfoCommon.Surf.BaseHeight = readTokValue(*tokSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__DEPTH: { + dst.GmmResourceInfoCommon.Surf.Depth = readTokValue(*tokSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__MAX_LOD: { + dst.GmmResourceInfoCommon.Surf.MaxLod = readTokValue(*tokSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__ARRAY_SIZE: { + dst.GmmResourceInfoCommon.Surf.ArraySize = readTokValue(*tokSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__CP_TAG: { + dst.GmmResourceInfoCommon.Surf.CpTag = readTokValue(*tokSurf); + } break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_MODE: { + auto srcData = reinterpret_cast &>(*tokSurf).getValue(); + auto srcSize = reinterpret_cast &>(*tokSurf).getValueSizeInBytes(); + if (srcSize < sizeof(dst.GmmResourceInfoCommon.Surf.MmcMode)) { + return false; + } + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.MmcMode, sizeof(dst.GmmResourceInfoCommon.Surf.MmcMode), srcData, sizeof(dst.GmmResourceInfoCommon.Surf.MmcMode)); + } break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_HINT: { + auto srcData = reinterpret_cast &>(*tokSurf).getValue(); + auto srcSize = reinterpret_cast &>(*tokSurf).getValueSizeInBytes(); + if (srcSize < sizeof(dst.GmmResourceInfoCommon.Surf.MmcHint)) { + return false; + } + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.MmcHint, sizeof(dst.GmmResourceInfoCommon.Surf.MmcHint), srcData, sizeof(dst.GmmResourceInfoCommon.Surf.MmcHint)); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__PITCH: { + dst.GmmResourceInfoCommon.Surf.Pitch = readTokValue(*tokSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__OVERRIDE_PITCH: { + dst.GmmResourceInfoCommon.Surf.OverridePitch = readTokValue(*tokSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE: { + dst.GmmResourceInfoCommon.Surf.Size = readTokValue(*tokSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__CCSIZE: { + dst.GmmResourceInfoCommon.Surf.CCSize = readTokValue(*tokSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__UNPADDED_SIZE: { + dst.GmmResourceInfoCommon.Surf.UnpaddedSize = readTokValue(*tokSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE_REPORT_TO_OS: { + dst.GmmResourceInfoCommon.Surf.SizeReportToOS = readTokValue(*tokSurf); + } break; + case TOK_FE_GMM_TEXTURE_INFO_REC__TILE_MODE: { + dst.GmmResourceInfoCommon.Surf.TileMode = readTokValue(*tokSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__CCSMODE_ALIGN: { + dst.GmmResourceInfoCommon.Surf.CCSModeAlign = readTokValue(*tokSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__LEGACY_FLAGS: { + dst.GmmResourceInfoCommon.Surf.LegacyFlags = readTokValue(*tokSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__MAXIMUM_RENAMING_LIST_LENGTH: { + dst.GmmResourceInfoCommon.Surf.MaximumRenamingListLength = readTokValue(*tokSurf); + } break; + }; + tokSurf = tokSurf + 1 + tokSurf->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSurf); + switch (tokSurf->id) { + default: + if (tokSurf->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_TEXTURE_INFO_REC__FLAGS: { + const TokenHeader *tokFlags = varLen->getValue(); + const TokenHeader *tokFlagsEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokFlags < tokFlagsEnd) { + if (false == tokFlags->flags.flag4IsVariableLength) { + if (tokFlags->flags.flag3IsMandatory) { + return false; + } + tokFlags = tokFlags + 1 + tokFlags->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokFlags); + switch (tokFlags->id) { + default: + if (tokFlags->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_RESOURCE_FLAG_REC__GPU: { + const TokenHeader *tokGpu = varLen->getValue(); + const TokenHeader *tokGpuEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokGpu < tokGpuEnd) { + if (false == tokGpu->flags.flag4IsVariableLength) { + switch (tokGpu->id) { + default: + if (tokGpu->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CAMERA_CAPTURE: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.CameraCapture = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CCS: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.CCS = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_DISCARD: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ColorDiscard = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ColorSeparation = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION_RGBX: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ColorSeparationRGBX = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CONSTANT: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Constant = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__DEPTH: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Depth = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.FlipChain = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN_PREFERRED: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.FlipChainPreferred = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HISTORY_BUFFER: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.HistoryBuffer = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HI_Z: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.HiZ = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDEX: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Index = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDIRECT_CLEAR_COLOR: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.IndirectClearColor = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INSTRUCTION_FLAT: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.InstructionFlat = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INTERLACED_SCAN: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.InterlacedScan = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MCS: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.MCS = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MMC: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.MMC = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MOTION_COMP: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.MotionComp = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__NO_RESTRICTION: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.NoRestriction = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__OVERLAY: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Overlay = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PRESENTABLE: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Presentable = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PROCEDURAL_TEXTURE: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ProceduralTexture = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__QUERY: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Query = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__RENDER_TARGET: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.RenderTarget = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.S3d = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D_DX: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.S3dDx = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_NON_PACKED: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__S3dNonPacked = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_WIDI: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__S3dWidi = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SCRATCH_FLAT: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ScratchFlat = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SEPARATE_STENCIL: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.SeparateStencil = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.State = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE_DX9CONSTANT_BUFFER: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.StateDx9ConstantBuffer = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STREAM: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Stream = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXT_API: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.TextApi = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXTURE: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Texture = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILED_RESOURCE: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.TiledResource = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILE_POOL: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.TilePool = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__UNIFIED_AUX_SURFACE: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.UnifiedAuxSurface = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VERTEX: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Vertex = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VIDEO: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Video = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_XCCS: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__NonMsaaTileXCcs = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_YCCS: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__NonMsaaTileYCcs = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____MSAA_TILE_MCS: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__MsaaTileMcs = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_LINEAR_CCS: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__NonMsaaLinearCCS = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____REMAINING: { + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__Remaining = readTokValue(*tokGpu); + } break; + }; + tokGpu = tokGpu + 1 + tokGpu->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokGpu); + if (tokGpu->flags.flag3IsMandatory) { + return false; + } + tokGpu = tokGpu + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokGpu == tokGpuEnd); + } break; + case TOK_FS_GMM_RESOURCE_FLAG_REC__INFO: { + const TokenHeader *tokInfo = varLen->getValue(); + const TokenHeader *tokInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokInfo < tokInfoEnd) { + if (false == tokInfo->flags.flag4IsVariableLength) { + switch (tokInfo->id) { + default: + if (tokInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ALLOW_VIRTUAL_PADDING: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.AllowVirtualPadding = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__BIG_PAGE: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.BigPage = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CACHEABLE: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.Cacheable = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CONTIG_PHYS_MEMORY_FORI_DART: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.ContigPhysMemoryForiDART = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CORNER_TEXEL_MODE: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.CornerTexelMode = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__EXISTING_SYS_MEM: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.ExistingSysMem = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__FORCE_RESIDENCY: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.ForceResidency = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GFDT: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.Gfdt = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GTT_MAP_TYPE: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.GttMapType = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__HARDWARE_PROTECTED: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.HardwareProtected = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__KERNEL_MODE_MAPPED: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.KernelModeMapped = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_BELOW: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.LayoutBelow = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_MONO: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.LayoutMono = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_RIGHT: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.LayoutRight = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LOCAL_ONLY: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.LocalOnly = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LINEAR: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.Linear = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__MEDIA_COMPRESSED: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.MediaCompressed = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_OPTIMIZATION_PADDING: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.NoOptimizationPadding = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_PHYS_MEMORY: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.NoPhysMemory = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NOT_LOCKABLE: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.NotLockable = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NON_LOCAL_ONLY: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.NonLocalOnly = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__STD_SWIZZLE: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.StdSwizzle = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__PSEUDO_STD_SWIZZLE: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.PseudoStdSwizzle = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__UNDEFINED64KBSWIZZLE: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.Undefined64KBSwizzle = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__REDECRIBED_PLANES: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.RedecribedPlanes = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__RENDER_COMPRESSED: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.RenderCompressed = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ROTATED: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.Rotated = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SHARED: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.Shared = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SOFTWARE_PROTECTED: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.SoftwareProtected = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SVM: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.SVM = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE4: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.Tile4 = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE64: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.Tile64 = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_W: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledW = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_X: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledX = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_Y: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledY = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YF: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledYf = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YS: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledYs = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__WDDM_PROTECTED: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.WddmProtected = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__XADAPTER: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.XAdapter = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PREALLOCATED_RES_INFO: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.__PreallocatedResInfo = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PRE_WDDM2SVM: { + dst.GmmResourceInfoCommon.Surf.Flags.Info.__PreWddm2SVM = readTokValue(*tokInfo); + } break; + }; + tokInfo = tokInfo + 1 + tokInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokInfo); + if (tokInfo->flags.flag3IsMandatory) { + return false; + } + tokInfo = tokInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokInfo == tokInfoEnd); + } break; + case TOK_FS_GMM_RESOURCE_FLAG_REC__WA: { + const TokenHeader *tokWa = varLen->getValue(); + const TokenHeader *tokWaEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokWa < tokWaEnd) { + if (false == tokWa->flags.flag4IsVariableLength) { + switch (tokWa->id) { + default: + if (tokWa->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__GTMFX2ND_LEVEL_BATCH_RING_SIZE_ALIGN: { + dst.GmmResourceInfoCommon.Surf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_MPR_ROW_STORE32KALIGN: { + dst.GmmResourceInfoCommon.Surf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_DMV_BUFFER32KALIGN: { + dst.GmmResourceInfoCommon.Surf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_BUFFER_SAMPLER_PADDING: { + dst.GmmResourceInfoCommon.Surf.Flags.Wa.NoBufferSamplerPadding = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_LEGACY_PLANAR_LINEAR_VIDEO_RESTRICTIONS: { + dst.GmmResourceInfoCommon.Surf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__CHVASTC_SKIP_VIRTUAL_MIPS: { + dst.GmmResourceInfoCommon.Surf.Flags.Wa.CHVAstcSkipVirtualMips = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_PACKED_MIP_TAIL: { + dst.GmmResourceInfoCommon.Surf.Flags.Wa.DisablePackedMipTail = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521____FORCE_OTHER_HVALIGN4: { + dst.GmmResourceInfoCommon.Surf.Flags.Wa.__ForceOtherHVALIGN4 = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR: { + dst.GmmResourceInfoCommon.Surf.Flags.Wa.DisableDisplayCcsClearColor = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION: { + dst.GmmResourceInfoCommon.Surf.Flags.Wa.DisableDisplayCcsCompression = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: { + dst.GmmResourceInfoCommon.Surf.Flags.Wa.PreGen12FastClearOnly = readTokValue(*tokWa); + } break; + }; + tokWa = tokWa + 1 + tokWa->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokWa); + if (tokWa->flags.flag3IsMandatory) { + return false; + } + tokWa = tokWa + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokWa == tokWaEnd); + } break; + }; + tokFlags = tokFlags + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokFlags == tokFlagsEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__CACHE_POLICY: { + const TokenHeader *tokCachePolicy = varLen->getValue(); + const TokenHeader *tokCachePolicyEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokCachePolicy < tokCachePolicyEnd) { + if (false == tokCachePolicy->flags.flag4IsVariableLength) { + switch (tokCachePolicy->id) { + default: + if (tokCachePolicy->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GMM_TEXTURE_INFO_REC__ANONYMOUS4927__USAGE: { + dst.GmmResourceInfoCommon.Surf.CachePolicy.Usage = readTokValue(*tokCachePolicy); + } break; + }; + tokCachePolicy = tokCachePolicy + 1 + tokCachePolicy->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokCachePolicy); + if (tokCachePolicy->flags.flag3IsMandatory) { + return false; + } + tokCachePolicy = tokCachePolicy + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokCachePolicy == tokCachePolicyEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__MSAA: { + const TokenHeader *tokMSAA = varLen->getValue(); + const TokenHeader *tokMSAAEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokMSAA < tokMSAAEnd) { + if (false == tokMSAA->flags.flag4IsVariableLength) { + switch (tokMSAA->id) { + default: + if (tokMSAA->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GMM_RESOURCE_MSAA_INFO_REC__SAMPLE_PATTERN: { + dst.GmmResourceInfoCommon.Surf.MSAA.SamplePattern = readTokValue(*tokMSAA); + } break; + case TOK_FBD_GMM_RESOURCE_MSAA_INFO_REC__NUM_SAMPLES: { + dst.GmmResourceInfoCommon.Surf.MSAA.NumSamples = readTokValue(*tokMSAA); + } break; + }; + tokMSAA = tokMSAA + 1 + tokMSAA->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokMSAA); + if (tokMSAA->flags.flag3IsMandatory) { + return false; + } + tokMSAA = tokMSAA + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokMSAA == tokMSAAEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__ALIGNMENT: { + const TokenHeader *tokAlignment = varLen->getValue(); + const TokenHeader *tokAlignmentEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokAlignment < tokAlignmentEnd) { + if (false == tokAlignment->flags.flag4IsVariableLength) { + switch (tokAlignment->id) { + default: + if (tokAlignment->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBC_GMM_RESOURCE_ALIGNMENT_REC__ARRAY_SPACING_SINGLE_LOD: { + dst.GmmResourceInfoCommon.Surf.Alignment.ArraySpacingSingleLod = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__BASE_ALIGNMENT: { + dst.GmmResourceInfoCommon.Surf.Alignment.BaseAlignment = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__HALIGN: { + dst.GmmResourceInfoCommon.Surf.Alignment.HAlign = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__VALIGN: { + dst.GmmResourceInfoCommon.Surf.Alignment.VAlign = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__DALIGN: { + dst.GmmResourceInfoCommon.Surf.Alignment.DAlign = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__MIP_TAIL_START_LOD: { + dst.GmmResourceInfoCommon.Surf.Alignment.MipTailStartLod = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_START_LOD: { + dst.GmmResourceInfoCommon.Surf.Alignment.PackedMipStartLod = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_WIDTH: { + dst.GmmResourceInfoCommon.Surf.Alignment.PackedMipWidth = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_HEIGHT: { + dst.GmmResourceInfoCommon.Surf.Alignment.PackedMipHeight = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__QPITCH: { + dst.GmmResourceInfoCommon.Surf.Alignment.QPitch = readTokValue(*tokAlignment); + } break; + }; + tokAlignment = tokAlignment + 1 + tokAlignment->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokAlignment); + if (tokAlignment->flags.flag3IsMandatory) { + return false; + } + tokAlignment = tokAlignment + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokAlignment == tokAlignmentEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__OFFSET_INFO: { + const TokenHeader *tokOffsetInfo = varLen->getValue(); + const TokenHeader *tokOffsetInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokOffsetInfo < tokOffsetInfoEnd) { + if (false == tokOffsetInfo->flags.flag4IsVariableLength) { + if (tokOffsetInfo->flags.flag3IsMandatory) { + return false; + } + tokOffsetInfo = tokOffsetInfo + 1 + tokOffsetInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokOffsetInfo); + switch (tokOffsetInfo->id) { + default: + if (tokOffsetInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO: { + const TokenHeader *tokTexture3DOffsetInfo = varLen->getValue(); + const TokenHeader *tokTexture3DOffsetInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokTexture3DOffsetInfo < tokTexture3DOffsetInfoEnd) { + if (false == tokTexture3DOffsetInfo->flags.flag4IsVariableLength) { + switch (tokTexture3DOffsetInfo->id) { + default: + if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: { + dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch = readTokValue(*tokTexture3DOffsetInfo); + } break; + case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: { + auto srcData = reinterpret_cast &>(*tokTexture3DOffsetInfo).getValue(); + auto srcSize = reinterpret_cast &>(*tokTexture3DOffsetInfo).getValueSizeInBytes(); + if (srcSize < sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture3DOffsetInfo.Offset)) { + return false; + } + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture3DOffsetInfo.Offset), srcData, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture3DOffsetInfo.Offset)); + } break; + }; + tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + 1 + tokTexture3DOffsetInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokTexture3DOffsetInfo); + if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokTexture3DOffsetInfo == tokTexture3DOffsetInfoEnd); + } break; + case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO: { + const TokenHeader *tokTexture2DOffsetInfo = varLen->getValue(); + const TokenHeader *tokTexture2DOffsetInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokTexture2DOffsetInfo < tokTexture2DOffsetInfoEnd) { + if (false == tokTexture2DOffsetInfo->flags.flag4IsVariableLength) { + switch (tokTexture2DOffsetInfo->id) { + default: + if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: { + dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock = readTokValue(*tokTexture2DOffsetInfo); + } break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: { + dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender = readTokValue(*tokTexture2DOffsetInfo); + } break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: { + auto srcData = reinterpret_cast &>(*tokTexture2DOffsetInfo).getValue(); + auto srcSize = reinterpret_cast &>(*tokTexture2DOffsetInfo).getValueSizeInBytes(); + if (srcSize < sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.Offset)) { + return false; + } + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.Offset), srcData, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.Offset)); + } break; + }; + tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + 1 + tokTexture2DOffsetInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokTexture2DOffsetInfo); + if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokTexture2DOffsetInfo == tokTexture2DOffsetInfoEnd); + } break; + case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE: { + const TokenHeader *tokPlane = varLen->getValue(); + const TokenHeader *tokPlaneEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokPlane < tokPlaneEnd) { + if (false == tokPlane->flags.flag4IsVariableLength) { + switch (tokPlane->id) { + default: + if (tokPlane->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: { + dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.ArrayQPitch = readTokValue(*tokPlane); + } break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: { + auto srcData = reinterpret_cast &>(*tokPlane).getValue(); + auto srcSize = reinterpret_cast &>(*tokPlane).getValueSizeInBytes(); + if (srcSize < sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.X)) { + return false; + } + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.X, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.X), srcData, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.X)); + } break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: { + auto srcData = reinterpret_cast &>(*tokPlane).getValue(); + auto srcSize = reinterpret_cast &>(*tokPlane).getValueSizeInBytes(); + if (srcSize < sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.Y)) { + return false; + } + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.Y, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.Y), srcData, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.Y)); + } break; + case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: { + dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.NoOfPlanes = readTokValue(*tokPlane); + } break; + case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: { + dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.IsTileAlignedPlanes = readTokValue(*tokPlane); + } break; + }; + tokPlane = tokPlane + 1 + tokPlane->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokPlane); + switch (tokPlane->id) { + default: + if (tokPlane->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: { + const TokenHeader *tokUnAligned = varLen->getValue(); + const TokenHeader *tokUnAlignedEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokUnAligned < tokUnAlignedEnd) { + if (false == tokUnAligned->flags.flag4IsVariableLength) { + switch (tokUnAligned->id) { + default: + if (tokUnAligned->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: { + auto srcData = reinterpret_cast &>(*tokUnAligned).getValue(); + auto srcSize = reinterpret_cast &>(*tokUnAligned).getValueSizeInBytes(); + if (srcSize < sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.UnAligned.Height)) { + return false; + } + 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)); + } break; + }; + tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokUnAligned); + if (tokUnAligned->flags.flag3IsMandatory) { + return false; + } + tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokUnAligned == tokUnAlignedEnd); + } break; + }; + tokPlane = tokPlane + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokPlane == tokPlaneEnd); + } break; + }; + tokOffsetInfo = tokOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokOffsetInfo == tokOffsetInfoEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__S3D: { + const TokenHeader *tokS3d = varLen->getValue(); + const TokenHeader *tokS3dEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokS3d < tokS3dEnd) { + if (false == tokS3d->flags.flag4IsVariableLength) { + switch (tokS3d->id) { + default: + if (tokS3d->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_S3D_INFO_REC__DISPLAY_MODE_HEIGHT: { + dst.GmmResourceInfoCommon.Surf.S3d.DisplayModeHeight = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__NUM_BLANK_ACTIVE_LINES: { + dst.GmmResourceInfoCommon.Surf.S3d.NumBlankActiveLines = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__RFRAME_OFFSET: { + dst.GmmResourceInfoCommon.Surf.S3d.RFrameOffset = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__BLANK_AREA_OFFSET: { + dst.GmmResourceInfoCommon.Surf.S3d.BlankAreaOffset = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_HEIGHT: { + dst.GmmResourceInfoCommon.Surf.S3d.TallBufferHeight = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_SIZE: { + dst.GmmResourceInfoCommon.Surf.S3d.TallBufferSize = readTokValue(*tokS3d); + } break; + case TOK_FBC_GMM_S3D_INFO_REC__IS_RFRAME: { + dst.GmmResourceInfoCommon.Surf.S3d.IsRFrame = readTokValue(*tokS3d); + } break; + }; + tokS3d = tokS3d + 1 + tokS3d->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokS3d); + if (tokS3d->flags.flag3IsMandatory) { + return false; + } + tokS3d = tokS3d + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokS3d == tokS3dEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__SEGMENT_OVERRIDE: { + const TokenHeader *tokSegmentOverride = varLen->getValue(); + const TokenHeader *tokSegmentOverrideEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSegmentOverride < tokSegmentOverrideEnd) { + if (false == tokSegmentOverride->flags.flag4IsVariableLength) { + switch (tokSegmentOverride->id) { + default: + if (tokSegmentOverride->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__SEG1: { + dst.GmmResourceInfoCommon.Surf.SegmentOverride.Seg1 = readTokValue(*tokSegmentOverride); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__EVICT: { + dst.GmmResourceInfoCommon.Surf.SegmentOverride.Evict = readTokValue(*tokSegmentOverride); + } break; + }; + tokSegmentOverride = tokSegmentOverride + 1 + tokSegmentOverride->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSegmentOverride); + if (tokSegmentOverride->flags.flag3IsMandatory) { + return false; + } + tokSegmentOverride = tokSegmentOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSegmentOverride == tokSegmentOverrideEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__PLATFORM: { +#if _DEBUG || _RELEASE_INTERNAL + const TokenHeader *tokPlatform = varLen->getValue(); + const TokenHeader *tokPlatformEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokPlatform < tokPlatformEnd) { + if (false == tokPlatform->flags.flag4IsVariableLength) { + switch (tokPlatform->id) { + default: + if (tokPlatform->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { + dst.GmmResourceInfoCommon.Surf.Platform.eProductFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { + dst.GmmResourceInfoCommon.Surf.Platform.ePCHProductFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { + dst.GmmResourceInfoCommon.Surf.Platform.eDisplayCoreFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { + dst.GmmResourceInfoCommon.Surf.Platform.eRenderCoreFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { + dst.GmmResourceInfoCommon.Surf.Platform.ePlatformType = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { + dst.GmmResourceInfoCommon.Surf.Platform.usDeviceID = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID: { + dst.GmmResourceInfoCommon.Surf.Platform.usRevId = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { + dst.GmmResourceInfoCommon.Surf.Platform.usDeviceID_PCH = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { + dst.GmmResourceInfoCommon.Surf.Platform.usRevId_PCH = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_GTTYPE: { + dst.GmmResourceInfoCommon.Surf.Platform.eGTType = readTokValue(*tokPlatform); + } break; + }; + tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokPlatform); + if (tokPlatform->flags.flag3IsMandatory) { + return false; + } + tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokPlatform == tokPlatformEnd); +#endif + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__EXISTING_SYS_MEM: { + const TokenHeader *tokExistingSysMem = varLen->getValue(); + const TokenHeader *tokExistingSysMemEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokExistingSysMem < tokExistingSysMemEnd) { + if (false == tokExistingSysMem->flags.flag4IsVariableLength) { + switch (tokExistingSysMem->id) { + default: + if (tokExistingSysMem->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_GMM_ALLOCATED: { + dst.GmmResourceInfoCommon.Surf.ExistingSysMem.IsGmmAllocated = readTokValue(*tokExistingSysMem); + } break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_PAGE_ALIGNED: { + dst.GmmResourceInfoCommon.Surf.ExistingSysMem.IsPageAligned = readTokValue(*tokExistingSysMem); + } break; + }; + tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokExistingSysMem); + if (tokExistingSysMem->flags.flag3IsMandatory) { + return false; + } + tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: { +#if !(_DEBUG || _RELEASE_INTERNAL) + const TokenHeader *tok__Platform = varLen->getValue(); + const TokenHeader *tok__PlatformEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tok__Platform < tok__PlatformEnd) { + if (false == tok__Platform->flags.flag4IsVariableLength) { + switch (tok__Platform->id) { + default: + if (tok__Platform->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { + dst.GmmResourceInfoCommon.Surf.__Platform.eProductFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { + dst.GmmResourceInfoCommon.Surf.__Platform.ePCHProductFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { + dst.GmmResourceInfoCommon.Surf.__Platform.eDisplayCoreFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { + dst.GmmResourceInfoCommon.Surf.__Platform.eRenderCoreFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { + dst.GmmResourceInfoCommon.Surf.__Platform.ePlatformType = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { + dst.GmmResourceInfoCommon.Surf.__Platform.usDeviceID = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID: { + dst.GmmResourceInfoCommon.Surf.__Platform.usRevId = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { + dst.GmmResourceInfoCommon.Surf.__Platform.usDeviceID_PCH = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { + dst.GmmResourceInfoCommon.Surf.__Platform.usRevId_PCH = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_GTTYPE: { + dst.GmmResourceInfoCommon.Surf.__Platform.eGTType = readTokValue(*tok__Platform); + } break; + }; + tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok__Platform); + if (tok__Platform->flags.flag3IsMandatory) { + return false; + } + tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok__Platform == tok__PlatformEnd); +#endif + } break; + }; + tokSurf = tokSurf + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSurf == tokSurfEnd); + } break; + case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__AUX_SURF: { + const TokenHeader *tokAuxSurf = varLen->getValue(); + const TokenHeader *tokAuxSurfEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokAuxSurf < tokAuxSurfEnd) { + if (false == tokAuxSurf->flags.flag4IsVariableLength) { + switch (tokAuxSurf->id) { + default: + if (tokAuxSurf->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GMM_TEXTURE_INFO_REC__TYPE: { + dst.GmmResourceInfoCommon.AuxSurf.Type = readTokValue(*tokAuxSurf); + } break; + case TOK_FE_GMM_TEXTURE_INFO_REC__FORMAT: { + dst.GmmResourceInfoCommon.AuxSurf.Format = readTokValue(*tokAuxSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__BITS_PER_PIXEL: { + dst.GmmResourceInfoCommon.AuxSurf.BitsPerPixel = readTokValue(*tokAuxSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__BASE_WIDTH: { + dst.GmmResourceInfoCommon.AuxSurf.BaseWidth = readTokValue(*tokAuxSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__BASE_HEIGHT: { + dst.GmmResourceInfoCommon.AuxSurf.BaseHeight = readTokValue(*tokAuxSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__DEPTH: { + dst.GmmResourceInfoCommon.AuxSurf.Depth = readTokValue(*tokAuxSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__MAX_LOD: { + dst.GmmResourceInfoCommon.AuxSurf.MaxLod = readTokValue(*tokAuxSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__ARRAY_SIZE: { + dst.GmmResourceInfoCommon.AuxSurf.ArraySize = readTokValue(*tokAuxSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__CP_TAG: { + dst.GmmResourceInfoCommon.AuxSurf.CpTag = readTokValue(*tokAuxSurf); + } break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_MODE: { + auto srcData = reinterpret_cast &>(*tokAuxSurf).getValue(); + auto srcSize = reinterpret_cast &>(*tokAuxSurf).getValueSizeInBytes(); + if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSurf.MmcMode)) { + return false; + } + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.MmcMode, sizeof(dst.GmmResourceInfoCommon.AuxSurf.MmcMode), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSurf.MmcMode)); + } break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_HINT: { + auto srcData = reinterpret_cast &>(*tokAuxSurf).getValue(); + auto srcSize = reinterpret_cast &>(*tokAuxSurf).getValueSizeInBytes(); + if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSurf.MmcHint)) { + return false; + } + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.MmcHint, sizeof(dst.GmmResourceInfoCommon.AuxSurf.MmcHint), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSurf.MmcHint)); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__PITCH: { + dst.GmmResourceInfoCommon.AuxSurf.Pitch = readTokValue(*tokAuxSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__OVERRIDE_PITCH: { + dst.GmmResourceInfoCommon.AuxSurf.OverridePitch = readTokValue(*tokAuxSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE: { + dst.GmmResourceInfoCommon.AuxSurf.Size = readTokValue(*tokAuxSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__CCSIZE: { + dst.GmmResourceInfoCommon.AuxSurf.CCSize = readTokValue(*tokAuxSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__UNPADDED_SIZE: { + dst.GmmResourceInfoCommon.AuxSurf.UnpaddedSize = readTokValue(*tokAuxSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE_REPORT_TO_OS: { + dst.GmmResourceInfoCommon.AuxSurf.SizeReportToOS = readTokValue(*tokAuxSurf); + } break; + case TOK_FE_GMM_TEXTURE_INFO_REC__TILE_MODE: { + dst.GmmResourceInfoCommon.AuxSurf.TileMode = readTokValue(*tokAuxSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__CCSMODE_ALIGN: { + dst.GmmResourceInfoCommon.AuxSurf.CCSModeAlign = readTokValue(*tokAuxSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__LEGACY_FLAGS: { + dst.GmmResourceInfoCommon.AuxSurf.LegacyFlags = readTokValue(*tokAuxSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__MAXIMUM_RENAMING_LIST_LENGTH: { + dst.GmmResourceInfoCommon.AuxSurf.MaximumRenamingListLength = readTokValue(*tokAuxSurf); + } break; + }; + tokAuxSurf = tokAuxSurf + 1 + tokAuxSurf->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokAuxSurf); + switch (tokAuxSurf->id) { + default: + if (tokAuxSurf->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_TEXTURE_INFO_REC__FLAGS: { + const TokenHeader *tokFlags = varLen->getValue(); + const TokenHeader *tokFlagsEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokFlags < tokFlagsEnd) { + if (false == tokFlags->flags.flag4IsVariableLength) { + if (tokFlags->flags.flag3IsMandatory) { + return false; + } + tokFlags = tokFlags + 1 + tokFlags->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokFlags); + switch (tokFlags->id) { + default: + if (tokFlags->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_RESOURCE_FLAG_REC__GPU: { + const TokenHeader *tokGpu = varLen->getValue(); + const TokenHeader *tokGpuEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokGpu < tokGpuEnd) { + if (false == tokGpu->flags.flag4IsVariableLength) { + switch (tokGpu->id) { + default: + if (tokGpu->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CAMERA_CAPTURE: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.CameraCapture = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CCS: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.CCS = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_DISCARD: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ColorDiscard = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ColorSeparation = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION_RGBX: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ColorSeparationRGBX = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CONSTANT: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Constant = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__DEPTH: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Depth = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.FlipChain = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN_PREFERRED: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.FlipChainPreferred = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HISTORY_BUFFER: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.HistoryBuffer = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HI_Z: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.HiZ = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDEX: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Index = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDIRECT_CLEAR_COLOR: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.IndirectClearColor = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INSTRUCTION_FLAT: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.InstructionFlat = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INTERLACED_SCAN: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.InterlacedScan = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MCS: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.MCS = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MMC: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.MMC = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MOTION_COMP: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.MotionComp = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__NO_RESTRICTION: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.NoRestriction = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__OVERLAY: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Overlay = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PRESENTABLE: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Presentable = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PROCEDURAL_TEXTURE: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ProceduralTexture = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__QUERY: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Query = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__RENDER_TARGET: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.RenderTarget = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.S3d = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D_DX: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.S3dDx = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_NON_PACKED: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__S3dNonPacked = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_WIDI: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__S3dWidi = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SCRATCH_FLAT: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ScratchFlat = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SEPARATE_STENCIL: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.SeparateStencil = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.State = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE_DX9CONSTANT_BUFFER: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.StateDx9ConstantBuffer = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STREAM: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Stream = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXT_API: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.TextApi = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXTURE: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Texture = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILED_RESOURCE: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.TiledResource = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILE_POOL: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.TilePool = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__UNIFIED_AUX_SURFACE: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.UnifiedAuxSurface = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VERTEX: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Vertex = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VIDEO: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Video = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_XCCS: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__NonMsaaTileXCcs = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_YCCS: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__NonMsaaTileYCcs = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____MSAA_TILE_MCS: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__MsaaTileMcs = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_LINEAR_CCS: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__NonMsaaLinearCCS = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____REMAINING: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__Remaining = readTokValue(*tokGpu); + } break; + }; + tokGpu = tokGpu + 1 + tokGpu->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokGpu); + if (tokGpu->flags.flag3IsMandatory) { + return false; + } + tokGpu = tokGpu + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokGpu == tokGpuEnd); + } break; + case TOK_FS_GMM_RESOURCE_FLAG_REC__INFO: { + const TokenHeader *tokInfo = varLen->getValue(); + const TokenHeader *tokInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokInfo < tokInfoEnd) { + if (false == tokInfo->flags.flag4IsVariableLength) { + switch (tokInfo->id) { + default: + if (tokInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ALLOW_VIRTUAL_PADDING: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.AllowVirtualPadding = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__BIG_PAGE: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.BigPage = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CACHEABLE: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Cacheable = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CONTIG_PHYS_MEMORY_FORI_DART: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.ContigPhysMemoryForiDART = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CORNER_TEXEL_MODE: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.CornerTexelMode = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__EXISTING_SYS_MEM: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.ExistingSysMem = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__FORCE_RESIDENCY: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.ForceResidency = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GFDT: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Gfdt = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GTT_MAP_TYPE: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.GttMapType = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__HARDWARE_PROTECTED: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.HardwareProtected = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__KERNEL_MODE_MAPPED: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.KernelModeMapped = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_BELOW: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.LayoutBelow = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_MONO: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.LayoutMono = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_RIGHT: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.LayoutRight = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LOCAL_ONLY: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.LocalOnly = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LINEAR: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Linear = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__MEDIA_COMPRESSED: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.MediaCompressed = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_OPTIMIZATION_PADDING: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.NoOptimizationPadding = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_PHYS_MEMORY: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.NoPhysMemory = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NOT_LOCKABLE: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.NotLockable = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NON_LOCAL_ONLY: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.NonLocalOnly = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__STD_SWIZZLE: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.StdSwizzle = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__PSEUDO_STD_SWIZZLE: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.PseudoStdSwizzle = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__UNDEFINED64KBSWIZZLE: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Undefined64KBSwizzle = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__REDECRIBED_PLANES: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.RedecribedPlanes = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__RENDER_COMPRESSED: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.RenderCompressed = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ROTATED: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Rotated = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SHARED: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Shared = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SOFTWARE_PROTECTED: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.SoftwareProtected = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SVM: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.SVM = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE4: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Tile4 = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE64: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Tile64 = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_W: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledW = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_X: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledX = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_Y: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledY = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YF: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledYf = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YS: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledYs = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__WDDM_PROTECTED: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.WddmProtected = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__XADAPTER: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.XAdapter = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PREALLOCATED_RES_INFO: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.__PreallocatedResInfo = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PRE_WDDM2SVM: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.__PreWddm2SVM = readTokValue(*tokInfo); + } break; + }; + tokInfo = tokInfo + 1 + tokInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokInfo); + if (tokInfo->flags.flag3IsMandatory) { + return false; + } + tokInfo = tokInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokInfo == tokInfoEnd); + } break; + case TOK_FS_GMM_RESOURCE_FLAG_REC__WA: { + const TokenHeader *tokWa = varLen->getValue(); + const TokenHeader *tokWaEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokWa < tokWaEnd) { + if (false == tokWa->flags.flag4IsVariableLength) { + switch (tokWa->id) { + default: + if (tokWa->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__GTMFX2ND_LEVEL_BATCH_RING_SIZE_ALIGN: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_MPR_ROW_STORE32KALIGN: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_DMV_BUFFER32KALIGN: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_BUFFER_SAMPLER_PADDING: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.NoBufferSamplerPadding = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_LEGACY_PLANAR_LINEAR_VIDEO_RESTRICTIONS: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__CHVASTC_SKIP_VIRTUAL_MIPS: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.CHVAstcSkipVirtualMips = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_PACKED_MIP_TAIL: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DisablePackedMipTail = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521____FORCE_OTHER_HVALIGN4: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.__ForceOtherHVALIGN4 = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DisableDisplayCcsClearColor = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DisableDisplayCcsCompression = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: { + dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.PreGen12FastClearOnly = readTokValue(*tokWa); + } break; + }; + tokWa = tokWa + 1 + tokWa->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokWa); + if (tokWa->flags.flag3IsMandatory) { + return false; + } + tokWa = tokWa + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokWa == tokWaEnd); + } break; + }; + tokFlags = tokFlags + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokFlags == tokFlagsEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__CACHE_POLICY: { + const TokenHeader *tokCachePolicy = varLen->getValue(); + const TokenHeader *tokCachePolicyEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokCachePolicy < tokCachePolicyEnd) { + if (false == tokCachePolicy->flags.flag4IsVariableLength) { + switch (tokCachePolicy->id) { + default: + if (tokCachePolicy->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GMM_TEXTURE_INFO_REC__ANONYMOUS4927__USAGE: { + dst.GmmResourceInfoCommon.AuxSurf.CachePolicy.Usage = readTokValue(*tokCachePolicy); + } break; + }; + tokCachePolicy = tokCachePolicy + 1 + tokCachePolicy->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokCachePolicy); + if (tokCachePolicy->flags.flag3IsMandatory) { + return false; + } + tokCachePolicy = tokCachePolicy + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokCachePolicy == tokCachePolicyEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__MSAA: { + const TokenHeader *tokMSAA = varLen->getValue(); + const TokenHeader *tokMSAAEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokMSAA < tokMSAAEnd) { + if (false == tokMSAA->flags.flag4IsVariableLength) { + switch (tokMSAA->id) { + default: + if (tokMSAA->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GMM_RESOURCE_MSAA_INFO_REC__SAMPLE_PATTERN: { + dst.GmmResourceInfoCommon.AuxSurf.MSAA.SamplePattern = readTokValue(*tokMSAA); + } break; + case TOK_FBD_GMM_RESOURCE_MSAA_INFO_REC__NUM_SAMPLES: { + dst.GmmResourceInfoCommon.AuxSurf.MSAA.NumSamples = readTokValue(*tokMSAA); + } break; + }; + tokMSAA = tokMSAA + 1 + tokMSAA->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokMSAA); + if (tokMSAA->flags.flag3IsMandatory) { + return false; + } + tokMSAA = tokMSAA + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokMSAA == tokMSAAEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__ALIGNMENT: { + const TokenHeader *tokAlignment = varLen->getValue(); + const TokenHeader *tokAlignmentEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokAlignment < tokAlignmentEnd) { + if (false == tokAlignment->flags.flag4IsVariableLength) { + switch (tokAlignment->id) { + default: + if (tokAlignment->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBC_GMM_RESOURCE_ALIGNMENT_REC__ARRAY_SPACING_SINGLE_LOD: { + dst.GmmResourceInfoCommon.AuxSurf.Alignment.ArraySpacingSingleLod = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__BASE_ALIGNMENT: { + dst.GmmResourceInfoCommon.AuxSurf.Alignment.BaseAlignment = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__HALIGN: { + dst.GmmResourceInfoCommon.AuxSurf.Alignment.HAlign = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__VALIGN: { + dst.GmmResourceInfoCommon.AuxSurf.Alignment.VAlign = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__DALIGN: { + dst.GmmResourceInfoCommon.AuxSurf.Alignment.DAlign = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__MIP_TAIL_START_LOD: { + dst.GmmResourceInfoCommon.AuxSurf.Alignment.MipTailStartLod = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_START_LOD: { + dst.GmmResourceInfoCommon.AuxSurf.Alignment.PackedMipStartLod = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_WIDTH: { + dst.GmmResourceInfoCommon.AuxSurf.Alignment.PackedMipWidth = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_HEIGHT: { + dst.GmmResourceInfoCommon.AuxSurf.Alignment.PackedMipHeight = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__QPITCH: { + dst.GmmResourceInfoCommon.AuxSurf.Alignment.QPitch = readTokValue(*tokAlignment); + } break; + }; + tokAlignment = tokAlignment + 1 + tokAlignment->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokAlignment); + if (tokAlignment->flags.flag3IsMandatory) { + return false; + } + tokAlignment = tokAlignment + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokAlignment == tokAlignmentEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__OFFSET_INFO: { + const TokenHeader *tokOffsetInfo = varLen->getValue(); + const TokenHeader *tokOffsetInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokOffsetInfo < tokOffsetInfoEnd) { + if (false == tokOffsetInfo->flags.flag4IsVariableLength) { + if (tokOffsetInfo->flags.flag3IsMandatory) { + return false; + } + tokOffsetInfo = tokOffsetInfo + 1 + tokOffsetInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokOffsetInfo); + switch (tokOffsetInfo->id) { + default: + if (tokOffsetInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO: { + const TokenHeader *tokTexture3DOffsetInfo = varLen->getValue(); + const TokenHeader *tokTexture3DOffsetInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokTexture3DOffsetInfo < tokTexture3DOffsetInfoEnd) { + if (false == tokTexture3DOffsetInfo->flags.flag4IsVariableLength) { + switch (tokTexture3DOffsetInfo->id) { + default: + if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: { + dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch = readTokValue(*tokTexture3DOffsetInfo); + } break; + case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: { + auto srcData = reinterpret_cast &>(*tokTexture3DOffsetInfo).getValue(); + auto srcSize = reinterpret_cast &>(*tokTexture3DOffsetInfo).getValueSizeInBytes(); + if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset)) { + return false; + } + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset)); + } break; + }; + tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + 1 + tokTexture3DOffsetInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokTexture3DOffsetInfo); + if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokTexture3DOffsetInfo == tokTexture3DOffsetInfoEnd); + } break; + case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO: { + const TokenHeader *tokTexture2DOffsetInfo = varLen->getValue(); + const TokenHeader *tokTexture2DOffsetInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokTexture2DOffsetInfo < tokTexture2DOffsetInfoEnd) { + if (false == tokTexture2DOffsetInfo->flags.flag4IsVariableLength) { + switch (tokTexture2DOffsetInfo->id) { + default: + if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: { + dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock = readTokValue(*tokTexture2DOffsetInfo); + } break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: { + dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender = readTokValue(*tokTexture2DOffsetInfo); + } break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: { + auto srcData = reinterpret_cast &>(*tokTexture2DOffsetInfo).getValue(); + auto srcSize = reinterpret_cast &>(*tokTexture2DOffsetInfo).getValueSizeInBytes(); + if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset)) { + return false; + } + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset)); + } break; + }; + tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + 1 + tokTexture2DOffsetInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokTexture2DOffsetInfo); + if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokTexture2DOffsetInfo == tokTexture2DOffsetInfoEnd); + } break; + case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE: { + const TokenHeader *tokPlane = varLen->getValue(); + const TokenHeader *tokPlaneEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokPlane < tokPlaneEnd) { + if (false == tokPlane->flags.flag4IsVariableLength) { + switch (tokPlane->id) { + default: + if (tokPlane->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: { + dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.ArrayQPitch = readTokValue(*tokPlane); + } break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: { + auto srcData = reinterpret_cast &>(*tokPlane).getValue(); + auto srcSize = reinterpret_cast &>(*tokPlane).getValueSizeInBytes(); + if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.X)) { + return false; + } + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.X, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.X), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.X)); + } break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: { + auto srcData = reinterpret_cast &>(*tokPlane).getValue(); + auto srcSize = reinterpret_cast &>(*tokPlane).getValueSizeInBytes(); + if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.Y)) { + return false; + } + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.Y, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.Y), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.Y)); + } break; + case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: { + dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.NoOfPlanes = readTokValue(*tokPlane); + } break; + case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: { + dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.IsTileAlignedPlanes = readTokValue(*tokPlane); + } break; + }; + tokPlane = tokPlane + 1 + tokPlane->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokPlane); + switch (tokPlane->id) { + default: + if (tokPlane->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: { + const TokenHeader *tokUnAligned = varLen->getValue(); + const TokenHeader *tokUnAlignedEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokUnAligned < tokUnAlignedEnd) { + if (false == tokUnAligned->flags.flag4IsVariableLength) { + switch (tokUnAligned->id) { + default: + if (tokUnAligned->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: { + auto srcData = reinterpret_cast &>(*tokUnAligned).getValue(); + auto srcSize = reinterpret_cast &>(*tokUnAligned).getValueSizeInBytes(); + if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.UnAligned.Height)) { + return false; + } + 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)); + } break; + }; + tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokUnAligned); + if (tokUnAligned->flags.flag3IsMandatory) { + return false; + } + tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokUnAligned == tokUnAlignedEnd); + } break; + }; + tokPlane = tokPlane + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokPlane == tokPlaneEnd); + } break; + }; + tokOffsetInfo = tokOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokOffsetInfo == tokOffsetInfoEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__S3D: { + const TokenHeader *tokS3d = varLen->getValue(); + const TokenHeader *tokS3dEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokS3d < tokS3dEnd) { + if (false == tokS3d->flags.flag4IsVariableLength) { + switch (tokS3d->id) { + default: + if (tokS3d->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_S3D_INFO_REC__DISPLAY_MODE_HEIGHT: { + dst.GmmResourceInfoCommon.AuxSurf.S3d.DisplayModeHeight = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__NUM_BLANK_ACTIVE_LINES: { + dst.GmmResourceInfoCommon.AuxSurf.S3d.NumBlankActiveLines = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__RFRAME_OFFSET: { + dst.GmmResourceInfoCommon.AuxSurf.S3d.RFrameOffset = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__BLANK_AREA_OFFSET: { + dst.GmmResourceInfoCommon.AuxSurf.S3d.BlankAreaOffset = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_HEIGHT: { + dst.GmmResourceInfoCommon.AuxSurf.S3d.TallBufferHeight = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_SIZE: { + dst.GmmResourceInfoCommon.AuxSurf.S3d.TallBufferSize = readTokValue(*tokS3d); + } break; + case TOK_FBC_GMM_S3D_INFO_REC__IS_RFRAME: { + dst.GmmResourceInfoCommon.AuxSurf.S3d.IsRFrame = readTokValue(*tokS3d); + } break; + }; + tokS3d = tokS3d + 1 + tokS3d->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokS3d); + if (tokS3d->flags.flag3IsMandatory) { + return false; + } + tokS3d = tokS3d + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokS3d == tokS3dEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__SEGMENT_OVERRIDE: { + const TokenHeader *tokSegmentOverride = varLen->getValue(); + const TokenHeader *tokSegmentOverrideEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSegmentOverride < tokSegmentOverrideEnd) { + if (false == tokSegmentOverride->flags.flag4IsVariableLength) { + switch (tokSegmentOverride->id) { + default: + if (tokSegmentOverride->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__SEG1: { + dst.GmmResourceInfoCommon.AuxSurf.SegmentOverride.Seg1 = readTokValue(*tokSegmentOverride); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__EVICT: { + dst.GmmResourceInfoCommon.AuxSurf.SegmentOverride.Evict = readTokValue(*tokSegmentOverride); + } break; + }; + tokSegmentOverride = tokSegmentOverride + 1 + tokSegmentOverride->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSegmentOverride); + if (tokSegmentOverride->flags.flag3IsMandatory) { + return false; + } + tokSegmentOverride = tokSegmentOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSegmentOverride == tokSegmentOverrideEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__PLATFORM: { +#if _DEBUG || _RELEASE_INTERNAL + const TokenHeader *tokPlatform = varLen->getValue(); + const TokenHeader *tokPlatformEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokPlatform < tokPlatformEnd) { + if (false == tokPlatform->flags.flag4IsVariableLength) { + switch (tokPlatform->id) { + default: + if (tokPlatform->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { + dst.GmmResourceInfoCommon.AuxSurf.Platform.eProductFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { + dst.GmmResourceInfoCommon.AuxSurf.Platform.ePCHProductFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { + dst.GmmResourceInfoCommon.AuxSurf.Platform.eDisplayCoreFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { + dst.GmmResourceInfoCommon.AuxSurf.Platform.eRenderCoreFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { + dst.GmmResourceInfoCommon.AuxSurf.Platform.ePlatformType = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { + dst.GmmResourceInfoCommon.AuxSurf.Platform.usDeviceID = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID: { + dst.GmmResourceInfoCommon.AuxSurf.Platform.usRevId = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { + dst.GmmResourceInfoCommon.AuxSurf.Platform.usDeviceID_PCH = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { + dst.GmmResourceInfoCommon.AuxSurf.Platform.usRevId_PCH = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_GTTYPE: { + dst.GmmResourceInfoCommon.AuxSurf.Platform.eGTType = readTokValue(*tokPlatform); + } break; + }; + tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokPlatform); + if (tokPlatform->flags.flag3IsMandatory) { + return false; + } + tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokPlatform == tokPlatformEnd); +#endif + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__EXISTING_SYS_MEM: { + const TokenHeader *tokExistingSysMem = varLen->getValue(); + const TokenHeader *tokExistingSysMemEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokExistingSysMem < tokExistingSysMemEnd) { + if (false == tokExistingSysMem->flags.flag4IsVariableLength) { + switch (tokExistingSysMem->id) { + default: + if (tokExistingSysMem->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_GMM_ALLOCATED: { + dst.GmmResourceInfoCommon.AuxSurf.ExistingSysMem.IsGmmAllocated = readTokValue(*tokExistingSysMem); + } break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_PAGE_ALIGNED: { + dst.GmmResourceInfoCommon.AuxSurf.ExistingSysMem.IsPageAligned = readTokValue(*tokExistingSysMem); + } break; + }; + tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokExistingSysMem); + if (tokExistingSysMem->flags.flag3IsMandatory) { + return false; + } + tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: { +#if !(_DEBUG || _RELEASE_INTERNAL) + const TokenHeader *tok__Platform = varLen->getValue(); + const TokenHeader *tok__PlatformEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tok__Platform < tok__PlatformEnd) { + if (false == tok__Platform->flags.flag4IsVariableLength) { + switch (tok__Platform->id) { + default: + if (tok__Platform->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { + dst.GmmResourceInfoCommon.AuxSurf.__Platform.eProductFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { + dst.GmmResourceInfoCommon.AuxSurf.__Platform.ePCHProductFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { + dst.GmmResourceInfoCommon.AuxSurf.__Platform.eDisplayCoreFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { + dst.GmmResourceInfoCommon.AuxSurf.__Platform.eRenderCoreFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { + dst.GmmResourceInfoCommon.AuxSurf.__Platform.ePlatformType = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { + dst.GmmResourceInfoCommon.AuxSurf.__Platform.usDeviceID = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID: { + dst.GmmResourceInfoCommon.AuxSurf.__Platform.usRevId = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { + dst.GmmResourceInfoCommon.AuxSurf.__Platform.usDeviceID_PCH = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { + dst.GmmResourceInfoCommon.AuxSurf.__Platform.usRevId_PCH = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_GTTYPE: { + dst.GmmResourceInfoCommon.AuxSurf.__Platform.eGTType = readTokValue(*tok__Platform); + } break; + }; + tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok__Platform); + if (tok__Platform->flags.flag3IsMandatory) { + return false; + } + tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok__Platform == tok__PlatformEnd); +#endif + } break; + }; + tokAuxSurf = tokAuxSurf + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokAuxSurf == tokAuxSurfEnd); + } break; + case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__AUX_SEC_SURF: { + const TokenHeader *tokAuxSecSurf = varLen->getValue(); + const TokenHeader *tokAuxSecSurfEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokAuxSecSurf < tokAuxSecSurfEnd) { + if (false == tokAuxSecSurf->flags.flag4IsVariableLength) { + switch (tokAuxSecSurf->id) { + default: + if (tokAuxSecSurf->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GMM_TEXTURE_INFO_REC__TYPE: { + dst.GmmResourceInfoCommon.AuxSecSurf.Type = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FE_GMM_TEXTURE_INFO_REC__FORMAT: { + dst.GmmResourceInfoCommon.AuxSecSurf.Format = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__BITS_PER_PIXEL: { + dst.GmmResourceInfoCommon.AuxSecSurf.BitsPerPixel = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__BASE_WIDTH: { + dst.GmmResourceInfoCommon.AuxSecSurf.BaseWidth = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__BASE_HEIGHT: { + dst.GmmResourceInfoCommon.AuxSecSurf.BaseHeight = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__DEPTH: { + dst.GmmResourceInfoCommon.AuxSecSurf.Depth = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__MAX_LOD: { + dst.GmmResourceInfoCommon.AuxSecSurf.MaxLod = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__ARRAY_SIZE: { + dst.GmmResourceInfoCommon.AuxSecSurf.ArraySize = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__CP_TAG: { + dst.GmmResourceInfoCommon.AuxSecSurf.CpTag = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_MODE: { + auto srcData = reinterpret_cast &>(*tokAuxSecSurf).getValue(); + auto srcSize = reinterpret_cast &>(*tokAuxSecSurf).getValueSizeInBytes(); + if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.MmcMode)) { + return false; + } + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.MmcMode, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.MmcMode), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.MmcMode)); + } break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_HINT: { + auto srcData = reinterpret_cast &>(*tokAuxSecSurf).getValue(); + auto srcSize = reinterpret_cast &>(*tokAuxSecSurf).getValueSizeInBytes(); + if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.MmcHint)) { + return false; + } + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.MmcHint, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.MmcHint), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.MmcHint)); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__PITCH: { + dst.GmmResourceInfoCommon.AuxSecSurf.Pitch = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__OVERRIDE_PITCH: { + dst.GmmResourceInfoCommon.AuxSecSurf.OverridePitch = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE: { + dst.GmmResourceInfoCommon.AuxSecSurf.Size = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__CCSIZE: { + dst.GmmResourceInfoCommon.AuxSecSurf.CCSize = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__UNPADDED_SIZE: { + dst.GmmResourceInfoCommon.AuxSecSurf.UnpaddedSize = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE_REPORT_TO_OS: { + dst.GmmResourceInfoCommon.AuxSecSurf.SizeReportToOS = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FE_GMM_TEXTURE_INFO_REC__TILE_MODE: { + dst.GmmResourceInfoCommon.AuxSecSurf.TileMode = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__CCSMODE_ALIGN: { + dst.GmmResourceInfoCommon.AuxSecSurf.CCSModeAlign = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__LEGACY_FLAGS: { + dst.GmmResourceInfoCommon.AuxSecSurf.LegacyFlags = readTokValue(*tokAuxSecSurf); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__MAXIMUM_RENAMING_LIST_LENGTH: { + dst.GmmResourceInfoCommon.AuxSecSurf.MaximumRenamingListLength = readTokValue(*tokAuxSecSurf); + } break; + }; + tokAuxSecSurf = tokAuxSecSurf + 1 + tokAuxSecSurf->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokAuxSecSurf); + switch (tokAuxSecSurf->id) { + default: + if (tokAuxSecSurf->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_TEXTURE_INFO_REC__FLAGS: { + const TokenHeader *tokFlags = varLen->getValue(); + const TokenHeader *tokFlagsEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokFlags < tokFlagsEnd) { + if (false == tokFlags->flags.flag4IsVariableLength) { + if (tokFlags->flags.flag3IsMandatory) { + return false; + } + tokFlags = tokFlags + 1 + tokFlags->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokFlags); + switch (tokFlags->id) { + default: + if (tokFlags->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_RESOURCE_FLAG_REC__GPU: { + const TokenHeader *tokGpu = varLen->getValue(); + const TokenHeader *tokGpuEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokGpu < tokGpuEnd) { + if (false == tokGpu->flags.flag4IsVariableLength) { + switch (tokGpu->id) { + default: + if (tokGpu->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CAMERA_CAPTURE: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.CameraCapture = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CCS: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.CCS = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_DISCARD: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ColorDiscard = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ColorSeparation = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION_RGBX: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ColorSeparationRGBX = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CONSTANT: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Constant = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__DEPTH: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Depth = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.FlipChain = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN_PREFERRED: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.FlipChainPreferred = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HISTORY_BUFFER: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.HistoryBuffer = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HI_Z: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.HiZ = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDEX: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Index = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDIRECT_CLEAR_COLOR: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.IndirectClearColor = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INSTRUCTION_FLAT: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.InstructionFlat = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INTERLACED_SCAN: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.InterlacedScan = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MCS: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.MCS = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MMC: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.MMC = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MOTION_COMP: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.MotionComp = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__NO_RESTRICTION: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.NoRestriction = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__OVERLAY: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Overlay = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PRESENTABLE: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Presentable = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PROCEDURAL_TEXTURE: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ProceduralTexture = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__QUERY: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Query = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__RENDER_TARGET: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.RenderTarget = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.S3d = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D_DX: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.S3dDx = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_NON_PACKED: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__S3dNonPacked = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_WIDI: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__S3dWidi = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SCRATCH_FLAT: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ScratchFlat = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SEPARATE_STENCIL: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.SeparateStencil = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.State = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE_DX9CONSTANT_BUFFER: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.StateDx9ConstantBuffer = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STREAM: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Stream = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXT_API: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.TextApi = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXTURE: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Texture = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILED_RESOURCE: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.TiledResource = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILE_POOL: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.TilePool = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__UNIFIED_AUX_SURFACE: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.UnifiedAuxSurface = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VERTEX: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Vertex = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VIDEO: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Video = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_XCCS: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__NonMsaaTileXCcs = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_YCCS: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__NonMsaaTileYCcs = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____MSAA_TILE_MCS: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__MsaaTileMcs = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_LINEAR_CCS: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__NonMsaaLinearCCS = readTokValue(*tokGpu); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____REMAINING: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__Remaining = readTokValue(*tokGpu); + } break; + }; + tokGpu = tokGpu + 1 + tokGpu->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokGpu); + if (tokGpu->flags.flag3IsMandatory) { + return false; + } + tokGpu = tokGpu + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokGpu == tokGpuEnd); + } break; + case TOK_FS_GMM_RESOURCE_FLAG_REC__INFO: { + const TokenHeader *tokInfo = varLen->getValue(); + const TokenHeader *tokInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokInfo < tokInfoEnd) { + if (false == tokInfo->flags.flag4IsVariableLength) { + switch (tokInfo->id) { + default: + if (tokInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ALLOW_VIRTUAL_PADDING: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.AllowVirtualPadding = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__BIG_PAGE: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.BigPage = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CACHEABLE: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Cacheable = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CONTIG_PHYS_MEMORY_FORI_DART: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.ContigPhysMemoryForiDART = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CORNER_TEXEL_MODE: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.CornerTexelMode = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__EXISTING_SYS_MEM: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.ExistingSysMem = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__FORCE_RESIDENCY: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.ForceResidency = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GFDT: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Gfdt = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GTT_MAP_TYPE: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.GttMapType = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__HARDWARE_PROTECTED: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.HardwareProtected = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__KERNEL_MODE_MAPPED: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.KernelModeMapped = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_BELOW: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LayoutBelow = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_MONO: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LayoutMono = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_RIGHT: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LayoutRight = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LOCAL_ONLY: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LocalOnly = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LINEAR: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Linear = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__MEDIA_COMPRESSED: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.MediaCompressed = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_OPTIMIZATION_PADDING: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NoOptimizationPadding = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_PHYS_MEMORY: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NoPhysMemory = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NOT_LOCKABLE: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NotLockable = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NON_LOCAL_ONLY: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NonLocalOnly = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__STD_SWIZZLE: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.StdSwizzle = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__PSEUDO_STD_SWIZZLE: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.PseudoStdSwizzle = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__UNDEFINED64KBSWIZZLE: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Undefined64KBSwizzle = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__REDECRIBED_PLANES: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.RedecribedPlanes = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__RENDER_COMPRESSED: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.RenderCompressed = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ROTATED: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Rotated = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SHARED: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Shared = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SOFTWARE_PROTECTED: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.SoftwareProtected = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SVM: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.SVM = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE4: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Tile4 = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE64: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Tile64 = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_W: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledW = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_X: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledX = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_Y: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledY = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YF: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledYf = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YS: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledYs = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__WDDM_PROTECTED: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.WddmProtected = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__XADAPTER: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.XAdapter = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PREALLOCATED_RES_INFO: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.__PreallocatedResInfo = readTokValue(*tokInfo); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PRE_WDDM2SVM: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.__PreWddm2SVM = readTokValue(*tokInfo); + } break; + }; + tokInfo = tokInfo + 1 + tokInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokInfo); + if (tokInfo->flags.flag3IsMandatory) { + return false; + } + tokInfo = tokInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokInfo == tokInfoEnd); + } break; + case TOK_FS_GMM_RESOURCE_FLAG_REC__WA: { + const TokenHeader *tokWa = varLen->getValue(); + const TokenHeader *tokWaEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokWa < tokWaEnd) { + if (false == tokWa->flags.flag4IsVariableLength) { + switch (tokWa->id) { + default: + if (tokWa->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__GTMFX2ND_LEVEL_BATCH_RING_SIZE_ALIGN: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_MPR_ROW_STORE32KALIGN: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_DMV_BUFFER32KALIGN: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_BUFFER_SAMPLER_PADDING: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.NoBufferSamplerPadding = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_LEGACY_PLANAR_LINEAR_VIDEO_RESTRICTIONS: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__CHVASTC_SKIP_VIRTUAL_MIPS: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.CHVAstcSkipVirtualMips = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_PACKED_MIP_TAIL: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DisablePackedMipTail = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521____FORCE_OTHER_HVALIGN4: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.__ForceOtherHVALIGN4 = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DisableDisplayCcsClearColor = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DisableDisplayCcsCompression = readTokValue(*tokWa); + } break; + case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: { + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.PreGen12FastClearOnly = readTokValue(*tokWa); + } break; + }; + tokWa = tokWa + 1 + tokWa->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokWa); + if (tokWa->flags.flag3IsMandatory) { + return false; + } + tokWa = tokWa + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokWa == tokWaEnd); + } break; + }; + tokFlags = tokFlags + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokFlags == tokFlagsEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__CACHE_POLICY: { + const TokenHeader *tokCachePolicy = varLen->getValue(); + const TokenHeader *tokCachePolicyEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokCachePolicy < tokCachePolicyEnd) { + if (false == tokCachePolicy->flags.flag4IsVariableLength) { + switch (tokCachePolicy->id) { + default: + if (tokCachePolicy->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GMM_TEXTURE_INFO_REC__ANONYMOUS4927__USAGE: { + dst.GmmResourceInfoCommon.AuxSecSurf.CachePolicy.Usage = readTokValue(*tokCachePolicy); + } break; + }; + tokCachePolicy = tokCachePolicy + 1 + tokCachePolicy->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokCachePolicy); + if (tokCachePolicy->flags.flag3IsMandatory) { + return false; + } + tokCachePolicy = tokCachePolicy + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokCachePolicy == tokCachePolicyEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__MSAA: { + const TokenHeader *tokMSAA = varLen->getValue(); + const TokenHeader *tokMSAAEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokMSAA < tokMSAAEnd) { + if (false == tokMSAA->flags.flag4IsVariableLength) { + switch (tokMSAA->id) { + default: + if (tokMSAA->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GMM_RESOURCE_MSAA_INFO_REC__SAMPLE_PATTERN: { + dst.GmmResourceInfoCommon.AuxSecSurf.MSAA.SamplePattern = readTokValue(*tokMSAA); + } break; + case TOK_FBD_GMM_RESOURCE_MSAA_INFO_REC__NUM_SAMPLES: { + dst.GmmResourceInfoCommon.AuxSecSurf.MSAA.NumSamples = readTokValue(*tokMSAA); + } break; + }; + tokMSAA = tokMSAA + 1 + tokMSAA->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokMSAA); + if (tokMSAA->flags.flag3IsMandatory) { + return false; + } + tokMSAA = tokMSAA + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokMSAA == tokMSAAEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__ALIGNMENT: { + const TokenHeader *tokAlignment = varLen->getValue(); + const TokenHeader *tokAlignmentEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokAlignment < tokAlignmentEnd) { + if (false == tokAlignment->flags.flag4IsVariableLength) { + switch (tokAlignment->id) { + default: + if (tokAlignment->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBC_GMM_RESOURCE_ALIGNMENT_REC__ARRAY_SPACING_SINGLE_LOD: { + dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.ArraySpacingSingleLod = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__BASE_ALIGNMENT: { + dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.BaseAlignment = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__HALIGN: { + dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.HAlign = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__VALIGN: { + dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.VAlign = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__DALIGN: { + dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.DAlign = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__MIP_TAIL_START_LOD: { + dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.MipTailStartLod = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_START_LOD: { + dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.PackedMipStartLod = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_WIDTH: { + dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.PackedMipWidth = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_HEIGHT: { + dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.PackedMipHeight = readTokValue(*tokAlignment); + } break; + case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__QPITCH: { + dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.QPitch = readTokValue(*tokAlignment); + } break; + }; + tokAlignment = tokAlignment + 1 + tokAlignment->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokAlignment); + if (tokAlignment->flags.flag3IsMandatory) { + return false; + } + tokAlignment = tokAlignment + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokAlignment == tokAlignmentEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__OFFSET_INFO: { + const TokenHeader *tokOffsetInfo = varLen->getValue(); + const TokenHeader *tokOffsetInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokOffsetInfo < tokOffsetInfoEnd) { + if (false == tokOffsetInfo->flags.flag4IsVariableLength) { + if (tokOffsetInfo->flags.flag3IsMandatory) { + return false; + } + tokOffsetInfo = tokOffsetInfo + 1 + tokOffsetInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokOffsetInfo); + switch (tokOffsetInfo->id) { + default: + if (tokOffsetInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO: { + const TokenHeader *tokTexture3DOffsetInfo = varLen->getValue(); + const TokenHeader *tokTexture3DOffsetInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokTexture3DOffsetInfo < tokTexture3DOffsetInfoEnd) { + if (false == tokTexture3DOffsetInfo->flags.flag4IsVariableLength) { + switch (tokTexture3DOffsetInfo->id) { + default: + if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: { + dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch = readTokValue(*tokTexture3DOffsetInfo); + } break; + case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: { + auto srcData = reinterpret_cast &>(*tokTexture3DOffsetInfo).getValue(); + auto srcSize = reinterpret_cast &>(*tokTexture3DOffsetInfo).getValueSizeInBytes(); + if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset)) { + return false; + } + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset)); + } break; + }; + tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + 1 + tokTexture3DOffsetInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokTexture3DOffsetInfo); + if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokTexture3DOffsetInfo == tokTexture3DOffsetInfoEnd); + } break; + case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO: { + const TokenHeader *tokTexture2DOffsetInfo = varLen->getValue(); + const TokenHeader *tokTexture2DOffsetInfoEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokTexture2DOffsetInfo < tokTexture2DOffsetInfoEnd) { + if (false == tokTexture2DOffsetInfo->flags.flag4IsVariableLength) { + switch (tokTexture2DOffsetInfo->id) { + default: + if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: { + dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock = readTokValue(*tokTexture2DOffsetInfo); + } break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: { + dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender = readTokValue(*tokTexture2DOffsetInfo); + } break; + case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: { + auto srcData = reinterpret_cast &>(*tokTexture2DOffsetInfo).getValue(); + auto srcSize = reinterpret_cast &>(*tokTexture2DOffsetInfo).getValueSizeInBytes(); + if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset)) { + return false; + } + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset)); + } break; + }; + tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + 1 + tokTexture2DOffsetInfo->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokTexture2DOffsetInfo); + if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) { + return false; + } + tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokTexture2DOffsetInfo == tokTexture2DOffsetInfoEnd); + } break; + case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE: { + const TokenHeader *tokPlane = varLen->getValue(); + const TokenHeader *tokPlaneEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokPlane < tokPlaneEnd) { + if (false == tokPlane->flags.flag4IsVariableLength) { + switch (tokPlane->id) { + default: + if (tokPlane->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: { + dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.ArrayQPitch = readTokValue(*tokPlane); + } break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: { + auto srcData = reinterpret_cast &>(*tokPlane).getValue(); + auto srcSize = reinterpret_cast &>(*tokPlane).getValueSizeInBytes(); + if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.X)) { + return false; + } + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.X, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.X), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.X)); + } break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: { + auto srcData = reinterpret_cast &>(*tokPlane).getValue(); + auto srcSize = reinterpret_cast &>(*tokPlane).getValueSizeInBytes(); + if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.Y)) { + return false; + } + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.Y, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.Y), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.Y)); + } break; + case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: { + dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.NoOfPlanes = readTokValue(*tokPlane); + } break; + case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: { + dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.IsTileAlignedPlanes = readTokValue(*tokPlane); + } break; + }; + tokPlane = tokPlane + 1 + tokPlane->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokPlane); + switch (tokPlane->id) { + default: + if (tokPlane->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: { + const TokenHeader *tokUnAligned = varLen->getValue(); + const TokenHeader *tokUnAlignedEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokUnAligned < tokUnAlignedEnd) { + if (false == tokUnAligned->flags.flag4IsVariableLength) { + switch (tokUnAligned->id) { + default: + if (tokUnAligned->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: { + auto srcData = reinterpret_cast &>(*tokUnAligned).getValue(); + auto srcSize = reinterpret_cast &>(*tokUnAligned).getValueSizeInBytes(); + if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height)) { + return false; + } + 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)); + } break; + }; + tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokUnAligned); + if (tokUnAligned->flags.flag3IsMandatory) { + return false; + } + tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokUnAligned == tokUnAlignedEnd); + } break; + }; + tokPlane = tokPlane + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokPlane == tokPlaneEnd); + } break; + }; + tokOffsetInfo = tokOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokOffsetInfo == tokOffsetInfoEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__S3D: { + const TokenHeader *tokS3d = varLen->getValue(); + const TokenHeader *tokS3dEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokS3d < tokS3dEnd) { + if (false == tokS3d->flags.flag4IsVariableLength) { + switch (tokS3d->id) { + default: + if (tokS3d->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_S3D_INFO_REC__DISPLAY_MODE_HEIGHT: { + dst.GmmResourceInfoCommon.AuxSecSurf.S3d.DisplayModeHeight = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__NUM_BLANK_ACTIVE_LINES: { + dst.GmmResourceInfoCommon.AuxSecSurf.S3d.NumBlankActiveLines = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__RFRAME_OFFSET: { + dst.GmmResourceInfoCommon.AuxSecSurf.S3d.RFrameOffset = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__BLANK_AREA_OFFSET: { + dst.GmmResourceInfoCommon.AuxSecSurf.S3d.BlankAreaOffset = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_HEIGHT: { + dst.GmmResourceInfoCommon.AuxSecSurf.S3d.TallBufferHeight = readTokValue(*tokS3d); + } break; + case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_SIZE: { + dst.GmmResourceInfoCommon.AuxSecSurf.S3d.TallBufferSize = readTokValue(*tokS3d); + } break; + case TOK_FBC_GMM_S3D_INFO_REC__IS_RFRAME: { + dst.GmmResourceInfoCommon.AuxSecSurf.S3d.IsRFrame = readTokValue(*tokS3d); + } break; + }; + tokS3d = tokS3d + 1 + tokS3d->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokS3d); + if (tokS3d->flags.flag3IsMandatory) { + return false; + } + tokS3d = tokS3d + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokS3d == tokS3dEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__SEGMENT_OVERRIDE: { + const TokenHeader *tokSegmentOverride = varLen->getValue(); + const TokenHeader *tokSegmentOverrideEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokSegmentOverride < tokSegmentOverrideEnd) { + if (false == tokSegmentOverride->flags.flag4IsVariableLength) { + switch (tokSegmentOverride->id) { + default: + if (tokSegmentOverride->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__SEG1: { + dst.GmmResourceInfoCommon.AuxSecSurf.SegmentOverride.Seg1 = readTokValue(*tokSegmentOverride); + } break; + case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__EVICT: { + dst.GmmResourceInfoCommon.AuxSecSurf.SegmentOverride.Evict = readTokValue(*tokSegmentOverride); + } break; + }; + tokSegmentOverride = tokSegmentOverride + 1 + tokSegmentOverride->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokSegmentOverride); + if (tokSegmentOverride->flags.flag3IsMandatory) { + return false; + } + tokSegmentOverride = tokSegmentOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokSegmentOverride == tokSegmentOverrideEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__PLATFORM: { +#if _DEBUG || _RELEASE_INTERNAL + const TokenHeader *tokPlatform = varLen->getValue(); + const TokenHeader *tokPlatformEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokPlatform < tokPlatformEnd) { + if (false == tokPlatform->flags.flag4IsVariableLength) { + switch (tokPlatform->id) { + default: + if (tokPlatform->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { + dst.GmmResourceInfoCommon.AuxSecSurf.Platform.eProductFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { + dst.GmmResourceInfoCommon.AuxSecSurf.Platform.ePCHProductFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { + dst.GmmResourceInfoCommon.AuxSecSurf.Platform.eDisplayCoreFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { + dst.GmmResourceInfoCommon.AuxSecSurf.Platform.eRenderCoreFamily = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { + dst.GmmResourceInfoCommon.AuxSecSurf.Platform.ePlatformType = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { + dst.GmmResourceInfoCommon.AuxSecSurf.Platform.usDeviceID = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID: { + dst.GmmResourceInfoCommon.AuxSecSurf.Platform.usRevId = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { + dst.GmmResourceInfoCommon.AuxSecSurf.Platform.usDeviceID_PCH = readTokValue(*tokPlatform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { + dst.GmmResourceInfoCommon.AuxSecSurf.Platform.usRevId_PCH = readTokValue(*tokPlatform); + } break; + case TOK_FE_PLATFORM_STR__E_GTTYPE: { + dst.GmmResourceInfoCommon.AuxSecSurf.Platform.eGTType = readTokValue(*tokPlatform); + } break; + }; + tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokPlatform); + if (tokPlatform->flags.flag3IsMandatory) { + return false; + } + tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokPlatform == tokPlatformEnd); +#endif + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC__EXISTING_SYS_MEM: { + const TokenHeader *tokExistingSysMem = varLen->getValue(); + const TokenHeader *tokExistingSysMemEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokExistingSysMem < tokExistingSysMemEnd) { + if (false == tokExistingSysMem->flags.flag4IsVariableLength) { + switch (tokExistingSysMem->id) { + default: + if (tokExistingSysMem->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_GMM_ALLOCATED: { + dst.GmmResourceInfoCommon.AuxSecSurf.ExistingSysMem.IsGmmAllocated = readTokValue(*tokExistingSysMem); + } break; + case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_PAGE_ALIGNED: { + dst.GmmResourceInfoCommon.AuxSecSurf.ExistingSysMem.IsPageAligned = readTokValue(*tokExistingSysMem); + } break; + }; + tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokExistingSysMem); + if (tokExistingSysMem->flags.flag3IsMandatory) { + return false; + } + tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd); + } break; + case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: { +#if !(_DEBUG || _RELEASE_INTERNAL) + const TokenHeader *tok__Platform = varLen->getValue(); + const TokenHeader *tok__PlatformEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tok__Platform < tok__PlatformEnd) { + if (false == tok__Platform->flags.flag4IsVariableLength) { + switch (tok__Platform->id) { + default: + if (tok__Platform->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: { + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eProductFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.ePCHProductFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eDisplayCoreFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eRenderCoreFamily = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.ePlatformType = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usDeviceID = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID: { + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usRevId = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usDeviceID_PCH = readTokValue(*tok__Platform); + } break; + case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usRevId_PCH = readTokValue(*tok__Platform); + } break; + case TOK_FE_PLATFORM_STR__E_GTTYPE: { + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eGTType = readTokValue(*tok__Platform); + } break; + }; + tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok__Platform); + if (tok__Platform->flags.flag3IsMandatory) { + return false; + } + tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok__Platform == tok__PlatformEnd); +#endif + } break; + }; + tokAuxSecSurf = tokAuxSecSurf + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokAuxSecSurf == tokAuxSecSurfEnd); + } break; + case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__EXISTING_SYS_MEM: { + const TokenHeader *tokExistingSysMem = varLen->getValue(); + const TokenHeader *tokExistingSysMemEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokExistingSysMem < tokExistingSysMemEnd) { + if (false == tokExistingSysMem->flags.flag4IsVariableLength) { + switch (tokExistingSysMem->id) { + default: + if (tokExistingSysMem->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_EXISTING_SYS_MEM: { + dst.GmmResourceInfoCommon.ExistingSysMem.pExistingSysMem = readTokValue(*tokExistingSysMem); + } break; + case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_VIRT_ADDRESS: { + dst.GmmResourceInfoCommon.ExistingSysMem.pVirtAddress = readTokValue(*tokExistingSysMem); + } break; + case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_GFX_ALIGNED_VIRT_ADDRESS: { + dst.GmmResourceInfoCommon.ExistingSysMem.pGfxAlignedVirtAddress = readTokValue(*tokExistingSysMem); + } break; + case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__SIZE: { + dst.GmmResourceInfoCommon.ExistingSysMem.Size = readTokValue(*tokExistingSysMem); + } break; + case TOK_FBC_GMM_EXISTING_SYS_MEM_REC__IS_GMM_ALLOCATED: { + dst.GmmResourceInfoCommon.ExistingSysMem.IsGmmAllocated = readTokValue(*tokExistingSysMem); + } break; + }; + tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokExistingSysMem); + if (tokExistingSysMem->flags.flag3IsMandatory) { + return false; + } + tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd); + } break; + case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__MULTI_TILE_ARCH: { + const TokenHeader *tokMultiTileArch = varLen->getValue(); + const TokenHeader *tokMultiTileArchEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokMultiTileArch < tokMultiTileArchEnd) { + if (false == tokMultiTileArch->flags.flag4IsVariableLength) { + switch (tokMultiTileArch->id) { + default: + if (tokMultiTileArch->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__ENABLE: { + dst.GmmResourceInfoCommon.MultiTileArch.Enable = readTokValue(*tokMultiTileArch); + } break; + case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__TILE_INSTANCED: { + dst.GmmResourceInfoCommon.MultiTileArch.TileInstanced = readTokValue(*tokMultiTileArch); + } break; + case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__GPU_VA_MAPPING_SET: { + dst.GmmResourceInfoCommon.MultiTileArch.GpuVaMappingSet = readTokValue(*tokMultiTileArch); + } break; + case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__LOCAL_MEM_ELIGIBILITY_SET: { + dst.GmmResourceInfoCommon.MultiTileArch.LocalMemEligibilitySet = readTokValue(*tokMultiTileArch); + } break; + case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__LOCAL_MEM_PREFERRED_SET: { + dst.GmmResourceInfoCommon.MultiTileArch.LocalMemPreferredSet = readTokValue(*tokMultiTileArch); + } break; + }; + tokMultiTileArch = tokMultiTileArch + 1 + tokMultiTileArch->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokMultiTileArch); + if (tokMultiTileArch->flags.flag3IsMandatory) { + return false; + } + tokMultiTileArch = tokMultiTileArch + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokMultiTileArch == tokMultiTileArchEnd); + } break; + }; + tokGmmResourceInfoCommon = tokGmmResourceInfoCommon + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokGmmResourceInfoCommon == tokGmmResourceInfoCommonEnd); + } break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(GFX_ESCAPE_HEADERT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__SIZE: { + dst.Size = readTokValue(*tok); + } break; + case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__CHECK_SUM: { + dst.CheckSum = readTokValue(*tok); + } break; + case TOK_FE_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__ESCAPE_CODE: { + dst.EscapeCode = readTokValue(*tok); + } break; + case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__UL_RESERVED: { + dst.ulReserved = readTokValue(*tok); + } break; + case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UL_RESERVED1: { + dst.ulReserved1 = readTokValue(*tok); + } break; + case TOK_FBW_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__US_ESCAPE_VERSION: { + dst.usEscapeVersion = readTokValue(*tok); + } break; + case TOK_FBW_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__US_FILE_VERSION: { + dst.usFileVersion = readTokValue(*tok); + } break; + case TOK_FE_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UL_MAJOR_ESCAPE_CODE: { + dst.ulMajorEscapeCode = readTokValue(*tok); + } break; + case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UI_MINOR_ESCAPE_CODE: { + dst.uiMinorEscapeCode = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GFX_ESCAPE_HEADER: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(GTDIBaseInStructT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GTDIBASE_IN_STRUCT__FUNCTION: { + dst.Function = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GTDIBASE_IN_STRUCT: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(GTDIGetGpuCpuTimestampsOutStructT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__RET_CODE: { + dst.RetCode = readTokValue(*tok); + } break; + case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__GPU_PERF_TICKS: { + dst.gpuPerfTicks = readTokValue(*tok); + } break; + case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__CPU_PERF_TICKS: { + dst.cpuPerfTicks = readTokValue(*tok); + } break; + case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__GPU_PERF_FREQ: { + dst.gpuPerfFreq = readTokValue(*tok); + } break; + case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__CPU_PERF_FREQ: { + dst.cpuPerfFreq = readTokValue(*tok); + } break; + }; + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; + +template <> +struct Demarshaller { + template + static bool demarshall(TimeStampDataHeaderT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) { + const TokenHeader *tok = srcTokensBeg; + while (tok < srcTokensEnd) { + if (false == tok->flags.flag4IsVariableLength) { + if (tok->flags.flag3IsMandatory) { + return false; + } + tok = tok + 1 + tok->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tok); + switch (tok->id) { + default: + if (tok->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_S_TIME_STAMP_DATA_HEADER: + if (false == demarshall(dst, varLen->getValue(), varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader))) { + return false; + } + break; + case TOK_FS_TIME_STAMP_DATA_HEADER__M_HEADER: { + const TokenHeader *tokM_Header = varLen->getValue(); + const TokenHeader *tokM_HeaderEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokM_Header < tokM_HeaderEnd) { + if (false == tokM_Header->flags.flag4IsVariableLength) { + switch (tokM_Header->id) { + default: + if (tokM_Header->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__SIZE: { + dst.m_Header.Size = readTokValue(*tokM_Header); + } break; + case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__CHECK_SUM: { + dst.m_Header.CheckSum = readTokValue(*tokM_Header); + } break; + case TOK_FE_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__ESCAPE_CODE: { + dst.m_Header.EscapeCode = readTokValue(*tokM_Header); + } break; + case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__UL_RESERVED: { + dst.m_Header.ulReserved = readTokValue(*tokM_Header); + } break; + case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UL_RESERVED1: { + dst.m_Header.ulReserved1 = readTokValue(*tokM_Header); + } break; + case TOK_FBW_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__US_ESCAPE_VERSION: { + dst.m_Header.usEscapeVersion = readTokValue(*tokM_Header); + } break; + case TOK_FBW_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__US_FILE_VERSION: { + dst.m_Header.usFileVersion = readTokValue(*tokM_Header); + } break; + case TOK_FE_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UL_MAJOR_ESCAPE_CODE: { + dst.m_Header.ulMajorEscapeCode = readTokValue(*tokM_Header); + } break; + case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UI_MINOR_ESCAPE_CODE: { + dst.m_Header.uiMinorEscapeCode = readTokValue(*tokM_Header); + } break; + }; + tokM_Header = tokM_Header + 1 + tokM_Header->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokM_Header); + if (tokM_Header->flags.flag3IsMandatory) { + return false; + } + tokM_Header = tokM_Header + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokM_Header == tokM_HeaderEnd); + } break; + case TOK_FS_TIME_STAMP_DATA_HEADER__M_DATA: { + const TokenHeader *tokM_Data = varLen->getValue(); + const TokenHeader *tokM_DataEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokM_Data < tokM_DataEnd) { + if (false == tokM_Data->flags.flag4IsVariableLength) { + if (tokM_Data->flags.flag3IsMandatory) { + return false; + } + tokM_Data = tokM_Data + 1 + tokM_Data->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokM_Data); + switch (tokM_Data->id) { + default: + if (tokM_Data->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FXS_TIME_STAMP_DATA_HEADER__ANONYMOUS2466__M_IN: { + const TokenHeader *tokM_In = varLen->getValue(); + const TokenHeader *tokM_InEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokM_In < tokM_InEnd) { + if (false == tokM_In->flags.flag4IsVariableLength) { + switch (tokM_In->id) { + default: + if (tokM_In->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GTDIBASE_IN_STRUCT__FUNCTION: { + dst.m_Data.m_In.Function = readTokValue(*tokM_In); + } break; + }; + tokM_In = tokM_In + 1 + tokM_In->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokM_In); + if (tokM_In->flags.flag3IsMandatory) { + return false; + } + tokM_In = tokM_In + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokM_In == tokM_InEnd); + } break; + case TOK_FS_TIME_STAMP_DATA_HEADER__ANONYMOUS2466__M_OUT: { + const TokenHeader *tokM_Out = varLen->getValue(); + const TokenHeader *tokM_OutEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); + while (tokM_Out < tokM_OutEnd) { + if (false == tokM_Out->flags.flag4IsVariableLength) { + switch (tokM_Out->id) { + default: + if (tokM_Out->flags.flag3IsMandatory) { + return false; + } + break; + case TOK_FE_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__RET_CODE: { + dst.m_Data.m_Out.RetCode = readTokValue(*tokM_Out); + } break; + case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__GPU_PERF_TICKS: { + dst.m_Data.m_Out.gpuPerfTicks = readTokValue(*tokM_Out); + } break; + case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__CPU_PERF_TICKS: { + dst.m_Data.m_Out.cpuPerfTicks = readTokValue(*tokM_Out); + } break; + case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__GPU_PERF_FREQ: { + dst.m_Data.m_Out.gpuPerfFreq = readTokValue(*tokM_Out); + } break; + case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__CPU_PERF_FREQ: { + dst.m_Data.m_Out.cpuPerfFreq = readTokValue(*tokM_Out); + } break; + }; + tokM_Out = tokM_Out + 1 + tokM_Out->valueDwordCount; + } else { + auto varLen = reinterpret_cast(tokM_Out); + if (tokM_Out->flags.flag3IsMandatory) { + return false; + } + tokM_Out = tokM_Out + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokM_Out == tokM_OutEnd); + } break; + }; + tokM_Data = tokM_Data + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tokM_Data == tokM_DataEnd); + } break; + }; + tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords; + } + } + WCH_ASSERT(tok == srcTokensEnd); + return true; + } +}; diff --git a/shared/wsl_compute_helper/source/wsl_compute_helper_types_marshall.cpp b/shared/wsl_compute_helper/source/wsl_compute_helper_types_marshall.cpp new file mode 100644 index 0000000000..d0abd9259b --- /dev/null +++ b/shared/wsl_compute_helper/source/wsl_compute_helper_types_marshall.cpp @@ -0,0 +1,9 @@ +/* + * Copyright (C) 2021 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +// This is a generated file - please don't modify directly +#include "wsl_compute_helper_types_marshall.h" diff --git a/shared/wsl_compute_helper/source/wsl_compute_helper_types_marshall.h b/shared/wsl_compute_helper/source/wsl_compute_helper_types_marshall.h new file mode 100644 index 0000000000..b2d756fc1b --- /dev/null +++ b/shared/wsl_compute_helper/source/wsl_compute_helper_types_marshall.h @@ -0,0 +1,4140 @@ +/* + * Copyright (C) 2021 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +// This is a generated file - please don't modify directly +#pragma once +#include "wsl_compute_helper_types_tokens.h" +#include "wsl_compute_helper_types_tokens_structs.h" + +template +struct Marshaller; + +template +inline void marshall(TOKSTR_GT_SUBSLICE_INFO &dst, const GT_SUBSLICE_INFOT &src) { + dst = {}; + dst.Enabled.setValue(src.Enabled); + dst.EuEnabledCount.setValue(src.EuEnabledCount); + dst.EuEnabledMask.setValue(src.EuEnabledMask); +} +template <> +struct Marshaller { + template + static TOKSTR_GT_SUBSLICE_INFO marshall(const GT_SUBSLICE_INFOT &src) { + TOKSTR_GT_SUBSLICE_INFO ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_GT_DUALSUBSLICE_INFO &dst, const GT_DUALSUBSLICE_INFOT &src) { + dst = {}; + dst.Enabled.setValue(src.Enabled); + dst.SubSlice[0].Enabled.setValue(src.SubSlice[0].Enabled); + dst.SubSlice[0].EuEnabledCount.setValue(src.SubSlice[0].EuEnabledCount); + dst.SubSlice[0].EuEnabledMask.setValue(src.SubSlice[0].EuEnabledMask); + dst.SubSlice[1].Enabled.setValue(src.SubSlice[1].Enabled); + dst.SubSlice[1].EuEnabledCount.setValue(src.SubSlice[1].EuEnabledCount); + dst.SubSlice[1].EuEnabledMask.setValue(src.SubSlice[1].EuEnabledMask); +} +template <> +struct Marshaller { + template + static TOKSTR_GT_DUALSUBSLICE_INFO marshall(const GT_DUALSUBSLICE_INFOT &src) { + TOKSTR_GT_DUALSUBSLICE_INFO ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_GT_SLICE_INFO &dst, const GT_SLICE_INFOT &src) { + dst = {}; + dst.Enabled.setValue(src.Enabled); + dst.SubSliceInfo[0].Enabled.setValue(src.SubSliceInfo[0].Enabled); + dst.SubSliceInfo[0].EuEnabledCount.setValue(src.SubSliceInfo[0].EuEnabledCount); + dst.SubSliceInfo[0].EuEnabledMask.setValue(src.SubSliceInfo[0].EuEnabledMask); + dst.SubSliceInfo[1].Enabled.setValue(src.SubSliceInfo[1].Enabled); + dst.SubSliceInfo[1].EuEnabledCount.setValue(src.SubSliceInfo[1].EuEnabledCount); + dst.SubSliceInfo[1].EuEnabledMask.setValue(src.SubSliceInfo[1].EuEnabledMask); + dst.SubSliceInfo[2].Enabled.setValue(src.SubSliceInfo[2].Enabled); + dst.SubSliceInfo[2].EuEnabledCount.setValue(src.SubSliceInfo[2].EuEnabledCount); + dst.SubSliceInfo[2].EuEnabledMask.setValue(src.SubSliceInfo[2].EuEnabledMask); + dst.SubSliceInfo[3].Enabled.setValue(src.SubSliceInfo[3].Enabled); + dst.SubSliceInfo[3].EuEnabledCount.setValue(src.SubSliceInfo[3].EuEnabledCount); + dst.SubSliceInfo[3].EuEnabledMask.setValue(src.SubSliceInfo[3].EuEnabledMask); + dst.SubSliceInfo[4].Enabled.setValue(src.SubSliceInfo[4].Enabled); + dst.SubSliceInfo[4].EuEnabledCount.setValue(src.SubSliceInfo[4].EuEnabledCount); + dst.SubSliceInfo[4].EuEnabledMask.setValue(src.SubSliceInfo[4].EuEnabledMask); + dst.SubSliceInfo[5].Enabled.setValue(src.SubSliceInfo[5].Enabled); + dst.SubSliceInfo[5].EuEnabledCount.setValue(src.SubSliceInfo[5].EuEnabledCount); + dst.SubSliceInfo[5].EuEnabledMask.setValue(src.SubSliceInfo[5].EuEnabledMask); + dst.SubSliceInfo[6].Enabled.setValue(src.SubSliceInfo[6].Enabled); + dst.SubSliceInfo[6].EuEnabledCount.setValue(src.SubSliceInfo[6].EuEnabledCount); + dst.SubSliceInfo[6].EuEnabledMask.setValue(src.SubSliceInfo[6].EuEnabledMask); + dst.SubSliceInfo[7].Enabled.setValue(src.SubSliceInfo[7].Enabled); + dst.SubSliceInfo[7].EuEnabledCount.setValue(src.SubSliceInfo[7].EuEnabledCount); + dst.SubSliceInfo[7].EuEnabledMask.setValue(src.SubSliceInfo[7].EuEnabledMask); + dst.DSSInfo[0].Enabled.setValue(src.DSSInfo[0].Enabled); + dst.DSSInfo[0].SubSlice[0].Enabled.setValue(src.DSSInfo[0].SubSlice[0].Enabled); + dst.DSSInfo[0].SubSlice[0].EuEnabledCount.setValue(src.DSSInfo[0].SubSlice[0].EuEnabledCount); + dst.DSSInfo[0].SubSlice[0].EuEnabledMask.setValue(src.DSSInfo[0].SubSlice[0].EuEnabledMask); + dst.DSSInfo[0].SubSlice[1].Enabled.setValue(src.DSSInfo[0].SubSlice[1].Enabled); + dst.DSSInfo[0].SubSlice[1].EuEnabledCount.setValue(src.DSSInfo[0].SubSlice[1].EuEnabledCount); + dst.DSSInfo[0].SubSlice[1].EuEnabledMask.setValue(src.DSSInfo[0].SubSlice[1].EuEnabledMask); + dst.DSSInfo[1].Enabled.setValue(src.DSSInfo[1].Enabled); + dst.DSSInfo[1].SubSlice[0].Enabled.setValue(src.DSSInfo[1].SubSlice[0].Enabled); + dst.DSSInfo[1].SubSlice[0].EuEnabledCount.setValue(src.DSSInfo[1].SubSlice[0].EuEnabledCount); + dst.DSSInfo[1].SubSlice[0].EuEnabledMask.setValue(src.DSSInfo[1].SubSlice[0].EuEnabledMask); + dst.DSSInfo[1].SubSlice[1].Enabled.setValue(src.DSSInfo[1].SubSlice[1].Enabled); + dst.DSSInfo[1].SubSlice[1].EuEnabledCount.setValue(src.DSSInfo[1].SubSlice[1].EuEnabledCount); + dst.DSSInfo[1].SubSlice[1].EuEnabledMask.setValue(src.DSSInfo[1].SubSlice[1].EuEnabledMask); + dst.DSSInfo[2].Enabled.setValue(src.DSSInfo[2].Enabled); + dst.DSSInfo[2].SubSlice[0].Enabled.setValue(src.DSSInfo[2].SubSlice[0].Enabled); + dst.DSSInfo[2].SubSlice[0].EuEnabledCount.setValue(src.DSSInfo[2].SubSlice[0].EuEnabledCount); + dst.DSSInfo[2].SubSlice[0].EuEnabledMask.setValue(src.DSSInfo[2].SubSlice[0].EuEnabledMask); + dst.DSSInfo[2].SubSlice[1].Enabled.setValue(src.DSSInfo[2].SubSlice[1].Enabled); + dst.DSSInfo[2].SubSlice[1].EuEnabledCount.setValue(src.DSSInfo[2].SubSlice[1].EuEnabledCount); + dst.DSSInfo[2].SubSlice[1].EuEnabledMask.setValue(src.DSSInfo[2].SubSlice[1].EuEnabledMask); + dst.DSSInfo[3].Enabled.setValue(src.DSSInfo[3].Enabled); + dst.DSSInfo[3].SubSlice[0].Enabled.setValue(src.DSSInfo[3].SubSlice[0].Enabled); + dst.DSSInfo[3].SubSlice[0].EuEnabledCount.setValue(src.DSSInfo[3].SubSlice[0].EuEnabledCount); + dst.DSSInfo[3].SubSlice[0].EuEnabledMask.setValue(src.DSSInfo[3].SubSlice[0].EuEnabledMask); + dst.DSSInfo[3].SubSlice[1].Enabled.setValue(src.DSSInfo[3].SubSlice[1].Enabled); + dst.DSSInfo[3].SubSlice[1].EuEnabledCount.setValue(src.DSSInfo[3].SubSlice[1].EuEnabledCount); + dst.DSSInfo[3].SubSlice[1].EuEnabledMask.setValue(src.DSSInfo[3].SubSlice[1].EuEnabledMask); + dst.DSSInfo[4].Enabled.setValue(src.DSSInfo[4].Enabled); + dst.DSSInfo[4].SubSlice[0].Enabled.setValue(src.DSSInfo[4].SubSlice[0].Enabled); + dst.DSSInfo[4].SubSlice[0].EuEnabledCount.setValue(src.DSSInfo[4].SubSlice[0].EuEnabledCount); + dst.DSSInfo[4].SubSlice[0].EuEnabledMask.setValue(src.DSSInfo[4].SubSlice[0].EuEnabledMask); + dst.DSSInfo[4].SubSlice[1].Enabled.setValue(src.DSSInfo[4].SubSlice[1].Enabled); + dst.DSSInfo[4].SubSlice[1].EuEnabledCount.setValue(src.DSSInfo[4].SubSlice[1].EuEnabledCount); + dst.DSSInfo[4].SubSlice[1].EuEnabledMask.setValue(src.DSSInfo[4].SubSlice[1].EuEnabledMask); + dst.DSSInfo[5].Enabled.setValue(src.DSSInfo[5].Enabled); + dst.DSSInfo[5].SubSlice[0].Enabled.setValue(src.DSSInfo[5].SubSlice[0].Enabled); + dst.DSSInfo[5].SubSlice[0].EuEnabledCount.setValue(src.DSSInfo[5].SubSlice[0].EuEnabledCount); + dst.DSSInfo[5].SubSlice[0].EuEnabledMask.setValue(src.DSSInfo[5].SubSlice[0].EuEnabledMask); + dst.DSSInfo[5].SubSlice[1].Enabled.setValue(src.DSSInfo[5].SubSlice[1].Enabled); + dst.DSSInfo[5].SubSlice[1].EuEnabledCount.setValue(src.DSSInfo[5].SubSlice[1].EuEnabledCount); + dst.DSSInfo[5].SubSlice[1].EuEnabledMask.setValue(src.DSSInfo[5].SubSlice[1].EuEnabledMask); + dst.SubSliceEnabledCount.setValue(src.SubSliceEnabledCount); + dst.DualSubSliceEnabledCount.setValue(src.DualSubSliceEnabledCount); +} +template <> +struct Marshaller { + template + static TOKSTR_GT_SLICE_INFO marshall(const GT_SLICE_INFOT &src) { + TOKSTR_GT_SLICE_INFO ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_GT_VEBOX_INFO &dst, const GT_VEBOX_INFOT &src) { + dst = {}; + dst.Instances.Bits.VEBox0Enabled.setValue(src.Instances.Bits.VEBox0Enabled); + dst.Instances.Bits.VEBox1Enabled.setValue(src.Instances.Bits.VEBox1Enabled); + dst.Instances.Bits.VEBox2Enabled.setValue(src.Instances.Bits.VEBox2Enabled); + dst.Instances.Bits.VEBox3Enabled.setValue(src.Instances.Bits.VEBox3Enabled); + dst.Instances.VEBoxEnableMask.setValue(src.Instances.VEBoxEnableMask); + dst.SFCSupport.SfcSupportedBits.VEBox0.setValue(src.SFCSupport.SfcSupportedBits.VEBox0); + dst.SFCSupport.SfcSupportedBits.VEBox1.setValue(src.SFCSupport.SfcSupportedBits.VEBox1); + dst.SFCSupport.SfcSupportedBits.VEBox2.setValue(src.SFCSupport.SfcSupportedBits.VEBox2); + dst.SFCSupport.SfcSupportedBits.VEBox3.setValue(src.SFCSupport.SfcSupportedBits.VEBox3); + dst.SFCSupport.Value.setValue(src.SFCSupport.Value); + dst.NumberOfVEBoxEnabled.setValue(src.NumberOfVEBoxEnabled); + dst.IsValid.setValue(src.IsValid); +} +template <> +struct Marshaller { + template + static TOKSTR_GT_VEBOX_INFO marshall(const GT_VEBOX_INFOT &src) { + TOKSTR_GT_VEBOX_INFO ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_GT_VDBOX_INFO &dst, const GT_VDBOX_INFOT &src) { + dst = {}; + dst.Instances.Bits.VDBox0Enabled.setValue(src.Instances.Bits.VDBox0Enabled); + dst.Instances.Bits.VDBox1Enabled.setValue(src.Instances.Bits.VDBox1Enabled); + dst.Instances.Bits.VDBox2Enabled.setValue(src.Instances.Bits.VDBox2Enabled); + dst.Instances.Bits.VDBox3Enabled.setValue(src.Instances.Bits.VDBox3Enabled); + dst.Instances.Bits.VDBox4Enabled.setValue(src.Instances.Bits.VDBox4Enabled); + dst.Instances.Bits.VDBox5Enabled.setValue(src.Instances.Bits.VDBox5Enabled); + dst.Instances.Bits.VDBox6Enabled.setValue(src.Instances.Bits.VDBox6Enabled); + dst.Instances.Bits.VDBox7Enabled.setValue(src.Instances.Bits.VDBox7Enabled); + dst.Instances.VDBoxEnableMask.setValue(src.Instances.VDBoxEnableMask); + dst.SFCSupport.SfcSupportedBits.VDBox0.setValue(src.SFCSupport.SfcSupportedBits.VDBox0); + dst.SFCSupport.SfcSupportedBits.VDBox1.setValue(src.SFCSupport.SfcSupportedBits.VDBox1); + dst.SFCSupport.SfcSupportedBits.VDBox2.setValue(src.SFCSupport.SfcSupportedBits.VDBox2); + dst.SFCSupport.SfcSupportedBits.VDBox3.setValue(src.SFCSupport.SfcSupportedBits.VDBox3); + dst.SFCSupport.SfcSupportedBits.VDBox4.setValue(src.SFCSupport.SfcSupportedBits.VDBox4); + dst.SFCSupport.SfcSupportedBits.VDBox5.setValue(src.SFCSupport.SfcSupportedBits.VDBox5); + dst.SFCSupport.SfcSupportedBits.VDBox6.setValue(src.SFCSupport.SfcSupportedBits.VDBox6); + dst.SFCSupport.SfcSupportedBits.VDBox7.setValue(src.SFCSupport.SfcSupportedBits.VDBox7); + dst.SFCSupport.Value.setValue(src.SFCSupport.Value); + dst.NumberOfVDBoxEnabled.setValue(src.NumberOfVDBoxEnabled); + dst.IsValid.setValue(src.IsValid); +} +template <> +struct Marshaller { + template + static TOKSTR_GT_VDBOX_INFO marshall(const GT_VDBOX_INFOT &src) { + TOKSTR_GT_VDBOX_INFO ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_GT_CCS_INFO &dst, const GT_CCS_INFOT &src) { + dst = {}; + dst.Instances.Bits.CCS0Enabled.setValue(src.Instances.Bits.CCS0Enabled); + dst.Instances.Bits.CCS1Enabled.setValue(src.Instances.Bits.CCS1Enabled); + dst.Instances.Bits.CCS2Enabled.setValue(src.Instances.Bits.CCS2Enabled); + dst.Instances.Bits.CCS3Enabled.setValue(src.Instances.Bits.CCS3Enabled); + dst.Instances.CCSEnableMask.setValue(src.Instances.CCSEnableMask); + dst.NumberOfCCSEnabled.setValue(src.NumberOfCCSEnabled); + dst.IsValid.setValue(src.IsValid); +} +template <> +struct Marshaller { + template + static TOKSTR_GT_CCS_INFO marshall(const GT_CCS_INFOT &src) { + TOKSTR_GT_CCS_INFO ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_GT_MULTI_TILE_ARCH_INFO &dst, const GT_MULTI_TILE_ARCH_INFOT &src) { + dst = {}; + dst.TileCount.setValue(src.TileCount); + dst.Tile0.setValue(src.Tile0); + dst.Tile1.setValue(src.Tile1); + dst.Tile2.setValue(src.Tile2); + dst.Tile3.setValue(src.Tile3); + dst.TileMask.setValue(src.TileMask); + dst.IsValid.setValue(src.IsValid); +} +template <> +struct Marshaller { + template + static TOKSTR_GT_MULTI_TILE_ARCH_INFO marshall(const GT_MULTI_TILE_ARCH_INFOT &src) { + TOKSTR_GT_MULTI_TILE_ARCH_INFO ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_GT_SQIDI_INFO &dst, const GT_SQIDI_INFOT &src) { + dst = {}; + dst.NumberofSQIDI.setValue(src.NumberofSQIDI); + dst.NumberofDoorbellPerSQIDI.setValue(src.NumberofDoorbellPerSQIDI); +} +template <> +struct Marshaller { + template + static TOKSTR_GT_SQIDI_INFO marshall(const GT_SQIDI_INFOT &src) { + TOKSTR_GT_SQIDI_INFO ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR__GT_CACHE_TYPES &dst, const _GT_CACHE_TYPEST &src) { + dst = {}; + dst.L3.setValue(src.L3); + dst.LLC.setValue(src.LLC); + dst.eDRAM.setValue(src.eDRAM); + dst.CacheTypeMask.setValue(src.CacheTypeMask); +} +template <> +struct Marshaller { + template + static TOKSTR__GT_CACHE_TYPES marshall(const _GT_CACHE_TYPEST &src) { + TOKSTR__GT_CACHE_TYPES ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_GT_SYSTEM_INFO &dst, const GT_SYSTEM_INFOT &src) { + dst = {}; + dst.EUCount.setValue(src.EUCount); + dst.ThreadCount.setValue(src.ThreadCount); + dst.SliceCount.setValue(src.SliceCount); + dst.SubSliceCount.setValue(src.SubSliceCount); + dst.DualSubSliceCount.setValue(src.DualSubSliceCount); + dst.L3CacheSizeInKb.setValue(src.L3CacheSizeInKb); + dst.LLCCacheSizeInKb.setValue(src.LLCCacheSizeInKb); + dst.EdramSizeInKb.setValue(src.EdramSizeInKb); + dst.L3BankCount.setValue(src.L3BankCount); + dst.MaxFillRate.setValue(src.MaxFillRate); + dst.EuCountPerPoolMax.setValue(src.EuCountPerPoolMax); + dst.EuCountPerPoolMin.setValue(src.EuCountPerPoolMin); + dst.TotalVsThreads.setValue(src.TotalVsThreads); + dst.TotalHsThreads.setValue(src.TotalHsThreads); + dst.TotalDsThreads.setValue(src.TotalDsThreads); + dst.TotalGsThreads.setValue(src.TotalGsThreads); + dst.TotalPsThreadsWindowerRange.setValue(src.TotalPsThreadsWindowerRange); + dst.TotalVsThreads_Pocs.setValue(src.TotalVsThreads_Pocs); + dst.CsrSizeInMb.setValue(src.CsrSizeInMb); + dst.MaxEuPerSubSlice.setValue(src.MaxEuPerSubSlice); + dst.MaxSlicesSupported.setValue(src.MaxSlicesSupported); + dst.MaxSubSlicesSupported.setValue(src.MaxSubSlicesSupported); + dst.MaxDualSubSlicesSupported.setValue(src.MaxDualSubSlicesSupported); + dst.IsL3HashModeEnabled.setValue(src.IsL3HashModeEnabled); + dst.SliceInfo[0].Enabled.setValue(src.SliceInfo[0].Enabled); + dst.SliceInfo[0].SubSliceInfo[0].Enabled.setValue(src.SliceInfo[0].SubSliceInfo[0].Enabled); + dst.SliceInfo[0].SubSliceInfo[0].EuEnabledCount.setValue(src.SliceInfo[0].SubSliceInfo[0].EuEnabledCount); + dst.SliceInfo[0].SubSliceInfo[0].EuEnabledMask.setValue(src.SliceInfo[0].SubSliceInfo[0].EuEnabledMask); + dst.SliceInfo[0].SubSliceInfo[1].Enabled.setValue(src.SliceInfo[0].SubSliceInfo[1].Enabled); + dst.SliceInfo[0].SubSliceInfo[1].EuEnabledCount.setValue(src.SliceInfo[0].SubSliceInfo[1].EuEnabledCount); + dst.SliceInfo[0].SubSliceInfo[1].EuEnabledMask.setValue(src.SliceInfo[0].SubSliceInfo[1].EuEnabledMask); + dst.SliceInfo[0].SubSliceInfo[2].Enabled.setValue(src.SliceInfo[0].SubSliceInfo[2].Enabled); + dst.SliceInfo[0].SubSliceInfo[2].EuEnabledCount.setValue(src.SliceInfo[0].SubSliceInfo[2].EuEnabledCount); + dst.SliceInfo[0].SubSliceInfo[2].EuEnabledMask.setValue(src.SliceInfo[0].SubSliceInfo[2].EuEnabledMask); + dst.SliceInfo[0].SubSliceInfo[3].Enabled.setValue(src.SliceInfo[0].SubSliceInfo[3].Enabled); + dst.SliceInfo[0].SubSliceInfo[3].EuEnabledCount.setValue(src.SliceInfo[0].SubSliceInfo[3].EuEnabledCount); + dst.SliceInfo[0].SubSliceInfo[3].EuEnabledMask.setValue(src.SliceInfo[0].SubSliceInfo[3].EuEnabledMask); + dst.SliceInfo[0].SubSliceInfo[4].Enabled.setValue(src.SliceInfo[0].SubSliceInfo[4].Enabled); + dst.SliceInfo[0].SubSliceInfo[4].EuEnabledCount.setValue(src.SliceInfo[0].SubSliceInfo[4].EuEnabledCount); + dst.SliceInfo[0].SubSliceInfo[4].EuEnabledMask.setValue(src.SliceInfo[0].SubSliceInfo[4].EuEnabledMask); + dst.SliceInfo[0].SubSliceInfo[5].Enabled.setValue(src.SliceInfo[0].SubSliceInfo[5].Enabled); + dst.SliceInfo[0].SubSliceInfo[5].EuEnabledCount.setValue(src.SliceInfo[0].SubSliceInfo[5].EuEnabledCount); + dst.SliceInfo[0].SubSliceInfo[5].EuEnabledMask.setValue(src.SliceInfo[0].SubSliceInfo[5].EuEnabledMask); + dst.SliceInfo[0].SubSliceInfo[6].Enabled.setValue(src.SliceInfo[0].SubSliceInfo[6].Enabled); + dst.SliceInfo[0].SubSliceInfo[6].EuEnabledCount.setValue(src.SliceInfo[0].SubSliceInfo[6].EuEnabledCount); + dst.SliceInfo[0].SubSliceInfo[6].EuEnabledMask.setValue(src.SliceInfo[0].SubSliceInfo[6].EuEnabledMask); + dst.SliceInfo[0].SubSliceInfo[7].Enabled.setValue(src.SliceInfo[0].SubSliceInfo[7].Enabled); + dst.SliceInfo[0].SubSliceInfo[7].EuEnabledCount.setValue(src.SliceInfo[0].SubSliceInfo[7].EuEnabledCount); + dst.SliceInfo[0].SubSliceInfo[7].EuEnabledMask.setValue(src.SliceInfo[0].SubSliceInfo[7].EuEnabledMask); + dst.SliceInfo[0].DSSInfo[0].Enabled.setValue(src.SliceInfo[0].DSSInfo[0].Enabled); + dst.SliceInfo[0].DSSInfo[0].SubSlice[0].Enabled.setValue(src.SliceInfo[0].DSSInfo[0].SubSlice[0].Enabled); + dst.SliceInfo[0].DSSInfo[0].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[0].DSSInfo[0].SubSlice[0].EuEnabledCount); + dst.SliceInfo[0].DSSInfo[0].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[0].DSSInfo[0].SubSlice[0].EuEnabledMask); + dst.SliceInfo[0].DSSInfo[0].SubSlice[1].Enabled.setValue(src.SliceInfo[0].DSSInfo[0].SubSlice[1].Enabled); + dst.SliceInfo[0].DSSInfo[0].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[0].DSSInfo[0].SubSlice[1].EuEnabledCount); + dst.SliceInfo[0].DSSInfo[0].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[0].DSSInfo[0].SubSlice[1].EuEnabledMask); + dst.SliceInfo[0].DSSInfo[1].Enabled.setValue(src.SliceInfo[0].DSSInfo[1].Enabled); + dst.SliceInfo[0].DSSInfo[1].SubSlice[0].Enabled.setValue(src.SliceInfo[0].DSSInfo[1].SubSlice[0].Enabled); + dst.SliceInfo[0].DSSInfo[1].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[0].DSSInfo[1].SubSlice[0].EuEnabledCount); + dst.SliceInfo[0].DSSInfo[1].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[0].DSSInfo[1].SubSlice[0].EuEnabledMask); + dst.SliceInfo[0].DSSInfo[1].SubSlice[1].Enabled.setValue(src.SliceInfo[0].DSSInfo[1].SubSlice[1].Enabled); + dst.SliceInfo[0].DSSInfo[1].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[0].DSSInfo[1].SubSlice[1].EuEnabledCount); + dst.SliceInfo[0].DSSInfo[1].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[0].DSSInfo[1].SubSlice[1].EuEnabledMask); + dst.SliceInfo[0].DSSInfo[2].Enabled.setValue(src.SliceInfo[0].DSSInfo[2].Enabled); + dst.SliceInfo[0].DSSInfo[2].SubSlice[0].Enabled.setValue(src.SliceInfo[0].DSSInfo[2].SubSlice[0].Enabled); + dst.SliceInfo[0].DSSInfo[2].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[0].DSSInfo[2].SubSlice[0].EuEnabledCount); + dst.SliceInfo[0].DSSInfo[2].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[0].DSSInfo[2].SubSlice[0].EuEnabledMask); + dst.SliceInfo[0].DSSInfo[2].SubSlice[1].Enabled.setValue(src.SliceInfo[0].DSSInfo[2].SubSlice[1].Enabled); + dst.SliceInfo[0].DSSInfo[2].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[0].DSSInfo[2].SubSlice[1].EuEnabledCount); + dst.SliceInfo[0].DSSInfo[2].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[0].DSSInfo[2].SubSlice[1].EuEnabledMask); + dst.SliceInfo[0].DSSInfo[3].Enabled.setValue(src.SliceInfo[0].DSSInfo[3].Enabled); + dst.SliceInfo[0].DSSInfo[3].SubSlice[0].Enabled.setValue(src.SliceInfo[0].DSSInfo[3].SubSlice[0].Enabled); + dst.SliceInfo[0].DSSInfo[3].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[0].DSSInfo[3].SubSlice[0].EuEnabledCount); + dst.SliceInfo[0].DSSInfo[3].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[0].DSSInfo[3].SubSlice[0].EuEnabledMask); + dst.SliceInfo[0].DSSInfo[3].SubSlice[1].Enabled.setValue(src.SliceInfo[0].DSSInfo[3].SubSlice[1].Enabled); + dst.SliceInfo[0].DSSInfo[3].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[0].DSSInfo[3].SubSlice[1].EuEnabledCount); + dst.SliceInfo[0].DSSInfo[3].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[0].DSSInfo[3].SubSlice[1].EuEnabledMask); + dst.SliceInfo[0].DSSInfo[4].Enabled.setValue(src.SliceInfo[0].DSSInfo[4].Enabled); + dst.SliceInfo[0].DSSInfo[4].SubSlice[0].Enabled.setValue(src.SliceInfo[0].DSSInfo[4].SubSlice[0].Enabled); + dst.SliceInfo[0].DSSInfo[4].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[0].DSSInfo[4].SubSlice[0].EuEnabledCount); + dst.SliceInfo[0].DSSInfo[4].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[0].DSSInfo[4].SubSlice[0].EuEnabledMask); + dst.SliceInfo[0].DSSInfo[4].SubSlice[1].Enabled.setValue(src.SliceInfo[0].DSSInfo[4].SubSlice[1].Enabled); + dst.SliceInfo[0].DSSInfo[4].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[0].DSSInfo[4].SubSlice[1].EuEnabledCount); + dst.SliceInfo[0].DSSInfo[4].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[0].DSSInfo[4].SubSlice[1].EuEnabledMask); + dst.SliceInfo[0].DSSInfo[5].Enabled.setValue(src.SliceInfo[0].DSSInfo[5].Enabled); + dst.SliceInfo[0].DSSInfo[5].SubSlice[0].Enabled.setValue(src.SliceInfo[0].DSSInfo[5].SubSlice[0].Enabled); + dst.SliceInfo[0].DSSInfo[5].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[0].DSSInfo[5].SubSlice[0].EuEnabledCount); + dst.SliceInfo[0].DSSInfo[5].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[0].DSSInfo[5].SubSlice[0].EuEnabledMask); + dst.SliceInfo[0].DSSInfo[5].SubSlice[1].Enabled.setValue(src.SliceInfo[0].DSSInfo[5].SubSlice[1].Enabled); + dst.SliceInfo[0].DSSInfo[5].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[0].DSSInfo[5].SubSlice[1].EuEnabledCount); + dst.SliceInfo[0].DSSInfo[5].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[0].DSSInfo[5].SubSlice[1].EuEnabledMask); + dst.SliceInfo[0].SubSliceEnabledCount.setValue(src.SliceInfo[0].SubSliceEnabledCount); + dst.SliceInfo[0].DualSubSliceEnabledCount.setValue(src.SliceInfo[0].DualSubSliceEnabledCount); + dst.SliceInfo[1].Enabled.setValue(src.SliceInfo[1].Enabled); + dst.SliceInfo[1].SubSliceInfo[0].Enabled.setValue(src.SliceInfo[1].SubSliceInfo[0].Enabled); + dst.SliceInfo[1].SubSliceInfo[0].EuEnabledCount.setValue(src.SliceInfo[1].SubSliceInfo[0].EuEnabledCount); + dst.SliceInfo[1].SubSliceInfo[0].EuEnabledMask.setValue(src.SliceInfo[1].SubSliceInfo[0].EuEnabledMask); + dst.SliceInfo[1].SubSliceInfo[1].Enabled.setValue(src.SliceInfo[1].SubSliceInfo[1].Enabled); + dst.SliceInfo[1].SubSliceInfo[1].EuEnabledCount.setValue(src.SliceInfo[1].SubSliceInfo[1].EuEnabledCount); + dst.SliceInfo[1].SubSliceInfo[1].EuEnabledMask.setValue(src.SliceInfo[1].SubSliceInfo[1].EuEnabledMask); + dst.SliceInfo[1].SubSliceInfo[2].Enabled.setValue(src.SliceInfo[1].SubSliceInfo[2].Enabled); + dst.SliceInfo[1].SubSliceInfo[2].EuEnabledCount.setValue(src.SliceInfo[1].SubSliceInfo[2].EuEnabledCount); + dst.SliceInfo[1].SubSliceInfo[2].EuEnabledMask.setValue(src.SliceInfo[1].SubSliceInfo[2].EuEnabledMask); + dst.SliceInfo[1].SubSliceInfo[3].Enabled.setValue(src.SliceInfo[1].SubSliceInfo[3].Enabled); + dst.SliceInfo[1].SubSliceInfo[3].EuEnabledCount.setValue(src.SliceInfo[1].SubSliceInfo[3].EuEnabledCount); + dst.SliceInfo[1].SubSliceInfo[3].EuEnabledMask.setValue(src.SliceInfo[1].SubSliceInfo[3].EuEnabledMask); + dst.SliceInfo[1].SubSliceInfo[4].Enabled.setValue(src.SliceInfo[1].SubSliceInfo[4].Enabled); + dst.SliceInfo[1].SubSliceInfo[4].EuEnabledCount.setValue(src.SliceInfo[1].SubSliceInfo[4].EuEnabledCount); + dst.SliceInfo[1].SubSliceInfo[4].EuEnabledMask.setValue(src.SliceInfo[1].SubSliceInfo[4].EuEnabledMask); + dst.SliceInfo[1].SubSliceInfo[5].Enabled.setValue(src.SliceInfo[1].SubSliceInfo[5].Enabled); + dst.SliceInfo[1].SubSliceInfo[5].EuEnabledCount.setValue(src.SliceInfo[1].SubSliceInfo[5].EuEnabledCount); + dst.SliceInfo[1].SubSliceInfo[5].EuEnabledMask.setValue(src.SliceInfo[1].SubSliceInfo[5].EuEnabledMask); + dst.SliceInfo[1].SubSliceInfo[6].Enabled.setValue(src.SliceInfo[1].SubSliceInfo[6].Enabled); + dst.SliceInfo[1].SubSliceInfo[6].EuEnabledCount.setValue(src.SliceInfo[1].SubSliceInfo[6].EuEnabledCount); + dst.SliceInfo[1].SubSliceInfo[6].EuEnabledMask.setValue(src.SliceInfo[1].SubSliceInfo[6].EuEnabledMask); + dst.SliceInfo[1].SubSliceInfo[7].Enabled.setValue(src.SliceInfo[1].SubSliceInfo[7].Enabled); + dst.SliceInfo[1].SubSliceInfo[7].EuEnabledCount.setValue(src.SliceInfo[1].SubSliceInfo[7].EuEnabledCount); + dst.SliceInfo[1].SubSliceInfo[7].EuEnabledMask.setValue(src.SliceInfo[1].SubSliceInfo[7].EuEnabledMask); + dst.SliceInfo[1].DSSInfo[0].Enabled.setValue(src.SliceInfo[1].DSSInfo[0].Enabled); + dst.SliceInfo[1].DSSInfo[0].SubSlice[0].Enabled.setValue(src.SliceInfo[1].DSSInfo[0].SubSlice[0].Enabled); + dst.SliceInfo[1].DSSInfo[0].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[1].DSSInfo[0].SubSlice[0].EuEnabledCount); + dst.SliceInfo[1].DSSInfo[0].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[1].DSSInfo[0].SubSlice[0].EuEnabledMask); + dst.SliceInfo[1].DSSInfo[0].SubSlice[1].Enabled.setValue(src.SliceInfo[1].DSSInfo[0].SubSlice[1].Enabled); + dst.SliceInfo[1].DSSInfo[0].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[1].DSSInfo[0].SubSlice[1].EuEnabledCount); + dst.SliceInfo[1].DSSInfo[0].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[1].DSSInfo[0].SubSlice[1].EuEnabledMask); + dst.SliceInfo[1].DSSInfo[1].Enabled.setValue(src.SliceInfo[1].DSSInfo[1].Enabled); + dst.SliceInfo[1].DSSInfo[1].SubSlice[0].Enabled.setValue(src.SliceInfo[1].DSSInfo[1].SubSlice[0].Enabled); + dst.SliceInfo[1].DSSInfo[1].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[1].DSSInfo[1].SubSlice[0].EuEnabledCount); + dst.SliceInfo[1].DSSInfo[1].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[1].DSSInfo[1].SubSlice[0].EuEnabledMask); + dst.SliceInfo[1].DSSInfo[1].SubSlice[1].Enabled.setValue(src.SliceInfo[1].DSSInfo[1].SubSlice[1].Enabled); + dst.SliceInfo[1].DSSInfo[1].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[1].DSSInfo[1].SubSlice[1].EuEnabledCount); + dst.SliceInfo[1].DSSInfo[1].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[1].DSSInfo[1].SubSlice[1].EuEnabledMask); + dst.SliceInfo[1].DSSInfo[2].Enabled.setValue(src.SliceInfo[1].DSSInfo[2].Enabled); + dst.SliceInfo[1].DSSInfo[2].SubSlice[0].Enabled.setValue(src.SliceInfo[1].DSSInfo[2].SubSlice[0].Enabled); + dst.SliceInfo[1].DSSInfo[2].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[1].DSSInfo[2].SubSlice[0].EuEnabledCount); + dst.SliceInfo[1].DSSInfo[2].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[1].DSSInfo[2].SubSlice[0].EuEnabledMask); + dst.SliceInfo[1].DSSInfo[2].SubSlice[1].Enabled.setValue(src.SliceInfo[1].DSSInfo[2].SubSlice[1].Enabled); + dst.SliceInfo[1].DSSInfo[2].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[1].DSSInfo[2].SubSlice[1].EuEnabledCount); + dst.SliceInfo[1].DSSInfo[2].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[1].DSSInfo[2].SubSlice[1].EuEnabledMask); + dst.SliceInfo[1].DSSInfo[3].Enabled.setValue(src.SliceInfo[1].DSSInfo[3].Enabled); + dst.SliceInfo[1].DSSInfo[3].SubSlice[0].Enabled.setValue(src.SliceInfo[1].DSSInfo[3].SubSlice[0].Enabled); + dst.SliceInfo[1].DSSInfo[3].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[1].DSSInfo[3].SubSlice[0].EuEnabledCount); + dst.SliceInfo[1].DSSInfo[3].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[1].DSSInfo[3].SubSlice[0].EuEnabledMask); + dst.SliceInfo[1].DSSInfo[3].SubSlice[1].Enabled.setValue(src.SliceInfo[1].DSSInfo[3].SubSlice[1].Enabled); + dst.SliceInfo[1].DSSInfo[3].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[1].DSSInfo[3].SubSlice[1].EuEnabledCount); + dst.SliceInfo[1].DSSInfo[3].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[1].DSSInfo[3].SubSlice[1].EuEnabledMask); + dst.SliceInfo[1].DSSInfo[4].Enabled.setValue(src.SliceInfo[1].DSSInfo[4].Enabled); + dst.SliceInfo[1].DSSInfo[4].SubSlice[0].Enabled.setValue(src.SliceInfo[1].DSSInfo[4].SubSlice[0].Enabled); + dst.SliceInfo[1].DSSInfo[4].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[1].DSSInfo[4].SubSlice[0].EuEnabledCount); + dst.SliceInfo[1].DSSInfo[4].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[1].DSSInfo[4].SubSlice[0].EuEnabledMask); + dst.SliceInfo[1].DSSInfo[4].SubSlice[1].Enabled.setValue(src.SliceInfo[1].DSSInfo[4].SubSlice[1].Enabled); + dst.SliceInfo[1].DSSInfo[4].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[1].DSSInfo[4].SubSlice[1].EuEnabledCount); + dst.SliceInfo[1].DSSInfo[4].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[1].DSSInfo[4].SubSlice[1].EuEnabledMask); + dst.SliceInfo[1].DSSInfo[5].Enabled.setValue(src.SliceInfo[1].DSSInfo[5].Enabled); + dst.SliceInfo[1].DSSInfo[5].SubSlice[0].Enabled.setValue(src.SliceInfo[1].DSSInfo[5].SubSlice[0].Enabled); + dst.SliceInfo[1].DSSInfo[5].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[1].DSSInfo[5].SubSlice[0].EuEnabledCount); + dst.SliceInfo[1].DSSInfo[5].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[1].DSSInfo[5].SubSlice[0].EuEnabledMask); + dst.SliceInfo[1].DSSInfo[5].SubSlice[1].Enabled.setValue(src.SliceInfo[1].DSSInfo[5].SubSlice[1].Enabled); + dst.SliceInfo[1].DSSInfo[5].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[1].DSSInfo[5].SubSlice[1].EuEnabledCount); + dst.SliceInfo[1].DSSInfo[5].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[1].DSSInfo[5].SubSlice[1].EuEnabledMask); + dst.SliceInfo[1].SubSliceEnabledCount.setValue(src.SliceInfo[1].SubSliceEnabledCount); + dst.SliceInfo[1].DualSubSliceEnabledCount.setValue(src.SliceInfo[1].DualSubSliceEnabledCount); + dst.SliceInfo[2].Enabled.setValue(src.SliceInfo[2].Enabled); + dst.SliceInfo[2].SubSliceInfo[0].Enabled.setValue(src.SliceInfo[2].SubSliceInfo[0].Enabled); + dst.SliceInfo[2].SubSliceInfo[0].EuEnabledCount.setValue(src.SliceInfo[2].SubSliceInfo[0].EuEnabledCount); + dst.SliceInfo[2].SubSliceInfo[0].EuEnabledMask.setValue(src.SliceInfo[2].SubSliceInfo[0].EuEnabledMask); + dst.SliceInfo[2].SubSliceInfo[1].Enabled.setValue(src.SliceInfo[2].SubSliceInfo[1].Enabled); + dst.SliceInfo[2].SubSliceInfo[1].EuEnabledCount.setValue(src.SliceInfo[2].SubSliceInfo[1].EuEnabledCount); + dst.SliceInfo[2].SubSliceInfo[1].EuEnabledMask.setValue(src.SliceInfo[2].SubSliceInfo[1].EuEnabledMask); + dst.SliceInfo[2].SubSliceInfo[2].Enabled.setValue(src.SliceInfo[2].SubSliceInfo[2].Enabled); + dst.SliceInfo[2].SubSliceInfo[2].EuEnabledCount.setValue(src.SliceInfo[2].SubSliceInfo[2].EuEnabledCount); + dst.SliceInfo[2].SubSliceInfo[2].EuEnabledMask.setValue(src.SliceInfo[2].SubSliceInfo[2].EuEnabledMask); + dst.SliceInfo[2].SubSliceInfo[3].Enabled.setValue(src.SliceInfo[2].SubSliceInfo[3].Enabled); + dst.SliceInfo[2].SubSliceInfo[3].EuEnabledCount.setValue(src.SliceInfo[2].SubSliceInfo[3].EuEnabledCount); + dst.SliceInfo[2].SubSliceInfo[3].EuEnabledMask.setValue(src.SliceInfo[2].SubSliceInfo[3].EuEnabledMask); + dst.SliceInfo[2].SubSliceInfo[4].Enabled.setValue(src.SliceInfo[2].SubSliceInfo[4].Enabled); + dst.SliceInfo[2].SubSliceInfo[4].EuEnabledCount.setValue(src.SliceInfo[2].SubSliceInfo[4].EuEnabledCount); + dst.SliceInfo[2].SubSliceInfo[4].EuEnabledMask.setValue(src.SliceInfo[2].SubSliceInfo[4].EuEnabledMask); + dst.SliceInfo[2].SubSliceInfo[5].Enabled.setValue(src.SliceInfo[2].SubSliceInfo[5].Enabled); + dst.SliceInfo[2].SubSliceInfo[5].EuEnabledCount.setValue(src.SliceInfo[2].SubSliceInfo[5].EuEnabledCount); + dst.SliceInfo[2].SubSliceInfo[5].EuEnabledMask.setValue(src.SliceInfo[2].SubSliceInfo[5].EuEnabledMask); + dst.SliceInfo[2].SubSliceInfo[6].Enabled.setValue(src.SliceInfo[2].SubSliceInfo[6].Enabled); + dst.SliceInfo[2].SubSliceInfo[6].EuEnabledCount.setValue(src.SliceInfo[2].SubSliceInfo[6].EuEnabledCount); + dst.SliceInfo[2].SubSliceInfo[6].EuEnabledMask.setValue(src.SliceInfo[2].SubSliceInfo[6].EuEnabledMask); + dst.SliceInfo[2].SubSliceInfo[7].Enabled.setValue(src.SliceInfo[2].SubSliceInfo[7].Enabled); + dst.SliceInfo[2].SubSliceInfo[7].EuEnabledCount.setValue(src.SliceInfo[2].SubSliceInfo[7].EuEnabledCount); + dst.SliceInfo[2].SubSliceInfo[7].EuEnabledMask.setValue(src.SliceInfo[2].SubSliceInfo[7].EuEnabledMask); + dst.SliceInfo[2].DSSInfo[0].Enabled.setValue(src.SliceInfo[2].DSSInfo[0].Enabled); + dst.SliceInfo[2].DSSInfo[0].SubSlice[0].Enabled.setValue(src.SliceInfo[2].DSSInfo[0].SubSlice[0].Enabled); + dst.SliceInfo[2].DSSInfo[0].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[2].DSSInfo[0].SubSlice[0].EuEnabledCount); + dst.SliceInfo[2].DSSInfo[0].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[2].DSSInfo[0].SubSlice[0].EuEnabledMask); + dst.SliceInfo[2].DSSInfo[0].SubSlice[1].Enabled.setValue(src.SliceInfo[2].DSSInfo[0].SubSlice[1].Enabled); + dst.SliceInfo[2].DSSInfo[0].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[2].DSSInfo[0].SubSlice[1].EuEnabledCount); + dst.SliceInfo[2].DSSInfo[0].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[2].DSSInfo[0].SubSlice[1].EuEnabledMask); + dst.SliceInfo[2].DSSInfo[1].Enabled.setValue(src.SliceInfo[2].DSSInfo[1].Enabled); + dst.SliceInfo[2].DSSInfo[1].SubSlice[0].Enabled.setValue(src.SliceInfo[2].DSSInfo[1].SubSlice[0].Enabled); + dst.SliceInfo[2].DSSInfo[1].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[2].DSSInfo[1].SubSlice[0].EuEnabledCount); + dst.SliceInfo[2].DSSInfo[1].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[2].DSSInfo[1].SubSlice[0].EuEnabledMask); + dst.SliceInfo[2].DSSInfo[1].SubSlice[1].Enabled.setValue(src.SliceInfo[2].DSSInfo[1].SubSlice[1].Enabled); + dst.SliceInfo[2].DSSInfo[1].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[2].DSSInfo[1].SubSlice[1].EuEnabledCount); + dst.SliceInfo[2].DSSInfo[1].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[2].DSSInfo[1].SubSlice[1].EuEnabledMask); + dst.SliceInfo[2].DSSInfo[2].Enabled.setValue(src.SliceInfo[2].DSSInfo[2].Enabled); + dst.SliceInfo[2].DSSInfo[2].SubSlice[0].Enabled.setValue(src.SliceInfo[2].DSSInfo[2].SubSlice[0].Enabled); + dst.SliceInfo[2].DSSInfo[2].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[2].DSSInfo[2].SubSlice[0].EuEnabledCount); + dst.SliceInfo[2].DSSInfo[2].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[2].DSSInfo[2].SubSlice[0].EuEnabledMask); + dst.SliceInfo[2].DSSInfo[2].SubSlice[1].Enabled.setValue(src.SliceInfo[2].DSSInfo[2].SubSlice[1].Enabled); + dst.SliceInfo[2].DSSInfo[2].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[2].DSSInfo[2].SubSlice[1].EuEnabledCount); + dst.SliceInfo[2].DSSInfo[2].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[2].DSSInfo[2].SubSlice[1].EuEnabledMask); + dst.SliceInfo[2].DSSInfo[3].Enabled.setValue(src.SliceInfo[2].DSSInfo[3].Enabled); + dst.SliceInfo[2].DSSInfo[3].SubSlice[0].Enabled.setValue(src.SliceInfo[2].DSSInfo[3].SubSlice[0].Enabled); + dst.SliceInfo[2].DSSInfo[3].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[2].DSSInfo[3].SubSlice[0].EuEnabledCount); + dst.SliceInfo[2].DSSInfo[3].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[2].DSSInfo[3].SubSlice[0].EuEnabledMask); + dst.SliceInfo[2].DSSInfo[3].SubSlice[1].Enabled.setValue(src.SliceInfo[2].DSSInfo[3].SubSlice[1].Enabled); + dst.SliceInfo[2].DSSInfo[3].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[2].DSSInfo[3].SubSlice[1].EuEnabledCount); + dst.SliceInfo[2].DSSInfo[3].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[2].DSSInfo[3].SubSlice[1].EuEnabledMask); + dst.SliceInfo[2].DSSInfo[4].Enabled.setValue(src.SliceInfo[2].DSSInfo[4].Enabled); + dst.SliceInfo[2].DSSInfo[4].SubSlice[0].Enabled.setValue(src.SliceInfo[2].DSSInfo[4].SubSlice[0].Enabled); + dst.SliceInfo[2].DSSInfo[4].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[2].DSSInfo[4].SubSlice[0].EuEnabledCount); + dst.SliceInfo[2].DSSInfo[4].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[2].DSSInfo[4].SubSlice[0].EuEnabledMask); + dst.SliceInfo[2].DSSInfo[4].SubSlice[1].Enabled.setValue(src.SliceInfo[2].DSSInfo[4].SubSlice[1].Enabled); + dst.SliceInfo[2].DSSInfo[4].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[2].DSSInfo[4].SubSlice[1].EuEnabledCount); + dst.SliceInfo[2].DSSInfo[4].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[2].DSSInfo[4].SubSlice[1].EuEnabledMask); + dst.SliceInfo[2].DSSInfo[5].Enabled.setValue(src.SliceInfo[2].DSSInfo[5].Enabled); + dst.SliceInfo[2].DSSInfo[5].SubSlice[0].Enabled.setValue(src.SliceInfo[2].DSSInfo[5].SubSlice[0].Enabled); + dst.SliceInfo[2].DSSInfo[5].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[2].DSSInfo[5].SubSlice[0].EuEnabledCount); + dst.SliceInfo[2].DSSInfo[5].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[2].DSSInfo[5].SubSlice[0].EuEnabledMask); + dst.SliceInfo[2].DSSInfo[5].SubSlice[1].Enabled.setValue(src.SliceInfo[2].DSSInfo[5].SubSlice[1].Enabled); + dst.SliceInfo[2].DSSInfo[5].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[2].DSSInfo[5].SubSlice[1].EuEnabledCount); + dst.SliceInfo[2].DSSInfo[5].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[2].DSSInfo[5].SubSlice[1].EuEnabledMask); + dst.SliceInfo[2].SubSliceEnabledCount.setValue(src.SliceInfo[2].SubSliceEnabledCount); + dst.SliceInfo[2].DualSubSliceEnabledCount.setValue(src.SliceInfo[2].DualSubSliceEnabledCount); + dst.SliceInfo[3].Enabled.setValue(src.SliceInfo[3].Enabled); + dst.SliceInfo[3].SubSliceInfo[0].Enabled.setValue(src.SliceInfo[3].SubSliceInfo[0].Enabled); + dst.SliceInfo[3].SubSliceInfo[0].EuEnabledCount.setValue(src.SliceInfo[3].SubSliceInfo[0].EuEnabledCount); + dst.SliceInfo[3].SubSliceInfo[0].EuEnabledMask.setValue(src.SliceInfo[3].SubSliceInfo[0].EuEnabledMask); + dst.SliceInfo[3].SubSliceInfo[1].Enabled.setValue(src.SliceInfo[3].SubSliceInfo[1].Enabled); + dst.SliceInfo[3].SubSliceInfo[1].EuEnabledCount.setValue(src.SliceInfo[3].SubSliceInfo[1].EuEnabledCount); + dst.SliceInfo[3].SubSliceInfo[1].EuEnabledMask.setValue(src.SliceInfo[3].SubSliceInfo[1].EuEnabledMask); + dst.SliceInfo[3].SubSliceInfo[2].Enabled.setValue(src.SliceInfo[3].SubSliceInfo[2].Enabled); + dst.SliceInfo[3].SubSliceInfo[2].EuEnabledCount.setValue(src.SliceInfo[3].SubSliceInfo[2].EuEnabledCount); + dst.SliceInfo[3].SubSliceInfo[2].EuEnabledMask.setValue(src.SliceInfo[3].SubSliceInfo[2].EuEnabledMask); + dst.SliceInfo[3].SubSliceInfo[3].Enabled.setValue(src.SliceInfo[3].SubSliceInfo[3].Enabled); + dst.SliceInfo[3].SubSliceInfo[3].EuEnabledCount.setValue(src.SliceInfo[3].SubSliceInfo[3].EuEnabledCount); + dst.SliceInfo[3].SubSliceInfo[3].EuEnabledMask.setValue(src.SliceInfo[3].SubSliceInfo[3].EuEnabledMask); + dst.SliceInfo[3].SubSliceInfo[4].Enabled.setValue(src.SliceInfo[3].SubSliceInfo[4].Enabled); + dst.SliceInfo[3].SubSliceInfo[4].EuEnabledCount.setValue(src.SliceInfo[3].SubSliceInfo[4].EuEnabledCount); + dst.SliceInfo[3].SubSliceInfo[4].EuEnabledMask.setValue(src.SliceInfo[3].SubSliceInfo[4].EuEnabledMask); + dst.SliceInfo[3].SubSliceInfo[5].Enabled.setValue(src.SliceInfo[3].SubSliceInfo[5].Enabled); + dst.SliceInfo[3].SubSliceInfo[5].EuEnabledCount.setValue(src.SliceInfo[3].SubSliceInfo[5].EuEnabledCount); + dst.SliceInfo[3].SubSliceInfo[5].EuEnabledMask.setValue(src.SliceInfo[3].SubSliceInfo[5].EuEnabledMask); + dst.SliceInfo[3].SubSliceInfo[6].Enabled.setValue(src.SliceInfo[3].SubSliceInfo[6].Enabled); + dst.SliceInfo[3].SubSliceInfo[6].EuEnabledCount.setValue(src.SliceInfo[3].SubSliceInfo[6].EuEnabledCount); + dst.SliceInfo[3].SubSliceInfo[6].EuEnabledMask.setValue(src.SliceInfo[3].SubSliceInfo[6].EuEnabledMask); + dst.SliceInfo[3].SubSliceInfo[7].Enabled.setValue(src.SliceInfo[3].SubSliceInfo[7].Enabled); + dst.SliceInfo[3].SubSliceInfo[7].EuEnabledCount.setValue(src.SliceInfo[3].SubSliceInfo[7].EuEnabledCount); + dst.SliceInfo[3].SubSliceInfo[7].EuEnabledMask.setValue(src.SliceInfo[3].SubSliceInfo[7].EuEnabledMask); + dst.SliceInfo[3].DSSInfo[0].Enabled.setValue(src.SliceInfo[3].DSSInfo[0].Enabled); + dst.SliceInfo[3].DSSInfo[0].SubSlice[0].Enabled.setValue(src.SliceInfo[3].DSSInfo[0].SubSlice[0].Enabled); + dst.SliceInfo[3].DSSInfo[0].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[3].DSSInfo[0].SubSlice[0].EuEnabledCount); + dst.SliceInfo[3].DSSInfo[0].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[3].DSSInfo[0].SubSlice[0].EuEnabledMask); + dst.SliceInfo[3].DSSInfo[0].SubSlice[1].Enabled.setValue(src.SliceInfo[3].DSSInfo[0].SubSlice[1].Enabled); + dst.SliceInfo[3].DSSInfo[0].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[3].DSSInfo[0].SubSlice[1].EuEnabledCount); + dst.SliceInfo[3].DSSInfo[0].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[3].DSSInfo[0].SubSlice[1].EuEnabledMask); + dst.SliceInfo[3].DSSInfo[1].Enabled.setValue(src.SliceInfo[3].DSSInfo[1].Enabled); + dst.SliceInfo[3].DSSInfo[1].SubSlice[0].Enabled.setValue(src.SliceInfo[3].DSSInfo[1].SubSlice[0].Enabled); + dst.SliceInfo[3].DSSInfo[1].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[3].DSSInfo[1].SubSlice[0].EuEnabledCount); + dst.SliceInfo[3].DSSInfo[1].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[3].DSSInfo[1].SubSlice[0].EuEnabledMask); + dst.SliceInfo[3].DSSInfo[1].SubSlice[1].Enabled.setValue(src.SliceInfo[3].DSSInfo[1].SubSlice[1].Enabled); + dst.SliceInfo[3].DSSInfo[1].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[3].DSSInfo[1].SubSlice[1].EuEnabledCount); + dst.SliceInfo[3].DSSInfo[1].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[3].DSSInfo[1].SubSlice[1].EuEnabledMask); + dst.SliceInfo[3].DSSInfo[2].Enabled.setValue(src.SliceInfo[3].DSSInfo[2].Enabled); + dst.SliceInfo[3].DSSInfo[2].SubSlice[0].Enabled.setValue(src.SliceInfo[3].DSSInfo[2].SubSlice[0].Enabled); + dst.SliceInfo[3].DSSInfo[2].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[3].DSSInfo[2].SubSlice[0].EuEnabledCount); + dst.SliceInfo[3].DSSInfo[2].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[3].DSSInfo[2].SubSlice[0].EuEnabledMask); + dst.SliceInfo[3].DSSInfo[2].SubSlice[1].Enabled.setValue(src.SliceInfo[3].DSSInfo[2].SubSlice[1].Enabled); + dst.SliceInfo[3].DSSInfo[2].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[3].DSSInfo[2].SubSlice[1].EuEnabledCount); + dst.SliceInfo[3].DSSInfo[2].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[3].DSSInfo[2].SubSlice[1].EuEnabledMask); + dst.SliceInfo[3].DSSInfo[3].Enabled.setValue(src.SliceInfo[3].DSSInfo[3].Enabled); + dst.SliceInfo[3].DSSInfo[3].SubSlice[0].Enabled.setValue(src.SliceInfo[3].DSSInfo[3].SubSlice[0].Enabled); + dst.SliceInfo[3].DSSInfo[3].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[3].DSSInfo[3].SubSlice[0].EuEnabledCount); + dst.SliceInfo[3].DSSInfo[3].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[3].DSSInfo[3].SubSlice[0].EuEnabledMask); + dst.SliceInfo[3].DSSInfo[3].SubSlice[1].Enabled.setValue(src.SliceInfo[3].DSSInfo[3].SubSlice[1].Enabled); + dst.SliceInfo[3].DSSInfo[3].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[3].DSSInfo[3].SubSlice[1].EuEnabledCount); + dst.SliceInfo[3].DSSInfo[3].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[3].DSSInfo[3].SubSlice[1].EuEnabledMask); + dst.SliceInfo[3].DSSInfo[4].Enabled.setValue(src.SliceInfo[3].DSSInfo[4].Enabled); + dst.SliceInfo[3].DSSInfo[4].SubSlice[0].Enabled.setValue(src.SliceInfo[3].DSSInfo[4].SubSlice[0].Enabled); + dst.SliceInfo[3].DSSInfo[4].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[3].DSSInfo[4].SubSlice[0].EuEnabledCount); + dst.SliceInfo[3].DSSInfo[4].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[3].DSSInfo[4].SubSlice[0].EuEnabledMask); + dst.SliceInfo[3].DSSInfo[4].SubSlice[1].Enabled.setValue(src.SliceInfo[3].DSSInfo[4].SubSlice[1].Enabled); + dst.SliceInfo[3].DSSInfo[4].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[3].DSSInfo[4].SubSlice[1].EuEnabledCount); + dst.SliceInfo[3].DSSInfo[4].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[3].DSSInfo[4].SubSlice[1].EuEnabledMask); + dst.SliceInfo[3].DSSInfo[5].Enabled.setValue(src.SliceInfo[3].DSSInfo[5].Enabled); + dst.SliceInfo[3].DSSInfo[5].SubSlice[0].Enabled.setValue(src.SliceInfo[3].DSSInfo[5].SubSlice[0].Enabled); + dst.SliceInfo[3].DSSInfo[5].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[3].DSSInfo[5].SubSlice[0].EuEnabledCount); + dst.SliceInfo[3].DSSInfo[5].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[3].DSSInfo[5].SubSlice[0].EuEnabledMask); + dst.SliceInfo[3].DSSInfo[5].SubSlice[1].Enabled.setValue(src.SliceInfo[3].DSSInfo[5].SubSlice[1].Enabled); + dst.SliceInfo[3].DSSInfo[5].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[3].DSSInfo[5].SubSlice[1].EuEnabledCount); + dst.SliceInfo[3].DSSInfo[5].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[3].DSSInfo[5].SubSlice[1].EuEnabledMask); + dst.SliceInfo[3].SubSliceEnabledCount.setValue(src.SliceInfo[3].SubSliceEnabledCount); + dst.SliceInfo[3].DualSubSliceEnabledCount.setValue(src.SliceInfo[3].DualSubSliceEnabledCount); + dst.SliceInfo[4].Enabled.setValue(src.SliceInfo[4].Enabled); + dst.SliceInfo[4].SubSliceInfo[0].Enabled.setValue(src.SliceInfo[4].SubSliceInfo[0].Enabled); + dst.SliceInfo[4].SubSliceInfo[0].EuEnabledCount.setValue(src.SliceInfo[4].SubSliceInfo[0].EuEnabledCount); + dst.SliceInfo[4].SubSliceInfo[0].EuEnabledMask.setValue(src.SliceInfo[4].SubSliceInfo[0].EuEnabledMask); + dst.SliceInfo[4].SubSliceInfo[1].Enabled.setValue(src.SliceInfo[4].SubSliceInfo[1].Enabled); + dst.SliceInfo[4].SubSliceInfo[1].EuEnabledCount.setValue(src.SliceInfo[4].SubSliceInfo[1].EuEnabledCount); + dst.SliceInfo[4].SubSliceInfo[1].EuEnabledMask.setValue(src.SliceInfo[4].SubSliceInfo[1].EuEnabledMask); + dst.SliceInfo[4].SubSliceInfo[2].Enabled.setValue(src.SliceInfo[4].SubSliceInfo[2].Enabled); + dst.SliceInfo[4].SubSliceInfo[2].EuEnabledCount.setValue(src.SliceInfo[4].SubSliceInfo[2].EuEnabledCount); + dst.SliceInfo[4].SubSliceInfo[2].EuEnabledMask.setValue(src.SliceInfo[4].SubSliceInfo[2].EuEnabledMask); + dst.SliceInfo[4].SubSliceInfo[3].Enabled.setValue(src.SliceInfo[4].SubSliceInfo[3].Enabled); + dst.SliceInfo[4].SubSliceInfo[3].EuEnabledCount.setValue(src.SliceInfo[4].SubSliceInfo[3].EuEnabledCount); + dst.SliceInfo[4].SubSliceInfo[3].EuEnabledMask.setValue(src.SliceInfo[4].SubSliceInfo[3].EuEnabledMask); + dst.SliceInfo[4].SubSliceInfo[4].Enabled.setValue(src.SliceInfo[4].SubSliceInfo[4].Enabled); + dst.SliceInfo[4].SubSliceInfo[4].EuEnabledCount.setValue(src.SliceInfo[4].SubSliceInfo[4].EuEnabledCount); + dst.SliceInfo[4].SubSliceInfo[4].EuEnabledMask.setValue(src.SliceInfo[4].SubSliceInfo[4].EuEnabledMask); + dst.SliceInfo[4].SubSliceInfo[5].Enabled.setValue(src.SliceInfo[4].SubSliceInfo[5].Enabled); + dst.SliceInfo[4].SubSliceInfo[5].EuEnabledCount.setValue(src.SliceInfo[4].SubSliceInfo[5].EuEnabledCount); + dst.SliceInfo[4].SubSliceInfo[5].EuEnabledMask.setValue(src.SliceInfo[4].SubSliceInfo[5].EuEnabledMask); + dst.SliceInfo[4].SubSliceInfo[6].Enabled.setValue(src.SliceInfo[4].SubSliceInfo[6].Enabled); + dst.SliceInfo[4].SubSliceInfo[6].EuEnabledCount.setValue(src.SliceInfo[4].SubSliceInfo[6].EuEnabledCount); + dst.SliceInfo[4].SubSliceInfo[6].EuEnabledMask.setValue(src.SliceInfo[4].SubSliceInfo[6].EuEnabledMask); + dst.SliceInfo[4].SubSliceInfo[7].Enabled.setValue(src.SliceInfo[4].SubSliceInfo[7].Enabled); + dst.SliceInfo[4].SubSliceInfo[7].EuEnabledCount.setValue(src.SliceInfo[4].SubSliceInfo[7].EuEnabledCount); + dst.SliceInfo[4].SubSliceInfo[7].EuEnabledMask.setValue(src.SliceInfo[4].SubSliceInfo[7].EuEnabledMask); + dst.SliceInfo[4].DSSInfo[0].Enabled.setValue(src.SliceInfo[4].DSSInfo[0].Enabled); + dst.SliceInfo[4].DSSInfo[0].SubSlice[0].Enabled.setValue(src.SliceInfo[4].DSSInfo[0].SubSlice[0].Enabled); + dst.SliceInfo[4].DSSInfo[0].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[4].DSSInfo[0].SubSlice[0].EuEnabledCount); + dst.SliceInfo[4].DSSInfo[0].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[4].DSSInfo[0].SubSlice[0].EuEnabledMask); + dst.SliceInfo[4].DSSInfo[0].SubSlice[1].Enabled.setValue(src.SliceInfo[4].DSSInfo[0].SubSlice[1].Enabled); + dst.SliceInfo[4].DSSInfo[0].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[4].DSSInfo[0].SubSlice[1].EuEnabledCount); + dst.SliceInfo[4].DSSInfo[0].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[4].DSSInfo[0].SubSlice[1].EuEnabledMask); + dst.SliceInfo[4].DSSInfo[1].Enabled.setValue(src.SliceInfo[4].DSSInfo[1].Enabled); + dst.SliceInfo[4].DSSInfo[1].SubSlice[0].Enabled.setValue(src.SliceInfo[4].DSSInfo[1].SubSlice[0].Enabled); + dst.SliceInfo[4].DSSInfo[1].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[4].DSSInfo[1].SubSlice[0].EuEnabledCount); + dst.SliceInfo[4].DSSInfo[1].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[4].DSSInfo[1].SubSlice[0].EuEnabledMask); + dst.SliceInfo[4].DSSInfo[1].SubSlice[1].Enabled.setValue(src.SliceInfo[4].DSSInfo[1].SubSlice[1].Enabled); + dst.SliceInfo[4].DSSInfo[1].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[4].DSSInfo[1].SubSlice[1].EuEnabledCount); + dst.SliceInfo[4].DSSInfo[1].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[4].DSSInfo[1].SubSlice[1].EuEnabledMask); + dst.SliceInfo[4].DSSInfo[2].Enabled.setValue(src.SliceInfo[4].DSSInfo[2].Enabled); + dst.SliceInfo[4].DSSInfo[2].SubSlice[0].Enabled.setValue(src.SliceInfo[4].DSSInfo[2].SubSlice[0].Enabled); + dst.SliceInfo[4].DSSInfo[2].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[4].DSSInfo[2].SubSlice[0].EuEnabledCount); + dst.SliceInfo[4].DSSInfo[2].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[4].DSSInfo[2].SubSlice[0].EuEnabledMask); + dst.SliceInfo[4].DSSInfo[2].SubSlice[1].Enabled.setValue(src.SliceInfo[4].DSSInfo[2].SubSlice[1].Enabled); + dst.SliceInfo[4].DSSInfo[2].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[4].DSSInfo[2].SubSlice[1].EuEnabledCount); + dst.SliceInfo[4].DSSInfo[2].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[4].DSSInfo[2].SubSlice[1].EuEnabledMask); + dst.SliceInfo[4].DSSInfo[3].Enabled.setValue(src.SliceInfo[4].DSSInfo[3].Enabled); + dst.SliceInfo[4].DSSInfo[3].SubSlice[0].Enabled.setValue(src.SliceInfo[4].DSSInfo[3].SubSlice[0].Enabled); + dst.SliceInfo[4].DSSInfo[3].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[4].DSSInfo[3].SubSlice[0].EuEnabledCount); + dst.SliceInfo[4].DSSInfo[3].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[4].DSSInfo[3].SubSlice[0].EuEnabledMask); + dst.SliceInfo[4].DSSInfo[3].SubSlice[1].Enabled.setValue(src.SliceInfo[4].DSSInfo[3].SubSlice[1].Enabled); + dst.SliceInfo[4].DSSInfo[3].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[4].DSSInfo[3].SubSlice[1].EuEnabledCount); + dst.SliceInfo[4].DSSInfo[3].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[4].DSSInfo[3].SubSlice[1].EuEnabledMask); + dst.SliceInfo[4].DSSInfo[4].Enabled.setValue(src.SliceInfo[4].DSSInfo[4].Enabled); + dst.SliceInfo[4].DSSInfo[4].SubSlice[0].Enabled.setValue(src.SliceInfo[4].DSSInfo[4].SubSlice[0].Enabled); + dst.SliceInfo[4].DSSInfo[4].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[4].DSSInfo[4].SubSlice[0].EuEnabledCount); + dst.SliceInfo[4].DSSInfo[4].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[4].DSSInfo[4].SubSlice[0].EuEnabledMask); + dst.SliceInfo[4].DSSInfo[4].SubSlice[1].Enabled.setValue(src.SliceInfo[4].DSSInfo[4].SubSlice[1].Enabled); + dst.SliceInfo[4].DSSInfo[4].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[4].DSSInfo[4].SubSlice[1].EuEnabledCount); + dst.SliceInfo[4].DSSInfo[4].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[4].DSSInfo[4].SubSlice[1].EuEnabledMask); + dst.SliceInfo[4].DSSInfo[5].Enabled.setValue(src.SliceInfo[4].DSSInfo[5].Enabled); + dst.SliceInfo[4].DSSInfo[5].SubSlice[0].Enabled.setValue(src.SliceInfo[4].DSSInfo[5].SubSlice[0].Enabled); + dst.SliceInfo[4].DSSInfo[5].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[4].DSSInfo[5].SubSlice[0].EuEnabledCount); + dst.SliceInfo[4].DSSInfo[5].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[4].DSSInfo[5].SubSlice[0].EuEnabledMask); + dst.SliceInfo[4].DSSInfo[5].SubSlice[1].Enabled.setValue(src.SliceInfo[4].DSSInfo[5].SubSlice[1].Enabled); + dst.SliceInfo[4].DSSInfo[5].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[4].DSSInfo[5].SubSlice[1].EuEnabledCount); + dst.SliceInfo[4].DSSInfo[5].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[4].DSSInfo[5].SubSlice[1].EuEnabledMask); + dst.SliceInfo[4].SubSliceEnabledCount.setValue(src.SliceInfo[4].SubSliceEnabledCount); + dst.SliceInfo[4].DualSubSliceEnabledCount.setValue(src.SliceInfo[4].DualSubSliceEnabledCount); + dst.SliceInfo[5].Enabled.setValue(src.SliceInfo[5].Enabled); + dst.SliceInfo[5].SubSliceInfo[0].Enabled.setValue(src.SliceInfo[5].SubSliceInfo[0].Enabled); + dst.SliceInfo[5].SubSliceInfo[0].EuEnabledCount.setValue(src.SliceInfo[5].SubSliceInfo[0].EuEnabledCount); + dst.SliceInfo[5].SubSliceInfo[0].EuEnabledMask.setValue(src.SliceInfo[5].SubSliceInfo[0].EuEnabledMask); + dst.SliceInfo[5].SubSliceInfo[1].Enabled.setValue(src.SliceInfo[5].SubSliceInfo[1].Enabled); + dst.SliceInfo[5].SubSliceInfo[1].EuEnabledCount.setValue(src.SliceInfo[5].SubSliceInfo[1].EuEnabledCount); + dst.SliceInfo[5].SubSliceInfo[1].EuEnabledMask.setValue(src.SliceInfo[5].SubSliceInfo[1].EuEnabledMask); + dst.SliceInfo[5].SubSliceInfo[2].Enabled.setValue(src.SliceInfo[5].SubSliceInfo[2].Enabled); + dst.SliceInfo[5].SubSliceInfo[2].EuEnabledCount.setValue(src.SliceInfo[5].SubSliceInfo[2].EuEnabledCount); + dst.SliceInfo[5].SubSliceInfo[2].EuEnabledMask.setValue(src.SliceInfo[5].SubSliceInfo[2].EuEnabledMask); + dst.SliceInfo[5].SubSliceInfo[3].Enabled.setValue(src.SliceInfo[5].SubSliceInfo[3].Enabled); + dst.SliceInfo[5].SubSliceInfo[3].EuEnabledCount.setValue(src.SliceInfo[5].SubSliceInfo[3].EuEnabledCount); + dst.SliceInfo[5].SubSliceInfo[3].EuEnabledMask.setValue(src.SliceInfo[5].SubSliceInfo[3].EuEnabledMask); + dst.SliceInfo[5].SubSliceInfo[4].Enabled.setValue(src.SliceInfo[5].SubSliceInfo[4].Enabled); + dst.SliceInfo[5].SubSliceInfo[4].EuEnabledCount.setValue(src.SliceInfo[5].SubSliceInfo[4].EuEnabledCount); + dst.SliceInfo[5].SubSliceInfo[4].EuEnabledMask.setValue(src.SliceInfo[5].SubSliceInfo[4].EuEnabledMask); + dst.SliceInfo[5].SubSliceInfo[5].Enabled.setValue(src.SliceInfo[5].SubSliceInfo[5].Enabled); + dst.SliceInfo[5].SubSliceInfo[5].EuEnabledCount.setValue(src.SliceInfo[5].SubSliceInfo[5].EuEnabledCount); + dst.SliceInfo[5].SubSliceInfo[5].EuEnabledMask.setValue(src.SliceInfo[5].SubSliceInfo[5].EuEnabledMask); + dst.SliceInfo[5].SubSliceInfo[6].Enabled.setValue(src.SliceInfo[5].SubSliceInfo[6].Enabled); + dst.SliceInfo[5].SubSliceInfo[6].EuEnabledCount.setValue(src.SliceInfo[5].SubSliceInfo[6].EuEnabledCount); + dst.SliceInfo[5].SubSliceInfo[6].EuEnabledMask.setValue(src.SliceInfo[5].SubSliceInfo[6].EuEnabledMask); + dst.SliceInfo[5].SubSliceInfo[7].Enabled.setValue(src.SliceInfo[5].SubSliceInfo[7].Enabled); + dst.SliceInfo[5].SubSliceInfo[7].EuEnabledCount.setValue(src.SliceInfo[5].SubSliceInfo[7].EuEnabledCount); + dst.SliceInfo[5].SubSliceInfo[7].EuEnabledMask.setValue(src.SliceInfo[5].SubSliceInfo[7].EuEnabledMask); + dst.SliceInfo[5].DSSInfo[0].Enabled.setValue(src.SliceInfo[5].DSSInfo[0].Enabled); + dst.SliceInfo[5].DSSInfo[0].SubSlice[0].Enabled.setValue(src.SliceInfo[5].DSSInfo[0].SubSlice[0].Enabled); + dst.SliceInfo[5].DSSInfo[0].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[5].DSSInfo[0].SubSlice[0].EuEnabledCount); + dst.SliceInfo[5].DSSInfo[0].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[5].DSSInfo[0].SubSlice[0].EuEnabledMask); + dst.SliceInfo[5].DSSInfo[0].SubSlice[1].Enabled.setValue(src.SliceInfo[5].DSSInfo[0].SubSlice[1].Enabled); + dst.SliceInfo[5].DSSInfo[0].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[5].DSSInfo[0].SubSlice[1].EuEnabledCount); + dst.SliceInfo[5].DSSInfo[0].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[5].DSSInfo[0].SubSlice[1].EuEnabledMask); + dst.SliceInfo[5].DSSInfo[1].Enabled.setValue(src.SliceInfo[5].DSSInfo[1].Enabled); + dst.SliceInfo[5].DSSInfo[1].SubSlice[0].Enabled.setValue(src.SliceInfo[5].DSSInfo[1].SubSlice[0].Enabled); + dst.SliceInfo[5].DSSInfo[1].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[5].DSSInfo[1].SubSlice[0].EuEnabledCount); + dst.SliceInfo[5].DSSInfo[1].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[5].DSSInfo[1].SubSlice[0].EuEnabledMask); + dst.SliceInfo[5].DSSInfo[1].SubSlice[1].Enabled.setValue(src.SliceInfo[5].DSSInfo[1].SubSlice[1].Enabled); + dst.SliceInfo[5].DSSInfo[1].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[5].DSSInfo[1].SubSlice[1].EuEnabledCount); + dst.SliceInfo[5].DSSInfo[1].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[5].DSSInfo[1].SubSlice[1].EuEnabledMask); + dst.SliceInfo[5].DSSInfo[2].Enabled.setValue(src.SliceInfo[5].DSSInfo[2].Enabled); + dst.SliceInfo[5].DSSInfo[2].SubSlice[0].Enabled.setValue(src.SliceInfo[5].DSSInfo[2].SubSlice[0].Enabled); + dst.SliceInfo[5].DSSInfo[2].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[5].DSSInfo[2].SubSlice[0].EuEnabledCount); + dst.SliceInfo[5].DSSInfo[2].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[5].DSSInfo[2].SubSlice[0].EuEnabledMask); + dst.SliceInfo[5].DSSInfo[2].SubSlice[1].Enabled.setValue(src.SliceInfo[5].DSSInfo[2].SubSlice[1].Enabled); + dst.SliceInfo[5].DSSInfo[2].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[5].DSSInfo[2].SubSlice[1].EuEnabledCount); + dst.SliceInfo[5].DSSInfo[2].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[5].DSSInfo[2].SubSlice[1].EuEnabledMask); + dst.SliceInfo[5].DSSInfo[3].Enabled.setValue(src.SliceInfo[5].DSSInfo[3].Enabled); + dst.SliceInfo[5].DSSInfo[3].SubSlice[0].Enabled.setValue(src.SliceInfo[5].DSSInfo[3].SubSlice[0].Enabled); + dst.SliceInfo[5].DSSInfo[3].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[5].DSSInfo[3].SubSlice[0].EuEnabledCount); + dst.SliceInfo[5].DSSInfo[3].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[5].DSSInfo[3].SubSlice[0].EuEnabledMask); + dst.SliceInfo[5].DSSInfo[3].SubSlice[1].Enabled.setValue(src.SliceInfo[5].DSSInfo[3].SubSlice[1].Enabled); + dst.SliceInfo[5].DSSInfo[3].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[5].DSSInfo[3].SubSlice[1].EuEnabledCount); + dst.SliceInfo[5].DSSInfo[3].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[5].DSSInfo[3].SubSlice[1].EuEnabledMask); + dst.SliceInfo[5].DSSInfo[4].Enabled.setValue(src.SliceInfo[5].DSSInfo[4].Enabled); + dst.SliceInfo[5].DSSInfo[4].SubSlice[0].Enabled.setValue(src.SliceInfo[5].DSSInfo[4].SubSlice[0].Enabled); + dst.SliceInfo[5].DSSInfo[4].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[5].DSSInfo[4].SubSlice[0].EuEnabledCount); + dst.SliceInfo[5].DSSInfo[4].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[5].DSSInfo[4].SubSlice[0].EuEnabledMask); + dst.SliceInfo[5].DSSInfo[4].SubSlice[1].Enabled.setValue(src.SliceInfo[5].DSSInfo[4].SubSlice[1].Enabled); + dst.SliceInfo[5].DSSInfo[4].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[5].DSSInfo[4].SubSlice[1].EuEnabledCount); + dst.SliceInfo[5].DSSInfo[4].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[5].DSSInfo[4].SubSlice[1].EuEnabledMask); + dst.SliceInfo[5].DSSInfo[5].Enabled.setValue(src.SliceInfo[5].DSSInfo[5].Enabled); + dst.SliceInfo[5].DSSInfo[5].SubSlice[0].Enabled.setValue(src.SliceInfo[5].DSSInfo[5].SubSlice[0].Enabled); + dst.SliceInfo[5].DSSInfo[5].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[5].DSSInfo[5].SubSlice[0].EuEnabledCount); + dst.SliceInfo[5].DSSInfo[5].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[5].DSSInfo[5].SubSlice[0].EuEnabledMask); + dst.SliceInfo[5].DSSInfo[5].SubSlice[1].Enabled.setValue(src.SliceInfo[5].DSSInfo[5].SubSlice[1].Enabled); + dst.SliceInfo[5].DSSInfo[5].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[5].DSSInfo[5].SubSlice[1].EuEnabledCount); + dst.SliceInfo[5].DSSInfo[5].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[5].DSSInfo[5].SubSlice[1].EuEnabledMask); + dst.SliceInfo[5].SubSliceEnabledCount.setValue(src.SliceInfo[5].SubSliceEnabledCount); + dst.SliceInfo[5].DualSubSliceEnabledCount.setValue(src.SliceInfo[5].DualSubSliceEnabledCount); + dst.SliceInfo[6].Enabled.setValue(src.SliceInfo[6].Enabled); + dst.SliceInfo[6].SubSliceInfo[0].Enabled.setValue(src.SliceInfo[6].SubSliceInfo[0].Enabled); + dst.SliceInfo[6].SubSliceInfo[0].EuEnabledCount.setValue(src.SliceInfo[6].SubSliceInfo[0].EuEnabledCount); + dst.SliceInfo[6].SubSliceInfo[0].EuEnabledMask.setValue(src.SliceInfo[6].SubSliceInfo[0].EuEnabledMask); + dst.SliceInfo[6].SubSliceInfo[1].Enabled.setValue(src.SliceInfo[6].SubSliceInfo[1].Enabled); + dst.SliceInfo[6].SubSliceInfo[1].EuEnabledCount.setValue(src.SliceInfo[6].SubSliceInfo[1].EuEnabledCount); + dst.SliceInfo[6].SubSliceInfo[1].EuEnabledMask.setValue(src.SliceInfo[6].SubSliceInfo[1].EuEnabledMask); + dst.SliceInfo[6].SubSliceInfo[2].Enabled.setValue(src.SliceInfo[6].SubSliceInfo[2].Enabled); + dst.SliceInfo[6].SubSliceInfo[2].EuEnabledCount.setValue(src.SliceInfo[6].SubSliceInfo[2].EuEnabledCount); + dst.SliceInfo[6].SubSliceInfo[2].EuEnabledMask.setValue(src.SliceInfo[6].SubSliceInfo[2].EuEnabledMask); + dst.SliceInfo[6].SubSliceInfo[3].Enabled.setValue(src.SliceInfo[6].SubSliceInfo[3].Enabled); + dst.SliceInfo[6].SubSliceInfo[3].EuEnabledCount.setValue(src.SliceInfo[6].SubSliceInfo[3].EuEnabledCount); + dst.SliceInfo[6].SubSliceInfo[3].EuEnabledMask.setValue(src.SliceInfo[6].SubSliceInfo[3].EuEnabledMask); + dst.SliceInfo[6].SubSliceInfo[4].Enabled.setValue(src.SliceInfo[6].SubSliceInfo[4].Enabled); + dst.SliceInfo[6].SubSliceInfo[4].EuEnabledCount.setValue(src.SliceInfo[6].SubSliceInfo[4].EuEnabledCount); + dst.SliceInfo[6].SubSliceInfo[4].EuEnabledMask.setValue(src.SliceInfo[6].SubSliceInfo[4].EuEnabledMask); + dst.SliceInfo[6].SubSliceInfo[5].Enabled.setValue(src.SliceInfo[6].SubSliceInfo[5].Enabled); + dst.SliceInfo[6].SubSliceInfo[5].EuEnabledCount.setValue(src.SliceInfo[6].SubSliceInfo[5].EuEnabledCount); + dst.SliceInfo[6].SubSliceInfo[5].EuEnabledMask.setValue(src.SliceInfo[6].SubSliceInfo[5].EuEnabledMask); + dst.SliceInfo[6].SubSliceInfo[6].Enabled.setValue(src.SliceInfo[6].SubSliceInfo[6].Enabled); + dst.SliceInfo[6].SubSliceInfo[6].EuEnabledCount.setValue(src.SliceInfo[6].SubSliceInfo[6].EuEnabledCount); + dst.SliceInfo[6].SubSliceInfo[6].EuEnabledMask.setValue(src.SliceInfo[6].SubSliceInfo[6].EuEnabledMask); + dst.SliceInfo[6].SubSliceInfo[7].Enabled.setValue(src.SliceInfo[6].SubSliceInfo[7].Enabled); + dst.SliceInfo[6].SubSliceInfo[7].EuEnabledCount.setValue(src.SliceInfo[6].SubSliceInfo[7].EuEnabledCount); + dst.SliceInfo[6].SubSliceInfo[7].EuEnabledMask.setValue(src.SliceInfo[6].SubSliceInfo[7].EuEnabledMask); + dst.SliceInfo[6].DSSInfo[0].Enabled.setValue(src.SliceInfo[6].DSSInfo[0].Enabled); + dst.SliceInfo[6].DSSInfo[0].SubSlice[0].Enabled.setValue(src.SliceInfo[6].DSSInfo[0].SubSlice[0].Enabled); + dst.SliceInfo[6].DSSInfo[0].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[6].DSSInfo[0].SubSlice[0].EuEnabledCount); + dst.SliceInfo[6].DSSInfo[0].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[6].DSSInfo[0].SubSlice[0].EuEnabledMask); + dst.SliceInfo[6].DSSInfo[0].SubSlice[1].Enabled.setValue(src.SliceInfo[6].DSSInfo[0].SubSlice[1].Enabled); + dst.SliceInfo[6].DSSInfo[0].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[6].DSSInfo[0].SubSlice[1].EuEnabledCount); + dst.SliceInfo[6].DSSInfo[0].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[6].DSSInfo[0].SubSlice[1].EuEnabledMask); + dst.SliceInfo[6].DSSInfo[1].Enabled.setValue(src.SliceInfo[6].DSSInfo[1].Enabled); + dst.SliceInfo[6].DSSInfo[1].SubSlice[0].Enabled.setValue(src.SliceInfo[6].DSSInfo[1].SubSlice[0].Enabled); + dst.SliceInfo[6].DSSInfo[1].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[6].DSSInfo[1].SubSlice[0].EuEnabledCount); + dst.SliceInfo[6].DSSInfo[1].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[6].DSSInfo[1].SubSlice[0].EuEnabledMask); + dst.SliceInfo[6].DSSInfo[1].SubSlice[1].Enabled.setValue(src.SliceInfo[6].DSSInfo[1].SubSlice[1].Enabled); + dst.SliceInfo[6].DSSInfo[1].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[6].DSSInfo[1].SubSlice[1].EuEnabledCount); + dst.SliceInfo[6].DSSInfo[1].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[6].DSSInfo[1].SubSlice[1].EuEnabledMask); + dst.SliceInfo[6].DSSInfo[2].Enabled.setValue(src.SliceInfo[6].DSSInfo[2].Enabled); + dst.SliceInfo[6].DSSInfo[2].SubSlice[0].Enabled.setValue(src.SliceInfo[6].DSSInfo[2].SubSlice[0].Enabled); + dst.SliceInfo[6].DSSInfo[2].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[6].DSSInfo[2].SubSlice[0].EuEnabledCount); + dst.SliceInfo[6].DSSInfo[2].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[6].DSSInfo[2].SubSlice[0].EuEnabledMask); + dst.SliceInfo[6].DSSInfo[2].SubSlice[1].Enabled.setValue(src.SliceInfo[6].DSSInfo[2].SubSlice[1].Enabled); + dst.SliceInfo[6].DSSInfo[2].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[6].DSSInfo[2].SubSlice[1].EuEnabledCount); + dst.SliceInfo[6].DSSInfo[2].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[6].DSSInfo[2].SubSlice[1].EuEnabledMask); + dst.SliceInfo[6].DSSInfo[3].Enabled.setValue(src.SliceInfo[6].DSSInfo[3].Enabled); + dst.SliceInfo[6].DSSInfo[3].SubSlice[0].Enabled.setValue(src.SliceInfo[6].DSSInfo[3].SubSlice[0].Enabled); + dst.SliceInfo[6].DSSInfo[3].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[6].DSSInfo[3].SubSlice[0].EuEnabledCount); + dst.SliceInfo[6].DSSInfo[3].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[6].DSSInfo[3].SubSlice[0].EuEnabledMask); + dst.SliceInfo[6].DSSInfo[3].SubSlice[1].Enabled.setValue(src.SliceInfo[6].DSSInfo[3].SubSlice[1].Enabled); + dst.SliceInfo[6].DSSInfo[3].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[6].DSSInfo[3].SubSlice[1].EuEnabledCount); + dst.SliceInfo[6].DSSInfo[3].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[6].DSSInfo[3].SubSlice[1].EuEnabledMask); + dst.SliceInfo[6].DSSInfo[4].Enabled.setValue(src.SliceInfo[6].DSSInfo[4].Enabled); + dst.SliceInfo[6].DSSInfo[4].SubSlice[0].Enabled.setValue(src.SliceInfo[6].DSSInfo[4].SubSlice[0].Enabled); + dst.SliceInfo[6].DSSInfo[4].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[6].DSSInfo[4].SubSlice[0].EuEnabledCount); + dst.SliceInfo[6].DSSInfo[4].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[6].DSSInfo[4].SubSlice[0].EuEnabledMask); + dst.SliceInfo[6].DSSInfo[4].SubSlice[1].Enabled.setValue(src.SliceInfo[6].DSSInfo[4].SubSlice[1].Enabled); + dst.SliceInfo[6].DSSInfo[4].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[6].DSSInfo[4].SubSlice[1].EuEnabledCount); + dst.SliceInfo[6].DSSInfo[4].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[6].DSSInfo[4].SubSlice[1].EuEnabledMask); + dst.SliceInfo[6].DSSInfo[5].Enabled.setValue(src.SliceInfo[6].DSSInfo[5].Enabled); + dst.SliceInfo[6].DSSInfo[5].SubSlice[0].Enabled.setValue(src.SliceInfo[6].DSSInfo[5].SubSlice[0].Enabled); + dst.SliceInfo[6].DSSInfo[5].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[6].DSSInfo[5].SubSlice[0].EuEnabledCount); + dst.SliceInfo[6].DSSInfo[5].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[6].DSSInfo[5].SubSlice[0].EuEnabledMask); + dst.SliceInfo[6].DSSInfo[5].SubSlice[1].Enabled.setValue(src.SliceInfo[6].DSSInfo[5].SubSlice[1].Enabled); + dst.SliceInfo[6].DSSInfo[5].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[6].DSSInfo[5].SubSlice[1].EuEnabledCount); + dst.SliceInfo[6].DSSInfo[5].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[6].DSSInfo[5].SubSlice[1].EuEnabledMask); + dst.SliceInfo[6].SubSliceEnabledCount.setValue(src.SliceInfo[6].SubSliceEnabledCount); + dst.SliceInfo[6].DualSubSliceEnabledCount.setValue(src.SliceInfo[6].DualSubSliceEnabledCount); + dst.SliceInfo[7].Enabled.setValue(src.SliceInfo[7].Enabled); + dst.SliceInfo[7].SubSliceInfo[0].Enabled.setValue(src.SliceInfo[7].SubSliceInfo[0].Enabled); + dst.SliceInfo[7].SubSliceInfo[0].EuEnabledCount.setValue(src.SliceInfo[7].SubSliceInfo[0].EuEnabledCount); + dst.SliceInfo[7].SubSliceInfo[0].EuEnabledMask.setValue(src.SliceInfo[7].SubSliceInfo[0].EuEnabledMask); + dst.SliceInfo[7].SubSliceInfo[1].Enabled.setValue(src.SliceInfo[7].SubSliceInfo[1].Enabled); + dst.SliceInfo[7].SubSliceInfo[1].EuEnabledCount.setValue(src.SliceInfo[7].SubSliceInfo[1].EuEnabledCount); + dst.SliceInfo[7].SubSliceInfo[1].EuEnabledMask.setValue(src.SliceInfo[7].SubSliceInfo[1].EuEnabledMask); + dst.SliceInfo[7].SubSliceInfo[2].Enabled.setValue(src.SliceInfo[7].SubSliceInfo[2].Enabled); + dst.SliceInfo[7].SubSliceInfo[2].EuEnabledCount.setValue(src.SliceInfo[7].SubSliceInfo[2].EuEnabledCount); + dst.SliceInfo[7].SubSliceInfo[2].EuEnabledMask.setValue(src.SliceInfo[7].SubSliceInfo[2].EuEnabledMask); + dst.SliceInfo[7].SubSliceInfo[3].Enabled.setValue(src.SliceInfo[7].SubSliceInfo[3].Enabled); + dst.SliceInfo[7].SubSliceInfo[3].EuEnabledCount.setValue(src.SliceInfo[7].SubSliceInfo[3].EuEnabledCount); + dst.SliceInfo[7].SubSliceInfo[3].EuEnabledMask.setValue(src.SliceInfo[7].SubSliceInfo[3].EuEnabledMask); + dst.SliceInfo[7].SubSliceInfo[4].Enabled.setValue(src.SliceInfo[7].SubSliceInfo[4].Enabled); + dst.SliceInfo[7].SubSliceInfo[4].EuEnabledCount.setValue(src.SliceInfo[7].SubSliceInfo[4].EuEnabledCount); + dst.SliceInfo[7].SubSliceInfo[4].EuEnabledMask.setValue(src.SliceInfo[7].SubSliceInfo[4].EuEnabledMask); + dst.SliceInfo[7].SubSliceInfo[5].Enabled.setValue(src.SliceInfo[7].SubSliceInfo[5].Enabled); + dst.SliceInfo[7].SubSliceInfo[5].EuEnabledCount.setValue(src.SliceInfo[7].SubSliceInfo[5].EuEnabledCount); + dst.SliceInfo[7].SubSliceInfo[5].EuEnabledMask.setValue(src.SliceInfo[7].SubSliceInfo[5].EuEnabledMask); + dst.SliceInfo[7].SubSliceInfo[6].Enabled.setValue(src.SliceInfo[7].SubSliceInfo[6].Enabled); + dst.SliceInfo[7].SubSliceInfo[6].EuEnabledCount.setValue(src.SliceInfo[7].SubSliceInfo[6].EuEnabledCount); + dst.SliceInfo[7].SubSliceInfo[6].EuEnabledMask.setValue(src.SliceInfo[7].SubSliceInfo[6].EuEnabledMask); + dst.SliceInfo[7].SubSliceInfo[7].Enabled.setValue(src.SliceInfo[7].SubSliceInfo[7].Enabled); + dst.SliceInfo[7].SubSliceInfo[7].EuEnabledCount.setValue(src.SliceInfo[7].SubSliceInfo[7].EuEnabledCount); + dst.SliceInfo[7].SubSliceInfo[7].EuEnabledMask.setValue(src.SliceInfo[7].SubSliceInfo[7].EuEnabledMask); + dst.SliceInfo[7].DSSInfo[0].Enabled.setValue(src.SliceInfo[7].DSSInfo[0].Enabled); + dst.SliceInfo[7].DSSInfo[0].SubSlice[0].Enabled.setValue(src.SliceInfo[7].DSSInfo[0].SubSlice[0].Enabled); + dst.SliceInfo[7].DSSInfo[0].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[7].DSSInfo[0].SubSlice[0].EuEnabledCount); + dst.SliceInfo[7].DSSInfo[0].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[7].DSSInfo[0].SubSlice[0].EuEnabledMask); + dst.SliceInfo[7].DSSInfo[0].SubSlice[1].Enabled.setValue(src.SliceInfo[7].DSSInfo[0].SubSlice[1].Enabled); + dst.SliceInfo[7].DSSInfo[0].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[7].DSSInfo[0].SubSlice[1].EuEnabledCount); + dst.SliceInfo[7].DSSInfo[0].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[7].DSSInfo[0].SubSlice[1].EuEnabledMask); + dst.SliceInfo[7].DSSInfo[1].Enabled.setValue(src.SliceInfo[7].DSSInfo[1].Enabled); + dst.SliceInfo[7].DSSInfo[1].SubSlice[0].Enabled.setValue(src.SliceInfo[7].DSSInfo[1].SubSlice[0].Enabled); + dst.SliceInfo[7].DSSInfo[1].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[7].DSSInfo[1].SubSlice[0].EuEnabledCount); + dst.SliceInfo[7].DSSInfo[1].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[7].DSSInfo[1].SubSlice[0].EuEnabledMask); + dst.SliceInfo[7].DSSInfo[1].SubSlice[1].Enabled.setValue(src.SliceInfo[7].DSSInfo[1].SubSlice[1].Enabled); + dst.SliceInfo[7].DSSInfo[1].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[7].DSSInfo[1].SubSlice[1].EuEnabledCount); + dst.SliceInfo[7].DSSInfo[1].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[7].DSSInfo[1].SubSlice[1].EuEnabledMask); + dst.SliceInfo[7].DSSInfo[2].Enabled.setValue(src.SliceInfo[7].DSSInfo[2].Enabled); + dst.SliceInfo[7].DSSInfo[2].SubSlice[0].Enabled.setValue(src.SliceInfo[7].DSSInfo[2].SubSlice[0].Enabled); + dst.SliceInfo[7].DSSInfo[2].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[7].DSSInfo[2].SubSlice[0].EuEnabledCount); + dst.SliceInfo[7].DSSInfo[2].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[7].DSSInfo[2].SubSlice[0].EuEnabledMask); + dst.SliceInfo[7].DSSInfo[2].SubSlice[1].Enabled.setValue(src.SliceInfo[7].DSSInfo[2].SubSlice[1].Enabled); + dst.SliceInfo[7].DSSInfo[2].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[7].DSSInfo[2].SubSlice[1].EuEnabledCount); + dst.SliceInfo[7].DSSInfo[2].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[7].DSSInfo[2].SubSlice[1].EuEnabledMask); + dst.SliceInfo[7].DSSInfo[3].Enabled.setValue(src.SliceInfo[7].DSSInfo[3].Enabled); + dst.SliceInfo[7].DSSInfo[3].SubSlice[0].Enabled.setValue(src.SliceInfo[7].DSSInfo[3].SubSlice[0].Enabled); + dst.SliceInfo[7].DSSInfo[3].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[7].DSSInfo[3].SubSlice[0].EuEnabledCount); + dst.SliceInfo[7].DSSInfo[3].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[7].DSSInfo[3].SubSlice[0].EuEnabledMask); + dst.SliceInfo[7].DSSInfo[3].SubSlice[1].Enabled.setValue(src.SliceInfo[7].DSSInfo[3].SubSlice[1].Enabled); + dst.SliceInfo[7].DSSInfo[3].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[7].DSSInfo[3].SubSlice[1].EuEnabledCount); + dst.SliceInfo[7].DSSInfo[3].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[7].DSSInfo[3].SubSlice[1].EuEnabledMask); + dst.SliceInfo[7].DSSInfo[4].Enabled.setValue(src.SliceInfo[7].DSSInfo[4].Enabled); + dst.SliceInfo[7].DSSInfo[4].SubSlice[0].Enabled.setValue(src.SliceInfo[7].DSSInfo[4].SubSlice[0].Enabled); + dst.SliceInfo[7].DSSInfo[4].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[7].DSSInfo[4].SubSlice[0].EuEnabledCount); + dst.SliceInfo[7].DSSInfo[4].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[7].DSSInfo[4].SubSlice[0].EuEnabledMask); + dst.SliceInfo[7].DSSInfo[4].SubSlice[1].Enabled.setValue(src.SliceInfo[7].DSSInfo[4].SubSlice[1].Enabled); + dst.SliceInfo[7].DSSInfo[4].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[7].DSSInfo[4].SubSlice[1].EuEnabledCount); + dst.SliceInfo[7].DSSInfo[4].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[7].DSSInfo[4].SubSlice[1].EuEnabledMask); + dst.SliceInfo[7].DSSInfo[5].Enabled.setValue(src.SliceInfo[7].DSSInfo[5].Enabled); + dst.SliceInfo[7].DSSInfo[5].SubSlice[0].Enabled.setValue(src.SliceInfo[7].DSSInfo[5].SubSlice[0].Enabled); + dst.SliceInfo[7].DSSInfo[5].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[7].DSSInfo[5].SubSlice[0].EuEnabledCount); + dst.SliceInfo[7].DSSInfo[5].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[7].DSSInfo[5].SubSlice[0].EuEnabledMask); + dst.SliceInfo[7].DSSInfo[5].SubSlice[1].Enabled.setValue(src.SliceInfo[7].DSSInfo[5].SubSlice[1].Enabled); + dst.SliceInfo[7].DSSInfo[5].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[7].DSSInfo[5].SubSlice[1].EuEnabledCount); + dst.SliceInfo[7].DSSInfo[5].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[7].DSSInfo[5].SubSlice[1].EuEnabledMask); + dst.SliceInfo[7].SubSliceEnabledCount.setValue(src.SliceInfo[7].SubSliceEnabledCount); + dst.SliceInfo[7].DualSubSliceEnabledCount.setValue(src.SliceInfo[7].DualSubSliceEnabledCount); + dst.SliceInfo[8].Enabled.setValue(src.SliceInfo[8].Enabled); + dst.SliceInfo[8].SubSliceInfo[0].Enabled.setValue(src.SliceInfo[8].SubSliceInfo[0].Enabled); + dst.SliceInfo[8].SubSliceInfo[0].EuEnabledCount.setValue(src.SliceInfo[8].SubSliceInfo[0].EuEnabledCount); + dst.SliceInfo[8].SubSliceInfo[0].EuEnabledMask.setValue(src.SliceInfo[8].SubSliceInfo[0].EuEnabledMask); + dst.SliceInfo[8].SubSliceInfo[1].Enabled.setValue(src.SliceInfo[8].SubSliceInfo[1].Enabled); + dst.SliceInfo[8].SubSliceInfo[1].EuEnabledCount.setValue(src.SliceInfo[8].SubSliceInfo[1].EuEnabledCount); + dst.SliceInfo[8].SubSliceInfo[1].EuEnabledMask.setValue(src.SliceInfo[8].SubSliceInfo[1].EuEnabledMask); + dst.SliceInfo[8].SubSliceInfo[2].Enabled.setValue(src.SliceInfo[8].SubSliceInfo[2].Enabled); + dst.SliceInfo[8].SubSliceInfo[2].EuEnabledCount.setValue(src.SliceInfo[8].SubSliceInfo[2].EuEnabledCount); + dst.SliceInfo[8].SubSliceInfo[2].EuEnabledMask.setValue(src.SliceInfo[8].SubSliceInfo[2].EuEnabledMask); + dst.SliceInfo[8].SubSliceInfo[3].Enabled.setValue(src.SliceInfo[8].SubSliceInfo[3].Enabled); + dst.SliceInfo[8].SubSliceInfo[3].EuEnabledCount.setValue(src.SliceInfo[8].SubSliceInfo[3].EuEnabledCount); + dst.SliceInfo[8].SubSliceInfo[3].EuEnabledMask.setValue(src.SliceInfo[8].SubSliceInfo[3].EuEnabledMask); + dst.SliceInfo[8].SubSliceInfo[4].Enabled.setValue(src.SliceInfo[8].SubSliceInfo[4].Enabled); + dst.SliceInfo[8].SubSliceInfo[4].EuEnabledCount.setValue(src.SliceInfo[8].SubSliceInfo[4].EuEnabledCount); + dst.SliceInfo[8].SubSliceInfo[4].EuEnabledMask.setValue(src.SliceInfo[8].SubSliceInfo[4].EuEnabledMask); + dst.SliceInfo[8].SubSliceInfo[5].Enabled.setValue(src.SliceInfo[8].SubSliceInfo[5].Enabled); + dst.SliceInfo[8].SubSliceInfo[5].EuEnabledCount.setValue(src.SliceInfo[8].SubSliceInfo[5].EuEnabledCount); + dst.SliceInfo[8].SubSliceInfo[5].EuEnabledMask.setValue(src.SliceInfo[8].SubSliceInfo[5].EuEnabledMask); + dst.SliceInfo[8].SubSliceInfo[6].Enabled.setValue(src.SliceInfo[8].SubSliceInfo[6].Enabled); + dst.SliceInfo[8].SubSliceInfo[6].EuEnabledCount.setValue(src.SliceInfo[8].SubSliceInfo[6].EuEnabledCount); + dst.SliceInfo[8].SubSliceInfo[6].EuEnabledMask.setValue(src.SliceInfo[8].SubSliceInfo[6].EuEnabledMask); + dst.SliceInfo[8].SubSliceInfo[7].Enabled.setValue(src.SliceInfo[8].SubSliceInfo[7].Enabled); + dst.SliceInfo[8].SubSliceInfo[7].EuEnabledCount.setValue(src.SliceInfo[8].SubSliceInfo[7].EuEnabledCount); + dst.SliceInfo[8].SubSliceInfo[7].EuEnabledMask.setValue(src.SliceInfo[8].SubSliceInfo[7].EuEnabledMask); + dst.SliceInfo[8].DSSInfo[0].Enabled.setValue(src.SliceInfo[8].DSSInfo[0].Enabled); + dst.SliceInfo[8].DSSInfo[0].SubSlice[0].Enabled.setValue(src.SliceInfo[8].DSSInfo[0].SubSlice[0].Enabled); + dst.SliceInfo[8].DSSInfo[0].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[8].DSSInfo[0].SubSlice[0].EuEnabledCount); + dst.SliceInfo[8].DSSInfo[0].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[8].DSSInfo[0].SubSlice[0].EuEnabledMask); + dst.SliceInfo[8].DSSInfo[0].SubSlice[1].Enabled.setValue(src.SliceInfo[8].DSSInfo[0].SubSlice[1].Enabled); + dst.SliceInfo[8].DSSInfo[0].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[8].DSSInfo[0].SubSlice[1].EuEnabledCount); + dst.SliceInfo[8].DSSInfo[0].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[8].DSSInfo[0].SubSlice[1].EuEnabledMask); + dst.SliceInfo[8].DSSInfo[1].Enabled.setValue(src.SliceInfo[8].DSSInfo[1].Enabled); + dst.SliceInfo[8].DSSInfo[1].SubSlice[0].Enabled.setValue(src.SliceInfo[8].DSSInfo[1].SubSlice[0].Enabled); + dst.SliceInfo[8].DSSInfo[1].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[8].DSSInfo[1].SubSlice[0].EuEnabledCount); + dst.SliceInfo[8].DSSInfo[1].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[8].DSSInfo[1].SubSlice[0].EuEnabledMask); + dst.SliceInfo[8].DSSInfo[1].SubSlice[1].Enabled.setValue(src.SliceInfo[8].DSSInfo[1].SubSlice[1].Enabled); + dst.SliceInfo[8].DSSInfo[1].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[8].DSSInfo[1].SubSlice[1].EuEnabledCount); + dst.SliceInfo[8].DSSInfo[1].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[8].DSSInfo[1].SubSlice[1].EuEnabledMask); + dst.SliceInfo[8].DSSInfo[2].Enabled.setValue(src.SliceInfo[8].DSSInfo[2].Enabled); + dst.SliceInfo[8].DSSInfo[2].SubSlice[0].Enabled.setValue(src.SliceInfo[8].DSSInfo[2].SubSlice[0].Enabled); + dst.SliceInfo[8].DSSInfo[2].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[8].DSSInfo[2].SubSlice[0].EuEnabledCount); + dst.SliceInfo[8].DSSInfo[2].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[8].DSSInfo[2].SubSlice[0].EuEnabledMask); + dst.SliceInfo[8].DSSInfo[2].SubSlice[1].Enabled.setValue(src.SliceInfo[8].DSSInfo[2].SubSlice[1].Enabled); + dst.SliceInfo[8].DSSInfo[2].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[8].DSSInfo[2].SubSlice[1].EuEnabledCount); + dst.SliceInfo[8].DSSInfo[2].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[8].DSSInfo[2].SubSlice[1].EuEnabledMask); + dst.SliceInfo[8].DSSInfo[3].Enabled.setValue(src.SliceInfo[8].DSSInfo[3].Enabled); + dst.SliceInfo[8].DSSInfo[3].SubSlice[0].Enabled.setValue(src.SliceInfo[8].DSSInfo[3].SubSlice[0].Enabled); + dst.SliceInfo[8].DSSInfo[3].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[8].DSSInfo[3].SubSlice[0].EuEnabledCount); + dst.SliceInfo[8].DSSInfo[3].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[8].DSSInfo[3].SubSlice[0].EuEnabledMask); + dst.SliceInfo[8].DSSInfo[3].SubSlice[1].Enabled.setValue(src.SliceInfo[8].DSSInfo[3].SubSlice[1].Enabled); + dst.SliceInfo[8].DSSInfo[3].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[8].DSSInfo[3].SubSlice[1].EuEnabledCount); + dst.SliceInfo[8].DSSInfo[3].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[8].DSSInfo[3].SubSlice[1].EuEnabledMask); + dst.SliceInfo[8].DSSInfo[4].Enabled.setValue(src.SliceInfo[8].DSSInfo[4].Enabled); + dst.SliceInfo[8].DSSInfo[4].SubSlice[0].Enabled.setValue(src.SliceInfo[8].DSSInfo[4].SubSlice[0].Enabled); + dst.SliceInfo[8].DSSInfo[4].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[8].DSSInfo[4].SubSlice[0].EuEnabledCount); + dst.SliceInfo[8].DSSInfo[4].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[8].DSSInfo[4].SubSlice[0].EuEnabledMask); + dst.SliceInfo[8].DSSInfo[4].SubSlice[1].Enabled.setValue(src.SliceInfo[8].DSSInfo[4].SubSlice[1].Enabled); + dst.SliceInfo[8].DSSInfo[4].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[8].DSSInfo[4].SubSlice[1].EuEnabledCount); + dst.SliceInfo[8].DSSInfo[4].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[8].DSSInfo[4].SubSlice[1].EuEnabledMask); + dst.SliceInfo[8].DSSInfo[5].Enabled.setValue(src.SliceInfo[8].DSSInfo[5].Enabled); + dst.SliceInfo[8].DSSInfo[5].SubSlice[0].Enabled.setValue(src.SliceInfo[8].DSSInfo[5].SubSlice[0].Enabled); + dst.SliceInfo[8].DSSInfo[5].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[8].DSSInfo[5].SubSlice[0].EuEnabledCount); + dst.SliceInfo[8].DSSInfo[5].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[8].DSSInfo[5].SubSlice[0].EuEnabledMask); + dst.SliceInfo[8].DSSInfo[5].SubSlice[1].Enabled.setValue(src.SliceInfo[8].DSSInfo[5].SubSlice[1].Enabled); + dst.SliceInfo[8].DSSInfo[5].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[8].DSSInfo[5].SubSlice[1].EuEnabledCount); + dst.SliceInfo[8].DSSInfo[5].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[8].DSSInfo[5].SubSlice[1].EuEnabledMask); + dst.SliceInfo[8].SubSliceEnabledCount.setValue(src.SliceInfo[8].SubSliceEnabledCount); + dst.SliceInfo[8].DualSubSliceEnabledCount.setValue(src.SliceInfo[8].DualSubSliceEnabledCount); + dst.SliceInfo[9].Enabled.setValue(src.SliceInfo[9].Enabled); + dst.SliceInfo[9].SubSliceInfo[0].Enabled.setValue(src.SliceInfo[9].SubSliceInfo[0].Enabled); + dst.SliceInfo[9].SubSliceInfo[0].EuEnabledCount.setValue(src.SliceInfo[9].SubSliceInfo[0].EuEnabledCount); + dst.SliceInfo[9].SubSliceInfo[0].EuEnabledMask.setValue(src.SliceInfo[9].SubSliceInfo[0].EuEnabledMask); + dst.SliceInfo[9].SubSliceInfo[1].Enabled.setValue(src.SliceInfo[9].SubSliceInfo[1].Enabled); + dst.SliceInfo[9].SubSliceInfo[1].EuEnabledCount.setValue(src.SliceInfo[9].SubSliceInfo[1].EuEnabledCount); + dst.SliceInfo[9].SubSliceInfo[1].EuEnabledMask.setValue(src.SliceInfo[9].SubSliceInfo[1].EuEnabledMask); + dst.SliceInfo[9].SubSliceInfo[2].Enabled.setValue(src.SliceInfo[9].SubSliceInfo[2].Enabled); + dst.SliceInfo[9].SubSliceInfo[2].EuEnabledCount.setValue(src.SliceInfo[9].SubSliceInfo[2].EuEnabledCount); + dst.SliceInfo[9].SubSliceInfo[2].EuEnabledMask.setValue(src.SliceInfo[9].SubSliceInfo[2].EuEnabledMask); + dst.SliceInfo[9].SubSliceInfo[3].Enabled.setValue(src.SliceInfo[9].SubSliceInfo[3].Enabled); + dst.SliceInfo[9].SubSliceInfo[3].EuEnabledCount.setValue(src.SliceInfo[9].SubSliceInfo[3].EuEnabledCount); + dst.SliceInfo[9].SubSliceInfo[3].EuEnabledMask.setValue(src.SliceInfo[9].SubSliceInfo[3].EuEnabledMask); + dst.SliceInfo[9].SubSliceInfo[4].Enabled.setValue(src.SliceInfo[9].SubSliceInfo[4].Enabled); + dst.SliceInfo[9].SubSliceInfo[4].EuEnabledCount.setValue(src.SliceInfo[9].SubSliceInfo[4].EuEnabledCount); + dst.SliceInfo[9].SubSliceInfo[4].EuEnabledMask.setValue(src.SliceInfo[9].SubSliceInfo[4].EuEnabledMask); + dst.SliceInfo[9].SubSliceInfo[5].Enabled.setValue(src.SliceInfo[9].SubSliceInfo[5].Enabled); + dst.SliceInfo[9].SubSliceInfo[5].EuEnabledCount.setValue(src.SliceInfo[9].SubSliceInfo[5].EuEnabledCount); + dst.SliceInfo[9].SubSliceInfo[5].EuEnabledMask.setValue(src.SliceInfo[9].SubSliceInfo[5].EuEnabledMask); + dst.SliceInfo[9].SubSliceInfo[6].Enabled.setValue(src.SliceInfo[9].SubSliceInfo[6].Enabled); + dst.SliceInfo[9].SubSliceInfo[6].EuEnabledCount.setValue(src.SliceInfo[9].SubSliceInfo[6].EuEnabledCount); + dst.SliceInfo[9].SubSliceInfo[6].EuEnabledMask.setValue(src.SliceInfo[9].SubSliceInfo[6].EuEnabledMask); + dst.SliceInfo[9].SubSliceInfo[7].Enabled.setValue(src.SliceInfo[9].SubSliceInfo[7].Enabled); + dst.SliceInfo[9].SubSliceInfo[7].EuEnabledCount.setValue(src.SliceInfo[9].SubSliceInfo[7].EuEnabledCount); + dst.SliceInfo[9].SubSliceInfo[7].EuEnabledMask.setValue(src.SliceInfo[9].SubSliceInfo[7].EuEnabledMask); + dst.SliceInfo[9].DSSInfo[0].Enabled.setValue(src.SliceInfo[9].DSSInfo[0].Enabled); + dst.SliceInfo[9].DSSInfo[0].SubSlice[0].Enabled.setValue(src.SliceInfo[9].DSSInfo[0].SubSlice[0].Enabled); + dst.SliceInfo[9].DSSInfo[0].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[9].DSSInfo[0].SubSlice[0].EuEnabledCount); + dst.SliceInfo[9].DSSInfo[0].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[9].DSSInfo[0].SubSlice[0].EuEnabledMask); + dst.SliceInfo[9].DSSInfo[0].SubSlice[1].Enabled.setValue(src.SliceInfo[9].DSSInfo[0].SubSlice[1].Enabled); + dst.SliceInfo[9].DSSInfo[0].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[9].DSSInfo[0].SubSlice[1].EuEnabledCount); + dst.SliceInfo[9].DSSInfo[0].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[9].DSSInfo[0].SubSlice[1].EuEnabledMask); + dst.SliceInfo[9].DSSInfo[1].Enabled.setValue(src.SliceInfo[9].DSSInfo[1].Enabled); + dst.SliceInfo[9].DSSInfo[1].SubSlice[0].Enabled.setValue(src.SliceInfo[9].DSSInfo[1].SubSlice[0].Enabled); + dst.SliceInfo[9].DSSInfo[1].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[9].DSSInfo[1].SubSlice[0].EuEnabledCount); + dst.SliceInfo[9].DSSInfo[1].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[9].DSSInfo[1].SubSlice[0].EuEnabledMask); + dst.SliceInfo[9].DSSInfo[1].SubSlice[1].Enabled.setValue(src.SliceInfo[9].DSSInfo[1].SubSlice[1].Enabled); + dst.SliceInfo[9].DSSInfo[1].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[9].DSSInfo[1].SubSlice[1].EuEnabledCount); + dst.SliceInfo[9].DSSInfo[1].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[9].DSSInfo[1].SubSlice[1].EuEnabledMask); + dst.SliceInfo[9].DSSInfo[2].Enabled.setValue(src.SliceInfo[9].DSSInfo[2].Enabled); + dst.SliceInfo[9].DSSInfo[2].SubSlice[0].Enabled.setValue(src.SliceInfo[9].DSSInfo[2].SubSlice[0].Enabled); + dst.SliceInfo[9].DSSInfo[2].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[9].DSSInfo[2].SubSlice[0].EuEnabledCount); + dst.SliceInfo[9].DSSInfo[2].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[9].DSSInfo[2].SubSlice[0].EuEnabledMask); + dst.SliceInfo[9].DSSInfo[2].SubSlice[1].Enabled.setValue(src.SliceInfo[9].DSSInfo[2].SubSlice[1].Enabled); + dst.SliceInfo[9].DSSInfo[2].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[9].DSSInfo[2].SubSlice[1].EuEnabledCount); + dst.SliceInfo[9].DSSInfo[2].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[9].DSSInfo[2].SubSlice[1].EuEnabledMask); + dst.SliceInfo[9].DSSInfo[3].Enabled.setValue(src.SliceInfo[9].DSSInfo[3].Enabled); + dst.SliceInfo[9].DSSInfo[3].SubSlice[0].Enabled.setValue(src.SliceInfo[9].DSSInfo[3].SubSlice[0].Enabled); + dst.SliceInfo[9].DSSInfo[3].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[9].DSSInfo[3].SubSlice[0].EuEnabledCount); + dst.SliceInfo[9].DSSInfo[3].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[9].DSSInfo[3].SubSlice[0].EuEnabledMask); + dst.SliceInfo[9].DSSInfo[3].SubSlice[1].Enabled.setValue(src.SliceInfo[9].DSSInfo[3].SubSlice[1].Enabled); + dst.SliceInfo[9].DSSInfo[3].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[9].DSSInfo[3].SubSlice[1].EuEnabledCount); + dst.SliceInfo[9].DSSInfo[3].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[9].DSSInfo[3].SubSlice[1].EuEnabledMask); + dst.SliceInfo[9].DSSInfo[4].Enabled.setValue(src.SliceInfo[9].DSSInfo[4].Enabled); + dst.SliceInfo[9].DSSInfo[4].SubSlice[0].Enabled.setValue(src.SliceInfo[9].DSSInfo[4].SubSlice[0].Enabled); + dst.SliceInfo[9].DSSInfo[4].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[9].DSSInfo[4].SubSlice[0].EuEnabledCount); + dst.SliceInfo[9].DSSInfo[4].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[9].DSSInfo[4].SubSlice[0].EuEnabledMask); + dst.SliceInfo[9].DSSInfo[4].SubSlice[1].Enabled.setValue(src.SliceInfo[9].DSSInfo[4].SubSlice[1].Enabled); + dst.SliceInfo[9].DSSInfo[4].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[9].DSSInfo[4].SubSlice[1].EuEnabledCount); + dst.SliceInfo[9].DSSInfo[4].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[9].DSSInfo[4].SubSlice[1].EuEnabledMask); + dst.SliceInfo[9].DSSInfo[5].Enabled.setValue(src.SliceInfo[9].DSSInfo[5].Enabled); + dst.SliceInfo[9].DSSInfo[5].SubSlice[0].Enabled.setValue(src.SliceInfo[9].DSSInfo[5].SubSlice[0].Enabled); + dst.SliceInfo[9].DSSInfo[5].SubSlice[0].EuEnabledCount.setValue(src.SliceInfo[9].DSSInfo[5].SubSlice[0].EuEnabledCount); + dst.SliceInfo[9].DSSInfo[5].SubSlice[0].EuEnabledMask.setValue(src.SliceInfo[9].DSSInfo[5].SubSlice[0].EuEnabledMask); + dst.SliceInfo[9].DSSInfo[5].SubSlice[1].Enabled.setValue(src.SliceInfo[9].DSSInfo[5].SubSlice[1].Enabled); + dst.SliceInfo[9].DSSInfo[5].SubSlice[1].EuEnabledCount.setValue(src.SliceInfo[9].DSSInfo[5].SubSlice[1].EuEnabledCount); + dst.SliceInfo[9].DSSInfo[5].SubSlice[1].EuEnabledMask.setValue(src.SliceInfo[9].DSSInfo[5].SubSlice[1].EuEnabledMask); + dst.SliceInfo[9].SubSliceEnabledCount.setValue(src.SliceInfo[9].SubSliceEnabledCount); + dst.SliceInfo[9].DualSubSliceEnabledCount.setValue(src.SliceInfo[9].DualSubSliceEnabledCount); + dst.IsDynamicallyPopulated.setValue(src.IsDynamicallyPopulated); + dst.SqidiInfo.NumberofSQIDI.setValue(src.SqidiInfo.NumberofSQIDI); + dst.SqidiInfo.NumberofDoorbellPerSQIDI.setValue(src.SqidiInfo.NumberofDoorbellPerSQIDI); + dst.ReservedCCSWays.setValue(src.ReservedCCSWays); + dst.CCSInfo.Instances.Bits.CCS0Enabled.setValue(src.CCSInfo.Instances.Bits.CCS0Enabled); + dst.CCSInfo.Instances.Bits.CCS1Enabled.setValue(src.CCSInfo.Instances.Bits.CCS1Enabled); + dst.CCSInfo.Instances.Bits.CCS2Enabled.setValue(src.CCSInfo.Instances.Bits.CCS2Enabled); + dst.CCSInfo.Instances.Bits.CCS3Enabled.setValue(src.CCSInfo.Instances.Bits.CCS3Enabled); + dst.CCSInfo.Instances.CCSEnableMask.setValue(src.CCSInfo.Instances.CCSEnableMask); + dst.CCSInfo.NumberOfCCSEnabled.setValue(src.CCSInfo.NumberOfCCSEnabled); + dst.CCSInfo.IsValid.setValue(src.CCSInfo.IsValid); + dst.MultiTileArchInfo.TileCount.setValue(src.MultiTileArchInfo.TileCount); + dst.MultiTileArchInfo.Tile0.setValue(src.MultiTileArchInfo.Tile0); + dst.MultiTileArchInfo.Tile1.setValue(src.MultiTileArchInfo.Tile1); + dst.MultiTileArchInfo.Tile2.setValue(src.MultiTileArchInfo.Tile2); + dst.MultiTileArchInfo.Tile3.setValue(src.MultiTileArchInfo.Tile3); + dst.MultiTileArchInfo.TileMask.setValue(src.MultiTileArchInfo.TileMask); + dst.MultiTileArchInfo.IsValid.setValue(src.MultiTileArchInfo.IsValid); + dst.VDBoxInfo.Instances.Bits.VDBox0Enabled.setValue(src.VDBoxInfo.Instances.Bits.VDBox0Enabled); + dst.VDBoxInfo.Instances.Bits.VDBox1Enabled.setValue(src.VDBoxInfo.Instances.Bits.VDBox1Enabled); + dst.VDBoxInfo.Instances.Bits.VDBox2Enabled.setValue(src.VDBoxInfo.Instances.Bits.VDBox2Enabled); + dst.VDBoxInfo.Instances.Bits.VDBox3Enabled.setValue(src.VDBoxInfo.Instances.Bits.VDBox3Enabled); + dst.VDBoxInfo.Instances.Bits.VDBox4Enabled.setValue(src.VDBoxInfo.Instances.Bits.VDBox4Enabled); + dst.VDBoxInfo.Instances.Bits.VDBox5Enabled.setValue(src.VDBoxInfo.Instances.Bits.VDBox5Enabled); + dst.VDBoxInfo.Instances.Bits.VDBox6Enabled.setValue(src.VDBoxInfo.Instances.Bits.VDBox6Enabled); + dst.VDBoxInfo.Instances.Bits.VDBox7Enabled.setValue(src.VDBoxInfo.Instances.Bits.VDBox7Enabled); + dst.VDBoxInfo.Instances.VDBoxEnableMask.setValue(src.VDBoxInfo.Instances.VDBoxEnableMask); + dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox0.setValue(src.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox0); + dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox1.setValue(src.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox1); + dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox2.setValue(src.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox2); + dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox3.setValue(src.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox3); + dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox4.setValue(src.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox4); + dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox5.setValue(src.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox5); + dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox6.setValue(src.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox6); + dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox7.setValue(src.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox7); + dst.VDBoxInfo.SFCSupport.Value.setValue(src.VDBoxInfo.SFCSupport.Value); + dst.VDBoxInfo.NumberOfVDBoxEnabled.setValue(src.VDBoxInfo.NumberOfVDBoxEnabled); + dst.VDBoxInfo.IsValid.setValue(src.VDBoxInfo.IsValid); + dst.VEBoxInfo.Instances.Bits.VEBox0Enabled.setValue(src.VEBoxInfo.Instances.Bits.VEBox0Enabled); + dst.VEBoxInfo.Instances.Bits.VEBox1Enabled.setValue(src.VEBoxInfo.Instances.Bits.VEBox1Enabled); + dst.VEBoxInfo.Instances.Bits.VEBox2Enabled.setValue(src.VEBoxInfo.Instances.Bits.VEBox2Enabled); + dst.VEBoxInfo.Instances.Bits.VEBox3Enabled.setValue(src.VEBoxInfo.Instances.Bits.VEBox3Enabled); + dst.VEBoxInfo.Instances.VEBoxEnableMask.setValue(src.VEBoxInfo.Instances.VEBoxEnableMask); + dst.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox0.setValue(src.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox0); + dst.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox1.setValue(src.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox1); + dst.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox2.setValue(src.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox2); + dst.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox3.setValue(src.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox3); + dst.VEBoxInfo.SFCSupport.Value.setValue(src.VEBoxInfo.SFCSupport.Value); + dst.VEBoxInfo.NumberOfVEBoxEnabled.setValue(src.VEBoxInfo.NumberOfVEBoxEnabled); + dst.VEBoxInfo.IsValid.setValue(src.VEBoxInfo.IsValid); + dst.NumThreadsPerEu.setValue(src.NumThreadsPerEu); + dst.CacheTypes.L3.setValue(src.CacheTypes.L3); + dst.CacheTypes.LLC.setValue(src.CacheTypes.LLC); + dst.CacheTypes.eDRAM.setValue(src.CacheTypes.eDRAM); + dst.CacheTypes.CacheTypeMask.setValue(src.CacheTypes.CacheTypeMask); + dst.MaxVECS.setValue(src.MaxVECS); +} +template <> +struct Marshaller { + template + static TOKSTR_GT_SYSTEM_INFO marshall(const GT_SYSTEM_INFOT &src) { + TOKSTR_GT_SYSTEM_INFO ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR__SKU_FEATURE_TABLE &dst, const _SKU_FEATURE_TABLET &src) { + dst = {}; + dst.FtrDesktop.setValue(src.FtrDesktop); + dst.FtrVERing.setValue(src.FtrVERing); + dst.FtrVcs2.setValue(src.FtrVcs2); + dst.FtrGtBigDie.setValue(src.FtrGtBigDie); + dst.FtrGtMediumDie.setValue(src.FtrGtMediumDie); + dst.FtrGtSmallDie.setValue(src.FtrGtSmallDie); + dst.FtrGT1.setValue(src.FtrGT1); + dst.FtrGT1_5.setValue(src.FtrGT1_5); + dst.FtrGT2.setValue(src.FtrGT2); + dst.FtrGT2_5.setValue(src.FtrGT2_5); + dst.FtrGT3.setValue(src.FtrGT3); + dst.FtrGT4.setValue(src.FtrGT4); + dst.FtrULT.setValue(src.FtrULT); + dst.FtrIVBM0M1Platform.setValue(src.FtrIVBM0M1Platform); + dst.FtrChannelSwizzlingXOREnabled.setValue(src.FtrChannelSwizzlingXOREnabled); + dst.FtrGTA.setValue(src.FtrGTA); + dst.FtrGTC.setValue(src.FtrGTC); + dst.FtrGTX.setValue(src.FtrGTX); + dst.Ftr5Slice.setValue(src.Ftr5Slice); + dst.FtrLCIA.setValue(src.FtrLCIA); + dst.FtrResourceStreamer.setValue(src.FtrResourceStreamer); + dst.FtrCCSRing.setValue(src.FtrCCSRing); + dst.FtrCCSNode.setValue(src.FtrCCSNode); + dst.FtrCCSMultiInstance.setValue(src.FtrCCSMultiInstance); + dst.FtrDisplayDisabled.setValue(src.FtrDisplayDisabled); + dst.FtrSGTPVSKUStrapPresent.setValue(src.FtrSGTPVSKUStrapPresent); + dst.FtrPooledEuEnabled.setValue(src.FtrPooledEuEnabled); + dst.FtrGpGpuMidBatchPreempt.setValue(src.FtrGpGpuMidBatchPreempt); + dst.FtrGpGpuThreadGroupLevelPreempt.setValue(src.FtrGpGpuThreadGroupLevelPreempt); + dst.FtrGpGpuMidThreadLevelPreempt.setValue(src.FtrGpGpuMidThreadLevelPreempt); + dst.Ftr3dMidBatchPreempt.setValue(src.Ftr3dMidBatchPreempt); + dst.Ftr3dObjectLevelPreempt.setValue(src.Ftr3dObjectLevelPreempt); + dst.FtrPerCtxtPreemptionGranularityControl.setValue(src.FtrPerCtxtPreemptionGranularityControl); + dst.FtrPPGTT.setValue(src.FtrPPGTT); + dst.FtrIA32eGfxPTEs.setValue(src.FtrIA32eGfxPTEs); + dst.FtrMemTypeMocsDeferPAT.setValue(src.FtrMemTypeMocsDeferPAT); + dst.FtrPml4Support.setValue(src.FtrPml4Support); + dst.FtrSVM.setValue(src.FtrSVM); + dst.FtrTileMappedResource.setValue(src.FtrTileMappedResource); + dst.FtrTranslationTable.setValue(src.FtrTranslationTable); + dst.FtrUserModeTranslationTable.setValue(src.FtrUserModeTranslationTable); + dst.FtrNullPages.setValue(src.FtrNullPages); + dst.FtrL3IACoherency.setValue(src.FtrL3IACoherency); + dst.FtrEDram.setValue(src.FtrEDram); + dst.FtrLLCBypass.setValue(src.FtrLLCBypass); + dst.FtrCrystalwell.setValue(src.FtrCrystalwell); + dst.FtrCentralCachePolicy.setValue(src.FtrCentralCachePolicy); + dst.FtrIoMmuPageFaulting.setValue(src.FtrIoMmuPageFaulting); + dst.FtrWddm2GpuMmu.setValue(src.FtrWddm2GpuMmu); + dst.FtrWddm2Svm.setValue(src.FtrWddm2Svm); + dst.FtrStandardMipTailFormat.setValue(src.FtrStandardMipTailFormat); + dst.FtrWddm2_1_64kbPages.setValue(src.FtrWddm2_1_64kbPages); + dst.FtrGttCacheInvalidation.setValue(src.FtrGttCacheInvalidation); + dst.FtrE2ECompression.setValue(src.FtrE2ECompression); + dst.FtrLinearCCS.setValue(src.FtrLinearCCS); + dst.FtrLocalMemory.setValue(src.FtrLocalMemory); + dst.FtrPpgtt64KBWalkOptimization.setValue(src.FtrPpgtt64KBWalkOptimization); + dst.FtrTileY.setValue(src.FtrTileY); + dst.FtrFlatPhysCCS.setValue(src.FtrFlatPhysCCS); + dst.FtrMultiTileArch.setValue(src.FtrMultiTileArch); + dst.FtrLocalMemoryAllows4KB.setValue(src.FtrLocalMemoryAllows4KB); + dst.FtrDisplayXTiling.setValue(src.FtrDisplayXTiling); + dst.FtrCameraCaptureCaching.setValue(src.FtrCameraCaptureCaching); + dst.FtrKmdDaf.setValue(src.FtrKmdDaf); + dst.FtrFrameBufferLLC.setValue(src.FtrFrameBufferLLC); + dst.FtrDriverFLR.setValue(src.FtrDriverFLR); + dst.FtrAstcLdr2D.setValue(src.FtrAstcLdr2D); + dst.FtrAstcHdr2D.setValue(src.FtrAstcHdr2D); + dst.FtrAstc3D.setValue(src.FtrAstc3D); + dst.FtrFbc.setValue(src.FtrFbc); + dst.FtrFbc2AddressTranslation.setValue(src.FtrFbc2AddressTranslation); + dst.FtrFbcBlitterTracking.setValue(src.FtrFbcBlitterTracking); + dst.FtrFbcCpuTracking.setValue(src.FtrFbcCpuTracking); + dst.FtrVEBOX.setValue(src.FtrVEBOX); + dst.FtrRendComp.setValue(src.FtrRendComp); + dst.FtrDisplayYTiling.setValue(src.FtrDisplayYTiling); + dst.FtrS3D.setValue(src.FtrS3D); + dst.FtrDisplayEngineS3d.setValue(src.FtrDisplayEngineS3d); + dst.FtrSingleVeboxSlice.setValue(src.FtrSingleVeboxSlice); + dst.FtrSimulationMode.setValue(src.FtrSimulationMode); + dst.FtrEnableGuC.setValue(src.FtrEnableGuC); + dst.FtrVgt.setValue(src.FtrVgt); + dst.FtrAssignedGpuTile.setValue(src.FtrAssignedGpuTile); +} +template <> +struct Marshaller { + template + static TOKSTR__SKU_FEATURE_TABLE marshall(const _SKU_FEATURE_TABLET &src) { + TOKSTR__SKU_FEATURE_TABLE ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR__WA_TABLE &dst, const _WA_TABLET &src) { + dst = {}; + dst.WaDoNotUseMIReportPerfCount.setValue(src.WaDoNotUseMIReportPerfCount); + dst.WaAlignIndexBuffer.setValue(src.WaAlignIndexBuffer); + dst.WaSendMIFLUSHBeforeVFE.setValue(src.WaSendMIFLUSHBeforeVFE); + dst.WaDisablePerCtxtPreemptionGranularityControl.setValue(src.WaDisablePerCtxtPreemptionGranularityControl); + dst.WaEnablePreemptionGranularityControlByUMD.setValue(src.WaEnablePreemptionGranularityControlByUMD); + dst.WaDisableLSQCROPERFforOCL.setValue(src.WaDisableLSQCROPERFforOCL); + dst.WaValign2For96bppFormats.setValue(src.WaValign2For96bppFormats); + dst.WaValign2ForR8G8B8UINTFormat.setValue(src.WaValign2ForR8G8B8UINTFormat); + dst.WaReportPerfCountUseGlobalContextID.setValue(src.WaReportPerfCountUseGlobalContextID); + dst.WaForcePcBbFullCfgRestore.setValue(src.WaForcePcBbFullCfgRestore); + dst.WaCSRUncachable.setValue(src.WaCSRUncachable); + dst.WaDisableFusedThreadScheduling.setValue(src.WaDisableFusedThreadScheduling); + dst.WaModifyVFEStateAfterGPGPUPreemption.setValue(src.WaModifyVFEStateAfterGPGPUPreemption); + dst.WaCursor16K.setValue(src.WaCursor16K); + dst.Wa8kAlignforAsyncFlip.setValue(src.Wa8kAlignforAsyncFlip); + dst.Wa29BitDisplayAddrLimit.setValue(src.Wa29BitDisplayAddrLimit); + dst.WaAlignContextImage.setValue(src.WaAlignContextImage); + dst.WaForceGlobalGTT.setValue(src.WaForceGlobalGTT); + dst.WaReportPerfCountForceGlobalGTT.setValue(src.WaReportPerfCountForceGlobalGTT); + dst.WaOaAddressTranslation.setValue(src.WaOaAddressTranslation); + dst.Wa2RowVerticalAlignment.setValue(src.Wa2RowVerticalAlignment); + dst.WaPpgttAliasGlobalGttSpace.setValue(src.WaPpgttAliasGlobalGttSpace); + dst.WaClearFenceRegistersAtDriverInit.setValue(src.WaClearFenceRegistersAtDriverInit); + dst.WaRestrictPitch128KB.setValue(src.WaRestrictPitch128KB); + dst.WaAvoidLLC.setValue(src.WaAvoidLLC); + dst.WaAvoidL3.setValue(src.WaAvoidL3); + dst.Wa16TileFencesOnly.setValue(src.Wa16TileFencesOnly); + dst.Wa16MBOABufferAlignment.setValue(src.Wa16MBOABufferAlignment); + dst.WaTranslationTableUnavailable.setValue(src.WaTranslationTableUnavailable); + dst.WaNoMinimizedTrivialSurfacePadding.setValue(src.WaNoMinimizedTrivialSurfacePadding); + dst.WaNoBufferSamplerPadding.setValue(src.WaNoBufferSamplerPadding); + dst.WaSurfaceStatePlanarYOffsetAlignBy2.setValue(src.WaSurfaceStatePlanarYOffsetAlignBy2); + dst.WaGttCachingOffByDefault.setValue(src.WaGttCachingOffByDefault); + dst.WaTouchAllSvmMemory.setValue(src.WaTouchAllSvmMemory); + dst.WaIOBAddressMustBeValidInHwContext.setValue(src.WaIOBAddressMustBeValidInHwContext); + dst.WaFlushTlbAfterCpuGgttWrites.setValue(src.WaFlushTlbAfterCpuGgttWrites); + dst.WaMsaa8xTileYDepthPitchAlignment.setValue(src.WaMsaa8xTileYDepthPitchAlignment); + dst.WaDisableNullPageAsDummy.setValue(src.WaDisableNullPageAsDummy); + dst.WaUseVAlign16OnTileXYBpp816.setValue(src.WaUseVAlign16OnTileXYBpp816); + dst.WaGttPat0.setValue(src.WaGttPat0); + dst.WaGttPat0WB.setValue(src.WaGttPat0WB); + dst.WaMemTypeIsMaxOfPatAndMocs.setValue(src.WaMemTypeIsMaxOfPatAndMocs); + dst.WaGttPat0GttWbOverOsIommuEllcOnly.setValue(src.WaGttPat0GttWbOverOsIommuEllcOnly); + dst.WaAddDummyPageForDisplayPrefetch.setValue(src.WaAddDummyPageForDisplayPrefetch); + dst.WaDefaultTile4.setValue(src.WaDefaultTile4); + dst.WaLLCCachingUnsupported.setValue(src.WaLLCCachingUnsupported); + dst.WaDoubleFastClearWidthAlignment.setValue(src.WaDoubleFastClearWidthAlignment); + dst.WaCompressedResourceRequiresConstVA21.setValue(src.WaCompressedResourceRequiresConstVA21); + dst.WaDisregardPlatformChecks.setValue(src.WaDisregardPlatformChecks); + dst.WaLosslessCompressionSurfaceStride.setValue(src.WaLosslessCompressionSurfaceStride); + dst.WaFbcLinearSurfaceStride.setValue(src.WaFbcLinearSurfaceStride); + dst.Wa4kAlignUVOffsetNV12LinearSurface.setValue(src.Wa4kAlignUVOffsetNV12LinearSurface); + dst.WaAstcCorruptionForOddCompressedBlockSizeX.setValue(src.WaAstcCorruptionForOddCompressedBlockSizeX); + dst.WaAuxTable16KGranular.setValue(src.WaAuxTable16KGranular); + dst.WaEncryptedEdramOnlyPartials.setValue(src.WaEncryptedEdramOnlyPartials); + dst.WaDisableEdramForDisplayRT.setValue(src.WaDisableEdramForDisplayRT); + dst.WaLimit128BMediaCompr.setValue(src.WaLimit128BMediaCompr); + dst.WaUntypedBufferCompression.setValue(src.WaUntypedBufferCompression); + dst.WaSamplerCacheFlushBetweenRedescribedSurfaceReads.setValue(src.WaSamplerCacheFlushBetweenRedescribedSurfaceReads); + dst.WaAlignYUVResourceToLCU.setValue(src.WaAlignYUVResourceToLCU); + dst.Wa32bppTileY2DColorNoHAlign4.setValue(src.Wa32bppTileY2DColorNoHAlign4); +} +template <> +struct Marshaller { + template + static TOKSTR__WA_TABLE marshall(const _WA_TABLET &src) { + TOKSTR__WA_TABLE ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_PLATFORM_STR &dst, const PLATFORM_STRT &src) { + dst = {}; + dst.eProductFamily.setValue(src.eProductFamily); + dst.ePCHProductFamily.setValue(src.ePCHProductFamily); + dst.eDisplayCoreFamily.setValue(src.eDisplayCoreFamily); + dst.eRenderCoreFamily.setValue(src.eRenderCoreFamily); + dst.ePlatformType.setValue(src.ePlatformType); + dst.usDeviceID.setValue(src.usDeviceID); + dst.usRevId.setValue(src.usRevId); + dst.usDeviceID_PCH.setValue(src.usDeviceID_PCH); + dst.usRevId_PCH.setValue(src.usRevId_PCH); + dst.eGTType.setValue(src.eGTType); +} +template <> +struct Marshaller { + template + static TOKSTR_PLATFORM_STR marshall(const PLATFORM_STRT &src) { + TOKSTR_PLATFORM_STR ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR___KMD_CAPS_INFO &dst, const __KMD_CAPS_INFOT &src) { + dst = {}; + dst.Gamma_Rgb256x3x16.setValue(src.Gamma_Rgb256x3x16); + dst.GDIAcceleration.setValue(src.GDIAcceleration); + dst.OsManagedHwContext.setValue(src.OsManagedHwContext); + dst.GraphicsPreemptionGranularity.setValue(src.GraphicsPreemptionGranularity); + dst.ComputePreemptionGranularity.setValue(src.ComputePreemptionGranularity); + dst.InstrumentationIsEnabled.setValue(src.InstrumentationIsEnabled); + dst.DriverStoreEnabled.setValue(src.DriverStoreEnabled); +} +template <> +struct Marshaller { + template + static TOKSTR___KMD_CAPS_INFO marshall(const __KMD_CAPS_INFOT &src) { + TOKSTR___KMD_CAPS_INFO ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR___KMD_OVERLAY_OVERRIDE &dst, const __KMD_OVERLAY_OVERRIDET &src) { + dst = {}; + dst.OverrideOverlayCaps.setValue(src.OverrideOverlayCaps); + dst.RGBOverlay.setValue(src.RGBOverlay); + dst.YUY2Overlay.setValue(src.YUY2Overlay); +} +template <> +struct Marshaller { + template + static TOKSTR___KMD_OVERLAY_OVERRIDE marshall(const __KMD_OVERLAY_OVERRIDET &src) { + TOKSTR___KMD_OVERLAY_OVERRIDE ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR___KMD_OVERLAY_CAPS_INFO &dst, const __KMD_OVERLAY_CAPS_INFOT &src) { + dst = {}; + dst.Caps.FullRangeRGB.setValue(src.Caps.FullRangeRGB); + dst.Caps.LimitedRangeRGB.setValue(src.Caps.LimitedRangeRGB); + dst.Caps.YCbCr_BT601.setValue(src.Caps.YCbCr_BT601); + dst.Caps.YCbCr_BT709.setValue(src.Caps.YCbCr_BT709); + dst.Caps.YCbCr_BT601_xvYCC.setValue(src.Caps.YCbCr_BT601_xvYCC); + dst.Caps.YCbCr_BT709_xvYCC.setValue(src.Caps.YCbCr_BT709_xvYCC); + dst.Caps.StretchX.setValue(src.Caps.StretchX); + dst.Caps.StretchY.setValue(src.Caps.StretchY); + dst.CapsValue.setValue(src.CapsValue); + dst.OVOverride.OverrideOverlayCaps.setValue(src.OVOverride.OverrideOverlayCaps); + dst.OVOverride.RGBOverlay.setValue(src.OVOverride.RGBOverlay); + dst.OVOverride.YUY2Overlay.setValue(src.OVOverride.YUY2Overlay); + dst.MaxOverlayDisplayWidth.setValue(src.MaxOverlayDisplayWidth); + dst.MaxOverlayDisplayHeight.setValue(src.MaxOverlayDisplayHeight); + dst.HWScalerExists.setValue(src.HWScalerExists); + dst.MaxHWScalerStride.setValue(src.MaxHWScalerStride); +} +template <> +struct Marshaller { + template + static TOKSTR___KMD_OVERLAY_CAPS_INFO marshall(const __KMD_OVERLAY_CAPS_INFOT &src) { + TOKSTR___KMD_OVERLAY_CAPS_INFO ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_FRAME_RATE &dst, const FRAME_RATET &src) { + dst = {}; + dst.uiNumerator.setValue(src.uiNumerator); + dst.uiDenominator.setValue(src.uiDenominator); +} +template <> +struct Marshaller { + template + static TOKSTR_FRAME_RATE marshall(const FRAME_RATET &src) { + TOKSTR_FRAME_RATE ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR__KM_DEFERRED_WAIT_INFO &dst, const _KM_DEFERRED_WAIT_INFOT &src) { + dst = {}; + dst.FeatureSupported.setValue(src.FeatureSupported); + dst.ActiveDisplay.setValue(src.ActiveDisplay); +} +template <> +struct Marshaller { + template + static TOKSTR__KM_DEFERRED_WAIT_INFO marshall(const _KM_DEFERRED_WAIT_INFOT &src) { + TOKSTR__KM_DEFERRED_WAIT_INFO ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR___GMM_GFX_PARTITIONING &dst, const __GMM_GFX_PARTITIONINGT &src) { + dst = {}; + dst.Standard.Base.setValue(src.Standard.Base); + dst.Standard.Limit.setValue(src.Standard.Limit); + dst.Standard64KB.Base.setValue(src.Standard64KB.Base); + dst.Standard64KB.Limit.setValue(src.Standard64KB.Limit); + dst.SVM.Base.setValue(src.SVM.Base); + dst.SVM.Limit.setValue(src.SVM.Limit); + dst.Heap32[0].Base.setValue(src.Heap32[0].Base); + dst.Heap32[0].Limit.setValue(src.Heap32[0].Limit); + dst.Heap32[1].Base.setValue(src.Heap32[1].Base); + dst.Heap32[1].Limit.setValue(src.Heap32[1].Limit); + dst.Heap32[2].Base.setValue(src.Heap32[2].Base); + dst.Heap32[2].Limit.setValue(src.Heap32[2].Limit); + dst.Heap32[3].Base.setValue(src.Heap32[3].Base); + dst.Heap32[3].Limit.setValue(src.Heap32[3].Limit); +} +template <> +struct Marshaller { + template + static TOKSTR___GMM_GFX_PARTITIONING marshall(const __GMM_GFX_PARTITIONINGT &src) { + TOKSTR___GMM_GFX_PARTITIONING ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR__ADAPTER_BDF_ &dst, const _ADAPTER_BDF_T &src) { + dst = {}; + dst.Bus.setValue(src.Bus); + dst.Device.setValue(src.Device); + dst.Function.setValue(src.Function); + dst.Data.setValue(src.Data); +} +template <> +struct Marshaller { + template + static TOKSTR__ADAPTER_BDF_ marshall(const _ADAPTER_BDF_T &src) { + TOKSTR__ADAPTER_BDF_ ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR__ADAPTER_INFO &dst, const _ADAPTER_INFOT &src) { + dst = {}; + dst.KmdVersionInfo.setValue(src.KmdVersionInfo); + WCH_SAFE_COPY(dst.DeviceRegistryPath.getValue(), dst.DeviceRegistryPath.getValueSizeInBytes(), src.DeviceRegistryPath, sizeof(src.DeviceRegistryPath)); + dst.GfxPlatform.eProductFamily.setValue(src.GfxPlatform.eProductFamily); + dst.GfxPlatform.ePCHProductFamily.setValue(src.GfxPlatform.ePCHProductFamily); + dst.GfxPlatform.eDisplayCoreFamily.setValue(src.GfxPlatform.eDisplayCoreFamily); + dst.GfxPlatform.eRenderCoreFamily.setValue(src.GfxPlatform.eRenderCoreFamily); + dst.GfxPlatform.ePlatformType.setValue(src.GfxPlatform.ePlatformType); + dst.GfxPlatform.usDeviceID.setValue(src.GfxPlatform.usDeviceID); + dst.GfxPlatform.usRevId.setValue(src.GfxPlatform.usRevId); + dst.GfxPlatform.usDeviceID_PCH.setValue(src.GfxPlatform.usDeviceID_PCH); + dst.GfxPlatform.usRevId_PCH.setValue(src.GfxPlatform.usRevId_PCH); + dst.GfxPlatform.eGTType.setValue(src.GfxPlatform.eGTType); + dst.SkuTable.FtrDesktop.setValue(src.SkuTable.FtrDesktop); + dst.SkuTable.FtrVERing.setValue(src.SkuTable.FtrVERing); + dst.SkuTable.FtrVcs2.setValue(src.SkuTable.FtrVcs2); + dst.SkuTable.FtrGtBigDie.setValue(src.SkuTable.FtrGtBigDie); + dst.SkuTable.FtrGtMediumDie.setValue(src.SkuTable.FtrGtMediumDie); + dst.SkuTable.FtrGtSmallDie.setValue(src.SkuTable.FtrGtSmallDie); + dst.SkuTable.FtrGT1.setValue(src.SkuTable.FtrGT1); + dst.SkuTable.FtrGT1_5.setValue(src.SkuTable.FtrGT1_5); + dst.SkuTable.FtrGT2.setValue(src.SkuTable.FtrGT2); + dst.SkuTable.FtrGT2_5.setValue(src.SkuTable.FtrGT2_5); + dst.SkuTable.FtrGT3.setValue(src.SkuTable.FtrGT3); + dst.SkuTable.FtrGT4.setValue(src.SkuTable.FtrGT4); + dst.SkuTable.FtrULT.setValue(src.SkuTable.FtrULT); + dst.SkuTable.FtrIVBM0M1Platform.setValue(src.SkuTable.FtrIVBM0M1Platform); + dst.SkuTable.FtrChannelSwizzlingXOREnabled.setValue(src.SkuTable.FtrChannelSwizzlingXOREnabled); + dst.SkuTable.FtrGTA.setValue(src.SkuTable.FtrGTA); + dst.SkuTable.FtrGTC.setValue(src.SkuTable.FtrGTC); + dst.SkuTable.FtrGTX.setValue(src.SkuTable.FtrGTX); + dst.SkuTable.Ftr5Slice.setValue(src.SkuTable.Ftr5Slice); + dst.SkuTable.FtrLCIA.setValue(src.SkuTable.FtrLCIA); + dst.SkuTable.FtrResourceStreamer.setValue(src.SkuTable.FtrResourceStreamer); + dst.SkuTable.FtrCCSRing.setValue(src.SkuTable.FtrCCSRing); + dst.SkuTable.FtrCCSNode.setValue(src.SkuTable.FtrCCSNode); + dst.SkuTable.FtrCCSMultiInstance.setValue(src.SkuTable.FtrCCSMultiInstance); + dst.SkuTable.FtrDisplayDisabled.setValue(src.SkuTable.FtrDisplayDisabled); + dst.SkuTable.FtrSGTPVSKUStrapPresent.setValue(src.SkuTable.FtrSGTPVSKUStrapPresent); + dst.SkuTable.FtrPooledEuEnabled.setValue(src.SkuTable.FtrPooledEuEnabled); + dst.SkuTable.FtrGpGpuMidBatchPreempt.setValue(src.SkuTable.FtrGpGpuMidBatchPreempt); + dst.SkuTable.FtrGpGpuThreadGroupLevelPreempt.setValue(src.SkuTable.FtrGpGpuThreadGroupLevelPreempt); + dst.SkuTable.FtrGpGpuMidThreadLevelPreempt.setValue(src.SkuTable.FtrGpGpuMidThreadLevelPreempt); + dst.SkuTable.Ftr3dMidBatchPreempt.setValue(src.SkuTable.Ftr3dMidBatchPreempt); + dst.SkuTable.Ftr3dObjectLevelPreempt.setValue(src.SkuTable.Ftr3dObjectLevelPreempt); + dst.SkuTable.FtrPerCtxtPreemptionGranularityControl.setValue(src.SkuTable.FtrPerCtxtPreemptionGranularityControl); + dst.SkuTable.FtrPPGTT.setValue(src.SkuTable.FtrPPGTT); + dst.SkuTable.FtrIA32eGfxPTEs.setValue(src.SkuTable.FtrIA32eGfxPTEs); + dst.SkuTable.FtrMemTypeMocsDeferPAT.setValue(src.SkuTable.FtrMemTypeMocsDeferPAT); + dst.SkuTable.FtrPml4Support.setValue(src.SkuTable.FtrPml4Support); + dst.SkuTable.FtrSVM.setValue(src.SkuTable.FtrSVM); + dst.SkuTable.FtrTileMappedResource.setValue(src.SkuTable.FtrTileMappedResource); + dst.SkuTable.FtrTranslationTable.setValue(src.SkuTable.FtrTranslationTable); + dst.SkuTable.FtrUserModeTranslationTable.setValue(src.SkuTable.FtrUserModeTranslationTable); + dst.SkuTable.FtrNullPages.setValue(src.SkuTable.FtrNullPages); + dst.SkuTable.FtrL3IACoherency.setValue(src.SkuTable.FtrL3IACoherency); + dst.SkuTable.FtrEDram.setValue(src.SkuTable.FtrEDram); + dst.SkuTable.FtrLLCBypass.setValue(src.SkuTable.FtrLLCBypass); + dst.SkuTable.FtrCrystalwell.setValue(src.SkuTable.FtrCrystalwell); + dst.SkuTable.FtrCentralCachePolicy.setValue(src.SkuTable.FtrCentralCachePolicy); + dst.SkuTable.FtrIoMmuPageFaulting.setValue(src.SkuTable.FtrIoMmuPageFaulting); + dst.SkuTable.FtrWddm2GpuMmu.setValue(src.SkuTable.FtrWddm2GpuMmu); + dst.SkuTable.FtrWddm2Svm.setValue(src.SkuTable.FtrWddm2Svm); + dst.SkuTable.FtrStandardMipTailFormat.setValue(src.SkuTable.FtrStandardMipTailFormat); + dst.SkuTable.FtrWddm2_1_64kbPages.setValue(src.SkuTable.FtrWddm2_1_64kbPages); + dst.SkuTable.FtrGttCacheInvalidation.setValue(src.SkuTable.FtrGttCacheInvalidation); + dst.SkuTable.FtrE2ECompression.setValue(src.SkuTable.FtrE2ECompression); + dst.SkuTable.FtrLinearCCS.setValue(src.SkuTable.FtrLinearCCS); + dst.SkuTable.FtrLocalMemory.setValue(src.SkuTable.FtrLocalMemory); + dst.SkuTable.FtrPpgtt64KBWalkOptimization.setValue(src.SkuTable.FtrPpgtt64KBWalkOptimization); + dst.SkuTable.FtrTileY.setValue(src.SkuTable.FtrTileY); + dst.SkuTable.FtrFlatPhysCCS.setValue(src.SkuTable.FtrFlatPhysCCS); + dst.SkuTable.FtrMultiTileArch.setValue(src.SkuTable.FtrMultiTileArch); + dst.SkuTable.FtrLocalMemoryAllows4KB.setValue(src.SkuTable.FtrLocalMemoryAllows4KB); + dst.SkuTable.FtrDisplayXTiling.setValue(src.SkuTable.FtrDisplayXTiling); + dst.SkuTable.FtrCameraCaptureCaching.setValue(src.SkuTable.FtrCameraCaptureCaching); + dst.SkuTable.FtrKmdDaf.setValue(src.SkuTable.FtrKmdDaf); + dst.SkuTable.FtrFrameBufferLLC.setValue(src.SkuTable.FtrFrameBufferLLC); + dst.SkuTable.FtrDriverFLR.setValue(src.SkuTable.FtrDriverFLR); + dst.SkuTable.FtrAstcLdr2D.setValue(src.SkuTable.FtrAstcLdr2D); + dst.SkuTable.FtrAstcHdr2D.setValue(src.SkuTable.FtrAstcHdr2D); + dst.SkuTable.FtrAstc3D.setValue(src.SkuTable.FtrAstc3D); + dst.SkuTable.FtrFbc.setValue(src.SkuTable.FtrFbc); + dst.SkuTable.FtrFbc2AddressTranslation.setValue(src.SkuTable.FtrFbc2AddressTranslation); + dst.SkuTable.FtrFbcBlitterTracking.setValue(src.SkuTable.FtrFbcBlitterTracking); + dst.SkuTable.FtrFbcCpuTracking.setValue(src.SkuTable.FtrFbcCpuTracking); + dst.SkuTable.FtrVEBOX.setValue(src.SkuTable.FtrVEBOX); + dst.SkuTable.FtrRendComp.setValue(src.SkuTable.FtrRendComp); + dst.SkuTable.FtrDisplayYTiling.setValue(src.SkuTable.FtrDisplayYTiling); + dst.SkuTable.FtrS3D.setValue(src.SkuTable.FtrS3D); + dst.SkuTable.FtrDisplayEngineS3d.setValue(src.SkuTable.FtrDisplayEngineS3d); + dst.SkuTable.FtrSingleVeboxSlice.setValue(src.SkuTable.FtrSingleVeboxSlice); + dst.SkuTable.FtrSimulationMode.setValue(src.SkuTable.FtrSimulationMode); + dst.SkuTable.FtrEnableGuC.setValue(src.SkuTable.FtrEnableGuC); + dst.SkuTable.FtrVgt.setValue(src.SkuTable.FtrVgt); + dst.SkuTable.FtrAssignedGpuTile.setValue(src.SkuTable.FtrAssignedGpuTile); + dst.WaTable.WaDoNotUseMIReportPerfCount.setValue(src.WaTable.WaDoNotUseMIReportPerfCount); + dst.WaTable.WaAlignIndexBuffer.setValue(src.WaTable.WaAlignIndexBuffer); + dst.WaTable.WaSendMIFLUSHBeforeVFE.setValue(src.WaTable.WaSendMIFLUSHBeforeVFE); + dst.WaTable.WaDisablePerCtxtPreemptionGranularityControl.setValue(src.WaTable.WaDisablePerCtxtPreemptionGranularityControl); + dst.WaTable.WaEnablePreemptionGranularityControlByUMD.setValue(src.WaTable.WaEnablePreemptionGranularityControlByUMD); + dst.WaTable.WaDisableLSQCROPERFforOCL.setValue(src.WaTable.WaDisableLSQCROPERFforOCL); + dst.WaTable.WaValign2For96bppFormats.setValue(src.WaTable.WaValign2For96bppFormats); + dst.WaTable.WaValign2ForR8G8B8UINTFormat.setValue(src.WaTable.WaValign2ForR8G8B8UINTFormat); + dst.WaTable.WaReportPerfCountUseGlobalContextID.setValue(src.WaTable.WaReportPerfCountUseGlobalContextID); + dst.WaTable.WaForcePcBbFullCfgRestore.setValue(src.WaTable.WaForcePcBbFullCfgRestore); + dst.WaTable.WaCSRUncachable.setValue(src.WaTable.WaCSRUncachable); + dst.WaTable.WaDisableFusedThreadScheduling.setValue(src.WaTable.WaDisableFusedThreadScheduling); + dst.WaTable.WaModifyVFEStateAfterGPGPUPreemption.setValue(src.WaTable.WaModifyVFEStateAfterGPGPUPreemption); + dst.WaTable.WaCursor16K.setValue(src.WaTable.WaCursor16K); + dst.WaTable.Wa8kAlignforAsyncFlip.setValue(src.WaTable.Wa8kAlignforAsyncFlip); + dst.WaTable.Wa29BitDisplayAddrLimit.setValue(src.WaTable.Wa29BitDisplayAddrLimit); + dst.WaTable.WaAlignContextImage.setValue(src.WaTable.WaAlignContextImage); + dst.WaTable.WaForceGlobalGTT.setValue(src.WaTable.WaForceGlobalGTT); + dst.WaTable.WaReportPerfCountForceGlobalGTT.setValue(src.WaTable.WaReportPerfCountForceGlobalGTT); + dst.WaTable.WaOaAddressTranslation.setValue(src.WaTable.WaOaAddressTranslation); + dst.WaTable.Wa2RowVerticalAlignment.setValue(src.WaTable.Wa2RowVerticalAlignment); + dst.WaTable.WaPpgttAliasGlobalGttSpace.setValue(src.WaTable.WaPpgttAliasGlobalGttSpace); + dst.WaTable.WaClearFenceRegistersAtDriverInit.setValue(src.WaTable.WaClearFenceRegistersAtDriverInit); + dst.WaTable.WaRestrictPitch128KB.setValue(src.WaTable.WaRestrictPitch128KB); + dst.WaTable.WaAvoidLLC.setValue(src.WaTable.WaAvoidLLC); + dst.WaTable.WaAvoidL3.setValue(src.WaTable.WaAvoidL3); + dst.WaTable.Wa16TileFencesOnly.setValue(src.WaTable.Wa16TileFencesOnly); + dst.WaTable.Wa16MBOABufferAlignment.setValue(src.WaTable.Wa16MBOABufferAlignment); + dst.WaTable.WaTranslationTableUnavailable.setValue(src.WaTable.WaTranslationTableUnavailable); + dst.WaTable.WaNoMinimizedTrivialSurfacePadding.setValue(src.WaTable.WaNoMinimizedTrivialSurfacePadding); + dst.WaTable.WaNoBufferSamplerPadding.setValue(src.WaTable.WaNoBufferSamplerPadding); + dst.WaTable.WaSurfaceStatePlanarYOffsetAlignBy2.setValue(src.WaTable.WaSurfaceStatePlanarYOffsetAlignBy2); + dst.WaTable.WaGttCachingOffByDefault.setValue(src.WaTable.WaGttCachingOffByDefault); + dst.WaTable.WaTouchAllSvmMemory.setValue(src.WaTable.WaTouchAllSvmMemory); + dst.WaTable.WaIOBAddressMustBeValidInHwContext.setValue(src.WaTable.WaIOBAddressMustBeValidInHwContext); + dst.WaTable.WaFlushTlbAfterCpuGgttWrites.setValue(src.WaTable.WaFlushTlbAfterCpuGgttWrites); + dst.WaTable.WaMsaa8xTileYDepthPitchAlignment.setValue(src.WaTable.WaMsaa8xTileYDepthPitchAlignment); + dst.WaTable.WaDisableNullPageAsDummy.setValue(src.WaTable.WaDisableNullPageAsDummy); + dst.WaTable.WaUseVAlign16OnTileXYBpp816.setValue(src.WaTable.WaUseVAlign16OnTileXYBpp816); + dst.WaTable.WaGttPat0.setValue(src.WaTable.WaGttPat0); + dst.WaTable.WaGttPat0WB.setValue(src.WaTable.WaGttPat0WB); + dst.WaTable.WaMemTypeIsMaxOfPatAndMocs.setValue(src.WaTable.WaMemTypeIsMaxOfPatAndMocs); + dst.WaTable.WaGttPat0GttWbOverOsIommuEllcOnly.setValue(src.WaTable.WaGttPat0GttWbOverOsIommuEllcOnly); + dst.WaTable.WaAddDummyPageForDisplayPrefetch.setValue(src.WaTable.WaAddDummyPageForDisplayPrefetch); + dst.WaTable.WaDefaultTile4.setValue(src.WaTable.WaDefaultTile4); + dst.WaTable.WaLLCCachingUnsupported.setValue(src.WaTable.WaLLCCachingUnsupported); + dst.WaTable.WaDoubleFastClearWidthAlignment.setValue(src.WaTable.WaDoubleFastClearWidthAlignment); + dst.WaTable.WaCompressedResourceRequiresConstVA21.setValue(src.WaTable.WaCompressedResourceRequiresConstVA21); + dst.WaTable.WaDisregardPlatformChecks.setValue(src.WaTable.WaDisregardPlatformChecks); + dst.WaTable.WaLosslessCompressionSurfaceStride.setValue(src.WaTable.WaLosslessCompressionSurfaceStride); + dst.WaTable.WaFbcLinearSurfaceStride.setValue(src.WaTable.WaFbcLinearSurfaceStride); + dst.WaTable.Wa4kAlignUVOffsetNV12LinearSurface.setValue(src.WaTable.Wa4kAlignUVOffsetNV12LinearSurface); + dst.WaTable.WaAstcCorruptionForOddCompressedBlockSizeX.setValue(src.WaTable.WaAstcCorruptionForOddCompressedBlockSizeX); + dst.WaTable.WaAuxTable16KGranular.setValue(src.WaTable.WaAuxTable16KGranular); + dst.WaTable.WaEncryptedEdramOnlyPartials.setValue(src.WaTable.WaEncryptedEdramOnlyPartials); + dst.WaTable.WaDisableEdramForDisplayRT.setValue(src.WaTable.WaDisableEdramForDisplayRT); + dst.WaTable.WaLimit128BMediaCompr.setValue(src.WaTable.WaLimit128BMediaCompr); + dst.WaTable.WaUntypedBufferCompression.setValue(src.WaTable.WaUntypedBufferCompression); + dst.WaTable.WaSamplerCacheFlushBetweenRedescribedSurfaceReads.setValue(src.WaTable.WaSamplerCacheFlushBetweenRedescribedSurfaceReads); + dst.WaTable.WaAlignYUVResourceToLCU.setValue(src.WaTable.WaAlignYUVResourceToLCU); + dst.WaTable.Wa32bppTileY2DColorNoHAlign4.setValue(src.WaTable.Wa32bppTileY2DColorNoHAlign4); + dst.GfxTimeStampFreq.setValue(src.GfxTimeStampFreq); + dst.GfxCoreFrequency.setValue(src.GfxCoreFrequency); + dst.FSBFrequency.setValue(src.FSBFrequency); + dst.MinRenderFreq.setValue(src.MinRenderFreq); + dst.MaxRenderFreq.setValue(src.MaxRenderFreq); + dst.PackageTdp.setValue(src.PackageTdp); + dst.MaxFillRate.setValue(src.MaxFillRate); + dst.NumberOfEUs.setValue(src.NumberOfEUs); + dst.dwReleaseTarget.setValue(src.dwReleaseTarget); + dst.SizeOfDmaBuffer.setValue(src.SizeOfDmaBuffer); + dst.PatchLocationListSize.setValue(src.PatchLocationListSize); + dst.AllocationListSize.setValue(src.AllocationListSize); + dst.SmallPatchLocationListSize.setValue(src.SmallPatchLocationListSize); + dst.DefaultCmdBufferSize.setValue(src.DefaultCmdBufferSize); + dst.GfxMemorySize.setValue(src.GfxMemorySize); + dst.SystemMemorySize.setValue(src.SystemMemorySize); + dst.CacheLineSize.setValue(src.CacheLineSize); + dst.ProcessorFamily.setValue(src.ProcessorFamily); + dst.IsHTSupported.setValue(src.IsHTSupported); + dst.IsMutiCoreCpu.setValue(src.IsMutiCoreCpu); + dst.IsVTDSupported.setValue(src.IsVTDSupported); + dst.RegistryPathLength.setValue(src.RegistryPathLength); + dst.DedicatedVideoMemory.setValue(src.DedicatedVideoMemory); + dst.SystemSharedMemory.setValue(src.SystemSharedMemory); + dst.SystemVideoMemory.setValue(src.SystemVideoMemory); + dst.OutputFrameRate.uiNumerator.setValue(src.OutputFrameRate.uiNumerator); + dst.OutputFrameRate.uiDenominator.setValue(src.OutputFrameRate.uiDenominator); + dst.InputFrameRate.uiNumerator.setValue(src.InputFrameRate.uiNumerator); + dst.InputFrameRate.uiDenominator.setValue(src.InputFrameRate.uiDenominator); + dst.Caps.Gamma_Rgb256x3x16.setValue(src.Caps.Gamma_Rgb256x3x16); + dst.Caps.GDIAcceleration.setValue(src.Caps.GDIAcceleration); + dst.Caps.OsManagedHwContext.setValue(src.Caps.OsManagedHwContext); + dst.Caps.GraphicsPreemptionGranularity.setValue(src.Caps.GraphicsPreemptionGranularity); + dst.Caps.ComputePreemptionGranularity.setValue(src.Caps.ComputePreemptionGranularity); + dst.Caps.InstrumentationIsEnabled.setValue(src.Caps.InstrumentationIsEnabled); + dst.Caps.DriverStoreEnabled.setValue(src.Caps.DriverStoreEnabled); + dst.OverlayCaps.Caps.FullRangeRGB.setValue(src.OverlayCaps.Caps.FullRangeRGB); + dst.OverlayCaps.Caps.LimitedRangeRGB.setValue(src.OverlayCaps.Caps.LimitedRangeRGB); + dst.OverlayCaps.Caps.YCbCr_BT601.setValue(src.OverlayCaps.Caps.YCbCr_BT601); + dst.OverlayCaps.Caps.YCbCr_BT709.setValue(src.OverlayCaps.Caps.YCbCr_BT709); + dst.OverlayCaps.Caps.YCbCr_BT601_xvYCC.setValue(src.OverlayCaps.Caps.YCbCr_BT601_xvYCC); + dst.OverlayCaps.Caps.YCbCr_BT709_xvYCC.setValue(src.OverlayCaps.Caps.YCbCr_BT709_xvYCC); + dst.OverlayCaps.Caps.StretchX.setValue(src.OverlayCaps.Caps.StretchX); + dst.OverlayCaps.Caps.StretchY.setValue(src.OverlayCaps.Caps.StretchY); + dst.OverlayCaps.CapsValue.setValue(src.OverlayCaps.CapsValue); + dst.OverlayCaps.OVOverride.OverrideOverlayCaps.setValue(src.OverlayCaps.OVOverride.OverrideOverlayCaps); + dst.OverlayCaps.OVOverride.RGBOverlay.setValue(src.OverlayCaps.OVOverride.RGBOverlay); + dst.OverlayCaps.OVOverride.YUY2Overlay.setValue(src.OverlayCaps.OVOverride.YUY2Overlay); + dst.OverlayCaps.MaxOverlayDisplayWidth.setValue(src.OverlayCaps.MaxOverlayDisplayWidth); + dst.OverlayCaps.MaxOverlayDisplayHeight.setValue(src.OverlayCaps.MaxOverlayDisplayHeight); + dst.OverlayCaps.HWScalerExists.setValue(src.OverlayCaps.HWScalerExists); + dst.OverlayCaps.MaxHWScalerStride.setValue(src.OverlayCaps.MaxHWScalerStride); + dst.SystemInfo.EUCount.setValue(src.SystemInfo.EUCount); + dst.SystemInfo.ThreadCount.setValue(src.SystemInfo.ThreadCount); + dst.SystemInfo.SliceCount.setValue(src.SystemInfo.SliceCount); + dst.SystemInfo.SubSliceCount.setValue(src.SystemInfo.SubSliceCount); + dst.SystemInfo.DualSubSliceCount.setValue(src.SystemInfo.DualSubSliceCount); + dst.SystemInfo.L3CacheSizeInKb.setValue(src.SystemInfo.L3CacheSizeInKb); + dst.SystemInfo.LLCCacheSizeInKb.setValue(src.SystemInfo.LLCCacheSizeInKb); + dst.SystemInfo.EdramSizeInKb.setValue(src.SystemInfo.EdramSizeInKb); + dst.SystemInfo.L3BankCount.setValue(src.SystemInfo.L3BankCount); + dst.SystemInfo.MaxFillRate.setValue(src.SystemInfo.MaxFillRate); + dst.SystemInfo.EuCountPerPoolMax.setValue(src.SystemInfo.EuCountPerPoolMax); + dst.SystemInfo.EuCountPerPoolMin.setValue(src.SystemInfo.EuCountPerPoolMin); + dst.SystemInfo.TotalVsThreads.setValue(src.SystemInfo.TotalVsThreads); + dst.SystemInfo.TotalHsThreads.setValue(src.SystemInfo.TotalHsThreads); + dst.SystemInfo.TotalDsThreads.setValue(src.SystemInfo.TotalDsThreads); + dst.SystemInfo.TotalGsThreads.setValue(src.SystemInfo.TotalGsThreads); + dst.SystemInfo.TotalPsThreadsWindowerRange.setValue(src.SystemInfo.TotalPsThreadsWindowerRange); + dst.SystemInfo.TotalVsThreads_Pocs.setValue(src.SystemInfo.TotalVsThreads_Pocs); + dst.SystemInfo.CsrSizeInMb.setValue(src.SystemInfo.CsrSizeInMb); + dst.SystemInfo.MaxEuPerSubSlice.setValue(src.SystemInfo.MaxEuPerSubSlice); + dst.SystemInfo.MaxSlicesSupported.setValue(src.SystemInfo.MaxSlicesSupported); + dst.SystemInfo.MaxSubSlicesSupported.setValue(src.SystemInfo.MaxSubSlicesSupported); + dst.SystemInfo.MaxDualSubSlicesSupported.setValue(src.SystemInfo.MaxDualSubSlicesSupported); + dst.SystemInfo.IsL3HashModeEnabled.setValue(src.SystemInfo.IsL3HashModeEnabled); + dst.SystemInfo.SliceInfo[0].Enabled.setValue(src.SystemInfo.SliceInfo[0].Enabled); + dst.SystemInfo.SliceInfo[0].SubSliceInfo[0].Enabled.setValue(src.SystemInfo.SliceInfo[0].SubSliceInfo[0].Enabled); + dst.SystemInfo.SliceInfo[0].SubSliceInfo[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[0].SubSliceInfo[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[0].SubSliceInfo[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[0].SubSliceInfo[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[0].SubSliceInfo[1].Enabled.setValue(src.SystemInfo.SliceInfo[0].SubSliceInfo[1].Enabled); + dst.SystemInfo.SliceInfo[0].SubSliceInfo[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[0].SubSliceInfo[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[0].SubSliceInfo[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[0].SubSliceInfo[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[0].SubSliceInfo[2].Enabled.setValue(src.SystemInfo.SliceInfo[0].SubSliceInfo[2].Enabled); + dst.SystemInfo.SliceInfo[0].SubSliceInfo[2].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[0].SubSliceInfo[2].EuEnabledCount); + dst.SystemInfo.SliceInfo[0].SubSliceInfo[2].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[0].SubSliceInfo[2].EuEnabledMask); + dst.SystemInfo.SliceInfo[0].SubSliceInfo[3].Enabled.setValue(src.SystemInfo.SliceInfo[0].SubSliceInfo[3].Enabled); + dst.SystemInfo.SliceInfo[0].SubSliceInfo[3].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[0].SubSliceInfo[3].EuEnabledCount); + dst.SystemInfo.SliceInfo[0].SubSliceInfo[3].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[0].SubSliceInfo[3].EuEnabledMask); + dst.SystemInfo.SliceInfo[0].SubSliceInfo[4].Enabled.setValue(src.SystemInfo.SliceInfo[0].SubSliceInfo[4].Enabled); + dst.SystemInfo.SliceInfo[0].SubSliceInfo[4].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[0].SubSliceInfo[4].EuEnabledCount); + dst.SystemInfo.SliceInfo[0].SubSliceInfo[4].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[0].SubSliceInfo[4].EuEnabledMask); + dst.SystemInfo.SliceInfo[0].SubSliceInfo[5].Enabled.setValue(src.SystemInfo.SliceInfo[0].SubSliceInfo[5].Enabled); + dst.SystemInfo.SliceInfo[0].SubSliceInfo[5].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[0].SubSliceInfo[5].EuEnabledCount); + dst.SystemInfo.SliceInfo[0].SubSliceInfo[5].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[0].SubSliceInfo[5].EuEnabledMask); + dst.SystemInfo.SliceInfo[0].SubSliceInfo[6].Enabled.setValue(src.SystemInfo.SliceInfo[0].SubSliceInfo[6].Enabled); + dst.SystemInfo.SliceInfo[0].SubSliceInfo[6].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[0].SubSliceInfo[6].EuEnabledCount); + dst.SystemInfo.SliceInfo[0].SubSliceInfo[6].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[0].SubSliceInfo[6].EuEnabledMask); + dst.SystemInfo.SliceInfo[0].SubSliceInfo[7].Enabled.setValue(src.SystemInfo.SliceInfo[0].SubSliceInfo[7].Enabled); + dst.SystemInfo.SliceInfo[0].SubSliceInfo[7].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[0].SubSliceInfo[7].EuEnabledCount); + dst.SystemInfo.SliceInfo[0].SubSliceInfo[7].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[0].SubSliceInfo[7].EuEnabledMask); + dst.SystemInfo.SliceInfo[0].DSSInfo[0].Enabled.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[0].Enabled); + dst.SystemInfo.SliceInfo[0].DSSInfo[0].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[0].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[0].DSSInfo[0].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[0].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[0].DSSInfo[0].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[0].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[0].DSSInfo[0].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[0].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[0].DSSInfo[0].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[0].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[0].DSSInfo[0].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[0].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[0].DSSInfo[1].Enabled.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[1].Enabled); + dst.SystemInfo.SliceInfo[0].DSSInfo[1].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[1].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[0].DSSInfo[1].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[1].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[0].DSSInfo[1].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[1].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[0].DSSInfo[1].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[1].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[0].DSSInfo[1].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[1].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[0].DSSInfo[1].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[1].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[0].DSSInfo[2].Enabled.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[2].Enabled); + dst.SystemInfo.SliceInfo[0].DSSInfo[2].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[2].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[0].DSSInfo[2].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[2].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[0].DSSInfo[2].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[2].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[0].DSSInfo[2].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[2].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[0].DSSInfo[2].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[2].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[0].DSSInfo[2].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[2].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[0].DSSInfo[3].Enabled.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[3].Enabled); + dst.SystemInfo.SliceInfo[0].DSSInfo[3].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[3].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[0].DSSInfo[3].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[3].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[0].DSSInfo[3].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[3].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[0].DSSInfo[3].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[3].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[0].DSSInfo[3].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[3].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[0].DSSInfo[3].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[3].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[0].DSSInfo[4].Enabled.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[4].Enabled); + dst.SystemInfo.SliceInfo[0].DSSInfo[4].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[4].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[0].DSSInfo[4].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[4].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[0].DSSInfo[4].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[4].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[0].DSSInfo[4].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[4].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[0].DSSInfo[4].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[4].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[0].DSSInfo[4].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[4].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[0].DSSInfo[5].Enabled.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[5].Enabled); + dst.SystemInfo.SliceInfo[0].DSSInfo[5].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[5].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[0].DSSInfo[5].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[5].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[0].DSSInfo[5].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[5].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[0].DSSInfo[5].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[5].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[0].DSSInfo[5].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[5].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[0].DSSInfo[5].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[0].DSSInfo[5].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[0].SubSliceEnabledCount.setValue(src.SystemInfo.SliceInfo[0].SubSliceEnabledCount); + dst.SystemInfo.SliceInfo[0].DualSubSliceEnabledCount.setValue(src.SystemInfo.SliceInfo[0].DualSubSliceEnabledCount); + dst.SystemInfo.SliceInfo[1].Enabled.setValue(src.SystemInfo.SliceInfo[1].Enabled); + dst.SystemInfo.SliceInfo[1].SubSliceInfo[0].Enabled.setValue(src.SystemInfo.SliceInfo[1].SubSliceInfo[0].Enabled); + dst.SystemInfo.SliceInfo[1].SubSliceInfo[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[1].SubSliceInfo[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[1].SubSliceInfo[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[1].SubSliceInfo[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[1].SubSliceInfo[1].Enabled.setValue(src.SystemInfo.SliceInfo[1].SubSliceInfo[1].Enabled); + dst.SystemInfo.SliceInfo[1].SubSliceInfo[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[1].SubSliceInfo[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[1].SubSliceInfo[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[1].SubSliceInfo[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[1].SubSliceInfo[2].Enabled.setValue(src.SystemInfo.SliceInfo[1].SubSliceInfo[2].Enabled); + dst.SystemInfo.SliceInfo[1].SubSliceInfo[2].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[1].SubSliceInfo[2].EuEnabledCount); + dst.SystemInfo.SliceInfo[1].SubSliceInfo[2].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[1].SubSliceInfo[2].EuEnabledMask); + dst.SystemInfo.SliceInfo[1].SubSliceInfo[3].Enabled.setValue(src.SystemInfo.SliceInfo[1].SubSliceInfo[3].Enabled); + dst.SystemInfo.SliceInfo[1].SubSliceInfo[3].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[1].SubSliceInfo[3].EuEnabledCount); + dst.SystemInfo.SliceInfo[1].SubSliceInfo[3].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[1].SubSliceInfo[3].EuEnabledMask); + dst.SystemInfo.SliceInfo[1].SubSliceInfo[4].Enabled.setValue(src.SystemInfo.SliceInfo[1].SubSliceInfo[4].Enabled); + dst.SystemInfo.SliceInfo[1].SubSliceInfo[4].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[1].SubSliceInfo[4].EuEnabledCount); + dst.SystemInfo.SliceInfo[1].SubSliceInfo[4].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[1].SubSliceInfo[4].EuEnabledMask); + dst.SystemInfo.SliceInfo[1].SubSliceInfo[5].Enabled.setValue(src.SystemInfo.SliceInfo[1].SubSliceInfo[5].Enabled); + dst.SystemInfo.SliceInfo[1].SubSliceInfo[5].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[1].SubSliceInfo[5].EuEnabledCount); + dst.SystemInfo.SliceInfo[1].SubSliceInfo[5].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[1].SubSliceInfo[5].EuEnabledMask); + dst.SystemInfo.SliceInfo[1].SubSliceInfo[6].Enabled.setValue(src.SystemInfo.SliceInfo[1].SubSliceInfo[6].Enabled); + dst.SystemInfo.SliceInfo[1].SubSliceInfo[6].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[1].SubSliceInfo[6].EuEnabledCount); + dst.SystemInfo.SliceInfo[1].SubSliceInfo[6].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[1].SubSliceInfo[6].EuEnabledMask); + dst.SystemInfo.SliceInfo[1].SubSliceInfo[7].Enabled.setValue(src.SystemInfo.SliceInfo[1].SubSliceInfo[7].Enabled); + dst.SystemInfo.SliceInfo[1].SubSliceInfo[7].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[1].SubSliceInfo[7].EuEnabledCount); + dst.SystemInfo.SliceInfo[1].SubSliceInfo[7].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[1].SubSliceInfo[7].EuEnabledMask); + dst.SystemInfo.SliceInfo[1].DSSInfo[0].Enabled.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[0].Enabled); + dst.SystemInfo.SliceInfo[1].DSSInfo[0].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[0].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[1].DSSInfo[0].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[0].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[1].DSSInfo[0].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[0].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[1].DSSInfo[0].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[0].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[1].DSSInfo[0].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[0].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[1].DSSInfo[0].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[0].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[1].DSSInfo[1].Enabled.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[1].Enabled); + dst.SystemInfo.SliceInfo[1].DSSInfo[1].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[1].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[1].DSSInfo[1].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[1].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[1].DSSInfo[1].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[1].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[1].DSSInfo[1].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[1].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[1].DSSInfo[1].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[1].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[1].DSSInfo[1].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[1].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[1].DSSInfo[2].Enabled.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[2].Enabled); + dst.SystemInfo.SliceInfo[1].DSSInfo[2].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[2].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[1].DSSInfo[2].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[2].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[1].DSSInfo[2].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[2].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[1].DSSInfo[2].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[2].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[1].DSSInfo[2].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[2].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[1].DSSInfo[2].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[2].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[1].DSSInfo[3].Enabled.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[3].Enabled); + dst.SystemInfo.SliceInfo[1].DSSInfo[3].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[3].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[1].DSSInfo[3].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[3].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[1].DSSInfo[3].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[3].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[1].DSSInfo[3].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[3].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[1].DSSInfo[3].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[3].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[1].DSSInfo[3].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[3].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[1].DSSInfo[4].Enabled.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[4].Enabled); + dst.SystemInfo.SliceInfo[1].DSSInfo[4].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[4].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[1].DSSInfo[4].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[4].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[1].DSSInfo[4].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[4].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[1].DSSInfo[4].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[4].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[1].DSSInfo[4].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[4].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[1].DSSInfo[4].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[4].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[1].DSSInfo[5].Enabled.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[5].Enabled); + dst.SystemInfo.SliceInfo[1].DSSInfo[5].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[5].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[1].DSSInfo[5].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[5].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[1].DSSInfo[5].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[5].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[1].DSSInfo[5].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[5].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[1].DSSInfo[5].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[5].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[1].DSSInfo[5].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[1].DSSInfo[5].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[1].SubSliceEnabledCount.setValue(src.SystemInfo.SliceInfo[1].SubSliceEnabledCount); + dst.SystemInfo.SliceInfo[1].DualSubSliceEnabledCount.setValue(src.SystemInfo.SliceInfo[1].DualSubSliceEnabledCount); + dst.SystemInfo.SliceInfo[2].Enabled.setValue(src.SystemInfo.SliceInfo[2].Enabled); + dst.SystemInfo.SliceInfo[2].SubSliceInfo[0].Enabled.setValue(src.SystemInfo.SliceInfo[2].SubSliceInfo[0].Enabled); + dst.SystemInfo.SliceInfo[2].SubSliceInfo[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[2].SubSliceInfo[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[2].SubSliceInfo[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[2].SubSliceInfo[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[2].SubSliceInfo[1].Enabled.setValue(src.SystemInfo.SliceInfo[2].SubSliceInfo[1].Enabled); + dst.SystemInfo.SliceInfo[2].SubSliceInfo[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[2].SubSliceInfo[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[2].SubSliceInfo[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[2].SubSliceInfo[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[2].SubSliceInfo[2].Enabled.setValue(src.SystemInfo.SliceInfo[2].SubSliceInfo[2].Enabled); + dst.SystemInfo.SliceInfo[2].SubSliceInfo[2].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[2].SubSliceInfo[2].EuEnabledCount); + dst.SystemInfo.SliceInfo[2].SubSliceInfo[2].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[2].SubSliceInfo[2].EuEnabledMask); + dst.SystemInfo.SliceInfo[2].SubSliceInfo[3].Enabled.setValue(src.SystemInfo.SliceInfo[2].SubSliceInfo[3].Enabled); + dst.SystemInfo.SliceInfo[2].SubSliceInfo[3].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[2].SubSliceInfo[3].EuEnabledCount); + dst.SystemInfo.SliceInfo[2].SubSliceInfo[3].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[2].SubSliceInfo[3].EuEnabledMask); + dst.SystemInfo.SliceInfo[2].SubSliceInfo[4].Enabled.setValue(src.SystemInfo.SliceInfo[2].SubSliceInfo[4].Enabled); + dst.SystemInfo.SliceInfo[2].SubSliceInfo[4].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[2].SubSliceInfo[4].EuEnabledCount); + dst.SystemInfo.SliceInfo[2].SubSliceInfo[4].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[2].SubSliceInfo[4].EuEnabledMask); + dst.SystemInfo.SliceInfo[2].SubSliceInfo[5].Enabled.setValue(src.SystemInfo.SliceInfo[2].SubSliceInfo[5].Enabled); + dst.SystemInfo.SliceInfo[2].SubSliceInfo[5].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[2].SubSliceInfo[5].EuEnabledCount); + dst.SystemInfo.SliceInfo[2].SubSliceInfo[5].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[2].SubSliceInfo[5].EuEnabledMask); + dst.SystemInfo.SliceInfo[2].SubSliceInfo[6].Enabled.setValue(src.SystemInfo.SliceInfo[2].SubSliceInfo[6].Enabled); + dst.SystemInfo.SliceInfo[2].SubSliceInfo[6].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[2].SubSliceInfo[6].EuEnabledCount); + dst.SystemInfo.SliceInfo[2].SubSliceInfo[6].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[2].SubSliceInfo[6].EuEnabledMask); + dst.SystemInfo.SliceInfo[2].SubSliceInfo[7].Enabled.setValue(src.SystemInfo.SliceInfo[2].SubSliceInfo[7].Enabled); + dst.SystemInfo.SliceInfo[2].SubSliceInfo[7].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[2].SubSliceInfo[7].EuEnabledCount); + dst.SystemInfo.SliceInfo[2].SubSliceInfo[7].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[2].SubSliceInfo[7].EuEnabledMask); + dst.SystemInfo.SliceInfo[2].DSSInfo[0].Enabled.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[0].Enabled); + dst.SystemInfo.SliceInfo[2].DSSInfo[0].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[0].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[2].DSSInfo[0].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[0].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[2].DSSInfo[0].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[0].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[2].DSSInfo[0].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[0].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[2].DSSInfo[0].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[0].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[2].DSSInfo[0].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[0].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[2].DSSInfo[1].Enabled.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[1].Enabled); + dst.SystemInfo.SliceInfo[2].DSSInfo[1].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[1].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[2].DSSInfo[1].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[1].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[2].DSSInfo[1].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[1].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[2].DSSInfo[1].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[1].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[2].DSSInfo[1].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[1].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[2].DSSInfo[1].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[1].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[2].DSSInfo[2].Enabled.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[2].Enabled); + dst.SystemInfo.SliceInfo[2].DSSInfo[2].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[2].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[2].DSSInfo[2].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[2].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[2].DSSInfo[2].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[2].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[2].DSSInfo[2].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[2].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[2].DSSInfo[2].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[2].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[2].DSSInfo[2].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[2].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[2].DSSInfo[3].Enabled.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[3].Enabled); + dst.SystemInfo.SliceInfo[2].DSSInfo[3].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[3].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[2].DSSInfo[3].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[3].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[2].DSSInfo[3].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[3].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[2].DSSInfo[3].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[3].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[2].DSSInfo[3].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[3].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[2].DSSInfo[3].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[3].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[2].DSSInfo[4].Enabled.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[4].Enabled); + dst.SystemInfo.SliceInfo[2].DSSInfo[4].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[4].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[2].DSSInfo[4].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[4].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[2].DSSInfo[4].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[4].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[2].DSSInfo[4].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[4].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[2].DSSInfo[4].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[4].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[2].DSSInfo[4].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[4].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[2].DSSInfo[5].Enabled.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[5].Enabled); + dst.SystemInfo.SliceInfo[2].DSSInfo[5].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[5].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[2].DSSInfo[5].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[5].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[2].DSSInfo[5].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[5].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[2].DSSInfo[5].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[5].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[2].DSSInfo[5].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[5].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[2].DSSInfo[5].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[2].DSSInfo[5].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[2].SubSliceEnabledCount.setValue(src.SystemInfo.SliceInfo[2].SubSliceEnabledCount); + dst.SystemInfo.SliceInfo[2].DualSubSliceEnabledCount.setValue(src.SystemInfo.SliceInfo[2].DualSubSliceEnabledCount); + dst.SystemInfo.SliceInfo[3].Enabled.setValue(src.SystemInfo.SliceInfo[3].Enabled); + dst.SystemInfo.SliceInfo[3].SubSliceInfo[0].Enabled.setValue(src.SystemInfo.SliceInfo[3].SubSliceInfo[0].Enabled); + dst.SystemInfo.SliceInfo[3].SubSliceInfo[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[3].SubSliceInfo[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[3].SubSliceInfo[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[3].SubSliceInfo[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[3].SubSliceInfo[1].Enabled.setValue(src.SystemInfo.SliceInfo[3].SubSliceInfo[1].Enabled); + dst.SystemInfo.SliceInfo[3].SubSliceInfo[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[3].SubSliceInfo[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[3].SubSliceInfo[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[3].SubSliceInfo[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[3].SubSliceInfo[2].Enabled.setValue(src.SystemInfo.SliceInfo[3].SubSliceInfo[2].Enabled); + dst.SystemInfo.SliceInfo[3].SubSliceInfo[2].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[3].SubSliceInfo[2].EuEnabledCount); + dst.SystemInfo.SliceInfo[3].SubSliceInfo[2].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[3].SubSliceInfo[2].EuEnabledMask); + dst.SystemInfo.SliceInfo[3].SubSliceInfo[3].Enabled.setValue(src.SystemInfo.SliceInfo[3].SubSliceInfo[3].Enabled); + dst.SystemInfo.SliceInfo[3].SubSliceInfo[3].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[3].SubSliceInfo[3].EuEnabledCount); + dst.SystemInfo.SliceInfo[3].SubSliceInfo[3].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[3].SubSliceInfo[3].EuEnabledMask); + dst.SystemInfo.SliceInfo[3].SubSliceInfo[4].Enabled.setValue(src.SystemInfo.SliceInfo[3].SubSliceInfo[4].Enabled); + dst.SystemInfo.SliceInfo[3].SubSliceInfo[4].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[3].SubSliceInfo[4].EuEnabledCount); + dst.SystemInfo.SliceInfo[3].SubSliceInfo[4].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[3].SubSliceInfo[4].EuEnabledMask); + dst.SystemInfo.SliceInfo[3].SubSliceInfo[5].Enabled.setValue(src.SystemInfo.SliceInfo[3].SubSliceInfo[5].Enabled); + dst.SystemInfo.SliceInfo[3].SubSliceInfo[5].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[3].SubSliceInfo[5].EuEnabledCount); + dst.SystemInfo.SliceInfo[3].SubSliceInfo[5].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[3].SubSliceInfo[5].EuEnabledMask); + dst.SystemInfo.SliceInfo[3].SubSliceInfo[6].Enabled.setValue(src.SystemInfo.SliceInfo[3].SubSliceInfo[6].Enabled); + dst.SystemInfo.SliceInfo[3].SubSliceInfo[6].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[3].SubSliceInfo[6].EuEnabledCount); + dst.SystemInfo.SliceInfo[3].SubSliceInfo[6].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[3].SubSliceInfo[6].EuEnabledMask); + dst.SystemInfo.SliceInfo[3].SubSliceInfo[7].Enabled.setValue(src.SystemInfo.SliceInfo[3].SubSliceInfo[7].Enabled); + dst.SystemInfo.SliceInfo[3].SubSliceInfo[7].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[3].SubSliceInfo[7].EuEnabledCount); + dst.SystemInfo.SliceInfo[3].SubSliceInfo[7].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[3].SubSliceInfo[7].EuEnabledMask); + dst.SystemInfo.SliceInfo[3].DSSInfo[0].Enabled.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[0].Enabled); + dst.SystemInfo.SliceInfo[3].DSSInfo[0].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[0].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[3].DSSInfo[0].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[0].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[3].DSSInfo[0].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[0].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[3].DSSInfo[0].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[0].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[3].DSSInfo[0].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[0].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[3].DSSInfo[0].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[0].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[3].DSSInfo[1].Enabled.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[1].Enabled); + dst.SystemInfo.SliceInfo[3].DSSInfo[1].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[1].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[3].DSSInfo[1].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[1].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[3].DSSInfo[1].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[1].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[3].DSSInfo[1].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[1].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[3].DSSInfo[1].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[1].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[3].DSSInfo[1].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[1].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[3].DSSInfo[2].Enabled.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[2].Enabled); + dst.SystemInfo.SliceInfo[3].DSSInfo[2].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[2].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[3].DSSInfo[2].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[2].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[3].DSSInfo[2].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[2].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[3].DSSInfo[2].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[2].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[3].DSSInfo[2].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[2].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[3].DSSInfo[2].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[2].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[3].DSSInfo[3].Enabled.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[3].Enabled); + dst.SystemInfo.SliceInfo[3].DSSInfo[3].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[3].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[3].DSSInfo[3].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[3].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[3].DSSInfo[3].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[3].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[3].DSSInfo[3].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[3].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[3].DSSInfo[3].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[3].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[3].DSSInfo[3].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[3].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[3].DSSInfo[4].Enabled.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[4].Enabled); + dst.SystemInfo.SliceInfo[3].DSSInfo[4].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[4].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[3].DSSInfo[4].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[4].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[3].DSSInfo[4].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[4].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[3].DSSInfo[4].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[4].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[3].DSSInfo[4].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[4].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[3].DSSInfo[4].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[4].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[3].DSSInfo[5].Enabled.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[5].Enabled); + dst.SystemInfo.SliceInfo[3].DSSInfo[5].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[5].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[3].DSSInfo[5].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[5].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[3].DSSInfo[5].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[5].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[3].DSSInfo[5].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[5].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[3].DSSInfo[5].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[5].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[3].DSSInfo[5].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[3].DSSInfo[5].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[3].SubSliceEnabledCount.setValue(src.SystemInfo.SliceInfo[3].SubSliceEnabledCount); + dst.SystemInfo.SliceInfo[3].DualSubSliceEnabledCount.setValue(src.SystemInfo.SliceInfo[3].DualSubSliceEnabledCount); + dst.SystemInfo.SliceInfo[4].Enabled.setValue(src.SystemInfo.SliceInfo[4].Enabled); + dst.SystemInfo.SliceInfo[4].SubSliceInfo[0].Enabled.setValue(src.SystemInfo.SliceInfo[4].SubSliceInfo[0].Enabled); + dst.SystemInfo.SliceInfo[4].SubSliceInfo[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[4].SubSliceInfo[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[4].SubSliceInfo[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[4].SubSliceInfo[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[4].SubSliceInfo[1].Enabled.setValue(src.SystemInfo.SliceInfo[4].SubSliceInfo[1].Enabled); + dst.SystemInfo.SliceInfo[4].SubSliceInfo[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[4].SubSliceInfo[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[4].SubSliceInfo[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[4].SubSliceInfo[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[4].SubSliceInfo[2].Enabled.setValue(src.SystemInfo.SliceInfo[4].SubSliceInfo[2].Enabled); + dst.SystemInfo.SliceInfo[4].SubSliceInfo[2].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[4].SubSliceInfo[2].EuEnabledCount); + dst.SystemInfo.SliceInfo[4].SubSliceInfo[2].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[4].SubSliceInfo[2].EuEnabledMask); + dst.SystemInfo.SliceInfo[4].SubSliceInfo[3].Enabled.setValue(src.SystemInfo.SliceInfo[4].SubSliceInfo[3].Enabled); + dst.SystemInfo.SliceInfo[4].SubSliceInfo[3].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[4].SubSliceInfo[3].EuEnabledCount); + dst.SystemInfo.SliceInfo[4].SubSliceInfo[3].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[4].SubSliceInfo[3].EuEnabledMask); + dst.SystemInfo.SliceInfo[4].SubSliceInfo[4].Enabled.setValue(src.SystemInfo.SliceInfo[4].SubSliceInfo[4].Enabled); + dst.SystemInfo.SliceInfo[4].SubSliceInfo[4].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[4].SubSliceInfo[4].EuEnabledCount); + dst.SystemInfo.SliceInfo[4].SubSliceInfo[4].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[4].SubSliceInfo[4].EuEnabledMask); + dst.SystemInfo.SliceInfo[4].SubSliceInfo[5].Enabled.setValue(src.SystemInfo.SliceInfo[4].SubSliceInfo[5].Enabled); + dst.SystemInfo.SliceInfo[4].SubSliceInfo[5].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[4].SubSliceInfo[5].EuEnabledCount); + dst.SystemInfo.SliceInfo[4].SubSliceInfo[5].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[4].SubSliceInfo[5].EuEnabledMask); + dst.SystemInfo.SliceInfo[4].SubSliceInfo[6].Enabled.setValue(src.SystemInfo.SliceInfo[4].SubSliceInfo[6].Enabled); + dst.SystemInfo.SliceInfo[4].SubSliceInfo[6].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[4].SubSliceInfo[6].EuEnabledCount); + dst.SystemInfo.SliceInfo[4].SubSliceInfo[6].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[4].SubSliceInfo[6].EuEnabledMask); + dst.SystemInfo.SliceInfo[4].SubSliceInfo[7].Enabled.setValue(src.SystemInfo.SliceInfo[4].SubSliceInfo[7].Enabled); + dst.SystemInfo.SliceInfo[4].SubSliceInfo[7].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[4].SubSliceInfo[7].EuEnabledCount); + dst.SystemInfo.SliceInfo[4].SubSliceInfo[7].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[4].SubSliceInfo[7].EuEnabledMask); + dst.SystemInfo.SliceInfo[4].DSSInfo[0].Enabled.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[0].Enabled); + dst.SystemInfo.SliceInfo[4].DSSInfo[0].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[0].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[4].DSSInfo[0].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[0].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[4].DSSInfo[0].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[0].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[4].DSSInfo[0].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[0].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[4].DSSInfo[0].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[0].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[4].DSSInfo[0].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[0].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[4].DSSInfo[1].Enabled.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[1].Enabled); + dst.SystemInfo.SliceInfo[4].DSSInfo[1].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[1].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[4].DSSInfo[1].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[1].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[4].DSSInfo[1].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[1].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[4].DSSInfo[1].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[1].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[4].DSSInfo[1].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[1].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[4].DSSInfo[1].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[1].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[4].DSSInfo[2].Enabled.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[2].Enabled); + dst.SystemInfo.SliceInfo[4].DSSInfo[2].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[2].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[4].DSSInfo[2].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[2].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[4].DSSInfo[2].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[2].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[4].DSSInfo[2].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[2].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[4].DSSInfo[2].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[2].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[4].DSSInfo[2].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[2].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[4].DSSInfo[3].Enabled.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[3].Enabled); + dst.SystemInfo.SliceInfo[4].DSSInfo[3].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[3].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[4].DSSInfo[3].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[3].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[4].DSSInfo[3].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[3].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[4].DSSInfo[3].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[3].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[4].DSSInfo[3].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[3].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[4].DSSInfo[3].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[3].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[4].DSSInfo[4].Enabled.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[4].Enabled); + dst.SystemInfo.SliceInfo[4].DSSInfo[4].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[4].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[4].DSSInfo[4].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[4].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[4].DSSInfo[4].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[4].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[4].DSSInfo[4].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[4].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[4].DSSInfo[4].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[4].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[4].DSSInfo[4].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[4].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[4].DSSInfo[5].Enabled.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[5].Enabled); + dst.SystemInfo.SliceInfo[4].DSSInfo[5].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[5].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[4].DSSInfo[5].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[5].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[4].DSSInfo[5].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[5].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[4].DSSInfo[5].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[5].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[4].DSSInfo[5].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[5].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[4].DSSInfo[5].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[4].DSSInfo[5].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[4].SubSliceEnabledCount.setValue(src.SystemInfo.SliceInfo[4].SubSliceEnabledCount); + dst.SystemInfo.SliceInfo[4].DualSubSliceEnabledCount.setValue(src.SystemInfo.SliceInfo[4].DualSubSliceEnabledCount); + dst.SystemInfo.SliceInfo[5].Enabled.setValue(src.SystemInfo.SliceInfo[5].Enabled); + dst.SystemInfo.SliceInfo[5].SubSliceInfo[0].Enabled.setValue(src.SystemInfo.SliceInfo[5].SubSliceInfo[0].Enabled); + dst.SystemInfo.SliceInfo[5].SubSliceInfo[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[5].SubSliceInfo[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[5].SubSliceInfo[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[5].SubSliceInfo[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[5].SubSliceInfo[1].Enabled.setValue(src.SystemInfo.SliceInfo[5].SubSliceInfo[1].Enabled); + dst.SystemInfo.SliceInfo[5].SubSliceInfo[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[5].SubSliceInfo[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[5].SubSliceInfo[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[5].SubSliceInfo[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[5].SubSliceInfo[2].Enabled.setValue(src.SystemInfo.SliceInfo[5].SubSliceInfo[2].Enabled); + dst.SystemInfo.SliceInfo[5].SubSliceInfo[2].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[5].SubSliceInfo[2].EuEnabledCount); + dst.SystemInfo.SliceInfo[5].SubSliceInfo[2].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[5].SubSliceInfo[2].EuEnabledMask); + dst.SystemInfo.SliceInfo[5].SubSliceInfo[3].Enabled.setValue(src.SystemInfo.SliceInfo[5].SubSliceInfo[3].Enabled); + dst.SystemInfo.SliceInfo[5].SubSliceInfo[3].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[5].SubSliceInfo[3].EuEnabledCount); + dst.SystemInfo.SliceInfo[5].SubSliceInfo[3].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[5].SubSliceInfo[3].EuEnabledMask); + dst.SystemInfo.SliceInfo[5].SubSliceInfo[4].Enabled.setValue(src.SystemInfo.SliceInfo[5].SubSliceInfo[4].Enabled); + dst.SystemInfo.SliceInfo[5].SubSliceInfo[4].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[5].SubSliceInfo[4].EuEnabledCount); + dst.SystemInfo.SliceInfo[5].SubSliceInfo[4].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[5].SubSliceInfo[4].EuEnabledMask); + dst.SystemInfo.SliceInfo[5].SubSliceInfo[5].Enabled.setValue(src.SystemInfo.SliceInfo[5].SubSliceInfo[5].Enabled); + dst.SystemInfo.SliceInfo[5].SubSliceInfo[5].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[5].SubSliceInfo[5].EuEnabledCount); + dst.SystemInfo.SliceInfo[5].SubSliceInfo[5].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[5].SubSliceInfo[5].EuEnabledMask); + dst.SystemInfo.SliceInfo[5].SubSliceInfo[6].Enabled.setValue(src.SystemInfo.SliceInfo[5].SubSliceInfo[6].Enabled); + dst.SystemInfo.SliceInfo[5].SubSliceInfo[6].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[5].SubSliceInfo[6].EuEnabledCount); + dst.SystemInfo.SliceInfo[5].SubSliceInfo[6].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[5].SubSliceInfo[6].EuEnabledMask); + dst.SystemInfo.SliceInfo[5].SubSliceInfo[7].Enabled.setValue(src.SystemInfo.SliceInfo[5].SubSliceInfo[7].Enabled); + dst.SystemInfo.SliceInfo[5].SubSliceInfo[7].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[5].SubSliceInfo[7].EuEnabledCount); + dst.SystemInfo.SliceInfo[5].SubSliceInfo[7].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[5].SubSliceInfo[7].EuEnabledMask); + dst.SystemInfo.SliceInfo[5].DSSInfo[0].Enabled.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[0].Enabled); + dst.SystemInfo.SliceInfo[5].DSSInfo[0].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[0].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[5].DSSInfo[0].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[0].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[5].DSSInfo[0].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[0].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[5].DSSInfo[0].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[0].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[5].DSSInfo[0].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[0].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[5].DSSInfo[0].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[0].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[5].DSSInfo[1].Enabled.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[1].Enabled); + dst.SystemInfo.SliceInfo[5].DSSInfo[1].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[1].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[5].DSSInfo[1].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[1].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[5].DSSInfo[1].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[1].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[5].DSSInfo[1].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[1].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[5].DSSInfo[1].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[1].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[5].DSSInfo[1].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[1].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[5].DSSInfo[2].Enabled.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[2].Enabled); + dst.SystemInfo.SliceInfo[5].DSSInfo[2].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[2].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[5].DSSInfo[2].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[2].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[5].DSSInfo[2].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[2].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[5].DSSInfo[2].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[2].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[5].DSSInfo[2].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[2].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[5].DSSInfo[2].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[2].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[5].DSSInfo[3].Enabled.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[3].Enabled); + dst.SystemInfo.SliceInfo[5].DSSInfo[3].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[3].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[5].DSSInfo[3].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[3].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[5].DSSInfo[3].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[3].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[5].DSSInfo[3].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[3].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[5].DSSInfo[3].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[3].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[5].DSSInfo[3].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[3].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[5].DSSInfo[4].Enabled.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[4].Enabled); + dst.SystemInfo.SliceInfo[5].DSSInfo[4].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[4].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[5].DSSInfo[4].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[4].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[5].DSSInfo[4].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[4].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[5].DSSInfo[4].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[4].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[5].DSSInfo[4].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[4].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[5].DSSInfo[4].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[4].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[5].DSSInfo[5].Enabled.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[5].Enabled); + dst.SystemInfo.SliceInfo[5].DSSInfo[5].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[5].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[5].DSSInfo[5].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[5].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[5].DSSInfo[5].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[5].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[5].DSSInfo[5].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[5].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[5].DSSInfo[5].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[5].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[5].DSSInfo[5].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[5].DSSInfo[5].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[5].SubSliceEnabledCount.setValue(src.SystemInfo.SliceInfo[5].SubSliceEnabledCount); + dst.SystemInfo.SliceInfo[5].DualSubSliceEnabledCount.setValue(src.SystemInfo.SliceInfo[5].DualSubSliceEnabledCount); + dst.SystemInfo.SliceInfo[6].Enabled.setValue(src.SystemInfo.SliceInfo[6].Enabled); + dst.SystemInfo.SliceInfo[6].SubSliceInfo[0].Enabled.setValue(src.SystemInfo.SliceInfo[6].SubSliceInfo[0].Enabled); + dst.SystemInfo.SliceInfo[6].SubSliceInfo[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[6].SubSliceInfo[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[6].SubSliceInfo[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[6].SubSliceInfo[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[6].SubSliceInfo[1].Enabled.setValue(src.SystemInfo.SliceInfo[6].SubSliceInfo[1].Enabled); + dst.SystemInfo.SliceInfo[6].SubSliceInfo[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[6].SubSliceInfo[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[6].SubSliceInfo[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[6].SubSliceInfo[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[6].SubSliceInfo[2].Enabled.setValue(src.SystemInfo.SliceInfo[6].SubSliceInfo[2].Enabled); + dst.SystemInfo.SliceInfo[6].SubSliceInfo[2].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[6].SubSliceInfo[2].EuEnabledCount); + dst.SystemInfo.SliceInfo[6].SubSliceInfo[2].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[6].SubSliceInfo[2].EuEnabledMask); + dst.SystemInfo.SliceInfo[6].SubSliceInfo[3].Enabled.setValue(src.SystemInfo.SliceInfo[6].SubSliceInfo[3].Enabled); + dst.SystemInfo.SliceInfo[6].SubSliceInfo[3].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[6].SubSliceInfo[3].EuEnabledCount); + dst.SystemInfo.SliceInfo[6].SubSliceInfo[3].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[6].SubSliceInfo[3].EuEnabledMask); + dst.SystemInfo.SliceInfo[6].SubSliceInfo[4].Enabled.setValue(src.SystemInfo.SliceInfo[6].SubSliceInfo[4].Enabled); + dst.SystemInfo.SliceInfo[6].SubSliceInfo[4].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[6].SubSliceInfo[4].EuEnabledCount); + dst.SystemInfo.SliceInfo[6].SubSliceInfo[4].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[6].SubSliceInfo[4].EuEnabledMask); + dst.SystemInfo.SliceInfo[6].SubSliceInfo[5].Enabled.setValue(src.SystemInfo.SliceInfo[6].SubSliceInfo[5].Enabled); + dst.SystemInfo.SliceInfo[6].SubSliceInfo[5].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[6].SubSliceInfo[5].EuEnabledCount); + dst.SystemInfo.SliceInfo[6].SubSliceInfo[5].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[6].SubSliceInfo[5].EuEnabledMask); + dst.SystemInfo.SliceInfo[6].SubSliceInfo[6].Enabled.setValue(src.SystemInfo.SliceInfo[6].SubSliceInfo[6].Enabled); + dst.SystemInfo.SliceInfo[6].SubSliceInfo[6].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[6].SubSliceInfo[6].EuEnabledCount); + dst.SystemInfo.SliceInfo[6].SubSliceInfo[6].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[6].SubSliceInfo[6].EuEnabledMask); + dst.SystemInfo.SliceInfo[6].SubSliceInfo[7].Enabled.setValue(src.SystemInfo.SliceInfo[6].SubSliceInfo[7].Enabled); + dst.SystemInfo.SliceInfo[6].SubSliceInfo[7].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[6].SubSliceInfo[7].EuEnabledCount); + dst.SystemInfo.SliceInfo[6].SubSliceInfo[7].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[6].SubSliceInfo[7].EuEnabledMask); + dst.SystemInfo.SliceInfo[6].DSSInfo[0].Enabled.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[0].Enabled); + dst.SystemInfo.SliceInfo[6].DSSInfo[0].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[0].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[6].DSSInfo[0].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[0].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[6].DSSInfo[0].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[0].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[6].DSSInfo[0].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[0].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[6].DSSInfo[0].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[0].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[6].DSSInfo[0].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[0].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[6].DSSInfo[1].Enabled.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[1].Enabled); + dst.SystemInfo.SliceInfo[6].DSSInfo[1].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[1].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[6].DSSInfo[1].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[1].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[6].DSSInfo[1].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[1].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[6].DSSInfo[1].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[1].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[6].DSSInfo[1].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[1].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[6].DSSInfo[1].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[1].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[6].DSSInfo[2].Enabled.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[2].Enabled); + dst.SystemInfo.SliceInfo[6].DSSInfo[2].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[2].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[6].DSSInfo[2].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[2].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[6].DSSInfo[2].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[2].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[6].DSSInfo[2].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[2].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[6].DSSInfo[2].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[2].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[6].DSSInfo[2].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[2].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[6].DSSInfo[3].Enabled.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[3].Enabled); + dst.SystemInfo.SliceInfo[6].DSSInfo[3].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[3].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[6].DSSInfo[3].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[3].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[6].DSSInfo[3].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[3].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[6].DSSInfo[3].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[3].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[6].DSSInfo[3].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[3].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[6].DSSInfo[3].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[3].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[6].DSSInfo[4].Enabled.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[4].Enabled); + dst.SystemInfo.SliceInfo[6].DSSInfo[4].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[4].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[6].DSSInfo[4].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[4].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[6].DSSInfo[4].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[4].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[6].DSSInfo[4].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[4].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[6].DSSInfo[4].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[4].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[6].DSSInfo[4].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[4].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[6].DSSInfo[5].Enabled.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[5].Enabled); + dst.SystemInfo.SliceInfo[6].DSSInfo[5].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[5].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[6].DSSInfo[5].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[5].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[6].DSSInfo[5].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[5].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[6].DSSInfo[5].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[5].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[6].DSSInfo[5].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[5].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[6].DSSInfo[5].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[6].DSSInfo[5].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[6].SubSliceEnabledCount.setValue(src.SystemInfo.SliceInfo[6].SubSliceEnabledCount); + dst.SystemInfo.SliceInfo[6].DualSubSliceEnabledCount.setValue(src.SystemInfo.SliceInfo[6].DualSubSliceEnabledCount); + dst.SystemInfo.SliceInfo[7].Enabled.setValue(src.SystemInfo.SliceInfo[7].Enabled); + dst.SystemInfo.SliceInfo[7].SubSliceInfo[0].Enabled.setValue(src.SystemInfo.SliceInfo[7].SubSliceInfo[0].Enabled); + dst.SystemInfo.SliceInfo[7].SubSliceInfo[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[7].SubSliceInfo[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[7].SubSliceInfo[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[7].SubSliceInfo[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[7].SubSliceInfo[1].Enabled.setValue(src.SystemInfo.SliceInfo[7].SubSliceInfo[1].Enabled); + dst.SystemInfo.SliceInfo[7].SubSliceInfo[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[7].SubSliceInfo[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[7].SubSliceInfo[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[7].SubSliceInfo[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[7].SubSliceInfo[2].Enabled.setValue(src.SystemInfo.SliceInfo[7].SubSliceInfo[2].Enabled); + dst.SystemInfo.SliceInfo[7].SubSliceInfo[2].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[7].SubSliceInfo[2].EuEnabledCount); + dst.SystemInfo.SliceInfo[7].SubSliceInfo[2].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[7].SubSliceInfo[2].EuEnabledMask); + dst.SystemInfo.SliceInfo[7].SubSliceInfo[3].Enabled.setValue(src.SystemInfo.SliceInfo[7].SubSliceInfo[3].Enabled); + dst.SystemInfo.SliceInfo[7].SubSliceInfo[3].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[7].SubSliceInfo[3].EuEnabledCount); + dst.SystemInfo.SliceInfo[7].SubSliceInfo[3].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[7].SubSliceInfo[3].EuEnabledMask); + dst.SystemInfo.SliceInfo[7].SubSliceInfo[4].Enabled.setValue(src.SystemInfo.SliceInfo[7].SubSliceInfo[4].Enabled); + dst.SystemInfo.SliceInfo[7].SubSliceInfo[4].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[7].SubSliceInfo[4].EuEnabledCount); + dst.SystemInfo.SliceInfo[7].SubSliceInfo[4].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[7].SubSliceInfo[4].EuEnabledMask); + dst.SystemInfo.SliceInfo[7].SubSliceInfo[5].Enabled.setValue(src.SystemInfo.SliceInfo[7].SubSliceInfo[5].Enabled); + dst.SystemInfo.SliceInfo[7].SubSliceInfo[5].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[7].SubSliceInfo[5].EuEnabledCount); + dst.SystemInfo.SliceInfo[7].SubSliceInfo[5].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[7].SubSliceInfo[5].EuEnabledMask); + dst.SystemInfo.SliceInfo[7].SubSliceInfo[6].Enabled.setValue(src.SystemInfo.SliceInfo[7].SubSliceInfo[6].Enabled); + dst.SystemInfo.SliceInfo[7].SubSliceInfo[6].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[7].SubSliceInfo[6].EuEnabledCount); + dst.SystemInfo.SliceInfo[7].SubSliceInfo[6].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[7].SubSliceInfo[6].EuEnabledMask); + dst.SystemInfo.SliceInfo[7].SubSliceInfo[7].Enabled.setValue(src.SystemInfo.SliceInfo[7].SubSliceInfo[7].Enabled); + dst.SystemInfo.SliceInfo[7].SubSliceInfo[7].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[7].SubSliceInfo[7].EuEnabledCount); + dst.SystemInfo.SliceInfo[7].SubSliceInfo[7].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[7].SubSliceInfo[7].EuEnabledMask); + dst.SystemInfo.SliceInfo[7].DSSInfo[0].Enabled.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[0].Enabled); + dst.SystemInfo.SliceInfo[7].DSSInfo[0].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[0].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[7].DSSInfo[0].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[0].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[7].DSSInfo[0].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[0].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[7].DSSInfo[0].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[0].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[7].DSSInfo[0].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[0].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[7].DSSInfo[0].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[0].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[7].DSSInfo[1].Enabled.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[1].Enabled); + dst.SystemInfo.SliceInfo[7].DSSInfo[1].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[1].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[7].DSSInfo[1].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[1].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[7].DSSInfo[1].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[1].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[7].DSSInfo[1].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[1].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[7].DSSInfo[1].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[1].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[7].DSSInfo[1].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[1].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[7].DSSInfo[2].Enabled.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[2].Enabled); + dst.SystemInfo.SliceInfo[7].DSSInfo[2].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[2].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[7].DSSInfo[2].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[2].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[7].DSSInfo[2].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[2].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[7].DSSInfo[2].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[2].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[7].DSSInfo[2].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[2].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[7].DSSInfo[2].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[2].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[7].DSSInfo[3].Enabled.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[3].Enabled); + dst.SystemInfo.SliceInfo[7].DSSInfo[3].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[3].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[7].DSSInfo[3].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[3].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[7].DSSInfo[3].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[3].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[7].DSSInfo[3].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[3].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[7].DSSInfo[3].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[3].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[7].DSSInfo[3].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[3].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[7].DSSInfo[4].Enabled.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[4].Enabled); + dst.SystemInfo.SliceInfo[7].DSSInfo[4].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[4].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[7].DSSInfo[4].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[4].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[7].DSSInfo[4].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[4].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[7].DSSInfo[4].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[4].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[7].DSSInfo[4].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[4].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[7].DSSInfo[4].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[4].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[7].DSSInfo[5].Enabled.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[5].Enabled); + dst.SystemInfo.SliceInfo[7].DSSInfo[5].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[5].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[7].DSSInfo[5].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[5].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[7].DSSInfo[5].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[5].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[7].DSSInfo[5].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[5].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[7].DSSInfo[5].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[5].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[7].DSSInfo[5].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[7].DSSInfo[5].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[7].SubSliceEnabledCount.setValue(src.SystemInfo.SliceInfo[7].SubSliceEnabledCount); + dst.SystemInfo.SliceInfo[7].DualSubSliceEnabledCount.setValue(src.SystemInfo.SliceInfo[7].DualSubSliceEnabledCount); + dst.SystemInfo.SliceInfo[8].Enabled.setValue(src.SystemInfo.SliceInfo[8].Enabled); + dst.SystemInfo.SliceInfo[8].SubSliceInfo[0].Enabled.setValue(src.SystemInfo.SliceInfo[8].SubSliceInfo[0].Enabled); + dst.SystemInfo.SliceInfo[8].SubSliceInfo[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[8].SubSliceInfo[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[8].SubSliceInfo[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[8].SubSliceInfo[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[8].SubSliceInfo[1].Enabled.setValue(src.SystemInfo.SliceInfo[8].SubSliceInfo[1].Enabled); + dst.SystemInfo.SliceInfo[8].SubSliceInfo[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[8].SubSliceInfo[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[8].SubSliceInfo[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[8].SubSliceInfo[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[8].SubSliceInfo[2].Enabled.setValue(src.SystemInfo.SliceInfo[8].SubSliceInfo[2].Enabled); + dst.SystemInfo.SliceInfo[8].SubSliceInfo[2].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[8].SubSliceInfo[2].EuEnabledCount); + dst.SystemInfo.SliceInfo[8].SubSliceInfo[2].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[8].SubSliceInfo[2].EuEnabledMask); + dst.SystemInfo.SliceInfo[8].SubSliceInfo[3].Enabled.setValue(src.SystemInfo.SliceInfo[8].SubSliceInfo[3].Enabled); + dst.SystemInfo.SliceInfo[8].SubSliceInfo[3].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[8].SubSliceInfo[3].EuEnabledCount); + dst.SystemInfo.SliceInfo[8].SubSliceInfo[3].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[8].SubSliceInfo[3].EuEnabledMask); + dst.SystemInfo.SliceInfo[8].SubSliceInfo[4].Enabled.setValue(src.SystemInfo.SliceInfo[8].SubSliceInfo[4].Enabled); + dst.SystemInfo.SliceInfo[8].SubSliceInfo[4].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[8].SubSliceInfo[4].EuEnabledCount); + dst.SystemInfo.SliceInfo[8].SubSliceInfo[4].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[8].SubSliceInfo[4].EuEnabledMask); + dst.SystemInfo.SliceInfo[8].SubSliceInfo[5].Enabled.setValue(src.SystemInfo.SliceInfo[8].SubSliceInfo[5].Enabled); + dst.SystemInfo.SliceInfo[8].SubSliceInfo[5].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[8].SubSliceInfo[5].EuEnabledCount); + dst.SystemInfo.SliceInfo[8].SubSliceInfo[5].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[8].SubSliceInfo[5].EuEnabledMask); + dst.SystemInfo.SliceInfo[8].SubSliceInfo[6].Enabled.setValue(src.SystemInfo.SliceInfo[8].SubSliceInfo[6].Enabled); + dst.SystemInfo.SliceInfo[8].SubSliceInfo[6].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[8].SubSliceInfo[6].EuEnabledCount); + dst.SystemInfo.SliceInfo[8].SubSliceInfo[6].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[8].SubSliceInfo[6].EuEnabledMask); + dst.SystemInfo.SliceInfo[8].SubSliceInfo[7].Enabled.setValue(src.SystemInfo.SliceInfo[8].SubSliceInfo[7].Enabled); + dst.SystemInfo.SliceInfo[8].SubSliceInfo[7].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[8].SubSliceInfo[7].EuEnabledCount); + dst.SystemInfo.SliceInfo[8].SubSliceInfo[7].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[8].SubSliceInfo[7].EuEnabledMask); + dst.SystemInfo.SliceInfo[8].DSSInfo[0].Enabled.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[0].Enabled); + dst.SystemInfo.SliceInfo[8].DSSInfo[0].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[0].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[8].DSSInfo[0].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[0].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[8].DSSInfo[0].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[0].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[8].DSSInfo[0].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[0].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[8].DSSInfo[0].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[0].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[8].DSSInfo[0].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[0].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[8].DSSInfo[1].Enabled.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[1].Enabled); + dst.SystemInfo.SliceInfo[8].DSSInfo[1].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[1].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[8].DSSInfo[1].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[1].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[8].DSSInfo[1].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[1].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[8].DSSInfo[1].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[1].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[8].DSSInfo[1].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[1].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[8].DSSInfo[1].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[1].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[8].DSSInfo[2].Enabled.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[2].Enabled); + dst.SystemInfo.SliceInfo[8].DSSInfo[2].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[2].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[8].DSSInfo[2].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[2].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[8].DSSInfo[2].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[2].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[8].DSSInfo[2].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[2].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[8].DSSInfo[2].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[2].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[8].DSSInfo[2].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[2].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[8].DSSInfo[3].Enabled.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[3].Enabled); + dst.SystemInfo.SliceInfo[8].DSSInfo[3].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[3].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[8].DSSInfo[3].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[3].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[8].DSSInfo[3].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[3].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[8].DSSInfo[3].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[3].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[8].DSSInfo[3].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[3].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[8].DSSInfo[3].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[3].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[8].DSSInfo[4].Enabled.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[4].Enabled); + dst.SystemInfo.SliceInfo[8].DSSInfo[4].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[4].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[8].DSSInfo[4].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[4].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[8].DSSInfo[4].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[4].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[8].DSSInfo[4].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[4].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[8].DSSInfo[4].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[4].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[8].DSSInfo[4].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[4].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[8].DSSInfo[5].Enabled.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[5].Enabled); + dst.SystemInfo.SliceInfo[8].DSSInfo[5].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[5].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[8].DSSInfo[5].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[5].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[8].DSSInfo[5].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[5].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[8].DSSInfo[5].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[5].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[8].DSSInfo[5].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[5].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[8].DSSInfo[5].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[8].DSSInfo[5].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[8].SubSliceEnabledCount.setValue(src.SystemInfo.SliceInfo[8].SubSliceEnabledCount); + dst.SystemInfo.SliceInfo[8].DualSubSliceEnabledCount.setValue(src.SystemInfo.SliceInfo[8].DualSubSliceEnabledCount); + dst.SystemInfo.SliceInfo[9].Enabled.setValue(src.SystemInfo.SliceInfo[9].Enabled); + dst.SystemInfo.SliceInfo[9].SubSliceInfo[0].Enabled.setValue(src.SystemInfo.SliceInfo[9].SubSliceInfo[0].Enabled); + dst.SystemInfo.SliceInfo[9].SubSliceInfo[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[9].SubSliceInfo[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[9].SubSliceInfo[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[9].SubSliceInfo[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[9].SubSliceInfo[1].Enabled.setValue(src.SystemInfo.SliceInfo[9].SubSliceInfo[1].Enabled); + dst.SystemInfo.SliceInfo[9].SubSliceInfo[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[9].SubSliceInfo[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[9].SubSliceInfo[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[9].SubSliceInfo[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[9].SubSliceInfo[2].Enabled.setValue(src.SystemInfo.SliceInfo[9].SubSliceInfo[2].Enabled); + dst.SystemInfo.SliceInfo[9].SubSliceInfo[2].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[9].SubSliceInfo[2].EuEnabledCount); + dst.SystemInfo.SliceInfo[9].SubSliceInfo[2].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[9].SubSliceInfo[2].EuEnabledMask); + dst.SystemInfo.SliceInfo[9].SubSliceInfo[3].Enabled.setValue(src.SystemInfo.SliceInfo[9].SubSliceInfo[3].Enabled); + dst.SystemInfo.SliceInfo[9].SubSliceInfo[3].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[9].SubSliceInfo[3].EuEnabledCount); + dst.SystemInfo.SliceInfo[9].SubSliceInfo[3].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[9].SubSliceInfo[3].EuEnabledMask); + dst.SystemInfo.SliceInfo[9].SubSliceInfo[4].Enabled.setValue(src.SystemInfo.SliceInfo[9].SubSliceInfo[4].Enabled); + dst.SystemInfo.SliceInfo[9].SubSliceInfo[4].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[9].SubSliceInfo[4].EuEnabledCount); + dst.SystemInfo.SliceInfo[9].SubSliceInfo[4].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[9].SubSliceInfo[4].EuEnabledMask); + dst.SystemInfo.SliceInfo[9].SubSliceInfo[5].Enabled.setValue(src.SystemInfo.SliceInfo[9].SubSliceInfo[5].Enabled); + dst.SystemInfo.SliceInfo[9].SubSliceInfo[5].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[9].SubSliceInfo[5].EuEnabledCount); + dst.SystemInfo.SliceInfo[9].SubSliceInfo[5].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[9].SubSliceInfo[5].EuEnabledMask); + dst.SystemInfo.SliceInfo[9].SubSliceInfo[6].Enabled.setValue(src.SystemInfo.SliceInfo[9].SubSliceInfo[6].Enabled); + dst.SystemInfo.SliceInfo[9].SubSliceInfo[6].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[9].SubSliceInfo[6].EuEnabledCount); + dst.SystemInfo.SliceInfo[9].SubSliceInfo[6].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[9].SubSliceInfo[6].EuEnabledMask); + dst.SystemInfo.SliceInfo[9].SubSliceInfo[7].Enabled.setValue(src.SystemInfo.SliceInfo[9].SubSliceInfo[7].Enabled); + dst.SystemInfo.SliceInfo[9].SubSliceInfo[7].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[9].SubSliceInfo[7].EuEnabledCount); + dst.SystemInfo.SliceInfo[9].SubSliceInfo[7].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[9].SubSliceInfo[7].EuEnabledMask); + dst.SystemInfo.SliceInfo[9].DSSInfo[0].Enabled.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[0].Enabled); + dst.SystemInfo.SliceInfo[9].DSSInfo[0].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[0].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[9].DSSInfo[0].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[0].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[9].DSSInfo[0].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[0].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[9].DSSInfo[0].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[0].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[9].DSSInfo[0].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[0].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[9].DSSInfo[0].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[0].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[9].DSSInfo[1].Enabled.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[1].Enabled); + dst.SystemInfo.SliceInfo[9].DSSInfo[1].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[1].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[9].DSSInfo[1].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[1].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[9].DSSInfo[1].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[1].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[9].DSSInfo[1].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[1].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[9].DSSInfo[1].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[1].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[9].DSSInfo[1].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[1].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[9].DSSInfo[2].Enabled.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[2].Enabled); + dst.SystemInfo.SliceInfo[9].DSSInfo[2].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[2].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[9].DSSInfo[2].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[2].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[9].DSSInfo[2].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[2].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[9].DSSInfo[2].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[2].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[9].DSSInfo[2].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[2].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[9].DSSInfo[2].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[2].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[9].DSSInfo[3].Enabled.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[3].Enabled); + dst.SystemInfo.SliceInfo[9].DSSInfo[3].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[3].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[9].DSSInfo[3].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[3].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[9].DSSInfo[3].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[3].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[9].DSSInfo[3].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[3].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[9].DSSInfo[3].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[3].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[9].DSSInfo[3].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[3].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[9].DSSInfo[4].Enabled.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[4].Enabled); + dst.SystemInfo.SliceInfo[9].DSSInfo[4].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[4].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[9].DSSInfo[4].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[4].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[9].DSSInfo[4].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[4].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[9].DSSInfo[4].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[4].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[9].DSSInfo[4].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[4].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[9].DSSInfo[4].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[4].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[9].DSSInfo[5].Enabled.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[5].Enabled); + dst.SystemInfo.SliceInfo[9].DSSInfo[5].SubSlice[0].Enabled.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[5].SubSlice[0].Enabled); + dst.SystemInfo.SliceInfo[9].DSSInfo[5].SubSlice[0].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[5].SubSlice[0].EuEnabledCount); + dst.SystemInfo.SliceInfo[9].DSSInfo[5].SubSlice[0].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[5].SubSlice[0].EuEnabledMask); + dst.SystemInfo.SliceInfo[9].DSSInfo[5].SubSlice[1].Enabled.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[5].SubSlice[1].Enabled); + dst.SystemInfo.SliceInfo[9].DSSInfo[5].SubSlice[1].EuEnabledCount.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[5].SubSlice[1].EuEnabledCount); + dst.SystemInfo.SliceInfo[9].DSSInfo[5].SubSlice[1].EuEnabledMask.setValue(src.SystemInfo.SliceInfo[9].DSSInfo[5].SubSlice[1].EuEnabledMask); + dst.SystemInfo.SliceInfo[9].SubSliceEnabledCount.setValue(src.SystemInfo.SliceInfo[9].SubSliceEnabledCount); + dst.SystemInfo.SliceInfo[9].DualSubSliceEnabledCount.setValue(src.SystemInfo.SliceInfo[9].DualSubSliceEnabledCount); + dst.SystemInfo.IsDynamicallyPopulated.setValue(src.SystemInfo.IsDynamicallyPopulated); + dst.SystemInfo.SqidiInfo.NumberofSQIDI.setValue(src.SystemInfo.SqidiInfo.NumberofSQIDI); + dst.SystemInfo.SqidiInfo.NumberofDoorbellPerSQIDI.setValue(src.SystemInfo.SqidiInfo.NumberofDoorbellPerSQIDI); + dst.SystemInfo.ReservedCCSWays.setValue(src.SystemInfo.ReservedCCSWays); + dst.SystemInfo.CCSInfo.Instances.Bits.CCS0Enabled.setValue(src.SystemInfo.CCSInfo.Instances.Bits.CCS0Enabled); + dst.SystemInfo.CCSInfo.Instances.Bits.CCS1Enabled.setValue(src.SystemInfo.CCSInfo.Instances.Bits.CCS1Enabled); + dst.SystemInfo.CCSInfo.Instances.Bits.CCS2Enabled.setValue(src.SystemInfo.CCSInfo.Instances.Bits.CCS2Enabled); + dst.SystemInfo.CCSInfo.Instances.Bits.CCS3Enabled.setValue(src.SystemInfo.CCSInfo.Instances.Bits.CCS3Enabled); + dst.SystemInfo.CCSInfo.Instances.CCSEnableMask.setValue(src.SystemInfo.CCSInfo.Instances.CCSEnableMask); + dst.SystemInfo.CCSInfo.NumberOfCCSEnabled.setValue(src.SystemInfo.CCSInfo.NumberOfCCSEnabled); + dst.SystemInfo.CCSInfo.IsValid.setValue(src.SystemInfo.CCSInfo.IsValid); + dst.SystemInfo.MultiTileArchInfo.TileCount.setValue(src.SystemInfo.MultiTileArchInfo.TileCount); + dst.SystemInfo.MultiTileArchInfo.Tile0.setValue(src.SystemInfo.MultiTileArchInfo.Tile0); + dst.SystemInfo.MultiTileArchInfo.Tile1.setValue(src.SystemInfo.MultiTileArchInfo.Tile1); + dst.SystemInfo.MultiTileArchInfo.Tile2.setValue(src.SystemInfo.MultiTileArchInfo.Tile2); + dst.SystemInfo.MultiTileArchInfo.Tile3.setValue(src.SystemInfo.MultiTileArchInfo.Tile3); + dst.SystemInfo.MultiTileArchInfo.TileMask.setValue(src.SystemInfo.MultiTileArchInfo.TileMask); + dst.SystemInfo.MultiTileArchInfo.IsValid.setValue(src.SystemInfo.MultiTileArchInfo.IsValid); + dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox0Enabled.setValue(src.SystemInfo.VDBoxInfo.Instances.Bits.VDBox0Enabled); + dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox1Enabled.setValue(src.SystemInfo.VDBoxInfo.Instances.Bits.VDBox1Enabled); + dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox2Enabled.setValue(src.SystemInfo.VDBoxInfo.Instances.Bits.VDBox2Enabled); + dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox3Enabled.setValue(src.SystemInfo.VDBoxInfo.Instances.Bits.VDBox3Enabled); + dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox4Enabled.setValue(src.SystemInfo.VDBoxInfo.Instances.Bits.VDBox4Enabled); + dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox5Enabled.setValue(src.SystemInfo.VDBoxInfo.Instances.Bits.VDBox5Enabled); + dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox6Enabled.setValue(src.SystemInfo.VDBoxInfo.Instances.Bits.VDBox6Enabled); + dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox7Enabled.setValue(src.SystemInfo.VDBoxInfo.Instances.Bits.VDBox7Enabled); + dst.SystemInfo.VDBoxInfo.Instances.VDBoxEnableMask.setValue(src.SystemInfo.VDBoxInfo.Instances.VDBoxEnableMask); + dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox0.setValue(src.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox0); + dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox1.setValue(src.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox1); + dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox2.setValue(src.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox2); + dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox3.setValue(src.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox3); + dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox4.setValue(src.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox4); + dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox5.setValue(src.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox5); + dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox6.setValue(src.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox6); + dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox7.setValue(src.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox7); + dst.SystemInfo.VDBoxInfo.SFCSupport.Value.setValue(src.SystemInfo.VDBoxInfo.SFCSupport.Value); + dst.SystemInfo.VDBoxInfo.NumberOfVDBoxEnabled.setValue(src.SystemInfo.VDBoxInfo.NumberOfVDBoxEnabled); + dst.SystemInfo.VDBoxInfo.IsValid.setValue(src.SystemInfo.VDBoxInfo.IsValid); + dst.SystemInfo.VEBoxInfo.Instances.Bits.VEBox0Enabled.setValue(src.SystemInfo.VEBoxInfo.Instances.Bits.VEBox0Enabled); + dst.SystemInfo.VEBoxInfo.Instances.Bits.VEBox1Enabled.setValue(src.SystemInfo.VEBoxInfo.Instances.Bits.VEBox1Enabled); + dst.SystemInfo.VEBoxInfo.Instances.Bits.VEBox2Enabled.setValue(src.SystemInfo.VEBoxInfo.Instances.Bits.VEBox2Enabled); + dst.SystemInfo.VEBoxInfo.Instances.Bits.VEBox3Enabled.setValue(src.SystemInfo.VEBoxInfo.Instances.Bits.VEBox3Enabled); + dst.SystemInfo.VEBoxInfo.Instances.VEBoxEnableMask.setValue(src.SystemInfo.VEBoxInfo.Instances.VEBoxEnableMask); + dst.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox0.setValue(src.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox0); + dst.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox1.setValue(src.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox1); + dst.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox2.setValue(src.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox2); + dst.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox3.setValue(src.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox3); + dst.SystemInfo.VEBoxInfo.SFCSupport.Value.setValue(src.SystemInfo.VEBoxInfo.SFCSupport.Value); + dst.SystemInfo.VEBoxInfo.NumberOfVEBoxEnabled.setValue(src.SystemInfo.VEBoxInfo.NumberOfVEBoxEnabled); + dst.SystemInfo.VEBoxInfo.IsValid.setValue(src.SystemInfo.VEBoxInfo.IsValid); + dst.SystemInfo.NumThreadsPerEu.setValue(src.SystemInfo.NumThreadsPerEu); + dst.SystemInfo.CacheTypes.L3.setValue(src.SystemInfo.CacheTypes.L3); + dst.SystemInfo.CacheTypes.LLC.setValue(src.SystemInfo.CacheTypes.LLC); + dst.SystemInfo.CacheTypes.eDRAM.setValue(src.SystemInfo.CacheTypes.eDRAM); + dst.SystemInfo.CacheTypes.CacheTypeMask.setValue(src.SystemInfo.CacheTypes.CacheTypeMask); + dst.SystemInfo.MaxVECS.setValue(src.SystemInfo.MaxVECS); + dst.DeferredWaitInfo.FeatureSupported.setValue(src.DeferredWaitInfo.FeatureSupported); + dst.DeferredWaitInfo.ActiveDisplay.setValue(src.DeferredWaitInfo.ActiveDisplay); + dst.GfxPartition.Standard.Base.setValue(src.GfxPartition.Standard.Base); + dst.GfxPartition.Standard.Limit.setValue(src.GfxPartition.Standard.Limit); + dst.GfxPartition.Standard64KB.Base.setValue(src.GfxPartition.Standard64KB.Base); + dst.GfxPartition.Standard64KB.Limit.setValue(src.GfxPartition.Standard64KB.Limit); + dst.GfxPartition.SVM.Base.setValue(src.GfxPartition.SVM.Base); + dst.GfxPartition.SVM.Limit.setValue(src.GfxPartition.SVM.Limit); + dst.GfxPartition.Heap32[0].Base.setValue(src.GfxPartition.Heap32[0].Base); + dst.GfxPartition.Heap32[0].Limit.setValue(src.GfxPartition.Heap32[0].Limit); + dst.GfxPartition.Heap32[1].Base.setValue(src.GfxPartition.Heap32[1].Base); + dst.GfxPartition.Heap32[1].Limit.setValue(src.GfxPartition.Heap32[1].Limit); + dst.GfxPartition.Heap32[2].Base.setValue(src.GfxPartition.Heap32[2].Base); + dst.GfxPartition.Heap32[2].Limit.setValue(src.GfxPartition.Heap32[2].Limit); + dst.GfxPartition.Heap32[3].Base.setValue(src.GfxPartition.Heap32[3].Base); + dst.GfxPartition.Heap32[3].Limit.setValue(src.GfxPartition.Heap32[3].Limit); + dst.stAdapterBDF.Bus.setValue(src.stAdapterBDF.Bus); + dst.stAdapterBDF.Device.setValue(src.stAdapterBDF.Device); + dst.stAdapterBDF.Function.setValue(src.stAdapterBDF.Function); + dst.stAdapterBDF.Data.setValue(src.stAdapterBDF.Data); +} +template <> +struct Marshaller { + template + static TOKSTR__ADAPTER_INFO marshall(const _ADAPTER_INFOT &src) { + TOKSTR__ADAPTER_INFO ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR__CREATECONTEXT_PVTDATA &dst, const _CREATECONTEXT_PVTDATAT &src) { + dst = {}; + dst.pHwContextId.setValue(src.pHwContextId); + dst.NumberOfHwContextIds.setValue(src.NumberOfHwContextIds); + dst.ProcessID.setValue(src.ProcessID); + dst.IsProtectedProcess.setValue(src.IsProtectedProcess); + dst.IsDwm.setValue(src.IsDwm); + dst.IsMediaUsage.setValue(src.IsMediaUsage); + dst.GpuVAContext.setValue(src.GpuVAContext); + dst.NoRingFlushes.setValue(src.NoRingFlushes); +} +template <> +struct Marshaller { + template + static TOKSTR__CREATECONTEXT_PVTDATA marshall(const _CREATECONTEXT_PVTDATAT &src) { + TOKSTR__CREATECONTEXT_PVTDATA ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_COMMAND_BUFFER_HEADER_REC &dst, const COMMAND_BUFFER_HEADER_RECT &src) { + dst = {}; + dst.UmdContextType.setValue(src.UmdContextType); + dst.UmdPatchList.setValue(src.UmdPatchList); + dst.UmdRequestedSliceState.setValue(src.UmdRequestedSliceState); + dst.UmdRequestedSubsliceCount.setValue(src.UmdRequestedSubsliceCount); + dst.UmdRequestedEUCount.setValue(src.UmdRequestedEUCount); + dst.UsesResourceStreamer.setValue(src.UsesResourceStreamer); + dst.NeedsMidBatchPreEmptionSupport.setValue(src.NeedsMidBatchPreEmptionSupport); + dst.UsesGPGPUPipeline.setValue(src.UsesGPGPUPipeline); + dst.RequiresCoherency.setValue(src.RequiresCoherency); + dst.PerfTag.setValue(src.PerfTag); + dst.MonitorFenceVA.setValue(src.MonitorFenceVA); + dst.MonitorFenceValue.setValue(src.MonitorFenceValue); +} +template <> +struct Marshaller { + template + static TOKSTR_COMMAND_BUFFER_HEADER_REC marshall(const COMMAND_BUFFER_HEADER_RECT &src) { + TOKSTR_COMMAND_BUFFER_HEADER_REC ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_GMM_RESOURCE_FLAG_REC &dst, const GMM_RESOURCE_FLAG_RECT &src) { + dst = {}; + dst.Gpu.CameraCapture.setValue(src.Gpu.CameraCapture); + dst.Gpu.CCS.setValue(src.Gpu.CCS); + dst.Gpu.ColorDiscard.setValue(src.Gpu.ColorDiscard); + dst.Gpu.ColorSeparation.setValue(src.Gpu.ColorSeparation); + dst.Gpu.ColorSeparationRGBX.setValue(src.Gpu.ColorSeparationRGBX); + dst.Gpu.Constant.setValue(src.Gpu.Constant); + dst.Gpu.Depth.setValue(src.Gpu.Depth); + dst.Gpu.FlipChain.setValue(src.Gpu.FlipChain); + dst.Gpu.FlipChainPreferred.setValue(src.Gpu.FlipChainPreferred); + dst.Gpu.HistoryBuffer.setValue(src.Gpu.HistoryBuffer); + dst.Gpu.HiZ.setValue(src.Gpu.HiZ); + dst.Gpu.Index.setValue(src.Gpu.Index); + dst.Gpu.IndirectClearColor.setValue(src.Gpu.IndirectClearColor); + dst.Gpu.InstructionFlat.setValue(src.Gpu.InstructionFlat); + dst.Gpu.InterlacedScan.setValue(src.Gpu.InterlacedScan); + dst.Gpu.MCS.setValue(src.Gpu.MCS); + dst.Gpu.MMC.setValue(src.Gpu.MMC); + dst.Gpu.MotionComp.setValue(src.Gpu.MotionComp); + dst.Gpu.NoRestriction.setValue(src.Gpu.NoRestriction); + dst.Gpu.Overlay.setValue(src.Gpu.Overlay); + dst.Gpu.Presentable.setValue(src.Gpu.Presentable); + dst.Gpu.ProceduralTexture.setValue(src.Gpu.ProceduralTexture); + dst.Gpu.Query.setValue(src.Gpu.Query); + dst.Gpu.RenderTarget.setValue(src.Gpu.RenderTarget); + dst.Gpu.S3d.setValue(src.Gpu.S3d); + dst.Gpu.S3dDx.setValue(src.Gpu.S3dDx); + dst.Gpu.__S3dNonPacked.setValue(src.Gpu.__S3dNonPacked); + dst.Gpu.__S3dWidi.setValue(src.Gpu.__S3dWidi); + dst.Gpu.ScratchFlat.setValue(src.Gpu.ScratchFlat); + dst.Gpu.SeparateStencil.setValue(src.Gpu.SeparateStencil); + dst.Gpu.State.setValue(src.Gpu.State); + dst.Gpu.StateDx9ConstantBuffer.setValue(src.Gpu.StateDx9ConstantBuffer); + dst.Gpu.Stream.setValue(src.Gpu.Stream); + dst.Gpu.TextApi.setValue(src.Gpu.TextApi); + dst.Gpu.Texture.setValue(src.Gpu.Texture); + dst.Gpu.TiledResource.setValue(src.Gpu.TiledResource); + dst.Gpu.TilePool.setValue(src.Gpu.TilePool); + dst.Gpu.UnifiedAuxSurface.setValue(src.Gpu.UnifiedAuxSurface); + dst.Gpu.Vertex.setValue(src.Gpu.Vertex); + dst.Gpu.Video.setValue(src.Gpu.Video); + dst.Gpu.__NonMsaaTileXCcs.setValue(src.Gpu.__NonMsaaTileXCcs); + dst.Gpu.__NonMsaaTileYCcs.setValue(src.Gpu.__NonMsaaTileYCcs); + dst.Gpu.__MsaaTileMcs.setValue(src.Gpu.__MsaaTileMcs); + dst.Gpu.__NonMsaaLinearCCS.setValue(src.Gpu.__NonMsaaLinearCCS); + dst.Gpu.__Remaining.setValue(src.Gpu.__Remaining); + dst.Info.AllowVirtualPadding.setValue(src.Info.AllowVirtualPadding); + dst.Info.BigPage.setValue(src.Info.BigPage); + dst.Info.Cacheable.setValue(src.Info.Cacheable); + dst.Info.ContigPhysMemoryForiDART.setValue(src.Info.ContigPhysMemoryForiDART); + dst.Info.CornerTexelMode.setValue(src.Info.CornerTexelMode); + dst.Info.ExistingSysMem.setValue(src.Info.ExistingSysMem); + dst.Info.ForceResidency.setValue(src.Info.ForceResidency); + dst.Info.Gfdt.setValue(src.Info.Gfdt); + dst.Info.GttMapType.setValue(src.Info.GttMapType); + dst.Info.HardwareProtected.setValue(src.Info.HardwareProtected); + dst.Info.KernelModeMapped.setValue(src.Info.KernelModeMapped); + dst.Info.LayoutBelow.setValue(src.Info.LayoutBelow); + dst.Info.LayoutMono.setValue(src.Info.LayoutMono); + dst.Info.LayoutRight.setValue(src.Info.LayoutRight); + dst.Info.LocalOnly.setValue(src.Info.LocalOnly); + dst.Info.Linear.setValue(src.Info.Linear); + dst.Info.MediaCompressed.setValue(src.Info.MediaCompressed); + dst.Info.NoOptimizationPadding.setValue(src.Info.NoOptimizationPadding); + dst.Info.NoPhysMemory.setValue(src.Info.NoPhysMemory); + dst.Info.NotLockable.setValue(src.Info.NotLockable); + dst.Info.NonLocalOnly.setValue(src.Info.NonLocalOnly); + dst.Info.StdSwizzle.setValue(src.Info.StdSwizzle); + dst.Info.PseudoStdSwizzle.setValue(src.Info.PseudoStdSwizzle); + dst.Info.Undefined64KBSwizzle.setValue(src.Info.Undefined64KBSwizzle); + dst.Info.RedecribedPlanes.setValue(src.Info.RedecribedPlanes); + dst.Info.RenderCompressed.setValue(src.Info.RenderCompressed); + dst.Info.Rotated.setValue(src.Info.Rotated); + dst.Info.Shared.setValue(src.Info.Shared); + dst.Info.SoftwareProtected.setValue(src.Info.SoftwareProtected); + dst.Info.SVM.setValue(src.Info.SVM); + dst.Info.Tile4.setValue(src.Info.Tile4); + dst.Info.Tile64.setValue(src.Info.Tile64); + dst.Info.TiledW.setValue(src.Info.TiledW); + dst.Info.TiledX.setValue(src.Info.TiledX); + dst.Info.TiledY.setValue(src.Info.TiledY); + dst.Info.TiledYf.setValue(src.Info.TiledYf); + dst.Info.TiledYs.setValue(src.Info.TiledYs); + dst.Info.WddmProtected.setValue(src.Info.WddmProtected); + dst.Info.XAdapter.setValue(src.Info.XAdapter); + dst.Info.__PreallocatedResInfo.setValue(src.Info.__PreallocatedResInfo); + dst.Info.__PreWddm2SVM.setValue(src.Info.__PreWddm2SVM); + dst.Wa.GTMfx2ndLevelBatchRingSizeAlign.setValue(src.Wa.GTMfx2ndLevelBatchRingSizeAlign); + dst.Wa.ILKNeedAvcMprRowStore32KAlign.setValue(src.Wa.ILKNeedAvcMprRowStore32KAlign); + dst.Wa.ILKNeedAvcDmvBuffer32KAlign.setValue(src.Wa.ILKNeedAvcDmvBuffer32KAlign); + dst.Wa.NoBufferSamplerPadding.setValue(src.Wa.NoBufferSamplerPadding); + dst.Wa.NoLegacyPlanarLinearVideoRestrictions.setValue(src.Wa.NoLegacyPlanarLinearVideoRestrictions); + dst.Wa.CHVAstcSkipVirtualMips.setValue(src.Wa.CHVAstcSkipVirtualMips); + dst.Wa.DisablePackedMipTail.setValue(src.Wa.DisablePackedMipTail); + dst.Wa.__ForceOtherHVALIGN4.setValue(src.Wa.__ForceOtherHVALIGN4); + dst.Wa.DisableDisplayCcsClearColor.setValue(src.Wa.DisableDisplayCcsClearColor); + dst.Wa.DisableDisplayCcsCompression.setValue(src.Wa.DisableDisplayCcsCompression); + dst.Wa.PreGen12FastClearOnly.setValue(src.Wa.PreGen12FastClearOnly); +} +template <> +struct Marshaller { + template + static TOKSTR_GMM_RESOURCE_FLAG_REC marshall(const GMM_RESOURCE_FLAG_RECT &src) { + TOKSTR_GMM_RESOURCE_FLAG_REC ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_GMM_RESOURCE_MSAA_INFO_REC &dst, const GMM_RESOURCE_MSAA_INFO_RECT &src) { + dst = {}; + dst.SamplePattern.setValue(src.SamplePattern); + dst.NumSamples.setValue(src.NumSamples); +} +template <> +struct Marshaller { + template + static TOKSTR_GMM_RESOURCE_MSAA_INFO_REC marshall(const GMM_RESOURCE_MSAA_INFO_RECT &src) { + TOKSTR_GMM_RESOURCE_MSAA_INFO_REC ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_GMM_RESOURCE_ALIGNMENT_REC &dst, const GMM_RESOURCE_ALIGNMENT_RECT &src) { + dst = {}; + dst.ArraySpacingSingleLod.setValue(src.ArraySpacingSingleLod); + dst.BaseAlignment.setValue(src.BaseAlignment); + dst.HAlign.setValue(src.HAlign); + dst.VAlign.setValue(src.VAlign); + dst.DAlign.setValue(src.DAlign); + dst.MipTailStartLod.setValue(src.MipTailStartLod); + dst.PackedMipStartLod.setValue(src.PackedMipStartLod); + dst.PackedMipWidth.setValue(src.PackedMipWidth); + dst.PackedMipHeight.setValue(src.PackedMipHeight); + dst.QPitch.setValue(src.QPitch); +} +template <> +struct Marshaller { + template + static TOKSTR_GMM_RESOURCE_ALIGNMENT_REC marshall(const GMM_RESOURCE_ALIGNMENT_RECT &src) { + TOKSTR_GMM_RESOURCE_ALIGNMENT_REC ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_GMM_S3D_INFO_REC &dst, const GMM_S3D_INFO_RECT &src) { + dst = {}; + dst.DisplayModeHeight.setValue(src.DisplayModeHeight); + dst.NumBlankActiveLines.setValue(src.NumBlankActiveLines); + dst.RFrameOffset.setValue(src.RFrameOffset); + dst.BlankAreaOffset.setValue(src.BlankAreaOffset); + dst.TallBufferHeight.setValue(src.TallBufferHeight); + dst.TallBufferSize.setValue(src.TallBufferSize); + dst.IsRFrame.setValue(src.IsRFrame); +} +template <> +struct Marshaller { + template + static TOKSTR_GMM_S3D_INFO_REC marshall(const GMM_S3D_INFO_RECT &src) { + TOKSTR_GMM_S3D_INFO_REC ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_GMM_MULTI_TILE_ARCH_REC &dst, const GMM_MULTI_TILE_ARCH_RECT &src) { + dst = {}; + dst.Enable.setValue(src.Enable); + dst.TileInstanced.setValue(src.TileInstanced); + dst.GpuVaMappingSet.setValue(src.GpuVaMappingSet); + dst.LocalMemEligibilitySet.setValue(src.LocalMemEligibilitySet); + dst.LocalMemPreferredSet.setValue(src.LocalMemPreferredSet); +} +template <> +struct Marshaller { + template + static TOKSTR_GMM_MULTI_TILE_ARCH_REC marshall(const GMM_MULTI_TILE_ARCH_RECT &src) { + TOKSTR_GMM_MULTI_TILE_ARCH_REC ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_GMM_PLANAR_OFFSET_INFO_REC &dst, const GMM_PLANAR_OFFSET_INFO_RECT &src) { + dst = {}; + dst.ArrayQPitch.setValue(src.ArrayQPitch); + WCH_SAFE_COPY(dst.X.getValue(), dst.X.getValueSizeInBytes(), src.X, sizeof(src.X)); + WCH_SAFE_COPY(dst.Y.getValue(), dst.Y.getValueSizeInBytes(), src.Y, sizeof(src.Y)); + WCH_SAFE_COPY(dst.UnAligned.Height.getValue(), dst.UnAligned.Height.getValueSizeInBytes(), src.UnAligned.Height, sizeof(src.UnAligned.Height)); + dst.NoOfPlanes.setValue(src.NoOfPlanes); + dst.IsTileAlignedPlanes.setValue(src.IsTileAlignedPlanes); +} +template <> +struct Marshaller { + template + static TOKSTR_GMM_PLANAR_OFFSET_INFO_REC marshall(const GMM_PLANAR_OFFSET_INFO_RECT &src) { + TOKSTR_GMM_PLANAR_OFFSET_INFO_REC ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_GMM_2D_TEXTURE_OFFSET_INFO_REC &dst, const GMM_2D_TEXTURE_OFFSET_INFO_RECT &src) { + dst = {}; + dst.ArrayQPitchLock.setValue(src.ArrayQPitchLock); + dst.ArrayQPitchRender.setValue(src.ArrayQPitchRender); + WCH_SAFE_COPY(dst.Offset.getValue(), dst.Offset.getValueSizeInBytes(), src.Offset, sizeof(src.Offset)); +} +template <> +struct Marshaller { + template + static TOKSTR_GMM_2D_TEXTURE_OFFSET_INFO_REC marshall(const GMM_2D_TEXTURE_OFFSET_INFO_RECT &src) { + TOKSTR_GMM_2D_TEXTURE_OFFSET_INFO_REC ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_GMM_3D_TEXTURE_OFFSET_INFO_REC &dst, const GMM_3D_TEXTURE_OFFSET_INFO_RECT &src) { + dst = {}; + dst.Mip0SlicePitch.setValue(src.Mip0SlicePitch); + WCH_SAFE_COPY(dst.Offset.getValue(), dst.Offset.getValueSizeInBytes(), src.Offset, sizeof(src.Offset)); +} +template <> +struct Marshaller { + template + static TOKSTR_GMM_3D_TEXTURE_OFFSET_INFO_REC marshall(const GMM_3D_TEXTURE_OFFSET_INFO_RECT &src) { + TOKSTR_GMM_3D_TEXTURE_OFFSET_INFO_REC ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_GMM_OFFSET_INFO_REC &dst, const GMM_OFFSET_INFO_RECT &src) { + dst = {}; + dst.Texture3DOffsetInfo.Mip0SlicePitch.setValue(src.Texture3DOffsetInfo.Mip0SlicePitch); + WCH_SAFE_COPY(dst.Texture3DOffsetInfo.Offset.getValue(), dst.Texture3DOffsetInfo.Offset.getValueSizeInBytes(), src.Texture3DOffsetInfo.Offset, sizeof(src.Texture3DOffsetInfo.Offset)); + dst.Texture2DOffsetInfo.ArrayQPitchLock.setValue(src.Texture2DOffsetInfo.ArrayQPitchLock); + dst.Texture2DOffsetInfo.ArrayQPitchRender.setValue(src.Texture2DOffsetInfo.ArrayQPitchRender); + WCH_SAFE_COPY(dst.Texture2DOffsetInfo.Offset.getValue(), dst.Texture2DOffsetInfo.Offset.getValueSizeInBytes(), src.Texture2DOffsetInfo.Offset, sizeof(src.Texture2DOffsetInfo.Offset)); + dst.Plane.ArrayQPitch.setValue(src.Plane.ArrayQPitch); + WCH_SAFE_COPY(dst.Plane.X.getValue(), dst.Plane.X.getValueSizeInBytes(), src.Plane.X, sizeof(src.Plane.X)); + WCH_SAFE_COPY(dst.Plane.Y.getValue(), dst.Plane.Y.getValueSizeInBytes(), src.Plane.Y, sizeof(src.Plane.Y)); + WCH_SAFE_COPY(dst.Plane.UnAligned.Height.getValue(), dst.Plane.UnAligned.Height.getValueSizeInBytes(), src.Plane.UnAligned.Height, sizeof(src.Plane.UnAligned.Height)); + dst.Plane.NoOfPlanes.setValue(src.Plane.NoOfPlanes); + dst.Plane.IsTileAlignedPlanes.setValue(src.Plane.IsTileAlignedPlanes); +} +template <> +struct Marshaller { + template + static TOKSTR_GMM_OFFSET_INFO_REC marshall(const GMM_OFFSET_INFO_RECT &src) { + TOKSTR_GMM_OFFSET_INFO_REC ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_GMM_TEXTURE_INFO_REC &dst, const GMM_TEXTURE_INFO_RECT &src) { + dst = {}; + dst.Type.setValue(src.Type); + dst.Format.setValue(src.Format); + dst.BitsPerPixel.setValue(src.BitsPerPixel); + dst.Flags.Gpu.CameraCapture.setValue(src.Flags.Gpu.CameraCapture); + dst.Flags.Gpu.CCS.setValue(src.Flags.Gpu.CCS); + dst.Flags.Gpu.ColorDiscard.setValue(src.Flags.Gpu.ColorDiscard); + dst.Flags.Gpu.ColorSeparation.setValue(src.Flags.Gpu.ColorSeparation); + dst.Flags.Gpu.ColorSeparationRGBX.setValue(src.Flags.Gpu.ColorSeparationRGBX); + dst.Flags.Gpu.Constant.setValue(src.Flags.Gpu.Constant); + dst.Flags.Gpu.Depth.setValue(src.Flags.Gpu.Depth); + dst.Flags.Gpu.FlipChain.setValue(src.Flags.Gpu.FlipChain); + dst.Flags.Gpu.FlipChainPreferred.setValue(src.Flags.Gpu.FlipChainPreferred); + dst.Flags.Gpu.HistoryBuffer.setValue(src.Flags.Gpu.HistoryBuffer); + dst.Flags.Gpu.HiZ.setValue(src.Flags.Gpu.HiZ); + dst.Flags.Gpu.Index.setValue(src.Flags.Gpu.Index); + dst.Flags.Gpu.IndirectClearColor.setValue(src.Flags.Gpu.IndirectClearColor); + dst.Flags.Gpu.InstructionFlat.setValue(src.Flags.Gpu.InstructionFlat); + dst.Flags.Gpu.InterlacedScan.setValue(src.Flags.Gpu.InterlacedScan); + dst.Flags.Gpu.MCS.setValue(src.Flags.Gpu.MCS); + dst.Flags.Gpu.MMC.setValue(src.Flags.Gpu.MMC); + dst.Flags.Gpu.MotionComp.setValue(src.Flags.Gpu.MotionComp); + dst.Flags.Gpu.NoRestriction.setValue(src.Flags.Gpu.NoRestriction); + dst.Flags.Gpu.Overlay.setValue(src.Flags.Gpu.Overlay); + dst.Flags.Gpu.Presentable.setValue(src.Flags.Gpu.Presentable); + dst.Flags.Gpu.ProceduralTexture.setValue(src.Flags.Gpu.ProceduralTexture); + dst.Flags.Gpu.Query.setValue(src.Flags.Gpu.Query); + dst.Flags.Gpu.RenderTarget.setValue(src.Flags.Gpu.RenderTarget); + dst.Flags.Gpu.S3d.setValue(src.Flags.Gpu.S3d); + dst.Flags.Gpu.S3dDx.setValue(src.Flags.Gpu.S3dDx); + dst.Flags.Gpu.__S3dNonPacked.setValue(src.Flags.Gpu.__S3dNonPacked); + dst.Flags.Gpu.__S3dWidi.setValue(src.Flags.Gpu.__S3dWidi); + dst.Flags.Gpu.ScratchFlat.setValue(src.Flags.Gpu.ScratchFlat); + dst.Flags.Gpu.SeparateStencil.setValue(src.Flags.Gpu.SeparateStencil); + dst.Flags.Gpu.State.setValue(src.Flags.Gpu.State); + dst.Flags.Gpu.StateDx9ConstantBuffer.setValue(src.Flags.Gpu.StateDx9ConstantBuffer); + dst.Flags.Gpu.Stream.setValue(src.Flags.Gpu.Stream); + dst.Flags.Gpu.TextApi.setValue(src.Flags.Gpu.TextApi); + dst.Flags.Gpu.Texture.setValue(src.Flags.Gpu.Texture); + dst.Flags.Gpu.TiledResource.setValue(src.Flags.Gpu.TiledResource); + dst.Flags.Gpu.TilePool.setValue(src.Flags.Gpu.TilePool); + dst.Flags.Gpu.UnifiedAuxSurface.setValue(src.Flags.Gpu.UnifiedAuxSurface); + dst.Flags.Gpu.Vertex.setValue(src.Flags.Gpu.Vertex); + dst.Flags.Gpu.Video.setValue(src.Flags.Gpu.Video); + dst.Flags.Gpu.__NonMsaaTileXCcs.setValue(src.Flags.Gpu.__NonMsaaTileXCcs); + dst.Flags.Gpu.__NonMsaaTileYCcs.setValue(src.Flags.Gpu.__NonMsaaTileYCcs); + dst.Flags.Gpu.__MsaaTileMcs.setValue(src.Flags.Gpu.__MsaaTileMcs); + dst.Flags.Gpu.__NonMsaaLinearCCS.setValue(src.Flags.Gpu.__NonMsaaLinearCCS); + dst.Flags.Gpu.__Remaining.setValue(src.Flags.Gpu.__Remaining); + dst.Flags.Info.AllowVirtualPadding.setValue(src.Flags.Info.AllowVirtualPadding); + dst.Flags.Info.BigPage.setValue(src.Flags.Info.BigPage); + dst.Flags.Info.Cacheable.setValue(src.Flags.Info.Cacheable); + dst.Flags.Info.ContigPhysMemoryForiDART.setValue(src.Flags.Info.ContigPhysMemoryForiDART); + dst.Flags.Info.CornerTexelMode.setValue(src.Flags.Info.CornerTexelMode); + dst.Flags.Info.ExistingSysMem.setValue(src.Flags.Info.ExistingSysMem); + dst.Flags.Info.ForceResidency.setValue(src.Flags.Info.ForceResidency); + dst.Flags.Info.Gfdt.setValue(src.Flags.Info.Gfdt); + dst.Flags.Info.GttMapType.setValue(src.Flags.Info.GttMapType); + dst.Flags.Info.HardwareProtected.setValue(src.Flags.Info.HardwareProtected); + dst.Flags.Info.KernelModeMapped.setValue(src.Flags.Info.KernelModeMapped); + dst.Flags.Info.LayoutBelow.setValue(src.Flags.Info.LayoutBelow); + dst.Flags.Info.LayoutMono.setValue(src.Flags.Info.LayoutMono); + dst.Flags.Info.LayoutRight.setValue(src.Flags.Info.LayoutRight); + dst.Flags.Info.LocalOnly.setValue(src.Flags.Info.LocalOnly); + dst.Flags.Info.Linear.setValue(src.Flags.Info.Linear); + dst.Flags.Info.MediaCompressed.setValue(src.Flags.Info.MediaCompressed); + dst.Flags.Info.NoOptimizationPadding.setValue(src.Flags.Info.NoOptimizationPadding); + dst.Flags.Info.NoPhysMemory.setValue(src.Flags.Info.NoPhysMemory); + dst.Flags.Info.NotLockable.setValue(src.Flags.Info.NotLockable); + dst.Flags.Info.NonLocalOnly.setValue(src.Flags.Info.NonLocalOnly); + dst.Flags.Info.StdSwizzle.setValue(src.Flags.Info.StdSwizzle); + dst.Flags.Info.PseudoStdSwizzle.setValue(src.Flags.Info.PseudoStdSwizzle); + dst.Flags.Info.Undefined64KBSwizzle.setValue(src.Flags.Info.Undefined64KBSwizzle); + dst.Flags.Info.RedecribedPlanes.setValue(src.Flags.Info.RedecribedPlanes); + dst.Flags.Info.RenderCompressed.setValue(src.Flags.Info.RenderCompressed); + dst.Flags.Info.Rotated.setValue(src.Flags.Info.Rotated); + dst.Flags.Info.Shared.setValue(src.Flags.Info.Shared); + dst.Flags.Info.SoftwareProtected.setValue(src.Flags.Info.SoftwareProtected); + dst.Flags.Info.SVM.setValue(src.Flags.Info.SVM); + dst.Flags.Info.Tile4.setValue(src.Flags.Info.Tile4); + dst.Flags.Info.Tile64.setValue(src.Flags.Info.Tile64); + dst.Flags.Info.TiledW.setValue(src.Flags.Info.TiledW); + dst.Flags.Info.TiledX.setValue(src.Flags.Info.TiledX); + dst.Flags.Info.TiledY.setValue(src.Flags.Info.TiledY); + dst.Flags.Info.TiledYf.setValue(src.Flags.Info.TiledYf); + dst.Flags.Info.TiledYs.setValue(src.Flags.Info.TiledYs); + dst.Flags.Info.WddmProtected.setValue(src.Flags.Info.WddmProtected); + dst.Flags.Info.XAdapter.setValue(src.Flags.Info.XAdapter); + dst.Flags.Info.__PreallocatedResInfo.setValue(src.Flags.Info.__PreallocatedResInfo); + dst.Flags.Info.__PreWddm2SVM.setValue(src.Flags.Info.__PreWddm2SVM); + dst.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign.setValue(src.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign); + dst.Flags.Wa.ILKNeedAvcMprRowStore32KAlign.setValue(src.Flags.Wa.ILKNeedAvcMprRowStore32KAlign); + dst.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign.setValue(src.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign); + dst.Flags.Wa.NoBufferSamplerPadding.setValue(src.Flags.Wa.NoBufferSamplerPadding); + dst.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions.setValue(src.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions); + dst.Flags.Wa.CHVAstcSkipVirtualMips.setValue(src.Flags.Wa.CHVAstcSkipVirtualMips); + dst.Flags.Wa.DisablePackedMipTail.setValue(src.Flags.Wa.DisablePackedMipTail); + dst.Flags.Wa.__ForceOtherHVALIGN4.setValue(src.Flags.Wa.__ForceOtherHVALIGN4); + dst.Flags.Wa.DisableDisplayCcsClearColor.setValue(src.Flags.Wa.DisableDisplayCcsClearColor); + dst.Flags.Wa.DisableDisplayCcsCompression.setValue(src.Flags.Wa.DisableDisplayCcsCompression); + dst.Flags.Wa.PreGen12FastClearOnly.setValue(src.Flags.Wa.PreGen12FastClearOnly); + dst.BaseWidth.setValue(src.BaseWidth); + dst.BaseHeight.setValue(src.BaseHeight); + dst.Depth.setValue(src.Depth); + dst.MaxLod.setValue(src.MaxLod); + dst.ArraySize.setValue(src.ArraySize); + dst.CpTag.setValue(src.CpTag); + dst.CachePolicy.Usage.setValue(src.CachePolicy.Usage); + dst.MSAA.SamplePattern.setValue(src.MSAA.SamplePattern); + dst.MSAA.NumSamples.setValue(src.MSAA.NumSamples); + dst.Alignment.ArraySpacingSingleLod.setValue(src.Alignment.ArraySpacingSingleLod); + dst.Alignment.BaseAlignment.setValue(src.Alignment.BaseAlignment); + dst.Alignment.HAlign.setValue(src.Alignment.HAlign); + dst.Alignment.VAlign.setValue(src.Alignment.VAlign); + dst.Alignment.DAlign.setValue(src.Alignment.DAlign); + dst.Alignment.MipTailStartLod.setValue(src.Alignment.MipTailStartLod); + dst.Alignment.PackedMipStartLod.setValue(src.Alignment.PackedMipStartLod); + dst.Alignment.PackedMipWidth.setValue(src.Alignment.PackedMipWidth); + dst.Alignment.PackedMipHeight.setValue(src.Alignment.PackedMipHeight); + dst.Alignment.QPitch.setValue(src.Alignment.QPitch); + WCH_SAFE_COPY(dst.MmcMode.getValue(), dst.MmcMode.getValueSizeInBytes(), src.MmcMode, sizeof(src.MmcMode)); + WCH_SAFE_COPY(dst.MmcHint.getValue(), dst.MmcHint.getValueSizeInBytes(), src.MmcHint, sizeof(src.MmcHint)); + dst.Pitch.setValue(src.Pitch); + dst.OverridePitch.setValue(src.OverridePitch); + dst.Size.setValue(src.Size); + dst.CCSize.setValue(src.CCSize); + dst.UnpaddedSize.setValue(src.UnpaddedSize); + dst.SizeReportToOS.setValue(src.SizeReportToOS); + dst.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch.setValue(src.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch); + WCH_SAFE_COPY(dst.OffsetInfo.Texture3DOffsetInfo.Offset.getValue(), dst.OffsetInfo.Texture3DOffsetInfo.Offset.getValueSizeInBytes(), src.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(src.OffsetInfo.Texture3DOffsetInfo.Offset)); + dst.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock.setValue(src.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock); + dst.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender.setValue(src.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender); + WCH_SAFE_COPY(dst.OffsetInfo.Texture2DOffsetInfo.Offset.getValue(), dst.OffsetInfo.Texture2DOffsetInfo.Offset.getValueSizeInBytes(), src.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(src.OffsetInfo.Texture2DOffsetInfo.Offset)); + dst.OffsetInfo.Plane.ArrayQPitch.setValue(src.OffsetInfo.Plane.ArrayQPitch); + WCH_SAFE_COPY(dst.OffsetInfo.Plane.X.getValue(), dst.OffsetInfo.Plane.X.getValueSizeInBytes(), src.OffsetInfo.Plane.X, sizeof(src.OffsetInfo.Plane.X)); + WCH_SAFE_COPY(dst.OffsetInfo.Plane.Y.getValue(), dst.OffsetInfo.Plane.Y.getValueSizeInBytes(), src.OffsetInfo.Plane.Y, sizeof(src.OffsetInfo.Plane.Y)); + WCH_SAFE_COPY(dst.OffsetInfo.Plane.UnAligned.Height.getValue(), dst.OffsetInfo.Plane.UnAligned.Height.getValueSizeInBytes(), src.OffsetInfo.Plane.UnAligned.Height, sizeof(src.OffsetInfo.Plane.UnAligned.Height)); + dst.OffsetInfo.Plane.NoOfPlanes.setValue(src.OffsetInfo.Plane.NoOfPlanes); + dst.OffsetInfo.Plane.IsTileAlignedPlanes.setValue(src.OffsetInfo.Plane.IsTileAlignedPlanes); + dst.TileMode.setValue(src.TileMode); + dst.CCSModeAlign.setValue(src.CCSModeAlign); + dst.LegacyFlags.setValue(src.LegacyFlags); + dst.S3d.DisplayModeHeight.setValue(src.S3d.DisplayModeHeight); + dst.S3d.NumBlankActiveLines.setValue(src.S3d.NumBlankActiveLines); + dst.S3d.RFrameOffset.setValue(src.S3d.RFrameOffset); + dst.S3d.BlankAreaOffset.setValue(src.S3d.BlankAreaOffset); + dst.S3d.TallBufferHeight.setValue(src.S3d.TallBufferHeight); + dst.S3d.TallBufferSize.setValue(src.S3d.TallBufferSize); + dst.S3d.IsRFrame.setValue(src.S3d.IsRFrame); + dst.SegmentOverride.Seg1.setValue(src.SegmentOverride.Seg1); + dst.SegmentOverride.Evict.setValue(src.SegmentOverride.Evict); + dst.MaximumRenamingListLength.setValue(src.MaximumRenamingListLength); +#if _DEBUG || _RELEASE_INTERNAL + dst.Platform.eProductFamily.setValue(src.Platform.eProductFamily); + dst.Platform.ePCHProductFamily.setValue(src.Platform.ePCHProductFamily); + dst.Platform.eDisplayCoreFamily.setValue(src.Platform.eDisplayCoreFamily); + dst.Platform.eRenderCoreFamily.setValue(src.Platform.eRenderCoreFamily); + dst.Platform.ePlatformType.setValue(src.Platform.ePlatformType); + dst.Platform.usDeviceID.setValue(src.Platform.usDeviceID); + dst.Platform.usRevId.setValue(src.Platform.usRevId); + dst.Platform.usDeviceID_PCH.setValue(src.Platform.usDeviceID_PCH); + dst.Platform.usRevId_PCH.setValue(src.Platform.usRevId_PCH); + dst.Platform.eGTType.setValue(src.Platform.eGTType); +#endif + dst.ExistingSysMem.IsGmmAllocated.setValue(src.ExistingSysMem.IsGmmAllocated); + dst.ExistingSysMem.IsPageAligned.setValue(src.ExistingSysMem.IsPageAligned); +#if !(_DEBUG || _RELEASE_INTERNAL) + dst.__Platform.eProductFamily.setValue(src.__Platform.eProductFamily); + dst.__Platform.ePCHProductFamily.setValue(src.__Platform.ePCHProductFamily); + dst.__Platform.eDisplayCoreFamily.setValue(src.__Platform.eDisplayCoreFamily); + dst.__Platform.eRenderCoreFamily.setValue(src.__Platform.eRenderCoreFamily); + dst.__Platform.ePlatformType.setValue(src.__Platform.ePlatformType); + dst.__Platform.usDeviceID.setValue(src.__Platform.usDeviceID); + dst.__Platform.usRevId.setValue(src.__Platform.usRevId); + dst.__Platform.usDeviceID_PCH.setValue(src.__Platform.usDeviceID_PCH); + dst.__Platform.usRevId_PCH.setValue(src.__Platform.usRevId_PCH); + dst.__Platform.eGTType.setValue(src.__Platform.eGTType); +#endif +} +template <> +struct Marshaller { + template + static TOKSTR_GMM_TEXTURE_INFO_REC marshall(const GMM_TEXTURE_INFO_RECT &src) { + TOKSTR_GMM_TEXTURE_INFO_REC ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_GMM_EXISTING_SYS_MEM_REC &dst, const GMM_EXISTING_SYS_MEM_RECT &src) { + dst = {}; + dst.pExistingSysMem.setValue(src.pExistingSysMem); + dst.pVirtAddress.setValue(src.pVirtAddress); + dst.pGfxAlignedVirtAddress.setValue(src.pGfxAlignedVirtAddress); + dst.Size.setValue(src.Size); + dst.IsGmmAllocated.setValue(src.IsGmmAllocated); +} +template <> +struct Marshaller { + template + static TOKSTR_GMM_EXISTING_SYS_MEM_REC marshall(const GMM_EXISTING_SYS_MEM_RECT &src) { + TOKSTR_GMM_EXISTING_SYS_MEM_REC ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_GmmResourceInfoCommonStruct &dst, const GmmResourceInfoCommonStructT &src) { + dst = {}; + dst.ClientType.setValue(src.ClientType); + dst.Surf.Type.setValue(src.Surf.Type); + dst.Surf.Format.setValue(src.Surf.Format); + dst.Surf.BitsPerPixel.setValue(src.Surf.BitsPerPixel); + dst.Surf.Flags.Gpu.CameraCapture.setValue(src.Surf.Flags.Gpu.CameraCapture); + dst.Surf.Flags.Gpu.CCS.setValue(src.Surf.Flags.Gpu.CCS); + dst.Surf.Flags.Gpu.ColorDiscard.setValue(src.Surf.Flags.Gpu.ColorDiscard); + dst.Surf.Flags.Gpu.ColorSeparation.setValue(src.Surf.Flags.Gpu.ColorSeparation); + dst.Surf.Flags.Gpu.ColorSeparationRGBX.setValue(src.Surf.Flags.Gpu.ColorSeparationRGBX); + dst.Surf.Flags.Gpu.Constant.setValue(src.Surf.Flags.Gpu.Constant); + dst.Surf.Flags.Gpu.Depth.setValue(src.Surf.Flags.Gpu.Depth); + dst.Surf.Flags.Gpu.FlipChain.setValue(src.Surf.Flags.Gpu.FlipChain); + dst.Surf.Flags.Gpu.FlipChainPreferred.setValue(src.Surf.Flags.Gpu.FlipChainPreferred); + dst.Surf.Flags.Gpu.HistoryBuffer.setValue(src.Surf.Flags.Gpu.HistoryBuffer); + dst.Surf.Flags.Gpu.HiZ.setValue(src.Surf.Flags.Gpu.HiZ); + dst.Surf.Flags.Gpu.Index.setValue(src.Surf.Flags.Gpu.Index); + dst.Surf.Flags.Gpu.IndirectClearColor.setValue(src.Surf.Flags.Gpu.IndirectClearColor); + dst.Surf.Flags.Gpu.InstructionFlat.setValue(src.Surf.Flags.Gpu.InstructionFlat); + dst.Surf.Flags.Gpu.InterlacedScan.setValue(src.Surf.Flags.Gpu.InterlacedScan); + dst.Surf.Flags.Gpu.MCS.setValue(src.Surf.Flags.Gpu.MCS); + dst.Surf.Flags.Gpu.MMC.setValue(src.Surf.Flags.Gpu.MMC); + dst.Surf.Flags.Gpu.MotionComp.setValue(src.Surf.Flags.Gpu.MotionComp); + dst.Surf.Flags.Gpu.NoRestriction.setValue(src.Surf.Flags.Gpu.NoRestriction); + dst.Surf.Flags.Gpu.Overlay.setValue(src.Surf.Flags.Gpu.Overlay); + dst.Surf.Flags.Gpu.Presentable.setValue(src.Surf.Flags.Gpu.Presentable); + dst.Surf.Flags.Gpu.ProceduralTexture.setValue(src.Surf.Flags.Gpu.ProceduralTexture); + dst.Surf.Flags.Gpu.Query.setValue(src.Surf.Flags.Gpu.Query); + dst.Surf.Flags.Gpu.RenderTarget.setValue(src.Surf.Flags.Gpu.RenderTarget); + dst.Surf.Flags.Gpu.S3d.setValue(src.Surf.Flags.Gpu.S3d); + dst.Surf.Flags.Gpu.S3dDx.setValue(src.Surf.Flags.Gpu.S3dDx); + dst.Surf.Flags.Gpu.__S3dNonPacked.setValue(src.Surf.Flags.Gpu.__S3dNonPacked); + dst.Surf.Flags.Gpu.__S3dWidi.setValue(src.Surf.Flags.Gpu.__S3dWidi); + dst.Surf.Flags.Gpu.ScratchFlat.setValue(src.Surf.Flags.Gpu.ScratchFlat); + dst.Surf.Flags.Gpu.SeparateStencil.setValue(src.Surf.Flags.Gpu.SeparateStencil); + dst.Surf.Flags.Gpu.State.setValue(src.Surf.Flags.Gpu.State); + dst.Surf.Flags.Gpu.StateDx9ConstantBuffer.setValue(src.Surf.Flags.Gpu.StateDx9ConstantBuffer); + dst.Surf.Flags.Gpu.Stream.setValue(src.Surf.Flags.Gpu.Stream); + dst.Surf.Flags.Gpu.TextApi.setValue(src.Surf.Flags.Gpu.TextApi); + dst.Surf.Flags.Gpu.Texture.setValue(src.Surf.Flags.Gpu.Texture); + dst.Surf.Flags.Gpu.TiledResource.setValue(src.Surf.Flags.Gpu.TiledResource); + dst.Surf.Flags.Gpu.TilePool.setValue(src.Surf.Flags.Gpu.TilePool); + dst.Surf.Flags.Gpu.UnifiedAuxSurface.setValue(src.Surf.Flags.Gpu.UnifiedAuxSurface); + dst.Surf.Flags.Gpu.Vertex.setValue(src.Surf.Flags.Gpu.Vertex); + dst.Surf.Flags.Gpu.Video.setValue(src.Surf.Flags.Gpu.Video); + dst.Surf.Flags.Gpu.__NonMsaaTileXCcs.setValue(src.Surf.Flags.Gpu.__NonMsaaTileXCcs); + dst.Surf.Flags.Gpu.__NonMsaaTileYCcs.setValue(src.Surf.Flags.Gpu.__NonMsaaTileYCcs); + dst.Surf.Flags.Gpu.__MsaaTileMcs.setValue(src.Surf.Flags.Gpu.__MsaaTileMcs); + dst.Surf.Flags.Gpu.__NonMsaaLinearCCS.setValue(src.Surf.Flags.Gpu.__NonMsaaLinearCCS); + dst.Surf.Flags.Gpu.__Remaining.setValue(src.Surf.Flags.Gpu.__Remaining); + dst.Surf.Flags.Info.AllowVirtualPadding.setValue(src.Surf.Flags.Info.AllowVirtualPadding); + dst.Surf.Flags.Info.BigPage.setValue(src.Surf.Flags.Info.BigPage); + dst.Surf.Flags.Info.Cacheable.setValue(src.Surf.Flags.Info.Cacheable); + dst.Surf.Flags.Info.ContigPhysMemoryForiDART.setValue(src.Surf.Flags.Info.ContigPhysMemoryForiDART); + dst.Surf.Flags.Info.CornerTexelMode.setValue(src.Surf.Flags.Info.CornerTexelMode); + dst.Surf.Flags.Info.ExistingSysMem.setValue(src.Surf.Flags.Info.ExistingSysMem); + dst.Surf.Flags.Info.ForceResidency.setValue(src.Surf.Flags.Info.ForceResidency); + dst.Surf.Flags.Info.Gfdt.setValue(src.Surf.Flags.Info.Gfdt); + dst.Surf.Flags.Info.GttMapType.setValue(src.Surf.Flags.Info.GttMapType); + dst.Surf.Flags.Info.HardwareProtected.setValue(src.Surf.Flags.Info.HardwareProtected); + dst.Surf.Flags.Info.KernelModeMapped.setValue(src.Surf.Flags.Info.KernelModeMapped); + dst.Surf.Flags.Info.LayoutBelow.setValue(src.Surf.Flags.Info.LayoutBelow); + dst.Surf.Flags.Info.LayoutMono.setValue(src.Surf.Flags.Info.LayoutMono); + dst.Surf.Flags.Info.LayoutRight.setValue(src.Surf.Flags.Info.LayoutRight); + dst.Surf.Flags.Info.LocalOnly.setValue(src.Surf.Flags.Info.LocalOnly); + dst.Surf.Flags.Info.Linear.setValue(src.Surf.Flags.Info.Linear); + dst.Surf.Flags.Info.MediaCompressed.setValue(src.Surf.Flags.Info.MediaCompressed); + dst.Surf.Flags.Info.NoOptimizationPadding.setValue(src.Surf.Flags.Info.NoOptimizationPadding); + dst.Surf.Flags.Info.NoPhysMemory.setValue(src.Surf.Flags.Info.NoPhysMemory); + dst.Surf.Flags.Info.NotLockable.setValue(src.Surf.Flags.Info.NotLockable); + dst.Surf.Flags.Info.NonLocalOnly.setValue(src.Surf.Flags.Info.NonLocalOnly); + dst.Surf.Flags.Info.StdSwizzle.setValue(src.Surf.Flags.Info.StdSwizzle); + dst.Surf.Flags.Info.PseudoStdSwizzle.setValue(src.Surf.Flags.Info.PseudoStdSwizzle); + dst.Surf.Flags.Info.Undefined64KBSwizzle.setValue(src.Surf.Flags.Info.Undefined64KBSwizzle); + dst.Surf.Flags.Info.RedecribedPlanes.setValue(src.Surf.Flags.Info.RedecribedPlanes); + dst.Surf.Flags.Info.RenderCompressed.setValue(src.Surf.Flags.Info.RenderCompressed); + dst.Surf.Flags.Info.Rotated.setValue(src.Surf.Flags.Info.Rotated); + dst.Surf.Flags.Info.Shared.setValue(src.Surf.Flags.Info.Shared); + dst.Surf.Flags.Info.SoftwareProtected.setValue(src.Surf.Flags.Info.SoftwareProtected); + dst.Surf.Flags.Info.SVM.setValue(src.Surf.Flags.Info.SVM); + dst.Surf.Flags.Info.Tile4.setValue(src.Surf.Flags.Info.Tile4); + dst.Surf.Flags.Info.Tile64.setValue(src.Surf.Flags.Info.Tile64); + dst.Surf.Flags.Info.TiledW.setValue(src.Surf.Flags.Info.TiledW); + dst.Surf.Flags.Info.TiledX.setValue(src.Surf.Flags.Info.TiledX); + dst.Surf.Flags.Info.TiledY.setValue(src.Surf.Flags.Info.TiledY); + dst.Surf.Flags.Info.TiledYf.setValue(src.Surf.Flags.Info.TiledYf); + dst.Surf.Flags.Info.TiledYs.setValue(src.Surf.Flags.Info.TiledYs); + dst.Surf.Flags.Info.WddmProtected.setValue(src.Surf.Flags.Info.WddmProtected); + dst.Surf.Flags.Info.XAdapter.setValue(src.Surf.Flags.Info.XAdapter); + dst.Surf.Flags.Info.__PreallocatedResInfo.setValue(src.Surf.Flags.Info.__PreallocatedResInfo); + dst.Surf.Flags.Info.__PreWddm2SVM.setValue(src.Surf.Flags.Info.__PreWddm2SVM); + dst.Surf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign.setValue(src.Surf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign); + dst.Surf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign.setValue(src.Surf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign); + dst.Surf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign.setValue(src.Surf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign); + dst.Surf.Flags.Wa.NoBufferSamplerPadding.setValue(src.Surf.Flags.Wa.NoBufferSamplerPadding); + dst.Surf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions.setValue(src.Surf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions); + dst.Surf.Flags.Wa.CHVAstcSkipVirtualMips.setValue(src.Surf.Flags.Wa.CHVAstcSkipVirtualMips); + dst.Surf.Flags.Wa.DisablePackedMipTail.setValue(src.Surf.Flags.Wa.DisablePackedMipTail); + dst.Surf.Flags.Wa.__ForceOtherHVALIGN4.setValue(src.Surf.Flags.Wa.__ForceOtherHVALIGN4); + dst.Surf.Flags.Wa.DisableDisplayCcsClearColor.setValue(src.Surf.Flags.Wa.DisableDisplayCcsClearColor); + dst.Surf.Flags.Wa.DisableDisplayCcsCompression.setValue(src.Surf.Flags.Wa.DisableDisplayCcsCompression); + dst.Surf.Flags.Wa.PreGen12FastClearOnly.setValue(src.Surf.Flags.Wa.PreGen12FastClearOnly); + dst.Surf.BaseWidth.setValue(src.Surf.BaseWidth); + dst.Surf.BaseHeight.setValue(src.Surf.BaseHeight); + dst.Surf.Depth.setValue(src.Surf.Depth); + dst.Surf.MaxLod.setValue(src.Surf.MaxLod); + dst.Surf.ArraySize.setValue(src.Surf.ArraySize); + dst.Surf.CpTag.setValue(src.Surf.CpTag); + dst.Surf.CachePolicy.Usage.setValue(src.Surf.CachePolicy.Usage); + dst.Surf.MSAA.SamplePattern.setValue(src.Surf.MSAA.SamplePattern); + dst.Surf.MSAA.NumSamples.setValue(src.Surf.MSAA.NumSamples); + dst.Surf.Alignment.ArraySpacingSingleLod.setValue(src.Surf.Alignment.ArraySpacingSingleLod); + dst.Surf.Alignment.BaseAlignment.setValue(src.Surf.Alignment.BaseAlignment); + dst.Surf.Alignment.HAlign.setValue(src.Surf.Alignment.HAlign); + dst.Surf.Alignment.VAlign.setValue(src.Surf.Alignment.VAlign); + dst.Surf.Alignment.DAlign.setValue(src.Surf.Alignment.DAlign); + dst.Surf.Alignment.MipTailStartLod.setValue(src.Surf.Alignment.MipTailStartLod); + dst.Surf.Alignment.PackedMipStartLod.setValue(src.Surf.Alignment.PackedMipStartLod); + dst.Surf.Alignment.PackedMipWidth.setValue(src.Surf.Alignment.PackedMipWidth); + dst.Surf.Alignment.PackedMipHeight.setValue(src.Surf.Alignment.PackedMipHeight); + dst.Surf.Alignment.QPitch.setValue(src.Surf.Alignment.QPitch); + WCH_SAFE_COPY(dst.Surf.MmcMode.getValue(), dst.Surf.MmcMode.getValueSizeInBytes(), src.Surf.MmcMode, sizeof(src.Surf.MmcMode)); + WCH_SAFE_COPY(dst.Surf.MmcHint.getValue(), dst.Surf.MmcHint.getValueSizeInBytes(), src.Surf.MmcHint, sizeof(src.Surf.MmcHint)); + dst.Surf.Pitch.setValue(src.Surf.Pitch); + dst.Surf.OverridePitch.setValue(src.Surf.OverridePitch); + dst.Surf.Size.setValue(src.Surf.Size); + dst.Surf.CCSize.setValue(src.Surf.CCSize); + dst.Surf.UnpaddedSize.setValue(src.Surf.UnpaddedSize); + dst.Surf.SizeReportToOS.setValue(src.Surf.SizeReportToOS); + dst.Surf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch.setValue(src.Surf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch); + WCH_SAFE_COPY(dst.Surf.OffsetInfo.Texture3DOffsetInfo.Offset.getValue(), dst.Surf.OffsetInfo.Texture3DOffsetInfo.Offset.getValueSizeInBytes(), src.Surf.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(src.Surf.OffsetInfo.Texture3DOffsetInfo.Offset)); + dst.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock.setValue(src.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock); + dst.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender.setValue(src.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender); + WCH_SAFE_COPY(dst.Surf.OffsetInfo.Texture2DOffsetInfo.Offset.getValue(), dst.Surf.OffsetInfo.Texture2DOffsetInfo.Offset.getValueSizeInBytes(), src.Surf.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(src.Surf.OffsetInfo.Texture2DOffsetInfo.Offset)); + dst.Surf.OffsetInfo.Plane.ArrayQPitch.setValue(src.Surf.OffsetInfo.Plane.ArrayQPitch); + WCH_SAFE_COPY(dst.Surf.OffsetInfo.Plane.X.getValue(), dst.Surf.OffsetInfo.Plane.X.getValueSizeInBytes(), src.Surf.OffsetInfo.Plane.X, sizeof(src.Surf.OffsetInfo.Plane.X)); + WCH_SAFE_COPY(dst.Surf.OffsetInfo.Plane.Y.getValue(), dst.Surf.OffsetInfo.Plane.Y.getValueSizeInBytes(), src.Surf.OffsetInfo.Plane.Y, sizeof(src.Surf.OffsetInfo.Plane.Y)); + WCH_SAFE_COPY(dst.Surf.OffsetInfo.Plane.UnAligned.Height.getValue(), dst.Surf.OffsetInfo.Plane.UnAligned.Height.getValueSizeInBytes(), src.Surf.OffsetInfo.Plane.UnAligned.Height, sizeof(src.Surf.OffsetInfo.Plane.UnAligned.Height)); + dst.Surf.OffsetInfo.Plane.NoOfPlanes.setValue(src.Surf.OffsetInfo.Plane.NoOfPlanes); + dst.Surf.OffsetInfo.Plane.IsTileAlignedPlanes.setValue(src.Surf.OffsetInfo.Plane.IsTileAlignedPlanes); + dst.Surf.TileMode.setValue(src.Surf.TileMode); + dst.Surf.CCSModeAlign.setValue(src.Surf.CCSModeAlign); + dst.Surf.LegacyFlags.setValue(src.Surf.LegacyFlags); + dst.Surf.S3d.DisplayModeHeight.setValue(src.Surf.S3d.DisplayModeHeight); + dst.Surf.S3d.NumBlankActiveLines.setValue(src.Surf.S3d.NumBlankActiveLines); + dst.Surf.S3d.RFrameOffset.setValue(src.Surf.S3d.RFrameOffset); + dst.Surf.S3d.BlankAreaOffset.setValue(src.Surf.S3d.BlankAreaOffset); + dst.Surf.S3d.TallBufferHeight.setValue(src.Surf.S3d.TallBufferHeight); + dst.Surf.S3d.TallBufferSize.setValue(src.Surf.S3d.TallBufferSize); + dst.Surf.S3d.IsRFrame.setValue(src.Surf.S3d.IsRFrame); + dst.Surf.SegmentOverride.Seg1.setValue(src.Surf.SegmentOverride.Seg1); + dst.Surf.SegmentOverride.Evict.setValue(src.Surf.SegmentOverride.Evict); + dst.Surf.MaximumRenamingListLength.setValue(src.Surf.MaximumRenamingListLength); +#if _DEBUG || _RELEASE_INTERNAL + dst.Surf.Platform.eProductFamily.setValue(src.Surf.Platform.eProductFamily); + dst.Surf.Platform.ePCHProductFamily.setValue(src.Surf.Platform.ePCHProductFamily); + dst.Surf.Platform.eDisplayCoreFamily.setValue(src.Surf.Platform.eDisplayCoreFamily); + dst.Surf.Platform.eRenderCoreFamily.setValue(src.Surf.Platform.eRenderCoreFamily); + dst.Surf.Platform.ePlatformType.setValue(src.Surf.Platform.ePlatformType); + dst.Surf.Platform.usDeviceID.setValue(src.Surf.Platform.usDeviceID); + dst.Surf.Platform.usRevId.setValue(src.Surf.Platform.usRevId); + dst.Surf.Platform.usDeviceID_PCH.setValue(src.Surf.Platform.usDeviceID_PCH); + dst.Surf.Platform.usRevId_PCH.setValue(src.Surf.Platform.usRevId_PCH); + dst.Surf.Platform.eGTType.setValue(src.Surf.Platform.eGTType); +#endif + dst.Surf.ExistingSysMem.IsGmmAllocated.setValue(src.Surf.ExistingSysMem.IsGmmAllocated); + dst.Surf.ExistingSysMem.IsPageAligned.setValue(src.Surf.ExistingSysMem.IsPageAligned); +#if !(_DEBUG || _RELEASE_INTERNAL) + dst.Surf.__Platform.eProductFamily.setValue(src.Surf.__Platform.eProductFamily); + dst.Surf.__Platform.ePCHProductFamily.setValue(src.Surf.__Platform.ePCHProductFamily); + dst.Surf.__Platform.eDisplayCoreFamily.setValue(src.Surf.__Platform.eDisplayCoreFamily); + dst.Surf.__Platform.eRenderCoreFamily.setValue(src.Surf.__Platform.eRenderCoreFamily); + dst.Surf.__Platform.ePlatformType.setValue(src.Surf.__Platform.ePlatformType); + dst.Surf.__Platform.usDeviceID.setValue(src.Surf.__Platform.usDeviceID); + dst.Surf.__Platform.usRevId.setValue(src.Surf.__Platform.usRevId); + dst.Surf.__Platform.usDeviceID_PCH.setValue(src.Surf.__Platform.usDeviceID_PCH); + dst.Surf.__Platform.usRevId_PCH.setValue(src.Surf.__Platform.usRevId_PCH); + dst.Surf.__Platform.eGTType.setValue(src.Surf.__Platform.eGTType); +#endif + dst.AuxSurf.Type.setValue(src.AuxSurf.Type); + dst.AuxSurf.Format.setValue(src.AuxSurf.Format); + dst.AuxSurf.BitsPerPixel.setValue(src.AuxSurf.BitsPerPixel); + dst.AuxSurf.Flags.Gpu.CameraCapture.setValue(src.AuxSurf.Flags.Gpu.CameraCapture); + dst.AuxSurf.Flags.Gpu.CCS.setValue(src.AuxSurf.Flags.Gpu.CCS); + dst.AuxSurf.Flags.Gpu.ColorDiscard.setValue(src.AuxSurf.Flags.Gpu.ColorDiscard); + dst.AuxSurf.Flags.Gpu.ColorSeparation.setValue(src.AuxSurf.Flags.Gpu.ColorSeparation); + dst.AuxSurf.Flags.Gpu.ColorSeparationRGBX.setValue(src.AuxSurf.Flags.Gpu.ColorSeparationRGBX); + dst.AuxSurf.Flags.Gpu.Constant.setValue(src.AuxSurf.Flags.Gpu.Constant); + dst.AuxSurf.Flags.Gpu.Depth.setValue(src.AuxSurf.Flags.Gpu.Depth); + dst.AuxSurf.Flags.Gpu.FlipChain.setValue(src.AuxSurf.Flags.Gpu.FlipChain); + dst.AuxSurf.Flags.Gpu.FlipChainPreferred.setValue(src.AuxSurf.Flags.Gpu.FlipChainPreferred); + dst.AuxSurf.Flags.Gpu.HistoryBuffer.setValue(src.AuxSurf.Flags.Gpu.HistoryBuffer); + dst.AuxSurf.Flags.Gpu.HiZ.setValue(src.AuxSurf.Flags.Gpu.HiZ); + dst.AuxSurf.Flags.Gpu.Index.setValue(src.AuxSurf.Flags.Gpu.Index); + dst.AuxSurf.Flags.Gpu.IndirectClearColor.setValue(src.AuxSurf.Flags.Gpu.IndirectClearColor); + dst.AuxSurf.Flags.Gpu.InstructionFlat.setValue(src.AuxSurf.Flags.Gpu.InstructionFlat); + dst.AuxSurf.Flags.Gpu.InterlacedScan.setValue(src.AuxSurf.Flags.Gpu.InterlacedScan); + dst.AuxSurf.Flags.Gpu.MCS.setValue(src.AuxSurf.Flags.Gpu.MCS); + dst.AuxSurf.Flags.Gpu.MMC.setValue(src.AuxSurf.Flags.Gpu.MMC); + dst.AuxSurf.Flags.Gpu.MotionComp.setValue(src.AuxSurf.Flags.Gpu.MotionComp); + dst.AuxSurf.Flags.Gpu.NoRestriction.setValue(src.AuxSurf.Flags.Gpu.NoRestriction); + dst.AuxSurf.Flags.Gpu.Overlay.setValue(src.AuxSurf.Flags.Gpu.Overlay); + dst.AuxSurf.Flags.Gpu.Presentable.setValue(src.AuxSurf.Flags.Gpu.Presentable); + dst.AuxSurf.Flags.Gpu.ProceduralTexture.setValue(src.AuxSurf.Flags.Gpu.ProceduralTexture); + dst.AuxSurf.Flags.Gpu.Query.setValue(src.AuxSurf.Flags.Gpu.Query); + dst.AuxSurf.Flags.Gpu.RenderTarget.setValue(src.AuxSurf.Flags.Gpu.RenderTarget); + dst.AuxSurf.Flags.Gpu.S3d.setValue(src.AuxSurf.Flags.Gpu.S3d); + dst.AuxSurf.Flags.Gpu.S3dDx.setValue(src.AuxSurf.Flags.Gpu.S3dDx); + dst.AuxSurf.Flags.Gpu.__S3dNonPacked.setValue(src.AuxSurf.Flags.Gpu.__S3dNonPacked); + dst.AuxSurf.Flags.Gpu.__S3dWidi.setValue(src.AuxSurf.Flags.Gpu.__S3dWidi); + dst.AuxSurf.Flags.Gpu.ScratchFlat.setValue(src.AuxSurf.Flags.Gpu.ScratchFlat); + dst.AuxSurf.Flags.Gpu.SeparateStencil.setValue(src.AuxSurf.Flags.Gpu.SeparateStencil); + dst.AuxSurf.Flags.Gpu.State.setValue(src.AuxSurf.Flags.Gpu.State); + dst.AuxSurf.Flags.Gpu.StateDx9ConstantBuffer.setValue(src.AuxSurf.Flags.Gpu.StateDx9ConstantBuffer); + dst.AuxSurf.Flags.Gpu.Stream.setValue(src.AuxSurf.Flags.Gpu.Stream); + dst.AuxSurf.Flags.Gpu.TextApi.setValue(src.AuxSurf.Flags.Gpu.TextApi); + dst.AuxSurf.Flags.Gpu.Texture.setValue(src.AuxSurf.Flags.Gpu.Texture); + dst.AuxSurf.Flags.Gpu.TiledResource.setValue(src.AuxSurf.Flags.Gpu.TiledResource); + dst.AuxSurf.Flags.Gpu.TilePool.setValue(src.AuxSurf.Flags.Gpu.TilePool); + dst.AuxSurf.Flags.Gpu.UnifiedAuxSurface.setValue(src.AuxSurf.Flags.Gpu.UnifiedAuxSurface); + dst.AuxSurf.Flags.Gpu.Vertex.setValue(src.AuxSurf.Flags.Gpu.Vertex); + dst.AuxSurf.Flags.Gpu.Video.setValue(src.AuxSurf.Flags.Gpu.Video); + dst.AuxSurf.Flags.Gpu.__NonMsaaTileXCcs.setValue(src.AuxSurf.Flags.Gpu.__NonMsaaTileXCcs); + dst.AuxSurf.Flags.Gpu.__NonMsaaTileYCcs.setValue(src.AuxSurf.Flags.Gpu.__NonMsaaTileYCcs); + dst.AuxSurf.Flags.Gpu.__MsaaTileMcs.setValue(src.AuxSurf.Flags.Gpu.__MsaaTileMcs); + dst.AuxSurf.Flags.Gpu.__NonMsaaLinearCCS.setValue(src.AuxSurf.Flags.Gpu.__NonMsaaLinearCCS); + dst.AuxSurf.Flags.Gpu.__Remaining.setValue(src.AuxSurf.Flags.Gpu.__Remaining); + dst.AuxSurf.Flags.Info.AllowVirtualPadding.setValue(src.AuxSurf.Flags.Info.AllowVirtualPadding); + dst.AuxSurf.Flags.Info.BigPage.setValue(src.AuxSurf.Flags.Info.BigPage); + dst.AuxSurf.Flags.Info.Cacheable.setValue(src.AuxSurf.Flags.Info.Cacheable); + dst.AuxSurf.Flags.Info.ContigPhysMemoryForiDART.setValue(src.AuxSurf.Flags.Info.ContigPhysMemoryForiDART); + dst.AuxSurf.Flags.Info.CornerTexelMode.setValue(src.AuxSurf.Flags.Info.CornerTexelMode); + dst.AuxSurf.Flags.Info.ExistingSysMem.setValue(src.AuxSurf.Flags.Info.ExistingSysMem); + dst.AuxSurf.Flags.Info.ForceResidency.setValue(src.AuxSurf.Flags.Info.ForceResidency); + dst.AuxSurf.Flags.Info.Gfdt.setValue(src.AuxSurf.Flags.Info.Gfdt); + dst.AuxSurf.Flags.Info.GttMapType.setValue(src.AuxSurf.Flags.Info.GttMapType); + dst.AuxSurf.Flags.Info.HardwareProtected.setValue(src.AuxSurf.Flags.Info.HardwareProtected); + dst.AuxSurf.Flags.Info.KernelModeMapped.setValue(src.AuxSurf.Flags.Info.KernelModeMapped); + dst.AuxSurf.Flags.Info.LayoutBelow.setValue(src.AuxSurf.Flags.Info.LayoutBelow); + dst.AuxSurf.Flags.Info.LayoutMono.setValue(src.AuxSurf.Flags.Info.LayoutMono); + dst.AuxSurf.Flags.Info.LayoutRight.setValue(src.AuxSurf.Flags.Info.LayoutRight); + dst.AuxSurf.Flags.Info.LocalOnly.setValue(src.AuxSurf.Flags.Info.LocalOnly); + dst.AuxSurf.Flags.Info.Linear.setValue(src.AuxSurf.Flags.Info.Linear); + dst.AuxSurf.Flags.Info.MediaCompressed.setValue(src.AuxSurf.Flags.Info.MediaCompressed); + dst.AuxSurf.Flags.Info.NoOptimizationPadding.setValue(src.AuxSurf.Flags.Info.NoOptimizationPadding); + dst.AuxSurf.Flags.Info.NoPhysMemory.setValue(src.AuxSurf.Flags.Info.NoPhysMemory); + dst.AuxSurf.Flags.Info.NotLockable.setValue(src.AuxSurf.Flags.Info.NotLockable); + dst.AuxSurf.Flags.Info.NonLocalOnly.setValue(src.AuxSurf.Flags.Info.NonLocalOnly); + dst.AuxSurf.Flags.Info.StdSwizzle.setValue(src.AuxSurf.Flags.Info.StdSwizzle); + dst.AuxSurf.Flags.Info.PseudoStdSwizzle.setValue(src.AuxSurf.Flags.Info.PseudoStdSwizzle); + dst.AuxSurf.Flags.Info.Undefined64KBSwizzle.setValue(src.AuxSurf.Flags.Info.Undefined64KBSwizzle); + dst.AuxSurf.Flags.Info.RedecribedPlanes.setValue(src.AuxSurf.Flags.Info.RedecribedPlanes); + dst.AuxSurf.Flags.Info.RenderCompressed.setValue(src.AuxSurf.Flags.Info.RenderCompressed); + dst.AuxSurf.Flags.Info.Rotated.setValue(src.AuxSurf.Flags.Info.Rotated); + dst.AuxSurf.Flags.Info.Shared.setValue(src.AuxSurf.Flags.Info.Shared); + dst.AuxSurf.Flags.Info.SoftwareProtected.setValue(src.AuxSurf.Flags.Info.SoftwareProtected); + dst.AuxSurf.Flags.Info.SVM.setValue(src.AuxSurf.Flags.Info.SVM); + dst.AuxSurf.Flags.Info.Tile4.setValue(src.AuxSurf.Flags.Info.Tile4); + dst.AuxSurf.Flags.Info.Tile64.setValue(src.AuxSurf.Flags.Info.Tile64); + dst.AuxSurf.Flags.Info.TiledW.setValue(src.AuxSurf.Flags.Info.TiledW); + dst.AuxSurf.Flags.Info.TiledX.setValue(src.AuxSurf.Flags.Info.TiledX); + dst.AuxSurf.Flags.Info.TiledY.setValue(src.AuxSurf.Flags.Info.TiledY); + dst.AuxSurf.Flags.Info.TiledYf.setValue(src.AuxSurf.Flags.Info.TiledYf); + dst.AuxSurf.Flags.Info.TiledYs.setValue(src.AuxSurf.Flags.Info.TiledYs); + dst.AuxSurf.Flags.Info.WddmProtected.setValue(src.AuxSurf.Flags.Info.WddmProtected); + dst.AuxSurf.Flags.Info.XAdapter.setValue(src.AuxSurf.Flags.Info.XAdapter); + dst.AuxSurf.Flags.Info.__PreallocatedResInfo.setValue(src.AuxSurf.Flags.Info.__PreallocatedResInfo); + dst.AuxSurf.Flags.Info.__PreWddm2SVM.setValue(src.AuxSurf.Flags.Info.__PreWddm2SVM); + dst.AuxSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign.setValue(src.AuxSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign); + dst.AuxSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign.setValue(src.AuxSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign); + dst.AuxSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign.setValue(src.AuxSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign); + dst.AuxSurf.Flags.Wa.NoBufferSamplerPadding.setValue(src.AuxSurf.Flags.Wa.NoBufferSamplerPadding); + dst.AuxSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions.setValue(src.AuxSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions); + dst.AuxSurf.Flags.Wa.CHVAstcSkipVirtualMips.setValue(src.AuxSurf.Flags.Wa.CHVAstcSkipVirtualMips); + dst.AuxSurf.Flags.Wa.DisablePackedMipTail.setValue(src.AuxSurf.Flags.Wa.DisablePackedMipTail); + dst.AuxSurf.Flags.Wa.__ForceOtherHVALIGN4.setValue(src.AuxSurf.Flags.Wa.__ForceOtherHVALIGN4); + dst.AuxSurf.Flags.Wa.DisableDisplayCcsClearColor.setValue(src.AuxSurf.Flags.Wa.DisableDisplayCcsClearColor); + dst.AuxSurf.Flags.Wa.DisableDisplayCcsCompression.setValue(src.AuxSurf.Flags.Wa.DisableDisplayCcsCompression); + dst.AuxSurf.Flags.Wa.PreGen12FastClearOnly.setValue(src.AuxSurf.Flags.Wa.PreGen12FastClearOnly); + dst.AuxSurf.BaseWidth.setValue(src.AuxSurf.BaseWidth); + dst.AuxSurf.BaseHeight.setValue(src.AuxSurf.BaseHeight); + dst.AuxSurf.Depth.setValue(src.AuxSurf.Depth); + dst.AuxSurf.MaxLod.setValue(src.AuxSurf.MaxLod); + dst.AuxSurf.ArraySize.setValue(src.AuxSurf.ArraySize); + dst.AuxSurf.CpTag.setValue(src.AuxSurf.CpTag); + dst.AuxSurf.CachePolicy.Usage.setValue(src.AuxSurf.CachePolicy.Usage); + dst.AuxSurf.MSAA.SamplePattern.setValue(src.AuxSurf.MSAA.SamplePattern); + dst.AuxSurf.MSAA.NumSamples.setValue(src.AuxSurf.MSAA.NumSamples); + dst.AuxSurf.Alignment.ArraySpacingSingleLod.setValue(src.AuxSurf.Alignment.ArraySpacingSingleLod); + dst.AuxSurf.Alignment.BaseAlignment.setValue(src.AuxSurf.Alignment.BaseAlignment); + dst.AuxSurf.Alignment.HAlign.setValue(src.AuxSurf.Alignment.HAlign); + dst.AuxSurf.Alignment.VAlign.setValue(src.AuxSurf.Alignment.VAlign); + dst.AuxSurf.Alignment.DAlign.setValue(src.AuxSurf.Alignment.DAlign); + dst.AuxSurf.Alignment.MipTailStartLod.setValue(src.AuxSurf.Alignment.MipTailStartLod); + dst.AuxSurf.Alignment.PackedMipStartLod.setValue(src.AuxSurf.Alignment.PackedMipStartLod); + dst.AuxSurf.Alignment.PackedMipWidth.setValue(src.AuxSurf.Alignment.PackedMipWidth); + dst.AuxSurf.Alignment.PackedMipHeight.setValue(src.AuxSurf.Alignment.PackedMipHeight); + dst.AuxSurf.Alignment.QPitch.setValue(src.AuxSurf.Alignment.QPitch); + WCH_SAFE_COPY(dst.AuxSurf.MmcMode.getValue(), dst.AuxSurf.MmcMode.getValueSizeInBytes(), src.AuxSurf.MmcMode, sizeof(src.AuxSurf.MmcMode)); + WCH_SAFE_COPY(dst.AuxSurf.MmcHint.getValue(), dst.AuxSurf.MmcHint.getValueSizeInBytes(), src.AuxSurf.MmcHint, sizeof(src.AuxSurf.MmcHint)); + dst.AuxSurf.Pitch.setValue(src.AuxSurf.Pitch); + dst.AuxSurf.OverridePitch.setValue(src.AuxSurf.OverridePitch); + dst.AuxSurf.Size.setValue(src.AuxSurf.Size); + dst.AuxSurf.CCSize.setValue(src.AuxSurf.CCSize); + dst.AuxSurf.UnpaddedSize.setValue(src.AuxSurf.UnpaddedSize); + dst.AuxSurf.SizeReportToOS.setValue(src.AuxSurf.SizeReportToOS); + dst.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch.setValue(src.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch); + WCH_SAFE_COPY(dst.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset.getValue(), dst.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset.getValueSizeInBytes(), src.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(src.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset)); + dst.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock.setValue(src.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock); + dst.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender.setValue(src.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender); + WCH_SAFE_COPY(dst.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset.getValue(), dst.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset.getValueSizeInBytes(), src.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(src.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset)); + dst.AuxSurf.OffsetInfo.Plane.ArrayQPitch.setValue(src.AuxSurf.OffsetInfo.Plane.ArrayQPitch); + WCH_SAFE_COPY(dst.AuxSurf.OffsetInfo.Plane.X.getValue(), dst.AuxSurf.OffsetInfo.Plane.X.getValueSizeInBytes(), src.AuxSurf.OffsetInfo.Plane.X, sizeof(src.AuxSurf.OffsetInfo.Plane.X)); + WCH_SAFE_COPY(dst.AuxSurf.OffsetInfo.Plane.Y.getValue(), dst.AuxSurf.OffsetInfo.Plane.Y.getValueSizeInBytes(), src.AuxSurf.OffsetInfo.Plane.Y, sizeof(src.AuxSurf.OffsetInfo.Plane.Y)); + WCH_SAFE_COPY(dst.AuxSurf.OffsetInfo.Plane.UnAligned.Height.getValue(), dst.AuxSurf.OffsetInfo.Plane.UnAligned.Height.getValueSizeInBytes(), src.AuxSurf.OffsetInfo.Plane.UnAligned.Height, sizeof(src.AuxSurf.OffsetInfo.Plane.UnAligned.Height)); + dst.AuxSurf.OffsetInfo.Plane.NoOfPlanes.setValue(src.AuxSurf.OffsetInfo.Plane.NoOfPlanes); + dst.AuxSurf.OffsetInfo.Plane.IsTileAlignedPlanes.setValue(src.AuxSurf.OffsetInfo.Plane.IsTileAlignedPlanes); + dst.AuxSurf.TileMode.setValue(src.AuxSurf.TileMode); + dst.AuxSurf.CCSModeAlign.setValue(src.AuxSurf.CCSModeAlign); + dst.AuxSurf.LegacyFlags.setValue(src.AuxSurf.LegacyFlags); + dst.AuxSurf.S3d.DisplayModeHeight.setValue(src.AuxSurf.S3d.DisplayModeHeight); + dst.AuxSurf.S3d.NumBlankActiveLines.setValue(src.AuxSurf.S3d.NumBlankActiveLines); + dst.AuxSurf.S3d.RFrameOffset.setValue(src.AuxSurf.S3d.RFrameOffset); + dst.AuxSurf.S3d.BlankAreaOffset.setValue(src.AuxSurf.S3d.BlankAreaOffset); + dst.AuxSurf.S3d.TallBufferHeight.setValue(src.AuxSurf.S3d.TallBufferHeight); + dst.AuxSurf.S3d.TallBufferSize.setValue(src.AuxSurf.S3d.TallBufferSize); + dst.AuxSurf.S3d.IsRFrame.setValue(src.AuxSurf.S3d.IsRFrame); + dst.AuxSurf.SegmentOverride.Seg1.setValue(src.AuxSurf.SegmentOverride.Seg1); + dst.AuxSurf.SegmentOverride.Evict.setValue(src.AuxSurf.SegmentOverride.Evict); + dst.AuxSurf.MaximumRenamingListLength.setValue(src.AuxSurf.MaximumRenamingListLength); +#if _DEBUG || _RELEASE_INTERNAL + dst.AuxSurf.Platform.eProductFamily.setValue(src.AuxSurf.Platform.eProductFamily); + dst.AuxSurf.Platform.ePCHProductFamily.setValue(src.AuxSurf.Platform.ePCHProductFamily); + dst.AuxSurf.Platform.eDisplayCoreFamily.setValue(src.AuxSurf.Platform.eDisplayCoreFamily); + dst.AuxSurf.Platform.eRenderCoreFamily.setValue(src.AuxSurf.Platform.eRenderCoreFamily); + dst.AuxSurf.Platform.ePlatformType.setValue(src.AuxSurf.Platform.ePlatformType); + dst.AuxSurf.Platform.usDeviceID.setValue(src.AuxSurf.Platform.usDeviceID); + dst.AuxSurf.Platform.usRevId.setValue(src.AuxSurf.Platform.usRevId); + dst.AuxSurf.Platform.usDeviceID_PCH.setValue(src.AuxSurf.Platform.usDeviceID_PCH); + dst.AuxSurf.Platform.usRevId_PCH.setValue(src.AuxSurf.Platform.usRevId_PCH); + dst.AuxSurf.Platform.eGTType.setValue(src.AuxSurf.Platform.eGTType); +#endif + dst.AuxSurf.ExistingSysMem.IsGmmAllocated.setValue(src.AuxSurf.ExistingSysMem.IsGmmAllocated); + dst.AuxSurf.ExistingSysMem.IsPageAligned.setValue(src.AuxSurf.ExistingSysMem.IsPageAligned); +#if !(_DEBUG || _RELEASE_INTERNAL) + dst.AuxSurf.__Platform.eProductFamily.setValue(src.AuxSurf.__Platform.eProductFamily); + dst.AuxSurf.__Platform.ePCHProductFamily.setValue(src.AuxSurf.__Platform.ePCHProductFamily); + dst.AuxSurf.__Platform.eDisplayCoreFamily.setValue(src.AuxSurf.__Platform.eDisplayCoreFamily); + dst.AuxSurf.__Platform.eRenderCoreFamily.setValue(src.AuxSurf.__Platform.eRenderCoreFamily); + dst.AuxSurf.__Platform.ePlatformType.setValue(src.AuxSurf.__Platform.ePlatformType); + dst.AuxSurf.__Platform.usDeviceID.setValue(src.AuxSurf.__Platform.usDeviceID); + dst.AuxSurf.__Platform.usRevId.setValue(src.AuxSurf.__Platform.usRevId); + dst.AuxSurf.__Platform.usDeviceID_PCH.setValue(src.AuxSurf.__Platform.usDeviceID_PCH); + dst.AuxSurf.__Platform.usRevId_PCH.setValue(src.AuxSurf.__Platform.usRevId_PCH); + dst.AuxSurf.__Platform.eGTType.setValue(src.AuxSurf.__Platform.eGTType); +#endif + dst.AuxSecSurf.Type.setValue(src.AuxSecSurf.Type); + dst.AuxSecSurf.Format.setValue(src.AuxSecSurf.Format); + dst.AuxSecSurf.BitsPerPixel.setValue(src.AuxSecSurf.BitsPerPixel); + dst.AuxSecSurf.Flags.Gpu.CameraCapture.setValue(src.AuxSecSurf.Flags.Gpu.CameraCapture); + dst.AuxSecSurf.Flags.Gpu.CCS.setValue(src.AuxSecSurf.Flags.Gpu.CCS); + dst.AuxSecSurf.Flags.Gpu.ColorDiscard.setValue(src.AuxSecSurf.Flags.Gpu.ColorDiscard); + dst.AuxSecSurf.Flags.Gpu.ColorSeparation.setValue(src.AuxSecSurf.Flags.Gpu.ColorSeparation); + dst.AuxSecSurf.Flags.Gpu.ColorSeparationRGBX.setValue(src.AuxSecSurf.Flags.Gpu.ColorSeparationRGBX); + dst.AuxSecSurf.Flags.Gpu.Constant.setValue(src.AuxSecSurf.Flags.Gpu.Constant); + dst.AuxSecSurf.Flags.Gpu.Depth.setValue(src.AuxSecSurf.Flags.Gpu.Depth); + dst.AuxSecSurf.Flags.Gpu.FlipChain.setValue(src.AuxSecSurf.Flags.Gpu.FlipChain); + dst.AuxSecSurf.Flags.Gpu.FlipChainPreferred.setValue(src.AuxSecSurf.Flags.Gpu.FlipChainPreferred); + dst.AuxSecSurf.Flags.Gpu.HistoryBuffer.setValue(src.AuxSecSurf.Flags.Gpu.HistoryBuffer); + dst.AuxSecSurf.Flags.Gpu.HiZ.setValue(src.AuxSecSurf.Flags.Gpu.HiZ); + dst.AuxSecSurf.Flags.Gpu.Index.setValue(src.AuxSecSurf.Flags.Gpu.Index); + dst.AuxSecSurf.Flags.Gpu.IndirectClearColor.setValue(src.AuxSecSurf.Flags.Gpu.IndirectClearColor); + dst.AuxSecSurf.Flags.Gpu.InstructionFlat.setValue(src.AuxSecSurf.Flags.Gpu.InstructionFlat); + dst.AuxSecSurf.Flags.Gpu.InterlacedScan.setValue(src.AuxSecSurf.Flags.Gpu.InterlacedScan); + dst.AuxSecSurf.Flags.Gpu.MCS.setValue(src.AuxSecSurf.Flags.Gpu.MCS); + dst.AuxSecSurf.Flags.Gpu.MMC.setValue(src.AuxSecSurf.Flags.Gpu.MMC); + dst.AuxSecSurf.Flags.Gpu.MotionComp.setValue(src.AuxSecSurf.Flags.Gpu.MotionComp); + dst.AuxSecSurf.Flags.Gpu.NoRestriction.setValue(src.AuxSecSurf.Flags.Gpu.NoRestriction); + dst.AuxSecSurf.Flags.Gpu.Overlay.setValue(src.AuxSecSurf.Flags.Gpu.Overlay); + dst.AuxSecSurf.Flags.Gpu.Presentable.setValue(src.AuxSecSurf.Flags.Gpu.Presentable); + dst.AuxSecSurf.Flags.Gpu.ProceduralTexture.setValue(src.AuxSecSurf.Flags.Gpu.ProceduralTexture); + dst.AuxSecSurf.Flags.Gpu.Query.setValue(src.AuxSecSurf.Flags.Gpu.Query); + dst.AuxSecSurf.Flags.Gpu.RenderTarget.setValue(src.AuxSecSurf.Flags.Gpu.RenderTarget); + dst.AuxSecSurf.Flags.Gpu.S3d.setValue(src.AuxSecSurf.Flags.Gpu.S3d); + dst.AuxSecSurf.Flags.Gpu.S3dDx.setValue(src.AuxSecSurf.Flags.Gpu.S3dDx); + dst.AuxSecSurf.Flags.Gpu.__S3dNonPacked.setValue(src.AuxSecSurf.Flags.Gpu.__S3dNonPacked); + dst.AuxSecSurf.Flags.Gpu.__S3dWidi.setValue(src.AuxSecSurf.Flags.Gpu.__S3dWidi); + dst.AuxSecSurf.Flags.Gpu.ScratchFlat.setValue(src.AuxSecSurf.Flags.Gpu.ScratchFlat); + dst.AuxSecSurf.Flags.Gpu.SeparateStencil.setValue(src.AuxSecSurf.Flags.Gpu.SeparateStencil); + dst.AuxSecSurf.Flags.Gpu.State.setValue(src.AuxSecSurf.Flags.Gpu.State); + dst.AuxSecSurf.Flags.Gpu.StateDx9ConstantBuffer.setValue(src.AuxSecSurf.Flags.Gpu.StateDx9ConstantBuffer); + dst.AuxSecSurf.Flags.Gpu.Stream.setValue(src.AuxSecSurf.Flags.Gpu.Stream); + dst.AuxSecSurf.Flags.Gpu.TextApi.setValue(src.AuxSecSurf.Flags.Gpu.TextApi); + dst.AuxSecSurf.Flags.Gpu.Texture.setValue(src.AuxSecSurf.Flags.Gpu.Texture); + dst.AuxSecSurf.Flags.Gpu.TiledResource.setValue(src.AuxSecSurf.Flags.Gpu.TiledResource); + dst.AuxSecSurf.Flags.Gpu.TilePool.setValue(src.AuxSecSurf.Flags.Gpu.TilePool); + dst.AuxSecSurf.Flags.Gpu.UnifiedAuxSurface.setValue(src.AuxSecSurf.Flags.Gpu.UnifiedAuxSurface); + dst.AuxSecSurf.Flags.Gpu.Vertex.setValue(src.AuxSecSurf.Flags.Gpu.Vertex); + dst.AuxSecSurf.Flags.Gpu.Video.setValue(src.AuxSecSurf.Flags.Gpu.Video); + dst.AuxSecSurf.Flags.Gpu.__NonMsaaTileXCcs.setValue(src.AuxSecSurf.Flags.Gpu.__NonMsaaTileXCcs); + dst.AuxSecSurf.Flags.Gpu.__NonMsaaTileYCcs.setValue(src.AuxSecSurf.Flags.Gpu.__NonMsaaTileYCcs); + dst.AuxSecSurf.Flags.Gpu.__MsaaTileMcs.setValue(src.AuxSecSurf.Flags.Gpu.__MsaaTileMcs); + dst.AuxSecSurf.Flags.Gpu.__NonMsaaLinearCCS.setValue(src.AuxSecSurf.Flags.Gpu.__NonMsaaLinearCCS); + dst.AuxSecSurf.Flags.Gpu.__Remaining.setValue(src.AuxSecSurf.Flags.Gpu.__Remaining); + dst.AuxSecSurf.Flags.Info.AllowVirtualPadding.setValue(src.AuxSecSurf.Flags.Info.AllowVirtualPadding); + dst.AuxSecSurf.Flags.Info.BigPage.setValue(src.AuxSecSurf.Flags.Info.BigPage); + dst.AuxSecSurf.Flags.Info.Cacheable.setValue(src.AuxSecSurf.Flags.Info.Cacheable); + dst.AuxSecSurf.Flags.Info.ContigPhysMemoryForiDART.setValue(src.AuxSecSurf.Flags.Info.ContigPhysMemoryForiDART); + dst.AuxSecSurf.Flags.Info.CornerTexelMode.setValue(src.AuxSecSurf.Flags.Info.CornerTexelMode); + dst.AuxSecSurf.Flags.Info.ExistingSysMem.setValue(src.AuxSecSurf.Flags.Info.ExistingSysMem); + dst.AuxSecSurf.Flags.Info.ForceResidency.setValue(src.AuxSecSurf.Flags.Info.ForceResidency); + dst.AuxSecSurf.Flags.Info.Gfdt.setValue(src.AuxSecSurf.Flags.Info.Gfdt); + dst.AuxSecSurf.Flags.Info.GttMapType.setValue(src.AuxSecSurf.Flags.Info.GttMapType); + dst.AuxSecSurf.Flags.Info.HardwareProtected.setValue(src.AuxSecSurf.Flags.Info.HardwareProtected); + dst.AuxSecSurf.Flags.Info.KernelModeMapped.setValue(src.AuxSecSurf.Flags.Info.KernelModeMapped); + dst.AuxSecSurf.Flags.Info.LayoutBelow.setValue(src.AuxSecSurf.Flags.Info.LayoutBelow); + dst.AuxSecSurf.Flags.Info.LayoutMono.setValue(src.AuxSecSurf.Flags.Info.LayoutMono); + dst.AuxSecSurf.Flags.Info.LayoutRight.setValue(src.AuxSecSurf.Flags.Info.LayoutRight); + dst.AuxSecSurf.Flags.Info.LocalOnly.setValue(src.AuxSecSurf.Flags.Info.LocalOnly); + dst.AuxSecSurf.Flags.Info.Linear.setValue(src.AuxSecSurf.Flags.Info.Linear); + dst.AuxSecSurf.Flags.Info.MediaCompressed.setValue(src.AuxSecSurf.Flags.Info.MediaCompressed); + dst.AuxSecSurf.Flags.Info.NoOptimizationPadding.setValue(src.AuxSecSurf.Flags.Info.NoOptimizationPadding); + dst.AuxSecSurf.Flags.Info.NoPhysMemory.setValue(src.AuxSecSurf.Flags.Info.NoPhysMemory); + dst.AuxSecSurf.Flags.Info.NotLockable.setValue(src.AuxSecSurf.Flags.Info.NotLockable); + dst.AuxSecSurf.Flags.Info.NonLocalOnly.setValue(src.AuxSecSurf.Flags.Info.NonLocalOnly); + dst.AuxSecSurf.Flags.Info.StdSwizzle.setValue(src.AuxSecSurf.Flags.Info.StdSwizzle); + dst.AuxSecSurf.Flags.Info.PseudoStdSwizzle.setValue(src.AuxSecSurf.Flags.Info.PseudoStdSwizzle); + dst.AuxSecSurf.Flags.Info.Undefined64KBSwizzle.setValue(src.AuxSecSurf.Flags.Info.Undefined64KBSwizzle); + dst.AuxSecSurf.Flags.Info.RedecribedPlanes.setValue(src.AuxSecSurf.Flags.Info.RedecribedPlanes); + dst.AuxSecSurf.Flags.Info.RenderCompressed.setValue(src.AuxSecSurf.Flags.Info.RenderCompressed); + dst.AuxSecSurf.Flags.Info.Rotated.setValue(src.AuxSecSurf.Flags.Info.Rotated); + dst.AuxSecSurf.Flags.Info.Shared.setValue(src.AuxSecSurf.Flags.Info.Shared); + dst.AuxSecSurf.Flags.Info.SoftwareProtected.setValue(src.AuxSecSurf.Flags.Info.SoftwareProtected); + dst.AuxSecSurf.Flags.Info.SVM.setValue(src.AuxSecSurf.Flags.Info.SVM); + dst.AuxSecSurf.Flags.Info.Tile4.setValue(src.AuxSecSurf.Flags.Info.Tile4); + dst.AuxSecSurf.Flags.Info.Tile64.setValue(src.AuxSecSurf.Flags.Info.Tile64); + dst.AuxSecSurf.Flags.Info.TiledW.setValue(src.AuxSecSurf.Flags.Info.TiledW); + dst.AuxSecSurf.Flags.Info.TiledX.setValue(src.AuxSecSurf.Flags.Info.TiledX); + dst.AuxSecSurf.Flags.Info.TiledY.setValue(src.AuxSecSurf.Flags.Info.TiledY); + dst.AuxSecSurf.Flags.Info.TiledYf.setValue(src.AuxSecSurf.Flags.Info.TiledYf); + dst.AuxSecSurf.Flags.Info.TiledYs.setValue(src.AuxSecSurf.Flags.Info.TiledYs); + dst.AuxSecSurf.Flags.Info.WddmProtected.setValue(src.AuxSecSurf.Flags.Info.WddmProtected); + dst.AuxSecSurf.Flags.Info.XAdapter.setValue(src.AuxSecSurf.Flags.Info.XAdapter); + dst.AuxSecSurf.Flags.Info.__PreallocatedResInfo.setValue(src.AuxSecSurf.Flags.Info.__PreallocatedResInfo); + dst.AuxSecSurf.Flags.Info.__PreWddm2SVM.setValue(src.AuxSecSurf.Flags.Info.__PreWddm2SVM); + dst.AuxSecSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign.setValue(src.AuxSecSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign); + dst.AuxSecSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign.setValue(src.AuxSecSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign); + dst.AuxSecSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign.setValue(src.AuxSecSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign); + dst.AuxSecSurf.Flags.Wa.NoBufferSamplerPadding.setValue(src.AuxSecSurf.Flags.Wa.NoBufferSamplerPadding); + dst.AuxSecSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions.setValue(src.AuxSecSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions); + dst.AuxSecSurf.Flags.Wa.CHVAstcSkipVirtualMips.setValue(src.AuxSecSurf.Flags.Wa.CHVAstcSkipVirtualMips); + dst.AuxSecSurf.Flags.Wa.DisablePackedMipTail.setValue(src.AuxSecSurf.Flags.Wa.DisablePackedMipTail); + dst.AuxSecSurf.Flags.Wa.__ForceOtherHVALIGN4.setValue(src.AuxSecSurf.Flags.Wa.__ForceOtherHVALIGN4); + dst.AuxSecSurf.Flags.Wa.DisableDisplayCcsClearColor.setValue(src.AuxSecSurf.Flags.Wa.DisableDisplayCcsClearColor); + dst.AuxSecSurf.Flags.Wa.DisableDisplayCcsCompression.setValue(src.AuxSecSurf.Flags.Wa.DisableDisplayCcsCompression); + dst.AuxSecSurf.Flags.Wa.PreGen12FastClearOnly.setValue(src.AuxSecSurf.Flags.Wa.PreGen12FastClearOnly); + dst.AuxSecSurf.BaseWidth.setValue(src.AuxSecSurf.BaseWidth); + dst.AuxSecSurf.BaseHeight.setValue(src.AuxSecSurf.BaseHeight); + dst.AuxSecSurf.Depth.setValue(src.AuxSecSurf.Depth); + dst.AuxSecSurf.MaxLod.setValue(src.AuxSecSurf.MaxLod); + dst.AuxSecSurf.ArraySize.setValue(src.AuxSecSurf.ArraySize); + dst.AuxSecSurf.CpTag.setValue(src.AuxSecSurf.CpTag); + dst.AuxSecSurf.CachePolicy.Usage.setValue(src.AuxSecSurf.CachePolicy.Usage); + dst.AuxSecSurf.MSAA.SamplePattern.setValue(src.AuxSecSurf.MSAA.SamplePattern); + dst.AuxSecSurf.MSAA.NumSamples.setValue(src.AuxSecSurf.MSAA.NumSamples); + dst.AuxSecSurf.Alignment.ArraySpacingSingleLod.setValue(src.AuxSecSurf.Alignment.ArraySpacingSingleLod); + dst.AuxSecSurf.Alignment.BaseAlignment.setValue(src.AuxSecSurf.Alignment.BaseAlignment); + dst.AuxSecSurf.Alignment.HAlign.setValue(src.AuxSecSurf.Alignment.HAlign); + dst.AuxSecSurf.Alignment.VAlign.setValue(src.AuxSecSurf.Alignment.VAlign); + dst.AuxSecSurf.Alignment.DAlign.setValue(src.AuxSecSurf.Alignment.DAlign); + dst.AuxSecSurf.Alignment.MipTailStartLod.setValue(src.AuxSecSurf.Alignment.MipTailStartLod); + dst.AuxSecSurf.Alignment.PackedMipStartLod.setValue(src.AuxSecSurf.Alignment.PackedMipStartLod); + dst.AuxSecSurf.Alignment.PackedMipWidth.setValue(src.AuxSecSurf.Alignment.PackedMipWidth); + dst.AuxSecSurf.Alignment.PackedMipHeight.setValue(src.AuxSecSurf.Alignment.PackedMipHeight); + dst.AuxSecSurf.Alignment.QPitch.setValue(src.AuxSecSurf.Alignment.QPitch); + WCH_SAFE_COPY(dst.AuxSecSurf.MmcMode.getValue(), dst.AuxSecSurf.MmcMode.getValueSizeInBytes(), src.AuxSecSurf.MmcMode, sizeof(src.AuxSecSurf.MmcMode)); + WCH_SAFE_COPY(dst.AuxSecSurf.MmcHint.getValue(), dst.AuxSecSurf.MmcHint.getValueSizeInBytes(), src.AuxSecSurf.MmcHint, sizeof(src.AuxSecSurf.MmcHint)); + dst.AuxSecSurf.Pitch.setValue(src.AuxSecSurf.Pitch); + dst.AuxSecSurf.OverridePitch.setValue(src.AuxSecSurf.OverridePitch); + dst.AuxSecSurf.Size.setValue(src.AuxSecSurf.Size); + dst.AuxSecSurf.CCSize.setValue(src.AuxSecSurf.CCSize); + dst.AuxSecSurf.UnpaddedSize.setValue(src.AuxSecSurf.UnpaddedSize); + dst.AuxSecSurf.SizeReportToOS.setValue(src.AuxSecSurf.SizeReportToOS); + dst.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch.setValue(src.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch); + WCH_SAFE_COPY(dst.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset.getValue(), dst.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset.getValueSizeInBytes(), src.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(src.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset)); + dst.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock.setValue(src.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock); + dst.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender.setValue(src.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender); + WCH_SAFE_COPY(dst.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset.getValue(), dst.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset.getValueSizeInBytes(), src.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(src.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset)); + dst.AuxSecSurf.OffsetInfo.Plane.ArrayQPitch.setValue(src.AuxSecSurf.OffsetInfo.Plane.ArrayQPitch); + WCH_SAFE_COPY(dst.AuxSecSurf.OffsetInfo.Plane.X.getValue(), dst.AuxSecSurf.OffsetInfo.Plane.X.getValueSizeInBytes(), src.AuxSecSurf.OffsetInfo.Plane.X, sizeof(src.AuxSecSurf.OffsetInfo.Plane.X)); + WCH_SAFE_COPY(dst.AuxSecSurf.OffsetInfo.Plane.Y.getValue(), dst.AuxSecSurf.OffsetInfo.Plane.Y.getValueSizeInBytes(), src.AuxSecSurf.OffsetInfo.Plane.Y, sizeof(src.AuxSecSurf.OffsetInfo.Plane.Y)); + WCH_SAFE_COPY(dst.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height.getValue(), dst.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height.getValueSizeInBytes(), src.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height, sizeof(src.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height)); + dst.AuxSecSurf.OffsetInfo.Plane.NoOfPlanes.setValue(src.AuxSecSurf.OffsetInfo.Plane.NoOfPlanes); + dst.AuxSecSurf.OffsetInfo.Plane.IsTileAlignedPlanes.setValue(src.AuxSecSurf.OffsetInfo.Plane.IsTileAlignedPlanes); + dst.AuxSecSurf.TileMode.setValue(src.AuxSecSurf.TileMode); + dst.AuxSecSurf.CCSModeAlign.setValue(src.AuxSecSurf.CCSModeAlign); + dst.AuxSecSurf.LegacyFlags.setValue(src.AuxSecSurf.LegacyFlags); + dst.AuxSecSurf.S3d.DisplayModeHeight.setValue(src.AuxSecSurf.S3d.DisplayModeHeight); + dst.AuxSecSurf.S3d.NumBlankActiveLines.setValue(src.AuxSecSurf.S3d.NumBlankActiveLines); + dst.AuxSecSurf.S3d.RFrameOffset.setValue(src.AuxSecSurf.S3d.RFrameOffset); + dst.AuxSecSurf.S3d.BlankAreaOffset.setValue(src.AuxSecSurf.S3d.BlankAreaOffset); + dst.AuxSecSurf.S3d.TallBufferHeight.setValue(src.AuxSecSurf.S3d.TallBufferHeight); + dst.AuxSecSurf.S3d.TallBufferSize.setValue(src.AuxSecSurf.S3d.TallBufferSize); + dst.AuxSecSurf.S3d.IsRFrame.setValue(src.AuxSecSurf.S3d.IsRFrame); + dst.AuxSecSurf.SegmentOverride.Seg1.setValue(src.AuxSecSurf.SegmentOverride.Seg1); + dst.AuxSecSurf.SegmentOverride.Evict.setValue(src.AuxSecSurf.SegmentOverride.Evict); + dst.AuxSecSurf.MaximumRenamingListLength.setValue(src.AuxSecSurf.MaximumRenamingListLength); +#if _DEBUG || _RELEASE_INTERNAL + dst.AuxSecSurf.Platform.eProductFamily.setValue(src.AuxSecSurf.Platform.eProductFamily); + dst.AuxSecSurf.Platform.ePCHProductFamily.setValue(src.AuxSecSurf.Platform.ePCHProductFamily); + dst.AuxSecSurf.Platform.eDisplayCoreFamily.setValue(src.AuxSecSurf.Platform.eDisplayCoreFamily); + dst.AuxSecSurf.Platform.eRenderCoreFamily.setValue(src.AuxSecSurf.Platform.eRenderCoreFamily); + dst.AuxSecSurf.Platform.ePlatformType.setValue(src.AuxSecSurf.Platform.ePlatformType); + dst.AuxSecSurf.Platform.usDeviceID.setValue(src.AuxSecSurf.Platform.usDeviceID); + dst.AuxSecSurf.Platform.usRevId.setValue(src.AuxSecSurf.Platform.usRevId); + dst.AuxSecSurf.Platform.usDeviceID_PCH.setValue(src.AuxSecSurf.Platform.usDeviceID_PCH); + dst.AuxSecSurf.Platform.usRevId_PCH.setValue(src.AuxSecSurf.Platform.usRevId_PCH); + dst.AuxSecSurf.Platform.eGTType.setValue(src.AuxSecSurf.Platform.eGTType); +#endif + dst.AuxSecSurf.ExistingSysMem.IsGmmAllocated.setValue(src.AuxSecSurf.ExistingSysMem.IsGmmAllocated); + dst.AuxSecSurf.ExistingSysMem.IsPageAligned.setValue(src.AuxSecSurf.ExistingSysMem.IsPageAligned); +#if !(_DEBUG || _RELEASE_INTERNAL) + dst.AuxSecSurf.__Platform.eProductFamily.setValue(src.AuxSecSurf.__Platform.eProductFamily); + dst.AuxSecSurf.__Platform.ePCHProductFamily.setValue(src.AuxSecSurf.__Platform.ePCHProductFamily); + dst.AuxSecSurf.__Platform.eDisplayCoreFamily.setValue(src.AuxSecSurf.__Platform.eDisplayCoreFamily); + dst.AuxSecSurf.__Platform.eRenderCoreFamily.setValue(src.AuxSecSurf.__Platform.eRenderCoreFamily); + dst.AuxSecSurf.__Platform.ePlatformType.setValue(src.AuxSecSurf.__Platform.ePlatformType); + dst.AuxSecSurf.__Platform.usDeviceID.setValue(src.AuxSecSurf.__Platform.usDeviceID); + dst.AuxSecSurf.__Platform.usRevId.setValue(src.AuxSecSurf.__Platform.usRevId); + dst.AuxSecSurf.__Platform.usDeviceID_PCH.setValue(src.AuxSecSurf.__Platform.usDeviceID_PCH); + dst.AuxSecSurf.__Platform.usRevId_PCH.setValue(src.AuxSecSurf.__Platform.usRevId_PCH); + dst.AuxSecSurf.__Platform.eGTType.setValue(src.AuxSecSurf.__Platform.eGTType); +#endif + dst.RotateInfo.setValue(src.RotateInfo); + dst.ExistingSysMem.pExistingSysMem.setValue(src.ExistingSysMem.pExistingSysMem); + dst.ExistingSysMem.pVirtAddress.setValue(src.ExistingSysMem.pVirtAddress); + dst.ExistingSysMem.pGfxAlignedVirtAddress.setValue(src.ExistingSysMem.pGfxAlignedVirtAddress); + dst.ExistingSysMem.Size.setValue(src.ExistingSysMem.Size); + dst.ExistingSysMem.IsGmmAllocated.setValue(src.ExistingSysMem.IsGmmAllocated); + dst.SvmAddress.setValue(src.SvmAddress); + dst.pPrivateData.setValue(src.pPrivateData); + dst.MultiTileArch.Enable.setValue(src.MultiTileArch.Enable); + dst.MultiTileArch.TileInstanced.setValue(src.MultiTileArch.TileInstanced); + dst.MultiTileArch.GpuVaMappingSet.setValue(src.MultiTileArch.GpuVaMappingSet); + dst.MultiTileArch.LocalMemEligibilitySet.setValue(src.MultiTileArch.LocalMemEligibilitySet); + dst.MultiTileArch.LocalMemPreferredSet.setValue(src.MultiTileArch.LocalMemPreferredSet); +} +template <> +struct Marshaller { + template + static TOKSTR_GmmResourceInfoCommonStruct marshall(const GmmResourceInfoCommonStructT &src) { + TOKSTR_GmmResourceInfoCommonStruct ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_GmmResourceInfoWinStruct &dst, const GmmResourceInfoWinStructT &src) { + dst = {}; + dst.GmmResourceInfoCommon.ClientType.setValue(src.GmmResourceInfoCommon.ClientType); + dst.GmmResourceInfoCommon.Surf.Type.setValue(src.GmmResourceInfoCommon.Surf.Type); + dst.GmmResourceInfoCommon.Surf.Format.setValue(src.GmmResourceInfoCommon.Surf.Format); + dst.GmmResourceInfoCommon.Surf.BitsPerPixel.setValue(src.GmmResourceInfoCommon.Surf.BitsPerPixel); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.CameraCapture.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.CameraCapture); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.CCS.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.CCS); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ColorDiscard.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.ColorDiscard); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ColorSeparation.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.ColorSeparation); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ColorSeparationRGBX.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.ColorSeparationRGBX); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Constant.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.Constant); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Depth.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.Depth); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.FlipChain.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.FlipChain); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.FlipChainPreferred.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.FlipChainPreferred); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.HistoryBuffer.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.HistoryBuffer); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.HiZ.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.HiZ); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Index.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.Index); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.IndirectClearColor.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.IndirectClearColor); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.InstructionFlat.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.InstructionFlat); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.InterlacedScan.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.InterlacedScan); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.MCS.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.MCS); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.MMC.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.MMC); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.MotionComp.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.MotionComp); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.NoRestriction.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.NoRestriction); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Overlay.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.Overlay); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Presentable.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.Presentable); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ProceduralTexture.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.ProceduralTexture); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Query.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.Query); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.RenderTarget.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.RenderTarget); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.S3d.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.S3d); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.S3dDx.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.S3dDx); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__S3dNonPacked.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.__S3dNonPacked); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__S3dWidi.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.__S3dWidi); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ScratchFlat.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.ScratchFlat); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.SeparateStencil.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.SeparateStencil); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.State.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.State); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.StateDx9ConstantBuffer.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.StateDx9ConstantBuffer); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Stream.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.Stream); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.TextApi.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.TextApi); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Texture.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.Texture); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.TiledResource.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.TiledResource); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.TilePool.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.TilePool); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.UnifiedAuxSurface.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.UnifiedAuxSurface); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Vertex.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.Vertex); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Video.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.Video); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__NonMsaaTileXCcs.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.__NonMsaaTileXCcs); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__NonMsaaTileYCcs.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.__NonMsaaTileYCcs); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__MsaaTileMcs.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.__MsaaTileMcs); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__NonMsaaLinearCCS.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.__NonMsaaLinearCCS); + dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__Remaining.setValue(src.GmmResourceInfoCommon.Surf.Flags.Gpu.__Remaining); + dst.GmmResourceInfoCommon.Surf.Flags.Info.AllowVirtualPadding.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.AllowVirtualPadding); + dst.GmmResourceInfoCommon.Surf.Flags.Info.BigPage.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.BigPage); + dst.GmmResourceInfoCommon.Surf.Flags.Info.Cacheable.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.Cacheable); + dst.GmmResourceInfoCommon.Surf.Flags.Info.ContigPhysMemoryForiDART.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.ContigPhysMemoryForiDART); + dst.GmmResourceInfoCommon.Surf.Flags.Info.CornerTexelMode.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.CornerTexelMode); + dst.GmmResourceInfoCommon.Surf.Flags.Info.ExistingSysMem.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.ExistingSysMem); + dst.GmmResourceInfoCommon.Surf.Flags.Info.ForceResidency.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.ForceResidency); + dst.GmmResourceInfoCommon.Surf.Flags.Info.Gfdt.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.Gfdt); + dst.GmmResourceInfoCommon.Surf.Flags.Info.GttMapType.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.GttMapType); + dst.GmmResourceInfoCommon.Surf.Flags.Info.HardwareProtected.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.HardwareProtected); + dst.GmmResourceInfoCommon.Surf.Flags.Info.KernelModeMapped.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.KernelModeMapped); + dst.GmmResourceInfoCommon.Surf.Flags.Info.LayoutBelow.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.LayoutBelow); + dst.GmmResourceInfoCommon.Surf.Flags.Info.LayoutMono.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.LayoutMono); + dst.GmmResourceInfoCommon.Surf.Flags.Info.LayoutRight.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.LayoutRight); + dst.GmmResourceInfoCommon.Surf.Flags.Info.LocalOnly.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.LocalOnly); + dst.GmmResourceInfoCommon.Surf.Flags.Info.Linear.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.Linear); + dst.GmmResourceInfoCommon.Surf.Flags.Info.MediaCompressed.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.MediaCompressed); + dst.GmmResourceInfoCommon.Surf.Flags.Info.NoOptimizationPadding.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.NoOptimizationPadding); + dst.GmmResourceInfoCommon.Surf.Flags.Info.NoPhysMemory.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.NoPhysMemory); + dst.GmmResourceInfoCommon.Surf.Flags.Info.NotLockable.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.NotLockable); + dst.GmmResourceInfoCommon.Surf.Flags.Info.NonLocalOnly.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.NonLocalOnly); + dst.GmmResourceInfoCommon.Surf.Flags.Info.StdSwizzle.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.StdSwizzle); + dst.GmmResourceInfoCommon.Surf.Flags.Info.PseudoStdSwizzle.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.PseudoStdSwizzle); + dst.GmmResourceInfoCommon.Surf.Flags.Info.Undefined64KBSwizzle.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.Undefined64KBSwizzle); + dst.GmmResourceInfoCommon.Surf.Flags.Info.RedecribedPlanes.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.RedecribedPlanes); + dst.GmmResourceInfoCommon.Surf.Flags.Info.RenderCompressed.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.RenderCompressed); + dst.GmmResourceInfoCommon.Surf.Flags.Info.Rotated.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.Rotated); + dst.GmmResourceInfoCommon.Surf.Flags.Info.Shared.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.Shared); + dst.GmmResourceInfoCommon.Surf.Flags.Info.SoftwareProtected.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.SoftwareProtected); + dst.GmmResourceInfoCommon.Surf.Flags.Info.SVM.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.SVM); + dst.GmmResourceInfoCommon.Surf.Flags.Info.Tile4.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.Tile4); + dst.GmmResourceInfoCommon.Surf.Flags.Info.Tile64.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.Tile64); + dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledW.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.TiledW); + dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledX.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.TiledX); + dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledY.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.TiledY); + dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledYf.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.TiledYf); + dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledYs.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.TiledYs); + dst.GmmResourceInfoCommon.Surf.Flags.Info.WddmProtected.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.WddmProtected); + dst.GmmResourceInfoCommon.Surf.Flags.Info.XAdapter.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.XAdapter); + dst.GmmResourceInfoCommon.Surf.Flags.Info.__PreallocatedResInfo.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.__PreallocatedResInfo); + dst.GmmResourceInfoCommon.Surf.Flags.Info.__PreWddm2SVM.setValue(src.GmmResourceInfoCommon.Surf.Flags.Info.__PreWddm2SVM); + dst.GmmResourceInfoCommon.Surf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign.setValue(src.GmmResourceInfoCommon.Surf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign); + dst.GmmResourceInfoCommon.Surf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign.setValue(src.GmmResourceInfoCommon.Surf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign); + dst.GmmResourceInfoCommon.Surf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign.setValue(src.GmmResourceInfoCommon.Surf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign); + dst.GmmResourceInfoCommon.Surf.Flags.Wa.NoBufferSamplerPadding.setValue(src.GmmResourceInfoCommon.Surf.Flags.Wa.NoBufferSamplerPadding); + dst.GmmResourceInfoCommon.Surf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions.setValue(src.GmmResourceInfoCommon.Surf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions); + dst.GmmResourceInfoCommon.Surf.Flags.Wa.CHVAstcSkipVirtualMips.setValue(src.GmmResourceInfoCommon.Surf.Flags.Wa.CHVAstcSkipVirtualMips); + dst.GmmResourceInfoCommon.Surf.Flags.Wa.DisablePackedMipTail.setValue(src.GmmResourceInfoCommon.Surf.Flags.Wa.DisablePackedMipTail); + dst.GmmResourceInfoCommon.Surf.Flags.Wa.__ForceOtherHVALIGN4.setValue(src.GmmResourceInfoCommon.Surf.Flags.Wa.__ForceOtherHVALIGN4); + dst.GmmResourceInfoCommon.Surf.Flags.Wa.DisableDisplayCcsClearColor.setValue(src.GmmResourceInfoCommon.Surf.Flags.Wa.DisableDisplayCcsClearColor); + dst.GmmResourceInfoCommon.Surf.Flags.Wa.DisableDisplayCcsCompression.setValue(src.GmmResourceInfoCommon.Surf.Flags.Wa.DisableDisplayCcsCompression); + dst.GmmResourceInfoCommon.Surf.Flags.Wa.PreGen12FastClearOnly.setValue(src.GmmResourceInfoCommon.Surf.Flags.Wa.PreGen12FastClearOnly); + dst.GmmResourceInfoCommon.Surf.BaseWidth.setValue(src.GmmResourceInfoCommon.Surf.BaseWidth); + dst.GmmResourceInfoCommon.Surf.BaseHeight.setValue(src.GmmResourceInfoCommon.Surf.BaseHeight); + dst.GmmResourceInfoCommon.Surf.Depth.setValue(src.GmmResourceInfoCommon.Surf.Depth); + dst.GmmResourceInfoCommon.Surf.MaxLod.setValue(src.GmmResourceInfoCommon.Surf.MaxLod); + dst.GmmResourceInfoCommon.Surf.ArraySize.setValue(src.GmmResourceInfoCommon.Surf.ArraySize); + dst.GmmResourceInfoCommon.Surf.CpTag.setValue(src.GmmResourceInfoCommon.Surf.CpTag); + dst.GmmResourceInfoCommon.Surf.CachePolicy.Usage.setValue(src.GmmResourceInfoCommon.Surf.CachePolicy.Usage); + dst.GmmResourceInfoCommon.Surf.MSAA.SamplePattern.setValue(src.GmmResourceInfoCommon.Surf.MSAA.SamplePattern); + dst.GmmResourceInfoCommon.Surf.MSAA.NumSamples.setValue(src.GmmResourceInfoCommon.Surf.MSAA.NumSamples); + dst.GmmResourceInfoCommon.Surf.Alignment.ArraySpacingSingleLod.setValue(src.GmmResourceInfoCommon.Surf.Alignment.ArraySpacingSingleLod); + dst.GmmResourceInfoCommon.Surf.Alignment.BaseAlignment.setValue(src.GmmResourceInfoCommon.Surf.Alignment.BaseAlignment); + dst.GmmResourceInfoCommon.Surf.Alignment.HAlign.setValue(src.GmmResourceInfoCommon.Surf.Alignment.HAlign); + dst.GmmResourceInfoCommon.Surf.Alignment.VAlign.setValue(src.GmmResourceInfoCommon.Surf.Alignment.VAlign); + dst.GmmResourceInfoCommon.Surf.Alignment.DAlign.setValue(src.GmmResourceInfoCommon.Surf.Alignment.DAlign); + dst.GmmResourceInfoCommon.Surf.Alignment.MipTailStartLod.setValue(src.GmmResourceInfoCommon.Surf.Alignment.MipTailStartLod); + dst.GmmResourceInfoCommon.Surf.Alignment.PackedMipStartLod.setValue(src.GmmResourceInfoCommon.Surf.Alignment.PackedMipStartLod); + dst.GmmResourceInfoCommon.Surf.Alignment.PackedMipWidth.setValue(src.GmmResourceInfoCommon.Surf.Alignment.PackedMipWidth); + dst.GmmResourceInfoCommon.Surf.Alignment.PackedMipHeight.setValue(src.GmmResourceInfoCommon.Surf.Alignment.PackedMipHeight); + dst.GmmResourceInfoCommon.Surf.Alignment.QPitch.setValue(src.GmmResourceInfoCommon.Surf.Alignment.QPitch); + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.MmcMode.getValue(), dst.GmmResourceInfoCommon.Surf.MmcMode.getValueSizeInBytes(), src.GmmResourceInfoCommon.Surf.MmcMode, sizeof(src.GmmResourceInfoCommon.Surf.MmcMode)); + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.MmcHint.getValue(), dst.GmmResourceInfoCommon.Surf.MmcHint.getValueSizeInBytes(), src.GmmResourceInfoCommon.Surf.MmcHint, sizeof(src.GmmResourceInfoCommon.Surf.MmcHint)); + dst.GmmResourceInfoCommon.Surf.Pitch.setValue(src.GmmResourceInfoCommon.Surf.Pitch); + dst.GmmResourceInfoCommon.Surf.OverridePitch.setValue(src.GmmResourceInfoCommon.Surf.OverridePitch); + dst.GmmResourceInfoCommon.Surf.Size.setValue(src.GmmResourceInfoCommon.Surf.Size); + dst.GmmResourceInfoCommon.Surf.CCSize.setValue(src.GmmResourceInfoCommon.Surf.CCSize); + dst.GmmResourceInfoCommon.Surf.UnpaddedSize.setValue(src.GmmResourceInfoCommon.Surf.UnpaddedSize); + dst.GmmResourceInfoCommon.Surf.SizeReportToOS.setValue(src.GmmResourceInfoCommon.Surf.SizeReportToOS); + dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch.setValue(src.GmmResourceInfoCommon.Surf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch); + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture3DOffsetInfo.Offset.getValue(), dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture3DOffsetInfo.Offset.getValueSizeInBytes(), src.GmmResourceInfoCommon.Surf.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(src.GmmResourceInfoCommon.Surf.OffsetInfo.Texture3DOffsetInfo.Offset)); + dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock.setValue(src.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock); + dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender.setValue(src.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender); + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.Offset.getValue(), dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.Offset.getValueSizeInBytes(), src.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(src.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.Offset)); + dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.ArrayQPitch.setValue(src.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.ArrayQPitch); + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.X.getValue(), dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.X.getValueSizeInBytes(), src.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.X, sizeof(src.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.X)); + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.Y.getValue(), dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.Y.getValueSizeInBytes(), src.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.Y, sizeof(src.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.Y)); + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.UnAligned.Height.getValue(), dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.UnAligned.Height.getValueSizeInBytes(), src.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.UnAligned.Height, sizeof(src.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.UnAligned.Height)); + dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.NoOfPlanes.setValue(src.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.NoOfPlanes); + dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.IsTileAlignedPlanes.setValue(src.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.IsTileAlignedPlanes); + dst.GmmResourceInfoCommon.Surf.TileMode.setValue(src.GmmResourceInfoCommon.Surf.TileMode); + dst.GmmResourceInfoCommon.Surf.CCSModeAlign.setValue(src.GmmResourceInfoCommon.Surf.CCSModeAlign); + dst.GmmResourceInfoCommon.Surf.LegacyFlags.setValue(src.GmmResourceInfoCommon.Surf.LegacyFlags); + dst.GmmResourceInfoCommon.Surf.S3d.DisplayModeHeight.setValue(src.GmmResourceInfoCommon.Surf.S3d.DisplayModeHeight); + dst.GmmResourceInfoCommon.Surf.S3d.NumBlankActiveLines.setValue(src.GmmResourceInfoCommon.Surf.S3d.NumBlankActiveLines); + dst.GmmResourceInfoCommon.Surf.S3d.RFrameOffset.setValue(src.GmmResourceInfoCommon.Surf.S3d.RFrameOffset); + dst.GmmResourceInfoCommon.Surf.S3d.BlankAreaOffset.setValue(src.GmmResourceInfoCommon.Surf.S3d.BlankAreaOffset); + dst.GmmResourceInfoCommon.Surf.S3d.TallBufferHeight.setValue(src.GmmResourceInfoCommon.Surf.S3d.TallBufferHeight); + dst.GmmResourceInfoCommon.Surf.S3d.TallBufferSize.setValue(src.GmmResourceInfoCommon.Surf.S3d.TallBufferSize); + dst.GmmResourceInfoCommon.Surf.S3d.IsRFrame.setValue(src.GmmResourceInfoCommon.Surf.S3d.IsRFrame); + dst.GmmResourceInfoCommon.Surf.SegmentOverride.Seg1.setValue(src.GmmResourceInfoCommon.Surf.SegmentOverride.Seg1); + dst.GmmResourceInfoCommon.Surf.SegmentOverride.Evict.setValue(src.GmmResourceInfoCommon.Surf.SegmentOverride.Evict); + dst.GmmResourceInfoCommon.Surf.MaximumRenamingListLength.setValue(src.GmmResourceInfoCommon.Surf.MaximumRenamingListLength); +#if _DEBUG || _RELEASE_INTERNAL + dst.GmmResourceInfoCommon.Surf.Platform.eProductFamily.setValue(src.GmmResourceInfoCommon.Surf.Platform.eProductFamily); + dst.GmmResourceInfoCommon.Surf.Platform.ePCHProductFamily.setValue(src.GmmResourceInfoCommon.Surf.Platform.ePCHProductFamily); + dst.GmmResourceInfoCommon.Surf.Platform.eDisplayCoreFamily.setValue(src.GmmResourceInfoCommon.Surf.Platform.eDisplayCoreFamily); + dst.GmmResourceInfoCommon.Surf.Platform.eRenderCoreFamily.setValue(src.GmmResourceInfoCommon.Surf.Platform.eRenderCoreFamily); + dst.GmmResourceInfoCommon.Surf.Platform.ePlatformType.setValue(src.GmmResourceInfoCommon.Surf.Platform.ePlatformType); + dst.GmmResourceInfoCommon.Surf.Platform.usDeviceID.setValue(src.GmmResourceInfoCommon.Surf.Platform.usDeviceID); + dst.GmmResourceInfoCommon.Surf.Platform.usRevId.setValue(src.GmmResourceInfoCommon.Surf.Platform.usRevId); + dst.GmmResourceInfoCommon.Surf.Platform.usDeviceID_PCH.setValue(src.GmmResourceInfoCommon.Surf.Platform.usDeviceID_PCH); + dst.GmmResourceInfoCommon.Surf.Platform.usRevId_PCH.setValue(src.GmmResourceInfoCommon.Surf.Platform.usRevId_PCH); + dst.GmmResourceInfoCommon.Surf.Platform.eGTType.setValue(src.GmmResourceInfoCommon.Surf.Platform.eGTType); +#endif + dst.GmmResourceInfoCommon.Surf.ExistingSysMem.IsGmmAllocated.setValue(src.GmmResourceInfoCommon.Surf.ExistingSysMem.IsGmmAllocated); + dst.GmmResourceInfoCommon.Surf.ExistingSysMem.IsPageAligned.setValue(src.GmmResourceInfoCommon.Surf.ExistingSysMem.IsPageAligned); +#if !(_DEBUG || _RELEASE_INTERNAL) + dst.GmmResourceInfoCommon.Surf.__Platform.eProductFamily.setValue(src.GmmResourceInfoCommon.Surf.__Platform.eProductFamily); + dst.GmmResourceInfoCommon.Surf.__Platform.ePCHProductFamily.setValue(src.GmmResourceInfoCommon.Surf.__Platform.ePCHProductFamily); + dst.GmmResourceInfoCommon.Surf.__Platform.eDisplayCoreFamily.setValue(src.GmmResourceInfoCommon.Surf.__Platform.eDisplayCoreFamily); + dst.GmmResourceInfoCommon.Surf.__Platform.eRenderCoreFamily.setValue(src.GmmResourceInfoCommon.Surf.__Platform.eRenderCoreFamily); + dst.GmmResourceInfoCommon.Surf.__Platform.ePlatformType.setValue(src.GmmResourceInfoCommon.Surf.__Platform.ePlatformType); + dst.GmmResourceInfoCommon.Surf.__Platform.usDeviceID.setValue(src.GmmResourceInfoCommon.Surf.__Platform.usDeviceID); + dst.GmmResourceInfoCommon.Surf.__Platform.usRevId.setValue(src.GmmResourceInfoCommon.Surf.__Platform.usRevId); + dst.GmmResourceInfoCommon.Surf.__Platform.usDeviceID_PCH.setValue(src.GmmResourceInfoCommon.Surf.__Platform.usDeviceID_PCH); + dst.GmmResourceInfoCommon.Surf.__Platform.usRevId_PCH.setValue(src.GmmResourceInfoCommon.Surf.__Platform.usRevId_PCH); + dst.GmmResourceInfoCommon.Surf.__Platform.eGTType.setValue(src.GmmResourceInfoCommon.Surf.__Platform.eGTType); +#endif + dst.GmmResourceInfoCommon.AuxSurf.Type.setValue(src.GmmResourceInfoCommon.AuxSurf.Type); + dst.GmmResourceInfoCommon.AuxSurf.Format.setValue(src.GmmResourceInfoCommon.AuxSurf.Format); + dst.GmmResourceInfoCommon.AuxSurf.BitsPerPixel.setValue(src.GmmResourceInfoCommon.AuxSurf.BitsPerPixel); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.CameraCapture.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.CameraCapture); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.CCS.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.CCS); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ColorDiscard.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ColorDiscard); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ColorSeparation.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ColorSeparation); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ColorSeparationRGBX.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ColorSeparationRGBX); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Constant.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Constant); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Depth.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Depth); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.FlipChain.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.FlipChain); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.FlipChainPreferred.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.FlipChainPreferred); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.HistoryBuffer.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.HistoryBuffer); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.HiZ.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.HiZ); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Index.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Index); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.IndirectClearColor.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.IndirectClearColor); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.InstructionFlat.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.InstructionFlat); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.InterlacedScan.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.InterlacedScan); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.MCS.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.MCS); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.MMC.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.MMC); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.MotionComp.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.MotionComp); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.NoRestriction.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.NoRestriction); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Overlay.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Overlay); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Presentable.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Presentable); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ProceduralTexture.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ProceduralTexture); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Query.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Query); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.RenderTarget.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.RenderTarget); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.S3d.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.S3d); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.S3dDx.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.S3dDx); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__S3dNonPacked.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__S3dNonPacked); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__S3dWidi.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__S3dWidi); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ScratchFlat.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ScratchFlat); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.SeparateStencil.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.SeparateStencil); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.State.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.State); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.StateDx9ConstantBuffer.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.StateDx9ConstantBuffer); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Stream.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Stream); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.TextApi.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.TextApi); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Texture.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Texture); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.TiledResource.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.TiledResource); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.TilePool.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.TilePool); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.UnifiedAuxSurface.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.UnifiedAuxSurface); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Vertex.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Vertex); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Video.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Video); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__NonMsaaTileXCcs.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__NonMsaaTileXCcs); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__NonMsaaTileYCcs.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__NonMsaaTileYCcs); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__MsaaTileMcs.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__MsaaTileMcs); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__NonMsaaLinearCCS.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__NonMsaaLinearCCS); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__Remaining.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__Remaining); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.AllowVirtualPadding.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.AllowVirtualPadding); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.BigPage.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.BigPage); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Cacheable.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.Cacheable); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.ContigPhysMemoryForiDART.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.ContigPhysMemoryForiDART); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.CornerTexelMode.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.CornerTexelMode); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.ExistingSysMem.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.ExistingSysMem); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.ForceResidency.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.ForceResidency); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Gfdt.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.Gfdt); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.GttMapType.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.GttMapType); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.HardwareProtected.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.HardwareProtected); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.KernelModeMapped.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.KernelModeMapped); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.LayoutBelow.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.LayoutBelow); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.LayoutMono.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.LayoutMono); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.LayoutRight.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.LayoutRight); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.LocalOnly.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.LocalOnly); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Linear.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.Linear); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.MediaCompressed.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.MediaCompressed); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.NoOptimizationPadding.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.NoOptimizationPadding); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.NoPhysMemory.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.NoPhysMemory); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.NotLockable.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.NotLockable); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.NonLocalOnly.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.NonLocalOnly); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.StdSwizzle.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.StdSwizzle); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.PseudoStdSwizzle.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.PseudoStdSwizzle); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Undefined64KBSwizzle.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.Undefined64KBSwizzle); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.RedecribedPlanes.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.RedecribedPlanes); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.RenderCompressed.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.RenderCompressed); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Rotated.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.Rotated); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Shared.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.Shared); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.SoftwareProtected.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.SoftwareProtected); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.SVM.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.SVM); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Tile4.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.Tile4); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Tile64.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.Tile64); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledW.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledW); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledX.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledX); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledY.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledY); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledYf.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledYf); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledYs.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledYs); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.WddmProtected.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.WddmProtected); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.XAdapter.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.XAdapter); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.__PreallocatedResInfo.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.__PreallocatedResInfo); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.__PreWddm2SVM.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Info.__PreWddm2SVM); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.NoBufferSamplerPadding.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Wa.NoBufferSamplerPadding); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.CHVAstcSkipVirtualMips.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Wa.CHVAstcSkipVirtualMips); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DisablePackedMipTail.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DisablePackedMipTail); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.__ForceOtherHVALIGN4.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Wa.__ForceOtherHVALIGN4); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DisableDisplayCcsClearColor.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DisableDisplayCcsClearColor); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DisableDisplayCcsCompression.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DisableDisplayCcsCompression); + dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.PreGen12FastClearOnly.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Wa.PreGen12FastClearOnly); + dst.GmmResourceInfoCommon.AuxSurf.BaseWidth.setValue(src.GmmResourceInfoCommon.AuxSurf.BaseWidth); + dst.GmmResourceInfoCommon.AuxSurf.BaseHeight.setValue(src.GmmResourceInfoCommon.AuxSurf.BaseHeight); + dst.GmmResourceInfoCommon.AuxSurf.Depth.setValue(src.GmmResourceInfoCommon.AuxSurf.Depth); + dst.GmmResourceInfoCommon.AuxSurf.MaxLod.setValue(src.GmmResourceInfoCommon.AuxSurf.MaxLod); + dst.GmmResourceInfoCommon.AuxSurf.ArraySize.setValue(src.GmmResourceInfoCommon.AuxSurf.ArraySize); + dst.GmmResourceInfoCommon.AuxSurf.CpTag.setValue(src.GmmResourceInfoCommon.AuxSurf.CpTag); + dst.GmmResourceInfoCommon.AuxSurf.CachePolicy.Usage.setValue(src.GmmResourceInfoCommon.AuxSurf.CachePolicy.Usage); + dst.GmmResourceInfoCommon.AuxSurf.MSAA.SamplePattern.setValue(src.GmmResourceInfoCommon.AuxSurf.MSAA.SamplePattern); + dst.GmmResourceInfoCommon.AuxSurf.MSAA.NumSamples.setValue(src.GmmResourceInfoCommon.AuxSurf.MSAA.NumSamples); + dst.GmmResourceInfoCommon.AuxSurf.Alignment.ArraySpacingSingleLod.setValue(src.GmmResourceInfoCommon.AuxSurf.Alignment.ArraySpacingSingleLod); + dst.GmmResourceInfoCommon.AuxSurf.Alignment.BaseAlignment.setValue(src.GmmResourceInfoCommon.AuxSurf.Alignment.BaseAlignment); + dst.GmmResourceInfoCommon.AuxSurf.Alignment.HAlign.setValue(src.GmmResourceInfoCommon.AuxSurf.Alignment.HAlign); + dst.GmmResourceInfoCommon.AuxSurf.Alignment.VAlign.setValue(src.GmmResourceInfoCommon.AuxSurf.Alignment.VAlign); + dst.GmmResourceInfoCommon.AuxSurf.Alignment.DAlign.setValue(src.GmmResourceInfoCommon.AuxSurf.Alignment.DAlign); + dst.GmmResourceInfoCommon.AuxSurf.Alignment.MipTailStartLod.setValue(src.GmmResourceInfoCommon.AuxSurf.Alignment.MipTailStartLod); + dst.GmmResourceInfoCommon.AuxSurf.Alignment.PackedMipStartLod.setValue(src.GmmResourceInfoCommon.AuxSurf.Alignment.PackedMipStartLod); + dst.GmmResourceInfoCommon.AuxSurf.Alignment.PackedMipWidth.setValue(src.GmmResourceInfoCommon.AuxSurf.Alignment.PackedMipWidth); + dst.GmmResourceInfoCommon.AuxSurf.Alignment.PackedMipHeight.setValue(src.GmmResourceInfoCommon.AuxSurf.Alignment.PackedMipHeight); + dst.GmmResourceInfoCommon.AuxSurf.Alignment.QPitch.setValue(src.GmmResourceInfoCommon.AuxSurf.Alignment.QPitch); + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.MmcMode.getValue(), dst.GmmResourceInfoCommon.AuxSurf.MmcMode.getValueSizeInBytes(), src.GmmResourceInfoCommon.AuxSurf.MmcMode, sizeof(src.GmmResourceInfoCommon.AuxSurf.MmcMode)); + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.MmcHint.getValue(), dst.GmmResourceInfoCommon.AuxSurf.MmcHint.getValueSizeInBytes(), src.GmmResourceInfoCommon.AuxSurf.MmcHint, sizeof(src.GmmResourceInfoCommon.AuxSurf.MmcHint)); + dst.GmmResourceInfoCommon.AuxSurf.Pitch.setValue(src.GmmResourceInfoCommon.AuxSurf.Pitch); + dst.GmmResourceInfoCommon.AuxSurf.OverridePitch.setValue(src.GmmResourceInfoCommon.AuxSurf.OverridePitch); + dst.GmmResourceInfoCommon.AuxSurf.Size.setValue(src.GmmResourceInfoCommon.AuxSurf.Size); + dst.GmmResourceInfoCommon.AuxSurf.CCSize.setValue(src.GmmResourceInfoCommon.AuxSurf.CCSize); + dst.GmmResourceInfoCommon.AuxSurf.UnpaddedSize.setValue(src.GmmResourceInfoCommon.AuxSurf.UnpaddedSize); + dst.GmmResourceInfoCommon.AuxSurf.SizeReportToOS.setValue(src.GmmResourceInfoCommon.AuxSurf.SizeReportToOS); + dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch.setValue(src.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch); + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset.getValue(), dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset.getValueSizeInBytes(), src.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(src.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset)); + dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock.setValue(src.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock); + dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender.setValue(src.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender); + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset.getValue(), dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset.getValueSizeInBytes(), src.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(src.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset)); + dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.ArrayQPitch.setValue(src.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.ArrayQPitch); + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.X.getValue(), dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.X.getValueSizeInBytes(), src.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.X, sizeof(src.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.X)); + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.Y.getValue(), dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.Y.getValueSizeInBytes(), src.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.Y, sizeof(src.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.Y)); + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.UnAligned.Height.getValue(), dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.UnAligned.Height.getValueSizeInBytes(), src.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.UnAligned.Height, sizeof(src.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.UnAligned.Height)); + dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.NoOfPlanes.setValue(src.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.NoOfPlanes); + dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.IsTileAlignedPlanes.setValue(src.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.IsTileAlignedPlanes); + dst.GmmResourceInfoCommon.AuxSurf.TileMode.setValue(src.GmmResourceInfoCommon.AuxSurf.TileMode); + dst.GmmResourceInfoCommon.AuxSurf.CCSModeAlign.setValue(src.GmmResourceInfoCommon.AuxSurf.CCSModeAlign); + dst.GmmResourceInfoCommon.AuxSurf.LegacyFlags.setValue(src.GmmResourceInfoCommon.AuxSurf.LegacyFlags); + dst.GmmResourceInfoCommon.AuxSurf.S3d.DisplayModeHeight.setValue(src.GmmResourceInfoCommon.AuxSurf.S3d.DisplayModeHeight); + dst.GmmResourceInfoCommon.AuxSurf.S3d.NumBlankActiveLines.setValue(src.GmmResourceInfoCommon.AuxSurf.S3d.NumBlankActiveLines); + dst.GmmResourceInfoCommon.AuxSurf.S3d.RFrameOffset.setValue(src.GmmResourceInfoCommon.AuxSurf.S3d.RFrameOffset); + dst.GmmResourceInfoCommon.AuxSurf.S3d.BlankAreaOffset.setValue(src.GmmResourceInfoCommon.AuxSurf.S3d.BlankAreaOffset); + dst.GmmResourceInfoCommon.AuxSurf.S3d.TallBufferHeight.setValue(src.GmmResourceInfoCommon.AuxSurf.S3d.TallBufferHeight); + dst.GmmResourceInfoCommon.AuxSurf.S3d.TallBufferSize.setValue(src.GmmResourceInfoCommon.AuxSurf.S3d.TallBufferSize); + dst.GmmResourceInfoCommon.AuxSurf.S3d.IsRFrame.setValue(src.GmmResourceInfoCommon.AuxSurf.S3d.IsRFrame); + dst.GmmResourceInfoCommon.AuxSurf.SegmentOverride.Seg1.setValue(src.GmmResourceInfoCommon.AuxSurf.SegmentOverride.Seg1); + dst.GmmResourceInfoCommon.AuxSurf.SegmentOverride.Evict.setValue(src.GmmResourceInfoCommon.AuxSurf.SegmentOverride.Evict); + dst.GmmResourceInfoCommon.AuxSurf.MaximumRenamingListLength.setValue(src.GmmResourceInfoCommon.AuxSurf.MaximumRenamingListLength); +#if _DEBUG || _RELEASE_INTERNAL + dst.GmmResourceInfoCommon.AuxSurf.Platform.eProductFamily.setValue(src.GmmResourceInfoCommon.AuxSurf.Platform.eProductFamily); + dst.GmmResourceInfoCommon.AuxSurf.Platform.ePCHProductFamily.setValue(src.GmmResourceInfoCommon.AuxSurf.Platform.ePCHProductFamily); + dst.GmmResourceInfoCommon.AuxSurf.Platform.eDisplayCoreFamily.setValue(src.GmmResourceInfoCommon.AuxSurf.Platform.eDisplayCoreFamily); + dst.GmmResourceInfoCommon.AuxSurf.Platform.eRenderCoreFamily.setValue(src.GmmResourceInfoCommon.AuxSurf.Platform.eRenderCoreFamily); + dst.GmmResourceInfoCommon.AuxSurf.Platform.ePlatformType.setValue(src.GmmResourceInfoCommon.AuxSurf.Platform.ePlatformType); + dst.GmmResourceInfoCommon.AuxSurf.Platform.usDeviceID.setValue(src.GmmResourceInfoCommon.AuxSurf.Platform.usDeviceID); + dst.GmmResourceInfoCommon.AuxSurf.Platform.usRevId.setValue(src.GmmResourceInfoCommon.AuxSurf.Platform.usRevId); + dst.GmmResourceInfoCommon.AuxSurf.Platform.usDeviceID_PCH.setValue(src.GmmResourceInfoCommon.AuxSurf.Platform.usDeviceID_PCH); + dst.GmmResourceInfoCommon.AuxSurf.Platform.usRevId_PCH.setValue(src.GmmResourceInfoCommon.AuxSurf.Platform.usRevId_PCH); + dst.GmmResourceInfoCommon.AuxSurf.Platform.eGTType.setValue(src.GmmResourceInfoCommon.AuxSurf.Platform.eGTType); +#endif + dst.GmmResourceInfoCommon.AuxSurf.ExistingSysMem.IsGmmAllocated.setValue(src.GmmResourceInfoCommon.AuxSurf.ExistingSysMem.IsGmmAllocated); + dst.GmmResourceInfoCommon.AuxSurf.ExistingSysMem.IsPageAligned.setValue(src.GmmResourceInfoCommon.AuxSurf.ExistingSysMem.IsPageAligned); +#if !(_DEBUG || _RELEASE_INTERNAL) + dst.GmmResourceInfoCommon.AuxSurf.__Platform.eProductFamily.setValue(src.GmmResourceInfoCommon.AuxSurf.__Platform.eProductFamily); + dst.GmmResourceInfoCommon.AuxSurf.__Platform.ePCHProductFamily.setValue(src.GmmResourceInfoCommon.AuxSurf.__Platform.ePCHProductFamily); + dst.GmmResourceInfoCommon.AuxSurf.__Platform.eDisplayCoreFamily.setValue(src.GmmResourceInfoCommon.AuxSurf.__Platform.eDisplayCoreFamily); + dst.GmmResourceInfoCommon.AuxSurf.__Platform.eRenderCoreFamily.setValue(src.GmmResourceInfoCommon.AuxSurf.__Platform.eRenderCoreFamily); + dst.GmmResourceInfoCommon.AuxSurf.__Platform.ePlatformType.setValue(src.GmmResourceInfoCommon.AuxSurf.__Platform.ePlatformType); + dst.GmmResourceInfoCommon.AuxSurf.__Platform.usDeviceID.setValue(src.GmmResourceInfoCommon.AuxSurf.__Platform.usDeviceID); + dst.GmmResourceInfoCommon.AuxSurf.__Platform.usRevId.setValue(src.GmmResourceInfoCommon.AuxSurf.__Platform.usRevId); + dst.GmmResourceInfoCommon.AuxSurf.__Platform.usDeviceID_PCH.setValue(src.GmmResourceInfoCommon.AuxSurf.__Platform.usDeviceID_PCH); + dst.GmmResourceInfoCommon.AuxSurf.__Platform.usRevId_PCH.setValue(src.GmmResourceInfoCommon.AuxSurf.__Platform.usRevId_PCH); + dst.GmmResourceInfoCommon.AuxSurf.__Platform.eGTType.setValue(src.GmmResourceInfoCommon.AuxSurf.__Platform.eGTType); +#endif + dst.GmmResourceInfoCommon.AuxSecSurf.Type.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Type); + dst.GmmResourceInfoCommon.AuxSecSurf.Format.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Format); + dst.GmmResourceInfoCommon.AuxSecSurf.BitsPerPixel.setValue(src.GmmResourceInfoCommon.AuxSecSurf.BitsPerPixel); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.CameraCapture.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.CameraCapture); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.CCS.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.CCS); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ColorDiscard.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ColorDiscard); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ColorSeparation.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ColorSeparation); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ColorSeparationRGBX.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ColorSeparationRGBX); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Constant.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Constant); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Depth.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Depth); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.FlipChain.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.FlipChain); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.FlipChainPreferred.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.FlipChainPreferred); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.HistoryBuffer.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.HistoryBuffer); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.HiZ.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.HiZ); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Index.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Index); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.IndirectClearColor.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.IndirectClearColor); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.InstructionFlat.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.InstructionFlat); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.InterlacedScan.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.InterlacedScan); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.MCS.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.MCS); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.MMC.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.MMC); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.MotionComp.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.MotionComp); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.NoRestriction.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.NoRestriction); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Overlay.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Overlay); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Presentable.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Presentable); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ProceduralTexture.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ProceduralTexture); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Query.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Query); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.RenderTarget.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.RenderTarget); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.S3d.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.S3d); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.S3dDx.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.S3dDx); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__S3dNonPacked.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__S3dNonPacked); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__S3dWidi.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__S3dWidi); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ScratchFlat.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ScratchFlat); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.SeparateStencil.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.SeparateStencil); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.State.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.State); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.StateDx9ConstantBuffer.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.StateDx9ConstantBuffer); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Stream.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Stream); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.TextApi.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.TextApi); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Texture.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Texture); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.TiledResource.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.TiledResource); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.TilePool.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.TilePool); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.UnifiedAuxSurface.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.UnifiedAuxSurface); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Vertex.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Vertex); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Video.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Video); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__NonMsaaTileXCcs.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__NonMsaaTileXCcs); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__NonMsaaTileYCcs.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__NonMsaaTileYCcs); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__MsaaTileMcs.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__MsaaTileMcs); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__NonMsaaLinearCCS.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__NonMsaaLinearCCS); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__Remaining.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__Remaining); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.AllowVirtualPadding.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.AllowVirtualPadding); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.BigPage.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.BigPage); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Cacheable.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Cacheable); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.ContigPhysMemoryForiDART.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.ContigPhysMemoryForiDART); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.CornerTexelMode.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.CornerTexelMode); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.ExistingSysMem.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.ExistingSysMem); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.ForceResidency.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.ForceResidency); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Gfdt.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Gfdt); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.GttMapType.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.GttMapType); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.HardwareProtected.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.HardwareProtected); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.KernelModeMapped.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.KernelModeMapped); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LayoutBelow.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LayoutBelow); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LayoutMono.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LayoutMono); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LayoutRight.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LayoutRight); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LocalOnly.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LocalOnly); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Linear.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Linear); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.MediaCompressed.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.MediaCompressed); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NoOptimizationPadding.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NoOptimizationPadding); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NoPhysMemory.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NoPhysMemory); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NotLockable.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NotLockable); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NonLocalOnly.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NonLocalOnly); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.StdSwizzle.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.StdSwizzle); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.PseudoStdSwizzle.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.PseudoStdSwizzle); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Undefined64KBSwizzle.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Undefined64KBSwizzle); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.RedecribedPlanes.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.RedecribedPlanes); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.RenderCompressed.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.RenderCompressed); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Rotated.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Rotated); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Shared.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Shared); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.SoftwareProtected.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.SoftwareProtected); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.SVM.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.SVM); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Tile4.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Tile4); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Tile64.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Tile64); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledW.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledW); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledX.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledX); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledY.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledY); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledYf.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledYf); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledYs.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledYs); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.WddmProtected.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.WddmProtected); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.XAdapter.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.XAdapter); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.__PreallocatedResInfo.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.__PreallocatedResInfo); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.__PreWddm2SVM.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.__PreWddm2SVM); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.NoBufferSamplerPadding.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.NoBufferSamplerPadding); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.CHVAstcSkipVirtualMips.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.CHVAstcSkipVirtualMips); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DisablePackedMipTail.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DisablePackedMipTail); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.__ForceOtherHVALIGN4.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.__ForceOtherHVALIGN4); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DisableDisplayCcsClearColor.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DisableDisplayCcsClearColor); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DisableDisplayCcsCompression.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DisableDisplayCcsCompression); + dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.PreGen12FastClearOnly.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.PreGen12FastClearOnly); + dst.GmmResourceInfoCommon.AuxSecSurf.BaseWidth.setValue(src.GmmResourceInfoCommon.AuxSecSurf.BaseWidth); + dst.GmmResourceInfoCommon.AuxSecSurf.BaseHeight.setValue(src.GmmResourceInfoCommon.AuxSecSurf.BaseHeight); + dst.GmmResourceInfoCommon.AuxSecSurf.Depth.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Depth); + dst.GmmResourceInfoCommon.AuxSecSurf.MaxLod.setValue(src.GmmResourceInfoCommon.AuxSecSurf.MaxLod); + dst.GmmResourceInfoCommon.AuxSecSurf.ArraySize.setValue(src.GmmResourceInfoCommon.AuxSecSurf.ArraySize); + dst.GmmResourceInfoCommon.AuxSecSurf.CpTag.setValue(src.GmmResourceInfoCommon.AuxSecSurf.CpTag); + dst.GmmResourceInfoCommon.AuxSecSurf.CachePolicy.Usage.setValue(src.GmmResourceInfoCommon.AuxSecSurf.CachePolicy.Usage); + dst.GmmResourceInfoCommon.AuxSecSurf.MSAA.SamplePattern.setValue(src.GmmResourceInfoCommon.AuxSecSurf.MSAA.SamplePattern); + dst.GmmResourceInfoCommon.AuxSecSurf.MSAA.NumSamples.setValue(src.GmmResourceInfoCommon.AuxSecSurf.MSAA.NumSamples); + dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.ArraySpacingSingleLod.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Alignment.ArraySpacingSingleLod); + dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.BaseAlignment.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Alignment.BaseAlignment); + dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.HAlign.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Alignment.HAlign); + dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.VAlign.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Alignment.VAlign); + dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.DAlign.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Alignment.DAlign); + dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.MipTailStartLod.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Alignment.MipTailStartLod); + dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.PackedMipStartLod.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Alignment.PackedMipStartLod); + dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.PackedMipWidth.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Alignment.PackedMipWidth); + dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.PackedMipHeight.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Alignment.PackedMipHeight); + dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.QPitch.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Alignment.QPitch); + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.MmcMode.getValue(), dst.GmmResourceInfoCommon.AuxSecSurf.MmcMode.getValueSizeInBytes(), src.GmmResourceInfoCommon.AuxSecSurf.MmcMode, sizeof(src.GmmResourceInfoCommon.AuxSecSurf.MmcMode)); + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.MmcHint.getValue(), dst.GmmResourceInfoCommon.AuxSecSurf.MmcHint.getValueSizeInBytes(), src.GmmResourceInfoCommon.AuxSecSurf.MmcHint, sizeof(src.GmmResourceInfoCommon.AuxSecSurf.MmcHint)); + dst.GmmResourceInfoCommon.AuxSecSurf.Pitch.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Pitch); + dst.GmmResourceInfoCommon.AuxSecSurf.OverridePitch.setValue(src.GmmResourceInfoCommon.AuxSecSurf.OverridePitch); + dst.GmmResourceInfoCommon.AuxSecSurf.Size.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Size); + dst.GmmResourceInfoCommon.AuxSecSurf.CCSize.setValue(src.GmmResourceInfoCommon.AuxSecSurf.CCSize); + dst.GmmResourceInfoCommon.AuxSecSurf.UnpaddedSize.setValue(src.GmmResourceInfoCommon.AuxSecSurf.UnpaddedSize); + dst.GmmResourceInfoCommon.AuxSecSurf.SizeReportToOS.setValue(src.GmmResourceInfoCommon.AuxSecSurf.SizeReportToOS); + dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch.setValue(src.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch); + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset.getValue(), dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset.getValueSizeInBytes(), src.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(src.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset)); + dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock.setValue(src.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock); + dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender.setValue(src.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender); + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset.getValue(), dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset.getValueSizeInBytes(), src.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(src.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset)); + dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.ArrayQPitch.setValue(src.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.ArrayQPitch); + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.X.getValue(), dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.X.getValueSizeInBytes(), src.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.X, sizeof(src.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.X)); + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.Y.getValue(), dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.Y.getValueSizeInBytes(), src.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.Y, sizeof(src.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.Y)); + WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height.getValue(), dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height.getValueSizeInBytes(), src.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height, sizeof(src.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height)); + dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.NoOfPlanes.setValue(src.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.NoOfPlanes); + dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.IsTileAlignedPlanes.setValue(src.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.IsTileAlignedPlanes); + dst.GmmResourceInfoCommon.AuxSecSurf.TileMode.setValue(src.GmmResourceInfoCommon.AuxSecSurf.TileMode); + dst.GmmResourceInfoCommon.AuxSecSurf.CCSModeAlign.setValue(src.GmmResourceInfoCommon.AuxSecSurf.CCSModeAlign); + dst.GmmResourceInfoCommon.AuxSecSurf.LegacyFlags.setValue(src.GmmResourceInfoCommon.AuxSecSurf.LegacyFlags); + dst.GmmResourceInfoCommon.AuxSecSurf.S3d.DisplayModeHeight.setValue(src.GmmResourceInfoCommon.AuxSecSurf.S3d.DisplayModeHeight); + dst.GmmResourceInfoCommon.AuxSecSurf.S3d.NumBlankActiveLines.setValue(src.GmmResourceInfoCommon.AuxSecSurf.S3d.NumBlankActiveLines); + dst.GmmResourceInfoCommon.AuxSecSurf.S3d.RFrameOffset.setValue(src.GmmResourceInfoCommon.AuxSecSurf.S3d.RFrameOffset); + dst.GmmResourceInfoCommon.AuxSecSurf.S3d.BlankAreaOffset.setValue(src.GmmResourceInfoCommon.AuxSecSurf.S3d.BlankAreaOffset); + dst.GmmResourceInfoCommon.AuxSecSurf.S3d.TallBufferHeight.setValue(src.GmmResourceInfoCommon.AuxSecSurf.S3d.TallBufferHeight); + dst.GmmResourceInfoCommon.AuxSecSurf.S3d.TallBufferSize.setValue(src.GmmResourceInfoCommon.AuxSecSurf.S3d.TallBufferSize); + dst.GmmResourceInfoCommon.AuxSecSurf.S3d.IsRFrame.setValue(src.GmmResourceInfoCommon.AuxSecSurf.S3d.IsRFrame); + dst.GmmResourceInfoCommon.AuxSecSurf.SegmentOverride.Seg1.setValue(src.GmmResourceInfoCommon.AuxSecSurf.SegmentOverride.Seg1); + dst.GmmResourceInfoCommon.AuxSecSurf.SegmentOverride.Evict.setValue(src.GmmResourceInfoCommon.AuxSecSurf.SegmentOverride.Evict); + dst.GmmResourceInfoCommon.AuxSecSurf.MaximumRenamingListLength.setValue(src.GmmResourceInfoCommon.AuxSecSurf.MaximumRenamingListLength); +#if _DEBUG || _RELEASE_INTERNAL + dst.GmmResourceInfoCommon.AuxSecSurf.Platform.eProductFamily.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Platform.eProductFamily); + dst.GmmResourceInfoCommon.AuxSecSurf.Platform.ePCHProductFamily.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Platform.ePCHProductFamily); + dst.GmmResourceInfoCommon.AuxSecSurf.Platform.eDisplayCoreFamily.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Platform.eDisplayCoreFamily); + dst.GmmResourceInfoCommon.AuxSecSurf.Platform.eRenderCoreFamily.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Platform.eRenderCoreFamily); + dst.GmmResourceInfoCommon.AuxSecSurf.Platform.ePlatformType.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Platform.ePlatformType); + dst.GmmResourceInfoCommon.AuxSecSurf.Platform.usDeviceID.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Platform.usDeviceID); + dst.GmmResourceInfoCommon.AuxSecSurf.Platform.usRevId.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Platform.usRevId); + dst.GmmResourceInfoCommon.AuxSecSurf.Platform.usDeviceID_PCH.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Platform.usDeviceID_PCH); + dst.GmmResourceInfoCommon.AuxSecSurf.Platform.usRevId_PCH.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Platform.usRevId_PCH); + dst.GmmResourceInfoCommon.AuxSecSurf.Platform.eGTType.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Platform.eGTType); +#endif + dst.GmmResourceInfoCommon.AuxSecSurf.ExistingSysMem.IsGmmAllocated.setValue(src.GmmResourceInfoCommon.AuxSecSurf.ExistingSysMem.IsGmmAllocated); + dst.GmmResourceInfoCommon.AuxSecSurf.ExistingSysMem.IsPageAligned.setValue(src.GmmResourceInfoCommon.AuxSecSurf.ExistingSysMem.IsPageAligned); +#if !(_DEBUG || _RELEASE_INTERNAL) + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eProductFamily.setValue(src.GmmResourceInfoCommon.AuxSecSurf.__Platform.eProductFamily); + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.ePCHProductFamily.setValue(src.GmmResourceInfoCommon.AuxSecSurf.__Platform.ePCHProductFamily); + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eDisplayCoreFamily.setValue(src.GmmResourceInfoCommon.AuxSecSurf.__Platform.eDisplayCoreFamily); + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eRenderCoreFamily.setValue(src.GmmResourceInfoCommon.AuxSecSurf.__Platform.eRenderCoreFamily); + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.ePlatformType.setValue(src.GmmResourceInfoCommon.AuxSecSurf.__Platform.ePlatformType); + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usDeviceID.setValue(src.GmmResourceInfoCommon.AuxSecSurf.__Platform.usDeviceID); + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usRevId.setValue(src.GmmResourceInfoCommon.AuxSecSurf.__Platform.usRevId); + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usDeviceID_PCH.setValue(src.GmmResourceInfoCommon.AuxSecSurf.__Platform.usDeviceID_PCH); + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usRevId_PCH.setValue(src.GmmResourceInfoCommon.AuxSecSurf.__Platform.usRevId_PCH); + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eGTType.setValue(src.GmmResourceInfoCommon.AuxSecSurf.__Platform.eGTType); +#endif + dst.GmmResourceInfoCommon.RotateInfo.setValue(src.GmmResourceInfoCommon.RotateInfo); + dst.GmmResourceInfoCommon.ExistingSysMem.pExistingSysMem.setValue(src.GmmResourceInfoCommon.ExistingSysMem.pExistingSysMem); + dst.GmmResourceInfoCommon.ExistingSysMem.pVirtAddress.setValue(src.GmmResourceInfoCommon.ExistingSysMem.pVirtAddress); + dst.GmmResourceInfoCommon.ExistingSysMem.pGfxAlignedVirtAddress.setValue(src.GmmResourceInfoCommon.ExistingSysMem.pGfxAlignedVirtAddress); + dst.GmmResourceInfoCommon.ExistingSysMem.Size.setValue(src.GmmResourceInfoCommon.ExistingSysMem.Size); + dst.GmmResourceInfoCommon.ExistingSysMem.IsGmmAllocated.setValue(src.GmmResourceInfoCommon.ExistingSysMem.IsGmmAllocated); + dst.GmmResourceInfoCommon.SvmAddress.setValue(src.GmmResourceInfoCommon.SvmAddress); + dst.GmmResourceInfoCommon.pPrivateData.setValue(src.GmmResourceInfoCommon.pPrivateData); + dst.GmmResourceInfoCommon.MultiTileArch.Enable.setValue(src.GmmResourceInfoCommon.MultiTileArch.Enable); + dst.GmmResourceInfoCommon.MultiTileArch.TileInstanced.setValue(src.GmmResourceInfoCommon.MultiTileArch.TileInstanced); + dst.GmmResourceInfoCommon.MultiTileArch.GpuVaMappingSet.setValue(src.GmmResourceInfoCommon.MultiTileArch.GpuVaMappingSet); + dst.GmmResourceInfoCommon.MultiTileArch.LocalMemEligibilitySet.setValue(src.GmmResourceInfoCommon.MultiTileArch.LocalMemEligibilitySet); + dst.GmmResourceInfoCommon.MultiTileArch.LocalMemPreferredSet.setValue(src.GmmResourceInfoCommon.MultiTileArch.LocalMemPreferredSet); +} +template <> +struct Marshaller { + template + static TOKSTR_GmmResourceInfoWinStruct marshall(const GmmResourceInfoWinStructT &src) { + TOKSTR_GmmResourceInfoWinStruct ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_GFX_ESCAPE_HEADER &dst, const GFX_ESCAPE_HEADERT &src) { + dst = {}; + dst.Size.setValue(src.Size); + dst.CheckSum.setValue(src.CheckSum); + dst.EscapeCode.setValue(src.EscapeCode); + dst.ulReserved.setValue(src.ulReserved); + dst.ulReserved1.setValue(src.ulReserved1); + dst.usEscapeVersion.setValue(src.usEscapeVersion); + dst.usFileVersion.setValue(src.usFileVersion); + dst.ulMajorEscapeCode.setValue(src.ulMajorEscapeCode); + dst.uiMinorEscapeCode.setValue(src.uiMinorEscapeCode); +} +template <> +struct Marshaller { + template + static TOKSTR_GFX_ESCAPE_HEADER marshall(const GFX_ESCAPE_HEADERT &src) { + TOKSTR_GFX_ESCAPE_HEADER ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_GTDIBaseInStruct &dst, const GTDIBaseInStructT &src) { + dst = {}; + dst.Function.setValue(src.Function); +} +template <> +struct Marshaller { + template + static TOKSTR_GTDIBaseInStruct marshall(const GTDIBaseInStructT &src) { + TOKSTR_GTDIBaseInStruct ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_GTDIGetGpuCpuTimestampsOutStruct &dst, const GTDIGetGpuCpuTimestampsOutStructT &src) { + dst = {}; + dst.RetCode.setValue(src.RetCode); + dst.gpuPerfTicks.setValue(src.gpuPerfTicks); + dst.cpuPerfTicks.setValue(src.cpuPerfTicks); + dst.gpuPerfFreq.setValue(src.gpuPerfFreq); + dst.cpuPerfFreq.setValue(src.cpuPerfFreq); +} +template <> +struct Marshaller { + template + static TOKSTR_GTDIGetGpuCpuTimestampsOutStruct marshall(const GTDIGetGpuCpuTimestampsOutStructT &src) { + TOKSTR_GTDIGetGpuCpuTimestampsOutStruct ret = {}; + ::marshall(ret, src); + return ret; + } +}; + +template +inline void marshall(TOKSTR_TimeStampDataHeader &dst, const TimeStampDataHeaderT &src) { + dst = {}; + dst.m_Header.Size.setValue(src.m_Header.Size); + dst.m_Header.CheckSum.setValue(src.m_Header.CheckSum); + dst.m_Header.EscapeCode.setValue(src.m_Header.EscapeCode); + dst.m_Header.ulReserved.setValue(src.m_Header.ulReserved); + dst.m_Header.ulReserved1.setValue(src.m_Header.ulReserved1); + dst.m_Header.usEscapeVersion.setValue(src.m_Header.usEscapeVersion); + dst.m_Header.usFileVersion.setValue(src.m_Header.usFileVersion); + dst.m_Header.ulMajorEscapeCode.setValue(src.m_Header.ulMajorEscapeCode); + dst.m_Header.uiMinorEscapeCode.setValue(src.m_Header.uiMinorEscapeCode); + dst.m_Data.m_In.Function.setValue(src.m_Data.m_In.Function); + dst.m_Data.m_Out.RetCode.setValue(src.m_Data.m_Out.RetCode); + dst.m_Data.m_Out.gpuPerfTicks.setValue(src.m_Data.m_Out.gpuPerfTicks); + dst.m_Data.m_Out.cpuPerfTicks.setValue(src.m_Data.m_Out.cpuPerfTicks); + dst.m_Data.m_Out.gpuPerfFreq.setValue(src.m_Data.m_Out.gpuPerfFreq); + dst.m_Data.m_Out.cpuPerfFreq.setValue(src.m_Data.m_Out.cpuPerfFreq); +} +template <> +struct Marshaller { + template + static TOKSTR_TimeStampDataHeader marshall(const TimeStampDataHeaderT &src) { + TOKSTR_TimeStampDataHeader ret = {}; + ::marshall(ret, src); + return ret; + } +}; diff --git a/shared/wsl_compute_helper/source/wsl_compute_helper_types_tokens.h b/shared/wsl_compute_helper/source/wsl_compute_helper_types_tokens.h new file mode 100644 index 0000000000..2cf33567ab --- /dev/null +++ b/shared/wsl_compute_helper/source/wsl_compute_helper_types_tokens.h @@ -0,0 +1,896 @@ +/* + * Copyright (C) 2021 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +// This is a generated file - please don't modify directly +#pragma once + +#include +#include +#include +#include +#include + +#ifndef WCH_SAFE_COPY +#ifdef WIN32 +#define WCH_SAFE_COPY memcpy_s +#else +inline int safeCopy(void *dst, size_t dstSize, const void *src, size_t sizeToCopy) { + if (0 == sizeToCopy) { + return 0; + } + if (!dst || !src || (sizeToCopy > dstSize)) { + return -1; + } + memcpy(dst, src, sizeToCopy); + return 0; +} +#define WCH_SAFE_COPY safeCopy +#endif +#endif + +#ifndef WCH_ASSERT +#define WCH_ASSERT assert +#endif + +struct TokenHeader { + TokenHeader(uint16_t tokenId, uint8_t valueDwordCount) : id(tokenId), valueDwordCount(valueDwordCount) {} + + uint16_t id = 0U; // token identifier + uint8_t valueDwordCount = 0U; // regular value length in dwords + union Flags { + struct { + bool flag0InlineValueBit0 : 1; // inline value bit 0 + bool flag1InlineValueBit1 : 1; // inline value bit 1 + bool flag2InlineValueBit2 : 1; // inline value bit 2 + bool flag3IsMandatory : 1; // if not 1, then can be ignored + bool flag4IsVariableLength : 1; // if 1, then token type is base of TokenVariableLength + bool flag6Reserved1 : 1; + bool flag6Reserved2 : 1; + bool flag7Reserved3 : 1; + }; + uint8_t packed = 0U; + } flags; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TokenHeader) == sizeof(uint32_t), ""); + +struct TokenVariableLength { + TokenHeader header; + + TokenVariableLength(uint16_t tokenId, uint32_t arrayElementId, uint32_t valueLengthInBytes, uint32_t valuePaddedSizeInDwords) + : header(tokenId, 0U), arrayElementId(arrayElementId), valueLengthInBytes(valueLengthInBytes), valuePaddedSizeInDwords(valuePaddedSizeInDwords) { + header.flags.flag4IsVariableLength = 1; + } + + TokenVariableLength(uint16_t tokenId, uint32_t arrayElementId, uint32_t valueLengthInBytes) + : header(tokenId, 0U), arrayElementId(arrayElementId), valueLengthInBytes(valueLengthInBytes) { + valuePaddedSizeInDwords = (valueLengthInBytes + sizeof(uint32_t) - 1) / sizeof(uint32_t); + header.flags.flag4IsVariableLength = 1; + } + + uint32_t arrayElementId = 0U; + uint32_t valueLengthInBytes = 0U; + uint32_t valuePaddedSizeInDwords = 1U; + + template + T *getValue() { + return reinterpret_cast(this + 1); + } + + template + const T *getValue() const { + return reinterpret_cast(this + 1); + } +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TokenVariableLength) == 3 * sizeof(uint32_t) + sizeof(TokenHeader), ""); + +template +struct TokenArray { + TokenHeader header; + + TokenArray(uint16_t tokenId, uint16_t elementSizeBits, uint16_t elementsCount) : header(tokenId, DwordsCount) { + WCH_ASSERT(elementSizeBits * elementsCount <= DwordsCount * sizeof(uint32_t) * 8); + } + + static_assert(DwordsCount <= 255, ""); + uint32_t value[DwordsCount] = {}; + + template + T *getValue() { + return reinterpret_cast(value); + } + + template + const T *getValue() const { + return reinterpret_cast(value); + } + + size_t getValueSizeInBytes() const { + return header.valueDwordCount * sizeof(uint32_t); + } +}; + +static_assert(std::is_standard_layout_v>, ""); +static_assert(sizeof(TokenArray<2>) == 2 * sizeof(uint32_t) + sizeof(TokenHeader), ""); + +struct TokenDword { + TokenHeader header; + + TokenDword(uint16_t tokenId) : header(tokenId, 1U) {} + + uint32_t value = 0U; + + constexpr uint32_t getValue() const { + return value; + } + + void setValue(uint32_t v) { + value = v; + } +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TokenDword) == sizeof(TokenHeader) + sizeof(uint32_t), ""); + +struct TokenQword { + TokenHeader header; + + TokenQword(uint16_t tokenId) : header(tokenId, 2U) {} + + uint32_t valueLo = 0U; + uint32_t valueHi = 0U; + + constexpr uint64_t getValue() const { + return (static_cast(valueHi) << 32) | valueLo; + } + + void setValue(uint64_t v) { + valueHi = static_cast(v >> 32); + valueLo = static_cast(v & 0x00000000FFFFFFFF); + } +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TokenQword) == sizeof(TokenHeader) + sizeof(uint64_t), ""); + +struct TokenBool : TokenHeader { + TokenBool(uint16_t tokenId) : TokenHeader(tokenId, 0U) {} + + constexpr bool getValue() const { + return TokenHeader::flags.flag0InlineValueBit0; + } + + void setValue(bool v) { + TokenHeader::flags.flag0InlineValueBit0 = (v != false); + } +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TokenBool) == sizeof(TokenHeader), ""); + +struct TokenPointer : TokenQword { + TokenPointer(uint16_t tokenId) : TokenQword(tokenId) {} + + template + constexpr T *getValue() const { + return reinterpret_cast(static_cast(TokenQword::getValue())); + } + + template + void setValue(T *v) { + TokenQword::setValue(static_cast(reinterpret_cast(v))); + } +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TokenPointer) == sizeof(TokenQword), ""); + +template +inline std::enable_if_t, T> readTokValue(const TokenHeader &token) { + T ret = {}; + switch (token.valueDwordCount) { + default: + WCH_ASSERT(false); + break; + case 0: + ret = {static_cast(reinterpret_cast(token).getValue())}; + break; + case 1: + ret = {static_cast(reinterpret_cast(token).getValue())}; + break; + case 2: + ret = {static_cast(reinterpret_cast(token).getValue())}; + break; + } + return ret; +} +template +inline std::enable_if_t, T> readTokValue(const TokenHeader &token) { + T ret = {}; + switch (token.valueDwordCount) { + default: + WCH_ASSERT(false); + break; + case 0: + ret = {reinterpret_cast(static_cast(reinterpret_cast(token).getValue()))}; + break; + case 1: + ret = {reinterpret_cast(static_cast(reinterpret_cast(token).getValue()))}; + break; + case 2: + ret = {reinterpret_cast(static_cast(reinterpret_cast(token).getValue()))}; + break; + } + return ret; +} + +// List of valid tokens +enum TOK : uint32_t { + TOK_S_ADAPTER_INFO = 1, + TOK_S_SKU_FEATURE_TABLE__ANONYMOUS89755 = 4, + TOK_S_GMM_RESOURCE_INFO_WIN_STRUCT = 7, + TOK_S_GMM_MULTI_TILE_ARCH_REC = 8, + TOK_S_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__ANONYMOUS32457__ANONYMOUS32501__ANONYMOUS32537 = 10, + TOK_S_GMM_RESOURCE_FLAG_REC = 12, + TOK_S_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882 = 14, + TOK_S_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__ANONYMOUS32457__ANONYMOUS32501__ANONYMOUS32680 = 16, + TOK_S_SKU_FEATURE_TABLE__ANONYMOUS42853 = 17, + TOK_S_SKU_FEATURE_TABLE = 19, + TOK_S_ADAPTER_BDF___ANONYMOUS8173 = 20, + TOK_S_WA_TABLE = 22, + TOK_S_GT_CCS_INFO__CCSINSTANCES = 25, + TOK_S_GFX_ESCAPE_HEADER = 26, + TOK_S_GMM_EXISTING_SYS_MEM_REC = 28, + TOK_S_GT_SUBSLICE_INFO = 29, + TOK_S_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT = 31, + TOK_S_GT_VDBOX_INFO__VDBOX_INSTANCES = 32, + TOK_S_CREATECONTEXT_PVTDATA = 33, + TOK_S_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193 = 36, + TOK_S_GT_VDBOX_INFO__ANONYMOUS5662 = 37, + TOK_S_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT = 39, + TOK_S_GT_DUALSUBSLICE_INFO = 41, + TOK_S_GMM_S3D_INFO_REC = 42, + TOK_S_GTDIBASE_IN_STRUCT = 43, + TOK_S_GFX_ESCAPE_HEADER__ANONYMOUS4410 = 44, + TOK_S_GT_SLICE_INFO = 47, + TOK_S_COMMAND_BUFFER_HEADER_REC = 48, + TOK_S_SKU_FEATURE_TABLE__ANONYMOUS3245 = 49, + TOK_S_SKU_FEATURE_TABLE__ANONYMOUS11155 = 51, + TOK_S_GT_MULTI_TILE_ARCH_INFO = 52, + TOK_S_SKU_FEATURE_TABLE__ANONYMOUS91822 = 53, + TOK_S_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430 = 54, + TOK_S_SKU_FEATURE_TABLE__ANONYMOUS21584 = 55, + TOK_S_GT_VEBOX_INFO = 56, + TOK_S_GMM_2D_TEXTURE_OFFSET_INFO_REC = 57, + TOK_S_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851 = 59, + TOK_S_GT_SQIDI_INFO = 61, + TOK_S_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856 = 62, + TOK_S_CREATECONTEXT_PVTDATA__ANONYMOUS18449 = 63, + TOK_S_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963 = 64, + TOK_S_SKU_FEATURE_TABLE__ANONYMOUS21990 = 65, + TOK_S_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682 = 66, + TOK_S_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401 = 67, + TOK_S_GT_VDBOX_INFO = 68, + TOK_S_GT_VEBOX_INFO__VEBOX_INSTANCES = 69, + TOK_S_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876 = 72, + TOK_S_KMD_CAPS_INFO = 73, + TOK_S_GT_VEBOX_INFO__ANONYMOUS3862 = 74, + TOK_S_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT = 75, + TOK_S_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__ANONYMOUS32457 = 76, + TOK_S_GMM_3D_TEXTURE_OFFSET_INFO_REC = 78, + TOK_S_KMD_OVERLAY_OVERRIDE = 79, + TOK_S_SKU_FEATURE_TABLE__ANONYMOUS54736 = 80, + TOK_S_GMM_RESOURCE_INFO_COMMON_STRUCT = 81, + TOK_S_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__ANONYMOUS32457__ANONYMOUS32501 = 82, + TOK_S_GT_CCS_INFO = 83, + TOK_S_GMM_OFFSET_INFO_REC = 84, + TOK_S_SKU_FEATURE_TABLE__ANONYMOUS66219 = 85, + TOK_S_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739 = 86, + TOK_S_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797 = 87, + TOK_S_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT = 88, + TOK_S_KMD_OVERLAY_CAPS_INFO = 91, + TOK_S_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521 = 92, + TOK_S_GMM_OFFSET_INFO_REC__ANONYMOUS3429 = 94, + TOK_S_TIME_STAMP_DATA_HEADER = 96, + TOK_S_GT_CACHE_TYPES = 97, + TOK_S_FRAME_RATE = 99, + TOK_S_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171 = 100, + TOK_S_GMM_RESOURCE_MSAA_INFO_REC = 102, + TOK_S_GMM_TEXTURE_INFO_REC = 103, + TOK_S_GMM_RESOURCE_ALIGNMENT_REC = 104, + TOK_S_GT_CACHE_TYPES__ANONYMOUS9544 = 105, + TOK_S_TIME_STAMP_DATA_HEADER__ANONYMOUS2466 = 109, + TOK_S_GMM_TEXTURE_INFO_REC__ANONYMOUS4927 = 111, + TOK_S_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191 = 112, + TOK_S_GMM_TEXTURE_INFO_REC__ANONYMOUS6185 = 113, + TOK_S_SKU_FEATURE_TABLE__ANONYMOUS88095 = 115, + TOK_S_GMM_TEXTURE_INFO_REC__ANONYMOUS6590 = 116, + TOK_S_GT_SYSTEM_INFO = 122, + TOK_S_KM_DEFERRED_WAIT_INFO = 123, + TOK_S_GMM_PLANAR_OFFSET_INFO_REC = 128, + TOK_S_SKU_FEATURE_TABLE__ANONYMOUS37751 = 134, + TOK_S_GMM_GFX_PARTITIONING = 135, + TOK_S_PLATFORM_STR = 141, + TOK_S_ADAPTER_BDF = 142, + TOK_S_GMM_GFX_PARTITIONING__ANONYMOUS7117 = 144, + TOK_FBB_GT_SUBSLICE_INFO__ENABLED = 195, + TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_COUNT = 196, + TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_MASK = 197, + TOK_FBB_GT_DUALSUBSLICE_INFO__ENABLED = 198, + TOK_FS_GT_DUALSUBSLICE_INFO__SUB_SLICE = 199, + TOK_FBB_GT_SLICE_INFO__ENABLED = 200, + TOK_FS_GT_SLICE_INFO__SUB_SLICE_INFO = 201, + TOK_FS_GT_SLICE_INFO__DSSINFO = 202, + TOK_FBD_GT_SLICE_INFO__SUB_SLICE_ENABLED_COUNT = 203, + TOK_FBD_GT_SLICE_INFO__DUAL_SUB_SLICE_ENABLED_COUNT = 204, + TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX0ENABLED = 205, + TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX1ENABLED = 206, + TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX2ENABLED = 207, + TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX3ENABLED = 208, + TOK_FS_GT_VEBOX_INFO__VEBOX_INSTANCES__BITS = 210, + TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBOX_ENABLE_MASK = 211, + TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX0 = 212, + TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX1 = 213, + TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX2 = 214, + TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX3 = 215, + TOK_FS_GT_VEBOX_INFO__ANONYMOUS3862__SFC_SUPPORTED_BITS = 217, + TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__VALUE = 218, + TOK_FS_GT_VEBOX_INFO__INSTANCES = 219, + TOK_FS_GT_VEBOX_INFO__SFCSUPPORT = 220, + TOK_FBD_GT_VEBOX_INFO__NUMBER_OF_VEBOX_ENABLED = 221, + TOK_FBB_GT_VEBOX_INFO__IS_VALID = 222, + TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX0ENABLED = 223, + TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX1ENABLED = 224, + TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX2ENABLED = 225, + TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX3ENABLED = 226, + TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX4ENABLED = 227, + TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX5ENABLED = 228, + TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX6ENABLED = 229, + TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX7ENABLED = 230, + TOK_FS_GT_VDBOX_INFO__VDBOX_INSTANCES__BITS = 232, + TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBOX_ENABLE_MASK = 233, + TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX0 = 234, + TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX1 = 235, + TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX2 = 236, + TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX3 = 237, + TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX4 = 238, + TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX5 = 239, + TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX6 = 240, + TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX7 = 241, + TOK_FS_GT_VDBOX_INFO__ANONYMOUS5662__SFC_SUPPORTED_BITS = 243, + TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__VALUE = 244, + TOK_FS_GT_VDBOX_INFO__INSTANCES = 245, + TOK_FS_GT_VDBOX_INFO__SFCSUPPORT = 246, + TOK_FBD_GT_VDBOX_INFO__NUMBER_OF_VDBOX_ENABLED = 247, + TOK_FBB_GT_VDBOX_INFO__IS_VALID = 248, + TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS0ENABLED = 257, + TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS1ENABLED = 258, + TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS2ENABLED = 259, + TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS3ENABLED = 260, + TOK_FS_GT_CCS_INFO__CCSINSTANCES__BITS = 262, + TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSENABLE_MASK = 263, + TOK_FS_GT_CCS_INFO__INSTANCES = 264, + TOK_FBD_GT_CCS_INFO__NUMBER_OF_CCSENABLED = 265, + TOK_FBB_GT_CCS_INFO__IS_VALID = 266, + TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE0 = 271, + TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE1 = 272, + TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE2 = 273, + TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE3 = 274, + TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__TILE_MASK = 276, + TOK_FBC_GT_MULTI_TILE_ARCH_INFO__TILE_COUNT = 277, + TOK_FBB_GT_MULTI_TILE_ARCH_INFO__IS_VALID = 278, + TOK_FBD_GT_SQIDI_INFO__NUMBEROF_SQIDI = 279, + TOK_FBD_GT_SQIDI_INFO__NUMBEROF_DOORBELL_PER_SQIDI = 280, + TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__L3 = 281, + TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__LLC = 282, + TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__E_DRAM = 283, + TOK_FBD_GT_CACHE_TYPES__CACHE_TYPE_MASK = 285, + TOK_FBD_GT_SYSTEM_INFO__EUCOUNT = 299, + TOK_FBD_GT_SYSTEM_INFO__THREAD_COUNT = 300, + TOK_FBD_GT_SYSTEM_INFO__SLICE_COUNT = 301, + TOK_FBD_GT_SYSTEM_INFO__SUB_SLICE_COUNT = 302, + TOK_FBD_GT_SYSTEM_INFO__DUAL_SUB_SLICE_COUNT = 303, + TOK_FBQ_GT_SYSTEM_INFO__L3CACHE_SIZE_IN_KB = 304, + TOK_FBQ_GT_SYSTEM_INFO__LLCCACHE_SIZE_IN_KB = 305, + TOK_FBQ_GT_SYSTEM_INFO__EDRAM_SIZE_IN_KB = 306, + TOK_FBD_GT_SYSTEM_INFO__L3BANK_COUNT = 308, + TOK_FBD_GT_SYSTEM_INFO__MAX_FILL_RATE = 309, + TOK_FBD_GT_SYSTEM_INFO__EU_COUNT_PER_POOL_MAX = 310, + TOK_FBD_GT_SYSTEM_INFO__EU_COUNT_PER_POOL_MIN = 311, + TOK_FBD_GT_SYSTEM_INFO__TOTAL_VS_THREADS = 312, + TOK_FBD_GT_SYSTEM_INFO__TOTAL_HS_THREADS = 313, + TOK_FBD_GT_SYSTEM_INFO__TOTAL_DS_THREADS = 314, + TOK_FBD_GT_SYSTEM_INFO__TOTAL_GS_THREADS = 315, + TOK_FBD_GT_SYSTEM_INFO__TOTAL_PS_THREADS_WINDOWER_RANGE = 316, + TOK_FBD_GT_SYSTEM_INFO__TOTAL_VS_THREADS_POCS = 317, + TOK_FBD_GT_SYSTEM_INFO__CSR_SIZE_IN_MB = 318, + TOK_FBD_GT_SYSTEM_INFO__MAX_EU_PER_SUB_SLICE = 319, + TOK_FBD_GT_SYSTEM_INFO__MAX_SLICES_SUPPORTED = 320, + TOK_FBD_GT_SYSTEM_INFO__MAX_SUB_SLICES_SUPPORTED = 321, + TOK_FBD_GT_SYSTEM_INFO__MAX_DUAL_SUB_SLICES_SUPPORTED = 322, + TOK_FBB_GT_SYSTEM_INFO__IS_L3HASH_MODE_ENABLED = 323, + TOK_FS_GT_SYSTEM_INFO__SLICE_INFO = 324, + TOK_FBB_GT_SYSTEM_INFO__IS_DYNAMICALLY_POPULATED = 325, + TOK_FS_GT_SYSTEM_INFO__SQIDI_INFO = 326, + TOK_FBD_GT_SYSTEM_INFO__RESERVED_CCSWAYS = 327, + TOK_FS_GT_SYSTEM_INFO__CCSINFO = 328, + TOK_FS_GT_SYSTEM_INFO__MULTI_TILE_ARCH_INFO = 329, + TOK_FS_GT_SYSTEM_INFO__VDBOX_INFO = 330, + TOK_FS_GT_SYSTEM_INFO__VEBOX_INFO = 331, + TOK_FBD_GT_SYSTEM_INFO__NUM_THREADS_PER_EU = 336, + TOK_FS_GT_SYSTEM_INFO__CACHE_TYPES = 363, + TOK_FBD_GT_SYSTEM_INFO__MAX_VECS = 371, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_DESKTOP = 381, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_VERING = 395, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_VCS2 = 398, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_BIG_DIE = 401, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_MEDIUM_DIE = 402, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_SMALL_DIE = 403, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT1 = 404, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT1_5 = 406, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT2 = 409, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT2_5 = 411, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT3 = 412, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT4 = 414, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_ULT = 423, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_IVBM0M1PLATFORM = 425, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CHANNEL_SWIZZLING_XORENABLED = 434, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTA = 439, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTC = 440, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTX = 441, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR5SLICE = 442, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_LCIA = 445, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_RESOURCE_STREAMER = 450, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSRING = 453, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSNODE = 457, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSMULTI_INSTANCE = 458, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_DISPLAY_DISABLED = 485, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_SGTPVSKUSTRAP_PRESENT = 486, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21584__FTR_POOLED_EU_ENABLED = 573, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_MID_BATCH_PREEMPT = 587, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_THREAD_GROUP_LEVEL_PREEMPT = 588, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_MID_THREAD_LEVEL_PREEMPT = 589, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR3D_MID_BATCH_PREEMPT = 590, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR3D_OBJECT_LEVEL_PREEMPT = 591, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PER_CTXT_PREEMPTION_GRANULARITY_CONTROL = 595, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PPGTT = 598, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_IA32E_GFX_PTES = 599, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_MEM_TYPE_MOCS_DEFER_PAT = 600, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PML4SUPPORT = 601, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_SVM = 603, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TILE_MAPPED_RESOURCE = 605, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TRANSLATION_TABLE = 606, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_USER_MODE_TRANSLATION_TABLE = 607, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_NULL_PAGES = 608, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_L3IACOHERENCY = 609, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_EDRAM = 615, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LLCBYPASS = 617, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CRYSTALWELL = 618, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CENTRAL_CACHE_POLICY = 619, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_IO_MMU_PAGE_FAULTING = 622, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2GPU_MMU = 626, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2SVM = 627, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_STANDARD_MIP_TAIL_FORMAT = 628, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2_1_64KB_PAGES = 630, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GTT_CACHE_INVALIDATION = 632, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_E2ECOMPRESSION = 634, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LINEAR_CCS = 636, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LOCAL_MEMORY = 640, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PPGTT64KBWALK_OPTIMIZATION = 642, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TILE_Y = 645, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_FLAT_PHYS_CCS = 647, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_MULTI_TILE_ARCH = 651, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LOCAL_MEMORY_ALLOWS4KB = 652, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_DISPLAY_XTILING = 653, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CAMERA_CAPTURE_CACHING = 660, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_KMD_DAF = 668, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_FRAME_BUFFER_LLC = 679, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_DRIVER_FLR = 681, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC_LDR2D = 726, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC_HDR2D = 727, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC3D = 728, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC = 760, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC2ADDRESS_TRANSLATION = 761, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC_BLITTER_TRACKING = 762, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC_CPU_TRACKING = 764, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_VEBOX = 800, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS54736__FTR_REND_COMP = 934, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS54736__FTR_DISPLAY_YTILING = 937, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_S3D = 1123, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_DISPLAY_ENGINE_S3D = 1124, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_SINGLE_VEBOX_SLICE = 1160, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_SIMULATION_MODE = 1168, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS88095__FTR_ENABLE_GU_C = 1224, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS89755__FTR_VGT = 1239, + TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS91822__FTR_ASSIGNED_GPU_TILE = 1257, + TOK_FBD_WA_TABLE__WA_DO_NOT_USE_MIREPORT_PERF_COUNT = 1562, + TOK_FBD_WA_TABLE__WA_ALIGN_INDEX_BUFFER = 1606, + TOK_FBD_WA_TABLE__WA_SEND_MIFLUSHBEFORE_VFE = 1644, + TOK_FBD_WA_TABLE__WA_DISABLE_PER_CTXT_PREEMPTION_GRANULARITY_CONTROL = 1651, + TOK_FBD_WA_TABLE__WA_ENABLE_PREEMPTION_GRANULARITY_CONTROL_BY_UMD = 1652, + TOK_FBD_WA_TABLE__WA_DISABLE_LSQCROPERFFOR_OCL = 1659, + TOK_FBD_WA_TABLE__WA_VALIGN2FOR96BPP_FORMATS = 1858, + TOK_FBD_WA_TABLE__WA_VALIGN2FOR_R8G8B8UINTFORMAT = 1859, + TOK_FBD_WA_TABLE__WA_REPORT_PERF_COUNT_USE_GLOBAL_CONTEXT_ID = 2061, + TOK_FBD_WA_TABLE__WA_FORCE_PC_BB_FULL_CFG_RESTORE = 2062, + TOK_FBD_WA_TABLE__WA_CSRUNCACHABLE = 2099, + TOK_FBD_WA_TABLE__WA_DISABLE_FUSED_THREAD_SCHEDULING = 2132, + TOK_FBD_WA_TABLE__WA_MODIFY_VFESTATE_AFTER_GPGPUPREEMPTION = 2137, + TOK_FBD_WA_TABLE__WA_CURSOR16K = 2148, + TOK_FBD_WA_TABLE__WA8K_ALIGNFOR_ASYNC_FLIP = 2152, + TOK_FBD_WA_TABLE__WA29BIT_DISPLAY_ADDR_LIMIT = 2153, + TOK_FBD_WA_TABLE__WA_ALIGN_CONTEXT_IMAGE = 2157, + TOK_FBD_WA_TABLE__WA_FORCE_GLOBAL_GTT = 2158, + TOK_FBD_WA_TABLE__WA_REPORT_PERF_COUNT_FORCE_GLOBAL_GTT = 2159, + TOK_FBD_WA_TABLE__WA_OA_ADDRESS_TRANSLATION = 2160, + TOK_FBD_WA_TABLE__WA2ROW_VERTICAL_ALIGNMENT = 2161, + TOK_FBD_WA_TABLE__WA_PPGTT_ALIAS_GLOBAL_GTT_SPACE = 2166, + TOK_FBD_WA_TABLE__WA_CLEAR_FENCE_REGISTERS_AT_DRIVER_INIT = 2167, + TOK_FBD_WA_TABLE__WA_RESTRICT_PITCH128KB = 2169, + TOK_FBD_WA_TABLE__WA_AVOID_LLC = 2170, + TOK_FBD_WA_TABLE__WA_AVOID_L3 = 2171, + TOK_FBD_WA_TABLE__WA16TILE_FENCES_ONLY = 2172, + TOK_FBD_WA_TABLE__WA16MBOABUFFER_ALIGNMENT = 2181, + TOK_FBD_WA_TABLE__WA_TRANSLATION_TABLE_UNAVAILABLE = 2185, + TOK_FBD_WA_TABLE__WA_NO_MINIMIZED_TRIVIAL_SURFACE_PADDING = 2189, + TOK_FBD_WA_TABLE__WA_NO_BUFFER_SAMPLER_PADDING = 2190, + TOK_FBD_WA_TABLE__WA_SURFACE_STATE_PLANAR_YOFFSET_ALIGN_BY2 = 2196, + TOK_FBD_WA_TABLE__WA_GTT_CACHING_OFF_BY_DEFAULT = 2197, + TOK_FBD_WA_TABLE__WA_TOUCH_ALL_SVM_MEMORY = 2203, + TOK_FBD_WA_TABLE__WA_IOBADDRESS_MUST_BE_VALID_IN_HW_CONTEXT = 2204, + TOK_FBD_WA_TABLE__WA_FLUSH_TLB_AFTER_CPU_GGTT_WRITES = 2206, + TOK_FBD_WA_TABLE__WA_MSAA8X_TILE_YDEPTH_PITCH_ALIGNMENT = 2207, + TOK_FBD_WA_TABLE__WA_DISABLE_NULL_PAGE_AS_DUMMY = 2209, + TOK_FBD_WA_TABLE__WA_USE_VALIGN16ON_TILE_XYBPP816 = 2211, + TOK_FBD_WA_TABLE__WA_GTT_PAT0 = 2214, + TOK_FBD_WA_TABLE__WA_GTT_PAT0WB = 2215, + TOK_FBD_WA_TABLE__WA_MEM_TYPE_IS_MAX_OF_PAT_AND_MOCS = 2216, + TOK_FBD_WA_TABLE__WA_GTT_PAT0GTT_WB_OVER_OS_IOMMU_ELLC_ONLY = 2218, + TOK_FBD_WA_TABLE__WA_ADD_DUMMY_PAGE_FOR_DISPLAY_PREFETCH = 2219, + TOK_FBD_WA_TABLE__WA_DEFAULT_TILE4 = 2221, + TOK_FBD_WA_TABLE__WA_LLCCACHING_UNSUPPORTED = 2244, + TOK_FBD_WA_TABLE__WA_DOUBLE_FAST_CLEAR_WIDTH_ALIGNMENT = 2350, + TOK_FBD_WA_TABLE__WA_COMPRESSED_RESOURCE_REQUIRES_CONST_VA21 = 2387, + TOK_FBD_WA_TABLE__WA_DISREGARD_PLATFORM_CHECKS = 2391, + TOK_FBD_WA_TABLE__WA_LOSSLESS_COMPRESSION_SURFACE_STRIDE = 2485, + TOK_FBD_WA_TABLE__WA_FBC_LINEAR_SURFACE_STRIDE = 2486, + TOK_FBD_WA_TABLE__WA4K_ALIGN_UVOFFSET_NV12LINEAR_SURFACE = 2490, + TOK_FBD_WA_TABLE__WA_ASTC_CORRUPTION_FOR_ODD_COMPRESSED_BLOCK_SIZE_X = 2528, + TOK_FBD_WA_TABLE__WA_AUX_TABLE16KGRANULAR = 2553, + TOK_FBD_WA_TABLE__WA_ENCRYPTED_EDRAM_ONLY_PARTIALS = 2600, + TOK_FBD_WA_TABLE__WA_DISABLE_EDRAM_FOR_DISPLAY_RT = 2601, + TOK_FBD_WA_TABLE__WA_LIMIT128BMEDIA_COMPR = 2602, + TOK_FBD_WA_TABLE__WA_UNTYPED_BUFFER_COMPRESSION = 2603, + TOK_FBD_WA_TABLE__WA_SAMPLER_CACHE_FLUSH_BETWEEN_REDESCRIBED_SURFACE_READS = 2606, + TOK_FBD_WA_TABLE__WA_ALIGN_YUVRESOURCE_TO_LCU = 2702, + TOK_FBD_WA_TABLE__WA32BPP_TILE_Y2DCOLOR_NO_HALIGN4 = 2711, + TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY = 3475, + TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY = 3476, + TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY = 3477, + TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY = 3478, + TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE = 3479, + TOK_FBW_PLATFORM_STR__US_DEVICE_ID = 3480, + TOK_FBW_PLATFORM_STR__US_REV_ID = 3481, + TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH = 3482, + TOK_FBW_PLATFORM_STR__US_REV_ID_PCH = 3483, + TOK_FE_PLATFORM_STR__E_GTTYPE = 3484, + TOK_FBD_KMD_CAPS_INFO__GAMMA_RGB256X3X16 = 3501, + TOK_FBD_KMD_CAPS_INFO__GDIACCELERATION = 3502, + TOK_FBD_KMD_CAPS_INFO__OS_MANAGED_HW_CONTEXT = 3503, + TOK_FBD_KMD_CAPS_INFO__GRAPHICS_PREEMPTION_GRANULARITY = 3504, + TOK_FBD_KMD_CAPS_INFO__COMPUTE_PREEMPTION_GRANULARITY = 3505, + TOK_FBD_KMD_CAPS_INFO__INSTRUMENTATION_IS_ENABLED = 3506, + TOK_FBD_KMD_CAPS_INFO__DRIVER_STORE_ENABLED = 3507, + TOK_FBD_KMD_OVERLAY_OVERRIDE__OVERRIDE_OVERLAY_CAPS = 3508, + TOK_FBD_KMD_OVERLAY_OVERRIDE__RGBOVERLAY = 3509, + TOK_FBD_KMD_OVERLAY_OVERRIDE__YUY2OVERLAY = 3510, + TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__FULL_RANGE_RGB = 3512, + TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__LIMITED_RANGE_RGB = 3513, + TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT601 = 3514, + TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT709 = 3515, + TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT601_XV_YCC = 3516, + TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT709_XV_YCC = 3517, + TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__STRETCH_X = 3518, + TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__STRETCH_Y = 3519, + TOK_FS_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__CAPS = 3521, + TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__CAPS_VALUE = 3522, + TOK_FS_KMD_OVERLAY_CAPS_INFO__OVOVERRIDE = 3523, + TOK_FBD_KMD_OVERLAY_CAPS_INFO__MAX_OVERLAY_DISPLAY_WIDTH = 3524, + TOK_FBD_KMD_OVERLAY_CAPS_INFO__MAX_OVERLAY_DISPLAY_HEIGHT = 3525, + TOK_FBC_KMD_OVERLAY_CAPS_INFO__HWSCALER_EXISTS = 3526, + TOK_FBD_KMD_OVERLAY_CAPS_INFO__MAX_HWSCALER_STRIDE = 3527, + TOK_FBD_FRAME_RATE__UI_NUMERATOR = 3528, + TOK_FBD_FRAME_RATE__UI_DENOMINATOR = 3529, + TOK_FBD_KM_DEFERRED_WAIT_INFO__FEATURE_SUPPORTED = 3530, + TOK_FBD_KM_DEFERRED_WAIT_INFO__ACTIVE_DISPLAY = 3531, + TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__BASE = 3532, + TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__LIMIT = 3533, + TOK_FS_GMM_GFX_PARTITIONING__STANDARD = 3534, + TOK_FS_GMM_GFX_PARTITIONING__STANDARD64KB = 3535, + TOK_FS_GMM_GFX_PARTITIONING__SVM = 3538, + TOK_FS_GMM_GFX_PARTITIONING__HEAP32 = 3540, + TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__BUS = 3541, + TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__DEVICE = 3542, + TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__FUNCTION = 3543, + TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__DATA = 3545, + TOK_FBD_ADAPTER_INFO__KMD_VERSION_INFO = 3548, + TOK_FBC_ADAPTER_INFO__DEVICE_REGISTRY_PATH = 3550, + TOK_FS_ADAPTER_INFO__GFX_PLATFORM = 3551, + TOK_FS_ADAPTER_INFO__SKU_TABLE = 3552, + TOK_FS_ADAPTER_INFO__WA_TABLE = 3553, + TOK_FBD_ADAPTER_INFO__GFX_TIME_STAMP_FREQ = 3555, + TOK_FBD_ADAPTER_INFO__GFX_CORE_FREQUENCY = 3556, + TOK_FBD_ADAPTER_INFO__FSBFREQUENCY = 3557, + TOK_FBD_ADAPTER_INFO__MIN_RENDER_FREQ = 3558, + TOK_FBD_ADAPTER_INFO__MAX_RENDER_FREQ = 3559, + TOK_FBD_ADAPTER_INFO__PACKAGE_TDP = 3560, + TOK_FBD_ADAPTER_INFO__MAX_FILL_RATE = 3561, + TOK_FBD_ADAPTER_INFO__NUMBER_OF_EUS = 3562, + TOK_FBD_ADAPTER_INFO__DW_RELEASE_TARGET = 3563, + TOK_FBD_ADAPTER_INFO__SIZE_OF_DMA_BUFFER = 3564, + TOK_FBD_ADAPTER_INFO__PATCH_LOCATION_LIST_SIZE = 3565, + TOK_FBD_ADAPTER_INFO__ALLOCATION_LIST_SIZE = 3566, + TOK_FBD_ADAPTER_INFO__SMALL_PATCH_LOCATION_LIST_SIZE = 3567, + TOK_FBD_ADAPTER_INFO__DEFAULT_CMD_BUFFER_SIZE = 3568, + TOK_FBQ_ADAPTER_INFO__GFX_MEMORY_SIZE = 3569, + TOK_FBD_ADAPTER_INFO__SYSTEM_MEMORY_SIZE = 3570, + TOK_FBD_ADAPTER_INFO__CACHE_LINE_SIZE = 3571, + TOK_FE_ADAPTER_INFO__PROCESSOR_FAMILY = 3572, + TOK_FBC_ADAPTER_INFO__IS_HTSUPPORTED = 3573, + TOK_FBC_ADAPTER_INFO__IS_MUTI_CORE_CPU = 3574, + TOK_FBC_ADAPTER_INFO__IS_VTDSUPPORTED = 3575, + TOK_FBD_ADAPTER_INFO__REGISTRY_PATH_LENGTH = 3576, + TOK_FBQ_ADAPTER_INFO__DEDICATED_VIDEO_MEMORY = 3577, + TOK_FBQ_ADAPTER_INFO__SYSTEM_SHARED_MEMORY = 3578, + TOK_FBQ_ADAPTER_INFO__SYSTEM_VIDEO_MEMORY = 3579, + TOK_FS_ADAPTER_INFO__OUTPUT_FRAME_RATE = 3580, + TOK_FS_ADAPTER_INFO__INPUT_FRAME_RATE = 3581, + TOK_FS_ADAPTER_INFO__CAPS = 3583, + TOK_FS_ADAPTER_INFO__OVERLAY_CAPS = 3584, + TOK_FS_ADAPTER_INFO__SYSTEM_INFO = 3585, + TOK_FS_ADAPTER_INFO__DEFERRED_WAIT_INFO = 3587, + TOK_FS_ADAPTER_INFO__GFX_PARTITION = 3588, + TOK_FS_ADAPTER_INFO__ST_ADAPTER_BDF = 3594, + TOK_PBQ_CREATECONTEXT_PVTDATA__ANONYMOUS18449__P_HW_CONTEXT_ID = 3632, + TOK_FBD_CREATECONTEXT_PVTDATA__NUMBER_OF_HW_CONTEXT_IDS = 3634, + TOK_FBD_CREATECONTEXT_PVTDATA__PROCESS_ID = 3635, + TOK_FBC_CREATECONTEXT_PVTDATA__IS_PROTECTED_PROCESS = 3636, + TOK_FBC_CREATECONTEXT_PVTDATA__IS_DWM = 3637, + TOK_FBC_CREATECONTEXT_PVTDATA__IS_MEDIA_USAGE = 3639, + TOK_FBC_CREATECONTEXT_PVTDATA__GPU_VACONTEXT = 3644, + TOK_FBC_CREATECONTEXT_PVTDATA__NO_RING_FLUSHES = 3651, + TOK_FBD_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__ANONYMOUS32457__ANONYMOUS32501__ANONYMOUS32537__INDEX = 3679, + TOK_FBD_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__ANONYMOUS32457__ANONYMOUS32501__ANONYMOUS32537__OFFSET = 3680, + TOK_FBD_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__ANONYMOUS32457__ANONYMOUS32501__ANONYMOUS32680__LOW_PART = 3681, + TOK_FBD_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__ANONYMOUS32457__ANONYMOUS32501__ANONYMOUS32680__HIGH_PART = 3682, + TOK_FS_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__ANONYMOUS32457__ANONYMOUS32501__ALLOCATION = 3683, + TOK_FS_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__ANONYMOUS32457__ANONYMOUS32501__GFX_ADDRESS = 3684, + TOK_FS_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__ANONYMOUS32457__ADDRESS = 3685, + TOK_FBD_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__ANONYMOUS32457__VALUE = 3686, + TOK_FBD_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__ENABLE = 3687, + TOK_FS_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__TAG = 3688, + TOK_FBD_COMMAND_BUFFER_HEADER_REC__UMD_CONTEXT_TYPE = 3690, + TOK_FBD_COMMAND_BUFFER_HEADER_REC__UMD_PATCH_LIST = 3691, + TOK_FBD_COMMAND_BUFFER_HEADER_REC__UMD_REQUESTED_SLICE_STATE = 3699, + TOK_FBD_COMMAND_BUFFER_HEADER_REC__UMD_REQUESTED_SUBSLICE_COUNT = 3701, + TOK_FBD_COMMAND_BUFFER_HEADER_REC__UMD_REQUESTED_EUCOUNT = 3702, + TOK_FBD_COMMAND_BUFFER_HEADER_REC__USES_RESOURCE_STREAMER = 3704, + TOK_FBD_COMMAND_BUFFER_HEADER_REC__NEEDS_MID_BATCH_PRE_EMPTION_SUPPORT = 3705, + TOK_FBD_COMMAND_BUFFER_HEADER_REC__USES_GPGPUPIPELINE = 3708, + TOK_FBD_COMMAND_BUFFER_HEADER_REC__REQUIRES_COHERENCY = 3709, + TOK_FBD_COMMAND_BUFFER_HEADER_REC__PERF_TAG = 3726, + TOK_FBQ_COMMAND_BUFFER_HEADER_REC__MONITOR_FENCE_VA = 3730, + TOK_FBQ_COMMAND_BUFFER_HEADER_REC__MONITOR_FENCE_VALUE = 3731, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CAMERA_CAPTURE = 3740, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CCS = 3741, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_DISCARD = 3742, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION = 3743, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION_RGBX = 3744, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CONSTANT = 3745, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__DEPTH = 3746, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN = 3747, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN_PREFERRED = 3748, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HISTORY_BUFFER = 3749, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HI_Z = 3750, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDEX = 3751, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDIRECT_CLEAR_COLOR = 3752, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INSTRUCTION_FLAT = 3753, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INTERLACED_SCAN = 3754, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MCS = 3755, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MMC = 3756, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MOTION_COMP = 3757, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__NO_RESTRICTION = 3758, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__OVERLAY = 3759, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PRESENTABLE = 3760, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PROCEDURAL_TEXTURE = 3761, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__QUERY = 3762, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__RENDER_TARGET = 3763, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D = 3764, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D_DX = 3765, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_NON_PACKED = 3766, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_WIDI = 3767, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SCRATCH_FLAT = 3768, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SEPARATE_STENCIL = 3769, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE = 3770, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE_DX9CONSTANT_BUFFER = 3771, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STREAM = 3772, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXT_API = 3773, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXTURE = 3774, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILED_RESOURCE = 3775, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILE_POOL = 3776, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__UNIFIED_AUX_SURFACE = 3777, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VERTEX = 3778, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VIDEO = 3779, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_XCCS = 3780, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_YCCS = 3781, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____MSAA_TILE_MCS = 3782, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_LINEAR_CCS = 3783, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____REMAINING = 3785, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ALLOW_VIRTUAL_PADDING = 3786, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__BIG_PAGE = 3787, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CACHEABLE = 3788, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CONTIG_PHYS_MEMORY_FORI_DART = 3789, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CORNER_TEXEL_MODE = 3790, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__EXISTING_SYS_MEM = 3791, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__FORCE_RESIDENCY = 3792, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GFDT = 3793, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GTT_MAP_TYPE = 3794, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__HARDWARE_PROTECTED = 3795, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__KERNEL_MODE_MAPPED = 3796, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_BELOW = 3797, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_MONO = 3798, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_RIGHT = 3799, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LOCAL_ONLY = 3800, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LINEAR = 3801, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__MEDIA_COMPRESSED = 3802, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_OPTIMIZATION_PADDING = 3803, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_PHYS_MEMORY = 3805, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NOT_LOCKABLE = 3806, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NON_LOCAL_ONLY = 3807, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__STD_SWIZZLE = 3808, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__PSEUDO_STD_SWIZZLE = 3809, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__UNDEFINED64KBSWIZZLE = 3810, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__REDECRIBED_PLANES = 3811, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__RENDER_COMPRESSED = 3812, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ROTATED = 3813, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SHARED = 3814, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SOFTWARE_PROTECTED = 3815, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SVM = 3816, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE4 = 3817, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE64 = 3818, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_W = 3819, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_X = 3820, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_Y = 3821, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YF = 3822, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YS = 3823, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__WDDM_PROTECTED = 3824, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__XADAPTER = 3825, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PREALLOCATED_RES_INFO = 3826, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PRE_WDDM2SVM = 3827, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__GTMFX2ND_LEVEL_BATCH_RING_SIZE_ALIGN = 3837, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_MPR_ROW_STORE32KALIGN = 3838, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_DMV_BUFFER32KALIGN = 3839, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_BUFFER_SAMPLER_PADDING = 3840, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_LEGACY_PLANAR_LINEAR_VIDEO_RESTRICTIONS = 3841, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__CHVASTC_SKIP_VIRTUAL_MIPS = 3842, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_PACKED_MIP_TAIL = 3843, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521____FORCE_OTHER_HVALIGN4 = 3844, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR = 3845, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION = 3846, + TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY = 3847, + TOK_FS_GMM_RESOURCE_FLAG_REC__GPU = 3849, + TOK_FS_GMM_RESOURCE_FLAG_REC__INFO = 3850, + TOK_FS_GMM_RESOURCE_FLAG_REC__WA = 3851, + TOK_FE_GMM_RESOURCE_MSAA_INFO_REC__SAMPLE_PATTERN = 3852, + TOK_FBD_GMM_RESOURCE_MSAA_INFO_REC__NUM_SAMPLES = 3853, + TOK_FBC_GMM_RESOURCE_ALIGNMENT_REC__ARRAY_SPACING_SINGLE_LOD = 3854, + TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__BASE_ALIGNMENT = 3855, + TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__HALIGN = 3856, + TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__VALIGN = 3857, + TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__DALIGN = 3858, + TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__MIP_TAIL_START_LOD = 3859, + TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_START_LOD = 3860, + TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_WIDTH = 3861, + TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_HEIGHT = 3862, + TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__QPITCH = 3863, + TOK_FBD_GMM_S3D_INFO_REC__DISPLAY_MODE_HEIGHT = 3864, + TOK_FBD_GMM_S3D_INFO_REC__NUM_BLANK_ACTIVE_LINES = 3865, + TOK_FBD_GMM_S3D_INFO_REC__RFRAME_OFFSET = 3866, + TOK_FBD_GMM_S3D_INFO_REC__BLANK_AREA_OFFSET = 3867, + TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_HEIGHT = 3868, + TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_SIZE = 3869, + TOK_FBC_GMM_S3D_INFO_REC__IS_RFRAME = 3870, + TOK_FBC_GMM_MULTI_TILE_ARCH_REC__ENABLE = 3871, + TOK_FBC_GMM_MULTI_TILE_ARCH_REC__TILE_INSTANCED = 3872, + TOK_FBC_GMM_MULTI_TILE_ARCH_REC__GPU_VA_MAPPING_SET = 3873, + TOK_FBC_GMM_MULTI_TILE_ARCH_REC__LOCAL_MEM_ELIGIBILITY_SET = 3874, + TOK_FBC_GMM_MULTI_TILE_ARCH_REC__LOCAL_MEM_PREFERRED_SET = 3875, + TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT = 3877, + TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH = 3878, + TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X = 3879, + TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y = 3880, + TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED = 3881, + TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES = 3886, + TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES = 3887, + TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK = 3888, + TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER = 3889, + TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET = 3890, + TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH = 3891, + TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET = 3892, + TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO = 3893, + TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO = 3894, + TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE = 3895, + TOK_FE_GMM_TEXTURE_INFO_REC__ANONYMOUS4927__USAGE = 3896, + TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__SEG1 = 3898, + TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__EVICT = 3899, + TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_GMM_ALLOCATED = 3900, + TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_PAGE_ALIGNED = 3901, + TOK_FE_GMM_TEXTURE_INFO_REC__TYPE = 3902, + TOK_FE_GMM_TEXTURE_INFO_REC__FORMAT = 3903, + TOK_FBD_GMM_TEXTURE_INFO_REC__BITS_PER_PIXEL = 3904, + TOK_FS_GMM_TEXTURE_INFO_REC__FLAGS = 3905, + TOK_FBQ_GMM_TEXTURE_INFO_REC__BASE_WIDTH = 3906, + TOK_FBD_GMM_TEXTURE_INFO_REC__BASE_HEIGHT = 3907, + TOK_FBD_GMM_TEXTURE_INFO_REC__DEPTH = 3908, + TOK_FBD_GMM_TEXTURE_INFO_REC__MAX_LOD = 3909, + TOK_FBD_GMM_TEXTURE_INFO_REC__ARRAY_SIZE = 3910, + TOK_FBD_GMM_TEXTURE_INFO_REC__CP_TAG = 3911, + TOK_FS_GMM_TEXTURE_INFO_REC__CACHE_POLICY = 3912, + TOK_FS_GMM_TEXTURE_INFO_REC__MSAA = 3913, + TOK_FS_GMM_TEXTURE_INFO_REC__ALIGNMENT = 3914, + TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_MODE = 3915, + TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_HINT = 3916, + TOK_FBQ_GMM_TEXTURE_INFO_REC__PITCH = 3917, + TOK_FBQ_GMM_TEXTURE_INFO_REC__OVERRIDE_PITCH = 3918, + TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE = 3919, + TOK_FBQ_GMM_TEXTURE_INFO_REC__CCSIZE = 3920, + TOK_FBQ_GMM_TEXTURE_INFO_REC__UNPADDED_SIZE = 3921, + TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE_REPORT_TO_OS = 3922, + TOK_FS_GMM_TEXTURE_INFO_REC__OFFSET_INFO = 3923, + TOK_FE_GMM_TEXTURE_INFO_REC__TILE_MODE = 3924, + TOK_FBD_GMM_TEXTURE_INFO_REC__CCSMODE_ALIGN = 3925, + TOK_FBD_GMM_TEXTURE_INFO_REC__LEGACY_FLAGS = 3926, + TOK_FS_GMM_TEXTURE_INFO_REC__S3D = 3927, + TOK_FS_GMM_TEXTURE_INFO_REC__SEGMENT_OVERRIDE = 3929, + TOK_FBD_GMM_TEXTURE_INFO_REC__MAXIMUM_RENAMING_LIST_LENGTH = 3930, + TOK_FS_GMM_TEXTURE_INFO_REC__PLATFORM = 3931, // _DEBUG || _RELEASE_INTERNAL + TOK_FS_GMM_TEXTURE_INFO_REC__EXISTING_SYS_MEM = 3932, + TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_EXISTING_SYS_MEM = 3944, + TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_VIRT_ADDRESS = 3945, + TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_GFX_ALIGNED_VIRT_ADDRESS = 3946, + TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__SIZE = 3948, + TOK_FBC_GMM_EXISTING_SYS_MEM_REC__IS_GMM_ALLOCATED = 3949, + TOK_FE_GMM_RESOURCE_INFO_COMMON_STRUCT__CLIENT_TYPE = 3950, + TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__SURF = 3951, + TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__AUX_SURF = 3952, + TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__AUX_SEC_SURF = 3953, + TOK_FBD_GMM_RESOURCE_INFO_COMMON_STRUCT__ROTATE_INFO = 3954, + TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__EXISTING_SYS_MEM = 3955, + TOK_FBQ_GMM_RESOURCE_INFO_COMMON_STRUCT__SVM_ADDRESS = 3956, + TOK_FBQ_GMM_RESOURCE_INFO_COMMON_STRUCT__P_PRIVATE_DATA = 3959, + TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__MULTI_TILE_ARCH = 3961, + TOK_FS_GMM_RESOURCE_INFO_WIN_STRUCT__GMM_RESOURCE_INFO_COMMON = 3962, + TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__SIZE = 3969, + TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__CHECK_SUM = 3970, + TOK_FE_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__ESCAPE_CODE = 3971, + TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__UL_RESERVED = 3972, + TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UL_RESERVED1 = 3973, + TOK_FBW_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__US_ESCAPE_VERSION = 3974, + TOK_FBW_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__US_FILE_VERSION = 3975, + TOK_FE_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UL_MAJOR_ESCAPE_CODE = 3976, + TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UI_MINOR_ESCAPE_CODE = 3977, + TOK_FE_GTDIBASE_IN_STRUCT__FUNCTION = 3978, + TOK_FE_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__RET_CODE = 3979, + TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__GPU_PERF_TICKS = 3980, + TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__CPU_PERF_TICKS = 3981, + TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__GPU_PERF_FREQ = 3982, + TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__CPU_PERF_FREQ = 3983, + TOK_FXS_TIME_STAMP_DATA_HEADER__ANONYMOUS2466__M_IN = 3984, + TOK_FS_TIME_STAMP_DATA_HEADER__ANONYMOUS2466__M_OUT = 3985, + TOK_FS_TIME_STAMP_DATA_HEADER__M_HEADER = 3986, + TOK_FS_TIME_STAMP_DATA_HEADER__M_DATA = 3987, + TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM = 3988, // !(_DEBUG || _RELEASE_INTERNAL) + + //------------------- +}; diff --git a/shared/wsl_compute_helper/source/wsl_compute_helper_types_tokens_structs.h b/shared/wsl_compute_helper/source/wsl_compute_helper_types_tokens_structs.h new file mode 100644 index 0000000000..1886ba7450 --- /dev/null +++ b/shared/wsl_compute_helper/source/wsl_compute_helper_types_tokens_structs.h @@ -0,0 +1,1864 @@ +/* + * Copyright (C) 2021 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +// This is a generated file - please don't modify directly +#pragma once +#include "wsl_compute_helper_types_tokens.h" + +// Token layout +struct TOKSTR_GT_SUBSLICE_INFO { + TokenVariableLength base; + + TOKSTR_GT_SUBSLICE_INFO(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GT_SUBSLICE_INFO, EuEnabledMask) + sizeof(EuEnabledMask) - offsetof(TOKSTR_GT_SUBSLICE_INFO, Enabled), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_GT_SUBSLICE_INFO() + : base(TOK_S_GT_SUBSLICE_INFO, 0, sizeof(*this) - sizeof(base)) {} + + TokenBool Enabled = {TOK_FBB_GT_SUBSLICE_INFO__ENABLED}; + TokenDword EuEnabledCount = {TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_COUNT}; + TokenDword EuEnabledMask = {TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_MASK}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_GT_SUBSLICE_INFO) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_GT_DUALSUBSLICE_INFO { + TokenVariableLength base; + + TOKSTR_GT_DUALSUBSLICE_INFO(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GT_DUALSUBSLICE_INFO, SubSlice) + sizeof(SubSlice) - offsetof(TOKSTR_GT_DUALSUBSLICE_INFO, Enabled), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_GT_DUALSUBSLICE_INFO() + : base(TOK_S_GT_DUALSUBSLICE_INFO, 0, sizeof(*this) - sizeof(base)) {} + + TokenBool Enabled = {TOK_FBB_GT_DUALSUBSLICE_INFO__ENABLED}; + TOKSTR_GT_SUBSLICE_INFO SubSlice[2] = {{TOK_FS_GT_DUALSUBSLICE_INFO__SUB_SLICE, 0}, {TOK_FS_GT_DUALSUBSLICE_INFO__SUB_SLICE, 1}}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_GT_DUALSUBSLICE_INFO) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_GT_SLICE_INFO { + TokenVariableLength base; + + TOKSTR_GT_SLICE_INFO(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GT_SLICE_INFO, DualSubSliceEnabledCount) + sizeof(DualSubSliceEnabledCount) - offsetof(TOKSTR_GT_SLICE_INFO, Enabled), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_GT_SLICE_INFO() + : base(TOK_S_GT_SLICE_INFO, 0, sizeof(*this) - sizeof(base)) {} + + TokenBool Enabled = {TOK_FBB_GT_SLICE_INFO__ENABLED}; + TOKSTR_GT_SUBSLICE_INFO SubSliceInfo[8] = {{TOK_FS_GT_SLICE_INFO__SUB_SLICE_INFO, 0}, {TOK_FS_GT_SLICE_INFO__SUB_SLICE_INFO, 1}, {TOK_FS_GT_SLICE_INFO__SUB_SLICE_INFO, 2}, {TOK_FS_GT_SLICE_INFO__SUB_SLICE_INFO, 3}, {TOK_FS_GT_SLICE_INFO__SUB_SLICE_INFO, 4}, {TOK_FS_GT_SLICE_INFO__SUB_SLICE_INFO, 5}, {TOK_FS_GT_SLICE_INFO__SUB_SLICE_INFO, 6}, {TOK_FS_GT_SLICE_INFO__SUB_SLICE_INFO, 7}}; + TOKSTR_GT_DUALSUBSLICE_INFO DSSInfo[6] = {{TOK_FS_GT_SLICE_INFO__DSSINFO, 0}, {TOK_FS_GT_SLICE_INFO__DSSINFO, 1}, {TOK_FS_GT_SLICE_INFO__DSSINFO, 2}, {TOK_FS_GT_SLICE_INFO__DSSINFO, 3}, {TOK_FS_GT_SLICE_INFO__DSSINFO, 4}, {TOK_FS_GT_SLICE_INFO__DSSINFO, 5}}; + TokenDword SubSliceEnabledCount = {TOK_FBD_GT_SLICE_INFO__SUB_SLICE_ENABLED_COUNT}; + TokenDword DualSubSliceEnabledCount = {TOK_FBD_GT_SLICE_INFO__DUAL_SUB_SLICE_ENABLED_COUNT}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_GT_SLICE_INFO) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_GT_VEBOX_INFO { + TokenVariableLength base; + + TOKSTR_GT_VEBOX_INFO(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GT_VEBOX_INFO, IsValid) + sizeof(IsValid) - offsetof(TOKSTR_GT_VEBOX_INFO, Instances), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_GT_VEBOX_INFO() + : base(TOK_S_GT_VEBOX_INFO, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_VEBoxInstances { + TokenVariableLength base; + + TOKSTR_VEBoxInstances(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_VEBoxInstances, VEBoxEnableMask) + sizeof(VEBoxEnableMask) - offsetof(TOKSTR_VEBoxInstances, Bits), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_VEBoxInstances() + : base(TOK_S_GT_VEBOX_INFO__VEBOX_INSTANCES, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_VEBitStruct { + TokenVariableLength base; + + TOKSTR_VEBitStruct(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_VEBitStruct, VEBox3Enabled) + sizeof(VEBox3Enabled) - offsetof(TOKSTR_VEBitStruct, VEBox0Enabled), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_VEBitStruct() + : base(TOK_S_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword VEBox0Enabled = {TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX0ENABLED}; + TokenDword VEBox1Enabled = {TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX1ENABLED}; + TokenDword VEBox2Enabled = {TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX2ENABLED}; + TokenDword VEBox3Enabled = {TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX3ENABLED}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_VEBitStruct) % sizeof(uint32_t) == 0, ""); + + TOKSTR_VEBitStruct Bits = {TOK_FS_GT_VEBOX_INFO__VEBOX_INSTANCES__BITS}; + TokenDword VEBoxEnableMask = {TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBOX_ENABLE_MASK}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_VEBoxInstances) % sizeof(uint32_t) == 0, ""); + + struct TOKSTR_ANONYMOUS3862 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS3862(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS3862, Value) + sizeof(Value) - offsetof(TOKSTR_ANONYMOUS3862, SfcSupportedBits), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS3862() + : base(TOK_S_GT_VEBOX_INFO__ANONYMOUS3862, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_ANONYMOUS3882 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS3882(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS3882, VEBox3) + sizeof(VEBox3) - offsetof(TOKSTR_ANONYMOUS3882, VEBox0), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS3882() + : base(TOK_S_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword VEBox0 = {TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX0}; + TokenDword VEBox1 = {TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX1}; + TokenDword VEBox2 = {TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX2}; + TokenDword VEBox3 = {TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX3}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS3882) % sizeof(uint32_t) == 0, ""); + + TOKSTR_ANONYMOUS3882 SfcSupportedBits = {TOK_FS_GT_VEBOX_INFO__ANONYMOUS3862__SFC_SUPPORTED_BITS}; + TokenDword Value = {TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__VALUE}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS3862) % sizeof(uint32_t) == 0, ""); + + TOKSTR_VEBoxInstances Instances = {TOK_FS_GT_VEBOX_INFO__INSTANCES}; + TOKSTR_ANONYMOUS3862 SFCSupport = {TOK_FS_GT_VEBOX_INFO__SFCSUPPORT}; + TokenDword NumberOfVEBoxEnabled = {TOK_FBD_GT_VEBOX_INFO__NUMBER_OF_VEBOX_ENABLED}; + TokenBool IsValid = {TOK_FBB_GT_VEBOX_INFO__IS_VALID}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_GT_VEBOX_INFO) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_GT_VDBOX_INFO { + TokenVariableLength base; + + TOKSTR_GT_VDBOX_INFO(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GT_VDBOX_INFO, IsValid) + sizeof(IsValid) - offsetof(TOKSTR_GT_VDBOX_INFO, Instances), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_GT_VDBOX_INFO() + : base(TOK_S_GT_VDBOX_INFO, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_VDBoxInstances { + TokenVariableLength base; + + TOKSTR_VDBoxInstances(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_VDBoxInstances, VDBoxEnableMask) + sizeof(VDBoxEnableMask) - offsetof(TOKSTR_VDBoxInstances, Bits), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_VDBoxInstances() + : base(TOK_S_GT_VDBOX_INFO__VDBOX_INSTANCES, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_VDBitStruct { + TokenVariableLength base; + + TOKSTR_VDBitStruct(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_VDBitStruct, VDBox7Enabled) + sizeof(VDBox7Enabled) - offsetof(TOKSTR_VDBitStruct, VDBox0Enabled), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_VDBitStruct() + : base(TOK_S_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword VDBox0Enabled = {TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX0ENABLED}; + TokenDword VDBox1Enabled = {TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX1ENABLED}; + TokenDword VDBox2Enabled = {TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX2ENABLED}; + TokenDword VDBox3Enabled = {TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX3ENABLED}; + TokenDword VDBox4Enabled = {TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX4ENABLED}; + TokenDword VDBox5Enabled = {TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX5ENABLED}; + TokenDword VDBox6Enabled = {TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX6ENABLED}; + TokenDword VDBox7Enabled = {TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX7ENABLED}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_VDBitStruct) % sizeof(uint32_t) == 0, ""); + + TOKSTR_VDBitStruct Bits = {TOK_FS_GT_VDBOX_INFO__VDBOX_INSTANCES__BITS}; + TokenDword VDBoxEnableMask = {TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBOX_ENABLE_MASK}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_VDBoxInstances) % sizeof(uint32_t) == 0, ""); + + struct TOKSTR_ANONYMOUS5662 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS5662(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS5662, Value) + sizeof(Value) - offsetof(TOKSTR_ANONYMOUS5662, SfcSupportedBits), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS5662() + : base(TOK_S_GT_VDBOX_INFO__ANONYMOUS5662, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_ANONYMOUS5682 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS5682(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS5682, VDBox7) + sizeof(VDBox7) - offsetof(TOKSTR_ANONYMOUS5682, VDBox0), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS5682() + : base(TOK_S_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword VDBox0 = {TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX0}; + TokenDword VDBox1 = {TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX1}; + TokenDword VDBox2 = {TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX2}; + TokenDword VDBox3 = {TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX3}; + TokenDword VDBox4 = {TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX4}; + TokenDword VDBox5 = {TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX5}; + TokenDword VDBox6 = {TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX6}; + TokenDword VDBox7 = {TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX7}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS5682) % sizeof(uint32_t) == 0, ""); + + TOKSTR_ANONYMOUS5682 SfcSupportedBits = {TOK_FS_GT_VDBOX_INFO__ANONYMOUS5662__SFC_SUPPORTED_BITS}; + TokenDword Value = {TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__VALUE}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS5662) % sizeof(uint32_t) == 0, ""); + + TOKSTR_VDBoxInstances Instances = {TOK_FS_GT_VDBOX_INFO__INSTANCES}; + TOKSTR_ANONYMOUS5662 SFCSupport = {TOK_FS_GT_VDBOX_INFO__SFCSUPPORT}; + TokenDword NumberOfVDBoxEnabled = {TOK_FBD_GT_VDBOX_INFO__NUMBER_OF_VDBOX_ENABLED}; + TokenBool IsValid = {TOK_FBB_GT_VDBOX_INFO__IS_VALID}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_GT_VDBOX_INFO) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_GT_CCS_INFO { + TokenVariableLength base; + + TOKSTR_GT_CCS_INFO(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GT_CCS_INFO, IsValid) + sizeof(IsValid) - offsetof(TOKSTR_GT_CCS_INFO, Instances), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_GT_CCS_INFO() + : base(TOK_S_GT_CCS_INFO, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_CCSInstances { + TokenVariableLength base; + + TOKSTR_CCSInstances(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_CCSInstances, CCSEnableMask) + sizeof(CCSEnableMask) - offsetof(TOKSTR_CCSInstances, Bits), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_CCSInstances() + : base(TOK_S_GT_CCS_INFO__CCSINSTANCES, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_CCSBitStruct { + TokenVariableLength base; + + TOKSTR_CCSBitStruct(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_CCSBitStruct, CCS3Enabled) + sizeof(CCS3Enabled) - offsetof(TOKSTR_CCSBitStruct, CCS0Enabled), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_CCSBitStruct() + : base(TOK_S_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword CCS0Enabled = {TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS0ENABLED}; + TokenDword CCS1Enabled = {TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS1ENABLED}; + TokenDword CCS2Enabled = {TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS2ENABLED}; + TokenDword CCS3Enabled = {TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS3ENABLED}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_CCSBitStruct) % sizeof(uint32_t) == 0, ""); + + TOKSTR_CCSBitStruct Bits = {TOK_FS_GT_CCS_INFO__CCSINSTANCES__BITS}; + TokenDword CCSEnableMask = {TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSENABLE_MASK}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_CCSInstances) % sizeof(uint32_t) == 0, ""); + + TOKSTR_CCSInstances Instances = {TOK_FS_GT_CCS_INFO__INSTANCES}; + TokenDword NumberOfCCSEnabled = {TOK_FBD_GT_CCS_INFO__NUMBER_OF_CCSENABLED}; + TokenBool IsValid = {TOK_FBB_GT_CCS_INFO__IS_VALID}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_GT_CCS_INFO) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_GT_MULTI_TILE_ARCH_INFO { + TokenVariableLength base; + + TOKSTR_GT_MULTI_TILE_ARCH_INFO(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GT_MULTI_TILE_ARCH_INFO, IsValid) + sizeof(IsValid) - offsetof(TOKSTR_GT_MULTI_TILE_ARCH_INFO, TileCount), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_GT_MULTI_TILE_ARCH_INFO() + : base(TOK_S_GT_MULTI_TILE_ARCH_INFO, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_ANONYMOUS8856 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS8856(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS8856, TileMask) + sizeof(TileMask) - offsetof(TOKSTR_ANONYMOUS8856, Tile0), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS8856() + : base(TOK_S_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_ANONYMOUS8876 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS8876(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS8876, Tile3) + sizeof(Tile3) - offsetof(TOKSTR_ANONYMOUS8876, Tile0), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS8876() + : base(TOK_S_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword Tile0 = {TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE0}; + TokenDword Tile1 = {TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE1}; + TokenDword Tile2 = {TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE2}; + TokenDword Tile3 = {TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE3}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS8876) % sizeof(uint32_t) == 0, ""); + + TokenDword Tile0 = {TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE0}; // Indirect field from anonymous struct + TokenDword Tile1 = {TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE1}; // Indirect field from anonymous struct + TokenDword Tile2 = {TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE2}; // Indirect field from anonymous struct + TokenDword Tile3 = {TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE3}; // Indirect field from anonymous struct + TokenDword TileMask = {TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__TILE_MASK}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS8856) % sizeof(uint32_t) == 0, ""); + + TokenDword TileCount = {TOK_FBC_GT_MULTI_TILE_ARCH_INFO__TILE_COUNT}; + TokenDword Tile0 = {TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE0}; // Indirect field from anonymous struct + TokenDword Tile1 = {TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE1}; // Indirect field from anonymous struct + TokenDword Tile2 = {TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE2}; // Indirect field from anonymous struct + TokenDword Tile3 = {TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE3}; // Indirect field from anonymous struct + TokenDword TileMask = {TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__TILE_MASK}; // Indirect field from anonymous struct + TokenBool IsValid = {TOK_FBB_GT_MULTI_TILE_ARCH_INFO__IS_VALID}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_GT_MULTI_TILE_ARCH_INFO) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_GT_SQIDI_INFO { + TokenVariableLength base; + + TOKSTR_GT_SQIDI_INFO(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GT_SQIDI_INFO, NumberofDoorbellPerSQIDI) + sizeof(NumberofDoorbellPerSQIDI) - offsetof(TOKSTR_GT_SQIDI_INFO, NumberofSQIDI), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_GT_SQIDI_INFO() + : base(TOK_S_GT_SQIDI_INFO, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword NumberofSQIDI = {TOK_FBD_GT_SQIDI_INFO__NUMBEROF_SQIDI}; + TokenDword NumberofDoorbellPerSQIDI = {TOK_FBD_GT_SQIDI_INFO__NUMBEROF_DOORBELL_PER_SQIDI}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_GT_SQIDI_INFO) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR__GT_CACHE_TYPES { + TokenVariableLength base; + + TOKSTR__GT_CACHE_TYPES(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR__GT_CACHE_TYPES, CacheTypeMask) + sizeof(CacheTypeMask) - offsetof(TOKSTR__GT_CACHE_TYPES, L3), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR__GT_CACHE_TYPES() + : base(TOK_S_GT_CACHE_TYPES, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_ANONYMOUS9544 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS9544(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS9544, eDRAM) + sizeof(eDRAM) - offsetof(TOKSTR_ANONYMOUS9544, L3), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS9544() + : base(TOK_S_GT_CACHE_TYPES__ANONYMOUS9544, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword L3 = {TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__L3}; + TokenDword LLC = {TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__LLC}; + TokenDword eDRAM = {TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__E_DRAM}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS9544) % sizeof(uint32_t) == 0, ""); + + TokenDword L3 = {TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__L3}; // Indirect field from anonymous struct + TokenDword LLC = {TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__LLC}; // Indirect field from anonymous struct + TokenDword eDRAM = {TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__E_DRAM}; // Indirect field from anonymous struct + TokenDword CacheTypeMask = {TOK_FBD_GT_CACHE_TYPES__CACHE_TYPE_MASK}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR__GT_CACHE_TYPES) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_GT_SYSTEM_INFO { + TokenVariableLength base; + + TOKSTR_GT_SYSTEM_INFO(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GT_SYSTEM_INFO, MaxVECS) + sizeof(MaxVECS) - offsetof(TOKSTR_GT_SYSTEM_INFO, EUCount), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_GT_SYSTEM_INFO() + : base(TOK_S_GT_SYSTEM_INFO, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword EUCount = {TOK_FBD_GT_SYSTEM_INFO__EUCOUNT}; + TokenDword ThreadCount = {TOK_FBD_GT_SYSTEM_INFO__THREAD_COUNT}; + TokenDword SliceCount = {TOK_FBD_GT_SYSTEM_INFO__SLICE_COUNT}; + TokenDword SubSliceCount = {TOK_FBD_GT_SYSTEM_INFO__SUB_SLICE_COUNT}; + TokenDword DualSubSliceCount = {TOK_FBD_GT_SYSTEM_INFO__DUAL_SUB_SLICE_COUNT}; + TokenQword L3CacheSizeInKb = {TOK_FBQ_GT_SYSTEM_INFO__L3CACHE_SIZE_IN_KB}; + TokenQword LLCCacheSizeInKb = {TOK_FBQ_GT_SYSTEM_INFO__LLCCACHE_SIZE_IN_KB}; + TokenQword EdramSizeInKb = {TOK_FBQ_GT_SYSTEM_INFO__EDRAM_SIZE_IN_KB}; + TokenDword L3BankCount = {TOK_FBD_GT_SYSTEM_INFO__L3BANK_COUNT}; + TokenDword MaxFillRate = {TOK_FBD_GT_SYSTEM_INFO__MAX_FILL_RATE}; + TokenDword EuCountPerPoolMax = {TOK_FBD_GT_SYSTEM_INFO__EU_COUNT_PER_POOL_MAX}; + TokenDword EuCountPerPoolMin = {TOK_FBD_GT_SYSTEM_INFO__EU_COUNT_PER_POOL_MIN}; + TokenDword TotalVsThreads = {TOK_FBD_GT_SYSTEM_INFO__TOTAL_VS_THREADS}; + TokenDword TotalHsThreads = {TOK_FBD_GT_SYSTEM_INFO__TOTAL_HS_THREADS}; + TokenDword TotalDsThreads = {TOK_FBD_GT_SYSTEM_INFO__TOTAL_DS_THREADS}; + TokenDword TotalGsThreads = {TOK_FBD_GT_SYSTEM_INFO__TOTAL_GS_THREADS}; + TokenDword TotalPsThreadsWindowerRange = {TOK_FBD_GT_SYSTEM_INFO__TOTAL_PS_THREADS_WINDOWER_RANGE}; + TokenDword TotalVsThreads_Pocs = {TOK_FBD_GT_SYSTEM_INFO__TOTAL_VS_THREADS_POCS}; + TokenDword CsrSizeInMb = {TOK_FBD_GT_SYSTEM_INFO__CSR_SIZE_IN_MB}; + TokenDword MaxEuPerSubSlice = {TOK_FBD_GT_SYSTEM_INFO__MAX_EU_PER_SUB_SLICE}; + TokenDword MaxSlicesSupported = {TOK_FBD_GT_SYSTEM_INFO__MAX_SLICES_SUPPORTED}; + TokenDword MaxSubSlicesSupported = {TOK_FBD_GT_SYSTEM_INFO__MAX_SUB_SLICES_SUPPORTED}; + TokenDword MaxDualSubSlicesSupported = {TOK_FBD_GT_SYSTEM_INFO__MAX_DUAL_SUB_SLICES_SUPPORTED}; + TokenBool IsL3HashModeEnabled = {TOK_FBB_GT_SYSTEM_INFO__IS_L3HASH_MODE_ENABLED}; + TOKSTR_GT_SLICE_INFO SliceInfo[10] = {{TOK_FS_GT_SYSTEM_INFO__SLICE_INFO, 0}, {TOK_FS_GT_SYSTEM_INFO__SLICE_INFO, 1}, {TOK_FS_GT_SYSTEM_INFO__SLICE_INFO, 2}, {TOK_FS_GT_SYSTEM_INFO__SLICE_INFO, 3}, {TOK_FS_GT_SYSTEM_INFO__SLICE_INFO, 4}, {TOK_FS_GT_SYSTEM_INFO__SLICE_INFO, 5}, {TOK_FS_GT_SYSTEM_INFO__SLICE_INFO, 6}, {TOK_FS_GT_SYSTEM_INFO__SLICE_INFO, 7}, {TOK_FS_GT_SYSTEM_INFO__SLICE_INFO, 8}, {TOK_FS_GT_SYSTEM_INFO__SLICE_INFO, 9}}; + TokenBool IsDynamicallyPopulated = {TOK_FBB_GT_SYSTEM_INFO__IS_DYNAMICALLY_POPULATED}; + TOKSTR_GT_SQIDI_INFO SqidiInfo = {TOK_FS_GT_SYSTEM_INFO__SQIDI_INFO}; + TokenDword ReservedCCSWays = {TOK_FBD_GT_SYSTEM_INFO__RESERVED_CCSWAYS}; + TOKSTR_GT_CCS_INFO CCSInfo = {TOK_FS_GT_SYSTEM_INFO__CCSINFO}; + TOKSTR_GT_MULTI_TILE_ARCH_INFO MultiTileArchInfo = {TOK_FS_GT_SYSTEM_INFO__MULTI_TILE_ARCH_INFO}; + TOKSTR_GT_VDBOX_INFO VDBoxInfo = {TOK_FS_GT_SYSTEM_INFO__VDBOX_INFO}; + TOKSTR_GT_VEBOX_INFO VEBoxInfo = {TOK_FS_GT_SYSTEM_INFO__VEBOX_INFO}; + TokenDword NumThreadsPerEu = {TOK_FBD_GT_SYSTEM_INFO__NUM_THREADS_PER_EU}; + TOKSTR__GT_CACHE_TYPES CacheTypes = {TOK_FS_GT_SYSTEM_INFO__CACHE_TYPES}; + TokenDword MaxVECS = {TOK_FBD_GT_SYSTEM_INFO__MAX_VECS}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_GT_SYSTEM_INFO) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR__SKU_FEATURE_TABLE { + TokenVariableLength base; + + TOKSTR__SKU_FEATURE_TABLE(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR__SKU_FEATURE_TABLE, FtrAssignedGpuTile) + sizeof(FtrAssignedGpuTile) - offsetof(TOKSTR__SKU_FEATURE_TABLE, FtrDesktop), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR__SKU_FEATURE_TABLE() + : base(TOK_S_SKU_FEATURE_TABLE, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_ANONYMOUS3245 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS3245(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS3245, FtrCCSMultiInstance) + sizeof(FtrCCSMultiInstance) - offsetof(TOKSTR_ANONYMOUS3245, FtrDesktop), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS3245() + : base(TOK_S_SKU_FEATURE_TABLE__ANONYMOUS3245, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword FtrDesktop = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_DESKTOP}; + TokenDword FtrVERing = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_VERING}; + TokenDword FtrVcs2 = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_VCS2}; + TokenDword FtrGtBigDie = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_BIG_DIE}; + TokenDword FtrGtMediumDie = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_MEDIUM_DIE}; + TokenDword FtrGtSmallDie = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_SMALL_DIE}; + TokenDword FtrGT1 = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT1}; + TokenDword FtrGT1_5 = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT1_5}; + TokenDword FtrGT2 = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT2}; + TokenDword FtrGT2_5 = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT2_5}; + TokenDword FtrGT3 = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT3}; + TokenDword FtrGT4 = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT4}; + TokenDword FtrULT = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_ULT}; + TokenDword FtrIVBM0M1Platform = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_IVBM0M1PLATFORM}; + TokenDword FtrChannelSwizzlingXOREnabled = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CHANNEL_SWIZZLING_XORENABLED}; + TokenDword FtrGTA = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTA}; + TokenDword FtrGTC = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTC}; + TokenDword FtrGTX = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTX}; + TokenDword Ftr5Slice = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR5SLICE}; + TokenDword FtrLCIA = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_LCIA}; + TokenDword FtrResourceStreamer = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_RESOURCE_STREAMER}; + TokenDword FtrCCSRing = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSRING}; + TokenDword FtrCCSNode = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSNODE}; + TokenDword FtrCCSMultiInstance = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSMULTI_INSTANCE}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS3245) % sizeof(uint32_t) == 0, ""); + + struct TOKSTR_ANONYMOUS11155 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS11155(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS11155, FtrSGTPVSKUStrapPresent) + sizeof(FtrSGTPVSKUStrapPresent) - offsetof(TOKSTR_ANONYMOUS11155, FtrDisplayDisabled), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS11155() + : base(TOK_S_SKU_FEATURE_TABLE__ANONYMOUS11155, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword FtrDisplayDisabled = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_DISPLAY_DISABLED}; + TokenDword FtrSGTPVSKUStrapPresent = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_SGTPVSKUSTRAP_PRESENT}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS11155) % sizeof(uint32_t) == 0, ""); + + struct TOKSTR_ANONYMOUS21584 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS21584(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS21584, FtrPooledEuEnabled) + sizeof(FtrPooledEuEnabled) - offsetof(TOKSTR_ANONYMOUS21584, FtrPooledEuEnabled), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS21584() + : base(TOK_S_SKU_FEATURE_TABLE__ANONYMOUS21584, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword FtrPooledEuEnabled = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21584__FTR_POOLED_EU_ENABLED}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS21584) % sizeof(uint32_t) == 0, ""); + + struct TOKSTR_ANONYMOUS21990 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS21990(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS21990, FtrDriverFLR) + sizeof(FtrDriverFLR) - offsetof(TOKSTR_ANONYMOUS21990, FtrGpGpuMidBatchPreempt), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS21990() + : base(TOK_S_SKU_FEATURE_TABLE__ANONYMOUS21990, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword FtrGpGpuMidBatchPreempt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_MID_BATCH_PREEMPT}; + TokenDword FtrGpGpuThreadGroupLevelPreempt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_THREAD_GROUP_LEVEL_PREEMPT}; + TokenDword FtrGpGpuMidThreadLevelPreempt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_MID_THREAD_LEVEL_PREEMPT}; + TokenDword Ftr3dMidBatchPreempt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR3D_MID_BATCH_PREEMPT}; + TokenDword Ftr3dObjectLevelPreempt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR3D_OBJECT_LEVEL_PREEMPT}; + TokenDword FtrPerCtxtPreemptionGranularityControl = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PER_CTXT_PREEMPTION_GRANULARITY_CONTROL}; + TokenDword FtrPPGTT = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PPGTT}; + TokenDword FtrIA32eGfxPTEs = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_IA32E_GFX_PTES}; + TokenDword FtrMemTypeMocsDeferPAT = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_MEM_TYPE_MOCS_DEFER_PAT}; + TokenDword FtrPml4Support = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PML4SUPPORT}; + TokenDword FtrSVM = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_SVM}; + TokenDword FtrTileMappedResource = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TILE_MAPPED_RESOURCE}; + TokenDword FtrTranslationTable = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TRANSLATION_TABLE}; + TokenDword FtrUserModeTranslationTable = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_USER_MODE_TRANSLATION_TABLE}; + TokenDword FtrNullPages = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_NULL_PAGES}; + TokenDword FtrL3IACoherency = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_L3IACOHERENCY}; + TokenDword FtrEDram = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_EDRAM}; + TokenDword FtrLLCBypass = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LLCBYPASS}; + TokenDword FtrCrystalwell = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CRYSTALWELL}; + TokenDword FtrCentralCachePolicy = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CENTRAL_CACHE_POLICY}; + TokenDword FtrIoMmuPageFaulting = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_IO_MMU_PAGE_FAULTING}; + TokenDword FtrWddm2GpuMmu = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2GPU_MMU}; + TokenDword FtrWddm2Svm = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2SVM}; + TokenDword FtrStandardMipTailFormat = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_STANDARD_MIP_TAIL_FORMAT}; + TokenDword FtrWddm2_1_64kbPages = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2_1_64KB_PAGES}; + TokenDword FtrGttCacheInvalidation = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GTT_CACHE_INVALIDATION}; + TokenDword FtrE2ECompression = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_E2ECOMPRESSION}; + TokenDword FtrLinearCCS = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LINEAR_CCS}; + TokenDword FtrLocalMemory = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LOCAL_MEMORY}; + TokenDword FtrPpgtt64KBWalkOptimization = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PPGTT64KBWALK_OPTIMIZATION}; + TokenDword FtrTileY = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TILE_Y}; + TokenDword FtrFlatPhysCCS = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_FLAT_PHYS_CCS}; + TokenDword FtrMultiTileArch = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_MULTI_TILE_ARCH}; + TokenDword FtrLocalMemoryAllows4KB = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LOCAL_MEMORY_ALLOWS4KB}; + TokenDword FtrDisplayXTiling = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_DISPLAY_XTILING}; + TokenDword FtrCameraCaptureCaching = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CAMERA_CAPTURE_CACHING}; + TokenDword FtrKmdDaf = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_KMD_DAF}; + TokenDword FtrFrameBufferLLC = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_FRAME_BUFFER_LLC}; + TokenDword FtrDriverFLR = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_DRIVER_FLR}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS21990) % sizeof(uint32_t) == 0, ""); + + struct TOKSTR_ANONYMOUS37751 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS37751(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS37751, FtrAstc3D) + sizeof(FtrAstc3D) - offsetof(TOKSTR_ANONYMOUS37751, FtrAstcLdr2D), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS37751() + : base(TOK_S_SKU_FEATURE_TABLE__ANONYMOUS37751, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword FtrAstcLdr2D = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC_LDR2D}; + TokenDword FtrAstcHdr2D = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC_HDR2D}; + TokenDword FtrAstc3D = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC3D}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS37751) % sizeof(uint32_t) == 0, ""); + + struct TOKSTR_ANONYMOUS42853 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS42853(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS42853, FtrVEBOX) + sizeof(FtrVEBOX) - offsetof(TOKSTR_ANONYMOUS42853, FtrFbc), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS42853() + : base(TOK_S_SKU_FEATURE_TABLE__ANONYMOUS42853, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword FtrFbc = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC}; + TokenDword FtrFbc2AddressTranslation = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC2ADDRESS_TRANSLATION}; + TokenDword FtrFbcBlitterTracking = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC_BLITTER_TRACKING}; + TokenDword FtrFbcCpuTracking = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC_CPU_TRACKING}; + TokenDword FtrVEBOX = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_VEBOX}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS42853) % sizeof(uint32_t) == 0, ""); + + struct TOKSTR_ANONYMOUS54736 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS54736(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS54736, FtrDisplayYTiling) + sizeof(FtrDisplayYTiling) - offsetof(TOKSTR_ANONYMOUS54736, FtrRendComp), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS54736() + : base(TOK_S_SKU_FEATURE_TABLE__ANONYMOUS54736, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword FtrRendComp = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS54736__FTR_REND_COMP}; + TokenDword FtrDisplayYTiling = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS54736__FTR_DISPLAY_YTILING}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS54736) % sizeof(uint32_t) == 0, ""); + + struct TOKSTR_ANONYMOUS66219 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS66219(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS66219, FtrSimulationMode) + sizeof(FtrSimulationMode) - offsetof(TOKSTR_ANONYMOUS66219, FtrS3D), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS66219() + : base(TOK_S_SKU_FEATURE_TABLE__ANONYMOUS66219, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword FtrS3D = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_S3D}; + TokenDword FtrDisplayEngineS3d = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_DISPLAY_ENGINE_S3D}; + TokenDword FtrSingleVeboxSlice = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_SINGLE_VEBOX_SLICE}; + TokenDword FtrSimulationMode = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_SIMULATION_MODE}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS66219) % sizeof(uint32_t) == 0, ""); + + struct TOKSTR_ANONYMOUS88095 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS88095(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS88095, FtrEnableGuC) + sizeof(FtrEnableGuC) - offsetof(TOKSTR_ANONYMOUS88095, FtrEnableGuC), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS88095() + : base(TOK_S_SKU_FEATURE_TABLE__ANONYMOUS88095, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword FtrEnableGuC = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS88095__FTR_ENABLE_GU_C}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS88095) % sizeof(uint32_t) == 0, ""); + + struct TOKSTR_ANONYMOUS89755 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS89755(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS89755, FtrVgt) + sizeof(FtrVgt) - offsetof(TOKSTR_ANONYMOUS89755, FtrVgt), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS89755() + : base(TOK_S_SKU_FEATURE_TABLE__ANONYMOUS89755, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword FtrVgt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS89755__FTR_VGT}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS89755) % sizeof(uint32_t) == 0, ""); + + struct TOKSTR_ANONYMOUS91822 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS91822(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS91822, FtrAssignedGpuTile) + sizeof(FtrAssignedGpuTile) - offsetof(TOKSTR_ANONYMOUS91822, FtrAssignedGpuTile), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS91822() + : base(TOK_S_SKU_FEATURE_TABLE__ANONYMOUS91822, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword FtrAssignedGpuTile = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS91822__FTR_ASSIGNED_GPU_TILE}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS91822) % sizeof(uint32_t) == 0, ""); + + TokenDword FtrDesktop = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_DESKTOP}; // Indirect field from anonymous struct + TokenDword FtrVERing = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_VERING}; // Indirect field from anonymous struct + TokenDword FtrVcs2 = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_VCS2}; // Indirect field from anonymous struct + TokenDword FtrGtBigDie = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_BIG_DIE}; // Indirect field from anonymous struct + TokenDword FtrGtMediumDie = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_MEDIUM_DIE}; // Indirect field from anonymous struct + TokenDword FtrGtSmallDie = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_SMALL_DIE}; // Indirect field from anonymous struct + TokenDword FtrGT1 = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT1}; // Indirect field from anonymous struct + TokenDword FtrGT1_5 = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT1_5}; // Indirect field from anonymous struct + TokenDword FtrGT2 = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT2}; // Indirect field from anonymous struct + TokenDword FtrGT2_5 = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT2_5}; // Indirect field from anonymous struct + TokenDword FtrGT3 = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT3}; // Indirect field from anonymous struct + TokenDword FtrGT4 = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT4}; // Indirect field from anonymous struct + TokenDword FtrULT = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_ULT}; // Indirect field from anonymous struct + TokenDword FtrIVBM0M1Platform = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_IVBM0M1PLATFORM}; // Indirect field from anonymous struct + TokenDword FtrChannelSwizzlingXOREnabled = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CHANNEL_SWIZZLING_XORENABLED}; // Indirect field from anonymous struct + TokenDword FtrGTA = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTA}; // Indirect field from anonymous struct + TokenDword FtrGTC = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTC}; // Indirect field from anonymous struct + TokenDword FtrGTX = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTX}; // Indirect field from anonymous struct + TokenDword Ftr5Slice = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR5SLICE}; // Indirect field from anonymous struct + TokenDword FtrLCIA = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_LCIA}; // Indirect field from anonymous struct + TokenDword FtrResourceStreamer = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_RESOURCE_STREAMER}; // Indirect field from anonymous struct + TokenDword FtrCCSRing = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSRING}; // Indirect field from anonymous struct + TokenDword FtrCCSNode = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSNODE}; // Indirect field from anonymous struct + TokenDword FtrCCSMultiInstance = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSMULTI_INSTANCE}; // Indirect field from anonymous struct + TokenDword FtrDisplayDisabled = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_DISPLAY_DISABLED}; // Indirect field from anonymous struct + TokenDword FtrSGTPVSKUStrapPresent = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_SGTPVSKUSTRAP_PRESENT}; // Indirect field from anonymous struct + TokenDword FtrPooledEuEnabled = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21584__FTR_POOLED_EU_ENABLED}; // Indirect field from anonymous struct + TokenDword FtrGpGpuMidBatchPreempt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_MID_BATCH_PREEMPT}; // Indirect field from anonymous struct + TokenDword FtrGpGpuThreadGroupLevelPreempt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_THREAD_GROUP_LEVEL_PREEMPT}; // Indirect field from anonymous struct + TokenDword FtrGpGpuMidThreadLevelPreempt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_MID_THREAD_LEVEL_PREEMPT}; // Indirect field from anonymous struct + TokenDword Ftr3dMidBatchPreempt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR3D_MID_BATCH_PREEMPT}; // Indirect field from anonymous struct + TokenDword Ftr3dObjectLevelPreempt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR3D_OBJECT_LEVEL_PREEMPT}; // Indirect field from anonymous struct + TokenDword FtrPerCtxtPreemptionGranularityControl = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PER_CTXT_PREEMPTION_GRANULARITY_CONTROL}; // Indirect field from anonymous struct + TokenDword FtrPPGTT = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PPGTT}; // Indirect field from anonymous struct + TokenDword FtrIA32eGfxPTEs = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_IA32E_GFX_PTES}; // Indirect field from anonymous struct + TokenDword FtrMemTypeMocsDeferPAT = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_MEM_TYPE_MOCS_DEFER_PAT}; // Indirect field from anonymous struct + TokenDword FtrPml4Support = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PML4SUPPORT}; // Indirect field from anonymous struct + TokenDword FtrSVM = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_SVM}; // Indirect field from anonymous struct + TokenDword FtrTileMappedResource = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TILE_MAPPED_RESOURCE}; // Indirect field from anonymous struct + TokenDword FtrTranslationTable = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TRANSLATION_TABLE}; // Indirect field from anonymous struct + TokenDword FtrUserModeTranslationTable = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_USER_MODE_TRANSLATION_TABLE}; // Indirect field from anonymous struct + TokenDword FtrNullPages = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_NULL_PAGES}; // Indirect field from anonymous struct + TokenDword FtrL3IACoherency = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_L3IACOHERENCY}; // Indirect field from anonymous struct + TokenDword FtrEDram = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_EDRAM}; // Indirect field from anonymous struct + TokenDword FtrLLCBypass = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LLCBYPASS}; // Indirect field from anonymous struct + TokenDword FtrCrystalwell = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CRYSTALWELL}; // Indirect field from anonymous struct + TokenDword FtrCentralCachePolicy = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CENTRAL_CACHE_POLICY}; // Indirect field from anonymous struct + TokenDword FtrIoMmuPageFaulting = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_IO_MMU_PAGE_FAULTING}; // Indirect field from anonymous struct + TokenDword FtrWddm2GpuMmu = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2GPU_MMU}; // Indirect field from anonymous struct + TokenDword FtrWddm2Svm = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2SVM}; // Indirect field from anonymous struct + TokenDword FtrStandardMipTailFormat = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_STANDARD_MIP_TAIL_FORMAT}; // Indirect field from anonymous struct + TokenDword FtrWddm2_1_64kbPages = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2_1_64KB_PAGES}; // Indirect field from anonymous struct + TokenDword FtrGttCacheInvalidation = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GTT_CACHE_INVALIDATION}; // Indirect field from anonymous struct + TokenDword FtrE2ECompression = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_E2ECOMPRESSION}; // Indirect field from anonymous struct + TokenDword FtrLinearCCS = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LINEAR_CCS}; // Indirect field from anonymous struct + TokenDword FtrLocalMemory = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LOCAL_MEMORY}; // Indirect field from anonymous struct + TokenDword FtrPpgtt64KBWalkOptimization = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PPGTT64KBWALK_OPTIMIZATION}; // Indirect field from anonymous struct + TokenDword FtrTileY = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TILE_Y}; // Indirect field from anonymous struct + TokenDword FtrFlatPhysCCS = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_FLAT_PHYS_CCS}; // Indirect field from anonymous struct + TokenDword FtrMultiTileArch = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_MULTI_TILE_ARCH}; // Indirect field from anonymous struct + TokenDword FtrLocalMemoryAllows4KB = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LOCAL_MEMORY_ALLOWS4KB}; // Indirect field from anonymous struct + TokenDword FtrDisplayXTiling = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_DISPLAY_XTILING}; // Indirect field from anonymous struct + TokenDword FtrCameraCaptureCaching = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CAMERA_CAPTURE_CACHING}; // Indirect field from anonymous struct + TokenDword FtrKmdDaf = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_KMD_DAF}; // Indirect field from anonymous struct + TokenDword FtrFrameBufferLLC = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_FRAME_BUFFER_LLC}; // Indirect field from anonymous struct + TokenDword FtrDriverFLR = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_DRIVER_FLR}; // Indirect field from anonymous struct + TokenDword FtrAstcLdr2D = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC_LDR2D}; // Indirect field from anonymous struct + TokenDword FtrAstcHdr2D = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC_HDR2D}; // Indirect field from anonymous struct + TokenDword FtrAstc3D = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC3D}; // Indirect field from anonymous struct + TokenDword FtrFbc = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC}; // Indirect field from anonymous struct + TokenDword FtrFbc2AddressTranslation = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC2ADDRESS_TRANSLATION}; // Indirect field from anonymous struct + TokenDword FtrFbcBlitterTracking = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC_BLITTER_TRACKING}; // Indirect field from anonymous struct + TokenDword FtrFbcCpuTracking = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC_CPU_TRACKING}; // Indirect field from anonymous struct + TokenDword FtrVEBOX = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_VEBOX}; // Indirect field from anonymous struct + TokenDword FtrRendComp = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS54736__FTR_REND_COMP}; // Indirect field from anonymous struct + TokenDword FtrDisplayYTiling = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS54736__FTR_DISPLAY_YTILING}; // Indirect field from anonymous struct + TokenDword FtrS3D = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_S3D}; // Indirect field from anonymous struct + TokenDword FtrDisplayEngineS3d = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_DISPLAY_ENGINE_S3D}; // Indirect field from anonymous struct + TokenDword FtrSingleVeboxSlice = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_SINGLE_VEBOX_SLICE}; // Indirect field from anonymous struct + TokenDword FtrSimulationMode = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_SIMULATION_MODE}; // Indirect field from anonymous struct + TokenDword FtrEnableGuC = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS88095__FTR_ENABLE_GU_C}; // Indirect field from anonymous struct + TokenDword FtrVgt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS89755__FTR_VGT}; // Indirect field from anonymous struct + TokenDword FtrAssignedGpuTile = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS91822__FTR_ASSIGNED_GPU_TILE}; // Indirect field from anonymous struct +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR__SKU_FEATURE_TABLE) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR__WA_TABLE { + TokenVariableLength base; + + TOKSTR__WA_TABLE(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR__WA_TABLE, Wa32bppTileY2DColorNoHAlign4) + sizeof(Wa32bppTileY2DColorNoHAlign4) - offsetof(TOKSTR__WA_TABLE, WaDoNotUseMIReportPerfCount), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR__WA_TABLE() + : base(TOK_S_WA_TABLE, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword WaDoNotUseMIReportPerfCount = {TOK_FBD_WA_TABLE__WA_DO_NOT_USE_MIREPORT_PERF_COUNT}; + TokenDword WaAlignIndexBuffer = {TOK_FBD_WA_TABLE__WA_ALIGN_INDEX_BUFFER}; + TokenDword WaSendMIFLUSHBeforeVFE = {TOK_FBD_WA_TABLE__WA_SEND_MIFLUSHBEFORE_VFE}; + TokenDword WaDisablePerCtxtPreemptionGranularityControl = {TOK_FBD_WA_TABLE__WA_DISABLE_PER_CTXT_PREEMPTION_GRANULARITY_CONTROL}; + TokenDword WaEnablePreemptionGranularityControlByUMD = {TOK_FBD_WA_TABLE__WA_ENABLE_PREEMPTION_GRANULARITY_CONTROL_BY_UMD}; + TokenDword WaDisableLSQCROPERFforOCL = {TOK_FBD_WA_TABLE__WA_DISABLE_LSQCROPERFFOR_OCL}; + TokenDword WaValign2For96bppFormats = {TOK_FBD_WA_TABLE__WA_VALIGN2FOR96BPP_FORMATS}; + TokenDword WaValign2ForR8G8B8UINTFormat = {TOK_FBD_WA_TABLE__WA_VALIGN2FOR_R8G8B8UINTFORMAT}; + TokenDword WaReportPerfCountUseGlobalContextID = {TOK_FBD_WA_TABLE__WA_REPORT_PERF_COUNT_USE_GLOBAL_CONTEXT_ID}; + TokenDword WaForcePcBbFullCfgRestore = {TOK_FBD_WA_TABLE__WA_FORCE_PC_BB_FULL_CFG_RESTORE}; + TokenDword WaCSRUncachable = {TOK_FBD_WA_TABLE__WA_CSRUNCACHABLE}; + TokenDword WaDisableFusedThreadScheduling = {TOK_FBD_WA_TABLE__WA_DISABLE_FUSED_THREAD_SCHEDULING}; + TokenDword WaModifyVFEStateAfterGPGPUPreemption = {TOK_FBD_WA_TABLE__WA_MODIFY_VFESTATE_AFTER_GPGPUPREEMPTION}; + TokenDword WaCursor16K = {TOK_FBD_WA_TABLE__WA_CURSOR16K}; + TokenDword Wa8kAlignforAsyncFlip = {TOK_FBD_WA_TABLE__WA8K_ALIGNFOR_ASYNC_FLIP}; + TokenDword Wa29BitDisplayAddrLimit = {TOK_FBD_WA_TABLE__WA29BIT_DISPLAY_ADDR_LIMIT}; + TokenDword WaAlignContextImage = {TOK_FBD_WA_TABLE__WA_ALIGN_CONTEXT_IMAGE}; + TokenDword WaForceGlobalGTT = {TOK_FBD_WA_TABLE__WA_FORCE_GLOBAL_GTT}; + TokenDword WaReportPerfCountForceGlobalGTT = {TOK_FBD_WA_TABLE__WA_REPORT_PERF_COUNT_FORCE_GLOBAL_GTT}; + TokenDword WaOaAddressTranslation = {TOK_FBD_WA_TABLE__WA_OA_ADDRESS_TRANSLATION}; + TokenDword Wa2RowVerticalAlignment = {TOK_FBD_WA_TABLE__WA2ROW_VERTICAL_ALIGNMENT}; + TokenDword WaPpgttAliasGlobalGttSpace = {TOK_FBD_WA_TABLE__WA_PPGTT_ALIAS_GLOBAL_GTT_SPACE}; + TokenDword WaClearFenceRegistersAtDriverInit = {TOK_FBD_WA_TABLE__WA_CLEAR_FENCE_REGISTERS_AT_DRIVER_INIT}; + TokenDword WaRestrictPitch128KB = {TOK_FBD_WA_TABLE__WA_RESTRICT_PITCH128KB}; + TokenDword WaAvoidLLC = {TOK_FBD_WA_TABLE__WA_AVOID_LLC}; + TokenDword WaAvoidL3 = {TOK_FBD_WA_TABLE__WA_AVOID_L3}; + TokenDword Wa16TileFencesOnly = {TOK_FBD_WA_TABLE__WA16TILE_FENCES_ONLY}; + TokenDword Wa16MBOABufferAlignment = {TOK_FBD_WA_TABLE__WA16MBOABUFFER_ALIGNMENT}; + TokenDword WaTranslationTableUnavailable = {TOK_FBD_WA_TABLE__WA_TRANSLATION_TABLE_UNAVAILABLE}; + TokenDword WaNoMinimizedTrivialSurfacePadding = {TOK_FBD_WA_TABLE__WA_NO_MINIMIZED_TRIVIAL_SURFACE_PADDING}; + TokenDword WaNoBufferSamplerPadding = {TOK_FBD_WA_TABLE__WA_NO_BUFFER_SAMPLER_PADDING}; + TokenDword WaSurfaceStatePlanarYOffsetAlignBy2 = {TOK_FBD_WA_TABLE__WA_SURFACE_STATE_PLANAR_YOFFSET_ALIGN_BY2}; + TokenDword WaGttCachingOffByDefault = {TOK_FBD_WA_TABLE__WA_GTT_CACHING_OFF_BY_DEFAULT}; + TokenDword WaTouchAllSvmMemory = {TOK_FBD_WA_TABLE__WA_TOUCH_ALL_SVM_MEMORY}; + TokenDword WaIOBAddressMustBeValidInHwContext = {TOK_FBD_WA_TABLE__WA_IOBADDRESS_MUST_BE_VALID_IN_HW_CONTEXT}; + TokenDword WaFlushTlbAfterCpuGgttWrites = {TOK_FBD_WA_TABLE__WA_FLUSH_TLB_AFTER_CPU_GGTT_WRITES}; + TokenDword WaMsaa8xTileYDepthPitchAlignment = {TOK_FBD_WA_TABLE__WA_MSAA8X_TILE_YDEPTH_PITCH_ALIGNMENT}; + TokenDword WaDisableNullPageAsDummy = {TOK_FBD_WA_TABLE__WA_DISABLE_NULL_PAGE_AS_DUMMY}; + TokenDword WaUseVAlign16OnTileXYBpp816 = {TOK_FBD_WA_TABLE__WA_USE_VALIGN16ON_TILE_XYBPP816}; + TokenDword WaGttPat0 = {TOK_FBD_WA_TABLE__WA_GTT_PAT0}; + TokenDword WaGttPat0WB = {TOK_FBD_WA_TABLE__WA_GTT_PAT0WB}; + TokenDword WaMemTypeIsMaxOfPatAndMocs = {TOK_FBD_WA_TABLE__WA_MEM_TYPE_IS_MAX_OF_PAT_AND_MOCS}; + TokenDword WaGttPat0GttWbOverOsIommuEllcOnly = {TOK_FBD_WA_TABLE__WA_GTT_PAT0GTT_WB_OVER_OS_IOMMU_ELLC_ONLY}; + TokenDword WaAddDummyPageForDisplayPrefetch = {TOK_FBD_WA_TABLE__WA_ADD_DUMMY_PAGE_FOR_DISPLAY_PREFETCH}; + TokenDword WaDefaultTile4 = {TOK_FBD_WA_TABLE__WA_DEFAULT_TILE4}; + TokenDword WaLLCCachingUnsupported = {TOK_FBD_WA_TABLE__WA_LLCCACHING_UNSUPPORTED}; + TokenDword WaDoubleFastClearWidthAlignment = {TOK_FBD_WA_TABLE__WA_DOUBLE_FAST_CLEAR_WIDTH_ALIGNMENT}; + TokenDword WaCompressedResourceRequiresConstVA21 = {TOK_FBD_WA_TABLE__WA_COMPRESSED_RESOURCE_REQUIRES_CONST_VA21}; + TokenDword WaDisregardPlatformChecks = {TOK_FBD_WA_TABLE__WA_DISREGARD_PLATFORM_CHECKS}; + TokenDword WaLosslessCompressionSurfaceStride = {TOK_FBD_WA_TABLE__WA_LOSSLESS_COMPRESSION_SURFACE_STRIDE}; + TokenDword WaFbcLinearSurfaceStride = {TOK_FBD_WA_TABLE__WA_FBC_LINEAR_SURFACE_STRIDE}; + TokenDword Wa4kAlignUVOffsetNV12LinearSurface = {TOK_FBD_WA_TABLE__WA4K_ALIGN_UVOFFSET_NV12LINEAR_SURFACE}; + TokenDword WaAstcCorruptionForOddCompressedBlockSizeX = {TOK_FBD_WA_TABLE__WA_ASTC_CORRUPTION_FOR_ODD_COMPRESSED_BLOCK_SIZE_X}; + TokenDword WaAuxTable16KGranular = {TOK_FBD_WA_TABLE__WA_AUX_TABLE16KGRANULAR}; + TokenDword WaEncryptedEdramOnlyPartials = {TOK_FBD_WA_TABLE__WA_ENCRYPTED_EDRAM_ONLY_PARTIALS}; + TokenDword WaDisableEdramForDisplayRT = {TOK_FBD_WA_TABLE__WA_DISABLE_EDRAM_FOR_DISPLAY_RT}; + TokenDword WaLimit128BMediaCompr = {TOK_FBD_WA_TABLE__WA_LIMIT128BMEDIA_COMPR}; + TokenDword WaUntypedBufferCompression = {TOK_FBD_WA_TABLE__WA_UNTYPED_BUFFER_COMPRESSION}; + TokenDword WaSamplerCacheFlushBetweenRedescribedSurfaceReads = {TOK_FBD_WA_TABLE__WA_SAMPLER_CACHE_FLUSH_BETWEEN_REDESCRIBED_SURFACE_READS}; + TokenDword WaAlignYUVResourceToLCU = {TOK_FBD_WA_TABLE__WA_ALIGN_YUVRESOURCE_TO_LCU}; + TokenDword Wa32bppTileY2DColorNoHAlign4 = {TOK_FBD_WA_TABLE__WA32BPP_TILE_Y2DCOLOR_NO_HALIGN4}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR__WA_TABLE) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_PLATFORM_STR { + TokenVariableLength base; + + TOKSTR_PLATFORM_STR(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_PLATFORM_STR, eGTType) + sizeof(eGTType) - offsetof(TOKSTR_PLATFORM_STR, eProductFamily), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_PLATFORM_STR() + : base(TOK_S_PLATFORM_STR, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword eProductFamily = {TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY}; + TokenDword ePCHProductFamily = {TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY}; + TokenDword eDisplayCoreFamily = {TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY}; + TokenDword eRenderCoreFamily = {TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY}; + TokenDword ePlatformType = {TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE}; + TokenDword usDeviceID = {TOK_FBW_PLATFORM_STR__US_DEVICE_ID}; + TokenDword usRevId = {TOK_FBW_PLATFORM_STR__US_REV_ID}; + TokenDword usDeviceID_PCH = {TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH}; + TokenDword usRevId_PCH = {TOK_FBW_PLATFORM_STR__US_REV_ID_PCH}; + TokenDword eGTType = {TOK_FE_PLATFORM_STR__E_GTTYPE}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_PLATFORM_STR) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR___KMD_CAPS_INFO { + TokenVariableLength base; + + TOKSTR___KMD_CAPS_INFO(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR___KMD_CAPS_INFO, DriverStoreEnabled) + sizeof(DriverStoreEnabled) - offsetof(TOKSTR___KMD_CAPS_INFO, Gamma_Rgb256x3x16), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR___KMD_CAPS_INFO() + : base(TOK_S_KMD_CAPS_INFO, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword Gamma_Rgb256x3x16 = {TOK_FBD_KMD_CAPS_INFO__GAMMA_RGB256X3X16}; + TokenDword GDIAcceleration = {TOK_FBD_KMD_CAPS_INFO__GDIACCELERATION}; + TokenDword OsManagedHwContext = {TOK_FBD_KMD_CAPS_INFO__OS_MANAGED_HW_CONTEXT}; + TokenDword GraphicsPreemptionGranularity = {TOK_FBD_KMD_CAPS_INFO__GRAPHICS_PREEMPTION_GRANULARITY}; + TokenDword ComputePreemptionGranularity = {TOK_FBD_KMD_CAPS_INFO__COMPUTE_PREEMPTION_GRANULARITY}; + TokenDword InstrumentationIsEnabled = {TOK_FBD_KMD_CAPS_INFO__INSTRUMENTATION_IS_ENABLED}; + TokenDword DriverStoreEnabled = {TOK_FBD_KMD_CAPS_INFO__DRIVER_STORE_ENABLED}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR___KMD_CAPS_INFO) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR___KMD_OVERLAY_OVERRIDE { + TokenVariableLength base; + + TOKSTR___KMD_OVERLAY_OVERRIDE(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR___KMD_OVERLAY_OVERRIDE, YUY2Overlay) + sizeof(YUY2Overlay) - offsetof(TOKSTR___KMD_OVERLAY_OVERRIDE, OverrideOverlayCaps), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR___KMD_OVERLAY_OVERRIDE() + : base(TOK_S_KMD_OVERLAY_OVERRIDE, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword OverrideOverlayCaps = {TOK_FBD_KMD_OVERLAY_OVERRIDE__OVERRIDE_OVERLAY_CAPS}; + TokenDword RGBOverlay = {TOK_FBD_KMD_OVERLAY_OVERRIDE__RGBOVERLAY}; + TokenDword YUY2Overlay = {TOK_FBD_KMD_OVERLAY_OVERRIDE__YUY2OVERLAY}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR___KMD_OVERLAY_OVERRIDE) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR___KMD_OVERLAY_CAPS_INFO { + TokenVariableLength base; + + TOKSTR___KMD_OVERLAY_CAPS_INFO(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR___KMD_OVERLAY_CAPS_INFO, MaxHWScalerStride) + sizeof(MaxHWScalerStride) - offsetof(TOKSTR___KMD_OVERLAY_CAPS_INFO, Caps), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR___KMD_OVERLAY_CAPS_INFO() + : base(TOK_S_KMD_OVERLAY_CAPS_INFO, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_ANONYMOUS5171 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS5171(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS5171, CapsValue) + sizeof(CapsValue) - offsetof(TOKSTR_ANONYMOUS5171, Caps), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS5171() + : base(TOK_S_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_ANONYMOUS5191 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS5191(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS5191, StretchY) + sizeof(StretchY) - offsetof(TOKSTR_ANONYMOUS5191, FullRangeRGB), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS5191() + : base(TOK_S_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword FullRangeRGB = {TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__FULL_RANGE_RGB}; + TokenDword LimitedRangeRGB = {TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__LIMITED_RANGE_RGB}; + TokenDword YCbCr_BT601 = {TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT601}; + TokenDword YCbCr_BT709 = {TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT709}; + TokenDword YCbCr_BT601_xvYCC = {TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT601_XV_YCC}; + TokenDword YCbCr_BT709_xvYCC = {TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT709_XV_YCC}; + TokenDword StretchX = {TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__STRETCH_X}; + TokenDword StretchY = {TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__STRETCH_Y}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS5191) % sizeof(uint32_t) == 0, ""); + + TOKSTR_ANONYMOUS5191 Caps = {TOK_FS_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__CAPS}; + TokenDword CapsValue = {TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__CAPS_VALUE}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS5171) % sizeof(uint32_t) == 0, ""); + + TOKSTR_ANONYMOUS5171::TOKSTR_ANONYMOUS5191 Caps = {TOK_FS_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__CAPS}; // Indirect field from anonymous struct + TokenDword CapsValue = {TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__CAPS_VALUE}; // Indirect field from anonymous struct + TOKSTR___KMD_OVERLAY_OVERRIDE OVOverride = {TOK_FS_KMD_OVERLAY_CAPS_INFO__OVOVERRIDE}; + TokenDword MaxOverlayDisplayWidth = {TOK_FBD_KMD_OVERLAY_CAPS_INFO__MAX_OVERLAY_DISPLAY_WIDTH}; + TokenDword MaxOverlayDisplayHeight = {TOK_FBD_KMD_OVERLAY_CAPS_INFO__MAX_OVERLAY_DISPLAY_HEIGHT}; + TokenDword HWScalerExists = {TOK_FBC_KMD_OVERLAY_CAPS_INFO__HWSCALER_EXISTS}; + TokenDword MaxHWScalerStride = {TOK_FBD_KMD_OVERLAY_CAPS_INFO__MAX_HWSCALER_STRIDE}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR___KMD_OVERLAY_CAPS_INFO) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_FRAME_RATE { + TokenVariableLength base; + + TOKSTR_FRAME_RATE(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_FRAME_RATE, uiDenominator) + sizeof(uiDenominator) - offsetof(TOKSTR_FRAME_RATE, uiNumerator), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_FRAME_RATE() + : base(TOK_S_FRAME_RATE, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword uiNumerator = {TOK_FBD_FRAME_RATE__UI_NUMERATOR}; + TokenDword uiDenominator = {TOK_FBD_FRAME_RATE__UI_DENOMINATOR}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_FRAME_RATE) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR__KM_DEFERRED_WAIT_INFO { + TokenVariableLength base; + + TOKSTR__KM_DEFERRED_WAIT_INFO(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR__KM_DEFERRED_WAIT_INFO, ActiveDisplay) + sizeof(ActiveDisplay) - offsetof(TOKSTR__KM_DEFERRED_WAIT_INFO, FeatureSupported), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR__KM_DEFERRED_WAIT_INFO() + : base(TOK_S_KM_DEFERRED_WAIT_INFO, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword FeatureSupported = {TOK_FBD_KM_DEFERRED_WAIT_INFO__FEATURE_SUPPORTED}; + TokenDword ActiveDisplay = {TOK_FBD_KM_DEFERRED_WAIT_INFO__ACTIVE_DISPLAY}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR__KM_DEFERRED_WAIT_INFO) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR___GMM_GFX_PARTITIONING { + TokenVariableLength base; + + TOKSTR___GMM_GFX_PARTITIONING(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR___GMM_GFX_PARTITIONING, Heap32) + sizeof(Heap32) - offsetof(TOKSTR___GMM_GFX_PARTITIONING, Standard), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR___GMM_GFX_PARTITIONING() + : base(TOK_S_GMM_GFX_PARTITIONING, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_ANONYMOUS7117 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS7117(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS7117, Limit) + sizeof(Limit) - offsetof(TOKSTR_ANONYMOUS7117, Base), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS7117() + : base(TOK_S_GMM_GFX_PARTITIONING__ANONYMOUS7117, 0, sizeof(*this) - sizeof(base)) {} + + TokenQword Base = {TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__BASE}; + TokenQword Limit = {TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__LIMIT}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS7117) % sizeof(uint32_t) == 0, ""); + + TOKSTR_ANONYMOUS7117 Standard = {TOK_FS_GMM_GFX_PARTITIONING__STANDARD}; + TOKSTR_ANONYMOUS7117 Standard64KB = {TOK_FS_GMM_GFX_PARTITIONING__STANDARD64KB}; + TOKSTR_ANONYMOUS7117 SVM = {TOK_FS_GMM_GFX_PARTITIONING__SVM}; + TOKSTR_ANONYMOUS7117 Heap32[4] = {{TOK_FS_GMM_GFX_PARTITIONING__HEAP32, 0}, {TOK_FS_GMM_GFX_PARTITIONING__HEAP32, 1}, {TOK_FS_GMM_GFX_PARTITIONING__HEAP32, 2}, {TOK_FS_GMM_GFX_PARTITIONING__HEAP32, 3}}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR___GMM_GFX_PARTITIONING) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR__ADAPTER_BDF_ { + TokenVariableLength base; + + TOKSTR__ADAPTER_BDF_(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR__ADAPTER_BDF_, Data) + sizeof(Data) - offsetof(TOKSTR__ADAPTER_BDF_, Bus), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR__ADAPTER_BDF_() + : base(TOK_S_ADAPTER_BDF, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_ANONYMOUS8173 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS8173(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS8173, Data) + sizeof(Data) - offsetof(TOKSTR_ANONYMOUS8173, Bus), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS8173() + : base(TOK_S_ADAPTER_BDF___ANONYMOUS8173, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_ANONYMOUS8193 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS8193(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS8193, Function) + sizeof(Function) - offsetof(TOKSTR_ANONYMOUS8193, Bus), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS8193() + : base(TOK_S_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword Bus = {TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__BUS}; + TokenDword Device = {TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__DEVICE}; + TokenDword Function = {TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__FUNCTION}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS8193) % sizeof(uint32_t) == 0, ""); + + TokenDword Bus = {TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__BUS}; // Indirect field from anonymous struct + TokenDword Device = {TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__DEVICE}; // Indirect field from anonymous struct + TokenDword Function = {TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__FUNCTION}; // Indirect field from anonymous struct + TokenDword Data = {TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__DATA}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS8173) % sizeof(uint32_t) == 0, ""); + + TokenDword Bus = {TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__BUS}; // Indirect field from anonymous struct + TokenDword Device = {TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__DEVICE}; // Indirect field from anonymous struct + TokenDword Function = {TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__FUNCTION}; // Indirect field from anonymous struct + TokenDword Data = {TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__DATA}; // Indirect field from anonymous struct +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR__ADAPTER_BDF_) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR__ADAPTER_INFO { + TokenVariableLength base; + + TOKSTR__ADAPTER_INFO(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR__ADAPTER_INFO, stAdapterBDF) + sizeof(stAdapterBDF) - offsetof(TOKSTR__ADAPTER_INFO, KmdVersionInfo), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR__ADAPTER_INFO() + : base(TOK_S_ADAPTER_INFO, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword KmdVersionInfo = {TOK_FBD_ADAPTER_INFO__KMD_VERSION_INFO}; + TokenArray<128> DeviceRegistryPath = {TOK_FBC_ADAPTER_INFO__DEVICE_REGISTRY_PATH, 8, 512}; + TOKSTR_PLATFORM_STR GfxPlatform = {TOK_FS_ADAPTER_INFO__GFX_PLATFORM}; + TOKSTR__SKU_FEATURE_TABLE SkuTable = {TOK_FS_ADAPTER_INFO__SKU_TABLE}; + TOKSTR__WA_TABLE WaTable = {TOK_FS_ADAPTER_INFO__WA_TABLE}; + TokenDword GfxTimeStampFreq = {TOK_FBD_ADAPTER_INFO__GFX_TIME_STAMP_FREQ}; + TokenDword GfxCoreFrequency = {TOK_FBD_ADAPTER_INFO__GFX_CORE_FREQUENCY}; + TokenDword FSBFrequency = {TOK_FBD_ADAPTER_INFO__FSBFREQUENCY}; + TokenDword MinRenderFreq = {TOK_FBD_ADAPTER_INFO__MIN_RENDER_FREQ}; + TokenDword MaxRenderFreq = {TOK_FBD_ADAPTER_INFO__MAX_RENDER_FREQ}; + TokenDword PackageTdp = {TOK_FBD_ADAPTER_INFO__PACKAGE_TDP}; + TokenDword MaxFillRate = {TOK_FBD_ADAPTER_INFO__MAX_FILL_RATE}; + TokenDword NumberOfEUs = {TOK_FBD_ADAPTER_INFO__NUMBER_OF_EUS}; + TokenDword dwReleaseTarget = {TOK_FBD_ADAPTER_INFO__DW_RELEASE_TARGET}; + TokenDword SizeOfDmaBuffer = {TOK_FBD_ADAPTER_INFO__SIZE_OF_DMA_BUFFER}; + TokenDword PatchLocationListSize = {TOK_FBD_ADAPTER_INFO__PATCH_LOCATION_LIST_SIZE}; + TokenDword AllocationListSize = {TOK_FBD_ADAPTER_INFO__ALLOCATION_LIST_SIZE}; + TokenDword SmallPatchLocationListSize = {TOK_FBD_ADAPTER_INFO__SMALL_PATCH_LOCATION_LIST_SIZE}; + TokenDword DefaultCmdBufferSize = {TOK_FBD_ADAPTER_INFO__DEFAULT_CMD_BUFFER_SIZE}; + TokenQword GfxMemorySize = {TOK_FBQ_ADAPTER_INFO__GFX_MEMORY_SIZE}; + TokenDword SystemMemorySize = {TOK_FBD_ADAPTER_INFO__SYSTEM_MEMORY_SIZE}; + TokenDword CacheLineSize = {TOK_FBD_ADAPTER_INFO__CACHE_LINE_SIZE}; + TokenDword ProcessorFamily = {TOK_FE_ADAPTER_INFO__PROCESSOR_FAMILY}; + TokenDword IsHTSupported = {TOK_FBC_ADAPTER_INFO__IS_HTSUPPORTED}; + TokenDword IsMutiCoreCpu = {TOK_FBC_ADAPTER_INFO__IS_MUTI_CORE_CPU}; + TokenDword IsVTDSupported = {TOK_FBC_ADAPTER_INFO__IS_VTDSUPPORTED}; + TokenDword RegistryPathLength = {TOK_FBD_ADAPTER_INFO__REGISTRY_PATH_LENGTH}; + TokenQword DedicatedVideoMemory = {TOK_FBQ_ADAPTER_INFO__DEDICATED_VIDEO_MEMORY}; + TokenQword SystemSharedMemory = {TOK_FBQ_ADAPTER_INFO__SYSTEM_SHARED_MEMORY}; + TokenQword SystemVideoMemory = {TOK_FBQ_ADAPTER_INFO__SYSTEM_VIDEO_MEMORY}; + TOKSTR_FRAME_RATE OutputFrameRate = {TOK_FS_ADAPTER_INFO__OUTPUT_FRAME_RATE}; + TOKSTR_FRAME_RATE InputFrameRate = {TOK_FS_ADAPTER_INFO__INPUT_FRAME_RATE}; + TOKSTR___KMD_CAPS_INFO Caps = {TOK_FS_ADAPTER_INFO__CAPS}; + TOKSTR___KMD_OVERLAY_CAPS_INFO OverlayCaps = {TOK_FS_ADAPTER_INFO__OVERLAY_CAPS}; + TOKSTR_GT_SYSTEM_INFO SystemInfo = {TOK_FS_ADAPTER_INFO__SYSTEM_INFO}; + TOKSTR__KM_DEFERRED_WAIT_INFO DeferredWaitInfo = {TOK_FS_ADAPTER_INFO__DEFERRED_WAIT_INFO}; + TOKSTR___GMM_GFX_PARTITIONING GfxPartition = {TOK_FS_ADAPTER_INFO__GFX_PARTITION}; + TOKSTR__ADAPTER_BDF_ stAdapterBDF = {TOK_FS_ADAPTER_INFO__ST_ADAPTER_BDF}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR__ADAPTER_INFO) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR__CREATECONTEXT_PVTDATA { + TokenVariableLength base; + + TOKSTR__CREATECONTEXT_PVTDATA(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR__CREATECONTEXT_PVTDATA, NoRingFlushes) + sizeof(NoRingFlushes) - offsetof(TOKSTR__CREATECONTEXT_PVTDATA, pHwContextId), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR__CREATECONTEXT_PVTDATA() + : base(TOK_S_CREATECONTEXT_PVTDATA, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_ANONYMOUS18449 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS18449(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS18449, pHwContextId) + sizeof(pHwContextId) - offsetof(TOKSTR_ANONYMOUS18449, pHwContextId), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS18449() + : base(TOK_S_CREATECONTEXT_PVTDATA__ANONYMOUS18449, 0, sizeof(*this) - sizeof(base)) {} + + TokenPointer pHwContextId = {TOK_PBQ_CREATECONTEXT_PVTDATA__ANONYMOUS18449__P_HW_CONTEXT_ID}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS18449) % sizeof(uint32_t) == 0, ""); + + TokenPointer pHwContextId = {TOK_PBQ_CREATECONTEXT_PVTDATA__ANONYMOUS18449__P_HW_CONTEXT_ID}; // Indirect field from anonymous struct + TokenDword NumberOfHwContextIds = {TOK_FBD_CREATECONTEXT_PVTDATA__NUMBER_OF_HW_CONTEXT_IDS}; + TokenDword ProcessID = {TOK_FBD_CREATECONTEXT_PVTDATA__PROCESS_ID}; + TokenDword IsProtectedProcess = {TOK_FBC_CREATECONTEXT_PVTDATA__IS_PROTECTED_PROCESS}; + TokenDword IsDwm = {TOK_FBC_CREATECONTEXT_PVTDATA__IS_DWM}; + TokenDword IsMediaUsage = {TOK_FBC_CREATECONTEXT_PVTDATA__IS_MEDIA_USAGE}; + TokenDword GpuVAContext = {TOK_FBC_CREATECONTEXT_PVTDATA__GPU_VACONTEXT}; + TokenDword NoRingFlushes = {TOK_FBC_CREATECONTEXT_PVTDATA__NO_RING_FLUSHES}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR__CREATECONTEXT_PVTDATA) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_COMMAND_BUFFER_HEADER_REC { + TokenVariableLength base; + + TOKSTR_COMMAND_BUFFER_HEADER_REC(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_COMMAND_BUFFER_HEADER_REC, MonitorFenceValue) + sizeof(MonitorFenceValue) - offsetof(TOKSTR_COMMAND_BUFFER_HEADER_REC, UmdContextType), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_COMMAND_BUFFER_HEADER_REC() + : base(TOK_S_COMMAND_BUFFER_HEADER_REC, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_ANONYMOUS32401 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS32401(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS32401, Tag) + sizeof(Tag) - offsetof(TOKSTR_ANONYMOUS32401, Enable), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS32401() + : base(TOK_S_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_ANONYMOUS32457 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS32457(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS32457, Value) + sizeof(Value) - offsetof(TOKSTR_ANONYMOUS32457, Address), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS32457() + : base(TOK_S_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__ANONYMOUS32457, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_ANONYMOUS32501 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS32501(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS32501, GfxAddress) + sizeof(GfxAddress) - offsetof(TOKSTR_ANONYMOUS32501, Allocation), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS32501() + : base(TOK_S_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__ANONYMOUS32457__ANONYMOUS32501, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_ANONYMOUS32537 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS32537(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS32537, Offset) + sizeof(Offset) - offsetof(TOKSTR_ANONYMOUS32537, Index), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS32537() + : base(TOK_S_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__ANONYMOUS32457__ANONYMOUS32501__ANONYMOUS32537, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword Index = {TOK_FBD_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__ANONYMOUS32457__ANONYMOUS32501__ANONYMOUS32537__INDEX}; + TokenDword Offset = {TOK_FBD_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__ANONYMOUS32457__ANONYMOUS32501__ANONYMOUS32537__OFFSET}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS32537) % sizeof(uint32_t) == 0, ""); + + struct TOKSTR_ANONYMOUS32680 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS32680(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS32680, HighPart) + sizeof(HighPart) - offsetof(TOKSTR_ANONYMOUS32680, LowPart), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS32680() + : base(TOK_S_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__ANONYMOUS32457__ANONYMOUS32501__ANONYMOUS32680, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword LowPart = {TOK_FBD_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__ANONYMOUS32457__ANONYMOUS32501__ANONYMOUS32680__LOW_PART}; + TokenDword HighPart = {TOK_FBD_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__ANONYMOUS32457__ANONYMOUS32501__ANONYMOUS32680__HIGH_PART}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS32680) % sizeof(uint32_t) == 0, ""); + + TOKSTR_ANONYMOUS32537 Allocation = {TOK_FS_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__ANONYMOUS32457__ANONYMOUS32501__ALLOCATION}; + TOKSTR_ANONYMOUS32680 GfxAddress = {TOK_FS_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__ANONYMOUS32457__ANONYMOUS32501__GFX_ADDRESS}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS32501) % sizeof(uint32_t) == 0, ""); + + TOKSTR_ANONYMOUS32501 Address = {TOK_FS_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__ANONYMOUS32457__ADDRESS}; + TokenDword Value = {TOK_FBD_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__ANONYMOUS32457__VALUE}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS32457) % sizeof(uint32_t) == 0, ""); + + TokenDword Enable = {TOK_FBD_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__ENABLE}; + TOKSTR_ANONYMOUS32457 Tag = {TOK_FS_COMMAND_BUFFER_HEADER_REC__ANONYMOUS32401__TAG}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS32401) % sizeof(uint32_t) == 0, ""); + + TokenDword UmdContextType = {TOK_FBD_COMMAND_BUFFER_HEADER_REC__UMD_CONTEXT_TYPE}; + TokenDword UmdPatchList = {TOK_FBD_COMMAND_BUFFER_HEADER_REC__UMD_PATCH_LIST}; + TokenDword UmdRequestedSliceState = {TOK_FBD_COMMAND_BUFFER_HEADER_REC__UMD_REQUESTED_SLICE_STATE}; + TokenDword UmdRequestedSubsliceCount = {TOK_FBD_COMMAND_BUFFER_HEADER_REC__UMD_REQUESTED_SUBSLICE_COUNT}; + TokenDword UmdRequestedEUCount = {TOK_FBD_COMMAND_BUFFER_HEADER_REC__UMD_REQUESTED_EUCOUNT}; + TokenDword UsesResourceStreamer = {TOK_FBD_COMMAND_BUFFER_HEADER_REC__USES_RESOURCE_STREAMER}; + TokenDword NeedsMidBatchPreEmptionSupport = {TOK_FBD_COMMAND_BUFFER_HEADER_REC__NEEDS_MID_BATCH_PRE_EMPTION_SUPPORT}; + TokenDword UsesGPGPUPipeline = {TOK_FBD_COMMAND_BUFFER_HEADER_REC__USES_GPGPUPIPELINE}; + TokenDword RequiresCoherency = {TOK_FBD_COMMAND_BUFFER_HEADER_REC__REQUIRES_COHERENCY}; + TokenDword PerfTag = {TOK_FBD_COMMAND_BUFFER_HEADER_REC__PERF_TAG}; + TokenQword MonitorFenceVA = {TOK_FBQ_COMMAND_BUFFER_HEADER_REC__MONITOR_FENCE_VA}; + TokenQword MonitorFenceValue = {TOK_FBQ_COMMAND_BUFFER_HEADER_REC__MONITOR_FENCE_VALUE}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_COMMAND_BUFFER_HEADER_REC) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_GMM_RESOURCE_FLAG_REC { + TokenVariableLength base; + + TOKSTR_GMM_RESOURCE_FLAG_REC(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GMM_RESOURCE_FLAG_REC, Wa) + sizeof(Wa) - offsetof(TOKSTR_GMM_RESOURCE_FLAG_REC, Gpu), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_GMM_RESOURCE_FLAG_REC() + : base(TOK_S_GMM_RESOURCE_FLAG_REC, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_ANONYMOUS1739 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS1739(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS1739, __Remaining) + sizeof(__Remaining) - offsetof(TOKSTR_ANONYMOUS1739, CameraCapture), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS1739() + : base(TOK_S_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword CameraCapture = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CAMERA_CAPTURE}; + TokenDword CCS = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CCS}; + TokenDword ColorDiscard = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_DISCARD}; + TokenDword ColorSeparation = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION}; + TokenDword ColorSeparationRGBX = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION_RGBX}; + TokenDword Constant = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CONSTANT}; + TokenDword Depth = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__DEPTH}; + TokenDword FlipChain = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN}; + TokenDword FlipChainPreferred = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN_PREFERRED}; + TokenDword HistoryBuffer = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HISTORY_BUFFER}; + TokenDword HiZ = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HI_Z}; + TokenDword Index = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDEX}; + TokenDword IndirectClearColor = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDIRECT_CLEAR_COLOR}; + TokenDword InstructionFlat = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INSTRUCTION_FLAT}; + TokenDword InterlacedScan = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INTERLACED_SCAN}; + TokenDword MCS = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MCS}; + TokenDword MMC = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MMC}; + TokenDword MotionComp = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MOTION_COMP}; + TokenDword NoRestriction = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__NO_RESTRICTION}; + TokenDword Overlay = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__OVERLAY}; + TokenDword Presentable = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PRESENTABLE}; + TokenDword ProceduralTexture = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PROCEDURAL_TEXTURE}; + TokenDword Query = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__QUERY}; + TokenDword RenderTarget = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__RENDER_TARGET}; + TokenDword S3d = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D}; + TokenDword S3dDx = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D_DX}; + TokenDword __S3dNonPacked = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_NON_PACKED}; + TokenDword __S3dWidi = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_WIDI}; + TokenDword ScratchFlat = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SCRATCH_FLAT}; + TokenDword SeparateStencil = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SEPARATE_STENCIL}; + TokenDword State = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE}; + TokenDword StateDx9ConstantBuffer = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE_DX9CONSTANT_BUFFER}; + TokenDword Stream = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STREAM}; + TokenDword TextApi = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXT_API}; + TokenDword Texture = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXTURE}; + TokenDword TiledResource = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILED_RESOURCE}; + TokenDword TilePool = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILE_POOL}; + TokenDword UnifiedAuxSurface = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__UNIFIED_AUX_SURFACE}; + TokenDword Vertex = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VERTEX}; + TokenDword Video = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VIDEO}; + TokenDword __NonMsaaTileXCcs = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_XCCS}; + TokenDword __NonMsaaTileYCcs = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_YCCS}; + TokenDword __MsaaTileMcs = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____MSAA_TILE_MCS}; + TokenDword __NonMsaaLinearCCS = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_LINEAR_CCS}; + TokenDword __Remaining = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____REMAINING}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS1739) % sizeof(uint32_t) == 0, ""); + + struct TOKSTR_ANONYMOUS6797 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS6797(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS6797, __PreWddm2SVM) + sizeof(__PreWddm2SVM) - offsetof(TOKSTR_ANONYMOUS6797, AllowVirtualPadding), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS6797() + : base(TOK_S_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword AllowVirtualPadding = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ALLOW_VIRTUAL_PADDING}; + TokenDword BigPage = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__BIG_PAGE}; + TokenDword Cacheable = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CACHEABLE}; + TokenDword ContigPhysMemoryForiDART = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CONTIG_PHYS_MEMORY_FORI_DART}; + TokenDword CornerTexelMode = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CORNER_TEXEL_MODE}; + TokenDword ExistingSysMem = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__EXISTING_SYS_MEM}; + TokenDword ForceResidency = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__FORCE_RESIDENCY}; + TokenDword Gfdt = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GFDT}; + TokenDword GttMapType = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GTT_MAP_TYPE}; + TokenDword HardwareProtected = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__HARDWARE_PROTECTED}; + TokenDword KernelModeMapped = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__KERNEL_MODE_MAPPED}; + TokenDword LayoutBelow = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_BELOW}; + TokenDword LayoutMono = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_MONO}; + TokenDword LayoutRight = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_RIGHT}; + TokenDword LocalOnly = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LOCAL_ONLY}; + TokenDword Linear = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LINEAR}; + TokenDword MediaCompressed = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__MEDIA_COMPRESSED}; + TokenDword NoOptimizationPadding = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_OPTIMIZATION_PADDING}; + TokenDword NoPhysMemory = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_PHYS_MEMORY}; + TokenDword NotLockable = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NOT_LOCKABLE}; + TokenDword NonLocalOnly = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NON_LOCAL_ONLY}; + TokenDword StdSwizzle = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__STD_SWIZZLE}; + TokenDword PseudoStdSwizzle = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__PSEUDO_STD_SWIZZLE}; + TokenDword Undefined64KBSwizzle = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__UNDEFINED64KBSWIZZLE}; + TokenDword RedecribedPlanes = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__REDECRIBED_PLANES}; + TokenDword RenderCompressed = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__RENDER_COMPRESSED}; + TokenDword Rotated = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ROTATED}; + TokenDword Shared = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SHARED}; + TokenDword SoftwareProtected = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SOFTWARE_PROTECTED}; + TokenDword SVM = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SVM}; + TokenDword Tile4 = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE4}; + TokenDword Tile64 = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE64}; + TokenDword TiledW = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_W}; + TokenDword TiledX = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_X}; + TokenDword TiledY = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_Y}; + TokenDword TiledYf = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YF}; + TokenDword TiledYs = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YS}; + TokenDword WddmProtected = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__WDDM_PROTECTED}; + TokenDword XAdapter = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__XADAPTER}; + TokenDword __PreallocatedResInfo = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PREALLOCATED_RES_INFO}; + TokenDword __PreWddm2SVM = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PRE_WDDM2SVM}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS6797) % sizeof(uint32_t) == 0, ""); + + struct TOKSTR_ANONYMOUS12521 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS12521(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS12521, PreGen12FastClearOnly) + sizeof(PreGen12FastClearOnly) - offsetof(TOKSTR_ANONYMOUS12521, GTMfx2ndLevelBatchRingSizeAlign), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS12521() + : base(TOK_S_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword GTMfx2ndLevelBatchRingSizeAlign = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__GTMFX2ND_LEVEL_BATCH_RING_SIZE_ALIGN}; + TokenDword ILKNeedAvcMprRowStore32KAlign = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_MPR_ROW_STORE32KALIGN}; + TokenDword ILKNeedAvcDmvBuffer32KAlign = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_DMV_BUFFER32KALIGN}; + TokenDword NoBufferSamplerPadding = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_BUFFER_SAMPLER_PADDING}; + TokenDword NoLegacyPlanarLinearVideoRestrictions = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_LEGACY_PLANAR_LINEAR_VIDEO_RESTRICTIONS}; + TokenDword CHVAstcSkipVirtualMips = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__CHVASTC_SKIP_VIRTUAL_MIPS}; + TokenDword DisablePackedMipTail = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_PACKED_MIP_TAIL}; + TokenDword __ForceOtherHVALIGN4 = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521____FORCE_OTHER_HVALIGN4}; + TokenDword DisableDisplayCcsClearColor = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR}; + TokenDword DisableDisplayCcsCompression = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION}; + TokenDword PreGen12FastClearOnly = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS12521) % sizeof(uint32_t) == 0, ""); + + TOKSTR_ANONYMOUS1739 Gpu = {TOK_FS_GMM_RESOURCE_FLAG_REC__GPU}; + TOKSTR_ANONYMOUS6797 Info = {TOK_FS_GMM_RESOURCE_FLAG_REC__INFO}; + TOKSTR_ANONYMOUS12521 Wa = {TOK_FS_GMM_RESOURCE_FLAG_REC__WA}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_GMM_RESOURCE_FLAG_REC) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_GMM_RESOURCE_MSAA_INFO_REC { + TokenVariableLength base; + + TOKSTR_GMM_RESOURCE_MSAA_INFO_REC(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GMM_RESOURCE_MSAA_INFO_REC, NumSamples) + sizeof(NumSamples) - offsetof(TOKSTR_GMM_RESOURCE_MSAA_INFO_REC, SamplePattern), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_GMM_RESOURCE_MSAA_INFO_REC() + : base(TOK_S_GMM_RESOURCE_MSAA_INFO_REC, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword SamplePattern = {TOK_FE_GMM_RESOURCE_MSAA_INFO_REC__SAMPLE_PATTERN}; + TokenDword NumSamples = {TOK_FBD_GMM_RESOURCE_MSAA_INFO_REC__NUM_SAMPLES}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_GMM_RESOURCE_MSAA_INFO_REC) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_GMM_RESOURCE_ALIGNMENT_REC { + TokenVariableLength base; + + TOKSTR_GMM_RESOURCE_ALIGNMENT_REC(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GMM_RESOURCE_ALIGNMENT_REC, QPitch) + sizeof(QPitch) - offsetof(TOKSTR_GMM_RESOURCE_ALIGNMENT_REC, ArraySpacingSingleLod), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_GMM_RESOURCE_ALIGNMENT_REC() + : base(TOK_S_GMM_RESOURCE_ALIGNMENT_REC, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword ArraySpacingSingleLod = {TOK_FBC_GMM_RESOURCE_ALIGNMENT_REC__ARRAY_SPACING_SINGLE_LOD}; + TokenDword BaseAlignment = {TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__BASE_ALIGNMENT}; + TokenDword HAlign = {TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__HALIGN}; + TokenDword VAlign = {TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__VALIGN}; + TokenDword DAlign = {TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__DALIGN}; + TokenDword MipTailStartLod = {TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__MIP_TAIL_START_LOD}; + TokenDword PackedMipStartLod = {TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_START_LOD}; + TokenDword PackedMipWidth = {TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_WIDTH}; + TokenDword PackedMipHeight = {TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_HEIGHT}; + TokenDword QPitch = {TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__QPITCH}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_GMM_RESOURCE_ALIGNMENT_REC) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_GMM_S3D_INFO_REC { + TokenVariableLength base; + + TOKSTR_GMM_S3D_INFO_REC(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GMM_S3D_INFO_REC, IsRFrame) + sizeof(IsRFrame) - offsetof(TOKSTR_GMM_S3D_INFO_REC, DisplayModeHeight), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_GMM_S3D_INFO_REC() + : base(TOK_S_GMM_S3D_INFO_REC, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword DisplayModeHeight = {TOK_FBD_GMM_S3D_INFO_REC__DISPLAY_MODE_HEIGHT}; + TokenDword NumBlankActiveLines = {TOK_FBD_GMM_S3D_INFO_REC__NUM_BLANK_ACTIVE_LINES}; + TokenDword RFrameOffset = {TOK_FBD_GMM_S3D_INFO_REC__RFRAME_OFFSET}; + TokenDword BlankAreaOffset = {TOK_FBD_GMM_S3D_INFO_REC__BLANK_AREA_OFFSET}; + TokenDword TallBufferHeight = {TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_HEIGHT}; + TokenDword TallBufferSize = {TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_SIZE}; + TokenDword IsRFrame = {TOK_FBC_GMM_S3D_INFO_REC__IS_RFRAME}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_GMM_S3D_INFO_REC) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_GMM_MULTI_TILE_ARCH_REC { + TokenVariableLength base; + + TOKSTR_GMM_MULTI_TILE_ARCH_REC(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GMM_MULTI_TILE_ARCH_REC, LocalMemPreferredSet) + sizeof(LocalMemPreferredSet) - offsetof(TOKSTR_GMM_MULTI_TILE_ARCH_REC, Enable), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_GMM_MULTI_TILE_ARCH_REC() + : base(TOK_S_GMM_MULTI_TILE_ARCH_REC, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword Enable = {TOK_FBC_GMM_MULTI_TILE_ARCH_REC__ENABLE}; + TokenDword TileInstanced = {TOK_FBC_GMM_MULTI_TILE_ARCH_REC__TILE_INSTANCED}; + TokenDword GpuVaMappingSet = {TOK_FBC_GMM_MULTI_TILE_ARCH_REC__GPU_VA_MAPPING_SET}; + TokenDword LocalMemEligibilitySet = {TOK_FBC_GMM_MULTI_TILE_ARCH_REC__LOCAL_MEM_ELIGIBILITY_SET}; + TokenDword LocalMemPreferredSet = {TOK_FBC_GMM_MULTI_TILE_ARCH_REC__LOCAL_MEM_PREFERRED_SET}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_GMM_MULTI_TILE_ARCH_REC) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_GMM_PLANAR_OFFSET_INFO_REC { + TokenVariableLength base; + + TOKSTR_GMM_PLANAR_OFFSET_INFO_REC(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GMM_PLANAR_OFFSET_INFO_REC, IsTileAlignedPlanes) + sizeof(IsTileAlignedPlanes) - offsetof(TOKSTR_GMM_PLANAR_OFFSET_INFO_REC, ArrayQPitch), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_GMM_PLANAR_OFFSET_INFO_REC() + : base(TOK_S_GMM_PLANAR_OFFSET_INFO_REC, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_ANONYMOUS1851 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS1851(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS1851, Height) + sizeof(Height) - offsetof(TOKSTR_ANONYMOUS1851, Height), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS1851() + : base(TOK_S_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851, 0, sizeof(*this) - sizeof(base)) {} + + TokenArray<8> Height = {TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT, 64, 4}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS1851) % sizeof(uint32_t) == 0, ""); + + TokenQword ArrayQPitch = {TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH}; + TokenArray<8> X = {TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X, 64, 4}; + TokenArray<8> Y = {TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y, 64, 4}; + TOKSTR_ANONYMOUS1851 UnAligned = {TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED}; + TokenDword NoOfPlanes = {TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES}; + TokenBool IsTileAlignedPlanes = {TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_GMM_PLANAR_OFFSET_INFO_REC) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_GMM_2D_TEXTURE_OFFSET_INFO_REC { + TokenVariableLength base; + + TOKSTR_GMM_2D_TEXTURE_OFFSET_INFO_REC(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GMM_2D_TEXTURE_OFFSET_INFO_REC, Offset) + sizeof(Offset) - offsetof(TOKSTR_GMM_2D_TEXTURE_OFFSET_INFO_REC, ArrayQPitchLock), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_GMM_2D_TEXTURE_OFFSET_INFO_REC() + : base(TOK_S_GMM_2D_TEXTURE_OFFSET_INFO_REC, 0, sizeof(*this) - sizeof(base)) {} + + TokenQword ArrayQPitchLock = {TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK}; + TokenQword ArrayQPitchRender = {TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER}; + TokenArray<30> Offset = {TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET, 64, 15}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_GMM_2D_TEXTURE_OFFSET_INFO_REC) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_GMM_3D_TEXTURE_OFFSET_INFO_REC { + TokenVariableLength base; + + TOKSTR_GMM_3D_TEXTURE_OFFSET_INFO_REC(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GMM_3D_TEXTURE_OFFSET_INFO_REC, Offset) + sizeof(Offset) - offsetof(TOKSTR_GMM_3D_TEXTURE_OFFSET_INFO_REC, Mip0SlicePitch), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_GMM_3D_TEXTURE_OFFSET_INFO_REC() + : base(TOK_S_GMM_3D_TEXTURE_OFFSET_INFO_REC, 0, sizeof(*this) - sizeof(base)) {} + + TokenQword Mip0SlicePitch = {TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH}; + TokenArray<30> Offset = {TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET, 64, 15}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_GMM_3D_TEXTURE_OFFSET_INFO_REC) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_GMM_OFFSET_INFO_REC { + TokenVariableLength base; + + TOKSTR_GMM_OFFSET_INFO_REC(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GMM_OFFSET_INFO_REC, Plane) + sizeof(Plane) - offsetof(TOKSTR_GMM_OFFSET_INFO_REC, Texture3DOffsetInfo), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_GMM_OFFSET_INFO_REC() + : base(TOK_S_GMM_OFFSET_INFO_REC, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_ANONYMOUS3429 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS3429(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS3429, Plane) + sizeof(Plane) - offsetof(TOKSTR_ANONYMOUS3429, Texture3DOffsetInfo), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS3429() + : base(TOK_S_GMM_OFFSET_INFO_REC__ANONYMOUS3429, 0, sizeof(*this) - sizeof(base)) {} + + TOKSTR_GMM_3D_TEXTURE_OFFSET_INFO_REC Texture3DOffsetInfo = {TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO}; + TOKSTR_GMM_2D_TEXTURE_OFFSET_INFO_REC Texture2DOffsetInfo = {TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO}; + TOKSTR_GMM_PLANAR_OFFSET_INFO_REC Plane = {TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS3429) % sizeof(uint32_t) == 0, ""); + + TOKSTR_GMM_3D_TEXTURE_OFFSET_INFO_REC Texture3DOffsetInfo = {TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO}; // Indirect field from anonymous struct + TOKSTR_GMM_2D_TEXTURE_OFFSET_INFO_REC Texture2DOffsetInfo = {TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO}; // Indirect field from anonymous struct + TOKSTR_GMM_PLANAR_OFFSET_INFO_REC Plane = {TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE}; // Indirect field from anonymous struct +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_GMM_OFFSET_INFO_REC) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_GMM_TEXTURE_INFO_REC { + TokenVariableLength base; + + TOKSTR_GMM_TEXTURE_INFO_REC(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GMM_TEXTURE_INFO_REC, __Platform) + sizeof(__Platform) - offsetof(TOKSTR_GMM_TEXTURE_INFO_REC, Type), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_GMM_TEXTURE_INFO_REC() + : base(TOK_S_GMM_TEXTURE_INFO_REC, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_ANONYMOUS4927 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS4927(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS4927, Usage) + sizeof(Usage) - offsetof(TOKSTR_ANONYMOUS4927, Usage), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS4927() + : base(TOK_S_GMM_TEXTURE_INFO_REC__ANONYMOUS4927, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword Usage = {TOK_FE_GMM_TEXTURE_INFO_REC__ANONYMOUS4927__USAGE}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS4927) % sizeof(uint32_t) == 0, ""); + + struct TOKSTR_ANONYMOUS6185 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS6185(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS6185, Evict) + sizeof(Evict) - offsetof(TOKSTR_ANONYMOUS6185, Seg1), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS6185() + : base(TOK_S_GMM_TEXTURE_INFO_REC__ANONYMOUS6185, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword Seg1 = {TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__SEG1}; + TokenDword Evict = {TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__EVICT}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS6185) % sizeof(uint32_t) == 0, ""); + + struct TOKSTR_ANONYMOUS6590 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS6590(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS6590, IsPageAligned) + sizeof(IsPageAligned) - offsetof(TOKSTR_ANONYMOUS6590, IsGmmAllocated), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS6590() + : base(TOK_S_GMM_TEXTURE_INFO_REC__ANONYMOUS6590, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword IsGmmAllocated = {TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_GMM_ALLOCATED}; + TokenDword IsPageAligned = {TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_PAGE_ALIGNED}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS6590) % sizeof(uint32_t) == 0, ""); + + TokenDword Type = {TOK_FE_GMM_TEXTURE_INFO_REC__TYPE}; + TokenDword Format = {TOK_FE_GMM_TEXTURE_INFO_REC__FORMAT}; + TokenDword BitsPerPixel = {TOK_FBD_GMM_TEXTURE_INFO_REC__BITS_PER_PIXEL}; + TOKSTR_GMM_RESOURCE_FLAG_REC Flags = {TOK_FS_GMM_TEXTURE_INFO_REC__FLAGS}; + TokenQword BaseWidth = {TOK_FBQ_GMM_TEXTURE_INFO_REC__BASE_WIDTH}; + TokenDword BaseHeight = {TOK_FBD_GMM_TEXTURE_INFO_REC__BASE_HEIGHT}; + TokenDword Depth = {TOK_FBD_GMM_TEXTURE_INFO_REC__DEPTH}; + TokenDword MaxLod = {TOK_FBD_GMM_TEXTURE_INFO_REC__MAX_LOD}; + TokenDword ArraySize = {TOK_FBD_GMM_TEXTURE_INFO_REC__ARRAY_SIZE}; + TokenDword CpTag = {TOK_FBD_GMM_TEXTURE_INFO_REC__CP_TAG}; + TOKSTR_ANONYMOUS4927 CachePolicy = {TOK_FS_GMM_TEXTURE_INFO_REC__CACHE_POLICY}; + TOKSTR_GMM_RESOURCE_MSAA_INFO_REC MSAA = {TOK_FS_GMM_TEXTURE_INFO_REC__MSAA}; + TOKSTR_GMM_RESOURCE_ALIGNMENT_REC Alignment = {TOK_FS_GMM_TEXTURE_INFO_REC__ALIGNMENT}; + TokenArray<16> MmcMode = {TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_MODE, 8, 64}; + TokenArray<16> MmcHint = {TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_HINT, 8, 64}; + TokenQword Pitch = {TOK_FBQ_GMM_TEXTURE_INFO_REC__PITCH}; + TokenQword OverridePitch = {TOK_FBQ_GMM_TEXTURE_INFO_REC__OVERRIDE_PITCH}; + TokenQword Size = {TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE}; + TokenQword CCSize = {TOK_FBQ_GMM_TEXTURE_INFO_REC__CCSIZE}; + TokenQword UnpaddedSize = {TOK_FBQ_GMM_TEXTURE_INFO_REC__UNPADDED_SIZE}; + TokenQword SizeReportToOS = {TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE_REPORT_TO_OS}; + TOKSTR_GMM_OFFSET_INFO_REC OffsetInfo = {TOK_FS_GMM_TEXTURE_INFO_REC__OFFSET_INFO}; + TokenDword TileMode = {TOK_FE_GMM_TEXTURE_INFO_REC__TILE_MODE}; + TokenDword CCSModeAlign = {TOK_FBD_GMM_TEXTURE_INFO_REC__CCSMODE_ALIGN}; + TokenDword LegacyFlags = {TOK_FBD_GMM_TEXTURE_INFO_REC__LEGACY_FLAGS}; + TOKSTR_GMM_S3D_INFO_REC S3d = {TOK_FS_GMM_TEXTURE_INFO_REC__S3D}; + TOKSTR_ANONYMOUS6185 SegmentOverride = {TOK_FS_GMM_TEXTURE_INFO_REC__SEGMENT_OVERRIDE}; + TokenDword MaximumRenamingListLength = {TOK_FBD_GMM_TEXTURE_INFO_REC__MAXIMUM_RENAMING_LIST_LENGTH}; + TOKSTR_PLATFORM_STR Platform = {TOK_FS_GMM_TEXTURE_INFO_REC__PLATFORM}; // _DEBUG || _RELEASE_INTERNAL + TOKSTR_ANONYMOUS6590 ExistingSysMem = {TOK_FS_GMM_TEXTURE_INFO_REC__EXISTING_SYS_MEM}; + TOKSTR_PLATFORM_STR __Platform = {TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM}; // !(_DEBUG || _RELEASE_INTERNAL) +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_GMM_TEXTURE_INFO_REC) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_GMM_EXISTING_SYS_MEM_REC { + TokenVariableLength base; + + TOKSTR_GMM_EXISTING_SYS_MEM_REC(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GMM_EXISTING_SYS_MEM_REC, IsGmmAllocated) + sizeof(IsGmmAllocated) - offsetof(TOKSTR_GMM_EXISTING_SYS_MEM_REC, pExistingSysMem), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_GMM_EXISTING_SYS_MEM_REC() + : base(TOK_S_GMM_EXISTING_SYS_MEM_REC, 0, sizeof(*this) - sizeof(base)) {} + + TokenQword pExistingSysMem = {TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_EXISTING_SYS_MEM}; + TokenQword pVirtAddress = {TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_VIRT_ADDRESS}; + TokenQword pGfxAlignedVirtAddress = {TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_GFX_ALIGNED_VIRT_ADDRESS}; + TokenQword Size = {TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__SIZE}; + TokenDword IsGmmAllocated = {TOK_FBC_GMM_EXISTING_SYS_MEM_REC__IS_GMM_ALLOCATED}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_GMM_EXISTING_SYS_MEM_REC) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_GmmResourceInfoCommonStruct { + TokenVariableLength base; + + TOKSTR_GmmResourceInfoCommonStruct(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GmmResourceInfoCommonStruct, MultiTileArch) + sizeof(MultiTileArch) - offsetof(TOKSTR_GmmResourceInfoCommonStruct, ClientType), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_GmmResourceInfoCommonStruct() + : base(TOK_S_GMM_RESOURCE_INFO_COMMON_STRUCT, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword ClientType = {TOK_FE_GMM_RESOURCE_INFO_COMMON_STRUCT__CLIENT_TYPE}; + TOKSTR_GMM_TEXTURE_INFO_REC Surf = {TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__SURF}; + TOKSTR_GMM_TEXTURE_INFO_REC AuxSurf = {TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__AUX_SURF}; + TOKSTR_GMM_TEXTURE_INFO_REC AuxSecSurf = {TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__AUX_SEC_SURF}; + TokenDword RotateInfo = {TOK_FBD_GMM_RESOURCE_INFO_COMMON_STRUCT__ROTATE_INFO}; + TOKSTR_GMM_EXISTING_SYS_MEM_REC ExistingSysMem = {TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__EXISTING_SYS_MEM}; + TokenQword SvmAddress = {TOK_FBQ_GMM_RESOURCE_INFO_COMMON_STRUCT__SVM_ADDRESS}; + TokenQword pPrivateData = {TOK_FBQ_GMM_RESOURCE_INFO_COMMON_STRUCT__P_PRIVATE_DATA}; + TOKSTR_GMM_MULTI_TILE_ARCH_REC MultiTileArch = {TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__MULTI_TILE_ARCH}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_GmmResourceInfoCommonStruct) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_GmmResourceInfoWinStructPadding00 { + TokenVariableLength base; + + TOKSTR_GmmResourceInfoWinStructPadding00(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GmmResourceInfoWinStructPadding00, padding000) + sizeof(padding000) - offsetof(TOKSTR_GmmResourceInfoWinStructPadding00, padding000), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TokenQword padding000 = {3933}; +}; + +struct TOKSTR_GmmResourceInfoWinStructPadding0 { + TokenVariableLength base; + + TOKSTR_GmmResourceInfoWinStructPadding0(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GmmResourceInfoWinStructPadding0, padding00) + sizeof(padding00) - offsetof(TOKSTR_GmmResourceInfoWinStructPadding0, padding00), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_GmmResourceInfoWinStructPadding00 padding00 = {3943}; +}; + +struct TOKSTR_GmmResourceInfoWinStruct { + TokenVariableLength base; + + TOKSTR_GmmResourceInfoWinStruct(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GmmResourceInfoWinStruct, padding0) + sizeof(padding0) - offsetof(TOKSTR_GmmResourceInfoWinStruct, GmmResourceInfoCommon), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_GmmResourceInfoWinStruct() + : base(TOK_S_GMM_RESOURCE_INFO_WIN_STRUCT, 0, sizeof(*this) - sizeof(base)) {} + + TOKSTR_GmmResourceInfoCommonStruct GmmResourceInfoCommon = {TOK_FS_GMM_RESOURCE_INFO_WIN_STRUCT__GMM_RESOURCE_INFO_COMMON}; + TOKSTR_GmmResourceInfoWinStructPadding0 padding0 = {3967}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_GmmResourceInfoWinStruct) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_GFX_ESCAPE_HEADER { + TokenVariableLength base; + + TOKSTR_GFX_ESCAPE_HEADER(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GFX_ESCAPE_HEADER, uiMinorEscapeCode) + sizeof(uiMinorEscapeCode) - offsetof(TOKSTR_GFX_ESCAPE_HEADER, Size), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_GFX_ESCAPE_HEADER() + : base(TOK_S_GFX_ESCAPE_HEADER, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_ANONYMOUS4410 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS4410(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS4410, uiMinorEscapeCode) + sizeof(uiMinorEscapeCode) - offsetof(TOKSTR_ANONYMOUS4410, Size), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS4410() + : base(TOK_S_GFX_ESCAPE_HEADER__ANONYMOUS4410, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_ANONYMOUS4430 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS4430(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS4430, ulReserved) + sizeof(ulReserved) - offsetof(TOKSTR_ANONYMOUS4430, Size), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS4430() + : base(TOK_S_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword Size = {TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__SIZE}; + TokenDword CheckSum = {TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__CHECK_SUM}; + TokenDword EscapeCode = {TOK_FE_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__ESCAPE_CODE}; + TokenDword ulReserved = {TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__UL_RESERVED}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS4430) % sizeof(uint32_t) == 0, ""); + + struct TOKSTR_ANONYMOUS4963 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS4963(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS4963, uiMinorEscapeCode) + sizeof(uiMinorEscapeCode) - offsetof(TOKSTR_ANONYMOUS4963, ulReserved1), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS4963() + : base(TOK_S_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword ulReserved1 = {TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UL_RESERVED1}; + TokenDword usEscapeVersion = {TOK_FBW_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__US_ESCAPE_VERSION}; + TokenDword usFileVersion = {TOK_FBW_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__US_FILE_VERSION}; + TokenDword ulMajorEscapeCode = {TOK_FE_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UL_MAJOR_ESCAPE_CODE}; + TokenDword uiMinorEscapeCode = {TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UI_MINOR_ESCAPE_CODE}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS4963) % sizeof(uint32_t) == 0, ""); + + TokenDword Size = {TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__SIZE}; // Indirect field from anonymous struct + TokenDword CheckSum = {TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__CHECK_SUM}; // Indirect field from anonymous struct + TokenDword EscapeCode = {TOK_FE_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__ESCAPE_CODE}; // Indirect field from anonymous struct + TokenDword ulReserved = {TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__UL_RESERVED}; // Indirect field from anonymous struct + TokenDword ulReserved1 = {TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UL_RESERVED1}; // Indirect field from anonymous struct + TokenDword usEscapeVersion = {TOK_FBW_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__US_ESCAPE_VERSION}; // Indirect field from anonymous struct + TokenDword usFileVersion = {TOK_FBW_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__US_FILE_VERSION}; // Indirect field from anonymous struct + TokenDword ulMajorEscapeCode = {TOK_FE_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UL_MAJOR_ESCAPE_CODE}; // Indirect field from anonymous struct + TokenDword uiMinorEscapeCode = {TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UI_MINOR_ESCAPE_CODE}; // Indirect field from anonymous struct + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS4410) % sizeof(uint32_t) == 0, ""); + + TokenDword Size = {TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__SIZE}; // Indirect field from anonymous struct + TokenDword CheckSum = {TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__CHECK_SUM}; // Indirect field from anonymous struct + TokenDword EscapeCode = {TOK_FE_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__ESCAPE_CODE}; // Indirect field from anonymous struct + TokenDword ulReserved = {TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__UL_RESERVED}; // Indirect field from anonymous struct + TokenDword ulReserved1 = {TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UL_RESERVED1}; // Indirect field from anonymous struct + TokenDword usEscapeVersion = {TOK_FBW_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__US_ESCAPE_VERSION}; // Indirect field from anonymous struct + TokenDword usFileVersion = {TOK_FBW_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__US_FILE_VERSION}; // Indirect field from anonymous struct + TokenDword ulMajorEscapeCode = {TOK_FE_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UL_MAJOR_ESCAPE_CODE}; // Indirect field from anonymous struct + TokenDword uiMinorEscapeCode = {TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UI_MINOR_ESCAPE_CODE}; // Indirect field from anonymous struct +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_GFX_ESCAPE_HEADER) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_GTDIBaseInStruct { + TokenVariableLength base; + + TOKSTR_GTDIBaseInStruct(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GTDIBaseInStruct, Function) + sizeof(Function) - offsetof(TOKSTR_GTDIBaseInStruct, Function), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_GTDIBaseInStruct() + : base(TOK_S_GTDIBASE_IN_STRUCT, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword Function = {TOK_FE_GTDIBASE_IN_STRUCT__FUNCTION}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_GTDIBaseInStruct) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_GTDIGetGpuCpuTimestampsOutStruct { + TokenVariableLength base; + + TOKSTR_GTDIGetGpuCpuTimestampsOutStruct(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_GTDIGetGpuCpuTimestampsOutStruct, cpuPerfFreq) + sizeof(cpuPerfFreq) - offsetof(TOKSTR_GTDIGetGpuCpuTimestampsOutStruct, RetCode), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_GTDIGetGpuCpuTimestampsOutStruct() + : base(TOK_S_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT, 0, sizeof(*this) - sizeof(base)) {} + + TokenDword RetCode = {TOK_FE_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__RET_CODE}; + TokenQword gpuPerfTicks = {TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__GPU_PERF_TICKS}; + TokenQword cpuPerfTicks = {TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__CPU_PERF_TICKS}; + TokenQword gpuPerfFreq = {TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__GPU_PERF_FREQ}; + TokenQword cpuPerfFreq = {TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__CPU_PERF_FREQ}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_GTDIGetGpuCpuTimestampsOutStruct) % sizeof(uint32_t) == 0, ""); + +struct TOKSTR_TimeStampDataHeader { + TokenVariableLength base; + + TOKSTR_TimeStampDataHeader(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_TimeStampDataHeader, m_Data) + sizeof(m_Data) - offsetof(TOKSTR_TimeStampDataHeader, m_Header), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_TimeStampDataHeader() + : base(TOK_S_TIME_STAMP_DATA_HEADER, 0, sizeof(*this) - sizeof(base)) {} + + struct TOKSTR_ANONYMOUS2466 { + TokenVariableLength base; + + TOKSTR_ANONYMOUS2466(uint16_t tokenId, uint32_t elementId = 0) + : base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS2466, m_Out) + sizeof(m_Out) - offsetof(TOKSTR_ANONYMOUS2466, m_In), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {} + + TOKSTR_ANONYMOUS2466() + : base(TOK_S_TIME_STAMP_DATA_HEADER__ANONYMOUS2466, 0, sizeof(*this) - sizeof(base)) {} + + TOKSTR_GTDIBaseInStruct m_In = {TOK_FXS_TIME_STAMP_DATA_HEADER__ANONYMOUS2466__M_IN}; + TOKSTR_GTDIGetGpuCpuTimestampsOutStruct m_Out = {TOK_FS_TIME_STAMP_DATA_HEADER__ANONYMOUS2466__M_OUT}; + }; + static_assert(std::is_standard_layout_v, ""); + static_assert(sizeof(TOKSTR_ANONYMOUS2466) % sizeof(uint32_t) == 0, ""); + + TOKSTR_GFX_ESCAPE_HEADER m_Header = {TOK_FS_TIME_STAMP_DATA_HEADER__M_HEADER}; + TOKSTR_ANONYMOUS2466 m_Data = {TOK_FS_TIME_STAMP_DATA_HEADER__M_DATA}; +}; +static_assert(std::is_standard_layout_v, ""); +static_assert(sizeof(TOKSTR_TimeStampDataHeader) % sizeof(uint32_t) == 0, "");