1/*
2 * Copyright (C) 2021 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8#pragma pack(1)
9
10typedef struct tagBINDING_TABLE_STATE {
11    union tagTheStructure {
12        struct tagCommon {
13            uint32_t Reserved_0 : BITFIELD_RANGE(0, 5);
14            uint32_t SurfaceStatePointer : BITFIELD_RANGE(6, 31);
15        } Common;
16        uint32_t RawData[1];
17    } TheStructure;
18    typedef enum tagPATCH_CONSTANTS {
19        SURFACESTATEPOINTER_BYTEOFFSET = 0x0,
20        SURFACESTATEPOINTER_INDEX = 0x0,
21    } PATCH_CONSTANTS;
22    inline void init() {
23        memset(&TheStructure, 0, sizeof(TheStructure));
24    }
25    static tagBINDING_TABLE_STATE sInit() {
26        BINDING_TABLE_STATE state;
27        state.init();
28        return state;
29    }
30    inline uint32_t &getRawData(const uint32_t index) {
31        DEBUG_BREAK_IF(index >= 1);
32        return TheStructure.RawData[index];
33    }
34    inline const uint32_t &getRawData(const uint32_t index) const {
35        DEBUG_BREAK_IF(index >= 1);
36        return TheStructure.RawData[index];
37    }
38    typedef enum tagSURFACESTATEPOINTER {
39        SURFACESTATEPOINTER_BIT_SHIFT = 0x6,
40        SURFACESTATEPOINTER_ALIGN_SIZE = 0x40,
41    } SURFACESTATEPOINTER;
42    inline void setSurfaceStatePointer(const uint64_t value) {
43        DEBUG_BREAK_IF(value >= 0x100000000);
44        TheStructure.Common.SurfaceStatePointer = (uint32_t)value >> SURFACESTATEPOINTER_BIT_SHIFT;
45    }
46    inline uint32_t getSurfaceStatePointer() const {
47        return (TheStructure.Common.SurfaceStatePointer << SURFACESTATEPOINTER_BIT_SHIFT);
48    }
49} BINDING_TABLE_STATE;
50STATIC_ASSERT(4 == sizeof(BINDING_TABLE_STATE));
51
52typedef struct tagMEDIA_SURFACE_STATE {
53    union tagTheStructure {
54        struct tagCommon {
55            // DWORD 0
56            uint32_t CompressionFormat : BITFIELD_RANGE(0, 4);
57            uint32_t Reserved115_5 : BITFIELD_RANGE(5, 11);
58            uint32_t Reserved_12 : BITFIELD_RANGE(12, 15);
59            uint32_t Reserved_16 : BITFIELD_RANGE(16, 19);
60            uint32_t Reserved_20 : BITFIELD_RANGE(20, 26);
61            uint32_t Reserved_27 : BITFIELD_RANGE(27, 29);
62            uint32_t Rotation : BITFIELD_RANGE(30, 31);
63            // DWORD 1
64            uint32_t Cr_VCb_UPixelOffsetVDirection : BITFIELD_RANGE(0, 1);
65            uint32_t PictureStructure : BITFIELD_RANGE(2, 3);
66            uint32_t Width : BITFIELD_RANGE(4, 17);
67            uint32_t Height : BITFIELD_RANGE(18, 31);
68            // DWORD 2
69            uint32_t TileMode : BITFIELD_RANGE(0, 1);
70            uint32_t HalfPitchForChroma : BITFIELD_RANGE(2, 2);
71            uint32_t SurfacePitch : BITFIELD_RANGE(3, 20);
72            uint32_t AddressControl : BITFIELD_RANGE(21, 21);
73            uint32_t MemoryCompressionEnable : BITFIELD_RANGE(22, 22);
74            uint32_t MemoryCompressionType : BITFIELD_RANGE(23, 23);
75            uint32_t Cr_VCb_UPixelOffsetVDirectionMsb : BITFIELD_RANGE(24, 24);
76            uint32_t Cr_VCb_UPixelOffsetUDirection : BITFIELD_RANGE(25, 25);
77            uint32_t InterleaveChroma : BITFIELD_RANGE(26, 26);
78            uint32_t SurfaceFormat : BITFIELD_RANGE(27, 31);
79            // DWORD 3
80            uint32_t YOffsetForU_Cb : BITFIELD_RANGE(0, 13);
81            uint32_t Reserved_110 : BITFIELD_RANGE(14, 15);
82            uint32_t XOffsetForU_Cb : BITFIELD_RANGE(16, 29);
83            uint32_t Reserved_126 : BITFIELD_RANGE(30, 31);
84            // DWORD 4
85            uint32_t Reserved_128 : BITFIELD_RANGE(0, 14);
86            uint32_t Reserved_143 : BITFIELD_RANGE(15, 15);
87            uint32_t Reserved_144 : BITFIELD_RANGE(16, 29);
88            uint32_t Reserved_158 : BITFIELD_RANGE(30, 31);
89            // DWORD 5
90            uint32_t SurfaceMemoryObjectControlStateReserved_160 : BITFIELD_RANGE(0, 0);
91            uint32_t SurfaceMemoryObjectControlStateIndexToMocsTables : BITFIELD_RANGE(1, 6);
92            uint32_t Reserved_167 : BITFIELD_RANGE(7, 17);
93            uint32_t Reserved_178 : BITFIELD_RANGE(18, 19);
94            uint32_t Reserved_180 : BITFIELD_RANGE(20, 29);
95            uint32_t VerticalLineStrideOffset : BITFIELD_RANGE(30, 30);
96            uint32_t VerticalLineStride : BITFIELD_RANGE(31, 31);
97            // DWORD 6
98            uint32_t SurfaceBaseAddressLow;
99            // DWORD 7
100            uint32_t SurfaceBaseAddressHigh : BITFIELD_RANGE(0, 15);
101            uint32_t Reserved_240 : BITFIELD_RANGE(16, 31);
102        } Common;
103        struct tagSurfaceFormatIsOneOfPlanarFormats {
104            // DWORD 0
105            uint32_t Reserved_0 : BITFIELD_RANGE(0, 4);
106            uint32_t Reserved_5 : BITFIELD_RANGE(5, 11);
107            uint32_t Reserved_12 : BITFIELD_RANGE(12, 15);
108            uint32_t YOffset : BITFIELD_RANGE(16, 19);
109            uint32_t XOffset : BITFIELD_RANGE(20, 26);
110            uint32_t Reserved_27 : BITFIELD_RANGE(27, 29);
111            uint32_t Reserved_30 : BITFIELD_RANGE(30, 31);
112            // DWORD 1
113            uint32_t Reserved_32 : BITFIELD_RANGE(0, 1);
114            uint32_t Reserved_34 : BITFIELD_RANGE(2, 3);
115            uint32_t Reserved_36 : BITFIELD_RANGE(4, 17);
116            uint32_t Reserved_50 : BITFIELD_RANGE(18, 31);
117            // DWORD 2
118            uint32_t Reserved_64 : BITFIELD_RANGE(0, 1);
119            uint32_t Reserved_66 : BITFIELD_RANGE(2, 2);
120            uint32_t Reserved_67 : BITFIELD_RANGE(3, 20);
121            uint32_t Reserved_85 : BITFIELD_RANGE(21, 21);
122            uint32_t Reserved_86 : BITFIELD_RANGE(22, 22);
123            uint32_t Reserved_87 : BITFIELD_RANGE(23, 23);
124            uint32_t Reserved_88 : BITFIELD_RANGE(24, 24);
125            uint32_t Reserved_89 : BITFIELD_RANGE(25, 25);
126            uint32_t Reserved_90 : BITFIELD_RANGE(26, 26);
127            uint32_t Reserved_91 : BITFIELD_RANGE(27, 31);
128            // DWORD 3
129            uint32_t Reserved_96 : BITFIELD_RANGE(0, 13);
130            uint32_t Reserved_110 : BITFIELD_RANGE(14, 15);
131            uint32_t Reserved_112 : BITFIELD_RANGE(16, 29);
132            uint32_t Reserved_126 : BITFIELD_RANGE(30, 31);
133            // DWORD 4
134            uint32_t Reserved_128 : BITFIELD_RANGE(0, 14);
135            uint32_t Reserved_143 : BITFIELD_RANGE(15, 15);
136            uint32_t Reserved_144 : BITFIELD_RANGE(16, 29);
137            uint32_t Reserved_158 : BITFIELD_RANGE(30, 31);
138            // DWORD 5
139            uint32_t Reserved_160 : BITFIELD_RANGE(0, 0);
140            uint32_t Reserved_161 : BITFIELD_RANGE(1, 6);
141            uint32_t Reserved_167 : BITFIELD_RANGE(7, 17);
142            uint32_t Reserved_178 : BITFIELD_RANGE(18, 19);
143            uint32_t Reserved_180 : BITFIELD_RANGE(20, 29);
144            uint32_t Reserved_190 : BITFIELD_RANGE(30, 30);
145            uint32_t Reserved_191 : BITFIELD_RANGE(31, 31);
146            // DWORD 6
147            uint32_t Reserved_192;
148            // DWORD 7
149            uint32_t Reserved_224 : BITFIELD_RANGE(0, 15);
150            uint32_t Reserved_240 : BITFIELD_RANGE(16, 31);
151        } SurfaceFormatIsOneOfPlanarFormats;
152        struct tag_SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0 {
153            // DWORD 0
154            uint32_t Reserved_0 : BITFIELD_RANGE(0, 4);
155            uint32_t Reserved_5 : BITFIELD_RANGE(5, 11);
156            uint32_t Reserved_12 : BITFIELD_RANGE(12, 15);
157            uint32_t Reserved_16 : BITFIELD_RANGE(16, 19);
158            uint32_t Reserved_20 : BITFIELD_RANGE(20, 26);
159            uint32_t Reserved_27 : BITFIELD_RANGE(27, 29);
160            uint32_t Reserved_30 : BITFIELD_RANGE(30, 31);
161            // DWORD 1
162            uint32_t Reserved_32 : BITFIELD_RANGE(0, 1);
163            uint32_t Reserved_34 : BITFIELD_RANGE(2, 3);
164            uint32_t Reserved_36 : BITFIELD_RANGE(4, 17);
165            uint32_t Reserved_50 : BITFIELD_RANGE(18, 31);
166            // DWORD 2
167            uint32_t Reserved_64 : BITFIELD_RANGE(0, 1);
168            uint32_t Reserved_66 : BITFIELD_RANGE(2, 2);
169            uint32_t Reserved_67 : BITFIELD_RANGE(3, 20);
170            uint32_t Reserved_85 : BITFIELD_RANGE(21, 21);
171            uint32_t Reserved_86 : BITFIELD_RANGE(22, 22);
172            uint32_t Reserved_87 : BITFIELD_RANGE(23, 23);
173            uint32_t Reserved_88 : BITFIELD_RANGE(24, 24);
174            uint32_t Reserved_89 : BITFIELD_RANGE(25, 25);
175            uint32_t Reserved_90 : BITFIELD_RANGE(26, 26);
176            uint32_t Reserved_91 : BITFIELD_RANGE(27, 31);
177            // DWORD 3
178            uint32_t Reserved_96 : BITFIELD_RANGE(0, 13);
179            uint32_t Reserved_110 : BITFIELD_RANGE(14, 15);
180            uint32_t Reserved_112 : BITFIELD_RANGE(16, 29);
181            uint32_t Reserved_126 : BITFIELD_RANGE(30, 31);
182            // DWORD 4
183            uint32_t YOffsetForV_Cr : BITFIELD_RANGE(0, 14);
184            uint32_t Reserved_143 : BITFIELD_RANGE(15, 15);
185            uint32_t XOffsetForV_Cr : BITFIELD_RANGE(16, 29);
186            uint32_t Reserved_158 : BITFIELD_RANGE(30, 31);
187            // DWORD 5
188            uint32_t Reserved_160 : BITFIELD_RANGE(0, 0);
189            uint32_t Reserved_161 : BITFIELD_RANGE(1, 6);
190            uint32_t Reserved_167 : BITFIELD_RANGE(7, 17);
191            uint32_t Reserved_178 : BITFIELD_RANGE(18, 19);
192            uint32_t Reserved_180 : BITFIELD_RANGE(20, 29);
193            uint32_t Reserved_190 : BITFIELD_RANGE(30, 30);
194            uint32_t Reserved_191 : BITFIELD_RANGE(31, 31);
195            // DWORD 6
196            uint32_t Reserved_192;
197            // DWORD 7
198            uint32_t Reserved_224 : BITFIELD_RANGE(0, 15);
199            uint32_t Reserved_240 : BITFIELD_RANGE(16, 31);
200        } _SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0;
201        uint32_t RawData[8];
202    } TheStructure;
203    typedef enum tagCOMPRESSION_FORMAT {
204        COMPRESSION_FORMAT_RGBA16_FLOAT = 0x1,
205        COMPRESSION_FORMAT_Y210 = 0x2,
206        COMPRESSION_FORMAT_YUY2 = 0x3,
207        COMPRESSION_FORMAT_Y410_1010102 = 0x4,
208        COMPRESSION_FORMAT_Y216 = 0x5,
209        COMPRESSION_FORMAT_Y416 = 0x6,
210        COMPRESSION_FORMAT_P010 = 0x7,
211        COMPRESSION_FORMAT_P016 = 0x8,
212        COMPRESSION_FORMAT_AYUV = 0x9,
213        COMPRESSION_FORMAT_ARGB_8B = 0xa,
214        COMPRESSION_FORMAT_YCRCB_SWAPY = 0xb,
215        COMPRESSION_FORMAT_YCRCB_SWAPUV = 0xc,
216        COMPRESSION_FORMAT_YCRCB_SWAPUVY = 0xd,
217        COMPRESSION_FORMAT_RGB_10B = 0xe,
218        COMPRESSION_FORMAT_NV21NV12 = 0xf,
219    } COMPRESSION_FORMAT;
220    typedef enum tagROTATION {
221        ROTATION_NO_ROTATION_OR_0_DEGREE = 0x0,
222        ROTATION_90_DEGREE_ROTATION = 0x1,
223        ROTATION_180_DEGREE_ROTATION = 0x2,
224        ROTATION_270_DEGREE_ROTATION = 0x3,
225    } ROTATION;
226    typedef enum tagPICTURE_STRUCTURE {
227        PICTURE_STRUCTURE_FRAME_PICTURE = 0x0,
228        PICTURE_STRUCTURE_TOP_FIELD_PICTURE = 0x1,
229        PICTURE_STRUCTURE_BOTTOM_FIELD_PICTURE = 0x2,
230        PICTURE_STRUCTURE_INVALID_NOT_ALLOWED = 0x3,
231    } PICTURE_STRUCTURE;
232    typedef enum tagTILE_MODE {
233        TILE_MODE_TILEMODE_LINEAR = 0x0,
234        TILE_MODE_TILES_64K = 0x1,
235        TILE_MODE_TILEMODE_XMAJOR = 0x2,
236        TILE_MODE_TILEMODE_YMAJOR = 0x3,
237    } TILE_MODE;
238    typedef enum tagADDRESS_CONTROL {
239        ADDRESS_CONTROL_CLAMP = 0x0,
240        ADDRESS_CONTROL_MIRROR = 0x1,
241    } ADDRESS_CONTROL;
242    typedef enum tagMEMORY_COMPRESSION_TYPE {
243        MEMORY_COMPRESSION_TYPE_MEDIA_COMPRESSION = 0x0,
244        MEMORY_COMPRESSION_TYPE_RENDER_COMPRESSION = 0x1,
245    } MEMORY_COMPRESSION_TYPE;
246    typedef enum tagSURFACE_FORMAT {
247        SURFACE_FORMAT_YCRCB_NORMAL = 0x0,
248        SURFACE_FORMAT_YCRCB_SWAPUVY = 0x1,
249        SURFACE_FORMAT_YCRCB_SWAPUV = 0x2,
250        SURFACE_FORMAT_YCRCB_SWAPY = 0x3,
251        SURFACE_FORMAT_PLANAR_420_8 = 0x4,
252        SURFACE_FORMAT_Y8_UNORM_VA = 0x5,
253        SURFACE_FORMAT_R10G10B10A2_UNORM = 0x8,
254        SURFACE_FORMAT_R8G8B8A8_UNORM = 0x9,
255        SURFACE_FORMAT_R8B8_UNORM_CRCB = 0xa,
256        SURFACE_FORMAT_R8_UNORM_CRCB = 0xb,
257        SURFACE_FORMAT_Y8_UNORM = 0xc,
258        SURFACE_FORMAT_A8Y8U8V8_UNORM = 0xd,
259        SURFACE_FORMAT_B8G8R8A8_UNORM = 0xe,
260        SURFACE_FORMAT_R16G16B16A16 = 0xf,
261        SURFACE_FORMAT_Y1_UNORM = 0x10,
262        SURFACE_FORMAT_PLANAR_422_8 = 0x12,
263        SURFACE_FORMAT_PLANAR_420_16 = 0x17,
264        SURFACE_FORMAT_R16B16_UNORM_CRCB = 0x18,
265        SURFACE_FORMAT_R16_UNORM_CRCB = 0x19,
266        SURFACE_FORMAT_Y16_UNORM = 0x1a,
267    } SURFACE_FORMAT;
268    typedef enum tagSURFACE_MEMORY_OBJECT_CONTROL_STATE {
269        SURFACE_MEMORY_OBJECT_CONTROL_STATE_DEFAULTVAUEDESC = 0x0,
270    } SURFACE_MEMORY_OBJECT_CONTROL_STATE;
271    inline void init() {
272        memset(&TheStructure, 0, sizeof(TheStructure));
273        TheStructure.Common.Rotation = ROTATION_NO_ROTATION_OR_0_DEGREE;
274        TheStructure.Common.PictureStructure = PICTURE_STRUCTURE_FRAME_PICTURE;
275        TheStructure.Common.TileMode = TILE_MODE_TILEMODE_LINEAR;
276        TheStructure.Common.AddressControl = ADDRESS_CONTROL_CLAMP;
277        TheStructure.Common.MemoryCompressionType = MEMORY_COMPRESSION_TYPE_MEDIA_COMPRESSION;
278        TheStructure.Common.SurfaceFormat = SURFACE_FORMAT_YCRCB_NORMAL;
279    }
280    static tagMEDIA_SURFACE_STATE sInit() {
281        MEDIA_SURFACE_STATE state;
282        state.init();
283        return state;
284    }
285    inline uint32_t &getRawData(const uint32_t index) {
286        UNRECOVERABLE_IF(index >= 8);
287        return TheStructure.RawData[index];
288    }
289    inline void setCompressionFormat(uint32_t compressionFormat) {
290        UNRECOVERABLE_IF(compressionFormat > 0x1F);
291        TheStructure.Common.CompressionFormat = compressionFormat;
292    }
293    inline uint32_t getCompressionFormat() const {
294        return TheStructure.Common.CompressionFormat;
295    }
296    inline void setRotation(const ROTATION value) {
297        TheStructure.Common.Rotation = value;
298    }
299    inline ROTATION getRotation() const {
300        return static_cast<ROTATION>(TheStructure.Common.Rotation);
301    }
302    inline void setCrVCbUPixelOffsetVDirection(const uint32_t value) {
303        UNRECOVERABLE_IF(value > 0x3);
304        TheStructure.Common.Cr_VCb_UPixelOffsetVDirection = value;
305    }
306    inline uint32_t getCrVCbUPixelOffsetVDirection() const {
307        return TheStructure.Common.Cr_VCb_UPixelOffsetVDirection;
308    }
309    inline void setPictureStructure(const PICTURE_STRUCTURE value) {
310        TheStructure.Common.PictureStructure = value;
311    }
312    inline PICTURE_STRUCTURE getPictureStructure() const {
313        return static_cast<PICTURE_STRUCTURE>(TheStructure.Common.PictureStructure);
314    }
315    inline void setWidth(const uint32_t value) {
316        UNRECOVERABLE_IF(value > 0x3fff0);
317        TheStructure.Common.Width = value - 1;
318    }
319    inline uint32_t getWidth() const {
320        return TheStructure.Common.Width + 1;
321    }
322    inline void setHeight(const uint32_t value) {
323        UNRECOVERABLE_IF(value > 0xfffc0000);
324        TheStructure.Common.Height = value - 1;
325    }
326    inline uint32_t getHeight() const {
327        return TheStructure.Common.Height + 1;
328    }
329    inline void setTileMode(const TILE_MODE value) {
330        TheStructure.Common.TileMode = value;
331    }
332    inline TILE_MODE getTileMode() const {
333        return static_cast<TILE_MODE>(TheStructure.Common.TileMode);
334    }
335    inline void setHalfPitchForChroma(const bool value) {
336        TheStructure.Common.HalfPitchForChroma = value;
337    }
338    inline bool getHalfPitchForChroma() const {
339        return TheStructure.Common.HalfPitchForChroma;
340    }
341    inline void setSurfacePitch(const uint32_t value) {
342        UNRECOVERABLE_IF(value > 0x1ffff8);
343        TheStructure.Common.SurfacePitch = value - 1;
344    }
345    inline uint32_t getSurfacePitch() const {
346        return TheStructure.Common.SurfacePitch + 1;
347    }
348    inline void setAddressControl(const ADDRESS_CONTROL value) {
349        TheStructure.Common.AddressControl = value;
350    }
351    inline ADDRESS_CONTROL getAddressControl() const {
352        return static_cast<ADDRESS_CONTROL>(TheStructure.Common.AddressControl);
353    }
354    inline void setMemoryCompressionEnable(const bool value) {
355        TheStructure.Common.MemoryCompressionEnable = value;
356    }
357    inline bool getMemoryCompressionEnable() const {
358        return TheStructure.Common.MemoryCompressionEnable;
359    }
360    inline void setMemoryCompressionType(const MEMORY_COMPRESSION_TYPE value) {
361        TheStructure.Common.MemoryCompressionType = value;
362    }
363    inline MEMORY_COMPRESSION_TYPE getMemoryCompressionType() const {
364        return static_cast<MEMORY_COMPRESSION_TYPE>(TheStructure.Common.MemoryCompressionType);
365    }
366    inline void setCrVCbUPixelOffsetVDirectionMsb(const bool value) {
367        TheStructure.Common.Cr_VCb_UPixelOffsetVDirectionMsb = value;
368    }
369    inline bool getCrVCbUPixelOffsetVDirectionMsb() const {
370        return TheStructure.Common.Cr_VCb_UPixelOffsetVDirectionMsb;
371    }
372    inline void setCrVCbUPixelOffsetUDirection(const bool value) {
373        TheStructure.Common.Cr_VCb_UPixelOffsetUDirection = value;
374    }
375    inline bool getCrVCbUPixelOffsetUDirection() const {
376        return TheStructure.Common.Cr_VCb_UPixelOffsetUDirection;
377    }
378    inline void setInterleaveChroma(const bool value) {
379        TheStructure.Common.InterleaveChroma = value;
380    }
381    inline bool getInterleaveChroma() const {
382        return TheStructure.Common.InterleaveChroma;
383    }
384    inline void setSurfaceFormat(const SURFACE_FORMAT value) {
385        TheStructure.Common.SurfaceFormat = value;
386    }
387    inline SURFACE_FORMAT getSurfaceFormat() const {
388        return static_cast<SURFACE_FORMAT>(TheStructure.Common.SurfaceFormat);
389    }
390    inline void setYOffsetForUCb(const uint32_t value) {
391        UNRECOVERABLE_IF(value > 0x3fff);
392        TheStructure.Common.YOffsetForU_Cb = value;
393    }
394    inline uint32_t getYOffsetForUCb() const {
395        return TheStructure.Common.YOffsetForU_Cb;
396    }
397    inline void setXOffsetForUCb(const uint32_t value) {
398        UNRECOVERABLE_IF(value > 0x3fff0000);
399        TheStructure.Common.XOffsetForU_Cb = value;
400    }
401    inline uint32_t getXOffsetForUCb() const {
402        return TheStructure.Common.XOffsetForU_Cb;
403    }
404    inline void setSurfaceMemoryObjectControlState(const uint32_t value) {
405        UNRECOVERABLE_IF(value > 0x7e);
406        TheStructure.Common.SurfaceMemoryObjectControlStateIndexToMocsTables = value >> 1;
407    }
408    inline uint32_t getSurfaceMemoryObjectControlState() const {
409        return TheStructure.Common.SurfaceMemoryObjectControlStateIndexToMocsTables << 1;
410    }
411    inline void setVerticalLineStrideOffset(const bool value) {
412        TheStructure.Common.VerticalLineStrideOffset = value;
413    }
414    inline bool getVerticalLineStrideOffset() const {
415        return TheStructure.Common.VerticalLineStrideOffset;
416    }
417    inline void setVerticalLineStride(const bool value) {
418        TheStructure.Common.VerticalLineStride = value;
419    }
420    inline bool getVerticalLineStride() const {
421        return TheStructure.Common.VerticalLineStride;
422    }
423    inline void setSurfaceBaseAddress(const uint64_t value) {
424        TheStructure.Common.SurfaceBaseAddressLow = static_cast<uint32_t>(value & 0xffffffff);
425        TheStructure.Common.SurfaceBaseAddressHigh = (value >> 32) & 0xffffffff;
426    }
427    inline uint64_t getSurfaceBaseAddress() const {
428        return (TheStructure.Common.SurfaceBaseAddressLow |
429                static_cast<uint64_t>(TheStructure.Common.SurfaceBaseAddressHigh) << 32);
430    }
431    inline void setSurfaceBaseAddressHigh(const uint32_t value) {
432        UNRECOVERABLE_IF(value > 0xffff);
433        TheStructure.Common.SurfaceBaseAddressHigh = value;
434    }
435    inline uint32_t getSurfaceBaseAddressHigh() const {
436        return TheStructure.Common.SurfaceBaseAddressHigh;
437    }
438    inline void setYOffset(const uint32_t value) {
439        UNRECOVERABLE_IF(value > 0xf0000);
440        TheStructure.SurfaceFormatIsOneOfPlanarFormats.YOffset = value;
441    }
442    inline uint32_t getYOffset() const {
443        return TheStructure.SurfaceFormatIsOneOfPlanarFormats.YOffset;
444    }
445    inline void setXOffset(const uint32_t value) {
446        UNRECOVERABLE_IF(value > 0x7f00000);
447        TheStructure.SurfaceFormatIsOneOfPlanarFormats.XOffset = value;
448    }
449    inline uint32_t getXOffset() const {
450        return TheStructure.SurfaceFormatIsOneOfPlanarFormats.XOffset;
451    }
452    inline void setYOffsetForVCr(const uint32_t value) {
453        UNRECOVERABLE_IF(value > 0x7fff);
454        TheStructure._SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0.YOffsetForV_Cr = value;
455    }
456    inline uint32_t getYOffsetForVCr() const {
457        return TheStructure._SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0.YOffsetForV_Cr;
458    }
459    inline void setXOffsetForVCr(const uint32_t value) {
460        UNRECOVERABLE_IF(value > 0x3fff0000);
461        TheStructure._SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0.XOffsetForV_Cr = value;
462    }
463    inline uint32_t getXOffsetForVCr() const {
464        return TheStructure._SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0.XOffsetForV_Cr;
465    }
466} MEDIA_SURFACE_STATE;
467STATIC_ASSERT(32 == sizeof(MEDIA_SURFACE_STATE));
468
469typedef struct tagMEM_COPY {
470    union tagTheStructure {
471        struct tagCommon {
472            // DWORD 0
473            uint32_t DwordLength : BITFIELD_RANGE(0, 7);
474            uint32_t CompressionFormat : BITFIELD_RANGE(8, 12);
475            uint32_t DestinationCompressionEnable : BITFIELD_RANGE(13, 13);
476            uint32_t Reserved_14 : BITFIELD_RANGE(14, 14);
477            uint32_t DestinationCompressible : BITFIELD_RANGE(15, 15);
478            uint32_t SourceCompressible : BITFIELD_RANGE(16, 16);
479            uint32_t CopyType : BITFIELD_RANGE(17, 18);
480            uint32_t Reserved_19 : BITFIELD_RANGE(19, 21);
481            uint32_t InstructionTarget_Opcode : BITFIELD_RANGE(22, 28);
482            uint32_t Client : BITFIELD_RANGE(29, 31);
483            // DWORD 1
484            uint32_t TransferWidth : BITFIELD_RANGE(0, 17);
485            uint32_t Reserved_50 : BITFIELD_RANGE(18, 31);
486            // DWORD 2
487            uint32_t TransferHeight : BITFIELD_RANGE(0, 17);
488            uint32_t Reserved_82 : BITFIELD_RANGE(18, 31);
489            // DWORD 3
490            uint32_t SourcePitch : BITFIELD_RANGE(0, 17);
491            uint32_t Reserved_114 : BITFIELD_RANGE(18, 31);
492            // DWORD 4
493            uint32_t DestinationPitch : BITFIELD_RANGE(0, 17);
494            uint32_t Reserved_146 : BITFIELD_RANGE(18, 31);
495            // DWORD 5..6
496            uint64_t SourceBaseAddress;
497            // DWORD 7..8
498            uint64_t DestinationBaseAddress;
499            // DWORD 9
500            uint32_t DestinationMocs : BITFIELD_RANGE(0, 6);
501            uint32_t Reserved_295 : BITFIELD_RANGE(7, 24);
502            uint32_t SourceMocs : BITFIELD_RANGE(25, 31);
503        } Common;
504        uint32_t RawData[10];
505    } TheStructure;
506    typedef enum tagDWORD_LENGTH {
507        DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x8,
508    } DWORD_LENGTH;
509    typedef enum tagDESTINATION_COMPRESSION_ENABLE {
510        DESTINATION_COMPRESSION_ENABLE_DISABLE = 0x0,
511        DESTINATION_COMPRESSION_ENABLE_ENABLE = 0x1,
512    } DESTINATION_COMPRESSION_ENABLE;
513    typedef enum tagDESTINATION_COMPRESSIBLE {
514        DESTINATION_COMPRESSIBLE_NOT_COMPRESSIBLE = 0x0,
515        DESTINATION_COMPRESSIBLE_COMPRESSIBLE = 0x1,
516    } DESTINATION_COMPRESSIBLE;
517    typedef enum tagSOURCE_COMPRESSIBLE {
518        SOURCE_COMPRESSIBLE_NOT_COMPRESSIBLE = 0x0,
519        SOURCE_COMPRESSIBLE_COMPRESSIBLE = 0x1,
520    } SOURCE_COMPRESSIBLE;
521    typedef enum tagCOPY_TYPE {
522        COPY_TYPE_LINEAR_COPY = 0x0,
523        COPY_TYPE_MATRIX_COPY = 0x1,
524    } COPY_TYPE;
525    typedef enum tagINSTRUCTIONTARGET_OPCODE {
526        INSTRUCTIONTARGET_OPCODE_OPCODE = 0x5A,
527    } INSTRUCTIONTARGET_OPCODE;
528    typedef enum tagCLIENT {
529        CLIENT_2D_PROCESSOR = 0x2,
530    } CLIENT;
531    inline void init() {
532        memset(&TheStructure, 0, sizeof(TheStructure));
533        TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1;
534        TheStructure.Common.DestinationCompressionEnable = DESTINATION_COMPRESSION_ENABLE_DISABLE;
535        TheStructure.Common.DestinationCompressible = DESTINATION_COMPRESSIBLE_NOT_COMPRESSIBLE;
536        TheStructure.Common.SourceCompressible = SOURCE_COMPRESSIBLE_NOT_COMPRESSIBLE;
537        TheStructure.Common.CopyType = COPY_TYPE_LINEAR_COPY;
538        TheStructure.Common.InstructionTarget_Opcode = INSTRUCTIONTARGET_OPCODE_OPCODE;
539        TheStructure.Common.Client = CLIENT_2D_PROCESSOR;
540    }
541    static tagMEM_COPY sInit() {
542        MEM_COPY state;
543        state.init();
544        return state;
545    }
546    inline uint32_t &getRawData(const uint32_t index) {
547        UNRECOVERABLE_IF(index >= 10);
548        return TheStructure.RawData[index];
549    }
550    inline void setCompressionFormat(const uint32_t value) {
551        UNRECOVERABLE_IF(value > 0x1f);
552        TheStructure.Common.CompressionFormat = value;
553    }
554    inline uint32_t getCompressionFormat() const {
555        return TheStructure.Common.CompressionFormat;
556    }
557    inline void setDestinationCompressionEnable(const DESTINATION_COMPRESSION_ENABLE value) {
558        TheStructure.Common.DestinationCompressionEnable = value;
559    }
560    inline DESTINATION_COMPRESSION_ENABLE getDestinationCompressionEnable() const {
561        return static_cast<DESTINATION_COMPRESSION_ENABLE>(TheStructure.Common.DestinationCompressionEnable);
562    }
563    inline void setDestinationCompressible(const DESTINATION_COMPRESSIBLE value) {
564        TheStructure.Common.DestinationCompressible = value;
565    }
566    inline DESTINATION_COMPRESSIBLE getDestinationCompressible() const {
567        return static_cast<DESTINATION_COMPRESSIBLE>(TheStructure.Common.DestinationCompressible);
568    }
569    inline void setSourceCompressible(const SOURCE_COMPRESSIBLE value) {
570        TheStructure.Common.SourceCompressible = value;
571    }
572    inline SOURCE_COMPRESSIBLE getSourceCompressible() const {
573        return static_cast<SOURCE_COMPRESSIBLE>(TheStructure.Common.SourceCompressible);
574    }
575    inline void setCopyType(const COPY_TYPE value) {
576        TheStructure.Common.CopyType = value;
577    }
578    inline COPY_TYPE getCopyType() const {
579        return static_cast<COPY_TYPE>(TheStructure.Common.CopyType);
580    }
581    inline void setInstructionTargetOpcode(const uint32_t value) {
582        UNRECOVERABLE_IF(value > 0x7f);
583        TheStructure.Common.InstructionTarget_Opcode = value;
584    }
585    inline uint32_t getInstructionTargetOpcode() const {
586        return TheStructure.Common.InstructionTarget_Opcode;
587    }
588    inline void setClient(const CLIENT value) {
589        TheStructure.Common.Client = value;
590    }
591    inline CLIENT getClient() const {
592        return static_cast<CLIENT>(TheStructure.Common.Client);
593    }
594    inline void setDestinationX2CoordinateRight(const uint32_t value) {
595        UNRECOVERABLE_IF(value > 0x3ffff + 1);
596        TheStructure.Common.TransferWidth = value - 1;
597    }
598    inline uint32_t getDestinationX2CoordinateRight() const {
599        return TheStructure.Common.TransferWidth + 1;
600    }
601    inline void setDestinationY2CoordinateBottom(const uint32_t value) {
602        UNRECOVERABLE_IF(value > 0x3ffff + 1);
603        TheStructure.Common.TransferHeight = value - 1;
604    }
605    inline uint32_t getDestinationY2CoordinateBottom() const {
606        return TheStructure.Common.TransferHeight + 1;
607    }
608    inline void setSourcePitch(const uint32_t value) {
609        UNRECOVERABLE_IF(value > 0x3ffff + 1);
610        TheStructure.Common.SourcePitch = value - 1;
611    }
612    inline uint32_t getSourcePitch() const {
613        return TheStructure.Common.SourcePitch + 1;
614    }
615    inline void setDestinationPitch(const uint32_t value) {
616        UNRECOVERABLE_IF(value > 0x3ffff + 1);
617        TheStructure.Common.DestinationPitch = value - 1;
618    }
619    inline uint32_t getDestinationPitch() const {
620        return TheStructure.Common.DestinationPitch + 1;
621    }
622    inline void setSourceBaseAddress(const uint64_t value) {
623        TheStructure.Common.SourceBaseAddress = value;
624    }
625    inline uint64_t getSourceBaseAddress() const {
626        return TheStructure.Common.SourceBaseAddress;
627    }
628    inline void setDestinationBaseAddress(const uint64_t value) {
629        TheStructure.Common.DestinationBaseAddress = value;
630    }
631    inline uint64_t getDestinationBaseAddress() const {
632        return TheStructure.Common.DestinationBaseAddress;
633    }
634    inline void setDestinationMOCS(const uint32_t value) {
635        UNRECOVERABLE_IF(value > 0x7f);
636        TheStructure.Common.DestinationMocs = value;
637    }
638    inline uint32_t getDestinationMOCS() const {
639        return TheStructure.Common.DestinationMocs;
640    }
641    inline void setSourceMOCS(const uint32_t value) {
642        UNRECOVERABLE_IF(value > 0x7f);
643        TheStructure.Common.SourceMocs = value;
644    }
645    inline uint32_t getSourceMOCS() const {
646        return TheStructure.Common.SourceMocs;
647    }
648} MEM_COPY;
649STATIC_ASSERT(40 == sizeof(MEM_COPY));
650
651typedef struct tagMI_MATH {
652    union _DW0 {
653        struct _BitField {
654            uint32_t DwordLength : BITFIELD_RANGE(0, 7);
655            uint32_t Reserved : BITFIELD_RANGE(8, 22);
656            uint32_t InstructionOpcode : BITFIELD_RANGE(23, 28);
657            uint32_t InstructionType : BITFIELD_RANGE(29, 31);
658        } BitField;
659        uint32_t Value;
660    } DW0;
661    typedef enum tagMI_COMMAND_OPCODE {
662        MI_COMMAND_OPCODE_MI_MATH = 0x1A,
663    } MI_COMMAND_OPCODE;
664    typedef enum tagCOMMAND_TYPE {
665        COMMAND_TYPE_MI_COMMAND = 0x0,
666    } COMMAND_TYPE;
667} MI_MATH;
668
669typedef struct tagMI_MATH_ALU_INST_INLINE {
670    union _DW0 {
671        struct _BitField {
672            uint32_t Operand2 : BITFIELD_RANGE(0, 9);
673            uint32_t Operand1 : BITFIELD_RANGE(10, 19);
674            uint32_t ALUOpcode : BITFIELD_RANGE(20, 31);
675        } BitField;
676        uint32_t Value;
677    } DW0;
678} MI_MATH_ALU_INST_INLINE;
679
680typedef struct tagPIPE_CONTROL {
681    union tagTheStructure {
682        struct tagCommon {
683            // DWORD 0
684            uint32_t DwordLength : BITFIELD_RANGE(0, 7);
685            uint32_t PredicateEnable : BITFIELD_RANGE(8, 8);
686            uint32_t HdcPipelineFlush : BITFIELD_RANGE(9, 9);
687            uint32_t Reserved_10 : BITFIELD_RANGE(10, 10);
688            uint32_t UnTypedDataPortCacheFlush : BITFIELD_RANGE(11, 11);
689            uint32_t Reserved_12 : BITFIELD_RANGE(12, 12);
690            uint32_t CompressionControlSurface_CcsFlush : BITFIELD_RANGE(13, 13);
691            uint32_t WorkloadPartitionIdOffsetEnable : BITFIELD_RANGE(14, 14);
692            uint32_t Reserved_15 : BITFIELD_RANGE(15, 15);
693            uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23);
694            uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26);
695            uint32_t CommandSubtype : BITFIELD_RANGE(27, 28);
696            uint32_t CommandType : BITFIELD_RANGE(29, 31);
697            // DWORD 1
698            uint32_t DepthCacheFlushEnable : BITFIELD_RANGE(0, 0);
699            uint32_t StallAtPixelScoreboard : BITFIELD_RANGE(1, 1);
700            uint32_t StateCacheInvalidationEnable : BITFIELD_RANGE(2, 2);
701            uint32_t ConstantCacheInvalidationEnable : BITFIELD_RANGE(3, 3);
702            uint32_t VfCacheInvalidationEnable : BITFIELD_RANGE(4, 4);
703            uint32_t DcFlushEnable : BITFIELD_RANGE(5, 5);
704            uint32_t Reserved_38 : BITFIELD_RANGE(6, 6);
705            uint32_t PipeControlFlushEnable : BITFIELD_RANGE(7, 7);
706            uint32_t NotifyEnable : BITFIELD_RANGE(8, 8);
707            uint32_t IndirectStatePointersDisable : BITFIELD_RANGE(9, 9);
708            uint32_t TextureCacheInvalidationEnable : BITFIELD_RANGE(10, 10);
709            uint32_t InstructionCacheInvalidateEnable : BITFIELD_RANGE(11, 11);
710            uint32_t RenderTargetCacheFlushEnable : BITFIELD_RANGE(12, 12);
711            uint32_t DepthStallEnable : BITFIELD_RANGE(13, 13);
712            uint32_t PostSyncOperation : BITFIELD_RANGE(14, 15);
713            uint32_t GenericMediaStateClear : BITFIELD_RANGE(16, 16);
714            uint32_t PssStallSyncEnable : BITFIELD_RANGE(17, 17);
715            uint32_t TlbInvalidate : BITFIELD_RANGE(18, 18);
716            uint32_t DepthStallSyncEnable : BITFIELD_RANGE(19, 19);
717            uint32_t CommandStreamerStallEnable : BITFIELD_RANGE(20, 20);
718            uint32_t StoreDataIndex : BITFIELD_RANGE(21, 21);
719            uint32_t Reserved_54 : BITFIELD_RANGE(22, 22);
720            uint32_t LriPostSyncOperation : BITFIELD_RANGE(23, 23);
721            uint32_t DestinationAddressType : BITFIELD_RANGE(24, 24);
722            uint32_t AmfsFlushEnable : BITFIELD_RANGE(25, 25);
723            uint32_t FlushLlc : BITFIELD_RANGE(26, 26);
724            uint32_t Reserved_59 : BITFIELD_RANGE(27, 27);
725            uint32_t TileCacheFlushEnable : BITFIELD_RANGE(28, 28);
726            uint32_t CommandCacheInvalidateEnable : BITFIELD_RANGE(29, 29);
727            uint32_t L3FabricFlush : BITFIELD_RANGE(30, 30);
728            uint32_t TbimrForceBatchClosure : BITFIELD_RANGE(31, 31);
729            // DWORD 2
730            uint32_t Reserved_64 : BITFIELD_RANGE(0, 1);
731            uint32_t Address : BITFIELD_RANGE(2, 31);
732            // DWORD 3
733            uint32_t AddressHigh;
734            // DWORD 4
735            uint64_t ImmediateData;
736        } Common;
737        uint32_t RawData[6];
738    } TheStructure;
739    typedef enum tagDWORD_LENGTH {
740        DWORD_LENGTH_DWORD_COUNT_N = 0x4,
741    } DWORD_LENGTH;
742    typedef enum tagUN_TYPED_DATA_PORT_CACHE_FLUSH {
743        UN_TYPED_DATA_PORT_CACHE_FLUSH_DISABLED = 0x0,
744        UN_TYPED_DATA_PORT_CACHE_FLUSH_ENABLED = 0x1,
745    } UN_TYPED_DATA_PORT_CACHE_FLUSH;
746    typedef enum tag_3D_COMMAND_SUB_OPCODE {
747        _3D_COMMAND_SUB_OPCODE_PIPE_CONTROL = 0x0,
748    } _3D_COMMAND_SUB_OPCODE;
749    typedef enum tag_3D_COMMAND_OPCODE {
750        _3D_COMMAND_OPCODE_PIPE_CONTROL = 0x2,
751    } _3D_COMMAND_OPCODE;
752    typedef enum tagCOMMAND_SUBTYPE {
753        COMMAND_SUBTYPE_GFXPIPE_3D = 0x3,
754    } COMMAND_SUBTYPE;
755    typedef enum tagCOMMAND_TYPE {
756        COMMAND_TYPE_GFXPIPE = 0x3,
757    } COMMAND_TYPE;
758    typedef enum tagPOST_SYNC_OPERATION {
759        POST_SYNC_OPERATION_NO_WRITE = 0x0,
760        POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA = 0x1,
761        POST_SYNC_OPERATION_WRITE_PS_DEPTH_COUNT = 0x2,
762        POST_SYNC_OPERATION_WRITE_TIMESTAMP = 0x3,
763    } POST_SYNC_OPERATION;
764    typedef enum tagLRI_POST_SYNC_OPERATION {
765        LRI_POST_SYNC_OPERATION_NO_LRI_OPERATION = 0x0,
766        LRI_POST_SYNC_OPERATION_MMIO_WRITE_IMMEDIATE_DATA = 0x1,
767    } LRI_POST_SYNC_OPERATION;
768    typedef enum tagDESTINATION_ADDRESS_TYPE {
769        DESTINATION_ADDRESS_TYPE_PPGTT = 0x0,
770        DESTINATION_ADDRESS_TYPE_GGTT = 0x1,
771    } DESTINATION_ADDRESS_TYPE;
772    typedef enum tagTBIMR_FORCE_BATCH_CLOSURE {
773        TBIMR_FORCE_BATCH_CLOSURE_NO_BATCH_CLOSURE = 0x0,
774        TBIMR_FORCE_BATCH_CLOSURE_CLOSE_BATCH = 0x1,
775    } TBIMR_FORCE_BATCH_CLOSURE;
776    inline void init() {
777        memset(&TheStructure, 0, sizeof(TheStructure));
778        TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N;
779        TheStructure.Common.UnTypedDataPortCacheFlush = UN_TYPED_DATA_PORT_CACHE_FLUSH_DISABLED;
780        TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_PIPE_CONTROL;
781        TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_PIPE_CONTROL;
782        TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_3D;
783        TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE;
784        TheStructure.Common.PostSyncOperation = POST_SYNC_OPERATION_NO_WRITE;
785        TheStructure.Common.LriPostSyncOperation = LRI_POST_SYNC_OPERATION_NO_LRI_OPERATION;
786        TheStructure.Common.DestinationAddressType = DESTINATION_ADDRESS_TYPE_PPGTT;
787        TheStructure.Common.TbimrForceBatchClosure = TBIMR_FORCE_BATCH_CLOSURE_NO_BATCH_CLOSURE;
788        TheStructure.Common.CommandStreamerStallEnable = 1; // Patched
789    }
790    static tagPIPE_CONTROL sInit() {
791        PIPE_CONTROL state;
792        state.init();
793        return state;
794    }
795    inline uint32_t &getRawData(const uint32_t index) {
796        UNRECOVERABLE_IF(index >= 6);
797        return TheStructure.RawData[index];
798    }
799    inline void setPredicateEnable(const bool value) {
800        TheStructure.Common.PredicateEnable = value;
801    }
802    inline bool getPredicateEnable() const {
803        return TheStructure.Common.PredicateEnable;
804    }
805    inline void setHdcPipelineFlush(const bool value) {
806        TheStructure.Common.HdcPipelineFlush = value;
807    }
808    inline bool getHdcPipelineFlush() const {
809        return TheStructure.Common.HdcPipelineFlush;
810    }
811    inline void setUnTypedDataPortCacheFlush(const bool value) {
812        TheStructure.Common.UnTypedDataPortCacheFlush = value;
813    }
814    inline bool getUnTypedDataPortCacheFlush() const {
815        return TheStructure.Common.UnTypedDataPortCacheFlush;
816    }
817    inline void setCompressionControlSurfaceCcsFlush(const bool value) {
818        TheStructure.Common.CompressionControlSurface_CcsFlush = value;
819    }
820    inline bool getCompressionControlSurfaceCcsFlush() const {
821        return TheStructure.Common.CompressionControlSurface_CcsFlush;
822    }
823    inline void setWorkloadPartitionIdOffsetEnable(const bool value) {
824        TheStructure.Common.WorkloadPartitionIdOffsetEnable = value;
825    }
826    inline bool getWorkloadPartitionIdOffsetEnable() const {
827        return TheStructure.Common.WorkloadPartitionIdOffsetEnable;
828    }
829    inline void setDepthCacheFlushEnable(const bool value) {
830        TheStructure.Common.DepthCacheFlushEnable = value;
831    }
832    inline bool getDepthCacheFlushEnable() const {
833        return TheStructure.Common.DepthCacheFlushEnable;
834    }
835    inline void setStallAtPixelScoreboard(const bool value) {
836        TheStructure.Common.StallAtPixelScoreboard = value;
837    }
838    inline bool getStallAtPixelScoreboard() const {
839        return TheStructure.Common.StallAtPixelScoreboard;
840    }
841    inline void setStateCacheInvalidationEnable(const bool value) {
842        TheStructure.Common.StateCacheInvalidationEnable = value;
843    }
844    inline bool getStateCacheInvalidationEnable() const {
845        return TheStructure.Common.StateCacheInvalidationEnable;
846    }
847    inline void setConstantCacheInvalidationEnable(const bool value) {
848        TheStructure.Common.ConstantCacheInvalidationEnable = value;
849    }
850    inline bool getConstantCacheInvalidationEnable() const {
851        return TheStructure.Common.ConstantCacheInvalidationEnable;
852    }
853    inline void setVfCacheInvalidationEnable(const bool value) {
854        TheStructure.Common.VfCacheInvalidationEnable = value;
855    }
856    inline bool getVfCacheInvalidationEnable() const {
857        return TheStructure.Common.VfCacheInvalidationEnable;
858    }
859    inline void setDcFlushEnable(const bool value) {
860        TheStructure.Common.DcFlushEnable = value;
861    }
862    inline bool getDcFlushEnable() const {
863        return TheStructure.Common.DcFlushEnable;
864    }
865    inline void setPipeControlFlushEnable(const bool value) {
866        TheStructure.Common.PipeControlFlushEnable = value;
867    }
868    inline bool getPipeControlFlushEnable() const {
869        return TheStructure.Common.PipeControlFlushEnable;
870    }
871    inline void setNotifyEnable(const bool value) {
872        TheStructure.Common.NotifyEnable = value;
873    }
874    inline bool getNotifyEnable() const {
875        return TheStructure.Common.NotifyEnable;
876    }
877    inline void setIndirectStatePointersDisable(const bool value) {
878        TheStructure.Common.IndirectStatePointersDisable = value;
879    }
880    inline bool getIndirectStatePointersDisable() const {
881        return TheStructure.Common.IndirectStatePointersDisable;
882    }
883    inline void setTextureCacheInvalidationEnable(const bool value) {
884        TheStructure.Common.TextureCacheInvalidationEnable = value;
885    }
886    inline bool getTextureCacheInvalidationEnable() const {
887        return TheStructure.Common.TextureCacheInvalidationEnable;
888    }
889    inline void setInstructionCacheInvalidateEnable(const bool value) {
890        TheStructure.Common.InstructionCacheInvalidateEnable = value;
891    }
892    inline bool getInstructionCacheInvalidateEnable() const {
893        return TheStructure.Common.InstructionCacheInvalidateEnable;
894    }
895    inline void setRenderTargetCacheFlushEnable(const bool value) {
896        TheStructure.Common.RenderTargetCacheFlushEnable = value;
897    }
898    inline bool getRenderTargetCacheFlushEnable() const {
899        return TheStructure.Common.RenderTargetCacheFlushEnable;
900    }
901    inline void setDepthStallEnable(const bool value) {
902        TheStructure.Common.DepthStallEnable = value;
903    }
904    inline bool getDepthStallEnable() const {
905        return TheStructure.Common.DepthStallEnable;
906    }
907    inline void setPostSyncOperation(const POST_SYNC_OPERATION value) {
908        TheStructure.Common.PostSyncOperation = value;
909    }
910    inline POST_SYNC_OPERATION getPostSyncOperation() const {
911        return static_cast<POST_SYNC_OPERATION>(TheStructure.Common.PostSyncOperation);
912    }
913    inline void setGenericMediaStateClear(const bool value) {
914        TheStructure.Common.GenericMediaStateClear = value;
915    }
916    inline bool getGenericMediaStateClear() const {
917        return TheStructure.Common.GenericMediaStateClear;
918    }
919    inline void setPssStallSyncEnable(const bool value) {
920        TheStructure.Common.PssStallSyncEnable = value;
921    }
922    inline bool getPssStallSyncEnable() const {
923        return TheStructure.Common.PssStallSyncEnable;
924    }
925    inline void setTlbInvalidate(const bool value) {
926        TheStructure.Common.TlbInvalidate = value;
927    }
928    inline bool getTlbInvalidate() const {
929        return TheStructure.Common.TlbInvalidate;
930    }
931    inline void setDepthStallSyncEnable(const bool value) {
932        TheStructure.Common.DepthStallSyncEnable = value;
933    }
934    inline bool getDepthStallSyncEnable() const {
935        return TheStructure.Common.DepthStallSyncEnable;
936    }
937    inline void setCommandStreamerStallEnable(const bool value) {
938        TheStructure.Common.CommandStreamerStallEnable = value;
939    }
940    inline bool getCommandStreamerStallEnable() const {
941        return TheStructure.Common.CommandStreamerStallEnable;
942    }
943    inline void setStoreDataIndex(const bool value) {
944        TheStructure.Common.StoreDataIndex = value;
945    }
946    inline bool getStoreDataIndex() const {
947        return TheStructure.Common.StoreDataIndex;
948    }
949    inline void setLriPostSyncOperation(const LRI_POST_SYNC_OPERATION value) {
950        TheStructure.Common.LriPostSyncOperation = value;
951    }
952    inline LRI_POST_SYNC_OPERATION getLriPostSyncOperation() const {
953        return static_cast<LRI_POST_SYNC_OPERATION>(TheStructure.Common.LriPostSyncOperation);
954    }
955    inline void setDestinationAddressType(const DESTINATION_ADDRESS_TYPE value) {
956        TheStructure.Common.DestinationAddressType = value;
957    }
958    inline DESTINATION_ADDRESS_TYPE getDestinationAddressType() const {
959        return static_cast<DESTINATION_ADDRESS_TYPE>(TheStructure.Common.DestinationAddressType);
960    }
961    inline void setAmfsFlushEnable(const bool value) {
962        TheStructure.Common.AmfsFlushEnable = value;
963    }
964    inline bool getAmfsFlushEnable() const {
965        return TheStructure.Common.AmfsFlushEnable;
966    }
967    inline void setFlushLlc(const bool value) {
968        TheStructure.Common.FlushLlc = value;
969    }
970    inline bool getFlushLlc() const {
971        return TheStructure.Common.FlushLlc;
972    }
973    inline void setTileCacheFlushEnable(const bool value) {
974        TheStructure.Common.TileCacheFlushEnable = value;
975    }
976    inline bool getTileCacheFlushEnable() const {
977        return TheStructure.Common.TileCacheFlushEnable;
978    }
979    inline void setCommandCacheInvalidateEnable(const bool value) {
980        TheStructure.Common.CommandCacheInvalidateEnable = value;
981    }
982    inline bool getCommandCacheInvalidateEnable() const {
983        return TheStructure.Common.CommandCacheInvalidateEnable;
984    }
985    inline void setL3FabricFlush(const bool value) {
986        TheStructure.Common.L3FabricFlush = value;
987    }
988    inline bool getL3FabricFlush() const {
989        return TheStructure.Common.L3FabricFlush;
990    }
991    inline void setTbimrForceBatchClosure(const TBIMR_FORCE_BATCH_CLOSURE value) {
992        TheStructure.Common.TbimrForceBatchClosure = value;
993    }
994    inline TBIMR_FORCE_BATCH_CLOSURE getTbimrForceBatchClosure() const {
995        return static_cast<TBIMR_FORCE_BATCH_CLOSURE>(TheStructure.Common.TbimrForceBatchClosure);
996    }
997    typedef enum tagADDRESS {
998        ADDRESS_BIT_SHIFT = 0x2,
999        ADDRESS_ALIGN_SIZE = 0x4,
1000    } ADDRESS;
1001    inline void setAddress(const uint32_t value) {
1002        UNRECOVERABLE_IF(value > 0xffffffff);
1003        TheStructure.Common.Address = value >> ADDRESS_BIT_SHIFT;
1004    }
1005    inline uint32_t getAddress() const {
1006        return TheStructure.Common.Address << ADDRESS_BIT_SHIFT;
1007    }
1008    inline void setAddressHigh(const uint32_t value) {
1009        TheStructure.Common.AddressHigh = value;
1010    }
1011    inline uint32_t getAddressHigh() const {
1012        return TheStructure.Common.AddressHigh;
1013    }
1014    inline void setImmediateData(const uint64_t value) {
1015        TheStructure.Common.ImmediateData = value;
1016    }
1017    inline uint64_t getImmediateData() const {
1018        return TheStructure.Common.ImmediateData;
1019    }
1020} PIPE_CONTROL;
1021STATIC_ASSERT(24 == sizeof(PIPE_CONTROL));
1022
1023typedef struct tagMI_ATOMIC {
1024    union tagTheStructure {
1025        struct tagCommon {
1026            // DWORD 0
1027            uint32_t DwordLength : BITFIELD_RANGE(0, 7);
1028            uint32_t AtomicOpcode : BITFIELD_RANGE(8, 15);
1029            uint32_t ReturnDataControl : BITFIELD_RANGE(16, 16);
1030            uint32_t CsStall : BITFIELD_RANGE(17, 17);
1031            uint32_t InlineData : BITFIELD_RANGE(18, 18);
1032            uint32_t DataSize : BITFIELD_RANGE(19, 20);
1033            uint32_t PostSyncOperation : BITFIELD_RANGE(21, 21);
1034            uint32_t MemoryType : BITFIELD_RANGE(22, 22);
1035            uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28);
1036            uint32_t CommandType : BITFIELD_RANGE(29, 31);
1037            // DWORD 1
1038            uint64_t WorkloadPartitionIdOffsetEnable : BITFIELD_RANGE(0, 0);
1039            uint64_t Reserved_33 : BITFIELD_RANGE(1, 1);
1040            uint64_t MemoryAddress : BITFIELD_RANGE(2, 63);
1041            // DWORD 3
1042            uint32_t Operand1DataDword0;
1043            // DWORD 4
1044            uint32_t Operand2DataDword0;
1045            // DWORD 5
1046            uint32_t Operand1DataDword1;
1047            // DWORD 6
1048            uint32_t Operand2DataDword1;
1049            // DWORD 7
1050            uint32_t Operand1DataDword2;
1051            // DWORD 8
1052            uint32_t Operand2DataDword2;
1053            // DWORD 9
1054            uint32_t Operand1DataDword3;
1055            // DWORD 10
1056            uint32_t Operand2DataDword3;
1057        } Common;
1058        uint32_t RawData[11];
1059    } TheStructure;
1060    typedef enum tagDWORD_LENGTH {
1061        DWORD_LENGTH_INLINE_DATA_0 = 0x1,
1062        DWORD_LENGTH_INLINE_DATA_1 = 0x9,
1063    } DWORD_LENGTH;
1064    typedef enum tagDATA_SIZE {
1065        DATA_SIZE_DWORD = 0x0,
1066        DATA_SIZE_QWORD = 0x1,
1067        DATA_SIZE_OCTWORD = 0x2,
1068    } DATA_SIZE;
1069    typedef enum tagPOST_SYNC_OPERATION {
1070        POST_SYNC_OPERATION_NO_POST_SYNC_OPERATION = 0x0,
1071        POST_SYNC_OPERATION_POST_SYNC_OPERATION = 0x1,
1072    } POST_SYNC_OPERATION;
1073    typedef enum tagMEMORY_TYPE {
1074        MEMORY_TYPE_PER_PROCESS_GRAPHICS_ADDRESS = 0x0,
1075        MEMORY_TYPE_GLOBAL_GRAPHICS_ADDRESS = 0x1,
1076    } MEMORY_TYPE;
1077    typedef enum tagMI_COMMAND_OPCODE {
1078        MI_COMMAND_OPCODE_MI_ATOMIC = 0x2f,
1079    } MI_COMMAND_OPCODE;
1080    typedef enum tagCOMMAND_TYPE {
1081        COMMAND_TYPE_MI_COMMAND = 0x0,
1082    } COMMAND_TYPE;
1083    typedef enum tagATOMIC_OPCODES { // patched
1084        ATOMIC_4B_MOVE = 0x4,
1085        ATOMIC_4B_INCREMENT = 0x5,
1086        ATOMIC_4B_DECREMENT = 0x6,
1087        ATOMIC_8B_MOVE = 0x24,
1088        ATOMIC_8B_INCREMENT = 0x25,
1089        ATOMIC_8B_DECREMENT = 0x26,
1090    } ATOMIC_OPCODES;
1091    inline void init() {
1092        memset(&TheStructure, 0, sizeof(TheStructure));
1093        TheStructure.Common.DwordLength = DWORD_LENGTH_INLINE_DATA_0;
1094        TheStructure.Common.DataSize = DATA_SIZE_DWORD;
1095        TheStructure.Common.PostSyncOperation = POST_SYNC_OPERATION_NO_POST_SYNC_OPERATION;
1096        TheStructure.Common.MemoryType = MEMORY_TYPE_PER_PROCESS_GRAPHICS_ADDRESS;
1097        TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_ATOMIC;
1098        TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND;
1099    }
1100    static tagMI_ATOMIC sInit() {
1101        MI_ATOMIC state;
1102        state.init();
1103        return state;
1104    }
1105    inline uint32_t &getRawData(const uint32_t index) {
1106        UNRECOVERABLE_IF(index >= 11);
1107        return TheStructure.RawData[index];
1108    }
1109    inline void setDwordLength(const DWORD_LENGTH value) {
1110        TheStructure.Common.DwordLength = value;
1111    }
1112    inline DWORD_LENGTH getDwordLength() const {
1113        return static_cast<DWORD_LENGTH>(TheStructure.Common.DwordLength);
1114    }
1115    inline void setAtomicOpcode(const uint32_t value) {
1116        UNRECOVERABLE_IF(value > 0xff);
1117        TheStructure.Common.AtomicOpcode = value;
1118    }
1119    inline uint32_t getAtomicOpcode() const {
1120        return TheStructure.Common.AtomicOpcode;
1121    }
1122    inline void setReturnDataControl(const bool value) {
1123        TheStructure.Common.ReturnDataControl = value;
1124    }
1125    inline bool getReturnDataControl() const {
1126        return TheStructure.Common.ReturnDataControl;
1127    }
1128    inline void setCsStall(const bool value) {
1129        TheStructure.Common.CsStall = value;
1130    }
1131    inline bool getCsStall() const {
1132        return TheStructure.Common.CsStall;
1133    }
1134    inline void setInlineData(const bool value) {
1135        TheStructure.Common.InlineData = value;
1136    }
1137    inline bool getInlineData() const {
1138        return TheStructure.Common.InlineData;
1139    }
1140    inline void setDataSize(const DATA_SIZE value) {
1141        TheStructure.Common.DataSize = value;
1142    }
1143    inline DATA_SIZE getDataSize() const {
1144        return static_cast<DATA_SIZE>(TheStructure.Common.DataSize);
1145    }
1146    inline void setPostSyncOperation(const POST_SYNC_OPERATION value) {
1147        TheStructure.Common.PostSyncOperation = value;
1148    }
1149    inline POST_SYNC_OPERATION getPostSyncOperation() const {
1150        return static_cast<POST_SYNC_OPERATION>(TheStructure.Common.PostSyncOperation);
1151    }
1152    inline void setMemoryType(const MEMORY_TYPE value) {
1153        TheStructure.Common.MemoryType = value;
1154    }
1155    inline MEMORY_TYPE getMemoryType() const {
1156        return static_cast<MEMORY_TYPE>(TheStructure.Common.MemoryType);
1157    }
1158    inline void setWorkloadPartitionIdOffsetEnable(const bool value) {
1159        TheStructure.Common.WorkloadPartitionIdOffsetEnable = value;
1160    }
1161    inline bool getWorkloadPartitionIdOffsetEnable() const {
1162        return TheStructure.Common.WorkloadPartitionIdOffsetEnable;
1163    }
1164    typedef enum tagMEMORYADDRESS {
1165        MEMORYADDRESS_BIT_SHIFT = 0x2,
1166        MEMORYADDRESS_ALIGN_SIZE = 0x4,
1167    } MEMORYADDRESS;
1168    inline void setMemoryAddress(const uint64_t value) {
1169        UNRECOVERABLE_IF(value > 0xffffffffffffffffL);
1170        TheStructure.Common.MemoryAddress = value >> MEMORYADDRESS_BIT_SHIFT;
1171    }
1172    inline uint64_t getMemoryAddress() const {
1173        return TheStructure.Common.MemoryAddress << MEMORYADDRESS_BIT_SHIFT;
1174    }
1175    inline void setOperand1DataDword0(const uint32_t value) {
1176        TheStructure.Common.Operand1DataDword0 = value;
1177    }
1178    inline uint32_t getOperand1DataDword0() const {
1179        return TheStructure.Common.Operand1DataDword0;
1180    }
1181    inline void setOperand2DataDword0(const uint32_t value) {
1182        TheStructure.Common.Operand2DataDword0 = value;
1183    }
1184    inline uint32_t getOperand2DataDword0() const {
1185        return TheStructure.Common.Operand2DataDword0;
1186    }
1187    inline void setOperand1DataDword1(const uint32_t value) {
1188        TheStructure.Common.Operand1DataDword1 = value;
1189    }
1190    inline uint32_t getOperand1DataDword1() const {
1191        return TheStructure.Common.Operand1DataDword1;
1192    }
1193    inline void setOperand2DataDword1(const uint32_t value) {
1194        TheStructure.Common.Operand2DataDword1 = value;
1195    }
1196    inline uint32_t getOperand2DataDword1() const {
1197        return TheStructure.Common.Operand2DataDword1;
1198    }
1199    inline void setOperand1DataDword2(const uint32_t value) {
1200        TheStructure.Common.Operand1DataDword2 = value;
1201    }
1202    inline uint32_t getOperand1DataDword2() const {
1203        return TheStructure.Common.Operand1DataDword2;
1204    }
1205    inline void setOperand2DataDword2(const uint32_t value) {
1206        TheStructure.Common.Operand2DataDword2 = value;
1207    }
1208    inline uint32_t getOperand2DataDword2() const {
1209        return TheStructure.Common.Operand2DataDword2;
1210    }
1211    inline void setOperand1DataDword3(const uint32_t value) {
1212        TheStructure.Common.Operand1DataDword3 = value;
1213    }
1214    inline uint32_t getOperand1DataDword3() const {
1215        return TheStructure.Common.Operand1DataDword3;
1216    }
1217    inline void setOperand2DataDword3(const uint32_t value) {
1218        TheStructure.Common.Operand2DataDword3 = value;
1219    }
1220    inline uint32_t getOperand2DataDword3() const {
1221        return TheStructure.Common.Operand2DataDword3;
1222    }
1223} MI_ATOMIC;
1224STATIC_ASSERT(44 == sizeof(MI_ATOMIC));
1225
1226typedef struct tagMI_BATCH_BUFFER_END {
1227    union tagTheStructure {
1228        struct tagCommon {
1229            // DWORD 0
1230            uint32_t EndContext : BITFIELD_RANGE(0, 0);
1231            uint32_t Reserved_1 : BITFIELD_RANGE(1, 14);
1232            uint32_t PredicateEnable : BITFIELD_RANGE(15, 15);
1233            uint32_t Reserved_16 : BITFIELD_RANGE(16, 22);
1234            uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28);
1235            uint32_t CommandType : BITFIELD_RANGE(29, 31);
1236        } Common;
1237        uint32_t RawData[1];
1238    } TheStructure;
1239    typedef enum tagMI_COMMAND_OPCODE {
1240        MI_COMMAND_OPCODE_MI_BATCH_BUFFER_END = 0xa,
1241    } MI_COMMAND_OPCODE;
1242    typedef enum tagCOMMAND_TYPE {
1243        COMMAND_TYPE_MI_COMMAND = 0x0,
1244    } COMMAND_TYPE;
1245    inline void init() {
1246        memset(&TheStructure, 0, sizeof(TheStructure));
1247        TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_BATCH_BUFFER_END;
1248        TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND;
1249    }
1250    static tagMI_BATCH_BUFFER_END sInit() {
1251        MI_BATCH_BUFFER_END state;
1252        state.init();
1253        return state;
1254    }
1255    inline uint32_t &getRawData(const uint32_t index) {
1256        UNRECOVERABLE_IF(index >= 1);
1257        return TheStructure.RawData[index];
1258    }
1259    inline void setEndContext(const bool value) {
1260        TheStructure.Common.EndContext = value;
1261    }
1262    inline bool getEndContext() const {
1263        return TheStructure.Common.EndContext;
1264    }
1265    inline void setPredicateEnable(const bool value) {
1266        TheStructure.Common.PredicateEnable = value;
1267    }
1268    inline bool getPredicateEnable() const {
1269        return TheStructure.Common.PredicateEnable;
1270    }
1271} MI_BATCH_BUFFER_END;
1272STATIC_ASSERT(4 == sizeof(MI_BATCH_BUFFER_END));
1273
1274typedef struct tagMI_LOAD_REGISTER_IMM {
1275    union tagTheStructure {
1276        struct tagCommon {
1277            // DWORD 0
1278            uint32_t DwordLength : BITFIELD_RANGE(0, 7);
1279            uint32_t ByteWriteDisables : BITFIELD_RANGE(8, 11);
1280            uint32_t Reserved_12 : BITFIELD_RANGE(12, 16);
1281            uint32_t MmioRemapEnable : BITFIELD_RANGE(17, 17);
1282            uint32_t Reserved_18 : BITFIELD_RANGE(18, 18);
1283            uint32_t AddCsMmioStartOffset : BITFIELD_RANGE(19, 19);
1284            uint32_t Reserved_20 : BITFIELD_RANGE(20, 22);
1285            uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28);
1286            uint32_t CommandType : BITFIELD_RANGE(29, 31);
1287            // DWORD 1
1288            uint64_t Reserved_32 : BITFIELD_RANGE(0, 1);
1289            uint64_t RegisterOffset : BITFIELD_RANGE(2, 22);
1290            uint64_t Reserved_55 : BITFIELD_RANGE(23, 31);
1291            // DWORD 2
1292            uint64_t DataDword : BITFIELD_RANGE(32, 63);
1293        } Common;
1294        uint32_t RawData[3];
1295    } TheStructure;
1296    typedef enum tagDWORD_LENGTH {
1297        DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x1,
1298    } DWORD_LENGTH;
1299    typedef enum tagMI_COMMAND_OPCODE {
1300        MI_COMMAND_OPCODE_MI_LOAD_REGISTER_IMM = 0x22,
1301    } MI_COMMAND_OPCODE;
1302    typedef enum tagCOMMAND_TYPE {
1303        COMMAND_TYPE_MI_COMMAND = 0x0,
1304    } COMMAND_TYPE;
1305    inline void init() {
1306        memset(&TheStructure, 0, sizeof(TheStructure));
1307        TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1;
1308        TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_LOAD_REGISTER_IMM;
1309        TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND;
1310    }
1311    static tagMI_LOAD_REGISTER_IMM sInit() {
1312        MI_LOAD_REGISTER_IMM state;
1313        state.init();
1314        return state;
1315    }
1316    inline uint32_t &getRawData(const uint32_t index) {
1317        UNRECOVERABLE_IF(index >= 3);
1318        return TheStructure.RawData[index];
1319    }
1320    inline void setByteWriteDisables(const uint32_t value) {
1321        UNRECOVERABLE_IF(value > 0xf);
1322        TheStructure.Common.ByteWriteDisables = value;
1323    }
1324    inline uint32_t getByteWriteDisables() const {
1325        return TheStructure.Common.ByteWriteDisables;
1326    }
1327    inline void setMmioRemapEnable(const bool value) {
1328        TheStructure.Common.MmioRemapEnable = value;
1329    }
1330    inline bool getMmioRemapEnable() const {
1331        return TheStructure.Common.MmioRemapEnable;
1332    }
1333    inline void setAddCsMmioStartOffset(const bool value) {
1334        TheStructure.Common.AddCsMmioStartOffset = value;
1335    }
1336    inline bool getAddCsMmioStartOffset() const {
1337        return TheStructure.Common.AddCsMmioStartOffset;
1338    }
1339    typedef enum tagREGISTEROFFSET {
1340        REGISTEROFFSET_BIT_SHIFT = 0x2,
1341        REGISTEROFFSET_ALIGN_SIZE = 0x4,
1342    } REGISTEROFFSET;
1343    inline void setRegisterOffset(const uint64_t value) {
1344        UNRECOVERABLE_IF(value > 0x7fffffL);
1345        TheStructure.Common.RegisterOffset = value >> REGISTEROFFSET_BIT_SHIFT;
1346    }
1347    inline uint64_t getRegisterOffset() const {
1348        return TheStructure.Common.RegisterOffset << REGISTEROFFSET_BIT_SHIFT;
1349    }
1350    inline void setDataDword(const uint64_t value) {
1351        TheStructure.Common.DataDword = value;
1352    }
1353    inline uint64_t getDataDword() const {
1354        return TheStructure.Common.DataDword;
1355    }
1356} MI_LOAD_REGISTER_IMM;
1357STATIC_ASSERT(12 == sizeof(MI_LOAD_REGISTER_IMM));
1358
1359typedef struct tagMI_NOOP {
1360    union tagTheStructure {
1361        struct tagCommon {
1362            // DWORD 0
1363            uint32_t IdentificationNumber : BITFIELD_RANGE(0, 21);
1364            uint32_t IdentificationNumberRegisterWriteEnable : BITFIELD_RANGE(22, 22);
1365            uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28);
1366            uint32_t CommandType : BITFIELD_RANGE(29, 31);
1367        } Common;
1368        uint32_t RawData[1];
1369    } TheStructure;
1370    typedef enum tagMI_COMMAND_OPCODE {
1371        MI_COMMAND_OPCODE_MI_NOOP = 0x0,
1372    } MI_COMMAND_OPCODE;
1373    typedef enum tagCOMMAND_TYPE {
1374        COMMAND_TYPE_MI_COMMAND = 0x0,
1375    } COMMAND_TYPE;
1376    inline void init() {
1377        memset(&TheStructure, 0, sizeof(TheStructure));
1378        TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_NOOP;
1379        TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND;
1380    }
1381    static tagMI_NOOP sInit() {
1382        MI_NOOP state;
1383        state.init();
1384        return state;
1385    }
1386    inline uint32_t &getRawData(const uint32_t index) {
1387        UNRECOVERABLE_IF(index >= 1);
1388        return TheStructure.RawData[index];
1389    }
1390    inline void setIdentificationNumber(const uint32_t value) {
1391        UNRECOVERABLE_IF(value > 0x3fffff);
1392        TheStructure.Common.IdentificationNumber = value;
1393    }
1394    inline uint32_t getIdentificationNumber() const {
1395        return TheStructure.Common.IdentificationNumber;
1396    }
1397    inline void setIdentificationNumberRegisterWriteEnable(const bool value) {
1398        TheStructure.Common.IdentificationNumberRegisterWriteEnable = value;
1399    }
1400    inline bool getIdentificationNumberRegisterWriteEnable() const {
1401        return TheStructure.Common.IdentificationNumberRegisterWriteEnable;
1402    }
1403} MI_NOOP;
1404STATIC_ASSERT(4 == sizeof(MI_NOOP));
1405
1406typedef struct tagRENDER_SURFACE_STATE {
1407    union tagTheStructure {
1408        struct tagCommon {
1409            // DWORD 0
1410            uint32_t CubeFaceEnablePositiveZ : BITFIELD_RANGE(0, 0);
1411            uint32_t CubeFaceEnableNegativeZ : BITFIELD_RANGE(1, 1);
1412            uint32_t CubeFaceEnablePositiveY : BITFIELD_RANGE(2, 2);
1413            uint32_t CubeFaceEnableNegativeY : BITFIELD_RANGE(3, 3);
1414            uint32_t CubeFaceEnablePositiveX : BITFIELD_RANGE(4, 4);
1415            uint32_t CubeFaceEnableNegativeX : BITFIELD_RANGE(5, 5);
1416            uint32_t MediaBoundaryPixelMode : BITFIELD_RANGE(6, 7);
1417            uint32_t RenderCacheReadWriteMode : BITFIELD_RANGE(8, 8);
1418            uint32_t SamplerL2OutOfOrderModeDisable : BITFIELD_RANGE(9, 9);
1419            uint32_t VerticalLineStrideOffset : BITFIELD_RANGE(10, 10);
1420            uint32_t VerticalLineStride : BITFIELD_RANGE(11, 11);
1421            uint32_t TileMode : BITFIELD_RANGE(12, 13);
1422            uint32_t SurfaceHorizontalAlignment : BITFIELD_RANGE(14, 15);
1423            uint32_t SurfaceVerticalAlignment : BITFIELD_RANGE(16, 17);
1424            uint32_t SurfaceFormat : BITFIELD_RANGE(18, 26);
1425            uint32_t AstcEnable : BITFIELD_RANGE(27, 27);
1426            uint32_t SurfaceArray : BITFIELD_RANGE(28, 28);
1427            uint32_t SurfaceType : BITFIELD_RANGE(29, 31);
1428            // DWORD 1
1429            uint32_t SurfaceQpitch : BITFIELD_RANGE(0, 14);
1430            uint32_t SampleTapDiscardDisable : BITFIELD_RANGE(15, 15);
1431            uint32_t Reserved_48 : BITFIELD_RANGE(16, 16);
1432            uint32_t DoubleFetchDisable : BITFIELD_RANGE(17, 17);
1433            uint32_t CornerTexelMode : BITFIELD_RANGE(18, 18);
1434            uint32_t BaseMipLevel : BITFIELD_RANGE(19, 23);
1435            uint32_t MemoryObjectControlStateReserved_56 : BITFIELD_RANGE(24, 24);
1436            uint32_t MemoryObjectControlStateIndexToMocsTables : BITFIELD_RANGE(25, 30);
1437            uint32_t Reserved_63 : BITFIELD_RANGE(31, 31);
1438            // DWORD 2
1439            uint32_t Width : BITFIELD_RANGE(0, 13);
1440            uint32_t Reserved_78 : BITFIELD_RANGE(14, 15);
1441            uint32_t Height : BITFIELD_RANGE(16, 29);
1442            uint32_t Reserved_94 : BITFIELD_RANGE(30, 30);
1443            uint32_t DepthStencilResource : BITFIELD_RANGE(31, 31);
1444            // DWORD 3
1445            uint32_t SurfacePitch : BITFIELD_RANGE(0, 17);
1446            uint32_t NullProbingEnable : BITFIELD_RANGE(18, 18);
1447            uint32_t Reserved_115 : BITFIELD_RANGE(19, 20);
1448            uint32_t Depth : BITFIELD_RANGE(21, 31);
1449            // DWORD 4
1450            uint32_t MultisamplePositionPaletteIndex : BITFIELD_RANGE(0, 2);
1451            uint32_t NumberOfMultisamples : BITFIELD_RANGE(3, 5);
1452            uint32_t MultisampledSurfaceStorageFormat : BITFIELD_RANGE(6, 6);
1453            uint32_t RenderTargetViewExtent : BITFIELD_RANGE(7, 17);
1454            uint32_t MinimumArrayElement : BITFIELD_RANGE(18, 28);
1455            uint32_t RenderTargetAndSampleUnormRotation : BITFIELD_RANGE(29, 30);
1456            uint32_t Reserved_159 : BITFIELD_RANGE(31, 31);
1457            // DWORD 5
1458            uint32_t MipCountLod : BITFIELD_RANGE(0, 3);
1459            uint32_t SurfaceMinLod : BITFIELD_RANGE(4, 7);
1460            uint32_t MipTailStartLod : BITFIELD_RANGE(8, 11);
1461            uint32_t Reserved_172 : BITFIELD_RANGE(12, 13);
1462            uint32_t CoherencyType : BITFIELD_RANGE(14, 15);
1463            uint32_t L1CachePolicyL1CacheControl : BITFIELD_RANGE(16, 18);
1464            uint32_t Reserved_179 : BITFIELD_RANGE(19, 19);
1465            uint32_t EwaDisableForCube : BITFIELD_RANGE(20, 20);
1466            uint32_t YOffset : BITFIELD_RANGE(21, 23);
1467            uint32_t Reserved_184 : BITFIELD_RANGE(24, 24);
1468            uint32_t XOffset : BITFIELD_RANGE(25, 31);
1469            // DWORD 6
1470            uint32_t Reserved_192 : BITFIELD_RANGE(0, 14);
1471            uint32_t YuvInterpolationEnable : BITFIELD_RANGE(15, 15);
1472            uint32_t Reserved_208 : BITFIELD_RANGE(16, 31);
1473            // DWORD 7
1474            uint32_t ResourceMinLod : BITFIELD_RANGE(0, 11);
1475            uint32_t Reserved_236 : BITFIELD_RANGE(12, 13);
1476            uint32_t DisableSupportForMultiGpuAtomics : BITFIELD_RANGE(14, 14);
1477            uint32_t DisableSupportForMultiGpuPartialWrites : BITFIELD_RANGE(15, 15);
1478            uint32_t ShaderChannelSelectAlpha : BITFIELD_RANGE(16, 18);
1479            uint32_t ShaderChannelSelectBlue : BITFIELD_RANGE(19, 21);
1480            uint32_t ShaderChannelSelectGreen : BITFIELD_RANGE(22, 24);
1481            uint32_t ShaderChannelSelectRed : BITFIELD_RANGE(25, 27);
1482            uint32_t Reserved_252 : BITFIELD_RANGE(28, 29);
1483            uint32_t MemoryCompressionEnable : BITFIELD_RANGE(30, 30);
1484            uint32_t MemoryCompressionMode : BITFIELD_RANGE(31, 31);
1485            // DWORD 8
1486            uint64_t SurfaceBaseAddress;
1487            // DWORD 10
1488            uint64_t QuiltWidth : BITFIELD_RANGE(0, 4);
1489            uint64_t QuiltHeight : BITFIELD_RANGE(5, 9);
1490            uint64_t ClearValueAddressEnable : BITFIELD_RANGE(10, 10);
1491            uint64_t ProceduralTexture : BITFIELD_RANGE(11, 11);
1492            uint64_t Reserved_332 : BITFIELD_RANGE(12, 63);
1493            // DWORD 12
1494            uint32_t CompressionFormat : BITFIELD_RANGE(0, 4);
1495            uint32_t Reserved_389 : BITFIELD_RANGE(5, 5);
1496            uint32_t ClearAddressLow : BITFIELD_RANGE(6, 31);
1497            // DWORD 13
1498            uint32_t ClearAddressHigh : BITFIELD_RANGE(0, 15);
1499            uint32_t Reserved_432 : BITFIELD_RANGE(16, 31);
1500            // DWORD 14
1501            uint32_t Reserved_448;
1502            // DWORD 15
1503            uint32_t Reserved_480;
1504        } Common;
1505        struct tag_SurfaceFormatIsPlanar {
1506            // DWORD 0
1507            uint32_t Reserved_0;
1508            // DWORD 1
1509            uint32_t Reserved_32;
1510            // DWORD 2
1511            uint32_t Reserved_64;
1512            // DWORD 3
1513            uint32_t Reserved_96;
1514            // DWORD 4
1515            uint32_t Reserved_128;
1516            // DWORD 5
1517            uint32_t Reserved_160;
1518            // DWORD 6
1519            uint32_t YOffsetForUOrUvPlane : BITFIELD_RANGE(0, 13);
1520            uint32_t Reserved_206 : BITFIELD_RANGE(14, 15);
1521            uint32_t XOffsetForUOrUvPlane : BITFIELD_RANGE(16, 29);
1522            uint32_t HalfPitchForChroma : BITFIELD_RANGE(30, 30);
1523            uint32_t SeparateUvPlaneEnable : BITFIELD_RANGE(31, 31);
1524            // DWORD 7
1525            uint32_t Reserved_224;
1526            // DWORD 8
1527            uint64_t Reserved_256;
1528            // DWORD 10
1529            uint64_t Reserved_320 : BITFIELD_RANGE(0, 11);
1530            uint64_t Reserved_332 : BITFIELD_RANGE(12, 31);
1531            // DWORD 11
1532            uint64_t YOffsetForVPlane : BITFIELD_RANGE(32, 45);
1533            uint64_t Reserved_366 : BITFIELD_RANGE(46, 47);
1534            uint64_t XOffsetForVPlane : BITFIELD_RANGE(48, 61);
1535            uint64_t Reserved_382 : BITFIELD_RANGE(62, 63);
1536            // DWORD 12
1537            uint32_t Reserved_384;
1538            // DWORD 13
1539            uint32_t Reserved_416;
1540            // DWORD 14
1541            uint32_t Reserved_448;
1542            // DWORD 15
1543            uint32_t Reserved_480;
1544        } _SurfaceFormatIsPlanar;
1545        struct tag_SurfaceFormatIsnotPlanar {
1546            // DWORD 0
1547            uint32_t Reserved_0;
1548            // DWORD 1
1549            uint32_t Reserved_32;
1550            // DWORD 2
1551            uint32_t Reserved_64;
1552            // DWORD 3
1553            uint32_t Reserved_96;
1554            // DWORD 4
1555            uint32_t Reserved_128;
1556            // DWORD 5
1557            uint32_t Reserved_160;
1558            // DWORD 6
1559            uint32_t AuxiliarySurfaceMode : BITFIELD_RANGE(0, 2);
1560            uint32_t AuxiliarySurfacePitch : BITFIELD_RANGE(3, 12);
1561            uint32_t Reserved_205 : BITFIELD_RANGE(13, 13);
1562            uint32_t Reserved_206 : BITFIELD_RANGE(14, 15);
1563            uint32_t AuxiliarySurfaceQpitch : BITFIELD_RANGE(16, 30);
1564            uint32_t Reserved_223 : BITFIELD_RANGE(31, 31);
1565            // DWORD 7
1566            uint32_t Reserved_224;
1567            // DWORD 8
1568            uint64_t Reserved_256;
1569            // DWORD 10
1570            uint64_t Reserved_320;
1571            // DWORD 12
1572            uint32_t Reserved_384;
1573            // DWORD 13
1574            uint32_t Reserved_416;
1575            // DWORD 14
1576            uint32_t Reserved_448;
1577            // DWORD 15
1578            uint32_t Reserved_480;
1579        } _SurfaceFormatIsnotPlanar;
1580        struct tag_SurfaceFormatIsnotPlanarAndMemoryCompressionEnableIs0 {
1581            // DWORD 0
1582            uint32_t Reserved_0;
1583            // DWORD 1
1584            uint32_t Reserved_32;
1585            // DWORD 2
1586            uint32_t Reserved_64;
1587            // DWORD 3
1588            uint32_t Reserved_96;
1589            // DWORD 4
1590            uint32_t Reserved_128;
1591            // DWORD 5
1592            uint32_t Reserved_160;
1593            // DWORD 6
1594            uint32_t Reserved_192;
1595            // DWORD 7
1596            uint32_t Reserved_224;
1597            // DWORD 8
1598            uint64_t Reserved_256;
1599            // DWORD 10
1600            uint64_t Reserved_320 : BITFIELD_RANGE(0, 11);
1601            uint64_t AuxiliarySurfaceBaseAddress : BITFIELD_RANGE(12, 63);
1602            // DWORD 12
1603            uint32_t Reserved_384;
1604            // DWORD 13
1605            uint32_t Reserved_416;
1606            // DWORD 14
1607            uint32_t Reserved_448;
1608            // DWORD 15
1609            uint32_t Reserved_480;
1610        } _SurfaceFormatIsnotPlanarAndMemoryCompressionEnableIs0;
1611        uint32_t RawData[16];
1612    } TheStructure;
1613    typedef enum tagMEDIA_BOUNDARY_PIXEL_MODE {
1614        MEDIA_BOUNDARY_PIXEL_MODE_NORMAL_MODE = 0x0,
1615        MEDIA_BOUNDARY_PIXEL_MODE_PROGRESSIVE_FRAME = 0x2,
1616        MEDIA_BOUNDARY_PIXEL_MODE_INTERLACED_FRAME = 0x3,
1617    } MEDIA_BOUNDARY_PIXEL_MODE;
1618    typedef enum tagRENDER_CACHE_READ_WRITE_MODE {
1619        RENDER_CACHE_READ_WRITE_MODE_WRITE_ONLY_CACHE = 0x0,
1620        RENDER_CACHE_READ_WRITE_MODE_READ_WRITE_CACHE = 0x1,
1621    } RENDER_CACHE_READ_WRITE_MODE;
1622    typedef enum tagTILE_MODE {
1623        TILE_MODE_LINEAR = 0x0,
1624        TILE_MODE_TILE64 = 0x1,
1625        TILE_MODE_XMAJOR = 0x2,
1626        TILE_MODE_YMAJOR = 0x3,
1627    } TILE_MODE;
1628    typedef enum tagSURFACE_HORIZONTAL_ALIGNMENT {
1629        SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_4 = 0x1,
1630        SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_8 = 0x2,
1631        SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_16 = 0x3,
1632    } SURFACE_HORIZONTAL_ALIGNMENT;
1633    typedef enum tagSURFACE_VERTICAL_ALIGNMENT {
1634        SURFACE_VERTICAL_ALIGNMENT_VALIGN_4 = 0x1,
1635        SURFACE_VERTICAL_ALIGNMENT_VALIGN_8 = 0x2,
1636        SURFACE_VERTICAL_ALIGNMENT_VALIGN_16 = 0x3,
1637    } SURFACE_VERTICAL_ALIGNMENT;
1638    typedef enum tagSURFACE_FORMAT {
1639        SURFACE_FORMAT_R32G32B32A32_FLOAT = 0x0,
1640        SURFACE_FORMAT_R32G32B32A32_SINT = 0x1,
1641        SURFACE_FORMAT_R32G32B32A32_UINT = 0x2,
1642        SURFACE_FORMAT_R32G32B32A32_UNORM = 0x3,
1643        SURFACE_FORMAT_R32G32B32A32_SNORM = 0x4,
1644        SURFACE_FORMAT_R64G64_FLOAT = 0x5,
1645        SURFACE_FORMAT_R32G32B32X32_FLOAT = 0x6,
1646        SURFACE_FORMAT_R32G32B32A32_SSCALED = 0x7,
1647        SURFACE_FORMAT_R32G32B32A32_USCALED = 0x8,
1648        SURFACE_FORMAT_R32G32B32A32_SFIXED = 0x20,
1649        SURFACE_FORMAT_R64G64_PASSTHRU = 0x21,
1650        SURFACE_FORMAT_R32G32B32_FLOAT = 0x40,
1651        SURFACE_FORMAT_R32G32B32_SINT = 0x41,
1652        SURFACE_FORMAT_R32G32B32_UINT = 0x42,
1653        SURFACE_FORMAT_R32G32B32_UNORM = 0x43,
1654        SURFACE_FORMAT_R32G32B32_SNORM = 0x44,
1655        SURFACE_FORMAT_R32G32B32_SSCALED = 0x45,
1656        SURFACE_FORMAT_R32G32B32_USCALED = 0x46,
1657        SURFACE_FORMAT_R32G32B32_SFIXED = 0x50,
1658        SURFACE_FORMAT_R16G16B16A16_UNORM = 0x80,
1659        SURFACE_FORMAT_R16G16B16A16_SNORM = 0x81,
1660        SURFACE_FORMAT_R16G16B16A16_SINT = 0x82,
1661        SURFACE_FORMAT_R16G16B16A16_UINT = 0x83,
1662        SURFACE_FORMAT_R16G16B16A16_FLOAT = 0x84,
1663        SURFACE_FORMAT_R32G32_FLOAT = 0x85,
1664        SURFACE_FORMAT_R32G32_SINT = 0x86,
1665        SURFACE_FORMAT_R32G32_UINT = 0x87,
1666        SURFACE_FORMAT_R32_FLOAT_X8X24_TYPELESS = 0x88,
1667        SURFACE_FORMAT_X32_TYPELESS_G8X24_UINT = 0x89,
1668        SURFACE_FORMAT_L32A32_FLOAT = 0x8a,
1669        SURFACE_FORMAT_R32G32_UNORM = 0x8b,
1670        SURFACE_FORMAT_R32G32_SNORM = 0x8c,
1671        SURFACE_FORMAT_R64_FLOAT = 0x8d,
1672        SURFACE_FORMAT_R16G16B16X16_UNORM = 0x8e,
1673        SURFACE_FORMAT_R16G16B16X16_FLOAT = 0x8f,
1674        SURFACE_FORMAT_A32X32_FLOAT = 0x90,
1675        SURFACE_FORMAT_L32X32_FLOAT = 0x91,
1676        SURFACE_FORMAT_I32X32_FLOAT = 0x92,
1677        SURFACE_FORMAT_R16G16B16A16_SSCALED = 0x93,
1678        SURFACE_FORMAT_R16G16B16A16_USCALED = 0x94,
1679        SURFACE_FORMAT_R32G32_SSCALED = 0x95,
1680        SURFACE_FORMAT_R32G32_USCALED = 0x96,
1681        SURFACE_FORMAT_R32G32_SFIXED = 0xa0,
1682        SURFACE_FORMAT_R64_PASSTHRU = 0xa1,
1683        SURFACE_FORMAT_B8G8R8A8_UNORM = 0xc0,
1684        SURFACE_FORMAT_B8G8R8A8_UNORM_SRGB = 0xc1,
1685        SURFACE_FORMAT_R10G10B10A2_UNORM = 0xc2,
1686        SURFACE_FORMAT_R10G10B10A2_UNORM_SRGB = 0xc3,
1687        SURFACE_FORMAT_R10G10B10A2_UINT = 0xc4,
1688        SURFACE_FORMAT_R10G10B10_SNORM_A2_UNORM = 0xc5,
1689        SURFACE_FORMAT_R8G8B8A8_UNORM = 0xc7,
1690        SURFACE_FORMAT_R8G8B8A8_UNORM_SRGB = 0xc8,
1691        SURFACE_FORMAT_R8G8B8A8_SNORM = 0xc9,
1692        SURFACE_FORMAT_R8G8B8A8_SINT = 0xca,
1693        SURFACE_FORMAT_R8G8B8A8_UINT = 0xcb,
1694        SURFACE_FORMAT_R16G16_UNORM = 0xcc,
1695        SURFACE_FORMAT_R16G16_SNORM = 0xcd,
1696        SURFACE_FORMAT_R16G16_SINT = 0xce,
1697        SURFACE_FORMAT_R16G16_UINT = 0xcf,
1698        SURFACE_FORMAT_R16G16_FLOAT = 0xd0,
1699        SURFACE_FORMAT_B10G10R10A2_UNORM = 0xd1,
1700        SURFACE_FORMAT_B10G10R10A2_UNORM_SRGB = 0xd2,
1701        SURFACE_FORMAT_R11G11B10_FLOAT = 0xd3,
1702        SURFACE_FORMAT_R10G10B10_FLOAT_A2_UNORM = 0xd5,
1703        SURFACE_FORMAT_R32_SINT = 0xd6,
1704        SURFACE_FORMAT_R32_UINT = 0xd7,
1705        SURFACE_FORMAT_R32_FLOAT = 0xd8,
1706        SURFACE_FORMAT_R24_UNORM_X8_TYPELESS = 0xd9,
1707        SURFACE_FORMAT_X24_TYPELESS_G8_UINT = 0xda,
1708        SURFACE_FORMAT_L32_UNORM = 0xdd,
1709        SURFACE_FORMAT_A32_UNORM = 0xde,
1710        SURFACE_FORMAT_L16A16_UNORM = 0xdf,
1711        SURFACE_FORMAT_I24X8_UNORM = 0xe0,
1712        SURFACE_FORMAT_L24X8_UNORM = 0xe1,
1713        SURFACE_FORMAT_A24X8_UNORM = 0xe2,
1714        SURFACE_FORMAT_I32_FLOAT = 0xe3,
1715        SURFACE_FORMAT_L32_FLOAT = 0xe4,
1716        SURFACE_FORMAT_A32_FLOAT = 0xe5,
1717        SURFACE_FORMAT_X8B8_UNORM_G8R8_SNORM = 0xe6,
1718        SURFACE_FORMAT_A8X8_UNORM_G8R8_SNORM = 0xe7,
1719        SURFACE_FORMAT_B8X8_UNORM_G8R8_SNORM = 0xe8,
1720        SURFACE_FORMAT_B8G8R8X8_UNORM = 0xe9,
1721        SURFACE_FORMAT_B8G8R8X8_UNORM_SRGB = 0xea,
1722        SURFACE_FORMAT_R8G8B8X8_UNORM = 0xeb,
1723        SURFACE_FORMAT_R8G8B8X8_UNORM_SRGB = 0xec,
1724        SURFACE_FORMAT_R9G9B9E5_SHAREDEXP = 0xed,
1725        SURFACE_FORMAT_B10G10R10X2_UNORM = 0xee,
1726        SURFACE_FORMAT_L16A16_FLOAT = 0xf0,
1727        SURFACE_FORMAT_R32_UNORM = 0xf1,
1728        SURFACE_FORMAT_R32_SNORM = 0xf2,
1729        SURFACE_FORMAT_R10G10B10X2_USCALED = 0xf3,
1730        SURFACE_FORMAT_R8G8B8A8_SSCALED = 0xf4,
1731        SURFACE_FORMAT_R8G8B8A8_USCALED = 0xf5,
1732        SURFACE_FORMAT_R16G16_SSCALED = 0xf6,
1733        SURFACE_FORMAT_R16G16_USCALED = 0xf7,
1734        SURFACE_FORMAT_R32_SSCALED = 0xf8,
1735        SURFACE_FORMAT_R32_USCALED = 0xf9,
1736        SURFACE_FORMAT_B5G6R5_UNORM = 0x100,
1737        SURFACE_FORMAT_B5G6R5_UNORM_SRGB = 0x101,
1738        SURFACE_FORMAT_B5G5R5A1_UNORM = 0x102,
1739        SURFACE_FORMAT_B5G5R5A1_UNORM_SRGB = 0x103,
1740        SURFACE_FORMAT_B4G4R4A4_UNORM = 0x104,
1741        SURFACE_FORMAT_B4G4R4A4_UNORM_SRGB = 0x105,
1742        SURFACE_FORMAT_R8G8_UNORM = 0x106,
1743        SURFACE_FORMAT_R8G8_SNORM = 0x107,
1744        SURFACE_FORMAT_R8G8_SINT = 0x108,
1745        SURFACE_FORMAT_R8G8_UINT = 0x109,
1746        SURFACE_FORMAT_R16_UNORM = 0x10a,
1747        SURFACE_FORMAT_R16_SNORM = 0x10b,
1748        SURFACE_FORMAT_R16_SINT = 0x10c,
1749        SURFACE_FORMAT_R16_UINT = 0x10d,
1750        SURFACE_FORMAT_R16_FLOAT = 0x10e,
1751        SURFACE_FORMAT_A8P8_UNORM_PALETTE0 = 0x10f,
1752        SURFACE_FORMAT_A8P8_UNORM_PALETTE1 = 0x110,
1753        SURFACE_FORMAT_I16_UNORM = 0x111,
1754        SURFACE_FORMAT_L16_UNORM = 0x112,
1755        SURFACE_FORMAT_A16_UNORM = 0x113,
1756        SURFACE_FORMAT_L8A8_UNORM = 0x114,
1757        SURFACE_FORMAT_I16_FLOAT = 0x115,
1758        SURFACE_FORMAT_L16_FLOAT = 0x116,
1759        SURFACE_FORMAT_A16_FLOAT = 0x117,
1760        SURFACE_FORMAT_L8A8_UNORM_SRGB = 0x118,
1761        SURFACE_FORMAT_R5G5_SNORM_B6_UNORM = 0x119,
1762        SURFACE_FORMAT_B5G5R5X1_UNORM = 0x11a,
1763        SURFACE_FORMAT_B5G5R5X1_UNORM_SRGB = 0x11b,
1764        SURFACE_FORMAT_R8G8_SSCALED = 0x11c,
1765        SURFACE_FORMAT_R8G8_USCALED = 0x11d,
1766        SURFACE_FORMAT_R16_SSCALED = 0x11e,
1767        SURFACE_FORMAT_R16_USCALED = 0x11f,
1768        SURFACE_FORMAT_P8A8_UNORM_PALETTE0 = 0x122,
1769        SURFACE_FORMAT_P8A8_UNORM_PALETTE1 = 0x123,
1770        SURFACE_FORMAT_A1B5G5R5_UNORM = 0x124,
1771        SURFACE_FORMAT_A4B4G4R4_UNORM = 0x125,
1772        SURFACE_FORMAT_L8A8_UINT = 0x126,
1773        SURFACE_FORMAT_L8A8_SINT = 0x127,
1774        SURFACE_FORMAT_R8_UNORM = 0x140,
1775        SURFACE_FORMAT_R8_SNORM = 0x141,
1776        SURFACE_FORMAT_R8_SINT = 0x142,
1777        SURFACE_FORMAT_R8_UINT = 0x143,
1778        SURFACE_FORMAT_A8_UNORM = 0x144,
1779        SURFACE_FORMAT_I8_UNORM = 0x145,
1780        SURFACE_FORMAT_L8_UNORM = 0x146,
1781        SURFACE_FORMAT_P4A4_UNORM_PALETTE0 = 0x147,
1782        SURFACE_FORMAT_A4P4_UNORM_PALETTE0 = 0x148,
1783        SURFACE_FORMAT_R8_SSCALED = 0x149,
1784        SURFACE_FORMAT_R8_USCALED = 0x14a,
1785        SURFACE_FORMAT_P8_UNORM_PALETTE0 = 0x14b,
1786        SURFACE_FORMAT_L8_UNORM_SRGB = 0x14c,
1787        SURFACE_FORMAT_P8_UNORM_PALETTE1 = 0x14d,
1788        SURFACE_FORMAT_P4A4_UNORM_PALETTE1 = 0x14e,
1789        SURFACE_FORMAT_A4P4_UNORM_PALETTE1 = 0x14f,
1790        SURFACE_FORMAT_Y8_UNORM = 0x150,
1791        SURFACE_FORMAT_L8_UINT = 0x152,
1792        SURFACE_FORMAT_L8_SINT = 0x153,
1793        SURFACE_FORMAT_I8_UINT = 0x154,
1794        SURFACE_FORMAT_I8_SINT = 0x155,
1795        SURFACE_FORMAT_DXT1_RGB_SRGB = 0x180,
1796        SURFACE_FORMAT_R1_UNORM = 0x181,
1797        SURFACE_FORMAT_YCRCB_NORMAL = 0x182,
1798        SURFACE_FORMAT_YCRCB_SWAPUVY = 0x183,
1799        SURFACE_FORMAT_P2_UNORM_PALETTE0 = 0x184,
1800        SURFACE_FORMAT_P2_UNORM_PALETTE1 = 0x185,
1801        SURFACE_FORMAT_BC1_UNORM = 0x186,
1802        SURFACE_FORMAT_BC2_UNORM = 0x187,
1803        SURFACE_FORMAT_BC3_UNORM = 0x188,
1804        SURFACE_FORMAT_BC4_UNORM = 0x189,
1805        SURFACE_FORMAT_BC5_UNORM = 0x18a,
1806        SURFACE_FORMAT_BC1_UNORM_SRGB = 0x18b,
1807        SURFACE_FORMAT_BC2_UNORM_SRGB = 0x18c,
1808        SURFACE_FORMAT_BC3_UNORM_SRGB = 0x18d,
1809        SURFACE_FORMAT_MONO8 = 0x18e,
1810        SURFACE_FORMAT_YCRCB_SWAPUV = 0x18f,
1811        SURFACE_FORMAT_YCRCB_SWAPY = 0x190,
1812        SURFACE_FORMAT_DXT1_RGB = 0x191,
1813        SURFACE_FORMAT_R8G8B8_UNORM = 0x193,
1814        SURFACE_FORMAT_R8G8B8_SNORM = 0x194,
1815        SURFACE_FORMAT_R8G8B8_SSCALED = 0x195,
1816        SURFACE_FORMAT_R8G8B8_USCALED = 0x196,
1817        SURFACE_FORMAT_R64G64B64A64_FLOAT = 0x197,
1818        SURFACE_FORMAT_R64G64B64_FLOAT = 0x198,
1819        SURFACE_FORMAT_BC4_SNORM = 0x199,
1820        SURFACE_FORMAT_BC5_SNORM = 0x19a,
1821        SURFACE_FORMAT_R16G16B16_FLOAT = 0x19b,
1822        SURFACE_FORMAT_R16G16B16_UNORM = 0x19c,
1823        SURFACE_FORMAT_R16G16B16_SNORM = 0x19d,
1824        SURFACE_FORMAT_R16G16B16_SSCALED = 0x19e,
1825        SURFACE_FORMAT_R16G16B16_USCALED = 0x19f,
1826        SURFACE_FORMAT_BC6H_SF16 = 0x1a1,
1827        SURFACE_FORMAT_BC7_UNORM = 0x1a2,
1828        SURFACE_FORMAT_BC7_UNORM_SRGB = 0x1a3,
1829        SURFACE_FORMAT_BC6H_UF16 = 0x1a4,
1830        SURFACE_FORMAT_PLANAR_420_8 = 0x1a5,
1831        SURFACE_FORMAT_PLANAR_420_16 = 0x1a6,
1832        SURFACE_FORMAT_R8G8B8_UNORM_SRGB = 0x1a8,
1833        SURFACE_FORMAT_ETC1_RGB8 = 0x1a9,
1834        SURFACE_FORMAT_ETC2_RGB8 = 0x1aa,
1835        SURFACE_FORMAT_EAC_R11 = 0x1ab,
1836        SURFACE_FORMAT_EAC_RG11 = 0x1ac,
1837        SURFACE_FORMAT_EAC_SIGNED_R11 = 0x1ad,
1838        SURFACE_FORMAT_EAC_SIGNED_RG11 = 0x1ae,
1839        SURFACE_FORMAT_ETC2_SRGB8 = 0x1af,
1840        SURFACE_FORMAT_R16G16B16_UINT = 0x1b0,
1841        SURFACE_FORMAT_R16G16B16_SINT = 0x1b1,
1842        SURFACE_FORMAT_R32_SFIXED = 0x1b2,
1843        SURFACE_FORMAT_R10G10B10A2_SNORM = 0x1b3,
1844        SURFACE_FORMAT_R10G10B10A2_USCALED = 0x1b4,
1845        SURFACE_FORMAT_R10G10B10A2_SSCALED = 0x1b5,
1846        SURFACE_FORMAT_R10G10B10A2_SINT = 0x1b6,
1847        SURFACE_FORMAT_B10G10R10A2_SNORM = 0x1b7,
1848        SURFACE_FORMAT_B10G10R10A2_USCALED = 0x1b8,
1849        SURFACE_FORMAT_B10G10R10A2_SSCALED = 0x1b9,
1850        SURFACE_FORMAT_B10G10R10A2_UINT = 0x1ba,
1851        SURFACE_FORMAT_B10G10R10A2_SINT = 0x1bb,
1852        SURFACE_FORMAT_R64G64B64A64_PASSTHRU = 0x1bc,
1853        SURFACE_FORMAT_R64G64B64_PASSTHRU = 0x1bd,
1854        SURFACE_FORMAT_ETC2_RGB8_PTA = 0x1c0,
1855        SURFACE_FORMAT_ETC2_SRGB8_PTA = 0x1c1,
1856        SURFACE_FORMAT_ETC2_EAC_RGBA8 = 0x1c2,
1857        SURFACE_FORMAT_ETC2_EAC_SRGB8_A8 = 0x1c3,
1858        SURFACE_FORMAT_R8G8B8_UINT = 0x1c8,
1859        SURFACE_FORMAT_R8G8B8_SINT = 0x1c9,
1860        SURFACE_FORMAT_RAW = 0x1ff,
1861    } SURFACE_FORMAT;
1862    typedef enum tagSURFACE_TYPE {
1863        SURFACE_TYPE_SURFTYPE_1D = 0x0,
1864        SURFACE_TYPE_SURFTYPE_2D = 0x1,
1865        SURFACE_TYPE_SURFTYPE_3D = 0x2,
1866        SURFACE_TYPE_SURFTYPE_CUBE = 0x3,
1867        SURFACE_TYPE_SURFTYPE_BUFFER = 0x4,
1868        SURFACE_TYPE_SURFTYPE_SCRATCH = 0x6,
1869        SURFACE_TYPE_SURFTYPE_NULL = 0x7,
1870    } SURFACE_TYPE;
1871    typedef enum tagSAMPLE_TAP_DISCARD_DISABLE {
1872        SAMPLE_TAP_DISCARD_DISABLE_DISABLE = 0x0,
1873        SAMPLE_TAP_DISCARD_DISABLE_ENABLE = 0x1,
1874    } SAMPLE_TAP_DISCARD_DISABLE;
1875    typedef enum tagNULL_PROBING_ENABLE {
1876        NULL_PROBING_ENABLE_DISABLE = 0x0,
1877        NULL_PROBING_ENABLE_ENABLE = 0x1,
1878    } NULL_PROBING_ENABLE;
1879    typedef enum tagNUMBER_OF_MULTISAMPLES {
1880        NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_1 = 0x0,
1881        NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_2 = 0x1,
1882        NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_4 = 0x2,
1883        NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_8 = 0x3,
1884        NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_16 = 0x4,
1885    } NUMBER_OF_MULTISAMPLES;
1886    typedef enum tagMULTISAMPLED_SURFACE_STORAGE_FORMAT {
1887        MULTISAMPLED_SURFACE_STORAGE_FORMAT_MSS = 0x0,
1888        MULTISAMPLED_SURFACE_STORAGE_FORMAT_DEPTH_STENCIL = 0x1,
1889    } MULTISAMPLED_SURFACE_STORAGE_FORMAT;
1890    typedef enum tagRENDER_TARGET_AND_SAMPLE_UNORM_ROTATION {
1891        RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION_0DEG = 0x0,
1892        RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION_90DEG = 0x1,
1893        RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION_180DEG = 0x2,
1894        RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION_270DEG = 0x3,
1895    } RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION;
1896    typedef enum tagCOHERENCY_TYPE {
1897        COHERENCY_TYPE_GPU_COHERENT = 0x0,
1898        COHERENCY_TYPE_IA_COHERENT = 0x1,
1899    } COHERENCY_TYPE;
1900    typedef enum tagL1_CACHE_POLICY {
1901        L1_CACHE_POLICY_WBP = 0x0,
1902        L1_CACHE_POLICY_UC = 0x1,
1903        L1_CACHE_POLICY_WB = 0x2,
1904        L1_CACHE_POLICY_WT = 0x3,
1905        L1_CACHE_POLICY_WS = 0x4,
1906    } L1_CACHE_POLICY;
1907    typedef enum tagAUXILIARY_SURFACE_MODE {
1908        AUXILIARY_SURFACE_MODE_AUX_NONE = 0x0,
1909        AUXILIARY_SURFACE_MODE_AUX_CCS_D = 0x1,
1910        AUXILIARY_SURFACE_MODE_AUX_APPEND = 0x2,
1911        AUXILIARY_SURFACE_MODE_AUX_MCS_LCE = 0x4,
1912        AUXILIARY_SURFACE_MODE_AUX_CCS_E = 0x5,
1913    } AUXILIARY_SURFACE_MODE;
1914    typedef enum tagHALF_PITCH_FOR_CHROMA {
1915        HALF_PITCH_FOR_CHROMA_DISABLE = 0x0,
1916        HALF_PITCH_FOR_CHROMA_ENABLE = 0x1,
1917    } HALF_PITCH_FOR_CHROMA;
1918    typedef enum tagSHADER_CHANNEL_SELECT {
1919        SHADER_CHANNEL_SELECT_ZERO = 0x0,
1920        SHADER_CHANNEL_SELECT_ONE = 0x1,
1921        SHADER_CHANNEL_SELECT_RED = 0x4,
1922        SHADER_CHANNEL_SELECT_GREEN = 0x5,
1923        SHADER_CHANNEL_SELECT_BLUE = 0x6,
1924        SHADER_CHANNEL_SELECT_ALPHA = 0x7,
1925    } SHADER_CHANNEL_SELECT;
1926    typedef enum tagMEMORY_COMPRESSION_MODE {
1927        MEMORY_COMPRESSION_MODE_HORIZONTAL = 0x0,
1928    } MEMORY_COMPRESSION_MODE;
1929    typedef enum tagCOMPRESSION_FORMAT {
1930        COMPRESSION_FORMAT_RGBA16_FLOAT = 0x1,
1931        COMPRESSION_FORMAT_Y210 = 0x2,
1932        COMPRESSION_FORMAT_YUY2 = 0x3,
1933        COMPRESSION_FORMAT_Y410_1010102 = 0x4,
1934        COMPRESSION_FORMAT_Y216 = 0x5,
1935        COMPRESSION_FORMAT_Y416 = 0x6,
1936        COMPRESSION_FORMAT_P010 = 0x7,
1937        COMPRESSION_FORMAT_P016 = 0x8,
1938        COMPRESSION_FORMAT_AYUV = 0x9,
1939        COMPRESSION_FORMAT_ARGB_8B = 0xa,
1940        COMPRESSION_FORMAT_YCRCB_SWAPY = 0xb,
1941        COMPRESSION_FORMAT_YCRCB_SWAPUV = 0xc,
1942        COMPRESSION_FORMAT_YCRCB_SWAPUVY = 0xd,
1943        COMPRESSION_FORMAT_RGB_10B = 0xe,
1944        COMPRESSION_FORMAT_NV21NV12 = 0xf,
1945    } COMPRESSION_FORMAT;
1946    inline void init() {
1947        memset(&TheStructure, 0, sizeof(TheStructure));
1948        TheStructure.Common.MediaBoundaryPixelMode = MEDIA_BOUNDARY_PIXEL_MODE_NORMAL_MODE;
1949        TheStructure.Common.RenderCacheReadWriteMode = RENDER_CACHE_READ_WRITE_MODE_WRITE_ONLY_CACHE;
1950        TheStructure.Common.TileMode = TILE_MODE_LINEAR;
1951        TheStructure.Common.SurfaceHorizontalAlignment = SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_16;
1952        TheStructure.Common.SurfaceVerticalAlignment = SURFACE_VERTICAL_ALIGNMENT_VALIGN_4;
1953        TheStructure.Common.SurfaceType = SURFACE_TYPE_SURFTYPE_1D;
1954        TheStructure.Common.SampleTapDiscardDisable = SAMPLE_TAP_DISCARD_DISABLE_DISABLE;
1955        TheStructure.Common.NullProbingEnable = NULL_PROBING_ENABLE_DISABLE;
1956        TheStructure.Common.NumberOfMultisamples = NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_1;
1957        TheStructure.Common.MultisampledSurfaceStorageFormat = MULTISAMPLED_SURFACE_STORAGE_FORMAT_MSS;
1958        TheStructure.Common.RenderTargetAndSampleUnormRotation = RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION_0DEG;
1959        TheStructure.Common.CoherencyType = COHERENCY_TYPE_GPU_COHERENT;
1960        TheStructure.Common.L1CachePolicyL1CacheControl = L1_CACHE_POLICY_WBP;
1961        TheStructure.Common.MemoryCompressionMode = MEMORY_COMPRESSION_MODE_HORIZONTAL;
1962        TheStructure._SurfaceFormatIsPlanar.HalfPitchForChroma = HALF_PITCH_FOR_CHROMA_DISABLE;
1963        TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfaceMode = AUXILIARY_SURFACE_MODE_AUX_NONE;
1964        TheStructure.Common.DisableSupportForMultiGpuAtomics = 1;
1965        TheStructure.Common.DisableSupportForMultiGpuPartialWrites = 1;
1966    }
1967    static tagRENDER_SURFACE_STATE sInit() {
1968        RENDER_SURFACE_STATE state;
1969        state.init();
1970        return state;
1971    }
1972    inline uint32_t &getRawData(const uint32_t index) {
1973        UNRECOVERABLE_IF(index >= 16);
1974        return TheStructure.RawData[index];
1975    }
1976    inline void setCubeFaceEnablePositiveZ(const bool value) {
1977        TheStructure.Common.CubeFaceEnablePositiveZ = value;
1978    }
1979    inline bool getCubeFaceEnablePositiveZ() const {
1980        return TheStructure.Common.CubeFaceEnablePositiveZ;
1981    }
1982    inline void setCubeFaceEnableNegativeZ(const bool value) {
1983        TheStructure.Common.CubeFaceEnableNegativeZ = value;
1984    }
1985    inline bool getCubeFaceEnableNegativeZ() const {
1986        return TheStructure.Common.CubeFaceEnableNegativeZ;
1987    }
1988    inline void setCubeFaceEnablePositiveY(const bool value) {
1989        TheStructure.Common.CubeFaceEnablePositiveY = value;
1990    }
1991    inline bool getCubeFaceEnablePositiveY() const {
1992        return TheStructure.Common.CubeFaceEnablePositiveY;
1993    }
1994    inline void setCubeFaceEnableNegativeY(const bool value) {
1995        TheStructure.Common.CubeFaceEnableNegativeY = value;
1996    }
1997    inline bool getCubeFaceEnableNegativeY() const {
1998        return TheStructure.Common.CubeFaceEnableNegativeY;
1999    }
2000    inline void setCubeFaceEnablePositiveX(const bool value) {
2001        TheStructure.Common.CubeFaceEnablePositiveX = value;
2002    }
2003    inline bool getCubeFaceEnablePositiveX() const {
2004        return TheStructure.Common.CubeFaceEnablePositiveX;
2005    }
2006    inline void setCubeFaceEnableNegativeX(const bool value) {
2007        TheStructure.Common.CubeFaceEnableNegativeX = value;
2008    }
2009    inline bool getCubeFaceEnableNegativeX() const {
2010        return TheStructure.Common.CubeFaceEnableNegativeX;
2011    }
2012    inline void setMediaBoundaryPixelMode(const MEDIA_BOUNDARY_PIXEL_MODE value) {
2013        TheStructure.Common.MediaBoundaryPixelMode = value;
2014    }
2015    inline MEDIA_BOUNDARY_PIXEL_MODE getMediaBoundaryPixelMode() const {
2016        return static_cast<MEDIA_BOUNDARY_PIXEL_MODE>(TheStructure.Common.MediaBoundaryPixelMode);
2017    }
2018    inline void setRenderCacheReadWriteMode(const RENDER_CACHE_READ_WRITE_MODE value) {
2019        TheStructure.Common.RenderCacheReadWriteMode = value;
2020    }
2021    inline RENDER_CACHE_READ_WRITE_MODE getRenderCacheReadWriteMode() const {
2022        return static_cast<RENDER_CACHE_READ_WRITE_MODE>(TheStructure.Common.RenderCacheReadWriteMode);
2023    }
2024    inline void setSamplerL2OutOfOrderModeDisable(const bool value) {
2025        TheStructure.Common.SamplerL2OutOfOrderModeDisable = value;
2026    }
2027    inline bool getSamplerL2OutOfOrderModeDisable() const {
2028        return TheStructure.Common.SamplerL2OutOfOrderModeDisable;
2029    }
2030    inline void setVerticalLineStrideOffset(const bool value) {
2031        TheStructure.Common.VerticalLineStrideOffset = value;
2032    }
2033    inline bool getVerticalLineStrideOffset() const {
2034        return TheStructure.Common.VerticalLineStrideOffset;
2035    }
2036    inline void setVerticalLineStride(const bool value) {
2037        TheStructure.Common.VerticalLineStride = value;
2038    }
2039    inline bool getVerticalLineStride() const {
2040        return TheStructure.Common.VerticalLineStride;
2041    }
2042    inline void setTileMode(const TILE_MODE value) {
2043        TheStructure.Common.TileMode = value;
2044    }
2045    inline TILE_MODE getTileMode() const {
2046        return static_cast<TILE_MODE>(TheStructure.Common.TileMode);
2047    }
2048    inline void setSurfaceHorizontalAlignment(const SURFACE_HORIZONTAL_ALIGNMENT value) {
2049        TheStructure.Common.SurfaceHorizontalAlignment = value;
2050    }
2051    inline SURFACE_HORIZONTAL_ALIGNMENT getSurfaceHorizontalAlignment() const {
2052        return static_cast<SURFACE_HORIZONTAL_ALIGNMENT>(TheStructure.Common.SurfaceHorizontalAlignment);
2053    }
2054    inline void setSurfaceVerticalAlignment(const SURFACE_VERTICAL_ALIGNMENT value) {
2055        TheStructure.Common.SurfaceVerticalAlignment = value;
2056    }
2057    inline SURFACE_VERTICAL_ALIGNMENT getSurfaceVerticalAlignment() const {
2058        return static_cast<SURFACE_VERTICAL_ALIGNMENT>(TheStructure.Common.SurfaceVerticalAlignment);
2059    }
2060    inline void setSurfaceFormat(const SURFACE_FORMAT value) {
2061        TheStructure.Common.SurfaceFormat = value;
2062    }
2063    inline SURFACE_FORMAT getSurfaceFormat() const {
2064        return static_cast<SURFACE_FORMAT>(TheStructure.Common.SurfaceFormat);
2065    }
2066    inline void setAstcEnable(const bool value) {
2067        TheStructure.Common.AstcEnable = value;
2068    }
2069    inline bool getAstcEnable() const {
2070        return TheStructure.Common.AstcEnable;
2071    }
2072    inline void setSurfaceArray(const bool value) {
2073        TheStructure.Common.SurfaceArray = value;
2074    }
2075    inline bool getSurfaceArray() const {
2076        return TheStructure.Common.SurfaceArray;
2077    }
2078    inline void setSurfaceType(const SURFACE_TYPE value) {
2079        TheStructure.Common.SurfaceType = value;
2080    }
2081    inline SURFACE_TYPE getSurfaceType() const {
2082        return static_cast<SURFACE_TYPE>(TheStructure.Common.SurfaceType);
2083    }
2084    typedef enum tagSURFACEQPITCH {
2085        SURFACEQPITCH_BIT_SHIFT = 0x2,
2086        SURFACEQPITCH_ALIGN_SIZE = 0x4,
2087    } SURFACEQPITCH;
2088    inline void setSurfaceQpitch(const uint32_t value) {
2089        UNRECOVERABLE_IF(value > 0x1ffff);
2090        TheStructure.Common.SurfaceQpitch = value >> SURFACEQPITCH_BIT_SHIFT;
2091    }
2092    inline uint32_t getSurfaceQpitch() const {
2093        return TheStructure.Common.SurfaceQpitch << SURFACEQPITCH_BIT_SHIFT;
2094    }
2095    inline void setSampleTapDiscardDisable(const SAMPLE_TAP_DISCARD_DISABLE value) {
2096        TheStructure.Common.SampleTapDiscardDisable = value;
2097    }
2098    inline SAMPLE_TAP_DISCARD_DISABLE getSampleTapDiscardDisable() const {
2099        return static_cast<SAMPLE_TAP_DISCARD_DISABLE>(TheStructure.Common.SampleTapDiscardDisable);
2100    }
2101    inline void setDoubleFetchDisable(const bool value) {
2102        TheStructure.Common.DoubleFetchDisable = value;
2103    }
2104    inline bool getDoubleFetchDisable() const {
2105        return TheStructure.Common.DoubleFetchDisable;
2106    }
2107    inline void setCornerTexelMode(const bool value) {
2108        TheStructure.Common.CornerTexelMode = value;
2109    }
2110    inline bool getCornerTexelMode() const {
2111        return TheStructure.Common.CornerTexelMode;
2112    }
2113    inline void setBaseMipLevel(const uint32_t value) {
2114        UNRECOVERABLE_IF(value > 0x1f);
2115        TheStructure.Common.BaseMipLevel = value;
2116    }
2117    inline uint32_t getBaseMipLevel() const {
2118        return TheStructure.Common.BaseMipLevel;
2119    }
2120    inline void setMemoryObjectControlStateReserved(const uint32_t value) {
2121        TheStructure.Common.MemoryObjectControlStateReserved_56 = value;
2122    }
2123    inline uint32_t getMemoryObjectControlStateReserved() const {
2124        return (TheStructure.Common.MemoryObjectControlStateReserved_56);
2125    }
2126    inline void setMemoryObjectControlState(const uint32_t value) {
2127        TheStructure.Common.MemoryObjectControlStateReserved_56 = value;
2128        TheStructure.Common.MemoryObjectControlStateIndexToMocsTables = (value >> 1);
2129    }
2130    inline uint32_t getMemoryObjectControlState() const {
2131        uint32_t mocs = TheStructure.Common.MemoryObjectControlStateReserved_56;
2132        mocs |= (TheStructure.Common.MemoryObjectControlStateIndexToMocsTables << 1);
2133        return (mocs);
2134    }
2135    inline void setWidth(const uint32_t value) {
2136        TheStructure.Common.Width = value - 1;
2137    }
2138    inline uint32_t getWidth() const {
2139        return TheStructure.Common.Width + 1;
2140    }
2141    inline void setHeight(const uint32_t value) {
2142        TheStructure.Common.Height = value - 1;
2143    }
2144    inline uint32_t getHeight() const {
2145        return TheStructure.Common.Height + 1;
2146    }
2147    inline void setDepthStencilResource(const bool value) {
2148        TheStructure.Common.DepthStencilResource = value;
2149    }
2150    inline bool getDepthStencilResource() const {
2151        return TheStructure.Common.DepthStencilResource;
2152    }
2153    inline void setSurfacePitch(const uint32_t value) {
2154        UNRECOVERABLE_IF(value > 0x40000);
2155        TheStructure.Common.SurfacePitch = value - 1;
2156    }
2157    inline uint32_t getSurfacePitch() const {
2158        return TheStructure.Common.SurfacePitch + 1;
2159    }
2160    inline void setNullProbingEnable(const NULL_PROBING_ENABLE value) {
2161        TheStructure.Common.NullProbingEnable = value;
2162    }
2163    inline NULL_PROBING_ENABLE getNullProbingEnable() const {
2164        return static_cast<NULL_PROBING_ENABLE>(TheStructure.Common.NullProbingEnable);
2165    }
2166    inline void setDepth(const uint32_t value) {
2167        TheStructure.Common.Depth = value - 1;
2168    }
2169    inline uint32_t getDepth() const {
2170        return TheStructure.Common.Depth + 1;
2171    }
2172    inline void setMultisamplePositionPaletteIndex(const uint32_t value) {
2173        UNRECOVERABLE_IF(value > 0x7);
2174        TheStructure.Common.MultisamplePositionPaletteIndex = value;
2175    }
2176    inline uint32_t getMultisamplePositionPaletteIndex() const {
2177        return TheStructure.Common.MultisamplePositionPaletteIndex;
2178    }
2179    inline void setNumberOfMultisamples(const NUMBER_OF_MULTISAMPLES value) {
2180        TheStructure.Common.NumberOfMultisamples = value;
2181    }
2182    inline NUMBER_OF_MULTISAMPLES getNumberOfMultisamples() const {
2183        return static_cast<NUMBER_OF_MULTISAMPLES>(TheStructure.Common.NumberOfMultisamples);
2184    }
2185    inline void setMultisampledSurfaceStorageFormat(const MULTISAMPLED_SURFACE_STORAGE_FORMAT value) {
2186        TheStructure.Common.MultisampledSurfaceStorageFormat = value;
2187    }
2188    inline MULTISAMPLED_SURFACE_STORAGE_FORMAT getMultisampledSurfaceStorageFormat() const {
2189        return static_cast<MULTISAMPLED_SURFACE_STORAGE_FORMAT>(TheStructure.Common.MultisampledSurfaceStorageFormat);
2190    }
2191    inline void setRenderTargetViewExtent(const uint32_t value) {
2192        UNRECOVERABLE_IF(value > 0x7ff);
2193        TheStructure.Common.RenderTargetViewExtent = value - 1;
2194    }
2195    inline uint32_t getRenderTargetViewExtent() const {
2196        return TheStructure.Common.RenderTargetViewExtent + 1;
2197    }
2198    inline void setMinimumArrayElement(const uint32_t value) {
2199        UNRECOVERABLE_IF(value > 0x7ff);
2200        TheStructure.Common.MinimumArrayElement = value;
2201    }
2202    inline uint32_t getMinimumArrayElement() const {
2203        return TheStructure.Common.MinimumArrayElement;
2204    }
2205    inline void setRenderTargetAndSampleUnormRotation(const RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION value) {
2206        TheStructure.Common.RenderTargetAndSampleUnormRotation = value;
2207    }
2208    inline RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION getRenderTargetAndSampleUnormRotation() const {
2209        return static_cast<RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION>(TheStructure.Common.RenderTargetAndSampleUnormRotation);
2210    }
2211    inline void setMipCountLod(const uint32_t value) {
2212        UNRECOVERABLE_IF(value > 0xf);
2213        TheStructure.Common.MipCountLod = value;
2214    }
2215    inline uint32_t getMipCountLod() const {
2216        return TheStructure.Common.MipCountLod;
2217    }
2218    inline void setSurfaceMinLod(const uint32_t value) {
2219        UNRECOVERABLE_IF(value > 0xf);
2220        TheStructure.Common.SurfaceMinLod = value;
2221    }
2222    inline uint32_t getSurfaceMinLod() const {
2223        return TheStructure.Common.SurfaceMinLod;
2224    }
2225    inline void setMipTailStartLod(const uint32_t value) {
2226        UNRECOVERABLE_IF(value > 0xf);
2227        TheStructure.Common.MipTailStartLod = value;
2228    }
2229    inline uint32_t getMipTailStartLod() const {
2230        return TheStructure.Common.MipTailStartLod;
2231    }
2232    inline void setCoherencyType(const COHERENCY_TYPE value) {
2233        TheStructure.Common.CoherencyType = value;
2234    }
2235    inline COHERENCY_TYPE getCoherencyType() const {
2236        return static_cast<COHERENCY_TYPE>(TheStructure.Common.CoherencyType);
2237    }
2238    inline void setL1CachePolicyL1CacheControl(const L1_CACHE_POLICY value) {
2239        TheStructure.Common.L1CachePolicyL1CacheControl = value;
2240    }
2241    inline L1_CACHE_POLICY getL1CachePolicyL1CacheControl() const {
2242        return static_cast<L1_CACHE_POLICY>(TheStructure.Common.L1CachePolicyL1CacheControl);
2243    }
2244    inline void setEwaDisableForCube(const bool value) {
2245        TheStructure.Common.EwaDisableForCube = value;
2246    }
2247    inline bool getEwaDisableForCube() const {
2248        return TheStructure.Common.EwaDisableForCube;
2249    }
2250    typedef enum tagYOFFSET {
2251        YOFFSET_BIT_SHIFT = 0x2,
2252        YOFFSET_ALIGN_SIZE = 0x4,
2253    } YOFFSET;
2254    inline void setYOffset(const uint32_t value) {
2255        UNRECOVERABLE_IF(value > 0x1f);
2256        TheStructure.Common.YOffset = value >> YOFFSET_BIT_SHIFT;
2257    }
2258    inline uint32_t getYOffset() const {
2259        return TheStructure.Common.YOffset << YOFFSET_BIT_SHIFT;
2260    }
2261    typedef enum tagXOFFSET {
2262        XOFFSET_BIT_SHIFT = 0x2,
2263        XOFFSET_ALIGN_SIZE = 0x4,
2264    } XOFFSET;
2265    inline void setXOffset(const uint32_t value) {
2266        UNRECOVERABLE_IF(value > 0x1ff);
2267        TheStructure.Common.XOffset = value >> XOFFSET_BIT_SHIFT;
2268    }
2269    inline uint32_t getXOffset() const {
2270        return TheStructure.Common.XOffset << XOFFSET_BIT_SHIFT;
2271    }
2272    inline void setYuvInterpolationEnable(const bool value) {
2273        TheStructure.Common.YuvInterpolationEnable = value;
2274    }
2275    inline bool getYuvInterpolationEnable() const {
2276        return TheStructure.Common.YuvInterpolationEnable;
2277    }
2278    inline void setResourceMinLod(const uint32_t value) {
2279        UNRECOVERABLE_IF(value > 0xfff);
2280        TheStructure.Common.ResourceMinLod = value;
2281    }
2282    inline uint32_t getResourceMinLod() const {
2283        return TheStructure.Common.ResourceMinLod;
2284    }
2285    inline void setDisableSupportForMultiGpuAtomics(const bool value) {
2286        TheStructure.Common.DisableSupportForMultiGpuAtomics = value;
2287    }
2288    inline bool getDisableSupportForMultiGpuAtomics() const {
2289        return TheStructure.Common.DisableSupportForMultiGpuAtomics;
2290    }
2291    inline void setDisableSupportForMultiGpuPartialWrites(const bool value) {
2292        TheStructure.Common.DisableSupportForMultiGpuPartialWrites = value;
2293    }
2294    inline bool getDisableSupportForMultiGpuPartialWrites() const {
2295        return TheStructure.Common.DisableSupportForMultiGpuPartialWrites;
2296    }
2297
2298    inline void setShaderChannelSelectAlpha(const SHADER_CHANNEL_SELECT value) {
2299        TheStructure.Common.ShaderChannelSelectAlpha = value;
2300    }
2301    inline SHADER_CHANNEL_SELECT getShaderChannelSelectAlpha() const {
2302        return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectAlpha);
2303    }
2304    inline void setShaderChannelSelectBlue(const SHADER_CHANNEL_SELECT value) {
2305        TheStructure.Common.ShaderChannelSelectBlue = value;
2306    }
2307    inline SHADER_CHANNEL_SELECT getShaderChannelSelectBlue() const {
2308        return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectBlue);
2309    }
2310    inline void setShaderChannelSelectGreen(const SHADER_CHANNEL_SELECT value) {
2311        TheStructure.Common.ShaderChannelSelectGreen = value;
2312    }
2313    inline SHADER_CHANNEL_SELECT getShaderChannelSelectGreen() const {
2314        return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectGreen);
2315    }
2316    inline void setShaderChannelSelectRed(const SHADER_CHANNEL_SELECT value) {
2317        TheStructure.Common.ShaderChannelSelectRed = value;
2318    }
2319    inline SHADER_CHANNEL_SELECT getShaderChannelSelectRed() const {
2320        return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectRed);
2321    }
2322    inline void setMemoryCompressionEnable(const bool value) {
2323        TheStructure.Common.MemoryCompressionEnable = value;
2324    }
2325    inline bool getMemoryCompressionEnable() const {
2326        return TheStructure.Common.MemoryCompressionEnable;
2327    }
2328    inline void setMemoryCompressionMode(const MEMORY_COMPRESSION_MODE value) {
2329        TheStructure.Common.MemoryCompressionMode = value;
2330    }
2331    inline MEMORY_COMPRESSION_MODE getMemoryCompressionMode() const {
2332        return static_cast<MEMORY_COMPRESSION_MODE>(TheStructure.Common.MemoryCompressionMode);
2333    }
2334    inline void setSurfaceBaseAddress(const uint64_t value) {
2335        TheStructure.Common.SurfaceBaseAddress = value;
2336    }
2337    inline uint64_t getSurfaceBaseAddress() const {
2338        return TheStructure.Common.SurfaceBaseAddress;
2339    }
2340    inline void setQuiltWidth(const uint64_t value) {
2341        UNRECOVERABLE_IF(value > 0x1fL);
2342        TheStructure.Common.QuiltWidth = value;
2343    }
2344    inline uint64_t getQuiltWidth() const {
2345        return TheStructure.Common.QuiltWidth;
2346    }
2347    inline void setQuiltHeight(const uint64_t value) {
2348        UNRECOVERABLE_IF(value > 0x1fL);
2349        TheStructure.Common.QuiltHeight = value;
2350    }
2351    inline uint64_t getQuiltHeight() const {
2352        return TheStructure.Common.QuiltHeight;
2353    }
2354    inline void setClearValueAddressEnable(const bool value) {
2355        TheStructure.Common.ClearValueAddressEnable = value;
2356    }
2357    inline bool getClearValueAddressEnable() const {
2358        return TheStructure.Common.ClearValueAddressEnable;
2359    }
2360    inline void setProceduralTexture(const bool value) {
2361        TheStructure.Common.ProceduralTexture = value;
2362    }
2363    inline bool getProceduralTexture() const {
2364        return TheStructure.Common.ProceduralTexture;
2365    }
2366    inline void setCompressionFormat(uint32_t compressionFormat) {
2367        UNRECOVERABLE_IF(compressionFormat > 0x1F);
2368        TheStructure.Common.CompressionFormat = compressionFormat;
2369    }
2370    inline uint32_t getCompressionFormat() const {
2371        return TheStructure.Common.CompressionFormat;
2372    }
2373    typedef enum tagCLEARADDRESSLOW {
2374        CLEARADDRESSLOW_BIT_SHIFT = 0x6,
2375        CLEARADDRESSLOW_ALIGN_SIZE = 0x40,
2376    } CLEARADDRESSLOW;
2377    inline void setClearColorAddress(const uint32_t value) {
2378        UNRECOVERABLE_IF(value > 0xffffffff);
2379        TheStructure.Common.ClearAddressLow = value >> CLEARADDRESSLOW_BIT_SHIFT;
2380    }
2381    inline uint32_t getClearColorAddress() const {
2382        return TheStructure.Common.ClearAddressLow << CLEARADDRESSLOW_BIT_SHIFT;
2383    }
2384    inline void setClearColorAddressHigh(const uint32_t value) {
2385        UNRECOVERABLE_IF(value > 0xffff);
2386        TheStructure.Common.ClearAddressHigh = value;
2387    }
2388    inline uint32_t getClearColorAddressHigh() const {
2389        return TheStructure.Common.ClearAddressHigh;
2390    }
2391    inline void setYOffsetForUOrUvPlane(const uint32_t value) {
2392        UNRECOVERABLE_IF(value > 0x3fff);
2393        TheStructure._SurfaceFormatIsPlanar.YOffsetForUOrUvPlane = value;
2394    }
2395    inline uint32_t getYOffsetForUOrUvPlane() const {
2396        return TheStructure._SurfaceFormatIsPlanar.YOffsetForUOrUvPlane;
2397    }
2398    inline void setXOffsetForUOrUvPlane(const uint32_t value) {
2399        UNRECOVERABLE_IF(value > 0x3fff);
2400        TheStructure._SurfaceFormatIsPlanar.XOffsetForUOrUvPlane = value;
2401    }
2402    inline uint32_t getXOffsetForUOrUvPlane() const {
2403        return TheStructure._SurfaceFormatIsPlanar.XOffsetForUOrUvPlane;
2404    }
2405    inline void setHalfPitchForChroma(const HALF_PITCH_FOR_CHROMA value) {
2406        TheStructure._SurfaceFormatIsPlanar.HalfPitchForChroma = value;
2407    }
2408    inline HALF_PITCH_FOR_CHROMA getHalfPitchForChroma() const {
2409        return static_cast<HALF_PITCH_FOR_CHROMA>(TheStructure._SurfaceFormatIsPlanar.HalfPitchForChroma);
2410    }
2411    inline void setSeparateUvPlaneEnable(const bool value) {
2412        TheStructure._SurfaceFormatIsPlanar.SeparateUvPlaneEnable = value;
2413    }
2414    inline bool getSeparateUvPlaneEnable() const {
2415        return TheStructure._SurfaceFormatIsPlanar.SeparateUvPlaneEnable;
2416    }
2417    inline void setYOffsetForVPlane(const uint64_t value) {
2418        UNRECOVERABLE_IF(value > 0x3fffL);
2419        TheStructure._SurfaceFormatIsPlanar.YOffsetForVPlane = value;
2420    }
2421    inline uint64_t getYOffsetForVPlane() const {
2422        return TheStructure._SurfaceFormatIsPlanar.YOffsetForVPlane;
2423    }
2424    inline void setXOffsetForVPlane(const uint64_t value) {
2425        UNRECOVERABLE_IF(value > 0x3fffL);
2426        TheStructure._SurfaceFormatIsPlanar.XOffsetForVPlane = value;
2427    }
2428    inline uint64_t getXOffsetForVPlane() const {
2429        return TheStructure._SurfaceFormatIsPlanar.XOffsetForVPlane;
2430    }
2431    inline void setAuxiliarySurfaceMode(const AUXILIARY_SURFACE_MODE value) {
2432        TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfaceMode = value;
2433    }
2434    inline AUXILIARY_SURFACE_MODE getAuxiliarySurfaceMode() const {
2435        return static_cast<AUXILIARY_SURFACE_MODE>(TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfaceMode);
2436    }
2437    inline void setAuxiliarySurfacePitch(const uint32_t value) {
2438        UNRECOVERABLE_IF(value > 0x3ff);
2439        TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfacePitch = value - 1;
2440    }
2441    inline uint32_t getAuxiliarySurfacePitch() const {
2442        return TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfacePitch + 1;
2443    }
2444    typedef enum tagAUXILIARYSURFACEQPITCH {
2445        AUXILIARYSURFACEQPITCH_BIT_SHIFT = 0x2,
2446        AUXILIARYSURFACEQPITCH_ALIGN_SIZE = 0x4,
2447    } AUXILIARYSURFACEQPITCH;
2448    inline void setAuxiliarySurfaceQpitch(const uint32_t value) {
2449        UNRECOVERABLE_IF(value > 0x1ffff);
2450        TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfaceQpitch = value >> AUXILIARYSURFACEQPITCH_BIT_SHIFT;
2451    }
2452    inline uint32_t getAuxiliarySurfaceQpitch() const {
2453        return TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfaceQpitch << AUXILIARYSURFACEQPITCH_BIT_SHIFT;
2454    }
2455    typedef enum tagAUXILIARYSURFACEBASEADDRESS {
2456        AUXILIARYSURFACEBASEADDRESS_BIT_SHIFT = 0xc,
2457        AUXILIARYSURFACEBASEADDRESS_ALIGN_SIZE = 0x1000,
2458    } AUXILIARYSURFACEBASEADDRESS;
2459    inline void setAuxiliarySurfaceBaseAddress(const uint64_t value) {
2460        UNRECOVERABLE_IF(value > 0xffffffffffffffffL);
2461        TheStructure._SurfaceFormatIsnotPlanarAndMemoryCompressionEnableIs0.AuxiliarySurfaceBaseAddress = value >> AUXILIARYSURFACEBASEADDRESS_BIT_SHIFT;
2462    }
2463    inline uint64_t getAuxiliarySurfaceBaseAddress() const {
2464        return TheStructure._SurfaceFormatIsnotPlanarAndMemoryCompressionEnableIs0.AuxiliarySurfaceBaseAddress << AUXILIARYSURFACEBASEADDRESS_BIT_SHIFT;
2465    }
2466} RENDER_SURFACE_STATE;
2467STATIC_ASSERT(64 == sizeof(RENDER_SURFACE_STATE));
2468
2469typedef struct tagSAMPLER_STATE {
2470    union tagTheStructure {
2471        struct tagCommon {
2472            // DWORD 0
2473            uint32_t LodAlgorithm : BITFIELD_RANGE(0, 0);
2474            uint32_t TextureLodBias : BITFIELD_RANGE(1, 13);
2475            uint32_t MinModeFilter : BITFIELD_RANGE(14, 16);
2476            uint32_t MagModeFilter : BITFIELD_RANGE(17, 19);
2477            uint32_t MipModeFilter : BITFIELD_RANGE(20, 21);
2478            uint32_t Reserved_22 : BITFIELD_RANGE(22, 25);
2479            uint32_t Reserved_26 : BITFIELD_RANGE(26, 26);
2480            uint32_t LodPreclampMode : BITFIELD_RANGE(27, 28);
2481            uint32_t Reserved_29 : BITFIELD_RANGE(29, 29);
2482            uint32_t CpsLodCompensationEnable : BITFIELD_RANGE(30, 30);
2483            uint32_t SamplerDisable : BITFIELD_RANGE(31, 31);
2484            // DWORD 1
2485            uint32_t CubeSurfaceControlMode : BITFIELD_RANGE(0, 0);
2486            uint32_t ShadowFunction : BITFIELD_RANGE(1, 3);
2487            uint32_t ChromakeyMode : BITFIELD_RANGE(4, 4);
2488            uint32_t ChromakeyIndex : BITFIELD_RANGE(5, 6);
2489            uint32_t ChromakeyEnable : BITFIELD_RANGE(7, 7);
2490            uint32_t MaxLod : BITFIELD_RANGE(8, 19);
2491            uint32_t MinLod : BITFIELD_RANGE(20, 31);
2492            // DWORD 2
2493            uint32_t LodClampMagnificationMode : BITFIELD_RANGE(0, 0);
2494            uint32_t SrgbDecode : BITFIELD_RANGE(1, 1);
2495            uint32_t ReturnFilterWeightForNullTexels : BITFIELD_RANGE(2, 2);
2496            uint32_t ReturnFilterWeightForBorderTexels : BITFIELD_RANGE(3, 3);
2497            uint32_t Reserved_68 : BITFIELD_RANGE(4, 4);
2498            uint32_t ForceGather4Behavior : BITFIELD_RANGE(5, 5);
2499            uint32_t IndirectStatePointer : BITFIELD_RANGE(6, 23);
2500            uint32_t ExtendedIndirectStatePointer : BITFIELD_RANGE(24, 31);
2501            // DWORD 3
2502            uint32_t TczAddressControlMode : BITFIELD_RANGE(0, 2);
2503            uint32_t TcyAddressControlMode : BITFIELD_RANGE(3, 5);
2504            uint32_t TcxAddressControlMode : BITFIELD_RANGE(6, 8);
2505            uint32_t ReductionTypeEnable : BITFIELD_RANGE(9, 9);
2506            uint32_t NonNormalizedCoordinateEnable : BITFIELD_RANGE(10, 10);
2507            uint32_t MipLinearFilterQuality : BITFIELD_RANGE(11, 12);
2508            uint32_t RAddressMinFilterRoundingEnable : BITFIELD_RANGE(13, 13);
2509            uint32_t RAddressMagFilterRoundingEnable : BITFIELD_RANGE(14, 14);
2510            uint32_t VAddressMinFilterRoundingEnable : BITFIELD_RANGE(15, 15);
2511            uint32_t VAddressMagFilterRoundingEnable : BITFIELD_RANGE(16, 16);
2512            uint32_t UAddressMinFilterRoundingEnable : BITFIELD_RANGE(17, 17);
2513            uint32_t UAddressMagFilterRoundingEnable : BITFIELD_RANGE(18, 18);
2514            uint32_t MaximumAnisotropy : BITFIELD_RANGE(19, 21);
2515            uint32_t ReductionType : BITFIELD_RANGE(22, 23);
2516            uint32_t AllowLowQualityLodCalculation : BITFIELD_RANGE(24, 24);
2517            uint32_t Reserved_121 : BITFIELD_RANGE(25, 25);
2518            uint32_t LowQualityFilter : BITFIELD_RANGE(26, 26);
2519            uint32_t Reserved_123 : BITFIELD_RANGE(27, 31);
2520        } Common;
2521        uint32_t RawData[4];
2522    } TheStructure;
2523    typedef enum tagLOD_ALGORITHM {
2524        LOD_ALGORITHM_LEGACY = 0x0,
2525        LOD_ALGORITHM_EWA_APPROXIMATION = 0x1,
2526    } LOD_ALGORITHM;
2527    typedef enum tagMIN_MODE_FILTER {
2528        MIN_MODE_FILTER_NEAREST = 0x0,
2529        MIN_MODE_FILTER_LINEAR = 0x1,
2530        MIN_MODE_FILTER_ANISOTROPIC = 0x2,
2531    } MIN_MODE_FILTER;
2532    typedef enum tagMAG_MODE_FILTER {
2533        MAG_MODE_FILTER_NEAREST = 0x0,
2534        MAG_MODE_FILTER_LINEAR = 0x1,
2535        MAG_MODE_FILTER_ANISOTROPIC = 0x2,
2536    } MAG_MODE_FILTER;
2537    typedef enum tagMIP_MODE_FILTER {
2538        MIP_MODE_FILTER_NONE = 0x0,
2539        MIP_MODE_FILTER_NEAREST = 0x1,
2540        MIP_MODE_FILTER_LINEAR = 0x3,
2541    } MIP_MODE_FILTER;
2542    typedef enum tagLOD_PRECLAMP_MODE {
2543        LOD_PRECLAMP_MODE_NONE = 0x0,
2544        LOD_PRECLAMP_MODE_OGL = 0x2,
2545    } LOD_PRECLAMP_MODE;
2546    typedef enum tagCUBE_SURFACE_CONTROL_MODE {
2547        CUBE_SURFACE_CONTROL_MODE_PROGRAMMED = 0x0,
2548        CUBE_SURFACE_CONTROL_MODE_OVERRIDE = 0x1,
2549    } CUBE_SURFACE_CONTROL_MODE;
2550    typedef enum tagSHADOW_FUNCTION {
2551        SHADOW_FUNCTION_PREFILTEROP_ALWAYS = 0x0,
2552        SHADOW_FUNCTION_PREFILTEROP_NEVER = 0x1,
2553        SHADOW_FUNCTION_PREFILTEROP_LESS = 0x2,
2554        SHADOW_FUNCTION_PREFILTEROP_EQUAL = 0x3,
2555        SHADOW_FUNCTION_PREFILTEROP_LEQUAL = 0x4,
2556        SHADOW_FUNCTION_PREFILTEROP_GREATER = 0x5,
2557        SHADOW_FUNCTION_PREFILTEROP_NOTEQUAL = 0x6,
2558        SHADOW_FUNCTION_PREFILTEROP_GEQUAL = 0x7,
2559    } SHADOW_FUNCTION;
2560    typedef enum tagCHROMAKEY_MODE {
2561        CHROMAKEY_MODE_KEYFILTER_KILL_ON_ANY_MATCH = 0x0,
2562        CHROMAKEY_MODE_KEYFILTER_REPLACE_BLACK = 0x1,
2563    } CHROMAKEY_MODE;
2564    typedef enum tagLOD_CLAMP_MAGNIFICATION_MODE {
2565        LOD_CLAMP_MAGNIFICATION_MODE_MIPNONE = 0x0,
2566        LOD_CLAMP_MAGNIFICATION_MODE_MIPFILTER = 0x1,
2567    } LOD_CLAMP_MAGNIFICATION_MODE;
2568    typedef enum tagSRGB_DECODE {
2569        SRGB_DECODE_DECODE_EXT = 0x0,
2570        SRGB_DECODE_SKIP_DECODE_EXT = 0x1,
2571    } SRGB_DECODE;
2572    typedef enum tagRETURN_FILTER_WEIGHT_FOR_NULL_TEXELS {
2573        RETURN_FILTER_WEIGHT_FOR_NULL_TEXELS_DISABLE = 0x0,
2574        RETURN_FILTER_WEIGHT_FOR_NULL_TEXELS_ENABLE = 0x1,
2575    } RETURN_FILTER_WEIGHT_FOR_NULL_TEXELS;
2576    typedef enum tagRETURN_FILTER_WEIGHT_FOR_BORDER_TEXELS {
2577        RETURN_FILTER_WEIGHT_FOR_BORDER_TEXELS_DISABLE = 0x0,
2578        RETURN_FILTER_WEIGHT_FOR_BORDER_TEXELS_ENABLE = 0x1,
2579    } RETURN_FILTER_WEIGHT_FOR_BORDER_TEXELS;
2580    typedef enum tagTEXTURE_COORDINATE_MODE {
2581        TEXTURE_COORDINATE_MODE_WRAP = 0x0,
2582        TEXTURE_COORDINATE_MODE_MIRROR = 0x1,
2583        TEXTURE_COORDINATE_MODE_CLAMP = 0x2,
2584        TEXTURE_COORDINATE_MODE_CUBE = 0x3,
2585        TEXTURE_COORDINATE_MODE_CLAMP_BORDER = 0x4,
2586        TEXTURE_COORDINATE_MODE_MIRROR_ONCE = 0x5,
2587        TEXTURE_COORDINATE_MODE_HALF_BORDER = 0x6,
2588        TEXTURE_COORDINATE_MODE_MIRROR_101 = 0x7,
2589    } TEXTURE_COORDINATE_MODE;
2590    typedef enum tagMIP_LINEAR_FILTER_QUALITY {
2591        MIP_LINEAR_FILTER_QUALITY_FULL_QUALITY = 0x0,
2592        MIP_LINEAR_FILTER_QUALITY_HIGH_QUALITY = 0x1,
2593        MIP_LINEAR_FILTER_QUALITY_MEDIUM_QUALITY = 0x2,
2594        MIP_LINEAR_FILTER_QUALITY_LOW_QUALITY = 0x3,
2595    } MIP_LINEAR_FILTER_QUALITY;
2596    typedef enum tagMAXIMUM_ANISOTROPY {
2597        MAXIMUM_ANISOTROPY_RATIO_21 = 0x0,
2598        MAXIMUM_ANISOTROPY_RATIO_41 = 0x1,
2599        MAXIMUM_ANISOTROPY_RATIO_61 = 0x2,
2600        MAXIMUM_ANISOTROPY_RATIO_81 = 0x3,
2601        MAXIMUM_ANISOTROPY_RATIO_101 = 0x4,
2602        MAXIMUM_ANISOTROPY_RATIO_121 = 0x5,
2603        MAXIMUM_ANISOTROPY_RATIO_141 = 0x6,
2604        MAXIMUM_ANISOTROPY_RATIO_161 = 0x7,
2605    } MAXIMUM_ANISOTROPY;
2606    typedef enum tagREDUCTION_TYPE {
2607        REDUCTION_TYPE_STD_FILTER = 0x0,
2608        REDUCTION_TYPE_COMPARISON = 0x1,
2609        REDUCTION_TYPE_MINIMUM = 0x2,
2610        REDUCTION_TYPE_MAXIMUM = 0x3,
2611    } REDUCTION_TYPE;
2612    typedef enum tagLOW_QUALITY_FILTER {
2613        LOW_QUALITY_FILTER_DISABLE = 0x0,
2614        LOW_QUALITY_FILTER_ENABLE = 0x1,
2615    } LOW_QUALITY_FILTER;
2616    inline void init() {
2617        memset(&TheStructure, 0, sizeof(TheStructure));
2618        TheStructure.Common.LodAlgorithm = LOD_ALGORITHM_LEGACY;
2619        TheStructure.Common.MinModeFilter = MIN_MODE_FILTER_NEAREST;
2620        TheStructure.Common.MagModeFilter = MAG_MODE_FILTER_NEAREST;
2621        TheStructure.Common.MipModeFilter = MIP_MODE_FILTER_NONE;
2622        TheStructure.Common.LodPreclampMode = LOD_PRECLAMP_MODE_NONE;
2623        TheStructure.Common.CubeSurfaceControlMode = CUBE_SURFACE_CONTROL_MODE_PROGRAMMED;
2624        TheStructure.Common.ShadowFunction = SHADOW_FUNCTION_PREFILTEROP_ALWAYS;
2625        TheStructure.Common.ChromakeyMode = CHROMAKEY_MODE_KEYFILTER_KILL_ON_ANY_MATCH;
2626        TheStructure.Common.LodClampMagnificationMode = LOD_CLAMP_MAGNIFICATION_MODE_MIPNONE;
2627        TheStructure.Common.SrgbDecode = SRGB_DECODE_DECODE_EXT;
2628        TheStructure.Common.ReturnFilterWeightForNullTexels = RETURN_FILTER_WEIGHT_FOR_NULL_TEXELS_DISABLE;
2629        TheStructure.Common.ReturnFilterWeightForBorderTexels = RETURN_FILTER_WEIGHT_FOR_BORDER_TEXELS_DISABLE;
2630        TheStructure.Common.TczAddressControlMode = TEXTURE_COORDINATE_MODE_WRAP;
2631        TheStructure.Common.TcyAddressControlMode = TEXTURE_COORDINATE_MODE_WRAP;
2632        TheStructure.Common.TcxAddressControlMode = TEXTURE_COORDINATE_MODE_WRAP;
2633        TheStructure.Common.MipLinearFilterQuality = MIP_LINEAR_FILTER_QUALITY_FULL_QUALITY;
2634        TheStructure.Common.MaximumAnisotropy = MAXIMUM_ANISOTROPY_RATIO_21;
2635        TheStructure.Common.ReductionType = REDUCTION_TYPE_STD_FILTER;
2636        TheStructure.Common.LowQualityFilter = LOW_QUALITY_FILTER_DISABLE;
2637    }
2638    static tagSAMPLER_STATE sInit() {
2639        SAMPLER_STATE state;
2640        state.init();
2641        return state;
2642    }
2643    inline uint32_t &getRawData(const uint32_t index) {
2644        UNRECOVERABLE_IF(index >= 4);
2645        return TheStructure.RawData[index];
2646    }
2647    inline void setLodAlgorithm(const LOD_ALGORITHM value) {
2648        TheStructure.Common.LodAlgorithm = value;
2649    }
2650    inline LOD_ALGORITHM getLodAlgorithm() const {
2651        return static_cast<LOD_ALGORITHM>(TheStructure.Common.LodAlgorithm);
2652    }
2653    inline void setTextureLodBias(const uint32_t value) {
2654        UNRECOVERABLE_IF(value > 0x3ffe);
2655        TheStructure.Common.TextureLodBias = value;
2656    }
2657    inline uint32_t getTextureLodBias() const {
2658        return TheStructure.Common.TextureLodBias;
2659    }
2660    inline void setMinModeFilter(const MIN_MODE_FILTER value) {
2661        TheStructure.Common.MinModeFilter = value;
2662    }
2663    inline MIN_MODE_FILTER getMinModeFilter() const {
2664        return static_cast<MIN_MODE_FILTER>(TheStructure.Common.MinModeFilter);
2665    }
2666    inline void setMagModeFilter(const MAG_MODE_FILTER value) {
2667        TheStructure.Common.MagModeFilter = value;
2668    }
2669    inline MAG_MODE_FILTER getMagModeFilter() const {
2670        return static_cast<MAG_MODE_FILTER>(TheStructure.Common.MagModeFilter);
2671    }
2672    inline void setMipModeFilter(const MIP_MODE_FILTER value) {
2673        TheStructure.Common.MipModeFilter = value;
2674    }
2675    inline MIP_MODE_FILTER getMipModeFilter() const {
2676        return static_cast<MIP_MODE_FILTER>(TheStructure.Common.MipModeFilter);
2677    }
2678    inline void setLodPreclampMode(const LOD_PRECLAMP_MODE value) {
2679        TheStructure.Common.LodPreclampMode = value;
2680    }
2681    inline LOD_PRECLAMP_MODE getLodPreclampMode() const {
2682        return static_cast<LOD_PRECLAMP_MODE>(TheStructure.Common.LodPreclampMode);
2683    }
2684    inline void setCpsLodCompensationEnable(const bool value) {
2685        TheStructure.Common.CpsLodCompensationEnable = value;
2686    }
2687    inline bool getCpsLodCompensationEnable() const {
2688        return TheStructure.Common.CpsLodCompensationEnable;
2689    }
2690    inline void setSamplerDisable(const bool value) {
2691        TheStructure.Common.SamplerDisable = value;
2692    }
2693    inline bool getSamplerDisable() const {
2694        return TheStructure.Common.SamplerDisable;
2695    }
2696    inline void setCubeSurfaceControlMode(const CUBE_SURFACE_CONTROL_MODE value) {
2697        TheStructure.Common.CubeSurfaceControlMode = value;
2698    }
2699    inline CUBE_SURFACE_CONTROL_MODE getCubeSurfaceControlMode() const {
2700        return static_cast<CUBE_SURFACE_CONTROL_MODE>(TheStructure.Common.CubeSurfaceControlMode);
2701    }
2702    inline void setShadowFunction(const SHADOW_FUNCTION value) {
2703        TheStructure.Common.ShadowFunction = value;
2704    }
2705    inline SHADOW_FUNCTION getShadowFunction() const {
2706        return static_cast<SHADOW_FUNCTION>(TheStructure.Common.ShadowFunction);
2707    }
2708    inline void setChromakeyMode(const CHROMAKEY_MODE value) {
2709        TheStructure.Common.ChromakeyMode = value;
2710    }
2711    inline CHROMAKEY_MODE getChromakeyMode() const {
2712        return static_cast<CHROMAKEY_MODE>(TheStructure.Common.ChromakeyMode);
2713    }
2714    inline void setChromakeyIndex(const uint32_t value) {
2715        UNRECOVERABLE_IF(value > 0x60);
2716        TheStructure.Common.ChromakeyIndex = value;
2717    }
2718    inline uint32_t getChromakeyIndex() const {
2719        return TheStructure.Common.ChromakeyIndex;
2720    }
2721    inline void setChromakeyEnable(const bool value) {
2722        TheStructure.Common.ChromakeyEnable = value;
2723    }
2724    inline bool getChromakeyEnable() const {
2725        return TheStructure.Common.ChromakeyEnable;
2726    }
2727    inline void setMaxLod(const uint32_t value) {
2728        UNRECOVERABLE_IF(value > 0xfff00);
2729        TheStructure.Common.MaxLod = value;
2730    }
2731    inline uint32_t getMaxLod() const {
2732        return TheStructure.Common.MaxLod;
2733    }
2734    inline void setMinLod(const uint32_t value) {
2735        UNRECOVERABLE_IF(value > 0xfff00000);
2736        TheStructure.Common.MinLod = value;
2737    }
2738    inline uint32_t getMinLod() const {
2739        return TheStructure.Common.MinLod;
2740    }
2741    inline void setLodClampMagnificationMode(const LOD_CLAMP_MAGNIFICATION_MODE value) {
2742        TheStructure.Common.LodClampMagnificationMode = value;
2743    }
2744    inline LOD_CLAMP_MAGNIFICATION_MODE getLodClampMagnificationMode() const {
2745        return static_cast<LOD_CLAMP_MAGNIFICATION_MODE>(TheStructure.Common.LodClampMagnificationMode);
2746    }
2747    inline void setSrgbDecode(const SRGB_DECODE value) {
2748        TheStructure.Common.SrgbDecode = value;
2749    }
2750    inline SRGB_DECODE getSrgbDecode() const {
2751        return static_cast<SRGB_DECODE>(TheStructure.Common.SrgbDecode);
2752    }
2753    inline void setReturnFilterWeightForNullTexels(const RETURN_FILTER_WEIGHT_FOR_NULL_TEXELS value) {
2754        TheStructure.Common.ReturnFilterWeightForNullTexels = value;
2755    }
2756    inline RETURN_FILTER_WEIGHT_FOR_NULL_TEXELS getReturnFilterWeightForNullTexels() const {
2757        return static_cast<RETURN_FILTER_WEIGHT_FOR_NULL_TEXELS>(TheStructure.Common.ReturnFilterWeightForNullTexels);
2758    }
2759    inline void setReturnFilterWeightForBorderTexels(const RETURN_FILTER_WEIGHT_FOR_BORDER_TEXELS value) {
2760        TheStructure.Common.ReturnFilterWeightForBorderTexels = value;
2761    }
2762    inline RETURN_FILTER_WEIGHT_FOR_BORDER_TEXELS getReturnFilterWeightForBorderTexels() const {
2763        return static_cast<RETURN_FILTER_WEIGHT_FOR_BORDER_TEXELS>(TheStructure.Common.ReturnFilterWeightForBorderTexels);
2764    }
2765    inline void setForceGather4Behavior(const bool value) {
2766        TheStructure.Common.ForceGather4Behavior = value;
2767    }
2768    inline bool getForceGather4Behavior() const {
2769        return TheStructure.Common.ForceGather4Behavior;
2770    }
2771    typedef enum tagINDIRECTSTATEPOINTER {
2772        INDIRECTSTATEPOINTER_BIT_SHIFT = 0x6,
2773        INDIRECTSTATEPOINTER_ALIGN_SIZE = 0x40,
2774    } INDIRECTSTATEPOINTER;
2775    inline void setIndirectStatePointer(const uint64_t value) {
2776        UNRECOVERABLE_IF(value > 0xffffc0L);
2777        TheStructure.Common.IndirectStatePointer = static_cast<uint32_t>(value) >> INDIRECTSTATEPOINTER_BIT_SHIFT;
2778    }
2779    inline uint64_t getIndirectStatePointer() const {
2780        return TheStructure.Common.IndirectStatePointer << INDIRECTSTATEPOINTER_BIT_SHIFT;
2781    }
2782    inline void setTczAddressControlMode(const TEXTURE_COORDINATE_MODE value) {
2783        TheStructure.Common.TczAddressControlMode = value;
2784    }
2785    inline TEXTURE_COORDINATE_MODE getTczAddressControlMode() const {
2786        return static_cast<TEXTURE_COORDINATE_MODE>(TheStructure.Common.TczAddressControlMode);
2787    }
2788    inline void setTcyAddressControlMode(const TEXTURE_COORDINATE_MODE value) {
2789        TheStructure.Common.TcyAddressControlMode = value;
2790    }
2791    inline TEXTURE_COORDINATE_MODE getTcyAddressControlMode() const {
2792        return static_cast<TEXTURE_COORDINATE_MODE>(TheStructure.Common.TcyAddressControlMode);
2793    }
2794    inline void setTcxAddressControlMode(const TEXTURE_COORDINATE_MODE value) {
2795        TheStructure.Common.TcxAddressControlMode = value;
2796    }
2797    inline TEXTURE_COORDINATE_MODE getTcxAddressControlMode() const {
2798        return static_cast<TEXTURE_COORDINATE_MODE>(TheStructure.Common.TcxAddressControlMode);
2799    }
2800    inline void setReductionTypeEnable(const bool value) {
2801        TheStructure.Common.ReductionTypeEnable = value;
2802    }
2803    inline bool getReductionTypeEnable() const {
2804        return TheStructure.Common.ReductionTypeEnable;
2805    }
2806    inline void setNonNormalizedCoordinateEnable(const bool value) {
2807        TheStructure.Common.NonNormalizedCoordinateEnable = value;
2808    }
2809    inline bool getNonNormalizedCoordinateEnable() const {
2810        return TheStructure.Common.NonNormalizedCoordinateEnable;
2811    }
2812    inline void setMipLinearFilterQuality(const MIP_LINEAR_FILTER_QUALITY value) {
2813        TheStructure.Common.MipLinearFilterQuality = value;
2814    }
2815    inline MIP_LINEAR_FILTER_QUALITY getMipLinearFilterQuality() const {
2816        return static_cast<MIP_LINEAR_FILTER_QUALITY>(TheStructure.Common.MipLinearFilterQuality);
2817    }
2818    inline void setRAddressMinFilterRoundingEnable(const bool value) {
2819        TheStructure.Common.RAddressMinFilterRoundingEnable = value;
2820    }
2821    inline bool getRAddressMinFilterRoundingEnable() const {
2822        return TheStructure.Common.RAddressMinFilterRoundingEnable;
2823    }
2824    inline void setRAddressMagFilterRoundingEnable(const bool value) {
2825        TheStructure.Common.RAddressMagFilterRoundingEnable = value;
2826    }
2827    inline bool getRAddressMagFilterRoundingEnable() const {
2828        return TheStructure.Common.RAddressMagFilterRoundingEnable;
2829    }
2830    inline void setVAddressMinFilterRoundingEnable(const bool value) {
2831        TheStructure.Common.VAddressMinFilterRoundingEnable = value;
2832    }
2833    inline bool getVAddressMinFilterRoundingEnable() const {
2834        return TheStructure.Common.VAddressMinFilterRoundingEnable;
2835    }
2836    inline void setVAddressMagFilterRoundingEnable(const bool value) {
2837        TheStructure.Common.VAddressMagFilterRoundingEnable = value;
2838    }
2839    inline bool getVAddressMagFilterRoundingEnable() const {
2840        return TheStructure.Common.VAddressMagFilterRoundingEnable;
2841    }
2842    inline void setUAddressMinFilterRoundingEnable(const bool value) {
2843        TheStructure.Common.UAddressMinFilterRoundingEnable = value;
2844    }
2845    inline bool getUAddressMinFilterRoundingEnable() const {
2846        return TheStructure.Common.UAddressMinFilterRoundingEnable;
2847    }
2848    inline void setUAddressMagFilterRoundingEnable(const bool value) {
2849        TheStructure.Common.UAddressMagFilterRoundingEnable = value;
2850    }
2851    inline bool getUAddressMagFilterRoundingEnable() const {
2852        return TheStructure.Common.UAddressMagFilterRoundingEnable;
2853    }
2854    inline void setMaximumAnisotropy(const MAXIMUM_ANISOTROPY value) {
2855        TheStructure.Common.MaximumAnisotropy = value;
2856    }
2857    inline MAXIMUM_ANISOTROPY getMaximumAnisotropy() const {
2858        return static_cast<MAXIMUM_ANISOTROPY>(TheStructure.Common.MaximumAnisotropy);
2859    }
2860    inline void setReductionType(const REDUCTION_TYPE value) {
2861        TheStructure.Common.ReductionType = value;
2862    }
2863    inline REDUCTION_TYPE getReductionType() const {
2864        return static_cast<REDUCTION_TYPE>(TheStructure.Common.ReductionType);
2865    }
2866    inline void setLowQualityFilter(const LOW_QUALITY_FILTER value) {
2867        TheStructure.Common.LowQualityFilter = value;
2868    }
2869    inline LOW_QUALITY_FILTER getLowQualityFilter() const {
2870        return static_cast<LOW_QUALITY_FILTER>(TheStructure.Common.LowQualityFilter);
2871    }
2872    inline void setAllowLowQualityLodCalculation(const bool value) {
2873        TheStructure.Common.AllowLowQualityLodCalculation = value;
2874    }
2875    inline bool getAllowLowQualityLodCalculation() const {
2876        return TheStructure.Common.AllowLowQualityLodCalculation;
2877    }
2878} SAMPLER_STATE;
2879STATIC_ASSERT(16 == sizeof(SAMPLER_STATE));
2880
2881typedef struct tagSTATE_BASE_ADDRESS {
2882    union tagTheStructure {
2883        struct tagCommon {
2884            // DWORD 0
2885            uint32_t DwordLength : BITFIELD_RANGE(0, 7);
2886            uint32_t Reserved_8 : BITFIELD_RANGE(8, 15);
2887            uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23);
2888            uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26);
2889            uint32_t CommandSubtype : BITFIELD_RANGE(27, 28);
2890            uint32_t CommandType : BITFIELD_RANGE(29, 31);
2891            // DWORD 1
2892            uint64_t GeneralStateBaseAddressModifyEnable : BITFIELD_RANGE(0, 0);
2893            uint64_t Reserved_33 : BITFIELD_RANGE(1, 4);
2894            uint64_t GeneralStateMemoryObjectControlStateIndexToMocsTables : BITFIELD_RANGE(5, 10);
2895            uint64_t Reserved_43 : BITFIELD_RANGE(11, 11);
2896            uint64_t GeneralStateBaseAddress : BITFIELD_RANGE(12, 56);
2897            uint64_t GeneralStateBaseAddressReserved_89 : BITFIELD_RANGE(57, 63);
2898            // DWORD 3
2899            uint32_t CoherencySettingModifyEnable : BITFIELD_RANGE(0, 0);
2900            uint32_t Reserved_97 : BITFIELD_RANGE(1, 12);
2901            uint32_t EnableMemoryCompressionForAllStatelessAccesses : BITFIELD_RANGE(13, 13);
2902            uint32_t DisableSupportForMultiGpuAtomicsForStatelessAccesses : BITFIELD_RANGE(14, 14);
2903            uint32_t DisableSupportForMultiGpuPartialWritesForStatelessMessages : BITFIELD_RANGE(15, 15);
2904            uint32_t StatelessDataPortAccessMemoryObjectControlStateReserved_112 : BITFIELD_RANGE(16, 16);
2905            uint32_t StatelessDataPortAccessMemoryObjectControlStateIndexToMocsTables : BITFIELD_RANGE(17, 22);
2906            uint32_t L1CachePolicyL1CacheControl : BITFIELD_RANGE(23, 25);
2907            uint32_t Reserved_122 : BITFIELD_RANGE(26, 31);
2908            // DWORD 4
2909            uint64_t SurfaceStateBaseAddressModifyEnable : BITFIELD_RANGE(0, 0);
2910            uint64_t Reserved_129 : BITFIELD_RANGE(1, 4);
2911            uint64_t SurfaceStateMemoryObjectControlStateIndexToMocsTables : BITFIELD_RANGE(5, 10);
2912            uint64_t Reserved_139 : BITFIELD_RANGE(11, 11);
2913            uint64_t SurfaceStateBaseAddress : BITFIELD_RANGE(12, 63);
2914            // DWORD 6
2915            uint64_t DynamicStateBaseAddressModifyEnable : BITFIELD_RANGE(0, 0);
2916            uint64_t Reserved_193 : BITFIELD_RANGE(1, 4);
2917            uint64_t DynamicStateMemoryObjectControlStateIndexToMocsTables : BITFIELD_RANGE(5, 10);
2918            uint64_t Reserved_203 : BITFIELD_RANGE(11, 11);
2919            uint64_t DynamicStateBaseAddress : BITFIELD_RANGE(12, 63);
2920            // DWORD 8
2921            uint64_t Reserved8 : BITFIELD_RANGE(0, 63);
2922            // DWORD 10
2923            uint64_t InstructionBaseAddressModifyEnable : BITFIELD_RANGE(0, 0);
2924            uint64_t Reserved_321 : BITFIELD_RANGE(1, 3);
2925            uint64_t InstructionMemoryObjectControlStateReserved_324 : BITFIELD_RANGE(4, 4); // patched
2926            uint64_t InstructionMemoryObjectControlStateIndexToMocsTables : BITFIELD_RANGE(5, 10);
2927            uint64_t Reserved_331 : BITFIELD_RANGE(11, 11);
2928            uint64_t InstructionBaseAddress : BITFIELD_RANGE(12, 63);
2929            // DWORD 12
2930            uint32_t GeneralStateBufferSizeModifyEnable : BITFIELD_RANGE(0, 0);
2931            uint32_t Reserved_385 : BITFIELD_RANGE(1, 11);
2932            uint32_t GeneralStateBufferSize : BITFIELD_RANGE(12, 31);
2933            // DWORD 13
2934            uint32_t DynamicStateBufferSizeModifyEnable : BITFIELD_RANGE(0, 0);
2935            uint32_t Reserved_417 : BITFIELD_RANGE(1, 11);
2936            uint32_t DynamicStateBufferSize : BITFIELD_RANGE(12, 31);
2937            // DWORD 14
2938            uint32_t IndirectObjectBufferSizeModifyEnable : BITFIELD_RANGE(0, 0);
2939            uint32_t Reserved_449 : BITFIELD_RANGE(1, 11);
2940            uint32_t IndirectObjectBufferSize : BITFIELD_RANGE(12, 31);
2941            // DWORD 15
2942            uint32_t InstructionBufferSizeModifyEnable : BITFIELD_RANGE(0, 0);
2943            uint32_t Reserved_481 : BITFIELD_RANGE(1, 11);
2944            uint32_t InstructionBufferSize : BITFIELD_RANGE(12, 31);
2945            // DWORD 16
2946            uint64_t BindlessSurfaceStateBaseAddressModifyEnable : BITFIELD_RANGE(0, 0);
2947            uint64_t Reserved_513 : BITFIELD_RANGE(1, 4);
2948            uint64_t BindlessSurfaceStateMemoryObjectControlStateIndexToMocsTables : BITFIELD_RANGE(5, 10);
2949            uint64_t Reserved_523 : BITFIELD_RANGE(11, 11);
2950            uint64_t BindlessSurfaceStateBaseAddress : BITFIELD_RANGE(12, 63);
2951            // DWORD 18
2952            uint32_t BindlessSurfaceStateSize;
2953            // DWORD 19
2954            uint64_t BindlessSamplerStateBaseAddressModifyEnable : BITFIELD_RANGE(0, 0);
2955            uint64_t Reserved_609 : BITFIELD_RANGE(1, 3);
2956            uint64_t BindlessSamplerStateMemoryObjectControlStateReserved_612 : BITFIELD_RANGE(4, 4);
2957            uint64_t BindlessSamplerStateMemoryObjectControlStateIndexToMocsTables : BITFIELD_RANGE(5, 10);
2958            uint64_t Reserved_619 : BITFIELD_RANGE(11, 11);
2959            uint64_t BindlessSamplerStateBaseAddress : BITFIELD_RANGE(12, 63);
2960            // DWORD 21
2961            uint32_t Reserved_672 : BITFIELD_RANGE(0, 11);
2962            uint32_t BindlessSamplerStateBufferSize : BITFIELD_RANGE(12, 31);
2963        } Common;
2964        uint32_t RawData[22];
2965    } TheStructure;
2966    typedef enum tagDWORD_LENGTH {
2967        DWORD_LENGTH_DWORD_COUNT_N = 0x14,
2968    } DWORD_LENGTH;
2969    typedef enum tag_3D_COMMAND_SUB_OPCODE {
2970        _3D_COMMAND_SUB_OPCODE_STATE_BASE_ADDRESS = 0x1,
2971    } _3D_COMMAND_SUB_OPCODE;
2972    typedef enum tag_3D_COMMAND_OPCODE {
2973        _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED = 0x1,
2974    } _3D_COMMAND_OPCODE;
2975    typedef enum tagCOMMAND_SUBTYPE {
2976        COMMAND_SUBTYPE_GFXPIPE_COMMON = 0x0,
2977    } COMMAND_SUBTYPE;
2978    typedef enum tagCOMMAND_TYPE {
2979        COMMAND_TYPE_GFXPIPE = 0x3,
2980    } COMMAND_TYPE;
2981    typedef enum tagCOHERENCY_SETTING_MODIFY_ENABLE {
2982        COHERENCY_SETTING_MODIFY_ENABLE_DISABLE_WRITE_TO_THIS_DW = 0x0,
2983        COHERENCY_SETTING_MODIFY_ENABLE_ENABLE_WRITE_TO_THIS_DW = 0x1,
2984    } COHERENCY_SETTING_MODIFY_ENABLE;
2985    typedef enum tagENABLE_MEMORY_COMPRESSION_FOR_ALL_STATELESS_ACCESSES {
2986        ENABLE_MEMORY_COMPRESSION_FOR_ALL_STATELESS_ACCESSES_DISABLED = 0x0,
2987        ENABLE_MEMORY_COMPRESSION_FOR_ALL_STATELESS_ACCESSES_ENABLED = 0x1,
2988    } ENABLE_MEMORY_COMPRESSION_FOR_ALL_STATELESS_ACCESSES;
2989    typedef enum tagL1_CACHE_POLICY {
2990        L1_CACHE_POLICY_WBP = 0x0,
2991        L1_CACHE_POLICY_UC = 0x1,
2992        L1_CACHE_POLICY_WB = 0x2,
2993        L1_CACHE_POLICY_WT = 0x3,
2994        L1_CACHE_POLICY_WS = 0x4,
2995    } L1_CACHE_POLICY;
2996    typedef enum tagPATCH_CONSTANTS { // patched
2997        GENERALSTATEBASEADDRESS_BYTEOFFSET = 0x4,
2998        GENERALSTATEBASEADDRESS_INDEX = 0x1,
2999        SURFACESTATEBASEADDRESS_BYTEOFFSET = 0x10,
3000        SURFACESTATEBASEADDRESS_INDEX = 0x4,
3001        DYNAMICSTATEBASEADDRESS_BYTEOFFSET = 0x18,
3002        DYNAMICSTATEBASEADDRESS_INDEX = 0x6,
3003        INSTRUCTIONBASEADDRESS_BYTEOFFSET = 0x28,
3004        INSTRUCTIONBASEADDRESS_INDEX = 0xa,
3005        BINDLESSSURFACESTATEBASEADDRESS_BYTEOFFSET = 0x40,
3006        BINDLESSSURFACESTATEBASEADDRESS_INDEX = 0x10,
3007        BINDLESSSAMPLERSTATEBASEADDRESS_BYTEOFFSET = 0x4c,
3008        BINDLESSSAMPLERSTATEBASEADDRESS_INDEX = 0x13,
3009    } PATCH_CONSTANTS;
3010    inline void init() {
3011        memset(&TheStructure, 0, sizeof(TheStructure));
3012        TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N;
3013        TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_STATE_BASE_ADDRESS;
3014        TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED;
3015        TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_COMMON;
3016        TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE;
3017        TheStructure.Common.CoherencySettingModifyEnable = COHERENCY_SETTING_MODIFY_ENABLE_DISABLE_WRITE_TO_THIS_DW;
3018        TheStructure.Common.EnableMemoryCompressionForAllStatelessAccesses = ENABLE_MEMORY_COMPRESSION_FOR_ALL_STATELESS_ACCESSES_DISABLED;
3019        TheStructure.Common.L1CachePolicyL1CacheControl = L1_CACHE_POLICY_WBP;
3020    }
3021    static tagSTATE_BASE_ADDRESS sInit() {
3022        STATE_BASE_ADDRESS state;
3023        state.init();
3024        return state;
3025    }
3026    inline uint32_t &getRawData(const uint32_t index) {
3027        UNRECOVERABLE_IF(index >= 22);
3028        return TheStructure.RawData[index];
3029    }
3030    inline void setGeneralStateBaseAddressModifyEnable(const bool value) {
3031        TheStructure.Common.GeneralStateBaseAddressModifyEnable = value;
3032    }
3033    inline bool getGeneralStateBaseAddressModifyEnable() const {
3034        return TheStructure.Common.GeneralStateBaseAddressModifyEnable;
3035    }
3036    inline void setGeneralStateMemoryObjectControlState(const uint64_t value) {
3037        UNRECOVERABLE_IF(value > 0x7fL);
3038        TheStructure.Common.GeneralStateMemoryObjectControlStateIndexToMocsTables = (value >> 1); // patched
3039    }
3040    inline uint64_t getGeneralStateMemoryObjectControlState() const {
3041        return TheStructure.Common.GeneralStateMemoryObjectControlStateIndexToMocsTables << 1; // patched
3042    }
3043    typedef enum tagGENERALSTATEBASEADDRESS {
3044        GENERALSTATEBASEADDRESS_BIT_SHIFT = 0xc,
3045        GENERALSTATEBASEADDRESS_ALIGN_SIZE = 0x1000,
3046    } GENERALSTATEBASEADDRESS;
3047    inline void setGeneralStateBaseAddress(const uint64_t value) {
3048        UNRECOVERABLE_IF(value > 0x1ffffffffffffffL);
3049        TheStructure.Common.GeneralStateBaseAddress = value >> GENERALSTATEBASEADDRESS_BIT_SHIFT;
3050    }
3051    inline uint64_t getGeneralStateBaseAddress() const {
3052        return TheStructure.Common.GeneralStateBaseAddress << GENERALSTATEBASEADDRESS_BIT_SHIFT;
3053    }
3054    inline void setCoherencySettingModifyEnable(const COHERENCY_SETTING_MODIFY_ENABLE value) {
3055        TheStructure.Common.CoherencySettingModifyEnable = value;
3056    }
3057    inline COHERENCY_SETTING_MODIFY_ENABLE getCoherencySettingModifyEnable() const {
3058        return static_cast<COHERENCY_SETTING_MODIFY_ENABLE>(TheStructure.Common.CoherencySettingModifyEnable);
3059    }
3060    inline void setEnableMemoryCompressionForAllStatelessAccesses(const ENABLE_MEMORY_COMPRESSION_FOR_ALL_STATELESS_ACCESSES value) {
3061        TheStructure.Common.EnableMemoryCompressionForAllStatelessAccesses = value;
3062    }
3063    inline ENABLE_MEMORY_COMPRESSION_FOR_ALL_STATELESS_ACCESSES getEnableMemoryCompressionForAllStatelessAccesses() const {
3064        return static_cast<ENABLE_MEMORY_COMPRESSION_FOR_ALL_STATELESS_ACCESSES>(TheStructure.Common.EnableMemoryCompressionForAllStatelessAccesses);
3065    }
3066    inline void setDisableSupportForMultiGpuAtomicsForStatelessAccesses(const bool value) {
3067        TheStructure.Common.DisableSupportForMultiGpuAtomicsForStatelessAccesses = value;
3068    }
3069    inline bool getDisableSupportForMultiGpuAtomicsForStatelessAccesses() const {
3070        return TheStructure.Common.DisableSupportForMultiGpuAtomicsForStatelessAccesses;
3071    }
3072    inline void setDisableSupportForMultiGpuPartialWritesForStatelessMessages(const bool value) {
3073        TheStructure.Common.DisableSupportForMultiGpuPartialWritesForStatelessMessages = value;
3074    }
3075    inline bool getDisableSupportForMultiGpuPartialWritesForStatelessMessages() const {
3076        return TheStructure.Common.DisableSupportForMultiGpuPartialWritesForStatelessMessages;
3077    }
3078    inline void setStatelessDataPortAccessMemoryObjectControlState(const uint32_t value) { // patched
3079        TheStructure.Common.StatelessDataPortAccessMemoryObjectControlStateReserved_112 = value;
3080        TheStructure.Common.StatelessDataPortAccessMemoryObjectControlStateIndexToMocsTables = (value >> 1);
3081    }
3082    inline uint32_t getStatelessDataPortAccessMemoryObjectControlState() const { // patched
3083        uint32_t mocs = TheStructure.Common.StatelessDataPortAccessMemoryObjectControlStateReserved_112;
3084        mocs |= TheStructure.Common.StatelessDataPortAccessMemoryObjectControlStateIndexToMocsTables << 1;
3085        return (mocs);
3086    }
3087    inline void setL1CachePolicyL1CacheControl(const L1_CACHE_POLICY value) {
3088        TheStructure.Common.L1CachePolicyL1CacheControl = value;
3089    }
3090    inline L1_CACHE_POLICY getL1CachePolicyL1CacheControl() const {
3091        return static_cast<L1_CACHE_POLICY>(TheStructure.Common.L1CachePolicyL1CacheControl);
3092    }
3093
3094    inline void setSurfaceStateBaseAddressModifyEnable(const bool value) {
3095        TheStructure.Common.SurfaceStateBaseAddressModifyEnable = value;
3096    }
3097    inline bool getSurfaceStateBaseAddressModifyEnable() const {
3098        return TheStructure.Common.SurfaceStateBaseAddressModifyEnable;
3099    }
3100    inline void setSurfaceStateMemoryObjectControlState(const uint64_t value) {
3101        UNRECOVERABLE_IF(value > 0x7fL);
3102        TheStructure.Common.SurfaceStateMemoryObjectControlStateIndexToMocsTables = (value >> 1); // patched
3103    }
3104    inline uint64_t getSurfaceStateMemoryObjectControlState() const {
3105        return TheStructure.Common.SurfaceStateMemoryObjectControlStateIndexToMocsTables << 1; // patched
3106    }
3107    typedef enum tagSURFACESTATEBASEADDRESS {
3108        SURFACESTATEBASEADDRESS_BIT_SHIFT = 0xc,
3109        SURFACESTATEBASEADDRESS_ALIGN_SIZE = 0x1000,
3110    } SURFACESTATEBASEADDRESS;
3111    inline void setSurfaceStateBaseAddress(const uint64_t value) {
3112        UNRECOVERABLE_IF(value > 0xffffffffffffffffL);
3113        TheStructure.Common.SurfaceStateBaseAddress = value >> SURFACESTATEBASEADDRESS_BIT_SHIFT;
3114    }
3115    inline uint64_t getSurfaceStateBaseAddress() const {
3116        return TheStructure.Common.SurfaceStateBaseAddress << SURFACESTATEBASEADDRESS_BIT_SHIFT;
3117    }
3118    inline void setDynamicStateBaseAddressModifyEnable(const bool value) {
3119        TheStructure.Common.DynamicStateBaseAddressModifyEnable = value;
3120    }
3121    inline bool getDynamicStateBaseAddressModifyEnable() const {
3122        return TheStructure.Common.DynamicStateBaseAddressModifyEnable;
3123    }
3124    inline void setDynamicStateMemoryObjectControlState(const uint64_t value) {
3125        UNRECOVERABLE_IF(value > 0x7fL);
3126        TheStructure.Common.DynamicStateMemoryObjectControlStateIndexToMocsTables = (value >> 1); // patched
3127    }
3128    inline uint64_t getDynamicStateMemoryObjectControlState() const {
3129        return TheStructure.Common.DynamicStateMemoryObjectControlStateIndexToMocsTables << 1; // patched
3130    }
3131    typedef enum tagDYNAMICSTATEBASEADDRESS {
3132        DYNAMICSTATEBASEADDRESS_BIT_SHIFT = 0xc,
3133        DYNAMICSTATEBASEADDRESS_ALIGN_SIZE = 0x1000,
3134    } DYNAMICSTATEBASEADDRESS;
3135    inline void setDynamicStateBaseAddress(const uint64_t value) {
3136        UNRECOVERABLE_IF(value > 0xffffffffffffffffL);
3137        TheStructure.Common.DynamicStateBaseAddress = value >> DYNAMICSTATEBASEADDRESS_BIT_SHIFT;
3138    }
3139    inline uint64_t getDynamicStateBaseAddress() const {
3140        return TheStructure.Common.DynamicStateBaseAddress << DYNAMICSTATEBASEADDRESS_BIT_SHIFT;
3141    }
3142    inline void setInstructionBaseAddressModifyEnable(const bool value) {
3143        TheStructure.Common.InstructionBaseAddressModifyEnable = value;
3144    }
3145    inline bool getInstructionBaseAddressModifyEnable() const {
3146        return TheStructure.Common.InstructionBaseAddressModifyEnable;
3147    }
3148    inline void setInstructionMemoryObjectControlState(const uint32_t value) { // patched
3149        uint64_t val = static_cast<uint64_t>(value);
3150        TheStructure.Common.InstructionMemoryObjectControlStateReserved_324 = val;
3151        TheStructure.Common.InstructionMemoryObjectControlStateIndexToMocsTables = (val >> 1);
3152    }
3153    inline uint32_t getInstructionMemoryObjectControlState() const { // patched
3154        uint64_t mocs = TheStructure.Common.InstructionMemoryObjectControlStateReserved_324;
3155        mocs |= (TheStructure.Common.InstructionMemoryObjectControlStateIndexToMocsTables << 1);
3156        return static_cast<uint32_t>(mocs);
3157    }
3158    typedef enum tagINSTRUCTIONBASEADDRESS {
3159        INSTRUCTIONBASEADDRESS_BIT_SHIFT = 0xc,
3160        INSTRUCTIONBASEADDRESS_ALIGN_SIZE = 0x1000,
3161    } INSTRUCTIONBASEADDRESS;
3162    inline void setInstructionBaseAddress(const uint64_t value) {
3163        UNRECOVERABLE_IF(value > 0xffffffffffffffffL);
3164        TheStructure.Common.InstructionBaseAddress = value >> INSTRUCTIONBASEADDRESS_BIT_SHIFT;
3165    }
3166    inline uint64_t getInstructionBaseAddress() const {
3167        return TheStructure.Common.InstructionBaseAddress << INSTRUCTIONBASEADDRESS_BIT_SHIFT;
3168    }
3169    inline void setGeneralStateBufferSizeModifyEnable(const bool value) {
3170        TheStructure.Common.GeneralStateBufferSizeModifyEnable = value;
3171    }
3172    inline bool getGeneralStateBufferSizeModifyEnable() const {
3173        return TheStructure.Common.GeneralStateBufferSizeModifyEnable;
3174    }
3175    inline void setGeneralStateBufferSize(const uint32_t value) {
3176        UNRECOVERABLE_IF(value > 0xfffff);
3177        TheStructure.Common.GeneralStateBufferSize = value;
3178    }
3179    inline uint32_t getGeneralStateBufferSize() const {
3180        return TheStructure.Common.GeneralStateBufferSize;
3181    }
3182    inline void setDynamicStateBufferSizeModifyEnable(const bool value) {
3183        TheStructure.Common.DynamicStateBufferSizeModifyEnable = value;
3184    }
3185    inline bool getDynamicStateBufferSizeModifyEnable() const {
3186        return TheStructure.Common.DynamicStateBufferSizeModifyEnable;
3187    }
3188    inline void setDynamicStateBufferSize(const uint32_t value) {
3189        UNRECOVERABLE_IF(value > 0xfffff);
3190        TheStructure.Common.DynamicStateBufferSize = value;
3191    }
3192    inline uint32_t getDynamicStateBufferSize() const {
3193        return TheStructure.Common.DynamicStateBufferSize;
3194    }
3195    inline void setIndirectObjectBufferSizeModifyEnable(const bool value) {
3196        TheStructure.Common.IndirectObjectBufferSizeModifyEnable = value;
3197    }
3198    inline bool getIndirectObjectBufferSizeModifyEnable() const {
3199        return TheStructure.Common.IndirectObjectBufferSizeModifyEnable;
3200    }
3201    inline void setIndirectObjectBufferSize(const uint32_t value) {
3202        UNRECOVERABLE_IF(value > 0xfffff);
3203        TheStructure.Common.IndirectObjectBufferSize = value;
3204    }
3205    inline uint32_t getIndirectObjectBufferSize() const {
3206        return TheStructure.Common.IndirectObjectBufferSize;
3207    }
3208    inline void setInstructionBufferSizeModifyEnable(const bool value) {
3209        TheStructure.Common.InstructionBufferSizeModifyEnable = value;
3210    }
3211    inline bool getInstructionBufferSizeModifyEnable() const {
3212        return TheStructure.Common.InstructionBufferSizeModifyEnable;
3213    }
3214    inline void setInstructionBufferSize(const uint32_t value) {
3215        UNRECOVERABLE_IF(value > 0xfffff);
3216        TheStructure.Common.InstructionBufferSize = value;
3217    }
3218    inline uint32_t getInstructionBufferSize() const {
3219        return TheStructure.Common.InstructionBufferSize;
3220    }
3221    inline void setBindlessSurfaceStateBaseAddressModifyEnable(const bool value) {
3222        TheStructure.Common.BindlessSurfaceStateBaseAddressModifyEnable = value;
3223    }
3224    inline bool getBindlessSurfaceStateBaseAddressModifyEnable() const {
3225        return TheStructure.Common.BindlessSurfaceStateBaseAddressModifyEnable;
3226    }
3227    inline void setBindlessSurfaceStateMemoryObjectControlState(const uint64_t value) {
3228        UNRECOVERABLE_IF((value >> 1) > 0x3fL);
3229        TheStructure.Common.BindlessSurfaceStateMemoryObjectControlStateIndexToMocsTables = value >> 1;
3230    }
3231    inline uint64_t getBindlessSurfaceStateMemoryObjectControlState() const {
3232        return (TheStructure.Common.BindlessSurfaceStateMemoryObjectControlStateIndexToMocsTables << 1);
3233    }
3234    typedef enum tagBINDLESSSURFACESTATEBASEADDRESS {
3235        BINDLESSSURFACESTATEBASEADDRESS_BIT_SHIFT = 0xc,
3236        BINDLESSSURFACESTATEBASEADDRESS_ALIGN_SIZE = 0x1000,
3237    } BINDLESSSURFACESTATEBASEADDRESS;
3238    inline void setBindlessSurfaceStateBaseAddress(const uint64_t value) {
3239        UNRECOVERABLE_IF(value > 0xffffffffffffffffL);
3240        TheStructure.Common.BindlessSurfaceStateBaseAddress = value >> BINDLESSSURFACESTATEBASEADDRESS_BIT_SHIFT;
3241    }
3242    inline uint64_t getBindlessSurfaceStateBaseAddress() const {
3243        return TheStructure.Common.BindlessSurfaceStateBaseAddress << BINDLESSSURFACESTATEBASEADDRESS_BIT_SHIFT;
3244    }
3245    inline void setBindlessSurfaceStateSize(const uint32_t value) {
3246        TheStructure.Common.BindlessSurfaceStateSize = value;
3247    }
3248    inline uint32_t getBindlessSurfaceStateSize() const {
3249        return TheStructure.Common.BindlessSurfaceStateSize;
3250    }
3251    inline void setBindlessSamplerStateBaseAddressModifyEnable(const bool value) {
3252        TheStructure.Common.BindlessSamplerStateBaseAddressModifyEnable = value;
3253    }
3254    inline bool getBindlessSamplerStateBaseAddressModifyEnable() const {
3255        return TheStructure.Common.BindlessSamplerStateBaseAddressModifyEnable;
3256    }
3257    inline void setBindlessSamplerStateMemoryObjectControlStateReserved(const uint64_t value) {
3258        TheStructure.Common.BindlessSamplerStateMemoryObjectControlStateReserved_612 = value;
3259    }
3260    inline uint64_t getBindlessSamplerStateMemoryObjectControlStateReserved() const {
3261        return (TheStructure.Common.BindlessSamplerStateMemoryObjectControlStateReserved_612);
3262    }
3263    inline void setBindlessSamplerStateMemoryObjectControlState(const uint64_t value) {
3264        UNRECOVERABLE_IF((value >> 1) > 0x3fL);
3265        TheStructure.Common.BindlessSamplerStateMemoryObjectControlStateIndexToMocsTables = value >> 1;
3266    }
3267    inline uint64_t getBindlessSamplerStateMemoryObjectControlState() const {
3268        return (TheStructure.Common.BindlessSamplerStateMemoryObjectControlStateIndexToMocsTables << 1);
3269    }
3270    typedef enum tagBINDLESSSAMPLERSTATEBASEADDRESS {
3271        BINDLESSSAMPLERSTATEBASEADDRESS_BIT_SHIFT = 0xc,
3272        BINDLESSSAMPLERSTATEBASEADDRESS_ALIGN_SIZE = 0x1000,
3273    } BINDLESSSAMPLERSTATEBASEADDRESS;
3274    inline void setBindlessSamplerStateBaseAddress(const uint64_t value) {
3275        UNRECOVERABLE_IF(value > 0xffffffffffffffffL);
3276        TheStructure.Common.BindlessSamplerStateBaseAddress = value >> BINDLESSSAMPLERSTATEBASEADDRESS_BIT_SHIFT;
3277    }
3278    inline uint64_t getBindlessSamplerStateBaseAddress() const {
3279        return TheStructure.Common.BindlessSamplerStateBaseAddress << BINDLESSSAMPLERSTATEBASEADDRESS_BIT_SHIFT;
3280    }
3281    inline void setBindlessSamplerStateBufferSize(const uint32_t value) {
3282        UNRECOVERABLE_IF(value > 0xfffff);
3283        TheStructure.Common.BindlessSamplerStateBufferSize = value;
3284    }
3285    inline uint32_t getBindlessSamplerStateBufferSize() const {
3286        return TheStructure.Common.BindlessSamplerStateBufferSize;
3287    }
3288} STATE_BASE_ADDRESS;
3289STATIC_ASSERT(88 == sizeof(STATE_BASE_ADDRESS));
3290
3291typedef struct tagMI_REPORT_PERF_COUNT {
3292    union tagTheStructure {
3293        struct tagCommon {
3294            // DWORD 0
3295            uint32_t DwordLength : BITFIELD_RANGE(0, 5);
3296            uint32_t Reserved_6 : BITFIELD_RANGE(6, 22);
3297            uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28);
3298            uint32_t CommandType : BITFIELD_RANGE(29, 31);
3299            // DWORD 1
3300            uint64_t UseGlobalGtt : BITFIELD_RANGE(0, 0);
3301            uint64_t Reserved_33 : BITFIELD_RANGE(1, 3);
3302            uint64_t CoreModeEnable : BITFIELD_RANGE(4, 4);
3303            uint64_t Reserved_37 : BITFIELD_RANGE(5, 5);
3304            uint64_t MemoryAddress : BITFIELD_RANGE(6, 63);
3305            // DWORD 3
3306            uint32_t ReportId;
3307        } Common;
3308        uint32_t RawData[4];
3309    } TheStructure;
3310    typedef enum tagDWORD_LENGTH {
3311        DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x2,
3312    } DWORD_LENGTH;
3313    typedef enum tagMI_COMMAND_OPCODE {
3314        MI_COMMAND_OPCODE_MI_REPORT_PERF_COUNT = 0x28,
3315    } MI_COMMAND_OPCODE;
3316    typedef enum tagCOMMAND_TYPE {
3317        COMMAND_TYPE_MI_COMMAND = 0x0,
3318    } COMMAND_TYPE;
3319    typedef enum tagPATCH_CONSTANTS {
3320        MEMORYADDRESS_BYTEOFFSET = 0x4,
3321        MEMORYADDRESS_INDEX = 0x1,
3322    } PATCH_CONSTANTS;
3323    inline void init() {
3324        memset(&TheStructure, 0, sizeof(TheStructure));
3325        TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1;
3326        TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_REPORT_PERF_COUNT;
3327        TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND;
3328    }
3329    static tagMI_REPORT_PERF_COUNT sInit() {
3330        MI_REPORT_PERF_COUNT state;
3331        state.init();
3332        return state;
3333    }
3334    inline uint32_t &getRawData(const uint32_t index) {
3335        UNRECOVERABLE_IF(index >= 4);
3336        return TheStructure.RawData[index];
3337    }
3338    inline void setUseGlobalGtt(const bool value) {
3339        TheStructure.Common.UseGlobalGtt = value;
3340    }
3341    inline bool getUseGlobalGtt() const {
3342        return TheStructure.Common.UseGlobalGtt;
3343    }
3344    inline void setCoreModeEnable(const bool value) {
3345        TheStructure.Common.CoreModeEnable = value;
3346    }
3347    inline bool getCoreModeEnable() const {
3348        return TheStructure.Common.CoreModeEnable;
3349    }
3350    typedef enum tagMEMORYADDRESS {
3351        MEMORYADDRESS_BIT_SHIFT = 0x6,
3352        MEMORYADDRESS_ALIGN_SIZE = 0x40,
3353    } MEMORYADDRESS;
3354    inline void setMemoryAddress(const uint64_t value) {
3355        UNRECOVERABLE_IF(value > 0xffffffffffffffffL);
3356        TheStructure.Common.MemoryAddress = value >> MEMORYADDRESS_BIT_SHIFT;
3357    }
3358    inline uint64_t getMemoryAddress() const {
3359        return TheStructure.Common.MemoryAddress << MEMORYADDRESS_BIT_SHIFT;
3360    }
3361    inline void setReportId(const uint32_t value) {
3362        TheStructure.Common.ReportId = value;
3363    }
3364    inline uint32_t getReportId() const {
3365        return TheStructure.Common.ReportId;
3366    }
3367} MI_REPORT_PERF_COUNT;
3368STATIC_ASSERT(16 == sizeof(MI_REPORT_PERF_COUNT));
3369
3370struct MI_USER_INTERRUPT {
3371    union tagTheStructure {
3372        struct tagCommon {
3373            uint32_t Reserved_0 : BITFIELD_RANGE(0, 22);
3374            uint32_t MICommandOpcode : BITFIELD_RANGE(23, 28);
3375            uint32_t CommandType : BITFIELD_RANGE(29, 31);
3376        } Common;
3377        uint32_t RawData[1];
3378    } TheStructure;
3379    enum MI_COMMAND_OPCODE {
3380        MI_COMMAND_OPCODE_MI_USER_INTERRUPT = 2,
3381    };
3382    enum COMMAND_TYPE {
3383        COMMAND_TYPE_MI_COMMAND = 0,
3384    };
3385    inline void init() {
3386        memset(&TheStructure, 0, sizeof(TheStructure));
3387        TheStructure.Common.MICommandOpcode = MI_COMMAND_OPCODE_MI_USER_INTERRUPT;
3388    }
3389    static MI_USER_INTERRUPT sInit() {
3390        MI_USER_INTERRUPT state;
3391        state.init();
3392        return state;
3393    }
3394    inline uint32_t &getRawData(const uint32_t index) {
3395        return TheStructure.RawData[index];
3396    }
3397};
3398STATIC_ASSERT(4 == sizeof(MI_USER_INTERRUPT));
3399
3400typedef struct tagMI_SET_PREDICATE {
3401    union tagTheStructure {
3402        struct tagCommon {
3403            uint32_t PredicateEnable : BITFIELD_RANGE(0, 3);
3404            uint32_t PredicateEnableWparid : BITFIELD_RANGE(4, 5);
3405            uint32_t Reserved_6 : BITFIELD_RANGE(6, 22);
3406            uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28);
3407            uint32_t CommandType : BITFIELD_RANGE(29, 31);
3408        } Common;
3409        uint32_t RawData[1];
3410    } TheStructure;
3411    typedef enum tagPREDICATE_ENABLE {
3412        PREDICATE_ENABLE_PREDICATE_DISABLE = 0x0,
3413        PREDICATE_ENABLE_PREDICATE_ON_CLEAR = 0x1,
3414        PREDICATE_ENABLE_PREDICATE_ON_SET = 0x2,
3415        PREDICATE_ENABLE_NOOP_ALWAYS = 0xf,
3416    } PREDICATE_ENABLE;
3417    typedef enum tagPREDICATE_ENABLE_WPARID {
3418        PREDICATE_ENABLE_WPARID_NOOP_NEVER = 0x0,
3419        PREDICATE_ENABLE_WPARID_NOOP_ON_ZERO_VALUE = 0x1,
3420        PREDICATE_ENABLE_WPARID_NOOP_ON_NON_ZERO_VALUE = 0x2,
3421    } PREDICATE_ENABLE_WPARID;
3422    typedef enum tagMI_COMMAND_OPCODE {
3423        MI_COMMAND_OPCODE_MI_SET_PREDICATE = 0x1,
3424    } MI_COMMAND_OPCODE;
3425    typedef enum tagCOMMAND_TYPE {
3426        COMMAND_TYPE_MI_COMMAND = 0x0,
3427    } COMMAND_TYPE;
3428    inline void init() {
3429        memset(&TheStructure, 0, sizeof(TheStructure));
3430        TheStructure.Common.PredicateEnable = PREDICATE_ENABLE_PREDICATE_DISABLE;
3431        TheStructure.Common.PredicateEnableWparid = PREDICATE_ENABLE_WPARID_NOOP_NEVER;
3432        TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_SET_PREDICATE;
3433        TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND;
3434    }
3435    static tagMI_SET_PREDICATE sInit() {
3436        MI_SET_PREDICATE state;
3437        state.init();
3438        return state;
3439    }
3440    inline uint32_t &getRawData(const uint32_t index) {
3441        UNRECOVERABLE_IF(index >= 1);
3442        return TheStructure.RawData[index];
3443    }
3444    inline void setPredicateEnable(const PREDICATE_ENABLE value) {
3445        TheStructure.Common.PredicateEnable = value;
3446    }
3447    inline PREDICATE_ENABLE getPredicateEnable() const {
3448        return static_cast<PREDICATE_ENABLE>(TheStructure.Common.PredicateEnable);
3449    }
3450    inline void setPredicateEnableWparid(const PREDICATE_ENABLE_WPARID value) {
3451        TheStructure.Common.PredicateEnableWparid = value;
3452    }
3453    inline PREDICATE_ENABLE_WPARID getPredicateEnableWparid() const {
3454        return static_cast<PREDICATE_ENABLE_WPARID>(TheStructure.Common.PredicateEnableWparid);
3455    }
3456} MI_SET_PREDICATE;
3457STATIC_ASSERT(4 == sizeof(MI_SET_PREDICATE));
3458
3459typedef struct tagMI_CONDITIONAL_BATCH_BUFFER_END {
3460    union tagTheStructure {
3461        struct tagCommon {
3462            // DWORD 0
3463            uint32_t DwordLength : BITFIELD_RANGE(0, 7);
3464            uint32_t Reserved_8 : BITFIELD_RANGE(8, 11);
3465            uint32_t CompareOperation : BITFIELD_RANGE(12, 14);
3466            uint32_t PredicateEnable : BITFIELD_RANGE(15, 15);
3467            uint32_t Reserved_16 : BITFIELD_RANGE(16, 17);
3468            uint32_t EndCurrentBatchBufferLevel : BITFIELD_RANGE(18, 18);
3469            uint32_t CompareMaskMode : BITFIELD_RANGE(19, 19);
3470            uint32_t Reserved_20 : BITFIELD_RANGE(20, 20);
3471            uint32_t CompareSemaphore : BITFIELD_RANGE(21, 21);
3472            uint32_t UseGlobalGtt : BITFIELD_RANGE(22, 22);
3473            uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28);
3474            uint32_t CommandType : BITFIELD_RANGE(29, 31);
3475            // DWORD 1
3476            uint32_t CompareDataDword;
3477            // DWORD 2
3478            uint64_t Reserved_64 : BITFIELD_RANGE(0, 2);
3479            uint64_t CompareAddress : BITFIELD_RANGE(3, 56);
3480            uint64_t CompareAddressReserved_121 : BITFIELD_RANGE(57, 63);
3481        } Common;
3482        uint32_t RawData[4];
3483    } TheStructure;
3484    typedef enum tagDWORD_LENGTH {
3485        DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x2,
3486    } DWORD_LENGTH;
3487    typedef enum tagCOMPARE_OPERATION {
3488        COMPARE_OPERATION_MAD_GREATER_THAN_IDD = 0x0,
3489        COMPARE_OPERATION_MAD_GREATER_THAN_OR_EQUAL_IDD = 0x1,
3490        COMPARE_OPERATION_MAD_LESS_THAN_IDD = 0x2,
3491        COMPARE_OPERATION_MAD_LESS_THAN_OR_EQUAL_IDD = 0x3,
3492        COMPARE_OPERATION_MAD_EQUAL_IDD = 0x4,
3493        COMPARE_OPERATION_MAD_NOT_EQUAL_IDD = 0x5,
3494    } COMPARE_OPERATION;
3495    typedef enum tagCOMPARE_MASK_MODE {
3496        COMPARE_MASK_MODE_COMPARE_MASK_MODE_DISABLED = 0x0,
3497        COMPARE_MASK_MODE_COMPARE_MASK_MODE_ENABLED = 0x1,
3498    } COMPARE_MASK_MODE;
3499    typedef enum tagMI_COMMAND_OPCODE {
3500        MI_COMMAND_OPCODE_MI_CONDITIONAL_BATCH_BUFFER_END = 0x36,
3501    } MI_COMMAND_OPCODE;
3502    typedef enum tagCOMMAND_TYPE {
3503        COMMAND_TYPE_MI_COMMAND = 0x0,
3504    } COMMAND_TYPE;
3505    inline void init() {
3506        memset(&TheStructure, 0, sizeof(TheStructure));
3507        TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1;
3508        TheStructure.Common.CompareOperation = COMPARE_OPERATION_MAD_GREATER_THAN_IDD;
3509        TheStructure.Common.CompareMaskMode = COMPARE_MASK_MODE_COMPARE_MASK_MODE_DISABLED;
3510        TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_CONDITIONAL_BATCH_BUFFER_END;
3511        TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND;
3512    }
3513    static tagMI_CONDITIONAL_BATCH_BUFFER_END sInit() {
3514        MI_CONDITIONAL_BATCH_BUFFER_END state;
3515        state.init();
3516        return state;
3517    }
3518    inline uint32_t &getRawData(const uint32_t index) {
3519        UNRECOVERABLE_IF(index >= 4);
3520        return TheStructure.RawData[index];
3521    }
3522    inline void setCompareOperation(const COMPARE_OPERATION value) {
3523        TheStructure.Common.CompareOperation = value;
3524    }
3525    inline COMPARE_OPERATION getCompareOperation() const {
3526        return static_cast<COMPARE_OPERATION>(TheStructure.Common.CompareOperation);
3527    }
3528    inline void setPredicateEnable(const bool value) {
3529        TheStructure.Common.PredicateEnable = value;
3530    }
3531    inline bool getPredicateEnable() const {
3532        return TheStructure.Common.PredicateEnable;
3533    }
3534    inline void setEndCurrentBatchBufferLevel(const bool value) {
3535        TheStructure.Common.EndCurrentBatchBufferLevel = value;
3536    }
3537    inline bool getEndCurrentBatchBufferLevel() const {
3538        return TheStructure.Common.EndCurrentBatchBufferLevel;
3539    }
3540    inline void setCompareMaskMode(const COMPARE_MASK_MODE value) {
3541        TheStructure.Common.CompareMaskMode = value;
3542    }
3543    inline COMPARE_MASK_MODE getCompareMaskMode() const {
3544        return static_cast<COMPARE_MASK_MODE>(TheStructure.Common.CompareMaskMode);
3545    }
3546    inline void setCompareSemaphore(const bool value) {
3547        TheStructure.Common.CompareSemaphore = value;
3548    }
3549    inline bool getCompareSemaphore() const {
3550        return TheStructure.Common.CompareSemaphore;
3551    }
3552    inline void setUseGlobalGtt(const bool value) {
3553        TheStructure.Common.UseGlobalGtt = value;
3554    }
3555    inline bool getUseGlobalGtt() const {
3556        return TheStructure.Common.UseGlobalGtt;
3557    }
3558    inline void setCompareDataDword(const uint32_t value) {
3559        TheStructure.Common.CompareDataDword = value;
3560    }
3561    inline uint32_t getCompareDataDword() const {
3562        return TheStructure.Common.CompareDataDword;
3563    }
3564    typedef enum tagCOMPAREADDRESS {
3565        COMPAREADDRESS_BIT_SHIFT = 0x3,
3566        COMPAREADDRESS_ALIGN_SIZE = 0x8,
3567    } COMPAREADDRESS;
3568    inline void setCompareAddress(const uint64_t value) {
3569        TheStructure.Common.CompareAddress = value >> COMPAREADDRESS_BIT_SHIFT;
3570    }
3571    inline uint64_t getCompareAddress() const {
3572        return TheStructure.Common.CompareAddress << COMPAREADDRESS_BIT_SHIFT;
3573    }
3574} MI_CONDITIONAL_BATCH_BUFFER_END;
3575STATIC_ASSERT(16 == sizeof(MI_CONDITIONAL_BATCH_BUFFER_END));
3576
3577struct XY_BLOCK_COPY_BLT {
3578    union tagTheStructure {
3579        struct tagCommon {
3580            /// DWORD 0
3581            uint32_t DwordLength : BITFIELD_RANGE(0, 7);
3582            uint32_t Reserved_8 : BITFIELD_RANGE(8, 8);
3583            uint32_t NumberofMultisamples : BITFIELD_RANGE(9, 11);
3584            uint32_t SpecialModeofOperation : BITFIELD_RANGE(12, 13);
3585            uint32_t Reserved_14 : BITFIELD_RANGE(14, 18);
3586            uint32_t ColorDepth : BITFIELD_RANGE(19, 21);
3587            uint32_t InstructionTarget_Opcode : BITFIELD_RANGE(22, 28);
3588            uint32_t Client : BITFIELD_RANGE(29, 31);
3589
3590            /// DWORD 1
3591            uint32_t DestinationPitch : BITFIELD_RANGE(0, 17);
3592            uint32_t DestinationAuxiliarysurfacemode : BITFIELD_RANGE(18, 20);
3593            uint32_t DestinationMOCS : BITFIELD_RANGE(21, 27);
3594            uint32_t DestinationCompressionType : BITFIELD_RANGE(28, 28);
3595            uint32_t DestinationCompressionEnable : BITFIELD_RANGE(29, 29);
3596            uint32_t DestinationTiling : BITFIELD_RANGE(30, 31);
3597
3598            /// DWORD 2
3599            uint32_t DestinationX1Coordinate_Left : BITFIELD_RANGE(0, 15);
3600            uint32_t DestinationY1Coordinate_Top : BITFIELD_RANGE(16, 31);
3601
3602            /// DWORD 3
3603            uint32_t DestinationX2Coordinate_Right : BITFIELD_RANGE(0, 15);
3604            uint32_t DestinationY2Coordinate_Bottom : BITFIELD_RANGE(16, 31);
3605
3606            /// DWORD 4..5
3607            uint64_t DestinationBaseAddress;
3608
3609            /// DWORD 6
3610            uint32_t DestinationXoffset : BITFIELD_RANGE(0, 13);
3611            uint32_t Reserved_206 : BITFIELD_RANGE(14, 15);
3612            uint32_t DestinationYoffset : BITFIELD_RANGE(16, 29);
3613            uint32_t Reserved_222 : BITFIELD_RANGE(30, 30);
3614            uint32_t DestinationTargetMemory : BITFIELD_RANGE(31, 31);
3615
3616            /// DWORD 7
3617            uint32_t SourceX1Coordinate_Left : BITFIELD_RANGE(0, 15);
3618            uint32_t SourceY1Coordinate_Top : BITFIELD_RANGE(16, 31);
3619
3620            /// DWORD 8
3621            uint32_t SourcePitch : BITFIELD_RANGE(0, 17);
3622            uint32_t SourceAuxiliarysurfacemode : BITFIELD_RANGE(18, 20);
3623            uint32_t SourceMOCS : BITFIELD_RANGE(21, 27);
3624            uint32_t SourceCompressionType : BITFIELD_RANGE(28, 28);
3625            uint32_t SourceCompressionEnable : BITFIELD_RANGE(29, 29);
3626            uint32_t SourceTiling : BITFIELD_RANGE(30, 31);
3627
3628            /// DWORD 9..10
3629            uint64_t SourceBaseAddress;
3630
3631            /// DWORD 11
3632            uint32_t SourceXoffset : BITFIELD_RANGE(0, 13);
3633            uint32_t Reserved_366 : BITFIELD_RANGE(14, 15);
3634            uint32_t SourceYoffset : BITFIELD_RANGE(16, 29);
3635            uint32_t Reserved_382 : BITFIELD_RANGE(30, 30);
3636            uint32_t SourceTargetMemory : BITFIELD_RANGE(31, 31);
3637
3638            /// DWORD 12
3639            uint32_t SourceCompressionFormat : BITFIELD_RANGE(0, 4);
3640            uint32_t SourceClearValueEnable : BITFIELD_RANGE(5, 5);
3641            uint32_t SourceClearAddressLow : BITFIELD_RANGE(6, 31);
3642
3643            /// DWORD 13
3644            uint32_t SourceClearAddressHigh : BITFIELD_RANGE(0, 15);
3645            uint32_t Reserved_432 : BITFIELD_RANGE(16, 31);
3646
3647            /// DWORD 14
3648            uint32_t DestinationCompressionFormat : BITFIELD_RANGE(0, 4);
3649            uint32_t DestinationClearValueEnable : BITFIELD_RANGE(5, 5);
3650            uint32_t DestinationClearAddressLow : BITFIELD_RANGE(6, 31);
3651
3652            /// DWORD 15
3653            uint32_t DestinationClearAddressHigh : BITFIELD_RANGE(0, 15);
3654            uint32_t Reserved_496 : BITFIELD_RANGE(16, 31);
3655
3656            /// DWORD 16
3657            uint32_t DestinationSurfaceHeight : BITFIELD_RANGE(0, 13);
3658            uint32_t DestinationSurfaceWidth : BITFIELD_RANGE(14, 27);
3659            uint32_t Reserved_540 : BITFIELD_RANGE(28, 28);
3660            uint32_t DestinationSurfaceType : BITFIELD_RANGE(29, 31);
3661
3662            /// DWORD 17
3663            uint32_t DestinationLOD : BITFIELD_RANGE(0, 3);
3664            uint32_t DestinationSurfaceQpitch : BITFIELD_RANGE(4, 20);
3665            uint32_t DestinationSurfaceDepth : BITFIELD_RANGE(21, 31);
3666
3667            /// DWORD 18
3668            uint32_t DestinationHorizontalAlign : BITFIELD_RANGE(0, 1);
3669            uint32_t Reserved_578 : BITFIELD_RANGE(2, 2);
3670            uint32_t DestinationVerticalAlign : BITFIELD_RANGE(3, 4);
3671            uint32_t DestinationSSID : BITFIELD_RANGE(5, 7);
3672            uint32_t DestinationMipTailStartLOD : BITFIELD_RANGE(8, 11);
3673            uint32_t Reserved_588 : BITFIELD_RANGE(12, 17);
3674            uint32_t DestinationDepthStencilResource : BITFIELD_RANGE(18, 18);
3675            uint32_t Reserved_595 : BITFIELD_RANGE(19, 20);
3676            uint32_t DestinationArrayIndex : BITFIELD_RANGE(21, 31);
3677
3678            /// DWORD 19
3679            uint32_t SourceSurfaceHeight : BITFIELD_RANGE(0, 13);
3680            uint32_t SourceSurfaceWidth : BITFIELD_RANGE(14, 27);
3681            uint32_t Reserved_636 : BITFIELD_RANGE(28, 28);
3682            uint32_t SourceSurfaceType : BITFIELD_RANGE(29, 31);
3683
3684            /// DWORD 20
3685            uint32_t SourceLOD : BITFIELD_RANGE(0, 3);
3686            uint32_t SourceSurfaceQpitch : BITFIELD_RANGE(4, 20);
3687            uint32_t SourceSurfaceDepth : BITFIELD_RANGE(21, 31);
3688
3689            /// DWORD 21
3690            uint32_t SourceHorizontalAlign : BITFIELD_RANGE(0, 1);
3691            uint32_t Reserved_674 : BITFIELD_RANGE(2, 2);
3692            uint32_t SourceVerticalAlign : BITFIELD_RANGE(3, 4);
3693            uint32_t SourceSSID : BITFIELD_RANGE(5, 7);
3694            uint32_t SourceMipTailStartLOD : BITFIELD_RANGE(8, 11);
3695            uint32_t Reserved_684 : BITFIELD_RANGE(12, 17);
3696            uint32_t SourceDepthStencilResource : BITFIELD_RANGE(18, 18);
3697            uint32_t Reserved_691 : BITFIELD_RANGE(19, 20);
3698            uint32_t SourceArrayIndex : BITFIELD_RANGE(21, 31);
3699
3700        } Common;
3701        uint32_t RawData[22];
3702    } TheStructure;
3703
3704    enum DWORD_LENGTH {
3705        DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 20,
3706    };
3707
3708    enum NUMBER_OF_MULTISAMPLES {
3709        NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_1 = 0,
3710        NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_2 = 1,
3711        NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_4 = 2,
3712        NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_8 = 3,
3713        NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_16 = 4,
3714    };
3715
3716    enum SPECIAL_MODE_OF_OPERATION {
3717        SPECIAL_MODE_OF_OPERATION_NONE = 0,
3718        SPECIAL_MODE_OF_OPERATION_FULL_RESOLVE = 1,
3719        SPECIAL_MODE_OF_OPERATION_PARTIAL_RESOLVE = 2,
3720    };
3721
3722    enum COLOR_DEPTH {
3723        COLOR_DEPTH_8_BIT_COLOR = 0,
3724        COLOR_DEPTH_16_BIT_COLOR = 1,
3725        COLOR_DEPTH_32_BIT_COLOR = 2,
3726        COLOR_DEPTH_64_BIT_COLOR = 3,
3727        COLOR_DEPTH_96_BIT_COLOR_ONLY_LINEAR_CASE_IS_SUPPORTED = 4,
3728        COLOR_DEPTH_128_BIT_COLOR = 5,
3729    };
3730
3731    enum CLIENT {
3732        CLIENT_2D_PROCESSOR = 2,
3733    };
3734
3735    enum AUXILIARY_SURFACE_MODE {
3736        AUXILIARY_SURFACE_MODE_AUX_NONE = 0,
3737        AUXILIARY_SURFACE_MODE_AUX_CCS_E = 5,
3738    };
3739
3740    enum COMPRESSION_TYPE {
3741        COMPRESSION_TYPE_3D_COMPRESSION = 0,
3742        COMPRESSION_TYPE_MEDIA_COMPRESSION = 1,
3743    };
3744
3745    enum COMPRESSION_ENABLE {
3746        COMPRESSION_ENABLE_COMPRESSION_DISABLE = 0,
3747        COMPRESSION_ENABLE_COMPRESSION_ENABLE = 1,
3748    };
3749
3750    enum TILING {
3751        TILING_LINEAR = 0,
3752        TILING_TILE4 = 2,
3753        TILING_TILE64 = 3,
3754    };
3755
3756    enum TARGET_MEMORY {
3757        TARGET_MEMORY_LOCAL_MEM = 0,
3758        TARGET_MEMORY_SYSTEM_MEM = 1,
3759    };
3760
3761    enum CLEAR_VALUE_ENABLE {
3762        CLEAR_VALUE_ENABLE_DISABLE = 0,
3763        CLEAR_VALUE_ENABLE_ENABLE = 1,
3764    };
3765
3766    enum SURFACE_TYPE {
3767        SURFACE_TYPE_SURFTYPE_1D = 0,
3768        SURFACE_TYPE_SURFTYPE_2D = 1,
3769        SURFACE_TYPE_SURFTYPE_3D = 2,
3770        SURFACE_TYPE_SURFTYPE_CUBE = 3,
3771        SURFACE_TYPE_SURFTYPE_BUFFER = 4,
3772        SURFACE_TYPE_SURFTYPE_STRBUF = 5,
3773        SURFACE_TYPE_SURFTYPE_NULL = 7,
3774    };
3775
3776    enum INSTRUCTIONTARGET_OPCODE {
3777        INSTRUCTIONTARGET_OPCODE_OPCODE = 0x41,
3778    };
3779
3780    inline void init() {
3781        memset(&TheStructure, 0, sizeof(TheStructure));
3782        TheStructure.Common.DwordLength = DWORD_LENGTH::DWORD_LENGTH_EXCLUDES_DWORD_0_1;
3783        TheStructure.Common.InstructionTarget_Opcode = INSTRUCTIONTARGET_OPCODE_OPCODE;
3784        TheStructure.Common.Client = CLIENT::CLIENT_2D_PROCESSOR;
3785    }
3786
3787    static XY_BLOCK_COPY_BLT sInit() {
3788        XY_BLOCK_COPY_BLT state;
3789        state.init();
3790        return state;
3791    }
3792
3793    inline uint32_t &getRawData(const uint32_t index) {
3794        UNRECOVERABLE_IF(index < 22);
3795        return TheStructure.RawData[index];
3796    }
3797
3798    inline void setNumberofMultisamples(const NUMBER_OF_MULTISAMPLES value) {
3799        TheStructure.Common.NumberofMultisamples = value;
3800    }
3801
3802    inline NUMBER_OF_MULTISAMPLES getNumberofMultisamples() const {
3803        return static_cast<NUMBER_OF_MULTISAMPLES>(TheStructure.Common.NumberofMultisamples);
3804    }
3805
3806    inline void setSpecialModeofOperation(const SPECIAL_MODE_OF_OPERATION value) {
3807        TheStructure.Common.SpecialModeofOperation = value;
3808    }
3809
3810    inline SPECIAL_MODE_OF_OPERATION getSpecialModeofOperation() const {
3811        return static_cast<SPECIAL_MODE_OF_OPERATION>(TheStructure.Common.SpecialModeofOperation);
3812    }
3813
3814    inline void setColorDepth(const COLOR_DEPTH value) {
3815        TheStructure.Common.ColorDepth = value;
3816    }
3817
3818    inline COLOR_DEPTH getColorDepth() const {
3819        return static_cast<COLOR_DEPTH>(TheStructure.Common.ColorDepth);
3820    }
3821
3822    inline void setInstructionTargetOpcode(const uint32_t value) {
3823        TheStructure.Common.InstructionTarget_Opcode = value;
3824    }
3825
3826    inline uint32_t getInstructionTargetOpcode() const {
3827        return (TheStructure.Common.InstructionTarget_Opcode);
3828    }
3829
3830    inline void setClient(const CLIENT value) {
3831        TheStructure.Common.Client = value;
3832    }
3833
3834    inline CLIENT getClient() const {
3835        return static_cast<CLIENT>(TheStructure.Common.Client);
3836    }
3837
3838    inline void setDestinationPitch(const uint32_t value) {
3839        TheStructure.Common.DestinationPitch = value - 1;
3840    }
3841
3842    inline uint32_t getDestinationPitch() const {
3843        return (TheStructure.Common.DestinationPitch + 1);
3844    }
3845
3846    inline void setDestinationAuxiliarysurfacemode(const AUXILIARY_SURFACE_MODE value) {
3847        TheStructure.Common.DestinationAuxiliarysurfacemode = value;
3848    }
3849
3850    inline AUXILIARY_SURFACE_MODE getDestinationAuxiliarysurfacemode() const {
3851        return static_cast<AUXILIARY_SURFACE_MODE>(TheStructure.Common.DestinationAuxiliarysurfacemode);
3852    }
3853
3854    inline void setDestinationMOCS(const uint32_t value) {
3855        TheStructure.Common.DestinationMOCS = value;
3856    }
3857
3858    inline uint32_t getDestinationMOCS() const {
3859        return (TheStructure.Common.DestinationMOCS);
3860    }
3861
3862    inline void setDestinationCompressionType(const COMPRESSION_TYPE value) {
3863        TheStructure.Common.DestinationCompressionType = value;
3864    }
3865
3866    inline COMPRESSION_TYPE getDestinationCompressionType() const {
3867        return static_cast<COMPRESSION_TYPE>(TheStructure.Common.DestinationCompressionType);
3868    }
3869
3870    inline void setDestinationCompressionEnable(const COMPRESSION_ENABLE value) {
3871        TheStructure.Common.DestinationCompressionEnable = value;
3872    }
3873
3874    inline COMPRESSION_ENABLE getDestinationCompressionEnable() const {
3875        return static_cast<COMPRESSION_ENABLE>(TheStructure.Common.DestinationCompressionEnable);
3876    }
3877
3878    inline void setDestinationTiling(const TILING value) {
3879        TheStructure.Common.DestinationTiling = value;
3880    }
3881
3882    inline TILING getDestinationTiling() const {
3883        return static_cast<TILING>(TheStructure.Common.DestinationTiling);
3884    }
3885
3886    inline void setDestinationX1CoordinateLeft(const uint32_t value) {
3887        TheStructure.Common.DestinationX1Coordinate_Left = value;
3888    }
3889
3890    inline uint32_t getDestinationX1CoordinateLeft() const {
3891        return (TheStructure.Common.DestinationX1Coordinate_Left);
3892    }
3893
3894    inline void setDestinationY1CoordinateTop(const uint32_t value) {
3895        TheStructure.Common.DestinationY1Coordinate_Top = value;
3896    }
3897
3898    inline uint32_t getDestinationY1CoordinateTop() const {
3899        return (TheStructure.Common.DestinationY1Coordinate_Top);
3900    }
3901
3902    inline void setDestinationX2CoordinateRight(const uint32_t value) {
3903        TheStructure.Common.DestinationX2Coordinate_Right = value;
3904    }
3905
3906    inline uint32_t getDestinationX2CoordinateRight() const {
3907        return (TheStructure.Common.DestinationX2Coordinate_Right);
3908    }
3909
3910    inline void setDestinationY2CoordinateBottom(const uint32_t value) {
3911        TheStructure.Common.DestinationY2Coordinate_Bottom = value;
3912    }
3913
3914    inline uint32_t getDestinationY2CoordinateBottom() const {
3915        return (TheStructure.Common.DestinationY2Coordinate_Bottom);
3916    }
3917
3918    inline void setDestinationBaseAddress(const uint64_t value) {
3919        TheStructure.Common.DestinationBaseAddress = value;
3920    }
3921
3922    inline uint64_t getDestinationBaseAddress() const {
3923        return (TheStructure.Common.DestinationBaseAddress);
3924    }
3925
3926    inline void setDestinationXoffset(const uint32_t value) {
3927        TheStructure.Common.DestinationXoffset = value;
3928    }
3929
3930    inline uint32_t getDestinationXoffset() const {
3931        return (TheStructure.Common.DestinationXoffset);
3932    }
3933
3934    inline void setDestinationYoffset(const uint32_t value) {
3935        TheStructure.Common.DestinationYoffset = value;
3936    }
3937
3938    inline uint32_t getDestinationYoffset() const {
3939        return (TheStructure.Common.DestinationYoffset);
3940    }
3941
3942    inline void setDestinationTargetMemory(const TARGET_MEMORY value) {
3943        TheStructure.Common.DestinationTargetMemory = value;
3944    }
3945
3946    inline TARGET_MEMORY getDestinationTargetMemory() const {
3947        return static_cast<TARGET_MEMORY>(TheStructure.Common.DestinationTargetMemory);
3948    }
3949
3950    inline void setSourceX1CoordinateLeft(const uint32_t value) {
3951        TheStructure.Common.SourceX1Coordinate_Left = value;
3952    }
3953
3954    inline uint32_t getSourceX1CoordinateLeft() const {
3955        return (TheStructure.Common.SourceX1Coordinate_Left);
3956    }
3957
3958    inline void setSourceY1CoordinateTop(const uint32_t value) {
3959        TheStructure.Common.SourceY1Coordinate_Top = value;
3960    }
3961
3962    inline uint32_t getSourceY1CoordinateTop() const {
3963        return (TheStructure.Common.SourceY1Coordinate_Top);
3964    }
3965
3966    inline void setSourcePitch(const uint32_t value) {
3967        TheStructure.Common.SourcePitch = value - 1;
3968    }
3969
3970    inline uint32_t getSourcePitch() const {
3971        return (TheStructure.Common.SourcePitch + 1);
3972    }
3973
3974    inline void setSourceAuxiliarysurfacemode(const AUXILIARY_SURFACE_MODE value) {
3975        TheStructure.Common.SourceAuxiliarysurfacemode = value;
3976    }
3977
3978    inline AUXILIARY_SURFACE_MODE getSourceAuxiliarysurfacemode() const {
3979        return static_cast<AUXILIARY_SURFACE_MODE>(TheStructure.Common.SourceAuxiliarysurfacemode);
3980    }
3981
3982    inline void setSourceMOCS(const uint32_t value) {
3983        TheStructure.Common.SourceMOCS = value;
3984    }
3985
3986    inline uint32_t getSourceMOCS() const {
3987        return (TheStructure.Common.SourceMOCS);
3988    }
3989
3990    inline void setSourceCompressionType(const COMPRESSION_TYPE value) {
3991        TheStructure.Common.SourceCompressionType = value;
3992    }
3993
3994    inline COMPRESSION_TYPE getSourceCompressionType() const {
3995        return static_cast<COMPRESSION_TYPE>(TheStructure.Common.SourceCompressionType);
3996    }
3997
3998    inline void setSourceCompressionEnable(const COMPRESSION_ENABLE value) {
3999        TheStructure.Common.SourceCompressionEnable = value;
4000    }
4001
4002    inline COMPRESSION_ENABLE getSourceCompressionEnable() const {
4003        return static_cast<COMPRESSION_ENABLE>(TheStructure.Common.SourceCompressionEnable);
4004    }
4005
4006    inline void setSourceTiling(const TILING value) {
4007        TheStructure.Common.SourceTiling = value;
4008    }
4009
4010    inline TILING getSourceTiling() const {
4011        return static_cast<TILING>(TheStructure.Common.SourceTiling);
4012    }
4013
4014    inline void setSourceBaseAddress(const uint64_t value) {
4015        TheStructure.Common.SourceBaseAddress = value;
4016    }
4017
4018    inline uint64_t getSourceBaseAddress() const {
4019        return (TheStructure.Common.SourceBaseAddress);
4020    }
4021
4022    inline void setSourceXoffset(const uint32_t value) {
4023        TheStructure.Common.SourceXoffset = value;
4024    }
4025
4026    inline uint32_t getSourceXoffset() const {
4027        return (TheStructure.Common.SourceXoffset);
4028    }
4029
4030    inline void setSourceYoffset(const uint32_t value) {
4031        TheStructure.Common.SourceYoffset = value;
4032    }
4033
4034    inline uint32_t getSourceYoffset() const {
4035        return (TheStructure.Common.SourceYoffset);
4036    }
4037
4038    inline void setSourceTargetMemory(const TARGET_MEMORY value) {
4039        TheStructure.Common.SourceTargetMemory = value;
4040    }
4041
4042    inline TARGET_MEMORY getSourceTargetMemory() const {
4043        return static_cast<TARGET_MEMORY>(TheStructure.Common.SourceTargetMemory);
4044    }
4045
4046    inline void setSourceCompressionFormat(const uint32_t value) {
4047        TheStructure.Common.SourceCompressionFormat = value;
4048    }
4049
4050    inline uint32_t getSourceCompressionFormat() const {
4051        return (TheStructure.Common.SourceCompressionFormat);
4052    }
4053
4054    inline void setSourceClearValueEnable(const CLEAR_VALUE_ENABLE value) {
4055        TheStructure.Common.SourceClearValueEnable = value;
4056    }
4057
4058    inline CLEAR_VALUE_ENABLE getSourceClearValueEnable() const {
4059        return static_cast<CLEAR_VALUE_ENABLE>(TheStructure.Common.SourceClearValueEnable);
4060    }
4061
4062    typedef enum tagCLEARADDRESSLOW {
4063        CLEARADDRESSLOW_BIT_SHIFT = 6,
4064        CLEARADDRESSLOW_ALIGN_SIZE = 64,
4065    } CLEARADDRESSLOW;
4066
4067    inline void setSourceClearAddressLow(const uint32_t value) {
4068        TheStructure.Common.SourceClearAddressLow = value >> CLEARADDRESSLOW_BIT_SHIFT;
4069    }
4070
4071    inline uint32_t getSourceClearAddressLow() const {
4072        return (TheStructure.Common.SourceClearAddressLow << CLEARADDRESSLOW_BIT_SHIFT);
4073    }
4074
4075    inline void setSourceClearAddressHigh(const uint32_t value) {
4076        TheStructure.Common.SourceClearAddressHigh = value;
4077    }
4078
4079    inline uint32_t getSourceClearAddressHigh() const {
4080        return (TheStructure.Common.SourceClearAddressHigh);
4081    }
4082
4083    inline void setDestinationCompressionFormat(const uint32_t value) {
4084        TheStructure.Common.DestinationCompressionFormat = value;
4085    }
4086
4087    inline uint32_t getDestinationCompressionFormat() const {
4088        return (TheStructure.Common.DestinationCompressionFormat);
4089    }
4090
4091    inline void setDestinationClearValueEnable(const CLEAR_VALUE_ENABLE value) {
4092        TheStructure.Common.DestinationClearValueEnable = value;
4093    }
4094
4095    inline CLEAR_VALUE_ENABLE getDestinationClearValueEnable() const {
4096        return static_cast<CLEAR_VALUE_ENABLE>(TheStructure.Common.DestinationClearValueEnable);
4097    }
4098
4099    inline void setDestinationClearAddressLow(const uint32_t value) {
4100        TheStructure.Common.DestinationClearAddressLow = value >> CLEARADDRESSLOW_BIT_SHIFT;
4101    }
4102
4103    inline uint32_t getDestinationClearAddressLow() const {
4104        return (TheStructure.Common.DestinationClearAddressLow << CLEARADDRESSLOW_BIT_SHIFT);
4105    }
4106
4107    inline void setDestinationClearAddressHigh(const uint32_t value) {
4108        TheStructure.Common.DestinationClearAddressHigh = value;
4109    }
4110
4111    inline uint32_t getDestinationClearAddressHigh() const {
4112        return (TheStructure.Common.DestinationClearAddressHigh);
4113    }
4114
4115    inline void setDestinationSurfaceHeight(const uint32_t value) {
4116        TheStructure.Common.DestinationSurfaceHeight = value - 1;
4117    }
4118
4119    inline uint32_t getDestinationSurfaceHeight() const {
4120        return (TheStructure.Common.DestinationSurfaceHeight + 1);
4121    }
4122
4123    inline void setDestinationSurfaceWidth(const uint32_t value) {
4124        TheStructure.Common.DestinationSurfaceWidth = value - 1;
4125    }
4126
4127    inline uint32_t getDestinationSurfaceWidth() const {
4128        return (TheStructure.Common.DestinationSurfaceWidth + 1);
4129    }
4130
4131    inline void setDestinationSurfaceType(const SURFACE_TYPE value) {
4132        TheStructure.Common.DestinationSurfaceType = value;
4133    }
4134
4135    inline SURFACE_TYPE getDestinationSurfaceType() const {
4136        return static_cast<SURFACE_TYPE>(TheStructure.Common.DestinationSurfaceType);
4137    }
4138
4139    inline void setDestinationLOD(const uint32_t value) {
4140        TheStructure.Common.DestinationLOD = value;
4141    }
4142
4143    inline uint32_t getDestinationLOD() const {
4144        return (TheStructure.Common.DestinationLOD);
4145    }
4146
4147    inline void setDestinationSurfaceQpitch(const uint32_t value) {
4148        TheStructure.Common.DestinationSurfaceQpitch = value;
4149    }
4150
4151    inline uint32_t getDestinationSurfaceQpitch() const {
4152        return (TheStructure.Common.DestinationSurfaceQpitch);
4153    }
4154
4155    inline void setDestinationSurfaceDepth(const uint32_t value) {
4156        TheStructure.Common.DestinationSurfaceDepth = value;
4157    }
4158
4159    inline uint32_t getDestinationSurfaceDepth() const {
4160        return (TheStructure.Common.DestinationSurfaceDepth);
4161    }
4162
4163    inline void setDestinationHorizontalAlign(const uint32_t value) {
4164        TheStructure.Common.DestinationHorizontalAlign = value;
4165    }
4166
4167    inline uint32_t getDestinationHorizontalAlign() const {
4168        return (TheStructure.Common.DestinationHorizontalAlign);
4169    }
4170
4171    inline void setDestinationVerticalAlign(const uint32_t value) {
4172        TheStructure.Common.DestinationVerticalAlign = value;
4173    }
4174
4175    inline uint32_t getDestinationVerticalAlign() const {
4176        return (TheStructure.Common.DestinationVerticalAlign);
4177    }
4178
4179    inline void setDestinationSSID(const uint32_t value) {
4180        TheStructure.Common.DestinationSSID = value;
4181    }
4182
4183    inline uint32_t getDestinationSSID() const {
4184        return (TheStructure.Common.DestinationSSID);
4185    }
4186
4187    inline void setDestinationMipTailStartLOD(const uint32_t value) {
4188        TheStructure.Common.DestinationMipTailStartLOD = value;
4189    }
4190
4191    inline uint32_t getDestinationMipTailStartLOD() const {
4192        return (TheStructure.Common.DestinationMipTailStartLOD);
4193    }
4194
4195    inline void setDestinationDepthStencilResource(const uint32_t value) {
4196        TheStructure.Common.DestinationDepthStencilResource = value;
4197    }
4198
4199    inline uint32_t getDestinationDepthStencilResource() const {
4200        return (TheStructure.Common.DestinationDepthStencilResource);
4201    }
4202
4203    inline void setDestinationArrayIndex(const uint32_t value) {
4204        TheStructure.Common.DestinationArrayIndex = value - 1;
4205    }
4206
4207    inline uint32_t getDestinationArrayIndex() const {
4208        return (TheStructure.Common.DestinationArrayIndex + 1);
4209    }
4210
4211    inline void setSourceSurfaceHeight(const uint32_t value) {
4212        TheStructure.Common.SourceSurfaceHeight = value - 1;
4213    }
4214
4215    inline uint32_t getSourceSurfaceHeight() const {
4216        return (TheStructure.Common.SourceSurfaceHeight + 1);
4217    }
4218
4219    inline void setSourceSurfaceWidth(const uint32_t value) {
4220        TheStructure.Common.SourceSurfaceWidth = value - 1;
4221    }
4222
4223    inline uint32_t getSourceSurfaceWidth() const {
4224        return (TheStructure.Common.SourceSurfaceWidth + 1);
4225    }
4226
4227    inline void setSourceSurfaceType(const SURFACE_TYPE value) {
4228        TheStructure.Common.SourceSurfaceType = value;
4229    }
4230
4231    inline SURFACE_TYPE getSourceSurfaceType() const {
4232        return static_cast<SURFACE_TYPE>(TheStructure.Common.SourceSurfaceType);
4233    }
4234
4235    inline void setSourceLOD(const uint32_t value) {
4236        TheStructure.Common.SourceLOD = value;
4237    }
4238
4239    inline uint32_t getSourceLOD() const {
4240        return (TheStructure.Common.SourceLOD);
4241    }
4242
4243    inline void setSourceSurfaceQpitch(const uint32_t value) {
4244        TheStructure.Common.SourceSurfaceQpitch = value;
4245    }
4246
4247    inline uint32_t getSourceSurfaceQpitch() const {
4248        return (TheStructure.Common.SourceSurfaceQpitch);
4249    }
4250
4251    inline void setSourceSurfaceDepth(const uint32_t value) {
4252        TheStructure.Common.SourceSurfaceDepth = value - 1;
4253    }
4254
4255    inline uint32_t getSourceSurfaceDepth() const {
4256        return (TheStructure.Common.SourceSurfaceDepth + 1);
4257    }
4258
4259    inline void setSourceHorizontalAlign(const uint32_t value) {
4260        TheStructure.Common.SourceHorizontalAlign = value;
4261    }
4262
4263    inline uint32_t getSourceHorizontalAlign() const {
4264        return (TheStructure.Common.SourceHorizontalAlign);
4265    }
4266
4267    inline void setSourceVerticalAlign(const uint32_t value) {
4268        TheStructure.Common.SourceVerticalAlign = value;
4269    }
4270
4271    inline uint32_t getSourceVerticalAlign() const {
4272        return (TheStructure.Common.SourceVerticalAlign);
4273    }
4274
4275    inline void setSourceSSID(const uint32_t value) {
4276        TheStructure.Common.SourceSSID = value;
4277    }
4278
4279    inline uint32_t getSourceSSID() const {
4280        return (TheStructure.Common.SourceSSID);
4281    }
4282
4283    inline void setSourceMipTailStartLOD(const uint32_t value) {
4284        TheStructure.Common.SourceMipTailStartLOD = value;
4285    }
4286
4287    inline uint32_t getSourceMipTailStartLOD() const {
4288        return (TheStructure.Common.SourceMipTailStartLOD);
4289    }
4290
4291    inline void setSourceDepthStencilResource(const uint32_t value) {
4292        TheStructure.Common.SourceDepthStencilResource = value;
4293    }
4294
4295    inline uint32_t getSourceDepthStencilResource() const {
4296        return (TheStructure.Common.SourceDepthStencilResource);
4297    }
4298
4299    inline void setSourceArrayIndex(const uint32_t value) {
4300        TheStructure.Common.SourceArrayIndex = value - 1;
4301    }
4302
4303    inline uint32_t getSourceArrayIndex() const {
4304        return (TheStructure.Common.SourceArrayIndex + 1);
4305    }
4306};
4307STATIC_ASSERT(88 == sizeof(XY_BLOCK_COPY_BLT));
4308
4309struct XY_FAST_COLOR_BLT {
4310    union tagTheStructure {
4311        struct tagCommon {
4312            /// DWORD 0
4313            uint32_t DwordLength : BITFIELD_RANGE(0, 7);
4314            uint32_t Reserved_8 : BITFIELD_RANGE(8, 8);
4315            uint32_t NumberofMultisamples : BITFIELD_RANGE(9, 11);
4316            uint32_t SpecialModeofOperation : BITFIELD_RANGE(12, 13);
4317            uint32_t Reserved_14 : BITFIELD_RANGE(14, 18);
4318            uint32_t ColorDepth : BITFIELD_RANGE(19, 21);
4319            uint32_t InstructionTarget_Opcode : BITFIELD_RANGE(22, 28);
4320            uint32_t Client : BITFIELD_RANGE(29, 31);
4321
4322            /// DWORD 1
4323            uint32_t DestinationPitch : BITFIELD_RANGE(0, 17);
4324            uint32_t DestinationAuxiliarysurfacemode : BITFIELD_RANGE(18, 20);
4325            uint32_t DestinationMOCS : BITFIELD_RANGE(21, 27);
4326            uint32_t DestinationCompressionType : BITFIELD_RANGE(28, 28);
4327            uint32_t DestinationCompressionEnable : BITFIELD_RANGE(29, 29);
4328            uint32_t DestinationTiling : BITFIELD_RANGE(30, 31);
4329
4330            /// DWORD 2
4331            uint32_t DestinationX1Coordinate_Left : BITFIELD_RANGE(0, 15);
4332            uint32_t DestinationY1Coordinate_Top : BITFIELD_RANGE(16, 31);
4333
4334            /// DWORD 3
4335            uint32_t DestinationX2Coordinate_Right : BITFIELD_RANGE(0, 15);
4336            uint32_t DestinationY2Coordinate_Bottom : BITFIELD_RANGE(16, 31);
4337
4338            /// DWORD 4..5
4339            uint64_t DestinationBaseAddress;
4340
4341            /// DWORD 6
4342            uint32_t DestinationXoffset : BITFIELD_RANGE(0, 13);
4343            uint32_t Reserved_206 : BITFIELD_RANGE(14, 15);
4344            uint32_t DestinationYoffset : BITFIELD_RANGE(16, 29);
4345            uint32_t Reserved_222 : BITFIELD_RANGE(30, 30);
4346            uint32_t DestinationTargetMemory : BITFIELD_RANGE(31, 31);
4347
4348            /// DWORD 7 - 10
4349            uint32_t FillColor[4];
4350
4351            // DWORD 11
4352            uint32_t DestinationCompressionFormat : BITFIELD_RANGE(0, 4);
4353            uint32_t DestinationClearValueEnable : BITFIELD_RANGE(5, 5);
4354            uint32_t DestinationClearAddressLow : BITFIELD_RANGE(6, 31);
4355
4356            // DWORD 12
4357            uint32_t DestinationClearAddressHigh : BITFIELD_RANGE(0, 24);
4358            uint32_t Reserved1 : BITFIELD_RANGE(25, 31);
4359
4360            // DWORD 13
4361            uint32_t DestinationSurfaceHeight : BITFIELD_RANGE(0, 13);
4362            uint32_t DestinationSurfaceWidth : BITFIELD_RANGE(14, 27);
4363            uint32_t Reserved2 : BITFIELD_RANGE(28, 28);
4364            uint32_t DestinationSurfaceType : BITFIELD_RANGE(29, 31);
4365
4366            // DWORD 14
4367            uint32_t DestinationLOD : BITFIELD_RANGE(0, 3);
4368            uint32_t DestinationSurfaceQpitch : BITFIELD_RANGE(4, 18);
4369            uint32_t Reserved3 : BITFIELD_RANGE(19, 20);
4370            uint32_t DestinationSurfaceDepth : BITFIELD_RANGE(21, 31);
4371
4372            // DWORD 15
4373            uint32_t DestinationHorizontalAlign : BITFIELD_RANGE(0, 1);
4374            uint32_t Reserved4 : BITFIELD_RANGE(2, 2);
4375            uint32_t DestinationVerticalAlign : BITFIELD_RANGE(3, 4);
4376            uint32_t Reserved5 : BITFIELD_RANGE(5, 7);
4377            uint32_t DestinationMipTailStartLOD : BITFIELD_RANGE(8, 11);
4378            uint32_t Reserved6 : BITFIELD_RANGE(12, 17);
4379            uint32_t DestinationDepthStencilResource : BITFIELD_RANGE(18, 18);
4380            uint32_t Reserved7 : BITFIELD_RANGE(19, 20);
4381            uint32_t DestinationArrayIndex : BITFIELD_RANGE(21, 31);
4382        } Common;
4383        uint32_t RawData[15];
4384    } TheStructure;
4385
4386    enum DWORD_LENGTH {
4387        DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0xE,
4388    };
4389
4390    enum NUMBER_OF_MULTISAMPLES {
4391        NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_1 = 0,
4392        NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_2 = 1,
4393        NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_4 = 2,
4394        NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_8 = 3,
4395        NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_16 = 4,
4396    };
4397
4398    enum SPECIAL_MODE_OF_OPERATION {
4399        SPECIAL_MODE_OF_OPERATION_NONE = 0,
4400        SPECIAL_MODE_OF_OPERATION_FULL_RESOLVE = 1,
4401        SPECIAL_MODE_OF_OPERATION_PARTIAL_RESOLVE = 2,
4402    };
4403
4404    enum COLOR_DEPTH {
4405        COLOR_DEPTH_8_BIT_COLOR = 0,
4406        COLOR_DEPTH_16_BIT_COLOR = 1,
4407        COLOR_DEPTH_32_BIT_COLOR = 2,
4408        COLOR_DEPTH_64_BIT_COLOR = 3,
4409        COLOR_DEPTH_96_BIT_COLOR_ONLY_LINEAR_CASE_IS_SUPPORTED = 4,
4410        COLOR_DEPTH_128_BIT_COLOR = 5,
4411    };
4412
4413    enum CLIENT {
4414        CLIENT_2D_PROCESSOR = 2,
4415    };
4416
4417    enum DESTINATION_AUXILIARY_SURFACE_MODE {
4418        DESTINATION_AUXILIARY_SURFACE_MODE_AUX_NONE = 0,
4419        DESTINATION_AUXILIARY_SURFACE_MODE_AUX_CCS_E = 5,
4420    };
4421
4422    enum DESTINATION_CLEAR_VALUE_ENABLE {
4423        DESTINATION_CLEAR_VALUE_ENABLE_DISABLE = 0,
4424        DESTINATION_CLEAR_VALUE_ENABLE_ENABLE = 1,
4425    };
4426
4427    enum DESTINATION_COMPRESSION_TYPE {
4428        DESTINATION_COMPRESSION_TYPE_3D_COMPRESSION = 0,
4429        DESTINATION_COMPRESSION_TYPE_MEDIA_COMPRESSION = 1,
4430    };
4431
4432    enum DESTINATION_COMPRESSION_ENABLE {
4433        DESTINATION_COMPRESSION_ENABLE_COMPRESSION_DISABLE = 0,
4434        DESTINATION_COMPRESSION_ENABLE_COMPRESSION_ENABLE = 1,
4435    };
4436
4437    enum DESTINATION_TILING {
4438        DESTINATION_TILING_LINEAR = 0,
4439        DESTINATION_TILING_TILE4 = 2,
4440        DESTINATION_TILING_TILE64 = 3,
4441    };
4442
4443    enum DESTINATION_TARGET_MEMORY {
4444        DESTINATION_TARGET_MEMORY_LOCAL_MEM = 0,
4445        DESTINATION_TARGET_MEMORY_SYSTEM_MEM = 1,
4446    };
4447
4448    enum DESTINATION_SURFACE_TYPE {
4449        DESTINATION_SURFACE_TYPE_1D = 0,
4450        DESTINATION_SURFACE_TYPE_2D = 1,
4451        DESTINATION_SURFACE_TYPE_3D = 2,
4452        DESTINATION_SURFACE_TYPE_CUBE = 3,
4453    };
4454    enum INSTRUCTIONTARGET_OPCODE {
4455        INSTRUCTIONTARGET_OPCODE_OPCODE = 0x44,
4456    };
4457
4458    inline void init() {
4459        memset(&TheStructure, 0, sizeof(TheStructure));
4460        TheStructure.Common.DwordLength = DWORD_LENGTH::DWORD_LENGTH_EXCLUDES_DWORD_0_1;
4461        TheStructure.Common.InstructionTarget_Opcode = INSTRUCTIONTARGET_OPCODE::INSTRUCTIONTARGET_OPCODE_OPCODE;
4462        TheStructure.Common.Client = CLIENT::CLIENT_2D_PROCESSOR;
4463    }
4464
4465    static XY_FAST_COLOR_BLT sInit() {
4466        XY_FAST_COLOR_BLT state;
4467        state.init();
4468        return state;
4469    }
4470
4471    inline uint32_t &getRawData(const uint32_t index) {
4472        UNRECOVERABLE_IF(index < 22);
4473        return TheStructure.RawData[index];
4474    }
4475
4476    inline void setNumberofMultisamples(const NUMBER_OF_MULTISAMPLES value) {
4477        TheStructure.Common.NumberofMultisamples = value;
4478    }
4479
4480    inline NUMBER_OF_MULTISAMPLES getNumberofMultisamples() const {
4481        return static_cast<NUMBER_OF_MULTISAMPLES>(TheStructure.Common.NumberofMultisamples);
4482    }
4483
4484    inline void setSpecialModeofOperation(const SPECIAL_MODE_OF_OPERATION value) {
4485        TheStructure.Common.SpecialModeofOperation = value;
4486    }
4487
4488    inline SPECIAL_MODE_OF_OPERATION getSpecialModeofOperation() const {
4489        return static_cast<SPECIAL_MODE_OF_OPERATION>(TheStructure.Common.SpecialModeofOperation);
4490    }
4491
4492    inline void setColorDepth(const COLOR_DEPTH value) {
4493        TheStructure.Common.ColorDepth = value;
4494    }
4495
4496    inline COLOR_DEPTH getColorDepth() const {
4497        return static_cast<COLOR_DEPTH>(TheStructure.Common.ColorDepth);
4498    }
4499
4500    inline void setInstructionTargetOpcode(const uint32_t value) {
4501        TheStructure.Common.InstructionTarget_Opcode = value;
4502    }
4503
4504    inline uint32_t getInstructionTargetOpcode() const {
4505        return (TheStructure.Common.InstructionTarget_Opcode);
4506    }
4507
4508    inline void setClient(const CLIENT value) {
4509        TheStructure.Common.Client = value;
4510    }
4511
4512    inline CLIENT getClient() const {
4513        return static_cast<CLIENT>(TheStructure.Common.Client);
4514    }
4515
4516    inline void setDestinationPitch(const uint32_t value) {
4517        TheStructure.Common.DestinationPitch = value - 1;
4518    }
4519
4520    inline uint32_t getDestinationPitch() const {
4521        return (TheStructure.Common.DestinationPitch + 1);
4522    }
4523
4524    inline void setDestinationAuxiliarysurfacemode(const DESTINATION_AUXILIARY_SURFACE_MODE value) {
4525        TheStructure.Common.DestinationAuxiliarysurfacemode = value;
4526    }
4527
4528    inline DESTINATION_AUXILIARY_SURFACE_MODE getDestinationAuxiliarysurfacemode() const {
4529        return static_cast<DESTINATION_AUXILIARY_SURFACE_MODE>(TheStructure.Common.DestinationAuxiliarysurfacemode);
4530    }
4531
4532    inline void setDestinationMOCS(const uint32_t value) {
4533        TheStructure.Common.DestinationMOCS = value;
4534    }
4535
4536    inline uint32_t getDestinationMOCS() const {
4537        return (TheStructure.Common.DestinationMOCS);
4538    }
4539
4540    inline void setDestinationCompressionType(const DESTINATION_COMPRESSION_TYPE value) {
4541        TheStructure.Common.DestinationCompressionType = value;
4542    }
4543
4544    inline DESTINATION_COMPRESSION_TYPE getDestinationCompressionType() const {
4545        return static_cast<DESTINATION_COMPRESSION_TYPE>(TheStructure.Common.DestinationCompressionType);
4546    }
4547
4548    inline void setDestinationCompressionEnable(const DESTINATION_COMPRESSION_ENABLE value) {
4549        TheStructure.Common.DestinationCompressionEnable = value;
4550    }
4551
4552    inline DESTINATION_COMPRESSION_ENABLE getDestinationCompressionEnable() const {
4553        return static_cast<DESTINATION_COMPRESSION_ENABLE>(TheStructure.Common.DestinationCompressionEnable);
4554    }
4555
4556    inline void setDestinationTiling(const DESTINATION_TILING value) {
4557        TheStructure.Common.DestinationTiling = value;
4558    }
4559
4560    inline DESTINATION_TILING getDestinationTiling() const {
4561        return static_cast<DESTINATION_TILING>(TheStructure.Common.DestinationTiling);
4562    }
4563
4564    inline void setDestinationX1CoordinateLeft(const uint32_t value) {
4565        TheStructure.Common.DestinationX1Coordinate_Left = value;
4566    }
4567
4568    inline uint32_t getDestinationX1CoordinateLeft() const {
4569        return (TheStructure.Common.DestinationX1Coordinate_Left);
4570    }
4571
4572    inline void setDestinationY1CoordinateTop(const uint32_t value) {
4573        TheStructure.Common.DestinationY1Coordinate_Top = value;
4574    }
4575
4576    inline uint32_t getDestinationY1CoordinateTop() const {
4577        return (TheStructure.Common.DestinationY1Coordinate_Top);
4578    }
4579
4580    inline void setDestinationX2CoordinateRight(const uint32_t value) {
4581        TheStructure.Common.DestinationX2Coordinate_Right = value;
4582    }
4583
4584    inline uint32_t getDestinationX2CoordinateRight() const {
4585        return (TheStructure.Common.DestinationX2Coordinate_Right);
4586    }
4587
4588    inline void setDestinationY2CoordinateBottom(const uint32_t value) {
4589        TheStructure.Common.DestinationY2Coordinate_Bottom = value;
4590    }
4591
4592    inline uint32_t getDestinationY2CoordinateBottom() const {
4593        return (TheStructure.Common.DestinationY2Coordinate_Bottom);
4594    }
4595
4596    inline void setDestinationBaseAddress(const uint64_t value) {
4597        TheStructure.Common.DestinationBaseAddress = value;
4598    }
4599
4600    inline uint64_t getDestinationBaseAddress() const {
4601        return (TheStructure.Common.DestinationBaseAddress);
4602    }
4603
4604    inline void setDestinationXoffset(const uint32_t value) {
4605        TheStructure.Common.DestinationXoffset = value;
4606    }
4607
4608    inline uint32_t getDestinationXoffset() const {
4609        return (TheStructure.Common.DestinationXoffset);
4610    }
4611
4612    inline void setDestinationYoffset(const uint32_t value) {
4613        TheStructure.Common.DestinationYoffset = value;
4614    }
4615
4616    inline uint32_t getDestinationYoffset() const {
4617        return (TheStructure.Common.DestinationYoffset);
4618    }
4619
4620    inline void setDestinationTargetMemory(const DESTINATION_TARGET_MEMORY value) {
4621        TheStructure.Common.DestinationTargetMemory = value;
4622    }
4623
4624    inline DESTINATION_TARGET_MEMORY getDestinationTargetMemory() const {
4625        return static_cast<DESTINATION_TARGET_MEMORY>(TheStructure.Common.DestinationTargetMemory);
4626    }
4627
4628    inline void setFillColor(const uint32_t *value) {
4629        TheStructure.Common.FillColor[0] = value[0];
4630        TheStructure.Common.FillColor[1] = value[1];
4631        TheStructure.Common.FillColor[2] = value[2];
4632        TheStructure.Common.FillColor[3] = value[3];
4633    }
4634
4635    inline void setDestinationCompressionFormat(const uint32_t value) {
4636        TheStructure.Common.DestinationCompressionFormat = value;
4637    }
4638
4639    inline uint32_t getDestinationCompressionFormat() const {
4640        return (TheStructure.Common.DestinationCompressionFormat);
4641    }
4642
4643    inline void setDestinationClearValueEnable(const DESTINATION_CLEAR_VALUE_ENABLE value) {
4644        TheStructure.Common.DestinationClearValueEnable = value;
4645    }
4646
4647    inline DESTINATION_CLEAR_VALUE_ENABLE getDestinationClearValueEnable() const {
4648        return static_cast<DESTINATION_CLEAR_VALUE_ENABLE>(TheStructure.Common.DestinationClearValueEnable);
4649    }
4650
4651    typedef enum tagDESTINATIONCLEARADDRESSLOW {
4652        DESTINATIONCLEARADDRESSLOW_BIT_SHIFT = 6,
4653        DESTINATIONCLEARADDRESSLOW_ALIGN_SIZE = 64,
4654    } DESTINATIONCLEARADDRESSLOW;
4655
4656    inline void setDestinationClearAddressLow(const uint32_t value) {
4657        TheStructure.Common.DestinationClearAddressLow = value >> DESTINATIONCLEARADDRESSLOW_BIT_SHIFT;
4658    }
4659
4660    inline uint32_t getDestinationClearAddressLow() const {
4661        return (TheStructure.Common.DestinationClearAddressLow << DESTINATIONCLEARADDRESSLOW_BIT_SHIFT);
4662    }
4663
4664    inline void setDestinationClearAddressHigh(const uint32_t value) {
4665        TheStructure.Common.DestinationClearAddressHigh = value;
4666    }
4667
4668    inline uint32_t getDestinationClearAddressHigh() const {
4669        return (TheStructure.Common.DestinationClearAddressHigh);
4670    }
4671
4672    inline void setDestinationSurfaceHeight(const uint32_t value) {
4673        TheStructure.Common.DestinationSurfaceHeight = value - 1;
4674    }
4675
4676    inline uint32_t getDestinationSurfaceHeight() const {
4677        return (TheStructure.Common.DestinationSurfaceHeight + 1);
4678    }
4679
4680    inline void setDestinationSurfaceWidth(const uint32_t value) {
4681        TheStructure.Common.DestinationSurfaceWidth = value - 1;
4682    }
4683
4684    inline uint32_t getDestinationSurfaceWidth() const {
4685        return (TheStructure.Common.DestinationSurfaceWidth + 1);
4686    }
4687
4688    inline void setDestinationSurfaceType(const DESTINATION_SURFACE_TYPE value) {
4689        TheStructure.Common.DestinationSurfaceType = value;
4690    }
4691
4692    inline DESTINATION_SURFACE_TYPE getDestinationSurfaceType() const {
4693        return static_cast<DESTINATION_SURFACE_TYPE>(TheStructure.Common.DestinationSurfaceType);
4694    }
4695
4696    inline void setDestinationLOD(const uint32_t value) {
4697        TheStructure.Common.DestinationLOD = value;
4698    }
4699
4700    inline uint32_t getDestinationLOD() const {
4701        return (TheStructure.Common.DestinationLOD);
4702    }
4703
4704    inline void setDestinationSurfaceQpitch(const uint32_t value) {
4705        TheStructure.Common.DestinationSurfaceQpitch = value;
4706    }
4707
4708    inline uint32_t getDestinationSurfaceQpitch() const {
4709        return (TheStructure.Common.DestinationSurfaceQpitch);
4710    }
4711
4712    inline void setDestinationSurfaceDepth(const uint32_t value) {
4713        TheStructure.Common.DestinationSurfaceDepth = value;
4714    }
4715
4716    inline uint32_t getDestinationSurfaceDepth() const {
4717        return (TheStructure.Common.DestinationSurfaceDepth);
4718    }
4719
4720    inline void setDestinationHorizontalAlign(const uint32_t value) {
4721        TheStructure.Common.DestinationHorizontalAlign = value;
4722    }
4723
4724    inline uint32_t getDestinationHorizontalAlign() const {
4725        return (TheStructure.Common.DestinationHorizontalAlign);
4726    }
4727
4728    inline void setDestinationVerticalAlign(const uint32_t value) {
4729        TheStructure.Common.DestinationVerticalAlign = value;
4730    }
4731
4732    inline uint32_t getDestinationVerticalAlign() const {
4733        return (TheStructure.Common.DestinationVerticalAlign);
4734    }
4735
4736    inline void setDestinationMipTailStartLOD(const uint32_t value) {
4737        TheStructure.Common.DestinationMipTailStartLOD = value;
4738    }
4739
4740    inline uint32_t getDestinationMipTailStartLOD() const {
4741        return (TheStructure.Common.DestinationMipTailStartLOD);
4742    }
4743
4744    inline void setDestinationDepthStencilResource(const uint32_t value) {
4745        TheStructure.Common.DestinationDepthStencilResource = value;
4746    }
4747
4748    inline uint32_t getDestinationDepthStencilResource() const {
4749        return (TheStructure.Common.DestinationDepthStencilResource);
4750    }
4751
4752    inline void setDestinationArrayIndex(const uint32_t value) {
4753        TheStructure.Common.DestinationArrayIndex = value - 1;
4754    }
4755
4756    inline uint32_t getDestinationArrayIndex() const {
4757        return (TheStructure.Common.DestinationArrayIndex + 1);
4758    }
4759};
4760STATIC_ASSERT(64 == sizeof(XY_FAST_COLOR_BLT));
4761
4762struct MI_FLUSH_DW {
4763    union tagData {
4764        struct tagCommon {
4765            /// DWORD 0
4766            uint32_t DwordLength : BITFIELD_RANGE(0, 5);
4767            uint32_t Reserved_6 : BITFIELD_RANGE(6, 7);
4768            uint32_t NotifyEnable : BITFIELD_RANGE(8, 8);
4769            uint32_t FlushLlc : BITFIELD_RANGE(9, 9);
4770            uint32_t Reserved_10 : BITFIELD_RANGE(10, 13);
4771            uint32_t PostSyncOperation : BITFIELD_RANGE(14, 15);
4772            uint32_t FlushCcs : BITFIELD_RANGE(16, 16);
4773            uint32_t Reserved_17 : BITFIELD_RANGE(17, 17);
4774            uint32_t TlbInvalidate : BITFIELD_RANGE(18, 18);
4775            uint32_t Reserved_19 : BITFIELD_RANGE(19, 20);
4776            uint32_t StoreDataIndex : BITFIELD_RANGE(21, 21);
4777            uint32_t Reserved_22 : BITFIELD_RANGE(22, 22);
4778            uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28);
4779            uint32_t CommandType : BITFIELD_RANGE(29, 31);
4780
4781            /// DWORD 1..2
4782            uint64_t Reserved_32 : BITFIELD_RANGE(0, 1);
4783            uint64_t DestinationAddress : BITFIELD_RANGE(2, 47);
4784            uint64_t Reserved_80 : BITFIELD_RANGE(48, 63);
4785
4786            /// DWORD 3..4
4787            uint64_t ImmediateData;
4788
4789        } Common;
4790        uint32_t RawData[5];
4791    } TheStructure;
4792
4793    enum DWORD_LENGTH {
4794        DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 3,
4795    };
4796
4797    enum POST_SYNC_OPERATION {
4798        POST_SYNC_OPERATION_NO_WRITE = 0,
4799        POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA_QWORD = 1,
4800        POST_SYNC_OPERATION_WRITE_TIMESTAMP_REGISTER = 3,
4801    };
4802
4803    enum MI_COMMAND_OPCODE {
4804        MI_COMMAND_OPCODE_MI_FLUSH_DW = 38,
4805    };
4806
4807    enum COMMAND_TYPE {
4808        COMMAND_TYPE_MI_COMMAND = 0,
4809    };
4810
4811    inline void init() {
4812        memset(&TheStructure, 0, sizeof(TheStructure));
4813        TheStructure.Common.DwordLength = DWORD_LENGTH::DWORD_LENGTH_EXCLUDES_DWORD_0_1;
4814        TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE::MI_COMMAND_OPCODE_MI_FLUSH_DW;
4815    }
4816
4817    static MI_FLUSH_DW sInit() {
4818        MI_FLUSH_DW state;
4819        state.init();
4820        return state;
4821    }
4822
4823    inline uint32_t &getRawData(const uint32_t index) {
4824        UNRECOVERABLE_IF(index < 5);
4825        return TheStructure.RawData[index];
4826    }
4827
4828    inline void setNotifyEnable(const uint32_t value) {
4829        TheStructure.Common.NotifyEnable = value;
4830    }
4831
4832    inline uint32_t getNotifyEnable() const {
4833        return (TheStructure.Common.NotifyEnable);
4834    }
4835
4836    inline void setFlushLlc(const uint32_t value) {
4837        TheStructure.Common.FlushLlc = value;
4838    }
4839
4840    inline uint32_t getFlushLlc() const {
4841        return (TheStructure.Common.FlushLlc);
4842    }
4843
4844    inline void setFlushCcs(const uint32_t value) {
4845        TheStructure.Common.FlushCcs = value;
4846    }
4847
4848    inline uint32_t getFlushCcs() const {
4849        return (TheStructure.Common.FlushCcs);
4850    }
4851
4852    inline void setPostSyncOperation(const POST_SYNC_OPERATION value) {
4853        TheStructure.Common.PostSyncOperation = value;
4854    }
4855
4856    inline POST_SYNC_OPERATION getPostSyncOperation() const {
4857        return static_cast<POST_SYNC_OPERATION>(TheStructure.Common.PostSyncOperation);
4858    }
4859
4860    inline void setTlbInvalidate(const uint32_t value) {
4861        TheStructure.Common.TlbInvalidate = value;
4862    }
4863
4864    inline uint32_t getTlbInvalidate() const {
4865        return (TheStructure.Common.TlbInvalidate);
4866    }
4867
4868    inline void setStoreDataIndex(const uint32_t value) {
4869        TheStructure.Common.StoreDataIndex = value;
4870    }
4871
4872    inline uint32_t getStoreDataIndex() const {
4873        return (TheStructure.Common.StoreDataIndex);
4874    }
4875
4876    typedef enum tagDESTINATIONADDRESS {
4877        DESTINATIONADDRESS_BIT_SHIFT = 2,
4878        DESTINATIONADDRESS_ALIGN_SIZE = 4,
4879    } DESTINATIONADDRESS;
4880
4881    inline void setDestinationAddress(const uint64_t value) {
4882        TheStructure.Common.DestinationAddress = value >> DESTINATIONADDRESS_BIT_SHIFT;
4883    }
4884
4885    inline uint64_t getDestinationAddress() const {
4886        return (TheStructure.Common.DestinationAddress << DESTINATIONADDRESS_BIT_SHIFT);
4887    }
4888
4889    inline void setImmediateData(const uint64_t value) {
4890        TheStructure.Common.ImmediateData = value;
4891    }
4892
4893    inline uint64_t getImmediateData() const {
4894        return (TheStructure.Common.ImmediateData);
4895    }
4896};
4897STATIC_ASSERT(20 == sizeof(MI_FLUSH_DW));
4898
4899typedef struct tag_3DSTATE_BTD_BODY {
4900    union tagTheStructure {
4901        struct tagCommon {
4902            // DWORD 0
4903            uint32_t DispatchTimeoutCounter : BITFIELD_RANGE(0, 1);
4904            uint32_t Reserved_2 : BITFIELD_RANGE(2, 2);
4905            uint32_t AmfsMode : BITFIELD_RANGE(3, 4);
4906            uint32_t Reserved_5 : BITFIELD_RANGE(5, 31);
4907            // DWORD 1
4908            uint64_t PerDssMemoryBackedBufferSize : BITFIELD_RANGE(0, 2);
4909            uint64_t Reserved_35 : BITFIELD_RANGE(3, 9);
4910            uint64_t MemoryBackedBufferBasePointer : BITFIELD_RANGE(10, 63);
4911            // DWORD 3
4912            uint64_t PerThreadScratchSpace : BITFIELD_RANGE(0, 3);
4913            uint64_t Reserved_100 : BITFIELD_RANGE(4, 9);
4914            uint64_t BtdScratchSpaceBasePointer : BITFIELD_RANGE(10, 31);
4915            // DWORD 4
4916            uint64_t Reserved_128 : BITFIELD_RANGE(32, 63);
4917        } Common;
4918        uint32_t RawData[5];
4919    } TheStructure;
4920    typedef enum tagAMFS_MODE {
4921        AMFS_MODE_NORMAL_MODE = 0x0,
4922        AMFS_MODE_TOUCH_MODE = 0x1,
4923        AMFS_MODE_BACKFILL_MODE = 0x2,
4924        AMFS_MODE_FALLBACK_MODE = 0x3,
4925    } AMFS_MODE;
4926    typedef enum tagPER_DSS_MEMORY_BACKED_BUFFER_SIZE {
4927        PER_DSS_MEMORY_BACKED_BUFFER_SIZE_2KB = 0x0,
4928        PER_DSS_MEMORY_BACKED_BUFFER_SIZE_4KB = 0x1,
4929        PER_DSS_MEMORY_BACKED_BUFFER_SIZE_8KB = 0x2,
4930        PER_DSS_MEMORY_BACKED_BUFFER_SIZE_16KB = 0x3,
4931        PER_DSS_MEMORY_BACKED_BUFFER_SIZE_32KB = 0x4,
4932        PER_DSS_MEMORY_BACKED_BUFFER_SIZE_64KB = 0x5,
4933        PER_DSS_MEMORY_BACKED_BUFFER_SIZE_128KB = 0x6,
4934    } PER_DSS_MEMORY_BACKED_BUFFER_SIZE;
4935    inline void init() {
4936        memset(&TheStructure, 0, sizeof(TheStructure));
4937        TheStructure.Common.AmfsMode = AMFS_MODE_NORMAL_MODE;
4938        TheStructure.Common.PerDssMemoryBackedBufferSize = PER_DSS_MEMORY_BACKED_BUFFER_SIZE_128KB;
4939    }
4940    static tag_3DSTATE_BTD_BODY sInit() {
4941        _3DSTATE_BTD_BODY state;
4942        state.init();
4943        return state;
4944    }
4945    inline uint32_t &getRawData(const uint32_t index) {
4946        UNRECOVERABLE_IF(index >= 5);
4947        return TheStructure.RawData[index];
4948    }
4949    inline void setDispatchTimeoutCounter(const uint32_t value) {
4950        UNRECOVERABLE_IF(value > 0x3);
4951        TheStructure.Common.DispatchTimeoutCounter = value;
4952    }
4953    inline uint32_t getDispatchTimeoutCounter() const {
4954        return TheStructure.Common.DispatchTimeoutCounter;
4955    }
4956    inline void setAmfsMode(const AMFS_MODE value) {
4957        TheStructure.Common.AmfsMode = value;
4958    }
4959    inline AMFS_MODE getAmfsMode() const {
4960        return static_cast<AMFS_MODE>(TheStructure.Common.AmfsMode);
4961    }
4962    inline void setPerDssMemoryBackedBufferSize(const PER_DSS_MEMORY_BACKED_BUFFER_SIZE value) {
4963        TheStructure.Common.PerDssMemoryBackedBufferSize = value;
4964    }
4965    inline PER_DSS_MEMORY_BACKED_BUFFER_SIZE getPerDssMemoryBackedBufferSize() const {
4966        return static_cast<PER_DSS_MEMORY_BACKED_BUFFER_SIZE>(TheStructure.Common.PerDssMemoryBackedBufferSize);
4967    }
4968    typedef enum tagMEMORYBACKEDBUFFERBASEPOINTER {
4969        MEMORYBACKEDBUFFERBASEPOINTER_BIT_SHIFT = 0xa,
4970        MEMORYBACKEDBUFFERBASEPOINTER_ALIGN_SIZE = 0x400,
4971    } MEMORYBACKEDBUFFERBASEPOINTER;
4972    inline void setMemoryBackedBufferBasePointer(const uint64_t value) {
4973        UNRECOVERABLE_IF(value > 0xffffffffffffffffL);
4974        TheStructure.Common.MemoryBackedBufferBasePointer = value >> MEMORYBACKEDBUFFERBASEPOINTER_BIT_SHIFT;
4975    }
4976    inline uint64_t getMemoryBackedBufferBasePointer() const {
4977        return TheStructure.Common.MemoryBackedBufferBasePointer << MEMORYBACKEDBUFFERBASEPOINTER_BIT_SHIFT;
4978    }
4979    inline void setPerThreadScratchSpace(const uint64_t value) {
4980        UNRECOVERABLE_IF(value > 0xfL);
4981        TheStructure.Common.PerThreadScratchSpace = value;
4982    }
4983    inline uint64_t getPerThreadScratchSpace() const {
4984        return TheStructure.Common.PerThreadScratchSpace;
4985    }
4986    typedef enum tagBTDSCRATCHSPACEBASEPOINTER {
4987        BTDSCRATCHSPACEBASEPOINTER_BIT_SHIFT = 0xa,
4988        BTDSCRATCHSPACEBASEPOINTER_ALIGN_SIZE = 0x400,
4989    } BTDSCRATCHSPACEBASEPOINTER;
4990    inline void setBtdScratchSpaceBasePointer(const uint64_t value) {
4991        UNRECOVERABLE_IF(value > 0xffffffffL);
4992        TheStructure.Common.BtdScratchSpaceBasePointer = value >> BTDSCRATCHSPACEBASEPOINTER_BIT_SHIFT;
4993    }
4994    inline uint64_t getBtdScratchSpaceBasePointer() const {
4995        return TheStructure.Common.BtdScratchSpaceBasePointer << BTDSCRATCHSPACEBASEPOINTER_BIT_SHIFT;
4996    }
4997} _3DSTATE_BTD_BODY;
4998STATIC_ASSERT(20 == sizeof(_3DSTATE_BTD_BODY));
4999
5000typedef struct tag_3DSTATE_BTD {
5001    union tagTheStructure {
5002        struct tagCommon {
5003            // DWORD 0
5004            uint32_t DwordLength : BITFIELD_RANGE(0, 7);
5005            uint32_t Reserved_8 : BITFIELD_RANGE(8, 15);
5006            uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23);
5007            uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26);
5008            uint32_t CommandSubtype : BITFIELD_RANGE(27, 28);
5009            uint32_t CommandType : BITFIELD_RANGE(29, 31);
5010            // DWORD 1
5011            _3DSTATE_BTD_BODY BtdStateBody;
5012        } Common;
5013        uint32_t RawData[6];
5014    } TheStructure;
5015    typedef enum tagDWORD_LENGTH {
5016        DWORD_LENGTH_DWORD_COUNT_N = 0x4,
5017    } DWORD_LENGTH;
5018    typedef enum tag_3D_COMMAND_SUB_OPCODE {
5019        _3D_COMMAND_SUB_OPCODE_3DSTATE_BTD = 0x6,
5020    } _3D_COMMAND_SUB_OPCODE;
5021    typedef enum tag_3D_COMMAND_OPCODE {
5022        _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED = 0x1,
5023    } _3D_COMMAND_OPCODE;
5024    typedef enum tagCOMMAND_SUBTYPE {
5025        COMMAND_SUBTYPE_GFXPIPE_COMMON = 0x0,
5026    } COMMAND_SUBTYPE;
5027    typedef enum tagCOMMAND_TYPE {
5028        COMMAND_TYPE_GFXPIPE = 0x3,
5029    } COMMAND_TYPE;
5030    inline void init() {
5031        memset(&TheStructure, 0, sizeof(TheStructure));
5032        TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N;
5033        TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_3DSTATE_BTD;
5034        TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED;
5035        TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_COMMON;
5036        TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE;
5037        TheStructure.Common.BtdStateBody.init();
5038    }
5039    static tag_3DSTATE_BTD sInit() {
5040        _3DSTATE_BTD state;
5041        state.init();
5042        return state;
5043    }
5044    inline uint32_t &getRawData(const uint32_t index) {
5045        UNRECOVERABLE_IF(index >= 6);
5046        return TheStructure.RawData[index];
5047    }
5048    inline void setBtdStateBody(const _3DSTATE_BTD_BODY &value) {
5049        TheStructure.Common.BtdStateBody = value;
5050    }
5051    inline _3DSTATE_BTD_BODY &getBtdStateBody() {
5052        return TheStructure.Common.BtdStateBody;
5053    }
5054} _3DSTATE_BTD;
5055STATIC_ASSERT(24 == sizeof(_3DSTATE_BTD));
5056STATIC_ASSERT(std::is_pod<_3DSTATE_BTD>::value);
5057
5058typedef struct tagGRF {
5059    union tagTheStructure {
5060        float fRegs[16];
5061        uint32_t dwRegs[16];
5062        uint16_t wRegs[32];
5063        uint32_t RawData[16];
5064    } TheStructure;
5065} GRF;
5066STATIC_ASSERT(64 == sizeof(GRF));
5067
5068typedef struct tagPOSTSYNC_DATA {
5069    union tagTheStructure {
5070        struct tagCommon {
5071            // DWORD 0
5072            uint32_t Operation : BITFIELD_RANGE(0, 1);
5073            uint32_t DataportPipelineFlush : BITFIELD_RANGE(2, 2);
5074            uint32_t Reserved_3 : BITFIELD_RANGE(3, 3);
5075            uint32_t MocsReserved_4 : BITFIELD_RANGE(4, 4);
5076            uint32_t MocsIndexToMocsTables : BITFIELD_RANGE(5, 10);
5077            uint32_t SystemMemoryFenceRequest : BITFIELD_RANGE(11, 11);
5078            uint32_t DataportSubsliceCacheFlush : BITFIELD_RANGE(12, 12);
5079            uint32_t Reserved_13 : BITFIELD_RANGE(13, 31);
5080            // DWORD 1
5081            uint64_t DestinationAddress;
5082            // DWORD 3
5083            uint64_t ImmediateData;
5084        } Common;
5085        uint32_t RawData[5];
5086    } TheStructure;
5087    typedef enum tagOPERATION {
5088        OPERATION_NO_WRITE = 0x0,
5089        OPERATION_WRITE_IMMEDIATE_DATA = 0x1,
5090        OPERATION_WRITE_TIMESTAMP = 0x3,
5091    } OPERATION;
5092    inline void init() {
5093        memset(&TheStructure, 0, sizeof(TheStructure));
5094        TheStructure.Common.Operation = OPERATION_NO_WRITE;
5095    }
5096    static tagPOSTSYNC_DATA sInit() {
5097        POSTSYNC_DATA state;
5098        state.init();
5099        return state;
5100    }
5101    inline uint32_t &getRawData(const uint32_t index) {
5102        UNRECOVERABLE_IF(index >= 5);
5103        return TheStructure.RawData[index];
5104    }
5105    inline void setOperation(const OPERATION value) {
5106        TheStructure.Common.Operation = value;
5107    }
5108    inline OPERATION getOperation() const {
5109        return static_cast<OPERATION>(TheStructure.Common.Operation);
5110    }
5111    inline void setDataportPipelineFlush(const bool value) {
5112        TheStructure.Common.DataportPipelineFlush = value;
5113    }
5114    inline bool getDataportPipelineFlush() const {
5115        return TheStructure.Common.DataportPipelineFlush;
5116    }
5117    inline void setMocs(const uint32_t value) { // patched
5118        UNRECOVERABLE_IF(value > 0x7f);
5119        TheStructure.Common.MocsReserved_4 = value;
5120        TheStructure.Common.MocsIndexToMocsTables = value >> 1;
5121    }
5122    inline uint32_t getMocs() const { // patched
5123        return (TheStructure.Common.MocsIndexToMocsTables << 1) | TheStructure.Common.MocsReserved_4;
5124    }
5125    inline void setSystemMemoryFenceRequest(const bool value) {
5126        TheStructure.Common.SystemMemoryFenceRequest = value;
5127    }
5128    inline bool getSystemMemoryFenceRequest() const {
5129        return TheStructure.Common.SystemMemoryFenceRequest;
5130    }
5131    inline void setDataportSubsliceCacheFlush(const bool value) {
5132        TheStructure.Common.DataportSubsliceCacheFlush = value;
5133    }
5134    inline bool getDataportSubsliceCacheFlush() const {
5135        return TheStructure.Common.DataportSubsliceCacheFlush;
5136    }
5137    inline void setDestinationAddress(const uint64_t value) {
5138        TheStructure.Common.DestinationAddress = value;
5139    }
5140    inline uint64_t getDestinationAddress() const {
5141        return TheStructure.Common.DestinationAddress;
5142    }
5143    inline void setImmediateData(const uint64_t value) {
5144        TheStructure.Common.ImmediateData = value;
5145    }
5146    inline uint64_t getImmediateData() const {
5147        return TheStructure.Common.ImmediateData;
5148    }
5149} POSTSYNC_DATA;
5150STATIC_ASSERT(20 == sizeof(POSTSYNC_DATA));
5151
5152typedef struct tagINTERFACE_DESCRIPTOR_DATA {
5153    union tagTheStructure {
5154        struct tagCommon {
5155            uint32_t Reserved_0_0_5 : BITFIELD_RANGE(0, 5);
5156            uint32_t KernelStartPointer : BITFIELD_RANGE(6, 31);
5157
5158            uint32_t KernelStartPointerHigh : BITFIELD_RANGE(0, 15);
5159            uint32_t Reserved_1_16_31 : BITFIELD_RANGE(16, 31);
5160
5161            uint32_t Reserved_2_0_6 : BITFIELD_RANGE(0, 6);
5162            uint32_t SoftwareExceptionEnable : BITFIELD_RANGE(7, 7);
5163            uint32_t RegistersPerThread : BITFIELD_RANGE(8, 10);
5164            uint32_t MaskStackExceptionEnable : BITFIELD_RANGE(11, 11);
5165            uint32_t Reserved_2_12_12 : BITFIELD_RANGE(12, 12);
5166            uint32_t IllegalOpcodeExceptionEnable : BITFIELD_RANGE(13, 13);
5167            uint32_t Reserved_2_14_15 : BITFIELD_RANGE(14, 15);
5168            uint32_t FloatingPointMode : BITFIELD_RANGE(16, 16);
5169            uint32_t Reserved_2_17_17 : BITFIELD_RANGE(17, 17);
5170            uint32_t SingleProgramFlow : BITFIELD_RANGE(18, 18);
5171            uint32_t DenormMode : BITFIELD_RANGE(19, 19);
5172            uint32_t ThreadPreemptionDisable : BITFIELD_RANGE(20, 20);
5173            uint32_t Reserved_2_21_31 : BITFIELD_RANGE(21, 31);
5174
5175            uint32_t Reserved_3_0_1 : BITFIELD_RANGE(0, 1);
5176            uint32_t SamplerCount : BITFIELD_RANGE(2, 4);
5177            uint32_t SamplerStatePointer : BITFIELD_RANGE(5, 31);
5178
5179            uint32_t BindingTableEntryCount : BITFIELD_RANGE(0, 4);
5180            uint32_t BindingTablePointer : BITFIELD_RANGE(5, 20);
5181            uint32_t Reserved_4_21_31 : BITFIELD_RANGE(21, 31);
5182
5183            uint32_t NumberOfThreadsInGpgpuThreadGroup : BITFIELD_RANGE(0, 9);
5184            uint32_t Reserved_5_10_15 : BITFIELD_RANGE(10, 15);
5185            uint32_t SharedLocalMemorySize : BITFIELD_RANGE(16, 20);
5186            uint32_t Reserved_5_21_21 : BITFIELD_RANGE(21, 21);
5187            uint32_t RoundingMode : BITFIELD_RANGE(22, 23);
5188            uint32_t Reserved_5_24_25 : BITFIELD_RANGE(24, 25);
5189            uint32_t ThreadGroupDispatchSize : BITFIELD_RANGE(26, 27);
5190            uint32_t NumberOfBarriers : BITFIELD_RANGE(28, 30);
5191            uint32_t Reserved_5_31_31 : BITFIELD_RANGE(31, 31);
5192
5193            uint32_t PreferredSlmAllocationSizePerDss : BITFIELD_RANGE(0, 2);
5194            uint32_t PreferredSlmSizeOverride : BITFIELD_RANGE(3, 3);
5195            uint32_t Reserved_6_4_31 : BITFIELD_RANGE(4, 31);
5196
5197            uint32_t Reserved_7;
5198        } Common;
5199        uint32_t RawData[8];
5200    } TheStructure;
5201    typedef enum tagFLOATING_POINT_MODE {
5202        FLOATING_POINT_MODE_IEEE_754 = 0x0,
5203        FLOATING_POINT_MODE_ALTERNATE = 0x1,
5204    } FLOATING_POINT_MODE;
5205    typedef enum tagSINGLE_PROGRAM_FLOW {
5206        SINGLE_PROGRAM_FLOW_MULTIPLE = 0x0,
5207        SINGLE_PROGRAM_FLOW_SINGLE = 0x1,
5208    } SINGLE_PROGRAM_FLOW;
5209    typedef enum tagDENORM_MODE {
5210        DENORM_MODE_FTZ = 0x0,
5211        DENORM_MODE_SETBYKERNEL = 0x1,
5212    } DENORM_MODE;
5213    typedef enum tagTHREAD_PREEMPTION_DISABLE {
5214        THREAD_PREEMPTION_DISABLE_DISABLE = 0x0,
5215        THREAD_PREEMPTION_DISABLE_ENABLE = 0x1,
5216    } THREAD_PREEMPTION_DISABLE;
5217    typedef enum tagSAMPLER_COUNT {
5218        SAMPLER_COUNT_NO_SAMPLERS_USED = 0x0,
5219        SAMPLER_COUNT_BETWEEN_1_AND_4_SAMPLERS_USED = 0x1,
5220        SAMPLER_COUNT_BETWEEN_5_AND_8_SAMPLERS_USED = 0x2,
5221        SAMPLER_COUNT_BETWEEN_9_AND_12_SAMPLERS_USED = 0x3,
5222        SAMPLER_COUNT_BETWEEN_13_AND_16_SAMPLERS_USED = 0x4,
5223    } SAMPLER_COUNT;
5224    typedef enum tagSHARED_LOCAL_MEMORY_SIZE {
5225        SHARED_LOCAL_MEMORY_SIZE_ENCODES_0K = 0x0,
5226        SHARED_LOCAL_MEMORY_SIZE_ENCODES_1K = 0x1,
5227        SHARED_LOCAL_MEMORY_SIZE_ENCODES_2K = 0x2,
5228        SHARED_LOCAL_MEMORY_SIZE_ENCODES_4K = 0x3,
5229        SHARED_LOCAL_MEMORY_SIZE_ENCODES_8K = 0x4,
5230        SHARED_LOCAL_MEMORY_SIZE_ENCODES_16K = 0x5,
5231        SHARED_LOCAL_MEMORY_SIZE_ENCODES_24K = 0x8,
5232        SHARED_LOCAL_MEMORY_SIZE_ENCODES_32K = 0x6,
5233        SHARED_LOCAL_MEMORY_SIZE_ENCODES_48K = 0x9,
5234        SHARED_LOCAL_MEMORY_SIZE_ENCODES_64K = 0x7,
5235        SHARED_LOCAL_MEMORY_SIZE_ENCODES_96K = 0xA,
5236        SHARED_LOCAL_MEMORY_SIZE_ENCODES_128K = 0xB,
5237    } SHARED_LOCAL_MEMORY_SIZE;
5238    typedef enum tagROUNDING_MODE {
5239        ROUNDING_MODE_RTNE = 0x0,
5240        ROUNDING_MODE_RU = 0x1,
5241        ROUNDING_MODE_RD = 0x2,
5242        ROUNDING_MODE_RTZ = 0x3,
5243    } ROUNDING_MODE;
5244    typedef enum tagREGISTERS_PER_THREAD {
5245        REGISTERS_PER_THREAD_DEFAULT = 0x0,
5246        REGISTERS_PER_THREAD_64_REGISTERS = 0x1,
5247        REGISTERS_PER_THREAD_96_REGISTERS = 0x2,
5248        REGISTERS_PER_THREAD_128_REGISTERS = 0x3,
5249        REGISTERS_PER_THREAD_160_REGISTERS = 0x4,
5250        REGISTERS_PER_THREAD_192_REGISTERS = 0x5,
5251        REGISTERS_PER_THREAD_256_REGISTERS = 0x6,
5252    } REGISTERS_PER_THREAD;
5253    typedef enum tagPREFERRED_SLM_SIZE_OVERRIDE {
5254        PREFERRED_SLM_SIZE_OVERRIDE_IS_DISABLED = 0x0,
5255        PREFERRED_SLM_SIZE_OVERRIDE_IS_ENABLED = 0x1,
5256    } PREFERRED_SLM_SIZE_OVERRIDE;
5257    typedef enum tagPREFERRED_SLM_ALLOCATION_SIZE_PER_DSS {
5258        PREFERRED_SLM_SIZE_IS_0K = 0x0,
5259        PREFERRED_SLM_SIZE_IS_16K = 0x1,
5260        PREFERRED_SLM_SIZE_IS_32K = 0x2,
5261        PREFERRED_SLM_SIZE_IS_64K = 0x3,
5262        PREFERRED_SLM_SIZE_IS_96K = 0x4,
5263        PREFERRED_SLM_SIZE_IS_128K = 0x5,
5264    } PREFERRED_SLM_ALLOCATION_SIZE_PER_DSS;
5265
5266    inline void init() {
5267        memset(&TheStructure, 0, sizeof(TheStructure));
5268        TheStructure.Common.FloatingPointMode = FLOATING_POINT_MODE_IEEE_754;
5269        TheStructure.Common.SingleProgramFlow = SINGLE_PROGRAM_FLOW_MULTIPLE;
5270        TheStructure.Common.DenormMode = DENORM_MODE_FTZ;
5271        TheStructure.Common.ThreadPreemptionDisable =
5272            THREAD_PREEMPTION_DISABLE_DISABLE;
5273        TheStructure.Common.SamplerCount = SAMPLER_COUNT_NO_SAMPLERS_USED;
5274        TheStructure.Common.SharedLocalMemorySize =
5275            SHARED_LOCAL_MEMORY_SIZE_ENCODES_0K;
5276        TheStructure.Common.RoundingMode = ROUNDING_MODE_RTNE;
5277        TheStructure.Common.RegistersPerThread = REGISTERS_PER_THREAD_DEFAULT;
5278        TheStructure.Common.PreferredSlmSizeOverride = PREFERRED_SLM_SIZE_OVERRIDE_IS_DISABLED;
5279        TheStructure.Common.PreferredSlmAllocationSizePerDss = PREFERRED_SLM_SIZE_IS_0K;
5280    }
5281    static tagINTERFACE_DESCRIPTOR_DATA sInit() {
5282        INTERFACE_DESCRIPTOR_DATA state;
5283        state.init();
5284        return state;
5285    }
5286    inline uint32_t &getRawData(const uint32_t index) {
5287        DEBUG_BREAK_IF(index >= 8);
5288        return TheStructure.RawData[index];
5289    }
5290    typedef enum tagKERNELSTARTPOINTER {
5291        KERNELSTARTPOINTER_BIT_SHIFT = 0x6,
5292        KERNELSTARTPOINTER_ALIGN_SIZE = 0x40,
5293    } KERNELSTARTPOINTER;
5294    inline void setKernelStartPointer(const uint64_t value) {
5295        DEBUG_BREAK_IF(value >= 0x100000000);
5296        TheStructure.Common.KernelStartPointer = (uint32_t)value >> KERNELSTARTPOINTER_BIT_SHIFT;
5297    }
5298    inline uint32_t getKernelStartPointer() const {
5299        return (TheStructure.Common.KernelStartPointer << KERNELSTARTPOINTER_BIT_SHIFT);
5300    }
5301    inline void setKernelStartPointerHigh(const uint32_t value) {
5302        TheStructure.Common.KernelStartPointerHigh = value;
5303    }
5304    inline uint32_t getKernelStartPointerHigh() const {
5305        return (TheStructure.Common.KernelStartPointerHigh);
5306    }
5307    inline void setSoftwareExceptionEnable(const uint32_t value) {
5308        TheStructure.Common.SoftwareExceptionEnable = value;
5309    }
5310    inline uint32_t getSoftwareExceptionEnable() const {
5311        return (TheStructure.Common.SoftwareExceptionEnable);
5312    }
5313    inline void setMaskStackExceptionEnable(const uint32_t value) {
5314        TheStructure.Common.MaskStackExceptionEnable = value;
5315    }
5316    inline uint32_t getMaskStackExceptionEnable() const {
5317        return (TheStructure.Common.MaskStackExceptionEnable);
5318    }
5319    inline void setIllegalOpcodeExceptionEnable(const uint32_t value) {
5320        TheStructure.Common.IllegalOpcodeExceptionEnable = value;
5321    }
5322    inline uint32_t getIllegalOpcodeExceptionEnable() const {
5323        return (TheStructure.Common.IllegalOpcodeExceptionEnable);
5324    }
5325    inline void setFloatingPointMode(const FLOATING_POINT_MODE value) {
5326        TheStructure.Common.FloatingPointMode = value;
5327    }
5328    inline FLOATING_POINT_MODE getFloatingPointMode() const {
5329        return static_cast<FLOATING_POINT_MODE>(TheStructure.Common.FloatingPointMode);
5330    }
5331    inline void setSingleProgramFlow(const SINGLE_PROGRAM_FLOW value) {
5332        TheStructure.Common.SingleProgramFlow = value;
5333    }
5334    inline SINGLE_PROGRAM_FLOW getSingleProgramFlow() const {
5335        return static_cast<SINGLE_PROGRAM_FLOW>(TheStructure.Common.SingleProgramFlow);
5336    }
5337    inline void setDenormMode(const DENORM_MODE value) {
5338        TheStructure.Common.DenormMode = value;
5339    }
5340    inline DENORM_MODE getDenormMode() const {
5341        return static_cast<DENORM_MODE>(TheStructure.Common.DenormMode);
5342    }
5343    inline void setThreadPreemptionDisable(const THREAD_PREEMPTION_DISABLE value) {
5344        TheStructure.Common.ThreadPreemptionDisable = value;
5345    }
5346    inline THREAD_PREEMPTION_DISABLE getThreadPreemptionDisable() const {
5347        return static_cast<THREAD_PREEMPTION_DISABLE>(TheStructure.Common.ThreadPreemptionDisable);
5348    }
5349    inline void setSamplerCount(const SAMPLER_COUNT value) {
5350        TheStructure.Common.SamplerCount = value;
5351    }
5352    inline SAMPLER_COUNT getSamplerCount() const {
5353        return static_cast<SAMPLER_COUNT>(TheStructure.Common.SamplerCount);
5354    }
5355    typedef enum tagSAMPLERSTATEPOINTER {
5356        SAMPLERSTATEPOINTER_BIT_SHIFT = 0x5,
5357        SAMPLERSTATEPOINTER_ALIGN_SIZE = 0x20,
5358    } SAMPLERSTATEPOINTER;
5359    inline void setSamplerStatePointer(const uint64_t value) {
5360        DEBUG_BREAK_IF(value >= 0x100000000);
5361        TheStructure.Common.SamplerStatePointer = (uint32_t)value >> SAMPLERSTATEPOINTER_BIT_SHIFT;
5362    }
5363    inline uint32_t getSamplerStatePointer() const {
5364        return (TheStructure.Common.SamplerStatePointer << SAMPLERSTATEPOINTER_BIT_SHIFT);
5365    }
5366    inline void setBindingTableEntryCount(const uint32_t value) {
5367        TheStructure.Common.BindingTableEntryCount = value;
5368    }
5369    inline uint32_t getBindingTableEntryCount() const {
5370        return (TheStructure.Common.BindingTableEntryCount);
5371    }
5372    typedef enum tagBINDINGTABLEPOINTER {
5373        BINDINGTABLEPOINTER_BIT_SHIFT = 0x5,
5374        BINDINGTABLEPOINTER_ALIGN_SIZE = 0x20,
5375    } BINDINGTABLEPOINTER;
5376    inline void setBindingTablePointer(const uint64_t value) {
5377        DEBUG_BREAK_IF(value >= 0x100000000);
5378        TheStructure.Common.BindingTablePointer = (uint32_t)value >> BINDINGTABLEPOINTER_BIT_SHIFT;
5379    }
5380    inline uint32_t getBindingTablePointer() const {
5381        return (TheStructure.Common.BindingTablePointer << BINDINGTABLEPOINTER_BIT_SHIFT);
5382    }
5383    inline void setNumberOfThreadsInGpgpuThreadGroup(const uint32_t value) {
5384        UNRECOVERABLE_IF(value > 128);
5385        TheStructure.Common.NumberOfThreadsInGpgpuThreadGroup = value;
5386    }
5387    inline uint32_t getNumberOfThreadsInGpgpuThreadGroup() const {
5388        return (TheStructure.Common.NumberOfThreadsInGpgpuThreadGroup);
5389    }
5390    inline void setSharedLocalMemorySize(const SHARED_LOCAL_MEMORY_SIZE value) {
5391        TheStructure.Common.SharedLocalMemorySize = value;
5392    }
5393    inline SHARED_LOCAL_MEMORY_SIZE getSharedLocalMemorySize() const {
5394        return static_cast<SHARED_LOCAL_MEMORY_SIZE>(TheStructure.Common.SharedLocalMemorySize);
5395    }
5396    inline void setNumberOfBarriers(const uint32_t value) {
5397        TheStructure.Common.NumberOfBarriers = value;
5398    }
5399    inline uint32_t getNumberOfBarriers() const {
5400        return TheStructure.Common.NumberOfBarriers;
5401    }
5402    inline void setRoundingMode(const ROUNDING_MODE value) {
5403        TheStructure.Common.RoundingMode = value;
5404    }
5405    inline ROUNDING_MODE getRoundingMode() const {
5406        return static_cast<ROUNDING_MODE>(TheStructure.Common.RoundingMode);
5407    }
5408    inline void setThreadGroupDispatchSize(const uint32_t value) {
5409        TheStructure.Common.ThreadGroupDispatchSize = value;
5410    }
5411    inline uint32_t getThreadGroupDispatchSize() const {
5412        return (TheStructure.Common.ThreadGroupDispatchSize);
5413    }
5414    inline void setRegistersPerThread(const REGISTERS_PER_THREAD value) {
5415        TheStructure.Common.RegistersPerThread = value;
5416    }
5417    inline REGISTERS_PER_THREAD getRegistersPerThread() const {
5418        return static_cast<REGISTERS_PER_THREAD>(TheStructure.Common.RegistersPerThread);
5419    }
5420    inline void setPreferredSlmSizeOverride(const PREFERRED_SLM_SIZE_OVERRIDE value) {
5421        TheStructure.Common.PreferredSlmSizeOverride = value;
5422    }
5423    inline PREFERRED_SLM_SIZE_OVERRIDE getPreferredSlmSizeOverride() const {
5424        return static_cast<PREFERRED_SLM_SIZE_OVERRIDE>(TheStructure.Common.PreferredSlmSizeOverride);
5425    }
5426    inline void setPreferredSlmAllocationSizePerDss(const PREFERRED_SLM_ALLOCATION_SIZE_PER_DSS value) {
5427        TheStructure.Common.PreferredSlmAllocationSizePerDss = value;
5428    }
5429    inline PREFERRED_SLM_ALLOCATION_SIZE_PER_DSS getPreferredSlmAllocationSizePerDss() const {
5430        return static_cast<PREFERRED_SLM_ALLOCATION_SIZE_PER_DSS>(TheStructure.Common.PreferredSlmAllocationSizePerDss);
5431    }
5432} INTERFACE_DESCRIPTOR_DATA;
5433STATIC_ASSERT(32 == sizeof(INTERFACE_DESCRIPTOR_DATA));
5434
5435typedef struct tagINLINE_DATA {
5436    uint32_t RawData[8];
5437} INLINE_DATA;
5438STATIC_ASSERT(32 == sizeof(INLINE_DATA));
5439
5440typedef struct tagCOMPUTE_WALKER {
5441    union tagTheStructure {
5442        struct tagCommon {
5443            // DWORD 0
5444            uint32_t DwordLength : BITFIELD_RANGE(0, 7);
5445            uint32_t PredicateEnable : BITFIELD_RANGE(8, 8);
5446            uint32_t WorkloadPartitionEnable : BITFIELD_RANGE(9, 9);
5447            uint32_t IndirectParameterEnable : BITFIELD_RANGE(10, 10);
5448            uint32_t UavWaitToProduce : BITFIELD_RANGE(11, 11);
5449            uint32_t UavProducer : BITFIELD_RANGE(12, 12);
5450            uint32_t UavConsumer : BITFIELD_RANGE(13, 13);
5451            uint32_t SystolicModeEnable : BITFIELD_RANGE(14, 14);
5452            uint32_t Reserved_15 : BITFIELD_RANGE(15, 15);
5453            uint32_t CfeSubopcodeVariant : BITFIELD_RANGE(16, 17);
5454            uint32_t CfeSubopcode : BITFIELD_RANGE(18, 23);
5455            uint32_t ComputeCommandOpcode : BITFIELD_RANGE(24, 26);
5456            uint32_t Pipeline : BITFIELD_RANGE(27, 28);
5457            uint32_t CommandType : BITFIELD_RANGE(29, 31);
5458            // DWORD 1
5459            uint32_t Reserved_32 : BITFIELD_RANGE(0, 7);
5460            uint32_t Reserved_40 : BITFIELD_RANGE(8, 31);
5461            // DWORD 2
5462            uint32_t IndirectDataLength : BITFIELD_RANGE(0, 16);
5463            uint32_t L3PrefetchDisable : BITFIELD_RANGE(17, 17);
5464            uint32_t Reserved_82 : BITFIELD_RANGE(18, 29);
5465            uint32_t PartitionType : BITFIELD_RANGE(30, 31);
5466            // DWORD 3
5467            uint32_t Reserved_96 : BITFIELD_RANGE(0, 5);
5468            uint32_t IndirectDataStartAddress : BITFIELD_RANGE(6, 31);
5469            // DWORD 4
5470            uint32_t ComputeDispatchAllWalkerEnable : BITFIELD_RANGE(0, 0);
5471            uint32_t Reserved_129 : BITFIELD_RANGE(1, 16);
5472            uint32_t MessageSimd : BITFIELD_RANGE(17, 18);
5473            uint32_t TileLayout : BITFIELD_RANGE(19, 21);
5474            uint32_t WalkOrder : BITFIELD_RANGE(22, 24);
5475            uint32_t EmitInlineParameter : BITFIELD_RANGE(25, 25);
5476            uint32_t EmitLocalId : BITFIELD_RANGE(26, 28);
5477            uint32_t GenerateLocalId : BITFIELD_RANGE(29, 29);
5478            uint32_t SimdSize : BITFIELD_RANGE(30, 31);
5479            // DWORD 5
5480            uint32_t ExecutionMask;
5481            // DWORD 6
5482            uint32_t LocalXMaximum : BITFIELD_RANGE(0, 9);
5483            uint32_t LocalYMaximum : BITFIELD_RANGE(10, 19);
5484            uint32_t LocalZMaximum : BITFIELD_RANGE(20, 29);
5485            uint32_t Reserved_222 : BITFIELD_RANGE(30, 31);
5486            // DWORD 7
5487            uint32_t ThreadGroupIdXDimension;
5488            // DWORD 8
5489            uint32_t ThreadGroupIdYDimension;
5490            // DWORD 9
5491            uint32_t ThreadGroupIdZDimension;
5492            // DWORD 10
5493            uint32_t ThreadGroupIdStartingX;
5494            // DWORD 11
5495            uint32_t ThreadGroupIdStartingY;
5496            // DWORD 12
5497            uint32_t ThreadGroupIdStartingZ;
5498            // DWORD 13
5499            uint64_t PartitionId : BITFIELD_RANGE(0, 31);
5500            // DWORD 14
5501            uint64_t PartitionSize : BITFIELD_RANGE(32, 63);
5502            // DWORD 15
5503            uint32_t PreemptX;
5504            // DWORD 16
5505            uint32_t PreemptY;
5506            // DWORD 17
5507            uint32_t PreemptZ;
5508            // DWORD 18
5509            INTERFACE_DESCRIPTOR_DATA InterfaceDescriptor;
5510            // DWORD 26
5511            POSTSYNC_DATA PostSync;
5512            // DWORD 31
5513            INLINE_DATA InlineData;
5514        } Common;
5515        uint32_t RawData[39];
5516    } TheStructure;
5517    typedef enum tagDWORD_LENGTH {
5518        DWORD_LENGTH_FIXED_SIZE = 0x25,
5519    } DWORD_LENGTH;
5520    typedef enum tagCFE_SUBOPCODE_VARIANT {
5521        CFE_SUBOPCODE_VARIANT_STANDARD = 0x0,
5522    } CFE_SUBOPCODE_VARIANT;
5523    typedef enum tagCFE_SUBOPCODE {
5524        CFE_SUBOPCODE_COMPUTE_WALKER = 0x2,
5525    } CFE_SUBOPCODE;
5526    typedef enum tagCOMPUTE_COMMAND_OPCODE {
5527        COMPUTE_COMMAND_OPCODE_NEW_CFE_COMMAND = 0x2,
5528    } COMPUTE_COMMAND_OPCODE;
5529    typedef enum tagPIPELINE {
5530        PIPELINE_COMPUTE = 0x2,
5531    } PIPELINE;
5532    typedef enum tagCOMMAND_TYPE {
5533        COMMAND_TYPE_GFXPIPE = 0x3,
5534    } COMMAND_TYPE;
5535    typedef enum tagPARTITION_TYPE {
5536        PARTITION_TYPE_DISABLED = 0x0,
5537        PARTITION_TYPE_X = 0x1,
5538        PARTITION_TYPE_Y = 0x2,
5539        PARTITION_TYPE_Z = 0x3,
5540    } PARTITION_TYPE;
5541    typedef enum tagSIMD_SIZE {
5542        SIMD_SIZE_SIMT16 = 0x1,
5543        SIMD_SIZE_SIMT32 = 0x2,
5544    } SIMD_SIZE;
5545    typedef enum tagPARTITION_ID {
5546        PARTITION_ID_SUPPORTED_MIN = 0x0,
5547        PARTITION_ID_SUPPORTED_MAX = 0xf,
5548    } PARTITION_ID;
5549    inline void init() {
5550        memset(&TheStructure, 0, sizeof(TheStructure));
5551        TheStructure.Common.DwordLength = DWORD_LENGTH_FIXED_SIZE;
5552        TheStructure.Common.CfeSubopcodeVariant = CFE_SUBOPCODE_VARIANT_STANDARD;
5553        TheStructure.Common.CfeSubopcode = CFE_SUBOPCODE_COMPUTE_WALKER;
5554        TheStructure.Common.ComputeCommandOpcode = COMPUTE_COMMAND_OPCODE_NEW_CFE_COMMAND;
5555        TheStructure.Common.Pipeline = PIPELINE_COMPUTE;
5556        TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE;
5557        TheStructure.Common.PartitionType = PARTITION_TYPE_DISABLED;
5558        TheStructure.Common.InterfaceDescriptor.init();
5559        TheStructure.Common.PostSync.init();
5560    }
5561    static tagCOMPUTE_WALKER sInit() {
5562        COMPUTE_WALKER state;
5563        state.init();
5564        return state;
5565    }
5566    inline uint32_t &getRawData(const uint32_t index) {
5567        UNRECOVERABLE_IF(index >= 39);
5568        return TheStructure.RawData[index];
5569    }
5570    inline void setDwordLength(const DWORD_LENGTH value) {
5571        TheStructure.Common.DwordLength = value;
5572    }
5573    inline DWORD_LENGTH getDwordLength() const {
5574        return static_cast<DWORD_LENGTH>(TheStructure.Common.DwordLength);
5575    }
5576    inline void setPredicateEnable(const bool value) {
5577        TheStructure.Common.PredicateEnable = value;
5578    }
5579    inline bool getPredicateEnable() const {
5580        return TheStructure.Common.PredicateEnable;
5581    }
5582    inline void setIndirectParameterEnable(const uint32_t value) {
5583        TheStructure.Common.IndirectParameterEnable = value;
5584    }
5585    inline void setUavWaitToProduce(const bool value) {
5586        TheStructure.Common.UavWaitToProduce = value;
5587    }
5588    inline bool getUavWaitToProduce() const {
5589        return TheStructure.Common.UavWaitToProduce;
5590    }
5591    inline void setUavProducer(const bool value) {
5592        TheStructure.Common.UavProducer = value;
5593    }
5594    inline bool getUavProducer() const {
5595        return TheStructure.Common.UavProducer;
5596    }
5597    inline void setUavConsumer(const bool value) {
5598        TheStructure.Common.UavConsumer = value;
5599    }
5600    inline bool getUavConsumer() const {
5601        return TheStructure.Common.UavConsumer;
5602    }
5603    inline void setWorkloadPartitionEnable(const bool value) {
5604        TheStructure.Common.WorkloadPartitionEnable = value;
5605    }
5606    inline bool getWorkloadPartitionEnable() const {
5607        return TheStructure.Common.WorkloadPartitionEnable;
5608    }
5609    inline void setIndirectParameterEnable(const bool value) {
5610        TheStructure.Common.IndirectParameterEnable = value;
5611    }
5612    inline bool getIndirectParameterEnable() const {
5613        return TheStructure.Common.IndirectParameterEnable;
5614    }
5615    inline void setSystolicModeEnable(const bool value) {
5616        TheStructure.Common.SystolicModeEnable = value;
5617    }
5618    inline bool getSystolicModeEnable() const {
5619        return TheStructure.Common.SystolicModeEnable;
5620    }
5621    inline void setCfeSubopcodeVariant(const CFE_SUBOPCODE_VARIANT value) {
5622        TheStructure.Common.CfeSubopcodeVariant = value;
5623    }
5624    inline CFE_SUBOPCODE_VARIANT getCfeSubopcodeVariant() const {
5625        return static_cast<CFE_SUBOPCODE_VARIANT>(TheStructure.Common.CfeSubopcodeVariant);
5626    }
5627    inline void setCfeSubopcode(const CFE_SUBOPCODE value) {
5628        TheStructure.Common.CfeSubopcode = value;
5629    }
5630    inline CFE_SUBOPCODE getCfeSubopcode() const {
5631        return static_cast<CFE_SUBOPCODE>(TheStructure.Common.CfeSubopcode);
5632    }
5633    inline void setComputeCommandOpcode(const COMPUTE_COMMAND_OPCODE value) {
5634        TheStructure.Common.ComputeCommandOpcode = value;
5635    }
5636    inline COMPUTE_COMMAND_OPCODE getComputeCommandOpcode() const {
5637        return static_cast<COMPUTE_COMMAND_OPCODE>(TheStructure.Common.ComputeCommandOpcode);
5638    }
5639    inline void setIndirectDataLength(const uint32_t value) {
5640        UNRECOVERABLE_IF(value > 0x1ffff);
5641        TheStructure.Common.IndirectDataLength = value;
5642    }
5643    inline uint32_t getIndirectDataLength() const {
5644        return TheStructure.Common.IndirectDataLength;
5645    }
5646    inline void setL3PrefetchDisable(const bool value) {
5647        TheStructure.Common.L3PrefetchDisable = value;
5648    }
5649    inline bool getL3PrefetchDisable() const {
5650        return TheStructure.Common.L3PrefetchDisable;
5651    }
5652    inline void setPartitionType(const PARTITION_TYPE value) {
5653        TheStructure.Common.PartitionType = value;
5654    }
5655    inline PARTITION_TYPE getPartitionType() const {
5656        return static_cast<PARTITION_TYPE>(TheStructure.Common.PartitionType);
5657    }
5658    typedef enum tagINDIRECTDATASTARTADDRESS {
5659        INDIRECTDATASTARTADDRESS_BIT_SHIFT = 0x6,
5660        INDIRECTDATASTARTADDRESS_ALIGN_SIZE = 0x40,
5661    } INDIRECTDATASTARTADDRESS;
5662    inline void setIndirectDataStartAddress(const uint32_t value) {
5663        UNRECOVERABLE_IF(value > 0xffffffc0);
5664        TheStructure.Common.IndirectDataStartAddress = value >> INDIRECTDATASTARTADDRESS_BIT_SHIFT;
5665    }
5666    inline uint32_t getIndirectDataStartAddress() const {
5667        return TheStructure.Common.IndirectDataStartAddress << INDIRECTDATASTARTADDRESS_BIT_SHIFT;
5668    }
5669    inline void setComputeDispatchAllWalkerEnable(const bool value) {
5670        TheStructure.Common.ComputeDispatchAllWalkerEnable = value;
5671    }
5672    inline bool getComputeDispatchAllWalkerEnable() const {
5673        return TheStructure.Common.ComputeDispatchAllWalkerEnable;
5674    }
5675    inline void setMessageSimd(const uint32_t value) {
5676        TheStructure.Common.MessageSimd = value;
5677    }
5678    inline uint32_t getMessageSimd() const {
5679        return (TheStructure.Common.MessageSimd);
5680    }
5681    inline void setTileLayout(const uint32_t value) {
5682        TheStructure.Common.TileLayout = value;
5683    }
5684    inline uint32_t getTileLayout() const {
5685        return (TheStructure.Common.TileLayout);
5686    }
5687    inline void setWalkOrder(const uint32_t value) {
5688        TheStructure.Common.WalkOrder = value;
5689    }
5690    inline uint32_t getWalkOrder() const {
5691        return (TheStructure.Common.WalkOrder);
5692    }
5693    inline void setEmitInlineParameter(const uint32_t value) {
5694        TheStructure.Common.EmitInlineParameter = value;
5695    }
5696    inline uint32_t getEmitInlineParameter() const {
5697        return (TheStructure.Common.EmitInlineParameter);
5698    }
5699    inline void setEmitLocalId(const uint32_t value) {
5700        TheStructure.Common.EmitLocalId = value;
5701    }
5702    inline uint32_t getEmitLocalId() const {
5703        return (TheStructure.Common.EmitLocalId);
5704    }
5705    inline void setGenerateLocalId(const uint32_t value) {
5706        TheStructure.Common.GenerateLocalId = value;
5707    }
5708    inline uint32_t getGenerateLocalId() const {
5709        return (TheStructure.Common.GenerateLocalId);
5710    }
5711    inline void setSimdSize(const SIMD_SIZE value) {
5712        TheStructure.Common.SimdSize = value;
5713    }
5714    inline SIMD_SIZE getSimdSize() const {
5715        return static_cast<SIMD_SIZE>(TheStructure.Common.SimdSize);
5716    }
5717    inline void setExecutionMask(const uint32_t value) {
5718        TheStructure.Common.ExecutionMask = value;
5719    }
5720    inline uint32_t getExecutionMask() const {
5721        return TheStructure.Common.ExecutionMask;
5722    }
5723    inline void setLocalXMaximum(const uint32_t value) {
5724        TheStructure.Common.LocalXMaximum = value;
5725    }
5726    inline uint32_t getLocalXMaximum() const {
5727        return (TheStructure.Common.LocalXMaximum);
5728    }
5729    inline void setLocalYMaximum(const uint32_t value) {
5730        TheStructure.Common.LocalYMaximum = value;
5731    }
5732    inline uint32_t getLocalYMaximum() const {
5733        return (TheStructure.Common.LocalYMaximum);
5734    }
5735    inline void setLocalZMaximum(const uint32_t value) {
5736        TheStructure.Common.LocalZMaximum = value;
5737    }
5738    inline uint32_t getLocalZMaximum() const {
5739        return (TheStructure.Common.LocalZMaximum);
5740    }
5741    inline void setThreadGroupIdXDimension(const uint32_t value) {
5742        TheStructure.Common.ThreadGroupIdXDimension = value;
5743    }
5744    inline uint32_t getThreadGroupIdXDimension() const {
5745        return TheStructure.Common.ThreadGroupIdXDimension;
5746    }
5747    inline void setThreadGroupIdYDimension(const uint32_t value) {
5748        TheStructure.Common.ThreadGroupIdYDimension = value;
5749    }
5750    inline uint32_t getThreadGroupIdYDimension() const {
5751        return TheStructure.Common.ThreadGroupIdYDimension;
5752    }
5753    inline void setThreadGroupIdZDimension(const uint32_t value) {
5754        TheStructure.Common.ThreadGroupIdZDimension = value;
5755    }
5756    inline uint32_t getThreadGroupIdZDimension() const {
5757        return TheStructure.Common.ThreadGroupIdZDimension;
5758    }
5759    inline void setThreadGroupIdStartingX(const uint32_t value) {
5760        TheStructure.Common.ThreadGroupIdStartingX = value;
5761    }
5762    inline uint32_t getThreadGroupIdStartingX() const {
5763        return TheStructure.Common.ThreadGroupIdStartingX;
5764    }
5765    inline void setThreadGroupIdStartingY(const uint32_t value) {
5766        TheStructure.Common.ThreadGroupIdStartingY = value;
5767    }
5768    inline uint32_t getThreadGroupIdStartingY() const {
5769        return TheStructure.Common.ThreadGroupIdStartingY;
5770    }
5771    inline void setThreadGroupIdStartingZ(const uint32_t value) {
5772        TheStructure.Common.ThreadGroupIdStartingZ = value;
5773    }
5774    inline uint32_t getThreadGroupIdStartingZ() const {
5775        return TheStructure.Common.ThreadGroupIdStartingZ;
5776    }
5777    inline void setPartitionId(const uint64_t value) {
5778        TheStructure.Common.PartitionId = value;
5779    }
5780    inline uint64_t getPartitionId() const {
5781        return TheStructure.Common.PartitionId;
5782    }
5783    inline void setPartitionSize(const uint64_t value) {
5784        TheStructure.Common.PartitionSize = value;
5785    }
5786    inline uint64_t getPartitionSize() const {
5787        return TheStructure.Common.PartitionSize;
5788    }
5789    inline void setPreemptX(const uint32_t value) {
5790        TheStructure.Common.PreemptX = value;
5791    }
5792    inline uint32_t getPreemptX() const {
5793        return TheStructure.Common.PreemptX;
5794    }
5795    inline void setPreemptY(const uint32_t value) {
5796        TheStructure.Common.PreemptY = value;
5797    }
5798    inline uint32_t getPreemptY() const {
5799        return TheStructure.Common.PreemptY;
5800    }
5801    inline void setPreemptZ(const uint32_t value) {
5802        TheStructure.Common.PreemptZ = value;
5803    }
5804    inline uint32_t getPreemptZ() const {
5805        return TheStructure.Common.PreemptZ;
5806    }
5807    inline void setInterfaceDescriptor(const INTERFACE_DESCRIPTOR_DATA &value) {
5808        TheStructure.Common.InterfaceDescriptor = value;
5809    }
5810    inline INTERFACE_DESCRIPTOR_DATA &getInterfaceDescriptor() {
5811        return TheStructure.Common.InterfaceDescriptor;
5812    }
5813    inline void setPostSync(const POSTSYNC_DATA &value) {
5814        TheStructure.Common.PostSync = value;
5815    }
5816    inline POSTSYNC_DATA &getPostSync() {
5817        return TheStructure.Common.PostSync;
5818    }
5819    inline uint32_t *getInlineDataPointer() {
5820        return reinterpret_cast<uint32_t *>(&TheStructure.Common.InlineData);
5821    }
5822} COMPUTE_WALKER;
5823STATIC_ASSERT(156 == sizeof(COMPUTE_WALKER));
5824
5825typedef struct tagCFE_STATE {
5826    union tagTheStructure {
5827        struct tagCommon {
5828            // DWORD 0
5829            uint32_t DwordLength : BITFIELD_RANGE(0, 7);
5830            uint32_t Reserved_8 : BITFIELD_RANGE(8, 15);
5831            uint32_t CfeSubopcodeVariant : BITFIELD_RANGE(16, 17);
5832            uint32_t CfeSubopcode : BITFIELD_RANGE(18, 23);
5833            uint32_t ComputeCommandOpcode : BITFIELD_RANGE(24, 26);
5834            uint32_t Pipeline : BITFIELD_RANGE(27, 28);
5835            uint32_t CommandType : BITFIELD_RANGE(29, 31);
5836            // DWORD 1
5837            uint64_t Reserved_32 : BITFIELD_RANGE(0, 7);
5838            uint64_t Reserved_40 : BITFIELD_RANGE(8, 9);
5839            uint64_t ScratchSpaceBuffer : BITFIELD_RANGE(10, 31);
5840            // DWORD 2
5841            uint64_t Reserved_64 : BITFIELD_RANGE(32, 63);
5842            // DWORD 3
5843            uint32_t Reserved_96 : BITFIELD_RANGE(0, 2);
5844            uint32_t NumberOfWalkers : BITFIELD_RANGE(3, 5);
5845            uint32_t FusedEuDispatch : BITFIELD_RANGE(6, 6);
5846            uint32_t Reserved_103 : BITFIELD_RANGE(7, 9);
5847            uint32_t LargeGRFThreadAdjustDisable : BITFIELD_RANGE(10, 10);
5848            uint32_t ComputeOverdispatchDisable : BITFIELD_RANGE(11, 11);
5849            uint32_t ComputeDispatchAllWalkerEnable : BITFIELD_RANGE(12, 12);
5850            uint32_t SingleSliceDispatchCcsMode : BITFIELD_RANGE(13, 13);
5851            uint32_t OverDispatchControl : BITFIELD_RANGE(14, 15);
5852            uint32_t MaximumNumberOfThreads : BITFIELD_RANGE(16, 31);
5853            // DWORD 4
5854            uint32_t Reserved_128;
5855            // DWORD 5
5856            uint32_t Reserved_160 : BITFIELD_RANGE(0, 0);
5857            uint32_t Reserved_161 : BITFIELD_RANGE(1, 10);
5858            uint32_t Reserved_171 : BITFIELD_RANGE(11, 31);
5859        } Common;
5860        uint32_t RawData[6];
5861    } TheStructure;
5862    typedef enum tagDWORD_LENGTH {
5863        DWORD_LENGTH_DWORD_COUNT_N = 0x4,
5864    } DWORD_LENGTH;
5865    typedef enum tagCFE_SUBOPCODE_VARIANT {
5866        CFE_SUBOPCODE_VARIANT_STANDARD = 0x0,
5867    } CFE_SUBOPCODE_VARIANT;
5868    typedef enum tagCFE_SUBOPCODE {
5869        CFE_SUBOPCODE_CFE_STATE = 0x0,
5870    } CFE_SUBOPCODE;
5871    typedef enum tagCOMPUTE_COMMAND_OPCODE {
5872        COMPUTE_COMMAND_OPCODE_NEW_CFE_COMMAND = 0x2,
5873    } COMPUTE_COMMAND_OPCODE;
5874    typedef enum tagPIPELINE {
5875        PIPELINE_COMPUTE = 0x2,
5876    } PIPELINE;
5877    typedef enum tagCOMMAND_TYPE {
5878        COMMAND_TYPE_GFXPIPE = 0x3,
5879    } COMMAND_TYPE;
5880    typedef enum tagOVER_DISPATCH_CONTROL {
5881        OVER_DISPATCH_CONTROL_NONE = 0x0,
5882        OVER_DISPATCH_CONTROL_LOW = 0x1,
5883        OVER_DISPATCH_CONTROL_NORMAL = 0x2,
5884        OVER_DISPATCH_CONTROL_HIGH = 0x3,
5885    } OVER_DISPATCH_CONTROL;
5886    inline void init() {
5887        memset(&TheStructure, 0, sizeof(TheStructure));
5888        TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N;
5889        TheStructure.Common.CfeSubopcodeVariant = CFE_SUBOPCODE_VARIANT_STANDARD;
5890        TheStructure.Common.CfeSubopcode = CFE_SUBOPCODE_CFE_STATE;
5891        TheStructure.Common.ComputeCommandOpcode = COMPUTE_COMMAND_OPCODE_NEW_CFE_COMMAND;
5892        TheStructure.Common.Pipeline = PIPELINE_COMPUTE;
5893        TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE;
5894        TheStructure.Common.OverDispatchControl = OVER_DISPATCH_CONTROL_NORMAL;
5895    }
5896    static tagCFE_STATE sInit() {
5897        CFE_STATE state;
5898        state.init();
5899        return state;
5900    }
5901    inline uint32_t &getRawData(const uint32_t index) {
5902        UNRECOVERABLE_IF(index >= 6);
5903        return TheStructure.RawData[index];
5904    }
5905    inline void setCfeSubopcodeVariant(const CFE_SUBOPCODE_VARIANT value) {
5906        TheStructure.Common.CfeSubopcodeVariant = value;
5907    }
5908    inline CFE_SUBOPCODE_VARIANT getCfeSubopcodeVariant() const {
5909        return static_cast<CFE_SUBOPCODE_VARIANT>(TheStructure.Common.CfeSubopcodeVariant);
5910    }
5911    inline void setCfeSubopcode(const CFE_SUBOPCODE value) {
5912        TheStructure.Common.CfeSubopcode = value;
5913    }
5914    inline CFE_SUBOPCODE getCfeSubopcode() const {
5915        return static_cast<CFE_SUBOPCODE>(TheStructure.Common.CfeSubopcode);
5916    }
5917    inline void setComputeCommandOpcode(const COMPUTE_COMMAND_OPCODE value) {
5918        TheStructure.Common.ComputeCommandOpcode = value;
5919    }
5920    inline COMPUTE_COMMAND_OPCODE getComputeCommandOpcode() const {
5921        return static_cast<COMPUTE_COMMAND_OPCODE>(TheStructure.Common.ComputeCommandOpcode);
5922    }
5923    typedef enum tagSCRATCHSPACEBUFFER {
5924        SCRATCHSPACEBUFFER_BIT_SHIFT = 0x6,
5925        SCRATCHSPACEBUFFER_ALIGN_SIZE = 0x40,
5926    } SCRATCHSPACEBUFFER;
5927    inline void setScratchSpaceBuffer(const uint64_t value) {
5928        UNRECOVERABLE_IF(value > 0xfffffc00L);
5929        TheStructure.Common.ScratchSpaceBuffer = static_cast<uint32_t>(value) >> SCRATCHSPACEBUFFER_BIT_SHIFT;
5930    }
5931    inline uint64_t getScratchSpaceBuffer() const {
5932        return TheStructure.Common.ScratchSpaceBuffer << SCRATCHSPACEBUFFER_BIT_SHIFT;
5933    }
5934    inline void setNumberOfWalkers(const uint32_t value) {
5935        UNRECOVERABLE_IF(value > 0x38);
5936        TheStructure.Common.NumberOfWalkers = value - 1;
5937    }
5938    inline uint32_t getNumberOfWalkers() const {
5939        return TheStructure.Common.NumberOfWalkers + 1;
5940    }
5941    inline void setFusedEuDispatch(const bool value) {
5942        TheStructure.Common.FusedEuDispatch = value;
5943    }
5944    inline bool getFusedEuDispatch() const {
5945        return TheStructure.Common.FusedEuDispatch;
5946    }
5947    inline void setLargeGRFThreadAdjustDisable(const bool value) {
5948        TheStructure.Common.LargeGRFThreadAdjustDisable = value;
5949    }
5950    inline bool getLargeGRFThreadAdjustDisable() const {
5951        return TheStructure.Common.LargeGRFThreadAdjustDisable;
5952    }
5953    inline void setComputeOverdispatchDisable(const bool value) {
5954        TheStructure.Common.ComputeOverdispatchDisable = value;
5955    }
5956    inline bool getComputeOverdispatchDisable() const {
5957        return TheStructure.Common.ComputeOverdispatchDisable;
5958    }
5959    inline void setComputeDispatchAllWalkerEnable(const bool value) {
5960        TheStructure.Common.ComputeDispatchAllWalkerEnable = value;
5961    }
5962    inline bool getComputeDispatchAllWalkerEnable() const {
5963        return TheStructure.Common.ComputeDispatchAllWalkerEnable;
5964    }
5965    inline void setSingleSliceDispatchCcsMode(const bool value) {
5966        TheStructure.Common.SingleSliceDispatchCcsMode = value;
5967    }
5968    inline bool getSingleSliceDispatchCcsMode() const {
5969        return TheStructure.Common.SingleSliceDispatchCcsMode;
5970    }
5971    inline void setOverDispatchControl(const OVER_DISPATCH_CONTROL value) {
5972        TheStructure.Common.OverDispatchControl = value;
5973    }
5974    inline OVER_DISPATCH_CONTROL getOverDispatchControl() const {
5975        return static_cast<OVER_DISPATCH_CONTROL>(TheStructure.Common.OverDispatchControl);
5976    }
5977    inline void setMaximumNumberOfThreads(const uint32_t value) {
5978        UNRECOVERABLE_IF(value > 0xffff0000);
5979        TheStructure.Common.MaximumNumberOfThreads = value;
5980    }
5981    inline uint32_t getMaximumNumberOfThreads() const {
5982        return TheStructure.Common.MaximumNumberOfThreads;
5983    }
5984} CFE_STATE;
5985STATIC_ASSERT(24 == sizeof(CFE_STATE));
5986
5987typedef struct tagMI_ARB_CHECK {
5988    union tagTheStructure {
5989        struct tagCommon {
5990            // DWORD 0
5991            uint32_t PreParserDisable : BITFIELD_RANGE(0, 0);
5992            uint32_t Reserved_1 : BITFIELD_RANGE(1, 7);
5993            uint32_t MaskBits : BITFIELD_RANGE(8, 15);
5994            uint32_t Reserved_16 : BITFIELD_RANGE(16, 22);
5995            uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28);
5996            uint32_t CommandType : BITFIELD_RANGE(29, 31);
5997        } Common;
5998        uint32_t RawData[1];
5999    } TheStructure;
6000    typedef enum tagMI_COMMAND_OPCODE {
6001        MI_COMMAND_OPCODE_MI_ARB_CHECK = 0x5,
6002    } MI_COMMAND_OPCODE;
6003    typedef enum tagCOMMAND_TYPE {
6004        COMMAND_TYPE_MI_COMMAND = 0x0,
6005    } COMMAND_TYPE;
6006    inline void init() {
6007        memset(&TheStructure, 0, sizeof(TheStructure));
6008        TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_ARB_CHECK;
6009        TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND;
6010    }
6011    static tagMI_ARB_CHECK sInit() {
6012        MI_ARB_CHECK state;
6013        state.init();
6014        return state;
6015    }
6016    inline uint32_t &getRawData(const uint32_t index) {
6017        UNRECOVERABLE_IF(index >= 1);
6018        return TheStructure.RawData[index];
6019    }
6020    inline void setPreParserDisable(const bool value) {
6021        TheStructure.Common.PreParserDisable = value;
6022        TheStructure.Common.MaskBits = 1 << 0; //PreParserDisable is at bit0, so set bit0 of mask to 1
6023    }
6024    inline bool getPreParserDisable() const {
6025        return TheStructure.Common.PreParserDisable;
6026    }
6027    inline void setMaskBits(const uint32_t value) {
6028        UNRECOVERABLE_IF(value > 0xff00);
6029        TheStructure.Common.MaskBits = value;
6030    }
6031    inline uint32_t getMaskBits() const {
6032        return TheStructure.Common.MaskBits;
6033    }
6034} MI_ARB_CHECK;
6035STATIC_ASSERT(4 == sizeof(MI_ARB_CHECK));
6036
6037typedef struct tagMI_BATCH_BUFFER_START {
6038    union tagTheStructure {
6039        struct tagCommon {
6040            // DWORD 0
6041            uint32_t DwordLength : BITFIELD_RANGE(0, 7);
6042            uint32_t AddressSpaceIndicator : BITFIELD_RANGE(8, 8);
6043            uint32_t Reserved_9 : BITFIELD_RANGE(9, 9);
6044            uint32_t Reserved_10 : BITFIELD_RANGE(10, 14);
6045            uint32_t PredicationEnable : BITFIELD_RANGE(15, 15);
6046            uint32_t Reserved_16 : BITFIELD_RANGE(16, 18);
6047            uint32_t EnableCommandCache : BITFIELD_RANGE(19, 19);
6048            uint32_t PoshEnable : BITFIELD_RANGE(20, 20);
6049            uint32_t PoshStart : BITFIELD_RANGE(21, 21);
6050            uint32_t Reserved_22 : BITFIELD_RANGE(22, 22);
6051            uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28);
6052            uint32_t CommandType : BITFIELD_RANGE(29, 31);
6053            // DWORD 1
6054            uint64_t Reserved_32 : BITFIELD_RANGE(0, 1);
6055            uint64_t BatchBufferStartAddress : BITFIELD_RANGE(2, 56);
6056            uint64_t BatchBufferStartAddressReserved_89 : BITFIELD_RANGE(57, 63);
6057        } Common;
6058        struct tagMi_Mode_Nestedbatchbufferenableis0 {
6059            // DWORD 0
6060            uint32_t Reserved_0 : BITFIELD_RANGE(0, 7);
6061            uint32_t Reserved_8 : BITFIELD_RANGE(8, 8);
6062            uint32_t Reserved_9 : BITFIELD_RANGE(9, 9);
6063            uint32_t Reserved_10 : BITFIELD_RANGE(10, 14);
6064            uint32_t Reserved_15 : BITFIELD_RANGE(15, 15);
6065            uint32_t Reserved_16 : BITFIELD_RANGE(16, 18);
6066            uint32_t Reserved_19 : BITFIELD_RANGE(19, 19);
6067            uint32_t Reserved_20 : BITFIELD_RANGE(20, 20);
6068            uint32_t Reserved_21 : BITFIELD_RANGE(21, 21);
6069            uint32_t SecondLevelBatchBuffer : BITFIELD_RANGE(22, 22);
6070            uint32_t Reserved_23 : BITFIELD_RANGE(23, 28);
6071            uint32_t Reserved_29 : BITFIELD_RANGE(29, 31);
6072            // DWORD 1
6073            uint64_t Reserved_32 : BITFIELD_RANGE(0, 1);
6074            uint64_t Reserved_34 : BITFIELD_RANGE(2, 56);
6075            uint64_t Reserved_89 : BITFIELD_RANGE(57, 63);
6076        } Mi_Mode_Nestedbatchbufferenableis0;
6077        struct tagMi_Mode_Nestedbatchbufferenableis1 {
6078            // DWORD 0
6079            uint32_t Reserved_0 : BITFIELD_RANGE(0, 7);
6080            uint32_t Reserved_8 : BITFIELD_RANGE(8, 8);
6081            uint32_t Reserved_9 : BITFIELD_RANGE(9, 9);
6082            uint32_t Reserved_10 : BITFIELD_RANGE(10, 14);
6083            uint32_t Reserved_15 : BITFIELD_RANGE(15, 15);
6084            uint32_t Reserved_16 : BITFIELD_RANGE(16, 18);
6085            uint32_t Reserved_19 : BITFIELD_RANGE(19, 19);
6086            uint32_t Reserved_20 : BITFIELD_RANGE(20, 20);
6087            uint32_t Reserved_21 : BITFIELD_RANGE(21, 21);
6088            uint32_t NestedLevelBatchBuffer : BITFIELD_RANGE(22, 22);
6089            uint32_t Reserved_23 : BITFIELD_RANGE(23, 28);
6090            uint32_t Reserved_29 : BITFIELD_RANGE(29, 31);
6091            // DWORD 1
6092            uint64_t Reserved_32 : BITFIELD_RANGE(0, 1);
6093            uint64_t Reserved_34 : BITFIELD_RANGE(2, 56);
6094            uint64_t Reserved_89 : BITFIELD_RANGE(57, 63);
6095        } Mi_Mode_Nestedbatchbufferenableis1;
6096        uint32_t RawData[3];
6097    } TheStructure;
6098    typedef enum tagDWORD_LENGTH {
6099        DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x1,
6100    } DWORD_LENGTH;
6101    typedef enum tagADDRESS_SPACE_INDICATOR {
6102        ADDRESS_SPACE_INDICATOR_GGTT = 0x0,
6103        ADDRESS_SPACE_INDICATOR_PPGTT = 0x1,
6104    } ADDRESS_SPACE_INDICATOR;
6105    typedef enum tagNESTED_LEVEL_BATCH_BUFFER {
6106        NESTED_LEVEL_BATCH_BUFFER_CHAIN = 0x0,
6107        NESTED_LEVEL_BATCH_BUFFER_NESTED = 0x1,
6108    } NESTED_LEVEL_BATCH_BUFFER;
6109    typedef enum tagSECOND_LEVEL_BATCH_BUFFER {
6110        SECOND_LEVEL_BATCH_BUFFER_FIRST_LEVEL_BATCH = 0x0,
6111        SECOND_LEVEL_BATCH_BUFFER_SECOND_LEVEL_BATCH = 0x1,
6112    } SECOND_LEVEL_BATCH_BUFFER;
6113    typedef enum tagMI_COMMAND_OPCODE {
6114        MI_COMMAND_OPCODE_MI_BATCH_BUFFER_START = 0x31,
6115    } MI_COMMAND_OPCODE;
6116    typedef enum tagCOMMAND_TYPE {
6117        COMMAND_TYPE_MI_COMMAND = 0x0,
6118    } COMMAND_TYPE;
6119    inline void init() {
6120        memset(&TheStructure, 0, sizeof(TheStructure));
6121        TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1;
6122        TheStructure.Common.AddressSpaceIndicator = ADDRESS_SPACE_INDICATOR_GGTT;
6123        TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_BATCH_BUFFER_START;
6124        TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND;
6125        TheStructure.Mi_Mode_Nestedbatchbufferenableis0.SecondLevelBatchBuffer = SECOND_LEVEL_BATCH_BUFFER_FIRST_LEVEL_BATCH;
6126        TheStructure.Mi_Mode_Nestedbatchbufferenableis1.NestedLevelBatchBuffer = NESTED_LEVEL_BATCH_BUFFER_CHAIN;
6127    }
6128    static tagMI_BATCH_BUFFER_START sInit() {
6129        MI_BATCH_BUFFER_START state;
6130        state.init();
6131        return state;
6132    }
6133    inline uint32_t &getRawData(const uint32_t index) {
6134        DEBUG_BREAK_IF(index >= 3);
6135        return TheStructure.RawData[index];
6136    }
6137    inline void setAddressSpaceIndicator(const ADDRESS_SPACE_INDICATOR value) {
6138        TheStructure.Common.AddressSpaceIndicator = value;
6139    }
6140    inline ADDRESS_SPACE_INDICATOR getAddressSpaceIndicator() const {
6141        return static_cast<ADDRESS_SPACE_INDICATOR>(TheStructure.Common.AddressSpaceIndicator);
6142    }
6143    inline void setPredicationEnable(const uint32_t value) {
6144        TheStructure.Common.PredicationEnable = value;
6145    }
6146    inline uint32_t getPredicationEnable() const {
6147        return TheStructure.Common.PredicationEnable;
6148    }
6149    inline void setEnableCommandCache(const uint32_t value) {
6150        TheStructure.Common.EnableCommandCache = value;
6151    }
6152    inline uint32_t getEnableCommandCache() const {
6153        return TheStructure.Common.EnableCommandCache;
6154    }
6155    inline void setPoshEnable(const uint32_t value) {
6156        TheStructure.Common.PoshEnable = value;
6157    }
6158    inline uint32_t getPoshEnable() const {
6159        return TheStructure.Common.PoshEnable;
6160    }
6161    inline void setPoshStart(const uint32_t value) {
6162        TheStructure.Common.PoshStart = value;
6163    }
6164    inline uint32_t getPoshStart() const {
6165        return TheStructure.Common.PoshStart;
6166    }
6167    typedef enum tagBATCHBUFFERSTARTADDRESS {
6168        BATCHBUFFERSTARTADDRESS_BIT_SHIFT = 0x2,
6169        BATCHBUFFERSTARTADDRESS_ALIGN_SIZE = 0x4,
6170    } BATCHBUFFERSTARTADDRESS;
6171    inline void setBatchBufferStartAddress(const uint64_t value) {
6172        TheStructure.Common.BatchBufferStartAddress = value >> BATCHBUFFERSTARTADDRESS_BIT_SHIFT;
6173    }
6174    inline uint64_t getBatchBufferStartAddress() const {
6175        return TheStructure.Common.BatchBufferStartAddress << BATCHBUFFERSTARTADDRESS_BIT_SHIFT;
6176    }
6177    inline void setSecondLevelBatchBuffer(const SECOND_LEVEL_BATCH_BUFFER value) {
6178        TheStructure.Mi_Mode_Nestedbatchbufferenableis0.SecondLevelBatchBuffer = value;
6179    }
6180    inline SECOND_LEVEL_BATCH_BUFFER getSecondLevelBatchBuffer() const {
6181        return static_cast<SECOND_LEVEL_BATCH_BUFFER>(TheStructure.Mi_Mode_Nestedbatchbufferenableis0.SecondLevelBatchBuffer);
6182    }
6183    inline void setNestedLevelBatchBuffer(const NESTED_LEVEL_BATCH_BUFFER value) {
6184        TheStructure.Mi_Mode_Nestedbatchbufferenableis1.NestedLevelBatchBuffer = value;
6185    }
6186    inline NESTED_LEVEL_BATCH_BUFFER getNestedLevelBatchBuffer() const {
6187        return static_cast<NESTED_LEVEL_BATCH_BUFFER>(TheStructure.Mi_Mode_Nestedbatchbufferenableis1.NestedLevelBatchBuffer);
6188    }
6189} MI_BATCH_BUFFER_START;
6190STATIC_ASSERT(12 == sizeof(MI_BATCH_BUFFER_START));
6191
6192typedef struct tagMI_LOAD_REGISTER_MEM {
6193    union tagTheStructure {
6194        struct tagCommon {
6195            // DWORD 0
6196            uint32_t DwordLength : BITFIELD_RANGE(0, 7);
6197            uint32_t Reserved_8 : BITFIELD_RANGE(8, 15);
6198            uint32_t WorkloadPartitionIdOffsetEnable : BITFIELD_RANGE(16, 16);
6199            uint32_t MmioRemapEnable : BITFIELD_RANGE(17, 17);
6200            uint32_t Reserved_18 : BITFIELD_RANGE(18, 18);
6201            uint32_t AddCsMmioStartOffset : BITFIELD_RANGE(19, 19);
6202            uint32_t Reserved_20 : BITFIELD_RANGE(20, 20);
6203            uint32_t AsyncModeEnable : BITFIELD_RANGE(21, 21);
6204            uint32_t UseGlobalGtt : BITFIELD_RANGE(22, 22);
6205            uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28);
6206            uint32_t CommandType : BITFIELD_RANGE(29, 31);
6207            // DWORD 1
6208            uint32_t Reserved_32 : BITFIELD_RANGE(0, 1);
6209            uint32_t RegisterAddress : BITFIELD_RANGE(2, 22);
6210            uint32_t Reserved_55 : BITFIELD_RANGE(23, 31);
6211            // DWORD 2
6212            uint64_t Reserved_64 : BITFIELD_RANGE(0, 1);
6213            uint64_t MemoryAddress : BITFIELD_RANGE(2, 63);
6214        } Common;
6215        uint32_t RawData[4];
6216    } TheStructure;
6217    typedef enum tagDWORD_LENGTH {
6218        DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x2,
6219    } DWORD_LENGTH;
6220    typedef enum tagMI_COMMAND_OPCODE {
6221        MI_COMMAND_OPCODE_MI_LOAD_REGISTER_MEM = 0x29,
6222    } MI_COMMAND_OPCODE;
6223    typedef enum tagCOMMAND_TYPE {
6224        COMMAND_TYPE_MI_COMMAND = 0x0,
6225    } COMMAND_TYPE;
6226    inline void init() {
6227        memset(&TheStructure, 0, sizeof(TheStructure));
6228        TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1;
6229        TheStructure.Common.MiCommandOpcode =
6230            MI_COMMAND_OPCODE_MI_LOAD_REGISTER_MEM;
6231        TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND;
6232    }
6233    static tagMI_LOAD_REGISTER_MEM sInit() {
6234        MI_LOAD_REGISTER_MEM state;
6235        state.init();
6236        return state;
6237    }
6238    inline uint32_t &getRawData(const uint32_t index) {
6239        DEBUG_BREAK_IF(index >= 4);
6240        return TheStructure.RawData[index];
6241    }
6242    inline void setWorkloadPartitionIdOffsetEnable(const bool value) {
6243        TheStructure.Common.WorkloadPartitionIdOffsetEnable = value;
6244    }
6245    inline bool getWorkloadPartitionIdOffsetEnable() const {
6246        return TheStructure.Common.WorkloadPartitionIdOffsetEnable;
6247    }
6248    inline void setMmioRemapEnable(const bool value) {
6249        TheStructure.Common.MmioRemapEnable = value;
6250    }
6251    inline bool getMmioRemapEnable() const {
6252        return TheStructure.Common.MmioRemapEnable;
6253    }
6254    inline void setAddCsMmioStartOffset(const uint32_t value) {
6255        TheStructure.Common.AddCsMmioStartOffset = value;
6256    }
6257    inline uint32_t getAddCsMmioStartOffset() const {
6258        return TheStructure.Common.AddCsMmioStartOffset;
6259    }
6260    inline void setAsyncModeEnable(const bool value) {
6261        TheStructure.Common.AsyncModeEnable = value;
6262    }
6263    inline bool getAsyncModeEnable() const {
6264        return TheStructure.Common.AsyncModeEnable;
6265    }
6266    inline void setUseGlobalGtt(const bool value) {
6267        TheStructure.Common.UseGlobalGtt = value;
6268    }
6269    inline bool getUseGlobalGtt() const {
6270        return TheStructure.Common.UseGlobalGtt;
6271    }
6272    typedef enum tagREGISTERADDRESS {
6273        REGISTERADDRESS_BIT_SHIFT = 0x2,
6274        REGISTERADDRESS_ALIGN_SIZE = 0x4,
6275    } REGISTERADDRESS;
6276    inline void setRegisterAddress(const uint32_t value) {
6277        DEBUG_BREAK_IF(value > 0x7ffffc);
6278        TheStructure.Common.RegisterAddress = value >> REGISTERADDRESS_BIT_SHIFT;
6279    }
6280    inline uint32_t getRegisterAddress() const {
6281        return TheStructure.Common.RegisterAddress << REGISTERADDRESS_BIT_SHIFT;
6282    }
6283    typedef enum tagMEMORYADDRESS {
6284        MEMORYADDRESS_BIT_SHIFT = 0x2,
6285        MEMORYADDRESS_ALIGN_SIZE = 0x4,
6286    } MEMORYADDRESS;
6287    inline void setMemoryAddress(const uint64_t value) {
6288        DEBUG_BREAK_IF(value > 0xfffffffffffffffcL);
6289        TheStructure.Common.MemoryAddress = value >> MEMORYADDRESS_BIT_SHIFT;
6290    }
6291    inline uint64_t getMemoryAddress() const {
6292        return TheStructure.Common.MemoryAddress << MEMORYADDRESS_BIT_SHIFT;
6293    }
6294} MI_LOAD_REGISTER_MEM;
6295STATIC_ASSERT(16 == sizeof(MI_LOAD_REGISTER_MEM));
6296
6297typedef struct tagMI_LOAD_REGISTER_REG {
6298    union tagTheStructure {
6299        struct tagCommon {
6300            // DWORD 0
6301            uint32_t DwordLength : BITFIELD_RANGE(0, 7);
6302            uint32_t Reserved_8 : BITFIELD_RANGE(8, 15);
6303            uint32_t MmioRemapEnableSource : BITFIELD_RANGE(16, 16);
6304            uint32_t MmioRemapEnableDestination : BITFIELD_RANGE(17, 17);
6305            uint32_t AddCsMmioStartOffsetSource : BITFIELD_RANGE(18, 18);
6306            uint32_t AddCsMmioStartOffsetDestination : BITFIELD_RANGE(19, 19);
6307            uint32_t Reserved_20 : BITFIELD_RANGE(20, 22);
6308            uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28);
6309            uint32_t CommandType : BITFIELD_RANGE(29, 31);
6310            // DWORD 1
6311            uint32_t Reserved_32 : BITFIELD_RANGE(0, 1);
6312            uint32_t SourceRegisterAddress : BITFIELD_RANGE(2, 22);
6313            uint32_t Reserved_55 : BITFIELD_RANGE(23, 31);
6314            // DWORD 2
6315            uint32_t Reserved_64 : BITFIELD_RANGE(0, 1);
6316            uint32_t DestinationRegisterAddress : BITFIELD_RANGE(2, 22);
6317            uint32_t Reserved_87 : BITFIELD_RANGE(23, 31);
6318        } Common;
6319        uint32_t RawData[3];
6320    } TheStructure;
6321    typedef enum tagDWORD_LENGTH {
6322        DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x1,
6323    } DWORD_LENGTH;
6324    typedef enum tagMI_COMMAND_OPCODE {
6325        MI_COMMAND_OPCODE_MI_LOAD_REGISTER_REG = 0x2a,
6326    } MI_COMMAND_OPCODE;
6327    typedef enum tagCOMMAND_TYPE {
6328        COMMAND_TYPE_MI_COMMAND = 0x0,
6329    } COMMAND_TYPE;
6330    inline void init() {
6331        memset(&TheStructure, 0, sizeof(TheStructure));
6332        TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1;
6333        TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_LOAD_REGISTER_REG;
6334        TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND;
6335    }
6336    static tagMI_LOAD_REGISTER_REG sInit() {
6337        MI_LOAD_REGISTER_REG state;
6338        state.init();
6339        return state;
6340    }
6341    inline uint32_t &getRawData(const uint32_t index) {
6342        DEBUG_BREAK_IF(index >= 3);
6343        return TheStructure.RawData[index];
6344    }
6345    inline void setMmioRemapEnableSource(const bool value) {
6346        TheStructure.Common.MmioRemapEnableSource = value;
6347    }
6348    inline bool getMmioRemapEnableSource() const {
6349        return TheStructure.Common.MmioRemapEnableSource;
6350    }
6351    inline void setMmioRemapEnableDestination(const bool value) {
6352        TheStructure.Common.MmioRemapEnableDestination = value;
6353    }
6354    inline bool getMmioRemapEnableDestination() const {
6355        return TheStructure.Common.MmioRemapEnableDestination;
6356    }
6357    inline void setAddCsMmioStartOffsetSource(const uint32_t value) {
6358        TheStructure.Common.AddCsMmioStartOffsetSource = value;
6359    }
6360    inline uint32_t getAddCsMmioStartOffsetSource() const {
6361        return TheStructure.Common.AddCsMmioStartOffsetSource;
6362    }
6363    inline void setAddCsMmioStartOffsetDestination(const uint32_t value) {
6364        TheStructure.Common.AddCsMmioStartOffsetDestination = value;
6365    }
6366    inline uint32_t getAddCsMmioStartOffsetDestination() const {
6367        return TheStructure.Common.AddCsMmioStartOffsetDestination;
6368    }
6369    typedef enum tagSOURCEREGISTERADDRESS {
6370        SOURCEREGISTERADDRESS_BIT_SHIFT = 0x2,
6371        SOURCEREGISTERADDRESS_ALIGN_SIZE = 0x4,
6372    } SOURCEREGISTERADDRESS;
6373    inline void setSourceRegisterAddress(const uint32_t value) {
6374        DEBUG_BREAK_IF(value > 0x7ffffc);
6375        TheStructure.Common.SourceRegisterAddress = value >> SOURCEREGISTERADDRESS_BIT_SHIFT;
6376    }
6377    inline uint32_t getSourceRegisterAddress() const {
6378        return TheStructure.Common.SourceRegisterAddress << SOURCEREGISTERADDRESS_BIT_SHIFT;
6379    }
6380    typedef enum tagDESTINATIONREGISTERADDRESS {
6381        DESTINATIONREGISTERADDRESS_BIT_SHIFT = 0x2,
6382        DESTINATIONREGISTERADDRESS_ALIGN_SIZE = 0x4,
6383    } DESTINATIONREGISTERADDRESS;
6384    inline void setDestinationRegisterAddress(const uint32_t value) {
6385        DEBUG_BREAK_IF(value > 0x7ffffc);
6386        TheStructure.Common.DestinationRegisterAddress = value >> DESTINATIONREGISTERADDRESS_BIT_SHIFT;
6387    }
6388    inline uint32_t getDestinationRegisterAddress() const {
6389        return TheStructure.Common.DestinationRegisterAddress << DESTINATIONREGISTERADDRESS_BIT_SHIFT;
6390    }
6391} MI_LOAD_REGISTER_REG;
6392STATIC_ASSERT(12 == sizeof(MI_LOAD_REGISTER_REG));
6393
6394typedef struct tagMI_SEMAPHORE_WAIT {
6395    union tagTheStructure {
6396        struct tagCommon {
6397            // DWORD 0
6398            uint32_t DwordLength : BITFIELD_RANGE(0, 7);
6399            uint32_t SemaphoreWaitContextSwitchMode : BITFIELD_RANGE(8, 9);
6400            uint32_t Reserved_10 : BITFIELD_RANGE(10, 11);
6401            uint32_t CompareOperation : BITFIELD_RANGE(12, 14);
6402            uint32_t WaitMode : BITFIELD_RANGE(15, 15);
6403            uint32_t RegisterPollMode : BITFIELD_RANGE(16, 16);
6404            uint32_t Reserved_17 : BITFIELD_RANGE(17, 17);
6405            uint32_t WorkloadPartitionIdOffsetEnable : BITFIELD_RANGE(18, 18);
6406            uint32_t Reserved_19 : BITFIELD_RANGE(19, 21);
6407            uint32_t MemoryType : BITFIELD_RANGE(22, 22);
6408            uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28);
6409            uint32_t CommandType : BITFIELD_RANGE(29, 31);
6410            // DWORD 1
6411            uint32_t SemaphoreDataDword;
6412            // DWORD 2
6413            uint64_t Reserved_64 : BITFIELD_RANGE(0, 1);
6414            uint64_t SemaphoreAddress : BITFIELD_RANGE(2, 56);
6415            uint64_t SemaphoreAddressReserved_121 : BITFIELD_RANGE(57, 63);
6416            // DWORD 4
6417            uint32_t Reserved_128 : BITFIELD_RANGE(0, 1);
6418            uint32_t WaitTokenNumber : BITFIELD_RANGE(2, 9);
6419            uint32_t Reserved_138 : BITFIELD_RANGE(10, 21);
6420            uint32_t ContextSwitchWaitTime : BITFIELD_RANGE(22, 31);
6421        } Common;
6422        uint32_t RawData[5];
6423    } TheStructure;
6424    typedef enum tagDWORD_LENGTH {
6425        DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x3,
6426    } DWORD_LENGTH;
6427    typedef enum tagSEMAPHORE_WAIT_CONTEXT_SWITCH_MODE {
6428        SEMAPHORE_WAIT_CONTEXT_SWITCH_MODE_LEGACY_MODE = 0x0,
6429        SEMAPHORE_WAIT_CONTEXT_SWITCH_MODE_CONTEXT_SWITCH_ON_UN_SUCCESSFUL_SEMAPHORE_WAIT = 0x1,
6430        SEMAPHORE_WAIT_CONTEXT_SWITCH_MODE_INHIBIT_CONTEXT_SWITCH_ON_UN_SUCCESSFUL_SEMAPHORE_WAIT = 0x2,
6431        SEMAPHORE_WAIT_CONTEXT_SWITCH_MODE_DELAY_CONTEXT_SWITCH_ON_UN_SUCCESSFUL_SEMAPHORE_WAIT = 0x3,
6432    } SEMAPHORE_WAIT_CONTEXT_SWITCH_MODE;
6433    typedef enum tagCOMPARE_OPERATION {
6434        COMPARE_OPERATION_SAD_GREATER_THAN_SDD = 0x0,
6435        COMPARE_OPERATION_SAD_GREATER_THAN_OR_EQUAL_SDD = 0x1,
6436        COMPARE_OPERATION_SAD_LESS_THAN_SDD = 0x2,
6437        COMPARE_OPERATION_SAD_LESS_THAN_OR_EQUAL_SDD = 0x3,
6438        COMPARE_OPERATION_SAD_EQUAL_SDD = 0x4,
6439        COMPARE_OPERATION_SAD_NOT_EQUAL_SDD = 0x5,
6440    } COMPARE_OPERATION;
6441    typedef enum tagWAIT_MODE {
6442        WAIT_MODE_SIGNAL_MODE = 0x0,
6443        WAIT_MODE_POLLING_MODE = 0x1,
6444    } WAIT_MODE;
6445    typedef enum tagREGISTER_POLL_MODE {
6446        REGISTER_POLL_MODE_MEMORY_POLL = 0x0,
6447        REGISTER_POLL_MODE_REGISTER_POLL = 0x1,
6448    } REGISTER_POLL_MODE;
6449    typedef enum tagMEMORY_TYPE {
6450        MEMORY_TYPE_PER_PROCESS_GRAPHICS_ADDRESS = 0x0,
6451        MEMORY_TYPE_GLOBAL_GRAPHICS_ADDRESS = 0x1,
6452    } MEMORY_TYPE;
6453    typedef enum tagMI_COMMAND_OPCODE {
6454        MI_COMMAND_OPCODE_MI_SEMAPHORE_WAIT = 0x1c,
6455    } MI_COMMAND_OPCODE;
6456    typedef enum tagCOMMAND_TYPE {
6457        COMMAND_TYPE_MI_COMMAND = 0x0,
6458    } COMMAND_TYPE;
6459    inline void init() {
6460        memset(&TheStructure, 0, sizeof(TheStructure));
6461        TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1;
6462        TheStructure.Common.CompareOperation =
6463            COMPARE_OPERATION_SAD_GREATER_THAN_SDD;
6464        TheStructure.Common.WaitMode = WAIT_MODE_SIGNAL_MODE;
6465        TheStructure.Common.RegisterPollMode = REGISTER_POLL_MODE_MEMORY_POLL;
6466        TheStructure.Common.MemoryType = MEMORY_TYPE_PER_PROCESS_GRAPHICS_ADDRESS;
6467        TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_SEMAPHORE_WAIT;
6468        TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND;
6469    }
6470    static tagMI_SEMAPHORE_WAIT sInit() {
6471        MI_SEMAPHORE_WAIT state;
6472        state.init();
6473        return state;
6474    }
6475    inline uint32_t &getRawData(const uint32_t index) {
6476        UNRECOVERABLE_IF(index >= 5);
6477        return TheStructure.RawData[index];
6478    }
6479    inline void setSemaphoreWaitContextSwitchMode(const SEMAPHORE_WAIT_CONTEXT_SWITCH_MODE value) {
6480        TheStructure.Common.SemaphoreWaitContextSwitchMode = value;
6481    }
6482    inline SEMAPHORE_WAIT_CONTEXT_SWITCH_MODE getSemaphoreWaitContextSwitchMode() const {
6483        return static_cast<SEMAPHORE_WAIT_CONTEXT_SWITCH_MODE>(TheStructure.Common.SemaphoreWaitContextSwitchMode);
6484    }
6485    inline void setCompareOperation(const COMPARE_OPERATION value) {
6486        TheStructure.Common.CompareOperation = value;
6487    }
6488    inline COMPARE_OPERATION getCompareOperation() const {
6489        return static_cast<COMPARE_OPERATION>(TheStructure.Common.CompareOperation);
6490    }
6491    inline void setWaitMode(const WAIT_MODE value) {
6492        TheStructure.Common.WaitMode = value;
6493    }
6494    inline WAIT_MODE getWaitMode() const {
6495        return static_cast<WAIT_MODE>(TheStructure.Common.WaitMode);
6496    }
6497    inline void setRegisterPollMode(const REGISTER_POLL_MODE value) {
6498        TheStructure.Common.RegisterPollMode = value;
6499    }
6500    inline REGISTER_POLL_MODE getRegisterPollMode() const {
6501        return static_cast<REGISTER_POLL_MODE>(
6502            TheStructure.Common.RegisterPollMode);
6503    }
6504    inline void setWorkloadPartitionIdOffsetEnable(const bool value) {
6505        TheStructure.Common.WorkloadPartitionIdOffsetEnable = value;
6506    }
6507    inline bool getWorkloadPartitionIdOffsetEnable() const {
6508        return TheStructure.Common.WorkloadPartitionIdOffsetEnable;
6509    }
6510    inline void setMemoryType(const MEMORY_TYPE value) {
6511        TheStructure.Common.MemoryType = value;
6512    }
6513    inline MEMORY_TYPE getMemoryType() const {
6514        return static_cast<MEMORY_TYPE>(TheStructure.Common.MemoryType);
6515    }
6516    inline void setSemaphoreDataDword(const uint32_t value) {
6517        TheStructure.Common.SemaphoreDataDword = value;
6518    }
6519    inline uint32_t getSemaphoreDataDword() const {
6520        return TheStructure.Common.SemaphoreDataDword;
6521    }
6522    typedef enum tagSEMAPHOREADDRESS {
6523        SEMAPHOREADDRESS_BIT_SHIFT = 0x2,
6524        SEMAPHOREADDRESS_ALIGN_SIZE = 0x4,
6525    } SEMAPHOREADDRESS;
6526    inline void setSemaphoreGraphicsAddress(const uint64_t value) {
6527        TheStructure.Common.SemaphoreAddress = value >> SEMAPHOREADDRESS_BIT_SHIFT;
6528    }
6529    inline uint64_t getSemaphoreGraphicsAddress() const {
6530        return TheStructure.Common.SemaphoreAddress << SEMAPHOREADDRESS_BIT_SHIFT;
6531    }
6532    inline void setWaitTokenNumber(const uint32_t value) {
6533        UNRECOVERABLE_IF(value > 0x3fc);
6534        TheStructure.Common.WaitTokenNumber = value;
6535    }
6536    inline uint32_t getWaitTokenNumber() const {
6537        return TheStructure.Common.WaitTokenNumber;
6538    }
6539    inline void setContextSwitchWaitTime(const uint32_t value) {
6540        UNRECOVERABLE_IF(value > 0xffc00000);
6541        TheStructure.Common.ContextSwitchWaitTime = value;
6542    }
6543    inline uint32_t getContextSwitchWaitTime() const {
6544        return TheStructure.Common.ContextSwitchWaitTime;
6545    }
6546} MI_SEMAPHORE_WAIT;
6547STATIC_ASSERT(20 == sizeof(MI_SEMAPHORE_WAIT));
6548
6549typedef struct tagMI_STORE_DATA_IMM {
6550    union tagTheStructure {
6551        struct tagCommon {
6552            // DWORD 0
6553            uint32_t DwordLength : BITFIELD_RANGE(0, 9);
6554            uint32_t Reserved_10 : BITFIELD_RANGE(10, 10);
6555            uint32_t WorkloadPartitionIdOffsetEnable : BITFIELD_RANGE(11, 11);
6556            uint32_t Reserved_12 : BITFIELD_RANGE(12, 12);
6557            uint32_t Reserved_13 : BITFIELD_RANGE(13, 20);
6558            uint32_t StoreQword : BITFIELD_RANGE(21, 21);
6559            uint32_t UseGlobalGtt : BITFIELD_RANGE(22, 22);
6560            uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28);
6561            uint32_t CommandType : BITFIELD_RANGE(29, 31);
6562            // DWORD 1
6563            uint64_t CoreModeEnable : BITFIELD_RANGE(0, 0);
6564            uint64_t Reserved_33 : BITFIELD_RANGE(1, 1);
6565            uint64_t Address : BITFIELD_RANGE(2, 56);
6566            uint64_t AddressReserved_89 : BITFIELD_RANGE(57, 63);
6567            // DWORD 3
6568            uint32_t DataDword0;
6569            // DWORD 4
6570            uint32_t DataDword1;
6571        } Common;
6572        uint32_t RawData[5];
6573    } TheStructure;
6574    typedef enum tagDWORD_LENGTH {
6575        DWORD_LENGTH_STORE_DWORD = 0x2,
6576        DWORD_LENGTH_STORE_QWORD = 0x3,
6577    } DWORD_LENGTH;
6578    typedef enum tagMI_COMMAND_OPCODE {
6579        MI_COMMAND_OPCODE_MI_STORE_DATA_IMM = 0x20,
6580    } MI_COMMAND_OPCODE;
6581    typedef enum tagCOMMAND_TYPE {
6582        COMMAND_TYPE_MI_COMMAND = 0x0,
6583    } COMMAND_TYPE;
6584    inline void init() {
6585        memset(&TheStructure, 0, sizeof(TheStructure));
6586        TheStructure.Common.DwordLength = DWORD_LENGTH_STORE_DWORD;
6587        TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_STORE_DATA_IMM;
6588        TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND;
6589    }
6590    static tagMI_STORE_DATA_IMM sInit() {
6591        MI_STORE_DATA_IMM state;
6592        state.init();
6593        return state;
6594    }
6595    inline uint32_t &getRawData(const uint32_t index) {
6596        UNRECOVERABLE_IF(index >= 5);
6597        return TheStructure.RawData[index];
6598    }
6599    inline void setDwordLength(const DWORD_LENGTH value) {
6600        TheStructure.Common.DwordLength = value;
6601    }
6602    inline DWORD_LENGTH getDwordLength() const {
6603        return static_cast<DWORD_LENGTH>(TheStructure.Common.DwordLength);
6604    }
6605    inline void setWorkloadPartitionIdOffsetEnable(const bool value) {
6606        TheStructure.Common.WorkloadPartitionIdOffsetEnable = value;
6607    }
6608    inline bool getWorkloadPartitionIdOffsetEnable() const {
6609        return TheStructure.Common.WorkloadPartitionIdOffsetEnable;
6610    }
6611    inline void setStoreQword(const bool value) {
6612        TheStructure.Common.StoreQword = value;
6613    }
6614    inline bool getStoreQword() const {
6615        return TheStructure.Common.StoreQword;
6616    }
6617    inline void setUseGlobalGtt(const bool value) {
6618        TheStructure.Common.UseGlobalGtt = value;
6619    }
6620    inline bool getUseGlobalGtt() const {
6621        return TheStructure.Common.UseGlobalGtt;
6622    }
6623    inline void setCoreModeEnable(const uint64_t value) {
6624        TheStructure.Common.CoreModeEnable = value;
6625    }
6626    inline uint64_t getCoreModeEnable() const {
6627        return TheStructure.Common.CoreModeEnable;
6628    }
6629    typedef enum tagADDRESS {
6630        ADDRESS_BIT_SHIFT = 0x2,
6631        ADDRESS_ALIGN_SIZE = 0x4,
6632    } ADDRESS;
6633    inline void setAddress(const uint64_t value) {
6634        UNRECOVERABLE_IF(value > 0x1fffffffffffffcL);
6635        TheStructure.Common.Address = value >> ADDRESS_BIT_SHIFT;
6636    }
6637    inline uint64_t getAddress() const {
6638        return TheStructure.Common.Address << ADDRESS_BIT_SHIFT;
6639    }
6640    inline void setDataDword0(const uint32_t value) {
6641        TheStructure.Common.DataDword0 = value;
6642    }
6643    inline uint32_t getDataDword0() const {
6644        return TheStructure.Common.DataDword0;
6645    }
6646    inline void setDataDword1(const uint32_t value) {
6647        TheStructure.Common.DataDword1 = value;
6648    }
6649    inline uint32_t getDataDword1() const {
6650        return TheStructure.Common.DataDword1;
6651    }
6652} MI_STORE_DATA_IMM;
6653STATIC_ASSERT(20 == sizeof(MI_STORE_DATA_IMM));
6654
6655typedef struct tagMI_STORE_REGISTER_MEM {
6656    union tagTheStructure {
6657        struct tagCommon {
6658            // DWORD 0
6659            uint32_t DwordLength : BITFIELD_RANGE(0, 7);
6660            uint32_t Reserved_8 : BITFIELD_RANGE(8, 15);
6661            uint32_t WorkloadPartitionIdOffsetEnable : BITFIELD_RANGE(16, 16);
6662            uint32_t MmioRemapEnable : BITFIELD_RANGE(17, 17);
6663            uint32_t Reserved_18 : BITFIELD_RANGE(18, 18);
6664            uint32_t AddCsMmioStartOffset : BITFIELD_RANGE(19, 19);
6665            uint32_t Reserved_20 : BITFIELD_RANGE(20, 20);
6666            uint32_t PredicateEnable : BITFIELD_RANGE(21, 21);
6667            uint32_t UseGlobalGtt : BITFIELD_RANGE(22, 22);
6668            uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28);
6669            uint32_t CommandType : BITFIELD_RANGE(29, 31);
6670            // DWORD 1
6671            uint32_t Reserved_32 : BITFIELD_RANGE(0, 1);
6672            uint32_t RegisterAddress : BITFIELD_RANGE(2, 22);
6673            uint32_t Reserved_55 : BITFIELD_RANGE(23, 31);
6674            // DWORD 2
6675            uint64_t Reserved_64 : BITFIELD_RANGE(0, 1);
6676            uint64_t MemoryAddress : BITFIELD_RANGE(2, 63);
6677        } Common;
6678        uint32_t RawData[4];
6679    } TheStructure;
6680    typedef enum tagDWORD_LENGTH {
6681        DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x2,
6682    } DWORD_LENGTH;
6683    typedef enum tagMI_COMMAND_OPCODE {
6684        MI_COMMAND_OPCODE_MI_STORE_REGISTER_MEM = 0x24,
6685    } MI_COMMAND_OPCODE;
6686    typedef enum tagCOMMAND_TYPE {
6687        COMMAND_TYPE_MI_COMMAND = 0x0,
6688    } COMMAND_TYPE;
6689    inline void init() {
6690        memset(&TheStructure, 0, sizeof(TheStructure));
6691        TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1;
6692        TheStructure.Common.MiCommandOpcode =
6693            MI_COMMAND_OPCODE_MI_STORE_REGISTER_MEM;
6694        TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND;
6695    }
6696    static tagMI_STORE_REGISTER_MEM sInit() {
6697        MI_STORE_REGISTER_MEM state;
6698        state.init();
6699        return state;
6700    }
6701    inline uint32_t &getRawData(const uint32_t index) {
6702        UNRECOVERABLE_IF(index >= 4);
6703        return TheStructure.RawData[index];
6704    }
6705    inline void setWorkloadPartitionIdOffsetEnable(const bool value) {
6706        TheStructure.Common.WorkloadPartitionIdOffsetEnable = value;
6707    }
6708    inline bool getWorkloadPartitionIdOffsetEnable() const {
6709        return TheStructure.Common.WorkloadPartitionIdOffsetEnable;
6710    }
6711    inline void setMmioRemapEnable(const bool value) {
6712        TheStructure.Common.MmioRemapEnable = value;
6713    }
6714    inline bool getMmioRemapEnable() const {
6715        return TheStructure.Common.MmioRemapEnable;
6716    }
6717    inline void setAddCsMmioStartOffset(const uint32_t value) {
6718        TheStructure.Common.AddCsMmioStartOffset = value;
6719    }
6720    inline uint32_t getAddCsMmioStartOffset() const {
6721        return TheStructure.Common.AddCsMmioStartOffset;
6722    }
6723    inline void setPredicateEnable(const bool value) {
6724        TheStructure.Common.PredicateEnable = value;
6725    }
6726    inline bool getPredicateEnable() const {
6727        return TheStructure.Common.PredicateEnable;
6728    }
6729    inline void setUseGlobalGtt(const bool value) {
6730        TheStructure.Common.UseGlobalGtt = value;
6731    }
6732    inline bool getUseGlobalGtt() const {
6733        return TheStructure.Common.UseGlobalGtt;
6734    }
6735    typedef enum tagREGISTERADDRESS {
6736        REGISTERADDRESS_BIT_SHIFT = 0x2,
6737        REGISTERADDRESS_ALIGN_SIZE = 0x4,
6738    } REGISTERADDRESS;
6739    inline void setRegisterAddress(const uint32_t value) {
6740        UNRECOVERABLE_IF(value > 0x7ffffc);
6741        TheStructure.Common.RegisterAddress = value >> REGISTERADDRESS_BIT_SHIFT;
6742    }
6743    inline uint32_t getRegisterAddress() const {
6744        return TheStructure.Common.RegisterAddress << REGISTERADDRESS_BIT_SHIFT;
6745    }
6746    typedef enum tagMEMORYADDRESS {
6747        MEMORYADDRESS_BIT_SHIFT = 0x2,
6748        MEMORYADDRESS_ALIGN_SIZE = 0x4,
6749    } MEMORYADDRESS;
6750    inline void setMemoryAddress(const uint64_t value) {
6751        UNRECOVERABLE_IF(value > 0xfffffffffffffffcL);
6752        TheStructure.Common.MemoryAddress = value >> MEMORYADDRESS_BIT_SHIFT;
6753    }
6754    inline uint64_t getMemoryAddress() const {
6755        return TheStructure.Common.MemoryAddress << MEMORYADDRESS_BIT_SHIFT;
6756    }
6757} MI_STORE_REGISTER_MEM;
6758STATIC_ASSERT(16 == sizeof(MI_STORE_REGISTER_MEM));
6759
6760typedef struct tagPIPELINE_SELECT {
6761    union tagTheStructure {
6762        struct tagCommon {
6763            // DWORD 0
6764            uint32_t PipelineSelection : BITFIELD_RANGE(0, 1);
6765            uint32_t RenderSliceCommonPowerGateEnable : BITFIELD_RANGE(2, 2);
6766            uint32_t RenderSamplerPowerGateEnable : BITFIELD_RANGE(3, 3);
6767            uint32_t MediaSamplerDopClockGateEnable : BITFIELD_RANGE(4, 4);
6768            uint32_t Reserved_5 : BITFIELD_RANGE(5, 5);
6769            uint32_t MediaSamplerPowerClockGateDisable : BITFIELD_RANGE(6, 6);
6770            uint32_t SystolicModeEnable : BITFIELD_RANGE(7, 7);
6771            uint32_t MaskBits : BITFIELD_RANGE(8, 15);
6772            uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23);
6773            uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26);
6774            uint32_t CommandSubtype : BITFIELD_RANGE(27, 28);
6775            uint32_t CommandType : BITFIELD_RANGE(29, 31);
6776        } Common;
6777        uint32_t RawData[1];
6778    } TheStructure;
6779    typedef enum tagPIPELINE_SELECTION {
6780        PIPELINE_SELECTION_3D = 0x0,
6781        PIPELINE_SELECTION_GPGPU = 0x2,
6782    } PIPELINE_SELECTION;
6783    typedef enum tag_3D_COMMAND_SUB_OPCODE {
6784        _3D_COMMAND_SUB_OPCODE_PIPELINE_SELECT = 0x4,
6785    } _3D_COMMAND_SUB_OPCODE;
6786    typedef enum tag_3D_COMMAND_OPCODE {
6787        _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED = 0x1,
6788    } _3D_COMMAND_OPCODE;
6789    typedef enum tagCOMMAND_SUBTYPE {
6790        COMMAND_SUBTYPE_GFXPIPE_SINGLE_DW = 0x1,
6791    } COMMAND_SUBTYPE;
6792    typedef enum tagCOMMAND_TYPE {
6793        COMMAND_TYPE_GFXPIPE = 0x3,
6794    } COMMAND_TYPE;
6795    inline void init() {
6796        memset(&TheStructure, 0, sizeof(TheStructure));
6797        TheStructure.Common.PipelineSelection = PIPELINE_SELECTION_3D;
6798        TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_PIPELINE_SELECT;
6799        TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED;
6800        TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_SINGLE_DW;
6801        TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE;
6802    }
6803    static tagPIPELINE_SELECT sInit() {
6804        PIPELINE_SELECT state;
6805        state.init();
6806        return state;
6807    }
6808    inline uint32_t &getRawData(const uint32_t index) {
6809        UNRECOVERABLE_IF(index >= 1);
6810        return TheStructure.RawData[index];
6811    }
6812    inline void setPipelineSelection(const PIPELINE_SELECTION value) {
6813        TheStructure.Common.PipelineSelection = value;
6814    }
6815    inline PIPELINE_SELECTION getPipelineSelection() const {
6816        return static_cast<PIPELINE_SELECTION>(TheStructure.Common.PipelineSelection);
6817    }
6818    inline void setRenderSliceCommonPowerGateEnable(const bool value) {
6819        TheStructure.Common.RenderSliceCommonPowerGateEnable = value;
6820    }
6821    inline bool getRenderSliceCommonPowerGateEnable() const {
6822        return TheStructure.Common.RenderSliceCommonPowerGateEnable;
6823    }
6824    inline void setRenderSamplerPowerGateEnable(const bool value) {
6825        TheStructure.Common.RenderSamplerPowerGateEnable = value;
6826    }
6827    inline bool getRenderSamplerPowerGateEnable() const {
6828        return TheStructure.Common.RenderSamplerPowerGateEnable;
6829    }
6830    inline void setMediaSamplerDopClockGateEnable(const bool value) {
6831        TheStructure.Common.MediaSamplerDopClockGateEnable = value;
6832    }
6833    inline bool getMediaSamplerDopClockGateEnable() const {
6834        return TheStructure.Common.MediaSamplerDopClockGateEnable;
6835    }
6836    inline void setMediaSamplerPowerClockGateDisable(const bool value) {
6837        TheStructure.Common.MediaSamplerPowerClockGateDisable = value;
6838    }
6839    inline bool getMediaSamplerPowerClockGateDisable() const {
6840        return TheStructure.Common.MediaSamplerPowerClockGateDisable;
6841    }
6842    inline void setSystolicModeEnable(const bool value) {
6843        TheStructure.Common.SystolicModeEnable = value;
6844    }
6845    inline bool getSystolicModeEnable() const {
6846        return TheStructure.Common.SystolicModeEnable;
6847    }
6848    inline void setMaskBits(const uint32_t value) {
6849        UNRECOVERABLE_IF(value > 0xff00);
6850        TheStructure.Common.MaskBits = value;
6851    }
6852    inline uint32_t getMaskBits() const {
6853        return TheStructure.Common.MaskBits;
6854    }
6855} PIPELINE_SELECT;
6856STATIC_ASSERT(4 == sizeof(PIPELINE_SELECT));
6857
6858typedef struct tagSTATE_COMPUTE_MODE {
6859    union tagTheStructure {
6860        struct tagCommon {
6861            // DWORD 0
6862            uint32_t DwordLength : BITFIELD_RANGE(0, 7);
6863            uint32_t Reserved_8 : BITFIELD_RANGE(8, 15);
6864            uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23);
6865            uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26);
6866            uint32_t CommandSubtype : BITFIELD_RANGE(27, 28);
6867            uint32_t CommandType : BITFIELD_RANGE(29, 31);
6868            // DWORD 1
6869            uint32_t Reserved_32 : BITFIELD_RANGE(0, 2);
6870            uint32_t ForceNonCoherent : BITFIELD_RANGE(3, 4);
6871            uint32_t FastClearDisabledOnCompressedSurface : BITFIELD_RANGE(5, 5);
6872            uint32_t DisableSlmReadMergeOptimization : BITFIELD_RANGE(6, 6);
6873            uint32_t Reserved_39 : BITFIELD_RANGE(7, 10);
6874            uint32_t DisableAtomicOnClearData : BITFIELD_RANGE(11, 11);
6875            uint32_t Reserved_44 : BITFIELD_RANGE(12, 12);
6876            uint32_t EuThreadSchedulingModeOverride : BITFIELD_RANGE(13, 14);
6877            uint32_t LargeGrfMode : BITFIELD_RANGE(15, 15);
6878            uint32_t Mask : BITFIELD_RANGE(16, 31);
6879        } Common;
6880        uint32_t RawData[2];
6881    } TheStructure;
6882    typedef enum tagDWORD_LENGTH {
6883        DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x0,
6884    } DWORD_LENGTH;
6885    typedef enum tag_3D_COMMAND_SUB_OPCODE {
6886        _3D_COMMAND_SUB_OPCODE_STATE_COMPUTE_MODE = 0x5,
6887    } _3D_COMMAND_SUB_OPCODE;
6888    typedef enum tag_3D_COMMAND_OPCODE {
6889        _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED = 0x1,
6890    } _3D_COMMAND_OPCODE;
6891    typedef enum tagCOMMAND_SUBTYPE {
6892        COMMAND_SUBTYPE_GFXPIPE_COMMON = 0x0,
6893    } COMMAND_SUBTYPE;
6894    typedef enum tagCOMMAND_TYPE {
6895        COMMAND_TYPE_GFXPIPE = 0x3,
6896    } COMMAND_TYPE;
6897    typedef enum tagFORCE_NON_COHERENT {
6898        FORCE_NON_COHERENT_FORCE_DISABLED = 0x0,
6899        FORCE_NON_COHERENT_FORCE_CPU_NON_COHERENT = 0x1,
6900        FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT = 0x2,
6901    } FORCE_NON_COHERENT;
6902    typedef enum tagFAST_CLEAR_DISABLED_ON_COMPRESSED_SURFACE {
6903        FAST_CLEAR_DISABLED_ON_COMPRESSED_SURFACE_ENABLED = 0x0,
6904        FAST_CLEAR_DISABLED_ON_COMPRESSED_SURFACE_DISABLED = 0x1,
6905    } FAST_CLEAR_DISABLED_ON_COMPRESSED_SURFACE;
6906    typedef enum tagDISABLE_SLM_READ_MERGE_OPTIMIZATION {
6907        DISABLE_SLM_READ_MERGE_OPTIMIZATION_ENABLED = 0x0,
6908        DISABLE_SLM_READ_MERGE_OPTIMIZATION_DISABLED = 0x1,
6909    } DISABLE_SLM_READ_MERGE_OPTIMIZATION;
6910    typedef enum tagDISABLE_ATOMIC_ON_CLEAR_DATA {
6911        DISABLE_ATOMIC_ON_CLEAR_DATA_ENABLE = 0x0,
6912        DISABLE_ATOMIC_ON_CLEAR_DATA_DISABLE = 0x1,
6913    } DISABLE_ATOMIC_ON_CLEAR_DATA;
6914    typedef enum tagEU_THREAD_SCHEDULING_MODE_OVERRIDE {
6915        EU_THREAD_SCHEDULING_MODE_OVERRIDE_HW_DEFAULT = 0x0,
6916        EU_THREAD_SCHEDULING_MODE_OVERRIDE_OLDEST_FIRST = 0x1,
6917        EU_THREAD_SCHEDULING_MODE_OVERRIDE_ROUND_ROBIN = 0x2,
6918        EU_THREAD_SCHEDULING_MODE_OVERRIDE_STALL_BASED_ROUND_ROBIN = 0x3,
6919    } EU_THREAD_SCHEDULING_MODE_OVERRIDE;
6920    inline void init() {
6921        memset(&TheStructure, 0, sizeof(TheStructure));
6922        TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1;
6923        TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_STATE_COMPUTE_MODE;
6924        TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED;
6925        TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_COMMON;
6926        TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE;
6927        TheStructure.Common.ForceNonCoherent = FORCE_NON_COHERENT_FORCE_DISABLED;
6928        TheStructure.Common.FastClearDisabledOnCompressedSurface = FAST_CLEAR_DISABLED_ON_COMPRESSED_SURFACE_ENABLED;
6929        TheStructure.Common.DisableSlmReadMergeOptimization = DISABLE_SLM_READ_MERGE_OPTIMIZATION_ENABLED;
6930        TheStructure.Common.DisableAtomicOnClearData = DISABLE_ATOMIC_ON_CLEAR_DATA_ENABLE;
6931        TheStructure.Common.EuThreadSchedulingModeOverride = EU_THREAD_SCHEDULING_MODE_OVERRIDE_HW_DEFAULT;
6932    }
6933    static tagSTATE_COMPUTE_MODE sInit() {
6934        STATE_COMPUTE_MODE state;
6935        state.init();
6936        return state;
6937    }
6938    inline uint32_t &getRawData(const uint32_t index) {
6939        UNRECOVERABLE_IF(index >= 2);
6940        return TheStructure.RawData[index];
6941    }
6942    inline void setForceNonCoherent(const FORCE_NON_COHERENT value) {
6943        TheStructure.Common.ForceNonCoherent = value;
6944    }
6945    inline FORCE_NON_COHERENT getForceNonCoherent() const {
6946        return static_cast<FORCE_NON_COHERENT>(TheStructure.Common.ForceNonCoherent);
6947    }
6948    inline void setFastClearDisabledOnCompressedSurface(const FAST_CLEAR_DISABLED_ON_COMPRESSED_SURFACE value) {
6949        TheStructure.Common.FastClearDisabledOnCompressedSurface = value;
6950    }
6951    inline FAST_CLEAR_DISABLED_ON_COMPRESSED_SURFACE getFastClearDisabledOnCompressedSurface() const {
6952        return static_cast<FAST_CLEAR_DISABLED_ON_COMPRESSED_SURFACE>(TheStructure.Common.FastClearDisabledOnCompressedSurface);
6953    }
6954    inline void setDisableSlmReadMergeOptimization(const DISABLE_SLM_READ_MERGE_OPTIMIZATION value) {
6955        TheStructure.Common.DisableSlmReadMergeOptimization = value;
6956    }
6957    inline DISABLE_SLM_READ_MERGE_OPTIMIZATION getDisableSlmReadMergeOptimization() const {
6958        return static_cast<DISABLE_SLM_READ_MERGE_OPTIMIZATION>(TheStructure.Common.DisableSlmReadMergeOptimization);
6959    }
6960    inline void setDisableAtomicOnClearData(const DISABLE_ATOMIC_ON_CLEAR_DATA value) {
6961        TheStructure.Common.DisableAtomicOnClearData = value;
6962    }
6963    inline DISABLE_ATOMIC_ON_CLEAR_DATA getDisableAtomicOnClearData() const {
6964        return static_cast<DISABLE_ATOMIC_ON_CLEAR_DATA>(TheStructure.Common.DisableAtomicOnClearData);
6965    }
6966    inline void setEuThreadSchedulingModeOverride(const EU_THREAD_SCHEDULING_MODE_OVERRIDE value) {
6967        TheStructure.Common.EuThreadSchedulingModeOverride = value;
6968    }
6969    inline EU_THREAD_SCHEDULING_MODE_OVERRIDE getEuThreadSchedulingModeOverride() const {
6970        return static_cast<EU_THREAD_SCHEDULING_MODE_OVERRIDE>(TheStructure.Common.EuThreadSchedulingModeOverride);
6971    }
6972    inline void setLargeGrfMode(const bool value) {
6973        TheStructure.Common.LargeGrfMode = value;
6974    }
6975    inline bool getLargeGrfMode() const {
6976        return TheStructure.Common.LargeGrfMode;
6977    }
6978    inline void setMaskBits(const uint32_t value) {
6979        UNRECOVERABLE_IF(value > 0xffff);
6980        TheStructure.Common.Mask = value;
6981    }
6982    inline uint32_t getMaskBits() const {
6983        return TheStructure.Common.Mask;
6984    }
6985} STATE_COMPUTE_MODE;
6986STATIC_ASSERT(8 == sizeof(STATE_COMPUTE_MODE));
6987
6988typedef struct tag_3DSTATE_BINDING_TABLE_POOL_ALLOC {
6989    union tagTheStructure {
6990        struct tagCommon {
6991            uint32_t DwordLength : BITFIELD_RANGE(0, 7);
6992            uint32_t Reserved_8 : BITFIELD_RANGE(8, 15);
6993            uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23);
6994            uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26);
6995            uint32_t CommandSubtype : BITFIELD_RANGE(27, 28);
6996            uint32_t CommandType : BITFIELD_RANGE(29, 31);
6997            uint64_t SurfaceObjectControlStateEncryptedData : BITFIELD_RANGE(0, 0);
6998            uint64_t SurfaceObjectControlStateIndexToMocsTables : BITFIELD_RANGE(1, 6);
6999            uint64_t Reserved_39 : BITFIELD_RANGE(7, 9);
7000            uint64_t Reserved_42 : BITFIELD_RANGE(10, 10);
7001            uint64_t Reserved_43 : BITFIELD_RANGE(11, 11);
7002            uint64_t BindingTablePoolBaseAddress : BITFIELD_RANGE(12, 47);
7003            uint64_t BindingTablePoolBaseAddressReserved_80 : BITFIELD_RANGE(48, 63);
7004            uint32_t Reserved_96 : BITFIELD_RANGE(0, 11);
7005            uint32_t BindingTablePoolBufferSize : BITFIELD_RANGE(12, 31);
7006        } Common;
7007        uint32_t RawData[4];
7008    } TheStructure;
7009    typedef enum tagDWORD_LENGTH {
7010        DWORD_LENGTH_DWORD_COUNT_N = 0x2,
7011    } DWORD_LENGTH;
7012    typedef enum tag_3D_COMMAND_SUB_OPCODE {
7013        _3D_COMMAND_SUB_OPCODE_3DSTATE_BINDING_TABLE_POOL_ALLOC = 0x19,
7014    } _3D_COMMAND_SUB_OPCODE;
7015    typedef enum tag_3D_COMMAND_OPCODE {
7016        _3D_COMMAND_OPCODE_3DSTATE_NONPIPELINED = 0x1,
7017    } _3D_COMMAND_OPCODE;
7018    typedef enum tagCOMMAND_SUBTYPE {
7019        COMMAND_SUBTYPE_GFXPIPE_3D = 0x3,
7020    } COMMAND_SUBTYPE;
7021    typedef enum tagCOMMAND_TYPE {
7022        COMMAND_TYPE_GFXPIPE = 0x3,
7023    } COMMAND_TYPE;
7024
7025    inline void init() {
7026        memset(&TheStructure, 0, sizeof(TheStructure));
7027        TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N;
7028        TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_3DSTATE_BINDING_TABLE_POOL_ALLOC;
7029        TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_3DSTATE_NONPIPELINED;
7030        TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_3D;
7031        TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE;
7032        TheStructure.Common.BindingTablePoolBufferSize = 0;
7033    }
7034    static tag_3DSTATE_BINDING_TABLE_POOL_ALLOC sInit() {
7035        _3DSTATE_BINDING_TABLE_POOL_ALLOC state;
7036        state.init();
7037        return state;
7038    }
7039    inline uint32_t &getRawData(const uint32_t index) {
7040        UNRECOVERABLE_IF(index >= 4);
7041        return TheStructure.RawData[index];
7042    }
7043    inline void setSurfaceObjectControlStateEncryptedData(const bool value) {
7044        TheStructure.Common.SurfaceObjectControlStateEncryptedData = value;
7045    }
7046    inline bool getSurfaceObjectControlStateEncryptedData() const {
7047        return TheStructure.Common.SurfaceObjectControlStateEncryptedData;
7048    }
7049    inline void setSurfaceObjectControlStateIndexToMocsTables(const uint64_t value) {
7050        UNRECOVERABLE_IF(value > 0x7eL);
7051        TheStructure.Common.SurfaceObjectControlStateIndexToMocsTables = value >> 1;
7052    }
7053    inline uint64_t getSurfaceObjectControlStateIndexToMocsTables() const {
7054        return (TheStructure.Common.SurfaceObjectControlStateIndexToMocsTables << 1);
7055    }
7056    typedef enum tagBINDINGTABLEPOOLBASEADDRESS {
7057        BINDINGTABLEPOOLBASEADDRESS_BIT_SHIFT = 0xc,
7058        BINDINGTABLEPOOLBASEADDRESS_ALIGN_SIZE = 0x1000,
7059    } BINDINGTABLEPOOLBASEADDRESS;
7060    inline void setBindingTablePoolBaseAddress(const uint64_t value) {
7061        TheStructure.Common.BindingTablePoolBaseAddress = value >> BINDINGTABLEPOOLBASEADDRESS_BIT_SHIFT;
7062    }
7063    inline uint64_t getBindingTablePoolBaseAddress() const {
7064        return TheStructure.Common.BindingTablePoolBaseAddress << BINDINGTABLEPOOLBASEADDRESS_BIT_SHIFT;
7065    }
7066    inline void setBindingTablePoolBufferSize(const uint32_t value) { TheStructure.Common.BindingTablePoolBufferSize = value; }
7067    inline uint32_t getBindingTablePoolBufferSize() const { return TheStructure.Common.BindingTablePoolBufferSize; }
7068} _3DSTATE_BINDING_TABLE_POOL_ALLOC;
7069STATIC_ASSERT(16 == sizeof(_3DSTATE_BINDING_TABLE_POOL_ALLOC));
7070
7071struct MI_MEM_FENCE {
7072    union tagTheStructure {
7073        struct tagCommon {
7074            uint32_t FenceType : BITFIELD_RANGE(0, 0);
7075            uint32_t Reserved_116 : BITFIELD_RANGE(1, 16);
7076            uint32_t MiCommandSubOpcode : BITFIELD_RANGE(17, 22);
7077            uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28);
7078            uint32_t CommandType : BITFIELD_RANGE(29, 31);
7079        } Common;
7080        uint32_t RawData[1];
7081    } TheStructure;
7082
7083    typedef enum tagFENCE_TYPE {
7084        FENCE_TYPE_RELEASE = 0x0,
7085        FENCE_TYPE_ACQUIRE = 0x1,
7086    } FENCE_TYPE;
7087
7088    inline void init() {
7089        memset(&TheStructure, 0, sizeof(TheStructure));
7090        TheStructure.Common.MiCommandOpcode = 0x9;
7091        TheStructure.Common.FenceType = FENCE_TYPE::FENCE_TYPE_RELEASE;
7092    }
7093
7094    static MI_MEM_FENCE sInit() {
7095        MI_MEM_FENCE memFence;
7096        memFence.init();
7097        return memFence;
7098    }
7099
7100    inline void setFenceType(const FENCE_TYPE value) {
7101        TheStructure.Common.FenceType = value;
7102    }
7103    inline FENCE_TYPE getAFenceType() const {
7104        return static_cast<FENCE_TYPE>(TheStructure.Common.FenceType);
7105    }
7106};
7107STATIC_ASSERT(4 == sizeof(MI_MEM_FENCE));
7108
7109struct STATE_SYSTEM_MEM_FENCE_ADDRESS {
7110    union tagTheStructure {
7111        struct tagCommon {
7112            // DWORD 0
7113            uint32_t DwordLength : BITFIELD_RANGE(0, 7);
7114            uint32_t Reserved814 : BITFIELD_RANGE(8, 14);
7115            uint32_t ContextRestoreInvalid : BITFIELD_RANGE(15, 15);
7116            uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23);
7117            uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26);
7118            uint32_t CommandSubType : BITFIELD_RANGE(27, 28);
7119            uint32_t CommandType : BITFIELD_RANGE(29, 31);
7120            // DWORD 1-2
7121            uint64_t Reserved011 : BITFIELD_RANGE(0, 11);
7122            uint64_t SystemMemoryFenceAddress : BITFIELD_RANGE(12, 63);
7123        } Common;
7124        uint32_t RawData[3];
7125    } TheStructure;
7126
7127    typedef enum tagSYSTEM_MEMORY_FENCE_ADDRESS {
7128        SYSTEM_MEMORY_FENCE_ADDRESS_BIT_SHIFT = 0xc,
7129    } SYSTEM_MEMORY_FENCE_ADDRESS;
7130
7131    inline void init() {
7132        memset(&TheStructure, 0, sizeof(TheStructure));
7133        TheStructure.Common.DwordLength = 0x1;
7134        TheStructure.Common._3DCommandSubOpcode = 0x9;
7135        TheStructure.Common._3DCommandOpcode = 0x1;
7136        TheStructure.Common.CommandType = 0x3;
7137    }
7138
7139    static STATE_SYSTEM_MEM_FENCE_ADDRESS sInit() {
7140        STATE_SYSTEM_MEM_FENCE_ADDRESS state;
7141        state.init();
7142        return state;
7143    }
7144
7145    inline void setContextRestoreInvalid(const bool value) {
7146        TheStructure.Common.ContextRestoreInvalid = value;
7147    }
7148    inline bool getContextRestoreInvalid() const {
7149        return TheStructure.Common.ContextRestoreInvalid;
7150    }
7151
7152    inline void setSystemMemoryFenceAddress(const uint64_t value) {
7153        TheStructure.Common.SystemMemoryFenceAddress = (value >> SYSTEM_MEMORY_FENCE_ADDRESS_BIT_SHIFT);
7154    }
7155    inline uint64_t getSystemMemoryFenceAddress() const {
7156        return (TheStructure.Common.SystemMemoryFenceAddress << SYSTEM_MEMORY_FENCE_ADDRESS_BIT_SHIFT);
7157    }
7158};
7159STATIC_ASSERT(12 == sizeof(STATE_SYSTEM_MEM_FENCE_ADDRESS));
7160
7161struct STATE_PREFETCH {
7162    union tagTheStructure {
7163        struct tagCommon {
7164            // DWORD 0
7165            uint32_t DwordLength : BITFIELD_RANGE(0, 7);
7166            uint32_t Reserved814 : BITFIELD_RANGE(8, 15);
7167            uint32_t _3dCommandSubOpcode : BITFIELD_RANGE(16, 23);
7168            uint32_t _3dCommandOpcode : BITFIELD_RANGE(24, 26);
7169            uint32_t CommandSubType : BITFIELD_RANGE(27, 28);
7170            uint32_t CommandType : BITFIELD_RANGE(29, 31);
7171            // DWORD 1
7172            uint32_t PrefetchSize : BITFIELD_RANGE(0, 9);
7173            uint32_t Reserved1015 : BITFIELD_RANGE(10, 15);
7174            uint32_t KernelInstructionPrefetch : BITFIELD_RANGE(16, 16);
7175            uint32_t Reserved1719 : BITFIELD_RANGE(17, 19);
7176            uint32_t ParserStall : BITFIELD_RANGE(20, 20);
7177            uint32_t Reserved2123 : BITFIELD_RANGE(21, 23);
7178            uint32_t MemoryObjectControlState : BITFIELD_RANGE(24, 30);
7179            uint32_t Reserved31 : BITFIELD_RANGE(31, 31);
7180            // DWORD 2-3
7181            uint64_t Reserved05 : BITFIELD_RANGE(0, 5);
7182            uint64_t Address : BITFIELD_RANGE(6, 63);
7183        } Common;
7184        uint32_t RawData[4];
7185    } TheStructure;
7186
7187    typedef enum tagADDRESS {
7188        ADDRESS_BIT_SHIFT = 0x6,
7189    } ADDRESS;
7190
7191    inline void init() {
7192        memset(&TheStructure, 0, sizeof(TheStructure));
7193        TheStructure.Common.DwordLength = 0x2;
7194        TheStructure.Common._3dCommandSubOpcode = 0x3;
7195        TheStructure.Common.CommandType = 0x3;
7196    }
7197
7198    static STATE_PREFETCH sInit() {
7199        STATE_PREFETCH state;
7200        state.init();
7201        return state;
7202    }
7203
7204    inline void setPrefetchSize(const uint32_t value) {
7205        TheStructure.Common.PrefetchSize = value;
7206    }
7207    inline uint32_t getPrefetchSize() const {
7208        return TheStructure.Common.PrefetchSize;
7209    }
7210
7211    inline void setKernelInstructionPrefetch(const bool value) {
7212        TheStructure.Common.KernelInstructionPrefetch = value;
7213    }
7214    inline bool getKernelInstructionPrefetch() const {
7215        return TheStructure.Common.KernelInstructionPrefetch;
7216    }
7217
7218    inline void setParserStall(const bool value) {
7219        TheStructure.Common.ParserStall = value;
7220    }
7221    inline bool getParserStall() const {
7222        return TheStructure.Common.ParserStall;
7223    }
7224
7225    inline void setMemoryObjectControlState(const uint32_t value) {
7226        TheStructure.Common.MemoryObjectControlState = value;
7227    }
7228    inline uint32_t getMemoryObjectControlState() const {
7229        return TheStructure.Common.MemoryObjectControlState;
7230    }
7231
7232    inline void setAddress(const uint64_t value) {
7233        TheStructure.Common.Address = (value >> ADDRESS_BIT_SHIFT);
7234    }
7235    inline uint64_t getAddress() const {
7236        return (TheStructure.Common.Address << ADDRESS_BIT_SHIFT);
7237    }
7238};
7239STATIC_ASSERT(16 == sizeof(STATE_PREFETCH));
7240
7241typedef struct tagMEM_SET {
7242    union tagTheStructure {
7243        struct tagCommon {
7244            // DWORD 0
7245            uint32_t DwordLength : BITFIELD_RANGE(0, 7);
7246            uint32_t CompressionFormat40 : BITFIELD_RANGE(8, 12);
7247            uint32_t DestinationCompressionEnable : BITFIELD_RANGE(13, 13);
7248            uint32_t Reserved_14 : BITFIELD_RANGE(14, 14);
7249            uint32_t DestinationCompressible : BITFIELD_RANGE(15, 15);
7250            uint32_t Reserved_16 : BITFIELD_RANGE(16, 16);
7251            uint32_t FillType : BITFIELD_RANGE(17, 18);
7252            uint32_t Reserved_19 : BITFIELD_RANGE(19, 21);
7253            uint32_t InstructionTarget_Opcode : BITFIELD_RANGE(22, 28);
7254            uint32_t Client : BITFIELD_RANGE(29, 31);
7255            // DWORD 1
7256            uint32_t FillWidth : BITFIELD_RANGE(0, 17);
7257            uint32_t Reserved_50 : BITFIELD_RANGE(18, 31);
7258            // DWORD 2
7259            uint32_t FillHeight : BITFIELD_RANGE(0, 17);
7260            uint32_t Reserved_82 : BITFIELD_RANGE(18, 31);
7261            // DWORD 3
7262            uint32_t DestinationPitch : BITFIELD_RANGE(0, 17);
7263            uint32_t Reserved_114 : BITFIELD_RANGE(18, 31);
7264            // DWORD 4
7265            uint64_t DestinationStartAddress;
7266            // DWORD 6
7267            uint32_t DestinationMOCS : BITFIELD_RANGE(0, 6);
7268            uint32_t Reserved_199 : BITFIELD_RANGE(7, 23);
7269            uint32_t FillData : BITFIELD_RANGE(24, 31);
7270        } Common;
7271        uint32_t RawData[7];
7272    } TheStructure;
7273    typedef enum tagDWORD_LENGTH {
7274        DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x5,
7275    } DWORD_LENGTH;
7276    typedef enum tagDESTINATION_COMPRESSION_ENABLE {
7277        DESTINATION_COMPRESSION_ENABLE_DISABLE = 0x0,
7278        DESTINATION_COMPRESSION_ENABLE_ENABLE = 0x1,
7279    } DESTINATION_COMPRESSION_ENABLE;
7280    typedef enum tagDESTINATION_COMPRESSIBLE {
7281        DESTINATION_COMPRESSIBLE_NOT_COMPRESSIBLE = 0x0,
7282        DESTINATION_COMPRESSIBLE_COMPRESSIBLE = 0x1,
7283    } DESTINATION_COMPRESSIBLE;
7284    typedef enum tagFILL_TYPE {
7285        FILL_TYPE_LINEAR_FILL = 0x0,
7286        FILL_TYPE_MATRIX_FILL = 0x1,
7287    } FILL_TYPE;
7288    typedef enum tagCLIENT {
7289        CLIENT_2D_PROCESSOR = 0x2,
7290    } CLIENT;
7291    typedef enum tagINSTRUCTIONTARGET_OPCODE {
7292        INSTRUCTIONTARGET_OPCODE_OPCODE = 0x5B,
7293    } INSTRUCTIONTARGET_OPCODE;
7294    inline void init() {
7295        memset(&TheStructure, 0, sizeof(TheStructure));
7296        TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1;
7297        TheStructure.Common.DestinationCompressionEnable = DESTINATION_COMPRESSION_ENABLE_DISABLE;
7298        TheStructure.Common.DestinationCompressible = DESTINATION_COMPRESSIBLE_NOT_COMPRESSIBLE;
7299        TheStructure.Common.FillType = FILL_TYPE_LINEAR_FILL;
7300        TheStructure.Common.Client = CLIENT_2D_PROCESSOR;
7301        TheStructure.Common.InstructionTarget_Opcode = INSTRUCTIONTARGET_OPCODE::INSTRUCTIONTARGET_OPCODE_OPCODE;
7302    }
7303    static tagMEM_SET sInit() {
7304        MEM_SET state;
7305        state.init();
7306        return state;
7307    }
7308    inline uint32_t &getRawData(const uint32_t index) {
7309        UNRECOVERABLE_IF(index >= 7);
7310        return TheStructure.RawData[index];
7311    }
7312    inline void setCompressionFormat40(const uint32_t value) {
7313        UNRECOVERABLE_IF(value > 0x1f);
7314        TheStructure.Common.CompressionFormat40 = value;
7315    }
7316    inline uint32_t getCompressionFormat40() const {
7317        return TheStructure.Common.CompressionFormat40;
7318    }
7319    inline void setDestinationCompressionEnable(const DESTINATION_COMPRESSION_ENABLE value) {
7320        TheStructure.Common.DestinationCompressionEnable = value;
7321    }
7322    inline DESTINATION_COMPRESSION_ENABLE getDestinationCompressionEnable() const {
7323        return static_cast<DESTINATION_COMPRESSION_ENABLE>(TheStructure.Common.DestinationCompressionEnable);
7324    }
7325    inline void setDestinationCompressible(const DESTINATION_COMPRESSIBLE value) {
7326        TheStructure.Common.DestinationCompressible = value;
7327    }
7328    inline DESTINATION_COMPRESSIBLE getDestinationCompressible() const {
7329        return static_cast<DESTINATION_COMPRESSIBLE>(TheStructure.Common.DestinationCompressible);
7330    }
7331    inline void setFillType(const FILL_TYPE value) {
7332        TheStructure.Common.FillType = value;
7333    }
7334    inline FILL_TYPE getFillType() const {
7335        return static_cast<FILL_TYPE>(TheStructure.Common.FillType);
7336    }
7337    inline void setInstructionTargetOpcode(const uint32_t value) {
7338        UNRECOVERABLE_IF(value > 0x7f);
7339        TheStructure.Common.InstructionTarget_Opcode = value;
7340    }
7341    inline uint32_t getInstructionTargetOpcode() const {
7342        return TheStructure.Common.InstructionTarget_Opcode;
7343    }
7344    inline void setClient(const CLIENT value) {
7345        TheStructure.Common.Client = value;
7346    }
7347    inline CLIENT getClient() const {
7348        return static_cast<CLIENT>(TheStructure.Common.Client);
7349    }
7350    inline void setFillWidth(const uint32_t value) {
7351        UNRECOVERABLE_IF(value > 0x3ffff);
7352        TheStructure.Common.FillWidth = value - 1;
7353    }
7354    inline uint32_t getFillWidth() const {
7355        return TheStructure.Common.FillWidth + 1;
7356    }
7357    inline void setFillHeight(const uint32_t value) {
7358        UNRECOVERABLE_IF(value > 0x3ffff);
7359        TheStructure.Common.FillHeight = value - 1;
7360    }
7361    inline uint32_t getFillHeight() const {
7362        return TheStructure.Common.FillHeight + 1;
7363    }
7364    inline void setDestinationPitch(const uint32_t value) {
7365        UNRECOVERABLE_IF(value > 0x3ffff);
7366        TheStructure.Common.DestinationPitch = value - 1;
7367    }
7368    inline uint32_t getDestinationPitch() const {
7369        return TheStructure.Common.DestinationPitch + 1;
7370    }
7371    inline void setDestinationStartAddress(const uint64_t value) {
7372        TheStructure.Common.DestinationStartAddress = value;
7373    }
7374    inline uint64_t getDestinationStartAddress() const {
7375        return TheStructure.Common.DestinationStartAddress;
7376    }
7377    inline void setDestinationMOCS(const uint32_t value) {
7378        UNRECOVERABLE_IF(value > 0x7f);
7379        TheStructure.Common.DestinationMOCS = value;
7380    }
7381    inline uint32_t getDestinationMOCS() const {
7382        return TheStructure.Common.DestinationMOCS;
7383    }
7384    inline void setFillData(const uint32_t value) {
7385        UNRECOVERABLE_IF(value > 0xff);
7386        TheStructure.Common.FillData = value;
7387    }
7388    inline uint32_t getFillData() const {
7389        return TheStructure.Common.FillData;
7390    }
7391} MEM_SET;
7392STATIC_ASSERT(28 == sizeof(MEM_SET));
7393
7394typedef struct tagSTATE_SIP {
7395    union tagTheStructure {
7396        struct tagCommon {
7397            // DWORD 0
7398            uint32_t DwordLength : BITFIELD_RANGE(0, 7);
7399            uint32_t Reserved_8 : BITFIELD_RANGE(8, 15);
7400            uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23);
7401            uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26);
7402            uint32_t CommandSubtype : BITFIELD_RANGE(27, 28);
7403            uint32_t CommandType : BITFIELD_RANGE(29, 31);
7404            // DWORD 1
7405            uint64_t Reserved_32 : BITFIELD_RANGE(0, 3);
7406            uint64_t SystemInstructionPointer : BITFIELD_RANGE(4, 63);
7407        } Common;
7408        uint32_t RawData[3];
7409    } TheStructure;
7410    typedef enum tagDWORD_LENGTH {
7411        DWORD_LENGTH_DWORD_COUNT_N = 0x1,
7412    } DWORD_LENGTH;
7413    typedef enum tag_3D_COMMAND_SUB_OPCODE {
7414        _3D_COMMAND_SUB_OPCODE_STATE_SIP = 0x2,
7415    } _3D_COMMAND_SUB_OPCODE;
7416    typedef enum tag_3D_COMMAND_OPCODE {
7417        _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED = 0x1,
7418    } _3D_COMMAND_OPCODE;
7419    typedef enum tagCOMMAND_SUBTYPE {
7420        COMMAND_SUBTYPE_GFXPIPE_COMMON = 0x0,
7421    } COMMAND_SUBTYPE;
7422    typedef enum tagCOMMAND_TYPE {
7423        COMMAND_TYPE_GFXPIPE = 0x3,
7424    } COMMAND_TYPE;
7425    inline void init() {
7426        memset(&TheStructure, 0, sizeof(TheStructure));
7427        TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N;
7428        TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_STATE_SIP;
7429        TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED;
7430        TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_COMMON;
7431        TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE;
7432    }
7433    static tagSTATE_SIP sInit() {
7434        STATE_SIP state;
7435        state.init();
7436        return state;
7437    }
7438    inline uint32_t &getRawData(const uint32_t index) {
7439        UNRECOVERABLE_IF(index >= 3);
7440        return TheStructure.RawData[index];
7441    }
7442    typedef enum tagSYSTEMINSTRUCTIONPOINTER {
7443        SYSTEMINSTRUCTIONPOINTER_BIT_SHIFT = 0x4,
7444        SYSTEMINSTRUCTIONPOINTER_ALIGN_SIZE = 0x10,
7445    } SYSTEMINSTRUCTIONPOINTER;
7446    inline void setSystemInstructionPointer(const uint64_t value) {
7447        UNRECOVERABLE_IF(value > 0xffffffffffffffffL);
7448        TheStructure.Common.SystemInstructionPointer = value >> SYSTEMINSTRUCTIONPOINTER_BIT_SHIFT;
7449    }
7450    inline uint64_t getSystemInstructionPointer() const {
7451        return TheStructure.Common.SystemInstructionPointer << SYSTEMINSTRUCTIONPOINTER_BIT_SHIFT;
7452    }
7453} STATE_SIP;
7454STATIC_ASSERT(12 == sizeof(STATE_SIP));
7455
7456typedef struct tagSAMPLER_BORDER_COLOR_STATE {
7457    union tagTheStructure {
7458        struct tagCommon {
7459            // DWORD 0
7460            float BorderColorRed;
7461            // DWORD 1
7462            float BorderColorGreen;
7463            // DWORD 2
7464            float BorderColorBlue;
7465            // DWORD 3
7466            float BorderColorAlpha;
7467        } Common;
7468        uint32_t RawData[4];
7469    } TheStructure;
7470    inline void init() {
7471        memset(&TheStructure, 0, sizeof(TheStructure));
7472        TheStructure.Common.BorderColorRed = 0.0;
7473        TheStructure.Common.BorderColorGreen = 0.0;
7474        TheStructure.Common.BorderColorBlue = 0.0;
7475        TheStructure.Common.BorderColorAlpha = 0.0;
7476    }
7477    static tagSAMPLER_BORDER_COLOR_STATE sInit() {
7478        SAMPLER_BORDER_COLOR_STATE state;
7479        state.init();
7480        return state;
7481    }
7482    inline uint32_t &getRawData(const uint32_t index) {
7483        UNRECOVERABLE_IF(index >= 4);
7484        return TheStructure.RawData[index];
7485    }
7486    inline void setBorderColorRed(const float value) {
7487        TheStructure.Common.BorderColorRed = value;
7488    }
7489    inline float getBorderColorRed() const {
7490        return TheStructure.Common.BorderColorRed;
7491    }
7492    inline void setBorderColorGreen(const float value) {
7493        TheStructure.Common.BorderColorGreen = value;
7494    }
7495    inline float getBorderColorGreen() const {
7496        return TheStructure.Common.BorderColorGreen;
7497    }
7498    inline void setBorderColorBlue(const float value) {
7499        TheStructure.Common.BorderColorBlue = value;
7500    }
7501    inline float getBorderColorBlue() const {
7502        return TheStructure.Common.BorderColorBlue;
7503    }
7504    inline void setBorderColorAlpha(const float value) {
7505        TheStructure.Common.BorderColorAlpha = value;
7506    }
7507    inline float getBorderColorAlpha() const {
7508        return TheStructure.Common.BorderColorAlpha;
7509    }
7510} SAMPLER_BORDER_COLOR_STATE;
7511STATIC_ASSERT(16 == sizeof(SAMPLER_BORDER_COLOR_STATE));
7512
7513#pragma pack()
7514