1/* 2 * Copyright (C) 2019-2021 Intel Corporation 3 * 4 * SPDX-License-Identifier: MIT 5 * 6 */ 7 8#pragma pack(1) 9typedef struct tagBINDING_TABLE_STATE { 10 union tagTheStructure { 11 struct tagCommon { 12 uint32_t Reserved_0 : BITFIELD_RANGE(0, 5); 13 uint32_t SurfaceStatePointer : BITFIELD_RANGE(6, 31); 14 } Common; 15 uint32_t RawData[1]; 16 } TheStructure; 17 typedef enum tagPATCH_CONSTANTS { 18 SURFACESTATEPOINTER_BYTEOFFSET = 0x0, 19 SURFACESTATEPOINTER_INDEX = 0x0, 20 } PATCH_CONSTANTS; 21 inline void init() { 22 memset(&TheStructure, 0, sizeof(TheStructure)); 23 } 24 static tagBINDING_TABLE_STATE sInit() { 25 BINDING_TABLE_STATE state; 26 state.init(); 27 return state; 28 } 29 inline uint32_t &getRawData(const uint32_t index) { 30 DEBUG_BREAK_IF(index >= 1); 31 return TheStructure.RawData[index]; 32 } 33 inline const uint32_t &getRawData(const uint32_t index) const { 34 DEBUG_BREAK_IF(index >= 1); 35 return TheStructure.RawData[index]; 36 } 37 typedef enum tagSURFACESTATEPOINTER { 38 SURFACESTATEPOINTER_BIT_SHIFT = 0x6, 39 SURFACESTATEPOINTER_ALIGN_SIZE = 0x40, 40 } SURFACESTATEPOINTER; 41 inline void setSurfaceStatePointer(const uint64_t value) { 42 DEBUG_BREAK_IF(value >= 0x100000000); 43 TheStructure.Common.SurfaceStatePointer = (uint32_t)value >> SURFACESTATEPOINTER_BIT_SHIFT; 44 } 45 inline uint32_t getSurfaceStatePointer() const { 46 return (TheStructure.Common.SurfaceStatePointer << SURFACESTATEPOINTER_BIT_SHIFT); 47 } 48} BINDING_TABLE_STATE; 49STATIC_ASSERT(4 == sizeof(BINDING_TABLE_STATE)); 50 51typedef struct tagGPGPU_WALKER { 52 union tagTheStructure { 53 struct tagCommon { 54 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 55 uint32_t PredicateEnable : BITFIELD_RANGE(8, 8); 56 uint32_t Reserved_9 : BITFIELD_RANGE(9, 9); 57 uint32_t IndirectParameterEnable : BITFIELD_RANGE(10, 10); 58 uint32_t Reserved_11 : BITFIELD_RANGE(11, 15); 59 uint32_t Subopcode : BITFIELD_RANGE(16, 23); 60 uint32_t MediaCommandOpcode : BITFIELD_RANGE(24, 26); 61 uint32_t Pipeline : BITFIELD_RANGE(27, 28); 62 uint32_t CommandType : BITFIELD_RANGE(29, 31); 63 uint32_t InterfaceDescriptorOffset : BITFIELD_RANGE(0, 5); 64 uint32_t Reserved_38 : BITFIELD_RANGE(6, 31); 65 uint32_t IndirectDataLength : BITFIELD_RANGE(0, 16); 66 uint32_t Reserved_81 : BITFIELD_RANGE(17, 31); 67 uint32_t Reserved_96 : BITFIELD_RANGE(0, 5); 68 uint32_t IndirectDataStartAddress : BITFIELD_RANGE(6, 31); 69 uint32_t ThreadWidthCounterMaximum : BITFIELD_RANGE(0, 5); 70 uint32_t Reserved_134 : BITFIELD_RANGE(6, 7); 71 uint32_t ThreadHeightCounterMaximum : BITFIELD_RANGE(8, 13); 72 uint32_t Reserved_142 : BITFIELD_RANGE(14, 15); 73 uint32_t ThreadDepthCounterMaximum : BITFIELD_RANGE(16, 21); 74 uint32_t Reserved_150 : BITFIELD_RANGE(22, 29); 75 uint32_t SimdSize : BITFIELD_RANGE(30, 31); 76 uint32_t ThreadGroupIdStartingX; 77 uint32_t Reserved_192; 78 uint32_t ThreadGroupIdXDimension; 79 uint32_t ThreadGroupIdStartingY; 80 uint32_t Reserved_288; 81 uint32_t ThreadGroupIdYDimension; 82 uint32_t ThreadGroupIdStartingResumeZ; 83 uint32_t ThreadGroupIdZDimension; 84 uint32_t RightExecutionMask; 85 uint32_t BottomExecutionMask; 86 } Common; 87 uint32_t RawData[15]; 88 } TheStructure; 89 typedef enum tagDWORD_LENGTH { 90 DWORD_LENGTH_DWORD_COUNT_N = 0xd, 91 } DWORD_LENGTH; 92 typedef enum tagSUBOPCODE { 93 SUBOPCODE_GPGPU_WALKER_SUBOP = 0x5, 94 } SUBOPCODE; 95 typedef enum tagMEDIA_COMMAND_OPCODE { 96 MEDIA_COMMAND_OPCODE_GPGPU_WALKER = 0x1, 97 } MEDIA_COMMAND_OPCODE; 98 typedef enum tagPIPELINE { 99 PIPELINE_MEDIA = 0x2, 100 } PIPELINE; 101 typedef enum tagCOMMAND_TYPE { 102 COMMAND_TYPE_GFXPIPE = 0x3, 103 } COMMAND_TYPE; 104 typedef enum tagSIMD_SIZE { 105 SIMD_SIZE_SIMD8 = 0x0, 106 SIMD_SIZE_SIMD16 = 0x1, 107 SIMD_SIZE_SIMD32 = 0x2, 108 } SIMD_SIZE; 109 typedef enum tagPATCH_CONSTANTS { 110 INDIRECTDATASTARTADDRESS_BYTEOFFSET = 0xc, 111 INDIRECTDATASTARTADDRESS_INDEX = 0x3, 112 } PATCH_CONSTANTS; 113 inline void init() { 114 memset(&TheStructure, 0, sizeof(TheStructure)); 115 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 116 TheStructure.Common.Subopcode = SUBOPCODE_GPGPU_WALKER_SUBOP; 117 TheStructure.Common.MediaCommandOpcode = MEDIA_COMMAND_OPCODE_GPGPU_WALKER; 118 TheStructure.Common.Pipeline = PIPELINE_MEDIA; 119 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 120 TheStructure.Common.SimdSize = SIMD_SIZE_SIMD8; 121 } 122 static tagGPGPU_WALKER sInit() { 123 GPGPU_WALKER state; 124 state.init(); 125 return state; 126 } 127 inline uint32_t &getRawData(const uint32_t index) { 128 DEBUG_BREAK_IF(index >= 15); 129 return TheStructure.RawData[index]; 130 } 131 inline void setPredicateEnable(const bool value) { 132 TheStructure.Common.PredicateEnable = value; 133 } 134 inline bool getPredicateEnable() const { 135 return (TheStructure.Common.PredicateEnable); 136 } 137 inline void setIndirectParameterEnable(const bool value) { 138 TheStructure.Common.IndirectParameterEnable = value; 139 } 140 inline bool getIndirectParameterEnable() const { 141 return (TheStructure.Common.IndirectParameterEnable); 142 } 143 inline void setInterfaceDescriptorOffset(const uint32_t value) { 144 TheStructure.Common.InterfaceDescriptorOffset = value; 145 } 146 inline uint32_t getInterfaceDescriptorOffset() const { 147 return (TheStructure.Common.InterfaceDescriptorOffset); 148 } 149 inline void setIndirectDataLength(const uint32_t value) { 150 TheStructure.Common.IndirectDataLength = value; 151 } 152 inline uint32_t getIndirectDataLength() const { 153 return (TheStructure.Common.IndirectDataLength); 154 } 155 typedef enum tagINDIRECTDATASTARTADDRESS { 156 INDIRECTDATASTARTADDRESS_BIT_SHIFT = 0x6, 157 INDIRECTDATASTARTADDRESS_ALIGN_SIZE = 0x40, 158 } INDIRECTDATASTARTADDRESS; 159 inline void setIndirectDataStartAddress(const uint32_t value) { 160 TheStructure.Common.IndirectDataStartAddress = value >> INDIRECTDATASTARTADDRESS_BIT_SHIFT; 161 } 162 inline uint32_t getIndirectDataStartAddress() const { 163 return (TheStructure.Common.IndirectDataStartAddress << INDIRECTDATASTARTADDRESS_BIT_SHIFT); 164 } 165 inline void setThreadWidthCounterMaximum(const uint32_t value) { 166 TheStructure.Common.ThreadWidthCounterMaximum = value - 1; 167 } 168 inline uint32_t getThreadWidthCounterMaximum() const { 169 return (TheStructure.Common.ThreadWidthCounterMaximum + 1); 170 } 171 inline void setThreadHeightCounterMaximum(const uint32_t value) { 172 TheStructure.Common.ThreadHeightCounterMaximum = value - 1; 173 } 174 inline uint32_t getThreadHeightCounterMaximum() const { 175 return (TheStructure.Common.ThreadHeightCounterMaximum + 1); 176 } 177 inline void setThreadDepthCounterMaximum(const uint32_t value) { 178 TheStructure.Common.ThreadDepthCounterMaximum = value; 179 } 180 inline uint32_t getThreadDepthCounterMaximum() const { 181 return (TheStructure.Common.ThreadDepthCounterMaximum); 182 } 183 inline void setSimdSize(const SIMD_SIZE value) { 184 TheStructure.Common.SimdSize = value; 185 } 186 inline SIMD_SIZE getSimdSize() const { 187 return static_cast<SIMD_SIZE>(TheStructure.Common.SimdSize); 188 } 189 inline void setThreadGroupIdStartingX(const uint32_t value) { 190 TheStructure.Common.ThreadGroupIdStartingX = value; 191 } 192 inline uint32_t getThreadGroupIdStartingX() const { 193 return (TheStructure.Common.ThreadGroupIdStartingX); 194 } 195 inline void setThreadGroupIdXDimension(const uint32_t value) { 196 TheStructure.Common.ThreadGroupIdXDimension = value; 197 } 198 inline uint32_t getThreadGroupIdXDimension() const { 199 return (TheStructure.Common.ThreadGroupIdXDimension); 200 } 201 inline void setThreadGroupIdStartingY(const uint32_t value) { 202 TheStructure.Common.ThreadGroupIdStartingY = value; 203 } 204 inline uint32_t getThreadGroupIdStartingY() const { 205 return (TheStructure.Common.ThreadGroupIdStartingY); 206 } 207 inline void setThreadGroupIdYDimension(const uint32_t value) { 208 TheStructure.Common.ThreadGroupIdYDimension = value; 209 } 210 inline uint32_t getThreadGroupIdYDimension() const { 211 return (TheStructure.Common.ThreadGroupIdYDimension); 212 } 213 inline void setThreadGroupIdStartingResumeZ(const uint32_t value) { 214 TheStructure.Common.ThreadGroupIdStartingResumeZ = value; 215 } 216 inline uint32_t getThreadGroupIdStartingResumeZ() const { 217 return (TheStructure.Common.ThreadGroupIdStartingResumeZ); 218 } 219 inline void setThreadGroupIdZDimension(const uint32_t value) { 220 TheStructure.Common.ThreadGroupIdZDimension = value; 221 } 222 inline uint32_t getThreadGroupIdZDimension() const { 223 return (TheStructure.Common.ThreadGroupIdZDimension); 224 } 225 inline void setRightExecutionMask(const uint32_t value) { 226 TheStructure.Common.RightExecutionMask = value; 227 } 228 inline uint32_t getRightExecutionMask() const { 229 return (TheStructure.Common.RightExecutionMask); 230 } 231 inline void setBottomExecutionMask(const uint32_t value) { 232 TheStructure.Common.BottomExecutionMask = value; 233 } 234 inline uint32_t getBottomExecutionMask() const { 235 return (TheStructure.Common.BottomExecutionMask); 236 } 237} GPGPU_WALKER; 238STATIC_ASSERT(60 == sizeof(GPGPU_WALKER)); 239 240typedef struct tagINTERFACE_DESCRIPTOR_DATA { 241 union tagTheStructure { 242 struct tagCommon { 243 uint32_t Reserved_0 : BITFIELD_RANGE(0, 5); 244 uint32_t KernelStartPointer : BITFIELD_RANGE(6, 31); 245 uint32_t KernelStartPointerHigh : BITFIELD_RANGE(0, 15); 246 uint32_t Reserved_48 : BITFIELD_RANGE(16, 31); 247 uint32_t Reserved_64 : BITFIELD_RANGE(0, 6); 248 uint32_t SoftwareExceptionEnable : BITFIELD_RANGE(7, 7); 249 uint32_t Reserved_72 : BITFIELD_RANGE(8, 10); 250 uint32_t MaskStackExceptionEnable : BITFIELD_RANGE(11, 11); 251 uint32_t Reserved_76 : BITFIELD_RANGE(12, 12); 252 uint32_t IllegalOpcodeExceptionEnable : BITFIELD_RANGE(13, 13); 253 uint32_t Reserved_78 : BITFIELD_RANGE(14, 15); 254 uint32_t FloatingPointMode : BITFIELD_RANGE(16, 16); 255 uint32_t ThreadPriority : BITFIELD_RANGE(17, 17); 256 uint32_t SingleProgramFlow : BITFIELD_RANGE(18, 18); 257 uint32_t DenormMode : BITFIELD_RANGE(19, 19); 258 uint32_t Reserved_84 : BITFIELD_RANGE(20, 31); 259 uint32_t Reserved_96 : BITFIELD_RANGE(0, 1); 260 uint32_t SamplerCount : BITFIELD_RANGE(2, 4); 261 uint32_t SamplerStatePointer : BITFIELD_RANGE(5, 31); 262 uint32_t BindingTableEntryCount : BITFIELD_RANGE(0, 4); 263 uint32_t BindingTablePointer : BITFIELD_RANGE(5, 15); 264 uint32_t Reserved_144 : BITFIELD_RANGE(16, 31); 265 uint32_t ConstantUrbEntryReadOffset : BITFIELD_RANGE(0, 15); 266 uint32_t ConstantIndirectUrbEntryReadLength : BITFIELD_RANGE(16, 31); 267 uint32_t NumberOfThreadsInGpgpuThreadGroup : BITFIELD_RANGE(0, 9); 268 uint32_t Reserved_202 : BITFIELD_RANGE(10, 14); 269 uint32_t GlobalBarrierEnable : BITFIELD_RANGE(15, 15); 270 uint32_t SharedLocalMemorySize : BITFIELD_RANGE(16, 20); 271 uint32_t BarrierEnable : BITFIELD_RANGE(21, 21); 272 uint32_t RoundingMode : BITFIELD_RANGE(22, 23); 273 uint32_t Reserved_216 : BITFIELD_RANGE(24, 31); 274 uint32_t Cross_ThreadConstantDataReadLength : BITFIELD_RANGE(0, 7); 275 uint32_t Reserved_232 : BITFIELD_RANGE(8, 31); 276 } Common; 277 uint32_t RawData[8]; 278 } TheStructure; 279 typedef enum tagFLOATING_POINT_MODE { 280 FLOATING_POINT_MODE_IEEE_754 = 0x0, 281 FLOATING_POINT_MODE_ALTERNATE = 0x1, 282 } FLOATING_POINT_MODE; 283 typedef enum tagTHREAD_PRIORITY { 284 THREAD_PRIORITY_NORMAL_PRIORITY = 0x0, 285 THREAD_PRIORITY_HIGH_PRIORITY = 0x1, 286 } THREAD_PRIORITY; 287 typedef enum tagSINGLE_PROGRAM_FLOW { 288 SINGLE_PROGRAM_FLOW_MULTIPLE = 0x0, 289 SINGLE_PROGRAM_FLOW_SINGLE = 0x1, 290 } SINGLE_PROGRAM_FLOW; 291 typedef enum tagDENORM_MODE { 292 DENORM_MODE_FTZ = 0x0, 293 DENORM_MODE_SETBYKERNEL = 0x1, 294 } DENORM_MODE; 295 typedef enum tagSAMPLER_COUNT { 296 SAMPLER_COUNT_NO_SAMPLERS_USED = 0x0, 297 SAMPLER_COUNT_BETWEEN_1_AND_4_SAMPLERS_USED = 0x1, 298 SAMPLER_COUNT_BETWEEN_5_AND_8_SAMPLERS_USED = 0x2, 299 SAMPLER_COUNT_BETWEEN_9_AND_12_SAMPLERS_USED = 0x3, 300 SAMPLER_COUNT_BETWEEN_13_AND_16_SAMPLERS_USED = 0x4, 301 } SAMPLER_COUNT; 302 typedef enum tagSHARED_LOCAL_MEMORY_SIZE { 303 SHARED_LOCAL_MEMORY_SIZE_ENCODES_0K = 0x0, 304 SHARED_LOCAL_MEMORY_SIZE_ENCODES_1K = 0x1, 305 SHARED_LOCAL_MEMORY_SIZE_ENCODES_2K = 0x2, 306 SHARED_LOCAL_MEMORY_SIZE_ENCODES_4K = 0x3, 307 SHARED_LOCAL_MEMORY_SIZE_ENCODES_8K = 0x4, 308 SHARED_LOCAL_MEMORY_SIZE_ENCODES_16K = 0x5, 309 SHARED_LOCAL_MEMORY_SIZE_ENCODES_32K = 0x6, 310 SHARED_LOCAL_MEMORY_SIZE_ENCODES_64K = 0x7, 311 } SHARED_LOCAL_MEMORY_SIZE; 312 typedef enum tagROUNDING_MODE { 313 ROUNDING_MODE_RTNE = 0x0, 314 ROUNDING_MODE_RU = 0x1, 315 ROUNDING_MODE_RD = 0x2, 316 ROUNDING_MODE_RTZ = 0x3, 317 } ROUNDING_MODE; 318 typedef enum tagPATCH_CONSTANTS { 319 KERNELSTARTPOINTER_BYTEOFFSET = 0x0, 320 KERNELSTARTPOINTER_INDEX = 0x0, 321 KERNELSTARTPOINTERHIGH_BYTEOFFSET = 0x4, 322 KERNELSTARTPOINTERHIGH_INDEX = 0x1, 323 SAMPLERSTATEPOINTER_BYTEOFFSET = 0xc, 324 SAMPLERSTATEPOINTER_INDEX = 0x3, 325 BINDINGTABLEPOINTER_BYTEOFFSET = 0x10, 326 BINDINGTABLEPOINTER_INDEX = 0x4, 327 } PATCH_CONSTANTS; 328 inline void init() { 329 memset(&TheStructure, 0, sizeof(TheStructure)); 330 TheStructure.Common.FloatingPointMode = FLOATING_POINT_MODE_IEEE_754; 331 TheStructure.Common.ThreadPriority = THREAD_PRIORITY_NORMAL_PRIORITY; 332 TheStructure.Common.SingleProgramFlow = SINGLE_PROGRAM_FLOW_MULTIPLE; 333 TheStructure.Common.DenormMode = DENORM_MODE_FTZ; 334 TheStructure.Common.SamplerCount = SAMPLER_COUNT_NO_SAMPLERS_USED; 335 TheStructure.Common.SharedLocalMemorySize = SHARED_LOCAL_MEMORY_SIZE_ENCODES_0K; 336 TheStructure.Common.RoundingMode = ROUNDING_MODE_RTNE; 337 } 338 static tagINTERFACE_DESCRIPTOR_DATA sInit() { 339 INTERFACE_DESCRIPTOR_DATA state; 340 state.init(); 341 return state; 342 } 343 inline uint32_t &getRawData(const uint32_t index) { 344 DEBUG_BREAK_IF(index >= 8); 345 return TheStructure.RawData[index]; 346 } 347 typedef enum tagKERNELSTARTPOINTER { 348 KERNELSTARTPOINTER_BIT_SHIFT = 0x6, 349 KERNELSTARTPOINTER_ALIGN_SIZE = 0x40, 350 } KERNELSTARTPOINTER; 351 inline void setKernelStartPointer(const uint64_t value) { 352 DEBUG_BREAK_IF(value >= 0x100000000); 353 TheStructure.Common.KernelStartPointer = (uint32_t)value >> KERNELSTARTPOINTER_BIT_SHIFT; 354 } 355 inline uint32_t getKernelStartPointer() const { 356 return (TheStructure.Common.KernelStartPointer << KERNELSTARTPOINTER_BIT_SHIFT); 357 } 358 inline void setKernelStartPointerHigh(const uint32_t value) { 359 TheStructure.Common.KernelStartPointerHigh = value; 360 } 361 inline uint32_t getKernelStartPointerHigh() const { 362 return (TheStructure.Common.KernelStartPointerHigh); 363 } 364 inline void setSoftwareExceptionEnable(const bool value) { 365 TheStructure.Common.SoftwareExceptionEnable = value; 366 } 367 inline bool getSoftwareExceptionEnable() const { 368 return (TheStructure.Common.SoftwareExceptionEnable); 369 } 370 inline void setMaskStackExceptionEnable(const bool value) { 371 TheStructure.Common.MaskStackExceptionEnable = value; 372 } 373 inline bool getMaskStackExceptionEnable() const { 374 return (TheStructure.Common.MaskStackExceptionEnable); 375 } 376 inline void setIllegalOpcodeExceptionEnable(const bool value) { 377 TheStructure.Common.IllegalOpcodeExceptionEnable = value; 378 } 379 inline bool getIllegalOpcodeExceptionEnable() const { 380 return (TheStructure.Common.IllegalOpcodeExceptionEnable); 381 } 382 inline void setFloatingPointMode(const FLOATING_POINT_MODE value) { 383 TheStructure.Common.FloatingPointMode = value; 384 } 385 inline FLOATING_POINT_MODE getFloatingPointMode() const { 386 return static_cast<FLOATING_POINT_MODE>(TheStructure.Common.FloatingPointMode); 387 } 388 inline void setThreadPriority(const THREAD_PRIORITY value) { 389 TheStructure.Common.ThreadPriority = value; 390 } 391 inline THREAD_PRIORITY getThreadPriority() const { 392 return static_cast<THREAD_PRIORITY>(TheStructure.Common.ThreadPriority); 393 } 394 inline void setSingleProgramFlow(const SINGLE_PROGRAM_FLOW value) { 395 TheStructure.Common.SingleProgramFlow = value; 396 } 397 inline SINGLE_PROGRAM_FLOW getSingleProgramFlow() const { 398 return static_cast<SINGLE_PROGRAM_FLOW>(TheStructure.Common.SingleProgramFlow); 399 } 400 inline void setDenormMode(const DENORM_MODE value) { 401 TheStructure.Common.DenormMode = value; 402 } 403 inline DENORM_MODE getDenormMode() const { 404 return static_cast<DENORM_MODE>(TheStructure.Common.DenormMode); 405 } 406 inline void setSamplerCount(const SAMPLER_COUNT value) { 407 TheStructure.Common.SamplerCount = value; 408 } 409 inline SAMPLER_COUNT getSamplerCount() const { 410 return static_cast<SAMPLER_COUNT>(TheStructure.Common.SamplerCount); 411 } 412 typedef enum tagSAMPLERSTATEPOINTER { 413 SAMPLERSTATEPOINTER_BIT_SHIFT = 0x5, 414 SAMPLERSTATEPOINTER_ALIGN_SIZE = 0x20, 415 } SAMPLERSTATEPOINTER; 416 inline void setSamplerStatePointer(const uint64_t value) { 417 DEBUG_BREAK_IF(value >= 0x100000000); 418 TheStructure.Common.SamplerStatePointer = (uint32_t)value >> SAMPLERSTATEPOINTER_BIT_SHIFT; 419 } 420 inline uint32_t getSamplerStatePointer() const { 421 return (TheStructure.Common.SamplerStatePointer << SAMPLERSTATEPOINTER_BIT_SHIFT); 422 } 423 inline void setBindingTableEntryCount(const uint32_t value) { 424 TheStructure.Common.BindingTableEntryCount = value; 425 } 426 inline uint32_t getBindingTableEntryCount() const { 427 return (TheStructure.Common.BindingTableEntryCount); 428 } 429 typedef enum tagBINDINGTABLEPOINTER { 430 BINDINGTABLEPOINTER_BIT_SHIFT = 0x5, 431 BINDINGTABLEPOINTER_ALIGN_SIZE = 0x20, 432 } BINDINGTABLEPOINTER; 433 inline void setBindingTablePointer(const uint64_t value) { 434 DEBUG_BREAK_IF(value > 0xFFE0); 435 TheStructure.Common.BindingTablePointer = (uint32_t)value >> BINDINGTABLEPOINTER_BIT_SHIFT; 436 } 437 inline uint32_t getBindingTablePointer() const { 438 return (TheStructure.Common.BindingTablePointer << BINDINGTABLEPOINTER_BIT_SHIFT); 439 } 440 inline void setConstantUrbEntryReadOffset(const uint32_t value) { 441 TheStructure.Common.ConstantUrbEntryReadOffset = value; 442 } 443 inline uint32_t getConstantUrbEntryReadOffset() const { 444 return (TheStructure.Common.ConstantUrbEntryReadOffset); 445 } 446 inline void setConstantIndirectUrbEntryReadLength(const uint32_t value) { 447 TheStructure.Common.ConstantIndirectUrbEntryReadLength = value; 448 } 449 inline uint32_t getConstantIndirectUrbEntryReadLength() const { 450 return (TheStructure.Common.ConstantIndirectUrbEntryReadLength); 451 } 452 inline void setNumberOfThreadsInGpgpuThreadGroup(const uint32_t value) { 453 TheStructure.Common.NumberOfThreadsInGpgpuThreadGroup = value; 454 } 455 inline uint32_t getNumberOfThreadsInGpgpuThreadGroup() const { 456 return (TheStructure.Common.NumberOfThreadsInGpgpuThreadGroup); 457 } 458 inline void setGlobalBarrierEnable(const bool value) { 459 TheStructure.Common.GlobalBarrierEnable = value; 460 } 461 inline bool getGlobalBarrierEnable() const { 462 return (TheStructure.Common.GlobalBarrierEnable); 463 } 464 inline void setSharedLocalMemorySize(const SHARED_LOCAL_MEMORY_SIZE value) { 465 TheStructure.Common.SharedLocalMemorySize = value; 466 } 467 inline SHARED_LOCAL_MEMORY_SIZE getSharedLocalMemorySize() const { 468 return static_cast<SHARED_LOCAL_MEMORY_SIZE>(TheStructure.Common.SharedLocalMemorySize); 469 } 470 inline void setBarrierEnable(const uint32_t value) { 471 TheStructure.Common.BarrierEnable = (value > 0u) ? 1u : 0u; 472 } 473 inline bool getBarrierEnable() const { 474 return (TheStructure.Common.BarrierEnable); 475 } 476 inline void setRoundingMode(const ROUNDING_MODE value) { 477 TheStructure.Common.RoundingMode = value; 478 } 479 inline ROUNDING_MODE getRoundingMode() const { 480 return static_cast<ROUNDING_MODE>(TheStructure.Common.RoundingMode); 481 } 482 inline void setCrossThreadConstantDataReadLength(const uint32_t value) { 483 TheStructure.Common.Cross_ThreadConstantDataReadLength = value; 484 } 485 inline uint32_t getCrossThreadConstantDataReadLength() const { 486 return (TheStructure.Common.Cross_ThreadConstantDataReadLength); 487 } 488} INTERFACE_DESCRIPTOR_DATA; 489STATIC_ASSERT(32 == sizeof(INTERFACE_DESCRIPTOR_DATA)); 490 491typedef struct tagMEDIA_INTERFACE_DESCRIPTOR_LOAD { 492 union tagTheStructure { 493 struct tagCommon { 494 uint32_t DwordLength : BITFIELD_RANGE(0, 15); 495 uint32_t Subopcode : BITFIELD_RANGE(16, 23); 496 uint32_t MediaCommandOpcode : BITFIELD_RANGE(24, 26); 497 uint32_t Pipeline : BITFIELD_RANGE(27, 28); 498 uint32_t CommandType : BITFIELD_RANGE(29, 31); 499 uint32_t Reserved_32; 500 uint32_t InterfaceDescriptorTotalLength : BITFIELD_RANGE(0, 16); 501 uint32_t Reserved_81 : BITFIELD_RANGE(17, 31); 502 uint32_t InterfaceDescriptorDataStartAddress; 503 } Common; 504 uint32_t RawData[4]; 505 } TheStructure; 506 typedef enum tagDWORD_LENGTH { 507 DWORD_LENGTH_DWORD_COUNT_N = 0x2, 508 } DWORD_LENGTH; 509 typedef enum tagSUBOPCODE { 510 SUBOPCODE_MEDIA_INTERFACE_DESCRIPTOR_LOAD_SUBOP = 0x2, 511 } SUBOPCODE; 512 typedef enum tagMEDIA_COMMAND_OPCODE { 513 MEDIA_COMMAND_OPCODE_MEDIA_INTERFACE_DESCRIPTOR_LOAD = 0x0, 514 } MEDIA_COMMAND_OPCODE; 515 typedef enum tagPIPELINE { 516 PIPELINE_MEDIA = 0x2, 517 } PIPELINE; 518 typedef enum tagCOMMAND_TYPE { 519 COMMAND_TYPE_GFXPIPE = 0x3, 520 } COMMAND_TYPE; 521 typedef enum tagPATCH_CONSTANTS { 522 INTERFACEDESCRIPTORDATASTARTADDRESS_BYTEOFFSET = 0xc, 523 INTERFACEDESCRIPTORDATASTARTADDRESS_INDEX = 0x3, 524 } PATCH_CONSTANTS; 525 inline void init() { 526 memset(&TheStructure, 0, sizeof(TheStructure)); 527 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 528 TheStructure.Common.Subopcode = SUBOPCODE_MEDIA_INTERFACE_DESCRIPTOR_LOAD_SUBOP; 529 TheStructure.Common.MediaCommandOpcode = MEDIA_COMMAND_OPCODE_MEDIA_INTERFACE_DESCRIPTOR_LOAD; 530 TheStructure.Common.Pipeline = PIPELINE_MEDIA; 531 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 532 } 533 static tagMEDIA_INTERFACE_DESCRIPTOR_LOAD sInit() { 534 MEDIA_INTERFACE_DESCRIPTOR_LOAD state; 535 state.init(); 536 return state; 537 } 538 inline uint32_t &getRawData(const uint32_t index) { 539 DEBUG_BREAK_IF(index >= 4); 540 return TheStructure.RawData[index]; 541 } 542 inline void setInterfaceDescriptorTotalLength(const uint32_t value) { 543 TheStructure.Common.InterfaceDescriptorTotalLength = value; 544 } 545 inline uint32_t getInterfaceDescriptorTotalLength() const { 546 return (TheStructure.Common.InterfaceDescriptorTotalLength); 547 } 548 inline void setInterfaceDescriptorDataStartAddress(const uint32_t value) { 549 TheStructure.Common.InterfaceDescriptorDataStartAddress = value; 550 } 551 inline uint32_t getInterfaceDescriptorDataStartAddress() const { 552 return (TheStructure.Common.InterfaceDescriptorDataStartAddress); 553 } 554} MEDIA_INTERFACE_DESCRIPTOR_LOAD; 555STATIC_ASSERT(16 == sizeof(MEDIA_INTERFACE_DESCRIPTOR_LOAD)); 556 557typedef struct tagMEDIA_STATE_FLUSH { 558 union tagTheStructure { 559 struct tagCommon { 560 uint32_t DwordLength : BITFIELD_RANGE(0, 15); 561 uint32_t Subopcode : BITFIELD_RANGE(16, 23); 562 uint32_t MediaCommandOpcode : BITFIELD_RANGE(24, 26); 563 uint32_t Pipeline : BITFIELD_RANGE(27, 28); 564 uint32_t CommandType : BITFIELD_RANGE(29, 31); 565 uint32_t InterfaceDescriptorOffset : BITFIELD_RANGE(0, 5); 566 uint32_t WatermarkRequired : BITFIELD_RANGE(6, 6); 567 uint32_t FlushToGo : BITFIELD_RANGE(7, 7); 568 uint32_t Reserved_40 : BITFIELD_RANGE(8, 31); 569 } Common; 570 uint32_t RawData[2]; 571 } TheStructure; 572 typedef enum tagDWORD_LENGTH { 573 DWORD_LENGTH_DWORD_COUNT_N = 0x0, 574 } DWORD_LENGTH; 575 typedef enum tagSUBOPCODE { 576 SUBOPCODE_MEDIA_STATE_FLUSH_SUBOP = 0x4, 577 } SUBOPCODE; 578 typedef enum tagMEDIA_COMMAND_OPCODE { 579 MEDIA_COMMAND_OPCODE_MEDIA_STATE_FLUSH = 0x0, 580 } MEDIA_COMMAND_OPCODE; 581 typedef enum tagPIPELINE { 582 PIPELINE_MEDIA = 0x2, 583 } PIPELINE; 584 typedef enum tagCOMMAND_TYPE { 585 COMMAND_TYPE_GFXPIPE = 0x3, 586 } COMMAND_TYPE; 587 inline void init() { 588 memset(&TheStructure, 0, sizeof(TheStructure)); 589 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 590 TheStructure.Common.Subopcode = SUBOPCODE_MEDIA_STATE_FLUSH_SUBOP; 591 TheStructure.Common.MediaCommandOpcode = MEDIA_COMMAND_OPCODE_MEDIA_STATE_FLUSH; 592 TheStructure.Common.Pipeline = PIPELINE_MEDIA; 593 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 594 } 595 static tagMEDIA_STATE_FLUSH sInit() { 596 MEDIA_STATE_FLUSH state; 597 state.init(); 598 return state; 599 } 600 inline uint32_t &getRawData(const uint32_t index) { 601 DEBUG_BREAK_IF(index >= 2); 602 return TheStructure.RawData[index]; 603 } 604 inline void setInterfaceDescriptorOffset(const uint32_t value) { 605 TheStructure.Common.InterfaceDescriptorOffset = value; 606 } 607 inline uint32_t getInterfaceDescriptorOffset() const { 608 return (TheStructure.Common.InterfaceDescriptorOffset); 609 } 610 inline void setWatermarkRequired(const uint32_t value) { 611 TheStructure.Common.WatermarkRequired = value; 612 } 613 inline uint32_t getWatermarkRequired() const { 614 return (TheStructure.Common.WatermarkRequired); 615 } 616 inline void setFlushToGo(const bool value) { 617 TheStructure.Common.FlushToGo = value; 618 } 619 inline bool getFlushToGo() const { 620 return (TheStructure.Common.FlushToGo); 621 } 622} MEDIA_STATE_FLUSH; 623STATIC_ASSERT(8 == sizeof(MEDIA_STATE_FLUSH)); 624 625typedef struct tagMEDIA_VFE_STATE { 626 union tagTheStructure { 627 struct tagCommon { 628 uint32_t DwordLength : BITFIELD_RANGE(0, 15); 629 uint32_t Subopcode : BITFIELD_RANGE(16, 23); 630 uint32_t MediaCommandOpcode : BITFIELD_RANGE(24, 26); 631 uint32_t Pipeline : BITFIELD_RANGE(27, 28); 632 uint32_t CommandType : BITFIELD_RANGE(29, 31); 633 uint32_t PerThreadScratchSpace : BITFIELD_RANGE(0, 3); 634 uint32_t StackSize : BITFIELD_RANGE(4, 7); 635 uint32_t Reserved_40 : BITFIELD_RANGE(8, 9); 636 uint32_t ScratchSpaceBasePointer : BITFIELD_RANGE(10, 31); 637 uint32_t ScratchSpaceBasePointerHigh : BITFIELD_RANGE(0, 15); 638 uint32_t Reserved_80 : BITFIELD_RANGE(16, 31); 639 uint32_t Reserved_96 : BITFIELD_RANGE(0, 6); 640 uint32_t ResetGatewayTimer : BITFIELD_RANGE(7, 7); 641 uint32_t NumberOfUrbEntries : BITFIELD_RANGE(8, 15); 642 uint32_t MaximumNumberOfThreads : BITFIELD_RANGE(16, 31); 643 uint32_t SliceDisable : BITFIELD_RANGE(0, 1); 644 uint32_t Reserved_130 : BITFIELD_RANGE(2, 31); 645 uint32_t CurbeAllocationSize : BITFIELD_RANGE(0, 15); 646 uint32_t UrbEntryAllocationSize : BITFIELD_RANGE(16, 31); 647 uint32_t ScoreboardMask : BITFIELD_RANGE(0, 7); 648 uint32_t Reserved_200 : BITFIELD_RANGE(8, 29); 649 uint32_t ScoreboardType : BITFIELD_RANGE(30, 30); 650 uint32_t ScoreboardEnable : BITFIELD_RANGE(31, 31); 651 uint32_t Scoreboard0DeltaX : BITFIELD_RANGE(0, 3); 652 uint32_t Scoreboard0DeltaY : BITFIELD_RANGE(4, 7); 653 uint32_t Scoreboard1DeltaX : BITFIELD_RANGE(8, 11); 654 uint32_t Scoreboard1DeltaY : BITFIELD_RANGE(12, 15); 655 uint32_t Scoreboard2DeltaX : BITFIELD_RANGE(16, 19); 656 uint32_t Scoreboard2DeltaY : BITFIELD_RANGE(20, 23); 657 uint32_t Scoreboard3DeltaX : BITFIELD_RANGE(24, 27); 658 uint32_t Scoreboard3DeltaY : BITFIELD_RANGE(28, 31); 659 uint32_t Scoreboard4DeltaX : BITFIELD_RANGE(0, 3); 660 uint32_t Scoreboard4DeltaY : BITFIELD_RANGE(4, 7); 661 uint32_t Scoreboard5DeltaX : BITFIELD_RANGE(8, 11); 662 uint32_t Scoreboard5DeltaY : BITFIELD_RANGE(12, 15); 663 uint32_t Scoreboard6DeltaX : BITFIELD_RANGE(16, 19); 664 uint32_t Scoreboard6DeltaY : BITFIELD_RANGE(20, 23); 665 uint32_t Scoreboard7DeltaX : BITFIELD_RANGE(24, 27); 666 uint32_t Scoreboard7DeltaY : BITFIELD_RANGE(28, 31); 667 } Common; 668 uint32_t RawData[9]; 669 } TheStructure; 670 typedef enum tagDWORD_LENGTH { 671 DWORD_LENGTH_DWORD_COUNT_N = 0x7, 672 } DWORD_LENGTH; 673 typedef enum tagSUBOPCODE { 674 SUBOPCODE_MEDIA_VFE_STATE_SUBOP = 0x0, 675 } SUBOPCODE; 676 typedef enum tagMEDIA_COMMAND_OPCODE { 677 MEDIA_COMMAND_OPCODE_MEDIA_VFE_STATE = 0x0, 678 } MEDIA_COMMAND_OPCODE; 679 typedef enum tagPIPELINE { 680 PIPELINE_MEDIA = 0x2, 681 } PIPELINE; 682 typedef enum tagCOMMAND_TYPE { 683 COMMAND_TYPE_GFXPIPE = 0x3, 684 } COMMAND_TYPE; 685 typedef enum tagRESET_GATEWAY_TIMER { 686 RESET_GATEWAY_TIMER_MAINTAINING_THE_EXISTING_TIMESTAMP_STATE = 0x0, 687 RESET_GATEWAY_TIMER_RESETTING_RELATIVE_TIMER_AND_LATCHING_THE_GLOBAL_TIMESTAMP = 0x1, 688 } RESET_GATEWAY_TIMER; 689 typedef enum tagSLICE_DISABLE { 690 SLICE_DISABLE_ALL_SUBSLICES_ENABLED = 0x0, 691 SLICE_DISABLE_ONLY_SLICE_0_ENABLED = 0x1, 692 SLICE_DISABLE_ONLY_SLICE_0_SUBSLICE_0_ENABLED = 0x3, 693 } SLICE_DISABLE; 694 typedef enum tagSCOREBOARD_TYPE { 695 SCOREBOARD_TYPE_STALLING_SCOREBOARD = 0x0, 696 SCOREBOARD_TYPE_NON_STALLING_SCOREBOARD = 0x1, 697 } SCOREBOARD_TYPE; 698 typedef enum tagPATCH_CONSTANTS { 699 SCRATCHSPACEBASEPOINTER_BYTEOFFSET = 0x4, 700 SCRATCHSPACEBASEPOINTER_INDEX = 0x1, 701 SCRATCHSPACEBASEPOINTERHIGH_BYTEOFFSET = 0x8, 702 SCRATCHSPACEBASEPOINTERHIGH_INDEX = 0x2, 703 } PATCH_CONSTANTS; 704 inline void init() { 705 memset(&TheStructure, 0, sizeof(TheStructure)); 706 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 707 TheStructure.Common.Subopcode = SUBOPCODE_MEDIA_VFE_STATE_SUBOP; 708 TheStructure.Common.MediaCommandOpcode = MEDIA_COMMAND_OPCODE_MEDIA_VFE_STATE; 709 TheStructure.Common.Pipeline = PIPELINE_MEDIA; 710 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 711 TheStructure.Common.ResetGatewayTimer = RESET_GATEWAY_TIMER_MAINTAINING_THE_EXISTING_TIMESTAMP_STATE; 712 TheStructure.Common.SliceDisable = SLICE_DISABLE_ALL_SUBSLICES_ENABLED; 713 TheStructure.Common.ScoreboardType = SCOREBOARD_TYPE_STALLING_SCOREBOARD; 714 } 715 static tagMEDIA_VFE_STATE sInit() { 716 MEDIA_VFE_STATE state; 717 state.init(); 718 return state; 719 } 720 inline uint32_t &getRawData(const uint32_t index) { 721 DEBUG_BREAK_IF(index >= 9); 722 return TheStructure.RawData[index]; 723 } 724 inline void setPerThreadScratchSpace(const uint32_t value) { 725 TheStructure.Common.PerThreadScratchSpace = value; 726 } 727 inline uint32_t getPerThreadScratchSpace() const { 728 return (TheStructure.Common.PerThreadScratchSpace); 729 } 730 inline void setStackSize(const uint32_t value) { 731 TheStructure.Common.StackSize = value; 732 } 733 inline uint32_t getStackSize() const { 734 return (TheStructure.Common.StackSize); 735 } 736 typedef enum tagSCRATCHSPACEBASEPOINTER { 737 SCRATCHSPACEBASEPOINTER_BIT_SHIFT = 0xa, 738 SCRATCHSPACEBASEPOINTER_ALIGN_SIZE = 0x400, 739 } SCRATCHSPACEBASEPOINTER; 740 inline void setScratchSpaceBasePointer(const uint32_t value) { 741 TheStructure.Common.ScratchSpaceBasePointer = value >> SCRATCHSPACEBASEPOINTER_BIT_SHIFT; 742 } 743 inline uint32_t getScratchSpaceBasePointer() const { 744 return (TheStructure.Common.ScratchSpaceBasePointer << SCRATCHSPACEBASEPOINTER_BIT_SHIFT); 745 } 746 inline void setScratchSpaceBasePointerHigh(const uint32_t value) { 747 TheStructure.Common.ScratchSpaceBasePointerHigh = value; 748 } 749 inline uint32_t getScratchSpaceBasePointerHigh() const { 750 return (TheStructure.Common.ScratchSpaceBasePointerHigh); 751 } 752 inline void setResetGatewayTimer(const RESET_GATEWAY_TIMER value) { 753 TheStructure.Common.ResetGatewayTimer = value; 754 } 755 inline RESET_GATEWAY_TIMER getResetGatewayTimer() const { 756 return static_cast<RESET_GATEWAY_TIMER>(TheStructure.Common.ResetGatewayTimer); 757 } 758 inline void setNumberOfUrbEntries(const uint32_t value) { 759 TheStructure.Common.NumberOfUrbEntries = value; 760 } 761 inline uint32_t getNumberOfUrbEntries() const { 762 return (TheStructure.Common.NumberOfUrbEntries); 763 } 764 inline void setMaximumNumberOfThreads(const uint32_t value) { 765 TheStructure.Common.MaximumNumberOfThreads = value - 1; 766 } 767 inline uint32_t getMaximumNumberOfThreads() const { 768 return (TheStructure.Common.MaximumNumberOfThreads + 1); 769 } 770 inline void setSliceDisable(const SLICE_DISABLE value) { 771 TheStructure.Common.SliceDisable = value; 772 } 773 inline SLICE_DISABLE getSliceDisable() const { 774 return static_cast<SLICE_DISABLE>(TheStructure.Common.SliceDisable); 775 } 776 inline void setCurbeAllocationSize(const uint32_t value) { 777 TheStructure.Common.CurbeAllocationSize = value; 778 } 779 inline uint32_t getCurbeAllocationSize() const { 780 return (TheStructure.Common.CurbeAllocationSize); 781 } 782 inline void setUrbEntryAllocationSize(const uint32_t value) { 783 TheStructure.Common.UrbEntryAllocationSize = value; 784 } 785 inline uint32_t getUrbEntryAllocationSize() const { 786 return (TheStructure.Common.UrbEntryAllocationSize); 787 } 788 inline void setScoreboardMask(const uint32_t value) { 789 TheStructure.Common.ScoreboardMask = value; 790 } 791 inline uint32_t getScoreboardMask() const { 792 return (TheStructure.Common.ScoreboardMask); 793 } 794 inline void setScoreboardType(const SCOREBOARD_TYPE value) { 795 TheStructure.Common.ScoreboardType = value; 796 } 797 inline SCOREBOARD_TYPE getScoreboardType() const { 798 return static_cast<SCOREBOARD_TYPE>(TheStructure.Common.ScoreboardType); 799 } 800 inline void setScoreboardEnable(const bool value) { 801 TheStructure.Common.ScoreboardEnable = value; 802 } 803 inline bool getScoreboardEnable() const { 804 return (TheStructure.Common.ScoreboardEnable); 805 } 806 inline void setScoreboard0DeltaX(const uint32_t value) { 807 TheStructure.Common.Scoreboard0DeltaX = value; 808 } 809 inline uint32_t getScoreboard0DeltaX() const { 810 return (TheStructure.Common.Scoreboard0DeltaX); 811 } 812 inline void setScoreboard0DeltaY(const uint32_t value) { 813 TheStructure.Common.Scoreboard0DeltaY = value; 814 } 815 inline uint32_t getScoreboard0DeltaY() const { 816 return (TheStructure.Common.Scoreboard0DeltaY); 817 } 818 inline void setScoreboard1DeltaX(const uint32_t value) { 819 TheStructure.Common.Scoreboard1DeltaX = value; 820 } 821 inline uint32_t getScoreboard1DeltaX() const { 822 return (TheStructure.Common.Scoreboard1DeltaX); 823 } 824 inline void setScoreboard1DeltaY(const uint32_t value) { 825 TheStructure.Common.Scoreboard1DeltaY = value; 826 } 827 inline uint32_t getScoreboard1DeltaY() const { 828 return (TheStructure.Common.Scoreboard1DeltaY); 829 } 830 inline void setScoreboard2DeltaX(const uint32_t value) { 831 TheStructure.Common.Scoreboard2DeltaX = value; 832 } 833 inline uint32_t getScoreboard2DeltaX() const { 834 return (TheStructure.Common.Scoreboard2DeltaX); 835 } 836 inline void setScoreboard2DeltaY(const uint32_t value) { 837 TheStructure.Common.Scoreboard2DeltaY = value; 838 } 839 inline uint32_t getScoreboard2DeltaY() const { 840 return (TheStructure.Common.Scoreboard2DeltaY); 841 } 842 inline void setScoreboard3DeltaX(const uint32_t value) { 843 TheStructure.Common.Scoreboard3DeltaX = value; 844 } 845 inline uint32_t getScoreboard3DeltaX() const { 846 return (TheStructure.Common.Scoreboard3DeltaX); 847 } 848 inline void setScoreboard3DeltaY(const uint32_t value) { 849 TheStructure.Common.Scoreboard3DeltaY = value; 850 } 851 inline uint32_t getScoreboard3DeltaY() const { 852 return (TheStructure.Common.Scoreboard3DeltaY); 853 } 854 inline void setScoreboard4DeltaX(const uint32_t value) { 855 TheStructure.Common.Scoreboard4DeltaX = value; 856 } 857 inline uint32_t getScoreboard4DeltaX() const { 858 return (TheStructure.Common.Scoreboard4DeltaX); 859 } 860 inline void setScoreboard4DeltaY(const uint32_t value) { 861 TheStructure.Common.Scoreboard4DeltaY = value; 862 } 863 inline uint32_t getScoreboard4DeltaY() const { 864 return (TheStructure.Common.Scoreboard4DeltaY); 865 } 866 inline void setScoreboard5DeltaX(const uint32_t value) { 867 TheStructure.Common.Scoreboard5DeltaX = value; 868 } 869 inline uint32_t getScoreboard5DeltaX() const { 870 return (TheStructure.Common.Scoreboard5DeltaX); 871 } 872 inline void setScoreboard5DeltaY(const uint32_t value) { 873 TheStructure.Common.Scoreboard5DeltaY = value; 874 } 875 inline uint32_t getScoreboard5DeltaY() const { 876 return (TheStructure.Common.Scoreboard5DeltaY); 877 } 878 inline void setScoreboard6DeltaX(const uint32_t value) { 879 TheStructure.Common.Scoreboard6DeltaX = value; 880 } 881 inline uint32_t getScoreboard6DeltaX() const { 882 return (TheStructure.Common.Scoreboard6DeltaX); 883 } 884 inline void setScoreboard6DeltaY(const uint32_t value) { 885 TheStructure.Common.Scoreboard6DeltaY = value; 886 } 887 inline uint32_t getScoreboard6DeltaY() const { 888 return (TheStructure.Common.Scoreboard6DeltaY); 889 } 890 inline void setScoreboard7DeltaX(const uint32_t value) { 891 TheStructure.Common.Scoreboard7DeltaX = value; 892 } 893 inline uint32_t getScoreboard7DeltaX() const { 894 return (TheStructure.Common.Scoreboard7DeltaX); 895 } 896 inline void setScoreboard7DeltaY(const uint32_t value) { 897 TheStructure.Common.Scoreboard7DeltaY = value; 898 } 899 inline uint32_t getScoreboard7DeltaY() const { 900 return (TheStructure.Common.Scoreboard7DeltaY); 901 } 902} MEDIA_VFE_STATE; 903STATIC_ASSERT(36 == sizeof(MEDIA_VFE_STATE)); 904 905typedef struct tagMI_ARB_CHECK { 906 union tagTheStructure { 907 struct tagCommon { 908 uint32_t Reserved_0 : BITFIELD_RANGE(0, 22); 909 uint32_t MiInstructionOpcode : BITFIELD_RANGE(23, 28); 910 uint32_t MiInstructionType : BITFIELD_RANGE(29, 31); 911 } Common; 912 uint32_t RawData[1]; 913 } TheStructure; 914 typedef enum tagMI_INSTRUCTION_OPCODE { 915 MI_INSTRUCTION_OPCODE_MI_ARB_CHECK = 0x5, 916 } MI_INSTRUCTION_OPCODE; 917 typedef enum tagMI_INSTRUCTION_TYPE { 918 MI_INSTRUCTION_TYPE_MI_INSTRUCTION = 0x0, 919 } MI_INSTRUCTION_TYPE; 920 inline void init() { 921 memset(&TheStructure, 0, sizeof(TheStructure)); 922 TheStructure.Common.MiInstructionOpcode = MI_INSTRUCTION_OPCODE_MI_ARB_CHECK; 923 TheStructure.Common.MiInstructionType = MI_INSTRUCTION_TYPE_MI_INSTRUCTION; 924 } 925 static tagMI_ARB_CHECK sInit() { 926 MI_ARB_CHECK state; 927 state.init(); 928 return state; 929 } 930 inline uint32_t &getRawData(const uint32_t index) { 931 DEBUG_BREAK_IF(index >= 1); 932 return TheStructure.RawData[index]; 933 } 934 inline void setMiInstructionOpcode(const MI_INSTRUCTION_OPCODE value) { 935 TheStructure.Common.MiInstructionOpcode = value; 936 } 937 inline MI_INSTRUCTION_OPCODE getMiInstructionOpcode() const { 938 return static_cast<MI_INSTRUCTION_OPCODE>(TheStructure.Common.MiInstructionOpcode); 939 } 940 inline void setMiInstructionType(const MI_INSTRUCTION_TYPE value) { 941 TheStructure.Common.MiInstructionType = value; 942 } 943 inline MI_INSTRUCTION_TYPE getMiInstructionType() const { 944 return static_cast<MI_INSTRUCTION_TYPE>(TheStructure.Common.MiInstructionType); 945 } 946} MI_ARB_CHECK; 947STATIC_ASSERT(4 == sizeof(MI_ARB_CHECK)); 948 949typedef struct tagMI_ATOMIC { 950 union tagTheStructure { 951 struct tagCommon { 952 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 953 uint32_t AtomicOpcode : BITFIELD_RANGE(8, 15); 954 uint32_t ReturnDataControl : BITFIELD_RANGE(16, 16); 955 uint32_t CsStall : BITFIELD_RANGE(17, 17); 956 uint32_t InlineData : BITFIELD_RANGE(18, 18); 957 uint32_t DataSize : BITFIELD_RANGE(19, 20); 958 uint32_t Post_SyncOperation : BITFIELD_RANGE(21, 21); 959 uint32_t MemoryType : BITFIELD_RANGE(22, 22); 960 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 961 uint32_t CommandType : BITFIELD_RANGE(29, 31); 962 uint32_t Reserved_32 : BITFIELD_RANGE(0, 1); 963 uint32_t MemoryAddress : BITFIELD_RANGE(2, 31); 964 uint32_t MemoryAddressHigh : BITFIELD_RANGE(0, 15); 965 uint32_t Reserved_80 : BITFIELD_RANGE(16, 31); 966 uint32_t Operand1DataDword0; 967 uint32_t Operand2DataDword0; 968 uint32_t Operand1DataDword1; 969 uint32_t Operand2DataDword1; 970 uint32_t Operand1DataDword2; 971 uint32_t Operand2DataDword2; 972 uint32_t Operand1DataDword3; 973 uint32_t Operand2DataDword3; 974 } Common; 975 uint32_t RawData[11]; 976 } TheStructure; 977 typedef enum tagDWORD_LENGTH { 978 DWORD_LENGTH_INLINE_DATA_0 = 0x1, 979 DWORD_LENGTH_INLINE_DATA_1 = 0x9, 980 } DWORD_LENGTH; 981 typedef enum tagDATA_SIZE { 982 DATA_SIZE_DWORD = 0x0, 983 DATA_SIZE_QWORD = 0x1, 984 DATA_SIZE_OCTWORD = 0x2, 985 } DATA_SIZE; 986 typedef enum tagPOST_SYNC_OPERATION { 987 POST_SYNC_OPERATION_NO_POST_SYNC_OPERATION = 0x0, 988 POST_SYNC_OPERATION_POST_SYNC_OPERATION = 0x1, 989 } POST_SYNC_OPERATION; 990 typedef enum tagMEMORY_TYPE { 991 MEMORY_TYPE_PER_PROCESS_GRAPHICS_ADDRESS = 0x0, 992 MEMORY_TYPE_GLOBAL_GRAPHICS_ADDRESS = 0x1, 993 } MEMORY_TYPE; 994 typedef enum tagMI_COMMAND_OPCODE { 995 MI_COMMAND_OPCODE_MI_ATOMIC = 0x2f, 996 } MI_COMMAND_OPCODE; 997 typedef enum tagCOMMAND_TYPE { 998 COMMAND_TYPE_MI_COMMAND = 0x0, 999 } COMMAND_TYPE; 1000 typedef enum tagPATCH_CONSTANTS { 1001 MEMORYADDRESS_BYTEOFFSET = 0x4, 1002 MEMORYADDRESS_INDEX = 0x1, 1003 } PATCH_CONSTANTS; 1004 typedef enum tagATOMIC_OPCODES { 1005 ATOMIC_4B_MOVE = 0x4, 1006 ATOMIC_4B_INCREMENT = 0x5, 1007 ATOMIC_4B_DECREMENT = 0x6, 1008 ATOMIC_8B_MOVE = 0x24, 1009 ATOMIC_8B_INCREMENT = 0x25, 1010 ATOMIC_8B_DECREMENT = 0x26, 1011 } ATOMIC_OPCODES; 1012 inline void init() { 1013 memset(&TheStructure, 0, sizeof(TheStructure)); 1014 TheStructure.Common.DwordLength = DWORD_LENGTH_INLINE_DATA_0; 1015 TheStructure.Common.DataSize = DATA_SIZE_DWORD; 1016 TheStructure.Common.Post_SyncOperation = POST_SYNC_OPERATION_NO_POST_SYNC_OPERATION; 1017 TheStructure.Common.MemoryType = MEMORY_TYPE_PER_PROCESS_GRAPHICS_ADDRESS; 1018 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_ATOMIC; 1019 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 1020 } 1021 static tagMI_ATOMIC sInit() { 1022 MI_ATOMIC state; 1023 state.init(); 1024 return state; 1025 } 1026 inline uint32_t &getRawData(const uint32_t index) { 1027 DEBUG_BREAK_IF(index >= 11); 1028 return TheStructure.RawData[index]; 1029 } 1030 inline void setDwordLength(const DWORD_LENGTH value) { 1031 TheStructure.Common.DwordLength = value; 1032 } 1033 inline DWORD_LENGTH getDwordLength() const { 1034 return static_cast<DWORD_LENGTH>(TheStructure.Common.DwordLength); 1035 } 1036 inline void setAtomicOpcode(const uint32_t value) { 1037 TheStructure.Common.AtomicOpcode = value; 1038 } 1039 inline uint32_t getAtomicOpcode() const { 1040 return (TheStructure.Common.AtomicOpcode); 1041 } 1042 inline void setReturnDataControl(const uint32_t value) { 1043 TheStructure.Common.ReturnDataControl = value; 1044 } 1045 inline uint32_t getReturnDataControl() const { 1046 return (TheStructure.Common.ReturnDataControl); 1047 } 1048 inline void setCsStall(const uint32_t value) { 1049 TheStructure.Common.CsStall = value; 1050 } 1051 inline uint32_t getCsStall() const { 1052 return (TheStructure.Common.CsStall); 1053 } 1054 inline void setInlineData(const uint32_t value) { 1055 TheStructure.Common.InlineData = value; 1056 } 1057 inline uint32_t getInlineData() const { 1058 return (TheStructure.Common.InlineData); 1059 } 1060 inline void setDataSize(const DATA_SIZE value) { 1061 TheStructure.Common.DataSize = value; 1062 } 1063 inline DATA_SIZE getDataSize() const { 1064 return static_cast<DATA_SIZE>(TheStructure.Common.DataSize); 1065 } 1066 inline void setPostSyncOperation(const POST_SYNC_OPERATION value) { 1067 TheStructure.Common.Post_SyncOperation = value; 1068 } 1069 inline POST_SYNC_OPERATION getPostSyncOperation() const { 1070 return static_cast<POST_SYNC_OPERATION>(TheStructure.Common.Post_SyncOperation); 1071 } 1072 inline void setMemoryType(const MEMORY_TYPE value) { 1073 TheStructure.Common.MemoryType = value; 1074 } 1075 inline MEMORY_TYPE getMemoryType() const { 1076 return static_cast<MEMORY_TYPE>(TheStructure.Common.MemoryType); 1077 } 1078 typedef enum tagMEMORYADDRESS { 1079 MEMORYADDRESS_BIT_SHIFT = 0x2, 1080 MEMORYADDRESS_ALIGN_SIZE = 0x4, 1081 } MEMORYADDRESS; 1082 inline void setMemoryAddress(const uint32_t value) { 1083 TheStructure.Common.MemoryAddress = value >> MEMORYADDRESS_BIT_SHIFT; 1084 } 1085 inline uint32_t getMemoryAddress() const { 1086 return (TheStructure.Common.MemoryAddress << MEMORYADDRESS_BIT_SHIFT); 1087 } 1088 inline void setMemoryAddressHigh(const uint32_t value) { 1089 TheStructure.Common.MemoryAddressHigh = value; 1090 } 1091 inline uint32_t getMemoryAddressHigh() const { 1092 return (TheStructure.Common.MemoryAddressHigh); 1093 } 1094 inline void setOperand1DataDword0(const uint32_t value) { 1095 TheStructure.Common.Operand1DataDword0 = value; 1096 } 1097 inline uint32_t getOperand1DataDword0() const { 1098 return (TheStructure.Common.Operand1DataDword0); 1099 } 1100 inline void setOperand2DataDword0(const uint32_t value) { 1101 TheStructure.Common.Operand2DataDword0 = value; 1102 } 1103 inline uint32_t getOperand2DataDword0() const { 1104 return (TheStructure.Common.Operand2DataDword0); 1105 } 1106 inline void setOperand1DataDword1(const uint32_t value) { 1107 TheStructure.Common.Operand1DataDword1 = value; 1108 } 1109 inline uint32_t getOperand1DataDword1() const { 1110 return (TheStructure.Common.Operand1DataDword1); 1111 } 1112 inline void setOperand2DataDword1(const uint32_t value) { 1113 TheStructure.Common.Operand2DataDword1 = value; 1114 } 1115 inline uint32_t getOperand2DataDword1() const { 1116 return (TheStructure.Common.Operand2DataDword1); 1117 } 1118 inline void setOperand1DataDword2(const uint32_t value) { 1119 TheStructure.Common.Operand1DataDword2 = value; 1120 } 1121 inline uint32_t getOperand1DataDword2() const { 1122 return (TheStructure.Common.Operand1DataDword2); 1123 } 1124 inline void setOperand2DataDword2(const uint32_t value) { 1125 TheStructure.Common.Operand2DataDword2 = value; 1126 } 1127 inline uint32_t getOperand2DataDword2() const { 1128 return (TheStructure.Common.Operand2DataDword2); 1129 } 1130 inline void setOperand1DataDword3(const uint32_t value) { 1131 TheStructure.Common.Operand1DataDword3 = value; 1132 } 1133 inline uint32_t getOperand1DataDword3() const { 1134 return (TheStructure.Common.Operand1DataDword3); 1135 } 1136 inline void setOperand2DataDword3(const uint32_t value) { 1137 TheStructure.Common.Operand2DataDword3 = value; 1138 } 1139 inline uint32_t getOperand2DataDword3() const { 1140 return (TheStructure.Common.Operand2DataDword3); 1141 } 1142} MI_ATOMIC; 1143STATIC_ASSERT(44 == sizeof(MI_ATOMIC)); 1144 1145typedef struct tagMI_BATCH_BUFFER_END { 1146 union tagTheStructure { 1147 struct tagCommon { 1148 uint32_t Reserved_0 : BITFIELD_RANGE(0, 22); 1149 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 1150 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1151 } Common; 1152 uint32_t RawData[1]; 1153 } TheStructure; 1154 typedef enum tagMI_COMMAND_OPCODE { 1155 MI_COMMAND_OPCODE_MI_BATCH_BUFFER_END = 0xa, 1156 } MI_COMMAND_OPCODE; 1157 typedef enum tagCOMMAND_TYPE { 1158 COMMAND_TYPE_MI_COMMAND = 0x0, 1159 } COMMAND_TYPE; 1160 inline void init() { 1161 memset(&TheStructure, 0, sizeof(TheStructure)); 1162 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_BATCH_BUFFER_END; 1163 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 1164 } 1165 static tagMI_BATCH_BUFFER_END sInit() { 1166 MI_BATCH_BUFFER_END state; 1167 state.init(); 1168 return state; 1169 } 1170 inline uint32_t &getRawData(const uint32_t index) { 1171 DEBUG_BREAK_IF(index >= 1); 1172 return TheStructure.RawData[index]; 1173 } 1174} MI_BATCH_BUFFER_END; 1175STATIC_ASSERT(4 == sizeof(MI_BATCH_BUFFER_END)); 1176 1177typedef struct tagMI_BATCH_BUFFER_START { 1178 union tagTheStructure { 1179 struct tagCommon { 1180 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 1181 uint32_t AddressSpaceIndicator : BITFIELD_RANGE(8, 8); 1182 uint32_t Reserved_9 : BITFIELD_RANGE(9, 9); 1183 uint32_t ResourceStreamerEnable : BITFIELD_RANGE(10, 10); 1184 uint32_t Reserved_11 : BITFIELD_RANGE(11, 14); 1185 uint32_t PredicationEnable : BITFIELD_RANGE(15, 15); 1186 uint32_t AddOffsetEnable : BITFIELD_RANGE(16, 16); 1187 uint32_t Reserved_17 : BITFIELD_RANGE(17, 21); 1188 uint32_t SecondLevelBatchBuffer : BITFIELD_RANGE(22, 22); 1189 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 1190 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1191 uint64_t Reserved_32 : BITFIELD_RANGE(0, 1); 1192 uint64_t BatchBufferStartAddress_Graphicsaddress47_2 : BITFIELD_RANGE(2, 47); 1193 uint64_t BatchBufferStartAddress_Reserved : BITFIELD_RANGE(48, 63); 1194 } Common; 1195 uint32_t RawData[3]; 1196 } TheStructure; 1197 typedef enum tagDWORD_LENGTH { 1198 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x1, 1199 } DWORD_LENGTH; 1200 typedef enum tagADDRESS_SPACE_INDICATOR { 1201 ADDRESS_SPACE_INDICATOR_GGTT = 0x0, 1202 ADDRESS_SPACE_INDICATOR_PPGTT = 0x1, 1203 } ADDRESS_SPACE_INDICATOR; 1204 typedef enum tagSECOND_LEVEL_BATCH_BUFFER { 1205 SECOND_LEVEL_BATCH_BUFFER_FIRST_LEVEL_BATCH = 0x0, 1206 SECOND_LEVEL_BATCH_BUFFER_SECOND_LEVEL_BATCH = 0x1, 1207 } SECOND_LEVEL_BATCH_BUFFER; 1208 typedef enum tagMI_COMMAND_OPCODE { 1209 MI_COMMAND_OPCODE_MI_BATCH_BUFFER_START = 0x31, 1210 } MI_COMMAND_OPCODE; 1211 typedef enum tagCOMMAND_TYPE { 1212 COMMAND_TYPE_MI_COMMAND = 0x0, 1213 } COMMAND_TYPE; 1214 inline void init() { 1215 memset(&TheStructure, 0, sizeof(TheStructure)); 1216 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 1217 TheStructure.Common.AddressSpaceIndicator = ADDRESS_SPACE_INDICATOR_GGTT; 1218 TheStructure.Common.SecondLevelBatchBuffer = SECOND_LEVEL_BATCH_BUFFER_FIRST_LEVEL_BATCH; 1219 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_BATCH_BUFFER_START; 1220 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 1221 } 1222 static tagMI_BATCH_BUFFER_START sInit() { 1223 MI_BATCH_BUFFER_START state; 1224 state.init(); 1225 return state; 1226 } 1227 inline uint32_t &getRawData(const uint32_t index) { 1228 DEBUG_BREAK_IF(index >= 3); 1229 return TheStructure.RawData[index]; 1230 } 1231 inline void setAddressSpaceIndicator(const ADDRESS_SPACE_INDICATOR value) { 1232 TheStructure.Common.AddressSpaceIndicator = value; 1233 } 1234 inline ADDRESS_SPACE_INDICATOR getAddressSpaceIndicator() const { 1235 return static_cast<ADDRESS_SPACE_INDICATOR>(TheStructure.Common.AddressSpaceIndicator); 1236 } 1237 inline void setResourceStreamerEnable(const bool value) { 1238 TheStructure.Common.ResourceStreamerEnable = value; 1239 } 1240 inline bool getResourceStreamerEnable() const { 1241 return (TheStructure.Common.ResourceStreamerEnable); 1242 } 1243 inline void setPredicationEnable(const uint32_t value) { 1244 TheStructure.Common.PredicationEnable = value; 1245 } 1246 inline uint32_t getPredicationEnable() const { 1247 return (TheStructure.Common.PredicationEnable); 1248 } 1249 inline void setAddOffsetEnable(const bool value) { 1250 TheStructure.Common.AddOffsetEnable = value; 1251 } 1252 inline bool getAddOffsetEnable() const { 1253 return (TheStructure.Common.AddOffsetEnable); 1254 } 1255 inline void setSecondLevelBatchBuffer(const SECOND_LEVEL_BATCH_BUFFER value) { 1256 TheStructure.Common.SecondLevelBatchBuffer = value; 1257 } 1258 inline SECOND_LEVEL_BATCH_BUFFER getSecondLevelBatchBuffer() const { 1259 return static_cast<SECOND_LEVEL_BATCH_BUFFER>(TheStructure.Common.SecondLevelBatchBuffer); 1260 } 1261 typedef enum tagBATCHBUFFERSTARTADDRESS_GRAPHICSADDRESS47_2 { 1262 BATCHBUFFERSTARTADDRESS_GRAPHICSADDRESS47_2_BIT_SHIFT = 0x2, 1263 BATCHBUFFERSTARTADDRESS_GRAPHICSADDRESS47_2_ALIGN_SIZE = 0x4, 1264 } BATCHBUFFERSTARTADDRESS_GRAPHICSADDRESS47_2; 1265 inline void setBatchBufferStartAddress(const uint64_t value) { 1266 TheStructure.Common.BatchBufferStartAddress_Graphicsaddress47_2 = value >> BATCHBUFFERSTARTADDRESS_GRAPHICSADDRESS47_2_BIT_SHIFT; 1267 } 1268 inline uint64_t getBatchBufferStartAddress() const { 1269 return (TheStructure.Common.BatchBufferStartAddress_Graphicsaddress47_2 << BATCHBUFFERSTARTADDRESS_GRAPHICSADDRESS47_2_BIT_SHIFT); 1270 } 1271 typedef enum tagBATCHBUFFERSTARTADDRESS_RESERVED { 1272 BATCHBUFFERSTARTADDRESS_RESERVED_BIT_SHIFT = 0x2, 1273 BATCHBUFFERSTARTADDRESS_RESERVED_ALIGN_SIZE = 0x4, 1274 } BATCHBUFFERSTARTADDRESS_RESERVED; 1275 inline void setBatchBufferStartAddressReserved(const uint64_t value) { 1276 TheStructure.Common.BatchBufferStartAddress_Reserved = value >> BATCHBUFFERSTARTADDRESS_RESERVED_BIT_SHIFT; 1277 } 1278 inline uint64_t getBatchBufferStartAddressReserved() const { 1279 return (TheStructure.Common.BatchBufferStartAddress_Reserved << BATCHBUFFERSTARTADDRESS_RESERVED_BIT_SHIFT); 1280 } 1281} MI_BATCH_BUFFER_START; 1282STATIC_ASSERT(12 == sizeof(MI_BATCH_BUFFER_START)); 1283 1284typedef struct tagMI_LOAD_REGISTER_IMM { 1285 union tagTheStructure { 1286 struct tagCommon { 1287 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 1288 uint32_t ByteWriteDisables : BITFIELD_RANGE(8, 11); 1289 uint32_t Reserved_12 : BITFIELD_RANGE(12, 22); 1290 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 1291 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1292 uint32_t Reserved_32 : BITFIELD_RANGE(0, 1); 1293 uint32_t RegisterOffset : BITFIELD_RANGE(2, 22); 1294 uint32_t Reserved_55 : BITFIELD_RANGE(23, 31); 1295 uint32_t DataDword; 1296 } Common; 1297 uint32_t RawData[3]; 1298 } TheStructure; 1299 typedef enum tagDWORD_LENGTH { 1300 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x1, 1301 } DWORD_LENGTH; 1302 typedef enum tagMI_COMMAND_OPCODE { 1303 MI_COMMAND_OPCODE_MI_LOAD_REGISTER_IMM = 0x22, 1304 } MI_COMMAND_OPCODE; 1305 typedef enum tagCOMMAND_TYPE { 1306 COMMAND_TYPE_MI_COMMAND = 0x0, 1307 } COMMAND_TYPE; 1308 inline void init() { 1309 memset(&TheStructure, 0, sizeof(TheStructure)); 1310 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 1311 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_LOAD_REGISTER_IMM; 1312 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 1313 } 1314 static tagMI_LOAD_REGISTER_IMM sInit() { 1315 MI_LOAD_REGISTER_IMM state; 1316 state.init(); 1317 return state; 1318 } 1319 inline uint32_t &getRawData(const uint32_t index) { 1320 DEBUG_BREAK_IF(index >= 3); 1321 return TheStructure.RawData[index]; 1322 } 1323 inline void setByteWriteDisables(const uint32_t value) { 1324 TheStructure.Common.ByteWriteDisables = value; 1325 } 1326 inline uint32_t getByteWriteDisables() const { 1327 return (TheStructure.Common.ByteWriteDisables); 1328 } 1329 typedef enum tagREGISTEROFFSET { 1330 REGISTEROFFSET_BIT_SHIFT = 0x2, 1331 REGISTEROFFSET_ALIGN_SIZE = 0x4, 1332 } REGISTEROFFSET; 1333 inline void setRegisterOffset(const uint32_t value) { 1334 TheStructure.Common.RegisterOffset = value >> REGISTEROFFSET_BIT_SHIFT; 1335 } 1336 inline uint32_t getRegisterOffset() const { 1337 return (TheStructure.Common.RegisterOffset << REGISTEROFFSET_BIT_SHIFT); 1338 } 1339 inline void setDataDword(const uint32_t value) { 1340 TheStructure.Common.DataDword = value; 1341 } 1342 inline uint32_t getDataDword() const { 1343 return (TheStructure.Common.DataDword); 1344 } 1345} MI_LOAD_REGISTER_IMM; 1346STATIC_ASSERT(12 == sizeof(MI_LOAD_REGISTER_IMM)); 1347 1348typedef struct tagMI_LOAD_REGISTER_MEM { 1349 union tagTheStructure { 1350 struct tagCommon { 1351 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 1352 uint32_t Reserved_8 : BITFIELD_RANGE(8, 20); 1353 uint32_t AsyncModeEnable : BITFIELD_RANGE(21, 21); 1354 uint32_t UseGlobalGtt : BITFIELD_RANGE(22, 22); 1355 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 1356 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1357 uint32_t Reserved_32 : BITFIELD_RANGE(0, 1); 1358 uint32_t RegisterAddress : BITFIELD_RANGE(2, 22); 1359 uint32_t Reserved_55 : BITFIELD_RANGE(23, 31); 1360 uint64_t Reserved_64 : BITFIELD_RANGE(0, 1); 1361 uint64_t MemoryAddress : BITFIELD_RANGE(2, 63); 1362 } Common; 1363 uint32_t RawData[4]; 1364 } TheStructure; 1365 typedef enum tagDWORD_LENGTH { 1366 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x2, 1367 } DWORD_LENGTH; 1368 typedef enum tagMI_COMMAND_OPCODE { 1369 MI_COMMAND_OPCODE_MI_LOAD_REGISTER_MEM = 0x29, 1370 } MI_COMMAND_OPCODE; 1371 typedef enum tagCOMMAND_TYPE { 1372 COMMAND_TYPE_MI_COMMAND = 0x0, 1373 } COMMAND_TYPE; 1374 typedef enum tagPATCH_CONSTANTS { 1375 MEMORYADDRESS_BYTEOFFSET = 0x8, 1376 MEMORYADDRESS_INDEX = 0x2, 1377 } PATCH_CONSTANTS; 1378 inline void init() { 1379 memset(&TheStructure, 0, sizeof(TheStructure)); 1380 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 1381 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_LOAD_REGISTER_MEM; 1382 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 1383 } 1384 static tagMI_LOAD_REGISTER_MEM sInit() { 1385 MI_LOAD_REGISTER_MEM state; 1386 state.init(); 1387 return state; 1388 } 1389 inline uint32_t &getRawData(const uint32_t index) { 1390 DEBUG_BREAK_IF(index >= 4); 1391 return TheStructure.RawData[index]; 1392 } 1393 inline void setAsyncModeEnable(const bool value) { 1394 TheStructure.Common.AsyncModeEnable = value; 1395 } 1396 inline bool getAsyncModeEnable() const { 1397 return (TheStructure.Common.AsyncModeEnable); 1398 } 1399 inline void setUseGlobalGtt(const bool value) { 1400 TheStructure.Common.UseGlobalGtt = value; 1401 } 1402 inline bool getUseGlobalGtt() const { 1403 return (TheStructure.Common.UseGlobalGtt); 1404 } 1405 typedef enum tagREGISTERADDRESS { 1406 REGISTERADDRESS_BIT_SHIFT = 0x2, 1407 REGISTERADDRESS_ALIGN_SIZE = 0x4, 1408 } REGISTERADDRESS; 1409 inline void setRegisterAddress(const uint32_t value) { 1410 TheStructure.Common.RegisterAddress = value >> REGISTERADDRESS_BIT_SHIFT; 1411 } 1412 inline uint32_t getRegisterAddress() const { 1413 return (TheStructure.Common.RegisterAddress << REGISTERADDRESS_BIT_SHIFT); 1414 } 1415 typedef enum tagMEMORYADDRESS { 1416 MEMORYADDRESS_BIT_SHIFT = 0x2, 1417 MEMORYADDRESS_ALIGN_SIZE = 0x4, 1418 } MEMORYADDRESS; 1419 inline void setMemoryAddress(const uint64_t value) { 1420 TheStructure.Common.MemoryAddress = value >> MEMORYADDRESS_BIT_SHIFT; 1421 } 1422 inline uint64_t getMemoryAddress() const { 1423 return (TheStructure.Common.MemoryAddress << MEMORYADDRESS_BIT_SHIFT); 1424 } 1425} MI_LOAD_REGISTER_MEM; 1426STATIC_ASSERT(16 == sizeof(MI_LOAD_REGISTER_MEM)); 1427 1428typedef struct tagMI_LOAD_REGISTER_REG { 1429 union tagTheStructure { 1430 struct tagCommon { 1431 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 1432 uint32_t Reserved_8 : BITFIELD_RANGE(8, 22); 1433 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 1434 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1435 uint32_t Reserved_32 : BITFIELD_RANGE(0, 1); 1436 uint32_t SourceRegisterAddress : BITFIELD_RANGE(2, 22); 1437 uint32_t Reserved_55 : BITFIELD_RANGE(23, 31); 1438 uint32_t Reserved_64 : BITFIELD_RANGE(0, 1); 1439 uint32_t DestinationRegisterAddress : BITFIELD_RANGE(2, 22); 1440 uint32_t Reserved_87 : BITFIELD_RANGE(23, 31); 1441 } Common; 1442 uint32_t RawData[3]; 1443 } TheStructure; 1444 typedef enum tagDWORD_LENGTH { 1445 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x1, 1446 } DWORD_LENGTH; 1447 typedef enum tagMI_COMMAND_OPCODE { 1448 MI_COMMAND_OPCODE_MI_LOAD_REGISTER_REG = 0x2a, 1449 } MI_COMMAND_OPCODE; 1450 typedef enum tagCOMMAND_TYPE { 1451 COMMAND_TYPE_MI_COMMAND = 0x0, 1452 } COMMAND_TYPE; 1453 inline void init() { 1454 memset(&TheStructure, 0, sizeof(TheStructure)); 1455 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 1456 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_LOAD_REGISTER_REG; 1457 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 1458 } 1459 static tagMI_LOAD_REGISTER_REG sInit() { 1460 MI_LOAD_REGISTER_REG state; 1461 state.init(); 1462 return state; 1463 } 1464 inline uint32_t &getRawData(const uint32_t index) { 1465 DEBUG_BREAK_IF(index >= 3); 1466 return TheStructure.RawData[index]; 1467 } 1468 typedef enum tagSOURCEREGISTERADDRESS { 1469 SOURCEREGISTERADDRESS_BIT_SHIFT = 0x2, 1470 SOURCEREGISTERADDRESS_ALIGN_SIZE = 0x4, 1471 } SOURCEREGISTERADDRESS; 1472 inline void setSourceRegisterAddress(const uint32_t value) { 1473 TheStructure.Common.SourceRegisterAddress = value >> SOURCEREGISTERADDRESS_BIT_SHIFT; 1474 } 1475 inline uint32_t getSourceRegisterAddress() const { 1476 return (TheStructure.Common.SourceRegisterAddress << SOURCEREGISTERADDRESS_BIT_SHIFT); 1477 } 1478 typedef enum tagDESTINATIONREGISTERADDRESS { 1479 DESTINATIONREGISTERADDRESS_BIT_SHIFT = 0x2, 1480 DESTINATIONREGISTERADDRESS_ALIGN_SIZE = 0x4, 1481 } DESTINATIONREGISTERADDRESS; 1482 inline void setDestinationRegisterAddress(const uint32_t value) { 1483 TheStructure.Common.DestinationRegisterAddress = value >> DESTINATIONREGISTERADDRESS_BIT_SHIFT; 1484 } 1485 inline uint32_t getDestinationRegisterAddress() const { 1486 return (TheStructure.Common.DestinationRegisterAddress << DESTINATIONREGISTERADDRESS_BIT_SHIFT); 1487 } 1488} MI_LOAD_REGISTER_REG; 1489STATIC_ASSERT(12 == sizeof(MI_LOAD_REGISTER_REG)); 1490 1491typedef struct tagMI_NOOP { 1492 union tagTheStructure { 1493 struct tagCommon { 1494 uint32_t IdentificationNumber : BITFIELD_RANGE(0, 21); 1495 uint32_t IdentificationNumberRegisterWriteEnable : BITFIELD_RANGE(22, 22); 1496 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 1497 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1498 } Common; 1499 uint32_t RawData[1]; 1500 } TheStructure; 1501 typedef enum tagMI_COMMAND_OPCODE { 1502 MI_COMMAND_OPCODE_MI_NOOP = 0x0, 1503 } MI_COMMAND_OPCODE; 1504 typedef enum tagCOMMAND_TYPE { 1505 COMMAND_TYPE_MI_COMMAND = 0x0, 1506 } COMMAND_TYPE; 1507 inline void init() { 1508 memset(&TheStructure, 0, sizeof(TheStructure)); 1509 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_NOOP; 1510 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 1511 } 1512 static tagMI_NOOP sInit() { 1513 MI_NOOP state; 1514 state.init(); 1515 return state; 1516 } 1517 inline uint32_t &getRawData(const uint32_t index) { 1518 DEBUG_BREAK_IF(index >= 1); 1519 return TheStructure.RawData[index]; 1520 } 1521 inline void setIdentificationNumber(const uint32_t value) { 1522 TheStructure.Common.IdentificationNumber = value; 1523 } 1524 inline uint32_t getIdentificationNumber() const { 1525 return (TheStructure.Common.IdentificationNumber); 1526 } 1527 inline void setIdentificationNumberRegisterWriteEnable(const bool value) { 1528 TheStructure.Common.IdentificationNumberRegisterWriteEnable = value; 1529 } 1530 inline bool getIdentificationNumberRegisterWriteEnable() const { 1531 return (TheStructure.Common.IdentificationNumberRegisterWriteEnable); 1532 } 1533} MI_NOOP; 1534STATIC_ASSERT(4 == sizeof(MI_NOOP)); 1535 1536typedef struct tagMI_STORE_REGISTER_MEM { 1537 union tagTheStructure { 1538 struct tagCommon { 1539 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 1540 uint32_t Reserved_8 : BITFIELD_RANGE(8, 20); 1541 uint32_t PredicateEnable : BITFIELD_RANGE(21, 21); 1542 uint32_t UseGlobalGtt : BITFIELD_RANGE(22, 22); 1543 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 1544 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1545 uint32_t Reserved_32 : BITFIELD_RANGE(0, 1); 1546 uint32_t RegisterAddress : BITFIELD_RANGE(2, 22); 1547 uint32_t Reserved_55 : BITFIELD_RANGE(23, 31); 1548 uint64_t Reserved_64 : BITFIELD_RANGE(0, 1); 1549 uint64_t MemoryAddress : BITFIELD_RANGE(2, 63); 1550 } Common; 1551 uint32_t RawData[4]; 1552 } TheStructure; 1553 typedef enum tagDWORD_LENGTH { 1554 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x2, 1555 } DWORD_LENGTH; 1556 typedef enum tagMI_COMMAND_OPCODE { 1557 MI_COMMAND_OPCODE_MI_STORE_REGISTER_MEM = 0x24, 1558 } MI_COMMAND_OPCODE; 1559 typedef enum tagCOMMAND_TYPE { 1560 COMMAND_TYPE_MI_COMMAND = 0x0, 1561 } COMMAND_TYPE; 1562 typedef enum tagPATCH_CONSTANTS { 1563 MEMORYADDRESS_BYTEOFFSET = 0x8, 1564 MEMORYADDRESS_INDEX = 0x2, 1565 } PATCH_CONSTANTS; 1566 inline void init() { 1567 memset(&TheStructure, 0, sizeof(TheStructure)); 1568 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 1569 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_STORE_REGISTER_MEM; 1570 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 1571 } 1572 static tagMI_STORE_REGISTER_MEM sInit() { 1573 MI_STORE_REGISTER_MEM state; 1574 state.init(); 1575 return state; 1576 } 1577 inline uint32_t &getRawData(const uint32_t index) { 1578 DEBUG_BREAK_IF(index >= 4); 1579 return TheStructure.RawData[index]; 1580 } 1581 inline void setPredicateEnable(const uint32_t value) { 1582 TheStructure.Common.PredicateEnable = value; 1583 } 1584 inline uint32_t getPredicateEnable() const { 1585 return (TheStructure.Common.PredicateEnable); 1586 } 1587 inline void setUseGlobalGtt(const bool value) { 1588 TheStructure.Common.UseGlobalGtt = value; 1589 } 1590 inline bool getUseGlobalGtt() const { 1591 return (TheStructure.Common.UseGlobalGtt); 1592 } 1593 typedef enum tagREGISTERADDRESS { 1594 REGISTERADDRESS_BIT_SHIFT = 0x2, 1595 REGISTERADDRESS_ALIGN_SIZE = 0x4, 1596 } REGISTERADDRESS; 1597 inline void setRegisterAddress(const uint32_t value) { 1598 TheStructure.Common.RegisterAddress = value >> REGISTERADDRESS_BIT_SHIFT; 1599 } 1600 inline uint32_t getRegisterAddress() const { 1601 return (TheStructure.Common.RegisterAddress << REGISTERADDRESS_BIT_SHIFT); 1602 } 1603 typedef enum tagMEMORYADDRESS { 1604 MEMORYADDRESS_BIT_SHIFT = 0x2, 1605 MEMORYADDRESS_ALIGN_SIZE = 0x4, 1606 } MEMORYADDRESS; 1607 inline void setMemoryAddress(const uint64_t value) { 1608 TheStructure.Common.MemoryAddress = value >> MEMORYADDRESS_BIT_SHIFT; 1609 } 1610 inline uint64_t getMemoryAddress() const { 1611 return (TheStructure.Common.MemoryAddress << MEMORYADDRESS_BIT_SHIFT); 1612 } 1613} MI_STORE_REGISTER_MEM; 1614STATIC_ASSERT(16 == sizeof(MI_STORE_REGISTER_MEM)); 1615 1616typedef struct tagPIPELINE_SELECT { 1617 union tagTheStructure { 1618 struct tagCommon { 1619 uint32_t PipelineSelection : BITFIELD_RANGE(0, 1); 1620 uint32_t RenderSliceCommonPowerGateEnable : BITFIELD_RANGE(2, 2); 1621 uint32_t RenderSamplerPowerGateEnable : BITFIELD_RANGE(3, 3); 1622 uint32_t MediaSamplerDopClockGateEnable : BITFIELD_RANGE(4, 4); 1623 uint32_t ForceMediaAwake : BITFIELD_RANGE(5, 5); 1624 uint32_t Reserved_6 : BITFIELD_RANGE(6, 7); 1625 uint32_t MaskBits : BITFIELD_RANGE(8, 15); 1626 uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23); 1627 uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26); 1628 uint32_t CommandSubtype : BITFIELD_RANGE(27, 28); 1629 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1630 } Common; 1631 uint32_t RawData[1]; 1632 } TheStructure; 1633 typedef enum tagPIPELINE_SELECTION { 1634 PIPELINE_SELECTION_3D = 0x0, 1635 PIPELINE_SELECTION_MEDIA = 0x1, 1636 PIPELINE_SELECTION_GPGPU = 0x2, 1637 } PIPELINE_SELECTION; 1638 typedef enum tag_3D_COMMAND_SUB_OPCODE { 1639 _3D_COMMAND_SUB_OPCODE_PIPELINE_SELECT = 0x4, 1640 } _3D_COMMAND_SUB_OPCODE; 1641 typedef enum tag_3D_COMMAND_OPCODE { 1642 _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED = 0x1, 1643 } _3D_COMMAND_OPCODE; 1644 typedef enum tagCOMMAND_SUBTYPE { 1645 COMMAND_SUBTYPE_GFXPIPE_SINGLE_DW = 0x1, 1646 } COMMAND_SUBTYPE; 1647 typedef enum tagCOMMAND_TYPE { 1648 COMMAND_TYPE_GFXPIPE = 0x3, 1649 } COMMAND_TYPE; 1650 inline void init() { 1651 memset(&TheStructure, 0, sizeof(TheStructure)); 1652 TheStructure.Common.PipelineSelection = PIPELINE_SELECTION_3D; 1653 TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_PIPELINE_SELECT; 1654 TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED; 1655 TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_SINGLE_DW; 1656 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 1657 } 1658 static tagPIPELINE_SELECT sInit() { 1659 PIPELINE_SELECT state; 1660 state.init(); 1661 return state; 1662 } 1663 inline uint32_t &getRawData(const uint32_t index) { 1664 DEBUG_BREAK_IF(index >= 1); 1665 return TheStructure.RawData[index]; 1666 } 1667 inline void setPipelineSelection(const PIPELINE_SELECTION value) { 1668 TheStructure.Common.PipelineSelection = value; 1669 } 1670 inline PIPELINE_SELECTION getPipelineSelection() const { 1671 return static_cast<PIPELINE_SELECTION>(TheStructure.Common.PipelineSelection); 1672 } 1673 inline void setRenderSliceCommonPowerGateEnable(const bool value) { 1674 TheStructure.Common.RenderSliceCommonPowerGateEnable = value; 1675 } 1676 inline bool getRenderSliceCommonPowerGateEnable() const { 1677 return (TheStructure.Common.RenderSliceCommonPowerGateEnable); 1678 } 1679 inline void setRenderSamplerPowerGateEnable(const bool value) { 1680 TheStructure.Common.RenderSamplerPowerGateEnable = value; 1681 } 1682 inline bool getRenderSamplerPowerGateEnable() const { 1683 return (TheStructure.Common.RenderSamplerPowerGateEnable); 1684 } 1685 inline void setMediaSamplerDopClockGateEnable(const bool value) { 1686 TheStructure.Common.MediaSamplerDopClockGateEnable = value; 1687 } 1688 inline bool getMediaSamplerDopClockGateEnable() const { 1689 return (TheStructure.Common.MediaSamplerDopClockGateEnable); 1690 } 1691 inline void setForceMediaAwake(const bool value) { 1692 TheStructure.Common.ForceMediaAwake = value; 1693 } 1694 inline bool getForceMediaAwake() const { 1695 return (TheStructure.Common.ForceMediaAwake); 1696 } 1697 inline void setMaskBits(const uint32_t value) { 1698 TheStructure.Common.MaskBits = value; 1699 } 1700 inline uint32_t getMaskBits() const { 1701 return (TheStructure.Common.MaskBits); 1702 } 1703} PIPELINE_SELECT; 1704STATIC_ASSERT(4 == sizeof(PIPELINE_SELECT)); 1705 1706typedef struct tagPIPE_CONTROL { 1707 union tagTheStructure { 1708 struct tagCommon { 1709 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 1710 uint32_t Reserved_8 : BITFIELD_RANGE(8, 15); 1711 uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23); 1712 uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26); 1713 uint32_t CommandSubtype : BITFIELD_RANGE(27, 28); 1714 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1715 uint32_t DepthCacheFlushEnable : BITFIELD_RANGE(0, 0); 1716 uint32_t StallAtPixelScoreboard : BITFIELD_RANGE(1, 1); 1717 uint32_t StateCacheInvalidationEnable : BITFIELD_RANGE(2, 2); 1718 uint32_t ConstantCacheInvalidationEnable : BITFIELD_RANGE(3, 3); 1719 uint32_t VfCacheInvalidationEnable : BITFIELD_RANGE(4, 4); 1720 uint32_t DcFlushEnable : BITFIELD_RANGE(5, 5); 1721 uint32_t ProtectedMemoryApplicationId : BITFIELD_RANGE(6, 6); 1722 uint32_t PipeControlFlushEnable : BITFIELD_RANGE(7, 7); 1723 uint32_t NotifyEnable : BITFIELD_RANGE(8, 8); 1724 uint32_t IndirectStatePointersDisable : BITFIELD_RANGE(9, 9); 1725 uint32_t TextureCacheInvalidationEnable : BITFIELD_RANGE(10, 10); 1726 uint32_t InstructionCacheInvalidateEnable : BITFIELD_RANGE(11, 11); 1727 uint32_t RenderTargetCacheFlushEnable : BITFIELD_RANGE(12, 12); 1728 uint32_t DepthStallEnable : BITFIELD_RANGE(13, 13); 1729 uint32_t PostSyncOperation : BITFIELD_RANGE(14, 15); 1730 uint32_t GenericMediaStateClear : BITFIELD_RANGE(16, 16); 1731 uint32_t Reserved_49 : BITFIELD_RANGE(17, 17); 1732 uint32_t TlbInvalidate : BITFIELD_RANGE(18, 18); 1733 uint32_t GlobalSnapshotCountReset : BITFIELD_RANGE(19, 19); 1734 uint32_t CommandStreamerStallEnable : BITFIELD_RANGE(20, 20); 1735 uint32_t StoreDataIndex : BITFIELD_RANGE(21, 21); 1736 uint32_t Reserved_54 : BITFIELD_RANGE(22, 22); 1737 uint32_t LriPostSyncOperation : BITFIELD_RANGE(23, 23); 1738 uint32_t DestinationAddressType : BITFIELD_RANGE(24, 24); 1739 uint32_t Reserved_57 : BITFIELD_RANGE(25, 25); 1740 uint32_t FlushLlc : BITFIELD_RANGE(26, 26); 1741 uint32_t ProtectedMemoryDisable : BITFIELD_RANGE(27, 27); 1742 uint32_t Reserved_60 : BITFIELD_RANGE(28, 31); 1743 uint32_t Reserved_64 : BITFIELD_RANGE(0, 1); 1744 uint32_t Address : BITFIELD_RANGE(2, 31); 1745 uint32_t AddressHigh; 1746 uint64_t ImmediateData; 1747 } Common; 1748 uint32_t RawData[6]; 1749 } TheStructure; 1750 typedef enum tagDWORD_LENGTH { 1751 DWORD_LENGTH_DWORD_COUNT_N = 0x4, 1752 } DWORD_LENGTH; 1753 typedef enum tag_3D_COMMAND_SUB_OPCODE { 1754 _3D_COMMAND_SUB_OPCODE_PIPE_CONTROL = 0x0, 1755 } _3D_COMMAND_SUB_OPCODE; 1756 typedef enum tag_3D_COMMAND_OPCODE { 1757 _3D_COMMAND_OPCODE_PIPE_CONTROL = 0x2, 1758 } _3D_COMMAND_OPCODE; 1759 typedef enum tagCOMMAND_SUBTYPE { 1760 COMMAND_SUBTYPE_GFXPIPE_3D = 0x3, 1761 } COMMAND_SUBTYPE; 1762 typedef enum tagCOMMAND_TYPE { 1763 COMMAND_TYPE_GFXPIPE = 0x3, 1764 } COMMAND_TYPE; 1765 typedef enum tagPOST_SYNC_OPERATION { 1766 POST_SYNC_OPERATION_NO_WRITE = 0x0, 1767 POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA = 0x1, 1768 POST_SYNC_OPERATION_WRITE_PS_DEPTH_COUNT = 0x2, 1769 POST_SYNC_OPERATION_WRITE_TIMESTAMP = 0x3, 1770 } POST_SYNC_OPERATION; 1771 typedef enum tagGLOBAL_SNAPSHOT_COUNT_RESET { 1772 GLOBAL_SNAPSHOT_COUNT_RESET_DON_T_RESET = 0x0, 1773 GLOBAL_SNAPSHOT_COUNT_RESET_RESET = 0x1, 1774 } GLOBAL_SNAPSHOT_COUNT_RESET; 1775 typedef enum tagLRI_POST_SYNC_OPERATION { 1776 LRI_POST_SYNC_OPERATION_NO_LRI_OPERATION = 0x0, 1777 LRI_POST_SYNC_OPERATION_MMIO_WRITE_IMMEDIATE_DATA = 0x1, 1778 } LRI_POST_SYNC_OPERATION; 1779 typedef enum tagDESTINATION_ADDRESS_TYPE { 1780 DESTINATION_ADDRESS_TYPE_PPGTT = 0x0, 1781 DESTINATION_ADDRESS_TYPE_GGTT = 0x1, 1782 } DESTINATION_ADDRESS_TYPE; 1783 typedef enum tagPATCH_CONSTANTS { 1784 ADDRESS_BYTEOFFSET = 0x8, 1785 ADDRESS_INDEX = 0x2, 1786 ADDRESSHIGH_BYTEOFFSET = 0xc, 1787 ADDRESSHIGH_INDEX = 0x3, 1788 } PATCH_CONSTANTS; 1789 inline void init() { 1790 memset(&TheStructure, 0, sizeof(TheStructure)); 1791 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 1792 TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_PIPE_CONTROL; 1793 TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_PIPE_CONTROL; 1794 TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_3D; 1795 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 1796 TheStructure.Common.PostSyncOperation = POST_SYNC_OPERATION_NO_WRITE; 1797 TheStructure.Common.GlobalSnapshotCountReset = GLOBAL_SNAPSHOT_COUNT_RESET_DON_T_RESET; 1798 TheStructure.Common.LriPostSyncOperation = LRI_POST_SYNC_OPERATION_NO_LRI_OPERATION; 1799 TheStructure.Common.DestinationAddressType = DESTINATION_ADDRESS_TYPE_PPGTT; 1800 } 1801 static tagPIPE_CONTROL sInit() { 1802 PIPE_CONTROL state; 1803 state.init(); 1804 return state; 1805 } 1806 inline uint32_t &getRawData(const uint32_t index) { 1807 DEBUG_BREAK_IF(index >= 6); 1808 return TheStructure.RawData[index]; 1809 } 1810 inline void setDepthCacheFlushEnable(const bool value) { 1811 TheStructure.Common.DepthCacheFlushEnable = value; 1812 } 1813 inline bool getDepthCacheFlushEnable() const { 1814 return (TheStructure.Common.DepthCacheFlushEnable); 1815 } 1816 inline void setStallAtPixelScoreboard(const bool value) { 1817 TheStructure.Common.StallAtPixelScoreboard = value; 1818 } 1819 inline bool getStallAtPixelScoreboard() const { 1820 return (TheStructure.Common.StallAtPixelScoreboard); 1821 } 1822 inline void setStateCacheInvalidationEnable(const bool value) { 1823 TheStructure.Common.StateCacheInvalidationEnable = value; 1824 } 1825 inline bool getStateCacheInvalidationEnable() const { 1826 return (TheStructure.Common.StateCacheInvalidationEnable); 1827 } 1828 inline void setConstantCacheInvalidationEnable(const bool value) { 1829 TheStructure.Common.ConstantCacheInvalidationEnable = value; 1830 } 1831 inline bool getConstantCacheInvalidationEnable() const { 1832 return (TheStructure.Common.ConstantCacheInvalidationEnable); 1833 } 1834 inline void setVfCacheInvalidationEnable(const bool value) { 1835 TheStructure.Common.VfCacheInvalidationEnable = value; 1836 } 1837 inline bool getVfCacheInvalidationEnable() const { 1838 return (TheStructure.Common.VfCacheInvalidationEnable); 1839 } 1840 inline void setDcFlushEnable(const bool value) { 1841 TheStructure.Common.DcFlushEnable = value; 1842 } 1843 inline bool getDcFlushEnable() const { 1844 return (TheStructure.Common.DcFlushEnable); 1845 } 1846 inline void setProtectedMemoryApplicationId(const uint32_t value) { 1847 TheStructure.Common.ProtectedMemoryApplicationId = value; 1848 } 1849 inline uint32_t getProtectedMemoryApplicationId() const { 1850 return (TheStructure.Common.ProtectedMemoryApplicationId); 1851 } 1852 inline void setPipeControlFlushEnable(const bool value) { 1853 TheStructure.Common.PipeControlFlushEnable = value; 1854 } 1855 inline bool getPipeControlFlushEnable() const { 1856 return (TheStructure.Common.PipeControlFlushEnable); 1857 } 1858 inline void setNotifyEnable(const bool value) { 1859 TheStructure.Common.NotifyEnable = value; 1860 } 1861 inline bool getNotifyEnable() const { 1862 return (TheStructure.Common.NotifyEnable); 1863 } 1864 inline void setIndirectStatePointersDisable(const bool value) { 1865 TheStructure.Common.IndirectStatePointersDisable = value; 1866 } 1867 inline bool getIndirectStatePointersDisable() const { 1868 return (TheStructure.Common.IndirectStatePointersDisable); 1869 } 1870 inline void setTextureCacheInvalidationEnable(const bool value) { 1871 TheStructure.Common.TextureCacheInvalidationEnable = value; 1872 } 1873 inline bool getTextureCacheInvalidationEnable() const { 1874 return (TheStructure.Common.TextureCacheInvalidationEnable); 1875 } 1876 inline void setInstructionCacheInvalidateEnable(const bool value) { 1877 TheStructure.Common.InstructionCacheInvalidateEnable = value; 1878 } 1879 inline bool getInstructionCacheInvalidateEnable() const { 1880 return (TheStructure.Common.InstructionCacheInvalidateEnable); 1881 } 1882 inline void setRenderTargetCacheFlushEnable(const bool value) { 1883 TheStructure.Common.RenderTargetCacheFlushEnable = value; 1884 } 1885 inline bool getRenderTargetCacheFlushEnable() const { 1886 return (TheStructure.Common.RenderTargetCacheFlushEnable); 1887 } 1888 inline void setDepthStallEnable(const bool value) { 1889 TheStructure.Common.DepthStallEnable = value; 1890 } 1891 inline bool getDepthStallEnable() const { 1892 return (TheStructure.Common.DepthStallEnable); 1893 } 1894 inline void setPostSyncOperation(const POST_SYNC_OPERATION value) { 1895 TheStructure.Common.PostSyncOperation = value; 1896 } 1897 inline POST_SYNC_OPERATION getPostSyncOperation() const { 1898 return static_cast<POST_SYNC_OPERATION>(TheStructure.Common.PostSyncOperation); 1899 } 1900 inline void setGenericMediaStateClear(const bool value) { 1901 TheStructure.Common.GenericMediaStateClear = value; 1902 } 1903 inline bool getGenericMediaStateClear() const { 1904 return (TheStructure.Common.GenericMediaStateClear); 1905 } 1906 inline void setTlbInvalidate(const uint32_t value) { 1907 TheStructure.Common.TlbInvalidate = value; 1908 } 1909 inline uint32_t getTlbInvalidate() const { 1910 return (TheStructure.Common.TlbInvalidate); 1911 } 1912 inline void setGlobalSnapshotCountReset(const GLOBAL_SNAPSHOT_COUNT_RESET value) { 1913 TheStructure.Common.GlobalSnapshotCountReset = value; 1914 } 1915 inline GLOBAL_SNAPSHOT_COUNT_RESET getGlobalSnapshotCountReset() const { 1916 return static_cast<GLOBAL_SNAPSHOT_COUNT_RESET>(TheStructure.Common.GlobalSnapshotCountReset); 1917 } 1918 inline void setCommandStreamerStallEnable(const uint32_t value) { 1919 TheStructure.Common.CommandStreamerStallEnable = value; 1920 } 1921 inline uint32_t getCommandStreamerStallEnable() const { 1922 return (TheStructure.Common.CommandStreamerStallEnable); 1923 } 1924 inline void setStoreDataIndex(const uint32_t value) { 1925 TheStructure.Common.StoreDataIndex = value; 1926 } 1927 inline uint32_t getStoreDataIndex() const { 1928 return (TheStructure.Common.StoreDataIndex); 1929 } 1930 inline void setLriPostSyncOperation(const LRI_POST_SYNC_OPERATION value) { 1931 TheStructure.Common.LriPostSyncOperation = value; 1932 } 1933 inline LRI_POST_SYNC_OPERATION getLriPostSyncOperation() const { 1934 return static_cast<LRI_POST_SYNC_OPERATION>(TheStructure.Common.LriPostSyncOperation); 1935 } 1936 inline void setDestinationAddressType(const DESTINATION_ADDRESS_TYPE value) { 1937 TheStructure.Common.DestinationAddressType = value; 1938 } 1939 inline DESTINATION_ADDRESS_TYPE getDestinationAddressType() const { 1940 return static_cast<DESTINATION_ADDRESS_TYPE>(TheStructure.Common.DestinationAddressType); 1941 } 1942 inline void setFlushLlc(const bool value) { 1943 TheStructure.Common.FlushLlc = value; 1944 } 1945 inline bool getFlushLlc() const { 1946 return (TheStructure.Common.FlushLlc); 1947 } 1948 inline void setProtectedMemoryDisable(const uint32_t value) { 1949 TheStructure.Common.ProtectedMemoryDisable = value; 1950 } 1951 inline uint32_t getProtectedMemoryDisable() const { 1952 return (TheStructure.Common.ProtectedMemoryDisable); 1953 } 1954 typedef enum tagADDRESS { 1955 ADDRESS_BIT_SHIFT = 0x2, 1956 ADDRESS_ALIGN_SIZE = 0x4, 1957 } ADDRESS; 1958 inline void setAddress(const uint32_t value) { 1959 TheStructure.Common.Address = value >> ADDRESS_BIT_SHIFT; 1960 } 1961 inline uint32_t getAddress() const { 1962 return (TheStructure.Common.Address << ADDRESS_BIT_SHIFT); 1963 } 1964 inline void setAddressHigh(const uint32_t value) { 1965 TheStructure.Common.AddressHigh = value; 1966 } 1967 inline uint32_t getAddressHigh() const { 1968 return (TheStructure.Common.AddressHigh); 1969 } 1970 inline void setImmediateData(const uint64_t value) { 1971 TheStructure.Common.ImmediateData = value; 1972 } 1973 inline uint64_t getImmediateData() const { 1974 return (TheStructure.Common.ImmediateData); 1975 } 1976} PIPE_CONTROL; 1977STATIC_ASSERT(24 == sizeof(PIPE_CONTROL)); 1978 1979typedef struct tagRENDER_SURFACE_STATE { 1980 union tagTheStructure { 1981 struct tagCommon { 1982 uint32_t Reserved_0 : BITFIELD_RANGE(0, 5); 1983 uint32_t MediaBoundaryPixelMode : BITFIELD_RANGE(6, 7); 1984 uint32_t RenderCacheReadWriteMode : BITFIELD_RANGE(8, 8); 1985 uint32_t SamplerL2OutOfOrderModeDisable : BITFIELD_RANGE(9, 9); 1986 uint32_t VerticalLineStrideOffset : BITFIELD_RANGE(10, 10); 1987 uint32_t VerticalLineStride : BITFIELD_RANGE(11, 11); 1988 uint32_t TileMode : BITFIELD_RANGE(12, 13); 1989 uint32_t SurfaceHorizontalAlignment : BITFIELD_RANGE(14, 15); 1990 uint32_t SurfaceVerticalAlignment : BITFIELD_RANGE(16, 17); 1991 uint32_t SurfaceFormat : BITFIELD_RANGE(18, 26); 1992 uint32_t Astc_Enable : BITFIELD_RANGE(27, 27); 1993 uint32_t SurfaceArray : BITFIELD_RANGE(28, 28); 1994 uint32_t SurfaceType : BITFIELD_RANGE(29, 31); 1995 uint32_t SurfaceQpitch : BITFIELD_RANGE(0, 14); 1996 uint32_t Reserved_47 : BITFIELD_RANGE(15, 18); 1997 uint32_t BaseMipLevel : BITFIELD_RANGE(19, 23); 1998 uint32_t MemoryObjectControlState_Reserved : BITFIELD_RANGE(24, 24); 1999 uint32_t MemoryObjectControlState_IndexToMocsTables : BITFIELD_RANGE(25, 30); 2000 uint32_t Reserved_63 : BITFIELD_RANGE(31, 31); 2001 uint32_t Width : BITFIELD_RANGE(0, 13); 2002 uint32_t Reserved_78 : BITFIELD_RANGE(14, 15); 2003 uint32_t Height : BITFIELD_RANGE(16, 29); 2004 uint32_t Reserved_94 : BITFIELD_RANGE(30, 31); 2005 uint32_t SurfacePitch : BITFIELD_RANGE(0, 17); 2006 uint32_t Reserved_114 : BITFIELD_RANGE(18, 20); 2007 uint32_t Depth : BITFIELD_RANGE(21, 31); 2008 uint32_t Reserved_128; 2009 uint32_t MipCountLod : BITFIELD_RANGE(0, 3); 2010 uint32_t SurfaceMinLod : BITFIELD_RANGE(4, 7); 2011 uint32_t MipTailStartLod : BITFIELD_RANGE(8, 11); 2012 uint32_t Reserved_172 : BITFIELD_RANGE(12, 13); 2013 uint32_t CoherencyType : BITFIELD_RANGE(14, 14); 2014 uint32_t Reserved_175 : BITFIELD_RANGE(15, 17); 2015 uint32_t TiledResourceMode : BITFIELD_RANGE(18, 19); 2016 uint32_t EwaDisableForCube : BITFIELD_RANGE(20, 20); 2017 uint32_t YOffset : BITFIELD_RANGE(21, 23); 2018 uint32_t Reserved_184 : BITFIELD_RANGE(24, 24); 2019 uint32_t XOffset : BITFIELD_RANGE(25, 31); 2020 uint32_t Reserved_192; 2021 uint32_t ResourceMinLod : BITFIELD_RANGE(0, 11); 2022 uint32_t Reserved_236 : BITFIELD_RANGE(12, 15); 2023 uint32_t ShaderChannelSelectAlpha : BITFIELD_RANGE(16, 18); 2024 uint32_t ShaderChannelSelectBlue : BITFIELD_RANGE(19, 21); 2025 uint32_t ShaderChannelSelectGreen : BITFIELD_RANGE(22, 24); 2026 uint32_t ShaderChannelSelectRed : BITFIELD_RANGE(25, 27); 2027 uint32_t Reserved_252 : BITFIELD_RANGE(28, 29); 2028 uint32_t MemoryCompressionEnable : BITFIELD_RANGE(30, 30); 2029 uint32_t MemoryCompressionMode : BITFIELD_RANGE(31, 31); 2030 uint64_t SurfaceBaseAddress; 2031 uint64_t QuiltWidth : BITFIELD_RANGE(0, 4); 2032 uint64_t QuiltHeight : BITFIELD_RANGE(5, 9); 2033 uint64_t Reserved_330 : BITFIELD_RANGE(10, 63); 2034 uint32_t Reserved_384; 2035 uint32_t Reserved_416; 2036 uint32_t Reserved_448; 2037 uint32_t Reserved_480; 2038 } Common; 2039 struct tagSurfaceTypeIsnotSurftype_Cube { 2040 uint32_t Reserved_0; 2041 uint32_t Reserved_32; 2042 uint32_t Reserved_64; 2043 uint32_t Reserved_96; 2044 uint32_t Reserved_128; 2045 uint32_t Reserved_160; 2046 uint32_t Reserved_192; 2047 uint32_t Reserved_224; 2048 uint64_t Reserved_256; 2049 uint64_t Reserved_320; 2050 uint32_t Reserved_384; 2051 uint32_t Reserved_416; 2052 uint32_t Reserved_448; 2053 uint32_t Reserved_480; 2054 } SurfaceTypeIsnotSurftype_Cube; 2055 struct tagSurfaceTypeIsSurftype_Cube { 2056 uint32_t CubeFaceEnable_PositiveZ : BITFIELD_RANGE(0, 0); 2057 uint32_t CubeFaceEnable_NegativeZ : BITFIELD_RANGE(1, 1); 2058 uint32_t CubeFaceEnable_PositiveY : BITFIELD_RANGE(2, 2); 2059 uint32_t CubeFaceEnable_NegativeY : BITFIELD_RANGE(3, 3); 2060 uint32_t CubeFaceEnable_PositiveX : BITFIELD_RANGE(4, 4); 2061 uint32_t CubeFaceEnable_NegativeX : BITFIELD_RANGE(5, 5); 2062 uint32_t Reserved_6 : BITFIELD_RANGE(6, 31); 2063 uint32_t Reserved_32; 2064 uint32_t Reserved_64; 2065 uint32_t Reserved_96; 2066 uint32_t Reserved_128; 2067 uint32_t Reserved_160; 2068 uint32_t Reserved_192; 2069 uint32_t Reserved_224; 2070 uint64_t Reserved_256; 2071 uint64_t Reserved_320; 2072 uint32_t Reserved_384; 2073 uint32_t Reserved_416; 2074 uint32_t Reserved_448; 2075 uint32_t Reserved_480; 2076 } SurfaceTypeIsSurftype_Cube; 2077 struct tagSurfaceTypeIsnotSurftype_Strbuf { 2078 uint32_t Reserved_0; 2079 uint32_t Reserved_32; 2080 uint32_t Reserved_64; 2081 uint32_t Reserved_96; 2082 uint32_t MultisamplePositionPaletteIndex : BITFIELD_RANGE(0, 2); 2083 uint32_t NumberOfMultisamples : BITFIELD_RANGE(3, 5); 2084 uint32_t MultisampledSurfaceStorageFormat : BITFIELD_RANGE(6, 6); 2085 uint32_t RenderTargetViewExtent : BITFIELD_RANGE(7, 17); 2086 uint32_t MinimumArrayElement : BITFIELD_RANGE(18, 28); 2087 uint32_t RenderTargetAndSampleUnormRotation : BITFIELD_RANGE(29, 30); 2088 uint32_t Reserved_159 : BITFIELD_RANGE(31, 31); 2089 uint32_t Reserved_160; 2090 uint32_t Reserved_192; 2091 uint32_t Reserved_224; 2092 uint64_t Reserved_256; 2093 uint64_t Reserved_320; 2094 uint32_t Reserved_384; 2095 uint32_t Reserved_416; 2096 uint32_t Reserved_448; 2097 uint32_t Reserved_480; 2098 } SurfaceTypeIsnotSurftype_Strbuf; 2099 struct tagSurfaceTypeIsSurftype_Strbuf { 2100 uint32_t Reserved_0; 2101 uint32_t Reserved_32; 2102 uint32_t Reserved_64; 2103 uint32_t Reserved_96; 2104 uint32_t Reserved_128; 2105 uint32_t Reserved_160; 2106 uint32_t Reserved_192; 2107 uint32_t Reserved_224; 2108 uint64_t Reserved_256; 2109 uint64_t Reserved_320; 2110 uint32_t Reserved_384; 2111 uint32_t Reserved_416; 2112 uint32_t Reserved_448; 2113 uint32_t Reserved_480; 2114 } SurfaceTypeIsSurftype_Strbuf; 2115 struct tag_SurfaceFormatIsnotPlanar { 2116 uint32_t Reserved_0; 2117 uint32_t Reserved_32; 2118 uint32_t Reserved_64; 2119 uint32_t Reserved_96; 2120 uint32_t Reserved_128; 2121 uint32_t Reserved_160; 2122 uint32_t AuxiliarySurfaceMode : BITFIELD_RANGE(0, 2); 2123 uint32_t AuxiliarySurfacePitch : BITFIELD_RANGE(3, 11); 2124 uint32_t Reserved_204 : BITFIELD_RANGE(12, 15); 2125 uint32_t AuxiliarySurfaceQpitch : BITFIELD_RANGE(16, 30); 2126 uint32_t Reserved_223 : BITFIELD_RANGE(31, 31); 2127 uint32_t Reserved_224; 2128 uint64_t Reserved_256; 2129 uint64_t Reserved_320; 2130 uint32_t Reserved_384; 2131 uint32_t Reserved_416; 2132 uint32_t Reserved_448; 2133 uint32_t Reserved_480; 2134 } _SurfaceFormatIsnotPlanar; 2135 struct tag_SurfaceFormatIsPlanar { 2136 uint32_t Reserved_0; 2137 uint32_t Reserved_32; 2138 uint32_t Reserved_64; 2139 uint32_t Reserved_96; 2140 uint32_t Reserved_128; 2141 uint32_t Reserved_160; 2142 uint32_t YOffsetForUOrUvPlane : BITFIELD_RANGE(0, 13); 2143 uint32_t Reserved_206 : BITFIELD_RANGE(14, 15); 2144 uint32_t XOffsetForUOrUvPlane : BITFIELD_RANGE(16, 29); 2145 uint32_t Reserved_222 : BITFIELD_RANGE(30, 30); 2146 uint32_t SeparateUvPlaneEnable : BITFIELD_RANGE(31, 31); 2147 uint32_t Reserved_224; 2148 uint64_t Reserved_256; 2149 uint64_t Reserved_320 : BITFIELD_RANGE(0, 31); 2150 uint64_t YOffsetForVPlane : BITFIELD_RANGE(32, 45); 2151 uint64_t Reserved_366 : BITFIELD_RANGE(46, 47); 2152 uint64_t XOffsetForVPlane : BITFIELD_RANGE(48, 61); 2153 uint64_t Reserved_382 : BITFIELD_RANGE(62, 63); 2154 uint32_t Reserved_384; 2155 uint32_t Reserved_416; 2156 uint32_t Reserved_448; 2157 uint32_t Reserved_480; 2158 } _SurfaceFormatIsPlanar; 2159 struct tag_SurfaceFormatIsnotPlanarAndMemoryCompressionEnableIs0 { 2160 uint32_t Reserved_0; 2161 uint32_t Reserved_32; 2162 uint32_t Reserved_64; 2163 uint32_t Reserved_96; 2164 uint32_t Reserved_128; 2165 uint32_t Reserved_160; 2166 uint32_t Reserved_192; 2167 uint32_t Reserved_224; 2168 uint64_t Reserved_256; 2169 uint64_t Reserved_320 : BITFIELD_RANGE(0, 11); 2170 uint64_t AuxiliarySurfaceBaseAddress : BITFIELD_RANGE(12, 63); 2171 uint32_t Reserved_384; 2172 uint32_t Reserved_416; 2173 uint32_t Reserved_448; 2174 uint32_t Reserved_480; 2175 } _SurfaceFormatIsnotPlanarAndMemoryCompressionEnableIs0; 2176 struct tagMemoryCompressionEnableIs1 { 2177 uint32_t Reserved_0; 2178 uint32_t Reserved_32; 2179 uint32_t Reserved_64; 2180 uint32_t Reserved_96; 2181 uint32_t Reserved_128; 2182 uint32_t Reserved_160; 2183 uint32_t Reserved_192; 2184 uint32_t Reserved_224; 2185 uint64_t Reserved_256; 2186 uint64_t Reserved_320 : BITFIELD_RANGE(0, 20); 2187 uint64_t AuxiliaryTableIndexForMediaCompressedSurface : BITFIELD_RANGE(21, 31); 2188 uint64_t Reserved_352 : BITFIELD_RANGE(32, 63); 2189 uint32_t Reserved_384; 2190 uint32_t Reserved_416; 2191 uint32_t Reserved_448; 2192 uint32_t Reserved_480; 2193 } MemoryCompressionEnableIs1; 2194 struct tagAuxiliarySurfaceModeIsAux_Hiz { 2195 uint32_t Reserved_0; 2196 uint32_t Reserved_32; 2197 uint32_t Reserved_64; 2198 uint32_t Reserved_96; 2199 uint32_t Reserved_128; 2200 uint32_t Reserved_160; 2201 uint32_t Reserved_192; 2202 uint32_t Reserved_224; 2203 uint64_t Reserved_256; 2204 uint64_t Reserved_320; 2205 float HierarchicalDepthClearValue; 2206 uint32_t Reserved_416; 2207 uint32_t Reserved_448; 2208 uint32_t Reserved_480; 2209 } AuxiliarySurfaceModeIsAux_Hiz; 2210 struct tagAuxiliarySurfaceModeIsAux_Ccs_DOrAuxiliarySurfaceModeIsAux_Ccs_E { 2211 uint32_t Reserved_0; 2212 uint32_t Reserved_32; 2213 uint32_t Reserved_64; 2214 uint32_t Reserved_96; 2215 uint32_t Reserved_128; 2216 uint32_t Reserved_160; 2217 uint32_t Reserved_192; 2218 uint32_t Reserved_224; 2219 uint64_t Reserved_256; 2220 uint64_t Reserved_320; 2221 uint32_t RedClearColor; 2222 uint32_t GreenClearColor; 2223 uint32_t BlueClearColor; 2224 uint32_t AlphaClearColor; 2225 } AuxiliarySurfaceModeIsAux_Ccs_DOrAuxiliarySurfaceModeIsAux_Ccs_E; 2226 struct tag_AuxiliarySurfaceModeIsnotAux_Ccs_DAnd_AuxiliarySurfaceModeIsnotAux_Ccs_EAnd_AuxiliarySurfaceModeIsnotAux_Hiz { 2227 uint32_t Reserved_0; 2228 uint32_t Reserved_32; 2229 uint32_t Reserved_64; 2230 uint32_t Reserved_96; 2231 uint32_t Reserved_128; 2232 uint32_t Reserved_160; 2233 uint32_t Reserved_192; 2234 uint32_t Reserved_224; 2235 uint64_t Reserved_256; 2236 uint64_t Reserved_320; 2237 uint32_t Reserved_384; 2238 uint32_t Reserved_416; 2239 uint32_t Reserved_448; 2240 uint32_t Reserved_480; 2241 } _AuxiliarySurfaceModeIsnotAux_Ccs_DAnd_AuxiliarySurfaceModeIsnotAux_Ccs_EAnd_AuxiliarySurfaceModeIsnotAux_Hiz; 2242 uint32_t RawData[16]; 2243 } TheStructure; 2244 typedef enum tagMEDIA_BOUNDARY_PIXEL_MODE { 2245 MEDIA_BOUNDARY_PIXEL_MODE_NORMAL_MODE = 0x0, 2246 MEDIA_BOUNDARY_PIXEL_MODE_PROGRESSIVE_FRAME = 0x2, 2247 MEDIA_BOUNDARY_PIXEL_MODE_INTERLACED_FRAME = 0x3, 2248 } MEDIA_BOUNDARY_PIXEL_MODE; 2249 typedef enum tagRENDER_CACHE_READ_WRITE_MODE { 2250 RENDER_CACHE_READ_WRITE_MODE_WRITE_ONLY_CACHE = 0x0, 2251 RENDER_CACHE_READ_WRITE_MODE_READ_WRITE_CACHE = 0x1, 2252 } RENDER_CACHE_READ_WRITE_MODE; 2253 typedef enum tagTILE_MODE { 2254 TILE_MODE_LINEAR = 0x0, 2255 TILE_MODE_WMAJOR = 0x1, 2256 TILE_MODE_XMAJOR = 0x2, 2257 TILE_MODE_YMAJOR = 0x3, 2258 } TILE_MODE; 2259 typedef enum tagSURFACE_HORIZONTAL_ALIGNMENT { 2260 SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_4 = 0x1, 2261 SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_8 = 0x2, 2262 SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_16 = 0x3, 2263 } SURFACE_HORIZONTAL_ALIGNMENT; 2264 typedef enum tagSURFACE_VERTICAL_ALIGNMENT { 2265 SURFACE_VERTICAL_ALIGNMENT_VALIGN_4 = 0x1, 2266 SURFACE_VERTICAL_ALIGNMENT_VALIGN_8 = 0x2, 2267 SURFACE_VERTICAL_ALIGNMENT_VALIGN_16 = 0x3, 2268 } SURFACE_VERTICAL_ALIGNMENT; 2269 typedef enum tagSURFACE_FORMAT { 2270 SURFACE_FORMAT_R32G32B32A32_FLOAT = 0x0, 2271 SURFACE_FORMAT_R32G32B32A32_SINT = 0x1, 2272 SURFACE_FORMAT_R32G32B32A32_UINT = 0x2, 2273 SURFACE_FORMAT_R32G32B32A32_UNORM = 0x3, 2274 SURFACE_FORMAT_R32G32B32A32_SNORM = 0x4, 2275 SURFACE_FORMAT_R64G64_FLOAT = 0x5, 2276 SURFACE_FORMAT_R32G32B32X32_FLOAT = 0x6, 2277 SURFACE_FORMAT_R32G32B32A32_SSCALED = 0x7, 2278 SURFACE_FORMAT_R32G32B32A32_USCALED = 0x8, 2279 SURFACE_FORMAT_R32G32B32A32_SFIXED = 0x20, 2280 SURFACE_FORMAT_R64G64_PASSTHRU = 0x21, 2281 SURFACE_FORMAT_R32G32B32_FLOAT = 0x40, 2282 SURFACE_FORMAT_R32G32B32_SINT = 0x41, 2283 SURFACE_FORMAT_R32G32B32_UINT = 0x42, 2284 SURFACE_FORMAT_R32G32B32_UNORM = 0x43, 2285 SURFACE_FORMAT_R32G32B32_SNORM = 0x44, 2286 SURFACE_FORMAT_R32G32B32_SSCALED = 0x45, 2287 SURFACE_FORMAT_R32G32B32_USCALED = 0x46, 2288 SURFACE_FORMAT_R32G32B32_SFIXED = 0x50, 2289 SURFACE_FORMAT_R16G16B16A16_UNORM = 0x80, 2290 SURFACE_FORMAT_R16G16B16A16_SNORM = 0x81, 2291 SURFACE_FORMAT_R16G16B16A16_SINT = 0x82, 2292 SURFACE_FORMAT_R16G16B16A16_UINT = 0x83, 2293 SURFACE_FORMAT_R16G16B16A16_FLOAT = 0x84, 2294 SURFACE_FORMAT_R32G32_FLOAT = 0x85, 2295 SURFACE_FORMAT_R32G32_SINT = 0x86, 2296 SURFACE_FORMAT_R32G32_UINT = 0x87, 2297 SURFACE_FORMAT_R32_FLOAT_X8X24_TYPELESS = 0x88, 2298 SURFACE_FORMAT_X32_TYPELESS_G8X24_UINT = 0x89, 2299 SURFACE_FORMAT_L32A32_FLOAT = 0x8a, 2300 SURFACE_FORMAT_R32G32_UNORM = 0x8b, 2301 SURFACE_FORMAT_R32G32_SNORM = 0x8c, 2302 SURFACE_FORMAT_R64_FLOAT = 0x8d, 2303 SURFACE_FORMAT_R16G16B16X16_UNORM = 0x8e, 2304 SURFACE_FORMAT_R16G16B16X16_FLOAT = 0x8f, 2305 SURFACE_FORMAT_A32X32_FLOAT = 0x90, 2306 SURFACE_FORMAT_L32X32_FLOAT = 0x91, 2307 SURFACE_FORMAT_I32X32_FLOAT = 0x92, 2308 SURFACE_FORMAT_R16G16B16A16_SSCALED = 0x93, 2309 SURFACE_FORMAT_R16G16B16A16_USCALED = 0x94, 2310 SURFACE_FORMAT_R32G32_SSCALED = 0x95, 2311 SURFACE_FORMAT_R32G32_USCALED = 0x96, 2312 SURFACE_FORMAT_R32G32_SFIXED = 0xa0, 2313 SURFACE_FORMAT_R64_PASSTHRU = 0xa1, 2314 SURFACE_FORMAT_B8G8R8A8_UNORM = 0xc0, 2315 SURFACE_FORMAT_B8G8R8A8_UNORM_SRGB = 0xc1, 2316 SURFACE_FORMAT_R10G10B10A2_UNORM = 0xc2, 2317 SURFACE_FORMAT_R10G10B10A2_UNORM_SRGB = 0xc3, 2318 SURFACE_FORMAT_R10G10B10A2_UINT = 0xc4, 2319 SURFACE_FORMAT_R10G10B10_SNORM_A2_UNORM = 0xc5, 2320 SURFACE_FORMAT_R8G8B8A8_UNORM = 0xc7, 2321 SURFACE_FORMAT_R8G8B8A8_UNORM_SRGB = 0xc8, 2322 SURFACE_FORMAT_R8G8B8A8_SNORM = 0xc9, 2323 SURFACE_FORMAT_R8G8B8A8_SINT = 0xca, 2324 SURFACE_FORMAT_R8G8B8A8_UINT = 0xcb, 2325 SURFACE_FORMAT_R16G16_UNORM = 0xcc, 2326 SURFACE_FORMAT_R16G16_SNORM = 0xcd, 2327 SURFACE_FORMAT_R16G16_SINT = 0xce, 2328 SURFACE_FORMAT_R16G16_UINT = 0xcf, 2329 SURFACE_FORMAT_R16G16_FLOAT = 0xd0, 2330 SURFACE_FORMAT_B10G10R10A2_UNORM = 0xd1, 2331 SURFACE_FORMAT_B10G10R10A2_UNORM_SRGB = 0xd2, 2332 SURFACE_FORMAT_R11G11B10_FLOAT = 0xd3, 2333 SURFACE_FORMAT_R32_SINT = 0xd6, 2334 SURFACE_FORMAT_R32_UINT = 0xd7, 2335 SURFACE_FORMAT_R32_FLOAT = 0xd8, 2336 SURFACE_FORMAT_R24_UNORM_X8_TYPELESS = 0xd9, 2337 SURFACE_FORMAT_X24_TYPELESS_G8_UINT = 0xda, 2338 SURFACE_FORMAT_L32_UNORM = 0xdd, 2339 SURFACE_FORMAT_A32_UNORM = 0xde, 2340 SURFACE_FORMAT_L16A16_UNORM = 0xdf, 2341 SURFACE_FORMAT_I24X8_UNORM = 0xe0, 2342 SURFACE_FORMAT_L24X8_UNORM = 0xe1, 2343 SURFACE_FORMAT_A24X8_UNORM = 0xe2, 2344 SURFACE_FORMAT_I32_FLOAT = 0xe3, 2345 SURFACE_FORMAT_L32_FLOAT = 0xe4, 2346 SURFACE_FORMAT_A32_FLOAT = 0xe5, 2347 SURFACE_FORMAT_X8B8_UNORM_G8R8_SNORM = 0xe6, 2348 SURFACE_FORMAT_A8X8_UNORM_G8R8_SNORM = 0xe7, 2349 SURFACE_FORMAT_B8X8_UNORM_G8R8_SNORM = 0xe8, 2350 SURFACE_FORMAT_B8G8R8X8_UNORM = 0xe9, 2351 SURFACE_FORMAT_B8G8R8X8_UNORM_SRGB = 0xea, 2352 SURFACE_FORMAT_R8G8B8X8_UNORM = 0xeb, 2353 SURFACE_FORMAT_R8G8B8X8_UNORM_SRGB = 0xec, 2354 SURFACE_FORMAT_R9G9B9E5_SHAREDEXP = 0xed, 2355 SURFACE_FORMAT_B10G10R10X2_UNORM = 0xee, 2356 SURFACE_FORMAT_L16A16_FLOAT = 0xf0, 2357 SURFACE_FORMAT_R32_UNORM = 0xf1, 2358 SURFACE_FORMAT_R32_SNORM = 0xf2, 2359 SURFACE_FORMAT_R10G10B10X2_USCALED = 0xf3, 2360 SURFACE_FORMAT_R8G8B8A8_SSCALED = 0xf4, 2361 SURFACE_FORMAT_R8G8B8A8_USCALED = 0xf5, 2362 SURFACE_FORMAT_R16G16_SSCALED = 0xf6, 2363 SURFACE_FORMAT_R16G16_USCALED = 0xf7, 2364 SURFACE_FORMAT_R32_SSCALED = 0xf8, 2365 SURFACE_FORMAT_R32_USCALED = 0xf9, 2366 SURFACE_FORMAT_B5G6R5_UNORM = 0x100, 2367 SURFACE_FORMAT_B5G6R5_UNORM_SRGB = 0x101, 2368 SURFACE_FORMAT_B5G5R5A1_UNORM = 0x102, 2369 SURFACE_FORMAT_B5G5R5A1_UNORM_SRGB = 0x103, 2370 SURFACE_FORMAT_B4G4R4A4_UNORM = 0x104, 2371 SURFACE_FORMAT_B4G4R4A4_UNORM_SRGB = 0x105, 2372 SURFACE_FORMAT_R8G8_UNORM = 0x106, 2373 SURFACE_FORMAT_R8G8_SNORM = 0x107, 2374 SURFACE_FORMAT_R8G8_SINT = 0x108, 2375 SURFACE_FORMAT_R8G8_UINT = 0x109, 2376 SURFACE_FORMAT_R16_UNORM = 0x10a, 2377 SURFACE_FORMAT_R16_SNORM = 0x10b, 2378 SURFACE_FORMAT_R16_SINT = 0x10c, 2379 SURFACE_FORMAT_R16_UINT = 0x10d, 2380 SURFACE_FORMAT_R16_FLOAT = 0x10e, 2381 SURFACE_FORMAT_A8P8_UNORM_PALETTE0 = 0x10f, 2382 SURFACE_FORMAT_A8P8_UNORM_PALETTE1 = 0x110, 2383 SURFACE_FORMAT_I16_UNORM = 0x111, 2384 SURFACE_FORMAT_L16_UNORM = 0x112, 2385 SURFACE_FORMAT_A16_UNORM = 0x113, 2386 SURFACE_FORMAT_L8A8_UNORM = 0x114, 2387 SURFACE_FORMAT_I16_FLOAT = 0x115, 2388 SURFACE_FORMAT_L16_FLOAT = 0x116, 2389 SURFACE_FORMAT_A16_FLOAT = 0x117, 2390 SURFACE_FORMAT_L8A8_UNORM_SRGB = 0x118, 2391 SURFACE_FORMAT_R5G5_SNORM_B6_UNORM = 0x119, 2392 SURFACE_FORMAT_B5G5R5X1_UNORM = 0x11a, 2393 SURFACE_FORMAT_B5G5R5X1_UNORM_SRGB = 0x11b, 2394 SURFACE_FORMAT_R8G8_SSCALED = 0x11c, 2395 SURFACE_FORMAT_R8G8_USCALED = 0x11d, 2396 SURFACE_FORMAT_R16_SSCALED = 0x11e, 2397 SURFACE_FORMAT_R16_USCALED = 0x11f, 2398 SURFACE_FORMAT_P8A8_UNORM_PALETTE0 = 0x122, 2399 SURFACE_FORMAT_P8A8_UNORM_PALETTE1 = 0x123, 2400 SURFACE_FORMAT_A1B5G5R5_UNORM = 0x124, 2401 SURFACE_FORMAT_A4B4G4R4_UNORM = 0x125, 2402 SURFACE_FORMAT_L8A8_UINT = 0x126, 2403 SURFACE_FORMAT_L8A8_SINT = 0x127, 2404 SURFACE_FORMAT_R8_UNORM = 0x140, 2405 SURFACE_FORMAT_R8_SNORM = 0x141, 2406 SURFACE_FORMAT_R8_SINT = 0x142, 2407 SURFACE_FORMAT_R8_UINT = 0x143, 2408 SURFACE_FORMAT_A8_UNORM = 0x144, 2409 SURFACE_FORMAT_I8_UNORM = 0x145, 2410 SURFACE_FORMAT_L8_UNORM = 0x146, 2411 SURFACE_FORMAT_P4A4_UNORM_PALETTE0 = 0x147, 2412 SURFACE_FORMAT_A4P4_UNORM_PALETTE0 = 0x148, 2413 SURFACE_FORMAT_R8_SSCALED = 0x149, 2414 SURFACE_FORMAT_R8_USCALED = 0x14a, 2415 SURFACE_FORMAT_P8_UNORM_PALETTE0 = 0x14b, 2416 SURFACE_FORMAT_L8_UNORM_SRGB = 0x14c, 2417 SURFACE_FORMAT_P8_UNORM_PALETTE1 = 0x14d, 2418 SURFACE_FORMAT_P4A4_UNORM_PALETTE1 = 0x14e, 2419 SURFACE_FORMAT_A4P4_UNORM_PALETTE1 = 0x14f, 2420 SURFACE_FORMAT_Y8_UNORM = 0x150, 2421 SURFACE_FORMAT_L8_UINT = 0x152, 2422 SURFACE_FORMAT_L8_SINT = 0x153, 2423 SURFACE_FORMAT_I8_UINT = 0x154, 2424 SURFACE_FORMAT_I8_SINT = 0x155, 2425 SURFACE_FORMAT_DXT1_RGB_SRGB = 0x180, 2426 SURFACE_FORMAT_R1_UNORM = 0x181, 2427 SURFACE_FORMAT_YCRCB_NORMAL = 0x182, 2428 SURFACE_FORMAT_YCRCB_SWAPUVY = 0x183, 2429 SURFACE_FORMAT_P2_UNORM_PALETTE0 = 0x184, 2430 SURFACE_FORMAT_P2_UNORM_PALETTE1 = 0x185, 2431 SURFACE_FORMAT_BC1_UNORM = 0x186, 2432 SURFACE_FORMAT_BC2_UNORM = 0x187, 2433 SURFACE_FORMAT_BC3_UNORM = 0x188, 2434 SURFACE_FORMAT_BC4_UNORM = 0x189, 2435 SURFACE_FORMAT_BC5_UNORM = 0x18a, 2436 SURFACE_FORMAT_BC1_UNORM_SRGB = 0x18b, 2437 SURFACE_FORMAT_BC2_UNORM_SRGB = 0x18c, 2438 SURFACE_FORMAT_BC3_UNORM_SRGB = 0x18d, 2439 SURFACE_FORMAT_MONO8 = 0x18e, 2440 SURFACE_FORMAT_YCRCB_SWAPUV = 0x18f, 2441 SURFACE_FORMAT_YCRCB_SWAPY = 0x190, 2442 SURFACE_FORMAT_DXT1_RGB = 0x191, 2443 SURFACE_FORMAT_FXT1 = 0x192, 2444 SURFACE_FORMAT_R8G8B8_UNORM = 0x193, 2445 SURFACE_FORMAT_R8G8B8_SNORM = 0x194, 2446 SURFACE_FORMAT_R8G8B8_SSCALED = 0x195, 2447 SURFACE_FORMAT_R8G8B8_USCALED = 0x196, 2448 SURFACE_FORMAT_R64G64B64A64_FLOAT = 0x197, 2449 SURFACE_FORMAT_R64G64B64_FLOAT = 0x198, 2450 SURFACE_FORMAT_BC4_SNORM = 0x199, 2451 SURFACE_FORMAT_BC5_SNORM = 0x19a, 2452 SURFACE_FORMAT_R16G16B16_FLOAT = 0x19b, 2453 SURFACE_FORMAT_R16G16B16_UNORM = 0x19c, 2454 SURFACE_FORMAT_R16G16B16_SNORM = 0x19d, 2455 SURFACE_FORMAT_R16G16B16_SSCALED = 0x19e, 2456 SURFACE_FORMAT_R16G16B16_USCALED = 0x19f, 2457 SURFACE_FORMAT_BC6H_SF16 = 0x1a1, 2458 SURFACE_FORMAT_BC7_UNORM = 0x1a2, 2459 SURFACE_FORMAT_BC7_UNORM_SRGB = 0x1a3, 2460 SURFACE_FORMAT_BC6H_UF16 = 0x1a4, 2461 SURFACE_FORMAT_PLANAR_420_8 = 0x1a5, 2462 SURFACE_FORMAT_PLANAR_420_16 = 0x1a6, 2463 SURFACE_FORMAT_R8G8B8_UNORM_SRGB = 0x1a8, 2464 SURFACE_FORMAT_ETC1_RGB8 = 0x1a9, 2465 SURFACE_FORMAT_ETC2_RGB8 = 0x1aa, 2466 SURFACE_FORMAT_EAC_R11 = 0x1ab, 2467 SURFACE_FORMAT_EAC_RG11 = 0x1ac, 2468 SURFACE_FORMAT_EAC_SIGNED_R11 = 0x1ad, 2469 SURFACE_FORMAT_EAC_SIGNED_RG11 = 0x1ae, 2470 SURFACE_FORMAT_ETC2_SRGB8 = 0x1af, 2471 SURFACE_FORMAT_R16G16B16_UINT = 0x1b0, 2472 SURFACE_FORMAT_R16G16B16_SINT = 0x1b1, 2473 SURFACE_FORMAT_R32_SFIXED = 0x1b2, 2474 SURFACE_FORMAT_R10G10B10A2_SNORM = 0x1b3, 2475 SURFACE_FORMAT_R10G10B10A2_USCALED = 0x1b4, 2476 SURFACE_FORMAT_R10G10B10A2_SSCALED = 0x1b5, 2477 SURFACE_FORMAT_R10G10B10A2_SINT = 0x1b6, 2478 SURFACE_FORMAT_B10G10R10A2_SNORM = 0x1b7, 2479 SURFACE_FORMAT_B10G10R10A2_USCALED = 0x1b8, 2480 SURFACE_FORMAT_B10G10R10A2_SSCALED = 0x1b9, 2481 SURFACE_FORMAT_B10G10R10A2_UINT = 0x1ba, 2482 SURFACE_FORMAT_B10G10R10A2_SINT = 0x1bb, 2483 SURFACE_FORMAT_R64G64B64A64_PASSTHRU = 0x1bc, 2484 SURFACE_FORMAT_R64G64B64_PASSTHRU = 0x1bd, 2485 SURFACE_FORMAT_ETC2_RGB8_PTA = 0x1c0, 2486 SURFACE_FORMAT_ETC2_SRGB8_PTA = 0x1c1, 2487 SURFACE_FORMAT_ETC2_EAC_RGBA8 = 0x1c2, 2488 SURFACE_FORMAT_ETC2_EAC_SRGB8_A8 = 0x1c3, 2489 SURFACE_FORMAT_R8G8B8_UINT = 0x1c8, 2490 SURFACE_FORMAT_R8G8B8_SINT = 0x1c9, 2491 SURFACE_FORMAT_RAW = 0x1ff, 2492 } SURFACE_FORMAT; 2493 typedef enum tagSURFACE_TYPE { 2494 SURFACE_TYPE_SURFTYPE_1D = 0x0, 2495 SURFACE_TYPE_SURFTYPE_2D = 0x1, 2496 SURFACE_TYPE_SURFTYPE_3D = 0x2, 2497 SURFACE_TYPE_SURFTYPE_CUBE = 0x3, 2498 SURFACE_TYPE_SURFTYPE_BUFFER = 0x4, 2499 SURFACE_TYPE_SURFTYPE_STRBUF = 0x5, 2500 SURFACE_TYPE_SURFTYPE_NULL = 0x7, 2501 } SURFACE_TYPE; 2502 typedef enum tagNUMBER_OF_MULTISAMPLES { 2503 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_1 = 0x0, 2504 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_2 = 0x1, 2505 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_4 = 0x2, 2506 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_8 = 0x3, 2507 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_16 = 0x4, 2508 } NUMBER_OF_MULTISAMPLES; 2509 typedef enum tagMULTISAMPLED_SURFACE_STORAGE_FORMAT { 2510 MULTISAMPLED_SURFACE_STORAGE_FORMAT_MSS = 0x0, 2511 MULTISAMPLED_SURFACE_STORAGE_FORMAT_DEPTH_STENCIL = 0x1, 2512 } MULTISAMPLED_SURFACE_STORAGE_FORMAT; 2513 typedef enum tagRENDER_TARGET_AND_SAMPLE_UNORM_ROTATION { 2514 RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION_0DEG = 0x0, 2515 RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION_90DEG = 0x1, 2516 RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION_180DEG = 0x2, 2517 RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION_270DEG = 0x3, 2518 } RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION; 2519 typedef enum tagCOHERENCY_TYPE { 2520 COHERENCY_TYPE_GPU_COHERENT = 0x0, 2521 COHERENCY_TYPE_IA_COHERENT = 0x1, 2522 } COHERENCY_TYPE; 2523 typedef enum tagTILED_RESOURCE_MODE { 2524 TILED_RESOURCE_MODE_NONE = 0x0, 2525 TILED_RESOURCE_MODE_4KB = 0x1, 2526 TILED_RESOURCE_MODE_TILEYF = 0x1, 2527 TILED_RESOURCE_MODE_64KB = 0x2, 2528 TILED_RESOURCE_MODE_TILEYS = 0x2, 2529 } TILED_RESOURCE_MODE; 2530 typedef enum tagAUXILIARY_SURFACE_MODE { 2531 AUXILIARY_SURFACE_MODE_AUX_NONE = 0x0, 2532 AUXILIARY_SURFACE_MODE_AUX_CCS_D = 0x1, 2533 AUXILIARY_SURFACE_MODE_AUX_APPEND = 0x2, 2534 AUXILIARY_SURFACE_MODE_AUX_HIZ = 0x3, 2535 AUXILIARY_SURFACE_MODE_AUX_CCS_E = 0x5, 2536 } AUXILIARY_SURFACE_MODE; 2537 typedef enum tagSHADER_CHANNEL_SELECT { 2538 SHADER_CHANNEL_SELECT_ZERO = 0x0, 2539 SHADER_CHANNEL_SELECT_ONE = 0x1, 2540 SHADER_CHANNEL_SELECT_RED = 0x4, 2541 SHADER_CHANNEL_SELECT_GREEN = 0x5, 2542 SHADER_CHANNEL_SELECT_BLUE = 0x6, 2543 SHADER_CHANNEL_SELECT_ALPHA = 0x7, 2544 } SHADER_CHANNEL_SELECT; 2545 typedef enum tagMEMORY_COMPRESSION_MODE { 2546 MEMORY_COMPRESSION_MODE_HORIZONTAL = 0x0, 2547 MEMORY_COMPRESSION_MODE_VERTICAL = 0x1, 2548 } MEMORY_COMPRESSION_MODE; 2549 typedef enum tagPATCH_CONSTANTS { 2550 SURFACEBASEADDRESS_BYTEOFFSET = 0x20, 2551 SURFACEBASEADDRESS_INDEX = 0x8, 2552 AUXILIARYSURFACEBASEADDRESS_BYTEOFFSET = 0x28, 2553 AUXILIARYSURFACEBASEADDRESS_INDEX = 0xa, 2554 } PATCH_CONSTANTS; 2555 inline void init() { 2556 memset(&TheStructure, 0, sizeof(TheStructure)); 2557 TheStructure.Common.MediaBoundaryPixelMode = MEDIA_BOUNDARY_PIXEL_MODE_NORMAL_MODE; 2558 TheStructure.Common.RenderCacheReadWriteMode = RENDER_CACHE_READ_WRITE_MODE_WRITE_ONLY_CACHE; 2559 TheStructure.Common.TileMode = TILE_MODE_LINEAR; 2560 TheStructure.Common.SurfaceHorizontalAlignment = SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_4; 2561 TheStructure.Common.SurfaceVerticalAlignment = SURFACE_VERTICAL_ALIGNMENT_VALIGN_4; 2562 TheStructure.Common.SurfaceType = SURFACE_TYPE_SURFTYPE_1D; 2563 TheStructure.Common.CoherencyType = COHERENCY_TYPE_GPU_COHERENT; 2564 TheStructure.Common.TiledResourceMode = TILED_RESOURCE_MODE_NONE; 2565 TheStructure.Common.ShaderChannelSelectAlpha = SHADER_CHANNEL_SELECT_ZERO; 2566 TheStructure.Common.ShaderChannelSelectBlue = SHADER_CHANNEL_SELECT_ZERO; 2567 TheStructure.Common.ShaderChannelSelectGreen = SHADER_CHANNEL_SELECT_ZERO; 2568 TheStructure.Common.ShaderChannelSelectRed = SHADER_CHANNEL_SELECT_ZERO; 2569 TheStructure.Common.MemoryCompressionMode = MEMORY_COMPRESSION_MODE_HORIZONTAL; 2570 TheStructure.SurfaceTypeIsnotSurftype_Strbuf.NumberOfMultisamples = NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_1; 2571 TheStructure.SurfaceTypeIsnotSurftype_Strbuf.MultisampledSurfaceStorageFormat = MULTISAMPLED_SURFACE_STORAGE_FORMAT_MSS; 2572 TheStructure.SurfaceTypeIsnotSurftype_Strbuf.RenderTargetAndSampleUnormRotation = RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION_0DEG; 2573 TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfaceMode = AUXILIARY_SURFACE_MODE_AUX_NONE; 2574 } 2575 static tagRENDER_SURFACE_STATE sInit() { 2576 RENDER_SURFACE_STATE state; 2577 state.init(); 2578 return state; 2579 } 2580 inline uint32_t &getRawData(const uint32_t index) { 2581 DEBUG_BREAK_IF(index >= 16); 2582 return TheStructure.RawData[index]; 2583 } 2584 inline void setMediaBoundaryPixelMode(const MEDIA_BOUNDARY_PIXEL_MODE value) { 2585 TheStructure.Common.MediaBoundaryPixelMode = value; 2586 } 2587 inline MEDIA_BOUNDARY_PIXEL_MODE getMediaBoundaryPixelMode() const { 2588 return static_cast<MEDIA_BOUNDARY_PIXEL_MODE>(TheStructure.Common.MediaBoundaryPixelMode); 2589 } 2590 inline void setRenderCacheReadWriteMode(const RENDER_CACHE_READ_WRITE_MODE value) { 2591 TheStructure.Common.RenderCacheReadWriteMode = value; 2592 } 2593 inline RENDER_CACHE_READ_WRITE_MODE getRenderCacheReadWriteMode() const { 2594 return static_cast<RENDER_CACHE_READ_WRITE_MODE>(TheStructure.Common.RenderCacheReadWriteMode); 2595 } 2596 inline void setSamplerL2OutOfOrderModeDisable(const bool value) { 2597 TheStructure.Common.SamplerL2OutOfOrderModeDisable = value; 2598 } 2599 inline bool getSamplerL2OutOfOrderModeDisable() const { 2600 return (TheStructure.Common.SamplerL2OutOfOrderModeDisable); 2601 } 2602 inline void setVerticalLineStrideOffset(const uint32_t value) { 2603 TheStructure.Common.VerticalLineStrideOffset = value; 2604 } 2605 inline uint32_t getVerticalLineStrideOffset() const { 2606 return (TheStructure.Common.VerticalLineStrideOffset); 2607 } 2608 inline void setVerticalLineStride(const uint32_t value) { 2609 TheStructure.Common.VerticalLineStride = value; 2610 } 2611 inline uint32_t getVerticalLineStride() const { 2612 return (TheStructure.Common.VerticalLineStride); 2613 } 2614 inline void setTileMode(const TILE_MODE value) { 2615 TheStructure.Common.TileMode = value; 2616 } 2617 inline TILE_MODE getTileMode() const { 2618 return static_cast<TILE_MODE>(TheStructure.Common.TileMode); 2619 } 2620 inline void setSurfaceHorizontalAlignment(const SURFACE_HORIZONTAL_ALIGNMENT value) { 2621 TheStructure.Common.SurfaceHorizontalAlignment = value; 2622 } 2623 inline SURFACE_HORIZONTAL_ALIGNMENT getSurfaceHorizontalAlignment() const { 2624 return static_cast<SURFACE_HORIZONTAL_ALIGNMENT>(TheStructure.Common.SurfaceHorizontalAlignment); 2625 } 2626 inline void setSurfaceVerticalAlignment(const SURFACE_VERTICAL_ALIGNMENT value) { 2627 TheStructure.Common.SurfaceVerticalAlignment = value; 2628 } 2629 inline SURFACE_VERTICAL_ALIGNMENT getSurfaceVerticalAlignment() const { 2630 return static_cast<SURFACE_VERTICAL_ALIGNMENT>(TheStructure.Common.SurfaceVerticalAlignment); 2631 } 2632 inline void setSurfaceFormat(const SURFACE_FORMAT value) { 2633 TheStructure.Common.SurfaceFormat = value; 2634 } 2635 inline SURFACE_FORMAT getSurfaceFormat() const { 2636 return static_cast<SURFACE_FORMAT>(TheStructure.Common.SurfaceFormat); 2637 } 2638 inline void setAstcEnable(const bool value) { 2639 TheStructure.Common.Astc_Enable = value; 2640 } 2641 inline bool getAstcEnable() const { 2642 return (TheStructure.Common.Astc_Enable); 2643 } 2644 inline void setSurfaceArray(const bool value) { 2645 TheStructure.Common.SurfaceArray = value; 2646 } 2647 inline bool getSurfaceArray() const { 2648 return (TheStructure.Common.SurfaceArray); 2649 } 2650 inline void setSurfaceType(const SURFACE_TYPE value) { 2651 TheStructure.Common.SurfaceType = value; 2652 } 2653 inline SURFACE_TYPE getSurfaceType() const { 2654 return static_cast<SURFACE_TYPE>(TheStructure.Common.SurfaceType); 2655 } 2656 typedef enum tagSURFACEQPITCH { 2657 SURFACEQPITCH_BIT_SHIFT = 0x2, 2658 SURFACEQPITCH_ALIGN_SIZE = 0x4, 2659 } SURFACEQPITCH; 2660 inline void setSurfaceQpitch(const uint32_t value) { 2661 TheStructure.Common.SurfaceQpitch = value >> SURFACEQPITCH_BIT_SHIFT; 2662 } 2663 inline uint32_t getSurfaceQpitch() const { 2664 return (TheStructure.Common.SurfaceQpitch << SURFACEQPITCH_BIT_SHIFT); 2665 } 2666 inline void setBaseMipLevel(const uint32_t value) { 2667 TheStructure.Common.BaseMipLevel = value; 2668 } 2669 inline uint32_t getBaseMipLevel() const { 2670 return (TheStructure.Common.BaseMipLevel); 2671 } 2672 inline void setMemoryObjectControlStateReserved(const uint32_t value) { 2673 TheStructure.Common.MemoryObjectControlState_Reserved = value; 2674 } 2675 inline uint32_t getMemoryObjectControlStateReserved() const { 2676 return (TheStructure.Common.MemoryObjectControlState_Reserved); 2677 } 2678 inline void setMemoryObjectControlState(const uint32_t value) { 2679 TheStructure.Common.MemoryObjectControlState_Reserved = value; 2680 TheStructure.Common.MemoryObjectControlState_IndexToMocsTables = (value >> 1); 2681 } 2682 inline uint32_t getMemoryObjectControlState() const { 2683 uint32_t mocs = TheStructure.Common.MemoryObjectControlState_Reserved; 2684 mocs |= (TheStructure.Common.MemoryObjectControlState_IndexToMocsTables << 1); 2685 return (mocs); 2686 } 2687 inline void setWidth(const uint32_t value) { 2688 TheStructure.Common.Width = value - 1; 2689 } 2690 inline uint32_t getWidth() const { 2691 return (TheStructure.Common.Width + 1); 2692 } 2693 inline void setHeight(const uint32_t value) { 2694 TheStructure.Common.Height = value - 1; 2695 } 2696 inline uint32_t getHeight() const { 2697 return (TheStructure.Common.Height + 1); 2698 } 2699 inline void setSurfacePitch(const uint32_t value) { 2700 TheStructure.Common.SurfacePitch = value - 1; 2701 } 2702 inline uint32_t getSurfacePitch() const { 2703 return (TheStructure.Common.SurfacePitch + 1); 2704 } 2705 inline void setDepth(const uint32_t value) { 2706 TheStructure.Common.Depth = value - 1; 2707 } 2708 inline uint32_t getDepth() const { 2709 return (TheStructure.Common.Depth + 1); 2710 } 2711 inline void setMipCountLod(const uint32_t value) { 2712 TheStructure.Common.MipCountLod = value; 2713 } 2714 inline uint32_t getMipCountLod() const { 2715 return (TheStructure.Common.MipCountLod); 2716 } 2717 inline void setSurfaceMinLod(const uint32_t value) { 2718 TheStructure.Common.SurfaceMinLod = value; 2719 } 2720 inline uint32_t getSurfaceMinLod() const { 2721 return (TheStructure.Common.SurfaceMinLod); 2722 } 2723 inline void setMipTailStartLod(const uint32_t value) { 2724 TheStructure.Common.MipTailStartLod = value; 2725 } 2726 inline uint32_t getMipTailStartLod() const { 2727 return (TheStructure.Common.MipTailStartLod); 2728 } 2729 inline void setCoherencyType(const COHERENCY_TYPE value) { 2730 TheStructure.Common.CoherencyType = value; 2731 } 2732 inline COHERENCY_TYPE getCoherencyType() const { 2733 return static_cast<COHERENCY_TYPE>(TheStructure.Common.CoherencyType); 2734 } 2735 inline void setTiledResourceMode(const TILED_RESOURCE_MODE value) { 2736 TheStructure.Common.TiledResourceMode = value; 2737 } 2738 inline TILED_RESOURCE_MODE getTiledResourceMode() const { 2739 return static_cast<TILED_RESOURCE_MODE>(TheStructure.Common.TiledResourceMode); 2740 } 2741 inline void setEwaDisableForCube(const bool value) { 2742 TheStructure.Common.EwaDisableForCube = value; 2743 } 2744 inline bool getEwaDisableForCube() const { 2745 return (TheStructure.Common.EwaDisableForCube); 2746 } 2747 typedef enum tagYOFFSET { 2748 YOFFSET_BIT_SHIFT = 0x2, 2749 YOFFSET_ALIGN_SIZE = 0x4, 2750 } YOFFSET; 2751 inline void setYOffset(const uint32_t value) { 2752 TheStructure.Common.YOffset = value >> YOFFSET_BIT_SHIFT; 2753 } 2754 inline uint32_t getYOffset() const { 2755 return (TheStructure.Common.YOffset << YOFFSET_BIT_SHIFT); 2756 } 2757 typedef enum tagXOFFSET { 2758 XOFFSET_BIT_SHIFT = 0x2, 2759 XOFFSET_ALIGN_SIZE = 0x4, 2760 } XOFFSET; 2761 inline void setXOffset(const uint32_t value) { 2762 TheStructure.Common.XOffset = value >> XOFFSET_BIT_SHIFT; 2763 } 2764 inline uint32_t getXOffset() const { 2765 return (TheStructure.Common.XOffset << XOFFSET_BIT_SHIFT); 2766 } 2767 inline void setResourceMinLod(const uint32_t value) { 2768 TheStructure.Common.ResourceMinLod = value; 2769 } 2770 inline uint32_t getResourceMinLod() const { 2771 return (TheStructure.Common.ResourceMinLod); 2772 } 2773 inline void setShaderChannelSelectAlpha(const SHADER_CHANNEL_SELECT value) { 2774 TheStructure.Common.ShaderChannelSelectAlpha = value; 2775 } 2776 inline SHADER_CHANNEL_SELECT getShaderChannelSelectAlpha() const { 2777 return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectAlpha); 2778 } 2779 inline void setShaderChannelSelectBlue(const SHADER_CHANNEL_SELECT value) { 2780 TheStructure.Common.ShaderChannelSelectBlue = value; 2781 } 2782 inline SHADER_CHANNEL_SELECT getShaderChannelSelectBlue() const { 2783 return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectBlue); 2784 } 2785 inline void setShaderChannelSelectGreen(const SHADER_CHANNEL_SELECT value) { 2786 TheStructure.Common.ShaderChannelSelectGreen = value; 2787 } 2788 inline SHADER_CHANNEL_SELECT getShaderChannelSelectGreen() const { 2789 return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectGreen); 2790 } 2791 inline void setShaderChannelSelectRed(const SHADER_CHANNEL_SELECT value) { 2792 TheStructure.Common.ShaderChannelSelectRed = value; 2793 } 2794 inline SHADER_CHANNEL_SELECT getShaderChannelSelectRed() const { 2795 return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectRed); 2796 } 2797 inline void setMemoryCompressionEnable(const bool value) { 2798 TheStructure.Common.MemoryCompressionEnable = value; 2799 } 2800 inline bool getMemoryCompressionEnable() const { 2801 return (TheStructure.Common.MemoryCompressionEnable); 2802 } 2803 inline void setMemoryCompressionMode(const MEMORY_COMPRESSION_MODE value) { 2804 TheStructure.Common.MemoryCompressionMode = value; 2805 } 2806 inline MEMORY_COMPRESSION_MODE getMemoryCompressionMode() const { 2807 return static_cast<MEMORY_COMPRESSION_MODE>(TheStructure.Common.MemoryCompressionMode); 2808 } 2809 inline void setSurfaceBaseAddress(const uint64_t value) { 2810 TheStructure.Common.SurfaceBaseAddress = value; 2811 } 2812 inline uint64_t getSurfaceBaseAddress() const { 2813 return (TheStructure.Common.SurfaceBaseAddress); 2814 } 2815 inline void setQuiltWidth(const uint64_t value) { 2816 TheStructure.Common.QuiltWidth = value; 2817 } 2818 inline uint64_t getQuiltWidth() const { 2819 return (TheStructure.Common.QuiltWidth); 2820 } 2821 inline void setQuiltHeight(const uint64_t value) { 2822 TheStructure.Common.QuiltHeight = value; 2823 } 2824 inline uint64_t getQuiltHeight() const { 2825 return (TheStructure.Common.QuiltHeight); 2826 } 2827 inline void setCubeFaceEnablePositiveZ(const bool value) { 2828 TheStructure.SurfaceTypeIsSurftype_Cube.CubeFaceEnable_PositiveZ = value; 2829 } 2830 inline bool getCubeFaceEnablePositiveZ() const { 2831 return (TheStructure.SurfaceTypeIsSurftype_Cube.CubeFaceEnable_PositiveZ); 2832 } 2833 inline void setCubeFaceEnableNegativeZ(const bool value) { 2834 TheStructure.SurfaceTypeIsSurftype_Cube.CubeFaceEnable_NegativeZ = value; 2835 } 2836 inline bool getCubeFaceEnableNegativeZ() const { 2837 return (TheStructure.SurfaceTypeIsSurftype_Cube.CubeFaceEnable_NegativeZ); 2838 } 2839 inline void setCubeFaceEnablePositiveY(const bool value) { 2840 TheStructure.SurfaceTypeIsSurftype_Cube.CubeFaceEnable_PositiveY = value; 2841 } 2842 inline bool getCubeFaceEnablePositiveY() const { 2843 return (TheStructure.SurfaceTypeIsSurftype_Cube.CubeFaceEnable_PositiveY); 2844 } 2845 inline void setCubeFaceEnableNegativeY(const bool value) { 2846 TheStructure.SurfaceTypeIsSurftype_Cube.CubeFaceEnable_NegativeY = value; 2847 } 2848 inline bool getCubeFaceEnableNegativeY() const { 2849 return (TheStructure.SurfaceTypeIsSurftype_Cube.CubeFaceEnable_NegativeY); 2850 } 2851 inline void setCubeFaceEnablePositiveX(const bool value) { 2852 TheStructure.SurfaceTypeIsSurftype_Cube.CubeFaceEnable_PositiveX = value; 2853 } 2854 inline bool getCubeFaceEnablePositiveX() const { 2855 return (TheStructure.SurfaceTypeIsSurftype_Cube.CubeFaceEnable_PositiveX); 2856 } 2857 inline void setCubeFaceEnableNegativeX(const bool value) { 2858 TheStructure.SurfaceTypeIsSurftype_Cube.CubeFaceEnable_NegativeX = value; 2859 } 2860 inline bool getCubeFaceEnableNegativeX() const { 2861 return (TheStructure.SurfaceTypeIsSurftype_Cube.CubeFaceEnable_NegativeX); 2862 } 2863 inline void setMultisamplePositionPaletteIndex(const uint32_t value) { 2864 TheStructure.SurfaceTypeIsnotSurftype_Strbuf.MultisamplePositionPaletteIndex = value; 2865 } 2866 inline uint32_t getMultisamplePositionPaletteIndex() const { 2867 return (TheStructure.SurfaceTypeIsnotSurftype_Strbuf.MultisamplePositionPaletteIndex); 2868 } 2869 inline void setNumberOfMultisamples(const NUMBER_OF_MULTISAMPLES value) { 2870 TheStructure.SurfaceTypeIsnotSurftype_Strbuf.NumberOfMultisamples = value; 2871 } 2872 inline NUMBER_OF_MULTISAMPLES getNumberOfMultisamples() const { 2873 return static_cast<NUMBER_OF_MULTISAMPLES>(TheStructure.SurfaceTypeIsnotSurftype_Strbuf.NumberOfMultisamples); 2874 } 2875 inline void setMultisampledSurfaceStorageFormat(const MULTISAMPLED_SURFACE_STORAGE_FORMAT value) { 2876 TheStructure.SurfaceTypeIsnotSurftype_Strbuf.MultisampledSurfaceStorageFormat = value; 2877 } 2878 inline MULTISAMPLED_SURFACE_STORAGE_FORMAT getMultisampledSurfaceStorageFormat() const { 2879 return static_cast<MULTISAMPLED_SURFACE_STORAGE_FORMAT>(TheStructure.SurfaceTypeIsnotSurftype_Strbuf.MultisampledSurfaceStorageFormat); 2880 } 2881 inline void setRenderTargetViewExtent(const uint32_t value) { 2882 TheStructure.SurfaceTypeIsnotSurftype_Strbuf.RenderTargetViewExtent = value - 1; 2883 } 2884 inline uint32_t getRenderTargetViewExtent() const { 2885 return (TheStructure.SurfaceTypeIsnotSurftype_Strbuf.RenderTargetViewExtent + 1); 2886 } 2887 inline void setMinimumArrayElement(const uint32_t value) { 2888 TheStructure.SurfaceTypeIsnotSurftype_Strbuf.MinimumArrayElement = value; 2889 } 2890 inline uint32_t getMinimumArrayElement() const { 2891 return (TheStructure.SurfaceTypeIsnotSurftype_Strbuf.MinimumArrayElement); 2892 } 2893 inline void setRenderTargetAndSampleUnormRotation(const RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION value) { 2894 TheStructure.SurfaceTypeIsnotSurftype_Strbuf.RenderTargetAndSampleUnormRotation = value; 2895 } 2896 inline RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION getRenderTargetAndSampleUnormRotation() const { 2897 return static_cast<RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION>(TheStructure.SurfaceTypeIsnotSurftype_Strbuf.RenderTargetAndSampleUnormRotation); 2898 } 2899 inline void setAuxiliarySurfaceMode(const AUXILIARY_SURFACE_MODE value) { 2900 TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfaceMode = value; 2901 } 2902 inline AUXILIARY_SURFACE_MODE getAuxiliarySurfaceMode() const { 2903 return static_cast<AUXILIARY_SURFACE_MODE>(TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfaceMode); 2904 } 2905 inline void setAuxiliarySurfacePitch(const uint32_t value) { 2906 TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfacePitch = value - 1; 2907 } 2908 inline uint32_t getAuxiliarySurfacePitch() const { 2909 return (TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfacePitch + 1); 2910 } 2911 typedef enum tagAUXILIARYSURFACEQPITCH { 2912 AUXILIARYSURFACEQPITCH_BIT_SHIFT = 0x2, 2913 AUXILIARYSURFACEQPITCH_ALIGN_SIZE = 0x4, 2914 } AUXILIARYSURFACEQPITCH; 2915 inline void setAuxiliarySurfaceQpitch(const uint32_t value) { 2916 TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfaceQpitch = value >> AUXILIARYSURFACEQPITCH_BIT_SHIFT; 2917 } 2918 inline uint32_t getAuxiliarySurfaceQpitch() const { 2919 return (TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfaceQpitch << AUXILIARYSURFACEQPITCH_BIT_SHIFT); 2920 } 2921 inline void setYOffsetForUOrUvPlane(const uint32_t value) { 2922 TheStructure._SurfaceFormatIsPlanar.YOffsetForUOrUvPlane = value; 2923 } 2924 inline uint32_t getYOffsetForUOrUvPlane() const { 2925 return (TheStructure._SurfaceFormatIsPlanar.YOffsetForUOrUvPlane); 2926 } 2927 inline void setXOffsetForUOrUvPlane(const uint32_t value) { 2928 TheStructure._SurfaceFormatIsPlanar.XOffsetForUOrUvPlane = value; 2929 } 2930 inline uint32_t getXOffsetForUOrUvPlane() const { 2931 return (TheStructure._SurfaceFormatIsPlanar.XOffsetForUOrUvPlane); 2932 } 2933 inline void setSeparateUvPlaneEnable(const bool value) { 2934 TheStructure._SurfaceFormatIsPlanar.SeparateUvPlaneEnable = value; 2935 } 2936 inline bool getSeparateUvPlaneEnable() const { 2937 return (TheStructure._SurfaceFormatIsPlanar.SeparateUvPlaneEnable); 2938 } 2939 inline void setYOffsetForVPlane(const uint64_t value) { 2940 TheStructure._SurfaceFormatIsPlanar.YOffsetForVPlane = value; 2941 } 2942 inline uint64_t getYOffsetForVPlane() const { 2943 return (TheStructure._SurfaceFormatIsPlanar.YOffsetForVPlane); 2944 } 2945 inline void setXOffsetForVPlane(const uint64_t value) { 2946 TheStructure._SurfaceFormatIsPlanar.XOffsetForVPlane = value; 2947 } 2948 inline uint64_t getXOffsetForVPlane() const { 2949 return (TheStructure._SurfaceFormatIsPlanar.XOffsetForVPlane); 2950 } 2951 typedef enum tagAUXILIARYSURFACEBASEADDRESS { 2952 AUXILIARYSURFACEBASEADDRESS_BIT_SHIFT = 0xc, 2953 AUXILIARYSURFACEBASEADDRESS_ALIGN_SIZE = 0x1000, 2954 } AUXILIARYSURFACEBASEADDRESS; 2955 inline void setAuxiliarySurfaceBaseAddress(const uint64_t value) { 2956 TheStructure._SurfaceFormatIsnotPlanarAndMemoryCompressionEnableIs0.AuxiliarySurfaceBaseAddress = value >> AUXILIARYSURFACEBASEADDRESS_BIT_SHIFT; 2957 } 2958 inline uint64_t getAuxiliarySurfaceBaseAddress() const { 2959 return (TheStructure._SurfaceFormatIsnotPlanarAndMemoryCompressionEnableIs0.AuxiliarySurfaceBaseAddress << AUXILIARYSURFACEBASEADDRESS_BIT_SHIFT); 2960 } 2961 inline void setAuxiliaryTableIndexForMediaCompressedSurface(const uint64_t value) { 2962 TheStructure.MemoryCompressionEnableIs1.AuxiliaryTableIndexForMediaCompressedSurface = value; 2963 } 2964 inline uint64_t getAuxiliaryTableIndexForMediaCompressedSurface() const { 2965 return (TheStructure.MemoryCompressionEnableIs1.AuxiliaryTableIndexForMediaCompressedSurface); 2966 } 2967 inline void setHierarchicalDepthClearValue(const float value) { 2968 TheStructure.AuxiliarySurfaceModeIsAux_Hiz.HierarchicalDepthClearValue = value; 2969 } 2970 inline float getHierarchicalDepthClearValue() const { 2971 return (TheStructure.AuxiliarySurfaceModeIsAux_Hiz.HierarchicalDepthClearValue); 2972 } 2973 inline void setRedClearColor(const uint32_t value) { 2974 TheStructure.AuxiliarySurfaceModeIsAux_Ccs_DOrAuxiliarySurfaceModeIsAux_Ccs_E.RedClearColor = value; 2975 } 2976 inline uint32_t getRedClearColor() const { 2977 return (TheStructure.AuxiliarySurfaceModeIsAux_Ccs_DOrAuxiliarySurfaceModeIsAux_Ccs_E.RedClearColor); 2978 } 2979 inline void setGreenClearColor(const uint32_t value) { 2980 TheStructure.AuxiliarySurfaceModeIsAux_Ccs_DOrAuxiliarySurfaceModeIsAux_Ccs_E.GreenClearColor = value; 2981 } 2982 inline uint32_t getGreenClearColor() const { 2983 return (TheStructure.AuxiliarySurfaceModeIsAux_Ccs_DOrAuxiliarySurfaceModeIsAux_Ccs_E.GreenClearColor); 2984 } 2985 inline void setBlueClearColor(const uint32_t value) { 2986 TheStructure.AuxiliarySurfaceModeIsAux_Ccs_DOrAuxiliarySurfaceModeIsAux_Ccs_E.BlueClearColor = value; 2987 } 2988 inline uint32_t getBlueClearColor() const { 2989 return (TheStructure.AuxiliarySurfaceModeIsAux_Ccs_DOrAuxiliarySurfaceModeIsAux_Ccs_E.BlueClearColor); 2990 } 2991 inline void setAlphaClearColor(const uint32_t value) { 2992 TheStructure.AuxiliarySurfaceModeIsAux_Ccs_DOrAuxiliarySurfaceModeIsAux_Ccs_E.AlphaClearColor = value; 2993 } 2994 inline uint32_t getAlphaClearColor() const { 2995 return (TheStructure.AuxiliarySurfaceModeIsAux_Ccs_DOrAuxiliarySurfaceModeIsAux_Ccs_E.AlphaClearColor); 2996 } 2997} RENDER_SURFACE_STATE; 2998STATIC_ASSERT(64 == sizeof(RENDER_SURFACE_STATE)); 2999 3000typedef struct tagSAMPLER_STATE { 3001 union tagTheStructure { 3002 struct tagCommon { 3003 uint32_t LodAlgorithm : BITFIELD_RANGE(0, 0); 3004 uint32_t TextureLodBias : BITFIELD_RANGE(1, 13); 3005 uint32_t MinModeFilter : BITFIELD_RANGE(14, 16); 3006 uint32_t MagModeFilter : BITFIELD_RANGE(17, 19); 3007 uint32_t MipModeFilter : BITFIELD_RANGE(20, 21); 3008 uint32_t CoarseLodQualityMode : BITFIELD_RANGE(22, 26); 3009 uint32_t LodPreclampMode : BITFIELD_RANGE(27, 28); 3010 uint32_t TextureBorderColorMode : BITFIELD_RANGE(29, 29); 3011 uint32_t Reserved_30 : BITFIELD_RANGE(30, 30); 3012 uint32_t SamplerDisable : BITFIELD_RANGE(31, 31); 3013 uint32_t CubeSurfaceControlMode : BITFIELD_RANGE(0, 0); 3014 uint32_t ShadowFunction : BITFIELD_RANGE(1, 3); 3015 uint32_t ChromakeyMode : BITFIELD_RANGE(4, 4); 3016 uint32_t ChromakeyIndex : BITFIELD_RANGE(5, 6); 3017 uint32_t ChromakeyEnable : BITFIELD_RANGE(7, 7); 3018 uint32_t MaxLod : BITFIELD_RANGE(8, 19); 3019 uint32_t MinLod : BITFIELD_RANGE(20, 31); 3020 uint32_t LodClampMagnificationMode : BITFIELD_RANGE(0, 0); 3021 uint32_t Reserved_65 : BITFIELD_RANGE(1, 5); 3022 uint32_t IndirectStatePointer : BITFIELD_RANGE(6, 23); 3023 uint32_t Reserved_88 : BITFIELD_RANGE(24, 31); 3024 uint32_t TczAddressControlMode : BITFIELD_RANGE(0, 2); 3025 uint32_t TcyAddressControlMode : BITFIELD_RANGE(3, 5); 3026 uint32_t TcxAddressControlMode : BITFIELD_RANGE(6, 8); 3027 uint32_t ReductionTypeEnable : BITFIELD_RANGE(9, 9); 3028 uint32_t Non_NormalizedCoordinateEnable : BITFIELD_RANGE(10, 10); 3029 uint32_t TrilinearFilterQuality : BITFIELD_RANGE(11, 12); 3030 uint32_t RAddressMinFilterRoundingEnable : BITFIELD_RANGE(13, 13); 3031 uint32_t RAddressMagFilterRoundingEnable : BITFIELD_RANGE(14, 14); 3032 uint32_t VAddressMinFilterRoundingEnable : BITFIELD_RANGE(15, 15); 3033 uint32_t VAddressMagFilterRoundingEnable : BITFIELD_RANGE(16, 16); 3034 uint32_t UAddressMinFilterRoundingEnable : BITFIELD_RANGE(17, 17); 3035 uint32_t UAddressMagFilterRoundingEnable : BITFIELD_RANGE(18, 18); 3036 uint32_t MaximumAnisotropy : BITFIELD_RANGE(19, 21); 3037 uint32_t ReductionType : BITFIELD_RANGE(22, 23); 3038 uint32_t Reserved_120 : BITFIELD_RANGE(24, 31); 3039 } Common; 3040 uint32_t RawData[4]; 3041 } TheStructure; 3042 typedef enum tagLOD_ALGORITHM { 3043 LOD_ALGORITHM_LEGACY = 0x0, 3044 LOD_ALGORITHM_EWA_APPROXIMATION = 0x1, 3045 } LOD_ALGORITHM; 3046 typedef enum tagMIN_MODE_FILTER { 3047 MIN_MODE_FILTER_NEAREST = 0x0, 3048 MIN_MODE_FILTER_LINEAR = 0x1, 3049 MIN_MODE_FILTER_ANISOTROPIC = 0x2, 3050 MIN_MODE_FILTER_MONO = 0x6, 3051 } MIN_MODE_FILTER; 3052 typedef enum tagMAG_MODE_FILTER { 3053 MAG_MODE_FILTER_NEAREST = 0x0, 3054 MAG_MODE_FILTER_LINEAR = 0x1, 3055 MAG_MODE_FILTER_ANISOTROPIC = 0x2, 3056 MAG_MODE_FILTER_MONO = 0x6, 3057 } MAG_MODE_FILTER; 3058 typedef enum tagMIP_MODE_FILTER { 3059 MIP_MODE_FILTER_NONE = 0x0, 3060 MIP_MODE_FILTER_NEAREST = 0x1, 3061 MIP_MODE_FILTER_LINEAR = 0x3, 3062 } MIP_MODE_FILTER; 3063 typedef enum tagCOARSE_LOD_QUALITY_MODE { 3064 COARSE_LOD_QUALITY_MODE_DISABLED = 0x0, 3065 } COARSE_LOD_QUALITY_MODE; 3066 typedef enum tagLOD_PRECLAMP_MODE { 3067 LOD_PRECLAMP_MODE_NONE = 0x0, 3068 LOD_PRECLAMP_MODE_OGL = 0x2, 3069 } LOD_PRECLAMP_MODE; 3070 typedef enum tagTEXTURE_BORDER_COLOR_MODE { 3071 TEXTURE_BORDER_COLOR_MODE_DX10_OGL = 0x0, 3072 TEXTURE_BORDER_COLOR_MODE_DX9 = 0x1, 3073 } TEXTURE_BORDER_COLOR_MODE; 3074 typedef enum tagCUBE_SURFACE_CONTROL_MODE { 3075 CUBE_SURFACE_CONTROL_MODE_PROGRAMMED = 0x0, 3076 CUBE_SURFACE_CONTROL_MODE_OVERRIDE = 0x1, 3077 } CUBE_SURFACE_CONTROL_MODE; 3078 typedef enum tagSHADOW_FUNCTION { 3079 SHADOW_FUNCTION_PREFILTEROP_ALWAYS = 0x0, 3080 SHADOW_FUNCTION_PREFILTEROP_NEVER = 0x1, 3081 SHADOW_FUNCTION_PREFILTEROP_LESS = 0x2, 3082 SHADOW_FUNCTION_PREFILTEROP_EQUAL = 0x3, 3083 SHADOW_FUNCTION_PREFILTEROP_LEQUAL = 0x4, 3084 SHADOW_FUNCTION_PREFILTEROP_GREATER = 0x5, 3085 SHADOW_FUNCTION_PREFILTEROP_NOTEQUAL = 0x6, 3086 SHADOW_FUNCTION_PREFILTEROP_GEQUAL = 0x7, 3087 } SHADOW_FUNCTION; 3088 typedef enum tagCHROMAKEY_MODE { 3089 CHROMAKEY_MODE_KEYFILTER_KILL_ON_ANY_MATCH = 0x0, 3090 CHROMAKEY_MODE_KEYFILTER_REPLACE_BLACK = 0x1, 3091 } CHROMAKEY_MODE; 3092 typedef enum tagLOD_CLAMP_MAGNIFICATION_MODE { 3093 LOD_CLAMP_MAGNIFICATION_MODE_MIPNONE = 0x0, 3094 LOD_CLAMP_MAGNIFICATION_MODE_MIPFILTER = 0x1, 3095 } LOD_CLAMP_MAGNIFICATION_MODE; 3096 typedef enum tagTEXTURE_COORDINATE_MODE { 3097 TEXTURE_COORDINATE_MODE_WRAP = 0x0, 3098 TEXTURE_COORDINATE_MODE_MIRROR = 0x1, 3099 TEXTURE_COORDINATE_MODE_CLAMP = 0x2, 3100 TEXTURE_COORDINATE_MODE_CUBE = 0x3, 3101 TEXTURE_COORDINATE_MODE_CLAMP_BORDER = 0x4, 3102 TEXTURE_COORDINATE_MODE_MIRROR_ONCE = 0x5, 3103 TEXTURE_COORDINATE_MODE_HALF_BORDER = 0x6, 3104 TEXTURE_COORDINATE_MODE_MIRROR_101 = 0x7, 3105 } TEXTURE_COORDINATE_MODE; 3106 typedef enum tagTRILINEAR_FILTER_QUALITY { 3107 TRILINEAR_FILTER_QUALITY_FULL = 0x0, 3108 TRILINEAR_FILTER_QUALITY_TRIQUAL_HIGH_MAG_CLAMP_MIPFILTER = 0x1, 3109 TRILINEAR_FILTER_QUALITY_MED = 0x2, 3110 TRILINEAR_FILTER_QUALITY_LOW = 0x3, 3111 } TRILINEAR_FILTER_QUALITY; 3112 typedef enum tagMAXIMUM_ANISOTROPY { 3113 MAXIMUM_ANISOTROPY_RATIO_21 = 0x0, 3114 MAXIMUM_ANISOTROPY_RATIO_41 = 0x1, 3115 MAXIMUM_ANISOTROPY_RATIO_61 = 0x2, 3116 MAXIMUM_ANISOTROPY_RATIO_81 = 0x3, 3117 MAXIMUM_ANISOTROPY_RATIO_101 = 0x4, 3118 MAXIMUM_ANISOTROPY_RATIO_121 = 0x5, 3119 MAXIMUM_ANISOTROPY_RATIO_141 = 0x6, 3120 MAXIMUM_ANISOTROPY_RATIO_161 = 0x7, 3121 } MAXIMUM_ANISOTROPY; 3122 typedef enum tagREDUCTION_TYPE { 3123 REDUCTION_TYPE_STD_FILTER = 0x0, 3124 REDUCTION_TYPE_COMPARISON = 0x1, 3125 REDUCTION_TYPE_MINIMUM = 0x2, 3126 REDUCTION_TYPE_MAXIMUM = 0x3, 3127 } REDUCTION_TYPE; 3128 inline void init() { 3129 memset(&TheStructure, 0, sizeof(TheStructure)); 3130 TheStructure.Common.LodAlgorithm = LOD_ALGORITHM_LEGACY; 3131 TheStructure.Common.MinModeFilter = MIN_MODE_FILTER_NEAREST; 3132 TheStructure.Common.MagModeFilter = MAG_MODE_FILTER_NEAREST; 3133 TheStructure.Common.MipModeFilter = MIP_MODE_FILTER_NONE; 3134 TheStructure.Common.CoarseLodQualityMode = COARSE_LOD_QUALITY_MODE_DISABLED; 3135 TheStructure.Common.LodPreclampMode = LOD_PRECLAMP_MODE_NONE; 3136 TheStructure.Common.TextureBorderColorMode = TEXTURE_BORDER_COLOR_MODE_DX10_OGL; 3137 TheStructure.Common.CubeSurfaceControlMode = CUBE_SURFACE_CONTROL_MODE_PROGRAMMED; 3138 TheStructure.Common.ShadowFunction = SHADOW_FUNCTION_PREFILTEROP_ALWAYS; 3139 TheStructure.Common.ChromakeyMode = CHROMAKEY_MODE_KEYFILTER_KILL_ON_ANY_MATCH; 3140 TheStructure.Common.LodClampMagnificationMode = LOD_CLAMP_MAGNIFICATION_MODE_MIPNONE; 3141 TheStructure.Common.TczAddressControlMode = TEXTURE_COORDINATE_MODE_WRAP; 3142 TheStructure.Common.TcyAddressControlMode = TEXTURE_COORDINATE_MODE_WRAP; 3143 TheStructure.Common.TcxAddressControlMode = TEXTURE_COORDINATE_MODE_WRAP; 3144 TheStructure.Common.TrilinearFilterQuality = TRILINEAR_FILTER_QUALITY_FULL; 3145 TheStructure.Common.MaximumAnisotropy = MAXIMUM_ANISOTROPY_RATIO_21; 3146 TheStructure.Common.ReductionType = REDUCTION_TYPE_STD_FILTER; 3147 } 3148 static tagSAMPLER_STATE sInit() { 3149 SAMPLER_STATE state; 3150 state.init(); 3151 return state; 3152 } 3153 inline uint32_t &getRawData(const uint32_t index) { 3154 DEBUG_BREAK_IF(index >= 4); 3155 return TheStructure.RawData[index]; 3156 } 3157 inline void setLodAlgorithm(const LOD_ALGORITHM value) { 3158 TheStructure.Common.LodAlgorithm = value; 3159 } 3160 inline LOD_ALGORITHM getLodAlgorithm() const { 3161 return static_cast<LOD_ALGORITHM>(TheStructure.Common.LodAlgorithm); 3162 } 3163 inline void setTextureLodBias(const uint32_t value) { 3164 TheStructure.Common.TextureLodBias = value; 3165 } 3166 inline uint32_t getTextureLodBias() const { 3167 return (TheStructure.Common.TextureLodBias); 3168 } 3169 inline void setMinModeFilter(const MIN_MODE_FILTER value) { 3170 TheStructure.Common.MinModeFilter = value; 3171 } 3172 inline MIN_MODE_FILTER getMinModeFilter() const { 3173 return static_cast<MIN_MODE_FILTER>(TheStructure.Common.MinModeFilter); 3174 } 3175 inline void setMagModeFilter(const MAG_MODE_FILTER value) { 3176 TheStructure.Common.MagModeFilter = value; 3177 } 3178 inline MAG_MODE_FILTER getMagModeFilter() const { 3179 return static_cast<MAG_MODE_FILTER>(TheStructure.Common.MagModeFilter); 3180 } 3181 inline void setMipModeFilter(const MIP_MODE_FILTER value) { 3182 TheStructure.Common.MipModeFilter = value; 3183 } 3184 inline MIP_MODE_FILTER getMipModeFilter() const { 3185 return static_cast<MIP_MODE_FILTER>(TheStructure.Common.MipModeFilter); 3186 } 3187 inline void setCoarseLodQualityMode(const COARSE_LOD_QUALITY_MODE value) { 3188 TheStructure.Common.CoarseLodQualityMode = value; 3189 } 3190 inline COARSE_LOD_QUALITY_MODE getCoarseLodQualityMode() const { 3191 return static_cast<COARSE_LOD_QUALITY_MODE>(TheStructure.Common.CoarseLodQualityMode); 3192 } 3193 inline void setLodPreclampMode(const LOD_PRECLAMP_MODE value) { 3194 TheStructure.Common.LodPreclampMode = value; 3195 } 3196 inline LOD_PRECLAMP_MODE getLodPreclampMode() const { 3197 return static_cast<LOD_PRECLAMP_MODE>(TheStructure.Common.LodPreclampMode); 3198 } 3199 inline void setTextureBorderColorMode(const TEXTURE_BORDER_COLOR_MODE value) { 3200 TheStructure.Common.TextureBorderColorMode = value; 3201 } 3202 inline TEXTURE_BORDER_COLOR_MODE getTextureBorderColorMode() const { 3203 return static_cast<TEXTURE_BORDER_COLOR_MODE>(TheStructure.Common.TextureBorderColorMode); 3204 } 3205 inline void setSamplerDisable(const bool value) { 3206 TheStructure.Common.SamplerDisable = value; 3207 } 3208 inline bool getSamplerDisable() const { 3209 return (TheStructure.Common.SamplerDisable); 3210 } 3211 inline void setCubeSurfaceControlMode(const CUBE_SURFACE_CONTROL_MODE value) { 3212 TheStructure.Common.CubeSurfaceControlMode = value; 3213 } 3214 inline CUBE_SURFACE_CONTROL_MODE getCubeSurfaceControlMode() const { 3215 return static_cast<CUBE_SURFACE_CONTROL_MODE>(TheStructure.Common.CubeSurfaceControlMode); 3216 } 3217 inline void setShadowFunction(const SHADOW_FUNCTION value) { 3218 TheStructure.Common.ShadowFunction = value; 3219 } 3220 inline SHADOW_FUNCTION getShadowFunction() const { 3221 return static_cast<SHADOW_FUNCTION>(TheStructure.Common.ShadowFunction); 3222 } 3223 inline void setChromakeyMode(const CHROMAKEY_MODE value) { 3224 TheStructure.Common.ChromakeyMode = value; 3225 } 3226 inline CHROMAKEY_MODE getChromakeyMode() const { 3227 return static_cast<CHROMAKEY_MODE>(TheStructure.Common.ChromakeyMode); 3228 } 3229 inline void setChromakeyIndex(const uint32_t value) { 3230 TheStructure.Common.ChromakeyIndex = value; 3231 } 3232 inline uint32_t getChromakeyIndex() const { 3233 return (TheStructure.Common.ChromakeyIndex); 3234 } 3235 inline void setChromakeyEnable(const bool value) { 3236 TheStructure.Common.ChromakeyEnable = value; 3237 } 3238 inline bool getChromakeyEnable() const { 3239 return (TheStructure.Common.ChromakeyEnable); 3240 } 3241 inline void setMaxLod(const uint32_t value) { 3242 TheStructure.Common.MaxLod = value; 3243 } 3244 inline uint32_t getMaxLod() const { 3245 return (TheStructure.Common.MaxLod); 3246 } 3247 inline void setMinLod(const uint32_t value) { 3248 TheStructure.Common.MinLod = value; 3249 } 3250 inline uint32_t getMinLod() const { 3251 return (TheStructure.Common.MinLod); 3252 } 3253 inline void setLodClampMagnificationMode(const LOD_CLAMP_MAGNIFICATION_MODE value) { 3254 TheStructure.Common.LodClampMagnificationMode = value; 3255 } 3256 inline LOD_CLAMP_MAGNIFICATION_MODE getLodClampMagnificationMode() const { 3257 return static_cast<LOD_CLAMP_MAGNIFICATION_MODE>(TheStructure.Common.LodClampMagnificationMode); 3258 } 3259 typedef enum tagINDIRECTSTATEPOINTER { 3260 INDIRECTSTATEPOINTER_BIT_SHIFT = 0x6, 3261 INDIRECTSTATEPOINTER_ALIGN_SIZE = 0x40, 3262 } INDIRECTSTATEPOINTER; 3263 inline uint32_t getIndirectStatePointer() const { 3264 return (uint32_t)TheStructure.Common.IndirectStatePointer << INDIRECTSTATEPOINTER_BIT_SHIFT; 3265 } 3266 inline void setIndirectStatePointer(const uint32_t indirectStatePointerValue) { 3267 TheStructure.Common.IndirectStatePointer = indirectStatePointerValue >> INDIRECTSTATEPOINTER_BIT_SHIFT; 3268 } 3269 inline void setTczAddressControlMode(const TEXTURE_COORDINATE_MODE value) { 3270 TheStructure.Common.TczAddressControlMode = value; 3271 } 3272 inline TEXTURE_COORDINATE_MODE getTczAddressControlMode() const { 3273 return static_cast<TEXTURE_COORDINATE_MODE>(TheStructure.Common.TczAddressControlMode); 3274 } 3275 inline void setTcyAddressControlMode(const TEXTURE_COORDINATE_MODE value) { 3276 TheStructure.Common.TcyAddressControlMode = value; 3277 } 3278 inline TEXTURE_COORDINATE_MODE getTcyAddressControlMode() const { 3279 return static_cast<TEXTURE_COORDINATE_MODE>(TheStructure.Common.TcyAddressControlMode); 3280 } 3281 inline void setTcxAddressControlMode(const TEXTURE_COORDINATE_MODE value) { 3282 TheStructure.Common.TcxAddressControlMode = value; 3283 } 3284 inline TEXTURE_COORDINATE_MODE getTcxAddressControlMode() const { 3285 return static_cast<TEXTURE_COORDINATE_MODE>(TheStructure.Common.TcxAddressControlMode); 3286 } 3287 inline void setReductionTypeEnable(const bool value) { 3288 TheStructure.Common.ReductionTypeEnable = value; 3289 } 3290 inline bool getReductionTypeEnable() const { 3291 return (TheStructure.Common.ReductionTypeEnable); 3292 } 3293 inline void setNonNormalizedCoordinateEnable(const bool value) { 3294 TheStructure.Common.Non_NormalizedCoordinateEnable = value; 3295 } 3296 inline bool getNonNormalizedCoordinateEnable() const { 3297 return (TheStructure.Common.Non_NormalizedCoordinateEnable); 3298 } 3299 inline void setTrilinearFilterQuality(const TRILINEAR_FILTER_QUALITY value) { 3300 TheStructure.Common.TrilinearFilterQuality = value; 3301 } 3302 inline TRILINEAR_FILTER_QUALITY getTrilinearFilterQuality() const { 3303 return static_cast<TRILINEAR_FILTER_QUALITY>(TheStructure.Common.TrilinearFilterQuality); 3304 } 3305 inline void setRAddressMinFilterRoundingEnable(const bool value) { 3306 TheStructure.Common.RAddressMinFilterRoundingEnable = value; 3307 } 3308 inline bool getRAddressMinFilterRoundingEnable() const { 3309 return (TheStructure.Common.RAddressMinFilterRoundingEnable); 3310 } 3311 inline void setRAddressMagFilterRoundingEnable(const bool value) { 3312 TheStructure.Common.RAddressMagFilterRoundingEnable = value; 3313 } 3314 inline bool getRAddressMagFilterRoundingEnable() const { 3315 return (TheStructure.Common.RAddressMagFilterRoundingEnable); 3316 } 3317 inline void setVAddressMinFilterRoundingEnable(const bool value) { 3318 TheStructure.Common.VAddressMinFilterRoundingEnable = value; 3319 } 3320 inline bool getVAddressMinFilterRoundingEnable() const { 3321 return (TheStructure.Common.VAddressMinFilterRoundingEnable); 3322 } 3323 inline void setVAddressMagFilterRoundingEnable(const bool value) { 3324 TheStructure.Common.VAddressMagFilterRoundingEnable = value; 3325 } 3326 inline bool getVAddressMagFilterRoundingEnable() const { 3327 return (TheStructure.Common.VAddressMagFilterRoundingEnable); 3328 } 3329 inline void setUAddressMinFilterRoundingEnable(const bool value) { 3330 TheStructure.Common.UAddressMinFilterRoundingEnable = value; 3331 } 3332 inline bool getUAddressMinFilterRoundingEnable() const { 3333 return (TheStructure.Common.UAddressMinFilterRoundingEnable); 3334 } 3335 inline void setUAddressMagFilterRoundingEnable(const bool value) { 3336 TheStructure.Common.UAddressMagFilterRoundingEnable = value; 3337 } 3338 inline bool getUAddressMagFilterRoundingEnable() const { 3339 return (TheStructure.Common.UAddressMagFilterRoundingEnable); 3340 } 3341 inline void setMaximumAnisotropy(const MAXIMUM_ANISOTROPY value) { 3342 TheStructure.Common.MaximumAnisotropy = value; 3343 } 3344 inline MAXIMUM_ANISOTROPY getMaximumAnisotropy() const { 3345 return static_cast<MAXIMUM_ANISOTROPY>(TheStructure.Common.MaximumAnisotropy); 3346 } 3347 inline void setReductionType(const REDUCTION_TYPE value) { 3348 TheStructure.Common.ReductionType = value; 3349 } 3350 inline REDUCTION_TYPE getReductionType() const { 3351 return static_cast<REDUCTION_TYPE>(TheStructure.Common.ReductionType); 3352 } 3353} SAMPLER_STATE; 3354STATIC_ASSERT(16 == sizeof(SAMPLER_STATE)); 3355 3356typedef struct tagSTATE_BASE_ADDRESS { 3357 union tagTheStructure { 3358 struct tagCommon { 3359 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 3360 uint32_t Reserved_8 : BITFIELD_RANGE(8, 15); 3361 uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23); 3362 uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26); 3363 uint32_t CommandSubtype : BITFIELD_RANGE(27, 28); 3364 uint32_t CommandType : BITFIELD_RANGE(29, 31); 3365 uint64_t GeneralStateBaseAddressModifyEnable : BITFIELD_RANGE(0, 0); 3366 uint64_t Reserved_33 : BITFIELD_RANGE(1, 3); 3367 uint64_t GeneralStateMemoryObjectControlState_Reserved : BITFIELD_RANGE(4, 4); 3368 uint64_t GeneralStateMemoryObjectControlState_IndexToMocsTables : BITFIELD_RANGE(5, 10); 3369 uint64_t Reserved_43 : BITFIELD_RANGE(11, 11); 3370 uint64_t GeneralStateBaseAddress : BITFIELD_RANGE(12, 63); 3371 uint32_t Reserved_96 : BITFIELD_RANGE(0, 15); 3372 uint32_t StatelessDataPortAccessMemoryObjectControlState_Reserved : BITFIELD_RANGE(16, 16); 3373 uint32_t StatelessDataPortAccessMemoryObjectControlState_IndexToMocsTables : BITFIELD_RANGE(17, 22); 3374 uint32_t Reserved_119 : BITFIELD_RANGE(23, 31); 3375 uint64_t SurfaceStateBaseAddressModifyEnable : BITFIELD_RANGE(0, 0); 3376 uint64_t Reserved_129 : BITFIELD_RANGE(1, 3); 3377 uint64_t SurfaceStateMemoryObjectControlState_Reserved : BITFIELD_RANGE(4, 4); 3378 uint64_t SurfaceStateMemoryObjectControlState_IndexToMocsTables : BITFIELD_RANGE(5, 10); 3379 uint64_t Reserved_139 : BITFIELD_RANGE(11, 11); 3380 uint64_t SurfaceStateBaseAddress : BITFIELD_RANGE(12, 63); 3381 uint64_t DynamicStateBaseAddressModifyEnable : BITFIELD_RANGE(0, 0); 3382 uint64_t Reserved_193 : BITFIELD_RANGE(1, 3); 3383 uint64_t DynamicStateMemoryObjectControlState_Reserved : BITFIELD_RANGE(4, 4); 3384 uint64_t DynamicStateMemoryObjectControlState_IndexToMocsTables : BITFIELD_RANGE(5, 10); 3385 uint64_t Reserved_203 : BITFIELD_RANGE(11, 11); 3386 uint64_t DynamicStateBaseAddress : BITFIELD_RANGE(12, 63); 3387 uint64_t IndirectObjectBaseAddressModifyEnable : BITFIELD_RANGE(0, 0); 3388 uint64_t Reserved_257 : BITFIELD_RANGE(1, 3); 3389 uint64_t IndirectObjectMemoryObjectControlState_Reserved : BITFIELD_RANGE(4, 4); 3390 uint64_t IndirectObjectMemoryObjectControlState_IndexToMocsTables : BITFIELD_RANGE(5, 10); 3391 uint64_t Reserved_267 : BITFIELD_RANGE(11, 11); 3392 uint64_t IndirectObjectBaseAddress : BITFIELD_RANGE(12, 63); 3393 uint64_t InstructionBaseAddressModifyEnable : BITFIELD_RANGE(0, 0); 3394 uint64_t Reserved_321 : BITFIELD_RANGE(1, 3); 3395 uint64_t InstructionMemoryObjectControlState_Reserved : BITFIELD_RANGE(4, 4); 3396 uint64_t InstructionMemoryObjectControlState_IndexToMocsTables : BITFIELD_RANGE(5, 10); 3397 uint64_t Reserved_331 : BITFIELD_RANGE(11, 11); 3398 uint64_t InstructionBaseAddress : BITFIELD_RANGE(12, 63); 3399 uint32_t GeneralStateBufferSizeModifyEnable : BITFIELD_RANGE(0, 0); 3400 uint32_t Reserved_385 : BITFIELD_RANGE(1, 11); 3401 uint32_t GeneralStateBufferSize : BITFIELD_RANGE(12, 31); 3402 uint32_t DynamicStateBufferSizeModifyEnable : BITFIELD_RANGE(0, 0); 3403 uint32_t Reserved_417 : BITFIELD_RANGE(1, 11); 3404 uint32_t DynamicStateBufferSize : BITFIELD_RANGE(12, 31); 3405 uint32_t IndirectObjectBufferSizeModifyEnable : BITFIELD_RANGE(0, 0); 3406 uint32_t Reserved_449 : BITFIELD_RANGE(1, 11); 3407 uint32_t IndirectObjectBufferSize : BITFIELD_RANGE(12, 31); 3408 uint32_t InstructionBufferSizeModifyEnable : BITFIELD_RANGE(0, 0); 3409 uint32_t Reserved_481 : BITFIELD_RANGE(1, 11); 3410 uint32_t InstructionBufferSize : BITFIELD_RANGE(12, 31); 3411 uint64_t BindlessSurfaceStateBaseAddressModifyEnable : BITFIELD_RANGE(0, 0); 3412 uint64_t Reserved_513 : BITFIELD_RANGE(1, 3); 3413 uint64_t BindlessSurfaceStateMemoryObjectControlState_Reserved : BITFIELD_RANGE(4, 4); 3414 uint64_t BindlessSurfaceStateMemoryObjectControlState_IndexToMocsTables : BITFIELD_RANGE(5, 10); 3415 uint64_t Reserved_523 : BITFIELD_RANGE(11, 11); 3416 uint64_t BindlessSurfaceStateBaseAddress : BITFIELD_RANGE(12, 63); 3417 uint32_t Reserved_576 : BITFIELD_RANGE(0, 11); 3418 uint32_t BindlessSurfaceStateSize : BITFIELD_RANGE(12, 31); 3419 } Common; 3420 uint32_t RawData[19]; 3421 } TheStructure; 3422 typedef enum tagDWORD_LENGTH { 3423 DWORD_LENGTH_DWORD_COUNT_MODIFY = 0x10, 3424 DWORD_LENGTH_DWORD_COUNT_N = 0x11, 3425 } DWORD_LENGTH; 3426 typedef enum tag_3D_COMMAND_SUB_OPCODE { 3427 _3D_COMMAND_SUB_OPCODE_STATE_BASE_ADDRESS = 0x1, 3428 } _3D_COMMAND_SUB_OPCODE; 3429 typedef enum tag_3D_COMMAND_OPCODE { 3430 _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED = 0x1, 3431 } _3D_COMMAND_OPCODE; 3432 typedef enum tagCOMMAND_SUBTYPE { 3433 COMMAND_SUBTYPE_GFXPIPE_COMMON = 0x0, 3434 } COMMAND_SUBTYPE; 3435 typedef enum tagCOMMAND_TYPE { 3436 COMMAND_TYPE_GFXPIPE = 0x3, 3437 } COMMAND_TYPE; 3438 typedef enum tagPATCH_CONSTANTS { 3439 GENERALSTATEBASEADDRESS_BYTEOFFSET = 0x4, 3440 GENERALSTATEBASEADDRESS_INDEX = 0x1, 3441 SURFACESTATEBASEADDRESS_BYTEOFFSET = 0x10, 3442 SURFACESTATEBASEADDRESS_INDEX = 0x4, 3443 DYNAMICSTATEBASEADDRESS_BYTEOFFSET = 0x18, 3444 DYNAMICSTATEBASEADDRESS_INDEX = 0x6, 3445 INDIRECTOBJECTBASEADDRESS_BYTEOFFSET = 0x20, 3446 INDIRECTOBJECTBASEADDRESS_INDEX = 0x8, 3447 INSTRUCTIONBASEADDRESS_BYTEOFFSET = 0x28, 3448 INSTRUCTIONBASEADDRESS_INDEX = 0xa, 3449 BINDLESSSURFACESTATEBASEADDRESS_BYTEOFFSET = 0x40, 3450 BINDLESSSURFACESTATEBASEADDRESS_INDEX = 0x10, 3451 } PATCH_CONSTANTS; 3452 inline void init() { 3453 memset(&TheStructure, 0, sizeof(TheStructure)); 3454 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 3455 TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_STATE_BASE_ADDRESS; 3456 TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED; 3457 TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_COMMON; 3458 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 3459 } 3460 static tagSTATE_BASE_ADDRESS sInit() { 3461 STATE_BASE_ADDRESS state; 3462 state.init(); 3463 return state; 3464 } 3465 inline uint32_t &getRawData(const uint32_t index) { 3466 DEBUG_BREAK_IF(index >= 19); 3467 return TheStructure.RawData[index]; 3468 } 3469 inline void setGeneralStateBaseAddressModifyEnable(const bool value) { 3470 TheStructure.Common.GeneralStateBaseAddressModifyEnable = value; 3471 } 3472 inline bool getGeneralStateBaseAddressModifyEnable() const { 3473 return (TheStructure.Common.GeneralStateBaseAddressModifyEnable); 3474 } 3475 inline void setGeneralStateMemoryObjectControlStateReserved(const uint64_t value) { 3476 TheStructure.Common.GeneralStateMemoryObjectControlState_Reserved = value; 3477 } 3478 inline uint64_t getGeneralStateMemoryObjectControlStateReserved() const { 3479 return (TheStructure.Common.GeneralStateMemoryObjectControlState_Reserved); 3480 } 3481 inline void setGeneralStateMemoryObjectControlState(const uint64_t value) { 3482 TheStructure.Common.GeneralStateMemoryObjectControlState_IndexToMocsTables = value >> 1; 3483 } 3484 inline uint64_t getGeneralStateMemoryObjectControlState() const { 3485 return (TheStructure.Common.GeneralStateMemoryObjectControlState_IndexToMocsTables << 1); 3486 } 3487 typedef enum tagGENERALSTATEBASEADDRESS { 3488 GENERALSTATEBASEADDRESS_BIT_SHIFT = 0xc, 3489 GENERALSTATEBASEADDRESS_ALIGN_SIZE = 0x1000, 3490 } GENERALSTATEBASEADDRESS; 3491 inline void setGeneralStateBaseAddress(const uint64_t value) { 3492 TheStructure.Common.GeneralStateBaseAddress = value >> GENERALSTATEBASEADDRESS_BIT_SHIFT; 3493 } 3494 inline uint64_t getGeneralStateBaseAddress() const { 3495 return (TheStructure.Common.GeneralStateBaseAddress << GENERALSTATEBASEADDRESS_BIT_SHIFT); 3496 } 3497 inline void setStatelessDataPortAccessMemoryObjectControlStateReserved(const uint32_t value) { 3498 TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_Reserved = value; 3499 } 3500 inline uint32_t getStatelessDataPortAccessMemoryObjectControlStateReserved() const { 3501 return (TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_Reserved); 3502 } 3503 inline void setStatelessDataPortAccessMemoryObjectControlState(const uint32_t value) { 3504 TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_Reserved = value; 3505 TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_IndexToMocsTables = (value >> 1); 3506 } 3507 inline uint32_t getStatelessDataPortAccessMemoryObjectControlState() const { 3508 uint32_t mocs = TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_Reserved; 3509 mocs |= (TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_IndexToMocsTables << 1); 3510 return (mocs); 3511 } 3512 inline void setSurfaceStateBaseAddressModifyEnable(const bool value) { 3513 TheStructure.Common.SurfaceStateBaseAddressModifyEnable = value; 3514 } 3515 inline bool getSurfaceStateBaseAddressModifyEnable() const { 3516 return (TheStructure.Common.SurfaceStateBaseAddressModifyEnable); 3517 } 3518 inline void setSurfaceStateMemoryObjectControlStateReserved(const uint64_t value) { 3519 TheStructure.Common.SurfaceStateMemoryObjectControlState_Reserved = value; 3520 } 3521 inline uint64_t getSurfaceStateMemoryObjectControlStateReserved() const { 3522 return (TheStructure.Common.SurfaceStateMemoryObjectControlState_Reserved); 3523 } 3524 inline void setSurfaceStateMemoryObjectControlState(const uint64_t value) { 3525 TheStructure.Common.SurfaceStateMemoryObjectControlState_IndexToMocsTables = value >> 1; 3526 } 3527 inline uint64_t getSurfaceStateMemoryObjectControlState() const { 3528 return (TheStructure.Common.SurfaceStateMemoryObjectControlState_IndexToMocsTables << 1); 3529 } 3530 typedef enum tagSURFACESTATEBASEADDRESS { 3531 SURFACESTATEBASEADDRESS_BIT_SHIFT = 0xc, 3532 SURFACESTATEBASEADDRESS_ALIGN_SIZE = 0x1000, 3533 } SURFACESTATEBASEADDRESS; 3534 inline void setSurfaceStateBaseAddress(const uint64_t value) { 3535 TheStructure.Common.SurfaceStateBaseAddress = value >> SURFACESTATEBASEADDRESS_BIT_SHIFT; 3536 } 3537 inline uint64_t getSurfaceStateBaseAddress() const { 3538 return (TheStructure.Common.SurfaceStateBaseAddress << SURFACESTATEBASEADDRESS_BIT_SHIFT); 3539 } 3540 inline void setDynamicStateBaseAddressModifyEnable(const bool value) { 3541 TheStructure.Common.DynamicStateBaseAddressModifyEnable = value; 3542 } 3543 inline bool getDynamicStateBaseAddressModifyEnable() const { 3544 return (TheStructure.Common.DynamicStateBaseAddressModifyEnable); 3545 } 3546 inline void setDynamicStateMemoryObjectControlStateReserved(const uint64_t value) { 3547 TheStructure.Common.DynamicStateMemoryObjectControlState_Reserved = value; 3548 } 3549 inline uint64_t getDynamicStateMemoryObjectControlStateReserved() const { 3550 return (TheStructure.Common.DynamicStateMemoryObjectControlState_Reserved); 3551 } 3552 inline void setDynamicStateMemoryObjectControlState(const uint64_t value) { 3553 TheStructure.Common.DynamicStateMemoryObjectControlState_IndexToMocsTables = value >> 1; 3554 } 3555 inline uint64_t getDynamicStateMemoryObjectControlState() const { 3556 return (TheStructure.Common.DynamicStateMemoryObjectControlState_IndexToMocsTables << 1); 3557 } 3558 typedef enum tagDYNAMICSTATEBASEADDRESS { 3559 DYNAMICSTATEBASEADDRESS_BIT_SHIFT = 0xc, 3560 DYNAMICSTATEBASEADDRESS_ALIGN_SIZE = 0x1000, 3561 } DYNAMICSTATEBASEADDRESS; 3562 inline void setDynamicStateBaseAddress(const uint64_t value) { 3563 TheStructure.Common.DynamicStateBaseAddress = value >> DYNAMICSTATEBASEADDRESS_BIT_SHIFT; 3564 } 3565 inline uint64_t getDynamicStateBaseAddress() const { 3566 return (TheStructure.Common.DynamicStateBaseAddress << DYNAMICSTATEBASEADDRESS_BIT_SHIFT); 3567 } 3568 inline void setIndirectObjectBaseAddressModifyEnable(const bool value) { 3569 TheStructure.Common.IndirectObjectBaseAddressModifyEnable = value; 3570 } 3571 inline bool getIndirectObjectBaseAddressModifyEnable() const { 3572 return (TheStructure.Common.IndirectObjectBaseAddressModifyEnable); 3573 } 3574 inline void setIndirectObjectMemoryObjectControlStateReserved(const uint64_t value) { 3575 TheStructure.Common.IndirectObjectMemoryObjectControlState_Reserved = value; 3576 } 3577 inline uint64_t getIndirectObjectMemoryObjectControlStateReserved() const { 3578 return (TheStructure.Common.IndirectObjectMemoryObjectControlState_Reserved); 3579 } 3580 inline void setIndirectObjectMemoryObjectControlState(const uint64_t value) { 3581 TheStructure.Common.IndirectObjectMemoryObjectControlState_IndexToMocsTables = value >> 1; 3582 } 3583 inline uint64_t getIndirectObjectMemoryObjectControlState() const { 3584 return (TheStructure.Common.IndirectObjectMemoryObjectControlState_IndexToMocsTables << 1); 3585 } 3586 typedef enum tagINDIRECTOBJECTBASEADDRESS { 3587 INDIRECTOBJECTBASEADDRESS_BIT_SHIFT = 0xc, 3588 INDIRECTOBJECTBASEADDRESS_ALIGN_SIZE = 0x1000, 3589 } INDIRECTOBJECTBASEADDRESS; 3590 inline void setIndirectObjectBaseAddress(const uint64_t value) { 3591 TheStructure.Common.IndirectObjectBaseAddress = value >> INDIRECTOBJECTBASEADDRESS_BIT_SHIFT; 3592 } 3593 inline uint64_t getIndirectObjectBaseAddress() const { 3594 return (TheStructure.Common.IndirectObjectBaseAddress << INDIRECTOBJECTBASEADDRESS_BIT_SHIFT); 3595 } 3596 inline void setInstructionBaseAddressModifyEnable(const bool value) { 3597 TheStructure.Common.InstructionBaseAddressModifyEnable = value; 3598 } 3599 inline bool getInstructionBaseAddressModifyEnable() const { 3600 return (TheStructure.Common.InstructionBaseAddressModifyEnable); 3601 } 3602 inline void setInstructionMemoryObjectControlStateReserved(const uint64_t value) { 3603 TheStructure.Common.InstructionMemoryObjectControlState_Reserved = value; 3604 } 3605 inline uint64_t getInstructionMemoryObjectControlStateReserved() const { 3606 return (TheStructure.Common.InstructionMemoryObjectControlState_Reserved); 3607 } 3608 inline void setInstructionMemoryObjectControlState(const uint32_t value) { 3609 uint64_t val = static_cast<uint64_t>(value); 3610 TheStructure.Common.InstructionMemoryObjectControlState_Reserved = val; 3611 TheStructure.Common.InstructionMemoryObjectControlState_IndexToMocsTables = (val >> 1); 3612 } 3613 inline uint32_t getInstructionMemoryObjectControlState() const { 3614 uint64_t mocs = TheStructure.Common.InstructionMemoryObjectControlState_Reserved; 3615 mocs |= (TheStructure.Common.InstructionMemoryObjectControlState_IndexToMocsTables << 1); 3616 return static_cast<uint32_t>(mocs); 3617 } 3618 typedef enum tagINSTRUCTIONBASEADDRESS { 3619 INSTRUCTIONBASEADDRESS_BIT_SHIFT = 0xc, 3620 INSTRUCTIONBASEADDRESS_ALIGN_SIZE = 0x1000, 3621 } INSTRUCTIONBASEADDRESS; 3622 inline void setInstructionBaseAddress(const uint64_t value) { 3623 TheStructure.Common.InstructionBaseAddress = value >> INSTRUCTIONBASEADDRESS_BIT_SHIFT; 3624 } 3625 inline uint64_t getInstructionBaseAddress() const { 3626 return (TheStructure.Common.InstructionBaseAddress << INSTRUCTIONBASEADDRESS_BIT_SHIFT); 3627 } 3628 inline void setGeneralStateBufferSizeModifyEnable(const bool value) { 3629 TheStructure.Common.GeneralStateBufferSizeModifyEnable = value; 3630 } 3631 inline bool getGeneralStateBufferSizeModifyEnable() const { 3632 return (TheStructure.Common.GeneralStateBufferSizeModifyEnable); 3633 } 3634 inline void setGeneralStateBufferSize(const uint32_t value) { 3635 TheStructure.Common.GeneralStateBufferSize = value; 3636 } 3637 inline uint32_t getGeneralStateBufferSize() const { 3638 return (TheStructure.Common.GeneralStateBufferSize); 3639 } 3640 inline void setDynamicStateBufferSizeModifyEnable(const bool value) { 3641 TheStructure.Common.DynamicStateBufferSizeModifyEnable = value; 3642 } 3643 inline bool getDynamicStateBufferSizeModifyEnable() const { 3644 return (TheStructure.Common.DynamicStateBufferSizeModifyEnable); 3645 } 3646 inline void setDynamicStateBufferSize(const uint32_t value) { 3647 TheStructure.Common.DynamicStateBufferSize = value; 3648 } 3649 inline uint32_t getDynamicStateBufferSize() const { 3650 return (TheStructure.Common.DynamicStateBufferSize); 3651 } 3652 inline void setIndirectObjectBufferSizeModifyEnable(const bool value) { 3653 TheStructure.Common.IndirectObjectBufferSizeModifyEnable = value; 3654 } 3655 inline bool getIndirectObjectBufferSizeModifyEnable() const { 3656 return (TheStructure.Common.IndirectObjectBufferSizeModifyEnable); 3657 } 3658 inline void setIndirectObjectBufferSize(const uint32_t value) { 3659 TheStructure.Common.IndirectObjectBufferSize = value; 3660 } 3661 inline uint32_t getIndirectObjectBufferSize() const { 3662 return (TheStructure.Common.IndirectObjectBufferSize); 3663 } 3664 inline void setInstructionBufferSizeModifyEnable(const bool value) { 3665 TheStructure.Common.InstructionBufferSizeModifyEnable = value; 3666 } 3667 inline bool getInstructionBufferSizeModifyEnable() const { 3668 return (TheStructure.Common.InstructionBufferSizeModifyEnable); 3669 } 3670 inline void setInstructionBufferSize(const uint32_t value) { 3671 TheStructure.Common.InstructionBufferSize = value; 3672 } 3673 inline uint32_t getInstructionBufferSize() const { 3674 return (TheStructure.Common.InstructionBufferSize); 3675 } 3676 inline void setBindlessSurfaceStateBaseAddressModifyEnable(const bool value) { 3677 TheStructure.Common.BindlessSurfaceStateBaseAddressModifyEnable = value; 3678 } 3679 inline bool getBindlessSurfaceStateBaseAddressModifyEnable() const { 3680 return (TheStructure.Common.BindlessSurfaceStateBaseAddressModifyEnable); 3681 } 3682 inline void setBindlessSurfaceStateMemoryObjectControlStateReserved(const uint64_t value) { 3683 TheStructure.Common.BindlessSurfaceStateMemoryObjectControlState_Reserved = value; 3684 } 3685 inline uint64_t getBindlessSurfaceStateMemoryObjectControlStateReserved() const { 3686 return (TheStructure.Common.BindlessSurfaceStateMemoryObjectControlState_Reserved); 3687 } 3688 inline void setBindlessSurfaceStateMemoryObjectControlState(const uint64_t value) { 3689 TheStructure.Common.BindlessSurfaceStateMemoryObjectControlState_IndexToMocsTables = value >> 1; 3690 } 3691 inline uint64_t getBindlessSurfaceStateMemoryObjectControlState() const { 3692 return (TheStructure.Common.BindlessSurfaceStateMemoryObjectControlState_IndexToMocsTables << 1); 3693 } 3694 typedef enum tagBINDLESSSURFACESTATEBASEADDRESS { 3695 BINDLESSSURFACESTATEBASEADDRESS_BIT_SHIFT = 0xc, 3696 BINDLESSSURFACESTATEBASEADDRESS_ALIGN_SIZE = 0x1000, 3697 } BINDLESSSURFACESTATEBASEADDRESS; 3698 inline void setBindlessSurfaceStateBaseAddress(const uint64_t value) { 3699 TheStructure.Common.BindlessSurfaceStateBaseAddress = value >> BINDLESSSURFACESTATEBASEADDRESS_BIT_SHIFT; 3700 } 3701 inline uint64_t getBindlessSurfaceStateBaseAddress() const { 3702 return (TheStructure.Common.BindlessSurfaceStateBaseAddress << BINDLESSSURFACESTATEBASEADDRESS_BIT_SHIFT); 3703 } 3704 inline void setBindlessSurfaceStateSize(const uint32_t value) { 3705 TheStructure.Common.BindlessSurfaceStateSize = value; 3706 } 3707 inline uint32_t getBindlessSurfaceStateSize() const { 3708 return (TheStructure.Common.BindlessSurfaceStateSize); 3709 } 3710} STATE_BASE_ADDRESS; 3711STATIC_ASSERT(76 == sizeof(STATE_BASE_ADDRESS)); 3712 3713typedef struct tagMI_REPORT_PERF_COUNT { 3714 union tagTheStructure { 3715 struct tagCommon { 3716 uint32_t DwordLength : BITFIELD_RANGE(0, 5); 3717 uint32_t Reserved_6 : BITFIELD_RANGE(6, 22); 3718 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 3719 uint32_t CommandType : BITFIELD_RANGE(29, 31); 3720 uint64_t UseGlobalGtt : BITFIELD_RANGE(0, 0); 3721 uint64_t Reserved_33 : BITFIELD_RANGE(1, 3); 3722 uint64_t CoreModeEnable : BITFIELD_RANGE(4, 4); 3723 uint64_t Reserved_37 : BITFIELD_RANGE(5, 5); 3724 uint64_t MemoryAddress : BITFIELD_RANGE(6, 63); 3725 uint32_t ReportId; 3726 } Common; 3727 uint32_t RawData[4]; 3728 } TheStructure; 3729 typedef enum tagDWORD_LENGTH { 3730 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x2, 3731 } DWORD_LENGTH; 3732 typedef enum tagMI_COMMAND_OPCODE { 3733 MI_COMMAND_OPCODE_MI_REPORT_PERF_COUNT = 0x28, 3734 } MI_COMMAND_OPCODE; 3735 typedef enum tagCOMMAND_TYPE { 3736 COMMAND_TYPE_MI_COMMAND = 0x0, 3737 } COMMAND_TYPE; 3738 typedef enum tagPATCH_CONSTANTS { 3739 MEMORYADDRESS_BYTEOFFSET = 0x4, 3740 MEMORYADDRESS_INDEX = 0x1, 3741 } PATCH_CONSTANTS; 3742 inline void init() { 3743 memset(&TheStructure, 0, sizeof(TheStructure)); 3744 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 3745 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_REPORT_PERF_COUNT; 3746 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 3747 } 3748 static tagMI_REPORT_PERF_COUNT sInit() { 3749 MI_REPORT_PERF_COUNT state; 3750 state.init(); 3751 return state; 3752 } 3753 inline uint32_t &getRawData(const uint32_t index) { 3754 DEBUG_BREAK_IF(index >= 4); 3755 return TheStructure.RawData[index]; 3756 } 3757 inline void setUseGlobalGtt(const bool value) { 3758 TheStructure.Common.UseGlobalGtt = value; 3759 } 3760 inline bool getUseGlobalGtt() const { 3761 return (TheStructure.Common.UseGlobalGtt); 3762 } 3763 inline void setCoreModeEnable(const uint64_t value) { 3764 TheStructure.Common.CoreModeEnable = value; 3765 } 3766 inline uint64_t getCoreModeEnable() const { 3767 return (TheStructure.Common.CoreModeEnable); 3768 } 3769 typedef enum tagMEMORYADDRESS { 3770 MEMORYADDRESS_BIT_SHIFT = 0x6, 3771 MEMORYADDRESS_ALIGN_SIZE = 0x40, 3772 } MEMORYADDRESS; 3773 inline void setMemoryAddress(const uint64_t value) { 3774 TheStructure.Common.MemoryAddress = value >> MEMORYADDRESS_BIT_SHIFT; 3775 } 3776 inline uint64_t getMemoryAddress() const { 3777 return (TheStructure.Common.MemoryAddress << MEMORYADDRESS_BIT_SHIFT); 3778 } 3779 inline void setReportId(const uint32_t value) { 3780 TheStructure.Common.ReportId = value; 3781 } 3782 inline uint32_t getReportId() const { 3783 return (TheStructure.Common.ReportId); 3784 } 3785} MI_REPORT_PERF_COUNT; 3786STATIC_ASSERT(16 == sizeof(MI_REPORT_PERF_COUNT)); 3787 3788typedef struct tagGPGPU_CSR_BASE_ADDRESS { 3789 union tagTheStructure { 3790 struct tagCommon { 3791 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 3792 uint32_t Reserved_8 : BITFIELD_RANGE(8, 15); 3793 uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23); 3794 uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26); 3795 uint32_t CommandSubtype : BITFIELD_RANGE(27, 28); 3796 uint32_t CommandType : BITFIELD_RANGE(29, 31); 3797 uint64_t Reserved_32 : BITFIELD_RANGE(0, 11); 3798 uint64_t GpgpuCsrBaseAddress : BITFIELD_RANGE(12, 63); 3799 } Common; 3800 uint32_t RawData[3]; 3801 } TheStructure; 3802 typedef enum tagDWORD_LENGTH { 3803 DWORD_LENGTH_UNNAMED_1 = 0x1, 3804 } DWORD_LENGTH; 3805 typedef enum tag_3D_COMMAND_SUB_OPCODE { 3806 _3D_COMMAND_SUB_OPCODE_GPGPU_CSR_BASE_ADDRESS = 0x4, 3807 } _3D_COMMAND_SUB_OPCODE; 3808 typedef enum tag_3D_COMMAND_OPCODE { 3809 _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED = 0x1, 3810 } _3D_COMMAND_OPCODE; 3811 typedef enum tagCOMMAND_SUBTYPE { 3812 COMMAND_SUBTYPE_GFXPIPE_COMMON = 0x0, 3813 } COMMAND_SUBTYPE; 3814 typedef enum tagCOMMAND_TYPE { 3815 COMMAND_TYPE_GFXPIPE = 0x3, 3816 } COMMAND_TYPE; 3817 typedef enum tagPATCH_CONSTANTS { 3818 GPGPUCSRBASEADDRESS_BYTEOFFSET = 0x4, 3819 GPGPUCSRBASEADDRESS_INDEX = 0x1, 3820 } PATCH_CONSTANTS; 3821 inline void init() { 3822 memset(&TheStructure, 0, sizeof(TheStructure)); 3823 TheStructure.Common.DwordLength = DWORD_LENGTH_UNNAMED_1; 3824 TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_GPGPU_CSR_BASE_ADDRESS; 3825 TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED; 3826 TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_COMMON; 3827 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 3828 } 3829 static tagGPGPU_CSR_BASE_ADDRESS sInit() { 3830 GPGPU_CSR_BASE_ADDRESS state; 3831 state.init(); 3832 return state; 3833 } 3834 inline uint32_t &getRawData(uint32_t const index) { 3835 DEBUG_BREAK_IF(index >= 3); 3836 return TheStructure.RawData[index]; 3837 } 3838 typedef enum tagGPGPUCSRBASEADDRESS { 3839 GPGPUCSRBASEADDRESS_BIT_SHIFT = 0xC, 3840 GPGPUCSRBASEADDRESS_ALIGN_SIZE = 0x1000, 3841 } GPGPUCSRBASEADDRESS; 3842 inline uint64_t getGpgpuCsrBaseAddress() const { 3843 return (uint64_t)TheStructure.Common.GpgpuCsrBaseAddress << GPGPUCSRBASEADDRESS_BIT_SHIFT; 3844 } 3845 inline void setGpgpuCsrBaseAddress(uint64_t value) { 3846 TheStructure.Common.GpgpuCsrBaseAddress = value >> GPGPUCSRBASEADDRESS_BIT_SHIFT; 3847 } 3848} GPGPU_CSR_BASE_ADDRESS; 3849STATIC_ASSERT(12 == sizeof(GPGPU_CSR_BASE_ADDRESS)); 3850 3851typedef struct tagSTATE_SIP { 3852 union tagTheStructure { 3853 struct tagCommon { 3854 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 3855 uint32_t Reserved_8 : BITFIELD_RANGE(8, 15); 3856 uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23); 3857 uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26); 3858 uint32_t CommandSubtype : BITFIELD_RANGE(27, 28); 3859 uint32_t CommandType : BITFIELD_RANGE(29, 31); 3860 uint64_t Reserved_32 : BITFIELD_RANGE(0, 3); 3861 uint64_t SystemInstructionPointer : BITFIELD_RANGE(4, 63); 3862 } Common; 3863 uint32_t RawData[3]; 3864 } TheStructure; 3865 typedef enum tagDWORD_LENGTH { 3866 DWORD_LENGTH_DWORD_COUNT_N = 0x1, 3867 } DWORD_LENGTH; 3868 typedef enum tag_3D_COMMAND_SUB_OPCODE { 3869 _3D_COMMAND_SUB_OPCODE_STATE_SIP = 0x2, 3870 } _3D_COMMAND_SUB_OPCODE; 3871 typedef enum tag_3D_COMMAND_OPCODE { 3872 _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED = 0x1, 3873 } _3D_COMMAND_OPCODE; 3874 typedef enum tagCOMMAND_SUBTYPE { 3875 COMMAND_SUBTYPE_GFXPIPE_COMMON = 0x0, 3876 } COMMAND_SUBTYPE; 3877 typedef enum tagCOMMAND_TYPE { 3878 COMMAND_TYPE_GFXPIPE = 0x3, 3879 } COMMAND_TYPE; 3880 typedef enum tagPATCH_CONSTANTS { 3881 SYSTEMINSTRUCTIONPOINTER_BYTEOFFSET = 0x4, 3882 SYSTEMINSTRUCTIONPOINTER_INDEX = 0x1, 3883 } PATCH_CONSTANTS; 3884 void init() { 3885 memset(&TheStructure, 0, sizeof(TheStructure)); 3886 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 3887 TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_STATE_SIP; 3888 TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED; 3889 TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_COMMON; 3890 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 3891 } 3892 static tagSTATE_SIP sInit() { 3893 STATE_SIP state; 3894 state.init(); 3895 return state; 3896 } 3897 inline uint32_t &getRawData(uint32_t const index) { 3898 DEBUG_BREAK_IF(index >= 3); 3899 return TheStructure.RawData[index]; 3900 } 3901 typedef enum tagSYSTEMINSTRUCTIONPOINTER { 3902 SYSTEMINSTRUCTIONPOINTER_BIT_SHIFT = 0x4, 3903 SYSTEMINSTRUCTIONPOINTER_ALIGN_SIZE = 0x10, 3904 } SYSTEMINSTRUCTIONPOINTER; 3905 inline uint64_t getSystemInstructionPointer() const { 3906 return (uint64_t)TheStructure.Common.SystemInstructionPointer << SYSTEMINSTRUCTIONPOINTER_BIT_SHIFT; 3907 } 3908 inline void setSystemInstructionPointer(uint64_t value) { 3909 TheStructure.Common.SystemInstructionPointer = value >> SYSTEMINSTRUCTIONPOINTER_BIT_SHIFT; 3910 } 3911} STATE_SIP; 3912STATIC_ASSERT(12 == sizeof(STATE_SIP)); 3913 3914struct MI_USER_INTERRUPT { 3915 union tagTheStructure { 3916 struct tagCommon { 3917 uint32_t Reserved_0 : BITFIELD_RANGE(0, 22); 3918 uint32_t MICommandOpcode : BITFIELD_RANGE(23, 28); 3919 uint32_t CommandType : BITFIELD_RANGE(29, 31); 3920 } Common; 3921 uint32_t RawData[1]; 3922 } TheStructure; 3923 enum MI_COMMAND_OPCODE { 3924 MI_COMMAND_OPCODE_MI_USER_INTERRUPT = 2, 3925 }; 3926 enum COMMAND_TYPE { 3927 COMMAND_TYPE_MI_COMMAND = 0, 3928 }; 3929 inline void init() { 3930 memset(&TheStructure, 0, sizeof(TheStructure)); 3931 TheStructure.Common.MICommandOpcode = MI_COMMAND_OPCODE_MI_USER_INTERRUPT; 3932 } 3933 static MI_USER_INTERRUPT sInit() { 3934 MI_USER_INTERRUPT state; 3935 state.init(); 3936 return state; 3937 } 3938 inline uint32_t &getRawData(const uint32_t index) { 3939 return TheStructure.RawData[index]; 3940 } 3941}; 3942STATIC_ASSERT(4 == sizeof(MI_USER_INTERRUPT)); 3943 3944typedef struct tagMI_FLUSH_DW { 3945 union tagTheStructure { 3946 struct tagCommon { 3947 // DWORD 0 3948 uint32_t DwordLength : BITFIELD_RANGE(0, 5); 3949 uint32_t Reserved_6 : BITFIELD_RANGE(6, 7); 3950 uint32_t NotifyEnable : BITFIELD_RANGE(8, 8); 3951 uint32_t FlushLlc : BITFIELD_RANGE(9, 9); 3952 uint32_t Reserved_10 : BITFIELD_RANGE(10, 13); 3953 uint32_t PostSyncOperation : BITFIELD_RANGE(14, 15); 3954 uint32_t Reserved_16 : BITFIELD_RANGE(16, 16); 3955 uint32_t Reserved_17 : BITFIELD_RANGE(17, 17); 3956 uint32_t TlbInvalidate : BITFIELD_RANGE(18, 18); 3957 uint32_t Reserved_19 : BITFIELD_RANGE(19, 20); 3958 uint32_t StoreDataIndex : BITFIELD_RANGE(21, 21); 3959 uint32_t Reserved_22 : BITFIELD_RANGE(22, 22); 3960 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 3961 uint32_t CommandType : BITFIELD_RANGE(29, 31); 3962 // DWORD 1-2 3963 uint64_t Reserved_32 : BITFIELD_RANGE(0, 1); 3964 uint64_t DestinationAddressType : BITFIELD_RANGE(2, 2); 3965 uint64_t DestinationAddress : BITFIELD_RANGE(3, 47); 3966 uint64_t Reserved_80 : BITFIELD_RANGE(48, 63); 3967 // DWORD 3-4 3968 uint64_t ImmediateData; 3969 } Common; 3970 uint32_t RawData[5]; 3971 } TheStructure; 3972 typedef enum tagDWORD_LENGTH { 3973 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x3, 3974 } DWORD_LENGTH; 3975 typedef enum tagPOST_SYNC_OPERATION { 3976 POST_SYNC_OPERATION_NO_WRITE = 0x0, 3977 POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA_QWORD = 0x1, 3978 POST_SYNC_OPERATION_WRITE_TIMESTAMP_REGISTER = 0x3, 3979 } POST_SYNC_OPERATION; 3980 typedef enum tagMI_COMMAND_OPCODE { 3981 MI_COMMAND_OPCODE_MI_FLUSH_DW = 0x26, 3982 } MI_COMMAND_OPCODE; 3983 typedef enum tagCOMMAND_TYPE { 3984 COMMAND_TYPE_MI_COMMAND = 0x0, 3985 } COMMAND_TYPE; 3986 typedef enum tagDESTINATION_ADDRESS_TYPE { 3987 DESTINATION_ADDRESS_TYPE_PPGTT = 0x0, 3988 DESTINATION_ADDRESS_TYPE_GGTT = 0x1, 3989 } DESTINATION_ADDRESS_TYPE; 3990 inline void init() { 3991 memset(&TheStructure, 0, sizeof(TheStructure)); 3992 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 3993 TheStructure.Common.PostSyncOperation = POST_SYNC_OPERATION_NO_WRITE; 3994 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_FLUSH_DW; 3995 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 3996 TheStructure.Common.DestinationAddressType = DESTINATION_ADDRESS_TYPE_PPGTT; 3997 } 3998 static tagMI_FLUSH_DW sInit() { 3999 MI_FLUSH_DW state; 4000 state.init(); 4001 return state; 4002 } 4003 inline uint32_t &getRawData(const uint32_t index) { 4004 UNRECOVERABLE_IF(index >= 5); 4005 return TheStructure.RawData[index]; 4006 } 4007 inline void setNotifyEnable(const bool value) { 4008 TheStructure.Common.NotifyEnable = value; 4009 } 4010 inline bool getNotifyEnable() const { 4011 return TheStructure.Common.NotifyEnable; 4012 } 4013 inline void setFlushLlc(const bool value) { 4014 TheStructure.Common.FlushLlc = value; 4015 } 4016 inline bool getFlushLlc() const { 4017 return TheStructure.Common.FlushLlc; 4018 } 4019 inline void setPostSyncOperation(const POST_SYNC_OPERATION value) { 4020 TheStructure.Common.PostSyncOperation = value; 4021 } 4022 inline POST_SYNC_OPERATION getPostSyncOperation() const { 4023 return static_cast<POST_SYNC_OPERATION>(TheStructure.Common.PostSyncOperation); 4024 } 4025 inline void setTlbInvalidate(const bool value) { 4026 TheStructure.Common.TlbInvalidate = value; 4027 } 4028 inline bool getTlbInvalidate() const { 4029 return TheStructure.Common.TlbInvalidate; 4030 } 4031 inline void setStoreDataIndex(const bool value) { 4032 TheStructure.Common.StoreDataIndex = value; 4033 } 4034 inline bool getStoreDataIndex() const { 4035 return TheStructure.Common.StoreDataIndex; 4036 } 4037 inline void setDestinationAddressType(const DESTINATION_ADDRESS_TYPE value) { 4038 TheStructure.Common.DestinationAddressType = value; 4039 } 4040 inline DESTINATION_ADDRESS_TYPE getDestinationAddressType() const { 4041 return static_cast<DESTINATION_ADDRESS_TYPE>(TheStructure.Common.DestinationAddressType); 4042 } 4043 typedef enum tagDESTINATIONADDRESS { 4044 DESTINATIONADDRESS_BIT_SHIFT = 0x3, 4045 DESTINATIONADDRESS_ALIGN_SIZE = 0x8, 4046 } DESTINATIONADDRESS; 4047 inline void setDestinationAddress(const uint64_t value) { 4048 UNRECOVERABLE_IF(value > 0xfffffffffff8L); 4049 TheStructure.Common.DestinationAddress = value >> DESTINATIONADDRESS_BIT_SHIFT; 4050 } 4051 inline uint64_t getDestinationAddress() const { 4052 return TheStructure.Common.DestinationAddress << DESTINATIONADDRESS_BIT_SHIFT; 4053 } 4054 inline void setImmediateData(const uint64_t value) { 4055 TheStructure.Common.ImmediateData = value; 4056 } 4057 inline uint64_t getImmediateData() const { 4058 return TheStructure.Common.ImmediateData; 4059 } 4060} MI_FLUSH_DW; 4061STATIC_ASSERT(20 == sizeof(MI_FLUSH_DW)); 4062 4063typedef struct tagXY_SRC_COPY_BLT { 4064 union tagTheStructure { 4065 struct tagCommon { 4066 // DWORD 0 4067 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 4068 uint32_t Reserved_8 : BITFIELD_RANGE(8, 10); 4069 uint32_t DestTilingEnable : BITFIELD_RANGE(11, 11); 4070 uint32_t Reserved_12 : BITFIELD_RANGE(12, 14); 4071 uint32_t SrcTilingEnable : BITFIELD_RANGE(15, 15); 4072 uint32_t Reserved_16 : BITFIELD_RANGE(16, 19); 4073 uint32_t _32BppByteMask : BITFIELD_RANGE(20, 21); 4074 uint32_t InstructionTarget_Opcode : BITFIELD_RANGE(22, 28); 4075 uint32_t Client : BITFIELD_RANGE(29, 31); 4076 // DWORD 1 4077 uint32_t DestinationPitch : BITFIELD_RANGE(0, 15); 4078 uint32_t RasterOperation : BITFIELD_RANGE(16, 23); 4079 uint32_t ColorDepth : BITFIELD_RANGE(24, 25); 4080 uint32_t Reserved_58 : BITFIELD_RANGE(26, 29); 4081 uint32_t ClippingEnabled : BITFIELD_RANGE(30, 30); 4082 uint32_t Reserved_63 : BITFIELD_RANGE(31, 31); 4083 // DWORD 2 4084 uint32_t DestinationX1Coordinate_Left : BITFIELD_RANGE(0, 15); 4085 uint32_t DestinationY1Coordinate_Top : BITFIELD_RANGE(16, 31); 4086 // DWORD 3 4087 uint32_t DestinationX2Coordinate_Right : BITFIELD_RANGE(0, 15); 4088 uint32_t DestinationY2Coordinate_Bottom : BITFIELD_RANGE(16, 31); 4089 // DWORD 4-5 4090 uint64_t DestinationBaseAddress; 4091 // DWORD 6 4092 uint32_t SourceX1Coordinate_Left : BITFIELD_RANGE(0, 15); 4093 uint32_t SourceY1Coordinate_Top : BITFIELD_RANGE(16, 31); 4094 // DWORD 7 4095 uint32_t SourcePitch : BITFIELD_RANGE(0, 15); 4096 uint32_t Reserved_240 : BITFIELD_RANGE(16, 31); 4097 // DWORD 8-9 4098 uint64_t SourceBaseAddress; 4099 } Common; 4100 uint32_t RawData[10]; 4101 } TheStructure; 4102 typedef enum tagDEST_TILING_ENABLE { 4103 DEST_TILING_ENABLE_TILING_DISABLED_LINEAR_BLIT = 0x0, 4104 DEST_TILING_ENABLE_TILING_ENABLED = 0x1, 4105 } DEST_TILING_ENABLE; 4106 typedef enum tagSRC_TILING_ENABLE { 4107 SRC_TILING_ENABLE_TILING_DISABLED_LINEAR = 0x0, 4108 SRC_TILING_ENABLE_TILING_ENABLED = 0x1, 4109 } SRC_TILING_ENABLE; 4110 typedef enum tag_32BPP_BYTE_MASK { 4111 _32BPP_BYTE_MASK_WRITE_RGB_CHANNEL = 0x1, 4112 _32BPP_BYTE_MASK_WRITE_ALPHA_CHANNEL = 0x2, 4113 } _32BPP_BYTE_MASK; 4114 typedef enum tagCLIENT { 4115 CLIENT_2D_PROCESSOR = 0x2, 4116 } CLIENT; 4117 typedef enum tagCOLOR_DEPTH { 4118 COLOR_DEPTH_8_BIT_COLOR = 0x0, 4119 COLOR_DEPTH_16_BIT_COLOR565 = 0x1, 4120 COLOR_DEPTH_16_BIT_COLOR1555 = 0x2, 4121 COLOR_DEPTH_32_BIT_COLOR = 0x3, 4122 } COLOR_DEPTH; 4123 typedef enum tagCLIPPING_ENABLED { 4124 CLIPPING_ENABLED_DISABLED = 0x0, 4125 CLIPPING_ENABLED_ENABLED = 0x1, 4126 } CLIPPING_ENABLED; 4127 typedef enum tagINSTRUCTIONTARGET_OPCODE { 4128 INSTRUCTIONTARGET_OPCODE_OPCODE = 0x53, 4129 } INSTRUCTIONTARGET_OPCODE; 4130 typedef enum tagDWORD_LENGTH { 4131 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x8, 4132 } DWORD_LENGTH; 4133 inline void init() { 4134 memset(&TheStructure, 0, sizeof(TheStructure)); 4135 TheStructure.Common.DestTilingEnable = DEST_TILING_ENABLE_TILING_DISABLED_LINEAR_BLIT; 4136 TheStructure.Common.SrcTilingEnable = SRC_TILING_ENABLE_TILING_DISABLED_LINEAR; 4137 TheStructure.Common.Client = CLIENT_2D_PROCESSOR; 4138 TheStructure.Common.ColorDepth = COLOR_DEPTH_8_BIT_COLOR; 4139 TheStructure.Common.ClippingEnabled = CLIPPING_ENABLED_DISABLED; 4140 TheStructure.Common.InstructionTarget_Opcode = INSTRUCTIONTARGET_OPCODE_OPCODE; 4141 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 4142 TheStructure.Common.RasterOperation = 0xCC; 4143 } 4144 static tagXY_SRC_COPY_BLT sInit() { 4145 XY_SRC_COPY_BLT state; 4146 state.init(); 4147 return state; 4148 } 4149 inline uint32_t &getRawData(const uint32_t index) { 4150 UNRECOVERABLE_IF(index >= 10); 4151 return TheStructure.RawData[index]; 4152 } 4153 inline void setDestTilingEnable(const DEST_TILING_ENABLE value) { 4154 TheStructure.Common.DestTilingEnable = value; 4155 } 4156 inline DEST_TILING_ENABLE getDestTilingEnable() const { 4157 return static_cast<DEST_TILING_ENABLE>(TheStructure.Common.DestTilingEnable); 4158 } 4159 inline void setSrcTilingEnable(const SRC_TILING_ENABLE value) { 4160 TheStructure.Common.SrcTilingEnable = value; 4161 } 4162 inline SRC_TILING_ENABLE getSrcTilingEnable() const { 4163 return static_cast<SRC_TILING_ENABLE>(TheStructure.Common.SrcTilingEnable); 4164 } 4165 inline void set32BppByteMask(const _32BPP_BYTE_MASK value) { 4166 TheStructure.Common._32BppByteMask = value; 4167 } 4168 inline _32BPP_BYTE_MASK get32BppByteMask() const { 4169 return static_cast<_32BPP_BYTE_MASK>(TheStructure.Common._32BppByteMask); 4170 } 4171 inline void setInstructionTargetOpcode(const uint32_t value) { 4172 UNRECOVERABLE_IF(value > 0x1fc00000); 4173 TheStructure.Common.InstructionTarget_Opcode = value; 4174 } 4175 inline uint32_t getInstructionTargetOpcode() const { 4176 return TheStructure.Common.InstructionTarget_Opcode; 4177 } 4178 inline void setClient(const CLIENT value) { 4179 TheStructure.Common.Client = value; 4180 } 4181 inline CLIENT getClient() const { 4182 return static_cast<CLIENT>(TheStructure.Common.Client); 4183 } 4184 inline void setDestinationPitch(const uint32_t value) { 4185 UNRECOVERABLE_IF(value > 0xffff); 4186 TheStructure.Common.DestinationPitch = value; 4187 } 4188 inline uint32_t getDestinationPitch() const { 4189 return TheStructure.Common.DestinationPitch; 4190 } 4191 inline void setRasterOperation(const uint32_t value) { 4192 UNRECOVERABLE_IF(value > 0xff0000); 4193 TheStructure.Common.RasterOperation = value; 4194 } 4195 inline uint32_t getRasterOperation() const { 4196 return TheStructure.Common.RasterOperation; 4197 } 4198 inline void setColorDepth(const COLOR_DEPTH value) { 4199 TheStructure.Common.ColorDepth = value; 4200 } 4201 inline COLOR_DEPTH getColorDepth() const { 4202 return static_cast<COLOR_DEPTH>(TheStructure.Common.ColorDepth); 4203 } 4204 inline void setClippingEnabled(const CLIPPING_ENABLED value) { 4205 TheStructure.Common.ClippingEnabled = value; 4206 } 4207 inline CLIPPING_ENABLED getClippingEnabled() const { 4208 return static_cast<CLIPPING_ENABLED>(TheStructure.Common.ClippingEnabled); 4209 } 4210 inline void setDestinationX1CoordinateLeft(const uint32_t value) { 4211 UNRECOVERABLE_IF(value > 0xffff); 4212 TheStructure.Common.DestinationX1Coordinate_Left = value; 4213 } 4214 inline uint32_t getDestinationX1CoordinateLeft() const { 4215 return TheStructure.Common.DestinationX1Coordinate_Left; 4216 } 4217 inline void setDestinationY1CoordinateTop(const uint32_t value) { 4218 UNRECOVERABLE_IF(value > 0xffff0000); 4219 TheStructure.Common.DestinationY1Coordinate_Top = value; 4220 } 4221 inline uint32_t getDestinationY1CoordinateTop() const { 4222 return TheStructure.Common.DestinationY1Coordinate_Top; 4223 } 4224 inline void setDestinationX2CoordinateRight(const uint32_t value) { 4225 UNRECOVERABLE_IF(value > 0xffff); 4226 TheStructure.Common.DestinationX2Coordinate_Right = value; 4227 } 4228 inline uint32_t getDestinationX2CoordinateRight() const { 4229 return TheStructure.Common.DestinationX2Coordinate_Right; 4230 } 4231 inline void setDestinationY2CoordinateBottom(const uint32_t value) { 4232 UNRECOVERABLE_IF(value > 0xffff0000); 4233 TheStructure.Common.DestinationY2Coordinate_Bottom = value; 4234 } 4235 inline uint32_t getDestinationY2CoordinateBottom() const { 4236 return TheStructure.Common.DestinationY2Coordinate_Bottom; 4237 } 4238 inline void setDestinationBaseAddress(const uint64_t value) { 4239 TheStructure.Common.DestinationBaseAddress = value; 4240 } 4241 inline uint64_t getDestinationBaseAddress() const { 4242 return TheStructure.Common.DestinationBaseAddress; 4243 } 4244 inline void setSourceX1CoordinateLeft(const uint32_t value) { 4245 UNRECOVERABLE_IF(value > 0xffff); 4246 TheStructure.Common.SourceX1Coordinate_Left = value; 4247 } 4248 inline uint32_t getSourceX1CoordinateLeft() const { 4249 return TheStructure.Common.SourceX1Coordinate_Left; 4250 } 4251 inline void setSourceY1CoordinateTop(const uint32_t value) { 4252 UNRECOVERABLE_IF(value > 0xffff0000); 4253 TheStructure.Common.SourceY1Coordinate_Top = value; 4254 } 4255 inline uint32_t getSourceY1CoordinateTop() const { 4256 return TheStructure.Common.SourceY1Coordinate_Top; 4257 } 4258 inline void setSourcePitch(const uint32_t value) { 4259 UNRECOVERABLE_IF(value > 0xffff); 4260 TheStructure.Common.SourcePitch = value; 4261 } 4262 inline uint32_t getSourcePitch() const { 4263 return TheStructure.Common.SourcePitch; 4264 } 4265 inline void setSourceBaseAddress(const uint64_t value) { 4266 TheStructure.Common.SourceBaseAddress = value; 4267 } 4268 inline uint64_t getSourceBaseAddress() const { 4269 return TheStructure.Common.SourceBaseAddress; 4270 } 4271} XY_SRC_COPY_BLT; 4272STATIC_ASSERT(40 == sizeof(XY_SRC_COPY_BLT)); 4273 4274typedef struct tagXY_COLOR_BLT { 4275 union tagTheStructure { 4276 struct tagCommon { 4277 // DWORD 0 4278 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 4279 uint32_t Reserved_8 : BITFIELD_RANGE(8, 10); 4280 uint32_t DestTilingEnable : BITFIELD_RANGE(11, 11); 4281 uint32_t Reserved_12 : BITFIELD_RANGE(12, 19); 4282 uint32_t _32BppByteMask : BITFIELD_RANGE(20, 21); 4283 uint32_t InstructionTarget_Opcode : BITFIELD_RANGE(22, 28); 4284 uint32_t Client : BITFIELD_RANGE(29, 31); 4285 // DWORD 1 4286 uint32_t DestinationPitch : BITFIELD_RANGE(0, 15); 4287 uint32_t RasterOperation : BITFIELD_RANGE(16, 23); 4288 uint32_t ColorDepth : BITFIELD_RANGE(24, 25); 4289 uint32_t Reserved_58 : BITFIELD_RANGE(26, 29); 4290 uint32_t ClippingEnabled : BITFIELD_RANGE(30, 30); 4291 uint32_t Reserved_63 : BITFIELD_RANGE(31, 31); 4292 // DWORD 2 4293 uint32_t DestinationX1Coordinate_Left : BITFIELD_RANGE(0, 15); 4294 uint32_t DestinationY1Coordinate_Top : BITFIELD_RANGE(16, 31); 4295 // DWORD 3 4296 uint32_t DestinationX2Coordinate_Right : BITFIELD_RANGE(0, 15); 4297 uint32_t DestinationY2Coordinate_Bottom : BITFIELD_RANGE(16, 31); 4298 // DWORD 4-5 4299 uint64_t DestinationBaseAddress; 4300 // DWORD 6 4301 uint32_t SolidPaternColor; 4302 } Common; 4303 uint32_t RawData[7]; 4304 } TheStructure; 4305 typedef enum tagDEST_TILING_ENABLE { 4306 DEST_TILING_ENABLE_TILING_DISABLED_LINEAR_BLIT = 0x0, 4307 DEST_TILING_ENABLE_TILING_ENABLED = 0x1, 4308 } DEST_TILING_ENABLE; 4309 typedef enum tag_32BPP_BYTE_MASK { 4310 _32BPP_BYTE_MASK_WRITE_RGB_CHANNEL = 0x1, 4311 _32BPP_BYTE_MASK_WRITE_ALPHA_CHANNEL = 0x2, 4312 _32BPP_BYTE_MASK_WRITE_RGBA_CHANNEL = 0x3 4313 } _32BPP_BYTE_MASK; 4314 typedef enum tagCLIENT { 4315 CLIENT_2D_PROCESSOR = 0x2, 4316 } CLIENT; 4317 typedef enum tagCOLOR_DEPTH { 4318 COLOR_DEPTH_8_BIT_COLOR = 0x0, 4319 COLOR_DEPTH_16_BIT_COLOR565 = 0x1, 4320 COLOR_DEPTH_16_BIT_COLOR1555 = 0x2, 4321 COLOR_DEPTH_32_BIT_COLOR = 0x3, 4322 } COLOR_DEPTH; 4323 typedef enum tagCLIPPING_ENABLED { 4324 CLIPPING_ENABLED_DISABLED = 0x0, 4325 CLIPPING_ENABLED_ENABLED = 0x1, 4326 } CLIPPING_ENABLED; 4327 typedef enum tagINSTRUCTIONTARGET_OPCODE { 4328 INSTRUCTIONTARGET_OPCODE_OPCODE = 0x50, 4329 } INSTRUCTIONTARGET_OPCODE; 4330 typedef enum tagDWORD_LENGTH { 4331 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x5, 4332 } DWORD_LENGTH; 4333 inline void init() { 4334 memset(&TheStructure, 0, sizeof(TheStructure)); 4335 TheStructure.Common.DestTilingEnable = DEST_TILING_ENABLE_TILING_DISABLED_LINEAR_BLIT; 4336 TheStructure.Common.Client = CLIENT_2D_PROCESSOR; 4337 TheStructure.Common.ColorDepth = COLOR_DEPTH_8_BIT_COLOR; 4338 TheStructure.Common.ClippingEnabled = CLIPPING_ENABLED_DISABLED; 4339 TheStructure.Common.InstructionTarget_Opcode = INSTRUCTIONTARGET_OPCODE_OPCODE; 4340 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 4341 TheStructure.Common.RasterOperation = 0xF0; 4342 } 4343 static tagXY_COLOR_BLT sInit() { 4344 XY_COLOR_BLT state; 4345 state.init(); 4346 return state; 4347 } 4348 inline uint32_t &getRawData(const uint32_t index) { 4349 UNRECOVERABLE_IF(index >= 10); 4350 return TheStructure.RawData[index]; 4351 } 4352 inline void setDestTilingEnable(const DEST_TILING_ENABLE value) { 4353 TheStructure.Common.DestTilingEnable = value; 4354 } 4355 inline DEST_TILING_ENABLE getDestTilingEnable() const { 4356 return static_cast<DEST_TILING_ENABLE>(TheStructure.Common.DestTilingEnable); 4357 } 4358 inline void set32BppByteMask(const _32BPP_BYTE_MASK value) { 4359 TheStructure.Common._32BppByteMask = value; 4360 } 4361 inline _32BPP_BYTE_MASK get32BppByteMask() const { 4362 return static_cast<_32BPP_BYTE_MASK>(TheStructure.Common._32BppByteMask); 4363 } 4364 inline void setInstructionTargetOpcode(const uint32_t value) { 4365 UNRECOVERABLE_IF(value > 0x1fc00000); 4366 TheStructure.Common.InstructionTarget_Opcode = value; 4367 } 4368 inline uint32_t getInstructionTargetOpcode() const { 4369 return TheStructure.Common.InstructionTarget_Opcode; 4370 } 4371 inline void setClient(const CLIENT value) { 4372 TheStructure.Common.Client = value; 4373 } 4374 inline CLIENT getClient() const { 4375 return static_cast<CLIENT>(TheStructure.Common.Client); 4376 } 4377 inline void setDestinationPitch(const uint32_t value) { 4378 UNRECOVERABLE_IF(value > 0xffff); 4379 TheStructure.Common.DestinationPitch = value; 4380 } 4381 inline uint32_t getDestinationPitch() const { 4382 return TheStructure.Common.DestinationPitch; 4383 } 4384 inline void setRasterOperation(const uint32_t value) { 4385 UNRECOVERABLE_IF(value > 0xff0000); 4386 TheStructure.Common.RasterOperation = value; 4387 } 4388 inline uint32_t getRasterOperation() const { 4389 return TheStructure.Common.RasterOperation; 4390 } 4391 inline void setColorDepth(const COLOR_DEPTH value) { 4392 TheStructure.Common.ColorDepth = value; 4393 } 4394 inline COLOR_DEPTH getColorDepth() const { 4395 return static_cast<COLOR_DEPTH>(TheStructure.Common.ColorDepth); 4396 } 4397 inline void setClippingEnabled(const CLIPPING_ENABLED value) { 4398 TheStructure.Common.ClippingEnabled = value; 4399 } 4400 inline CLIPPING_ENABLED getClippingEnabled() const { 4401 return static_cast<CLIPPING_ENABLED>(TheStructure.Common.ClippingEnabled); 4402 } 4403 inline void setDestinationX1CoordinateLeft(const uint32_t value) { 4404 UNRECOVERABLE_IF(value > 0xffff); 4405 TheStructure.Common.DestinationX1Coordinate_Left = value; 4406 } 4407 inline uint32_t getDestinationX1CoordinateLeft() const { 4408 return TheStructure.Common.DestinationX1Coordinate_Left; 4409 } 4410 inline void setDestinationY1CoordinateTop(const uint32_t value) { 4411 UNRECOVERABLE_IF(value > 0xffff0000); 4412 TheStructure.Common.DestinationY1Coordinate_Top = value; 4413 } 4414 inline uint32_t getDestinationY1CoordinateTop() const { 4415 return TheStructure.Common.DestinationY1Coordinate_Top; 4416 } 4417 inline void setDestinationX2CoordinateRight(const uint32_t value) { 4418 UNRECOVERABLE_IF(value > 0xffff); 4419 TheStructure.Common.DestinationX2Coordinate_Right = value; 4420 } 4421 inline uint32_t getDestinationX2CoordinateRight() const { 4422 return TheStructure.Common.DestinationX2Coordinate_Right; 4423 } 4424 inline void setDestinationY2CoordinateBottom(const uint32_t value) { 4425 UNRECOVERABLE_IF(value > 0xffff0000); 4426 TheStructure.Common.DestinationY2Coordinate_Bottom = value; 4427 } 4428 inline uint32_t getDestinationY2CoordinateBottom() const { 4429 return TheStructure.Common.DestinationY2Coordinate_Bottom; 4430 } 4431 inline void setDestinationBaseAddress(const uint64_t value) { 4432 TheStructure.Common.DestinationBaseAddress = value; 4433 } 4434 inline uint64_t getDestinationBaseAddress() const { 4435 return TheStructure.Common.DestinationBaseAddress; 4436 } 4437 inline void setFillColor(const uint32_t *value) { 4438 TheStructure.Common.SolidPaternColor = *value; 4439 } 4440} XY_COLOR_BLT; 4441STATIC_ASSERT(28 == sizeof(XY_COLOR_BLT)); 4442 4443typedef struct tagGRF { 4444 union tagTheStructure { 4445 float fRegs[8]; 4446 uint32_t dwRegs[8]; 4447 uint16_t wRegs[16]; 4448 uint32_t RawData[8]; 4449 } TheStructure; 4450} GRF; 4451STATIC_ASSERT(32 == sizeof(GRF)); 4452 4453typedef struct tagMEDIA_SURFACE_STATE { 4454 union tagTheStructure { 4455 struct tagCommon { 4456 uint32_t Reserved_0 : BITFIELD_RANGE(0, 29); 4457 uint32_t Rotation : BITFIELD_RANGE(30, 31); 4458 uint32_t Cr_VCb_UPixelOffsetVDirection : BITFIELD_RANGE(0, 1); 4459 uint32_t PictureStructure : BITFIELD_RANGE(2, 3); 4460 uint32_t Width : BITFIELD_RANGE(4, 17); 4461 uint32_t Height : BITFIELD_RANGE(18, 31); 4462 uint32_t TileMode : BITFIELD_RANGE(0, 1); 4463 uint32_t HalfPitchForChroma : BITFIELD_RANGE(2, 2); 4464 uint32_t SurfacePitch : BITFIELD_RANGE(3, 20); 4465 uint32_t AddressControl : BITFIELD_RANGE(21, 21); 4466 uint32_t MemoryCompressionEnable : BITFIELD_RANGE(22, 22); 4467 uint32_t MemoryCompressionMode : BITFIELD_RANGE(23, 23); 4468 uint32_t Cr_VCb_UPixelOffsetVDirectionMsb : BITFIELD_RANGE(24, 24); 4469 uint32_t Cr_VCb_UPixelOffsetUDirection : BITFIELD_RANGE(25, 25); 4470 uint32_t InterleaveChroma : BITFIELD_RANGE(26, 26); 4471 uint32_t SurfaceFormat : BITFIELD_RANGE(27, 31); 4472 uint32_t YOffsetForU_Cb : BITFIELD_RANGE(0, 13); 4473 uint32_t Reserved_110 : BITFIELD_RANGE(14, 15); 4474 uint32_t XOffsetForU_Cb : BITFIELD_RANGE(16, 29); 4475 uint32_t Reserved_126 : BITFIELD_RANGE(30, 31); 4476 uint32_t Reserved_128; 4477 uint32_t SurfaceMemoryObjectControlState_Reserved : BITFIELD_RANGE(0, 0); 4478 uint32_t SurfaceMemoryObjectControlState_IndexToMocsTables : BITFIELD_RANGE(1, 6); 4479 uint32_t Reserved_167 : BITFIELD_RANGE(7, 17); 4480 uint32_t TiledResourceMode : BITFIELD_RANGE(18, 19); 4481 uint32_t Reserved_180 : BITFIELD_RANGE(20, 29); 4482 uint32_t VerticalLineStrideOffset : BITFIELD_RANGE(30, 30); 4483 uint32_t VerticalLineStride : BITFIELD_RANGE(31, 31); 4484 uint32_t SurfaceBaseAddressLow; 4485 uint32_t SurfaceBaseAddressHigh : BITFIELD_RANGE(0, 15); 4486 uint32_t Reserved_240 : BITFIELD_RANGE(16, 31); 4487 } Common; 4488 struct tagSurfaceFormatIsNotOneOfPlanarFormats { 4489 uint32_t Reserved_0; 4490 uint32_t Reserved_32; 4491 uint32_t Reserved_64; 4492 uint32_t Reserved_96; 4493 uint32_t Reserved_128; 4494 uint32_t Reserved_160; 4495 uint32_t Reserved_192; 4496 uint32_t Reserved_224; 4497 } SurfaceFormatIsNotOneOfPlanarFormats; 4498 struct tagSurfaceFormatIsOneOfPlanarFormats { 4499 uint32_t Reserved_0 : BITFIELD_RANGE(0, 15); 4500 uint32_t YOffset : BITFIELD_RANGE(16, 19); 4501 uint32_t XOffset : BITFIELD_RANGE(20, 26); 4502 uint32_t Reserved_27 : BITFIELD_RANGE(27, 31); 4503 uint32_t Reserved_32; 4504 uint32_t Reserved_64; 4505 uint32_t Reserved_96; 4506 uint32_t Reserved_128; 4507 uint32_t Reserved_160; 4508 uint32_t Reserved_192; 4509 uint32_t Reserved_224; 4510 } SurfaceFormatIsOneOfPlanarFormats; 4511 struct tag_SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0 { 4512 uint32_t Reserved_0; 4513 uint32_t Reserved_32; 4514 uint32_t Reserved_64; 4515 uint32_t Reserved_96; 4516 uint32_t YOffsetForV_Cr : BITFIELD_RANGE(0, 14); 4517 uint32_t Reserved_143 : BITFIELD_RANGE(15, 15); 4518 uint32_t XOffsetForV_Cr : BITFIELD_RANGE(16, 29); 4519 uint32_t Reserved_158 : BITFIELD_RANGE(30, 31); 4520 uint32_t Reserved_160; 4521 uint32_t Reserved_192; 4522 uint32_t Reserved_224; 4523 } _SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0; 4524 uint32_t RawData[8]; 4525 } TheStructure; 4526 typedef enum tagROTATION { 4527 ROTATION_NO_ROTATION_OR_0_DEGREE = 0x0, 4528 ROTATION_90_DEGREE_ROTATION = 0x1, 4529 ROTATION_180_DEGREE_ROTATION = 0x2, 4530 ROTATION_270_DEGREE_ROTATION = 0x3, 4531 } ROTATION; 4532 typedef enum tagPICTURE_STRUCTURE { 4533 PICTURE_STRUCTURE_FRAME_PICTURE = 0x0, 4534 PICTURE_STRUCTURE_TOP_FIELD_PICTURE = 0x1, 4535 PICTURE_STRUCTURE_BOTTOM_FIELD_PICTURE = 0x2, 4536 PICTURE_STRUCTURE_INVALID_NOT_ALLOWED = 0x3, 4537 } PICTURE_STRUCTURE; 4538 typedef enum tagTILE_MODE { 4539 TILE_MODE_TILEMODE_LINEAR = 0x0, 4540 TILE_MODE_TILEMODE_XMAJOR = 0x2, 4541 TILE_MODE_TILEMODE_YMAJOR = 0x3, 4542 } TILE_MODE; 4543 typedef enum tagADDRESS_CONTROL { 4544 ADDRESS_CONTROL_CLAMP = 0x0, 4545 ADDRESS_CONTROL_MIRROR = 0x1, 4546 } ADDRESS_CONTROL; 4547 typedef enum tagMEMORY_COMPRESSION_MODE { 4548 MEMORY_COMPRESSION_MODE_HORIZONTAL_COMPRESSION_MODE = 0x0, 4549 MEMORY_COMPRESSION_MODE_VERTICAL_COMPRESSION_MODE = 0x1, 4550 } MEMORY_COMPRESSION_MODE; 4551 typedef enum tagSURFACE_FORMAT { 4552 SURFACE_FORMAT_YCRCB_NORMAL = 0x0, 4553 SURFACE_FORMAT_YCRCB_SWAPUVY = 0x1, 4554 SURFACE_FORMAT_YCRCB_SWAPUV = 0x2, 4555 SURFACE_FORMAT_YCRCB_SWAPY = 0x3, 4556 SURFACE_FORMAT_PLANAR_420_8 = 0x4, 4557 SURFACE_FORMAT_Y8_UNORM_VA = 0x5, 4558 SURFACE_FORMAT_Y16_SNORM = 0x6, 4559 SURFACE_FORMAT_Y16_UNORM_VA = 0x7, 4560 SURFACE_FORMAT_R10G10B10A2_UNORM = 0x8, 4561 SURFACE_FORMAT_R8G8B8A8_UNORM = 0x9, 4562 SURFACE_FORMAT_R8B8_UNORM_CRCB = 0xa, 4563 SURFACE_FORMAT_R8_UNORM_CR_CB = 0xb, 4564 SURFACE_FORMAT_Y8_UNORM = 0xc, 4565 SURFACE_FORMAT_A8Y8U8V8_UNORM = 0xd, 4566 SURFACE_FORMAT_B8G8R8A8_UNORM = 0xe, 4567 SURFACE_FORMAT_R16G16B16A16 = 0xf, 4568 SURFACE_FORMAT_Y1_UNORM = 0x10, 4569 SURFACE_FORMAT_Y32_UNORM = 0x11, 4570 SURFACE_FORMAT_PLANAR_422_8 = 0x12, 4571 } SURFACE_FORMAT; 4572 typedef enum tagSURFACE_MEMORY_OBJECT_CONTROL_STATE { 4573 SURFACE_MEMORY_OBJECT_CONTROL_STATE_DEFAULTVAUEDESC = 0x0, 4574 } SURFACE_MEMORY_OBJECT_CONTROL_STATE; 4575 typedef enum tagTILED_RESOURCE_MODE { 4576 TILED_RESOURCE_MODE_TRMODE_NONE = 0x0, 4577 TILED_RESOURCE_MODE_TRMODE_TILEYF = 0x1, 4578 TILED_RESOURCE_MODE_TRMODE_TILEYS = 0x2, 4579 } TILED_RESOURCE_MODE; 4580 typedef enum tagPATCH_CONSTANTS { 4581 SURFACEBASEADDRESS_BYTEOFFSET = 0x18, 4582 SURFACEBASEADDRESS_INDEX = 0x6, 4583 SURFACEBASEADDRESSHIGH_BYTEOFFSET = 0x1c, 4584 SURFACEBASEADDRESSHIGH_INDEX = 0x7, 4585 } PATCH_CONSTANTS; 4586 inline void init() { 4587 memset(&TheStructure, 0, sizeof(TheStructure)); 4588 TheStructure.Common.Rotation = ROTATION_NO_ROTATION_OR_0_DEGREE; 4589 TheStructure.Common.PictureStructure = PICTURE_STRUCTURE_FRAME_PICTURE; 4590 TheStructure.Common.TileMode = TILE_MODE_TILEMODE_LINEAR; 4591 TheStructure.Common.AddressControl = ADDRESS_CONTROL_CLAMP; 4592 TheStructure.Common.MemoryCompressionMode = MEMORY_COMPRESSION_MODE_HORIZONTAL_COMPRESSION_MODE; 4593 TheStructure.Common.SurfaceFormat = SURFACE_FORMAT_YCRCB_NORMAL; 4594 TheStructure.Common.TiledResourceMode = TILED_RESOURCE_MODE_TRMODE_NONE; 4595 } 4596 static tagMEDIA_SURFACE_STATE sInit() { 4597 MEDIA_SURFACE_STATE state; 4598 state.init(); 4599 return state; 4600 } 4601 inline uint32_t &getRawData(const uint32_t index) { 4602 DEBUG_BREAK_IF(index >= 8); 4603 return TheStructure.RawData[index]; 4604 } 4605 inline void setRotation(const ROTATION value) { 4606 TheStructure.Common.Rotation = value; 4607 } 4608 inline ROTATION getRotation() const { 4609 return static_cast<ROTATION>(TheStructure.Common.Rotation); 4610 } 4611 inline void setCrVCbUPixelOffsetVDirection(const uint32_t value) { 4612 TheStructure.Common.Cr_VCb_UPixelOffsetVDirection = value; 4613 } 4614 inline uint32_t getCrVCbUPixelOffsetVDirection() const { 4615 return (TheStructure.Common.Cr_VCb_UPixelOffsetVDirection); 4616 } 4617 inline void setPictureStructure(const PICTURE_STRUCTURE value) { 4618 TheStructure.Common.PictureStructure = value; 4619 } 4620 inline PICTURE_STRUCTURE getPictureStructure() const { 4621 return static_cast<PICTURE_STRUCTURE>(TheStructure.Common.PictureStructure); 4622 } 4623 inline void setWidth(const uint32_t value) { 4624 TheStructure.Common.Width = value - 1; 4625 } 4626 inline uint32_t getWidth() const { 4627 return (TheStructure.Common.Width + 1); 4628 } 4629 inline void setHeight(const uint32_t value) { 4630 TheStructure.Common.Height = value - 1; 4631 } 4632 inline uint32_t getHeight() const { 4633 return (TheStructure.Common.Height + 1); 4634 } 4635 inline void setTileMode(const TILE_MODE value) { 4636 TheStructure.Common.TileMode = value; 4637 } 4638 inline TILE_MODE getTileMode() const { 4639 return static_cast<TILE_MODE>(TheStructure.Common.TileMode); 4640 } 4641 inline void setHalfPitchForChroma(const bool value) { 4642 TheStructure.Common.HalfPitchForChroma = value; 4643 } 4644 inline bool getHalfPitchForChroma() const { 4645 return (TheStructure.Common.HalfPitchForChroma); 4646 } 4647 inline void setSurfacePitch(const uint32_t value) { 4648 TheStructure.Common.SurfacePitch = value - 1; 4649 } 4650 inline uint32_t getSurfacePitch() const { 4651 return (TheStructure.Common.SurfacePitch + 1); 4652 } 4653 inline void setAddressControl(const ADDRESS_CONTROL value) { 4654 TheStructure.Common.AddressControl = value; 4655 } 4656 inline ADDRESS_CONTROL getAddressControl() const { 4657 return static_cast<ADDRESS_CONTROL>(TheStructure.Common.AddressControl); 4658 } 4659 inline void setMemoryCompressionEnable(const bool value) { 4660 TheStructure.Common.MemoryCompressionEnable = value; 4661 } 4662 inline bool getMemoryCompressionEnable() const { 4663 return (TheStructure.Common.MemoryCompressionEnable); 4664 } 4665 inline void setMemoryCompressionMode(const MEMORY_COMPRESSION_MODE value) { 4666 TheStructure.Common.MemoryCompressionMode = value; 4667 } 4668 inline MEMORY_COMPRESSION_MODE getMemoryCompressionMode() const { 4669 return static_cast<MEMORY_COMPRESSION_MODE>(TheStructure.Common.MemoryCompressionMode); 4670 } 4671 inline void setCrVCbUPixelOffsetVDirectionMsb(const uint32_t value) { 4672 TheStructure.Common.Cr_VCb_UPixelOffsetVDirectionMsb = value; 4673 } 4674 inline uint32_t getCrVCbUPixelOffsetVDirectionMsb() const { 4675 return (TheStructure.Common.Cr_VCb_UPixelOffsetVDirectionMsb); 4676 } 4677 inline void setCrVCbUPixelOffsetUDirection(const uint32_t value) { 4678 TheStructure.Common.Cr_VCb_UPixelOffsetUDirection = value; 4679 } 4680 inline uint32_t getCrVCbUPixelOffsetUDirection() const { 4681 return (TheStructure.Common.Cr_VCb_UPixelOffsetUDirection); 4682 } 4683 inline void setInterleaveChroma(const bool value) { 4684 TheStructure.Common.InterleaveChroma = value; 4685 } 4686 inline bool getInterleaveChroma() const { 4687 return (TheStructure.Common.InterleaveChroma); 4688 } 4689 inline void setSurfaceFormat(const SURFACE_FORMAT value) { 4690 TheStructure.Common.SurfaceFormat = value; 4691 } 4692 inline SURFACE_FORMAT getSurfaceFormat() const { 4693 return static_cast<SURFACE_FORMAT>(TheStructure.Common.SurfaceFormat); 4694 } 4695 inline void setYOffsetForUCb(const uint32_t value) { 4696 TheStructure.Common.YOffsetForU_Cb = value; 4697 } 4698 inline uint32_t getYOffsetForUCb() const { 4699 return (TheStructure.Common.YOffsetForU_Cb); 4700 } 4701 inline void setXOffsetForUCb(const uint32_t value) { 4702 TheStructure.Common.XOffsetForU_Cb = value; 4703 } 4704 inline uint32_t getXOffsetForUCb() const { 4705 return (TheStructure.Common.XOffsetForU_Cb); 4706 } 4707 inline void setSurfaceMemoryObjectControlStateReserved(const uint32_t value) { 4708 TheStructure.Common.SurfaceMemoryObjectControlState_Reserved = value; 4709 } 4710 inline uint32_t getSurfaceMemoryObjectControlStateReserved() const { 4711 return (TheStructure.Common.SurfaceMemoryObjectControlState_Reserved); 4712 } 4713 inline void setSurfaceMemoryObjectControlState(const uint32_t value) { 4714 TheStructure.Common.SurfaceMemoryObjectControlState_IndexToMocsTables = value >> 1; 4715 } 4716 inline uint32_t getSurfaceMemoryObjectControlState() const { 4717 return (TheStructure.Common.SurfaceMemoryObjectControlState_IndexToMocsTables << 1); 4718 } 4719 inline void setTiledResourceMode(const TILED_RESOURCE_MODE value) { 4720 TheStructure.Common.TiledResourceMode = value; 4721 } 4722 inline TILED_RESOURCE_MODE getTiledResourceMode() const { 4723 return static_cast<TILED_RESOURCE_MODE>(TheStructure.Common.TiledResourceMode); 4724 } 4725 inline void setVerticalLineStrideOffset(const uint32_t value) { 4726 TheStructure.Common.VerticalLineStrideOffset = value; 4727 } 4728 inline uint32_t getVerticalLineStrideOffset() const { 4729 return (TheStructure.Common.VerticalLineStrideOffset); 4730 } 4731 inline void setVerticalLineStride(const uint32_t value) { 4732 TheStructure.Common.VerticalLineStride = value; 4733 } 4734 inline uint32_t getVerticalLineStride() const { 4735 return (TheStructure.Common.VerticalLineStride); 4736 } 4737 inline void setSurfaceBaseAddress(const uint64_t value) { 4738 TheStructure.Common.SurfaceBaseAddressLow = static_cast<uint32_t>(value & 0xffffffff); 4739 TheStructure.Common.SurfaceBaseAddressHigh = (value >> 32) & 0xffffffff; 4740 } 4741 inline uint64_t getSurfaceBaseAddress() const { 4742 return (TheStructure.Common.SurfaceBaseAddressLow | 4743 static_cast<uint64_t>(TheStructure.Common.SurfaceBaseAddressHigh) << 32); 4744 } 4745 inline void setSurfaceBaseAddressHigh(const uint32_t value) { 4746 TheStructure.Common.SurfaceBaseAddressHigh = value; 4747 } 4748 inline uint32_t getSurfaceBaseAddressHigh() const { 4749 return (TheStructure.Common.SurfaceBaseAddressHigh); 4750 } 4751 typedef enum tagYOFFSET { 4752 YOFFSET_BIT_SHIFT = 0x2, 4753 YOFFSET_ALIGN_SIZE = 0x4, 4754 } YOFFSET; 4755 inline void setYOffset(const uint32_t value) { 4756 TheStructure.SurfaceFormatIsOneOfPlanarFormats.YOffset = value >> YOFFSET_BIT_SHIFT; 4757 } 4758 inline uint32_t getYOffset() const { 4759 return (TheStructure.SurfaceFormatIsOneOfPlanarFormats.YOffset << YOFFSET_BIT_SHIFT); 4760 } 4761 typedef enum tagXOFFSET { 4762 XOFFSET_BIT_SHIFT = 0x2, 4763 XOFFSET_ALIGN_SIZE = 0x4, 4764 } XOFFSET; 4765 inline void setXOffset(const uint32_t value) { 4766 TheStructure.SurfaceFormatIsOneOfPlanarFormats.XOffset = value >> XOFFSET_BIT_SHIFT; 4767 } 4768 inline uint32_t getXOffset() const { 4769 return (TheStructure.SurfaceFormatIsOneOfPlanarFormats.XOffset << XOFFSET_BIT_SHIFT); 4770 } 4771 inline void setYOffsetForVCr(const uint32_t value) { 4772 TheStructure._SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0.YOffsetForV_Cr = value; 4773 } 4774 inline uint32_t getYOffsetForVCr() const { 4775 return (TheStructure._SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0.YOffsetForV_Cr); 4776 } 4777 inline void setXOffsetForVCr(const uint32_t value) { 4778 TheStructure._SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0.XOffsetForV_Cr = value; 4779 } 4780 inline uint32_t getXOffsetForVCr() const { 4781 return (TheStructure._SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0.XOffsetForV_Cr); 4782 } 4783} MEDIA_SURFACE_STATE; 4784STATIC_ASSERT(32 == sizeof(MEDIA_SURFACE_STATE)); 4785 4786typedef struct tagMI_MATH { 4787 union _DW0 { 4788 struct _BitField { 4789 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 4790 uint32_t Reserved : BITFIELD_RANGE(8, 22); 4791 uint32_t InstructionOpcode : BITFIELD_RANGE(23, 28); 4792 uint32_t InstructionType : BITFIELD_RANGE(29, 31); 4793 } BitField; 4794 uint32_t Value; 4795 } DW0; 4796 typedef enum tagMI_COMMAND_OPCODE { 4797 MI_COMMAND_OPCODE_MI_MATH = 0x1A, 4798 } MI_COMMAND_OPCODE; 4799 typedef enum tagCOMMAND_TYPE { 4800 COMMAND_TYPE_MI_COMMAND = 0x0, 4801 } COMMAND_TYPE; 4802} MI_MATH; 4803 4804typedef struct tagMI_MATH_ALU_INST_INLINE { 4805 union _DW0 { 4806 struct _BitField { 4807 uint32_t Operand2 : BITFIELD_RANGE(0, 9); 4808 uint32_t Operand1 : BITFIELD_RANGE(10, 19); 4809 uint32_t ALUOpcode : BITFIELD_RANGE(20, 31); 4810 } BitField; 4811 uint32_t Value; 4812 } DW0; 4813} MI_MATH_ALU_INST_INLINE; 4814 4815typedef struct tagMI_SEMAPHORE_WAIT { 4816 union tagTheStructure { 4817 struct tagCommon { 4818 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 4819 uint32_t Reserved_8 : BITFIELD_RANGE(8, 11); 4820 uint32_t CompareOperation : BITFIELD_RANGE(12, 14); 4821 uint32_t WaitMode : BITFIELD_RANGE(15, 15); 4822 uint32_t Reserved_16 : BITFIELD_RANGE(16, 21); 4823 uint32_t MemoryType : BITFIELD_RANGE(22, 22); 4824 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 4825 uint32_t CommandType : BITFIELD_RANGE(29, 31); 4826 uint32_t SemaphoreDataDword; 4827 uint64_t Reserved_64 : BITFIELD_RANGE(0, 1); 4828 uint64_t SemaphoreAddress_Graphicsaddress : BITFIELD_RANGE(2, 47); 4829 uint64_t SemaphoreAddress_Reserved : BITFIELD_RANGE(48, 63); 4830 } Common; 4831 uint32_t RawData[4]; 4832 } TheStructure; 4833 typedef enum tagDWORD_LENGTH { 4834 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x2, 4835 } DWORD_LENGTH; 4836 typedef enum tagCOMPARE_OPERATION { 4837 COMPARE_OPERATION_SAD_GREATER_THAN_SDD = 0x0, 4838 COMPARE_OPERATION_SAD_GREATER_THAN_OR_EQUAL_SDD = 0x1, 4839 COMPARE_OPERATION_SAD_LESS_THAN_SDD = 0x2, 4840 COMPARE_OPERATION_SAD_LESS_THAN_OR_EQUAL_SDD = 0x3, 4841 COMPARE_OPERATION_SAD_EQUAL_SDD = 0x4, 4842 COMPARE_OPERATION_SAD_NOT_EQUAL_SDD = 0x5, 4843 } COMPARE_OPERATION; 4844 typedef enum tagWAIT_MODE { 4845 WAIT_MODE_SIGNAL_MODE = 0x0, 4846 WAIT_MODE_POLLING_MODE = 0x1, 4847 } WAIT_MODE; 4848 typedef enum tagMEMORY_TYPE { 4849 MEMORY_TYPE_PER_PROCESS_GRAPHICS_ADDRESS = 0x0, 4850 MEMORY_TYPE_GLOBAL_GRAPHICS_ADDRESS = 0x1, 4851 } MEMORY_TYPE; 4852 typedef enum tagMI_COMMAND_OPCODE { 4853 MI_COMMAND_OPCODE_MI_SEMAPHORE_WAIT = 0x1c, 4854 } MI_COMMAND_OPCODE; 4855 typedef enum tagCOMMAND_TYPE { 4856 COMMAND_TYPE_MI_COMMAND = 0x0, 4857 } COMMAND_TYPE; 4858 inline void init() { 4859 memset(&TheStructure, 0, sizeof(TheStructure)); 4860 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 4861 TheStructure.Common.CompareOperation = COMPARE_OPERATION_SAD_GREATER_THAN_SDD; 4862 TheStructure.Common.WaitMode = WAIT_MODE_SIGNAL_MODE; 4863 TheStructure.Common.MemoryType = MEMORY_TYPE_PER_PROCESS_GRAPHICS_ADDRESS; 4864 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_SEMAPHORE_WAIT; 4865 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 4866 } 4867 static tagMI_SEMAPHORE_WAIT sInit() { 4868 MI_SEMAPHORE_WAIT state; 4869 state.init(); 4870 return state; 4871 } 4872 inline uint32_t &getRawData(const uint32_t index) { 4873 DEBUG_BREAK_IF(index >= 4); 4874 return TheStructure.RawData[index]; 4875 } 4876 inline void setCompareOperation(const COMPARE_OPERATION value) { 4877 TheStructure.Common.CompareOperation = value; 4878 } 4879 inline COMPARE_OPERATION getCompareOperation() const { 4880 return static_cast<COMPARE_OPERATION>(TheStructure.Common.CompareOperation); 4881 } 4882 inline void setWaitMode(const WAIT_MODE value) { 4883 TheStructure.Common.WaitMode = value; 4884 } 4885 inline WAIT_MODE getWaitMode() const { 4886 return static_cast<WAIT_MODE>(TheStructure.Common.WaitMode); 4887 } 4888 inline void setMemoryType(const MEMORY_TYPE value) { 4889 TheStructure.Common.MemoryType = value; 4890 } 4891 inline MEMORY_TYPE getMemoryType() const { 4892 return static_cast<MEMORY_TYPE>(TheStructure.Common.MemoryType); 4893 } 4894 inline void setSemaphoreDataDword(const uint32_t value) { 4895 TheStructure.Common.SemaphoreDataDword = value; 4896 } 4897 inline uint32_t getSemaphoreDataDword() const { 4898 return (TheStructure.Common.SemaphoreDataDword); 4899 } 4900 typedef enum tagSEMAPHOREADDRESS_GRAPHICSADDRESS { 4901 SEMAPHOREADDRESS_GRAPHICSADDRESS_BIT_SHIFT = 0x2, 4902 SEMAPHOREADDRESS_GRAPHICSADDRESS_ALIGN_SIZE = 0x4, 4903 } SEMAPHOREADDRESS_GRAPHICSADDRESS; 4904 inline void setSemaphoreGraphicsAddress(const uint64_t value) { 4905 TheStructure.Common.SemaphoreAddress_Graphicsaddress = value >> SEMAPHOREADDRESS_GRAPHICSADDRESS_BIT_SHIFT; 4906 } 4907 inline uint64_t getSemaphoreGraphicsAddress() const { 4908 return (TheStructure.Common.SemaphoreAddress_Graphicsaddress << SEMAPHOREADDRESS_GRAPHICSADDRESS_BIT_SHIFT); 4909 } 4910 typedef enum tagSEMAPHOREADDRESS_RESERVED { 4911 SEMAPHOREADDRESS_RESERVED_BIT_SHIFT = 0x2, 4912 SEMAPHOREADDRESS_RESERVED_ALIGN_SIZE = 0x4, 4913 } SEMAPHOREADDRESS_RESERVED; 4914 inline void setSemaphoreAddressReserved(const uint64_t value) { 4915 TheStructure.Common.SemaphoreAddress_Reserved = value >> SEMAPHOREADDRESS_RESERVED_BIT_SHIFT; 4916 } 4917 inline uint64_t getSemaphoreAddressReserved() const { 4918 return (TheStructure.Common.SemaphoreAddress_Reserved << SEMAPHOREADDRESS_RESERVED_BIT_SHIFT); 4919 } 4920} MI_SEMAPHORE_WAIT; 4921STATIC_ASSERT(16 == sizeof(MI_SEMAPHORE_WAIT)); 4922 4923typedef struct tagMI_STORE_DATA_IMM { 4924 union tagTheStructure { 4925 struct tagCommon { 4926 uint32_t DwordLength : BITFIELD_RANGE(0, 9); 4927 uint32_t Reserved_10 : BITFIELD_RANGE(10, 20); 4928 uint32_t StoreQword : BITFIELD_RANGE(21, 21); 4929 uint32_t UseGlobalGtt : BITFIELD_RANGE(22, 22); 4930 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 4931 uint32_t CommandType : BITFIELD_RANGE(29, 31); 4932 uint64_t CoreModeEnable : BITFIELD_RANGE(0, 0); 4933 uint64_t Reserved_33 : BITFIELD_RANGE(1, 1); 4934 uint64_t Address_Graphicsaddress47_2 : BITFIELD_RANGE(2, 47); 4935 uint64_t Address_Reserved : BITFIELD_RANGE(48, 63); 4936 uint32_t DataDword0; 4937 uint32_t DataDword1; 4938 } Common; 4939 uint32_t RawData[5]; 4940 } TheStructure; 4941 typedef enum tagDWORD_LENGTH { 4942 DWORD_LENGTH_STORE_DWORD = 0x2, 4943 DWORD_LENGTH_STORE_QWORD = 0x3, 4944 } DWORD_LENGTH; 4945 typedef enum tagMI_COMMAND_OPCODE { 4946 MI_COMMAND_OPCODE_MI_STORE_DATA_IMM = 0x20, 4947 } MI_COMMAND_OPCODE; 4948 typedef enum tagCOMMAND_TYPE { 4949 COMMAND_TYPE_MI_COMMAND = 0x0, 4950 } COMMAND_TYPE; 4951 inline void init() { 4952 memset(&TheStructure, 0, sizeof(TheStructure)); 4953 TheStructure.Common.DwordLength = DWORD_LENGTH_STORE_DWORD; 4954 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_STORE_DATA_IMM; 4955 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 4956 } 4957 static tagMI_STORE_DATA_IMM sInit() { 4958 MI_STORE_DATA_IMM state; 4959 state.init(); 4960 return state; 4961 } 4962 inline uint32_t &getRawData(const uint32_t index) { 4963 DEBUG_BREAK_IF(index >= 5); 4964 return TheStructure.RawData[index]; 4965 } 4966 inline void setDwordLength(const DWORD_LENGTH value) { 4967 TheStructure.Common.DwordLength = value; 4968 } 4969 inline DWORD_LENGTH getDwordLength() const { 4970 return static_cast<DWORD_LENGTH>(TheStructure.Common.DwordLength); 4971 } 4972 inline void setStoreQword(const bool value) { 4973 TheStructure.Common.StoreQword = value; 4974 } 4975 inline bool getStoreQword() const { 4976 return (TheStructure.Common.StoreQword); 4977 } 4978 inline void setUseGlobalGtt(const bool value) { 4979 TheStructure.Common.UseGlobalGtt = value; 4980 } 4981 inline bool getUseGlobalGtt() const { 4982 return (TheStructure.Common.UseGlobalGtt); 4983 } 4984 inline void setCoreModeEnable(const uint64_t value) { 4985 TheStructure.Common.CoreModeEnable = value; 4986 } 4987 inline uint64_t getCoreModeEnable() const { 4988 return (TheStructure.Common.CoreModeEnable); 4989 } 4990 typedef enum tagADDRESS_GRAPHICSADDRESS47_2 { 4991 ADDRESS_GRAPHICSADDRESS47_2_BIT_SHIFT = 0x2, 4992 ADDRESS_GRAPHICSADDRESS47_2_ALIGN_SIZE = 0x4, 4993 } ADDRESS_GRAPHICSADDRESS47_2; 4994 inline void setAddress(const uint64_t value) { 4995 TheStructure.Common.Address_Graphicsaddress47_2 = value >> ADDRESS_GRAPHICSADDRESS47_2_BIT_SHIFT; 4996 } 4997 inline uint64_t getAddress() const { 4998 return (TheStructure.Common.Address_Graphicsaddress47_2 << ADDRESS_GRAPHICSADDRESS47_2_BIT_SHIFT); 4999 } 5000 typedef enum tagADDRESS_RESERVED { 5001 ADDRESS_RESERVED_BIT_SHIFT = 0x2, 5002 ADDRESS_RESERVED_ALIGN_SIZE = 0x4, 5003 } ADDRESS_RESERVED; 5004 inline void setAddressReserved(const uint64_t value) { 5005 TheStructure.Common.Address_Reserved = value >> ADDRESS_RESERVED_BIT_SHIFT; 5006 } 5007 inline uint64_t getAddressReserved() const { 5008 return (TheStructure.Common.Address_Reserved << ADDRESS_RESERVED_BIT_SHIFT); 5009 } 5010 inline void setDataDword0(const uint32_t value) { 5011 TheStructure.Common.DataDword0 = value; 5012 } 5013 inline uint32_t getDataDword0() const { 5014 return (TheStructure.Common.DataDword0); 5015 } 5016 inline void setDataDword1(const uint32_t value) { 5017 TheStructure.Common.DataDword1 = value; 5018 } 5019 inline uint32_t getDataDword1() const { 5020 return (TheStructure.Common.DataDword1); 5021 } 5022} MI_STORE_DATA_IMM; 5023STATIC_ASSERT(20 == sizeof(MI_STORE_DATA_IMM)); 5024 5025typedef struct tagSAMPLER_BORDER_COLOR_STATE { 5026 union tagTheStructure { 5027 struct tagCommon { 5028 // DWORD 0 5029 float BorderColorRed; 5030 // DWORD 1 5031 float BorderColorGreen; 5032 // DWORD 2 5033 float BorderColorBlue; 5034 // DWORD 3 5035 float BorderColorAlpha; 5036 } Common; 5037 uint32_t RawData[4]; 5038 } TheStructure; 5039 inline void init() { 5040 memset(&TheStructure, 0, sizeof(TheStructure)); 5041 TheStructure.Common.BorderColorRed = 0.0; 5042 TheStructure.Common.BorderColorGreen = 0.0; 5043 TheStructure.Common.BorderColorBlue = 0.0; 5044 TheStructure.Common.BorderColorAlpha = 0.0; 5045 } 5046 static tagSAMPLER_BORDER_COLOR_STATE sInit() { 5047 SAMPLER_BORDER_COLOR_STATE state; 5048 state.init(); 5049 return state; 5050 } 5051 inline uint32_t &getRawData(const uint32_t index) { 5052 UNRECOVERABLE_IF(index >= 4); 5053 return TheStructure.RawData[index]; 5054 } 5055 inline void setBorderColorRed(const float value) { 5056 TheStructure.Common.BorderColorRed = value; 5057 } 5058 inline float getBorderColorRed() const { 5059 return TheStructure.Common.BorderColorRed; 5060 } 5061 inline void setBorderColorGreen(const float value) { 5062 TheStructure.Common.BorderColorGreen = value; 5063 } 5064 inline float getBorderColorGreen() const { 5065 return TheStructure.Common.BorderColorGreen; 5066 } 5067 inline void setBorderColorBlue(const float value) { 5068 TheStructure.Common.BorderColorBlue = value; 5069 } 5070 inline float getBorderColorBlue() const { 5071 return TheStructure.Common.BorderColorBlue; 5072 } 5073 inline void setBorderColorAlpha(const float value) { 5074 TheStructure.Common.BorderColorAlpha = value; 5075 } 5076 inline float getBorderColorAlpha() const { 5077 return TheStructure.Common.BorderColorAlpha; 5078 } 5079} SAMPLER_BORDER_COLOR_STATE; 5080STATIC_ASSERT(16 == sizeof(SAMPLER_BORDER_COLOR_STATE)); 5081 5082#pragma pack() 5083