pub mod gen7 {
use crate::*;
#[derive(Clone, Copy)]
pub enum _3dColorBufferBlendFactor {
_3dColorBufferBlendFactorOne,
_3dColorBufferBlendFactorSrcColor,
_3dColorBufferBlendFactorSrcAlpha,
_3dColorBufferBlendFactorDstAlpha,
_3dColorBufferBlendFactorDstColor,
_3dColorBufferBlendFactorSrcAlphaSaturate,
_3dColorBufferBlendFactorConstColor,
_3dColorBufferBlendFactorConstAlpha,
_3dColorBufferBlendFactorSrc1Color,
_3dColorBufferBlendFactorSrc1Alpha,
_3dColorBufferBlendFactorZero,
_3dColorBufferBlendFactorInvSrcColor,
_3dColorBufferBlendFactorInvSrcAlpha,
_3dColorBufferBlendFactorInvDstAlpha,
_3dColorBufferBlendFactorInvDstColor,
_3dColorBufferBlendFactorInvConstColor,
_3dColorBufferBlendFactorInvConstAlpha,
_3dColorBufferBlendFactorInvSrc1Color,
_3dColorBufferBlendFactorInvSrc1Alpha,
Unknown(u32),
}
impl Into<u32> for _3dColorBufferBlendFactor {
fn into(self) -> u32 {
type E = _3dColorBufferBlendFactor;
match self {
E::_3dColorBufferBlendFactorOne => 1,
E::_3dColorBufferBlendFactorSrcColor => 2,
E::_3dColorBufferBlendFactorSrcAlpha => 3,
E::_3dColorBufferBlendFactorDstAlpha => 4,
E::_3dColorBufferBlendFactorDstColor => 5,
E::_3dColorBufferBlendFactorSrcAlphaSaturate => 6,
E::_3dColorBufferBlendFactorConstColor => 7,
E::_3dColorBufferBlendFactorConstAlpha => 8,
E::_3dColorBufferBlendFactorSrc1Color => 9,
E::_3dColorBufferBlendFactorSrc1Alpha => 10,
E::_3dColorBufferBlendFactorZero => 17,
E::_3dColorBufferBlendFactorInvSrcColor => 18,
E::_3dColorBufferBlendFactorInvSrcAlpha => 19,
E::_3dColorBufferBlendFactorInvDstAlpha => 20,
E::_3dColorBufferBlendFactorInvDstColor => 21,
E::_3dColorBufferBlendFactorInvConstColor => 23,
E::_3dColorBufferBlendFactorInvConstAlpha => 24,
E::_3dColorBufferBlendFactorInvSrc1Color => 25,
E::_3dColorBufferBlendFactorInvSrc1Alpha => 26,
E::Unknown(val) => val,
}
}
}
impl From<u32> for _3dColorBufferBlendFactor {
fn from(val: u32) -> Self {
match val {
1 => Self::_3dColorBufferBlendFactorOne,
2 => Self::_3dColorBufferBlendFactorSrcColor,
3 => Self::_3dColorBufferBlendFactorSrcAlpha,
4 => Self::_3dColorBufferBlendFactorDstAlpha,
5 => Self::_3dColorBufferBlendFactorDstColor,
6 => Self::_3dColorBufferBlendFactorSrcAlphaSaturate,
7 => Self::_3dColorBufferBlendFactorConstColor,
8 => Self::_3dColorBufferBlendFactorConstAlpha,
9 => Self::_3dColorBufferBlendFactorSrc1Color,
10 => Self::_3dColorBufferBlendFactorSrc1Alpha,
17 => Self::_3dColorBufferBlendFactorZero,
18 => Self::_3dColorBufferBlendFactorInvSrcColor,
19 => Self::_3dColorBufferBlendFactorInvSrcAlpha,
20 => Self::_3dColorBufferBlendFactorInvDstAlpha,
21 => Self::_3dColorBufferBlendFactorInvDstColor,
23 => Self::_3dColorBufferBlendFactorInvConstColor,
24 => Self::_3dColorBufferBlendFactorInvConstAlpha,
25 => Self::_3dColorBufferBlendFactorInvSrc1Color,
26 => Self::_3dColorBufferBlendFactorInvSrc1Alpha,
_ => Self::Unknown(val),
}
}
}
impl Default for _3dColorBufferBlendFactor {
fn default() -> Self {
0u32.into()
}
}
#[derive(Clone, Copy)]
pub enum _3dColorBufferBlendFunction {
_3dColorBufferBlendFunctionAdd,
_3dColorBufferBlendFunctionSubtract,
_3dColorBufferBlendFunctionReverseSubtract,
_3dColorBufferBlendFunctionMin,
_3dColorBufferBlendFunctionMax,
Unknown(u32),
}
impl Into<u32> for _3dColorBufferBlendFunction {
fn into(self) -> u32 {
type E = _3dColorBufferBlendFunction;
match self {
E::_3dColorBufferBlendFunctionAdd => 0,
E::_3dColorBufferBlendFunctionSubtract => 1,
E::_3dColorBufferBlendFunctionReverseSubtract => 2,
E::_3dColorBufferBlendFunctionMin => 3,
E::_3dColorBufferBlendFunctionMax => 4,
E::Unknown(val) => val,
}
}
}
impl From<u32> for _3dColorBufferBlendFunction {
fn from(val: u32) -> Self {
match val {
0 => Self::_3dColorBufferBlendFunctionAdd,
1 => Self::_3dColorBufferBlendFunctionSubtract,
2 => Self::_3dColorBufferBlendFunctionReverseSubtract,
3 => Self::_3dColorBufferBlendFunctionMin,
4 => Self::_3dColorBufferBlendFunctionMax,
_ => Self::Unknown(val),
}
}
}
impl Default for _3dColorBufferBlendFunction {
fn default() -> Self {
0u32.into()
}
}
#[derive(Clone, Copy)]
pub enum _3dCompareFunction {
_3dCompareFunctionAlways,
_3dCompareFunctionNever,
_3dCompareFunctionLess,
_3dCompareFunctionEqual,
_3dCompareFunctionLequal,
_3dCompareFunctionGreater,
_3dCompareFunctionNotequal,
_3dCompareFunctionGequal,
Unknown(u32),
}
impl Into<u32> for _3dCompareFunction {
fn into(self) -> u32 {
type E = _3dCompareFunction;
match self {
E::_3dCompareFunctionAlways => 0,
E::_3dCompareFunctionNever => 1,
E::_3dCompareFunctionLess => 2,
E::_3dCompareFunctionEqual => 3,
E::_3dCompareFunctionLequal => 4,
E::_3dCompareFunctionGreater => 5,
E::_3dCompareFunctionNotequal => 6,
E::_3dCompareFunctionGequal => 7,
E::Unknown(val) => val,
}
}
}
impl From<u32> for _3dCompareFunction {
fn from(val: u32) -> Self {
match val {
0 => Self::_3dCompareFunctionAlways,
1 => Self::_3dCompareFunctionNever,
2 => Self::_3dCompareFunctionLess,
3 => Self::_3dCompareFunctionEqual,
4 => Self::_3dCompareFunctionLequal,
5 => Self::_3dCompareFunctionGreater,
6 => Self::_3dCompareFunctionNotequal,
7 => Self::_3dCompareFunctionGequal,
_ => Self::Unknown(val),
}
}
}
impl Default for _3dCompareFunction {
fn default() -> Self {
0u32.into()
}
}
#[derive(Clone, Copy)]
pub enum _3dLogicOpFunction {
_3dLogicOpFunctionClear,
_3dLogicOpFunctionNor,
_3dLogicOpFunctionAndInverted,
_3dLogicOpFunctionCopyInverted,
_3dLogicOpFunctionAndReverse,
_3dLogicOpFunctionInvert,
_3dLogicOpFunctionXor,
_3dLogicOpFunctionNand,
_3dLogicOpFunctionAnd,
_3dLogicOpFunctionEquiv,
_3dLogicOpFunctionNoop,
_3dLogicOpFunctionOrInverted,
_3dLogicOpFunctionCopy,
_3dLogicOpFunctionOrReverse,
_3dLogicOpFunctionOr,
_3dLogicOpFunctionSet,
Unknown(u32),
}
impl Into<u32> for _3dLogicOpFunction {
fn into(self) -> u32 {
type E = _3dLogicOpFunction;
match self {
E::_3dLogicOpFunctionClear => 0,
E::_3dLogicOpFunctionNor => 1,
E::_3dLogicOpFunctionAndInverted => 2,
E::_3dLogicOpFunctionCopyInverted => 3,
E::_3dLogicOpFunctionAndReverse => 4,
E::_3dLogicOpFunctionInvert => 5,
E::_3dLogicOpFunctionXor => 6,
E::_3dLogicOpFunctionNand => 7,
E::_3dLogicOpFunctionAnd => 8,
E::_3dLogicOpFunctionEquiv => 9,
E::_3dLogicOpFunctionNoop => 10,
E::_3dLogicOpFunctionOrInverted => 11,
E::_3dLogicOpFunctionCopy => 12,
E::_3dLogicOpFunctionOrReverse => 13,
E::_3dLogicOpFunctionOr => 14,
E::_3dLogicOpFunctionSet => 15,
E::Unknown(val) => val,
}
}
}
impl From<u32> for _3dLogicOpFunction {
fn from(val: u32) -> Self {
match val {
0 => Self::_3dLogicOpFunctionClear,
1 => Self::_3dLogicOpFunctionNor,
2 => Self::_3dLogicOpFunctionAndInverted,
3 => Self::_3dLogicOpFunctionCopyInverted,
4 => Self::_3dLogicOpFunctionAndReverse,
5 => Self::_3dLogicOpFunctionInvert,
6 => Self::_3dLogicOpFunctionXor,
7 => Self::_3dLogicOpFunctionNand,
8 => Self::_3dLogicOpFunctionAnd,
9 => Self::_3dLogicOpFunctionEquiv,
10 => Self::_3dLogicOpFunctionNoop,
11 => Self::_3dLogicOpFunctionOrInverted,
12 => Self::_3dLogicOpFunctionCopy,
13 => Self::_3dLogicOpFunctionOrReverse,
14 => Self::_3dLogicOpFunctionOr,
15 => Self::_3dLogicOpFunctionSet,
_ => Self::Unknown(val),
}
}
}
impl Default for _3dLogicOpFunction {
fn default() -> Self {
0u32.into()
}
}
#[derive(Clone, Copy)]
pub enum _3dPrimTopoType {
_3dPrimTopoTypePointlist,
_3dPrimTopoTypeLinelist,
_3dPrimTopoTypeLinestrip,
_3dPrimTopoTypeTrilist,
_3dPrimTopoTypeTristrip,
_3dPrimTopoTypeTrifan,
_3dPrimTopoTypeQuadlist,
_3dPrimTopoTypeQuadstrip,
_3dPrimTopoTypeLinelistAdj,
_3dPrimTopoTypeLinestripAdj,
_3dPrimTopoTypeTrilistAdj,
_3dPrimTopoTypeTristripAdj,
_3dPrimTopoTypeTristripReverse,
_3dPrimTopoTypePolygon,
_3dPrimTopoTypeRectlist,
_3dPrimTopoTypeLineloop,
_3dPrimTopoTypePointlistBf,
_3dPrimTopoTypeLinestripCont,
_3dPrimTopoTypeLinestripBf,
_3dPrimTopoTypeLinestripContBf,
_3dPrimTopoTypeTrifanNostipple,
_3dPrimTopoTypePatchlist1,
_3dPrimTopoTypePatchlist2,
_3dPrimTopoTypePatchlist3,
_3dPrimTopoTypePatchlist4,
_3dPrimTopoTypePatchlist5,
_3dPrimTopoTypePatchlist6,
_3dPrimTopoTypePatchlist7,
_3dPrimTopoTypePatchlist8,
_3dPrimTopoTypePatchlist9,
_3dPrimTopoTypePatchlist10,
_3dPrimTopoTypePatchlist11,
_3dPrimTopoTypePatchlist12,
_3dPrimTopoTypePatchlist13,
_3dPrimTopoTypePatchlist14,
_3dPrimTopoTypePatchlist15,
_3dPrimTopoTypePatchlist16,
_3dPrimTopoTypePatchlist17,
_3dPrimTopoTypePatchlist18,
_3dPrimTopoTypePatchlist19,
_3dPrimTopoTypePatchlist20,
_3dPrimTopoTypePatchlist21,
_3dPrimTopoTypePatchlist22,
_3dPrimTopoTypePatchlist23,
_3dPrimTopoTypePatchlist24,
_3dPrimTopoTypePatchlist25,
_3dPrimTopoTypePatchlist26,
_3dPrimTopoTypePatchlist27,
_3dPrimTopoTypePatchlist28,
_3dPrimTopoTypePatchlist29,
_3dPrimTopoTypePatchlist30,
_3dPrimTopoTypePatchlist31,
_3dPrimTopoTypePatchlist32,
Unknown(u32),
}
impl Into<u32> for _3dPrimTopoType {
fn into(self) -> u32 {
type E = _3dPrimTopoType;
match self {
E::_3dPrimTopoTypePointlist => 1,
E::_3dPrimTopoTypeLinelist => 2,
E::_3dPrimTopoTypeLinestrip => 3,
E::_3dPrimTopoTypeTrilist => 4,
E::_3dPrimTopoTypeTristrip => 5,
E::_3dPrimTopoTypeTrifan => 6,
E::_3dPrimTopoTypeQuadlist => 7,
E::_3dPrimTopoTypeQuadstrip => 8,
E::_3dPrimTopoTypeLinelistAdj => 9,
E::_3dPrimTopoTypeLinestripAdj => 10,
E::_3dPrimTopoTypeTrilistAdj => 11,
E::_3dPrimTopoTypeTristripAdj => 12,
E::_3dPrimTopoTypeTristripReverse => 13,
E::_3dPrimTopoTypePolygon => 14,
E::_3dPrimTopoTypeRectlist => 15,
E::_3dPrimTopoTypeLineloop => 16,
E::_3dPrimTopoTypePointlistBf => 17,
E::_3dPrimTopoTypeLinestripCont => 18,
E::_3dPrimTopoTypeLinestripBf => 19,
E::_3dPrimTopoTypeLinestripContBf => 20,
E::_3dPrimTopoTypeTrifanNostipple => 22,
E::_3dPrimTopoTypePatchlist1 => 32,
E::_3dPrimTopoTypePatchlist2 => 33,
E::_3dPrimTopoTypePatchlist3 => 34,
E::_3dPrimTopoTypePatchlist4 => 35,
E::_3dPrimTopoTypePatchlist5 => 36,
E::_3dPrimTopoTypePatchlist6 => 37,
E::_3dPrimTopoTypePatchlist7 => 38,
E::_3dPrimTopoTypePatchlist8 => 39,
E::_3dPrimTopoTypePatchlist9 => 40,
E::_3dPrimTopoTypePatchlist10 => 41,
E::_3dPrimTopoTypePatchlist11 => 42,
E::_3dPrimTopoTypePatchlist12 => 43,
E::_3dPrimTopoTypePatchlist13 => 44,
E::_3dPrimTopoTypePatchlist14 => 45,
E::_3dPrimTopoTypePatchlist15 => 46,
E::_3dPrimTopoTypePatchlist16 => 47,
E::_3dPrimTopoTypePatchlist17 => 48,
E::_3dPrimTopoTypePatchlist18 => 49,
E::_3dPrimTopoTypePatchlist19 => 50,
E::_3dPrimTopoTypePatchlist20 => 51,
E::_3dPrimTopoTypePatchlist21 => 52,
E::_3dPrimTopoTypePatchlist22 => 53,
E::_3dPrimTopoTypePatchlist23 => 54,
E::_3dPrimTopoTypePatchlist24 => 55,
E::_3dPrimTopoTypePatchlist25 => 56,
E::_3dPrimTopoTypePatchlist26 => 57,
E::_3dPrimTopoTypePatchlist27 => 58,
E::_3dPrimTopoTypePatchlist28 => 59,
E::_3dPrimTopoTypePatchlist29 => 60,
E::_3dPrimTopoTypePatchlist30 => 61,
E::_3dPrimTopoTypePatchlist31 => 62,
E::_3dPrimTopoTypePatchlist32 => 63,
E::Unknown(val) => val,
}
}
}
impl From<u32> for _3dPrimTopoType {
fn from(val: u32) -> Self {
match val {
1 => Self::_3dPrimTopoTypePointlist,
2 => Self::_3dPrimTopoTypeLinelist,
3 => Self::_3dPrimTopoTypeLinestrip,
4 => Self::_3dPrimTopoTypeTrilist,
5 => Self::_3dPrimTopoTypeTristrip,
6 => Self::_3dPrimTopoTypeTrifan,
7 => Self::_3dPrimTopoTypeQuadlist,
8 => Self::_3dPrimTopoTypeQuadstrip,
9 => Self::_3dPrimTopoTypeLinelistAdj,
10 => Self::_3dPrimTopoTypeLinestripAdj,
11 => Self::_3dPrimTopoTypeTrilistAdj,
12 => Self::_3dPrimTopoTypeTristripAdj,
13 => Self::_3dPrimTopoTypeTristripReverse,
14 => Self::_3dPrimTopoTypePolygon,
15 => Self::_3dPrimTopoTypeRectlist,
16 => Self::_3dPrimTopoTypeLineloop,
17 => Self::_3dPrimTopoTypePointlistBf,
18 => Self::_3dPrimTopoTypeLinestripCont,
19 => Self::_3dPrimTopoTypeLinestripBf,
20 => Self::_3dPrimTopoTypeLinestripContBf,
22 => Self::_3dPrimTopoTypeTrifanNostipple,
32 => Self::_3dPrimTopoTypePatchlist1,
33 => Self::_3dPrimTopoTypePatchlist2,
34 => Self::_3dPrimTopoTypePatchlist3,
35 => Self::_3dPrimTopoTypePatchlist4,
36 => Self::_3dPrimTopoTypePatchlist5,
37 => Self::_3dPrimTopoTypePatchlist6,
38 => Self::_3dPrimTopoTypePatchlist7,
39 => Self::_3dPrimTopoTypePatchlist8,
40 => Self::_3dPrimTopoTypePatchlist9,
41 => Self::_3dPrimTopoTypePatchlist10,
42 => Self::_3dPrimTopoTypePatchlist11,
43 => Self::_3dPrimTopoTypePatchlist12,
44 => Self::_3dPrimTopoTypePatchlist13,
45 => Self::_3dPrimTopoTypePatchlist14,
46 => Self::_3dPrimTopoTypePatchlist15,
47 => Self::_3dPrimTopoTypePatchlist16,
48 => Self::_3dPrimTopoTypePatchlist17,
49 => Self::_3dPrimTopoTypePatchlist18,
50 => Self::_3dPrimTopoTypePatchlist19,
51 => Self::_3dPrimTopoTypePatchlist20,
52 => Self::_3dPrimTopoTypePatchlist21,
53 => Self::_3dPrimTopoTypePatchlist22,
54 => Self::_3dPrimTopoTypePatchlist23,
55 => Self::_3dPrimTopoTypePatchlist24,
56 => Self::_3dPrimTopoTypePatchlist25,
57 => Self::_3dPrimTopoTypePatchlist26,
58 => Self::_3dPrimTopoTypePatchlist27,
59 => Self::_3dPrimTopoTypePatchlist28,
60 => Self::_3dPrimTopoTypePatchlist29,
61 => Self::_3dPrimTopoTypePatchlist30,
62 => Self::_3dPrimTopoTypePatchlist31,
63 => Self::_3dPrimTopoTypePatchlist32,
_ => Self::Unknown(val),
}
}
}
impl Default for _3dPrimTopoType {
fn default() -> Self {
0u32.into()
}
}
#[derive(Clone, Copy)]
pub enum _3dStencilOperation {
_3dStencilOperationKeep,
_3dStencilOperationZero,
_3dStencilOperationReplace,
_3dStencilOperationIncrsat,
_3dStencilOperationDecrsat,
_3dStencilOperationIncr,
_3dStencilOperationDecr,
_3dStencilOperationInvert,
Unknown(u32),
}
impl Into<u32> for _3dStencilOperation {
fn into(self) -> u32 {
type E = _3dStencilOperation;
match self {
E::_3dStencilOperationKeep => 0,
E::_3dStencilOperationZero => 1,
E::_3dStencilOperationReplace => 2,
E::_3dStencilOperationIncrsat => 3,
E::_3dStencilOperationDecrsat => 4,
E::_3dStencilOperationIncr => 5,
E::_3dStencilOperationDecr => 6,
E::_3dStencilOperationInvert => 7,
E::Unknown(val) => val,
}
}
}
impl From<u32> for _3dStencilOperation {
fn from(val: u32) -> Self {
match val {
0 => Self::_3dStencilOperationKeep,
1 => Self::_3dStencilOperationZero,
2 => Self::_3dStencilOperationReplace,
3 => Self::_3dStencilOperationIncrsat,
4 => Self::_3dStencilOperationDecrsat,
5 => Self::_3dStencilOperationIncr,
6 => Self::_3dStencilOperationDecr,
7 => Self::_3dStencilOperationInvert,
_ => Self::Unknown(val),
}
}
}
impl Default for _3dStencilOperation {
fn default() -> Self {
0u32.into()
}
}
#[derive(Clone, Copy)]
pub enum _3dVertexComponentControl {
_3dVertexComponentControlNostore,
_3dVertexComponentControlStoreSrc,
_3dVertexComponentControlStore0,
_3dVertexComponentControlStore1Fp,
_3dVertexComponentControlStore1Int,
_3dVertexComponentControlStoreVid,
_3dVertexComponentControlStoreIid,
_3dVertexComponentControlStorePid,
Unknown(u32),
}
impl Into<u32> for _3dVertexComponentControl {
fn into(self) -> u32 {
type E = _3dVertexComponentControl;
match self {
E::_3dVertexComponentControlNostore => 0,
E::_3dVertexComponentControlStoreSrc => 1,
E::_3dVertexComponentControlStore0 => 2,
E::_3dVertexComponentControlStore1Fp => 3,
E::_3dVertexComponentControlStore1Int => 4,
E::_3dVertexComponentControlStoreVid => 5,
E::_3dVertexComponentControlStoreIid => 6,
E::_3dVertexComponentControlStorePid => 7,
E::Unknown(val) => val,
}
}
}
impl From<u32> for _3dVertexComponentControl {
fn from(val: u32) -> Self {
match val {
0 => Self::_3dVertexComponentControlNostore,
1 => Self::_3dVertexComponentControlStoreSrc,
2 => Self::_3dVertexComponentControlStore0,
3 => Self::_3dVertexComponentControlStore1Fp,
4 => Self::_3dVertexComponentControlStore1Int,
5 => Self::_3dVertexComponentControlStoreVid,
6 => Self::_3dVertexComponentControlStoreIid,
7 => Self::_3dVertexComponentControlStorePid,
_ => Self::Unknown(val),
}
}
}
impl Default for _3dVertexComponentControl {
fn default() -> Self {
0u32.into()
}
}
#[derive(Clone, Copy)]
pub enum TextureCoordinateMode {
TextureCoordinateModeWrap,
TextureCoordinateModeMirror,
TextureCoordinateModeClamp,
TextureCoordinateModeCube,
TextureCoordinateModeClampBorder,
TextureCoordinateModeMirrorOnce,
Unknown(u32),
}
impl Into<u32> for TextureCoordinateMode {
fn into(self) -> u32 {
type E = TextureCoordinateMode;
match self {
E::TextureCoordinateModeWrap => 0,
E::TextureCoordinateModeMirror => 1,
E::TextureCoordinateModeClamp => 2,
E::TextureCoordinateModeCube => 3,
E::TextureCoordinateModeClampBorder => 4,
E::TextureCoordinateModeMirrorOnce => 5,
E::Unknown(val) => val,
}
}
}
impl From<u32> for TextureCoordinateMode {
fn from(val: u32) -> Self {
match val {
0 => Self::TextureCoordinateModeWrap,
1 => Self::TextureCoordinateModeMirror,
2 => Self::TextureCoordinateModeClamp,
3 => Self::TextureCoordinateModeCube,
4 => Self::TextureCoordinateModeClampBorder,
5 => Self::TextureCoordinateModeMirrorOnce,
_ => Self::Unknown(val),
}
}
}
impl Default for TextureCoordinateMode {
fn default() -> Self {
0u32.into()
}
}
pub struct BcsFaultReg<A: Addr + Default> {
pub valid_bit: bool,
pub fault_type: u32,
pub srcid_of_fault: u32,
pub gttsel: u32,
pub virtual_address_of_fault: A,
}
impl<A: Addr + Default> BcsFaultReg<A> {
pub const DWORD_LENGTH: u32 = 1;
pub const NUM: u64 = 0x4294;
pub const GGTT: u32 = 1;
pub const INVALID_AND_UNLOADED_PD_FAULT: u32 = 3;
pub const INVALID_PD_FAULT: u32 = 1;
pub const PAGE_FAULT: u32 = 0;
pub const PPGTT: u32 = 0;
pub const UNLOADED_PD_FAULT: u32 = 2;
}
impl<A: Addr + Default> Default for BcsFaultReg<A> {
fn default() -> Self {
BcsFaultReg {
valid_bit: Default::default(),
fault_type: Default::default(),
srcid_of_fault: Default::default(),
gttsel: Default::default(),
virtual_address_of_fault: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for BcsFaultReg<A> {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
let v0 = __gen_uint(self.valid_bit.into(), 0, 0) |
__gen_uint(self.fault_type, 1, 2) |
__gen_uint(self.srcid_of_fault, 3, 10) |
__gen_uint(self.gttsel, 11, 11);
let v0_address = self.virtual_address_of_fault.combine(v0);
out[0] = v0_address as u32;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for BcsFaultReg<u64> {
fn from(input: &[u32; 1]) -> Self {
BcsFaultReg {
valid_bit: __gen_unuint(input[0], 0, 0) != 0,
fault_type: __gen_unuint(input[0], 1, 2),
srcid_of_fault: __gen_unuint(input[0], 3, 10),
gttsel: __gen_unuint(input[0], 11, 11),
virtual_address_of_fault: (__gen_unuint(input[0], 12, 31) as u64) << 12,
}
}
}
impl Deserialize for BcsFaultReg<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct BcsInstdone {
pub ring_enable: bool,
pub blitter_idle: bool,
pub gab_idle: bool,
pub bcs_done: bool,
}
impl BcsInstdone {
pub const DWORD_LENGTH: u32 = 1;
pub const NUM: u64 = 0x2206c;
}
impl Default for BcsInstdone {
fn default() -> Self {
BcsInstdone {
ring_enable: Default::default(),
blitter_idle: Default::default(),
gab_idle: Default::default(),
bcs_done: Default::default(),
}
}
}
impl Serialize for BcsInstdone {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.ring_enable.into(), 0, 0) |
__gen_uint(self.blitter_idle.into(), 1, 1) |
__gen_uint(self.gab_idle.into(), 2, 2) |
__gen_uint(self.bcs_done.into(), 3, 3);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for BcsInstdone {
fn from(input: &[u32; 1]) -> Self {
BcsInstdone {
ring_enable: __gen_unuint(input[0], 0, 0) != 0,
blitter_idle: __gen_unuint(input[0], 1, 1) != 0,
gab_idle: __gen_unuint(input[0], 2, 2) != 0,
bcs_done: __gen_unuint(input[0], 3, 3) != 0,
}
}
}
impl Deserialize for BcsInstdone {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct BcsRingBufferCtl {
pub ring_buffer_enable: bool,
pub automatic_report_head_pointer: u32,
pub disable_register_accesses: bool,
pub semaphore_wait: bool,
pub rbwait: bool,
pub buffer_length_in_pages_1: u32,
}
impl BcsRingBufferCtl {
pub const DWORD_LENGTH: u32 = 1;
pub const NUM: u64 = 0x2203c;
pub const MI_AUTOREPORT_128KB: u32 = 3;
pub const MI_AUTOREPORT_4KB: u32 = 2;
pub const MI_AUTOREPORT_64KB: u32 = 1;
pub const MI_AUTOREPORT_OFF: u32 = 0;
}
impl Default for BcsRingBufferCtl {
fn default() -> Self {
BcsRingBufferCtl {
ring_buffer_enable: Default::default(),
automatic_report_head_pointer: Default::default(),
disable_register_accesses: Default::default(),
semaphore_wait: Default::default(),
rbwait: Default::default(),
buffer_length_in_pages_1: Default::default(),
}
}
}
impl Serialize for BcsRingBufferCtl {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.ring_buffer_enable.into(), 0, 0) |
__gen_uint(self.automatic_report_head_pointer, 1, 2) |
__gen_uint(self.disable_register_accesses.into(), 8, 8) |
__gen_uint(self.semaphore_wait.into(), 10, 10) |
__gen_uint(self.rbwait.into(), 11, 11) |
__gen_uint(self.buffer_length_in_pages_1, 12, 20);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for BcsRingBufferCtl {
fn from(input: &[u32; 1]) -> Self {
BcsRingBufferCtl {
ring_buffer_enable: __gen_unuint(input[0], 0, 0) != 0,
automatic_report_head_pointer: __gen_unuint(input[0], 1, 2),
disable_register_accesses: __gen_unuint(input[0], 8, 8) != 0,
semaphore_wait: __gen_unuint(input[0], 10, 10) != 0,
rbwait: __gen_unuint(input[0], 11, 11) != 0,
buffer_length_in_pages_1: __gen_unuint(input[0], 12, 20),
}
}
}
impl Deserialize for BcsRingBufferCtl {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct BindingTableState {
pub surface_state_pointer: u64,
}
impl BindingTableState {
pub const DWORD_LENGTH: u32 = 1;
}
impl Default for BindingTableState {
fn default() -> Self {
BindingTableState {
surface_state_pointer: Default::default(),
}
}
}
impl Serialize for BindingTableState {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_offset(self.surface_state_pointer as u32, 5, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for BindingTableState {
fn from(input: &[u32; 1]) -> Self {
BindingTableState {
surface_state_pointer: (__gen_unuint(input[0], 5, 31) as u64) << 5,
}
}
}
impl Deserialize for BindingTableState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct BlendState {
}
impl BlendState {
pub const DWORD_LENGTH: u32 = 1;
}
impl Default for BlendState {
fn default() -> Self {
BlendState {
}
}
}
impl Serialize for BlendState {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = 0;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for BlendState {
fn from(_input: &[u32; 1]) -> Self {
BlendState {
}
}
}
impl Deserialize for BlendState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct BlendStateEntry {
pub destination_blend_factor: _3dColorBufferBlendFactor,
pub source_blend_factor: _3dColorBufferBlendFactor,
pub color_blend_function: _3dColorBufferBlendFunction,
pub destination_alpha_blend_factor: _3dColorBufferBlendFactor,
pub source_alpha_blend_factor: _3dColorBufferBlendFactor,
pub alpha_blend_function: _3dColorBufferBlendFunction,
pub independent_alpha_blend_enable: bool,
pub color_buffer_blend_enable: bool,
pub post_blend_color_clamp_enable: bool,
pub pre_blend_color_clamp_enable: bool,
pub color_clamp_range: u32,
pub y_dither_offset: u32,
pub x_dither_offset: u32,
pub color_dither_enable: bool,
pub alpha_test_function: _3dCompareFunction,
pub alpha_test_enable: bool,
pub logic_op_function: _3dLogicOpFunction,
pub logic_op_enable: bool,
pub write_disable_blue: bool,
pub write_disable_green: bool,
pub write_disable_red: bool,
pub write_disable_alpha: bool,
pub alphatocoverage_dither_enable: bool,
pub alphatoone_enable: bool,
pub alphatocoverage_enable: bool,
}
impl BlendStateEntry {
pub const DWORD_LENGTH: u32 = 2;
pub const COLORCLAMP_RTFORMAT: u32 = 2;
pub const COLORCLAMP_SNORM: u32 = 1;
pub const COLORCLAMP_UNORM: u32 = 0;
}
impl Default for BlendStateEntry {
fn default() -> Self {
BlendStateEntry {
destination_blend_factor: Default::default(),
source_blend_factor: Default::default(),
color_blend_function: Default::default(),
destination_alpha_blend_factor: Default::default(),
source_alpha_blend_factor: Default::default(),
alpha_blend_function: Default::default(),
independent_alpha_blend_enable: Default::default(),
color_buffer_blend_enable: Default::default(),
post_blend_color_clamp_enable: Default::default(),
pre_blend_color_clamp_enable: Default::default(),
color_clamp_range: Default::default(),
y_dither_offset: Default::default(),
x_dither_offset: Default::default(),
color_dither_enable: Default::default(),
alpha_test_function: Default::default(),
alpha_test_enable: Default::default(),
logic_op_function: Default::default(),
logic_op_enable: Default::default(),
write_disable_blue: Default::default(),
write_disable_green: Default::default(),
write_disable_red: Default::default(),
write_disable_alpha: Default::default(),
alphatocoverage_dither_enable: Default::default(),
alphatoone_enable: Default::default(),
alphatocoverage_enable: Default::default(),
}
}
}
impl Serialize for BlendStateEntry {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.destination_blend_factor.into(), 0, 4) |
__gen_uint(self.source_blend_factor.into(), 5, 9) |
__gen_uint(self.color_blend_function.into(), 11, 13) |
__gen_uint(self.destination_alpha_blend_factor.into(), 15, 19) |
__gen_uint(self.source_alpha_blend_factor.into(), 20, 24) |
__gen_uint(self.alpha_blend_function.into(), 26, 28) |
__gen_uint(self.independent_alpha_blend_enable.into(), 30, 30) |
__gen_uint(self.color_buffer_blend_enable.into(), 31, 31);
out[1] = __gen_uint(self.post_blend_color_clamp_enable.into(), 0, 0) |
__gen_uint(self.pre_blend_color_clamp_enable.into(), 1, 1) |
__gen_uint(self.color_clamp_range, 2, 3) |
__gen_uint(self.y_dither_offset, 8, 9) |
__gen_uint(self.x_dither_offset, 10, 11) |
__gen_uint(self.color_dither_enable.into(), 12, 12) |
__gen_uint(self.alpha_test_function.into(), 13, 15) |
__gen_uint(self.alpha_test_enable.into(), 16, 16) |
__gen_uint(self.logic_op_function.into(), 18, 21) |
__gen_uint(self.logic_op_enable.into(), 22, 22) |
__gen_uint(self.write_disable_blue.into(), 24, 24) |
__gen_uint(self.write_disable_green.into(), 25, 25) |
__gen_uint(self.write_disable_red.into(), 26, 26) |
__gen_uint(self.write_disable_alpha.into(), 27, 27) |
__gen_uint(self.alphatocoverage_dither_enable.into(), 29, 29) |
__gen_uint(self.alphatoone_enable.into(), 30, 30) |
__gen_uint(self.alphatocoverage_enable.into(), 31, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for BlendStateEntry {
fn from(input: &[u32; 2]) -> Self {
BlendStateEntry {
destination_blend_factor: (__gen_unuint(input[0], 0, 4)).into(),
source_blend_factor: (__gen_unuint(input[0], 5, 9)).into(),
color_blend_function: (__gen_unuint(input[0], 11, 13)).into(),
destination_alpha_blend_factor: (__gen_unuint(input[0], 15, 19)).into(),
source_alpha_blend_factor: (__gen_unuint(input[0], 20, 24)).into(),
alpha_blend_function: (__gen_unuint(input[0], 26, 28)).into(),
independent_alpha_blend_enable: __gen_unuint(input[0], 30, 30) != 0,
color_buffer_blend_enable: __gen_unuint(input[0], 31, 31) != 0,
post_blend_color_clamp_enable: __gen_unuint(input[1], 0, 0) != 0,
pre_blend_color_clamp_enable: __gen_unuint(input[1], 1, 1) != 0,
color_clamp_range: __gen_unuint(input[1], 2, 3),
y_dither_offset: __gen_unuint(input[1], 8, 9),
x_dither_offset: __gen_unuint(input[1], 10, 11),
color_dither_enable: __gen_unuint(input[1], 12, 12) != 0,
alpha_test_function: (__gen_unuint(input[1], 13, 15)).into(),
alpha_test_enable: __gen_unuint(input[1], 16, 16) != 0,
logic_op_function: (__gen_unuint(input[1], 18, 21)).into(),
logic_op_enable: __gen_unuint(input[1], 22, 22) != 0,
write_disable_blue: __gen_unuint(input[1], 24, 24) != 0,
write_disable_green: __gen_unuint(input[1], 25, 25) != 0,
write_disable_red: __gen_unuint(input[1], 26, 26) != 0,
write_disable_alpha: __gen_unuint(input[1], 27, 27) != 0,
alphatocoverage_dither_enable: __gen_unuint(input[1], 29, 29) != 0,
alphatoone_enable: __gen_unuint(input[1], 30, 30) != 0,
alphatocoverage_enable: __gen_unuint(input[1], 31, 31) != 0,
}
}
}
impl Deserialize for BlendStateEntry {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct CcViewport {
pub minimum_depth: f32,
pub maximum_depth: f32,
}
impl CcViewport {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for CcViewport {
fn default() -> Self {
CcViewport {
minimum_depth: Default::default(),
maximum_depth: Default::default(),
}
}
}
impl Serialize for CcViewport {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = self.minimum_depth.to_bits();
out[1] = self.maximum_depth.to_bits();
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for CcViewport {
fn from(input: &[u32; 2]) -> Self {
CcViewport {
minimum_depth: f32::from_bits(input[0]),
maximum_depth: f32::from_bits(input[1]),
}
}
}
impl Deserialize for CcViewport {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct ClInvocationCount {
pub cl_invocation_count_report: u64,
}
impl ClInvocationCount {
pub const DWORD_LENGTH: u32 = 2;
pub const NUM: u64 = 0x2338;
}
impl Default for ClInvocationCount {
fn default() -> Self {
ClInvocationCount {
cl_invocation_count_report: Default::default(),
}
}
}
impl Serialize for ClInvocationCount {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.cl_invocation_count_report as u32, 0, 31);
out[1] = __gen_uint((self.cl_invocation_count_report >> 32) as u32, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for ClInvocationCount {
fn from(input: &[u32; 2]) -> Self {
ClInvocationCount {
cl_invocation_count_report: (__gen_unuint(input[0], 0, 31) as u64) |
(__gen_unuint(input[1], 0, 31) as u64) << 32,
}
}
}
impl Deserialize for ClInvocationCount {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct ClPrimitivesCount {
pub cl_primitives_count_report: u64,
}
impl ClPrimitivesCount {
pub const DWORD_LENGTH: u32 = 2;
pub const NUM: u64 = 0x2340;
}
impl Default for ClPrimitivesCount {
fn default() -> Self {
ClPrimitivesCount {
cl_primitives_count_report: Default::default(),
}
}
}
impl Serialize for ClPrimitivesCount {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.cl_primitives_count_report as u32, 0, 31);
out[1] = __gen_uint((self.cl_primitives_count_report >> 32) as u32, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for ClPrimitivesCount {
fn from(input: &[u32; 2]) -> Self {
ClPrimitivesCount {
cl_primitives_count_report: (__gen_unuint(input[0], 0, 31) as u64) |
(__gen_unuint(input[1], 0, 31) as u64) << 32,
}
}
}
impl Deserialize for ClPrimitivesCount {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct ColorCalcState {
pub alpha_test_format: u32,
pub round_disable_function_disable: bool,
pub backface_stencil_reference_value: u32,
pub stencil_reference_value: u32,
pub alpha_reference_value_as_unorm8: u32,
pub alpha_reference_value_as_float32: f32,
pub blend_constant_color_red: f32,
pub blend_constant_color_green: f32,
pub blend_constant_color_blue: f32,
pub blend_constant_color_alpha: f32,
}
impl ColorCalcState {
pub const DWORD_LENGTH: u32 = 6;
pub const ALPHATEST_FLOAT32: u32 = 1;
pub const ALPHATEST_UNORM8: u32 = 0;
}
impl Default for ColorCalcState {
fn default() -> Self {
ColorCalcState {
alpha_test_format: Default::default(),
round_disable_function_disable: Default::default(),
backface_stencil_reference_value: Default::default(),
stencil_reference_value: Default::default(),
alpha_reference_value_as_unorm8: Default::default(),
alpha_reference_value_as_float32: Default::default(),
blend_constant_color_red: Default::default(),
blend_constant_color_green: Default::default(),
blend_constant_color_blue: Default::default(),
blend_constant_color_alpha: Default::default(),
}
}
}
impl Serialize for ColorCalcState {
type Out = [u32; 6];
fn pack_into(&self, out: &mut [u32; 6]) {
out[0] = __gen_uint(self.alpha_test_format, 0, 0) |
__gen_uint(self.round_disable_function_disable.into(), 15, 15) |
__gen_uint(self.backface_stencil_reference_value, 16, 23) |
__gen_uint(self.stencil_reference_value, 24, 31);
out[1] = self.alpha_reference_value_as_float32.to_bits();
out[2] = self.blend_constant_color_red.to_bits();
out[3] = self.blend_constant_color_green.to_bits();
out[4] = self.blend_constant_color_blue.to_bits();
out[5] = self.blend_constant_color_alpha.to_bits();
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 6];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 6] as *const [u8; 24]) })
}
}
impl From<&[u32; 6]> for ColorCalcState {
fn from(input: &[u32; 6]) -> Self {
ColorCalcState {
alpha_test_format: __gen_unuint(input[0], 0, 0),
round_disable_function_disable: __gen_unuint(input[0], 15, 15) != 0,
backface_stencil_reference_value: __gen_unuint(input[0], 16, 23),
stencil_reference_value: __gen_unuint(input[0], 24, 31),
alpha_reference_value_as_unorm8: __gen_unuint(input[1], 0, 31),
alpha_reference_value_as_float32: f32::from_bits(input[1]),
blend_constant_color_red: f32::from_bits(input[2]),
blend_constant_color_green: f32::from_bits(input[3]),
blend_constant_color_blue: f32::from_bits(input[4]),
blend_constant_color_alpha: f32::from_bits(input[5]),
}
}
}
impl Deserialize for ColorCalcState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 6];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 6] as *mut [u8; 24]) })?;
Ok((&input).into())
}
}
pub struct CsInvocationCount {
pub cs_invocation_count_report: u64,
}
impl CsInvocationCount {
pub const DWORD_LENGTH: u32 = 2;
pub const NUM: u64 = 0x2290;
}
impl Default for CsInvocationCount {
fn default() -> Self {
CsInvocationCount {
cs_invocation_count_report: Default::default(),
}
}
}
impl Serialize for CsInvocationCount {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.cs_invocation_count_report as u32, 0, 31);
out[1] = __gen_uint((self.cs_invocation_count_report >> 32) as u32, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for CsInvocationCount {
fn from(input: &[u32; 2]) -> Self {
CsInvocationCount {
cs_invocation_count_report: (__gen_unuint(input[0], 0, 31) as u64) |
(__gen_unuint(input[1], 0, 31) as u64) << 32,
}
}
}
impl Deserialize for CsInvocationCount {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct DepthStencilState {
pub backface_stencil_pass_depth_pass_op: _3dStencilOperation,
pub backface_stencil_pass_depth_fail_op: _3dStencilOperation,
pub backface_stencil_fail_op: _3dStencilOperation,
pub backface_stencil_test_function: _3dCompareFunction,
pub double_sided_stencil_enable: bool,
pub stencil_buffer_write_enable: bool,
pub stencil_pass_depth_pass_op: _3dStencilOperation,
pub stencil_pass_depth_fail_op: _3dStencilOperation,
pub stencil_fail_op: _3dStencilOperation,
pub stencil_test_function: _3dCompareFunction,
pub stencil_test_enable: bool,
pub backface_stencil_write_mask: u32,
pub backface_stencil_test_mask: u32,
pub stencil_write_mask: u32,
pub stencil_test_mask: u32,
pub depth_buffer_write_enable: bool,
pub depth_test_function: _3dCompareFunction,
pub depth_test_enable: bool,
}
impl DepthStencilState {
pub const DWORD_LENGTH: u32 = 3;
}
impl Default for DepthStencilState {
fn default() -> Self {
DepthStencilState {
backface_stencil_pass_depth_pass_op: Default::default(),
backface_stencil_pass_depth_fail_op: Default::default(),
backface_stencil_fail_op: Default::default(),
backface_stencil_test_function: Default::default(),
double_sided_stencil_enable: Default::default(),
stencil_buffer_write_enable: Default::default(),
stencil_pass_depth_pass_op: Default::default(),
stencil_pass_depth_fail_op: Default::default(),
stencil_fail_op: Default::default(),
stencil_test_function: Default::default(),
stencil_test_enable: Default::default(),
backface_stencil_write_mask: Default::default(),
backface_stencil_test_mask: Default::default(),
stencil_write_mask: Default::default(),
stencil_test_mask: Default::default(),
depth_buffer_write_enable: Default::default(),
depth_test_function: Default::default(),
depth_test_enable: Default::default(),
}
}
}
impl Serialize for DepthStencilState {
type Out = [u32; 3];
fn pack_into(&self, out: &mut [u32; 3]) {
out[0] = __gen_uint(self.backface_stencil_pass_depth_pass_op.into(), 3, 5) |
__gen_uint(self.backface_stencil_pass_depth_fail_op.into(), 6, 8) |
__gen_uint(self.backface_stencil_fail_op.into(), 9, 11) |
__gen_uint(self.backface_stencil_test_function.into(), 12, 14) |
__gen_uint(self.double_sided_stencil_enable.into(), 15, 15) |
__gen_uint(self.stencil_buffer_write_enable.into(), 18, 18) |
__gen_uint(self.stencil_pass_depth_pass_op.into(), 19, 21) |
__gen_uint(self.stencil_pass_depth_fail_op.into(), 22, 24) |
__gen_uint(self.stencil_fail_op.into(), 25, 27) |
__gen_uint(self.stencil_test_function.into(), 28, 30) |
__gen_uint(self.stencil_test_enable.into(), 31, 31);
out[1] = __gen_uint(self.backface_stencil_write_mask, 0, 7) |
__gen_uint(self.backface_stencil_test_mask, 8, 15) |
__gen_uint(self.stencil_write_mask, 16, 23) |
__gen_uint(self.stencil_test_mask, 24, 31);
out[2] = __gen_uint(self.depth_buffer_write_enable.into(), 26, 26) |
__gen_uint(self.depth_test_function.into(), 27, 29) |
__gen_uint(self.depth_test_enable.into(), 31, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 3];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 3] as *const [u8; 12]) })
}
}
impl From<&[u32; 3]> for DepthStencilState {
fn from(input: &[u32; 3]) -> Self {
DepthStencilState {
backface_stencil_pass_depth_pass_op: (__gen_unuint(input[0], 3, 5)).into(),
backface_stencil_pass_depth_fail_op: (__gen_unuint(input[0], 6, 8)).into(),
backface_stencil_fail_op: (__gen_unuint(input[0], 9, 11)).into(),
backface_stencil_test_function: (__gen_unuint(input[0], 12, 14)).into(),
double_sided_stencil_enable: __gen_unuint(input[0], 15, 15) != 0,
stencil_buffer_write_enable: __gen_unuint(input[0], 18, 18) != 0,
stencil_pass_depth_pass_op: (__gen_unuint(input[0], 19, 21)).into(),
stencil_pass_depth_fail_op: (__gen_unuint(input[0], 22, 24)).into(),
stencil_fail_op: (__gen_unuint(input[0], 25, 27)).into(),
stencil_test_function: (__gen_unuint(input[0], 28, 30)).into(),
stencil_test_enable: __gen_unuint(input[0], 31, 31) != 0,
backface_stencil_write_mask: __gen_unuint(input[1], 0, 7),
backface_stencil_test_mask: __gen_unuint(input[1], 8, 15),
stencil_write_mask: __gen_unuint(input[1], 16, 23),
stencil_test_mask: __gen_unuint(input[1], 24, 31),
depth_buffer_write_enable: __gen_unuint(input[2], 26, 26) != 0,
depth_test_function: (__gen_unuint(input[2], 27, 29)).into(),
depth_test_enable: __gen_unuint(input[2], 31, 31) != 0,
}
}
}
impl Deserialize for DepthStencilState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 3];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 3] as *mut [u8; 12]) })?;
Ok((&input).into())
}
}
pub struct DsInvocationCount {
pub ds_invocation_count_report: u64,
}
impl DsInvocationCount {
pub const DWORD_LENGTH: u32 = 2;
pub const NUM: u64 = 0x2308;
}
impl Default for DsInvocationCount {
fn default() -> Self {
DsInvocationCount {
ds_invocation_count_report: Default::default(),
}
}
}
impl Serialize for DsInvocationCount {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.ds_invocation_count_report as u32, 0, 31);
out[1] = __gen_uint((self.ds_invocation_count_report >> 32) as u32, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for DsInvocationCount {
fn from(input: &[u32; 2]) -> Self {
DsInvocationCount {
ds_invocation_count_report: (__gen_unuint(input[0], 0, 31) as u64) |
(__gen_unuint(input[1], 0, 31) as u64) << 32,
}
}
}
impl Deserialize for DsInvocationCount {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct ErrInt {
pub primary_a_gtt_fault_status: bool,
pub primary_b_gtt_fault_status: bool,
pub sprite_a_gtt_fault_status: bool,
pub sprite_b_gtt_fault_status: bool,
pub cursor_a_gtt_fault_status: bool,
pub cursor_b_gtt_fault_status: bool,
pub invalid_page_table_entry_data: bool,
pub invalid_gtt_page_table_entry: bool,
}
impl ErrInt {
pub const DWORD_LENGTH: u32 = 1;
pub const NUM: u64 = 0x44040;
}
impl Default for ErrInt {
fn default() -> Self {
ErrInt {
primary_a_gtt_fault_status: Default::default(),
primary_b_gtt_fault_status: Default::default(),
sprite_a_gtt_fault_status: Default::default(),
sprite_b_gtt_fault_status: Default::default(),
cursor_a_gtt_fault_status: Default::default(),
cursor_b_gtt_fault_status: Default::default(),
invalid_page_table_entry_data: Default::default(),
invalid_gtt_page_table_entry: Default::default(),
}
}
}
impl Serialize for ErrInt {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.primary_a_gtt_fault_status.into(), 0, 0) |
__gen_uint(self.primary_b_gtt_fault_status.into(), 1, 1) |
__gen_uint(self.sprite_a_gtt_fault_status.into(), 2, 2) |
__gen_uint(self.sprite_b_gtt_fault_status.into(), 3, 3) |
__gen_uint(self.cursor_a_gtt_fault_status.into(), 4, 4) |
__gen_uint(self.cursor_b_gtt_fault_status.into(), 5, 5) |
__gen_uint(self.invalid_page_table_entry_data.into(), 6, 6) |
__gen_uint(self.invalid_gtt_page_table_entry.into(), 7, 7);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for ErrInt {
fn from(input: &[u32; 1]) -> Self {
ErrInt {
primary_a_gtt_fault_status: __gen_unuint(input[0], 0, 0) != 0,
primary_b_gtt_fault_status: __gen_unuint(input[0], 1, 1) != 0,
sprite_a_gtt_fault_status: __gen_unuint(input[0], 2, 2) != 0,
sprite_b_gtt_fault_status: __gen_unuint(input[0], 3, 3) != 0,
cursor_a_gtt_fault_status: __gen_unuint(input[0], 4, 4) != 0,
cursor_b_gtt_fault_status: __gen_unuint(input[0], 5, 5) != 0,
invalid_page_table_entry_data: __gen_unuint(input[0], 6, 6) != 0,
invalid_gtt_page_table_entry: __gen_unuint(input[0], 7, 7) != 0,
}
}
}
impl Deserialize for ErrInt {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct GfxArbErrorRpt {
pub tlb_page_fault_error: bool,
pub context_page_fault_error: bool,
pub invalid_page_directory_entry_error: bool,
pub hardware_status_page_fault_error: bool,
pub tlb_page_vtd_translation_error: bool,
pub context_page_vtd_translation_error: bool,
pub page_directory_entry_vtd_translation_error: bool,
pub hardware_status_page_vtd_translation_error: bool,
pub unloaded_pd_error: bool,
}
impl GfxArbErrorRpt {
pub const DWORD_LENGTH: u32 = 1;
pub const NUM: u64 = 0x40a0;
}
impl Default for GfxArbErrorRpt {
fn default() -> Self {
GfxArbErrorRpt {
tlb_page_fault_error: Default::default(),
context_page_fault_error: Default::default(),
invalid_page_directory_entry_error: Default::default(),
hardware_status_page_fault_error: Default::default(),
tlb_page_vtd_translation_error: Default::default(),
context_page_vtd_translation_error: Default::default(),
page_directory_entry_vtd_translation_error: Default::default(),
hardware_status_page_vtd_translation_error: Default::default(),
unloaded_pd_error: Default::default(),
}
}
}
impl Serialize for GfxArbErrorRpt {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.tlb_page_fault_error.into(), 0, 0) |
__gen_uint(self.context_page_fault_error.into(), 1, 1) |
__gen_uint(self.invalid_page_directory_entry_error.into(), 2, 2) |
__gen_uint(self.hardware_status_page_fault_error.into(), 3, 3) |
__gen_uint(self.tlb_page_vtd_translation_error.into(), 4, 4) |
__gen_uint(self.context_page_vtd_translation_error.into(), 5, 5) |
__gen_uint(self.page_directory_entry_vtd_translation_error.into(), 6, 6) |
__gen_uint(self.hardware_status_page_vtd_translation_error.into(), 7, 7) |
__gen_uint(self.unloaded_pd_error.into(), 8, 8);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for GfxArbErrorRpt {
fn from(input: &[u32; 1]) -> Self {
GfxArbErrorRpt {
tlb_page_fault_error: __gen_unuint(input[0], 0, 0) != 0,
context_page_fault_error: __gen_unuint(input[0], 1, 1) != 0,
invalid_page_directory_entry_error: __gen_unuint(input[0], 2, 2) != 0,
hardware_status_page_fault_error: __gen_unuint(input[0], 3, 3) != 0,
tlb_page_vtd_translation_error: __gen_unuint(input[0], 4, 4) != 0,
context_page_vtd_translation_error: __gen_unuint(input[0], 5, 5) != 0,
page_directory_entry_vtd_translation_error: __gen_unuint(input[0], 6, 6) != 0,
hardware_status_page_vtd_translation_error: __gen_unuint(input[0], 7, 7) != 0,
unloaded_pd_error: __gen_unuint(input[0], 8, 8) != 0,
}
}
}
impl Deserialize for GfxArbErrorRpt {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct GpgpuObject {
pub dword_length: u32,
pub predicate_enable: bool,
pub subopcode: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub interface_descriptor_offset: u32,
pub shared_local_memory_fixed_offset: u32,
pub indirect_data_length: u32,
pub half_slice_destination_select: u32,
pub end_of_thread_group: u32,
pub shared_local_memory_offset: u32,
pub indirect_data_start_address: u64,
pub thread_group_id_x: u32,
pub thread_group_id_y: u32,
pub thread_group_id_z: u32,
pub execution_mask: u32,
}
impl GpgpuObject {
pub const DWORD_LENGTH: u32 = 8;
pub const EITHER_HALF_SLICE: u32 = 0;
pub const HALF_SLICE_0: u32 = 1;
pub const HALF_SLICE_1: u32 = 2;
}
impl Default for GpgpuObject {
fn default() -> Self {
GpgpuObject {
dword_length: 6,
predicate_enable: Default::default(),
subopcode: 4,
media_command_opcode: 1,
pipeline: 2,
command_type: 3,
interface_descriptor_offset: Default::default(),
shared_local_memory_fixed_offset: Default::default(),
indirect_data_length: Default::default(),
half_slice_destination_select: Default::default(),
end_of_thread_group: Default::default(),
shared_local_memory_offset: Default::default(),
indirect_data_start_address: Default::default(),
thread_group_id_x: Default::default(),
thread_group_id_y: Default::default(),
thread_group_id_z: Default::default(),
execution_mask: Default::default(),
}
}
}
impl Serialize for GpgpuObject {
type Out = [u32; 8];
fn pack_into(&self, out: &mut [u32; 8]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self.predicate_enable.into(), 8, 8) |
__gen_uint(self.subopcode, 16, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.interface_descriptor_offset, 0, 4) |
__gen_uint(self.shared_local_memory_fixed_offset, 7, 7);
out[2] = __gen_uint(self.indirect_data_length, 0, 16) |
__gen_uint(self.half_slice_destination_select, 17, 18) |
__gen_uint(self.end_of_thread_group, 24, 24) |
__gen_uint(self.shared_local_memory_offset, 28, 31);
out[3] = __gen_offset(self.indirect_data_start_address as u32, 0, 31);
out[4] = __gen_uint(self.thread_group_id_x, 0, 31);
out[5] = __gen_uint(self.thread_group_id_y, 0, 31);
out[6] = __gen_uint(self.thread_group_id_z, 0, 31);
out[7] = __gen_uint(self.execution_mask, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 8];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 8] as *const [u8; 32]) })
}
}
impl From<&[u32; 8]> for GpgpuObject {
fn from(input: &[u32; 8]) -> Self {
GpgpuObject {
dword_length: __gen_unuint(input[0], 0, 7),
predicate_enable: __gen_unuint(input[0], 8, 8) != 0,
subopcode: __gen_unuint(input[0], 16, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
interface_descriptor_offset: __gen_unuint(input[1], 0, 4),
shared_local_memory_fixed_offset: __gen_unuint(input[1], 7, 7),
indirect_data_length: __gen_unuint(input[2], 0, 16),
half_slice_destination_select: __gen_unuint(input[2], 17, 18),
end_of_thread_group: __gen_unuint(input[2], 24, 24),
shared_local_memory_offset: __gen_unuint(input[2], 28, 31),
indirect_data_start_address: (__gen_unuint(input[3], 0, 31) as u64),
thread_group_id_x: __gen_unuint(input[4], 0, 31),
thread_group_id_y: __gen_unuint(input[5], 0, 31),
thread_group_id_z: __gen_unuint(input[6], 0, 31),
execution_mask: __gen_unuint(input[7], 0, 31),
}
}
}
impl Deserialize for GpgpuObject {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 8];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 8] as *mut [u8; 32]) })?;
Ok((&input).into())
}
}
pub struct GpgpuWalker {
pub dword_length: u32,
pub predicate_enable: bool,
pub indirect_parameter_enable: bool,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub interface_descriptor_offset: u32,
pub thread_width_counter_maximum: u32,
pub thread_height_counter_maximum: u32,
pub thread_depth_counter_maximum: u32,
pub simd_size: u32,
pub thread_group_id_starting_x: u32,
pub thread_group_id_x_dimension: u32,
pub thread_group_id_starting_y: u32,
pub thread_group_id_y_dimension: u32,
pub thread_group_id_starting_z: u32,
pub thread_group_id_z_dimension: u32,
pub right_execution_mask: u32,
pub bottom_execution_mask: u32,
}
impl GpgpuWalker {
pub const DWORD_LENGTH: u32 = 11;
pub const SIMD16: u32 = 1;
pub const SIMD32: u32 = 2;
pub const SIMD8: u32 = 0;
}
impl Default for GpgpuWalker {
fn default() -> Self {
GpgpuWalker {
dword_length: 9,
predicate_enable: Default::default(),
indirect_parameter_enable: Default::default(),
subopcode_a: 5,
media_command_opcode: 1,
pipeline: 2,
command_type: 3,
interface_descriptor_offset: Default::default(),
thread_width_counter_maximum: Default::default(),
thread_height_counter_maximum: Default::default(),
thread_depth_counter_maximum: Default::default(),
simd_size: Default::default(),
thread_group_id_starting_x: Default::default(),
thread_group_id_x_dimension: Default::default(),
thread_group_id_starting_y: Default::default(),
thread_group_id_y_dimension: Default::default(),
thread_group_id_starting_z: Default::default(),
thread_group_id_z_dimension: Default::default(),
right_execution_mask: Default::default(),
bottom_execution_mask: Default::default(),
}
}
}
impl Serialize for GpgpuWalker {
type Out = [u32; 11];
fn pack_into(&self, out: &mut [u32; 11]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self.predicate_enable.into(), 8, 8) |
__gen_uint(self.indirect_parameter_enable.into(), 10, 10) |
__gen_uint(self.subopcode_a, 16, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.interface_descriptor_offset, 0, 4);
out[2] = __gen_uint(self.thread_width_counter_maximum, 0, 5) |
__gen_uint(self.thread_height_counter_maximum, 8, 13) |
__gen_uint(self.thread_depth_counter_maximum, 16, 21) |
__gen_uint(self.simd_size, 30, 31);
out[3] = __gen_uint(self.thread_group_id_starting_x, 0, 31);
out[4] = __gen_uint(self.thread_group_id_x_dimension, 0, 31);
out[5] = __gen_uint(self.thread_group_id_starting_y, 0, 31);
out[6] = __gen_uint(self.thread_group_id_y_dimension, 0, 31);
out[7] = __gen_uint(self.thread_group_id_starting_z, 0, 31);
out[8] = __gen_uint(self.thread_group_id_z_dimension, 0, 31);
out[9] = __gen_uint(self.right_execution_mask, 0, 31);
out[10] = __gen_uint(self.bottom_execution_mask, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 11];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 11] as *const [u8; 44]) })
}
}
impl From<&[u32; 11]> for GpgpuWalker {
fn from(input: &[u32; 11]) -> Self {
GpgpuWalker {
dword_length: __gen_unuint(input[0], 0, 7),
predicate_enable: __gen_unuint(input[0], 8, 8) != 0,
indirect_parameter_enable: __gen_unuint(input[0], 10, 10) != 0,
subopcode_a: __gen_unuint(input[0], 16, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
interface_descriptor_offset: __gen_unuint(input[1], 0, 4),
thread_width_counter_maximum: __gen_unuint(input[2], 0, 5),
thread_height_counter_maximum: __gen_unuint(input[2], 8, 13),
thread_depth_counter_maximum: __gen_unuint(input[2], 16, 21),
simd_size: __gen_unuint(input[2], 30, 31),
thread_group_id_starting_x: __gen_unuint(input[3], 0, 31),
thread_group_id_x_dimension: __gen_unuint(input[4], 0, 31),
thread_group_id_starting_y: __gen_unuint(input[5], 0, 31),
thread_group_id_y_dimension: __gen_unuint(input[6], 0, 31),
thread_group_id_starting_z: __gen_unuint(input[7], 0, 31),
thread_group_id_z_dimension: __gen_unuint(input[8], 0, 31),
right_execution_mask: __gen_unuint(input[9], 0, 31),
bottom_execution_mask: __gen_unuint(input[10], 0, 31),
}
}
}
impl Deserialize for GpgpuWalker {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 11];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 11] as *mut [u8; 44]) })?;
Ok((&input).into())
}
}
pub struct GsInvocationCount {
pub gs_invocation_count_report: u64,
}
impl GsInvocationCount {
pub const DWORD_LENGTH: u32 = 2;
pub const NUM: u64 = 0x2328;
}
impl Default for GsInvocationCount {
fn default() -> Self {
GsInvocationCount {
gs_invocation_count_report: Default::default(),
}
}
}
impl Serialize for GsInvocationCount {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.gs_invocation_count_report as u32, 0, 31);
out[1] = __gen_uint((self.gs_invocation_count_report >> 32) as u32, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for GsInvocationCount {
fn from(input: &[u32; 2]) -> Self {
GsInvocationCount {
gs_invocation_count_report: (__gen_unuint(input[0], 0, 31) as u64) |
(__gen_unuint(input[1], 0, 31) as u64) << 32,
}
}
}
impl Deserialize for GsInvocationCount {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct GsPrimitivesCount {
pub gs_primitives_count_report: u64,
}
impl GsPrimitivesCount {
pub const DWORD_LENGTH: u32 = 2;
pub const NUM: u64 = 0x2330;
}
impl Default for GsPrimitivesCount {
fn default() -> Self {
GsPrimitivesCount {
gs_primitives_count_report: Default::default(),
}
}
}
impl Serialize for GsPrimitivesCount {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.gs_primitives_count_report as u32, 0, 31);
out[1] = __gen_uint((self.gs_primitives_count_report >> 32) as u32, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for GsPrimitivesCount {
fn from(input: &[u32; 2]) -> Self {
GsPrimitivesCount {
gs_primitives_count_report: (__gen_unuint(input[0], 0, 31) as u64) |
(__gen_unuint(input[1], 0, 31) as u64) << 32,
}
}
}
impl Deserialize for GsPrimitivesCount {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct HsInvocationCount {
pub hs_invocation_count_report: u64,
}
impl HsInvocationCount {
pub const DWORD_LENGTH: u32 = 2;
pub const NUM: u64 = 0x2300;
}
impl Default for HsInvocationCount {
fn default() -> Self {
HsInvocationCount {
hs_invocation_count_report: Default::default(),
}
}
}
impl Serialize for HsInvocationCount {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.hs_invocation_count_report as u32, 0, 31);
out[1] = __gen_uint((self.hs_invocation_count_report >> 32) as u32, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for HsInvocationCount {
fn from(input: &[u32; 2]) -> Self {
HsInvocationCount {
hs_invocation_count_report: (__gen_unuint(input[0], 0, 31) as u64) |
(__gen_unuint(input[1], 0, 31) as u64) << 32,
}
}
}
impl Deserialize for HsInvocationCount {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct IaPrimitivesCount {
pub ia_primitives_count_report: u64,
}
impl IaPrimitivesCount {
pub const DWORD_LENGTH: u32 = 2;
pub const NUM: u64 = 0x2318;
}
impl Default for IaPrimitivesCount {
fn default() -> Self {
IaPrimitivesCount {
ia_primitives_count_report: Default::default(),
}
}
}
impl Serialize for IaPrimitivesCount {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.ia_primitives_count_report as u32, 0, 31);
out[1] = __gen_uint((self.ia_primitives_count_report >> 32) as u32, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for IaPrimitivesCount {
fn from(input: &[u32; 2]) -> Self {
IaPrimitivesCount {
ia_primitives_count_report: (__gen_unuint(input[0], 0, 31) as u64) |
(__gen_unuint(input[1], 0, 31) as u64) << 32,
}
}
}
impl Deserialize for IaPrimitivesCount {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct IaVerticesCount {
pub ia_vertices_count_report: u64,
}
impl IaVerticesCount {
pub const DWORD_LENGTH: u32 = 2;
pub const NUM: u64 = 0x2310;
}
impl Default for IaVerticesCount {
fn default() -> Self {
IaVerticesCount {
ia_vertices_count_report: Default::default(),
}
}
}
impl Serialize for IaVerticesCount {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.ia_vertices_count_report as u32, 0, 31);
out[1] = __gen_uint((self.ia_vertices_count_report >> 32) as u32, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for IaVerticesCount {
fn from(input: &[u32; 2]) -> Self {
IaVerticesCount {
ia_vertices_count_report: (__gen_unuint(input[0], 0, 31) as u64) |
(__gen_unuint(input[1], 0, 31) as u64) << 32,
}
}
}
impl Deserialize for IaVerticesCount {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct InlineDataDescriptionForMfdAvcBsdObject {
pub mb_error_concealment_p_slice_weight_prediction_disable: bool,
pub mb_error_concealment_p_slice_motion_vectors_override_disable: bool,
pub mb_error_concealment_p_slice_reference_index_override_disable: bool,
pub mb_error_concealment_b_spatial_weight_prediction_disable: bool,
pub mb_error_concealment_b_spatial_motion_vectors_override_disable: bool,
pub mb_error_concealment_b_spatial_reference_index_override_disable: bool,
pub mb_error_concealment_b_spatial_prediction_mode: u32,
pub mb_header_error_handling: bool,
pub entropy_error_handling: bool,
pub mpr_error_handling: bool,
pub bsd_premature_complete_error_handling: bool,
pub concealment_picture_id: u32,
pub mb_error_concealment_b_temporal_weight_prediction_disable: bool,
pub mb_error_concealment_b_temporal_motion_vectors_override_enable: bool,
pub mb_error_concealment_b_temporal_reference_index_override_enable: bool,
pub mb_error_concealment_b_temporal_prediction_mode: u32,
pub init_current_mb_number: bool,
pub concealment_method: u32,
pub first_mb_bit_offset: u32,
pub last_slice: bool,
pub emulation_prevention_byte_present: bool,
pub fix_prev_mb_skipped: bool,
pub first_mb_byte_offset_of_slice_data_or_slice_header: u32,
}
impl InlineDataDescriptionForMfdAvcBsdObject {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for InlineDataDescriptionForMfdAvcBsdObject {
fn default() -> Self {
InlineDataDescriptionForMfdAvcBsdObject {
mb_error_concealment_p_slice_weight_prediction_disable: Default::default(),
mb_error_concealment_p_slice_motion_vectors_override_disable: Default::default(),
mb_error_concealment_p_slice_reference_index_override_disable: Default::default(),
mb_error_concealment_b_spatial_weight_prediction_disable: Default::default(),
mb_error_concealment_b_spatial_motion_vectors_override_disable: Default::default(),
mb_error_concealment_b_spatial_reference_index_override_disable: Default::default(),
mb_error_concealment_b_spatial_prediction_mode: 0,
mb_header_error_handling: Default::default(),
entropy_error_handling: Default::default(),
mpr_error_handling: Default::default(),
bsd_premature_complete_error_handling: Default::default(),
concealment_picture_id: Default::default(),
mb_error_concealment_b_temporal_weight_prediction_disable: Default::default(),
mb_error_concealment_b_temporal_motion_vectors_override_enable: Default::default(),
mb_error_concealment_b_temporal_reference_index_override_enable: Default::default(),
mb_error_concealment_b_temporal_prediction_mode: 0,
init_current_mb_number: Default::default(),
concealment_method: Default::default(),
first_mb_bit_offset: Default::default(),
last_slice: Default::default(),
emulation_prevention_byte_present: Default::default(),
fix_prev_mb_skipped: Default::default(),
first_mb_byte_offset_of_slice_data_or_slice_header: Default::default(),
}
}
}
impl Serialize for InlineDataDescriptionForMfdAvcBsdObject {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.mb_error_concealment_p_slice_weight_prediction_disable.into(), 0, 0) |
__gen_uint(self.mb_error_concealment_p_slice_motion_vectors_override_disable.into(), 1, 1) |
__gen_uint(self.mb_error_concealment_p_slice_reference_index_override_disable.into(), 2, 2) |
__gen_uint(self.mb_error_concealment_b_spatial_weight_prediction_disable.into(), 3, 3) |
__gen_uint(self.mb_error_concealment_b_spatial_motion_vectors_override_disable.into(), 4, 4) |
__gen_uint(self.mb_error_concealment_b_spatial_reference_index_override_disable.into(), 5, 5) |
__gen_uint(self.mb_error_concealment_b_spatial_prediction_mode, 6, 7) |
__gen_uint(self.mb_header_error_handling.into(), 8, 8) |
__gen_uint(self.entropy_error_handling.into(), 10, 10) |
__gen_uint(self.mpr_error_handling.into(), 12, 12) |
__gen_uint(self.bsd_premature_complete_error_handling.into(), 14, 14) |
__gen_uint(self.concealment_picture_id, 16, 21) |
__gen_uint(self.mb_error_concealment_b_temporal_weight_prediction_disable.into(), 24, 24) |
__gen_uint(self.mb_error_concealment_b_temporal_motion_vectors_override_enable.into(), 25, 25) |
__gen_uint(self.mb_error_concealment_b_temporal_reference_index_override_enable.into(), 26, 26) |
__gen_uint(self.mb_error_concealment_b_temporal_prediction_mode, 27, 28) |
__gen_uint(self.init_current_mb_number.into(), 30, 30) |
__gen_uint(self.concealment_method, 31, 31);
out[1] = __gen_uint(self.first_mb_bit_offset, 0, 2) |
__gen_uint(self.last_slice.into(), 3, 3) |
__gen_uint(self.emulation_prevention_byte_present.into(), 4, 4) |
__gen_uint(self.fix_prev_mb_skipped.into(), 7, 7) |
__gen_uint(self.first_mb_byte_offset_of_slice_data_or_slice_header, 16, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for InlineDataDescriptionForMfdAvcBsdObject {
fn from(input: &[u32; 2]) -> Self {
InlineDataDescriptionForMfdAvcBsdObject {
mb_error_concealment_p_slice_weight_prediction_disable: __gen_unuint(input[0], 0, 0) != 0,
mb_error_concealment_p_slice_motion_vectors_override_disable: __gen_unuint(input[0], 1, 1) != 0,
mb_error_concealment_p_slice_reference_index_override_disable: __gen_unuint(input[0], 2, 2) != 0,
mb_error_concealment_b_spatial_weight_prediction_disable: __gen_unuint(input[0], 3, 3) != 0,
mb_error_concealment_b_spatial_motion_vectors_override_disable: __gen_unuint(input[0], 4, 4) != 0,
mb_error_concealment_b_spatial_reference_index_override_disable: __gen_unuint(input[0], 5, 5) != 0,
mb_error_concealment_b_spatial_prediction_mode: __gen_unuint(input[0], 6, 7),
mb_header_error_handling: __gen_unuint(input[0], 8, 8) != 0,
entropy_error_handling: __gen_unuint(input[0], 10, 10) != 0,
mpr_error_handling: __gen_unuint(input[0], 12, 12) != 0,
bsd_premature_complete_error_handling: __gen_unuint(input[0], 14, 14) != 0,
concealment_picture_id: __gen_unuint(input[0], 16, 21),
mb_error_concealment_b_temporal_weight_prediction_disable: __gen_unuint(input[0], 24, 24) != 0,
mb_error_concealment_b_temporal_motion_vectors_override_enable: __gen_unuint(input[0], 25, 25) != 0,
mb_error_concealment_b_temporal_reference_index_override_enable: __gen_unuint(input[0], 26, 26) != 0,
mb_error_concealment_b_temporal_prediction_mode: __gen_unuint(input[0], 27, 28),
init_current_mb_number: __gen_unuint(input[0], 30, 30) != 0,
concealment_method: __gen_unuint(input[0], 31, 31),
first_mb_bit_offset: __gen_unuint(input[1], 0, 2),
last_slice: __gen_unuint(input[1], 3, 3) != 0,
emulation_prevention_byte_present: __gen_unuint(input[1], 4, 4) != 0,
fix_prev_mb_skipped: __gen_unuint(input[1], 7, 7) != 0,
first_mb_byte_offset_of_slice_data_or_slice_header: __gen_unuint(input[1], 16, 31),
}
}
}
impl Deserialize for InlineDataDescriptionForMfdAvcBsdObject {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct Instdone1 {
pub prb0_ring_enable: bool,
pub vfg_done: bool,
pub vs_done: bool,
pub hs_done: bool,
pub te_done: bool,
pub ds_done: bool,
pub gs_done: bool,
pub sol_done: bool,
pub cl_done: bool,
pub sf_done: bool,
pub tdg_done: bool,
pub urbm_done: bool,
pub svg_done: bool,
pub gafs_done: bool,
pub vfe_done: bool,
pub tsg_done: bool,
pub gafm_done: bool,
pub gam_done: bool,
pub sde_done: bool,
pub rccfbc_cs_done: bool,
}
impl Instdone1 {
pub const DWORD_LENGTH: u32 = 1;
pub const NUM: u64 = 0x206c;
}
impl Default for Instdone1 {
fn default() -> Self {
Instdone1 {
prb0_ring_enable: Default::default(),
vfg_done: Default::default(),
vs_done: Default::default(),
hs_done: Default::default(),
te_done: Default::default(),
ds_done: Default::default(),
gs_done: Default::default(),
sol_done: Default::default(),
cl_done: Default::default(),
sf_done: Default::default(),
tdg_done: Default::default(),
urbm_done: Default::default(),
svg_done: Default::default(),
gafs_done: Default::default(),
vfe_done: Default::default(),
tsg_done: Default::default(),
gafm_done: Default::default(),
gam_done: Default::default(),
sde_done: Default::default(),
rccfbc_cs_done: Default::default(),
}
}
}
impl Serialize for Instdone1 {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.prb0_ring_enable.into(), 0, 0) |
__gen_uint(self.vfg_done.into(), 1, 1) |
__gen_uint(self.vs_done.into(), 2, 2) |
__gen_uint(self.hs_done.into(), 3, 3) |
__gen_uint(self.te_done.into(), 4, 4) |
__gen_uint(self.ds_done.into(), 5, 5) |
__gen_uint(self.gs_done.into(), 6, 6) |
__gen_uint(self.sol_done.into(), 7, 7) |
__gen_uint(self.cl_done.into(), 8, 8) |
__gen_uint(self.sf_done.into(), 9, 9) |
__gen_uint(self.tdg_done.into(), 12, 12) |
__gen_uint(self.urbm_done.into(), 13, 13) |
__gen_uint(self.svg_done.into(), 14, 14) |
__gen_uint(self.gafs_done.into(), 15, 15) |
__gen_uint(self.vfe_done.into(), 16, 16) |
__gen_uint(self.tsg_done.into(), 17, 17) |
__gen_uint(self.gafm_done.into(), 18, 18) |
__gen_uint(self.gam_done.into(), 19, 19) |
__gen_uint(self.sde_done.into(), 22, 22) |
__gen_uint(self.rccfbc_cs_done.into(), 23, 23);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for Instdone1 {
fn from(input: &[u32; 1]) -> Self {
Instdone1 {
prb0_ring_enable: __gen_unuint(input[0], 0, 0) != 0,
vfg_done: __gen_unuint(input[0], 1, 1) != 0,
vs_done: __gen_unuint(input[0], 2, 2) != 0,
hs_done: __gen_unuint(input[0], 3, 3) != 0,
te_done: __gen_unuint(input[0], 4, 4) != 0,
ds_done: __gen_unuint(input[0], 5, 5) != 0,
gs_done: __gen_unuint(input[0], 6, 6) != 0,
sol_done: __gen_unuint(input[0], 7, 7) != 0,
cl_done: __gen_unuint(input[0], 8, 8) != 0,
sf_done: __gen_unuint(input[0], 9, 9) != 0,
tdg_done: __gen_unuint(input[0], 12, 12) != 0,
urbm_done: __gen_unuint(input[0], 13, 13) != 0,
svg_done: __gen_unuint(input[0], 14, 14) != 0,
gafs_done: __gen_unuint(input[0], 15, 15) != 0,
vfe_done: __gen_unuint(input[0], 16, 16) != 0,
tsg_done: __gen_unuint(input[0], 17, 17) != 0,
gafm_done: __gen_unuint(input[0], 18, 18) != 0,
gam_done: __gen_unuint(input[0], 19, 19) != 0,
sde_done: __gen_unuint(input[0], 22, 22) != 0,
rccfbc_cs_done: __gen_unuint(input[0], 23, 23) != 0,
}
}
}
impl Deserialize for Instdone1 {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct Instpm {
pub _3d_state_instruction_disable: bool,
pub _3d_rendering_instruction_disable: bool,
pub media_instruction_disable: bool,
pub constant_buffer_address_offset_disable: bool,
pub _3d_state_instruction_disable_mask: bool,
pub _3d_rendering_instruction_disable_mask: bool,
pub media_instruction_disable_mask: bool,
pub constant_buffer_address_offset_disable_mask: bool,
}
impl Instpm {
pub const DWORD_LENGTH: u32 = 1;
pub const NUM: u64 = 0x20c0;
}
impl Default for Instpm {
fn default() -> Self {
Instpm {
_3d_state_instruction_disable: Default::default(),
_3d_rendering_instruction_disable: Default::default(),
media_instruction_disable: Default::default(),
constant_buffer_address_offset_disable: Default::default(),
_3d_state_instruction_disable_mask: Default::default(),
_3d_rendering_instruction_disable_mask: Default::default(),
media_instruction_disable_mask: Default::default(),
constant_buffer_address_offset_disable_mask: Default::default(),
}
}
}
impl Serialize for Instpm {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self._3d_state_instruction_disable.into(), 1, 1) |
__gen_uint(self._3d_rendering_instruction_disable.into(), 2, 2) |
__gen_uint(self.media_instruction_disable.into(), 3, 3) |
__gen_uint(self.constant_buffer_address_offset_disable.into(), 6, 6) |
__gen_uint(self._3d_state_instruction_disable_mask.into(), 17, 17) |
__gen_uint(self._3d_rendering_instruction_disable_mask.into(), 18, 18) |
__gen_uint(self.media_instruction_disable_mask.into(), 19, 19) |
__gen_uint(self.constant_buffer_address_offset_disable_mask.into(), 22, 22);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for Instpm {
fn from(input: &[u32; 1]) -> Self {
Instpm {
_3d_state_instruction_disable: __gen_unuint(input[0], 1, 1) != 0,
_3d_rendering_instruction_disable: __gen_unuint(input[0], 2, 2) != 0,
media_instruction_disable: __gen_unuint(input[0], 3, 3) != 0,
constant_buffer_address_offset_disable: __gen_unuint(input[0], 6, 6) != 0,
_3d_state_instruction_disable_mask: __gen_unuint(input[0], 17, 17) != 0,
_3d_rendering_instruction_disable_mask: __gen_unuint(input[0], 18, 18) != 0,
media_instruction_disable_mask: __gen_unuint(input[0], 19, 19) != 0,
constant_buffer_address_offset_disable_mask: __gen_unuint(input[0], 22, 22) != 0,
}
}
}
impl Deserialize for Instpm {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct InterfaceDescriptorData {
pub kernel_start_pointer: u64,
pub software_exception_enable: bool,
pub mask_stack_exception_enable: bool,
pub illegal_opcode_exception_enable: bool,
pub floating_point_mode: u32,
pub thread_priority: u32,
pub single_program_flow: bool,
pub sampler_count: u32,
pub sampler_state_pointer: u64,
pub binding_table_entry_count: u32,
pub binding_table_pointer: u64,
pub constant_urb_entry_read_offset: u32,
pub constant_urb_entry_read_length: u32,
pub number_of_threads_in_gpgpu_thread_group: u32,
pub shared_local_memory_size: u32,
pub barrier_enable: bool,
pub rounding_mode: u32,
}
impl InterfaceDescriptorData {
pub const DWORD_LENGTH: u32 = 8;
pub const ALTERNATE: u32 = 1;
pub const BETWEEN_13_AND_16_SAMPLERS_USED: u32 = 4;
pub const BETWEEN_1_AND_4_SAMPLERS_USED: u32 = 1;
pub const BETWEEN_5_AND_8_SAMPLERS_USED: u32 = 2;
pub const BETWEEN_9_AND_12_SAMPLERS_USED: u32 = 3;
pub const HIGH_PRIORITY: u32 = 1;
pub const IEEE_754: u32 = 0;
pub const NORMAL_PRIORITY: u32 = 0;
pub const NO_SAMPLERS_USED: u32 = 0;
pub const RD: u32 = 2;
pub const RTNE: u32 = 0;
pub const RTZ: u32 = 3;
pub const RU: u32 = 1;
}
impl Default for InterfaceDescriptorData {
fn default() -> Self {
InterfaceDescriptorData {
kernel_start_pointer: Default::default(),
software_exception_enable: Default::default(),
mask_stack_exception_enable: Default::default(),
illegal_opcode_exception_enable: Default::default(),
floating_point_mode: Default::default(),
thread_priority: Default::default(),
single_program_flow: Default::default(),
sampler_count: Default::default(),
sampler_state_pointer: Default::default(),
binding_table_entry_count: Default::default(),
binding_table_pointer: Default::default(),
constant_urb_entry_read_offset: Default::default(),
constant_urb_entry_read_length: Default::default(),
number_of_threads_in_gpgpu_thread_group: Default::default(),
shared_local_memory_size: Default::default(),
barrier_enable: Default::default(),
rounding_mode: Default::default(),
}
}
}
impl Serialize for InterfaceDescriptorData {
type Out = [u32; 8];
fn pack_into(&self, out: &mut [u32; 8]) {
out[0] = __gen_offset(self.kernel_start_pointer as u32, 6, 31);
out[1] = __gen_uint(self.software_exception_enable.into(), 7, 7) |
__gen_uint(self.mask_stack_exception_enable.into(), 11, 11) |
__gen_uint(self.illegal_opcode_exception_enable.into(), 13, 13) |
__gen_uint(self.floating_point_mode, 16, 16) |
__gen_uint(self.thread_priority, 17, 17) |
__gen_uint(self.single_program_flow.into(), 18, 18);
out[2] = __gen_uint(self.sampler_count, 2, 4) |
__gen_offset(self.sampler_state_pointer as u32, 5, 31);
out[3] = __gen_uint(self.binding_table_entry_count, 0, 4) |
__gen_offset(self.binding_table_pointer as u32, 5, 15);
out[4] = __gen_uint(self.constant_urb_entry_read_offset, 0, 15) |
__gen_uint(self.constant_urb_entry_read_length, 16, 31);
out[5] = __gen_uint(self.number_of_threads_in_gpgpu_thread_group, 0, 7) |
__gen_uint(self.shared_local_memory_size, 16, 20) |
__gen_uint(self.barrier_enable.into(), 21, 21) |
__gen_uint(self.rounding_mode, 22, 23);
out[6] = 0;
out[7] = 0;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 8];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 8] as *const [u8; 32]) })
}
}
impl From<&[u32; 8]> for InterfaceDescriptorData {
fn from(input: &[u32; 8]) -> Self {
InterfaceDescriptorData {
kernel_start_pointer: (__gen_unuint(input[0], 6, 31) as u64) << 6,
software_exception_enable: __gen_unuint(input[1], 7, 7) != 0,
mask_stack_exception_enable: __gen_unuint(input[1], 11, 11) != 0,
illegal_opcode_exception_enable: __gen_unuint(input[1], 13, 13) != 0,
floating_point_mode: __gen_unuint(input[1], 16, 16),
thread_priority: __gen_unuint(input[1], 17, 17),
single_program_flow: __gen_unuint(input[1], 18, 18) != 0,
sampler_count: __gen_unuint(input[2], 2, 4),
sampler_state_pointer: (__gen_unuint(input[2], 5, 31) as u64) << 5,
binding_table_entry_count: __gen_unuint(input[3], 0, 4),
binding_table_pointer: (__gen_unuint(input[3], 5, 15) as u64) << 5,
constant_urb_entry_read_offset: __gen_unuint(input[4], 0, 15),
constant_urb_entry_read_length: __gen_unuint(input[4], 16, 31),
number_of_threads_in_gpgpu_thread_group: __gen_unuint(input[5], 0, 7),
shared_local_memory_size: __gen_unuint(input[5], 16, 20),
barrier_enable: __gen_unuint(input[5], 21, 21) != 0,
rounding_mode: __gen_unuint(input[5], 22, 23),
}
}
}
impl Deserialize for InterfaceDescriptorData {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 8];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 8] as *mut [u8; 32]) })?;
Ok((&input).into())
}
}
pub struct L3cntlreg2 {
pub slm_enable: u32,
pub urb_allocation: u32,
pub urb_low_bandwidth: u32,
pub all_allocation: u32,
pub ro_allocation: u32,
pub ro_low_bandwidth: u32,
pub dc_allocation: u32,
pub dc_low_bandwidth: u32,
}
impl L3cntlreg2 {
pub const DWORD_LENGTH: u32 = 1;
pub const NUM: u64 = 0xb020;
}
impl Default for L3cntlreg2 {
fn default() -> Self {
L3cntlreg2 {
slm_enable: Default::default(),
urb_allocation: Default::default(),
urb_low_bandwidth: Default::default(),
all_allocation: Default::default(),
ro_allocation: Default::default(),
ro_low_bandwidth: Default::default(),
dc_allocation: Default::default(),
dc_low_bandwidth: Default::default(),
}
}
}
impl Serialize for L3cntlreg2 {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.slm_enable, 0, 0) |
__gen_uint(self.urb_allocation, 1, 6) |
__gen_uint(self.urb_low_bandwidth, 7, 7) |
__gen_uint(self.all_allocation, 8, 13) |
__gen_uint(self.ro_allocation, 14, 19) |
__gen_uint(self.ro_low_bandwidth, 20, 20) |
__gen_uint(self.dc_allocation, 21, 26) |
__gen_uint(self.dc_low_bandwidth, 27, 27);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for L3cntlreg2 {
fn from(input: &[u32; 1]) -> Self {
L3cntlreg2 {
slm_enable: __gen_unuint(input[0], 0, 0),
urb_allocation: __gen_unuint(input[0], 1, 6),
urb_low_bandwidth: __gen_unuint(input[0], 7, 7),
all_allocation: __gen_unuint(input[0], 8, 13),
ro_allocation: __gen_unuint(input[0], 14, 19),
ro_low_bandwidth: __gen_unuint(input[0], 20, 20),
dc_allocation: __gen_unuint(input[0], 21, 26),
dc_low_bandwidth: __gen_unuint(input[0], 27, 27),
}
}
}
impl Deserialize for L3cntlreg2 {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct L3cntlreg3 {
pub is_allocation: u32,
pub is_low_bandwidth: u32,
pub c_allocation: u32,
pub c_low_bandwidth: u32,
pub t_allocation: u32,
pub t_low_bandwidth: u32,
}
impl L3cntlreg3 {
pub const DWORD_LENGTH: u32 = 1;
pub const NUM: u64 = 0xb024;
}
impl Default for L3cntlreg3 {
fn default() -> Self {
L3cntlreg3 {
is_allocation: Default::default(),
is_low_bandwidth: Default::default(),
c_allocation: Default::default(),
c_low_bandwidth: Default::default(),
t_allocation: Default::default(),
t_low_bandwidth: Default::default(),
}
}
}
impl Serialize for L3cntlreg3 {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.is_allocation, 1, 6) |
__gen_uint(self.is_low_bandwidth, 7, 7) |
__gen_uint(self.c_allocation, 8, 13) |
__gen_uint(self.c_low_bandwidth, 14, 14) |
__gen_uint(self.t_allocation, 15, 20) |
__gen_uint(self.t_low_bandwidth, 21, 21);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for L3cntlreg3 {
fn from(input: &[u32; 1]) -> Self {
L3cntlreg3 {
is_allocation: __gen_unuint(input[0], 1, 6),
is_low_bandwidth: __gen_unuint(input[0], 7, 7),
c_allocation: __gen_unuint(input[0], 8, 13),
c_low_bandwidth: __gen_unuint(input[0], 14, 14),
t_allocation: __gen_unuint(input[0], 15, 20),
t_low_bandwidth: __gen_unuint(input[0], 21, 21),
}
}
}
impl Deserialize for L3cntlreg3 {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct L3sqcreg1 {
pub convert_dc_uc: u32,
pub convert_is_uc: u32,
pub convert_c_uc: u32,
pub convert_t_uc: u32,
}
impl L3sqcreg1 {
pub const DWORD_LENGTH: u32 = 1;
pub const NUM: u64 = 0xb010;
}
impl Default for L3sqcreg1 {
fn default() -> Self {
L3sqcreg1 {
convert_dc_uc: Default::default(),
convert_is_uc: Default::default(),
convert_c_uc: Default::default(),
convert_t_uc: Default::default(),
}
}
}
impl Serialize for L3sqcreg1 {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.convert_dc_uc, 24, 24) |
__gen_uint(self.convert_is_uc, 25, 25) |
__gen_uint(self.convert_c_uc, 26, 26) |
__gen_uint(self.convert_t_uc, 27, 27);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for L3sqcreg1 {
fn from(input: &[u32; 1]) -> Self {
L3sqcreg1 {
convert_dc_uc: __gen_unuint(input[0], 24, 24),
convert_is_uc: __gen_unuint(input[0], 25, 25),
convert_c_uc: __gen_unuint(input[0], 26, 26),
convert_t_uc: __gen_unuint(input[0], 27, 27),
}
}
}
impl Deserialize for L3sqcreg1 {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct MediaCurbeLoad {
pub dword_length: u32,
pub subopcode: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub curbe_total_data_length: u32,
pub curbe_data_start_address: u32,
}
impl MediaCurbeLoad {
pub const DWORD_LENGTH: u32 = 4;
}
impl Default for MediaCurbeLoad {
fn default() -> Self {
MediaCurbeLoad {
dword_length: 2,
subopcode: 1,
media_command_opcode: 0,
pipeline: 2,
command_type: 3,
curbe_total_data_length: Default::default(),
curbe_data_start_address: Default::default(),
}
}
}
impl Serialize for MediaCurbeLoad {
type Out = [u32; 4];
fn pack_into(&self, out: &mut [u32; 4]) {
out[0] = __gen_uint(self.dword_length, 0, 15) |
__gen_uint(self.subopcode, 16, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = 0;
out[2] = __gen_uint(self.curbe_total_data_length, 0, 16);
out[3] = __gen_uint(self.curbe_data_start_address, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 4];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 4] as *const [u8; 16]) })
}
}
impl From<&[u32; 4]> for MediaCurbeLoad {
fn from(input: &[u32; 4]) -> Self {
MediaCurbeLoad {
dword_length: __gen_unuint(input[0], 0, 15),
subopcode: __gen_unuint(input[0], 16, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
curbe_total_data_length: __gen_unuint(input[2], 0, 16),
curbe_data_start_address: __gen_unuint(input[3], 0, 31),
}
}
}
impl Deserialize for MediaCurbeLoad {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 4];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 4] as *mut [u8; 16]) })?;
Ok((&input).into())
}
}
pub struct MediaInterfaceDescriptorLoad {
pub dword_length: u32,
pub subopcode: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub interface_descriptor_total_length: u32,
pub interface_descriptor_data_start_address: u64,
}
impl MediaInterfaceDescriptorLoad {
pub const DWORD_LENGTH: u32 = 4;
}
impl Default for MediaInterfaceDescriptorLoad {
fn default() -> Self {
MediaInterfaceDescriptorLoad {
dword_length: 2,
subopcode: 2,
media_command_opcode: 0,
pipeline: 2,
command_type: 3,
interface_descriptor_total_length: Default::default(),
interface_descriptor_data_start_address: Default::default(),
}
}
}
impl Serialize for MediaInterfaceDescriptorLoad {
type Out = [u32; 4];
fn pack_into(&self, out: &mut [u32; 4]) {
out[0] = __gen_uint(self.dword_length, 0, 15) |
__gen_uint(self.subopcode, 16, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = 0;
out[2] = __gen_uint(self.interface_descriptor_total_length, 0, 16);
out[3] = __gen_offset(self.interface_descriptor_data_start_address as u32, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 4];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 4] as *const [u8; 16]) })
}
}
impl From<&[u32; 4]> for MediaInterfaceDescriptorLoad {
fn from(input: &[u32; 4]) -> Self {
MediaInterfaceDescriptorLoad {
dword_length: __gen_unuint(input[0], 0, 15),
subopcode: __gen_unuint(input[0], 16, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
interface_descriptor_total_length: __gen_unuint(input[2], 0, 16),
interface_descriptor_data_start_address: (__gen_unuint(input[3], 0, 31) as u64),
}
}
}
impl Deserialize for MediaInterfaceDescriptorLoad {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 4];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 4] as *mut [u8; 16]) })?;
Ok((&input).into())
}
}
pub struct MediaObject<A: Addr + Default> {
pub dword_length: u32,
pub media_command_sub_opcode: u32,
pub media_command_opcode: u32,
pub media_command_pipeline: u32,
pub command_type: u32,
pub interface_descriptor_offset: u32,
pub indirect_data_length: u32,
pub half_slice_destination_select: u32,
pub use_scoreboard: u32,
pub thread_synchronization: u32,
pub children_present: bool,
pub indirect_data_start_address: A,
pub scoreboard_x: u32,
pub scoredboard_y: u32,
pub scoreboard_mask: u32,
pub scoreboard_color: u32,
}
impl<A: Addr + Default> MediaObject<A> {
pub const DWORD_LENGTH: u32 = 6;
pub const EITHER_HALF_SLICE: u32 = 0;
pub const HALF_SLICE_0: u32 = 1;
pub const HALF_SLICE_1: u32 = 2;
pub const NOT_USING_SCOREBOARD: u32 = 0;
pub const NO_THREAD_SYNCHRONIZATION: u32 = 0;
pub const THREAD_DISPATCH_IS_SYNCHRONIZED_BY_THE_SPAWN_ROOT_THREAD_MESSAGE: u32 = 1;
pub const USING_SCOREBOARD: u32 = 1;
}
impl<A: Addr + Default> Default for MediaObject<A> {
fn default() -> Self {
MediaObject {
dword_length: 4,
media_command_sub_opcode: 0,
media_command_opcode: 1,
media_command_pipeline: 2,
command_type: 3,
interface_descriptor_offset: Default::default(),
indirect_data_length: Default::default(),
half_slice_destination_select: Default::default(),
use_scoreboard: Default::default(),
thread_synchronization: Default::default(),
children_present: Default::default(),
indirect_data_start_address: Default::default(),
scoreboard_x: Default::default(),
scoredboard_y: Default::default(),
scoreboard_mask: Default::default(),
scoreboard_color: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for MediaObject<A> {
type Out = [u32; 6];
fn pack_into(&self, out: &mut [u32; 6]) {
out[0] = __gen_uint(self.dword_length, 0, 15) |
__gen_uint(self.media_command_sub_opcode, 16, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.media_command_pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.interface_descriptor_offset, 0, 4);
out[2] = __gen_uint(self.indirect_data_length, 0, 16) |
__gen_uint(self.half_slice_destination_select, 17, 18) |
__gen_uint(self.use_scoreboard, 21, 21) |
__gen_uint(self.thread_synchronization, 24, 24) |
__gen_uint(self.children_present.into(), 31, 31);
let v3_address = self.indirect_data_start_address.combine(0);
out[3] = v3_address as u32;
out[4] = (v3_address >> 32) as u32;
out[4] = __gen_uint(self.scoreboard_x, 0, 8) |
__gen_uint(self.scoredboard_y, 16, 24);
out[5] = __gen_uint(self.scoreboard_mask, 0, 7) |
__gen_uint(self.scoreboard_color, 16, 19);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 6];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 6] as *const [u8; 24]) })
}
}
impl From<&[u32; 6]> for MediaObject<u64> {
fn from(input: &[u32; 6]) -> Self {
MediaObject {
dword_length: __gen_unuint(input[0], 0, 15),
media_command_sub_opcode: __gen_unuint(input[0], 16, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
media_command_pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
interface_descriptor_offset: __gen_unuint(input[1], 0, 4),
indirect_data_length: __gen_unuint(input[2], 0, 16),
half_slice_destination_select: __gen_unuint(input[2], 17, 18),
use_scoreboard: __gen_unuint(input[2], 21, 21),
thread_synchronization: __gen_unuint(input[2], 24, 24),
children_present: __gen_unuint(input[2], 31, 31) != 0,
indirect_data_start_address: (__gen_unuint(input[3], 0, 31) as u64),
scoreboard_x: __gen_unuint(input[4], 0, 8),
scoredboard_y: __gen_unuint(input[4], 16, 24),
scoreboard_mask: __gen_unuint(input[5], 0, 7),
scoreboard_color: __gen_unuint(input[5], 16, 19),
}
}
}
impl Deserialize for MediaObject<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 6];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 6] as *mut [u8; 24]) })?;
Ok((&input).into())
}
}
pub struct MediaObjectPrt {
pub dword_length: u32,
pub subopcode: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub interface_descriptor_offset: u32,
pub prt_fencetype: u32,
pub prt_fence_needed: bool,
pub children_present: bool,
pub inline_data: [u32; 12],
}
impl MediaObjectPrt {
pub const DWORD_LENGTH: u32 = 16;
pub const ROOT_THREAD_QUEUE: u32 = 0;
pub const VFE_STATE_FLUSH: u32 = 1;
}
impl Default for MediaObjectPrt {
fn default() -> Self {
MediaObjectPrt {
dword_length: 14,
subopcode: 2,
media_command_opcode: 1,
pipeline: 2,
command_type: 3,
interface_descriptor_offset: Default::default(),
prt_fencetype: Default::default(),
prt_fence_needed: Default::default(),
children_present: Default::default(),
inline_data: Default::default(),
}
}
}
impl Serialize for MediaObjectPrt {
type Out = [u32; 16];
fn pack_into(&self, out: &mut [u32; 16]) {
out[0] = __gen_uint(self.dword_length, 0, 15) |
__gen_uint(self.subopcode, 16, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.interface_descriptor_offset, 0, 4);
out[2] = __gen_uint(self.prt_fencetype, 22, 22) |
__gen_uint(self.prt_fence_needed.into(), 23, 23) |
__gen_uint(self.children_present.into(), 31, 31);
out[3] = 0;
out[4] = __gen_uint(self.inline_data[0], 0, 31);
out[5] = __gen_uint(self.inline_data[1], 0, 31);
out[6] = __gen_uint(self.inline_data[2], 0, 31);
out[7] = __gen_uint(self.inline_data[3], 0, 31);
out[8] = __gen_uint(self.inline_data[4], 0, 31);
out[9] = __gen_uint(self.inline_data[5], 0, 31);
out[10] = __gen_uint(self.inline_data[6], 0, 31);
out[11] = __gen_uint(self.inline_data[7], 0, 31);
out[12] = __gen_uint(self.inline_data[8], 0, 31);
out[13] = __gen_uint(self.inline_data[9], 0, 31);
out[14] = __gen_uint(self.inline_data[10], 0, 31);
out[15] = __gen_uint(self.inline_data[11], 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 16];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 16] as *const [u8; 64]) })
}
}
impl From<&[u32; 16]> for MediaObjectPrt {
fn from(input: &[u32; 16]) -> Self {
MediaObjectPrt {
dword_length: __gen_unuint(input[0], 0, 15),
subopcode: __gen_unuint(input[0], 16, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
interface_descriptor_offset: __gen_unuint(input[1], 0, 4),
prt_fencetype: __gen_unuint(input[2], 22, 22),
prt_fence_needed: __gen_unuint(input[2], 23, 23) != 0,
children_present: __gen_unuint(input[2], 31, 31) != 0,
inline_data: [
__gen_unuint(input[4], 0, 31),
__gen_unuint(input[5], 0, 31),
__gen_unuint(input[6], 0, 31),
__gen_unuint(input[7], 0, 31),
__gen_unuint(input[8], 0, 31),
__gen_unuint(input[9], 0, 31),
__gen_unuint(input[10], 0, 31),
__gen_unuint(input[11], 0, 31),
__gen_unuint(input[12], 0, 31),
__gen_unuint(input[13], 0, 31),
__gen_unuint(input[14], 0, 31),
__gen_unuint(input[15], 0, 31)
],
}
}
}
impl Deserialize for MediaObjectPrt {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 16];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 16] as *mut [u8; 64]) })?;
Ok((&input).into())
}
}
pub struct MediaObjectWalker {
pub dword_length: u32,
pub subopcode: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub interface_descriptor_offset: u32,
pub indirect_data_length: u32,
pub use_scoreboard: u32,
pub thread_synchronization: u32,
pub children_present: u32,
pub indirect_data_start_address: u64,
pub scoreboard_mask: u32,
pub mid_loop_unit_x: i32,
pub local_mid_loop_unit_y: i32,
pub middle_loop_extra_steps: u32,
pub color_count_minus_one: u32,
pub repel: u32,
pub dual_mode: u32,
pub local_loop_exec_count: u32,
pub global_loop_exec_count: u32,
pub block_resolution_x: u32,
pub block_resolution_y: u32,
pub local_start_x: u32,
pub local_start_y: u32,
pub local_end_x: u32,
pub local_end_y: u32,
pub local_outer_loop_stride_x: i32,
pub local_outer_loop_stride_y: i32,
pub local_inner_loop_unit_x: i32,
pub local_inner_loop_unit_y: i32,
pub global_resolution_x: u32,
pub global_resolution_y: u32,
pub global_start_x: i32,
pub global_start_y: i32,
pub global_outer_loop_stride_x: i32,
pub global_outer_loop_stride_y: i32,
pub global_inner_loop_unit_x: i32,
pub global_inner_loop_unit_y: i32,
}
impl MediaObjectWalker {
pub const DWORD_LENGTH: u32 = 17;
pub const NOT_USING_SCOREBOARD: u32 = 0;
pub const NO_THREAD_SYNCHRONIZATION: u32 = 0;
pub const THREAD_DISPATCH_IS_SYNCHRONIZED_BY_THE_SPAWN_ROOT_THREAD_MESSAGE: u32 = 1;
pub const USING_SCOREBOARD: u32 = 1;
}
impl Default for MediaObjectWalker {
fn default() -> Self {
MediaObjectWalker {
dword_length: 15,
subopcode: 3,
media_command_opcode: 1,
pipeline: 2,
command_type: 3,
interface_descriptor_offset: Default::default(),
indirect_data_length: Default::default(),
use_scoreboard: Default::default(),
thread_synchronization: Default::default(),
children_present: Default::default(),
indirect_data_start_address: Default::default(),
scoreboard_mask: Default::default(),
mid_loop_unit_x: Default::default(),
local_mid_loop_unit_y: Default::default(),
middle_loop_extra_steps: Default::default(),
color_count_minus_one: Default::default(),
repel: Default::default(),
dual_mode: Default::default(),
local_loop_exec_count: Default::default(),
global_loop_exec_count: Default::default(),
block_resolution_x: Default::default(),
block_resolution_y: Default::default(),
local_start_x: Default::default(),
local_start_y: Default::default(),
local_end_x: Default::default(),
local_end_y: Default::default(),
local_outer_loop_stride_x: Default::default(),
local_outer_loop_stride_y: Default::default(),
local_inner_loop_unit_x: Default::default(),
local_inner_loop_unit_y: Default::default(),
global_resolution_x: Default::default(),
global_resolution_y: Default::default(),
global_start_x: Default::default(),
global_start_y: Default::default(),
global_outer_loop_stride_x: Default::default(),
global_outer_loop_stride_y: Default::default(),
global_inner_loop_unit_x: Default::default(),
global_inner_loop_unit_y: Default::default(),
}
}
}
impl Serialize for MediaObjectWalker {
type Out = [u32; 17];
fn pack_into(&self, out: &mut [u32; 17]) {
out[0] = __gen_uint(self.dword_length, 0, 15) |
__gen_uint(self.subopcode, 16, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.interface_descriptor_offset, 0, 4);
out[2] = __gen_uint(self.indirect_data_length, 0, 16) |
__gen_uint(self.use_scoreboard, 21, 21) |
__gen_uint(self.thread_synchronization, 24, 24) |
__gen_uint(self.children_present, 31, 31);
out[3] = __gen_offset(self.indirect_data_start_address as u32, 0, 31);
out[4] = 0;
out[5] = __gen_uint(self.scoreboard_mask, 0, 7);
out[6] = __gen_uint(self.mid_loop_unit_x as u32, 8, 9) |
__gen_uint(self.local_mid_loop_unit_y as u32, 12, 13) |
__gen_uint(self.middle_loop_extra_steps, 16, 20) |
__gen_uint(self.color_count_minus_one, 24, 27) |
__gen_uint(self.repel, 30, 30) |
__gen_uint(self.dual_mode, 31, 31);
out[7] = __gen_uint(self.local_loop_exec_count, 0, 9) |
__gen_uint(self.global_loop_exec_count, 16, 25);
out[8] = __gen_uint(self.block_resolution_x, 0, 8) |
__gen_uint(self.block_resolution_y, 16, 24);
out[9] = __gen_uint(self.local_start_x, 0, 8) |
__gen_uint(self.local_start_y, 16, 24);
out[10] = __gen_uint(self.local_end_x, 0, 8) |
__gen_uint(self.local_end_y, 16, 24);
out[11] = __gen_uint(self.local_outer_loop_stride_x as u32, 0, 9) |
__gen_uint(self.local_outer_loop_stride_y as u32, 16, 25);
out[12] = __gen_uint(self.local_inner_loop_unit_x as u32, 0, 9) |
__gen_uint(self.local_inner_loop_unit_y as u32, 16, 25);
out[13] = __gen_uint(self.global_resolution_x, 0, 8) |
__gen_uint(self.global_resolution_y, 16, 24);
out[14] = __gen_uint(self.global_start_x as u32, 0, 9) |
__gen_uint(self.global_start_y as u32, 16, 25);
out[15] = __gen_uint(self.global_outer_loop_stride_x as u32, 0, 9) |
__gen_uint(self.global_outer_loop_stride_y as u32, 16, 25);
out[16] = __gen_uint(self.global_inner_loop_unit_x as u32, 0, 9) |
__gen_uint(self.global_inner_loop_unit_y as u32, 16, 25);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 17];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 17] as *const [u8; 68]) })
}
}
impl From<&[u32; 17]> for MediaObjectWalker {
fn from(input: &[u32; 17]) -> Self {
MediaObjectWalker {
dword_length: __gen_unuint(input[0], 0, 15),
subopcode: __gen_unuint(input[0], 16, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
interface_descriptor_offset: __gen_unuint(input[1], 0, 4),
indirect_data_length: __gen_unuint(input[2], 0, 16),
use_scoreboard: __gen_unuint(input[2], 21, 21),
thread_synchronization: __gen_unuint(input[2], 24, 24),
children_present: __gen_unuint(input[2], 31, 31),
indirect_data_start_address: (__gen_unuint(input[3], 0, 31) as u64),
scoreboard_mask: __gen_unuint(input[5], 0, 7),
mid_loop_unit_x: (__gen_unuint(input[6], 8, 9)) as i32,
local_mid_loop_unit_y: (__gen_unuint(input[6], 12, 13)) as i32,
middle_loop_extra_steps: __gen_unuint(input[6], 16, 20),
color_count_minus_one: __gen_unuint(input[6], 24, 27),
repel: __gen_unuint(input[6], 30, 30),
dual_mode: __gen_unuint(input[6], 31, 31),
local_loop_exec_count: __gen_unuint(input[7], 0, 9),
global_loop_exec_count: __gen_unuint(input[7], 16, 25),
block_resolution_x: __gen_unuint(input[8], 0, 8),
block_resolution_y: __gen_unuint(input[8], 16, 24),
local_start_x: __gen_unuint(input[9], 0, 8),
local_start_y: __gen_unuint(input[9], 16, 24),
local_end_x: __gen_unuint(input[10], 0, 8),
local_end_y: __gen_unuint(input[10], 16, 24),
local_outer_loop_stride_x: (__gen_unuint(input[11], 0, 9)) as i32,
local_outer_loop_stride_y: (__gen_unuint(input[11], 16, 25)) as i32,
local_inner_loop_unit_x: (__gen_unuint(input[12], 0, 9)) as i32,
local_inner_loop_unit_y: (__gen_unuint(input[12], 16, 25)) as i32,
global_resolution_x: __gen_unuint(input[13], 0, 8),
global_resolution_y: __gen_unuint(input[13], 16, 24),
global_start_x: (__gen_unuint(input[14], 0, 9)) as i32,
global_start_y: (__gen_unuint(input[14], 16, 25)) as i32,
global_outer_loop_stride_x: (__gen_unuint(input[15], 0, 9)) as i32,
global_outer_loop_stride_y: (__gen_unuint(input[15], 16, 25)) as i32,
global_inner_loop_unit_x: (__gen_unuint(input[16], 0, 9)) as i32,
global_inner_loop_unit_y: (__gen_unuint(input[16], 16, 25)) as i32,
}
}
}
impl Deserialize for MediaObjectWalker {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 17];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 17] as *mut [u8; 68]) })?;
Ok((&input).into())
}
}
pub struct MediaStateFlush {
pub dword_length: u32,
pub subopcode: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub interface_descriptor_offset: u32,
pub watermark_required: u32,
}
impl MediaStateFlush {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for MediaStateFlush {
fn default() -> Self {
MediaStateFlush {
dword_length: 0,
subopcode: 4,
media_command_opcode: 0,
pipeline: 2,
command_type: 3,
interface_descriptor_offset: Default::default(),
watermark_required: Default::default(),
}
}
}
impl Serialize for MediaStateFlush {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 15) |
__gen_uint(self.subopcode, 16, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.interface_descriptor_offset, 0, 5) |
__gen_uint(self.watermark_required, 6, 6);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for MediaStateFlush {
fn from(input: &[u32; 2]) -> Self {
MediaStateFlush {
dword_length: __gen_unuint(input[0], 0, 15),
subopcode: __gen_unuint(input[0], 16, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
interface_descriptor_offset: __gen_unuint(input[1], 0, 5),
watermark_required: __gen_unuint(input[1], 6, 6),
}
}
}
impl Deserialize for MediaStateFlush {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct MediaVfeState<A: Addr + Default> {
pub dword_length: u32,
pub subopcode: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub per_thread_scratch_space: u32,
pub scratch_space_base_pointer: A,
pub gpgpu_mode: u32,
pub gateway_mmio_access_control: u32,
pub bypass_gateway_control: u32,
pub reset_gateway_timer: u32,
pub number_of_urb_entries: u32,
pub maximum_number_of_threads: u32,
pub curbe_allocation_size: u32,
pub urb_entry_allocation_size: u32,
pub scoreboard_mask: u32,
pub scoreboard_type: u32,
pub scoreboard_enable: u32,
pub scoreboard_0_delta_x: i32,
pub scoreboard_0_delta_y: i32,
pub scoreboard_1_delta_x: i32,
pub scoreboard_1_delta_y: i32,
pub scoreboard_2_delta_x: i32,
pub scoreboard_2_delta_y: i32,
pub scoreboard_3_delta_x: i32,
pub scoreboard_3_delta_y: i32,
pub scoreboard_4_delta_x: i32,
pub scoreboard_4_delta_y: i32,
pub scoreboard_5_delta_x: i32,
pub scoreboard_5_delta_y: i32,
pub scoreboard_6_delta_x: i32,
pub scoreboard_6_delta_y: i32,
pub scoreboard_7_delta_x: i32,
pub scoreboard_7_delta_y: i32,
}
impl<A: Addr + Default> MediaVfeState<A> {
pub const DWORD_LENGTH: u32 = 8;
pub const BYPASSING_OPENGATEWAY_CLOSEGATEWAY_PROTOCOL: u32 = 1;
pub const MAINTAINING_OPENGATEWAY_FORWARDMSG_CLOSEGATEWAY_PROTOCOL_LEGACY_MODE: u32 = 0;
pub const MAINTAINING_THE_EXISTING_TIMESTAMP_STATE: u32 = 0;
pub const MMIO_READ_WRITE_TO_ANY_ADDRESS: u32 = 2;
pub const NON_STALLING_SCOREBOARD: u32 = 1;
pub const NO_MMIO_READ_WRITE_ALLOWED: u32 = 0;
pub const RESETTING_RELATIVE_TIMER_AND_LATCHING_THE_GLOBAL_TIMESTAMP: u32 = 1;
pub const SCOREBOARD_DISABLED: u32 = 0;
pub const SCOREBOARD_ENABLED: u32 = 1;
pub const STALLING_SCOREBOARD: u32 = 0;
}
impl<A: Addr + Default> Default for MediaVfeState<A> {
fn default() -> Self {
MediaVfeState {
dword_length: 6,
subopcode: 0,
media_command_opcode: 0,
pipeline: 2,
command_type: 3,
per_thread_scratch_space: Default::default(),
scratch_space_base_pointer: Default::default(),
gpgpu_mode: Default::default(),
gateway_mmio_access_control: Default::default(),
bypass_gateway_control: Default::default(),
reset_gateway_timer: Default::default(),
number_of_urb_entries: Default::default(),
maximum_number_of_threads: Default::default(),
curbe_allocation_size: Default::default(),
urb_entry_allocation_size: Default::default(),
scoreboard_mask: Default::default(),
scoreboard_type: Default::default(),
scoreboard_enable: Default::default(),
scoreboard_0_delta_x: Default::default(),
scoreboard_0_delta_y: Default::default(),
scoreboard_1_delta_x: Default::default(),
scoreboard_1_delta_y: Default::default(),
scoreboard_2_delta_x: Default::default(),
scoreboard_2_delta_y: Default::default(),
scoreboard_3_delta_x: Default::default(),
scoreboard_3_delta_y: Default::default(),
scoreboard_4_delta_x: Default::default(),
scoreboard_4_delta_y: Default::default(),
scoreboard_5_delta_x: Default::default(),
scoreboard_5_delta_y: Default::default(),
scoreboard_6_delta_x: Default::default(),
scoreboard_6_delta_y: Default::default(),
scoreboard_7_delta_x: Default::default(),
scoreboard_7_delta_y: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for MediaVfeState<A> {
type Out = [u32; 8];
fn pack_into(&self, out: &mut [u32; 8]) {
out[0] = __gen_uint(self.dword_length, 0, 15) |
__gen_uint(self.subopcode, 16, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
let v1 = __gen_uint(self.per_thread_scratch_space, 0, 3);
let v1_address = self.scratch_space_base_pointer.combine(v1);
out[1] = v1_address as u32;
out[2] = (v1_address >> 32) as u32;
out[2] = __gen_uint(self.gpgpu_mode, 2, 2) |
__gen_uint(self.gateway_mmio_access_control, 3, 4) |
__gen_uint(self.bypass_gateway_control, 6, 6) |
__gen_uint(self.reset_gateway_timer, 7, 7) |
__gen_uint(self.number_of_urb_entries, 8, 15) |
__gen_uint(self.maximum_number_of_threads, 16, 31);
out[3] = 0;
out[4] = __gen_uint(self.curbe_allocation_size, 0, 15) |
__gen_uint(self.urb_entry_allocation_size, 16, 31);
out[5] = __gen_uint(self.scoreboard_mask, 0, 7) |
__gen_uint(self.scoreboard_type, 30, 30) |
__gen_uint(self.scoreboard_enable, 31, 31);
out[6] = __gen_uint(self.scoreboard_0_delta_x as u32, 0, 3) |
__gen_uint(self.scoreboard_0_delta_y as u32, 4, 7) |
__gen_uint(self.scoreboard_1_delta_x as u32, 8, 11) |
__gen_uint(self.scoreboard_1_delta_y as u32, 12, 15) |
__gen_uint(self.scoreboard_2_delta_x as u32, 16, 19) |
__gen_uint(self.scoreboard_2_delta_y as u32, 20, 23) |
__gen_uint(self.scoreboard_3_delta_x as u32, 24, 27) |
__gen_uint(self.scoreboard_3_delta_y as u32, 28, 31);
out[7] = __gen_uint(self.scoreboard_4_delta_x as u32, 0, 3) |
__gen_uint(self.scoreboard_4_delta_y as u32, 4, 7) |
__gen_uint(self.scoreboard_5_delta_x as u32, 8, 11) |
__gen_uint(self.scoreboard_5_delta_y as u32, 12, 15) |
__gen_uint(self.scoreboard_6_delta_x as u32, 16, 19) |
__gen_uint(self.scoreboard_6_delta_y as u32, 20, 23) |
__gen_uint(self.scoreboard_7_delta_x as u32, 24, 27) |
__gen_uint(self.scoreboard_7_delta_y as u32, 28, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 8];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 8] as *const [u8; 32]) })
}
}
impl From<&[u32; 8]> for MediaVfeState<u64> {
fn from(input: &[u32; 8]) -> Self {
MediaVfeState {
dword_length: __gen_unuint(input[0], 0, 15),
subopcode: __gen_unuint(input[0], 16, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
per_thread_scratch_space: __gen_unuint(input[1], 0, 3),
scratch_space_base_pointer: (__gen_unuint(input[1], 10, 31) as u64) << 10,
gpgpu_mode: __gen_unuint(input[2], 2, 2),
gateway_mmio_access_control: __gen_unuint(input[2], 3, 4),
bypass_gateway_control: __gen_unuint(input[2], 6, 6),
reset_gateway_timer: __gen_unuint(input[2], 7, 7),
number_of_urb_entries: __gen_unuint(input[2], 8, 15),
maximum_number_of_threads: __gen_unuint(input[2], 16, 31),
curbe_allocation_size: __gen_unuint(input[4], 0, 15),
urb_entry_allocation_size: __gen_unuint(input[4], 16, 31),
scoreboard_mask: __gen_unuint(input[5], 0, 7),
scoreboard_type: __gen_unuint(input[5], 30, 30),
scoreboard_enable: __gen_unuint(input[5], 31, 31),
scoreboard_0_delta_x: (__gen_unuint(input[6], 0, 3)) as i32,
scoreboard_0_delta_y: (__gen_unuint(input[6], 4, 7)) as i32,
scoreboard_1_delta_x: (__gen_unuint(input[6], 8, 11)) as i32,
scoreboard_1_delta_y: (__gen_unuint(input[6], 12, 15)) as i32,
scoreboard_2_delta_x: (__gen_unuint(input[6], 16, 19)) as i32,
scoreboard_2_delta_y: (__gen_unuint(input[6], 20, 23)) as i32,
scoreboard_3_delta_x: (__gen_unuint(input[6], 24, 27)) as i32,
scoreboard_3_delta_y: (__gen_unuint(input[6], 28, 31)) as i32,
scoreboard_4_delta_x: (__gen_unuint(input[7], 0, 3)) as i32,
scoreboard_4_delta_y: (__gen_unuint(input[7], 4, 7)) as i32,
scoreboard_5_delta_x: (__gen_unuint(input[7], 8, 11)) as i32,
scoreboard_5_delta_y: (__gen_unuint(input[7], 12, 15)) as i32,
scoreboard_6_delta_x: (__gen_unuint(input[7], 16, 19)) as i32,
scoreboard_6_delta_y: (__gen_unuint(input[7], 20, 23)) as i32,
scoreboard_7_delta_x: (__gen_unuint(input[7], 24, 27)) as i32,
scoreboard_7_delta_y: (__gen_unuint(input[7], 28, 31)) as i32,
}
}
}
impl Deserialize for MediaVfeState<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 8];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 8] as *mut [u8; 32]) })?;
Ok((&input).into())
}
}
pub struct MemoryObjectControlState {
pub l3_cacheability_control_l3cc: u32,
pub llc_cacheability_control_llccc: u32,
pub graphics_data_type_gfdt: u32,
}
impl MemoryObjectControlState {
pub const DWORD_LENGTH: u32 = 1;
}
impl Default for MemoryObjectControlState {
fn default() -> Self {
MemoryObjectControlState {
l3_cacheability_control_l3cc: Default::default(),
llc_cacheability_control_llccc: Default::default(),
graphics_data_type_gfdt: Default::default(),
}
}
}
impl Serialize for MemoryObjectControlState {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.l3_cacheability_control_l3cc, 0, 0) |
__gen_uint(self.llc_cacheability_control_llccc, 1, 1) |
__gen_uint(self.graphics_data_type_gfdt, 2, 2);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for MemoryObjectControlState {
fn from(input: &[u32; 1]) -> Self {
MemoryObjectControlState {
l3_cacheability_control_l3cc: __gen_unuint(input[0], 0, 0),
llc_cacheability_control_llccc: __gen_unuint(input[0], 1, 1),
graphics_data_type_gfdt: __gen_unuint(input[0], 2, 2),
}
}
}
impl Deserialize for MemoryObjectControlState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct MfcAvcPakObject {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub indirect_pak_mv_data_length: u32,
pub indirect_pak_mv_data_start_address_offset: u64,
pub inline_data: [u32; 8],
pub vdenc_mode_inline_data: [u32; 12],
}
impl MfcAvcPakObject {
pub const DWORD_LENGTH: u32 = 23;
}
impl Default for MfcAvcPakObject {
fn default() -> Self {
MfcAvcPakObject {
dword_length: 9,
subopcode_b: 9,
subopcode_a: 2,
media_command_opcode: 1,
pipeline: 2,
command_type: 3,
indirect_pak_mv_data_length: Default::default(),
indirect_pak_mv_data_start_address_offset: Default::default(),
inline_data: Default::default(),
vdenc_mode_inline_data: Default::default(),
}
}
}
impl Serialize for MfcAvcPakObject {
type Out = [u32; 23];
fn pack_into(&self, out: &mut [u32; 23]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.indirect_pak_mv_data_length, 0, 9);
out[2] = __gen_offset(self.indirect_pak_mv_data_start_address_offset as u32, 0, 28);
out[3] = __gen_uint(self.inline_data[0], 0, 31);
out[4] = __gen_uint(self.inline_data[1], 0, 31);
out[5] = __gen_uint(self.inline_data[2], 0, 31);
out[6] = __gen_uint(self.inline_data[3], 0, 31);
out[7] = __gen_uint(self.inline_data[4], 0, 31);
out[8] = __gen_uint(self.inline_data[5], 0, 31);
out[9] = __gen_uint(self.inline_data[6], 0, 31);
out[10] = __gen_uint(self.inline_data[7], 0, 31);
out[11] = __gen_uint(self.vdenc_mode_inline_data[0], 0, 31);
out[12] = __gen_uint(self.vdenc_mode_inline_data[1], 0, 31);
out[13] = __gen_uint(self.vdenc_mode_inline_data[2], 0, 31);
out[14] = __gen_uint(self.vdenc_mode_inline_data[3], 0, 31);
out[15] = __gen_uint(self.vdenc_mode_inline_data[4], 0, 31);
out[16] = __gen_uint(self.vdenc_mode_inline_data[5], 0, 31);
out[17] = __gen_uint(self.vdenc_mode_inline_data[6], 0, 31);
out[18] = __gen_uint(self.vdenc_mode_inline_data[7], 0, 31);
out[19] = __gen_uint(self.vdenc_mode_inline_data[8], 0, 31);
out[20] = __gen_uint(self.vdenc_mode_inline_data[9], 0, 31);
out[21] = __gen_uint(self.vdenc_mode_inline_data[10], 0, 31);
out[22] = __gen_uint(self.vdenc_mode_inline_data[11], 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 23];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 23] as *const [u8; 92]) })
}
}
impl From<&[u32; 23]> for MfcAvcPakObject {
fn from(input: &[u32; 23]) -> Self {
MfcAvcPakObject {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
indirect_pak_mv_data_length: __gen_unuint(input[1], 0, 9),
indirect_pak_mv_data_start_address_offset: (__gen_unuint(input[2], 0, 28) as u64),
inline_data: [
__gen_unuint(input[3], 0, 31),
__gen_unuint(input[4], 0, 31),
__gen_unuint(input[5], 0, 31),
__gen_unuint(input[6], 0, 31),
__gen_unuint(input[7], 0, 31),
__gen_unuint(input[8], 0, 31),
__gen_unuint(input[9], 0, 31),
__gen_unuint(input[10], 0, 31)
],
vdenc_mode_inline_data: [
__gen_unuint(input[11], 0, 31),
__gen_unuint(input[12], 0, 31),
__gen_unuint(input[13], 0, 31),
__gen_unuint(input[14], 0, 31),
__gen_unuint(input[15], 0, 31),
__gen_unuint(input[16], 0, 31),
__gen_unuint(input[17], 0, 31),
__gen_unuint(input[18], 0, 31),
__gen_unuint(input[19], 0, 31),
__gen_unuint(input[20], 0, 31),
__gen_unuint(input[21], 0, 31),
__gen_unuint(input[22], 0, 31)
],
}
}
}
impl Deserialize for MfcAvcPakObject {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 23];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 23] as *mut [u8; 92]) })?;
Ok((&input).into())
}
}
pub struct MfcMpeg2PakObject {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub inline_data: [u32; 8],
}
impl MfcMpeg2PakObject {
pub const DWORD_LENGTH: u32 = 9;
}
impl Default for MfcMpeg2PakObject {
fn default() -> Self {
MfcMpeg2PakObject {
dword_length: 7,
subopcode_b: 9,
subopcode_a: 2,
media_command_opcode: 3,
pipeline: 2,
command_type: 3,
inline_data: Default::default(),
}
}
}
impl Serialize for MfcMpeg2PakObject {
type Out = [u32; 9];
fn pack_into(&self, out: &mut [u32; 9]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.inline_data[0], 0, 31);
out[2] = __gen_uint(self.inline_data[1], 0, 31);
out[3] = __gen_uint(self.inline_data[2], 0, 31);
out[4] = __gen_uint(self.inline_data[3], 0, 31);
out[5] = __gen_uint(self.inline_data[4], 0, 31);
out[6] = __gen_uint(self.inline_data[5], 0, 31);
out[7] = __gen_uint(self.inline_data[6], 0, 31);
out[8] = __gen_uint(self.inline_data[7], 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 9];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 9] as *const [u8; 36]) })
}
}
impl From<&[u32; 9]> for MfcMpeg2PakObject {
fn from(input: &[u32; 9]) -> Self {
MfcMpeg2PakObject {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
inline_data: [
__gen_unuint(input[1], 0, 31),
__gen_unuint(input[2], 0, 31),
__gen_unuint(input[3], 0, 31),
__gen_unuint(input[4], 0, 31),
__gen_unuint(input[5], 0, 31),
__gen_unuint(input[6], 0, 31),
__gen_unuint(input[7], 0, 31),
__gen_unuint(input[8], 0, 31)
],
}
}
}
impl Deserialize for MfcMpeg2PakObject {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 9];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 9] as *mut [u8; 36]) })?;
Ok((&input).into())
}
}
pub struct MfcMpeg2SlicegroupState {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub stream_id: u32,
pub slice_id: u32,
pub intra_slice_flag: bool,
pub intra_slice: bool,
pub first_slice_header_disable: bool,
pub tail_insertion_present: bool,
pub slice_data_insertion_present: bool,
pub header_insertion_present: bool,
pub compressed_bitstream_output_disable: bool,
pub last_slice: bool,
pub mb_type_skip_conversion_disable: bool,
pub rate_control_panic_type: u32,
pub rate_control_panic_enable: bool,
pub rate_control_stable_tolerance: u32,
pub rate_control_triggle_mode: u32,
pub reset_rate_control_counter: bool,
pub rate_control_counter_enable: bool,
pub first_mb_x_count: u32,
pub first_mb_y_count: u32,
pub next_slice_group_mb_x_count: u32,
pub next_slice_group_mb_y_count: u32,
pub slice_group_qp: u32,
pub slice_group_skip: bool,
pub indirect_pak_bse_data_start_address: u64,
pub grow_init: u32,
pub grow_resistance: u32,
pub shrink_init: u32,
pub shrink_resistance: u32,
pub qp_max_positive_modifier_magnitude: u32,
pub qp_max_negative_modifier_magnitude: u32,
pub correct_1: u32,
pub correct_2: u32,
pub correct_3: u32,
pub correct_4: u32,
pub correct_5: u32,
pub correct_6: u32,
pub cv0: u32,
pub cv1: u32,
pub cv2: u32,
pub cv3: u32,
pub cv4: u32,
pub cv5: u32,
pub cv6: u32,
pub cv7: u32,
}
impl MfcMpeg2SlicegroupState {
pub const DWORD_LENGTH: u32 = 8;
pub const ALWAYS_RATE_CONTROL: u32 = 0;
pub const CBP_PANIC: u32 = 1;
pub const GENTLE_RATE_CONTROL: u32 = 1;
pub const LOOSE_RATE_CONTROL: u32 = 2;
pub const QP_PANIC: u32 = 0;
}
impl Default for MfcMpeg2SlicegroupState {
fn default() -> Self {
MfcMpeg2SlicegroupState {
dword_length: 6,
subopcode_b: 3,
subopcode_a: 2,
media_command_opcode: 3,
pipeline: 2,
command_type: 3,
stream_id: Default::default(),
slice_id: Default::default(),
intra_slice_flag: Default::default(),
intra_slice: Default::default(),
first_slice_header_disable: Default::default(),
tail_insertion_present: Default::default(),
slice_data_insertion_present: Default::default(),
header_insertion_present: Default::default(),
compressed_bitstream_output_disable: Default::default(),
last_slice: Default::default(),
mb_type_skip_conversion_disable: Default::default(),
rate_control_panic_type: Default::default(),
rate_control_panic_enable: Default::default(),
rate_control_stable_tolerance: Default::default(),
rate_control_triggle_mode: Default::default(),
reset_rate_control_counter: Default::default(),
rate_control_counter_enable: Default::default(),
first_mb_x_count: Default::default(),
first_mb_y_count: Default::default(),
next_slice_group_mb_x_count: Default::default(),
next_slice_group_mb_y_count: Default::default(),
slice_group_qp: Default::default(),
slice_group_skip: Default::default(),
indirect_pak_bse_data_start_address: Default::default(),
grow_init: Default::default(),
grow_resistance: Default::default(),
shrink_init: Default::default(),
shrink_resistance: Default::default(),
qp_max_positive_modifier_magnitude: Default::default(),
qp_max_negative_modifier_magnitude: Default::default(),
correct_1: Default::default(),
correct_2: Default::default(),
correct_3: Default::default(),
correct_4: Default::default(),
correct_5: Default::default(),
correct_6: Default::default(),
cv0: Default::default(),
cv1: Default::default(),
cv2: Default::default(),
cv3: Default::default(),
cv4: Default::default(),
cv5: Default::default(),
cv6: Default::default(),
cv7: Default::default(),
}
}
}
impl Serialize for MfcMpeg2SlicegroupState {
type Out = [u32; 8];
fn pack_into(&self, out: &mut [u32; 8]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.stream_id, 0, 1) |
__gen_uint(self.slice_id, 4, 7) |
__gen_uint(self.intra_slice_flag.into(), 12, 12) |
__gen_uint(self.intra_slice.into(), 13, 13) |
__gen_uint(self.first_slice_header_disable.into(), 14, 14) |
__gen_uint(self.tail_insertion_present.into(), 15, 15) |
__gen_uint(self.slice_data_insertion_present.into(), 16, 16) |
__gen_uint(self.header_insertion_present.into(), 17, 17) |
__gen_uint(self.compressed_bitstream_output_disable.into(), 18, 18) |
__gen_uint(self.last_slice.into(), 19, 19) |
__gen_uint(self.mb_type_skip_conversion_disable.into(), 20, 20) |
__gen_uint(self.rate_control_panic_type, 22, 22) |
__gen_uint(self.rate_control_panic_enable.into(), 23, 23) |
__gen_uint(self.rate_control_stable_tolerance, 24, 27) |
__gen_uint(self.rate_control_triggle_mode, 28, 29) |
__gen_uint(self.reset_rate_control_counter.into(), 30, 30) |
__gen_uint(self.rate_control_counter_enable.into(), 31, 31);
out[2] = __gen_uint(self.first_mb_x_count, 0, 7) |
__gen_uint(self.first_mb_y_count, 8, 15) |
__gen_uint(self.next_slice_group_mb_x_count, 16, 23) |
__gen_uint(self.next_slice_group_mb_y_count, 24, 31);
out[3] = __gen_uint(self.slice_group_qp, 0, 5) |
__gen_uint(self.slice_group_skip.into(), 8, 8);
out[4] = __gen_offset(self.indirect_pak_bse_data_start_address as u32, 0, 28);
out[5] = __gen_uint(self.grow_init, 0, 3) |
__gen_uint(self.grow_resistance, 4, 7) |
__gen_uint(self.shrink_init, 8, 11) |
__gen_uint(self.shrink_resistance, 12, 15) |
__gen_uint(self.qp_max_positive_modifier_magnitude, 16, 23) |
__gen_uint(self.qp_max_negative_modifier_magnitude, 24, 31);
out[6] = __gen_uint(self.correct_1, 0, 3) |
__gen_uint(self.correct_2, 4, 7) |
__gen_uint(self.correct_3, 8, 11) |
__gen_uint(self.correct_4, 12, 15) |
__gen_uint(self.correct_5, 16, 19) |
__gen_uint(self.correct_6, 20, 23);
out[7] = __gen_uint(self.cv0, 0, 3) |
__gen_uint(self.cv1, 4, 7) |
__gen_uint(self.cv2, 8, 11) |
__gen_uint(self.cv3, 12, 15) |
__gen_uint(self.cv4, 16, 19) |
__gen_uint(self.cv5, 20, 23) |
__gen_uint(self.cv6, 24, 27) |
__gen_uint(self.cv7, 28, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 8];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 8] as *const [u8; 32]) })
}
}
impl From<&[u32; 8]> for MfcMpeg2SlicegroupState {
fn from(input: &[u32; 8]) -> Self {
MfcMpeg2SlicegroupState {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
stream_id: __gen_unuint(input[1], 0, 1),
slice_id: __gen_unuint(input[1], 4, 7),
intra_slice_flag: __gen_unuint(input[1], 12, 12) != 0,
intra_slice: __gen_unuint(input[1], 13, 13) != 0,
first_slice_header_disable: __gen_unuint(input[1], 14, 14) != 0,
tail_insertion_present: __gen_unuint(input[1], 15, 15) != 0,
slice_data_insertion_present: __gen_unuint(input[1], 16, 16) != 0,
header_insertion_present: __gen_unuint(input[1], 17, 17) != 0,
compressed_bitstream_output_disable: __gen_unuint(input[1], 18, 18) != 0,
last_slice: __gen_unuint(input[1], 19, 19) != 0,
mb_type_skip_conversion_disable: __gen_unuint(input[1], 20, 20) != 0,
rate_control_panic_type: __gen_unuint(input[1], 22, 22),
rate_control_panic_enable: __gen_unuint(input[1], 23, 23) != 0,
rate_control_stable_tolerance: __gen_unuint(input[1], 24, 27),
rate_control_triggle_mode: __gen_unuint(input[1], 28, 29),
reset_rate_control_counter: __gen_unuint(input[1], 30, 30) != 0,
rate_control_counter_enable: __gen_unuint(input[1], 31, 31) != 0,
first_mb_x_count: __gen_unuint(input[2], 0, 7),
first_mb_y_count: __gen_unuint(input[2], 8, 15),
next_slice_group_mb_x_count: __gen_unuint(input[2], 16, 23),
next_slice_group_mb_y_count: __gen_unuint(input[2], 24, 31),
slice_group_qp: __gen_unuint(input[3], 0, 5),
slice_group_skip: __gen_unuint(input[3], 8, 8) != 0,
indirect_pak_bse_data_start_address: (__gen_unuint(input[4], 0, 28) as u64),
grow_init: __gen_unuint(input[5], 0, 3),
grow_resistance: __gen_unuint(input[5], 4, 7),
shrink_init: __gen_unuint(input[5], 8, 11),
shrink_resistance: __gen_unuint(input[5], 12, 15),
qp_max_positive_modifier_magnitude: __gen_unuint(input[5], 16, 23),
qp_max_negative_modifier_magnitude: __gen_unuint(input[5], 24, 31),
correct_1: __gen_unuint(input[6], 0, 3),
correct_2: __gen_unuint(input[6], 4, 7),
correct_3: __gen_unuint(input[6], 8, 11),
correct_4: __gen_unuint(input[6], 12, 15),
correct_5: __gen_unuint(input[6], 16, 19),
correct_6: __gen_unuint(input[6], 20, 23),
cv0: __gen_unuint(input[7], 0, 3),
cv1: __gen_unuint(input[7], 4, 7),
cv2: __gen_unuint(input[7], 8, 11),
cv3: __gen_unuint(input[7], 12, 15),
cv4: __gen_unuint(input[7], 16, 19),
cv5: __gen_unuint(input[7], 20, 23),
cv6: __gen_unuint(input[7], 24, 27),
cv7: __gen_unuint(input[7], 28, 31),
}
}
}
impl Deserialize for MfcMpeg2SlicegroupState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 8];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 8] as *mut [u8; 32]) })?;
Ok((&input).into())
}
}
pub struct MfdAvcBsdObject<A: Addr + Default> {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub indirect_bsd_data_length: u32,
pub indirect_bsd_data_start_address: A,
pub inline_data: InlineDataDescriptionForMfdAvcBsdObject,
}
impl<A: Addr + Default> MfdAvcBsdObject<A> {
pub const DWORD_LENGTH: u32 = 6;
}
impl<A: Addr + Default> Default for MfdAvcBsdObject<A> {
fn default() -> Self {
MfdAvcBsdObject {
dword_length: 4,
subopcode_b: 8,
subopcode_a: 1,
media_command_opcode: 1,
pipeline: 2,
command_type: 3,
indirect_bsd_data_length: Default::default(),
indirect_bsd_data_start_address: Default::default(),
inline_data: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for MfdAvcBsdObject<A> {
type Out = [u32; 6];
fn pack_into(&self, out: &mut [u32; 6]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.indirect_bsd_data_length, 0, 31);
let v2_address = self.indirect_bsd_data_start_address.combine(0);
out[2] = v2_address as u32;
out[3] = (v2_address >> 32) as u32;
{
let [_, _, _, ref mut out3_4 @ .., _] = out;
self.inline_data.pack_into(out3_4);
}
out[5] = 0;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 6];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 6] as *const [u8; 24]) })
}
}
impl From<&[u32; 6]> for MfdAvcBsdObject<u64> {
fn from(input: &[u32; 6]) -> Self {
MfdAvcBsdObject {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
indirect_bsd_data_length: __gen_unuint(input[1], 0, 31),
indirect_bsd_data_start_address: (__gen_unuint(input[2], 0, 28) as u64),
inline_data: {{
let [_, _, _, ref in3_4 @ .., _] = input;
in3_4.into()
}},
}
}
}
impl Deserialize for MfdAvcBsdObject<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 6];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 6] as *mut [u8; 24]) })?;
Ok((&input).into())
}
}
pub struct MfdAvcDpbState {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub non_existing_frame: [u32; 16],
pub long_term_frame: [u32; 16],
pub used_for_reference: [u32; 16],
pub ltst_frame_number_list: [u32; 16],
}
impl MfdAvcDpbState {
pub const DWORD_LENGTH: u32 = 11;
pub const BOTTOM_FIELD: u32 = 2;
pub const FRAME: u32 = 3;
pub const INVALID: u32 = 1;
pub const LONG_TERM_FRAME: u32 = 1;
pub const NOT_REFERENCE: u32 = 0;
pub const SHORT_TERM_FRAME: u32 = 0;
pub const TOP_FIELD: u32 = 1;
pub const VALID: u32 = 0;
}
impl Default for MfdAvcDpbState {
fn default() -> Self {
MfdAvcDpbState {
dword_length: 9,
subopcode_b: 6,
subopcode_a: 1,
media_command_opcode: 1,
pipeline: 2,
command_type: 3,
non_existing_frame: Default::default(),
long_term_frame: Default::default(),
used_for_reference: Default::default(),
ltst_frame_number_list: Default::default(),
}
}
}
impl Serialize for MfdAvcDpbState {
type Out = [u32; 11];
fn pack_into(&self, out: &mut [u32; 11]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.non_existing_frame[0], 0, 0) |
__gen_uint(self.non_existing_frame[1], 1, 1) |
__gen_uint(self.non_existing_frame[2], 2, 2) |
__gen_uint(self.non_existing_frame[3], 3, 3) |
__gen_uint(self.non_existing_frame[4], 4, 4) |
__gen_uint(self.non_existing_frame[5], 5, 5) |
__gen_uint(self.non_existing_frame[6], 6, 6) |
__gen_uint(self.non_existing_frame[7], 7, 7) |
__gen_uint(self.non_existing_frame[8], 8, 8) |
__gen_uint(self.non_existing_frame[9], 9, 9) |
__gen_uint(self.non_existing_frame[10], 10, 10) |
__gen_uint(self.non_existing_frame[11], 11, 11) |
__gen_uint(self.non_existing_frame[12], 12, 12) |
__gen_uint(self.non_existing_frame[13], 13, 13) |
__gen_uint(self.non_existing_frame[14], 14, 14) |
__gen_uint(self.non_existing_frame[15], 15, 15) |
__gen_uint(self.long_term_frame[0], 16, 16) |
__gen_uint(self.long_term_frame[1], 17, 17) |
__gen_uint(self.long_term_frame[2], 18, 18) |
__gen_uint(self.long_term_frame[3], 19, 19) |
__gen_uint(self.long_term_frame[4], 20, 20) |
__gen_uint(self.long_term_frame[5], 21, 21) |
__gen_uint(self.long_term_frame[6], 22, 22) |
__gen_uint(self.long_term_frame[7], 23, 23) |
__gen_uint(self.long_term_frame[8], 24, 24) |
__gen_uint(self.long_term_frame[9], 25, 25) |
__gen_uint(self.long_term_frame[10], 26, 26) |
__gen_uint(self.long_term_frame[11], 27, 27) |
__gen_uint(self.long_term_frame[12], 28, 28) |
__gen_uint(self.long_term_frame[13], 29, 29) |
__gen_uint(self.long_term_frame[14], 30, 30) |
__gen_uint(self.long_term_frame[15], 31, 31);
out[2] = __gen_uint(self.used_for_reference[0], 0, 1) |
__gen_uint(self.used_for_reference[1], 2, 3) |
__gen_uint(self.used_for_reference[2], 4, 5) |
__gen_uint(self.used_for_reference[3], 6, 7) |
__gen_uint(self.used_for_reference[4], 8, 9) |
__gen_uint(self.used_for_reference[5], 10, 11) |
__gen_uint(self.used_for_reference[6], 12, 13) |
__gen_uint(self.used_for_reference[7], 14, 15) |
__gen_uint(self.used_for_reference[8], 16, 17) |
__gen_uint(self.used_for_reference[9], 18, 19) |
__gen_uint(self.used_for_reference[10], 20, 21) |
__gen_uint(self.used_for_reference[11], 22, 23) |
__gen_uint(self.used_for_reference[12], 24, 25) |
__gen_uint(self.used_for_reference[13], 26, 27) |
__gen_uint(self.used_for_reference[14], 28, 29) |
__gen_uint(self.used_for_reference[15], 30, 31);
out[3] = __gen_uint(self.ltst_frame_number_list[0], 0, 15) |
__gen_uint(self.ltst_frame_number_list[1], 16, 31);
out[4] = __gen_uint(self.ltst_frame_number_list[2], 0, 15) |
__gen_uint(self.ltst_frame_number_list[3], 16, 31);
out[5] = __gen_uint(self.ltst_frame_number_list[4], 0, 15) |
__gen_uint(self.ltst_frame_number_list[5], 16, 31);
out[6] = __gen_uint(self.ltst_frame_number_list[6], 0, 15) |
__gen_uint(self.ltst_frame_number_list[7], 16, 31);
out[7] = __gen_uint(self.ltst_frame_number_list[8], 0, 15) |
__gen_uint(self.ltst_frame_number_list[9], 16, 31);
out[8] = __gen_uint(self.ltst_frame_number_list[10], 0, 15) |
__gen_uint(self.ltst_frame_number_list[11], 16, 31);
out[9] = __gen_uint(self.ltst_frame_number_list[12], 0, 15) |
__gen_uint(self.ltst_frame_number_list[13], 16, 31);
out[10] = __gen_uint(self.ltst_frame_number_list[14], 0, 15) |
__gen_uint(self.ltst_frame_number_list[15], 16, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 11];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 11] as *const [u8; 44]) })
}
}
impl From<&[u32; 11]> for MfdAvcDpbState {
fn from(input: &[u32; 11]) -> Self {
MfdAvcDpbState {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
non_existing_frame: [
__gen_unuint(input[1], 0, 0),
__gen_unuint(input[1], 1, 1),
__gen_unuint(input[1], 2, 2),
__gen_unuint(input[1], 3, 3),
__gen_unuint(input[1], 4, 4),
__gen_unuint(input[1], 5, 5),
__gen_unuint(input[1], 6, 6),
__gen_unuint(input[1], 7, 7),
__gen_unuint(input[1], 8, 8),
__gen_unuint(input[1], 9, 9),
__gen_unuint(input[1], 10, 10),
__gen_unuint(input[1], 11, 11),
__gen_unuint(input[1], 12, 12),
__gen_unuint(input[1], 13, 13),
__gen_unuint(input[1], 14, 14),
__gen_unuint(input[1], 15, 15)
],
long_term_frame: [
__gen_unuint(input[1], 16, 16),
__gen_unuint(input[1], 17, 17),
__gen_unuint(input[1], 18, 18),
__gen_unuint(input[1], 19, 19),
__gen_unuint(input[1], 20, 20),
__gen_unuint(input[1], 21, 21),
__gen_unuint(input[1], 22, 22),
__gen_unuint(input[1], 23, 23),
__gen_unuint(input[1], 24, 24),
__gen_unuint(input[1], 25, 25),
__gen_unuint(input[1], 26, 26),
__gen_unuint(input[1], 27, 27),
__gen_unuint(input[1], 28, 28),
__gen_unuint(input[1], 29, 29),
__gen_unuint(input[1], 30, 30),
__gen_unuint(input[1], 31, 31)
],
used_for_reference: [
__gen_unuint(input[2], 0, 1),
__gen_unuint(input[2], 2, 3),
__gen_unuint(input[2], 4, 5),
__gen_unuint(input[2], 6, 7),
__gen_unuint(input[2], 8, 9),
__gen_unuint(input[2], 10, 11),
__gen_unuint(input[2], 12, 13),
__gen_unuint(input[2], 14, 15),
__gen_unuint(input[2], 16, 17),
__gen_unuint(input[2], 18, 19),
__gen_unuint(input[2], 20, 21),
__gen_unuint(input[2], 22, 23),
__gen_unuint(input[2], 24, 25),
__gen_unuint(input[2], 26, 27),
__gen_unuint(input[2], 28, 29),
__gen_unuint(input[2], 30, 31)
],
ltst_frame_number_list: [
__gen_unuint(input[3], 0, 15),
__gen_unuint(input[3], 16, 31),
__gen_unuint(input[4], 0, 15),
__gen_unuint(input[4], 16, 31),
__gen_unuint(input[5], 0, 15),
__gen_unuint(input[5], 16, 31),
__gen_unuint(input[6], 0, 15),
__gen_unuint(input[6], 16, 31),
__gen_unuint(input[7], 0, 15),
__gen_unuint(input[7], 16, 31),
__gen_unuint(input[8], 0, 15),
__gen_unuint(input[8], 16, 31),
__gen_unuint(input[9], 0, 15),
__gen_unuint(input[9], 16, 31),
__gen_unuint(input[10], 0, 15),
__gen_unuint(input[10], 16, 31)
],
}
}
}
impl Deserialize for MfdAvcDpbState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 11];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 11] as *mut [u8; 44]) })?;
Ok((&input).into())
}
}
pub struct MfdAvcSliceaddr<A: Addr + Default> {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub indirect_bsd_data_length: u32,
pub indirect_bsd_data_start_address: A,
}
impl<A: Addr + Default> MfdAvcSliceaddr<A> {
pub const DWORD_LENGTH: u32 = 3;
}
impl<A: Addr + Default> Default for MfdAvcSliceaddr<A> {
fn default() -> Self {
MfdAvcSliceaddr {
dword_length: 1,
subopcode_b: 7,
subopcode_a: 1,
media_command_opcode: 1,
pipeline: 2,
command_type: 3,
indirect_bsd_data_length: Default::default(),
indirect_bsd_data_start_address: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for MfdAvcSliceaddr<A> {
type Out = [u32; 3];
fn pack_into(&self, out: &mut [u32; 3]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.indirect_bsd_data_length, 0, 31);
let v2_address = self.indirect_bsd_data_start_address.combine(0);
out[2] = v2_address as u32;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 3];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 3] as *const [u8; 12]) })
}
}
impl From<&[u32; 3]> for MfdAvcSliceaddr<u64> {
fn from(input: &[u32; 3]) -> Self {
MfdAvcSliceaddr {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
indirect_bsd_data_length: __gen_unuint(input[1], 0, 31),
indirect_bsd_data_start_address: (__gen_unuint(input[2], 0, 28) as u64),
}
}
}
impl Deserialize for MfdAvcSliceaddr<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 3];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 3] as *mut [u8; 12]) })?;
Ok((&input).into())
}
}
pub struct MfdItObject {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub indirect_it_mv_data_length: u32,
pub indirect_it_mv_data_start_address_offset: u64,
pub indirect_it_coeff_data_length: u32,
pub indirect_it_coeff_data_start_address_offset: u64,
pub indirect_it_dblk_control_data_length: u32,
pub indirect_it_dblk_control_data_start_address_offset: u64,
}
impl MfdItObject {
pub const DWORD_LENGTH: u32 = 7;
}
impl Default for MfdItObject {
fn default() -> Self {
MfdItObject {
dword_length: 6,
subopcode_b: 9,
subopcode_a: 1,
media_command_opcode: 0,
pipeline: 2,
command_type: 3,
indirect_it_mv_data_length: Default::default(),
indirect_it_mv_data_start_address_offset: Default::default(),
indirect_it_coeff_data_length: Default::default(),
indirect_it_coeff_data_start_address_offset: Default::default(),
indirect_it_dblk_control_data_length: Default::default(),
indirect_it_dblk_control_data_start_address_offset: Default::default(),
}
}
}
impl Serialize for MfdItObject {
type Out = [u32; 7];
fn pack_into(&self, out: &mut [u32; 7]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.indirect_it_mv_data_length, 0, 9);
out[2] = __gen_offset(self.indirect_it_mv_data_start_address_offset as u32, 0, 28);
out[3] = __gen_uint(self.indirect_it_coeff_data_length, 0, 11);
out[4] = __gen_offset(self.indirect_it_coeff_data_start_address_offset as u32, 0, 28);
out[5] = __gen_uint(self.indirect_it_dblk_control_data_length, 0, 5);
out[6] = __gen_offset(self.indirect_it_dblk_control_data_start_address_offset as u32, 0, 28);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 7];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 7] as *const [u8; 28]) })
}
}
impl From<&[u32; 7]> for MfdItObject {
fn from(input: &[u32; 7]) -> Self {
MfdItObject {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
indirect_it_mv_data_length: __gen_unuint(input[1], 0, 9),
indirect_it_mv_data_start_address_offset: (__gen_unuint(input[2], 0, 28) as u64),
indirect_it_coeff_data_length: __gen_unuint(input[3], 0, 11),
indirect_it_coeff_data_start_address_offset: (__gen_unuint(input[4], 0, 28) as u64),
indirect_it_dblk_control_data_length: __gen_unuint(input[5], 0, 5),
indirect_it_dblk_control_data_start_address_offset: (__gen_unuint(input[6], 0, 28) as u64),
}
}
}
impl Deserialize for MfdItObject {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 7];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 7] as *mut [u8; 28]) })?;
Ok((&input).into())
}
}
pub struct MfdJpegBsdObject {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub indirect_data_length: u32,
pub indirect_data_start_address: u64,
pub scan_vertical_position: u32,
pub scan_horizontal_position: u32,
pub mcu_count: u32,
pub scan_components: u32,
pub interleaved: bool,
pub restart_interval: u32,
}
impl MfdJpegBsdObject {
pub const DWORD_LENGTH: u32 = 6;
}
impl Default for MfdJpegBsdObject {
fn default() -> Self {
MfdJpegBsdObject {
dword_length: 4,
subopcode_b: 8,
subopcode_a: 1,
media_command_opcode: 7,
pipeline: 2,
command_type: 3,
indirect_data_length: Default::default(),
indirect_data_start_address: Default::default(),
scan_vertical_position: Default::default(),
scan_horizontal_position: Default::default(),
mcu_count: Default::default(),
scan_components: Default::default(),
interleaved: Default::default(),
restart_interval: Default::default(),
}
}
}
impl Serialize for MfdJpegBsdObject {
type Out = [u32; 6];
fn pack_into(&self, out: &mut [u32; 6]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.indirect_data_length, 0, 31);
out[2] = __gen_offset(self.indirect_data_start_address as u32, 0, 28);
out[3] = __gen_uint(self.scan_vertical_position, 0, 12) |
__gen_uint(self.scan_horizontal_position, 16, 28);
out[4] = __gen_uint(self.mcu_count, 0, 25) |
__gen_uint(self.scan_components, 27, 29) |
__gen_uint(self.interleaved.into(), 30, 30);
out[5] = __gen_uint(self.restart_interval, 0, 15);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 6];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 6] as *const [u8; 24]) })
}
}
impl From<&[u32; 6]> for MfdJpegBsdObject {
fn from(input: &[u32; 6]) -> Self {
MfdJpegBsdObject {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
indirect_data_length: __gen_unuint(input[1], 0, 31),
indirect_data_start_address: (__gen_unuint(input[2], 0, 28) as u64),
scan_vertical_position: __gen_unuint(input[3], 0, 12),
scan_horizontal_position: __gen_unuint(input[3], 16, 28),
mcu_count: __gen_unuint(input[4], 0, 25),
scan_components: __gen_unuint(input[4], 27, 29),
interleaved: __gen_unuint(input[4], 30, 30) != 0,
restart_interval: __gen_unuint(input[5], 0, 15),
}
}
}
impl Deserialize for MfdJpegBsdObject {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 6];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 6] as *mut [u8; 24]) })?;
Ok((&input).into())
}
}
pub struct MfdMpeg2BsdObject {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub indirect_bsd_data_length: u32,
pub indirect_bsd_data_start_address: u64,
pub inline_data: MfdMpeg2BsdObjectInlineDataDescription,
}
impl MfdMpeg2BsdObject {
pub const DWORD_LENGTH: u32 = 5;
}
impl Default for MfdMpeg2BsdObject {
fn default() -> Self {
MfdMpeg2BsdObject {
dword_length: 3,
subopcode_b: 8,
subopcode_a: 1,
media_command_opcode: 3,
pipeline: 2,
command_type: 3,
indirect_bsd_data_length: Default::default(),
indirect_bsd_data_start_address: Default::default(),
inline_data: Default::default(),
}
}
}
impl Serialize for MfdMpeg2BsdObject {
type Out = [u32; 5];
fn pack_into(&self, out: &mut [u32; 5]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.indirect_bsd_data_length, 0, 31);
out[2] = __gen_offset(self.indirect_bsd_data_start_address as u32, 0, 28);
{
let [_, _, _, ref mut out3_4 @ ..] = out;
self.inline_data.pack_into(out3_4);
}
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 5];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 5] as *const [u8; 20]) })
}
}
impl From<&[u32; 5]> for MfdMpeg2BsdObject {
fn from(input: &[u32; 5]) -> Self {
MfdMpeg2BsdObject {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
indirect_bsd_data_length: __gen_unuint(input[1], 0, 31),
indirect_bsd_data_start_address: (__gen_unuint(input[2], 0, 28) as u64),
inline_data: {{
let [_, _, _, ref in3_4 @ ..] = input;
in3_4.into()
}},
}
}
}
impl Deserialize for MfdMpeg2BsdObject {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 5];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 5] as *mut [u8; 20]) })?;
Ok((&input).into())
}
}
pub struct MfdMpeg2BsdObjectInlineDataDescription {
pub first_mb_bit_offset: u32,
pub last_mb: bool,
pub last_pic_slice: bool,
pub mb_count: u32,
pub slice_vertical_position: u32,
pub slice_horizontal_position: u32,
pub quantizer_scale_code: u32,
}
impl MfdMpeg2BsdObjectInlineDataDescription {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for MfdMpeg2BsdObjectInlineDataDescription {
fn default() -> Self {
MfdMpeg2BsdObjectInlineDataDescription {
first_mb_bit_offset: Default::default(),
last_mb: Default::default(),
last_pic_slice: Default::default(),
mb_count: Default::default(),
slice_vertical_position: Default::default(),
slice_horizontal_position: Default::default(),
quantizer_scale_code: Default::default(),
}
}
}
impl Serialize for MfdMpeg2BsdObjectInlineDataDescription {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.first_mb_bit_offset, 0, 2) |
__gen_uint(self.last_mb.into(), 3, 3) |
__gen_uint(self.last_pic_slice.into(), 5, 5) |
__gen_uint(self.mb_count, 8, 14) |
__gen_uint(self.slice_vertical_position, 16, 22) |
__gen_uint(self.slice_horizontal_position, 24, 30);
out[1] = __gen_uint(self.quantizer_scale_code, 24, 28);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for MfdMpeg2BsdObjectInlineDataDescription {
fn from(input: &[u32; 2]) -> Self {
MfdMpeg2BsdObjectInlineDataDescription {
first_mb_bit_offset: __gen_unuint(input[0], 0, 2),
last_mb: __gen_unuint(input[0], 3, 3) != 0,
last_pic_slice: __gen_unuint(input[0], 5, 5) != 0,
mb_count: __gen_unuint(input[0], 8, 14),
slice_vertical_position: __gen_unuint(input[0], 16, 22),
slice_horizontal_position: __gen_unuint(input[0], 24, 30),
quantizer_scale_code: __gen_unuint(input[1], 24, 28),
}
}
}
impl Deserialize for MfdMpeg2BsdObjectInlineDataDescription {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct MfdVc1BsdObject {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub indirect_bsd_data_length: u32,
pub indirect_bsd_data_start_address: u64,
pub next_slice_vertical_position: u32,
pub slice_start_vertical_position: u32,
pub first_mb_bit_offset: u32,
pub emulation_prevention_byte_present: bool,
pub first_mb_byte_offset_of_slice_data_or_slice_header: u32,
}
impl MfdVc1BsdObject {
pub const DWORD_LENGTH: u32 = 5;
}
impl Default for MfdVc1BsdObject {
fn default() -> Self {
MfdVc1BsdObject {
dword_length: 3,
subopcode_b: 8,
subopcode_a: 1,
media_command_opcode: 2,
pipeline: 2,
command_type: 3,
indirect_bsd_data_length: Default::default(),
indirect_bsd_data_start_address: Default::default(),
next_slice_vertical_position: Default::default(),
slice_start_vertical_position: Default::default(),
first_mb_bit_offset: Default::default(),
emulation_prevention_byte_present: Default::default(),
first_mb_byte_offset_of_slice_data_or_slice_header: Default::default(),
}
}
}
impl Serialize for MfdVc1BsdObject {
type Out = [u32; 5];
fn pack_into(&self, out: &mut [u32; 5]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.indirect_bsd_data_length, 0, 23);
out[2] = __gen_offset(self.indirect_bsd_data_start_address as u32, 0, 28);
out[3] = __gen_uint(self.next_slice_vertical_position, 0, 8) |
__gen_uint(self.slice_start_vertical_position, 16, 23);
out[4] = __gen_uint(self.first_mb_bit_offset, 0, 2) |
__gen_uint(self.emulation_prevention_byte_present.into(), 4, 4) |
__gen_uint(self.first_mb_byte_offset_of_slice_data_or_slice_header, 16, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 5];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 5] as *const [u8; 20]) })
}
}
impl From<&[u32; 5]> for MfdVc1BsdObject {
fn from(input: &[u32; 5]) -> Self {
MfdVc1BsdObject {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
indirect_bsd_data_length: __gen_unuint(input[1], 0, 23),
indirect_bsd_data_start_address: (__gen_unuint(input[2], 0, 28) as u64),
next_slice_vertical_position: __gen_unuint(input[3], 0, 8),
slice_start_vertical_position: __gen_unuint(input[3], 16, 23),
first_mb_bit_offset: __gen_unuint(input[4], 0, 2),
emulation_prevention_byte_present: __gen_unuint(input[4], 4, 4) != 0,
first_mb_byte_offset_of_slice_data_or_slice_header: __gen_unuint(input[4], 16, 31),
}
}
}
impl Deserialize for MfdVc1BsdObject {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 5];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 5] as *mut [u8; 20]) })?;
Ok((&input).into())
}
}
pub struct MfdVc1LongPicState {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub picture_width_in_mbs: u32,
pub picture_height_in_mbs: u32,
pub vc1_profile: u32,
pub second_field: bool,
pub overlap_smoothing_enable: bool,
pub loop_filter_enable: bool,
pub range_reduction_enable: bool,
pub range_reduction_scale: u32,
pub mv_mode: u32,
pub sync_marker: bool,
pub interpolation_rounder_control: bool,
pub implicit_quantizer: bool,
pub dmv_surface_valid: bool,
pub bitplane_buffer_pitch: u32,
pub b_scale_factor: u32,
pub pq_value: u32,
pub alternative_pq_value: u32,
pub frame_coding_mode: u32,
pub picure_type: u32,
pub condover: u32,
pub pq_uniform: bool,
pub half_qp: bool,
pub alternative_pq_configuration: u32,
pub alternative_pq_edge_mask: u32,
pub extended_mv_range: u32,
pub extended_dmv_range: u32,
pub forward_reference_distance: u32,
pub backward_reference_distance: u32,
pub number_of_references: u32,
pub reference_field_picture_polarity: u32,
pub fast_uv_motion_compensation: u32,
pub four_mv_switch: u32,
pub unified_mv_mode: u32,
pub coded_block_pattern_table: u32,
pub intra_transform_dc_table: u32,
pub picture_level_transform_chroma_ac_coding_set_index: u32,
pub picture_level_transform_luma_ac_coding_set_index: u32,
pub mb_mode_table: u32,
pub mb_transform_type: bool,
pub picture_level_transform_type: u32,
pub _2_mv_block_pattern_table: u32,
pub _4_mv_block_pattern_table: u32,
pub mv_table: u32,
pub fieldtx_raw: bool,
pub acpred_raw: bool,
pub overflags_raw: bool,
pub directmb_raw: bool,
pub skipmb_raw: bool,
pub mvtypemb_raw: bool,
pub forwardmb_raw: bool,
pub bitplane_buffer_present: bool,
}
impl MfdVc1LongPicState {
pub const DWORD_LENGTH: u32 = 6;
pub const ADVANCED_PROFILE: u32 = 1;
pub const BOTTOM_ODD_FIELD: u32 = 1;
pub const FIELD_PICTURE_WITH_BOTTOM_FIELD_FIRST: u32 = 3;
pub const FIELD_PICTURE_WITH_TOP_FIELD_FIRST: u32 = 2;
pub const INTERLACED_FRAME_PICTURE: u32 = 1;
pub const MIXED_MV: u32 = 0;
pub const NO_ROUNDING: u32 = 0;
pub const ONE_FIELD_REFERENCED: u32 = 0;
pub const ONLY_1_MV: u32 = 0;
pub const PROGRESSIVE_FRAME_PICTURE: u32 = 0;
pub const QUARTER_PEL_OFFSETS_TO_HALF_FULL_PEL_POSITIONS: u32 = 1;
pub const SIMPLE_MAIN_PROFILE: u32 = 0;
pub const TOP_EVEN_FIELD: u32 = 0;
pub const TWO_FIELDS_REFERENCED: u32 = 1;
pub const _1_2_OR_4_MVS: u32 = 1;
pub const _1_MV: u32 = 1;
pub const _1_MV_HALF_PEL: u32 = 2;
pub const _1_MV_HALF_PEL_BILINEAR: u32 = 3;
pub const _4X4_TRANSFORM: u32 = 3;
pub const _4X8_TRANSFORM: u32 = 2;
pub const _8X4_TRANSFORM: u32 = 1;
pub const _8X8_TRANSFORM: u32 = 0;
}
impl Default for MfdVc1LongPicState {
fn default() -> Self {
MfdVc1LongPicState {
dword_length: 4,
subopcode_b: 1,
subopcode_a: 1,
media_command_opcode: 2,
pipeline: 2,
command_type: 3,
picture_width_in_mbs: Default::default(),
picture_height_in_mbs: Default::default(),
vc1_profile: Default::default(),
second_field: Default::default(),
overlap_smoothing_enable: Default::default(),
loop_filter_enable: Default::default(),
range_reduction_enable: Default::default(),
range_reduction_scale: Default::default(),
mv_mode: Default::default(),
sync_marker: Default::default(),
interpolation_rounder_control: Default::default(),
implicit_quantizer: Default::default(),
dmv_surface_valid: Default::default(),
bitplane_buffer_pitch: Default::default(),
b_scale_factor: Default::default(),
pq_value: Default::default(),
alternative_pq_value: Default::default(),
frame_coding_mode: Default::default(),
picure_type: Default::default(),
condover: Default::default(),
pq_uniform: Default::default(),
half_qp: Default::default(),
alternative_pq_configuration: Default::default(),
alternative_pq_edge_mask: Default::default(),
extended_mv_range: Default::default(),
extended_dmv_range: Default::default(),
forward_reference_distance: Default::default(),
backward_reference_distance: Default::default(),
number_of_references: Default::default(),
reference_field_picture_polarity: Default::default(),
fast_uv_motion_compensation: Default::default(),
four_mv_switch: Default::default(),
unified_mv_mode: Default::default(),
coded_block_pattern_table: Default::default(),
intra_transform_dc_table: Default::default(),
picture_level_transform_chroma_ac_coding_set_index: Default::default(),
picture_level_transform_luma_ac_coding_set_index: Default::default(),
mb_mode_table: Default::default(),
mb_transform_type: Default::default(),
picture_level_transform_type: Default::default(),
_2_mv_block_pattern_table: Default::default(),
_4_mv_block_pattern_table: Default::default(),
mv_table: Default::default(),
fieldtx_raw: Default::default(),
acpred_raw: Default::default(),
overflags_raw: Default::default(),
directmb_raw: Default::default(),
skipmb_raw: Default::default(),
mvtypemb_raw: Default::default(),
forwardmb_raw: Default::default(),
bitplane_buffer_present: Default::default(),
}
}
}
impl Serialize for MfdVc1LongPicState {
type Out = [u32; 6];
fn pack_into(&self, out: &mut [u32; 6]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.picture_width_in_mbs, 0, 7) |
__gen_uint(self.picture_height_in_mbs, 16, 23);
out[2] = __gen_uint(self.vc1_profile, 0, 0) |
__gen_uint(self.second_field.into(), 3, 3) |
__gen_uint(self.overlap_smoothing_enable.into(), 4, 4) |
__gen_uint(self.loop_filter_enable.into(), 5, 5) |
__gen_uint(self.range_reduction_enable.into(), 6, 6) |
__gen_uint(self.range_reduction_scale, 7, 7) |
__gen_uint(self.mv_mode, 8, 11) |
__gen_uint(self.sync_marker.into(), 12, 12) |
__gen_uint(self.interpolation_rounder_control.into(), 13, 13) |
__gen_uint(self.implicit_quantizer.into(), 14, 14) |
__gen_uint(self.dmv_surface_valid.into(), 15, 15) |
__gen_uint(self.bitplane_buffer_pitch, 24, 31);
out[3] = __gen_uint(self.b_scale_factor, 0, 7) |
__gen_uint(self.pq_value, 8, 12) |
__gen_uint(self.alternative_pq_value, 16, 20) |
__gen_uint(self.frame_coding_mode, 24, 25) |
__gen_uint(self.picure_type, 26, 28) |
__gen_uint(self.condover, 29, 30);
out[4] = __gen_uint(self.pq_uniform.into(), 0, 0) |
__gen_uint(self.half_qp.into(), 1, 1) |
__gen_uint(self.alternative_pq_configuration, 2, 3) |
__gen_uint(self.alternative_pq_edge_mask, 4, 7) |
__gen_uint(self.extended_mv_range, 8, 9) |
__gen_uint(self.extended_dmv_range, 10, 11) |
__gen_uint(self.forward_reference_distance, 16, 19) |
__gen_uint(self.backward_reference_distance, 20, 23) |
__gen_uint(self.number_of_references, 24, 24) |
__gen_uint(self.reference_field_picture_polarity, 25, 25) |
__gen_uint(self.fast_uv_motion_compensation, 26, 26) |
__gen_uint(self.four_mv_switch, 27, 27) |
__gen_uint(self.unified_mv_mode, 28, 29);
out[5] = __gen_uint(self.coded_block_pattern_table, 0, 2) |
__gen_uint(self.intra_transform_dc_table, 3, 3) |
__gen_uint(self.picture_level_transform_chroma_ac_coding_set_index, 4, 5) |
__gen_uint(self.picture_level_transform_luma_ac_coding_set_index, 6, 7) |
__gen_uint(self.mb_mode_table, 8, 10) |
__gen_uint(self.mb_transform_type.into(), 11, 11) |
__gen_uint(self.picture_level_transform_type, 12, 13) |
__gen_uint(self._2_mv_block_pattern_table, 16, 17) |
__gen_uint(self._4_mv_block_pattern_table, 18, 19) |
__gen_uint(self.mv_table, 20, 22) |
__gen_uint(self.fieldtx_raw.into(), 24, 24) |
__gen_uint(self.acpred_raw.into(), 25, 25) |
__gen_uint(self.overflags_raw.into(), 26, 26) |
__gen_uint(self.directmb_raw.into(), 27, 27) |
__gen_uint(self.skipmb_raw.into(), 28, 28) |
__gen_uint(self.mvtypemb_raw.into(), 29, 29) |
__gen_uint(self.forwardmb_raw.into(), 30, 30) |
__gen_uint(self.bitplane_buffer_present.into(), 31, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 6];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 6] as *const [u8; 24]) })
}
}
impl From<&[u32; 6]> for MfdVc1LongPicState {
fn from(input: &[u32; 6]) -> Self {
MfdVc1LongPicState {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
picture_width_in_mbs: __gen_unuint(input[1], 0, 7),
picture_height_in_mbs: __gen_unuint(input[1], 16, 23),
vc1_profile: __gen_unuint(input[2], 0, 0),
second_field: __gen_unuint(input[2], 3, 3) != 0,
overlap_smoothing_enable: __gen_unuint(input[2], 4, 4) != 0,
loop_filter_enable: __gen_unuint(input[2], 5, 5) != 0,
range_reduction_enable: __gen_unuint(input[2], 6, 6) != 0,
range_reduction_scale: __gen_unuint(input[2], 7, 7),
mv_mode: __gen_unuint(input[2], 8, 11),
sync_marker: __gen_unuint(input[2], 12, 12) != 0,
interpolation_rounder_control: __gen_unuint(input[2], 13, 13) != 0,
implicit_quantizer: __gen_unuint(input[2], 14, 14) != 0,
dmv_surface_valid: __gen_unuint(input[2], 15, 15) != 0,
bitplane_buffer_pitch: __gen_unuint(input[2], 24, 31),
b_scale_factor: __gen_unuint(input[3], 0, 7),
pq_value: __gen_unuint(input[3], 8, 12),
alternative_pq_value: __gen_unuint(input[3], 16, 20),
frame_coding_mode: __gen_unuint(input[3], 24, 25),
picure_type: __gen_unuint(input[3], 26, 28),
condover: __gen_unuint(input[3], 29, 30),
pq_uniform: __gen_unuint(input[4], 0, 0) != 0,
half_qp: __gen_unuint(input[4], 1, 1) != 0,
alternative_pq_configuration: __gen_unuint(input[4], 2, 3),
alternative_pq_edge_mask: __gen_unuint(input[4], 4, 7),
extended_mv_range: __gen_unuint(input[4], 8, 9),
extended_dmv_range: __gen_unuint(input[4], 10, 11),
forward_reference_distance: __gen_unuint(input[4], 16, 19),
backward_reference_distance: __gen_unuint(input[4], 20, 23),
number_of_references: __gen_unuint(input[4], 24, 24),
reference_field_picture_polarity: __gen_unuint(input[4], 25, 25),
fast_uv_motion_compensation: __gen_unuint(input[4], 26, 26),
four_mv_switch: __gen_unuint(input[4], 27, 27),
unified_mv_mode: __gen_unuint(input[4], 28, 29),
coded_block_pattern_table: __gen_unuint(input[5], 0, 2),
intra_transform_dc_table: __gen_unuint(input[5], 3, 3),
picture_level_transform_chroma_ac_coding_set_index: __gen_unuint(input[5], 4, 5),
picture_level_transform_luma_ac_coding_set_index: __gen_unuint(input[5], 6, 7),
mb_mode_table: __gen_unuint(input[5], 8, 10),
mb_transform_type: __gen_unuint(input[5], 11, 11) != 0,
picture_level_transform_type: __gen_unuint(input[5], 12, 13),
_2_mv_block_pattern_table: __gen_unuint(input[5], 16, 17),
_4_mv_block_pattern_table: __gen_unuint(input[5], 18, 19),
mv_table: __gen_unuint(input[5], 20, 22),
fieldtx_raw: __gen_unuint(input[5], 24, 24) != 0,
acpred_raw: __gen_unuint(input[5], 25, 25) != 0,
overflags_raw: __gen_unuint(input[5], 26, 26) != 0,
directmb_raw: __gen_unuint(input[5], 27, 27) != 0,
skipmb_raw: __gen_unuint(input[5], 28, 28) != 0,
mvtypemb_raw: __gen_unuint(input[5], 29, 29) != 0,
forwardmb_raw: __gen_unuint(input[5], 30, 30) != 0,
bitplane_buffer_present: __gen_unuint(input[5], 31, 31) != 0,
}
}
}
impl Deserialize for MfdVc1LongPicState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 6];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 6] as *mut [u8; 24]) })?;
Ok((&input).into())
}
}
pub struct MfdVc1ShortPicState {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub picture_width: u32,
pub picture_height: u32,
pub picture_structure: u32,
pub second_field: bool,
pub intra_picture: bool,
pub backward_prediction_present: bool,
pub vc1_profile: u32,
pub dmv_surface_valid: bool,
pub mv_mode: u32,
pub interpolation_rounder_control: bool,
pub bitplane_buffer_pitch: u32,
pub variable_sized_transform_coding: bool,
pub dquant: u32,
pub extended_mv_present: bool,
pub fast_uv_motion_compensation: u32,
pub loop_filter_enable: bool,
pub refdist_flag: bool,
pub panscan_present: bool,
pub maxbframes: u32,
pub rangered_present: bool,
pub syncmarker_present: bool,
pub multires_present: bool,
pub quantizer: u32,
pub p_pic_ref_distance: u32,
pub progressive_pic_type: u32,
pub range_reduction_enable: u32,
pub range_reduction_scale: u32,
pub overlap_smoothing_enable: bool,
pub extended_dmv_present: bool,
pub psf: bool,
pub refpic: bool,
pub finterflag: bool,
pub tfcntrflag: bool,
pub interlace: bool,
pub pulldown: bool,
pub postproc: bool,
pub _4_mv_allowed: bool,
pub bfraction_enumeration: u32,
}
impl MfdVc1ShortPicState {
pub const DWORD_LENGTH: u32 = 5;
pub const ADVANCED_PROFILE: u32 = 1;
pub const NO_ROUNDING: u32 = 0;
pub const QUARTER_PEL_OFFSETS_TO_HALF_FULL_PEL_POSITIONS: u32 = 1;
pub const SIMPLE_MAIN_PROFILE: u32 = 0;
}
impl Default for MfdVc1ShortPicState {
fn default() -> Self {
MfdVc1ShortPicState {
dword_length: 3,
subopcode_b: 0,
subopcode_a: 1,
media_command_opcode: 2,
pipeline: 2,
command_type: 3,
picture_width: Default::default(),
picture_height: Default::default(),
picture_structure: Default::default(),
second_field: Default::default(),
intra_picture: Default::default(),
backward_prediction_present: Default::default(),
vc1_profile: Default::default(),
dmv_surface_valid: Default::default(),
mv_mode: Default::default(),
interpolation_rounder_control: Default::default(),
bitplane_buffer_pitch: Default::default(),
variable_sized_transform_coding: Default::default(),
dquant: Default::default(),
extended_mv_present: Default::default(),
fast_uv_motion_compensation: Default::default(),
loop_filter_enable: Default::default(),
refdist_flag: Default::default(),
panscan_present: Default::default(),
maxbframes: Default::default(),
rangered_present: Default::default(),
syncmarker_present: Default::default(),
multires_present: Default::default(),
quantizer: Default::default(),
p_pic_ref_distance: Default::default(),
progressive_pic_type: Default::default(),
range_reduction_enable: Default::default(),
range_reduction_scale: Default::default(),
overlap_smoothing_enable: Default::default(),
extended_dmv_present: Default::default(),
psf: Default::default(),
refpic: Default::default(),
finterflag: Default::default(),
tfcntrflag: Default::default(),
interlace: Default::default(),
pulldown: Default::default(),
postproc: Default::default(),
_4_mv_allowed: Default::default(),
bfraction_enumeration: Default::default(),
}
}
}
impl Serialize for MfdVc1ShortPicState {
type Out = [u32; 5];
fn pack_into(&self, out: &mut [u32; 5]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.picture_width, 0, 7) |
__gen_uint(self.picture_height, 16, 23);
out[2] = __gen_uint(self.picture_structure, 0, 1) |
__gen_uint(self.second_field.into(), 3, 3) |
__gen_uint(self.intra_picture.into(), 4, 4) |
__gen_uint(self.backward_prediction_present.into(), 5, 5) |
__gen_uint(self.vc1_profile, 11, 11) |
__gen_uint(self.dmv_surface_valid.into(), 15, 15) |
__gen_uint(self.mv_mode, 16, 19) |
__gen_uint(self.interpolation_rounder_control.into(), 23, 23) |
__gen_uint(self.bitplane_buffer_pitch, 24, 31);
out[3] = __gen_uint(self.variable_sized_transform_coding.into(), 0, 0) |
__gen_uint(self.dquant, 1, 2) |
__gen_uint(self.extended_mv_present.into(), 3, 3) |
__gen_uint(self.fast_uv_motion_compensation, 4, 4) |
__gen_uint(self.loop_filter_enable.into(), 5, 5) |
__gen_uint(self.refdist_flag.into(), 6, 6) |
__gen_uint(self.panscan_present.into(), 7, 7) |
__gen_uint(self.maxbframes, 8, 10) |
__gen_uint(self.rangered_present.into(), 11, 11) |
__gen_uint(self.syncmarker_present.into(), 12, 12) |
__gen_uint(self.multires_present.into(), 13, 13) |
__gen_uint(self.quantizer, 14, 15) |
__gen_uint(self.p_pic_ref_distance, 16, 20) |
__gen_uint(self.progressive_pic_type, 22, 23) |
__gen_uint(self.range_reduction_enable, 28, 28) |
__gen_uint(self.range_reduction_scale, 29, 29) |
__gen_uint(self.overlap_smoothing_enable.into(), 30, 30);
out[4] = __gen_uint(self.extended_dmv_present.into(), 0, 0) |
__gen_uint(self.psf.into(), 1, 1) |
__gen_uint(self.refpic.into(), 2, 2) |
__gen_uint(self.finterflag.into(), 3, 3) |
__gen_uint(self.tfcntrflag.into(), 4, 4) |
__gen_uint(self.interlace.into(), 5, 5) |
__gen_uint(self.pulldown.into(), 6, 6) |
__gen_uint(self.postproc.into(), 7, 7) |
__gen_uint(self._4_mv_allowed.into(), 8, 8) |
__gen_uint(self.bfraction_enumeration, 24, 28);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 5];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 5] as *const [u8; 20]) })
}
}
impl From<&[u32; 5]> for MfdVc1ShortPicState {
fn from(input: &[u32; 5]) -> Self {
MfdVc1ShortPicState {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
picture_width: __gen_unuint(input[1], 0, 7),
picture_height: __gen_unuint(input[1], 16, 23),
picture_structure: __gen_unuint(input[2], 0, 1),
second_field: __gen_unuint(input[2], 3, 3) != 0,
intra_picture: __gen_unuint(input[2], 4, 4) != 0,
backward_prediction_present: __gen_unuint(input[2], 5, 5) != 0,
vc1_profile: __gen_unuint(input[2], 11, 11),
dmv_surface_valid: __gen_unuint(input[2], 15, 15) != 0,
mv_mode: __gen_unuint(input[2], 16, 19),
interpolation_rounder_control: __gen_unuint(input[2], 23, 23) != 0,
bitplane_buffer_pitch: __gen_unuint(input[2], 24, 31),
variable_sized_transform_coding: __gen_unuint(input[3], 0, 0) != 0,
dquant: __gen_unuint(input[3], 1, 2),
extended_mv_present: __gen_unuint(input[3], 3, 3) != 0,
fast_uv_motion_compensation: __gen_unuint(input[3], 4, 4),
loop_filter_enable: __gen_unuint(input[3], 5, 5) != 0,
refdist_flag: __gen_unuint(input[3], 6, 6) != 0,
panscan_present: __gen_unuint(input[3], 7, 7) != 0,
maxbframes: __gen_unuint(input[3], 8, 10),
rangered_present: __gen_unuint(input[3], 11, 11) != 0,
syncmarker_present: __gen_unuint(input[3], 12, 12) != 0,
multires_present: __gen_unuint(input[3], 13, 13) != 0,
quantizer: __gen_unuint(input[3], 14, 15),
p_pic_ref_distance: __gen_unuint(input[3], 16, 20),
progressive_pic_type: __gen_unuint(input[3], 22, 23),
range_reduction_enable: __gen_unuint(input[3], 28, 28),
range_reduction_scale: __gen_unuint(input[3], 29, 29),
overlap_smoothing_enable: __gen_unuint(input[3], 30, 30) != 0,
extended_dmv_present: __gen_unuint(input[4], 0, 0) != 0,
psf: __gen_unuint(input[4], 1, 1) != 0,
refpic: __gen_unuint(input[4], 2, 2) != 0,
finterflag: __gen_unuint(input[4], 3, 3) != 0,
tfcntrflag: __gen_unuint(input[4], 4, 4) != 0,
interlace: __gen_unuint(input[4], 5, 5) != 0,
pulldown: __gen_unuint(input[4], 6, 6) != 0,
postproc: __gen_unuint(input[4], 7, 7) != 0,
_4_mv_allowed: __gen_unuint(input[4], 8, 8) != 0,
bfraction_enumeration: __gen_unuint(input[4], 24, 28),
}
}
}
impl Deserialize for MfdVc1ShortPicState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 5];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 5] as *mut [u8; 20]) })?;
Ok((&input).into())
}
}
pub struct MfxAvcDirectmodeState<A: Addr + Default> {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub direct_mv_buffer_address: [A; 32],
pub direct_mv_buffer_arbitration_priority_control: [u32; 32],
pub direct_mv_buffer_graphics_data_type: [u32; 32],
pub direct_mv_buffer_cacheability_control: [u32; 32],
pub direct_mv_buffer_write_address: [A; 2],
pub direct_mv_buffer_write_arbitration_priority_control: [u32; 2],
pub direct_mv_buffer_write_graphics_data_type: [u32; 2],
pub direct_mv_buffer_write_cacheability_control: [u32; 2],
pub poc_list: [u32; 34],
}
impl<A: Addr + Default> MfxAvcDirectmodeState<A> {
pub const DWORD_LENGTH: u32 = 69;
pub const BOTH_LLC_AND_MLC: u32 = 3;
pub const GTT_ENTRY: u32 = 0;
pub const HIGHEST_PRIORITY: u32 = 0;
pub const IN_LLC_BUT_NOT_MLC: u32 = 2;
pub const LOWEST_PRIORITY: u32 = 3;
pub const NOT_IN_LLC_OR_MLC: u32 = 1;
pub const SECOND_HIGHEST_PRIORITY: u32 = 1;
pub const THIRD_HIGHEST_PRIORITY: u32 = 2;
}
impl<A: Addr + Default> Default for MfxAvcDirectmodeState<A> {
fn default() -> Self {
MfxAvcDirectmodeState {
dword_length: 67,
subopcode_b: 2,
subopcode_a: 0,
media_command_opcode: 1,
pipeline: 2,
command_type: 3,
direct_mv_buffer_address: Default::default(),
direct_mv_buffer_arbitration_priority_control: Default::default(),
direct_mv_buffer_graphics_data_type: Default::default(),
direct_mv_buffer_cacheability_control: Default::default(),
direct_mv_buffer_write_address: Default::default(),
direct_mv_buffer_write_arbitration_priority_control: Default::default(),
direct_mv_buffer_write_graphics_data_type: Default::default(),
direct_mv_buffer_write_cacheability_control: Default::default(),
poc_list: [0; 34],
}
}
}
impl<A: Addr + Default> Serialize for MfxAvcDirectmodeState<A> {
type Out = [u32; 69];
fn pack_into(&self, out: &mut [u32; 69]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = 0;
out[2] = 0;
out[3] = 0;
out[4] = 0;
out[5] = 0;
out[6] = 0;
out[7] = 0;
out[8] = 0;
out[9] = 0;
out[10] = 0;
out[11] = 0;
out[12] = 0;
out[13] = 0;
out[14] = 0;
out[15] = 0;
out[16] = 0;
out[17] = 0;
out[18] = 0;
out[19] = 0;
out[20] = 0;
out[21] = 0;
out[22] = 0;
out[23] = 0;
out[24] = 0;
out[25] = 0;
out[26] = 0;
out[27] = 0;
out[28] = 0;
out[29] = 0;
out[30] = 0;
out[31] = 0;
out[32] = 0;
let v33 = __gen_uint(self.direct_mv_buffer_write_cacheability_control[0], 0, 1) |
__gen_uint(self.direct_mv_buffer_write_graphics_data_type[0], 2, 2) |
__gen_uint(self.direct_mv_buffer_write_arbitration_priority_control[0], 4, 5);
let v33_address = self.direct_mv_buffer_write_address[0].combine(v33);
out[33] = v33_address as u32;
out[34] = (v33_address >> 32) as u32;
let v34 = __gen_uint(self.direct_mv_buffer_write_cacheability_control[1], 0, 1) |
__gen_uint(self.direct_mv_buffer_write_graphics_data_type[1], 2, 2) |
__gen_uint(self.direct_mv_buffer_write_arbitration_priority_control[1], 4, 5);
let v34_address = self.direct_mv_buffer_write_address[1].combine(v34);
out[34] = v34_address as u32;
out[35] = (v34_address >> 32) as u32;
let v35 = __gen_uint(self.poc_list[0], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[2], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[2], 4, 5);
let v35_address = self.direct_mv_buffer_address[2].combine(v35);
out[35] = v35_address as u32;
out[36] = (v35_address >> 32) as u32;
let v36 = __gen_uint(self.poc_list[1], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[3], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[3], 4, 5);
let v36_address = self.direct_mv_buffer_address[3].combine(v36);
out[36] = v36_address as u32;
out[37] = (v36_address >> 32) as u32;
let v37 = __gen_uint(self.poc_list[2], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[4], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[4], 4, 5);
let v37_address = self.direct_mv_buffer_address[4].combine(v37);
out[37] = v37_address as u32;
out[38] = (v37_address >> 32) as u32;
let v38 = __gen_uint(self.poc_list[3], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[5], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[5], 4, 5);
let v38_address = self.direct_mv_buffer_address[5].combine(v38);
out[38] = v38_address as u32;
out[39] = (v38_address >> 32) as u32;
let v39 = __gen_uint(self.poc_list[4], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[6], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[6], 4, 5);
let v39_address = self.direct_mv_buffer_address[6].combine(v39);
out[39] = v39_address as u32;
out[40] = (v39_address >> 32) as u32;
let v40 = __gen_uint(self.poc_list[5], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[7], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[7], 4, 5);
let v40_address = self.direct_mv_buffer_address[7].combine(v40);
out[40] = v40_address as u32;
out[41] = (v40_address >> 32) as u32;
let v41 = __gen_uint(self.poc_list[6], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[8], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[8], 4, 5);
let v41_address = self.direct_mv_buffer_address[8].combine(v41);
out[41] = v41_address as u32;
out[42] = (v41_address >> 32) as u32;
let v42 = __gen_uint(self.poc_list[7], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[9], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[9], 4, 5);
let v42_address = self.direct_mv_buffer_address[9].combine(v42);
out[42] = v42_address as u32;
out[43] = (v42_address >> 32) as u32;
let v43 = __gen_uint(self.poc_list[8], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[10], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[10], 4, 5);
let v43_address = self.direct_mv_buffer_address[10].combine(v43);
out[43] = v43_address as u32;
out[44] = (v43_address >> 32) as u32;
let v44 = __gen_uint(self.poc_list[9], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[11], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[11], 4, 5);
let v44_address = self.direct_mv_buffer_address[11].combine(v44);
out[44] = v44_address as u32;
out[45] = (v44_address >> 32) as u32;
let v45 = __gen_uint(self.poc_list[10], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[12], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[12], 4, 5);
let v45_address = self.direct_mv_buffer_address[12].combine(v45);
out[45] = v45_address as u32;
out[46] = (v45_address >> 32) as u32;
let v46 = __gen_uint(self.poc_list[11], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[13], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[13], 4, 5);
let v46_address = self.direct_mv_buffer_address[13].combine(v46);
out[46] = v46_address as u32;
out[47] = (v46_address >> 32) as u32;
let v47 = __gen_uint(self.poc_list[12], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[14], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[14], 4, 5);
let v47_address = self.direct_mv_buffer_address[14].combine(v47);
out[47] = v47_address as u32;
out[48] = (v47_address >> 32) as u32;
let v48 = __gen_uint(self.poc_list[13], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[15], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[15], 4, 5);
let v48_address = self.direct_mv_buffer_address[15].combine(v48);
out[48] = v48_address as u32;
out[49] = (v48_address >> 32) as u32;
let v49 = __gen_uint(self.poc_list[14], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[16], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[16], 4, 5);
let v49_address = self.direct_mv_buffer_address[16].combine(v49);
out[49] = v49_address as u32;
out[50] = (v49_address >> 32) as u32;
let v50 = __gen_uint(self.poc_list[15], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[17], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[17], 4, 5);
let v50_address = self.direct_mv_buffer_address[17].combine(v50);
out[50] = v50_address as u32;
out[51] = (v50_address >> 32) as u32;
let v51 = __gen_uint(self.poc_list[16], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[18], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[18], 4, 5);
let v51_address = self.direct_mv_buffer_address[18].combine(v51);
out[51] = v51_address as u32;
out[52] = (v51_address >> 32) as u32;
let v52 = __gen_uint(self.poc_list[17], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[19], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[19], 4, 5);
let v52_address = self.direct_mv_buffer_address[19].combine(v52);
out[52] = v52_address as u32;
out[53] = (v52_address >> 32) as u32;
let v53 = __gen_uint(self.poc_list[18], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[20], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[20], 4, 5);
let v53_address = self.direct_mv_buffer_address[20].combine(v53);
out[53] = v53_address as u32;
out[54] = (v53_address >> 32) as u32;
let v54 = __gen_uint(self.poc_list[19], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[21], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[21], 4, 5);
let v54_address = self.direct_mv_buffer_address[21].combine(v54);
out[54] = v54_address as u32;
out[55] = (v54_address >> 32) as u32;
let v55 = __gen_uint(self.poc_list[20], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[22], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[22], 4, 5);
let v55_address = self.direct_mv_buffer_address[22].combine(v55);
out[55] = v55_address as u32;
out[56] = (v55_address >> 32) as u32;
let v56 = __gen_uint(self.poc_list[21], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[23], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[23], 4, 5);
let v56_address = self.direct_mv_buffer_address[23].combine(v56);
out[56] = v56_address as u32;
out[57] = (v56_address >> 32) as u32;
let v57 = __gen_uint(self.poc_list[22], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[24], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[24], 4, 5);
let v57_address = self.direct_mv_buffer_address[24].combine(v57);
out[57] = v57_address as u32;
out[58] = (v57_address >> 32) as u32;
let v58 = __gen_uint(self.poc_list[23], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[25], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[25], 4, 5);
let v58_address = self.direct_mv_buffer_address[25].combine(v58);
out[58] = v58_address as u32;
out[59] = (v58_address >> 32) as u32;
let v59 = __gen_uint(self.poc_list[24], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[26], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[26], 4, 5);
let v59_address = self.direct_mv_buffer_address[26].combine(v59);
out[59] = v59_address as u32;
out[60] = (v59_address >> 32) as u32;
let v60 = __gen_uint(self.poc_list[25], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[27], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[27], 4, 5);
let v60_address = self.direct_mv_buffer_address[27].combine(v60);
out[60] = v60_address as u32;
out[61] = (v60_address >> 32) as u32;
let v61 = __gen_uint(self.poc_list[26], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[28], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[28], 4, 5);
let v61_address = self.direct_mv_buffer_address[28].combine(v61);
out[61] = v61_address as u32;
out[62] = (v61_address >> 32) as u32;
let v62 = __gen_uint(self.poc_list[27], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[29], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[29], 4, 5);
let v62_address = self.direct_mv_buffer_address[29].combine(v62);
out[62] = v62_address as u32;
out[63] = (v62_address >> 32) as u32;
let v63 = __gen_uint(self.poc_list[28], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[30], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[30], 4, 5);
let v63_address = self.direct_mv_buffer_address[30].combine(v63);
out[63] = v63_address as u32;
out[64] = (v63_address >> 32) as u32;
let v64 = __gen_uint(self.poc_list[29], 0, 31) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[31], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[31], 4, 5);
let v64_address = self.direct_mv_buffer_address[31].combine(v64);
out[64] = v64_address as u32;
out[65] = (v64_address >> 32) as u32;
out[65] = __gen_uint(self.poc_list[30], 0, 31);
out[66] = __gen_uint(self.poc_list[31], 0, 31);
out[67] = __gen_uint(self.poc_list[32], 0, 31);
out[68] = __gen_uint(self.poc_list[33], 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 69];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 69] as *const [u8; 276]) })
}
}
impl From<&[u32; 69]> for MfxAvcDirectmodeState<u64> {
fn from(input: &[u32; 69]) -> Self {
MfxAvcDirectmodeState {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
direct_mv_buffer_address: [
(__gen_unuint(input[33], 6, 31) as u64) << 6,
(__gen_unuint(input[34], 6, 31) as u64) << 6,
(__gen_unuint(input[35], 6, 31) as u64) << 6,
(__gen_unuint(input[36], 6, 31) as u64) << 6,
(__gen_unuint(input[37], 6, 31) as u64) << 6,
(__gen_unuint(input[38], 6, 31) as u64) << 6,
(__gen_unuint(input[39], 6, 31) as u64) << 6,
(__gen_unuint(input[40], 6, 31) as u64) << 6,
(__gen_unuint(input[41], 6, 31) as u64) << 6,
(__gen_unuint(input[42], 6, 31) as u64) << 6,
(__gen_unuint(input[43], 6, 31) as u64) << 6,
(__gen_unuint(input[44], 6, 31) as u64) << 6,
(__gen_unuint(input[45], 6, 31) as u64) << 6,
(__gen_unuint(input[46], 6, 31) as u64) << 6,
(__gen_unuint(input[47], 6, 31) as u64) << 6,
(__gen_unuint(input[48], 6, 31) as u64) << 6,
(__gen_unuint(input[49], 6, 31) as u64) << 6,
(__gen_unuint(input[50], 6, 31) as u64) << 6,
(__gen_unuint(input[51], 6, 31) as u64) << 6,
(__gen_unuint(input[52], 6, 31) as u64) << 6,
(__gen_unuint(input[53], 6, 31) as u64) << 6,
(__gen_unuint(input[54], 6, 31) as u64) << 6,
(__gen_unuint(input[55], 6, 31) as u64) << 6,
(__gen_unuint(input[56], 6, 31) as u64) << 6,
(__gen_unuint(input[57], 6, 31) as u64) << 6,
(__gen_unuint(input[58], 6, 31) as u64) << 6,
(__gen_unuint(input[59], 6, 31) as u64) << 6,
(__gen_unuint(input[60], 6, 31) as u64) << 6,
(__gen_unuint(input[61], 6, 31) as u64) << 6,
(__gen_unuint(input[62], 6, 31) as u64) << 6,
(__gen_unuint(input[63], 6, 31) as u64) << 6,
(__gen_unuint(input[64], 6, 31) as u64) << 6
],
direct_mv_buffer_arbitration_priority_control: [
__gen_unuint(input[33], 4, 5),
__gen_unuint(input[34], 4, 5),
__gen_unuint(input[35], 4, 5),
__gen_unuint(input[36], 4, 5),
__gen_unuint(input[37], 4, 5),
__gen_unuint(input[38], 4, 5),
__gen_unuint(input[39], 4, 5),
__gen_unuint(input[40], 4, 5),
__gen_unuint(input[41], 4, 5),
__gen_unuint(input[42], 4, 5),
__gen_unuint(input[43], 4, 5),
__gen_unuint(input[44], 4, 5),
__gen_unuint(input[45], 4, 5),
__gen_unuint(input[46], 4, 5),
__gen_unuint(input[47], 4, 5),
__gen_unuint(input[48], 4, 5),
__gen_unuint(input[49], 4, 5),
__gen_unuint(input[50], 4, 5),
__gen_unuint(input[51], 4, 5),
__gen_unuint(input[52], 4, 5),
__gen_unuint(input[53], 4, 5),
__gen_unuint(input[54], 4, 5),
__gen_unuint(input[55], 4, 5),
__gen_unuint(input[56], 4, 5),
__gen_unuint(input[57], 4, 5),
__gen_unuint(input[58], 4, 5),
__gen_unuint(input[59], 4, 5),
__gen_unuint(input[60], 4, 5),
__gen_unuint(input[61], 4, 5),
__gen_unuint(input[62], 4, 5),
__gen_unuint(input[63], 4, 5),
__gen_unuint(input[64], 4, 5)
],
direct_mv_buffer_graphics_data_type: [
__gen_unuint(input[33], 2, 2),
__gen_unuint(input[34], 2, 2),
__gen_unuint(input[35], 2, 2),
__gen_unuint(input[36], 2, 2),
__gen_unuint(input[37], 2, 2),
__gen_unuint(input[38], 2, 2),
__gen_unuint(input[39], 2, 2),
__gen_unuint(input[40], 2, 2),
__gen_unuint(input[41], 2, 2),
__gen_unuint(input[42], 2, 2),
__gen_unuint(input[43], 2, 2),
__gen_unuint(input[44], 2, 2),
__gen_unuint(input[45], 2, 2),
__gen_unuint(input[46], 2, 2),
__gen_unuint(input[47], 2, 2),
__gen_unuint(input[48], 2, 2),
__gen_unuint(input[49], 2, 2),
__gen_unuint(input[50], 2, 2),
__gen_unuint(input[51], 2, 2),
__gen_unuint(input[52], 2, 2),
__gen_unuint(input[53], 2, 2),
__gen_unuint(input[54], 2, 2),
__gen_unuint(input[55], 2, 2),
__gen_unuint(input[56], 2, 2),
__gen_unuint(input[57], 2, 2),
__gen_unuint(input[58], 2, 2),
__gen_unuint(input[59], 2, 2),
__gen_unuint(input[60], 2, 2),
__gen_unuint(input[61], 2, 2),
__gen_unuint(input[62], 2, 2),
__gen_unuint(input[63], 2, 2),
__gen_unuint(input[64], 2, 2)
],
direct_mv_buffer_cacheability_control: [
__gen_unuint(input[33], 0, 1),
__gen_unuint(input[34], 0, 1),
__gen_unuint(input[35], 0, 1),
__gen_unuint(input[36], 0, 1),
__gen_unuint(input[37], 0, 1),
__gen_unuint(input[38], 0, 1),
__gen_unuint(input[39], 0, 1),
__gen_unuint(input[40], 0, 1),
__gen_unuint(input[41], 0, 1),
__gen_unuint(input[42], 0, 1),
__gen_unuint(input[43], 0, 1),
__gen_unuint(input[44], 0, 1),
__gen_unuint(input[45], 0, 1),
__gen_unuint(input[46], 0, 1),
__gen_unuint(input[47], 0, 1),
__gen_unuint(input[48], 0, 1),
__gen_unuint(input[49], 0, 1),
__gen_unuint(input[50], 0, 1),
__gen_unuint(input[51], 0, 1),
__gen_unuint(input[52], 0, 1),
__gen_unuint(input[53], 0, 1),
__gen_unuint(input[54], 0, 1),
__gen_unuint(input[55], 0, 1),
__gen_unuint(input[56], 0, 1),
__gen_unuint(input[57], 0, 1),
__gen_unuint(input[58], 0, 1),
__gen_unuint(input[59], 0, 1),
__gen_unuint(input[60], 0, 1),
__gen_unuint(input[61], 0, 1),
__gen_unuint(input[62], 0, 1),
__gen_unuint(input[63], 0, 1),
__gen_unuint(input[64], 0, 1)
],
direct_mv_buffer_write_address: [
(__gen_unuint(input[33], 6, 31) as u64) << 6,
(__gen_unuint(input[34], 6, 31) as u64) << 6
],
direct_mv_buffer_write_arbitration_priority_control: [
__gen_unuint(input[33], 4, 5),
__gen_unuint(input[34], 4, 5)
],
direct_mv_buffer_write_graphics_data_type: [
__gen_unuint(input[33], 2, 2),
__gen_unuint(input[34], 2, 2)
],
direct_mv_buffer_write_cacheability_control: [
__gen_unuint(input[33], 0, 1),
__gen_unuint(input[34], 0, 1)
],
poc_list: [
__gen_unuint(input[35], 0, 31),
__gen_unuint(input[36], 0, 31),
__gen_unuint(input[37], 0, 31),
__gen_unuint(input[38], 0, 31),
__gen_unuint(input[39], 0, 31),
__gen_unuint(input[40], 0, 31),
__gen_unuint(input[41], 0, 31),
__gen_unuint(input[42], 0, 31),
__gen_unuint(input[43], 0, 31),
__gen_unuint(input[44], 0, 31),
__gen_unuint(input[45], 0, 31),
__gen_unuint(input[46], 0, 31),
__gen_unuint(input[47], 0, 31),
__gen_unuint(input[48], 0, 31),
__gen_unuint(input[49], 0, 31),
__gen_unuint(input[50], 0, 31),
__gen_unuint(input[51], 0, 31),
__gen_unuint(input[52], 0, 31),
__gen_unuint(input[53], 0, 31),
__gen_unuint(input[54], 0, 31),
__gen_unuint(input[55], 0, 31),
__gen_unuint(input[56], 0, 31),
__gen_unuint(input[57], 0, 31),
__gen_unuint(input[58], 0, 31),
__gen_unuint(input[59], 0, 31),
__gen_unuint(input[60], 0, 31),
__gen_unuint(input[61], 0, 31),
__gen_unuint(input[62], 0, 31),
__gen_unuint(input[63], 0, 31),
__gen_unuint(input[64], 0, 31),
__gen_unuint(input[65], 0, 31),
__gen_unuint(input[66], 0, 31),
__gen_unuint(input[67], 0, 31),
__gen_unuint(input[68], 0, 31)
],
}
}
}
impl Deserialize for MfxAvcDirectmodeState<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 69];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 69] as *mut [u8; 276]) })?;
Ok((&input).into())
}
}
pub struct MfxAvcImgState {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub frame_size: u32,
pub frame_width: u32,
pub frame_height: u32,
pub image_structure: u32,
pub weighted_biprediction_idc: u32,
pub weighted_prediction_enable: bool,
pub first_chroma_qp_offset: u32,
pub second_chroma_qp_offset: u32,
pub field_picure: bool,
pub mbaff_mode: bool,
pub frame_mb_only: bool,
pub _8x8_idct_transform_mode: bool,
pub direct_8x8_inference: bool,
pub constrained_intra_prediction: bool,
pub non_reference_picture: bool,
pub entropy_coding_sync_enable: bool,
pub mb_mv_format: u32,
pub chroma_format_idc: u32,
pub mv_unpacked_enable: bool,
pub load_bitstream_pointer_per_slice: bool,
pub mb_status_read: bool,
pub minimum_frame_size: u32,
pub intra_mb_max_bit_control: bool,
pub inter_mb_max_bit_control: bool,
pub frame_bitrate_max_report: bool,
pub frame_bitrate_min_report: bool,
pub force_ipcm_control: bool,
pub mb_level_rate_control: bool,
pub minimum_frame_size_units: u32,
pub inter_mb_force_cbp_to_zero_control: bool,
pub non_first_pass: u32,
pub trellis_quantization_chroma_disable: bool,
pub trellis_quantization_rounding: u32,
pub trellis_quantization_enable: bool,
pub intra_mb_conformance_max_size: u32,
pub inter_mb_conformance_max_size: u32,
pub slice_delta_qp_max_0: i32,
pub slice_delta_qp_max_1: i32,
pub slice_delta_qp_max_2: u32,
pub slice_delta_qp_max_3: i32,
pub slice_delta_qp_min_0: i32,
pub slice_delta_qp_min_1: i32,
pub slice_delta_qp_min_2: i32,
pub slice_delta_qp_min_3: i32,
pub frame_bitrate_min: u32,
pub frame_bitrate_min_unit_mode: u32,
pub frame_bitrate_min_unit: u32,
pub frame_bitrate_max: u32,
pub frame_bitrate_max_unit_mode: u32,
pub frame_bitrate_max_unit: u32,
pub frame_bitrate_min_delta: u32,
pub frame_bitrate_max_delta: u32,
pub slice_stats_stream_out_enable: bool,
pub initial_qp_value: i32,
pub number_of_active_reference_pictures_from_l0: u32,
pub number_of_active_reference_pictures_from_l1: u32,
pub number_of_reference_frames: u32,
pub current_picture_has_performed_mmco5: bool,
pub pic_order_present: bool,
pub delta_pic_order_always_zero: bool,
pub pic_order_count_type: u32,
pub slice_group_map_type: u32,
pub redundant_pic_count_present: bool,
pub number_of_slice_groups: u32,
pub deblocking_filter_control_present: bool,
pub log2_max_frame_number: u32,
pub log2_max_pic_order_count_lsb: u32,
pub slice_group_change_rate: u32,
pub current_picture_frame_number: u32,
}
impl MfxAvcImgState {
pub const DWORD_LENGTH: u32 = 16;
pub const BOTTOM_FIELD_PICTURE: u32 = 3;
pub const COMPATIBILITY_MODE: u32 = 0;
pub const DEFAULT: u32 = 0;
pub const EXPLICIT: u32 = 1;
pub const FOLLOW: u32 = 1;
pub const FRAME_PICTURE: u32 = 0;
pub const IGNORE: u32 = 0;
pub const IMPLICIT: u32 = 2;
pub const INVALID_NOT_ALLOWED: u32 = 2;
pub const MONOCHROME_PICTURE: u32 = 0;
pub const NEW_MODE: u32 = 1;
pub const TOP_FIELD_PICTURE: u32 = 1;
pub const _16KB: u32 = 3;
pub const _16_BYTES: u32 = 1;
pub const _4KB: u32 = 2;
pub const _4_2_0_PICTURE: u32 = 1;
pub const _4_2_2_PICTURE_NOT_SUPPORTED: u32 = 2;
pub const _4_4_4_PICTURE_NOT_SUPPORTED: u32 = 3;
}
impl Default for MfxAvcImgState {
fn default() -> Self {
MfxAvcImgState {
dword_length: 12,
subopcode_b: 0,
subopcode_a: 0,
media_command_opcode: 1,
pipeline: 2,
command_type: 3,
frame_size: Default::default(),
frame_width: Default::default(),
frame_height: Default::default(),
image_structure: Default::default(),
weighted_biprediction_idc: Default::default(),
weighted_prediction_enable: Default::default(),
first_chroma_qp_offset: Default::default(),
second_chroma_qp_offset: Default::default(),
field_picure: Default::default(),
mbaff_mode: Default::default(),
frame_mb_only: Default::default(),
_8x8_idct_transform_mode: Default::default(),
direct_8x8_inference: Default::default(),
constrained_intra_prediction: Default::default(),
non_reference_picture: Default::default(),
entropy_coding_sync_enable: Default::default(),
mb_mv_format: Default::default(),
chroma_format_idc: Default::default(),
mv_unpacked_enable: Default::default(),
load_bitstream_pointer_per_slice: Default::default(),
mb_status_read: Default::default(),
minimum_frame_size: Default::default(),
intra_mb_max_bit_control: Default::default(),
inter_mb_max_bit_control: Default::default(),
frame_bitrate_max_report: Default::default(),
frame_bitrate_min_report: Default::default(),
force_ipcm_control: Default::default(),
mb_level_rate_control: Default::default(),
minimum_frame_size_units: Default::default(),
inter_mb_force_cbp_to_zero_control: Default::default(),
non_first_pass: Default::default(),
trellis_quantization_chroma_disable: Default::default(),
trellis_quantization_rounding: Default::default(),
trellis_quantization_enable: Default::default(),
intra_mb_conformance_max_size: Default::default(),
inter_mb_conformance_max_size: Default::default(),
slice_delta_qp_max_0: Default::default(),
slice_delta_qp_max_1: Default::default(),
slice_delta_qp_max_2: Default::default(),
slice_delta_qp_max_3: Default::default(),
slice_delta_qp_min_0: Default::default(),
slice_delta_qp_min_1: Default::default(),
slice_delta_qp_min_2: Default::default(),
slice_delta_qp_min_3: Default::default(),
frame_bitrate_min: Default::default(),
frame_bitrate_min_unit_mode: Default::default(),
frame_bitrate_min_unit: Default::default(),
frame_bitrate_max: Default::default(),
frame_bitrate_max_unit_mode: Default::default(),
frame_bitrate_max_unit: Default::default(),
frame_bitrate_min_delta: Default::default(),
frame_bitrate_max_delta: Default::default(),
slice_stats_stream_out_enable: Default::default(),
initial_qp_value: Default::default(),
number_of_active_reference_pictures_from_l0: Default::default(),
number_of_active_reference_pictures_from_l1: Default::default(),
number_of_reference_frames: Default::default(),
current_picture_has_performed_mmco5: Default::default(),
pic_order_present: Default::default(),
delta_pic_order_always_zero: Default::default(),
pic_order_count_type: Default::default(),
slice_group_map_type: Default::default(),
redundant_pic_count_present: Default::default(),
number_of_slice_groups: Default::default(),
deblocking_filter_control_present: Default::default(),
log2_max_frame_number: Default::default(),
log2_max_pic_order_count_lsb: Default::default(),
slice_group_change_rate: Default::default(),
current_picture_frame_number: Default::default(),
}
}
}
impl Serialize for MfxAvcImgState {
type Out = [u32; 16];
fn pack_into(&self, out: &mut [u32; 16]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.frame_size, 0, 15);
out[2] = __gen_uint(self.frame_width, 0, 7) |
__gen_uint(self.frame_height, 16, 23);
out[3] = __gen_uint(self.image_structure, 8, 9) |
__gen_uint(self.weighted_biprediction_idc, 10, 11) |
__gen_uint(self.weighted_prediction_enable.into(), 12, 12) |
__gen_uint(self.first_chroma_qp_offset, 16, 20) |
__gen_uint(self.second_chroma_qp_offset, 24, 28);
out[4] = __gen_uint(self.field_picure.into(), 0, 0) |
__gen_uint(self.mbaff_mode.into(), 1, 1) |
__gen_uint(self.frame_mb_only.into(), 2, 2) |
__gen_uint(self._8x8_idct_transform_mode.into(), 3, 3) |
__gen_uint(self.direct_8x8_inference.into(), 4, 4) |
__gen_uint(self.constrained_intra_prediction.into(), 5, 5) |
__gen_uint(self.non_reference_picture.into(), 6, 6) |
__gen_uint(self.entropy_coding_sync_enable.into(), 7, 7) |
__gen_uint(self.mb_mv_format, 8, 8) |
__gen_uint(self.chroma_format_idc, 10, 11) |
__gen_uint(self.mv_unpacked_enable.into(), 12, 12) |
__gen_uint(self.load_bitstream_pointer_per_slice.into(), 14, 14) |
__gen_uint(self.mb_status_read.into(), 15, 15) |
__gen_uint(self.minimum_frame_size, 16, 31);
out[5] = __gen_uint(self.intra_mb_max_bit_control.into(), 0, 0) |
__gen_uint(self.inter_mb_max_bit_control.into(), 1, 1) |
__gen_uint(self.frame_bitrate_max_report.into(), 2, 2) |
__gen_uint(self.frame_bitrate_min_report.into(), 3, 3) |
__gen_uint(self.force_ipcm_control.into(), 7, 7) |
__gen_uint(self.mb_level_rate_control.into(), 9, 9) |
__gen_uint(self.minimum_frame_size_units, 10, 11) |
__gen_uint(self.inter_mb_force_cbp_to_zero_control.into(), 12, 12) |
__gen_uint(self.non_first_pass, 16, 16) |
__gen_uint(self.trellis_quantization_chroma_disable.into(), 27, 27) |
__gen_uint(self.trellis_quantization_rounding, 28, 30) |
__gen_uint(self.trellis_quantization_enable.into(), 31, 31);
out[6] = __gen_uint(self.intra_mb_conformance_max_size, 0, 11) |
__gen_uint(self.inter_mb_conformance_max_size, 16, 27);
out[7] = 0;
out[8] = __gen_uint(self.slice_delta_qp_max_0 as u32, 0, 7) |
__gen_uint(self.slice_delta_qp_max_1 as u32, 8, 15) |
__gen_uint(self.slice_delta_qp_max_2, 16, 23) |
__gen_uint(self.slice_delta_qp_max_3 as u32, 24, 31);
out[9] = __gen_uint(self.slice_delta_qp_min_0 as u32, 0, 7) |
__gen_uint(self.slice_delta_qp_min_1 as u32, 8, 15) |
__gen_uint(self.slice_delta_qp_min_2 as u32, 16, 23) |
__gen_uint(self.slice_delta_qp_min_3 as u32, 24, 31);
out[10] = __gen_uint(self.frame_bitrate_min, 0, 13) |
__gen_uint(self.frame_bitrate_min_unit_mode, 14, 14) |
__gen_uint(self.frame_bitrate_min_unit, 15, 15) |
__gen_uint(self.frame_bitrate_max, 16, 29) |
__gen_uint(self.frame_bitrate_max_unit_mode, 30, 30) |
__gen_uint(self.frame_bitrate_max_unit, 31, 31);
out[11] = __gen_uint(self.frame_bitrate_min_delta, 0, 14) |
__gen_uint(self.frame_bitrate_max_delta, 16, 30) |
__gen_uint(self.slice_stats_stream_out_enable.into(), 31, 31);
out[12] = 0;
out[13] = __gen_uint(self.initial_qp_value as u32, 0, 7) |
__gen_uint(self.number_of_active_reference_pictures_from_l0, 8, 13) |
__gen_uint(self.number_of_active_reference_pictures_from_l1, 16, 21) |
__gen_uint(self.number_of_reference_frames, 24, 28) |
__gen_uint(self.current_picture_has_performed_mmco5.into(), 29, 29);
out[14] = __gen_uint(self.pic_order_present.into(), 0, 0) |
__gen_uint(self.delta_pic_order_always_zero.into(), 1, 1) |
__gen_uint(self.pic_order_count_type, 2, 3) |
__gen_uint(self.slice_group_map_type, 8, 10) |
__gen_uint(self.redundant_pic_count_present.into(), 11, 11) |
__gen_uint(self.number_of_slice_groups, 12, 14) |
__gen_uint(self.deblocking_filter_control_present.into(), 15, 15) |
__gen_uint(self.log2_max_frame_number, 16, 23) |
__gen_uint(self.log2_max_pic_order_count_lsb, 24, 31);
out[15] = __gen_uint(self.slice_group_change_rate, 0, 15) |
__gen_uint(self.current_picture_frame_number, 16, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 16];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 16] as *const [u8; 64]) })
}
}
impl From<&[u32; 16]> for MfxAvcImgState {
fn from(input: &[u32; 16]) -> Self {
MfxAvcImgState {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
frame_size: __gen_unuint(input[1], 0, 15),
frame_width: __gen_unuint(input[2], 0, 7),
frame_height: __gen_unuint(input[2], 16, 23),
image_structure: __gen_unuint(input[3], 8, 9),
weighted_biprediction_idc: __gen_unuint(input[3], 10, 11),
weighted_prediction_enable: __gen_unuint(input[3], 12, 12) != 0,
first_chroma_qp_offset: __gen_unuint(input[3], 16, 20),
second_chroma_qp_offset: __gen_unuint(input[3], 24, 28),
field_picure: __gen_unuint(input[4], 0, 0) != 0,
mbaff_mode: __gen_unuint(input[4], 1, 1) != 0,
frame_mb_only: __gen_unuint(input[4], 2, 2) != 0,
_8x8_idct_transform_mode: __gen_unuint(input[4], 3, 3) != 0,
direct_8x8_inference: __gen_unuint(input[4], 4, 4) != 0,
constrained_intra_prediction: __gen_unuint(input[4], 5, 5) != 0,
non_reference_picture: __gen_unuint(input[4], 6, 6) != 0,
entropy_coding_sync_enable: __gen_unuint(input[4], 7, 7) != 0,
mb_mv_format: __gen_unuint(input[4], 8, 8),
chroma_format_idc: __gen_unuint(input[4], 10, 11),
mv_unpacked_enable: __gen_unuint(input[4], 12, 12) != 0,
load_bitstream_pointer_per_slice: __gen_unuint(input[4], 14, 14) != 0,
mb_status_read: __gen_unuint(input[4], 15, 15) != 0,
minimum_frame_size: __gen_unuint(input[4], 16, 31),
intra_mb_max_bit_control: __gen_unuint(input[5], 0, 0) != 0,
inter_mb_max_bit_control: __gen_unuint(input[5], 1, 1) != 0,
frame_bitrate_max_report: __gen_unuint(input[5], 2, 2) != 0,
frame_bitrate_min_report: __gen_unuint(input[5], 3, 3) != 0,
force_ipcm_control: __gen_unuint(input[5], 7, 7) != 0,
mb_level_rate_control: __gen_unuint(input[5], 9, 9) != 0,
minimum_frame_size_units: __gen_unuint(input[5], 10, 11),
inter_mb_force_cbp_to_zero_control: __gen_unuint(input[5], 12, 12) != 0,
non_first_pass: __gen_unuint(input[5], 16, 16),
trellis_quantization_chroma_disable: __gen_unuint(input[5], 27, 27) != 0,
trellis_quantization_rounding: __gen_unuint(input[5], 28, 30),
trellis_quantization_enable: __gen_unuint(input[5], 31, 31) != 0,
intra_mb_conformance_max_size: __gen_unuint(input[6], 0, 11),
inter_mb_conformance_max_size: __gen_unuint(input[6], 16, 27),
slice_delta_qp_max_0: (__gen_unuint(input[8], 0, 7)) as i32,
slice_delta_qp_max_1: (__gen_unuint(input[8], 8, 15)) as i32,
slice_delta_qp_max_2: __gen_unuint(input[8], 16, 23),
slice_delta_qp_max_3: (__gen_unuint(input[8], 24, 31)) as i32,
slice_delta_qp_min_0: (__gen_unuint(input[9], 0, 7)) as i32,
slice_delta_qp_min_1: (__gen_unuint(input[9], 8, 15)) as i32,
slice_delta_qp_min_2: (__gen_unuint(input[9], 16, 23)) as i32,
slice_delta_qp_min_3: (__gen_unuint(input[9], 24, 31)) as i32,
frame_bitrate_min: __gen_unuint(input[10], 0, 13),
frame_bitrate_min_unit_mode: __gen_unuint(input[10], 14, 14),
frame_bitrate_min_unit: __gen_unuint(input[10], 15, 15),
frame_bitrate_max: __gen_unuint(input[10], 16, 29),
frame_bitrate_max_unit_mode: __gen_unuint(input[10], 30, 30),
frame_bitrate_max_unit: __gen_unuint(input[10], 31, 31),
frame_bitrate_min_delta: __gen_unuint(input[11], 0, 14),
frame_bitrate_max_delta: __gen_unuint(input[11], 16, 30),
slice_stats_stream_out_enable: __gen_unuint(input[11], 31, 31) != 0,
initial_qp_value: (__gen_unuint(input[13], 0, 7)) as i32,
number_of_active_reference_pictures_from_l0: __gen_unuint(input[13], 8, 13),
number_of_active_reference_pictures_from_l1: __gen_unuint(input[13], 16, 21),
number_of_reference_frames: __gen_unuint(input[13], 24, 28),
current_picture_has_performed_mmco5: __gen_unuint(input[13], 29, 29) != 0,
pic_order_present: __gen_unuint(input[14], 0, 0) != 0,
delta_pic_order_always_zero: __gen_unuint(input[14], 1, 1) != 0,
pic_order_count_type: __gen_unuint(input[14], 2, 3),
slice_group_map_type: __gen_unuint(input[14], 8, 10),
redundant_pic_count_present: __gen_unuint(input[14], 11, 11) != 0,
number_of_slice_groups: __gen_unuint(input[14], 12, 14),
deblocking_filter_control_present: __gen_unuint(input[14], 15, 15) != 0,
log2_max_frame_number: __gen_unuint(input[14], 16, 23),
log2_max_pic_order_count_lsb: __gen_unuint(input[14], 24, 31),
slice_group_change_rate: __gen_unuint(input[15], 0, 15),
current_picture_frame_number: __gen_unuint(input[15], 16, 31),
}
}
}
impl Deserialize for MfxAvcImgState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 16];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 16] as *mut [u8; 64]) })?;
Ok((&input).into())
}
}
pub struct MfxAvcRefIdxState {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub reference_picture_list_select: u32,
pub reference_list_entry: [u32; 32],
}
impl MfxAvcRefIdxState {
pub const DWORD_LENGTH: u32 = 10;
}
impl Default for MfxAvcRefIdxState {
fn default() -> Self {
MfxAvcRefIdxState {
dword_length: 8,
subopcode_b: 4,
subopcode_a: 0,
media_command_opcode: 1,
pipeline: 2,
command_type: 3,
reference_picture_list_select: Default::default(),
reference_list_entry: Default::default(),
}
}
}
impl Serialize for MfxAvcRefIdxState {
type Out = [u32; 10];
fn pack_into(&self, out: &mut [u32; 10]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.reference_picture_list_select, 0, 0);
out[2] = __gen_uint(self.reference_list_entry[0], 0, 7) |
__gen_uint(self.reference_list_entry[1], 8, 15) |
__gen_uint(self.reference_list_entry[2], 16, 23) |
__gen_uint(self.reference_list_entry[3], 24, 31);
out[3] = __gen_uint(self.reference_list_entry[4], 0, 7) |
__gen_uint(self.reference_list_entry[5], 8, 15) |
__gen_uint(self.reference_list_entry[6], 16, 23) |
__gen_uint(self.reference_list_entry[7], 24, 31);
out[4] = __gen_uint(self.reference_list_entry[8], 0, 7) |
__gen_uint(self.reference_list_entry[9], 8, 15) |
__gen_uint(self.reference_list_entry[10], 16, 23) |
__gen_uint(self.reference_list_entry[11], 24, 31);
out[5] = __gen_uint(self.reference_list_entry[12], 0, 7) |
__gen_uint(self.reference_list_entry[13], 8, 15) |
__gen_uint(self.reference_list_entry[14], 16, 23) |
__gen_uint(self.reference_list_entry[15], 24, 31);
out[6] = __gen_uint(self.reference_list_entry[16], 0, 7) |
__gen_uint(self.reference_list_entry[17], 8, 15) |
__gen_uint(self.reference_list_entry[18], 16, 23) |
__gen_uint(self.reference_list_entry[19], 24, 31);
out[7] = __gen_uint(self.reference_list_entry[20], 0, 7) |
__gen_uint(self.reference_list_entry[21], 8, 15) |
__gen_uint(self.reference_list_entry[22], 16, 23) |
__gen_uint(self.reference_list_entry[23], 24, 31);
out[8] = __gen_uint(self.reference_list_entry[24], 0, 7) |
__gen_uint(self.reference_list_entry[25], 8, 15) |
__gen_uint(self.reference_list_entry[26], 16, 23) |
__gen_uint(self.reference_list_entry[27], 24, 31);
out[9] = __gen_uint(self.reference_list_entry[28], 0, 7) |
__gen_uint(self.reference_list_entry[29], 8, 15) |
__gen_uint(self.reference_list_entry[30], 16, 23) |
__gen_uint(self.reference_list_entry[31], 24, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 10];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 10] as *const [u8; 40]) })
}
}
impl From<&[u32; 10]> for MfxAvcRefIdxState {
fn from(input: &[u32; 10]) -> Self {
MfxAvcRefIdxState {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
reference_picture_list_select: __gen_unuint(input[1], 0, 0),
reference_list_entry: [
__gen_unuint(input[2], 0, 7),
__gen_unuint(input[2], 8, 15),
__gen_unuint(input[2], 16, 23),
__gen_unuint(input[2], 24, 31),
__gen_unuint(input[3], 0, 7),
__gen_unuint(input[3], 8, 15),
__gen_unuint(input[3], 16, 23),
__gen_unuint(input[3], 24, 31),
__gen_unuint(input[4], 0, 7),
__gen_unuint(input[4], 8, 15),
__gen_unuint(input[4], 16, 23),
__gen_unuint(input[4], 24, 31),
__gen_unuint(input[5], 0, 7),
__gen_unuint(input[5], 8, 15),
__gen_unuint(input[5], 16, 23),
__gen_unuint(input[5], 24, 31),
__gen_unuint(input[6], 0, 7),
__gen_unuint(input[6], 8, 15),
__gen_unuint(input[6], 16, 23),
__gen_unuint(input[6], 24, 31),
__gen_unuint(input[7], 0, 7),
__gen_unuint(input[7], 8, 15),
__gen_unuint(input[7], 16, 23),
__gen_unuint(input[7], 24, 31),
__gen_unuint(input[8], 0, 7),
__gen_unuint(input[8], 8, 15),
__gen_unuint(input[8], 16, 23),
__gen_unuint(input[8], 24, 31),
__gen_unuint(input[9], 0, 7),
__gen_unuint(input[9], 8, 15),
__gen_unuint(input[9], 16, 23),
__gen_unuint(input[9], 24, 31)
],
}
}
}
impl Deserialize for MfxAvcRefIdxState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 10];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 10] as *mut [u8; 40]) })?;
Ok((&input).into())
}
}
pub struct MfxAvcSliceState {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub slice_type: u32,
pub log2_weight_denominator_luma: u32,
pub log2_weight_denominator_chroma: u32,
pub number_of_reference_pictures_in_inter_prediction_list_0: u32,
pub number_of_reference_pictures_in_inter_prediction_list_1: u32,
pub slice_alpha_c0_offset_div2: i32,
pub slice_beta_offset_div2: i32,
pub slice_quantization_parameter: u32,
pub cabac_init_idc: u32,
pub disable_deblocking_filter_indicator: u32,
pub direct_prediction_type: u32,
pub weighted_prediction_indicator: u32,
pub slice_start_mb_number: u32,
pub slice_horizontal_position: u32,
pub slice_vertical_position: u32,
pub next_slice_horizontal_position: u32,
pub next_slice_vertical_position: u32,
pub stream_id: u32,
pub slice_id: u32,
pub cabac_zero_word_insertion_enable: bool,
pub emulation_byte_slice_insert_enable: bool,
pub tail_insertion_present: bool,
pub slice_data_insertion_present: bool,
pub header_insertion_present: bool,
pub last_slice_group: bool,
pub mb_type_skip_conversion_disable: bool,
pub mb_type_direct_conversion_disable: bool,
pub rate_control_panic_type: u32,
pub rate_control_panic_enable: bool,
pub rate_control_stable_tolerance: u32,
pub rate_control_triggle_mode: u32,
pub reset_rate_control_counter: bool,
pub rate_control_counter_enable: u32,
pub indirect_pak_bse_data_start_address: u64,
pub grow_init: u32,
pub grow_resistance: u32,
pub shrink_init: u32,
pub shrink_resistance: u32,
pub qp_max_positive_modifier_magnitude: u32,
pub qp_max_negative_modifier_magnitude: u32,
pub correct_1: u32,
pub correct_2: u32,
pub correct_3: u32,
pub correct_4: u32,
pub correct_5: u32,
pub correct_6: u32,
pub round_intra: u32,
pub round_intra_enable: bool,
pub round_inter: u32,
pub round_inter_enable: bool,
pub cv0: u32,
pub cv1: u32,
pub cv2: u32,
pub cv3: u32,
pub cv4: u32,
pub cv5: u32,
pub cv6: u32,
pub cv7: u32,
}
impl MfxAvcSliceState {
pub const DWORD_LENGTH: u32 = 11;
pub const ALWAYS_RATE_CONTROL: u32 = 0;
pub const B_SLICE: u32 = 1;
pub const CBP_PANIC: u32 = 1;
pub const GENTLE_RATE_CONTROL: u32 = 1;
pub const I_SLICE: u32 = 2;
pub const LOOSE_RATE_CONTROL: u32 = 2;
pub const P_SLICE: u32 = 0;
pub const QP_PANIC: u32 = 0;
pub const SPATIAL: u32 = 1;
pub const TEMPORAL: u32 = 0;
pub const _1_16: u32 = 0;
pub const _2_16: u32 = 1;
pub const _3_16: u32 = 2;
pub const _4_16: u32 = 3;
pub const _5_16: u32 = 4;
pub const _6_16: u32 = 5;
pub const _7_16: u32 = 6;
pub const _8_16: u32 = 7;
}
impl Default for MfxAvcSliceState {
fn default() -> Self {
MfxAvcSliceState {
dword_length: 8,
subopcode_b: 3,
subopcode_a: 0,
media_command_opcode: 1,
pipeline: 2,
command_type: 3,
slice_type: Default::default(),
log2_weight_denominator_luma: Default::default(),
log2_weight_denominator_chroma: Default::default(),
number_of_reference_pictures_in_inter_prediction_list_0: Default::default(),
number_of_reference_pictures_in_inter_prediction_list_1: Default::default(),
slice_alpha_c0_offset_div2: Default::default(),
slice_beta_offset_div2: Default::default(),
slice_quantization_parameter: Default::default(),
cabac_init_idc: Default::default(),
disable_deblocking_filter_indicator: Default::default(),
direct_prediction_type: Default::default(),
weighted_prediction_indicator: Default::default(),
slice_start_mb_number: Default::default(),
slice_horizontal_position: Default::default(),
slice_vertical_position: Default::default(),
next_slice_horizontal_position: Default::default(),
next_slice_vertical_position: Default::default(),
stream_id: Default::default(),
slice_id: Default::default(),
cabac_zero_word_insertion_enable: Default::default(),
emulation_byte_slice_insert_enable: Default::default(),
tail_insertion_present: Default::default(),
slice_data_insertion_present: Default::default(),
header_insertion_present: Default::default(),
last_slice_group: Default::default(),
mb_type_skip_conversion_disable: Default::default(),
mb_type_direct_conversion_disable: Default::default(),
rate_control_panic_type: Default::default(),
rate_control_panic_enable: Default::default(),
rate_control_stable_tolerance: Default::default(),
rate_control_triggle_mode: Default::default(),
reset_rate_control_counter: Default::default(),
rate_control_counter_enable: Default::default(),
indirect_pak_bse_data_start_address: Default::default(),
grow_init: Default::default(),
grow_resistance: Default::default(),
shrink_init: Default::default(),
shrink_resistance: Default::default(),
qp_max_positive_modifier_magnitude: Default::default(),
qp_max_negative_modifier_magnitude: Default::default(),
correct_1: Default::default(),
correct_2: Default::default(),
correct_3: Default::default(),
correct_4: Default::default(),
correct_5: Default::default(),
correct_6: Default::default(),
round_intra: Default::default(),
round_intra_enable: Default::default(),
round_inter: Default::default(),
round_inter_enable: Default::default(),
cv0: Default::default(),
cv1: Default::default(),
cv2: Default::default(),
cv3: Default::default(),
cv4: Default::default(),
cv5: Default::default(),
cv6: Default::default(),
cv7: Default::default(),
}
}
}
impl Serialize for MfxAvcSliceState {
type Out = [u32; 11];
fn pack_into(&self, out: &mut [u32; 11]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.slice_type, 0, 3);
out[2] = __gen_uint(self.log2_weight_denominator_luma, 0, 2) |
__gen_uint(self.log2_weight_denominator_chroma, 8, 10) |
__gen_uint(self.number_of_reference_pictures_in_inter_prediction_list_0, 16, 21) |
__gen_uint(self.number_of_reference_pictures_in_inter_prediction_list_1, 24, 29);
out[3] = __gen_uint(self.slice_alpha_c0_offset_div2 as u32, 0, 3) |
__gen_uint(self.slice_beta_offset_div2 as u32, 8, 11) |
__gen_uint(self.slice_quantization_parameter, 16, 21) |
__gen_uint(self.cabac_init_idc, 24, 25) |
__gen_uint(self.disable_deblocking_filter_indicator, 27, 28) |
__gen_uint(self.direct_prediction_type, 29, 29) |
__gen_uint(self.weighted_prediction_indicator, 30, 31);
out[4] = __gen_uint(self.slice_start_mb_number, 0, 14) |
__gen_uint(self.slice_horizontal_position, 16, 23) |
__gen_uint(self.slice_vertical_position, 24, 31);
out[5] = __gen_uint(self.next_slice_horizontal_position, 0, 7) |
__gen_uint(self.next_slice_vertical_position, 16, 23);
out[6] = __gen_uint(self.stream_id, 0, 1) |
__gen_uint(self.slice_id, 4, 7) |
__gen_uint(self.cabac_zero_word_insertion_enable.into(), 12, 12) |
__gen_uint(self.emulation_byte_slice_insert_enable.into(), 13, 13) |
__gen_uint(self.tail_insertion_present.into(), 15, 15) |
__gen_uint(self.slice_data_insertion_present.into(), 16, 16) |
__gen_uint(self.header_insertion_present.into(), 17, 17) |
__gen_uint(self.last_slice_group.into(), 19, 19) |
__gen_uint(self.mb_type_skip_conversion_disable.into(), 20, 20) |
__gen_uint(self.mb_type_direct_conversion_disable.into(), 21, 21) |
__gen_uint(self.rate_control_panic_type, 22, 22) |
__gen_uint(self.rate_control_panic_enable.into(), 23, 23) |
__gen_uint(self.rate_control_stable_tolerance, 24, 27) |
__gen_uint(self.rate_control_triggle_mode, 28, 29) |
__gen_uint(self.reset_rate_control_counter.into(), 30, 30) |
__gen_uint(self.rate_control_counter_enable, 31, 31);
out[7] = __gen_offset(self.indirect_pak_bse_data_start_address as u32, 0, 28);
out[8] = __gen_uint(self.grow_init, 0, 3) |
__gen_uint(self.grow_resistance, 4, 7) |
__gen_uint(self.shrink_init, 8, 11) |
__gen_uint(self.shrink_resistance, 12, 15) |
__gen_uint(self.qp_max_positive_modifier_magnitude, 16, 23) |
__gen_uint(self.qp_max_negative_modifier_magnitude, 24, 31);
out[9] = __gen_uint(self.correct_1, 0, 3) |
__gen_uint(self.correct_2, 4, 7) |
__gen_uint(self.correct_3, 8, 11) |
__gen_uint(self.correct_4, 12, 15) |
__gen_uint(self.correct_5, 16, 19) |
__gen_uint(self.correct_6, 20, 23) |
__gen_uint(self.round_intra, 24, 26) |
__gen_uint(self.round_intra_enable.into(), 27, 27) |
__gen_uint(self.round_inter, 28, 30) |
__gen_uint(self.round_inter_enable.into(), 31, 31);
out[10] = __gen_uint(self.cv0, 0, 3) |
__gen_uint(self.cv1, 4, 7) |
__gen_uint(self.cv2, 8, 11) |
__gen_uint(self.cv3, 12, 15) |
__gen_uint(self.cv4, 16, 19) |
__gen_uint(self.cv5, 20, 23) |
__gen_uint(self.cv6, 24, 27) |
__gen_uint(self.cv7, 28, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 11];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 11] as *const [u8; 44]) })
}
}
impl From<&[u32; 11]> for MfxAvcSliceState {
fn from(input: &[u32; 11]) -> Self {
MfxAvcSliceState {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
slice_type: __gen_unuint(input[1], 0, 3),
log2_weight_denominator_luma: __gen_unuint(input[2], 0, 2),
log2_weight_denominator_chroma: __gen_unuint(input[2], 8, 10),
number_of_reference_pictures_in_inter_prediction_list_0: __gen_unuint(input[2], 16, 21),
number_of_reference_pictures_in_inter_prediction_list_1: __gen_unuint(input[2], 24, 29),
slice_alpha_c0_offset_div2: (__gen_unuint(input[3], 0, 3)) as i32,
slice_beta_offset_div2: (__gen_unuint(input[3], 8, 11)) as i32,
slice_quantization_parameter: __gen_unuint(input[3], 16, 21),
cabac_init_idc: __gen_unuint(input[3], 24, 25),
disable_deblocking_filter_indicator: __gen_unuint(input[3], 27, 28),
direct_prediction_type: __gen_unuint(input[3], 29, 29),
weighted_prediction_indicator: __gen_unuint(input[3], 30, 31),
slice_start_mb_number: __gen_unuint(input[4], 0, 14),
slice_horizontal_position: __gen_unuint(input[4], 16, 23),
slice_vertical_position: __gen_unuint(input[4], 24, 31),
next_slice_horizontal_position: __gen_unuint(input[5], 0, 7),
next_slice_vertical_position: __gen_unuint(input[5], 16, 23),
stream_id: __gen_unuint(input[6], 0, 1),
slice_id: __gen_unuint(input[6], 4, 7),
cabac_zero_word_insertion_enable: __gen_unuint(input[6], 12, 12) != 0,
emulation_byte_slice_insert_enable: __gen_unuint(input[6], 13, 13) != 0,
tail_insertion_present: __gen_unuint(input[6], 15, 15) != 0,
slice_data_insertion_present: __gen_unuint(input[6], 16, 16) != 0,
header_insertion_present: __gen_unuint(input[6], 17, 17) != 0,
last_slice_group: __gen_unuint(input[6], 19, 19) != 0,
mb_type_skip_conversion_disable: __gen_unuint(input[6], 20, 20) != 0,
mb_type_direct_conversion_disable: __gen_unuint(input[6], 21, 21) != 0,
rate_control_panic_type: __gen_unuint(input[6], 22, 22),
rate_control_panic_enable: __gen_unuint(input[6], 23, 23) != 0,
rate_control_stable_tolerance: __gen_unuint(input[6], 24, 27),
rate_control_triggle_mode: __gen_unuint(input[6], 28, 29),
reset_rate_control_counter: __gen_unuint(input[6], 30, 30) != 0,
rate_control_counter_enable: __gen_unuint(input[6], 31, 31),
indirect_pak_bse_data_start_address: (__gen_unuint(input[7], 0, 28) as u64),
grow_init: __gen_unuint(input[8], 0, 3),
grow_resistance: __gen_unuint(input[8], 4, 7),
shrink_init: __gen_unuint(input[8], 8, 11),
shrink_resistance: __gen_unuint(input[8], 12, 15),
qp_max_positive_modifier_magnitude: __gen_unuint(input[8], 16, 23),
qp_max_negative_modifier_magnitude: __gen_unuint(input[8], 24, 31),
correct_1: __gen_unuint(input[9], 0, 3),
correct_2: __gen_unuint(input[9], 4, 7),
correct_3: __gen_unuint(input[9], 8, 11),
correct_4: __gen_unuint(input[9], 12, 15),
correct_5: __gen_unuint(input[9], 16, 19),
correct_6: __gen_unuint(input[9], 20, 23),
round_intra: __gen_unuint(input[9], 24, 26),
round_intra_enable: __gen_unuint(input[9], 27, 27) != 0,
round_inter: __gen_unuint(input[9], 28, 30),
round_inter_enable: __gen_unuint(input[9], 31, 31) != 0,
cv0: __gen_unuint(input[10], 0, 3),
cv1: __gen_unuint(input[10], 4, 7),
cv2: __gen_unuint(input[10], 8, 11),
cv3: __gen_unuint(input[10], 12, 15),
cv4: __gen_unuint(input[10], 16, 19),
cv5: __gen_unuint(input[10], 20, 23),
cv6: __gen_unuint(input[10], 24, 27),
cv7: __gen_unuint(input[10], 28, 31),
}
}
}
impl Deserialize for MfxAvcSliceState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 11];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 11] as *mut [u8; 44]) })?;
Ok((&input).into())
}
}
pub struct MfxAvcWeightoffsetState {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub weight_and_offset_select: u32,
pub weight_offset: [u32; 96],
}
impl MfxAvcWeightoffsetState {
pub const DWORD_LENGTH: u32 = 98;
pub const L0_TABLE: u32 = 0;
pub const L1_TABLE: u32 = 1;
}
impl Default for MfxAvcWeightoffsetState {
fn default() -> Self {
MfxAvcWeightoffsetState {
dword_length: 96,
subopcode_b: 5,
subopcode_a: 0,
media_command_opcode: 1,
pipeline: 2,
command_type: 3,
weight_and_offset_select: Default::default(),
weight_offset: [0; 96],
}
}
}
impl Serialize for MfxAvcWeightoffsetState {
type Out = [u32; 98];
fn pack_into(&self, out: &mut [u32; 98]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.weight_and_offset_select, 0, 0);
out[2] = __gen_uint(self.weight_offset[0], 0, 31);
out[3] = __gen_uint(self.weight_offset[1], 0, 31);
out[4] = __gen_uint(self.weight_offset[2], 0, 31);
out[5] = __gen_uint(self.weight_offset[3], 0, 31);
out[6] = __gen_uint(self.weight_offset[4], 0, 31);
out[7] = __gen_uint(self.weight_offset[5], 0, 31);
out[8] = __gen_uint(self.weight_offset[6], 0, 31);
out[9] = __gen_uint(self.weight_offset[7], 0, 31);
out[10] = __gen_uint(self.weight_offset[8], 0, 31);
out[11] = __gen_uint(self.weight_offset[9], 0, 31);
out[12] = __gen_uint(self.weight_offset[10], 0, 31);
out[13] = __gen_uint(self.weight_offset[11], 0, 31);
out[14] = __gen_uint(self.weight_offset[12], 0, 31);
out[15] = __gen_uint(self.weight_offset[13], 0, 31);
out[16] = __gen_uint(self.weight_offset[14], 0, 31);
out[17] = __gen_uint(self.weight_offset[15], 0, 31);
out[18] = __gen_uint(self.weight_offset[16], 0, 31);
out[19] = __gen_uint(self.weight_offset[17], 0, 31);
out[20] = __gen_uint(self.weight_offset[18], 0, 31);
out[21] = __gen_uint(self.weight_offset[19], 0, 31);
out[22] = __gen_uint(self.weight_offset[20], 0, 31);
out[23] = __gen_uint(self.weight_offset[21], 0, 31);
out[24] = __gen_uint(self.weight_offset[22], 0, 31);
out[25] = __gen_uint(self.weight_offset[23], 0, 31);
out[26] = __gen_uint(self.weight_offset[24], 0, 31);
out[27] = __gen_uint(self.weight_offset[25], 0, 31);
out[28] = __gen_uint(self.weight_offset[26], 0, 31);
out[29] = __gen_uint(self.weight_offset[27], 0, 31);
out[30] = __gen_uint(self.weight_offset[28], 0, 31);
out[31] = __gen_uint(self.weight_offset[29], 0, 31);
out[32] = __gen_uint(self.weight_offset[30], 0, 31);
out[33] = __gen_uint(self.weight_offset[31], 0, 31);
out[34] = __gen_uint(self.weight_offset[32], 0, 31);
out[35] = __gen_uint(self.weight_offset[33], 0, 31);
out[36] = __gen_uint(self.weight_offset[34], 0, 31);
out[37] = __gen_uint(self.weight_offset[35], 0, 31);
out[38] = __gen_uint(self.weight_offset[36], 0, 31);
out[39] = __gen_uint(self.weight_offset[37], 0, 31);
out[40] = __gen_uint(self.weight_offset[38], 0, 31);
out[41] = __gen_uint(self.weight_offset[39], 0, 31);
out[42] = __gen_uint(self.weight_offset[40], 0, 31);
out[43] = __gen_uint(self.weight_offset[41], 0, 31);
out[44] = __gen_uint(self.weight_offset[42], 0, 31);
out[45] = __gen_uint(self.weight_offset[43], 0, 31);
out[46] = __gen_uint(self.weight_offset[44], 0, 31);
out[47] = __gen_uint(self.weight_offset[45], 0, 31);
out[48] = __gen_uint(self.weight_offset[46], 0, 31);
out[49] = __gen_uint(self.weight_offset[47], 0, 31);
out[50] = __gen_uint(self.weight_offset[48], 0, 31);
out[51] = __gen_uint(self.weight_offset[49], 0, 31);
out[52] = __gen_uint(self.weight_offset[50], 0, 31);
out[53] = __gen_uint(self.weight_offset[51], 0, 31);
out[54] = __gen_uint(self.weight_offset[52], 0, 31);
out[55] = __gen_uint(self.weight_offset[53], 0, 31);
out[56] = __gen_uint(self.weight_offset[54], 0, 31);
out[57] = __gen_uint(self.weight_offset[55], 0, 31);
out[58] = __gen_uint(self.weight_offset[56], 0, 31);
out[59] = __gen_uint(self.weight_offset[57], 0, 31);
out[60] = __gen_uint(self.weight_offset[58], 0, 31);
out[61] = __gen_uint(self.weight_offset[59], 0, 31);
out[62] = __gen_uint(self.weight_offset[60], 0, 31);
out[63] = __gen_uint(self.weight_offset[61], 0, 31);
out[64] = __gen_uint(self.weight_offset[62], 0, 31);
out[65] = __gen_uint(self.weight_offset[63], 0, 31);
out[66] = __gen_uint(self.weight_offset[64], 0, 31);
out[67] = __gen_uint(self.weight_offset[65], 0, 31);
out[68] = __gen_uint(self.weight_offset[66], 0, 31);
out[69] = __gen_uint(self.weight_offset[67], 0, 31);
out[70] = __gen_uint(self.weight_offset[68], 0, 31);
out[71] = __gen_uint(self.weight_offset[69], 0, 31);
out[72] = __gen_uint(self.weight_offset[70], 0, 31);
out[73] = __gen_uint(self.weight_offset[71], 0, 31);
out[74] = __gen_uint(self.weight_offset[72], 0, 31);
out[75] = __gen_uint(self.weight_offset[73], 0, 31);
out[76] = __gen_uint(self.weight_offset[74], 0, 31);
out[77] = __gen_uint(self.weight_offset[75], 0, 31);
out[78] = __gen_uint(self.weight_offset[76], 0, 31);
out[79] = __gen_uint(self.weight_offset[77], 0, 31);
out[80] = __gen_uint(self.weight_offset[78], 0, 31);
out[81] = __gen_uint(self.weight_offset[79], 0, 31);
out[82] = __gen_uint(self.weight_offset[80], 0, 31);
out[83] = __gen_uint(self.weight_offset[81], 0, 31);
out[84] = __gen_uint(self.weight_offset[82], 0, 31);
out[85] = __gen_uint(self.weight_offset[83], 0, 31);
out[86] = __gen_uint(self.weight_offset[84], 0, 31);
out[87] = __gen_uint(self.weight_offset[85], 0, 31);
out[88] = __gen_uint(self.weight_offset[86], 0, 31);
out[89] = __gen_uint(self.weight_offset[87], 0, 31);
out[90] = __gen_uint(self.weight_offset[88], 0, 31);
out[91] = __gen_uint(self.weight_offset[89], 0, 31);
out[92] = __gen_uint(self.weight_offset[90], 0, 31);
out[93] = __gen_uint(self.weight_offset[91], 0, 31);
out[94] = __gen_uint(self.weight_offset[92], 0, 31);
out[95] = __gen_uint(self.weight_offset[93], 0, 31);
out[96] = __gen_uint(self.weight_offset[94], 0, 31);
out[97] = __gen_uint(self.weight_offset[95], 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 98];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 98] as *const [u8; 392]) })
}
}
impl From<&[u32; 98]> for MfxAvcWeightoffsetState {
fn from(input: &[u32; 98]) -> Self {
MfxAvcWeightoffsetState {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
weight_and_offset_select: __gen_unuint(input[1], 0, 0),
weight_offset: [
__gen_unuint(input[2], 0, 31),
__gen_unuint(input[3], 0, 31),
__gen_unuint(input[4], 0, 31),
__gen_unuint(input[5], 0, 31),
__gen_unuint(input[6], 0, 31),
__gen_unuint(input[7], 0, 31),
__gen_unuint(input[8], 0, 31),
__gen_unuint(input[9], 0, 31),
__gen_unuint(input[10], 0, 31),
__gen_unuint(input[11], 0, 31),
__gen_unuint(input[12], 0, 31),
__gen_unuint(input[13], 0, 31),
__gen_unuint(input[14], 0, 31),
__gen_unuint(input[15], 0, 31),
__gen_unuint(input[16], 0, 31),
__gen_unuint(input[17], 0, 31),
__gen_unuint(input[18], 0, 31),
__gen_unuint(input[19], 0, 31),
__gen_unuint(input[20], 0, 31),
__gen_unuint(input[21], 0, 31),
__gen_unuint(input[22], 0, 31),
__gen_unuint(input[23], 0, 31),
__gen_unuint(input[24], 0, 31),
__gen_unuint(input[25], 0, 31),
__gen_unuint(input[26], 0, 31),
__gen_unuint(input[27], 0, 31),
__gen_unuint(input[28], 0, 31),
__gen_unuint(input[29], 0, 31),
__gen_unuint(input[30], 0, 31),
__gen_unuint(input[31], 0, 31),
__gen_unuint(input[32], 0, 31),
__gen_unuint(input[33], 0, 31),
__gen_unuint(input[34], 0, 31),
__gen_unuint(input[35], 0, 31),
__gen_unuint(input[36], 0, 31),
__gen_unuint(input[37], 0, 31),
__gen_unuint(input[38], 0, 31),
__gen_unuint(input[39], 0, 31),
__gen_unuint(input[40], 0, 31),
__gen_unuint(input[41], 0, 31),
__gen_unuint(input[42], 0, 31),
__gen_unuint(input[43], 0, 31),
__gen_unuint(input[44], 0, 31),
__gen_unuint(input[45], 0, 31),
__gen_unuint(input[46], 0, 31),
__gen_unuint(input[47], 0, 31),
__gen_unuint(input[48], 0, 31),
__gen_unuint(input[49], 0, 31),
__gen_unuint(input[50], 0, 31),
__gen_unuint(input[51], 0, 31),
__gen_unuint(input[52], 0, 31),
__gen_unuint(input[53], 0, 31),
__gen_unuint(input[54], 0, 31),
__gen_unuint(input[55], 0, 31),
__gen_unuint(input[56], 0, 31),
__gen_unuint(input[57], 0, 31),
__gen_unuint(input[58], 0, 31),
__gen_unuint(input[59], 0, 31),
__gen_unuint(input[60], 0, 31),
__gen_unuint(input[61], 0, 31),
__gen_unuint(input[62], 0, 31),
__gen_unuint(input[63], 0, 31),
__gen_unuint(input[64], 0, 31),
__gen_unuint(input[65], 0, 31),
__gen_unuint(input[66], 0, 31),
__gen_unuint(input[67], 0, 31),
__gen_unuint(input[68], 0, 31),
__gen_unuint(input[69], 0, 31),
__gen_unuint(input[70], 0, 31),
__gen_unuint(input[71], 0, 31),
__gen_unuint(input[72], 0, 31),
__gen_unuint(input[73], 0, 31),
__gen_unuint(input[74], 0, 31),
__gen_unuint(input[75], 0, 31),
__gen_unuint(input[76], 0, 31),
__gen_unuint(input[77], 0, 31),
__gen_unuint(input[78], 0, 31),
__gen_unuint(input[79], 0, 31),
__gen_unuint(input[80], 0, 31),
__gen_unuint(input[81], 0, 31),
__gen_unuint(input[82], 0, 31),
__gen_unuint(input[83], 0, 31),
__gen_unuint(input[84], 0, 31),
__gen_unuint(input[85], 0, 31),
__gen_unuint(input[86], 0, 31),
__gen_unuint(input[87], 0, 31),
__gen_unuint(input[88], 0, 31),
__gen_unuint(input[89], 0, 31),
__gen_unuint(input[90], 0, 31),
__gen_unuint(input[91], 0, 31),
__gen_unuint(input[92], 0, 31),
__gen_unuint(input[93], 0, 31),
__gen_unuint(input[94], 0, 31),
__gen_unuint(input[95], 0, 31),
__gen_unuint(input[96], 0, 31),
__gen_unuint(input[97], 0, 31)
],
}
}
}
impl Deserialize for MfxAvcWeightoffsetState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 98];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 98] as *mut [u8; 392]) })?;
Ok((&input).into())
}
}
pub struct MfxBspBufBaseAddrState<A: Addr + Default> {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub bsd_mpc_row_store_scratch_buffer_arbitration_priority_control: u32,
pub bsd_mpc_row_store_scratch_buffer_address: A,
pub mpr_row_store_scratch_buffer_arbitration_priority_control: u32,
pub mpr_row_store_scratch_buffer_address: A,
pub bitplane_read_buffer_arbitration_priority_control: u32,
pub bitplane_read_buffer_address: A,
}
impl<A: Addr + Default> MfxBspBufBaseAddrState<A> {
pub const DWORD_LENGTH: u32 = 4;
pub const HIGHEST_PRIORITY: u32 = 0;
pub const LOWEST_PRIORITY: u32 = 3;
pub const SECOND_HIGHEST_PRIORITY: u32 = 1;
pub const THIRD_HIGHEST_PRIORITY: u32 = 2;
}
impl<A: Addr + Default> Default for MfxBspBufBaseAddrState<A> {
fn default() -> Self {
MfxBspBufBaseAddrState {
dword_length: 2,
subopcode_b: 4,
subopcode_a: 0,
media_command_opcode: 0,
pipeline: 2,
command_type: 3,
bsd_mpc_row_store_scratch_buffer_arbitration_priority_control: Default::default(),
bsd_mpc_row_store_scratch_buffer_address: Default::default(),
mpr_row_store_scratch_buffer_arbitration_priority_control: Default::default(),
mpr_row_store_scratch_buffer_address: Default::default(),
bitplane_read_buffer_arbitration_priority_control: Default::default(),
bitplane_read_buffer_address: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for MfxBspBufBaseAddrState<A> {
type Out = [u32; 4];
fn pack_into(&self, out: &mut [u32; 4]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
let v1 = __gen_uint(self.bsd_mpc_row_store_scratch_buffer_arbitration_priority_control, 4, 5);
let v1_address = self.bsd_mpc_row_store_scratch_buffer_address.combine(v1);
out[1] = v1_address as u32;
out[2] = (v1_address >> 32) as u32;
let v2 = __gen_uint(self.mpr_row_store_scratch_buffer_arbitration_priority_control, 4, 5);
let v2_address = self.mpr_row_store_scratch_buffer_address.combine(v2);
out[2] = v2_address as u32;
out[3] = (v2_address >> 32) as u32;
let v3 = __gen_uint(self.bitplane_read_buffer_arbitration_priority_control, 4, 5);
let v3_address = self.bitplane_read_buffer_address.combine(v3);
out[3] = v3_address as u32;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 4];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 4] as *const [u8; 16]) })
}
}
impl From<&[u32; 4]> for MfxBspBufBaseAddrState<u64> {
fn from(input: &[u32; 4]) -> Self {
MfxBspBufBaseAddrState {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
bsd_mpc_row_store_scratch_buffer_arbitration_priority_control: __gen_unuint(input[1], 4, 5),
bsd_mpc_row_store_scratch_buffer_address: (__gen_unuint(input[1], 6, 31) as u64) << 6,
mpr_row_store_scratch_buffer_arbitration_priority_control: __gen_unuint(input[2], 4, 5),
mpr_row_store_scratch_buffer_address: (__gen_unuint(input[2], 6, 31) as u64) << 6,
bitplane_read_buffer_arbitration_priority_control: __gen_unuint(input[3], 4, 5),
bitplane_read_buffer_address: (__gen_unuint(input[3], 6, 31) as u64) << 6,
}
}
}
impl Deserialize for MfxBspBufBaseAddrState<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 4];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 4] as *mut [u8; 16]) })?;
Ok((&input).into())
}
}
pub struct MfxDbkObject<A: Addr + Default> {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub pre_deblocking_source_cacheability_control: u32,
pub pre_deblocking_source_graphics_data_type: u32,
pub pre_deblocking_source_arbitration_priority_control: u32,
pub pre_deblocking_source_address: A,
pub deblocking_control_cacheability_control: u32,
pub deblocking_control_graphics_data_type: u32,
pub deblocking_control_arbitration_priority_control: u32,
pub deblocking_control_address: A,
pub deblocking_cacheability_control: u32,
pub deblocking_graphics_data_type: u32,
pub deblocking_arbitration_priority_control: u32,
pub deblocking_address: A,
pub deblock_row_store_cacheability_control: u32,
pub deblock_row_store_graphics_data_type: u32,
pub deblock_row_store_arbitration_priority_control: u32,
pub deblock_row_store_address: A,
}
impl<A: Addr + Default> MfxDbkObject<A> {
pub const DWORD_LENGTH: u32 = 5;
pub const BOTH_LLC_AND_MLC: u32 = 3;
pub const GTT_ENTRY: u32 = 0;
pub const HIGHEST_PRIORITY: u32 = 0;
pub const IN_LLC_BUT_NOT_MLC: u32 = 2;
pub const LOWEST_PRIORITY: u32 = 3;
pub const NOT_IN_LLC_OR_MLC: u32 = 1;
pub const SECOND_HIGHEST_PRIORITY: u32 = 1;
pub const THIRD_HIGHEST_PRIORITY: u32 = 2;
}
impl<A: Addr + Default> Default for MfxDbkObject<A> {
fn default() -> Self {
MfxDbkObject {
dword_length: 3,
subopcode_b: 9,
subopcode_a: 0,
media_command_opcode: 0,
pipeline: 2,
command_type: 3,
pre_deblocking_source_cacheability_control: Default::default(),
pre_deblocking_source_graphics_data_type: Default::default(),
pre_deblocking_source_arbitration_priority_control: Default::default(),
pre_deblocking_source_address: Default::default(),
deblocking_control_cacheability_control: Default::default(),
deblocking_control_graphics_data_type: Default::default(),
deblocking_control_arbitration_priority_control: Default::default(),
deblocking_control_address: Default::default(),
deblocking_cacheability_control: Default::default(),
deblocking_graphics_data_type: Default::default(),
deblocking_arbitration_priority_control: Default::default(),
deblocking_address: Default::default(),
deblock_row_store_cacheability_control: Default::default(),
deblock_row_store_graphics_data_type: Default::default(),
deblock_row_store_arbitration_priority_control: Default::default(),
deblock_row_store_address: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for MfxDbkObject<A> {
type Out = [u32; 5];
fn pack_into(&self, out: &mut [u32; 5]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
let v1 = __gen_uint(self.pre_deblocking_source_cacheability_control, 0, 1) |
__gen_uint(self.pre_deblocking_source_graphics_data_type, 2, 2) |
__gen_uint(self.pre_deblocking_source_arbitration_priority_control, 4, 5);
let v1_address = self.pre_deblocking_source_address.combine(v1);
out[1] = v1_address as u32;
out[2] = (v1_address >> 32) as u32;
let v2 = __gen_uint(self.deblocking_control_cacheability_control, 0, 1) |
__gen_uint(self.deblocking_control_graphics_data_type, 2, 2) |
__gen_uint(self.deblocking_control_arbitration_priority_control, 4, 5);
let v2_address = self.deblocking_control_address.combine(v2);
out[2] = v2_address as u32;
out[3] = (v2_address >> 32) as u32;
let v3 = __gen_uint(self.deblocking_cacheability_control, 0, 1) |
__gen_uint(self.deblocking_graphics_data_type, 2, 2) |
__gen_uint(self.deblocking_arbitration_priority_control, 4, 5);
let v3_address = self.deblocking_address.combine(v3);
out[3] = v3_address as u32;
out[4] = (v3_address >> 32) as u32;
let v4 = __gen_uint(self.deblock_row_store_cacheability_control, 0, 1) |
__gen_uint(self.deblock_row_store_graphics_data_type, 2, 2) |
__gen_uint(self.deblock_row_store_arbitration_priority_control, 4, 5);
let v4_address = self.deblock_row_store_address.combine(v4);
out[4] = v4_address as u32;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 5];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 5] as *const [u8; 20]) })
}
}
impl From<&[u32; 5]> for MfxDbkObject<u64> {
fn from(input: &[u32; 5]) -> Self {
MfxDbkObject {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
pre_deblocking_source_cacheability_control: __gen_unuint(input[1], 0, 1),
pre_deblocking_source_graphics_data_type: __gen_unuint(input[1], 2, 2),
pre_deblocking_source_arbitration_priority_control: __gen_unuint(input[1], 4, 5),
pre_deblocking_source_address: (__gen_unuint(input[1], 6, 31) as u64) << 6,
deblocking_control_cacheability_control: __gen_unuint(input[2], 0, 1),
deblocking_control_graphics_data_type: __gen_unuint(input[2], 2, 2),
deblocking_control_arbitration_priority_control: __gen_unuint(input[2], 4, 5),
deblocking_control_address: (__gen_unuint(input[2], 6, 31) as u64) << 6,
deblocking_cacheability_control: __gen_unuint(input[3], 0, 1),
deblocking_graphics_data_type: __gen_unuint(input[3], 2, 2),
deblocking_arbitration_priority_control: __gen_unuint(input[3], 4, 5),
deblocking_address: (__gen_unuint(input[3], 6, 31) as u64) << 6,
deblock_row_store_cacheability_control: __gen_unuint(input[4], 0, 1),
deblock_row_store_graphics_data_type: __gen_unuint(input[4], 2, 2),
deblock_row_store_arbitration_priority_control: __gen_unuint(input[4], 4, 5),
deblock_row_store_address: (__gen_unuint(input[4], 6, 31) as u64) << 6,
}
}
}
impl Deserialize for MfxDbkObject<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 5];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 5] as *mut [u8; 20]) })?;
Ok((&input).into())
}
}
pub struct MfxFqmState {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub avc: u32,
pub mpeg2: u32,
pub forward_quantizer_matrix: [u8; 128],
}
impl MfxFqmState {
pub const DWORD_LENGTH: u32 = 34;
pub const AVC_4X4_INTER_MATRIX: u32 = 1;
pub const AVC_4X4_INTRA_MATRIX: u32 = 0;
pub const AVC_8X8_INTER_MATRIX: u32 = 3;
pub const AVC_8X8_INTRA_MATRIX: u32 = 2;
pub const MPEG_INTRA_QUANTIZER_MATRIX: u32 = 0;
pub const MPEG_NON_INTRA_QUANTIZER_MATRIX: u32 = 1;
}
impl Default for MfxFqmState {
fn default() -> Self {
MfxFqmState {
dword_length: 32,
subopcode_b: 8,
subopcode_a: 0,
media_command_opcode: 0,
pipeline: 2,
command_type: 3,
avc: Default::default(),
mpeg2: Default::default(),
forward_quantizer_matrix: [0; 128],
}
}
}
impl Serialize for MfxFqmState {
type Out = [u32; 34];
fn pack_into(&self, out: &mut [u32; 34]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.mpeg2, 0, 1);
out[2] = __gen_uint(self.forward_quantizer_matrix[0].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[1].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[2].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[3].into(), 24, 31);
out[3] = __gen_uint(self.forward_quantizer_matrix[4].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[5].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[6].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[7].into(), 24, 31);
out[4] = __gen_uint(self.forward_quantizer_matrix[8].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[9].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[10].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[11].into(), 24, 31);
out[5] = __gen_uint(self.forward_quantizer_matrix[12].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[13].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[14].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[15].into(), 24, 31);
out[6] = __gen_uint(self.forward_quantizer_matrix[16].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[17].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[18].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[19].into(), 24, 31);
out[7] = __gen_uint(self.forward_quantizer_matrix[20].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[21].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[22].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[23].into(), 24, 31);
out[8] = __gen_uint(self.forward_quantizer_matrix[24].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[25].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[26].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[27].into(), 24, 31);
out[9] = __gen_uint(self.forward_quantizer_matrix[28].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[29].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[30].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[31].into(), 24, 31);
out[10] = __gen_uint(self.forward_quantizer_matrix[32].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[33].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[34].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[35].into(), 24, 31);
out[11] = __gen_uint(self.forward_quantizer_matrix[36].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[37].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[38].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[39].into(), 24, 31);
out[12] = __gen_uint(self.forward_quantizer_matrix[40].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[41].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[42].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[43].into(), 24, 31);
out[13] = __gen_uint(self.forward_quantizer_matrix[44].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[45].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[46].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[47].into(), 24, 31);
out[14] = __gen_uint(self.forward_quantizer_matrix[48].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[49].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[50].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[51].into(), 24, 31);
out[15] = __gen_uint(self.forward_quantizer_matrix[52].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[53].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[54].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[55].into(), 24, 31);
out[16] = __gen_uint(self.forward_quantizer_matrix[56].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[57].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[58].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[59].into(), 24, 31);
out[17] = __gen_uint(self.forward_quantizer_matrix[60].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[61].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[62].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[63].into(), 24, 31);
out[18] = __gen_uint(self.forward_quantizer_matrix[64].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[65].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[66].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[67].into(), 24, 31);
out[19] = __gen_uint(self.forward_quantizer_matrix[68].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[69].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[70].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[71].into(), 24, 31);
out[20] = __gen_uint(self.forward_quantizer_matrix[72].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[73].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[74].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[75].into(), 24, 31);
out[21] = __gen_uint(self.forward_quantizer_matrix[76].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[77].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[78].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[79].into(), 24, 31);
out[22] = __gen_uint(self.forward_quantizer_matrix[80].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[81].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[82].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[83].into(), 24, 31);
out[23] = __gen_uint(self.forward_quantizer_matrix[84].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[85].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[86].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[87].into(), 24, 31);
out[24] = __gen_uint(self.forward_quantizer_matrix[88].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[89].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[90].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[91].into(), 24, 31);
out[25] = __gen_uint(self.forward_quantizer_matrix[92].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[93].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[94].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[95].into(), 24, 31);
out[26] = __gen_uint(self.forward_quantizer_matrix[96].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[97].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[98].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[99].into(), 24, 31);
out[27] = __gen_uint(self.forward_quantizer_matrix[100].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[101].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[102].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[103].into(), 24, 31);
out[28] = __gen_uint(self.forward_quantizer_matrix[104].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[105].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[106].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[107].into(), 24, 31);
out[29] = __gen_uint(self.forward_quantizer_matrix[108].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[109].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[110].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[111].into(), 24, 31);
out[30] = __gen_uint(self.forward_quantizer_matrix[112].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[113].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[114].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[115].into(), 24, 31);
out[31] = __gen_uint(self.forward_quantizer_matrix[116].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[117].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[118].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[119].into(), 24, 31);
out[32] = __gen_uint(self.forward_quantizer_matrix[120].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[121].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[122].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[123].into(), 24, 31);
out[33] = __gen_uint(self.forward_quantizer_matrix[124].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[125].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[126].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[127].into(), 24, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 34];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 34] as *const [u8; 136]) })
}
}
impl From<&[u32; 34]> for MfxFqmState {
fn from(input: &[u32; 34]) -> Self {
MfxFqmState {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
avc: __gen_unuint(input[1], 0, 1),
mpeg2: __gen_unuint(input[1], 0, 1),
forward_quantizer_matrix: [
(__gen_unuint(input[2], 0, 7)) as u8,
(__gen_unuint(input[2], 8, 15)) as u8,
(__gen_unuint(input[2], 16, 23)) as u8,
(__gen_unuint(input[2], 24, 31)) as u8,
(__gen_unuint(input[3], 0, 7)) as u8,
(__gen_unuint(input[3], 8, 15)) as u8,
(__gen_unuint(input[3], 16, 23)) as u8,
(__gen_unuint(input[3], 24, 31)) as u8,
(__gen_unuint(input[4], 0, 7)) as u8,
(__gen_unuint(input[4], 8, 15)) as u8,
(__gen_unuint(input[4], 16, 23)) as u8,
(__gen_unuint(input[4], 24, 31)) as u8,
(__gen_unuint(input[5], 0, 7)) as u8,
(__gen_unuint(input[5], 8, 15)) as u8,
(__gen_unuint(input[5], 16, 23)) as u8,
(__gen_unuint(input[5], 24, 31)) as u8,
(__gen_unuint(input[6], 0, 7)) as u8,
(__gen_unuint(input[6], 8, 15)) as u8,
(__gen_unuint(input[6], 16, 23)) as u8,
(__gen_unuint(input[6], 24, 31)) as u8,
(__gen_unuint(input[7], 0, 7)) as u8,
(__gen_unuint(input[7], 8, 15)) as u8,
(__gen_unuint(input[7], 16, 23)) as u8,
(__gen_unuint(input[7], 24, 31)) as u8,
(__gen_unuint(input[8], 0, 7)) as u8,
(__gen_unuint(input[8], 8, 15)) as u8,
(__gen_unuint(input[8], 16, 23)) as u8,
(__gen_unuint(input[8], 24, 31)) as u8,
(__gen_unuint(input[9], 0, 7)) as u8,
(__gen_unuint(input[9], 8, 15)) as u8,
(__gen_unuint(input[9], 16, 23)) as u8,
(__gen_unuint(input[9], 24, 31)) as u8,
(__gen_unuint(input[10], 0, 7)) as u8,
(__gen_unuint(input[10], 8, 15)) as u8,
(__gen_unuint(input[10], 16, 23)) as u8,
(__gen_unuint(input[10], 24, 31)) as u8,
(__gen_unuint(input[11], 0, 7)) as u8,
(__gen_unuint(input[11], 8, 15)) as u8,
(__gen_unuint(input[11], 16, 23)) as u8,
(__gen_unuint(input[11], 24, 31)) as u8,
(__gen_unuint(input[12], 0, 7)) as u8,
(__gen_unuint(input[12], 8, 15)) as u8,
(__gen_unuint(input[12], 16, 23)) as u8,
(__gen_unuint(input[12], 24, 31)) as u8,
(__gen_unuint(input[13], 0, 7)) as u8,
(__gen_unuint(input[13], 8, 15)) as u8,
(__gen_unuint(input[13], 16, 23)) as u8,
(__gen_unuint(input[13], 24, 31)) as u8,
(__gen_unuint(input[14], 0, 7)) as u8,
(__gen_unuint(input[14], 8, 15)) as u8,
(__gen_unuint(input[14], 16, 23)) as u8,
(__gen_unuint(input[14], 24, 31)) as u8,
(__gen_unuint(input[15], 0, 7)) as u8,
(__gen_unuint(input[15], 8, 15)) as u8,
(__gen_unuint(input[15], 16, 23)) as u8,
(__gen_unuint(input[15], 24, 31)) as u8,
(__gen_unuint(input[16], 0, 7)) as u8,
(__gen_unuint(input[16], 8, 15)) as u8,
(__gen_unuint(input[16], 16, 23)) as u8,
(__gen_unuint(input[16], 24, 31)) as u8,
(__gen_unuint(input[17], 0, 7)) as u8,
(__gen_unuint(input[17], 8, 15)) as u8,
(__gen_unuint(input[17], 16, 23)) as u8,
(__gen_unuint(input[17], 24, 31)) as u8,
(__gen_unuint(input[18], 0, 7)) as u8,
(__gen_unuint(input[18], 8, 15)) as u8,
(__gen_unuint(input[18], 16, 23)) as u8,
(__gen_unuint(input[18], 24, 31)) as u8,
(__gen_unuint(input[19], 0, 7)) as u8,
(__gen_unuint(input[19], 8, 15)) as u8,
(__gen_unuint(input[19], 16, 23)) as u8,
(__gen_unuint(input[19], 24, 31)) as u8,
(__gen_unuint(input[20], 0, 7)) as u8,
(__gen_unuint(input[20], 8, 15)) as u8,
(__gen_unuint(input[20], 16, 23)) as u8,
(__gen_unuint(input[20], 24, 31)) as u8,
(__gen_unuint(input[21], 0, 7)) as u8,
(__gen_unuint(input[21], 8, 15)) as u8,
(__gen_unuint(input[21], 16, 23)) as u8,
(__gen_unuint(input[21], 24, 31)) as u8,
(__gen_unuint(input[22], 0, 7)) as u8,
(__gen_unuint(input[22], 8, 15)) as u8,
(__gen_unuint(input[22], 16, 23)) as u8,
(__gen_unuint(input[22], 24, 31)) as u8,
(__gen_unuint(input[23], 0, 7)) as u8,
(__gen_unuint(input[23], 8, 15)) as u8,
(__gen_unuint(input[23], 16, 23)) as u8,
(__gen_unuint(input[23], 24, 31)) as u8,
(__gen_unuint(input[24], 0, 7)) as u8,
(__gen_unuint(input[24], 8, 15)) as u8,
(__gen_unuint(input[24], 16, 23)) as u8,
(__gen_unuint(input[24], 24, 31)) as u8,
(__gen_unuint(input[25], 0, 7)) as u8,
(__gen_unuint(input[25], 8, 15)) as u8,
(__gen_unuint(input[25], 16, 23)) as u8,
(__gen_unuint(input[25], 24, 31)) as u8,
(__gen_unuint(input[26], 0, 7)) as u8,
(__gen_unuint(input[26], 8, 15)) as u8,
(__gen_unuint(input[26], 16, 23)) as u8,
(__gen_unuint(input[26], 24, 31)) as u8,
(__gen_unuint(input[27], 0, 7)) as u8,
(__gen_unuint(input[27], 8, 15)) as u8,
(__gen_unuint(input[27], 16, 23)) as u8,
(__gen_unuint(input[27], 24, 31)) as u8,
(__gen_unuint(input[28], 0, 7)) as u8,
(__gen_unuint(input[28], 8, 15)) as u8,
(__gen_unuint(input[28], 16, 23)) as u8,
(__gen_unuint(input[28], 24, 31)) as u8,
(__gen_unuint(input[29], 0, 7)) as u8,
(__gen_unuint(input[29], 8, 15)) as u8,
(__gen_unuint(input[29], 16, 23)) as u8,
(__gen_unuint(input[29], 24, 31)) as u8,
(__gen_unuint(input[30], 0, 7)) as u8,
(__gen_unuint(input[30], 8, 15)) as u8,
(__gen_unuint(input[30], 16, 23)) as u8,
(__gen_unuint(input[30], 24, 31)) as u8,
(__gen_unuint(input[31], 0, 7)) as u8,
(__gen_unuint(input[31], 8, 15)) as u8,
(__gen_unuint(input[31], 16, 23)) as u8,
(__gen_unuint(input[31], 24, 31)) as u8,
(__gen_unuint(input[32], 0, 7)) as u8,
(__gen_unuint(input[32], 8, 15)) as u8,
(__gen_unuint(input[32], 16, 23)) as u8,
(__gen_unuint(input[32], 24, 31)) as u8,
(__gen_unuint(input[33], 0, 7)) as u8,
(__gen_unuint(input[33], 8, 15)) as u8,
(__gen_unuint(input[33], 16, 23)) as u8,
(__gen_unuint(input[33], 24, 31)) as u8
],
}
}
}
impl Deserialize for MfxFqmState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 34];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 34] as *mut [u8; 136]) })?;
Ok((&input).into())
}
}
pub struct MfxIndObjBaseAddrState<A: Addr + Default> {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub mfx_indirect_bitstream_object_cacheability_control: u32,
pub mfx_indirect_bitstream_object_graphics_data_type: u32,
pub mfx_indirect_bitstream_object_arbitration_priority_control: u32,
pub mfx_indirect_bitstream_object_address: A,
pub mfx_indirect_bitstream_object_access_upper_bound: A,
pub mfx_indirect_mv_object_cacheability_control: u32,
pub mfx_indirect_mv_object_graphics_data_type: u32,
pub mfx_indirect_mv_object_arbitration_priority_control: u32,
pub mfx_indirect_mv_object_address: A,
pub mfx_indirect_mv_object_access_upper_bound: A,
pub mfd_indirect_it_coeff_object_cacheability_control: u32,
pub mfd_indirect_it_coeff_object_graphics_data_type: u32,
pub mfd_indirect_it_coeff_object_arbitration_priority_control: u32,
pub mfd_indirect_it_coeff_object_address: A,
pub mfd_indirect_it_coeff_object_access_upper_bound: A,
pub mfd_indirect_it_dblk_object_cacheability_control: u32,
pub mfd_indirect_it_dblk_object_graphics_data_type: u32,
pub mfd_indirect_it_dblk_object_arbitration_priority_control: u32,
pub mfd_indirect_it_dblk_object_address: A,
pub mfd_indirect_it_dblk_object_access_upper_bound: A,
pub mfc_indirect_pak_bse_object_cacheability_control: u32,
pub mfc_indirect_pak_bse_object_graphics_data_type: u32,
pub mfc_indirect_pak_bse_object_arbitration_priority_control: u32,
pub mfc_indirect_pak_bse_object_address: A,
pub mfc_indirect_pak_bse_object_access_upper_bound: A,
}
impl<A: Addr + Default> MfxIndObjBaseAddrState<A> {
pub const DWORD_LENGTH: u32 = 11;
pub const BOTH_LLC_AND_MLC: u32 = 3;
pub const FROM_GTT_ENTRY: u32 = 0;
pub const GTT_ENTRY: u32 = 0;
pub const HIGHEST_PRIORITY: u32 = 0;
pub const IN_LLC_BUT_NOT_MLC: u32 = 2;
pub const LOWEST_PRIORITY: u32 = 3;
pub const NOT_CACHED_IN_LLC_OR_MLC: u32 = 1;
pub const NOT_IN_LLC_OR_MLC: u32 = 1;
pub const SECOND_HIGHEST_PRIORITY: u32 = 1;
pub const THIRD_HIGHEST_PRIORITY: u32 = 2;
}
impl<A: Addr + Default> Default for MfxIndObjBaseAddrState<A> {
fn default() -> Self {
MfxIndObjBaseAddrState {
dword_length: 9,
subopcode_b: 3,
subopcode_a: 0,
media_command_opcode: 0,
pipeline: 2,
command_type: 3,
mfx_indirect_bitstream_object_cacheability_control: Default::default(),
mfx_indirect_bitstream_object_graphics_data_type: Default::default(),
mfx_indirect_bitstream_object_arbitration_priority_control: Default::default(),
mfx_indirect_bitstream_object_address: Default::default(),
mfx_indirect_bitstream_object_access_upper_bound: Default::default(),
mfx_indirect_mv_object_cacheability_control: Default::default(),
mfx_indirect_mv_object_graphics_data_type: Default::default(),
mfx_indirect_mv_object_arbitration_priority_control: Default::default(),
mfx_indirect_mv_object_address: Default::default(),
mfx_indirect_mv_object_access_upper_bound: Default::default(),
mfd_indirect_it_coeff_object_cacheability_control: Default::default(),
mfd_indirect_it_coeff_object_graphics_data_type: Default::default(),
mfd_indirect_it_coeff_object_arbitration_priority_control: Default::default(),
mfd_indirect_it_coeff_object_address: Default::default(),
mfd_indirect_it_coeff_object_access_upper_bound: Default::default(),
mfd_indirect_it_dblk_object_cacheability_control: Default::default(),
mfd_indirect_it_dblk_object_graphics_data_type: Default::default(),
mfd_indirect_it_dblk_object_arbitration_priority_control: Default::default(),
mfd_indirect_it_dblk_object_address: Default::default(),
mfd_indirect_it_dblk_object_access_upper_bound: Default::default(),
mfc_indirect_pak_bse_object_cacheability_control: Default::default(),
mfc_indirect_pak_bse_object_graphics_data_type: Default::default(),
mfc_indirect_pak_bse_object_arbitration_priority_control: Default::default(),
mfc_indirect_pak_bse_object_address: Default::default(),
mfc_indirect_pak_bse_object_access_upper_bound: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for MfxIndObjBaseAddrState<A> {
type Out = [u32; 11];
fn pack_into(&self, out: &mut [u32; 11]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
let v1 = __gen_uint(self.mfx_indirect_bitstream_object_cacheability_control, 0, 1) |
__gen_uint(self.mfx_indirect_bitstream_object_graphics_data_type, 2, 2) |
__gen_uint(self.mfx_indirect_bitstream_object_arbitration_priority_control, 4, 5);
let v1_address = self.mfx_indirect_bitstream_object_address.combine(v1);
out[1] = v1_address as u32;
out[2] = (v1_address >> 32) as u32;
let v2_address = self.mfx_indirect_bitstream_object_access_upper_bound.combine(0);
out[2] = v2_address as u32;
out[3] = (v2_address >> 32) as u32;
let v3 = __gen_uint(self.mfx_indirect_mv_object_cacheability_control, 0, 1) |
__gen_uint(self.mfx_indirect_mv_object_graphics_data_type, 2, 2) |
__gen_uint(self.mfx_indirect_mv_object_arbitration_priority_control, 4, 5);
let v3_address = self.mfx_indirect_mv_object_address.combine(v3);
out[3] = v3_address as u32;
out[4] = (v3_address >> 32) as u32;
let v4_address = self.mfx_indirect_mv_object_access_upper_bound.combine(0);
out[4] = v4_address as u32;
out[5] = (v4_address >> 32) as u32;
let v5 = __gen_uint(self.mfd_indirect_it_coeff_object_cacheability_control, 0, 1) |
__gen_uint(self.mfd_indirect_it_coeff_object_graphics_data_type, 2, 2) |
__gen_uint(self.mfd_indirect_it_coeff_object_arbitration_priority_control, 4, 5);
let v5_address = self.mfd_indirect_it_coeff_object_address.combine(v5);
out[5] = v5_address as u32;
out[6] = (v5_address >> 32) as u32;
let v6_address = self.mfd_indirect_it_coeff_object_access_upper_bound.combine(0);
out[6] = v6_address as u32;
out[7] = (v6_address >> 32) as u32;
let v7 = __gen_uint(self.mfd_indirect_it_dblk_object_cacheability_control, 0, 1) |
__gen_uint(self.mfd_indirect_it_dblk_object_graphics_data_type, 2, 2) |
__gen_uint(self.mfd_indirect_it_dblk_object_arbitration_priority_control, 4, 5);
let v7_address = self.mfd_indirect_it_dblk_object_address.combine(v7);
out[7] = v7_address as u32;
out[8] = (v7_address >> 32) as u32;
let v8_address = self.mfd_indirect_it_dblk_object_access_upper_bound.combine(0);
out[8] = v8_address as u32;
out[9] = (v8_address >> 32) as u32;
let v9 = __gen_uint(self.mfc_indirect_pak_bse_object_cacheability_control, 0, 1) |
__gen_uint(self.mfc_indirect_pak_bse_object_graphics_data_type, 2, 2) |
__gen_uint(self.mfc_indirect_pak_bse_object_arbitration_priority_control, 4, 5);
let v9_address = self.mfc_indirect_pak_bse_object_address.combine(v9);
out[9] = v9_address as u32;
out[10] = (v9_address >> 32) as u32;
let v10_address = self.mfc_indirect_pak_bse_object_access_upper_bound.combine(0);
out[10] = v10_address as u32;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 11];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 11] as *const [u8; 44]) })
}
}
impl From<&[u32; 11]> for MfxIndObjBaseAddrState<u64> {
fn from(input: &[u32; 11]) -> Self {
MfxIndObjBaseAddrState {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
mfx_indirect_bitstream_object_cacheability_control: __gen_unuint(input[1], 0, 1),
mfx_indirect_bitstream_object_graphics_data_type: __gen_unuint(input[1], 2, 2),
mfx_indirect_bitstream_object_arbitration_priority_control: __gen_unuint(input[1], 4, 5),
mfx_indirect_bitstream_object_address: (__gen_unuint(input[1], 12, 31) as u64) << 12,
mfx_indirect_bitstream_object_access_upper_bound: (__gen_unuint(input[2], 12, 31) as u64) << 12,
mfx_indirect_mv_object_cacheability_control: __gen_unuint(input[3], 0, 1),
mfx_indirect_mv_object_graphics_data_type: __gen_unuint(input[3], 2, 2),
mfx_indirect_mv_object_arbitration_priority_control: __gen_unuint(input[3], 4, 5),
mfx_indirect_mv_object_address: (__gen_unuint(input[3], 12, 31) as u64) << 12,
mfx_indirect_mv_object_access_upper_bound: (__gen_unuint(input[4], 12, 31) as u64) << 12,
mfd_indirect_it_coeff_object_cacheability_control: __gen_unuint(input[5], 0, 1),
mfd_indirect_it_coeff_object_graphics_data_type: __gen_unuint(input[5], 2, 2),
mfd_indirect_it_coeff_object_arbitration_priority_control: __gen_unuint(input[5], 4, 5),
mfd_indirect_it_coeff_object_address: (__gen_unuint(input[5], 12, 31) as u64) << 12,
mfd_indirect_it_coeff_object_access_upper_bound: (__gen_unuint(input[6], 12, 31) as u64) << 12,
mfd_indirect_it_dblk_object_cacheability_control: __gen_unuint(input[7], 0, 1),
mfd_indirect_it_dblk_object_graphics_data_type: __gen_unuint(input[7], 2, 2),
mfd_indirect_it_dblk_object_arbitration_priority_control: __gen_unuint(input[7], 4, 5),
mfd_indirect_it_dblk_object_address: (__gen_unuint(input[7], 12, 31) as u64) << 12,
mfd_indirect_it_dblk_object_access_upper_bound: (__gen_unuint(input[8], 12, 31) as u64) << 12,
mfc_indirect_pak_bse_object_cacheability_control: __gen_unuint(input[9], 0, 1),
mfc_indirect_pak_bse_object_graphics_data_type: __gen_unuint(input[9], 2, 2),
mfc_indirect_pak_bse_object_arbitration_priority_control: __gen_unuint(input[9], 4, 5),
mfc_indirect_pak_bse_object_address: (__gen_unuint(input[9], 12, 31) as u64) << 12,
mfc_indirect_pak_bse_object_access_upper_bound: (__gen_unuint(input[10], 12, 31) as u64) << 12,
}
}
}
impl Deserialize for MfxIndObjBaseAddrState<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 11];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 11] as *mut [u8; 44]) })?;
Ok((&input).into())
}
}
pub struct MfxJpegHuffTableState {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub huffman_table_id: u32,
pub dc_bits: [u32; 12],
pub dc_huffval: [u32; 12],
pub ac_bits: [u32; 16],
pub ac_huffval: [u32; 160],
pub ac_huffval2: [u32; 2],
}
impl MfxJpegHuffTableState {
pub const DWORD_LENGTH: u32 = 831;
}
impl Default for MfxJpegHuffTableState {
fn default() -> Self {
MfxJpegHuffTableState {
dword_length: 829,
subopcode_b: 2,
subopcode_a: 0,
media_command_opcode: 7,
pipeline: 2,
command_type: 3,
huffman_table_id: Default::default(),
dc_bits: Default::default(),
dc_huffval: Default::default(),
ac_bits: Default::default(),
ac_huffval: [0; 160],
ac_huffval2: Default::default(),
}
}
}
impl Serialize for MfxJpegHuffTableState {
type Out = [u32; 831];
fn pack_into(&self, out: &mut [u32; 831]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.huffman_table_id, 0, 0);
out[2] = __gen_uint(self.dc_bits[0], 0, 7) |
__gen_uint(self.dc_bits[1], 8, 15) |
__gen_uint(self.dc_bits[2], 16, 23) |
__gen_uint(self.dc_bits[3], 24, 31);
out[3] = __gen_uint(self.dc_bits[4], 0, 7) |
__gen_uint(self.dc_bits[5], 8, 15) |
__gen_uint(self.dc_bits[6], 16, 23) |
__gen_uint(self.dc_bits[7], 24, 31);
out[4] = __gen_uint(self.dc_bits[8], 0, 7) |
__gen_uint(self.dc_bits[9], 8, 15) |
__gen_uint(self.dc_bits[10], 16, 23) |
__gen_uint(self.dc_bits[11], 24, 31);
out[5] = __gen_uint(self.dc_huffval[0], 0, 7) |
__gen_uint(self.dc_huffval[1], 8, 15) |
__gen_uint(self.dc_huffval[2], 16, 23) |
__gen_uint(self.dc_huffval[3], 24, 31);
out[6] = __gen_uint(self.dc_huffval[4], 0, 7) |
__gen_uint(self.dc_huffval[5], 8, 15) |
__gen_uint(self.dc_huffval[6], 16, 23) |
__gen_uint(self.dc_huffval[7], 24, 31);
out[7] = __gen_uint(self.dc_huffval[8], 0, 7) |
__gen_uint(self.dc_huffval[9], 8, 15) |
__gen_uint(self.dc_huffval[10], 16, 23) |
__gen_uint(self.dc_huffval[11], 24, 31);
out[8] = __gen_uint(self.ac_bits[0], 0, 7) |
__gen_uint(self.ac_bits[1], 8, 15) |
__gen_uint(self.ac_bits[2], 16, 23) |
__gen_uint(self.ac_bits[3], 24, 31);
out[9] = __gen_uint(self.ac_bits[4], 0, 7) |
__gen_uint(self.ac_bits[5], 8, 15) |
__gen_uint(self.ac_bits[6], 16, 23) |
__gen_uint(self.ac_bits[7], 24, 31);
out[10] = __gen_uint(self.ac_bits[8], 0, 7) |
__gen_uint(self.ac_bits[9], 8, 15) |
__gen_uint(self.ac_bits[10], 16, 23) |
__gen_uint(self.ac_bits[11], 24, 31);
out[11] = __gen_uint(self.ac_bits[12], 0, 7) |
__gen_uint(self.ac_bits[13], 8, 15) |
__gen_uint(self.ac_bits[14], 16, 23) |
__gen_uint(self.ac_bits[15], 24, 31);
out[12] = __gen_uint(self.ac_huffval[0], 0, 7) |
__gen_uint(self.ac_huffval[1], 8, 15) |
__gen_uint(self.ac_huffval[2], 16, 23) |
__gen_uint(self.ac_huffval[3], 24, 31);
out[13] = __gen_uint(self.ac_huffval[4], 0, 7) |
__gen_uint(self.ac_huffval[5], 8, 15) |
__gen_uint(self.ac_huffval[6], 16, 23) |
__gen_uint(self.ac_huffval[7], 24, 31);
out[14] = __gen_uint(self.ac_huffval[8], 0, 7) |
__gen_uint(self.ac_huffval[9], 8, 15) |
__gen_uint(self.ac_huffval[10], 16, 23) |
__gen_uint(self.ac_huffval[11], 24, 31);
out[15] = __gen_uint(self.ac_huffval[12], 0, 7) |
__gen_uint(self.ac_huffval[13], 8, 15) |
__gen_uint(self.ac_huffval[14], 16, 23) |
__gen_uint(self.ac_huffval[15], 24, 31);
out[16] = __gen_uint(self.ac_huffval[16], 0, 7) |
__gen_uint(self.ac_huffval[17], 8, 15) |
__gen_uint(self.ac_huffval[18], 16, 23) |
__gen_uint(self.ac_huffval[19], 24, 31);
out[17] = __gen_uint(self.ac_huffval[20], 0, 7) |
__gen_uint(self.ac_huffval[21], 8, 15) |
__gen_uint(self.ac_huffval[22], 16, 23) |
__gen_uint(self.ac_huffval[23], 24, 31);
out[18] = __gen_uint(self.ac_huffval[24], 0, 7) |
__gen_uint(self.ac_huffval[25], 8, 15) |
__gen_uint(self.ac_huffval[26], 16, 23) |
__gen_uint(self.ac_huffval[27], 24, 31);
out[19] = __gen_uint(self.ac_huffval[28], 0, 7) |
__gen_uint(self.ac_huffval[29], 8, 15) |
__gen_uint(self.ac_huffval[30], 16, 23) |
__gen_uint(self.ac_huffval[31], 24, 31);
out[20] = __gen_uint(self.ac_huffval[32], 0, 7) |
__gen_uint(self.ac_huffval[33], 8, 15) |
__gen_uint(self.ac_huffval[34], 16, 23) |
__gen_uint(self.ac_huffval[35], 24, 31);
out[21] = __gen_uint(self.ac_huffval[36], 0, 7) |
__gen_uint(self.ac_huffval[37], 8, 15) |
__gen_uint(self.ac_huffval[38], 16, 23) |
__gen_uint(self.ac_huffval[39], 24, 31);
out[22] = __gen_uint(self.ac_huffval[40], 0, 7) |
__gen_uint(self.ac_huffval[41], 8, 15) |
__gen_uint(self.ac_huffval[42], 16, 23) |
__gen_uint(self.ac_huffval[43], 24, 31);
out[23] = __gen_uint(self.ac_huffval[44], 0, 7) |
__gen_uint(self.ac_huffval[45], 8, 15) |
__gen_uint(self.ac_huffval[46], 16, 23) |
__gen_uint(self.ac_huffval[47], 24, 31);
out[24] = __gen_uint(self.ac_huffval[48], 0, 7) |
__gen_uint(self.ac_huffval[49], 8, 15) |
__gen_uint(self.ac_huffval[50], 16, 23) |
__gen_uint(self.ac_huffval[51], 24, 31);
out[25] = __gen_uint(self.ac_huffval[52], 0, 7) |
__gen_uint(self.ac_huffval[53], 8, 15) |
__gen_uint(self.ac_huffval[54], 16, 23) |
__gen_uint(self.ac_huffval[55], 24, 31);
out[26] = __gen_uint(self.ac_huffval[56], 0, 7) |
__gen_uint(self.ac_huffval[57], 8, 15) |
__gen_uint(self.ac_huffval[58], 16, 23) |
__gen_uint(self.ac_huffval[59], 24, 31);
out[27] = __gen_uint(self.ac_huffval[60], 0, 7) |
__gen_uint(self.ac_huffval[61], 8, 15) |
__gen_uint(self.ac_huffval[62], 16, 23) |
__gen_uint(self.ac_huffval[63], 24, 31);
out[28] = __gen_uint(self.ac_huffval[64], 0, 7) |
__gen_uint(self.ac_huffval[65], 8, 15) |
__gen_uint(self.ac_huffval[66], 16, 23) |
__gen_uint(self.ac_huffval[67], 24, 31);
out[29] = __gen_uint(self.ac_huffval[68], 0, 7) |
__gen_uint(self.ac_huffval[69], 8, 15) |
__gen_uint(self.ac_huffval[70], 16, 23) |
__gen_uint(self.ac_huffval[71], 24, 31);
out[30] = __gen_uint(self.ac_huffval[72], 0, 7) |
__gen_uint(self.ac_huffval[73], 8, 15) |
__gen_uint(self.ac_huffval[74], 16, 23) |
__gen_uint(self.ac_huffval[75], 24, 31);
out[31] = __gen_uint(self.ac_huffval[76], 0, 7) |
__gen_uint(self.ac_huffval[77], 8, 15) |
__gen_uint(self.ac_huffval[78], 16, 23) |
__gen_uint(self.ac_huffval[79], 24, 31);
out[32] = __gen_uint(self.ac_huffval[80], 0, 7) |
__gen_uint(self.ac_huffval[81], 8, 15) |
__gen_uint(self.ac_huffval[82], 16, 23) |
__gen_uint(self.ac_huffval[83], 24, 31);
out[33] = __gen_uint(self.ac_huffval[84], 0, 7) |
__gen_uint(self.ac_huffval[85], 8, 15) |
__gen_uint(self.ac_huffval[86], 16, 23) |
__gen_uint(self.ac_huffval[87], 24, 31);
out[34] = __gen_uint(self.ac_huffval[88], 0, 7) |
__gen_uint(self.ac_huffval[89], 8, 15) |
__gen_uint(self.ac_huffval[90], 16, 23) |
__gen_uint(self.ac_huffval[91], 24, 31);
out[35] = __gen_uint(self.ac_huffval[92], 0, 7) |
__gen_uint(self.ac_huffval[93], 8, 15) |
__gen_uint(self.ac_huffval[94], 16, 23) |
__gen_uint(self.ac_huffval[95], 24, 31);
out[36] = __gen_uint(self.ac_huffval[96], 0, 7) |
__gen_uint(self.ac_huffval[97], 8, 15) |
__gen_uint(self.ac_huffval[98], 16, 23) |
__gen_uint(self.ac_huffval[99], 24, 31);
out[37] = __gen_uint(self.ac_huffval[100], 0, 7) |
__gen_uint(self.ac_huffval[101], 8, 15) |
__gen_uint(self.ac_huffval[102], 16, 23) |
__gen_uint(self.ac_huffval[103], 24, 31);
out[38] = __gen_uint(self.ac_huffval[104], 0, 7) |
__gen_uint(self.ac_huffval[105], 8, 15) |
__gen_uint(self.ac_huffval[106], 16, 23) |
__gen_uint(self.ac_huffval[107], 24, 31);
out[39] = __gen_uint(self.ac_huffval[108], 0, 7) |
__gen_uint(self.ac_huffval[109], 8, 15) |
__gen_uint(self.ac_huffval[110], 16, 23) |
__gen_uint(self.ac_huffval[111], 24, 31);
out[40] = __gen_uint(self.ac_huffval[112], 0, 7) |
__gen_uint(self.ac_huffval[113], 8, 15) |
__gen_uint(self.ac_huffval[114], 16, 23) |
__gen_uint(self.ac_huffval[115], 24, 31);
out[41] = __gen_uint(self.ac_huffval[116], 0, 7) |
__gen_uint(self.ac_huffval[117], 8, 15) |
__gen_uint(self.ac_huffval[118], 16, 23) |
__gen_uint(self.ac_huffval[119], 24, 31);
out[42] = __gen_uint(self.ac_huffval[120], 0, 7) |
__gen_uint(self.ac_huffval[121], 8, 15) |
__gen_uint(self.ac_huffval[122], 16, 23) |
__gen_uint(self.ac_huffval[123], 24, 31);
out[43] = __gen_uint(self.ac_huffval[124], 0, 7) |
__gen_uint(self.ac_huffval[125], 8, 15) |
__gen_uint(self.ac_huffval[126], 16, 23) |
__gen_uint(self.ac_huffval[127], 24, 31);
out[44] = __gen_uint(self.ac_huffval[128], 0, 7) |
__gen_uint(self.ac_huffval[129], 8, 15) |
__gen_uint(self.ac_huffval[130], 16, 23) |
__gen_uint(self.ac_huffval[131], 24, 31);
out[45] = __gen_uint(self.ac_huffval[132], 0, 7) |
__gen_uint(self.ac_huffval[133], 8, 15) |
__gen_uint(self.ac_huffval[134], 16, 23) |
__gen_uint(self.ac_huffval[135], 24, 31);
out[46] = __gen_uint(self.ac_huffval[136], 0, 7) |
__gen_uint(self.ac_huffval[137], 8, 15) |
__gen_uint(self.ac_huffval[138], 16, 23) |
__gen_uint(self.ac_huffval[139], 24, 31);
out[47] = __gen_uint(self.ac_huffval[140], 0, 7) |
__gen_uint(self.ac_huffval[141], 8, 15) |
__gen_uint(self.ac_huffval[142], 16, 23) |
__gen_uint(self.ac_huffval[143], 24, 31);
out[48] = __gen_uint(self.ac_huffval[144], 0, 7) |
__gen_uint(self.ac_huffval[145], 8, 15) |
__gen_uint(self.ac_huffval[146], 16, 23) |
__gen_uint(self.ac_huffval[147], 24, 31);
out[49] = __gen_uint(self.ac_huffval[148], 0, 7) |
__gen_uint(self.ac_huffval[149], 8, 15) |
__gen_uint(self.ac_huffval[150], 16, 23) |
__gen_uint(self.ac_huffval[151], 24, 31);
out[50] = __gen_uint(self.ac_huffval[152], 0, 7) |
__gen_uint(self.ac_huffval[153], 8, 15) |
__gen_uint(self.ac_huffval[154], 16, 23) |
__gen_uint(self.ac_huffval[155], 24, 31);
out[51] = __gen_uint(self.ac_huffval[156], 0, 7) |
__gen_uint(self.ac_huffval[157], 8, 15) |
__gen_uint(self.ac_huffval[158], 16, 23) |
__gen_uint(self.ac_huffval[159], 24, 31);
out[52] = __gen_uint(self.ac_huffval2[0], 0, 7) |
__gen_uint(self.ac_huffval2[1], 8, 15);
out[53] = 0;
out[54] = 0;
out[55] = 0;
out[56] = 0;
out[57] = 0;
out[58] = 0;
out[59] = 0;
out[60] = 0;
out[61] = 0;
out[62] = 0;
out[63] = 0;
out[64] = 0;
out[65] = 0;
out[66] = 0;
out[67] = 0;
out[68] = 0;
out[69] = 0;
out[70] = 0;
out[71] = 0;
out[72] = 0;
out[73] = 0;
out[74] = 0;
out[75] = 0;
out[76] = 0;
out[77] = 0;
out[78] = 0;
out[79] = 0;
out[80] = 0;
out[81] = 0;
out[82] = 0;
out[83] = 0;
out[84] = 0;
out[85] = 0;
out[86] = 0;
out[87] = 0;
out[88] = 0;
out[89] = 0;
out[90] = 0;
out[91] = 0;
out[92] = 0;
out[93] = 0;
out[94] = 0;
out[95] = 0;
out[96] = 0;
out[97] = 0;
out[98] = 0;
out[99] = 0;
out[100] = 0;
out[101] = 0;
out[102] = 0;
out[103] = 0;
out[104] = 0;
out[105] = 0;
out[106] = 0;
out[107] = 0;
out[108] = 0;
out[109] = 0;
out[110] = 0;
out[111] = 0;
out[112] = 0;
out[113] = 0;
out[114] = 0;
out[115] = 0;
out[116] = 0;
out[117] = 0;
out[118] = 0;
out[119] = 0;
out[120] = 0;
out[121] = 0;
out[122] = 0;
out[123] = 0;
out[124] = 0;
out[125] = 0;
out[126] = 0;
out[127] = 0;
out[128] = 0;
out[129] = 0;
out[130] = 0;
out[131] = 0;
out[132] = 0;
out[133] = 0;
out[134] = 0;
out[135] = 0;
out[136] = 0;
out[137] = 0;
out[138] = 0;
out[139] = 0;
out[140] = 0;
out[141] = 0;
out[142] = 0;
out[143] = 0;
out[144] = 0;
out[145] = 0;
out[146] = 0;
out[147] = 0;
out[148] = 0;
out[149] = 0;
out[150] = 0;
out[151] = 0;
out[152] = 0;
out[153] = 0;
out[154] = 0;
out[155] = 0;
out[156] = 0;
out[157] = 0;
out[158] = 0;
out[159] = 0;
out[160] = 0;
out[161] = 0;
out[162] = 0;
out[163] = 0;
out[164] = 0;
out[165] = 0;
out[166] = 0;
out[167] = 0;
out[168] = 0;
out[169] = 0;
out[170] = 0;
out[171] = 0;
out[172] = 0;
out[173] = 0;
out[174] = 0;
out[175] = 0;
out[176] = 0;
out[177] = 0;
out[178] = 0;
out[179] = 0;
out[180] = 0;
out[181] = 0;
out[182] = 0;
out[183] = 0;
out[184] = 0;
out[185] = 0;
out[186] = 0;
out[187] = 0;
out[188] = 0;
out[189] = 0;
out[190] = 0;
out[191] = 0;
out[192] = 0;
out[193] = 0;
out[194] = 0;
out[195] = 0;
out[196] = 0;
out[197] = 0;
out[198] = 0;
out[199] = 0;
out[200] = 0;
out[201] = 0;
out[202] = 0;
out[203] = 0;
out[204] = 0;
out[205] = 0;
out[206] = 0;
out[207] = 0;
out[208] = 0;
out[209] = 0;
out[210] = 0;
out[211] = 0;
out[212] = 0;
out[213] = 0;
out[214] = 0;
out[215] = 0;
out[216] = 0;
out[217] = 0;
out[218] = 0;
out[219] = 0;
out[220] = 0;
out[221] = 0;
out[222] = 0;
out[223] = 0;
out[224] = 0;
out[225] = 0;
out[226] = 0;
out[227] = 0;
out[228] = 0;
out[229] = 0;
out[230] = 0;
out[231] = 0;
out[232] = 0;
out[233] = 0;
out[234] = 0;
out[235] = 0;
out[236] = 0;
out[237] = 0;
out[238] = 0;
out[239] = 0;
out[240] = 0;
out[241] = 0;
out[242] = 0;
out[243] = 0;
out[244] = 0;
out[245] = 0;
out[246] = 0;
out[247] = 0;
out[248] = 0;
out[249] = 0;
out[250] = 0;
out[251] = 0;
out[252] = 0;
out[253] = 0;
out[254] = 0;
out[255] = 0;
out[256] = 0;
out[257] = 0;
out[258] = 0;
out[259] = 0;
out[260] = 0;
out[261] = 0;
out[262] = 0;
out[263] = 0;
out[264] = 0;
out[265] = 0;
out[266] = 0;
out[267] = 0;
out[268] = 0;
out[269] = 0;
out[270] = 0;
out[271] = 0;
out[272] = 0;
out[273] = 0;
out[274] = 0;
out[275] = 0;
out[276] = 0;
out[277] = 0;
out[278] = 0;
out[279] = 0;
out[280] = 0;
out[281] = 0;
out[282] = 0;
out[283] = 0;
out[284] = 0;
out[285] = 0;
out[286] = 0;
out[287] = 0;
out[288] = 0;
out[289] = 0;
out[290] = 0;
out[291] = 0;
out[292] = 0;
out[293] = 0;
out[294] = 0;
out[295] = 0;
out[296] = 0;
out[297] = 0;
out[298] = 0;
out[299] = 0;
out[300] = 0;
out[301] = 0;
out[302] = 0;
out[303] = 0;
out[304] = 0;
out[305] = 0;
out[306] = 0;
out[307] = 0;
out[308] = 0;
out[309] = 0;
out[310] = 0;
out[311] = 0;
out[312] = 0;
out[313] = 0;
out[314] = 0;
out[315] = 0;
out[316] = 0;
out[317] = 0;
out[318] = 0;
out[319] = 0;
out[320] = 0;
out[321] = 0;
out[322] = 0;
out[323] = 0;
out[324] = 0;
out[325] = 0;
out[326] = 0;
out[327] = 0;
out[328] = 0;
out[329] = 0;
out[330] = 0;
out[331] = 0;
out[332] = 0;
out[333] = 0;
out[334] = 0;
out[335] = 0;
out[336] = 0;
out[337] = 0;
out[338] = 0;
out[339] = 0;
out[340] = 0;
out[341] = 0;
out[342] = 0;
out[343] = 0;
out[344] = 0;
out[345] = 0;
out[346] = 0;
out[347] = 0;
out[348] = 0;
out[349] = 0;
out[350] = 0;
out[351] = 0;
out[352] = 0;
out[353] = 0;
out[354] = 0;
out[355] = 0;
out[356] = 0;
out[357] = 0;
out[358] = 0;
out[359] = 0;
out[360] = 0;
out[361] = 0;
out[362] = 0;
out[363] = 0;
out[364] = 0;
out[365] = 0;
out[366] = 0;
out[367] = 0;
out[368] = 0;
out[369] = 0;
out[370] = 0;
out[371] = 0;
out[372] = 0;
out[373] = 0;
out[374] = 0;
out[375] = 0;
out[376] = 0;
out[377] = 0;
out[378] = 0;
out[379] = 0;
out[380] = 0;
out[381] = 0;
out[382] = 0;
out[383] = 0;
out[384] = 0;
out[385] = 0;
out[386] = 0;
out[387] = 0;
out[388] = 0;
out[389] = 0;
out[390] = 0;
out[391] = 0;
out[392] = 0;
out[393] = 0;
out[394] = 0;
out[395] = 0;
out[396] = 0;
out[397] = 0;
out[398] = 0;
out[399] = 0;
out[400] = 0;
out[401] = 0;
out[402] = 0;
out[403] = 0;
out[404] = 0;
out[405] = 0;
out[406] = 0;
out[407] = 0;
out[408] = 0;
out[409] = 0;
out[410] = 0;
out[411] = 0;
out[412] = 0;
out[413] = 0;
out[414] = 0;
out[415] = 0;
out[416] = 0;
out[417] = 0;
out[418] = 0;
out[419] = 0;
out[420] = 0;
out[421] = 0;
out[422] = 0;
out[423] = 0;
out[424] = 0;
out[425] = 0;
out[426] = 0;
out[427] = 0;
out[428] = 0;
out[429] = 0;
out[430] = 0;
out[431] = 0;
out[432] = 0;
out[433] = 0;
out[434] = 0;
out[435] = 0;
out[436] = 0;
out[437] = 0;
out[438] = 0;
out[439] = 0;
out[440] = 0;
out[441] = 0;
out[442] = 0;
out[443] = 0;
out[444] = 0;
out[445] = 0;
out[446] = 0;
out[447] = 0;
out[448] = 0;
out[449] = 0;
out[450] = 0;
out[451] = 0;
out[452] = 0;
out[453] = 0;
out[454] = 0;
out[455] = 0;
out[456] = 0;
out[457] = 0;
out[458] = 0;
out[459] = 0;
out[460] = 0;
out[461] = 0;
out[462] = 0;
out[463] = 0;
out[464] = 0;
out[465] = 0;
out[466] = 0;
out[467] = 0;
out[468] = 0;
out[469] = 0;
out[470] = 0;
out[471] = 0;
out[472] = 0;
out[473] = 0;
out[474] = 0;
out[475] = 0;
out[476] = 0;
out[477] = 0;
out[478] = 0;
out[479] = 0;
out[480] = 0;
out[481] = 0;
out[482] = 0;
out[483] = 0;
out[484] = 0;
out[485] = 0;
out[486] = 0;
out[487] = 0;
out[488] = 0;
out[489] = 0;
out[490] = 0;
out[491] = 0;
out[492] = 0;
out[493] = 0;
out[494] = 0;
out[495] = 0;
out[496] = 0;
out[497] = 0;
out[498] = 0;
out[499] = 0;
out[500] = 0;
out[501] = 0;
out[502] = 0;
out[503] = 0;
out[504] = 0;
out[505] = 0;
out[506] = 0;
out[507] = 0;
out[508] = 0;
out[509] = 0;
out[510] = 0;
out[511] = 0;
out[512] = 0;
out[513] = 0;
out[514] = 0;
out[515] = 0;
out[516] = 0;
out[517] = 0;
out[518] = 0;
out[519] = 0;
out[520] = 0;
out[521] = 0;
out[522] = 0;
out[523] = 0;
out[524] = 0;
out[525] = 0;
out[526] = 0;
out[527] = 0;
out[528] = 0;
out[529] = 0;
out[530] = 0;
out[531] = 0;
out[532] = 0;
out[533] = 0;
out[534] = 0;
out[535] = 0;
out[536] = 0;
out[537] = 0;
out[538] = 0;
out[539] = 0;
out[540] = 0;
out[541] = 0;
out[542] = 0;
out[543] = 0;
out[544] = 0;
out[545] = 0;
out[546] = 0;
out[547] = 0;
out[548] = 0;
out[549] = 0;
out[550] = 0;
out[551] = 0;
out[552] = 0;
out[553] = 0;
out[554] = 0;
out[555] = 0;
out[556] = 0;
out[557] = 0;
out[558] = 0;
out[559] = 0;
out[560] = 0;
out[561] = 0;
out[562] = 0;
out[563] = 0;
out[564] = 0;
out[565] = 0;
out[566] = 0;
out[567] = 0;
out[568] = 0;
out[569] = 0;
out[570] = 0;
out[571] = 0;
out[572] = 0;
out[573] = 0;
out[574] = 0;
out[575] = 0;
out[576] = 0;
out[577] = 0;
out[578] = 0;
out[579] = 0;
out[580] = 0;
out[581] = 0;
out[582] = 0;
out[583] = 0;
out[584] = 0;
out[585] = 0;
out[586] = 0;
out[587] = 0;
out[588] = 0;
out[589] = 0;
out[590] = 0;
out[591] = 0;
out[592] = 0;
out[593] = 0;
out[594] = 0;
out[595] = 0;
out[596] = 0;
out[597] = 0;
out[598] = 0;
out[599] = 0;
out[600] = 0;
out[601] = 0;
out[602] = 0;
out[603] = 0;
out[604] = 0;
out[605] = 0;
out[606] = 0;
out[607] = 0;
out[608] = 0;
out[609] = 0;
out[610] = 0;
out[611] = 0;
out[612] = 0;
out[613] = 0;
out[614] = 0;
out[615] = 0;
out[616] = 0;
out[617] = 0;
out[618] = 0;
out[619] = 0;
out[620] = 0;
out[621] = 0;
out[622] = 0;
out[623] = 0;
out[624] = 0;
out[625] = 0;
out[626] = 0;
out[627] = 0;
out[628] = 0;
out[629] = 0;
out[630] = 0;
out[631] = 0;
out[632] = 0;
out[633] = 0;
out[634] = 0;
out[635] = 0;
out[636] = 0;
out[637] = 0;
out[638] = 0;
out[639] = 0;
out[640] = 0;
out[641] = 0;
out[642] = 0;
out[643] = 0;
out[644] = 0;
out[645] = 0;
out[646] = 0;
out[647] = 0;
out[648] = 0;
out[649] = 0;
out[650] = 0;
out[651] = 0;
out[652] = 0;
out[653] = 0;
out[654] = 0;
out[655] = 0;
out[656] = 0;
out[657] = 0;
out[658] = 0;
out[659] = 0;
out[660] = 0;
out[661] = 0;
out[662] = 0;
out[663] = 0;
out[664] = 0;
out[665] = 0;
out[666] = 0;
out[667] = 0;
out[668] = 0;
out[669] = 0;
out[670] = 0;
out[671] = 0;
out[672] = 0;
out[673] = 0;
out[674] = 0;
out[675] = 0;
out[676] = 0;
out[677] = 0;
out[678] = 0;
out[679] = 0;
out[680] = 0;
out[681] = 0;
out[682] = 0;
out[683] = 0;
out[684] = 0;
out[685] = 0;
out[686] = 0;
out[687] = 0;
out[688] = 0;
out[689] = 0;
out[690] = 0;
out[691] = 0;
out[692] = 0;
out[693] = 0;
out[694] = 0;
out[695] = 0;
out[696] = 0;
out[697] = 0;
out[698] = 0;
out[699] = 0;
out[700] = 0;
out[701] = 0;
out[702] = 0;
out[703] = 0;
out[704] = 0;
out[705] = 0;
out[706] = 0;
out[707] = 0;
out[708] = 0;
out[709] = 0;
out[710] = 0;
out[711] = 0;
out[712] = 0;
out[713] = 0;
out[714] = 0;
out[715] = 0;
out[716] = 0;
out[717] = 0;
out[718] = 0;
out[719] = 0;
out[720] = 0;
out[721] = 0;
out[722] = 0;
out[723] = 0;
out[724] = 0;
out[725] = 0;
out[726] = 0;
out[727] = 0;
out[728] = 0;
out[729] = 0;
out[730] = 0;
out[731] = 0;
out[732] = 0;
out[733] = 0;
out[734] = 0;
out[735] = 0;
out[736] = 0;
out[737] = 0;
out[738] = 0;
out[739] = 0;
out[740] = 0;
out[741] = 0;
out[742] = 0;
out[743] = 0;
out[744] = 0;
out[745] = 0;
out[746] = 0;
out[747] = 0;
out[748] = 0;
out[749] = 0;
out[750] = 0;
out[751] = 0;
out[752] = 0;
out[753] = 0;
out[754] = 0;
out[755] = 0;
out[756] = 0;
out[757] = 0;
out[758] = 0;
out[759] = 0;
out[760] = 0;
out[761] = 0;
out[762] = 0;
out[763] = 0;
out[764] = 0;
out[765] = 0;
out[766] = 0;
out[767] = 0;
out[768] = 0;
out[769] = 0;
out[770] = 0;
out[771] = 0;
out[772] = 0;
out[773] = 0;
out[774] = 0;
out[775] = 0;
out[776] = 0;
out[777] = 0;
out[778] = 0;
out[779] = 0;
out[780] = 0;
out[781] = 0;
out[782] = 0;
out[783] = 0;
out[784] = 0;
out[785] = 0;
out[786] = 0;
out[787] = 0;
out[788] = 0;
out[789] = 0;
out[790] = 0;
out[791] = 0;
out[792] = 0;
out[793] = 0;
out[794] = 0;
out[795] = 0;
out[796] = 0;
out[797] = 0;
out[798] = 0;
out[799] = 0;
out[800] = 0;
out[801] = 0;
out[802] = 0;
out[803] = 0;
out[804] = 0;
out[805] = 0;
out[806] = 0;
out[807] = 0;
out[808] = 0;
out[809] = 0;
out[810] = 0;
out[811] = 0;
out[812] = 0;
out[813] = 0;
out[814] = 0;
out[815] = 0;
out[816] = 0;
out[817] = 0;
out[818] = 0;
out[819] = 0;
out[820] = 0;
out[821] = 0;
out[822] = 0;
out[823] = 0;
out[824] = 0;
out[825] = 0;
out[826] = 0;
out[827] = 0;
out[828] = 0;
out[829] = 0;
out[830] = 0;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 831];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 831] as *const [u8; 3324]) })
}
}
impl From<&[u32; 831]> for MfxJpegHuffTableState {
fn from(input: &[u32; 831]) -> Self {
MfxJpegHuffTableState {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
huffman_table_id: __gen_unuint(input[1], 0, 0),
dc_bits: [
__gen_unuint(input[2], 0, 7),
__gen_unuint(input[2], 8, 15),
__gen_unuint(input[2], 16, 23),
__gen_unuint(input[2], 24, 31),
__gen_unuint(input[3], 0, 7),
__gen_unuint(input[3], 8, 15),
__gen_unuint(input[3], 16, 23),
__gen_unuint(input[3], 24, 31),
__gen_unuint(input[4], 0, 7),
__gen_unuint(input[4], 8, 15),
__gen_unuint(input[4], 16, 23),
__gen_unuint(input[4], 24, 31)
],
dc_huffval: [
__gen_unuint(input[5], 0, 7),
__gen_unuint(input[5], 8, 15),
__gen_unuint(input[5], 16, 23),
__gen_unuint(input[5], 24, 31),
__gen_unuint(input[6], 0, 7),
__gen_unuint(input[6], 8, 15),
__gen_unuint(input[6], 16, 23),
__gen_unuint(input[6], 24, 31),
__gen_unuint(input[7], 0, 7),
__gen_unuint(input[7], 8, 15),
__gen_unuint(input[7], 16, 23),
__gen_unuint(input[7], 24, 31)
],
ac_bits: [
__gen_unuint(input[8], 0, 7),
__gen_unuint(input[8], 8, 15),
__gen_unuint(input[8], 16, 23),
__gen_unuint(input[8], 24, 31),
__gen_unuint(input[9], 0, 7),
__gen_unuint(input[9], 8, 15),
__gen_unuint(input[9], 16, 23),
__gen_unuint(input[9], 24, 31),
__gen_unuint(input[10], 0, 7),
__gen_unuint(input[10], 8, 15),
__gen_unuint(input[10], 16, 23),
__gen_unuint(input[10], 24, 31),
__gen_unuint(input[11], 0, 7),
__gen_unuint(input[11], 8, 15),
__gen_unuint(input[11], 16, 23),
__gen_unuint(input[11], 24, 31)
],
ac_huffval: [
__gen_unuint(input[12], 0, 7),
__gen_unuint(input[12], 8, 15),
__gen_unuint(input[12], 16, 23),
__gen_unuint(input[12], 24, 31),
__gen_unuint(input[13], 0, 7),
__gen_unuint(input[13], 8, 15),
__gen_unuint(input[13], 16, 23),
__gen_unuint(input[13], 24, 31),
__gen_unuint(input[14], 0, 7),
__gen_unuint(input[14], 8, 15),
__gen_unuint(input[14], 16, 23),
__gen_unuint(input[14], 24, 31),
__gen_unuint(input[15], 0, 7),
__gen_unuint(input[15], 8, 15),
__gen_unuint(input[15], 16, 23),
__gen_unuint(input[15], 24, 31),
__gen_unuint(input[16], 0, 7),
__gen_unuint(input[16], 8, 15),
__gen_unuint(input[16], 16, 23),
__gen_unuint(input[16], 24, 31),
__gen_unuint(input[17], 0, 7),
__gen_unuint(input[17], 8, 15),
__gen_unuint(input[17], 16, 23),
__gen_unuint(input[17], 24, 31),
__gen_unuint(input[18], 0, 7),
__gen_unuint(input[18], 8, 15),
__gen_unuint(input[18], 16, 23),
__gen_unuint(input[18], 24, 31),
__gen_unuint(input[19], 0, 7),
__gen_unuint(input[19], 8, 15),
__gen_unuint(input[19], 16, 23),
__gen_unuint(input[19], 24, 31),
__gen_unuint(input[20], 0, 7),
__gen_unuint(input[20], 8, 15),
__gen_unuint(input[20], 16, 23),
__gen_unuint(input[20], 24, 31),
__gen_unuint(input[21], 0, 7),
__gen_unuint(input[21], 8, 15),
__gen_unuint(input[21], 16, 23),
__gen_unuint(input[21], 24, 31),
__gen_unuint(input[22], 0, 7),
__gen_unuint(input[22], 8, 15),
__gen_unuint(input[22], 16, 23),
__gen_unuint(input[22], 24, 31),
__gen_unuint(input[23], 0, 7),
__gen_unuint(input[23], 8, 15),
__gen_unuint(input[23], 16, 23),
__gen_unuint(input[23], 24, 31),
__gen_unuint(input[24], 0, 7),
__gen_unuint(input[24], 8, 15),
__gen_unuint(input[24], 16, 23),
__gen_unuint(input[24], 24, 31),
__gen_unuint(input[25], 0, 7),
__gen_unuint(input[25], 8, 15),
__gen_unuint(input[25], 16, 23),
__gen_unuint(input[25], 24, 31),
__gen_unuint(input[26], 0, 7),
__gen_unuint(input[26], 8, 15),
__gen_unuint(input[26], 16, 23),
__gen_unuint(input[26], 24, 31),
__gen_unuint(input[27], 0, 7),
__gen_unuint(input[27], 8, 15),
__gen_unuint(input[27], 16, 23),
__gen_unuint(input[27], 24, 31),
__gen_unuint(input[28], 0, 7),
__gen_unuint(input[28], 8, 15),
__gen_unuint(input[28], 16, 23),
__gen_unuint(input[28], 24, 31),
__gen_unuint(input[29], 0, 7),
__gen_unuint(input[29], 8, 15),
__gen_unuint(input[29], 16, 23),
__gen_unuint(input[29], 24, 31),
__gen_unuint(input[30], 0, 7),
__gen_unuint(input[30], 8, 15),
__gen_unuint(input[30], 16, 23),
__gen_unuint(input[30], 24, 31),
__gen_unuint(input[31], 0, 7),
__gen_unuint(input[31], 8, 15),
__gen_unuint(input[31], 16, 23),
__gen_unuint(input[31], 24, 31),
__gen_unuint(input[32], 0, 7),
__gen_unuint(input[32], 8, 15),
__gen_unuint(input[32], 16, 23),
__gen_unuint(input[32], 24, 31),
__gen_unuint(input[33], 0, 7),
__gen_unuint(input[33], 8, 15),
__gen_unuint(input[33], 16, 23),
__gen_unuint(input[33], 24, 31),
__gen_unuint(input[34], 0, 7),
__gen_unuint(input[34], 8, 15),
__gen_unuint(input[34], 16, 23),
__gen_unuint(input[34], 24, 31),
__gen_unuint(input[35], 0, 7),
__gen_unuint(input[35], 8, 15),
__gen_unuint(input[35], 16, 23),
__gen_unuint(input[35], 24, 31),
__gen_unuint(input[36], 0, 7),
__gen_unuint(input[36], 8, 15),
__gen_unuint(input[36], 16, 23),
__gen_unuint(input[36], 24, 31),
__gen_unuint(input[37], 0, 7),
__gen_unuint(input[37], 8, 15),
__gen_unuint(input[37], 16, 23),
__gen_unuint(input[37], 24, 31),
__gen_unuint(input[38], 0, 7),
__gen_unuint(input[38], 8, 15),
__gen_unuint(input[38], 16, 23),
__gen_unuint(input[38], 24, 31),
__gen_unuint(input[39], 0, 7),
__gen_unuint(input[39], 8, 15),
__gen_unuint(input[39], 16, 23),
__gen_unuint(input[39], 24, 31),
__gen_unuint(input[40], 0, 7),
__gen_unuint(input[40], 8, 15),
__gen_unuint(input[40], 16, 23),
__gen_unuint(input[40], 24, 31),
__gen_unuint(input[41], 0, 7),
__gen_unuint(input[41], 8, 15),
__gen_unuint(input[41], 16, 23),
__gen_unuint(input[41], 24, 31),
__gen_unuint(input[42], 0, 7),
__gen_unuint(input[42], 8, 15),
__gen_unuint(input[42], 16, 23),
__gen_unuint(input[42], 24, 31),
__gen_unuint(input[43], 0, 7),
__gen_unuint(input[43], 8, 15),
__gen_unuint(input[43], 16, 23),
__gen_unuint(input[43], 24, 31),
__gen_unuint(input[44], 0, 7),
__gen_unuint(input[44], 8, 15),
__gen_unuint(input[44], 16, 23),
__gen_unuint(input[44], 24, 31),
__gen_unuint(input[45], 0, 7),
__gen_unuint(input[45], 8, 15),
__gen_unuint(input[45], 16, 23),
__gen_unuint(input[45], 24, 31),
__gen_unuint(input[46], 0, 7),
__gen_unuint(input[46], 8, 15),
__gen_unuint(input[46], 16, 23),
__gen_unuint(input[46], 24, 31),
__gen_unuint(input[47], 0, 7),
__gen_unuint(input[47], 8, 15),
__gen_unuint(input[47], 16, 23),
__gen_unuint(input[47], 24, 31),
__gen_unuint(input[48], 0, 7),
__gen_unuint(input[48], 8, 15),
__gen_unuint(input[48], 16, 23),
__gen_unuint(input[48], 24, 31),
__gen_unuint(input[49], 0, 7),
__gen_unuint(input[49], 8, 15),
__gen_unuint(input[49], 16, 23),
__gen_unuint(input[49], 24, 31),
__gen_unuint(input[50], 0, 7),
__gen_unuint(input[50], 8, 15),
__gen_unuint(input[50], 16, 23),
__gen_unuint(input[50], 24, 31),
__gen_unuint(input[51], 0, 7),
__gen_unuint(input[51], 8, 15),
__gen_unuint(input[51], 16, 23),
__gen_unuint(input[51], 24, 31)
],
ac_huffval2: [
__gen_unuint(input[52], 0, 7),
__gen_unuint(input[52], 8, 15)
],
}
}
}
impl Deserialize for MfxJpegHuffTableState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 831];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 831] as *mut [u8; 3324]) })?;
Ok((&input).into())
}
}
pub struct MfxJpegPicState {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub input_format_yuv: u32,
pub rotation: u32,
pub frame_width_in_blocks: u32,
pub frame_height_in_blocks: u32,
}
impl MfxJpegPicState {
pub const DWORD_LENGTH: u32 = 3;
}
impl Default for MfxJpegPicState {
fn default() -> Self {
MfxJpegPicState {
dword_length: 1,
subopcode_b: 0,
subopcode_a: 0,
media_command_opcode: 7,
pipeline: 2,
command_type: 3,
input_format_yuv: Default::default(),
rotation: Default::default(),
frame_width_in_blocks: Default::default(),
frame_height_in_blocks: Default::default(),
}
}
}
impl Serialize for MfxJpegPicState {
type Out = [u32; 3];
fn pack_into(&self, out: &mut [u32; 3]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.input_format_yuv, 0, 2) |
__gen_uint(self.rotation, 4, 5);
out[2] = __gen_uint(self.frame_width_in_blocks, 0, 12) |
__gen_uint(self.frame_height_in_blocks, 16, 28);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 3];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 3] as *const [u8; 12]) })
}
}
impl From<&[u32; 3]> for MfxJpegPicState {
fn from(input: &[u32; 3]) -> Self {
MfxJpegPicState {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
input_format_yuv: __gen_unuint(input[1], 0, 2),
rotation: __gen_unuint(input[1], 4, 5),
frame_width_in_blocks: __gen_unuint(input[2], 0, 12),
frame_height_in_blocks: __gen_unuint(input[2], 16, 28),
}
}
}
impl Deserialize for MfxJpegPicState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 3];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 3] as *mut [u8; 12]) })?;
Ok((&input).into())
}
}
pub struct MfxMpeg2PicState {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub scan_order: u32,
pub intra_vlc_format: u32,
pub quantizer_scale_type: u32,
pub concealment_mv: bool,
pub frame_prediction_frame_dct: u32,
pub top_field_first: bool,
pub picture_structure: u32,
pub intra_dc_precision: u32,
pub f_code_0_0: u32,
pub f_code_0_1: u32,
pub f_code_1_0: u32,
pub f_code_1_1: u32,
pub disable_mismatch: bool,
pub mismatch_control_disable: bool,
pub picture_coding_type: u32,
pub load_bitstream_pointer_per_slice: bool,
pub frame_width_in_mbs: u32,
pub frame_height_in_mbs: u32,
pub round_intra_dc: u32,
pub round_inter_dc: u32,
pub round_intra_ac: u32,
pub round_inter_ac: u32,
pub minimum_frame_size: u32,
pub intra_mb_max_bit_control: u32,
pub inter_mb_max_bit_control: u32,
pub frame_bitrate_max_report: u32,
pub frame_bitrate_min_report: u32,
pub mbratecontrolmask: u32,
pub minimum_frame_size_units: u32,
pub inter_mb_force_cbp_to_zero_control: u32,
pub frame_size_control: u32,
pub intra_mb_conformance_max_size: u32,
pub inter_mb_conformance_max_size: u32,
pub slice_delta_qp_max_0: i32,
pub slice_delta_qp_max_1: i32,
pub slice_delta_qp_max_2: i32,
pub slice_delta_qp_max_3: i32,
pub slice_delta_qp_min_0: i32,
pub slice_delta_qp_min_1: i32,
pub slice_delta_qp_min_2: i32,
pub slice_delta_qp_min_3: i32,
pub frame_bitrate_min: u32,
pub frame_bitrate_min_unit_mode: u32,
pub frame_bitrate_min_unit: u32,
pub frame_bitrate_max: u32,
pub frame_bitrate_max_unit_mode: u32,
pub frame_bitrate_max_unit: u32,
pub frame_bitrate_min_delta: u32,
pub frame_bitrate_max_delta: u32,
}
impl MfxMpeg2PicState {
pub const DWORD_LENGTH: u32 = 12;
pub const COMPATIBILITY_MODE: u32 = 0;
pub const MPEG_ALTERNATE_VERTICAL_SCAN: u32 = 1;
pub const MPEG_BOTTOM_FIELD: u32 = 2;
pub const MPEG_B_PICTURE: u32 = 3;
pub const MPEG_FRAME: u32 = 3;
pub const MPEG_I_PICTURE: u32 = 1;
pub const MPEG_P_PICTURE: u32 = 2;
pub const MPEG_QSCALE_LINEAR: u32 = 0;
pub const MPEG_QSCALE_NONLINEAR: u32 = 1;
pub const MPEG_TOP_FIELD: u32 = 1;
pub const MPEG_ZIGZAG_SCAN: u32 = 0;
pub const NEW_MODE: u32 = 1;
pub const _16KB: u32 = 3;
pub const _16_BYTES: u32 = 1;
pub const _4KB: u32 = 2;
}
impl Default for MfxMpeg2PicState {
fn default() -> Self {
MfxMpeg2PicState {
dword_length: 0,
subopcode_b: 0,
subopcode_a: 0,
media_command_opcode: 3,
pipeline: 2,
command_type: 3,
scan_order: Default::default(),
intra_vlc_format: Default::default(),
quantizer_scale_type: Default::default(),
concealment_mv: Default::default(),
frame_prediction_frame_dct: Default::default(),
top_field_first: Default::default(),
picture_structure: Default::default(),
intra_dc_precision: Default::default(),
f_code_0_0: Default::default(),
f_code_0_1: Default::default(),
f_code_1_0: Default::default(),
f_code_1_1: Default::default(),
disable_mismatch: Default::default(),
mismatch_control_disable: Default::default(),
picture_coding_type: Default::default(),
load_bitstream_pointer_per_slice: Default::default(),
frame_width_in_mbs: Default::default(),
frame_height_in_mbs: Default::default(),
round_intra_dc: Default::default(),
round_inter_dc: Default::default(),
round_intra_ac: Default::default(),
round_inter_ac: Default::default(),
minimum_frame_size: Default::default(),
intra_mb_max_bit_control: Default::default(),
inter_mb_max_bit_control: Default::default(),
frame_bitrate_max_report: Default::default(),
frame_bitrate_min_report: Default::default(),
mbratecontrolmask: Default::default(),
minimum_frame_size_units: Default::default(),
inter_mb_force_cbp_to_zero_control: Default::default(),
frame_size_control: Default::default(),
intra_mb_conformance_max_size: Default::default(),
inter_mb_conformance_max_size: Default::default(),
slice_delta_qp_max_0: Default::default(),
slice_delta_qp_max_1: Default::default(),
slice_delta_qp_max_2: Default::default(),
slice_delta_qp_max_3: Default::default(),
slice_delta_qp_min_0: Default::default(),
slice_delta_qp_min_1: Default::default(),
slice_delta_qp_min_2: Default::default(),
slice_delta_qp_min_3: Default::default(),
frame_bitrate_min: Default::default(),
frame_bitrate_min_unit_mode: Default::default(),
frame_bitrate_min_unit: Default::default(),
frame_bitrate_max: Default::default(),
frame_bitrate_max_unit_mode: Default::default(),
frame_bitrate_max_unit: Default::default(),
frame_bitrate_min_delta: Default::default(),
frame_bitrate_max_delta: Default::default(),
}
}
}
impl Serialize for MfxMpeg2PicState {
type Out = [u32; 12];
fn pack_into(&self, out: &mut [u32; 12]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.scan_order, 6, 6) |
__gen_uint(self.intra_vlc_format, 7, 7) |
__gen_uint(self.quantizer_scale_type, 8, 8) |
__gen_uint(self.concealment_mv.into(), 9, 9) |
__gen_uint(self.frame_prediction_frame_dct, 10, 10) |
__gen_uint(self.top_field_first.into(), 11, 11) |
__gen_uint(self.picture_structure, 12, 13) |
__gen_uint(self.intra_dc_precision, 14, 15) |
__gen_uint(self.f_code_0_0, 16, 19) |
__gen_uint(self.f_code_0_1, 20, 23) |
__gen_uint(self.f_code_1_0, 24, 27) |
__gen_uint(self.f_code_1_1, 28, 31);
out[2] = __gen_uint(self.disable_mismatch.into(), 0, 0) |
__gen_uint(self.mismatch_control_disable.into(), 1, 1) |
__gen_uint(self.picture_coding_type, 9, 10) |
__gen_uint(self.load_bitstream_pointer_per_slice.into(), 14, 14);
out[3] = __gen_uint(self.frame_width_in_mbs, 0, 7) |
__gen_uint(self.frame_height_in_mbs, 16, 23);
out[4] = __gen_uint(self.round_intra_dc, 1, 2) |
__gen_uint(self.round_inter_dc, 4, 6) |
__gen_uint(self.round_intra_ac, 8, 10) |
__gen_uint(self.round_inter_ac, 12, 14) |
__gen_uint(self.minimum_frame_size, 16, 31);
out[5] = __gen_uint(self.intra_mb_max_bit_control, 0, 0) |
__gen_uint(self.inter_mb_max_bit_control, 1, 1) |
__gen_uint(self.frame_bitrate_max_report, 2, 2) |
__gen_uint(self.frame_bitrate_min_report, 3, 3) |
__gen_uint(self.mbratecontrolmask, 9, 9) |
__gen_uint(self.minimum_frame_size_units, 10, 11) |
__gen_uint(self.inter_mb_force_cbp_to_zero_control, 12, 12) |
__gen_uint(self.frame_size_control, 16, 16);
out[6] = __gen_uint(self.intra_mb_conformance_max_size, 0, 11) |
__gen_uint(self.inter_mb_conformance_max_size, 16, 27);
out[7] = 0;
out[8] = __gen_uint(self.slice_delta_qp_max_0 as u32, 0, 7) |
__gen_uint(self.slice_delta_qp_max_1 as u32, 8, 15) |
__gen_uint(self.slice_delta_qp_max_2 as u32, 16, 23) |
__gen_uint(self.slice_delta_qp_max_3 as u32, 24, 31);
out[9] = __gen_uint(self.slice_delta_qp_min_0 as u32, 0, 7) |
__gen_uint(self.slice_delta_qp_min_1 as u32, 8, 15) |
__gen_uint(self.slice_delta_qp_min_2 as u32, 16, 23) |
__gen_uint(self.slice_delta_qp_min_3 as u32, 24, 31);
out[10] = __gen_uint(self.frame_bitrate_min, 0, 13) |
__gen_uint(self.frame_bitrate_min_unit_mode, 14, 14) |
__gen_uint(self.frame_bitrate_min_unit, 15, 15) |
__gen_uint(self.frame_bitrate_max, 16, 29) |
__gen_uint(self.frame_bitrate_max_unit_mode, 30, 30) |
__gen_uint(self.frame_bitrate_max_unit, 31, 31);
out[11] = __gen_uint(self.frame_bitrate_min_delta, 0, 14) |
__gen_uint(self.frame_bitrate_max_delta, 16, 30);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 12];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 12] as *const [u8; 48]) })
}
}
impl From<&[u32; 12]> for MfxMpeg2PicState {
fn from(input: &[u32; 12]) -> Self {
MfxMpeg2PicState {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
scan_order: __gen_unuint(input[1], 6, 6),
intra_vlc_format: __gen_unuint(input[1], 7, 7),
quantizer_scale_type: __gen_unuint(input[1], 8, 8),
concealment_mv: __gen_unuint(input[1], 9, 9) != 0,
frame_prediction_frame_dct: __gen_unuint(input[1], 10, 10),
top_field_first: __gen_unuint(input[1], 11, 11) != 0,
picture_structure: __gen_unuint(input[1], 12, 13),
intra_dc_precision: __gen_unuint(input[1], 14, 15),
f_code_0_0: __gen_unuint(input[1], 16, 19),
f_code_0_1: __gen_unuint(input[1], 20, 23),
f_code_1_0: __gen_unuint(input[1], 24, 27),
f_code_1_1: __gen_unuint(input[1], 28, 31),
disable_mismatch: __gen_unuint(input[2], 0, 0) != 0,
mismatch_control_disable: __gen_unuint(input[2], 1, 1) != 0,
picture_coding_type: __gen_unuint(input[2], 9, 10),
load_bitstream_pointer_per_slice: __gen_unuint(input[2], 14, 14) != 0,
frame_width_in_mbs: __gen_unuint(input[3], 0, 7),
frame_height_in_mbs: __gen_unuint(input[3], 16, 23),
round_intra_dc: __gen_unuint(input[4], 1, 2),
round_inter_dc: __gen_unuint(input[4], 4, 6),
round_intra_ac: __gen_unuint(input[4], 8, 10),
round_inter_ac: __gen_unuint(input[4], 12, 14),
minimum_frame_size: __gen_unuint(input[4], 16, 31),
intra_mb_max_bit_control: __gen_unuint(input[5], 0, 0),
inter_mb_max_bit_control: __gen_unuint(input[5], 1, 1),
frame_bitrate_max_report: __gen_unuint(input[5], 2, 2),
frame_bitrate_min_report: __gen_unuint(input[5], 3, 3),
mbratecontrolmask: __gen_unuint(input[5], 9, 9),
minimum_frame_size_units: __gen_unuint(input[5], 10, 11),
inter_mb_force_cbp_to_zero_control: __gen_unuint(input[5], 12, 12),
frame_size_control: __gen_unuint(input[5], 16, 16),
intra_mb_conformance_max_size: __gen_unuint(input[6], 0, 11),
inter_mb_conformance_max_size: __gen_unuint(input[6], 16, 27),
slice_delta_qp_max_0: (__gen_unuint(input[8], 0, 7)) as i32,
slice_delta_qp_max_1: (__gen_unuint(input[8], 8, 15)) as i32,
slice_delta_qp_max_2: (__gen_unuint(input[8], 16, 23)) as i32,
slice_delta_qp_max_3: (__gen_unuint(input[8], 24, 31)) as i32,
slice_delta_qp_min_0: (__gen_unuint(input[9], 0, 7)) as i32,
slice_delta_qp_min_1: (__gen_unuint(input[9], 8, 15)) as i32,
slice_delta_qp_min_2: (__gen_unuint(input[9], 16, 23)) as i32,
slice_delta_qp_min_3: (__gen_unuint(input[9], 24, 31)) as i32,
frame_bitrate_min: __gen_unuint(input[10], 0, 13),
frame_bitrate_min_unit_mode: __gen_unuint(input[10], 14, 14),
frame_bitrate_min_unit: __gen_unuint(input[10], 15, 15),
frame_bitrate_max: __gen_unuint(input[10], 16, 29),
frame_bitrate_max_unit_mode: __gen_unuint(input[10], 30, 30),
frame_bitrate_max_unit: __gen_unuint(input[10], 31, 31),
frame_bitrate_min_delta: __gen_unuint(input[11], 0, 14),
frame_bitrate_max_delta: __gen_unuint(input[11], 16, 30),
}
}
}
impl Deserialize for MfxMpeg2PicState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 12];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 12] as *mut [u8; 48]) })?;
Ok((&input).into())
}
}
pub struct MfxPakInsertObject {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub bitstream_start_reset: bool,
pub end_of_slice: bool,
pub last_header: bool,
pub emulation_byte_bits_insert_enable: bool,
pub skip_emulation_byte_count: u32,
pub data_bits_in_last_dw: u32,
pub slice_header_indicator: u32,
pub header_length_excluded_from_size: u32,
pub data_byte_offset: u32,
}
impl MfxPakInsertObject {
pub const DWORD_LENGTH: u32 = 2;
pub const ACCUMULATE: u32 = 0;
pub const LEGACY: u32 = 0;
pub const NO_ACCUMULATION: u32 = 1;
pub const SLICE_HEADER: u32 = 1;
}
impl Default for MfxPakInsertObject {
fn default() -> Self {
MfxPakInsertObject {
dword_length: 0,
subopcode_b: 8,
subopcode_a: 2,
media_command_opcode: 0,
pipeline: 2,
command_type: 3,
bitstream_start_reset: Default::default(),
end_of_slice: Default::default(),
last_header: Default::default(),
emulation_byte_bits_insert_enable: Default::default(),
skip_emulation_byte_count: Default::default(),
data_bits_in_last_dw: Default::default(),
slice_header_indicator: Default::default(),
header_length_excluded_from_size: Default::default(),
data_byte_offset: Default::default(),
}
}
}
impl Serialize for MfxPakInsertObject {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.bitstream_start_reset.into(), 0, 0) |
__gen_uint(self.end_of_slice.into(), 1, 1) |
__gen_uint(self.last_header.into(), 2, 2) |
__gen_uint(self.emulation_byte_bits_insert_enable.into(), 3, 3) |
__gen_uint(self.skip_emulation_byte_count, 4, 7) |
__gen_uint(self.data_bits_in_last_dw, 8, 13) |
__gen_uint(self.slice_header_indicator, 14, 14) |
__gen_uint(self.header_length_excluded_from_size, 15, 15) |
__gen_uint(self.data_byte_offset, 16, 17);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for MfxPakInsertObject {
fn from(input: &[u32; 2]) -> Self {
MfxPakInsertObject {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
bitstream_start_reset: __gen_unuint(input[1], 0, 0) != 0,
end_of_slice: __gen_unuint(input[1], 1, 1) != 0,
last_header: __gen_unuint(input[1], 2, 2) != 0,
emulation_byte_bits_insert_enable: __gen_unuint(input[1], 3, 3) != 0,
skip_emulation_byte_count: __gen_unuint(input[1], 4, 7),
data_bits_in_last_dw: __gen_unuint(input[1], 8, 13),
slice_header_indicator: __gen_unuint(input[1], 14, 14),
header_length_excluded_from_size: __gen_unuint(input[1], 15, 15),
data_byte_offset: __gen_unuint(input[1], 16, 17),
}
}
}
impl Deserialize for MfxPakInsertObject {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct MfxPipeBufAddrState<A: Addr + Default> {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub pre_deblocking_destination_arbitration_priority_control: u32,
pub pre_deblocking_destination_address: A,
pub post_deblocking_destination_cacheability_control: u32,
pub post_deblocking_destination_graphics_data_type: u32,
pub post_deblocking_destination_arbitration_priority_control: u32,
pub post_deblocking_destination_address: A,
pub original_uncompressed_picture_source_cacheability_control: u32,
pub original_uncompressed_picture_source_graphics_data_type: u32,
pub original_uncompressed_picture_source_arbitration_priority_control: u32,
pub original_uncompressed_picture_source_address: A,
pub stream_out_data_destination_cacheability_control: u32,
pub stream_out_data_destination_graphics_data_type: u32,
pub stream_out_data_destination_arbitration_priority_control: u32,
pub stream_out_data_destination_address: A,
pub intra_row_store_scratch_buffer_cacheability_control: u32,
pub intra_row_store_scratch_buffer_graphics_data_type: u32,
pub intra_row_store_scratch_buffer_arbitration_priority_control: u32,
pub intra_row_store_scratch_buffer_address: A,
pub deblocking_filter_row_store_scratch_buffer_cacheability_control: u32,
pub deblocking_filter_row_store_scratch_buffer_graphics_data_type: u32,
pub deblocking_filter_row_store_scratch_buffer_arbitration_priority_control: u32,
pub deblocking_filter_row_store_scratch_buffer_address: A,
pub reference_picture_address: [A; 16],
pub reference_picture_arbitration_priority_control: [u32; 16],
pub reference_picture_graphics_data_type: [u32; 16],
pub reference_picture_cacheability_control: [u32; 16],
pub mb_status_buffer_cacheability_control: u32,
pub mb_status_buffer_graphics_data_type: u32,
pub mb_status_buffer_arbitration_priority_control: u32,
pub mb_status_buffer_address: A,
}
impl<A: Addr + Default> MfxPipeBufAddrState<A> {
pub const DWORD_LENGTH: u32 = 24;
pub const BOTH_LLC_AND_MLC: u32 = 3;
pub const GTT: u32 = 0;
pub const GTT_ENTRY: u32 = 0;
pub const HIGHEST_PRIORITY: u32 = 0;
pub const IN_LLC_BUT_NOT_MLC: u32 = 2;
pub const LLC_BUT_NOT_MLC: u32 = 2;
pub const LOWEST_PRIORITY: u32 = 3;
pub const NOT_IN_LLC_OR_MLC: u32 = 1;
pub const NOT_LLC_OR_MLC: u32 = 1;
pub const SECOND_HIGHEST_PRIORITY: u32 = 1;
pub const THIRD_HIGHEST_PRIORITY: u32 = 2;
}
impl<A: Addr + Default> Default for MfxPipeBufAddrState<A> {
fn default() -> Self {
MfxPipeBufAddrState {
dword_length: 22,
subopcode_b: 2,
subopcode_a: 0,
media_command_opcode: 0,
pipeline: 2,
command_type: 3,
pre_deblocking_destination_arbitration_priority_control: Default::default(),
pre_deblocking_destination_address: Default::default(),
post_deblocking_destination_cacheability_control: Default::default(),
post_deblocking_destination_graphics_data_type: Default::default(),
post_deblocking_destination_arbitration_priority_control: Default::default(),
post_deblocking_destination_address: Default::default(),
original_uncompressed_picture_source_cacheability_control: Default::default(),
original_uncompressed_picture_source_graphics_data_type: Default::default(),
original_uncompressed_picture_source_arbitration_priority_control: Default::default(),
original_uncompressed_picture_source_address: Default::default(),
stream_out_data_destination_cacheability_control: Default::default(),
stream_out_data_destination_graphics_data_type: Default::default(),
stream_out_data_destination_arbitration_priority_control: Default::default(),
stream_out_data_destination_address: Default::default(),
intra_row_store_scratch_buffer_cacheability_control: Default::default(),
intra_row_store_scratch_buffer_graphics_data_type: Default::default(),
intra_row_store_scratch_buffer_arbitration_priority_control: Default::default(),
intra_row_store_scratch_buffer_address: Default::default(),
deblocking_filter_row_store_scratch_buffer_cacheability_control: Default::default(),
deblocking_filter_row_store_scratch_buffer_graphics_data_type: Default::default(),
deblocking_filter_row_store_scratch_buffer_arbitration_priority_control: Default::default(),
deblocking_filter_row_store_scratch_buffer_address: Default::default(),
reference_picture_address: Default::default(),
reference_picture_arbitration_priority_control: Default::default(),
reference_picture_graphics_data_type: Default::default(),
reference_picture_cacheability_control: Default::default(),
mb_status_buffer_cacheability_control: Default::default(),
mb_status_buffer_graphics_data_type: Default::default(),
mb_status_buffer_arbitration_priority_control: Default::default(),
mb_status_buffer_address: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for MfxPipeBufAddrState<A> {
type Out = [u32; 24];
fn pack_into(&self, out: &mut [u32; 24]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
let v1 = __gen_uint(self.pre_deblocking_destination_arbitration_priority_control, 4, 5);
let v1_address = self.pre_deblocking_destination_address.combine(v1);
out[1] = v1_address as u32;
out[2] = (v1_address >> 32) as u32;
let v2 = __gen_uint(self.post_deblocking_destination_cacheability_control, 0, 1) |
__gen_uint(self.post_deblocking_destination_graphics_data_type, 2, 2) |
__gen_uint(self.post_deblocking_destination_arbitration_priority_control, 4, 5);
let v2_address = self.post_deblocking_destination_address.combine(v2);
out[2] = v2_address as u32;
out[3] = (v2_address >> 32) as u32;
let v3 = __gen_uint(self.original_uncompressed_picture_source_cacheability_control, 0, 1) |
__gen_uint(self.original_uncompressed_picture_source_graphics_data_type, 2, 2) |
__gen_uint(self.original_uncompressed_picture_source_arbitration_priority_control, 4, 5);
let v3_address = self.original_uncompressed_picture_source_address.combine(v3);
out[3] = v3_address as u32;
out[4] = (v3_address >> 32) as u32;
let v4 = __gen_uint(self.stream_out_data_destination_cacheability_control, 0, 1) |
__gen_uint(self.stream_out_data_destination_graphics_data_type, 2, 2) |
__gen_uint(self.stream_out_data_destination_arbitration_priority_control, 4, 5);
let v4_address = self.stream_out_data_destination_address.combine(v4);
out[4] = v4_address as u32;
out[5] = (v4_address >> 32) as u32;
let v5 = __gen_uint(self.intra_row_store_scratch_buffer_cacheability_control, 0, 1) |
__gen_uint(self.intra_row_store_scratch_buffer_graphics_data_type, 2, 2) |
__gen_uint(self.intra_row_store_scratch_buffer_arbitration_priority_control, 4, 5);
let v5_address = self.intra_row_store_scratch_buffer_address.combine(v5);
out[5] = v5_address as u32;
out[6] = (v5_address >> 32) as u32;
let v6 = __gen_uint(self.deblocking_filter_row_store_scratch_buffer_cacheability_control, 0, 1) |
__gen_uint(self.deblocking_filter_row_store_scratch_buffer_graphics_data_type, 2, 2) |
__gen_uint(self.deblocking_filter_row_store_scratch_buffer_arbitration_priority_control, 4, 5);
let v6_address = self.deblocking_filter_row_store_scratch_buffer_address.combine(v6);
out[6] = v6_address as u32;
out[7] = (v6_address >> 32) as u32;
let v7 = __gen_uint(self.reference_picture_cacheability_control[0], 0, 1) |
__gen_uint(self.reference_picture_graphics_data_type[0], 2, 2) |
__gen_uint(self.reference_picture_arbitration_priority_control[0], 4, 5);
let v7_address = self.reference_picture_address[0].combine(v7);
out[7] = v7_address as u32;
out[8] = (v7_address >> 32) as u32;
let v8 = __gen_uint(self.reference_picture_cacheability_control[1], 0, 1) |
__gen_uint(self.reference_picture_graphics_data_type[1], 2, 2) |
__gen_uint(self.reference_picture_arbitration_priority_control[1], 4, 5);
let v8_address = self.reference_picture_address[1].combine(v8);
out[8] = v8_address as u32;
out[9] = (v8_address >> 32) as u32;
let v9 = __gen_uint(self.reference_picture_cacheability_control[2], 0, 1) |
__gen_uint(self.reference_picture_graphics_data_type[2], 2, 2) |
__gen_uint(self.reference_picture_arbitration_priority_control[2], 4, 5);
let v9_address = self.reference_picture_address[2].combine(v9);
out[9] = v9_address as u32;
out[10] = (v9_address >> 32) as u32;
let v10 = __gen_uint(self.reference_picture_cacheability_control[3], 0, 1) |
__gen_uint(self.reference_picture_graphics_data_type[3], 2, 2) |
__gen_uint(self.reference_picture_arbitration_priority_control[3], 4, 5);
let v10_address = self.reference_picture_address[3].combine(v10);
out[10] = v10_address as u32;
out[11] = (v10_address >> 32) as u32;
let v11 = __gen_uint(self.reference_picture_cacheability_control[4], 0, 1) |
__gen_uint(self.reference_picture_graphics_data_type[4], 2, 2) |
__gen_uint(self.reference_picture_arbitration_priority_control[4], 4, 5);
let v11_address = self.reference_picture_address[4].combine(v11);
out[11] = v11_address as u32;
out[12] = (v11_address >> 32) as u32;
let v12 = __gen_uint(self.reference_picture_cacheability_control[5], 0, 1) |
__gen_uint(self.reference_picture_graphics_data_type[5], 2, 2) |
__gen_uint(self.reference_picture_arbitration_priority_control[5], 4, 5);
let v12_address = self.reference_picture_address[5].combine(v12);
out[12] = v12_address as u32;
out[13] = (v12_address >> 32) as u32;
let v13 = __gen_uint(self.reference_picture_cacheability_control[6], 0, 1) |
__gen_uint(self.reference_picture_graphics_data_type[6], 2, 2) |
__gen_uint(self.reference_picture_arbitration_priority_control[6], 4, 5);
let v13_address = self.reference_picture_address[6].combine(v13);
out[13] = v13_address as u32;
out[14] = (v13_address >> 32) as u32;
let v14 = __gen_uint(self.reference_picture_cacheability_control[7], 0, 1) |
__gen_uint(self.reference_picture_graphics_data_type[7], 2, 2) |
__gen_uint(self.reference_picture_arbitration_priority_control[7], 4, 5);
let v14_address = self.reference_picture_address[7].combine(v14);
out[14] = v14_address as u32;
out[15] = (v14_address >> 32) as u32;
let v15 = __gen_uint(self.reference_picture_cacheability_control[8], 0, 1) |
__gen_uint(self.reference_picture_graphics_data_type[8], 2, 2) |
__gen_uint(self.reference_picture_arbitration_priority_control[8], 4, 5);
let v15_address = self.reference_picture_address[8].combine(v15);
out[15] = v15_address as u32;
out[16] = (v15_address >> 32) as u32;
let v16 = __gen_uint(self.reference_picture_cacheability_control[9], 0, 1) |
__gen_uint(self.reference_picture_graphics_data_type[9], 2, 2) |
__gen_uint(self.reference_picture_arbitration_priority_control[9], 4, 5);
let v16_address = self.reference_picture_address[9].combine(v16);
out[16] = v16_address as u32;
out[17] = (v16_address >> 32) as u32;
let v17 = __gen_uint(self.reference_picture_cacheability_control[10], 0, 1) |
__gen_uint(self.reference_picture_graphics_data_type[10], 2, 2) |
__gen_uint(self.reference_picture_arbitration_priority_control[10], 4, 5);
let v17_address = self.reference_picture_address[10].combine(v17);
out[17] = v17_address as u32;
out[18] = (v17_address >> 32) as u32;
let v18 = __gen_uint(self.reference_picture_cacheability_control[11], 0, 1) |
__gen_uint(self.reference_picture_graphics_data_type[11], 2, 2) |
__gen_uint(self.reference_picture_arbitration_priority_control[11], 4, 5);
let v18_address = self.reference_picture_address[11].combine(v18);
out[18] = v18_address as u32;
out[19] = (v18_address >> 32) as u32;
let v19 = __gen_uint(self.reference_picture_cacheability_control[12], 0, 1) |
__gen_uint(self.reference_picture_graphics_data_type[12], 2, 2) |
__gen_uint(self.reference_picture_arbitration_priority_control[12], 4, 5);
let v19_address = self.reference_picture_address[12].combine(v19);
out[19] = v19_address as u32;
out[20] = (v19_address >> 32) as u32;
let v20 = __gen_uint(self.reference_picture_cacheability_control[13], 0, 1) |
__gen_uint(self.reference_picture_graphics_data_type[13], 2, 2) |
__gen_uint(self.reference_picture_arbitration_priority_control[13], 4, 5);
let v20_address = self.reference_picture_address[13].combine(v20);
out[20] = v20_address as u32;
out[21] = (v20_address >> 32) as u32;
let v21 = __gen_uint(self.reference_picture_cacheability_control[14], 0, 1) |
__gen_uint(self.reference_picture_graphics_data_type[14], 2, 2) |
__gen_uint(self.reference_picture_arbitration_priority_control[14], 4, 5);
let v21_address = self.reference_picture_address[14].combine(v21);
out[21] = v21_address as u32;
out[22] = (v21_address >> 32) as u32;
let v22 = __gen_uint(self.reference_picture_cacheability_control[15], 0, 1) |
__gen_uint(self.reference_picture_graphics_data_type[15], 2, 2) |
__gen_uint(self.reference_picture_arbitration_priority_control[15], 4, 5);
let v22_address = self.reference_picture_address[15].combine(v22);
out[22] = v22_address as u32;
out[23] = (v22_address >> 32) as u32;
let v23 = __gen_uint(self.mb_status_buffer_cacheability_control, 0, 1) |
__gen_uint(self.mb_status_buffer_graphics_data_type, 2, 2) |
__gen_uint(self.mb_status_buffer_arbitration_priority_control, 4, 5);
let v23_address = self.mb_status_buffer_address.combine(v23);
out[23] = v23_address as u32;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 24];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 24] as *const [u8; 96]) })
}
}
impl From<&[u32; 24]> for MfxPipeBufAddrState<u64> {
fn from(input: &[u32; 24]) -> Self {
MfxPipeBufAddrState {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
pre_deblocking_destination_arbitration_priority_control: __gen_unuint(input[1], 4, 5),
pre_deblocking_destination_address: (__gen_unuint(input[1], 6, 31) as u64) << 6,
post_deblocking_destination_cacheability_control: __gen_unuint(input[2], 0, 1),
post_deblocking_destination_graphics_data_type: __gen_unuint(input[2], 2, 2),
post_deblocking_destination_arbitration_priority_control: __gen_unuint(input[2], 4, 5),
post_deblocking_destination_address: (__gen_unuint(input[2], 6, 31) as u64) << 6,
original_uncompressed_picture_source_cacheability_control: __gen_unuint(input[3], 0, 1),
original_uncompressed_picture_source_graphics_data_type: __gen_unuint(input[3], 2, 2),
original_uncompressed_picture_source_arbitration_priority_control: __gen_unuint(input[3], 4, 5),
original_uncompressed_picture_source_address: (__gen_unuint(input[3], 6, 31) as u64) << 6,
stream_out_data_destination_cacheability_control: __gen_unuint(input[4], 0, 1),
stream_out_data_destination_graphics_data_type: __gen_unuint(input[4], 2, 2),
stream_out_data_destination_arbitration_priority_control: __gen_unuint(input[4], 4, 5),
stream_out_data_destination_address: (__gen_unuint(input[4], 6, 31) as u64) << 6,
intra_row_store_scratch_buffer_cacheability_control: __gen_unuint(input[5], 0, 1),
intra_row_store_scratch_buffer_graphics_data_type: __gen_unuint(input[5], 2, 2),
intra_row_store_scratch_buffer_arbitration_priority_control: __gen_unuint(input[5], 4, 5),
intra_row_store_scratch_buffer_address: (__gen_unuint(input[5], 6, 31) as u64) << 6,
deblocking_filter_row_store_scratch_buffer_cacheability_control: __gen_unuint(input[6], 0, 1),
deblocking_filter_row_store_scratch_buffer_graphics_data_type: __gen_unuint(input[6], 2, 2),
deblocking_filter_row_store_scratch_buffer_arbitration_priority_control: __gen_unuint(input[6], 4, 5),
deblocking_filter_row_store_scratch_buffer_address: (__gen_unuint(input[6], 6, 31) as u64) << 6,
reference_picture_address: [
(__gen_unuint(input[7], 6, 31) as u64) << 6,
(__gen_unuint(input[8], 6, 31) as u64) << 6,
(__gen_unuint(input[9], 6, 31) as u64) << 6,
(__gen_unuint(input[10], 6, 31) as u64) << 6,
(__gen_unuint(input[11], 6, 31) as u64) << 6,
(__gen_unuint(input[12], 6, 31) as u64) << 6,
(__gen_unuint(input[13], 6, 31) as u64) << 6,
(__gen_unuint(input[14], 6, 31) as u64) << 6,
(__gen_unuint(input[15], 6, 31) as u64) << 6,
(__gen_unuint(input[16], 6, 31) as u64) << 6,
(__gen_unuint(input[17], 6, 31) as u64) << 6,
(__gen_unuint(input[18], 6, 31) as u64) << 6,
(__gen_unuint(input[19], 6, 31) as u64) << 6,
(__gen_unuint(input[20], 6, 31) as u64) << 6,
(__gen_unuint(input[21], 6, 31) as u64) << 6,
(__gen_unuint(input[22], 6, 31) as u64) << 6
],
reference_picture_arbitration_priority_control: [
__gen_unuint(input[7], 4, 5),
__gen_unuint(input[8], 4, 5),
__gen_unuint(input[9], 4, 5),
__gen_unuint(input[10], 4, 5),
__gen_unuint(input[11], 4, 5),
__gen_unuint(input[12], 4, 5),
__gen_unuint(input[13], 4, 5),
__gen_unuint(input[14], 4, 5),
__gen_unuint(input[15], 4, 5),
__gen_unuint(input[16], 4, 5),
__gen_unuint(input[17], 4, 5),
__gen_unuint(input[18], 4, 5),
__gen_unuint(input[19], 4, 5),
__gen_unuint(input[20], 4, 5),
__gen_unuint(input[21], 4, 5),
__gen_unuint(input[22], 4, 5)
],
reference_picture_graphics_data_type: [
__gen_unuint(input[7], 2, 2),
__gen_unuint(input[8], 2, 2),
__gen_unuint(input[9], 2, 2),
__gen_unuint(input[10], 2, 2),
__gen_unuint(input[11], 2, 2),
__gen_unuint(input[12], 2, 2),
__gen_unuint(input[13], 2, 2),
__gen_unuint(input[14], 2, 2),
__gen_unuint(input[15], 2, 2),
__gen_unuint(input[16], 2, 2),
__gen_unuint(input[17], 2, 2),
__gen_unuint(input[18], 2, 2),
__gen_unuint(input[19], 2, 2),
__gen_unuint(input[20], 2, 2),
__gen_unuint(input[21], 2, 2),
__gen_unuint(input[22], 2, 2)
],
reference_picture_cacheability_control: [
__gen_unuint(input[7], 0, 1),
__gen_unuint(input[8], 0, 1),
__gen_unuint(input[9], 0, 1),
__gen_unuint(input[10], 0, 1),
__gen_unuint(input[11], 0, 1),
__gen_unuint(input[12], 0, 1),
__gen_unuint(input[13], 0, 1),
__gen_unuint(input[14], 0, 1),
__gen_unuint(input[15], 0, 1),
__gen_unuint(input[16], 0, 1),
__gen_unuint(input[17], 0, 1),
__gen_unuint(input[18], 0, 1),
__gen_unuint(input[19], 0, 1),
__gen_unuint(input[20], 0, 1),
__gen_unuint(input[21], 0, 1),
__gen_unuint(input[22], 0, 1)
],
mb_status_buffer_cacheability_control: __gen_unuint(input[23], 0, 1),
mb_status_buffer_graphics_data_type: __gen_unuint(input[23], 2, 2),
mb_status_buffer_arbitration_priority_control: __gen_unuint(input[23], 4, 5),
mb_status_buffer_address: (__gen_unuint(input[23], 6, 31) as u64) << 6,
}
}
}
impl Deserialize for MfxPipeBufAddrState<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 24];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 24] as *mut [u8; 96]) })?;
Ok((&input).into())
}
}
pub struct MfxPipeModeSelect {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub standard_select: u32,
pub codec_select: u32,
pub stitch_mode: bool,
pub pre_deblocking_output_enable: bool,
pub post_deblocking_output_enable: bool,
pub stream_out_enable: bool,
pub pic_error_status_report_enable: bool,
pub decoder_mode_select: u32,
pub decoder_short_format_mode: u32,
pub extended_stream_out_enable: bool,
pub pic_status_error_report_id: u32,
}
impl MfxPipeModeSelect {
pub const DWORD_LENGTH: u32 = 5;
pub const AVC: u32 = 2;
pub const DEBLOCKER_MODE: u32 = 2;
pub const DECODE: u32 = 0;
pub const ENCODE: u32 = 1;
pub const INTERLAYER_MODE: u32 = 3;
pub const IT_MODE: u32 = 1;
pub const JPEG: u32 = 3;
pub const LONG_FORMAT_DRIVER_INTERFACE: u32 = 1;
pub const MPEG2: u32 = 0;
pub const SHORT_FORMAT_DRIVER_INTERFACE: u32 = 0;
pub const VC1: u32 = 1;
pub const VLD_MODE: u32 = 0;
}
impl Default for MfxPipeModeSelect {
fn default() -> Self {
MfxPipeModeSelect {
dword_length: 3,
subopcode_b: 0,
subopcode_a: 0,
media_command_opcode: 0,
pipeline: 2,
command_type: 3,
standard_select: Default::default(),
codec_select: Default::default(),
stitch_mode: Default::default(),
pre_deblocking_output_enable: Default::default(),
post_deblocking_output_enable: Default::default(),
stream_out_enable: Default::default(),
pic_error_status_report_enable: Default::default(),
decoder_mode_select: Default::default(),
decoder_short_format_mode: Default::default(),
extended_stream_out_enable: Default::default(),
pic_status_error_report_id: Default::default(),
}
}
}
impl Serialize for MfxPipeModeSelect {
type Out = [u32; 5];
fn pack_into(&self, out: &mut [u32; 5]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.standard_select, 0, 3) |
__gen_uint(self.codec_select, 4, 4) |
__gen_uint(self.stitch_mode.into(), 5, 5) |
__gen_uint(self.pre_deblocking_output_enable.into(), 8, 8) |
__gen_uint(self.post_deblocking_output_enable.into(), 9, 9) |
__gen_uint(self.stream_out_enable.into(), 10, 10) |
__gen_uint(self.pic_error_status_report_enable.into(), 11, 11) |
__gen_uint(self.decoder_mode_select, 15, 16) |
__gen_uint(self.decoder_short_format_mode, 17, 17) |
__gen_uint(self.extended_stream_out_enable.into(), 18, 18);
out[2] = 0;
out[3] = __gen_uint(self.pic_status_error_report_id, 0, 31);
out[4] = 0;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 5];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 5] as *const [u8; 20]) })
}
}
impl From<&[u32; 5]> for MfxPipeModeSelect {
fn from(input: &[u32; 5]) -> Self {
MfxPipeModeSelect {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
standard_select: __gen_unuint(input[1], 0, 3),
codec_select: __gen_unuint(input[1], 4, 4),
stitch_mode: __gen_unuint(input[1], 5, 5) != 0,
pre_deblocking_output_enable: __gen_unuint(input[1], 8, 8) != 0,
post_deblocking_output_enable: __gen_unuint(input[1], 9, 9) != 0,
stream_out_enable: __gen_unuint(input[1], 10, 10) != 0,
pic_error_status_report_enable: __gen_unuint(input[1], 11, 11) != 0,
decoder_mode_select: __gen_unuint(input[1], 15, 16),
decoder_short_format_mode: __gen_unuint(input[1], 17, 17),
extended_stream_out_enable: __gen_unuint(input[1], 18, 18) != 0,
pic_status_error_report_id: __gen_unuint(input[3], 0, 31),
}
}
}
impl Deserialize for MfxPipeModeSelect {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 5];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 5] as *mut [u8; 20]) })?;
Ok((&input).into())
}
}
pub struct MfxQmState {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub avc: u32,
pub mpeg2: u32,
pub forward_quantizer_matrix: [u8; 128],
}
impl MfxQmState {
pub const DWORD_LENGTH: u32 = 34;
pub const AVC_4X4_INTER_MATRIX: u32 = 1;
pub const AVC_4X4_INTRA_MATRIX: u32 = 0;
pub const AVC_8X8_INTER_MATRIX: u32 = 3;
pub const AVC_8X8_INTRA_MATRIX: u32 = 2;
pub const MPEG_INTRA_QUANTIZER_MATRIX: u32 = 0;
pub const MPEG_NON_INTRA_QUANTIZER_MATRIX: u32 = 1;
}
impl Default for MfxQmState {
fn default() -> Self {
MfxQmState {
dword_length: 32,
subopcode_b: 7,
subopcode_a: 0,
media_command_opcode: 0,
pipeline: 2,
command_type: 3,
avc: Default::default(),
mpeg2: Default::default(),
forward_quantizer_matrix: [0; 128],
}
}
}
impl Serialize for MfxQmState {
type Out = [u32; 34];
fn pack_into(&self, out: &mut [u32; 34]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.mpeg2, 0, 1);
out[2] = __gen_uint(self.forward_quantizer_matrix[0].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[1].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[2].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[3].into(), 24, 31);
out[3] = __gen_uint(self.forward_quantizer_matrix[4].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[5].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[6].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[7].into(), 24, 31);
out[4] = __gen_uint(self.forward_quantizer_matrix[8].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[9].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[10].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[11].into(), 24, 31);
out[5] = __gen_uint(self.forward_quantizer_matrix[12].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[13].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[14].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[15].into(), 24, 31);
out[6] = __gen_uint(self.forward_quantizer_matrix[16].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[17].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[18].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[19].into(), 24, 31);
out[7] = __gen_uint(self.forward_quantizer_matrix[20].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[21].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[22].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[23].into(), 24, 31);
out[8] = __gen_uint(self.forward_quantizer_matrix[24].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[25].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[26].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[27].into(), 24, 31);
out[9] = __gen_uint(self.forward_quantizer_matrix[28].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[29].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[30].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[31].into(), 24, 31);
out[10] = __gen_uint(self.forward_quantizer_matrix[32].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[33].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[34].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[35].into(), 24, 31);
out[11] = __gen_uint(self.forward_quantizer_matrix[36].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[37].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[38].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[39].into(), 24, 31);
out[12] = __gen_uint(self.forward_quantizer_matrix[40].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[41].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[42].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[43].into(), 24, 31);
out[13] = __gen_uint(self.forward_quantizer_matrix[44].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[45].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[46].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[47].into(), 24, 31);
out[14] = __gen_uint(self.forward_quantizer_matrix[48].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[49].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[50].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[51].into(), 24, 31);
out[15] = __gen_uint(self.forward_quantizer_matrix[52].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[53].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[54].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[55].into(), 24, 31);
out[16] = __gen_uint(self.forward_quantizer_matrix[56].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[57].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[58].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[59].into(), 24, 31);
out[17] = __gen_uint(self.forward_quantizer_matrix[60].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[61].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[62].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[63].into(), 24, 31);
out[18] = __gen_uint(self.forward_quantizer_matrix[64].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[65].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[66].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[67].into(), 24, 31);
out[19] = __gen_uint(self.forward_quantizer_matrix[68].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[69].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[70].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[71].into(), 24, 31);
out[20] = __gen_uint(self.forward_quantizer_matrix[72].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[73].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[74].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[75].into(), 24, 31);
out[21] = __gen_uint(self.forward_quantizer_matrix[76].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[77].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[78].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[79].into(), 24, 31);
out[22] = __gen_uint(self.forward_quantizer_matrix[80].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[81].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[82].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[83].into(), 24, 31);
out[23] = __gen_uint(self.forward_quantizer_matrix[84].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[85].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[86].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[87].into(), 24, 31);
out[24] = __gen_uint(self.forward_quantizer_matrix[88].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[89].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[90].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[91].into(), 24, 31);
out[25] = __gen_uint(self.forward_quantizer_matrix[92].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[93].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[94].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[95].into(), 24, 31);
out[26] = __gen_uint(self.forward_quantizer_matrix[96].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[97].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[98].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[99].into(), 24, 31);
out[27] = __gen_uint(self.forward_quantizer_matrix[100].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[101].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[102].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[103].into(), 24, 31);
out[28] = __gen_uint(self.forward_quantizer_matrix[104].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[105].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[106].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[107].into(), 24, 31);
out[29] = __gen_uint(self.forward_quantizer_matrix[108].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[109].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[110].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[111].into(), 24, 31);
out[30] = __gen_uint(self.forward_quantizer_matrix[112].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[113].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[114].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[115].into(), 24, 31);
out[31] = __gen_uint(self.forward_quantizer_matrix[116].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[117].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[118].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[119].into(), 24, 31);
out[32] = __gen_uint(self.forward_quantizer_matrix[120].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[121].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[122].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[123].into(), 24, 31);
out[33] = __gen_uint(self.forward_quantizer_matrix[124].into(), 0, 7) |
__gen_uint(self.forward_quantizer_matrix[125].into(), 8, 15) |
__gen_uint(self.forward_quantizer_matrix[126].into(), 16, 23) |
__gen_uint(self.forward_quantizer_matrix[127].into(), 24, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 34];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 34] as *const [u8; 136]) })
}
}
impl From<&[u32; 34]> for MfxQmState {
fn from(input: &[u32; 34]) -> Self {
MfxQmState {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
avc: __gen_unuint(input[1], 0, 1),
mpeg2: __gen_unuint(input[1], 0, 1),
forward_quantizer_matrix: [
(__gen_unuint(input[2], 0, 7)) as u8,
(__gen_unuint(input[2], 8, 15)) as u8,
(__gen_unuint(input[2], 16, 23)) as u8,
(__gen_unuint(input[2], 24, 31)) as u8,
(__gen_unuint(input[3], 0, 7)) as u8,
(__gen_unuint(input[3], 8, 15)) as u8,
(__gen_unuint(input[3], 16, 23)) as u8,
(__gen_unuint(input[3], 24, 31)) as u8,
(__gen_unuint(input[4], 0, 7)) as u8,
(__gen_unuint(input[4], 8, 15)) as u8,
(__gen_unuint(input[4], 16, 23)) as u8,
(__gen_unuint(input[4], 24, 31)) as u8,
(__gen_unuint(input[5], 0, 7)) as u8,
(__gen_unuint(input[5], 8, 15)) as u8,
(__gen_unuint(input[5], 16, 23)) as u8,
(__gen_unuint(input[5], 24, 31)) as u8,
(__gen_unuint(input[6], 0, 7)) as u8,
(__gen_unuint(input[6], 8, 15)) as u8,
(__gen_unuint(input[6], 16, 23)) as u8,
(__gen_unuint(input[6], 24, 31)) as u8,
(__gen_unuint(input[7], 0, 7)) as u8,
(__gen_unuint(input[7], 8, 15)) as u8,
(__gen_unuint(input[7], 16, 23)) as u8,
(__gen_unuint(input[7], 24, 31)) as u8,
(__gen_unuint(input[8], 0, 7)) as u8,
(__gen_unuint(input[8], 8, 15)) as u8,
(__gen_unuint(input[8], 16, 23)) as u8,
(__gen_unuint(input[8], 24, 31)) as u8,
(__gen_unuint(input[9], 0, 7)) as u8,
(__gen_unuint(input[9], 8, 15)) as u8,
(__gen_unuint(input[9], 16, 23)) as u8,
(__gen_unuint(input[9], 24, 31)) as u8,
(__gen_unuint(input[10], 0, 7)) as u8,
(__gen_unuint(input[10], 8, 15)) as u8,
(__gen_unuint(input[10], 16, 23)) as u8,
(__gen_unuint(input[10], 24, 31)) as u8,
(__gen_unuint(input[11], 0, 7)) as u8,
(__gen_unuint(input[11], 8, 15)) as u8,
(__gen_unuint(input[11], 16, 23)) as u8,
(__gen_unuint(input[11], 24, 31)) as u8,
(__gen_unuint(input[12], 0, 7)) as u8,
(__gen_unuint(input[12], 8, 15)) as u8,
(__gen_unuint(input[12], 16, 23)) as u8,
(__gen_unuint(input[12], 24, 31)) as u8,
(__gen_unuint(input[13], 0, 7)) as u8,
(__gen_unuint(input[13], 8, 15)) as u8,
(__gen_unuint(input[13], 16, 23)) as u8,
(__gen_unuint(input[13], 24, 31)) as u8,
(__gen_unuint(input[14], 0, 7)) as u8,
(__gen_unuint(input[14], 8, 15)) as u8,
(__gen_unuint(input[14], 16, 23)) as u8,
(__gen_unuint(input[14], 24, 31)) as u8,
(__gen_unuint(input[15], 0, 7)) as u8,
(__gen_unuint(input[15], 8, 15)) as u8,
(__gen_unuint(input[15], 16, 23)) as u8,
(__gen_unuint(input[15], 24, 31)) as u8,
(__gen_unuint(input[16], 0, 7)) as u8,
(__gen_unuint(input[16], 8, 15)) as u8,
(__gen_unuint(input[16], 16, 23)) as u8,
(__gen_unuint(input[16], 24, 31)) as u8,
(__gen_unuint(input[17], 0, 7)) as u8,
(__gen_unuint(input[17], 8, 15)) as u8,
(__gen_unuint(input[17], 16, 23)) as u8,
(__gen_unuint(input[17], 24, 31)) as u8,
(__gen_unuint(input[18], 0, 7)) as u8,
(__gen_unuint(input[18], 8, 15)) as u8,
(__gen_unuint(input[18], 16, 23)) as u8,
(__gen_unuint(input[18], 24, 31)) as u8,
(__gen_unuint(input[19], 0, 7)) as u8,
(__gen_unuint(input[19], 8, 15)) as u8,
(__gen_unuint(input[19], 16, 23)) as u8,
(__gen_unuint(input[19], 24, 31)) as u8,
(__gen_unuint(input[20], 0, 7)) as u8,
(__gen_unuint(input[20], 8, 15)) as u8,
(__gen_unuint(input[20], 16, 23)) as u8,
(__gen_unuint(input[20], 24, 31)) as u8,
(__gen_unuint(input[21], 0, 7)) as u8,
(__gen_unuint(input[21], 8, 15)) as u8,
(__gen_unuint(input[21], 16, 23)) as u8,
(__gen_unuint(input[21], 24, 31)) as u8,
(__gen_unuint(input[22], 0, 7)) as u8,
(__gen_unuint(input[22], 8, 15)) as u8,
(__gen_unuint(input[22], 16, 23)) as u8,
(__gen_unuint(input[22], 24, 31)) as u8,
(__gen_unuint(input[23], 0, 7)) as u8,
(__gen_unuint(input[23], 8, 15)) as u8,
(__gen_unuint(input[23], 16, 23)) as u8,
(__gen_unuint(input[23], 24, 31)) as u8,
(__gen_unuint(input[24], 0, 7)) as u8,
(__gen_unuint(input[24], 8, 15)) as u8,
(__gen_unuint(input[24], 16, 23)) as u8,
(__gen_unuint(input[24], 24, 31)) as u8,
(__gen_unuint(input[25], 0, 7)) as u8,
(__gen_unuint(input[25], 8, 15)) as u8,
(__gen_unuint(input[25], 16, 23)) as u8,
(__gen_unuint(input[25], 24, 31)) as u8,
(__gen_unuint(input[26], 0, 7)) as u8,
(__gen_unuint(input[26], 8, 15)) as u8,
(__gen_unuint(input[26], 16, 23)) as u8,
(__gen_unuint(input[26], 24, 31)) as u8,
(__gen_unuint(input[27], 0, 7)) as u8,
(__gen_unuint(input[27], 8, 15)) as u8,
(__gen_unuint(input[27], 16, 23)) as u8,
(__gen_unuint(input[27], 24, 31)) as u8,
(__gen_unuint(input[28], 0, 7)) as u8,
(__gen_unuint(input[28], 8, 15)) as u8,
(__gen_unuint(input[28], 16, 23)) as u8,
(__gen_unuint(input[28], 24, 31)) as u8,
(__gen_unuint(input[29], 0, 7)) as u8,
(__gen_unuint(input[29], 8, 15)) as u8,
(__gen_unuint(input[29], 16, 23)) as u8,
(__gen_unuint(input[29], 24, 31)) as u8,
(__gen_unuint(input[30], 0, 7)) as u8,
(__gen_unuint(input[30], 8, 15)) as u8,
(__gen_unuint(input[30], 16, 23)) as u8,
(__gen_unuint(input[30], 24, 31)) as u8,
(__gen_unuint(input[31], 0, 7)) as u8,
(__gen_unuint(input[31], 8, 15)) as u8,
(__gen_unuint(input[31], 16, 23)) as u8,
(__gen_unuint(input[31], 24, 31)) as u8,
(__gen_unuint(input[32], 0, 7)) as u8,
(__gen_unuint(input[32], 8, 15)) as u8,
(__gen_unuint(input[32], 16, 23)) as u8,
(__gen_unuint(input[32], 24, 31)) as u8,
(__gen_unuint(input[33], 0, 7)) as u8,
(__gen_unuint(input[33], 8, 15)) as u8,
(__gen_unuint(input[33], 16, 23)) as u8,
(__gen_unuint(input[33], 24, 31)) as u8
],
}
}
}
impl Deserialize for MfxQmState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 34];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 34] as *mut [u8; 136]) })?;
Ok((&input).into())
}
}
pub struct MfxStatePointer {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub state_pointer_index: u32,
pub state_pointer: u32,
}
impl MfxStatePointer {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for MfxStatePointer {
fn default() -> Self {
MfxStatePointer {
dword_length: 0,
subopcode_b: 6,
subopcode_a: 0,
media_command_opcode: 0,
pipeline: 2,
command_type: 3,
state_pointer_index: Default::default(),
state_pointer: Default::default(),
}
}
}
impl Serialize for MfxStatePointer {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.state_pointer_index, 0, 1) |
__gen_uint(self.state_pointer, 5, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for MfxStatePointer {
fn from(input: &[u32; 2]) -> Self {
MfxStatePointer {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
state_pointer_index: __gen_unuint(input[1], 0, 1),
state_pointer: __gen_unuint(input[1], 5, 31),
}
}
}
impl Deserialize for MfxStatePointer {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct MfxStitchObject {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub end_of_slice: bool,
pub last_header: bool,
pub source_data_ending_bit_inclusion: u32,
pub source_data_starting_byte_offset: u32,
pub indirect_data_length: u32,
pub indirect_data_start_address: u64,
}
impl MfxStitchObject {
pub const DWORD_LENGTH: u32 = 4;
}
impl Default for MfxStitchObject {
fn default() -> Self {
MfxStitchObject {
dword_length: 0,
subopcode_b: 10,
subopcode_a: 2,
media_command_opcode: 0,
pipeline: 2,
command_type: 3,
end_of_slice: Default::default(),
last_header: Default::default(),
source_data_ending_bit_inclusion: Default::default(),
source_data_starting_byte_offset: Default::default(),
indirect_data_length: Default::default(),
indirect_data_start_address: Default::default(),
}
}
}
impl Serialize for MfxStitchObject {
type Out = [u32; 4];
fn pack_into(&self, out: &mut [u32; 4]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.end_of_slice.into(), 1, 1) |
__gen_uint(self.last_header.into(), 2, 2) |
__gen_uint(self.source_data_ending_bit_inclusion, 8, 13) |
__gen_uint(self.source_data_starting_byte_offset, 16, 17);
out[2] = __gen_uint(self.indirect_data_length, 0, 18);
out[3] = __gen_offset(self.indirect_data_start_address as u32, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 4];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 4] as *const [u8; 16]) })
}
}
impl From<&[u32; 4]> for MfxStitchObject {
fn from(input: &[u32; 4]) -> Self {
MfxStitchObject {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
end_of_slice: __gen_unuint(input[1], 1, 1) != 0,
last_header: __gen_unuint(input[1], 2, 2) != 0,
source_data_ending_bit_inclusion: __gen_unuint(input[1], 8, 13),
source_data_starting_byte_offset: __gen_unuint(input[1], 16, 17),
indirect_data_length: __gen_unuint(input[2], 0, 18),
indirect_data_start_address: (__gen_unuint(input[3], 0, 31) as u64),
}
}
}
impl Deserialize for MfxStitchObject {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 4];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 4] as *mut [u8; 16]) })?;
Ok((&input).into())
}
}
pub struct MfxSurfaceState {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub cr_v_cb_u_pixel_offset_v_direction: u32,
pub width: u32,
pub height: u32,
pub tile_walk: u32,
pub tiled_surface: bool,
pub half_pitch_for_chroma: bool,
pub surface_pitch: u32,
pub interleave_chroma: bool,
pub surface_format: u32,
pub y_offset_for_u_cb: u32,
pub x_offset_for_u_cb: u32,
pub y_offset_for_v_cr: u32,
pub x_offset_for_v_cr: u32,
}
impl MfxSurfaceState {
pub const DWORD_LENGTH: u32 = 6;
pub const PLANAR_411_8: u32 = 5;
pub const PLANAR_420_8: u32 = 4;
pub const PLANAR_422_8: u32 = 6;
pub const R10G10B10A2_UNORM: u32 = 8;
pub const R8B8_UNORM_CRCB: u32 = 10;
pub const R8G8B8A8_UNORM: u32 = 9;
pub const R8_UNORM_CR_CB: u32 = 11;
pub const STMM_DN_STATISTICS: u32 = 7;
pub const XMAJOR: u32 = 0;
pub const Y8_UNORM: u32 = 12;
pub const YCRCB_NORMAL: u32 = 0;
pub const YCRCB_SWAPUV: u32 = 2;
pub const YCRCB_SWAPUVY: u32 = 1;
pub const YCRCB_SWAPY: u32 = 3;
pub const YMAJOR: u32 = 1;
}
impl Default for MfxSurfaceState {
fn default() -> Self {
MfxSurfaceState {
dword_length: 4,
subopcode_b: 1,
subopcode_a: 0,
media_command_opcode: 0,
pipeline: 2,
command_type: 3,
cr_v_cb_u_pixel_offset_v_direction: Default::default(),
width: Default::default(),
height: Default::default(),
tile_walk: Default::default(),
tiled_surface: Default::default(),
half_pitch_for_chroma: Default::default(),
surface_pitch: Default::default(),
interleave_chroma: Default::default(),
surface_format: Default::default(),
y_offset_for_u_cb: Default::default(),
x_offset_for_u_cb: Default::default(),
y_offset_for_v_cr: Default::default(),
x_offset_for_v_cr: Default::default(),
}
}
}
impl Serialize for MfxSurfaceState {
type Out = [u32; 6];
fn pack_into(&self, out: &mut [u32; 6]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = 0;
out[2] = __gen_uint(self.cr_v_cb_u_pixel_offset_v_direction, 0, 1) |
__gen_uint(self.width, 4, 17) |
__gen_uint(self.height, 18, 31);
out[3] = __gen_uint(self.tile_walk, 0, 0) |
__gen_uint(self.tiled_surface.into(), 1, 1) |
__gen_uint(self.half_pitch_for_chroma.into(), 2, 2) |
__gen_uint(self.surface_pitch, 3, 19) |
__gen_uint(self.interleave_chroma.into(), 27, 27) |
__gen_uint(self.surface_format, 28, 31);
out[4] = __gen_uint(self.y_offset_for_u_cb, 0, 14) |
__gen_uint(self.x_offset_for_u_cb, 16, 30);
out[5] = __gen_uint(self.y_offset_for_v_cr, 0, 15) |
__gen_uint(self.x_offset_for_v_cr, 16, 28);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 6];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 6] as *const [u8; 24]) })
}
}
impl From<&[u32; 6]> for MfxSurfaceState {
fn from(input: &[u32; 6]) -> Self {
MfxSurfaceState {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
cr_v_cb_u_pixel_offset_v_direction: __gen_unuint(input[2], 0, 1),
width: __gen_unuint(input[2], 4, 17),
height: __gen_unuint(input[2], 18, 31),
tile_walk: __gen_unuint(input[3], 0, 0),
tiled_surface: __gen_unuint(input[3], 1, 1) != 0,
half_pitch_for_chroma: __gen_unuint(input[3], 2, 2) != 0,
surface_pitch: __gen_unuint(input[3], 3, 19),
interleave_chroma: __gen_unuint(input[3], 27, 27) != 0,
surface_format: __gen_unuint(input[3], 28, 31),
y_offset_for_u_cb: __gen_unuint(input[4], 0, 14),
x_offset_for_u_cb: __gen_unuint(input[4], 16, 30),
y_offset_for_v_cr: __gen_unuint(input[5], 0, 15),
x_offset_for_v_cr: __gen_unuint(input[5], 16, 28),
}
}
}
impl Deserialize for MfxSurfaceState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 6];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 6] as *mut [u8; 24]) })?;
Ok((&input).into())
}
}
pub struct MfxVc1DirectmodeState<A: Addr + Default> {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub direct_mv_write_buffer_cacheability_control: u32,
pub direct_mv_write_buffer_graphics_data_type: u32,
pub direct_mv_write_buffer_arbitration_priority_control: u32,
pub direct_mv_write_buffer_address: A,
pub direct_mv_read_buffer_cacheability_control: u32,
pub direct_mv_read_buffer_graphics_data_type: u32,
pub direct_mv_read_buffer_arbitration_priority_control: u32,
pub direct_mv_read_buffer_address: A,
}
impl<A: Addr + Default> MfxVc1DirectmodeState<A> {
pub const DWORD_LENGTH: u32 = 3;
pub const BOTH_LLC_AND_MLC: u32 = 3;
pub const GTT_ENTRY: u32 = 0;
pub const HIGHEST_PRIORITY: u32 = 0;
pub const IN_LLC_BUT_NOT_MLC: u32 = 2;
pub const LOWEST_PRIORITY: u32 = 3;
pub const NOT_IN_LLC_OR_MLC: u32 = 1;
pub const SECOND_HIGHEST_PRIORITY: u32 = 1;
pub const THIRD_HIGHEST_PRIORITY: u32 = 2;
}
impl<A: Addr + Default> Default for MfxVc1DirectmodeState<A> {
fn default() -> Self {
MfxVc1DirectmodeState {
dword_length: 1,
subopcode_b: 2,
subopcode_a: 0,
media_command_opcode: 2,
pipeline: 2,
command_type: 3,
direct_mv_write_buffer_cacheability_control: Default::default(),
direct_mv_write_buffer_graphics_data_type: Default::default(),
direct_mv_write_buffer_arbitration_priority_control: Default::default(),
direct_mv_write_buffer_address: Default::default(),
direct_mv_read_buffer_cacheability_control: Default::default(),
direct_mv_read_buffer_graphics_data_type: Default::default(),
direct_mv_read_buffer_arbitration_priority_control: Default::default(),
direct_mv_read_buffer_address: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for MfxVc1DirectmodeState<A> {
type Out = [u32; 3];
fn pack_into(&self, out: &mut [u32; 3]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
let v1 = __gen_uint(self.direct_mv_write_buffer_cacheability_control, 0, 1) |
__gen_uint(self.direct_mv_write_buffer_graphics_data_type, 2, 2) |
__gen_uint(self.direct_mv_write_buffer_arbitration_priority_control, 4, 5);
let v1_address = self.direct_mv_write_buffer_address.combine(v1);
out[1] = v1_address as u32;
out[2] = (v1_address >> 32) as u32;
let v2 = __gen_uint(self.direct_mv_read_buffer_cacheability_control, 0, 1) |
__gen_uint(self.direct_mv_read_buffer_graphics_data_type, 2, 2) |
__gen_uint(self.direct_mv_read_buffer_arbitration_priority_control, 4, 5);
let v2_address = self.direct_mv_read_buffer_address.combine(v2);
out[2] = v2_address as u32;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 3];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 3] as *const [u8; 12]) })
}
}
impl From<&[u32; 3]> for MfxVc1DirectmodeState<u64> {
fn from(input: &[u32; 3]) -> Self {
MfxVc1DirectmodeState {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
direct_mv_write_buffer_cacheability_control: __gen_unuint(input[1], 0, 1),
direct_mv_write_buffer_graphics_data_type: __gen_unuint(input[1], 2, 2),
direct_mv_write_buffer_arbitration_priority_control: __gen_unuint(input[1], 4, 5),
direct_mv_write_buffer_address: (__gen_unuint(input[1], 6, 31) as u64) << 6,
direct_mv_read_buffer_cacheability_control: __gen_unuint(input[2], 0, 1),
direct_mv_read_buffer_graphics_data_type: __gen_unuint(input[2], 2, 2),
direct_mv_read_buffer_arbitration_priority_control: __gen_unuint(input[2], 4, 5),
direct_mv_read_buffer_address: (__gen_unuint(input[2], 6, 31) as u64) << 6,
}
}
}
impl Deserialize for MfxVc1DirectmodeState<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 3];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 3] as *mut [u8; 12]) })?;
Ok((&input).into())
}
}
pub struct MfxVc1PredPipeState {
pub dword_length: u32,
pub subopcode_b: u32,
pub subopcode_a: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub reference_frame_boundary_replication_mode: u32,
pub vin_intensitycomp_single_bwden: u32,
pub vin_intensitycomp_single_fwden: u32,
pub vin_intensitycomp_double_bwden: u32,
pub vin_intensitycomp_double_fwden: u32,
pub lumscale1_single_fwd: u32,
pub lumscale2_single_fwd: u32,
pub lumshift1_single_fwd: u32,
pub lumshift2_single_fwd: u32,
pub lumscale1_double_fwd: u32,
pub lumscale2_double_fwd: u32,
pub lumshift1_double_fwd: u32,
pub lumshift2_double_fwd: u32,
pub lumscale1_single_bwd: u32,
pub lumscale2_single_bwd: u32,
pub lumshift1_single_bwd: u32,
pub lumshift2_single_bwd: u32,
pub lumscale1_double_bwd: u32,
pub lumscale2_double_bwd: u32,
pub lumshift1_double_bwd: u32,
pub lumshift2_double_bwd: u32,
}
impl MfxVc1PredPipeState {
pub const DWORD_LENGTH: u32 = 6;
}
impl Default for MfxVc1PredPipeState {
fn default() -> Self {
MfxVc1PredPipeState {
dword_length: 4,
subopcode_b: 1,
subopcode_a: 0,
media_command_opcode: 2,
pipeline: 2,
command_type: 3,
reference_frame_boundary_replication_mode: Default::default(),
vin_intensitycomp_single_bwden: Default::default(),
vin_intensitycomp_single_fwden: Default::default(),
vin_intensitycomp_double_bwden: Default::default(),
vin_intensitycomp_double_fwden: Default::default(),
lumscale1_single_fwd: Default::default(),
lumscale2_single_fwd: Default::default(),
lumshift1_single_fwd: Default::default(),
lumshift2_single_fwd: Default::default(),
lumscale1_double_fwd: Default::default(),
lumscale2_double_fwd: Default::default(),
lumshift1_double_fwd: Default::default(),
lumshift2_double_fwd: Default::default(),
lumscale1_single_bwd: Default::default(),
lumscale2_single_bwd: Default::default(),
lumshift1_single_bwd: Default::default(),
lumshift2_single_bwd: Default::default(),
lumscale1_double_bwd: Default::default(),
lumscale2_double_bwd: Default::default(),
lumshift1_double_bwd: Default::default(),
lumshift2_double_bwd: Default::default(),
}
}
}
impl Serialize for MfxVc1PredPipeState {
type Out = [u32; 6];
fn pack_into(&self, out: &mut [u32; 6]) {
out[0] = __gen_uint(self.dword_length, 0, 11) |
__gen_uint(self.subopcode_b, 16, 20) |
__gen_uint(self.subopcode_a, 21, 23) |
__gen_uint(self.media_command_opcode, 24, 26) |
__gen_uint(self.pipeline, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.reference_frame_boundary_replication_mode, 4, 7) |
__gen_uint(self.vin_intensitycomp_single_bwden, 8, 9) |
__gen_uint(self.vin_intensitycomp_single_fwden, 10, 11) |
__gen_uint(self.vin_intensitycomp_double_bwden, 12, 13) |
__gen_uint(self.vin_intensitycomp_double_fwden, 14, 15);
out[2] = __gen_uint(self.lumscale1_single_fwd, 0, 5) |
__gen_uint(self.lumscale2_single_fwd, 8, 13) |
__gen_uint(self.lumshift1_single_fwd, 16, 21) |
__gen_uint(self.lumshift2_single_fwd, 24, 29);
out[3] = __gen_uint(self.lumscale1_double_fwd, 0, 5) |
__gen_uint(self.lumscale2_double_fwd, 8, 13) |
__gen_uint(self.lumshift1_double_fwd, 16, 21) |
__gen_uint(self.lumshift2_double_fwd, 24, 29);
out[4] = __gen_uint(self.lumscale1_single_bwd, 0, 5) |
__gen_uint(self.lumscale2_single_bwd, 8, 13) |
__gen_uint(self.lumshift1_single_bwd, 16, 21) |
__gen_uint(self.lumshift2_single_bwd, 24, 29);
out[5] = __gen_uint(self.lumscale1_double_bwd, 0, 5) |
__gen_uint(self.lumscale2_double_bwd, 8, 13) |
__gen_uint(self.lumshift1_double_bwd, 16, 21) |
__gen_uint(self.lumshift2_double_bwd, 24, 29);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 6];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 6] as *const [u8; 24]) })
}
}
impl From<&[u32; 6]> for MfxVc1PredPipeState {
fn from(input: &[u32; 6]) -> Self {
MfxVc1PredPipeState {
dword_length: __gen_unuint(input[0], 0, 11),
subopcode_b: __gen_unuint(input[0], 16, 20),
subopcode_a: __gen_unuint(input[0], 21, 23),
media_command_opcode: __gen_unuint(input[0], 24, 26),
pipeline: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
reference_frame_boundary_replication_mode: __gen_unuint(input[1], 4, 7),
vin_intensitycomp_single_bwden: __gen_unuint(input[1], 8, 9),
vin_intensitycomp_single_fwden: __gen_unuint(input[1], 10, 11),
vin_intensitycomp_double_bwden: __gen_unuint(input[1], 12, 13),
vin_intensitycomp_double_fwden: __gen_unuint(input[1], 14, 15),
lumscale1_single_fwd: __gen_unuint(input[2], 0, 5),
lumscale2_single_fwd: __gen_unuint(input[2], 8, 13),
lumshift1_single_fwd: __gen_unuint(input[2], 16, 21),
lumshift2_single_fwd: __gen_unuint(input[2], 24, 29),
lumscale1_double_fwd: __gen_unuint(input[3], 0, 5),
lumscale2_double_fwd: __gen_unuint(input[3], 8, 13),
lumshift1_double_fwd: __gen_unuint(input[3], 16, 21),
lumshift2_double_fwd: __gen_unuint(input[3], 24, 29),
lumscale1_single_bwd: __gen_unuint(input[4], 0, 5),
lumscale2_single_bwd: __gen_unuint(input[4], 8, 13),
lumshift1_single_bwd: __gen_unuint(input[4], 16, 21),
lumshift2_single_bwd: __gen_unuint(input[4], 24, 29),
lumscale1_double_bwd: __gen_unuint(input[5], 0, 5),
lumscale2_double_bwd: __gen_unuint(input[5], 8, 13),
lumshift1_double_bwd: __gen_unuint(input[5], 16, 21),
lumshift2_double_bwd: __gen_unuint(input[5], 24, 29),
}
}
}
impl Deserialize for MfxVc1PredPipeState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 6];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 6] as *mut [u8; 24]) })?;
Ok((&input).into())
}
}
pub struct MfxWait {
pub dword_length: u32,
pub mfx_sync_control_flag: bool,
pub subopcode: u32,
pub command_subtype: u32,
pub command_type: u32,
}
impl MfxWait {
pub const DWORD_LENGTH: u32 = 1;
}
impl Default for MfxWait {
fn default() -> Self {
MfxWait {
dword_length: 0,
mfx_sync_control_flag: Default::default(),
subopcode: 0,
command_subtype: 1,
command_type: 3,
}
}
}
impl Serialize for MfxWait {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.dword_length, 0, 5) |
__gen_uint(self.mfx_sync_control_flag.into(), 8, 8) |
__gen_uint(self.subopcode, 16, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for MfxWait {
fn from(input: &[u32; 1]) -> Self {
MfxWait {
dword_length: __gen_unuint(input[0], 0, 5),
mfx_sync_control_flag: __gen_unuint(input[0], 8, 8) != 0,
subopcode: __gen_unuint(input[0], 16, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
}
}
}
impl Deserialize for MfxWait {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct MiArbCheck {
pub mi_command_opcode: u32,
pub command_type: u32,
}
impl MiArbCheck {
pub const DWORD_LENGTH: u32 = 1;
}
impl Default for MiArbCheck {
fn default() -> Self {
MiArbCheck {
mi_command_opcode: 5,
command_type: 0,
}
}
}
impl Serialize for MiArbCheck {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.mi_command_opcode, 23, 28) |
__gen_uint(self.command_type, 29, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for MiArbCheck {
fn from(input: &[u32; 1]) -> Self {
MiArbCheck {
mi_command_opcode: __gen_unuint(input[0], 23, 28),
command_type: __gen_unuint(input[0], 29, 31),
}
}
}
impl Deserialize for MiArbCheck {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct MiArbOnOff {
pub arbitration_enable: bool,
pub mi_command_opcode: u32,
pub command_type: u32,
}
impl MiArbOnOff {
pub const DWORD_LENGTH: u32 = 1;
}
impl Default for MiArbOnOff {
fn default() -> Self {
MiArbOnOff {
arbitration_enable: Default::default(),
mi_command_opcode: 8,
command_type: 0,
}
}
}
impl Serialize for MiArbOnOff {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.arbitration_enable.into(), 0, 0) |
__gen_uint(self.mi_command_opcode, 23, 28) |
__gen_uint(self.command_type, 29, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for MiArbOnOff {
fn from(input: &[u32; 1]) -> Self {
MiArbOnOff {
arbitration_enable: __gen_unuint(input[0], 0, 0) != 0,
mi_command_opcode: __gen_unuint(input[0], 23, 28),
command_type: __gen_unuint(input[0], 29, 31),
}
}
}
impl Deserialize for MiArbOnOff {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct MiBatchBufferEnd {
pub mi_command_opcode: u32,
pub command_type: u32,
}
impl MiBatchBufferEnd {
pub const DWORD_LENGTH: u32 = 1;
}
impl Default for MiBatchBufferEnd {
fn default() -> Self {
MiBatchBufferEnd {
mi_command_opcode: 10,
command_type: 0,
}
}
}
impl Serialize for MiBatchBufferEnd {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.mi_command_opcode, 23, 28) |
__gen_uint(self.command_type, 29, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for MiBatchBufferEnd {
fn from(input: &[u32; 1]) -> Self {
MiBatchBufferEnd {
mi_command_opcode: __gen_unuint(input[0], 23, 28),
command_type: __gen_unuint(input[0], 29, 31),
}
}
}
impl Deserialize for MiBatchBufferEnd {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct MiBatchBufferStart<A: Addr + Default> {
pub dword_length: u32,
pub address_space_indicator: u32,
pub clear_command_buffer_enable: bool,
pub mi_command_opcode: u32,
pub command_type: u32,
pub batch_buffer_start_address: A,
}
impl<A: Addr + Default> MiBatchBufferStart<A> {
pub const DWORD_LENGTH: u32 = 2;
pub const GGTT: u32 = 0;
pub const PPGTT: u32 = 1;
}
impl<A: Addr + Default> Default for MiBatchBufferStart<A> {
fn default() -> Self {
MiBatchBufferStart {
dword_length: 0,
address_space_indicator: Default::default(),
clear_command_buffer_enable: Default::default(),
mi_command_opcode: 49,
command_type: 0,
batch_buffer_start_address: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for MiBatchBufferStart<A> {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self.address_space_indicator, 8, 8) |
__gen_uint(self.clear_command_buffer_enable.into(), 11, 11) |
__gen_uint(self.mi_command_opcode, 23, 28) |
__gen_uint(self.command_type, 29, 31);
let v1_address = self.batch_buffer_start_address.combine(0);
out[1] = v1_address as u32;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for MiBatchBufferStart<u64> {
fn from(input: &[u32; 2]) -> Self {
MiBatchBufferStart {
dword_length: __gen_unuint(input[0], 0, 7),
address_space_indicator: __gen_unuint(input[0], 8, 8),
clear_command_buffer_enable: __gen_unuint(input[0], 11, 11) != 0,
mi_command_opcode: __gen_unuint(input[0], 23, 28),
command_type: __gen_unuint(input[0], 29, 31),
batch_buffer_start_address: (__gen_unuint(input[1], 2, 31) as u64) << 2,
}
}
}
impl Deserialize for MiBatchBufferStart<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct MiClflush<A: Addr + Default> {
pub dword_length: u32,
pub use_global_gtt: bool,
pub mi_command_opcode: u32,
pub command_type: u32,
pub starting_cacheline_offset: u32,
pub page_base_address: A,
pub page_base_address_high: A,
}
impl<A: Addr + Default> MiClflush<A> {
pub const DWORD_LENGTH: u32 = 3;
}
impl<A: Addr + Default> Default for MiClflush<A> {
fn default() -> Self {
MiClflush {
dword_length: 1,
use_global_gtt: Default::default(),
mi_command_opcode: 39,
command_type: 0,
starting_cacheline_offset: Default::default(),
page_base_address: Default::default(),
page_base_address_high: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for MiClflush<A> {
type Out = [u32; 3];
fn pack_into(&self, out: &mut [u32; 3]) {
out[0] = __gen_uint(self.dword_length, 0, 9) |
__gen_uint(self.use_global_gtt.into(), 22, 22) |
__gen_uint(self.mi_command_opcode, 23, 28) |
__gen_uint(self.command_type, 29, 31);
let v1 = __gen_uint(self.starting_cacheline_offset, 6, 11);
let v1_address = self.page_base_address.combine(v1);
out[1] = v1_address as u32;
out[2] = (v1_address >> 32) as u32;
let v2_address = self.page_base_address_high.combine(0);
out[2] = v2_address as u32;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 3];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 3] as *const [u8; 12]) })
}
}
impl From<&[u32; 3]> for MiClflush<u64> {
fn from(input: &[u32; 3]) -> Self {
MiClflush {
dword_length: __gen_unuint(input[0], 0, 9),
use_global_gtt: __gen_unuint(input[0], 22, 22) != 0,
mi_command_opcode: __gen_unuint(input[0], 23, 28),
command_type: __gen_unuint(input[0], 29, 31),
starting_cacheline_offset: __gen_unuint(input[1], 6, 11),
page_base_address: (__gen_unuint(input[1], 12, 31) as u64) << 12,
page_base_address_high: (__gen_unuint(input[2], 0, 15) as u64),
}
}
}
impl Deserialize for MiClflush<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 3];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 3] as *mut [u8; 12]) })?;
Ok((&input).into())
}
}
pub struct MiConditionalBatchBufferEnd<A: Addr + Default> {
pub dword_length: u32,
pub compare_semaphore: u32,
pub use_global_gtt: bool,
pub mi_command_opcode: u32,
pub command_type: u32,
pub compare_data_dword: u32,
pub compare_address: A,
}
impl<A: Addr + Default> MiConditionalBatchBufferEnd<A> {
pub const DWORD_LENGTH: u32 = 3;
}
impl<A: Addr + Default> Default for MiConditionalBatchBufferEnd<A> {
fn default() -> Self {
MiConditionalBatchBufferEnd {
dword_length: 0,
compare_semaphore: 0,
use_global_gtt: Default::default(),
mi_command_opcode: 54,
command_type: 0,
compare_data_dword: Default::default(),
compare_address: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for MiConditionalBatchBufferEnd<A> {
type Out = [u32; 3];
fn pack_into(&self, out: &mut [u32; 3]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self.compare_semaphore, 21, 21) |
__gen_uint(self.use_global_gtt.into(), 22, 22) |
__gen_uint(self.mi_command_opcode, 23, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.compare_data_dword, 0, 31);
let v2_address = self.compare_address.combine(0);
out[2] = v2_address as u32;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 3];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 3] as *const [u8; 12]) })
}
}
impl From<&[u32; 3]> for MiConditionalBatchBufferEnd<u64> {
fn from(input: &[u32; 3]) -> Self {
MiConditionalBatchBufferEnd {
dword_length: __gen_unuint(input[0], 0, 7),
compare_semaphore: __gen_unuint(input[0], 21, 21),
use_global_gtt: __gen_unuint(input[0], 22, 22) != 0,
mi_command_opcode: __gen_unuint(input[0], 23, 28),
command_type: __gen_unuint(input[0], 29, 31),
compare_data_dword: __gen_unuint(input[1], 0, 31),
compare_address: (__gen_unuint(input[2], 3, 31) as u64) << 3,
}
}
}
impl Deserialize for MiConditionalBatchBufferEnd<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 3];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 3] as *mut [u8; 12]) })?;
Ok((&input).into())
}
}
pub struct MiFlush {
pub state_instruction_cache_invalidate: u32,
pub render_cache_flush_inhibit: u32,
pub global_snapshot_count_reset: u32,
pub generic_media_state_clear: bool,
pub indirect_state_pointers_disable: bool,
pub mi_command_opcode: u32,
pub command_type: u32,
}
impl MiFlush {
pub const DWORD_LENGTH: u32 = 1;
pub const DON_T_FLUSH: u32 = 1;
pub const DON_T_INVALIDATE: u32 = 0;
pub const DON_T_RESET: u32 = 0;
pub const FLUSH: u32 = 0;
pub const INVALIDATE: u32 = 1;
pub const RESET: u32 = 1;
}
impl Default for MiFlush {
fn default() -> Self {
MiFlush {
state_instruction_cache_invalidate: Default::default(),
render_cache_flush_inhibit: Default::default(),
global_snapshot_count_reset: Default::default(),
generic_media_state_clear: Default::default(),
indirect_state_pointers_disable: Default::default(),
mi_command_opcode: 4,
command_type: 0,
}
}
}
impl Serialize for MiFlush {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.state_instruction_cache_invalidate, 1, 1) |
__gen_uint(self.render_cache_flush_inhibit, 2, 2) |
__gen_uint(self.global_snapshot_count_reset, 3, 3) |
__gen_uint(self.generic_media_state_clear.into(), 4, 4) |
__gen_uint(self.indirect_state_pointers_disable.into(), 5, 5) |
__gen_uint(self.mi_command_opcode, 23, 28) |
__gen_uint(self.command_type, 29, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for MiFlush {
fn from(input: &[u32; 1]) -> Self {
MiFlush {
state_instruction_cache_invalidate: __gen_unuint(input[0], 1, 1),
render_cache_flush_inhibit: __gen_unuint(input[0], 2, 2),
global_snapshot_count_reset: __gen_unuint(input[0], 3, 3),
generic_media_state_clear: __gen_unuint(input[0], 4, 4) != 0,
indirect_state_pointers_disable: __gen_unuint(input[0], 5, 5) != 0,
mi_command_opcode: __gen_unuint(input[0], 23, 28),
command_type: __gen_unuint(input[0], 29, 31),
}
}
}
impl Deserialize for MiFlush {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct MiFlushDw<A: Addr + Default> {
pub dword_length: u32,
pub video_pipeline_cache_invalidate: bool,
pub notify_enable: bool,
pub post_sync_operation: u32,
pub synchronize_gfdt_surface: bool,
pub tlb_invalidate: bool,
pub store_data_index: bool,
pub mi_command_opcode: u32,
pub command_type: u32,
pub destination_address_type: u32,
pub address: A,
pub immediate_data: [u32; 2],
}
impl<A: Addr + Default> MiFlushDw<A> {
pub const DWORD_LENGTH: u32 = 4;
pub const GGTT: u32 = 1;
pub const PPGTT: u32 = 0;
}
impl<A: Addr + Default> Default for MiFlushDw<A> {
fn default() -> Self {
MiFlushDw {
dword_length: Default::default(),
video_pipeline_cache_invalidate: Default::default(),
notify_enable: Default::default(),
post_sync_operation: Default::default(),
synchronize_gfdt_surface: Default::default(),
tlb_invalidate: Default::default(),
store_data_index: Default::default(),
mi_command_opcode: 38,
command_type: 0,
destination_address_type: Default::default(),
address: Default::default(),
immediate_data: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for MiFlushDw<A> {
type Out = [u32; 4];
fn pack_into(&self, out: &mut [u32; 4]) {
out[0] = __gen_uint(self.dword_length, 0, 5) |
__gen_uint(self.video_pipeline_cache_invalidate.into(), 7, 7) |
__gen_uint(self.notify_enable.into(), 8, 8) |
__gen_uint(self.post_sync_operation, 14, 15) |
__gen_uint(self.synchronize_gfdt_surface.into(), 17, 17) |
__gen_uint(self.tlb_invalidate.into(), 18, 18) |
__gen_uint(self.store_data_index.into(), 21, 21) |
__gen_uint(self.mi_command_opcode, 23, 28) |
__gen_uint(self.command_type, 29, 31);
let v1 = __gen_uint(self.destination_address_type, 2, 2);
let v1_address = self.address.combine(v1);
out[1] = v1_address as u32;
out[2] = (v1_address >> 32) as u32;
out[2] = __gen_uint(self.immediate_data[0], 0, 31);
out[3] = __gen_uint(self.immediate_data[1], 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 4];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 4] as *const [u8; 16]) })
}
}
impl From<&[u32; 4]> for MiFlushDw<u64> {
fn from(input: &[u32; 4]) -> Self {
MiFlushDw {
dword_length: __gen_unuint(input[0], 0, 5),
video_pipeline_cache_invalidate: __gen_unuint(input[0], 7, 7) != 0,
notify_enable: __gen_unuint(input[0], 8, 8) != 0,
post_sync_operation: __gen_unuint(input[0], 14, 15),
synchronize_gfdt_surface: __gen_unuint(input[0], 17, 17) != 0,
tlb_invalidate: __gen_unuint(input[0], 18, 18) != 0,
store_data_index: __gen_unuint(input[0], 21, 21) != 0,
mi_command_opcode: __gen_unuint(input[0], 23, 28),
command_type: __gen_unuint(input[0], 29, 31),
destination_address_type: __gen_unuint(input[1], 2, 2),
address: (__gen_unuint(input[1], 3, 31) as u64) << 3,
immediate_data: [
__gen_unuint(input[2], 0, 31),
__gen_unuint(input[3], 0, 31)
],
}
}
}
impl Deserialize for MiFlushDw<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 4];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 4] as *mut [u8; 16]) })?;
Ok((&input).into())
}
}
pub struct MiLoadRegisterImm {
pub dword_length: u32,
pub byte_write_disables: u32,
pub mi_command_opcode: u32,
pub command_type: u32,
pub register_offset: u64,
pub data_dword: u32,
}
impl MiLoadRegisterImm {
pub const DWORD_LENGTH: u32 = 3;
}
impl Default for MiLoadRegisterImm {
fn default() -> Self {
MiLoadRegisterImm {
dword_length: 1,
byte_write_disables: Default::default(),
mi_command_opcode: 34,
command_type: 0,
register_offset: Default::default(),
data_dword: Default::default(),
}
}
}
impl Serialize for MiLoadRegisterImm {
type Out = [u32; 3];
fn pack_into(&self, out: &mut [u32; 3]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self.byte_write_disables, 8, 11) |
__gen_uint(self.mi_command_opcode, 23, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_offset(self.register_offset as u32, 2, 22);
out[2] = __gen_uint(self.data_dword, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 3];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 3] as *const [u8; 12]) })
}
}
impl From<&[u32; 3]> for MiLoadRegisterImm {
fn from(input: &[u32; 3]) -> Self {
MiLoadRegisterImm {
dword_length: __gen_unuint(input[0], 0, 7),
byte_write_disables: __gen_unuint(input[0], 8, 11),
mi_command_opcode: __gen_unuint(input[0], 23, 28),
command_type: __gen_unuint(input[0], 29, 31),
register_offset: (__gen_unuint(input[1], 2, 22) as u64) << 2,
data_dword: __gen_unuint(input[2], 0, 31),
}
}
}
impl Deserialize for MiLoadRegisterImm {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 3];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 3] as *mut [u8; 12]) })?;
Ok((&input).into())
}
}
pub struct MiLoadRegisterMem<A: Addr + Default> {
pub dword_length: u32,
pub async_mode_enable: bool,
pub use_global_gtt: bool,
pub mi_command_opcode: u32,
pub command_type: u32,
pub register_address: u64,
pub memory_address: A,
}
impl<A: Addr + Default> MiLoadRegisterMem<A> {
pub const DWORD_LENGTH: u32 = 3;
}
impl<A: Addr + Default> Default for MiLoadRegisterMem<A> {
fn default() -> Self {
MiLoadRegisterMem {
dword_length: 1,
async_mode_enable: Default::default(),
use_global_gtt: Default::default(),
mi_command_opcode: 41,
command_type: 0,
register_address: Default::default(),
memory_address: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for MiLoadRegisterMem<A> {
type Out = [u32; 3];
fn pack_into(&self, out: &mut [u32; 3]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self.async_mode_enable.into(), 21, 21) |
__gen_uint(self.use_global_gtt.into(), 22, 22) |
__gen_uint(self.mi_command_opcode, 23, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_offset(self.register_address as u32, 2, 22);
let v2_address = self.memory_address.combine(0);
out[2] = v2_address as u32;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 3];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 3] as *const [u8; 12]) })
}
}
impl From<&[u32; 3]> for MiLoadRegisterMem<u64> {
fn from(input: &[u32; 3]) -> Self {
MiLoadRegisterMem {
dword_length: __gen_unuint(input[0], 0, 7),
async_mode_enable: __gen_unuint(input[0], 21, 21) != 0,
use_global_gtt: __gen_unuint(input[0], 22, 22) != 0,
mi_command_opcode: __gen_unuint(input[0], 23, 28),
command_type: __gen_unuint(input[0], 29, 31),
register_address: (__gen_unuint(input[1], 2, 22) as u64) << 2,
memory_address: (__gen_unuint(input[2], 2, 31) as u64) << 2,
}
}
}
impl Deserialize for MiLoadRegisterMem<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 3];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 3] as *mut [u8; 12]) })?;
Ok((&input).into())
}
}
pub struct MiNoop {
pub identification_number: u32,
pub identification_number_register_write_enable: bool,
pub mi_command_opcode: u32,
pub command_type: u32,
}
impl MiNoop {
pub const DWORD_LENGTH: u32 = 1;
}
impl Default for MiNoop {
fn default() -> Self {
MiNoop {
identification_number: Default::default(),
identification_number_register_write_enable: Default::default(),
mi_command_opcode: 0,
command_type: 0,
}
}
}
impl Serialize for MiNoop {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.identification_number, 0, 21) |
__gen_uint(self.identification_number_register_write_enable.into(), 22, 22) |
__gen_uint(self.mi_command_opcode, 23, 28) |
__gen_uint(self.command_type, 29, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for MiNoop {
fn from(input: &[u32; 1]) -> Self {
MiNoop {
identification_number: __gen_unuint(input[0], 0, 21),
identification_number_register_write_enable: __gen_unuint(input[0], 22, 22) != 0,
mi_command_opcode: __gen_unuint(input[0], 23, 28),
command_type: __gen_unuint(input[0], 29, 31),
}
}
}
impl Deserialize for MiNoop {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct MiPredicate {
pub compare_operation: u32,
pub combine_operation: u32,
pub load_operation: u32,
pub mi_command_opcode: u32,
pub command_type: u32,
}
impl MiPredicate {
pub const DWORD_LENGTH: u32 = 1;
pub const AND: u32 = 1;
pub const DELTAS_EQUAL: u32 = 3;
pub const FALSE: u32 = 1;
pub const KEEP: u32 = 0;
pub const LOAD: u32 = 2;
pub const LOADINV: u32 = 3;
pub const OR: u32 = 2;
pub const SET: u32 = 0;
pub const SRCS_EQUAL: u32 = 2;
pub const TRUE: u32 = 0;
pub const XOR: u32 = 3;
}
impl Default for MiPredicate {
fn default() -> Self {
MiPredicate {
compare_operation: Default::default(),
combine_operation: Default::default(),
load_operation: Default::default(),
mi_command_opcode: 12,
command_type: 0,
}
}
}
impl Serialize for MiPredicate {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.compare_operation, 0, 1) |
__gen_uint(self.combine_operation, 3, 4) |
__gen_uint(self.load_operation, 6, 7) |
__gen_uint(self.mi_command_opcode, 23, 28) |
__gen_uint(self.command_type, 29, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for MiPredicate {
fn from(input: &[u32; 1]) -> Self {
MiPredicate {
compare_operation: __gen_unuint(input[0], 0, 1),
combine_operation: __gen_unuint(input[0], 3, 4),
load_operation: __gen_unuint(input[0], 6, 7),
mi_command_opcode: __gen_unuint(input[0], 23, 28),
command_type: __gen_unuint(input[0], 29, 31),
}
}
}
impl Deserialize for MiPredicate {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct MiReportHead {
pub mi_command_opcode: u32,
pub command_type: u32,
}
impl MiReportHead {
pub const DWORD_LENGTH: u32 = 1;
}
impl Default for MiReportHead {
fn default() -> Self {
MiReportHead {
mi_command_opcode: 7,
command_type: 0,
}
}
}
impl Serialize for MiReportHead {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.mi_command_opcode, 23, 28) |
__gen_uint(self.command_type, 29, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for MiReportHead {
fn from(input: &[u32; 1]) -> Self {
MiReportHead {
mi_command_opcode: __gen_unuint(input[0], 23, 28),
command_type: __gen_unuint(input[0], 29, 31),
}
}
}
impl Deserialize for MiReportHead {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct MiReportPerfCount<A: Addr + Default> {
pub dword_length: u32,
pub mi_command_opcode: u32,
pub command_type: u32,
pub use_global_gtt: bool,
pub memory_address: A,
pub report_id: u32,
}
impl<A: Addr + Default> MiReportPerfCount<A> {
pub const DWORD_LENGTH: u32 = 3;
}
impl<A: Addr + Default> Default for MiReportPerfCount<A> {
fn default() -> Self {
MiReportPerfCount {
dword_length: 1,
mi_command_opcode: 40,
command_type: 0,
use_global_gtt: Default::default(),
memory_address: Default::default(),
report_id: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for MiReportPerfCount<A> {
type Out = [u32; 3];
fn pack_into(&self, out: &mut [u32; 3]) {
out[0] = __gen_uint(self.dword_length, 0, 5) |
__gen_uint(self.mi_command_opcode, 23, 28) |
__gen_uint(self.command_type, 29, 31);
let v1 = __gen_uint(self.use_global_gtt.into(), 0, 0);
let v1_address = self.memory_address.combine(v1);
out[1] = v1_address as u32;
out[2] = (v1_address >> 32) as u32;
out[2] = __gen_uint(self.report_id, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 3];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 3] as *const [u8; 12]) })
}
}
impl From<&[u32; 3]> for MiReportPerfCount<u64> {
fn from(input: &[u32; 3]) -> Self {
MiReportPerfCount {
dword_length: __gen_unuint(input[0], 0, 5),
mi_command_opcode: __gen_unuint(input[0], 23, 28),
command_type: __gen_unuint(input[0], 29, 31),
use_global_gtt: __gen_unuint(input[1], 0, 0) != 0,
memory_address: (__gen_unuint(input[1], 6, 31) as u64) << 6,
report_id: __gen_unuint(input[2], 0, 31),
}
}
}
impl Deserialize for MiReportPerfCount<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 3];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 3] as *mut [u8; 12]) })?;
Ok((&input).into())
}
}
pub struct MiSemaphoreMbox {
pub dword_length: u32,
pub register_select: u32,
pub mi_command_opcode: u32,
pub command_type: u32,
pub semaphore_data_dword: u32,
}
impl MiSemaphoreMbox {
pub const DWORD_LENGTH: u32 = 3;
pub const RBSYNC: u32 = 2;
pub const RVSYNC: u32 = 0;
pub const USE_GENERAL_REGISTER_SELECT: u32 = 3;
}
impl Default for MiSemaphoreMbox {
fn default() -> Self {
MiSemaphoreMbox {
dword_length: 1,
register_select: Default::default(),
mi_command_opcode: 22,
command_type: 0,
semaphore_data_dword: Default::default(),
}
}
}
impl Serialize for MiSemaphoreMbox {
type Out = [u32; 3];
fn pack_into(&self, out: &mut [u32; 3]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self.register_select, 16, 17) |
__gen_uint(self.mi_command_opcode, 23, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.semaphore_data_dword, 0, 31);
out[2] = 0;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 3];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 3] as *const [u8; 12]) })
}
}
impl From<&[u32; 3]> for MiSemaphoreMbox {
fn from(input: &[u32; 3]) -> Self {
MiSemaphoreMbox {
dword_length: __gen_unuint(input[0], 0, 7),
register_select: __gen_unuint(input[0], 16, 17),
mi_command_opcode: __gen_unuint(input[0], 23, 28),
command_type: __gen_unuint(input[0], 29, 31),
semaphore_data_dword: __gen_unuint(input[1], 0, 31),
}
}
}
impl Deserialize for MiSemaphoreMbox {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 3];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 3] as *mut [u8; 12]) })?;
Ok((&input).into())
}
}
pub struct MiSetContext<A: Addr + Default> {
pub dword_length: u32,
pub mi_command_opcode: u32,
pub command_type: u32,
pub restore_inhibit: u32,
pub force_restore: u32,
pub extended_state_restore_enable: bool,
pub extended_state_save_enable: bool,
pub reserved_must_be_1: u32,
pub logical_context_address: A,
}
impl<A: Addr + Default> MiSetContext<A> {
pub const DWORD_LENGTH: u32 = 2;
}
impl<A: Addr + Default> Default for MiSetContext<A> {
fn default() -> Self {
MiSetContext {
dword_length: 0,
mi_command_opcode: 24,
command_type: 0,
restore_inhibit: Default::default(),
force_restore: Default::default(),
extended_state_restore_enable: Default::default(),
extended_state_save_enable: Default::default(),
reserved_must_be_1: Default::default(),
logical_context_address: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for MiSetContext<A> {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self.mi_command_opcode, 23, 28) |
__gen_uint(self.command_type, 29, 31);
let v1 = __gen_uint(self.restore_inhibit, 0, 0) |
__gen_uint(self.force_restore, 1, 1) |
__gen_uint(self.extended_state_restore_enable.into(), 2, 2) |
__gen_uint(self.extended_state_save_enable.into(), 3, 3) |
__gen_uint(self.reserved_must_be_1, 8, 8);
let v1_address = self.logical_context_address.combine(v1);
out[1] = v1_address as u32;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for MiSetContext<u64> {
fn from(input: &[u32; 2]) -> Self {
MiSetContext {
dword_length: __gen_unuint(input[0], 0, 7),
mi_command_opcode: __gen_unuint(input[0], 23, 28),
command_type: __gen_unuint(input[0], 29, 31),
restore_inhibit: __gen_unuint(input[1], 0, 0),
force_restore: __gen_unuint(input[1], 1, 1),
extended_state_restore_enable: __gen_unuint(input[1], 2, 2) != 0,
extended_state_save_enable: __gen_unuint(input[1], 3, 3) != 0,
reserved_must_be_1: __gen_unuint(input[1], 8, 8),
logical_context_address: (__gen_unuint(input[1], 12, 31) as u64) << 12,
}
}
}
impl Deserialize for MiSetContext<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct MiStoreDataImm<A: Addr + Default> {
pub dword_length: u32,
pub use_global_gtt: bool,
pub mi_command_opcode: u32,
pub command_type: u32,
pub core_mode_enable: u32,
pub address: A,
pub immediate_data: u64,
}
impl<A: Addr + Default> MiStoreDataImm<A> {
pub const DWORD_LENGTH: u32 = 5;
}
impl<A: Addr + Default> Default for MiStoreDataImm<A> {
fn default() -> Self {
MiStoreDataImm {
dword_length: 2,
use_global_gtt: Default::default(),
mi_command_opcode: 32,
command_type: 0,
core_mode_enable: Default::default(),
address: Default::default(),
immediate_data: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for MiStoreDataImm<A> {
type Out = [u32; 5];
fn pack_into(&self, out: &mut [u32; 5]) {
out[0] = __gen_uint(self.dword_length, 0, 5) |
__gen_uint(self.use_global_gtt.into(), 22, 22) |
__gen_uint(self.mi_command_opcode, 23, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = 0;
let v2 = __gen_uint(self.core_mode_enable, 0, 0);
let v2_address = self.address.combine(v2);
out[2] = v2_address as u32;
out[3] = (v2_address >> 32) as u32;
out[3] = __gen_uint(self.immediate_data as u32, 0, 31);
out[4] = __gen_uint((self.immediate_data >> 32) as u32, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 5];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 5] as *const [u8; 20]) })
}
}
impl From<&[u32; 5]> for MiStoreDataImm<u64> {
fn from(input: &[u32; 5]) -> Self {
MiStoreDataImm {
dword_length: __gen_unuint(input[0], 0, 5),
use_global_gtt: __gen_unuint(input[0], 22, 22) != 0,
mi_command_opcode: __gen_unuint(input[0], 23, 28),
command_type: __gen_unuint(input[0], 29, 31),
core_mode_enable: __gen_unuint(input[2], 0, 0),
address: (__gen_unuint(input[2], 2, 31) as u64) << 2,
immediate_data: (__gen_unuint(input[3], 0, 31) as u64) |
(__gen_unuint(input[4], 0, 31) as u64) << 32,
}
}
}
impl Deserialize for MiStoreDataImm<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 5];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 5] as *mut [u8; 20]) })?;
Ok((&input).into())
}
}
pub struct MiStoreDataIndex {
pub dword_length: u32,
pub mi_command_opcode: u32,
pub command_type: u32,
pub offset: u32,
pub data_dword_0: u32,
pub data_dword_1: u32,
}
impl MiStoreDataIndex {
pub const DWORD_LENGTH: u32 = 4;
}
impl Default for MiStoreDataIndex {
fn default() -> Self {
MiStoreDataIndex {
dword_length: 1,
mi_command_opcode: 33,
command_type: 0,
offset: Default::default(),
data_dword_0: Default::default(),
data_dword_1: Default::default(),
}
}
}
impl Serialize for MiStoreDataIndex {
type Out = [u32; 4];
fn pack_into(&self, out: &mut [u32; 4]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self.mi_command_opcode, 23, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.offset, 2, 11);
out[2] = __gen_uint(self.data_dword_0, 0, 31);
out[3] = __gen_uint(self.data_dword_1, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 4];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 4] as *const [u8; 16]) })
}
}
impl From<&[u32; 4]> for MiStoreDataIndex {
fn from(input: &[u32; 4]) -> Self {
MiStoreDataIndex {
dword_length: __gen_unuint(input[0], 0, 7),
mi_command_opcode: __gen_unuint(input[0], 23, 28),
command_type: __gen_unuint(input[0], 29, 31),
offset: __gen_unuint(input[1], 2, 11),
data_dword_0: __gen_unuint(input[2], 0, 31),
data_dword_1: __gen_unuint(input[3], 0, 31),
}
}
}
impl Deserialize for MiStoreDataIndex {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 4];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 4] as *mut [u8; 16]) })?;
Ok((&input).into())
}
}
pub struct MiStoreRegisterMem<A: Addr + Default> {
pub dword_length: u32,
pub use_global_gtt: bool,
pub mi_command_opcode: u32,
pub command_type: u32,
pub register_address: u64,
pub memory_address: A,
}
impl<A: Addr + Default> MiStoreRegisterMem<A> {
pub const DWORD_LENGTH: u32 = 3;
}
impl<A: Addr + Default> Default for MiStoreRegisterMem<A> {
fn default() -> Self {
MiStoreRegisterMem {
dword_length: 1,
use_global_gtt: Default::default(),
mi_command_opcode: 36,
command_type: 0,
register_address: Default::default(),
memory_address: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for MiStoreRegisterMem<A> {
type Out = [u32; 3];
fn pack_into(&self, out: &mut [u32; 3]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self.use_global_gtt.into(), 22, 22) |
__gen_uint(self.mi_command_opcode, 23, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_offset(self.register_address as u32, 2, 22);
let v2_address = self.memory_address.combine(0);
out[2] = v2_address as u32;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 3];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 3] as *const [u8; 12]) })
}
}
impl From<&[u32; 3]> for MiStoreRegisterMem<u64> {
fn from(input: &[u32; 3]) -> Self {
MiStoreRegisterMem {
dword_length: __gen_unuint(input[0], 0, 7),
use_global_gtt: __gen_unuint(input[0], 22, 22) != 0,
mi_command_opcode: __gen_unuint(input[0], 23, 28),
command_type: __gen_unuint(input[0], 29, 31),
register_address: (__gen_unuint(input[1], 2, 22) as u64) << 2,
memory_address: (__gen_unuint(input[2], 2, 31) as u64) << 2,
}
}
}
impl Deserialize for MiStoreRegisterMem<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 3];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 3] as *mut [u8; 12]) })?;
Ok((&input).into())
}
}
pub struct MiSuspendFlush {
pub suspend_flush: bool,
pub mi_command_opcode: u32,
pub command_type: u32,
}
impl MiSuspendFlush {
pub const DWORD_LENGTH: u32 = 1;
}
impl Default for MiSuspendFlush {
fn default() -> Self {
MiSuspendFlush {
suspend_flush: Default::default(),
mi_command_opcode: 11,
command_type: 0,
}
}
}
impl Serialize for MiSuspendFlush {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.suspend_flush.into(), 0, 0) |
__gen_uint(self.mi_command_opcode, 23, 28) |
__gen_uint(self.command_type, 29, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for MiSuspendFlush {
fn from(input: &[u32; 1]) -> Self {
MiSuspendFlush {
suspend_flush: __gen_unuint(input[0], 0, 0) != 0,
mi_command_opcode: __gen_unuint(input[0], 23, 28),
command_type: __gen_unuint(input[0], 29, 31),
}
}
}
impl Deserialize for MiSuspendFlush {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct MiTopologyFilter {
pub topology_filter_value: _3dPrimTopoType,
pub mi_command_opcode: u32,
pub command_type: u32,
}
impl MiTopologyFilter {
pub const DWORD_LENGTH: u32 = 1;
}
impl Default for MiTopologyFilter {
fn default() -> Self {
MiTopologyFilter {
topology_filter_value: Default::default(),
mi_command_opcode: 13,
command_type: 0,
}
}
}
impl Serialize for MiTopologyFilter {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.topology_filter_value.into(), 0, 5) |
__gen_uint(self.mi_command_opcode, 23, 28) |
__gen_uint(self.command_type, 29, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for MiTopologyFilter {
fn from(input: &[u32; 1]) -> Self {
MiTopologyFilter {
topology_filter_value: (__gen_unuint(input[0], 0, 5)).into(),
mi_command_opcode: __gen_unuint(input[0], 23, 28),
command_type: __gen_unuint(input[0], 29, 31),
}
}
}
impl Deserialize for MiTopologyFilter {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct MiUrbClear {
pub dword_length: u32,
pub mi_command_opcode: u32,
pub command_type: u32,
pub urb_address: u64,
pub urb_clear_length: u32,
}
impl MiUrbClear {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for MiUrbClear {
fn default() -> Self {
MiUrbClear {
dword_length: 0,
mi_command_opcode: 25,
command_type: 0,
urb_address: Default::default(),
urb_clear_length: Default::default(),
}
}
}
impl Serialize for MiUrbClear {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self.mi_command_opcode, 23, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_offset(self.urb_address as u32, 0, 13) |
__gen_uint(self.urb_clear_length, 16, 28);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for MiUrbClear {
fn from(input: &[u32; 2]) -> Self {
MiUrbClear {
dword_length: __gen_unuint(input[0], 0, 7),
mi_command_opcode: __gen_unuint(input[0], 23, 28),
command_type: __gen_unuint(input[0], 29, 31),
urb_address: (__gen_unuint(input[1], 0, 13) as u64),
urb_clear_length: __gen_unuint(input[1], 16, 28),
}
}
}
impl Deserialize for MiUrbClear {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct MiUserInterrupt {
pub mi_command_opcode: u32,
pub command_type: u32,
}
impl MiUserInterrupt {
pub const DWORD_LENGTH: u32 = 1;
}
impl Default for MiUserInterrupt {
fn default() -> Self {
MiUserInterrupt {
mi_command_opcode: 2,
command_type: 0,
}
}
}
impl Serialize for MiUserInterrupt {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.mi_command_opcode, 23, 28) |
__gen_uint(self.command_type, 29, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for MiUserInterrupt {
fn from(input: &[u32; 1]) -> Self {
MiUserInterrupt {
mi_command_opcode: __gen_unuint(input[0], 23, 28),
command_type: __gen_unuint(input[0], 29, 31),
}
}
}
impl Deserialize for MiUserInterrupt {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct MiWaitForEvent {
pub display_pipe_a_scan_line_wait_enable: bool,
pub display_plane_a_flip_pending_wait_enable: bool,
pub display_sprite_a_flip_pending_wait_enable: bool,
pub display_pipe_a_vertical_blank_wait_enable: bool,
pub display_pipe_a_horizontal_blank_wait_enable: bool,
pub display_pipe_b_scan_line_wait_enable: bool,
pub display_plane_b_flip_pending_wait_enable: bool,
pub display_sprite_b_flip_pending_wait_enable: bool,
pub display_pipe_b_vertical_blank_wait_enable: bool,
pub display_pipe_b_horizontal_blank_wait_enable: bool,
pub display_pipe_c_scan_line_wait_enable: bool,
pub display_plane_c_flip_pending_wait_enable: bool,
pub condition_code_wait_select: u32,
pub display_sprite_c_flip_pending_wait_enable: bool,
pub display_pipe_c_vertical_blank_wait_enable: bool,
pub display_pipe_c_horizontal_blank_wait_enable: bool,
pub mi_command_opcode: u32,
pub command_type: u32,
}
impl MiWaitForEvent {
pub const DWORD_LENGTH: u32 = 1;
pub const NOT_ENABLED: u32 = 0;
}
impl Default for MiWaitForEvent {
fn default() -> Self {
MiWaitForEvent {
display_pipe_a_scan_line_wait_enable: Default::default(),
display_plane_a_flip_pending_wait_enable: Default::default(),
display_sprite_a_flip_pending_wait_enable: Default::default(),
display_pipe_a_vertical_blank_wait_enable: Default::default(),
display_pipe_a_horizontal_blank_wait_enable: Default::default(),
display_pipe_b_scan_line_wait_enable: Default::default(),
display_plane_b_flip_pending_wait_enable: Default::default(),
display_sprite_b_flip_pending_wait_enable: Default::default(),
display_pipe_b_vertical_blank_wait_enable: Default::default(),
display_pipe_b_horizontal_blank_wait_enable: Default::default(),
display_pipe_c_scan_line_wait_enable: Default::default(),
display_plane_c_flip_pending_wait_enable: Default::default(),
condition_code_wait_select: Default::default(),
display_sprite_c_flip_pending_wait_enable: Default::default(),
display_pipe_c_vertical_blank_wait_enable: Default::default(),
display_pipe_c_horizontal_blank_wait_enable: Default::default(),
mi_command_opcode: 3,
command_type: 0,
}
}
}
impl Serialize for MiWaitForEvent {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.display_pipe_a_scan_line_wait_enable.into(), 0, 0) |
__gen_uint(self.display_plane_a_flip_pending_wait_enable.into(), 1, 1) |
__gen_uint(self.display_sprite_a_flip_pending_wait_enable.into(), 2, 2) |
__gen_uint(self.display_pipe_a_vertical_blank_wait_enable.into(), 3, 3) |
__gen_uint(self.display_pipe_a_horizontal_blank_wait_enable.into(), 5, 5) |
__gen_uint(self.display_pipe_b_scan_line_wait_enable.into(), 8, 8) |
__gen_uint(self.display_plane_b_flip_pending_wait_enable.into(), 9, 9) |
__gen_uint(self.display_sprite_b_flip_pending_wait_enable.into(), 10, 10) |
__gen_uint(self.display_pipe_b_vertical_blank_wait_enable.into(), 11, 11) |
__gen_uint(self.display_pipe_b_horizontal_blank_wait_enable.into(), 13, 13) |
__gen_uint(self.display_pipe_c_scan_line_wait_enable.into(), 14, 14) |
__gen_uint(self.display_plane_c_flip_pending_wait_enable.into(), 15, 15) |
__gen_uint(self.condition_code_wait_select, 16, 19) |
__gen_uint(self.display_sprite_c_flip_pending_wait_enable.into(), 20, 20) |
__gen_uint(self.display_pipe_c_vertical_blank_wait_enable.into(), 21, 21) |
__gen_uint(self.display_pipe_c_horizontal_blank_wait_enable.into(), 22, 22) |
__gen_uint(self.mi_command_opcode, 23, 28) |
__gen_uint(self.command_type, 29, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for MiWaitForEvent {
fn from(input: &[u32; 1]) -> Self {
MiWaitForEvent {
display_pipe_a_scan_line_wait_enable: __gen_unuint(input[0], 0, 0) != 0,
display_plane_a_flip_pending_wait_enable: __gen_unuint(input[0], 1, 1) != 0,
display_sprite_a_flip_pending_wait_enable: __gen_unuint(input[0], 2, 2) != 0,
display_pipe_a_vertical_blank_wait_enable: __gen_unuint(input[0], 3, 3) != 0,
display_pipe_a_horizontal_blank_wait_enable: __gen_unuint(input[0], 5, 5) != 0,
display_pipe_b_scan_line_wait_enable: __gen_unuint(input[0], 8, 8) != 0,
display_plane_b_flip_pending_wait_enable: __gen_unuint(input[0], 9, 9) != 0,
display_sprite_b_flip_pending_wait_enable: __gen_unuint(input[0], 10, 10) != 0,
display_pipe_b_vertical_blank_wait_enable: __gen_unuint(input[0], 11, 11) != 0,
display_pipe_b_horizontal_blank_wait_enable: __gen_unuint(input[0], 13, 13) != 0,
display_pipe_c_scan_line_wait_enable: __gen_unuint(input[0], 14, 14) != 0,
display_plane_c_flip_pending_wait_enable: __gen_unuint(input[0], 15, 15) != 0,
condition_code_wait_select: __gen_unuint(input[0], 16, 19),
display_sprite_c_flip_pending_wait_enable: __gen_unuint(input[0], 20, 20) != 0,
display_pipe_c_vertical_blank_wait_enable: __gen_unuint(input[0], 21, 21) != 0,
display_pipe_c_horizontal_blank_wait_enable: __gen_unuint(input[0], 22, 22) != 0,
mi_command_opcode: __gen_unuint(input[0], 23, 28),
command_type: __gen_unuint(input[0], 29, 31),
}
}
}
impl Deserialize for MiWaitForEvent {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct PaletteEntry {
pub blue: u32,
pub green: u32,
pub red: u32,
pub alpha: u32,
}
impl PaletteEntry {
pub const DWORD_LENGTH: u32 = 1;
}
impl Default for PaletteEntry {
fn default() -> Self {
PaletteEntry {
blue: Default::default(),
green: Default::default(),
red: Default::default(),
alpha: Default::default(),
}
}
}
impl Serialize for PaletteEntry {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.blue, 0, 7) |
__gen_uint(self.green, 8, 15) |
__gen_uint(self.red, 16, 23) |
__gen_uint(self.alpha, 24, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for PaletteEntry {
fn from(input: &[u32; 1]) -> Self {
PaletteEntry {
blue: __gen_unuint(input[0], 0, 7),
green: __gen_unuint(input[0], 8, 15),
red: __gen_unuint(input[0], 16, 23),
alpha: __gen_unuint(input[0], 24, 31),
}
}
}
impl Deserialize for PaletteEntry {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct PipeControl<A: Addr + Default> {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub depth_cache_flush_enable: bool,
pub stall_at_pixel_scoreboard: bool,
pub state_cache_invalidation_enable: bool,
pub constant_cache_invalidation_enable: bool,
pub vf_cache_invalidation_enable: bool,
pub dc_flush_enable: bool,
pub pipe_control_flush_enable: bool,
pub notify_enable: bool,
pub indirect_state_pointers_disable: bool,
pub texture_cache_invalidation_enable: bool,
pub instruction_cache_invalidate_enable: bool,
pub render_target_cache_flush_enable: bool,
pub depth_stall_enable: bool,
pub post_sync_operation: u32,
pub generic_media_state_clear: bool,
pub tlb_invalidate: bool,
pub global_snapshot_count_reset: bool,
pub command_streamer_stall_enable: bool,
pub store_data_index: u32,
pub lri_post_sync_operation: u32,
pub destination_address_type: u32,
pub address: A,
pub immediate_data: u64,
}
impl<A: Addr + Default> PipeControl<A> {
pub const DWORD_LENGTH: u32 = 5;
pub const GGTT: u32 = 1;
pub const MMIO_WRITE_IMMEDIATE_DATA: u32 = 1;
pub const NO_LRI_OPERATION: u32 = 0;
pub const NO_WRITE: u32 = 0;
pub const PPGTT: u32 = 0;
pub const WRITE_IMMEDIATE_DATA: u32 = 1;
pub const WRITE_PS_DEPTH_COUNT: u32 = 2;
pub const WRITE_TIMESTAMP: u32 = 3;
}
impl<A: Addr + Default> Default for PipeControl<A> {
fn default() -> Self {
PipeControl {
dword_length: 3,
_3d_command_sub_opcode: 0,
_3d_command_opcode: 2,
command_subtype: 3,
command_type: 3,
depth_cache_flush_enable: Default::default(),
stall_at_pixel_scoreboard: Default::default(),
state_cache_invalidation_enable: Default::default(),
constant_cache_invalidation_enable: Default::default(),
vf_cache_invalidation_enable: Default::default(),
dc_flush_enable: Default::default(),
pipe_control_flush_enable: Default::default(),
notify_enable: Default::default(),
indirect_state_pointers_disable: Default::default(),
texture_cache_invalidation_enable: Default::default(),
instruction_cache_invalidate_enable: Default::default(),
render_target_cache_flush_enable: Default::default(),
depth_stall_enable: Default::default(),
post_sync_operation: Default::default(),
generic_media_state_clear: Default::default(),
tlb_invalidate: Default::default(),
global_snapshot_count_reset: Default::default(),
command_streamer_stall_enable: Default::default(),
store_data_index: Default::default(),
lri_post_sync_operation: Default::default(),
destination_address_type: Default::default(),
address: Default::default(),
immediate_data: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for PipeControl<A> {
type Out = [u32; 5];
fn pack_into(&self, out: &mut [u32; 5]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.depth_cache_flush_enable.into(), 0, 0) |
__gen_uint(self.stall_at_pixel_scoreboard.into(), 1, 1) |
__gen_uint(self.state_cache_invalidation_enable.into(), 2, 2) |
__gen_uint(self.constant_cache_invalidation_enable.into(), 3, 3) |
__gen_uint(self.vf_cache_invalidation_enable.into(), 4, 4) |
__gen_uint(self.dc_flush_enable.into(), 5, 5) |
__gen_uint(self.pipe_control_flush_enable.into(), 7, 7) |
__gen_uint(self.notify_enable.into(), 8, 8) |
__gen_uint(self.indirect_state_pointers_disable.into(), 9, 9) |
__gen_uint(self.texture_cache_invalidation_enable.into(), 10, 10) |
__gen_uint(self.instruction_cache_invalidate_enable.into(), 11, 11) |
__gen_uint(self.render_target_cache_flush_enable.into(), 12, 12) |
__gen_uint(self.depth_stall_enable.into(), 13, 13) |
__gen_uint(self.post_sync_operation, 14, 15) |
__gen_uint(self.generic_media_state_clear.into(), 16, 16) |
__gen_uint(self.tlb_invalidate.into(), 18, 18) |
__gen_uint(self.global_snapshot_count_reset.into(), 19, 19) |
__gen_uint(self.command_streamer_stall_enable.into(), 20, 20) |
__gen_uint(self.store_data_index, 21, 21) |
__gen_uint(self.lri_post_sync_operation, 23, 23) |
__gen_uint(self.destination_address_type, 24, 24);
let v2_address = self.address.combine(0);
out[2] = v2_address as u32;
out[3] = (v2_address >> 32) as u32;
out[3] = __gen_uint(self.immediate_data as u32, 0, 31);
out[4] = __gen_uint((self.immediate_data >> 32) as u32, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 5];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 5] as *const [u8; 20]) })
}
}
impl From<&[u32; 5]> for PipeControl<u64> {
fn from(input: &[u32; 5]) -> Self {
PipeControl {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
depth_cache_flush_enable: __gen_unuint(input[1], 0, 0) != 0,
stall_at_pixel_scoreboard: __gen_unuint(input[1], 1, 1) != 0,
state_cache_invalidation_enable: __gen_unuint(input[1], 2, 2) != 0,
constant_cache_invalidation_enable: __gen_unuint(input[1], 3, 3) != 0,
vf_cache_invalidation_enable: __gen_unuint(input[1], 4, 4) != 0,
dc_flush_enable: __gen_unuint(input[1], 5, 5) != 0,
pipe_control_flush_enable: __gen_unuint(input[1], 7, 7) != 0,
notify_enable: __gen_unuint(input[1], 8, 8) != 0,
indirect_state_pointers_disable: __gen_unuint(input[1], 9, 9) != 0,
texture_cache_invalidation_enable: __gen_unuint(input[1], 10, 10) != 0,
instruction_cache_invalidate_enable: __gen_unuint(input[1], 11, 11) != 0,
render_target_cache_flush_enable: __gen_unuint(input[1], 12, 12) != 0,
depth_stall_enable: __gen_unuint(input[1], 13, 13) != 0,
post_sync_operation: __gen_unuint(input[1], 14, 15),
generic_media_state_clear: __gen_unuint(input[1], 16, 16) != 0,
tlb_invalidate: __gen_unuint(input[1], 18, 18) != 0,
global_snapshot_count_reset: __gen_unuint(input[1], 19, 19) != 0,
command_streamer_stall_enable: __gen_unuint(input[1], 20, 20) != 0,
store_data_index: __gen_unuint(input[1], 21, 21),
lri_post_sync_operation: __gen_unuint(input[1], 23, 23),
destination_address_type: __gen_unuint(input[1], 24, 24),
address: (__gen_unuint(input[2], 2, 31) as u64) << 2,
immediate_data: (__gen_unuint(input[3], 0, 31) as u64) |
(__gen_unuint(input[4], 0, 31) as u64) << 32,
}
}
}
impl Deserialize for PipeControl<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 5];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 5] as *mut [u8; 20]) })?;
Ok((&input).into())
}
}
pub struct PipelineSelect {
pub pipeline_selection: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
}
impl PipelineSelect {
pub const DWORD_LENGTH: u32 = 1;
pub const GPGPU: u32 = 2;
pub const MEDIA: u32 = 1;
pub const _3D: u32 = 0;
}
impl Default for PipelineSelect {
fn default() -> Self {
PipelineSelect {
pipeline_selection: Default::default(),
_3d_command_sub_opcode: 4,
_3d_command_opcode: 1,
command_subtype: 1,
command_type: 3,
}
}
}
impl Serialize for PipelineSelect {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.pipeline_selection, 0, 1) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for PipelineSelect {
fn from(input: &[u32; 1]) -> Self {
PipelineSelect {
pipeline_selection: __gen_unuint(input[0], 0, 1),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
}
}
}
impl Deserialize for PipelineSelect {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct PsInvocationCount {
pub ps_invocation_count_report: u64,
}
impl PsInvocationCount {
pub const DWORD_LENGTH: u32 = 2;
pub const NUM: u64 = 0x2348;
}
impl Default for PsInvocationCount {
fn default() -> Self {
PsInvocationCount {
ps_invocation_count_report: Default::default(),
}
}
}
impl Serialize for PsInvocationCount {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.ps_invocation_count_report as u32, 0, 31);
out[1] = __gen_uint((self.ps_invocation_count_report >> 32) as u32, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for PsInvocationCount {
fn from(input: &[u32; 2]) -> Self {
PsInvocationCount {
ps_invocation_count_report: (__gen_unuint(input[0], 0, 31) as u64) |
(__gen_unuint(input[1], 0, 31) as u64) << 32,
}
}
}
impl Deserialize for PsInvocationCount {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct RcsFaultReg<A: Addr + Default> {
pub valid_bit: bool,
pub fault_type: u32,
pub srcid_of_fault: u32,
pub gttsel: u32,
pub virtual_address_of_fault: A,
}
impl<A: Addr + Default> RcsFaultReg<A> {
pub const DWORD_LENGTH: u32 = 1;
pub const NUM: u64 = 0x4094;
pub const GGTT: u32 = 1;
pub const INVALID_AND_UNLOADED_PD_FAULT: u32 = 3;
pub const INVALID_PD_FAULT: u32 = 1;
pub const PAGE_FAULT: u32 = 0;
pub const PPGTT: u32 = 0;
pub const UNLOADED_PD_FAULT: u32 = 2;
}
impl<A: Addr + Default> Default for RcsFaultReg<A> {
fn default() -> Self {
RcsFaultReg {
valid_bit: Default::default(),
fault_type: Default::default(),
srcid_of_fault: Default::default(),
gttsel: Default::default(),
virtual_address_of_fault: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for RcsFaultReg<A> {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
let v0 = __gen_uint(self.valid_bit.into(), 0, 0) |
__gen_uint(self.fault_type, 1, 2) |
__gen_uint(self.srcid_of_fault, 3, 10) |
__gen_uint(self.gttsel, 11, 11);
let v0_address = self.virtual_address_of_fault.combine(v0);
out[0] = v0_address as u32;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for RcsFaultReg<u64> {
fn from(input: &[u32; 1]) -> Self {
RcsFaultReg {
valid_bit: __gen_unuint(input[0], 0, 0) != 0,
fault_type: __gen_unuint(input[0], 1, 2),
srcid_of_fault: __gen_unuint(input[0], 3, 10),
gttsel: __gen_unuint(input[0], 11, 11),
virtual_address_of_fault: (__gen_unuint(input[0], 12, 31) as u64) << 12,
}
}
}
impl Deserialize for RcsFaultReg<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct RcsRingBufferCtl {
pub ring_buffer_enable: bool,
pub automatic_report_head_pointer: u32,
pub semaphore_wait: bool,
pub rbwait: bool,
pub buffer_length_in_pages_1: u32,
}
impl RcsRingBufferCtl {
pub const DWORD_LENGTH: u32 = 1;
pub const NUM: u64 = 0x203c;
pub const MI_AUTOREPORT_128KB: u32 = 3;
pub const MI_AUTOREPORT_64KBMI_AUTOREPORT_4KB: u32 = 1;
pub const MI_AUTOREPORT_OFF: u32 = 0;
}
impl Default for RcsRingBufferCtl {
fn default() -> Self {
RcsRingBufferCtl {
ring_buffer_enable: Default::default(),
automatic_report_head_pointer: Default::default(),
semaphore_wait: Default::default(),
rbwait: Default::default(),
buffer_length_in_pages_1: Default::default(),
}
}
}
impl Serialize for RcsRingBufferCtl {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.ring_buffer_enable.into(), 0, 0) |
__gen_uint(self.automatic_report_head_pointer, 1, 2) |
__gen_uint(self.semaphore_wait.into(), 10, 10) |
__gen_uint(self.rbwait.into(), 11, 11) |
__gen_uint(self.buffer_length_in_pages_1, 12, 20);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for RcsRingBufferCtl {
fn from(input: &[u32; 1]) -> Self {
RcsRingBufferCtl {
ring_buffer_enable: __gen_unuint(input[0], 0, 0) != 0,
automatic_report_head_pointer: __gen_unuint(input[0], 1, 2),
semaphore_wait: __gen_unuint(input[0], 10, 10) != 0,
rbwait: __gen_unuint(input[0], 11, 11) != 0,
buffer_length_in_pages_1: __gen_unuint(input[0], 12, 20),
}
}
}
impl Deserialize for RcsRingBufferCtl {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct RenderSurfaceState<A: Addr + Default> {
pub cube_face_enable_positive_z: bool,
pub cube_face_enable_negative_z: bool,
pub cube_face_enable_positive_y: bool,
pub cube_face_enable_negative_y: bool,
pub cube_face_enable_positive_x: bool,
pub cube_face_enable_negative_x: bool,
pub media_boundary_pixel_mode: u32,
pub render_cache_read_write_mode: u32,
pub surface_array_spacing: u32,
pub vertical_line_stride_offset: u32,
pub vertical_line_stride: u32,
pub tile_walk: u32,
pub tiled_surface: bool,
pub surface_horizontal_alignment: u32,
pub surface_vertical_alignment: u32,
pub surface_format: u32,
pub surface_array: bool,
pub surface_type: u32,
pub surface_base_address: A,
pub width: u32,
pub height: u32,
pub surface_pitch: u32,
pub depth: u32,
pub multisample_position_palette_index: u32,
pub strbuf_minimum_array_element: u32,
pub number_of_multisamples: u32,
pub multisampled_surface_storage_format: u32,
pub render_target_view_extent: u32,
pub minimum_array_element: u32,
pub render_target_rotation: u32,
pub mip_count_lod: u32,
pub surface_min_lod: u32,
pub mocs: u32,
pub y_offset: u32,
pub x_offset: u32,
pub mcs_enable: bool,
pub y_offset_for_uv_plane: u32,
pub append_counter_enable: bool,
pub auxiliary_surface_pitch: u32,
pub append_counter_address: A,
pub auxiliary_surface_base_address: A,
pub x_offset_for_uv_plane: u32,
pub reserved_mbz: u32,
pub resource_min_lod: f32,
pub alpha_clear_color: u32,
pub blue_clear_color: u32,
pub green_clear_color: u32,
pub red_clear_color: u32,
}
impl<A: Addr + Default> RenderSurfaceState<A> {
pub const DWORD_LENGTH: u32 = 8;
pub const ARYSPC_FULL: u32 = 0;
pub const ARYSPC_LOD0: u32 = 1;
pub const CC_ONE: u32 = 1;
pub const CC_ZERO: u32 = 0;
pub const HALIGN_4: u32 = 0;
pub const HALIGN_8: u32 = 1;
pub const INTERLACED_FRAME: u32 = 3;
pub const MSFMT_DEPTH_STENCIL: u32 = 1;
pub const MSFMT_MSS: u32 = 0;
pub const MULTISAMPLECOUNT_1: u32 = 0;
pub const MULTISAMPLECOUNT_4: u32 = 2;
pub const MULTISAMPLECOUNT_8: u32 = 3;
pub const NORMAL_MODE: u32 = 0;
pub const PROGRESSIVE_FRAME: u32 = 2;
pub const RTROTATE_0DEG: u32 = 0;
pub const RTROTATE_270DEG: u32 = 3;
pub const RTROTATE_90DEG: u32 = 1;
pub const SURFTYPE_1D: u32 = 0;
pub const SURFTYPE_2D: u32 = 1;
pub const SURFTYPE_3D: u32 = 2;
pub const SURFTYPE_BUFFER: u32 = 4;
pub const SURFTYPE_CUBE: u32 = 3;
pub const SURFTYPE_NULL: u32 = 7;
pub const SURFTYPE_STRBUF: u32 = 5;
pub const TILEWALK_XMAJOR: u32 = 0;
pub const TILEWALK_YMAJOR: u32 = 1;
pub const VALIGN_2: u32 = 0;
pub const VALIGN_4: u32 = 1;
}
impl<A: Addr + Default> Default for RenderSurfaceState<A> {
fn default() -> Self {
RenderSurfaceState {
cube_face_enable_positive_z: Default::default(),
cube_face_enable_negative_z: Default::default(),
cube_face_enable_positive_y: Default::default(),
cube_face_enable_negative_y: Default::default(),
cube_face_enable_positive_x: Default::default(),
cube_face_enable_negative_x: Default::default(),
media_boundary_pixel_mode: Default::default(),
render_cache_read_write_mode: Default::default(),
surface_array_spacing: Default::default(),
vertical_line_stride_offset: Default::default(),
vertical_line_stride: Default::default(),
tile_walk: Default::default(),
tiled_surface: Default::default(),
surface_horizontal_alignment: Default::default(),
surface_vertical_alignment: Default::default(),
surface_format: Default::default(),
surface_array: Default::default(),
surface_type: Default::default(),
surface_base_address: Default::default(),
width: Default::default(),
height: Default::default(),
surface_pitch: Default::default(),
depth: Default::default(),
multisample_position_palette_index: Default::default(),
strbuf_minimum_array_element: Default::default(),
number_of_multisamples: Default::default(),
multisampled_surface_storage_format: Default::default(),
render_target_view_extent: Default::default(),
minimum_array_element: Default::default(),
render_target_rotation: Default::default(),
mip_count_lod: Default::default(),
surface_min_lod: Default::default(),
mocs: Default::default(),
y_offset: Default::default(),
x_offset: Default::default(),
mcs_enable: Default::default(),
y_offset_for_uv_plane: Default::default(),
append_counter_enable: Default::default(),
auxiliary_surface_pitch: Default::default(),
append_counter_address: Default::default(),
auxiliary_surface_base_address: Default::default(),
x_offset_for_uv_plane: Default::default(),
reserved_mbz: Default::default(),
resource_min_lod: Default::default(),
alpha_clear_color: Default::default(),
blue_clear_color: Default::default(),
green_clear_color: Default::default(),
red_clear_color: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for RenderSurfaceState<A> {
type Out = [u32; 8];
fn pack_into(&self, out: &mut [u32; 8]) {
out[0] = __gen_uint(self.cube_face_enable_positive_z.into(), 0, 0) |
__gen_uint(self.cube_face_enable_negative_z.into(), 1, 1) |
__gen_uint(self.cube_face_enable_positive_y.into(), 2, 2) |
__gen_uint(self.cube_face_enable_negative_y.into(), 3, 3) |
__gen_uint(self.cube_face_enable_positive_x.into(), 4, 4) |
__gen_uint(self.cube_face_enable_negative_x.into(), 5, 5) |
__gen_uint(self.media_boundary_pixel_mode, 6, 7) |
__gen_uint(self.render_cache_read_write_mode, 8, 8) |
__gen_uint(self.surface_array_spacing, 10, 10) |
__gen_uint(self.vertical_line_stride_offset, 11, 11) |
__gen_uint(self.vertical_line_stride, 12, 12) |
__gen_uint(self.tile_walk, 13, 13) |
__gen_uint(self.tiled_surface.into(), 14, 14) |
__gen_uint(self.surface_horizontal_alignment, 15, 15) |
__gen_uint(self.surface_vertical_alignment, 16, 17) |
__gen_uint(self.surface_format, 18, 26) |
__gen_uint(self.surface_array.into(), 28, 28) |
__gen_uint(self.surface_type, 29, 31);
let v1_address = self.surface_base_address.combine(0);
out[1] = v1_address as u32;
out[2] = (v1_address >> 32) as u32;
out[2] = __gen_uint(self.width, 0, 13) |
__gen_uint(self.height, 16, 29);
out[3] = __gen_uint(self.surface_pitch, 0, 17) |
__gen_uint(self.depth, 21, 31);
out[4] = __gen_uint(self.strbuf_minimum_array_element, 0, 26) |
__gen_uint(self.number_of_multisamples, 3, 5) |
__gen_uint(self.multisampled_surface_storage_format, 6, 6) |
__gen_uint(self.render_target_view_extent, 7, 17) |
__gen_uint(self.minimum_array_element, 18, 28) |
__gen_uint(self.render_target_rotation, 29, 30);
out[5] = __gen_uint(self.mip_count_lod, 0, 3) |
__gen_uint(self.surface_min_lod, 4, 7) |
__gen_uint(self.mocs, 16, 19) |
__gen_uint(self.y_offset, 20, 23) |
__gen_uint(self.x_offset, 25, 31);
let v6 = __gen_uint(self.y_offset_for_uv_plane, 0, 13) |
__gen_uint(self.append_counter_enable.into(), 1, 1) |
__gen_uint(self.auxiliary_surface_pitch, 3, 11) |
__gen_uint(self.x_offset_for_uv_plane, 16, 29) |
__gen_uint(self.reserved_mbz, 30, 31);
let v6_address = self.append_counter_address.combine(v6);
out[6] = v6_address as u32;
out[7] = (v6_address >> 32) as u32;
out[7] = __gen_ufixed(self.resource_min_lod, 0, 11, 8) |
__gen_uint(self.alpha_clear_color, 28, 28) |
__gen_uint(self.blue_clear_color, 29, 29) |
__gen_uint(self.green_clear_color, 30, 30) |
__gen_uint(self.red_clear_color, 31, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 8];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 8] as *const [u8; 32]) })
}
}
impl From<&[u32; 8]> for RenderSurfaceState<u64> {
fn from(input: &[u32; 8]) -> Self {
RenderSurfaceState {
cube_face_enable_positive_z: __gen_unuint(input[0], 0, 0) != 0,
cube_face_enable_negative_z: __gen_unuint(input[0], 1, 1) != 0,
cube_face_enable_positive_y: __gen_unuint(input[0], 2, 2) != 0,
cube_face_enable_negative_y: __gen_unuint(input[0], 3, 3) != 0,
cube_face_enable_positive_x: __gen_unuint(input[0], 4, 4) != 0,
cube_face_enable_negative_x: __gen_unuint(input[0], 5, 5) != 0,
media_boundary_pixel_mode: __gen_unuint(input[0], 6, 7),
render_cache_read_write_mode: __gen_unuint(input[0], 8, 8),
surface_array_spacing: __gen_unuint(input[0], 10, 10),
vertical_line_stride_offset: __gen_unuint(input[0], 11, 11),
vertical_line_stride: __gen_unuint(input[0], 12, 12),
tile_walk: __gen_unuint(input[0], 13, 13),
tiled_surface: __gen_unuint(input[0], 14, 14) != 0,
surface_horizontal_alignment: __gen_unuint(input[0], 15, 15),
surface_vertical_alignment: __gen_unuint(input[0], 16, 17),
surface_format: __gen_unuint(input[0], 18, 26),
surface_array: __gen_unuint(input[0], 28, 28) != 0,
surface_type: __gen_unuint(input[0], 29, 31),
surface_base_address: (__gen_unuint(input[1], 0, 31) as u64),
width: __gen_unuint(input[2], 0, 13),
height: __gen_unuint(input[2], 16, 29),
surface_pitch: __gen_unuint(input[3], 0, 17),
depth: __gen_unuint(input[3], 21, 31),
multisample_position_palette_index: __gen_unuint(input[4], 0, 2),
strbuf_minimum_array_element: __gen_unuint(input[4], 0, 26),
number_of_multisamples: __gen_unuint(input[4], 3, 5),
multisampled_surface_storage_format: __gen_unuint(input[4], 6, 6),
render_target_view_extent: __gen_unuint(input[4], 7, 17),
minimum_array_element: __gen_unuint(input[4], 18, 28),
render_target_rotation: __gen_unuint(input[4], 29, 30),
mip_count_lod: __gen_unuint(input[5], 0, 3),
surface_min_lod: __gen_unuint(input[5], 4, 7),
mocs: __gen_unuint(input[5], 16, 19),
y_offset: __gen_unuint(input[5], 20, 23),
x_offset: __gen_unuint(input[5], 25, 31),
mcs_enable: __gen_unuint(input[6], 0, 0) != 0,
y_offset_for_uv_plane: __gen_unuint(input[6], 0, 13),
append_counter_enable: __gen_unuint(input[6], 1, 1) != 0,
auxiliary_surface_pitch: __gen_unuint(input[6], 3, 11),
append_counter_address: (__gen_unuint(input[6], 6, 31) as u64) << 6,
auxiliary_surface_base_address: (__gen_unuint(input[6], 12, 31) as u64) << 12,
x_offset_for_uv_plane: __gen_unuint(input[6], 16, 29),
reserved_mbz: __gen_unuint(input[6], 30, 31),
resource_min_lod: __gen_unufixed(input[7], 0, 11, 8),
alpha_clear_color: __gen_unuint(input[7], 28, 28),
blue_clear_color: __gen_unuint(input[7], 29, 29),
green_clear_color: __gen_unuint(input[7], 30, 30),
red_clear_color: __gen_unuint(input[7], 31, 31),
}
}
}
impl Deserialize for RenderSurfaceState<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 8];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 8] as *mut [u8; 32]) })?;
Ok((&input).into())
}
}
pub struct RowInstdone {
pub bc_done: bool,
pub psd_done: bool,
pub dc_done: bool,
pub dapr_done: bool,
pub tdl_done: bool,
pub gw_done: bool,
pub ic_done: bool,
pub eu00_done_ss0: bool,
pub eu01_done_ss0: bool,
pub eu02_done_ss0: bool,
pub eu03_done_ss0: bool,
pub ma0_done_ss0: bool,
pub eu10_done_ss0: bool,
pub eu11_done_ss0: bool,
pub eu12_done_ss0: bool,
pub eu13_done_ss0: bool,
pub ma1_done: bool,
}
impl RowInstdone {
pub const DWORD_LENGTH: u32 = 1;
pub const NUM: u64 = 0xe164;
}
impl Default for RowInstdone {
fn default() -> Self {
RowInstdone {
bc_done: Default::default(),
psd_done: Default::default(),
dc_done: Default::default(),
dapr_done: Default::default(),
tdl_done: Default::default(),
gw_done: Default::default(),
ic_done: Default::default(),
eu00_done_ss0: Default::default(),
eu01_done_ss0: Default::default(),
eu02_done_ss0: Default::default(),
eu03_done_ss0: Default::default(),
ma0_done_ss0: Default::default(),
eu10_done_ss0: Default::default(),
eu11_done_ss0: Default::default(),
eu12_done_ss0: Default::default(),
eu13_done_ss0: Default::default(),
ma1_done: Default::default(),
}
}
}
impl Serialize for RowInstdone {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.bc_done.into(), 0, 0) |
__gen_uint(self.psd_done.into(), 1, 1) |
__gen_uint(self.dc_done.into(), 2, 2) |
__gen_uint(self.dapr_done.into(), 3, 3) |
__gen_uint(self.tdl_done.into(), 6, 6) |
__gen_uint(self.gw_done.into(), 8, 8) |
__gen_uint(self.ic_done.into(), 12, 12) |
__gen_uint(self.eu00_done_ss0.into(), 16, 16) |
__gen_uint(self.eu01_done_ss0.into(), 17, 17) |
__gen_uint(self.eu02_done_ss0.into(), 18, 18) |
__gen_uint(self.eu03_done_ss0.into(), 19, 19) |
__gen_uint(self.ma0_done_ss0.into(), 20, 20) |
__gen_uint(self.eu10_done_ss0.into(), 21, 21) |
__gen_uint(self.eu11_done_ss0.into(), 22, 22) |
__gen_uint(self.eu12_done_ss0.into(), 23, 23) |
__gen_uint(self.eu13_done_ss0.into(), 24, 24) |
__gen_uint(self.ma1_done.into(), 25, 25);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for RowInstdone {
fn from(input: &[u32; 1]) -> Self {
RowInstdone {
bc_done: __gen_unuint(input[0], 0, 0) != 0,
psd_done: __gen_unuint(input[0], 1, 1) != 0,
dc_done: __gen_unuint(input[0], 2, 2) != 0,
dapr_done: __gen_unuint(input[0], 3, 3) != 0,
tdl_done: __gen_unuint(input[0], 6, 6) != 0,
gw_done: __gen_unuint(input[0], 8, 8) != 0,
ic_done: __gen_unuint(input[0], 12, 12) != 0,
eu00_done_ss0: __gen_unuint(input[0], 16, 16) != 0,
eu01_done_ss0: __gen_unuint(input[0], 17, 17) != 0,
eu02_done_ss0: __gen_unuint(input[0], 18, 18) != 0,
eu03_done_ss0: __gen_unuint(input[0], 19, 19) != 0,
ma0_done_ss0: __gen_unuint(input[0], 20, 20) != 0,
eu10_done_ss0: __gen_unuint(input[0], 21, 21) != 0,
eu11_done_ss0: __gen_unuint(input[0], 22, 22) != 0,
eu12_done_ss0: __gen_unuint(input[0], 23, 23) != 0,
eu13_done_ss0: __gen_unuint(input[0], 24, 24) != 0,
ma1_done: __gen_unuint(input[0], 25, 25) != 0,
}
}
}
impl Deserialize for RowInstdone {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct Rpstat1 {
pub previous_gt_frequency: u32,
pub current_gt_frequency: u32,
}
impl Rpstat1 {
pub const DWORD_LENGTH: u32 = 1;
pub const NUM: u64 = 0xa01c;
}
impl Default for Rpstat1 {
fn default() -> Self {
Rpstat1 {
previous_gt_frequency: Default::default(),
current_gt_frequency: Default::default(),
}
}
}
impl Serialize for Rpstat1 {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.previous_gt_frequency, 0, 6) |
__gen_uint(self.current_gt_frequency, 7, 14);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for Rpstat1 {
fn from(input: &[u32; 1]) -> Self {
Rpstat1 {
previous_gt_frequency: __gen_unuint(input[0], 0, 6),
current_gt_frequency: __gen_unuint(input[0], 7, 14),
}
}
}
impl Deserialize for Rpstat1 {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct SamplerBorderColorState {
pub border_color_unorm_red: u32,
pub border_color_float_red: f32,
pub border_color_unorm_green: u32,
pub border_color_unorm_blue: u32,
pub border_color_unorm_alpha: u32,
pub border_color_float_green: f32,
pub border_color_float_blue: f32,
pub border_color_float_alpha: f32,
}
impl SamplerBorderColorState {
pub const DWORD_LENGTH: u32 = 4;
}
impl Default for SamplerBorderColorState {
fn default() -> Self {
SamplerBorderColorState {
border_color_unorm_red: Default::default(),
border_color_float_red: Default::default(),
border_color_unorm_green: Default::default(),
border_color_unorm_blue: Default::default(),
border_color_unorm_alpha: Default::default(),
border_color_float_green: Default::default(),
border_color_float_blue: Default::default(),
border_color_float_alpha: Default::default(),
}
}
}
impl Serialize for SamplerBorderColorState {
type Out = [u32; 4];
fn pack_into(&self, out: &mut [u32; 4]) {
out[0] = self.border_color_float_red.to_bits() |
__gen_uint(self.border_color_unorm_green, 8, 15) |
__gen_uint(self.border_color_unorm_blue, 16, 23) |
__gen_uint(self.border_color_unorm_alpha, 24, 31);
out[1] = self.border_color_float_green.to_bits();
out[2] = self.border_color_float_blue.to_bits();
out[3] = self.border_color_float_alpha.to_bits();
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 4];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 4] as *const [u8; 16]) })
}
}
impl From<&[u32; 4]> for SamplerBorderColorState {
fn from(input: &[u32; 4]) -> Self {
SamplerBorderColorState {
border_color_unorm_red: __gen_unuint(input[0], 0, 7),
border_color_float_red: f32::from_bits(input[0]),
border_color_unorm_green: __gen_unuint(input[0], 8, 15),
border_color_unorm_blue: __gen_unuint(input[0], 16, 23),
border_color_unorm_alpha: __gen_unuint(input[0], 24, 31),
border_color_float_green: f32::from_bits(input[1]),
border_color_float_blue: f32::from_bits(input[2]),
border_color_float_alpha: f32::from_bits(input[3]),
}
}
}
impl Deserialize for SamplerBorderColorState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 4];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 4] as *mut [u8; 16]) })?;
Ok((&input).into())
}
}
pub struct SamplerInstdone {
pub vme_done: bool,
pub pl0_done: bool,
pub so0_done: bool,
pub dg0_done: bool,
pub ft0_done: bool,
pub dm0_done: bool,
pub sc_done: bool,
pub fl0_done: bool,
pub qc_done: bool,
pub svsm_done: bool,
pub si0_done: bool,
pub mt0_done: bool,
pub avs_done: bool,
pub ief_done: bool,
pub vdi_done: bool,
pub svsm_arb3: bool,
pub svsm_arb2: bool,
pub svsm_arb1: bool,
pub svsm_adapter: bool,
}
impl SamplerInstdone {
pub const DWORD_LENGTH: u32 = 1;
pub const NUM: u64 = 0xe160;
}
impl Default for SamplerInstdone {
fn default() -> Self {
SamplerInstdone {
vme_done: Default::default(),
pl0_done: Default::default(),
so0_done: Default::default(),
dg0_done: Default::default(),
ft0_done: Default::default(),
dm0_done: Default::default(),
sc_done: Default::default(),
fl0_done: Default::default(),
qc_done: Default::default(),
svsm_done: Default::default(),
si0_done: Default::default(),
mt0_done: Default::default(),
avs_done: Default::default(),
ief_done: Default::default(),
vdi_done: Default::default(),
svsm_arb3: Default::default(),
svsm_arb2: Default::default(),
svsm_arb1: Default::default(),
svsm_adapter: Default::default(),
}
}
}
impl Serialize for SamplerInstdone {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.vme_done.into(), 0, 0) |
__gen_uint(self.pl0_done.into(), 1, 1) |
__gen_uint(self.so0_done.into(), 2, 2) |
__gen_uint(self.dg0_done.into(), 3, 3) |
__gen_uint(self.ft0_done.into(), 4, 4) |
__gen_uint(self.dm0_done.into(), 5, 5) |
__gen_uint(self.sc_done.into(), 6, 6) |
__gen_uint(self.fl0_done.into(), 7, 7) |
__gen_uint(self.qc_done.into(), 8, 8) |
__gen_uint(self.svsm_done.into(), 9, 9) |
__gen_uint(self.si0_done.into(), 10, 10) |
__gen_uint(self.mt0_done.into(), 11, 11) |
__gen_uint(self.avs_done.into(), 12, 12) |
__gen_uint(self.ief_done.into(), 13, 13) |
__gen_uint(self.vdi_done.into(), 14, 14) |
__gen_uint(self.svsm_arb3.into(), 15, 15) |
__gen_uint(self.svsm_arb2.into(), 16, 16) |
__gen_uint(self.svsm_arb1.into(), 17, 17) |
__gen_uint(self.svsm_adapter.into(), 18, 18);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for SamplerInstdone {
fn from(input: &[u32; 1]) -> Self {
SamplerInstdone {
vme_done: __gen_unuint(input[0], 0, 0) != 0,
pl0_done: __gen_unuint(input[0], 1, 1) != 0,
so0_done: __gen_unuint(input[0], 2, 2) != 0,
dg0_done: __gen_unuint(input[0], 3, 3) != 0,
ft0_done: __gen_unuint(input[0], 4, 4) != 0,
dm0_done: __gen_unuint(input[0], 5, 5) != 0,
sc_done: __gen_unuint(input[0], 6, 6) != 0,
fl0_done: __gen_unuint(input[0], 7, 7) != 0,
qc_done: __gen_unuint(input[0], 8, 8) != 0,
svsm_done: __gen_unuint(input[0], 9, 9) != 0,
si0_done: __gen_unuint(input[0], 10, 10) != 0,
mt0_done: __gen_unuint(input[0], 11, 11) != 0,
avs_done: __gen_unuint(input[0], 12, 12) != 0,
ief_done: __gen_unuint(input[0], 13, 13) != 0,
vdi_done: __gen_unuint(input[0], 14, 14) != 0,
svsm_arb3: __gen_unuint(input[0], 15, 15) != 0,
svsm_arb2: __gen_unuint(input[0], 16, 16) != 0,
svsm_arb1: __gen_unuint(input[0], 17, 17) != 0,
svsm_adapter: __gen_unuint(input[0], 18, 18) != 0,
}
}
}
impl Deserialize for SamplerInstdone {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct SamplerState {
pub anisotropic_algorithm: u32,
pub texture_lod_bias: f32,
pub min_mode_filter: u32,
pub mag_mode_filter: u32,
pub mip_mode_filter: u32,
pub base_mip_level: f32,
pub lod_preclamp_enable: u32,
pub texture_border_color_mode: u32,
pub sampler_disable: bool,
pub cube_surface_control_mode: u32,
pub shadow_function: u32,
pub max_lod: f32,
pub min_lod: f32,
pub border_color_pointer: u64,
pub tcz_address_control_mode: TextureCoordinateMode,
pub tcy_address_control_mode: TextureCoordinateMode,
pub tcx_address_control_mode: TextureCoordinateMode,
pub non_normalized_coordinate_enable: bool,
pub trilinear_filter_quality: u32,
pub r_address_min_filter_rounding_enable: bool,
pub r_address_mag_filter_rounding_enable: bool,
pub v_address_min_filter_rounding_enable: bool,
pub v_address_mag_filter_rounding_enable: bool,
pub u_address_min_filter_rounding_enable: bool,
pub u_address_mag_filter_rounding_enable: bool,
pub maximum_anisotropy: u32,
pub chromakey_mode: u32,
pub chromakey_index: u32,
pub chromakey_enable: bool,
}
impl SamplerState {
pub const DWORD_LENGTH: u32 = 4;
pub const ANISOTROPIC: u32 = 2;
pub const DX10_OGL: u32 = 0;
pub const DX9: u32 = 1;
pub const EWA_APPROXIMATION: u32 = 1;
pub const FULL: u32 = 0;
pub const KEYFILTER_KILL_ON_ANY_MATCH: u32 = 0;
pub const KEYFILTER_REPLACE_BLACK: u32 = 1;
pub const LEGACY: u32 = 0;
pub const LOW: u32 = 3;
pub const MED: u32 = 2;
pub const MONO: u32 = 6;
pub const NONE: u32 = 0;
pub const OGL: u32 = 1;
pub const OVERRIDE: u32 = 1;
pub const PREFILTEROP_ALWAYS: u32 = 0;
pub const PREFILTEROP_EQUAL: u32 = 3;
pub const PREFILTEROP_GEQUAL: u32 = 7;
pub const PREFILTEROP_GREATER: u32 = 5;
pub const PREFILTEROP_LEQUAL: u32 = 4;
pub const PREFILTEROP_LESS: u32 = 2;
pub const PREFILTEROP_NEVER: u32 = 1;
pub const PREFILTEROP_NOTEQUAL: u32 = 6;
pub const PROGRAMMED: u32 = 0;
pub const RATIO_10_1: u32 = 4;
pub const RATIO_12_1: u32 = 5;
pub const RATIO_14_1: u32 = 6;
pub const RATIO_16_1: u32 = 7;
pub const RATIO_2_1: u32 = 0;
pub const RATIO_4_1: u32 = 1;
pub const RATIO_6_1: u32 = 2;
pub const RATIO_8_1: u32 = 3;
}
impl Default for SamplerState {
fn default() -> Self {
SamplerState {
anisotropic_algorithm: Default::default(),
texture_lod_bias: Default::default(),
min_mode_filter: Default::default(),
mag_mode_filter: Default::default(),
mip_mode_filter: Default::default(),
base_mip_level: Default::default(),
lod_preclamp_enable: Default::default(),
texture_border_color_mode: Default::default(),
sampler_disable: Default::default(),
cube_surface_control_mode: Default::default(),
shadow_function: Default::default(),
max_lod: Default::default(),
min_lod: Default::default(),
border_color_pointer: Default::default(),
tcz_address_control_mode: Default::default(),
tcy_address_control_mode: Default::default(),
tcx_address_control_mode: Default::default(),
non_normalized_coordinate_enable: Default::default(),
trilinear_filter_quality: Default::default(),
r_address_min_filter_rounding_enable: Default::default(),
r_address_mag_filter_rounding_enable: Default::default(),
v_address_min_filter_rounding_enable: Default::default(),
v_address_mag_filter_rounding_enable: Default::default(),
u_address_min_filter_rounding_enable: Default::default(),
u_address_mag_filter_rounding_enable: Default::default(),
maximum_anisotropy: Default::default(),
chromakey_mode: Default::default(),
chromakey_index: Default::default(),
chromakey_enable: Default::default(),
}
}
}
impl Serialize for SamplerState {
type Out = [u32; 4];
fn pack_into(&self, out: &mut [u32; 4]) {
out[0] = __gen_uint(self.anisotropic_algorithm, 0, 0) |
__gen_sfixed(self.texture_lod_bias, 1, 13, 8) |
__gen_uint(self.min_mode_filter, 14, 16) |
__gen_uint(self.mag_mode_filter, 17, 19) |
__gen_uint(self.mip_mode_filter, 20, 21) |
__gen_ufixed(self.base_mip_level, 22, 26, 1) |
__gen_uint(self.lod_preclamp_enable, 28, 28) |
__gen_uint(self.texture_border_color_mode, 29, 29) |
__gen_uint(self.sampler_disable.into(), 31, 31);
out[1] = __gen_uint(self.cube_surface_control_mode, 0, 0) |
__gen_uint(self.shadow_function, 1, 3) |
__gen_ufixed(self.max_lod, 8, 19, 8) |
__gen_ufixed(self.min_lod, 20, 31, 8);
out[2] = __gen_offset(self.border_color_pointer as u32, 5, 31);
out[3] = __gen_uint(self.tcz_address_control_mode.into(), 0, 2) |
__gen_uint(self.tcy_address_control_mode.into(), 3, 5) |
__gen_uint(self.tcx_address_control_mode.into(), 6, 8) |
__gen_uint(self.non_normalized_coordinate_enable.into(), 10, 10) |
__gen_uint(self.trilinear_filter_quality, 11, 12) |
__gen_uint(self.r_address_min_filter_rounding_enable.into(), 13, 13) |
__gen_uint(self.r_address_mag_filter_rounding_enable.into(), 14, 14) |
__gen_uint(self.v_address_min_filter_rounding_enable.into(), 15, 15) |
__gen_uint(self.v_address_mag_filter_rounding_enable.into(), 16, 16) |
__gen_uint(self.u_address_min_filter_rounding_enable.into(), 17, 17) |
__gen_uint(self.u_address_mag_filter_rounding_enable.into(), 18, 18) |
__gen_uint(self.maximum_anisotropy, 19, 21) |
__gen_uint(self.chromakey_mode, 22, 22) |
__gen_uint(self.chromakey_index, 23, 24) |
__gen_uint(self.chromakey_enable.into(), 25, 25);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 4];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 4] as *const [u8; 16]) })
}
}
impl From<&[u32; 4]> for SamplerState {
fn from(input: &[u32; 4]) -> Self {
SamplerState {
anisotropic_algorithm: __gen_unuint(input[0], 0, 0),
texture_lod_bias: __gen_unsfixed(input[0], 1, 13, 8),
min_mode_filter: __gen_unuint(input[0], 14, 16),
mag_mode_filter: __gen_unuint(input[0], 17, 19),
mip_mode_filter: __gen_unuint(input[0], 20, 21),
base_mip_level: __gen_unufixed(input[0], 22, 26, 1),
lod_preclamp_enable: __gen_unuint(input[0], 28, 28),
texture_border_color_mode: __gen_unuint(input[0], 29, 29),
sampler_disable: __gen_unuint(input[0], 31, 31) != 0,
cube_surface_control_mode: __gen_unuint(input[1], 0, 0),
shadow_function: __gen_unuint(input[1], 1, 3),
max_lod: __gen_unufixed(input[1], 8, 19, 8),
min_lod: __gen_unufixed(input[1], 20, 31, 8),
border_color_pointer: (__gen_unuint(input[2], 5, 31) as u64) << 5,
tcz_address_control_mode: (__gen_unuint(input[3], 0, 2)).into(),
tcy_address_control_mode: (__gen_unuint(input[3], 3, 5)).into(),
tcx_address_control_mode: (__gen_unuint(input[3], 6, 8)).into(),
non_normalized_coordinate_enable: __gen_unuint(input[3], 10, 10) != 0,
trilinear_filter_quality: __gen_unuint(input[3], 11, 12),
r_address_min_filter_rounding_enable: __gen_unuint(input[3], 13, 13) != 0,
r_address_mag_filter_rounding_enable: __gen_unuint(input[3], 14, 14) != 0,
v_address_min_filter_rounding_enable: __gen_unuint(input[3], 15, 15) != 0,
v_address_mag_filter_rounding_enable: __gen_unuint(input[3], 16, 16) != 0,
u_address_min_filter_rounding_enable: __gen_unuint(input[3], 17, 17) != 0,
u_address_mag_filter_rounding_enable: __gen_unuint(input[3], 18, 18) != 0,
maximum_anisotropy: __gen_unuint(input[3], 19, 21),
chromakey_mode: __gen_unuint(input[3], 22, 22),
chromakey_index: __gen_unuint(input[3], 23, 24),
chromakey_enable: __gen_unuint(input[3], 25, 25) != 0,
}
}
}
impl Deserialize for SamplerState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 4];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 4] as *mut [u8; 16]) })?;
Ok((&input).into())
}
}
pub struct ScInstdone {
pub svl_done: bool,
pub wmfe_done: bool,
pub wmbe_done: bool,
pub hiz_done: bool,
pub stc_done: bool,
pub iz_done: bool,
pub sbe_done: bool,
pub rcz_done: bool,
pub rcc_done: bool,
pub rcpbe_done: bool,
pub rcpfe_done: bool,
pub dapb_done: bool,
pub daprbe_done: bool,
pub iecp_done: bool,
pub sarb_done: bool,
pub vsc_done: bool,
}
impl ScInstdone {
pub const DWORD_LENGTH: u32 = 1;
pub const NUM: u64 = 0x7100;
}
impl Default for ScInstdone {
fn default() -> Self {
ScInstdone {
svl_done: Default::default(),
wmfe_done: Default::default(),
wmbe_done: Default::default(),
hiz_done: Default::default(),
stc_done: Default::default(),
iz_done: Default::default(),
sbe_done: Default::default(),
rcz_done: Default::default(),
rcc_done: Default::default(),
rcpbe_done: Default::default(),
rcpfe_done: Default::default(),
dapb_done: Default::default(),
daprbe_done: Default::default(),
iecp_done: Default::default(),
sarb_done: Default::default(),
vsc_done: Default::default(),
}
}
}
impl Serialize for ScInstdone {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.svl_done.into(), 0, 0) |
__gen_uint(self.wmfe_done.into(), 1, 1) |
__gen_uint(self.wmbe_done.into(), 2, 2) |
__gen_uint(self.hiz_done.into(), 3, 3) |
__gen_uint(self.stc_done.into(), 4, 4) |
__gen_uint(self.iz_done.into(), 5, 5) |
__gen_uint(self.sbe_done.into(), 6, 6) |
__gen_uint(self.rcz_done.into(), 8, 8) |
__gen_uint(self.rcc_done.into(), 9, 9) |
__gen_uint(self.rcpbe_done.into(), 10, 10) |
__gen_uint(self.rcpfe_done.into(), 11, 11) |
__gen_uint(self.dapb_done.into(), 12, 12) |
__gen_uint(self.daprbe_done.into(), 13, 13) |
__gen_uint(self.iecp_done.into(), 14, 14) |
__gen_uint(self.sarb_done.into(), 15, 15) |
__gen_uint(self.vsc_done.into(), 16, 16);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for ScInstdone {
fn from(input: &[u32; 1]) -> Self {
ScInstdone {
svl_done: __gen_unuint(input[0], 0, 0) != 0,
wmfe_done: __gen_unuint(input[0], 1, 1) != 0,
wmbe_done: __gen_unuint(input[0], 2, 2) != 0,
hiz_done: __gen_unuint(input[0], 3, 3) != 0,
stc_done: __gen_unuint(input[0], 4, 4) != 0,
iz_done: __gen_unuint(input[0], 5, 5) != 0,
sbe_done: __gen_unuint(input[0], 6, 6) != 0,
rcz_done: __gen_unuint(input[0], 8, 8) != 0,
rcc_done: __gen_unuint(input[0], 9, 9) != 0,
rcpbe_done: __gen_unuint(input[0], 10, 10) != 0,
rcpfe_done: __gen_unuint(input[0], 11, 11) != 0,
dapb_done: __gen_unuint(input[0], 12, 12) != 0,
daprbe_done: __gen_unuint(input[0], 13, 13) != 0,
iecp_done: __gen_unuint(input[0], 14, 14) != 0,
sarb_done: __gen_unuint(input[0], 15, 15) != 0,
vsc_done: __gen_unuint(input[0], 16, 16) != 0,
}
}
}
impl Deserialize for ScInstdone {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct ScissorRect {
pub scissor_rectangle_x_min: u32,
pub scissor_rectangle_y_min: u32,
pub scissor_rectangle_x_max: u32,
pub scissor_rectangle_y_max: u32,
}
impl ScissorRect {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for ScissorRect {
fn default() -> Self {
ScissorRect {
scissor_rectangle_x_min: Default::default(),
scissor_rectangle_y_min: Default::default(),
scissor_rectangle_x_max: Default::default(),
scissor_rectangle_y_max: Default::default(),
}
}
}
impl Serialize for ScissorRect {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.scissor_rectangle_x_min, 0, 15) |
__gen_uint(self.scissor_rectangle_y_min, 16, 31);
out[1] = __gen_uint(self.scissor_rectangle_x_max, 0, 15) |
__gen_uint(self.scissor_rectangle_y_max, 16, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for ScissorRect {
fn from(input: &[u32; 2]) -> Self {
ScissorRect {
scissor_rectangle_x_min: __gen_unuint(input[0], 0, 15),
scissor_rectangle_y_min: __gen_unuint(input[0], 16, 31),
scissor_rectangle_x_max: __gen_unuint(input[1], 0, 15),
scissor_rectangle_y_max: __gen_unuint(input[1], 16, 31),
}
}
}
impl Deserialize for ScissorRect {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct SfClipViewport {
pub viewport_matrix_element_m00: f32,
pub viewport_matrix_element_m11: f32,
pub viewport_matrix_element_m22: f32,
pub viewport_matrix_element_m30: f32,
pub viewport_matrix_element_m31: f32,
pub viewport_matrix_element_m32: f32,
pub x_min_clip_guardband: f32,
pub x_max_clip_guardband: f32,
pub y_min_clip_guardband: f32,
pub y_max_clip_guardband: f32,
}
impl SfClipViewport {
pub const DWORD_LENGTH: u32 = 16;
}
impl Default for SfClipViewport {
fn default() -> Self {
SfClipViewport {
viewport_matrix_element_m00: Default::default(),
viewport_matrix_element_m11: Default::default(),
viewport_matrix_element_m22: Default::default(),
viewport_matrix_element_m30: Default::default(),
viewport_matrix_element_m31: Default::default(),
viewport_matrix_element_m32: Default::default(),
x_min_clip_guardband: Default::default(),
x_max_clip_guardband: Default::default(),
y_min_clip_guardband: Default::default(),
y_max_clip_guardband: Default::default(),
}
}
}
impl Serialize for SfClipViewport {
type Out = [u32; 16];
fn pack_into(&self, out: &mut [u32; 16]) {
out[0] = self.viewport_matrix_element_m00.to_bits();
out[1] = self.viewport_matrix_element_m11.to_bits();
out[2] = self.viewport_matrix_element_m22.to_bits();
out[3] = self.viewport_matrix_element_m30.to_bits();
out[4] = self.viewport_matrix_element_m31.to_bits();
out[5] = self.viewport_matrix_element_m32.to_bits();
out[6] = 0;
out[7] = 0;
out[8] = self.x_min_clip_guardband.to_bits();
out[9] = self.x_max_clip_guardband.to_bits();
out[10] = self.y_min_clip_guardband.to_bits();
out[11] = self.y_max_clip_guardband.to_bits();
out[12] = 0;
out[13] = 0;
out[14] = 0;
out[15] = 0;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 16];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 16] as *const [u8; 64]) })
}
}
impl From<&[u32; 16]> for SfClipViewport {
fn from(input: &[u32; 16]) -> Self {
SfClipViewport {
viewport_matrix_element_m00: f32::from_bits(input[0]),
viewport_matrix_element_m11: f32::from_bits(input[1]),
viewport_matrix_element_m22: f32::from_bits(input[2]),
viewport_matrix_element_m30: f32::from_bits(input[3]),
viewport_matrix_element_m31: f32::from_bits(input[4]),
viewport_matrix_element_m32: f32::from_bits(input[5]),
x_min_clip_guardband: f32::from_bits(input[8]),
x_max_clip_guardband: f32::from_bits(input[9]),
y_min_clip_guardband: f32::from_bits(input[10]),
y_max_clip_guardband: f32::from_bits(input[11]),
}
}
}
impl Deserialize for SfClipViewport {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 16];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 16] as *mut [u8; 64]) })?;
Ok((&input).into())
}
}
pub struct SfOutputAttributeDetail {
pub source_attribute: u32,
pub swizzle_select: u32,
pub constant_source: u32,
pub swizzle_control_mode: u32,
pub component_override_x: bool,
pub component_override_y: bool,
pub component_override_z: bool,
pub component_override_w: bool,
}
impl SfOutputAttributeDetail {
pub const DWORD_LENGTH: u32 = 1;
pub const CONST_0000: u32 = 0;
pub const CONST_0001_FLOAT: u32 = 1;
pub const CONST_1111_FLOAT: u32 = 2;
pub const INPUTATTR: u32 = 0;
pub const INPUTATTR_FACING: u32 = 1;
pub const INPUTATTR_FACING_W: u32 = 3;
pub const INPUTATTR_W: u32 = 2;
pub const PRIM_ID: u32 = 3;
}
impl Default for SfOutputAttributeDetail {
fn default() -> Self {
SfOutputAttributeDetail {
source_attribute: Default::default(),
swizzle_select: Default::default(),
constant_source: Default::default(),
swizzle_control_mode: Default::default(),
component_override_x: Default::default(),
component_override_y: Default::default(),
component_override_z: Default::default(),
component_override_w: Default::default(),
}
}
}
impl Serialize for SfOutputAttributeDetail {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.source_attribute, 0, 4) |
__gen_uint(self.swizzle_select, 6, 7) |
__gen_uint(self.constant_source, 9, 10) |
__gen_uint(self.swizzle_control_mode, 11, 11) |
__gen_uint(self.component_override_x.into(), 12, 12) |
__gen_uint(self.component_override_y.into(), 13, 13) |
__gen_uint(self.component_override_z.into(), 14, 14) |
__gen_uint(self.component_override_w.into(), 15, 15);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for SfOutputAttributeDetail {
fn from(input: &[u32; 1]) -> Self {
SfOutputAttributeDetail {
source_attribute: __gen_unuint(input[0], 0, 4),
swizzle_select: __gen_unuint(input[0], 6, 7),
constant_source: __gen_unuint(input[0], 9, 10),
swizzle_control_mode: __gen_unuint(input[0], 11, 11),
component_override_x: __gen_unuint(input[0], 12, 12) != 0,
component_override_y: __gen_unuint(input[0], 13, 13) != 0,
component_override_z: __gen_unuint(input[0], 14, 14) != 0,
component_override_w: __gen_unuint(input[0], 15, 15) != 0,
}
}
}
impl Deserialize for SfOutputAttributeDetail {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct SoDecl {
pub component_mask: u32,
pub register_index: u32,
pub hole_flag: bool,
pub output_buffer_slot: u32,
}
impl SoDecl {
pub const DWORD_LENGTH: u32 = 1;
}
impl Default for SoDecl {
fn default() -> Self {
SoDecl {
component_mask: 0,
register_index: Default::default(),
hole_flag: Default::default(),
output_buffer_slot: Default::default(),
}
}
}
impl Serialize for SoDecl {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.component_mask, 0, 3) |
__gen_uint(self.register_index, 4, 9) |
__gen_uint(self.hole_flag.into(), 11, 11) |
__gen_uint(self.output_buffer_slot, 12, 13);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for SoDecl {
fn from(input: &[u32; 1]) -> Self {
SoDecl {
component_mask: __gen_unuint(input[0], 0, 3),
register_index: __gen_unuint(input[0], 4, 9),
hole_flag: __gen_unuint(input[0], 11, 11) != 0,
output_buffer_slot: __gen_unuint(input[0], 12, 13),
}
}
}
impl Deserialize for SoDecl {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct SoDeclEntry {
pub stream_0_decl: SoDecl,
pub stream_1_decl: SoDecl,
pub stream_2_decl: SoDecl,
pub stream_3_decl: SoDecl,
}
impl SoDeclEntry {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for SoDeclEntry {
fn default() -> Self {
SoDeclEntry {
stream_0_decl: Default::default(),
stream_1_decl: Default::default(),
stream_2_decl: Default::default(),
stream_3_decl: Default::default(),
}
}
}
impl Serialize for SoDeclEntry {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
let mut v0_0 = [0_u32; 1];
self.stream_0_decl.pack_into(&mut v0_0);
let mut v0_1 = [0_u32; 1];
self.stream_1_decl.pack_into(&mut v0_1);
out[0] = __gen_uint(v0_0[0], 0, 15) |
__gen_uint(v0_1[0], 16, 31);
let mut v1_0 = [0_u32; 1];
self.stream_2_decl.pack_into(&mut v1_0);
let mut v1_1 = [0_u32; 1];
self.stream_3_decl.pack_into(&mut v1_1);
out[1] = __gen_uint(v1_0[0], 0, 15) |
__gen_uint(v1_1[0], 16, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for SoDeclEntry {
fn from(input: &[u32; 2]) -> Self {
SoDeclEntry {
stream_0_decl: {{
let [ref in0 @ .., _] = input;
in0.into()
}},
stream_1_decl: {{
let i: [u32; 1] = [__gen_unuint(input[0], 16, 31)];
(&i).into()
}},
stream_2_decl: {{
let [_, ref in1 @ ..] = input;
in1.into()
}},
stream_3_decl: {{
let i: [u32; 1] = [__gen_unuint(input[1], 16, 31)];
(&i).into()
}},
}
}
}
impl Deserialize for SoDeclEntry {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct SoNumPrimsWritten0 {
pub num_prims_written_count: u64,
}
impl SoNumPrimsWritten0 {
pub const DWORD_LENGTH: u32 = 2;
pub const NUM: u64 = 0x5200;
}
impl Default for SoNumPrimsWritten0 {
fn default() -> Self {
SoNumPrimsWritten0 {
num_prims_written_count: Default::default(),
}
}
}
impl Serialize for SoNumPrimsWritten0 {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.num_prims_written_count as u32, 0, 31);
out[1] = __gen_uint((self.num_prims_written_count >> 32) as u32, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for SoNumPrimsWritten0 {
fn from(input: &[u32; 2]) -> Self {
SoNumPrimsWritten0 {
num_prims_written_count: (__gen_unuint(input[0], 0, 31) as u64) |
(__gen_unuint(input[1], 0, 31) as u64) << 32,
}
}
}
impl Deserialize for SoNumPrimsWritten0 {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct SoNumPrimsWritten1 {
pub num_prims_written_count: u64,
}
impl SoNumPrimsWritten1 {
pub const DWORD_LENGTH: u32 = 2;
pub const NUM: u64 = 0x5208;
}
impl Default for SoNumPrimsWritten1 {
fn default() -> Self {
SoNumPrimsWritten1 {
num_prims_written_count: Default::default(),
}
}
}
impl Serialize for SoNumPrimsWritten1 {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.num_prims_written_count as u32, 0, 31);
out[1] = __gen_uint((self.num_prims_written_count >> 32) as u32, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for SoNumPrimsWritten1 {
fn from(input: &[u32; 2]) -> Self {
SoNumPrimsWritten1 {
num_prims_written_count: (__gen_unuint(input[0], 0, 31) as u64) |
(__gen_unuint(input[1], 0, 31) as u64) << 32,
}
}
}
impl Deserialize for SoNumPrimsWritten1 {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct SoNumPrimsWritten2 {
pub num_prims_written_count: u64,
}
impl SoNumPrimsWritten2 {
pub const DWORD_LENGTH: u32 = 2;
pub const NUM: u64 = 0x5210;
}
impl Default for SoNumPrimsWritten2 {
fn default() -> Self {
SoNumPrimsWritten2 {
num_prims_written_count: Default::default(),
}
}
}
impl Serialize for SoNumPrimsWritten2 {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.num_prims_written_count as u32, 0, 31);
out[1] = __gen_uint((self.num_prims_written_count >> 32) as u32, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for SoNumPrimsWritten2 {
fn from(input: &[u32; 2]) -> Self {
SoNumPrimsWritten2 {
num_prims_written_count: (__gen_unuint(input[0], 0, 31) as u64) |
(__gen_unuint(input[1], 0, 31) as u64) << 32,
}
}
}
impl Deserialize for SoNumPrimsWritten2 {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct SoNumPrimsWritten3 {
pub num_prims_written_count: u64,
}
impl SoNumPrimsWritten3 {
pub const DWORD_LENGTH: u32 = 2;
pub const NUM: u64 = 0x5218;
}
impl Default for SoNumPrimsWritten3 {
fn default() -> Self {
SoNumPrimsWritten3 {
num_prims_written_count: Default::default(),
}
}
}
impl Serialize for SoNumPrimsWritten3 {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.num_prims_written_count as u32, 0, 31);
out[1] = __gen_uint((self.num_prims_written_count >> 32) as u32, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for SoNumPrimsWritten3 {
fn from(input: &[u32; 2]) -> Self {
SoNumPrimsWritten3 {
num_prims_written_count: (__gen_unuint(input[0], 0, 31) as u64) |
(__gen_unuint(input[1], 0, 31) as u64) << 32,
}
}
}
impl Deserialize for SoNumPrimsWritten3 {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct SoPrimStorageNeeded0 {
pub prim_storage_needed_count: u64,
}
impl SoPrimStorageNeeded0 {
pub const DWORD_LENGTH: u32 = 2;
pub const NUM: u64 = 0x5240;
}
impl Default for SoPrimStorageNeeded0 {
fn default() -> Self {
SoPrimStorageNeeded0 {
prim_storage_needed_count: Default::default(),
}
}
}
impl Serialize for SoPrimStorageNeeded0 {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.prim_storage_needed_count as u32, 0, 31);
out[1] = __gen_uint((self.prim_storage_needed_count >> 32) as u32, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for SoPrimStorageNeeded0 {
fn from(input: &[u32; 2]) -> Self {
SoPrimStorageNeeded0 {
prim_storage_needed_count: (__gen_unuint(input[0], 0, 31) as u64) |
(__gen_unuint(input[1], 0, 31) as u64) << 32,
}
}
}
impl Deserialize for SoPrimStorageNeeded0 {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct SoPrimStorageNeeded1 {
pub prim_storage_needed_count: u64,
}
impl SoPrimStorageNeeded1 {
pub const DWORD_LENGTH: u32 = 2;
pub const NUM: u64 = 0x5248;
}
impl Default for SoPrimStorageNeeded1 {
fn default() -> Self {
SoPrimStorageNeeded1 {
prim_storage_needed_count: Default::default(),
}
}
}
impl Serialize for SoPrimStorageNeeded1 {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.prim_storage_needed_count as u32, 0, 31);
out[1] = __gen_uint((self.prim_storage_needed_count >> 32) as u32, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for SoPrimStorageNeeded1 {
fn from(input: &[u32; 2]) -> Self {
SoPrimStorageNeeded1 {
prim_storage_needed_count: (__gen_unuint(input[0], 0, 31) as u64) |
(__gen_unuint(input[1], 0, 31) as u64) << 32,
}
}
}
impl Deserialize for SoPrimStorageNeeded1 {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct SoPrimStorageNeeded2 {
pub prim_storage_needed_count: u64,
}
impl SoPrimStorageNeeded2 {
pub const DWORD_LENGTH: u32 = 2;
pub const NUM: u64 = 0x5250;
}
impl Default for SoPrimStorageNeeded2 {
fn default() -> Self {
SoPrimStorageNeeded2 {
prim_storage_needed_count: Default::default(),
}
}
}
impl Serialize for SoPrimStorageNeeded2 {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.prim_storage_needed_count as u32, 0, 31);
out[1] = __gen_uint((self.prim_storage_needed_count >> 32) as u32, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for SoPrimStorageNeeded2 {
fn from(input: &[u32; 2]) -> Self {
SoPrimStorageNeeded2 {
prim_storage_needed_count: (__gen_unuint(input[0], 0, 31) as u64) |
(__gen_unuint(input[1], 0, 31) as u64) << 32,
}
}
}
impl Deserialize for SoPrimStorageNeeded2 {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct SoPrimStorageNeeded3 {
pub prim_storage_needed_count: u64,
}
impl SoPrimStorageNeeded3 {
pub const DWORD_LENGTH: u32 = 2;
pub const NUM: u64 = 0x5258;
}
impl Default for SoPrimStorageNeeded3 {
fn default() -> Self {
SoPrimStorageNeeded3 {
prim_storage_needed_count: Default::default(),
}
}
}
impl Serialize for SoPrimStorageNeeded3 {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.prim_storage_needed_count as u32, 0, 31);
out[1] = __gen_uint((self.prim_storage_needed_count >> 32) as u32, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for SoPrimStorageNeeded3 {
fn from(input: &[u32; 2]) -> Self {
SoPrimStorageNeeded3 {
prim_storage_needed_count: (__gen_unuint(input[0], 0, 31) as u64) |
(__gen_unuint(input[1], 0, 31) as u64) << 32,
}
}
}
impl Deserialize for SoPrimStorageNeeded3 {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct SoWriteOffset0 {
pub write_offset: u64,
}
impl SoWriteOffset0 {
pub const DWORD_LENGTH: u32 = 1;
pub const NUM: u64 = 0x5280;
}
impl Default for SoWriteOffset0 {
fn default() -> Self {
SoWriteOffset0 {
write_offset: Default::default(),
}
}
}
impl Serialize for SoWriteOffset0 {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_offset(self.write_offset as u32, 2, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for SoWriteOffset0 {
fn from(input: &[u32; 1]) -> Self {
SoWriteOffset0 {
write_offset: (__gen_unuint(input[0], 2, 31) as u64) << 2,
}
}
}
impl Deserialize for SoWriteOffset0 {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct SoWriteOffset1 {
pub write_offset: u64,
}
impl SoWriteOffset1 {
pub const DWORD_LENGTH: u32 = 1;
pub const NUM: u64 = 0x5284;
}
impl Default for SoWriteOffset1 {
fn default() -> Self {
SoWriteOffset1 {
write_offset: Default::default(),
}
}
}
impl Serialize for SoWriteOffset1 {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_offset(self.write_offset as u32, 2, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for SoWriteOffset1 {
fn from(input: &[u32; 1]) -> Self {
SoWriteOffset1 {
write_offset: (__gen_unuint(input[0], 2, 31) as u64) << 2,
}
}
}
impl Deserialize for SoWriteOffset1 {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct SoWriteOffset2 {
pub write_offset: u64,
}
impl SoWriteOffset2 {
pub const DWORD_LENGTH: u32 = 1;
pub const NUM: u64 = 0x5288;
}
impl Default for SoWriteOffset2 {
fn default() -> Self {
SoWriteOffset2 {
write_offset: Default::default(),
}
}
}
impl Serialize for SoWriteOffset2 {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_offset(self.write_offset as u32, 2, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for SoWriteOffset2 {
fn from(input: &[u32; 1]) -> Self {
SoWriteOffset2 {
write_offset: (__gen_unuint(input[0], 2, 31) as u64) << 2,
}
}
}
impl Deserialize for SoWriteOffset2 {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct SoWriteOffset3 {
pub write_offset: u64,
}
impl SoWriteOffset3 {
pub const DWORD_LENGTH: u32 = 1;
pub const NUM: u64 = 0x528c;
}
impl Default for SoWriteOffset3 {
fn default() -> Self {
SoWriteOffset3 {
write_offset: Default::default(),
}
}
}
impl Serialize for SoWriteOffset3 {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_offset(self.write_offset as u32, 2, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for SoWriteOffset3 {
fn from(input: &[u32; 1]) -> Self {
SoWriteOffset3 {
write_offset: (__gen_unuint(input[0], 2, 31) as u64) << 2,
}
}
}
impl Deserialize for SoWriteOffset3 {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct StateBaseAddress<A: Addr + Default> {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub general_state_base_address_modify_enable: bool,
pub stateless_data_port_access_force_write_thru: u32,
pub stateless_data_port_access_mocs: u32,
pub general_state_mocs: u32,
pub general_state_base_address: A,
pub surface_state_base_address_modify_enable: bool,
pub surface_state_mocs: u32,
pub surface_state_base_address: A,
pub dynamic_state_base_address_modify_enable: bool,
pub dynamic_state_mocs: u32,
pub dynamic_state_base_address: A,
pub indirect_object_base_address_modify_enable: bool,
pub indirect_object_mocs: u32,
pub indirect_object_base_address: A,
pub instruction_base_address_modify_enable: bool,
pub instruction_mocs: u32,
pub instruction_base_address: A,
pub general_state_access_upper_bound_modify_enable: bool,
pub general_state_access_upper_bound: A,
pub dynamic_state_access_upper_bound_modify_enable: bool,
pub dynamic_state_access_upper_bound: A,
pub indirect_object_access_upper_bound_modify_enable: bool,
pub indirect_object_access_upper_bound: A,
pub instruction_access_upper_bound_modify_enable: bool,
pub instruction_access_upper_bound: A,
}
impl<A: Addr + Default> StateBaseAddress<A> {
pub const DWORD_LENGTH: u32 = 10;
}
impl<A: Addr + Default> Default for StateBaseAddress<A> {
fn default() -> Self {
StateBaseAddress {
dword_length: 8,
_3d_command_sub_opcode: 1,
_3d_command_opcode: 1,
command_subtype: 0,
command_type: 3,
general_state_base_address_modify_enable: Default::default(),
stateless_data_port_access_force_write_thru: Default::default(),
stateless_data_port_access_mocs: Default::default(),
general_state_mocs: Default::default(),
general_state_base_address: Default::default(),
surface_state_base_address_modify_enable: Default::default(),
surface_state_mocs: Default::default(),
surface_state_base_address: Default::default(),
dynamic_state_base_address_modify_enable: Default::default(),
dynamic_state_mocs: Default::default(),
dynamic_state_base_address: Default::default(),
indirect_object_base_address_modify_enable: Default::default(),
indirect_object_mocs: Default::default(),
indirect_object_base_address: Default::default(),
instruction_base_address_modify_enable: Default::default(),
instruction_mocs: Default::default(),
instruction_base_address: Default::default(),
general_state_access_upper_bound_modify_enable: Default::default(),
general_state_access_upper_bound: Default::default(),
dynamic_state_access_upper_bound_modify_enable: Default::default(),
dynamic_state_access_upper_bound: Default::default(),
indirect_object_access_upper_bound_modify_enable: Default::default(),
indirect_object_access_upper_bound: Default::default(),
instruction_access_upper_bound_modify_enable: Default::default(),
instruction_access_upper_bound: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for StateBaseAddress<A> {
type Out = [u32; 10];
fn pack_into(&self, out: &mut [u32; 10]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
let v1 = __gen_uint(self.general_state_base_address_modify_enable.into(), 0, 0) |
__gen_uint(self.stateless_data_port_access_force_write_thru, 3, 3) |
__gen_uint(self.stateless_data_port_access_mocs, 4, 7) |
__gen_uint(self.general_state_mocs, 8, 11);
let v1_address = self.general_state_base_address.combine(v1);
out[1] = v1_address as u32;
out[2] = (v1_address >> 32) as u32;
let v2 = __gen_uint(self.surface_state_base_address_modify_enable.into(), 0, 0) |
__gen_uint(self.surface_state_mocs, 8, 11);
let v2_address = self.surface_state_base_address.combine(v2);
out[2] = v2_address as u32;
out[3] = (v2_address >> 32) as u32;
let v3 = __gen_uint(self.dynamic_state_base_address_modify_enable.into(), 0, 0) |
__gen_uint(self.dynamic_state_mocs, 8, 11);
let v3_address = self.dynamic_state_base_address.combine(v3);
out[3] = v3_address as u32;
out[4] = (v3_address >> 32) as u32;
let v4 = __gen_uint(self.indirect_object_base_address_modify_enable.into(), 0, 0) |
__gen_uint(self.indirect_object_mocs, 8, 11);
let v4_address = self.indirect_object_base_address.combine(v4);
out[4] = v4_address as u32;
out[5] = (v4_address >> 32) as u32;
let v5 = __gen_uint(self.instruction_base_address_modify_enable.into(), 0, 0) |
__gen_uint(self.instruction_mocs, 8, 11);
let v5_address = self.instruction_base_address.combine(v5);
out[5] = v5_address as u32;
out[6] = (v5_address >> 32) as u32;
let v6 = __gen_uint(self.general_state_access_upper_bound_modify_enable.into(), 0, 0);
let v6_address = self.general_state_access_upper_bound.combine(v6);
out[6] = v6_address as u32;
out[7] = (v6_address >> 32) as u32;
let v7 = __gen_uint(self.dynamic_state_access_upper_bound_modify_enable.into(), 0, 0);
let v7_address = self.dynamic_state_access_upper_bound.combine(v7);
out[7] = v7_address as u32;
out[8] = (v7_address >> 32) as u32;
let v8 = __gen_uint(self.indirect_object_access_upper_bound_modify_enable.into(), 0, 0);
let v8_address = self.indirect_object_access_upper_bound.combine(v8);
out[8] = v8_address as u32;
out[9] = (v8_address >> 32) as u32;
let v9 = __gen_uint(self.instruction_access_upper_bound_modify_enable.into(), 0, 0);
let v9_address = self.instruction_access_upper_bound.combine(v9);
out[9] = v9_address as u32;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 10];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 10] as *const [u8; 40]) })
}
}
impl From<&[u32; 10]> for StateBaseAddress<u64> {
fn from(input: &[u32; 10]) -> Self {
StateBaseAddress {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
general_state_base_address_modify_enable: __gen_unuint(input[1], 0, 0) != 0,
stateless_data_port_access_force_write_thru: __gen_unuint(input[1], 3, 3),
stateless_data_port_access_mocs: __gen_unuint(input[1], 4, 7),
general_state_mocs: __gen_unuint(input[1], 8, 11),
general_state_base_address: (__gen_unuint(input[1], 12, 31) as u64) << 12,
surface_state_base_address_modify_enable: __gen_unuint(input[2], 0, 0) != 0,
surface_state_mocs: __gen_unuint(input[2], 8, 11),
surface_state_base_address: (__gen_unuint(input[2], 12, 31) as u64) << 12,
dynamic_state_base_address_modify_enable: __gen_unuint(input[3], 0, 0) != 0,
dynamic_state_mocs: __gen_unuint(input[3], 8, 11),
dynamic_state_base_address: (__gen_unuint(input[3], 12, 31) as u64) << 12,
indirect_object_base_address_modify_enable: __gen_unuint(input[4], 0, 0) != 0,
indirect_object_mocs: __gen_unuint(input[4], 8, 11),
indirect_object_base_address: (__gen_unuint(input[4], 12, 31) as u64) << 12,
instruction_base_address_modify_enable: __gen_unuint(input[5], 0, 0) != 0,
instruction_mocs: __gen_unuint(input[5], 8, 11),
instruction_base_address: (__gen_unuint(input[5], 12, 31) as u64) << 12,
general_state_access_upper_bound_modify_enable: __gen_unuint(input[6], 0, 0) != 0,
general_state_access_upper_bound: (__gen_unuint(input[6], 12, 31) as u64) << 12,
dynamic_state_access_upper_bound_modify_enable: __gen_unuint(input[7], 0, 0) != 0,
dynamic_state_access_upper_bound: (__gen_unuint(input[7], 12, 31) as u64) << 12,
indirect_object_access_upper_bound_modify_enable: __gen_unuint(input[8], 0, 0) != 0,
indirect_object_access_upper_bound: (__gen_unuint(input[8], 12, 31) as u64) << 12,
instruction_access_upper_bound_modify_enable: __gen_unuint(input[9], 0, 0) != 0,
instruction_access_upper_bound: (__gen_unuint(input[9], 12, 31) as u64) << 12,
}
}
}
impl Deserialize for StateBaseAddress<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 10];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 10] as *mut [u8; 40]) })?;
Ok((&input).into())
}
}
pub struct StatePrefetch<A: Addr + Default> {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub prefetch_count: u32,
pub prefetch_pointer: A,
}
impl<A: Addr + Default> StatePrefetch<A> {
pub const DWORD_LENGTH: u32 = 2;
}
impl<A: Addr + Default> Default for StatePrefetch<A> {
fn default() -> Self {
StatePrefetch {
dword_length: 0,
_3d_command_sub_opcode: 3,
_3d_command_opcode: 0,
command_subtype: 0,
command_type: 3,
prefetch_count: Default::default(),
prefetch_pointer: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for StatePrefetch<A> {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
let v1 = __gen_uint(self.prefetch_count, 0, 2);
let v1_address = self.prefetch_pointer.combine(v1);
out[1] = v1_address as u32;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for StatePrefetch<u64> {
fn from(input: &[u32; 2]) -> Self {
StatePrefetch {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
prefetch_count: __gen_unuint(input[1], 0, 2),
prefetch_pointer: (__gen_unuint(input[1], 6, 31) as u64) << 6,
}
}
}
impl Deserialize for StatePrefetch<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct StateSip {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub system_instruction_pointer: u64,
}
impl StateSip {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for StateSip {
fn default() -> Self {
StateSip {
dword_length: 0,
_3d_command_sub_opcode: 2,
_3d_command_opcode: 1,
command_subtype: 0,
command_type: 3,
system_instruction_pointer: Default::default(),
}
}
}
impl Serialize for StateSip {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_offset(self.system_instruction_pointer as u32, 4, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for StateSip {
fn from(input: &[u32; 2]) -> Self {
StateSip {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
system_instruction_pointer: (__gen_unuint(input[1], 4, 31) as u64) << 4,
}
}
}
impl Deserialize for StateSip {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct SwtessBaseAddress<A: Addr + Default> {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub sw_tessellation_mocs: u32,
pub sw_tessellation_base_address: A,
}
impl<A: Addr + Default> SwtessBaseAddress<A> {
pub const DWORD_LENGTH: u32 = 2;
}
impl<A: Addr + Default> Default for SwtessBaseAddress<A> {
fn default() -> Self {
SwtessBaseAddress {
dword_length: 0,
_3d_command_sub_opcode: 3,
_3d_command_opcode: 1,
command_subtype: 0,
command_type: 3,
sw_tessellation_mocs: Default::default(),
sw_tessellation_base_address: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for SwtessBaseAddress<A> {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
let v1 = __gen_uint(self.sw_tessellation_mocs, 8, 11);
let v1_address = self.sw_tessellation_base_address.combine(v1);
out[1] = v1_address as u32;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for SwtessBaseAddress<u64> {
fn from(input: &[u32; 2]) -> Self {
SwtessBaseAddress {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
sw_tessellation_mocs: __gen_unuint(input[1], 8, 11),
sw_tessellation_base_address: (__gen_unuint(input[1], 12, 31) as u64) << 12,
}
}
}
impl Deserialize for SwtessBaseAddress<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct VcsFaultReg<A: Addr + Default> {
pub valid_bit: bool,
pub fault_type: u32,
pub srcid_of_fault: u32,
pub gttsel: u32,
pub virtual_address_of_fault: A,
}
impl<A: Addr + Default> VcsFaultReg<A> {
pub const DWORD_LENGTH: u32 = 1;
pub const NUM: u64 = 0x4194;
pub const GGTT: u32 = 1;
pub const INVALID_AND_UNLOADED_PD_FAULT: u32 = 3;
pub const INVALID_PD_FAULT: u32 = 1;
pub const PAGE_FAULT: u32 = 0;
pub const PPGTT: u32 = 0;
pub const UNLOADED_PD_FAULT: u32 = 2;
}
impl<A: Addr + Default> Default for VcsFaultReg<A> {
fn default() -> Self {
VcsFaultReg {
valid_bit: Default::default(),
fault_type: Default::default(),
srcid_of_fault: Default::default(),
gttsel: Default::default(),
virtual_address_of_fault: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for VcsFaultReg<A> {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
let v0 = __gen_uint(self.valid_bit.into(), 0, 0) |
__gen_uint(self.fault_type, 1, 2) |
__gen_uint(self.srcid_of_fault, 3, 10) |
__gen_uint(self.gttsel, 11, 11);
let v0_address = self.virtual_address_of_fault.combine(v0);
out[0] = v0_address as u32;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for VcsFaultReg<u64> {
fn from(input: &[u32; 1]) -> Self {
VcsFaultReg {
valid_bit: __gen_unuint(input[0], 0, 0) != 0,
fault_type: __gen_unuint(input[0], 1, 2),
srcid_of_fault: __gen_unuint(input[0], 3, 10),
gttsel: __gen_unuint(input[0], 11, 11),
virtual_address_of_fault: (__gen_unuint(input[0], 12, 31) as u64) << 12,
}
}
}
impl Deserialize for VcsFaultReg<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct VcsInstdone {
pub ring_enable: bool,
pub usb_done: bool,
pub qrc_done: bool,
pub sec_done: bool,
pub mpc_done: bool,
pub vft_done: bool,
pub bsp_done: bool,
pub vlf_done: bool,
pub vop_done: bool,
pub vmc_done: bool,
pub vip_done: bool,
pub vit_done: bool,
pub vds_done: bool,
pub vmx_done: bool,
pub vcp_done: bool,
pub vcd_done: bool,
pub vad_done: bool,
pub vmd_done: bool,
pub vis_done: bool,
pub vac_done: bool,
pub vam_done: bool,
pub jpg_done: bool,
pub vbp_done: bool,
pub vhr_done: bool,
pub vci_done: bool,
pub vcr_done: bool,
pub vin_done: bool,
pub vpr_done: bool,
pub vtq_done: bool,
pub vcs_done: bool,
pub gac_done: bool,
}
impl VcsInstdone {
pub const DWORD_LENGTH: u32 = 1;
pub const NUM: u64 = 0x1206c;
}
impl Default for VcsInstdone {
fn default() -> Self {
VcsInstdone {
ring_enable: Default::default(),
usb_done: Default::default(),
qrc_done: Default::default(),
sec_done: Default::default(),
mpc_done: Default::default(),
vft_done: Default::default(),
bsp_done: Default::default(),
vlf_done: Default::default(),
vop_done: Default::default(),
vmc_done: Default::default(),
vip_done: Default::default(),
vit_done: Default::default(),
vds_done: Default::default(),
vmx_done: Default::default(),
vcp_done: Default::default(),
vcd_done: Default::default(),
vad_done: Default::default(),
vmd_done: Default::default(),
vis_done: Default::default(),
vac_done: Default::default(),
vam_done: Default::default(),
jpg_done: Default::default(),
vbp_done: Default::default(),
vhr_done: Default::default(),
vci_done: Default::default(),
vcr_done: Default::default(),
vin_done: Default::default(),
vpr_done: Default::default(),
vtq_done: Default::default(),
vcs_done: Default::default(),
gac_done: Default::default(),
}
}
}
impl Serialize for VcsInstdone {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.ring_enable.into(), 0, 0) |
__gen_uint(self.usb_done.into(), 1, 1) |
__gen_uint(self.qrc_done.into(), 2, 2) |
__gen_uint(self.sec_done.into(), 3, 3) |
__gen_uint(self.mpc_done.into(), 4, 4) |
__gen_uint(self.vft_done.into(), 5, 5) |
__gen_uint(self.bsp_done.into(), 6, 6) |
__gen_uint(self.vlf_done.into(), 7, 7) |
__gen_uint(self.vop_done.into(), 8, 8) |
__gen_uint(self.vmc_done.into(), 9, 9) |
__gen_uint(self.vip_done.into(), 10, 10) |
__gen_uint(self.vit_done.into(), 11, 11) |
__gen_uint(self.vds_done.into(), 12, 12) |
__gen_uint(self.vmx_done.into(), 13, 13) |
__gen_uint(self.vcp_done.into(), 14, 14) |
__gen_uint(self.vcd_done.into(), 15, 15) |
__gen_uint(self.vad_done.into(), 16, 16) |
__gen_uint(self.vmd_done.into(), 17, 17) |
__gen_uint(self.vis_done.into(), 18, 18) |
__gen_uint(self.vac_done.into(), 19, 19) |
__gen_uint(self.vam_done.into(), 20, 20) |
__gen_uint(self.jpg_done.into(), 21, 21) |
__gen_uint(self.vbp_done.into(), 22, 22) |
__gen_uint(self.vhr_done.into(), 23, 23) |
__gen_uint(self.vci_done.into(), 24, 24) |
__gen_uint(self.vcr_done.into(), 25, 25) |
__gen_uint(self.vin_done.into(), 26, 26) |
__gen_uint(self.vpr_done.into(), 27, 27) |
__gen_uint(self.vtq_done.into(), 28, 28) |
__gen_uint(self.vcs_done.into(), 30, 30) |
__gen_uint(self.gac_done.into(), 31, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for VcsInstdone {
fn from(input: &[u32; 1]) -> Self {
VcsInstdone {
ring_enable: __gen_unuint(input[0], 0, 0) != 0,
usb_done: __gen_unuint(input[0], 1, 1) != 0,
qrc_done: __gen_unuint(input[0], 2, 2) != 0,
sec_done: __gen_unuint(input[0], 3, 3) != 0,
mpc_done: __gen_unuint(input[0], 4, 4) != 0,
vft_done: __gen_unuint(input[0], 5, 5) != 0,
bsp_done: __gen_unuint(input[0], 6, 6) != 0,
vlf_done: __gen_unuint(input[0], 7, 7) != 0,
vop_done: __gen_unuint(input[0], 8, 8) != 0,
vmc_done: __gen_unuint(input[0], 9, 9) != 0,
vip_done: __gen_unuint(input[0], 10, 10) != 0,
vit_done: __gen_unuint(input[0], 11, 11) != 0,
vds_done: __gen_unuint(input[0], 12, 12) != 0,
vmx_done: __gen_unuint(input[0], 13, 13) != 0,
vcp_done: __gen_unuint(input[0], 14, 14) != 0,
vcd_done: __gen_unuint(input[0], 15, 15) != 0,
vad_done: __gen_unuint(input[0], 16, 16) != 0,
vmd_done: __gen_unuint(input[0], 17, 17) != 0,
vis_done: __gen_unuint(input[0], 18, 18) != 0,
vac_done: __gen_unuint(input[0], 19, 19) != 0,
vam_done: __gen_unuint(input[0], 20, 20) != 0,
jpg_done: __gen_unuint(input[0], 21, 21) != 0,
vbp_done: __gen_unuint(input[0], 22, 22) != 0,
vhr_done: __gen_unuint(input[0], 23, 23) != 0,
vci_done: __gen_unuint(input[0], 24, 24) != 0,
vcr_done: __gen_unuint(input[0], 25, 25) != 0,
vin_done: __gen_unuint(input[0], 26, 26) != 0,
vpr_done: __gen_unuint(input[0], 27, 27) != 0,
vtq_done: __gen_unuint(input[0], 28, 28) != 0,
vcs_done: __gen_unuint(input[0], 30, 30) != 0,
gac_done: __gen_unuint(input[0], 31, 31) != 0,
}
}
}
impl Deserialize for VcsInstdone {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct VcsRingBufferCtl {
pub ring_buffer_enable: bool,
pub automatic_report_head_pointer: u32,
pub disable_register_accesses: bool,
pub semaphore_wait: bool,
pub rbwait: bool,
pub buffer_length_in_pages_1: u32,
}
impl VcsRingBufferCtl {
pub const DWORD_LENGTH: u32 = 1;
pub const NUM: u64 = 0x1203c;
pub const MI_AUTOREPORT_128KB: u32 = 3;
pub const MI_AUTOREPORT_4KB: u32 = 2;
pub const MI_AUTOREPORT_64KB: u32 = 1;
pub const MI_AUTOREPORT_OFF: u32 = 0;
}
impl Default for VcsRingBufferCtl {
fn default() -> Self {
VcsRingBufferCtl {
ring_buffer_enable: Default::default(),
automatic_report_head_pointer: Default::default(),
disable_register_accesses: Default::default(),
semaphore_wait: Default::default(),
rbwait: Default::default(),
buffer_length_in_pages_1: Default::default(),
}
}
}
impl Serialize for VcsRingBufferCtl {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.ring_buffer_enable.into(), 0, 0) |
__gen_uint(self.automatic_report_head_pointer, 1, 2) |
__gen_uint(self.disable_register_accesses.into(), 8, 8) |
__gen_uint(self.semaphore_wait.into(), 10, 10) |
__gen_uint(self.rbwait.into(), 11, 11) |
__gen_uint(self.buffer_length_in_pages_1, 12, 20);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for VcsRingBufferCtl {
fn from(input: &[u32; 1]) -> Self {
VcsRingBufferCtl {
ring_buffer_enable: __gen_unuint(input[0], 0, 0) != 0,
automatic_report_head_pointer: __gen_unuint(input[0], 1, 2),
disable_register_accesses: __gen_unuint(input[0], 8, 8) != 0,
semaphore_wait: __gen_unuint(input[0], 10, 10) != 0,
rbwait: __gen_unuint(input[0], 11, 11) != 0,
buffer_length_in_pages_1: __gen_unuint(input[0], 12, 20),
}
}
}
impl Deserialize for VcsRingBufferCtl {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct VertexBufferState<A: Addr + Default> {
pub buffer_pitch: u32,
pub vertex_fetch_invalidate: bool,
pub null_vertex_buffer: bool,
pub address_modify_enable: bool,
pub mocs: u32,
pub buffer_access_type: u32,
pub vertex_buffer_index: u32,
pub buffer_starting_address: A,
pub end_address: A,
pub instance_data_step_rate: u32,
}
impl<A: Addr + Default> VertexBufferState<A> {
pub const DWORD_LENGTH: u32 = 4;
pub const INSTANCEDATA: u32 = 1;
pub const VERTEXDATA: u32 = 0;
}
impl<A: Addr + Default> Default for VertexBufferState<A> {
fn default() -> Self {
VertexBufferState {
buffer_pitch: Default::default(),
vertex_fetch_invalidate: false,
null_vertex_buffer: Default::default(),
address_modify_enable: Default::default(),
mocs: Default::default(),
buffer_access_type: Default::default(),
vertex_buffer_index: Default::default(),
buffer_starting_address: Default::default(),
end_address: Default::default(),
instance_data_step_rate: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for VertexBufferState<A> {
type Out = [u32; 4];
fn pack_into(&self, out: &mut [u32; 4]) {
out[0] = __gen_uint(self.buffer_pitch, 0, 11) |
__gen_uint(self.vertex_fetch_invalidate.into(), 12, 12) |
__gen_uint(self.null_vertex_buffer.into(), 13, 13) |
__gen_uint(self.address_modify_enable.into(), 14, 14) |
__gen_uint(self.mocs, 16, 19) |
__gen_uint(self.buffer_access_type, 20, 20) |
__gen_uint(self.vertex_buffer_index, 26, 31);
let v1_address = self.buffer_starting_address.combine(0);
out[1] = v1_address as u32;
out[2] = (v1_address >> 32) as u32;
let v2_address = self.end_address.combine(0);
out[2] = v2_address as u32;
out[3] = (v2_address >> 32) as u32;
out[3] = __gen_uint(self.instance_data_step_rate, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 4];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 4] as *const [u8; 16]) })
}
}
impl From<&[u32; 4]> for VertexBufferState<u64> {
fn from(input: &[u32; 4]) -> Self {
VertexBufferState {
buffer_pitch: __gen_unuint(input[0], 0, 11),
vertex_fetch_invalidate: __gen_unuint(input[0], 12, 12) != 0,
null_vertex_buffer: __gen_unuint(input[0], 13, 13) != 0,
address_modify_enable: __gen_unuint(input[0], 14, 14) != 0,
mocs: __gen_unuint(input[0], 16, 19),
buffer_access_type: __gen_unuint(input[0], 20, 20),
vertex_buffer_index: __gen_unuint(input[0], 26, 31),
buffer_starting_address: (__gen_unuint(input[1], 0, 31) as u64),
end_address: (__gen_unuint(input[2], 0, 31) as u64),
instance_data_step_rate: __gen_unuint(input[3], 0, 31),
}
}
}
impl Deserialize for VertexBufferState<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 4];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 4] as *mut [u8; 16]) })?;
Ok((&input).into())
}
}
pub struct VertexElementState {
pub source_element_offset: u32,
pub edge_flag_enable: bool,
pub source_element_format: u32,
pub valid: bool,
pub vertex_buffer_index: u32,
pub component_3_control: _3dVertexComponentControl,
pub component_2_control: _3dVertexComponentControl,
pub component_1_control: _3dVertexComponentControl,
pub component_0_control: _3dVertexComponentControl,
}
impl VertexElementState {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for VertexElementState {
fn default() -> Self {
VertexElementState {
source_element_offset: Default::default(),
edge_flag_enable: Default::default(),
source_element_format: Default::default(),
valid: Default::default(),
vertex_buffer_index: Default::default(),
component_3_control: Default::default(),
component_2_control: Default::default(),
component_1_control: Default::default(),
component_0_control: Default::default(),
}
}
}
impl Serialize for VertexElementState {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.source_element_offset, 0, 11) |
__gen_uint(self.edge_flag_enable.into(), 15, 15) |
__gen_uint(self.source_element_format, 16, 24) |
__gen_uint(self.valid.into(), 25, 25) |
__gen_uint(self.vertex_buffer_index, 26, 31);
out[1] = __gen_uint(self.component_3_control.into(), 16, 18) |
__gen_uint(self.component_2_control.into(), 20, 22) |
__gen_uint(self.component_1_control.into(), 24, 26) |
__gen_uint(self.component_0_control.into(), 28, 30);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for VertexElementState {
fn from(input: &[u32; 2]) -> Self {
VertexElementState {
source_element_offset: __gen_unuint(input[0], 0, 11),
edge_flag_enable: __gen_unuint(input[0], 15, 15) != 0,
source_element_format: __gen_unuint(input[0], 16, 24),
valid: __gen_unuint(input[0], 25, 25) != 0,
vertex_buffer_index: __gen_unuint(input[0], 26, 31),
component_3_control: (__gen_unuint(input[1], 16, 18)).into(),
component_2_control: (__gen_unuint(input[1], 20, 22)).into(),
component_1_control: (__gen_unuint(input[1], 24, 26)).into(),
component_0_control: (__gen_unuint(input[1], 28, 30)).into(),
}
}
}
impl Deserialize for VertexElementState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct VsInvocationCount {
pub vs_invocation_count_report: u64,
}
impl VsInvocationCount {
pub const DWORD_LENGTH: u32 = 2;
pub const NUM: u64 = 0x2320;
}
impl Default for VsInvocationCount {
fn default() -> Self {
VsInvocationCount {
vs_invocation_count_report: Default::default(),
}
}
}
impl Serialize for VsInvocationCount {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.vs_invocation_count_report as u32, 0, 31);
out[1] = __gen_uint((self.vs_invocation_count_report >> 32) as u32, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for VsInvocationCount {
fn from(input: &[u32; 2]) -> Self {
VsInvocationCount {
vs_invocation_count_report: (__gen_unuint(input[0], 0, 31) as u64) |
(__gen_unuint(input[1], 0, 31) as u64) << 32,
}
}
}
impl Deserialize for VsInvocationCount {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dPrimitive {
pub dword_length: u32,
pub predicate_enable: bool,
pub indirect_parameter_enable: bool,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub primitive_topology_type: _3dPrimTopoType,
pub vertex_access_type: u32,
pub end_offset_enable: bool,
pub vertex_count_per_instance: u32,
pub start_vertex_location: u32,
pub instance_count: u32,
pub start_instance_location: u32,
pub base_vertex_location: i32,
}
impl _3dPrimitive {
pub const DWORD_LENGTH: u32 = 7;
pub const RANDOM: u32 = 1;
pub const SEQUENTIAL: u32 = 0;
}
impl Default for _3dPrimitive {
fn default() -> Self {
_3dPrimitive {
dword_length: 5,
predicate_enable: Default::default(),
indirect_parameter_enable: Default::default(),
_3d_command_sub_opcode: 0,
_3d_command_opcode: 3,
command_subtype: 3,
command_type: 3,
primitive_topology_type: Default::default(),
vertex_access_type: Default::default(),
end_offset_enable: Default::default(),
vertex_count_per_instance: Default::default(),
start_vertex_location: Default::default(),
instance_count: Default::default(),
start_instance_location: Default::default(),
base_vertex_location: Default::default(),
}
}
}
impl Serialize for _3dPrimitive {
type Out = [u32; 7];
fn pack_into(&self, out: &mut [u32; 7]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self.predicate_enable.into(), 8, 8) |
__gen_uint(self.indirect_parameter_enable.into(), 10, 10) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.primitive_topology_type.into(), 0, 5) |
__gen_uint(self.vertex_access_type, 8, 8) |
__gen_uint(self.end_offset_enable.into(), 9, 9);
out[2] = __gen_uint(self.vertex_count_per_instance, 0, 31);
out[3] = __gen_uint(self.start_vertex_location, 0, 31);
out[4] = __gen_uint(self.instance_count, 0, 31);
out[5] = __gen_uint(self.start_instance_location, 0, 31);
out[6] = __gen_uint(self.base_vertex_location as u32, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 7];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 7] as *const [u8; 28]) })
}
}
impl From<&[u32; 7]> for _3dPrimitive {
fn from(input: &[u32; 7]) -> Self {
_3dPrimitive {
dword_length: __gen_unuint(input[0], 0, 7),
predicate_enable: __gen_unuint(input[0], 8, 8) != 0,
indirect_parameter_enable: __gen_unuint(input[0], 10, 10) != 0,
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
primitive_topology_type: (__gen_unuint(input[1], 0, 5)).into(),
vertex_access_type: __gen_unuint(input[1], 8, 8),
end_offset_enable: __gen_unuint(input[1], 9, 9) != 0,
vertex_count_per_instance: __gen_unuint(input[2], 0, 31),
start_vertex_location: __gen_unuint(input[3], 0, 31),
instance_count: __gen_unuint(input[4], 0, 31),
start_instance_location: __gen_unuint(input[5], 0, 31),
base_vertex_location: (__gen_unuint(input[6], 0, 31)) as i32,
}
}
}
impl Deserialize for _3dPrimitive {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 7];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 7] as *mut [u8; 28]) })?;
Ok((&input).into())
}
}
pub struct _3dStateAaLineParameters {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub aa_coverage_slope: f32,
pub aa_coverage_bias: f32,
pub aa_coverage_endcap_slope: f32,
pub aa_coverage_endcap_bias: f32,
}
impl _3dStateAaLineParameters {
pub const DWORD_LENGTH: u32 = 3;
}
impl Default for _3dStateAaLineParameters {
fn default() -> Self {
_3dStateAaLineParameters {
dword_length: 1,
_3d_command_sub_opcode: 10,
_3d_command_opcode: 1,
command_subtype: 3,
command_type: 3,
aa_coverage_slope: Default::default(),
aa_coverage_bias: Default::default(),
aa_coverage_endcap_slope: Default::default(),
aa_coverage_endcap_bias: Default::default(),
}
}
}
impl Serialize for _3dStateAaLineParameters {
type Out = [u32; 3];
fn pack_into(&self, out: &mut [u32; 3]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_ufixed(self.aa_coverage_slope, 0, 7, 8) |
__gen_ufixed(self.aa_coverage_bias, 16, 23, 8);
out[2] = __gen_ufixed(self.aa_coverage_endcap_slope, 0, 7, 8) |
__gen_ufixed(self.aa_coverage_endcap_bias, 16, 23, 8);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 3];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 3] as *const [u8; 12]) })
}
}
impl From<&[u32; 3]> for _3dStateAaLineParameters {
fn from(input: &[u32; 3]) -> Self {
_3dStateAaLineParameters {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
aa_coverage_slope: __gen_unufixed(input[1], 0, 7, 8),
aa_coverage_bias: __gen_unufixed(input[1], 16, 23, 8),
aa_coverage_endcap_slope: __gen_unufixed(input[2], 0, 7, 8),
aa_coverage_endcap_bias: __gen_unufixed(input[2], 16, 23, 8),
}
}
}
impl Deserialize for _3dStateAaLineParameters {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 3];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 3] as *mut [u8; 12]) })?;
Ok((&input).into())
}
}
pub struct _3dStateBindingTablePointersDs {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub pointer_to_ds_binding_table: u64,
}
impl _3dStateBindingTablePointersDs {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for _3dStateBindingTablePointersDs {
fn default() -> Self {
_3dStateBindingTablePointersDs {
dword_length: 0,
_3d_command_sub_opcode: 40,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
pointer_to_ds_binding_table: Default::default(),
}
}
}
impl Serialize for _3dStateBindingTablePointersDs {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_offset(self.pointer_to_ds_binding_table as u32, 5, 15);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStateBindingTablePointersDs {
fn from(input: &[u32; 2]) -> Self {
_3dStateBindingTablePointersDs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
pointer_to_ds_binding_table: (__gen_unuint(input[1], 5, 15) as u64) << 5,
}
}
}
impl Deserialize for _3dStateBindingTablePointersDs {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStateBindingTablePointersGs {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub pointer_to_gs_binding_table: u64,
}
impl _3dStateBindingTablePointersGs {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for _3dStateBindingTablePointersGs {
fn default() -> Self {
_3dStateBindingTablePointersGs {
dword_length: 0,
_3d_command_sub_opcode: 41,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
pointer_to_gs_binding_table: Default::default(),
}
}
}
impl Serialize for _3dStateBindingTablePointersGs {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_offset(self.pointer_to_gs_binding_table as u32, 5, 15);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStateBindingTablePointersGs {
fn from(input: &[u32; 2]) -> Self {
_3dStateBindingTablePointersGs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
pointer_to_gs_binding_table: (__gen_unuint(input[1], 5, 15) as u64) << 5,
}
}
}
impl Deserialize for _3dStateBindingTablePointersGs {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStateBindingTablePointersHs {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub pointer_to_hs_binding_table: u64,
}
impl _3dStateBindingTablePointersHs {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for _3dStateBindingTablePointersHs {
fn default() -> Self {
_3dStateBindingTablePointersHs {
dword_length: 0,
_3d_command_sub_opcode: 39,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
pointer_to_hs_binding_table: Default::default(),
}
}
}
impl Serialize for _3dStateBindingTablePointersHs {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_offset(self.pointer_to_hs_binding_table as u32, 5, 15);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStateBindingTablePointersHs {
fn from(input: &[u32; 2]) -> Self {
_3dStateBindingTablePointersHs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
pointer_to_hs_binding_table: (__gen_unuint(input[1], 5, 15) as u64) << 5,
}
}
}
impl Deserialize for _3dStateBindingTablePointersHs {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStateBindingTablePointersPs {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub pointer_to_ps_binding_table: u64,
}
impl _3dStateBindingTablePointersPs {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for _3dStateBindingTablePointersPs {
fn default() -> Self {
_3dStateBindingTablePointersPs {
dword_length: 0,
_3d_command_sub_opcode: 42,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
pointer_to_ps_binding_table: Default::default(),
}
}
}
impl Serialize for _3dStateBindingTablePointersPs {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_offset(self.pointer_to_ps_binding_table as u32, 5, 15);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStateBindingTablePointersPs {
fn from(input: &[u32; 2]) -> Self {
_3dStateBindingTablePointersPs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
pointer_to_ps_binding_table: (__gen_unuint(input[1], 5, 15) as u64) << 5,
}
}
}
impl Deserialize for _3dStateBindingTablePointersPs {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStateBindingTablePointersVs {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub pointer_to_vs_binding_table: u64,
}
impl _3dStateBindingTablePointersVs {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for _3dStateBindingTablePointersVs {
fn default() -> Self {
_3dStateBindingTablePointersVs {
dword_length: 0,
_3d_command_sub_opcode: 38,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
pointer_to_vs_binding_table: Default::default(),
}
}
}
impl Serialize for _3dStateBindingTablePointersVs {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_offset(self.pointer_to_vs_binding_table as u32, 5, 15);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStateBindingTablePointersVs {
fn from(input: &[u32; 2]) -> Self {
_3dStateBindingTablePointersVs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
pointer_to_vs_binding_table: (__gen_unuint(input[1], 5, 15) as u64) << 5,
}
}
}
impl Deserialize for _3dStateBindingTablePointersVs {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStateBlendStatePointers {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub blend_state_pointer: u64,
}
impl _3dStateBlendStatePointers {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for _3dStateBlendStatePointers {
fn default() -> Self {
_3dStateBlendStatePointers {
dword_length: 0,
_3d_command_sub_opcode: 36,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
blend_state_pointer: Default::default(),
}
}
}
impl Serialize for _3dStateBlendStatePointers {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_mbo(0, 0) |
__gen_offset(self.blend_state_pointer as u32, 6, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStateBlendStatePointers {
fn from(input: &[u32; 2]) -> Self {
_3dStateBlendStatePointers {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
blend_state_pointer: (__gen_unuint(input[1], 6, 31) as u64) << 6,
}
}
}
impl Deserialize for _3dStateBlendStatePointers {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStateCcStatePointers {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub color_calc_state_pointer: u64,
}
impl _3dStateCcStatePointers {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for _3dStateCcStatePointers {
fn default() -> Self {
_3dStateCcStatePointers {
dword_length: 0,
_3d_command_sub_opcode: 14,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
color_calc_state_pointer: Default::default(),
}
}
}
impl Serialize for _3dStateCcStatePointers {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_mbo(0, 0) |
__gen_offset(self.color_calc_state_pointer as u32, 6, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStateCcStatePointers {
fn from(input: &[u32; 2]) -> Self {
_3dStateCcStatePointers {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
color_calc_state_pointer: (__gen_unuint(input[1], 6, 31) as u64) << 6,
}
}
}
impl Deserialize for _3dStateCcStatePointers {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStateChromaKey {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub chromakey_table_index: u32,
pub chromakey_low_value: u32,
pub chromakey_high_value: u32,
}
impl _3dStateChromaKey {
pub const DWORD_LENGTH: u32 = 4;
}
impl Default for _3dStateChromaKey {
fn default() -> Self {
_3dStateChromaKey {
dword_length: 2,
_3d_command_sub_opcode: 4,
_3d_command_opcode: 1,
command_subtype: 3,
command_type: 3,
chromakey_table_index: Default::default(),
chromakey_low_value: Default::default(),
chromakey_high_value: Default::default(),
}
}
}
impl Serialize for _3dStateChromaKey {
type Out = [u32; 4];
fn pack_into(&self, out: &mut [u32; 4]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.chromakey_table_index, 30, 31);
out[2] = __gen_uint(self.chromakey_low_value, 0, 31);
out[3] = __gen_uint(self.chromakey_high_value, 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 4];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 4] as *const [u8; 16]) })
}
}
impl From<&[u32; 4]> for _3dStateChromaKey {
fn from(input: &[u32; 4]) -> Self {
_3dStateChromaKey {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
chromakey_table_index: __gen_unuint(input[1], 30, 31),
chromakey_low_value: __gen_unuint(input[2], 0, 31),
chromakey_high_value: __gen_unuint(input[3], 0, 31),
}
}
}
impl Deserialize for _3dStateChromaKey {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 4];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 4] as *mut [u8; 16]) })?;
Ok((&input).into())
}
}
pub struct _3dStateClearParams {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub depth_clear_value: u32,
pub depth_clear_value_valid: bool,
}
impl _3dStateClearParams {
pub const DWORD_LENGTH: u32 = 3;
}
impl Default for _3dStateClearParams {
fn default() -> Self {
_3dStateClearParams {
dword_length: 1,
_3d_command_sub_opcode: 4,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
depth_clear_value: Default::default(),
depth_clear_value_valid: Default::default(),
}
}
}
impl Serialize for _3dStateClearParams {
type Out = [u32; 3];
fn pack_into(&self, out: &mut [u32; 3]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.depth_clear_value, 0, 31);
out[2] = __gen_uint(self.depth_clear_value_valid.into(), 0, 0);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 3];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 3] as *const [u8; 12]) })
}
}
impl From<&[u32; 3]> for _3dStateClearParams {
fn from(input: &[u32; 3]) -> Self {
_3dStateClearParams {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
depth_clear_value: __gen_unuint(input[1], 0, 31),
depth_clear_value_valid: __gen_unuint(input[2], 0, 0) != 0,
}
}
}
impl Deserialize for _3dStateClearParams {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 3];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 3] as *mut [u8; 12]) })?;
Ok((&input).into())
}
}
pub struct _3dStateClip {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub user_clip_distance_cull_test_enable_bitmask: u32,
pub statistics_enable: bool,
pub cull_mode: u32,
pub early_cull_enable: bool,
pub vertex_sub_pixel_precision_select: u32,
pub front_winding: u32,
pub triangle_fan_provoking_vertex_select: u32,
pub line_strip_list_provoking_vertex_select: u32,
pub triangle_strip_list_provoking_vertex_select: u32,
pub non_perspective_barycentric_enable: bool,
pub perspective_divide_disable: bool,
pub clip_mode: u32,
pub user_clip_distance_clip_test_enable_bitmask: u32,
pub guardband_clip_test_enable: bool,
pub viewport_z_clip_test_enable: bool,
pub viewport_xy_clip_test_enable: bool,
pub api_mode: u32,
pub clip_enable: bool,
pub maximum_vp_index: u32,
pub force_zero_rta_index_enable: bool,
pub maximum_point_width: f32,
pub minimum_point_width: f32,
}
impl _3dStateClip {
pub const DWORD_LENGTH: u32 = 4;
pub const APIMODE_D3D: u32 = 1;
pub const APIMODE_OGL: u32 = 0;
pub const BACK: u32 = 3;
pub const BOTH: u32 = 0;
pub const CLIPMODE_ACCEPT_ALL: u32 = 4;
pub const CLIPMODE_NORMAL: u32 = 0;
pub const CLIPMODE_REJECT_ALL: u32 = 3;
pub const FRONT: u32 = 2;
pub const NONE: u32 = 1;
pub const VERTEX_0: u32 = 0;
pub const VERTEX_1: u32 = 1;
pub const VERTEX_2: u32 = 2;
}
impl Default for _3dStateClip {
fn default() -> Self {
_3dStateClip {
dword_length: 2,
_3d_command_sub_opcode: 18,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
user_clip_distance_cull_test_enable_bitmask: Default::default(),
statistics_enable: Default::default(),
cull_mode: Default::default(),
early_cull_enable: Default::default(),
vertex_sub_pixel_precision_select: Default::default(),
front_winding: Default::default(),
triangle_fan_provoking_vertex_select: Default::default(),
line_strip_list_provoking_vertex_select: Default::default(),
triangle_strip_list_provoking_vertex_select: Default::default(),
non_perspective_barycentric_enable: Default::default(),
perspective_divide_disable: Default::default(),
clip_mode: Default::default(),
user_clip_distance_clip_test_enable_bitmask: Default::default(),
guardband_clip_test_enable: Default::default(),
viewport_z_clip_test_enable: Default::default(),
viewport_xy_clip_test_enable: Default::default(),
api_mode: Default::default(),
clip_enable: Default::default(),
maximum_vp_index: Default::default(),
force_zero_rta_index_enable: Default::default(),
maximum_point_width: Default::default(),
minimum_point_width: Default::default(),
}
}
}
impl Serialize for _3dStateClip {
type Out = [u32; 4];
fn pack_into(&self, out: &mut [u32; 4]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.user_clip_distance_cull_test_enable_bitmask, 0, 7) |
__gen_uint(self.statistics_enable.into(), 10, 10) |
__gen_uint(self.cull_mode, 16, 17) |
__gen_uint(self.early_cull_enable.into(), 18, 18) |
__gen_uint(self.vertex_sub_pixel_precision_select, 19, 19) |
__gen_uint(self.front_winding, 20, 20);
out[2] = __gen_uint(self.triangle_fan_provoking_vertex_select, 0, 1) |
__gen_uint(self.line_strip_list_provoking_vertex_select, 2, 3) |
__gen_uint(self.triangle_strip_list_provoking_vertex_select, 4, 5) |
__gen_uint(self.non_perspective_barycentric_enable.into(), 8, 8) |
__gen_uint(self.perspective_divide_disable.into(), 9, 9) |
__gen_uint(self.clip_mode, 13, 15) |
__gen_uint(self.user_clip_distance_clip_test_enable_bitmask, 16, 23) |
__gen_uint(self.guardband_clip_test_enable.into(), 26, 26) |
__gen_uint(self.viewport_z_clip_test_enable.into(), 27, 27) |
__gen_uint(self.viewport_xy_clip_test_enable.into(), 28, 28) |
__gen_uint(self.api_mode, 30, 30) |
__gen_uint(self.clip_enable.into(), 31, 31);
out[3] = __gen_uint(self.maximum_vp_index, 0, 3) |
__gen_uint(self.force_zero_rta_index_enable.into(), 5, 5) |
__gen_ufixed(self.maximum_point_width, 6, 16, 3) |
__gen_ufixed(self.minimum_point_width, 17, 27, 3);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 4];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 4] as *const [u8; 16]) })
}
}
impl From<&[u32; 4]> for _3dStateClip {
fn from(input: &[u32; 4]) -> Self {
_3dStateClip {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
user_clip_distance_cull_test_enable_bitmask: __gen_unuint(input[1], 0, 7),
statistics_enable: __gen_unuint(input[1], 10, 10) != 0,
cull_mode: __gen_unuint(input[1], 16, 17),
early_cull_enable: __gen_unuint(input[1], 18, 18) != 0,
vertex_sub_pixel_precision_select: __gen_unuint(input[1], 19, 19),
front_winding: __gen_unuint(input[1], 20, 20),
triangle_fan_provoking_vertex_select: __gen_unuint(input[2], 0, 1),
line_strip_list_provoking_vertex_select: __gen_unuint(input[2], 2, 3),
triangle_strip_list_provoking_vertex_select: __gen_unuint(input[2], 4, 5),
non_perspective_barycentric_enable: __gen_unuint(input[2], 8, 8) != 0,
perspective_divide_disable: __gen_unuint(input[2], 9, 9) != 0,
clip_mode: __gen_unuint(input[2], 13, 15),
user_clip_distance_clip_test_enable_bitmask: __gen_unuint(input[2], 16, 23),
guardband_clip_test_enable: __gen_unuint(input[2], 26, 26) != 0,
viewport_z_clip_test_enable: __gen_unuint(input[2], 27, 27) != 0,
viewport_xy_clip_test_enable: __gen_unuint(input[2], 28, 28) != 0,
api_mode: __gen_unuint(input[2], 30, 30),
clip_enable: __gen_unuint(input[2], 31, 31) != 0,
maximum_vp_index: __gen_unuint(input[3], 0, 3),
force_zero_rta_index_enable: __gen_unuint(input[3], 5, 5) != 0,
maximum_point_width: __gen_unufixed(input[3], 6, 16, 3),
minimum_point_width: __gen_unufixed(input[3], 17, 27, 3),
}
}
}
impl Deserialize for _3dStateClip {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 4];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 4] as *mut [u8; 16]) })?;
Ok((&input).into())
}
}
pub struct _3dStateConstantBody<A: Addr + Default> {
pub read_length: [u32; 4],
pub mocs: u32,
pub buffer: [A; 4],
}
impl<A: Addr + Default> _3dStateConstantBody<A> {
pub const DWORD_LENGTH: u32 = 6;
}
impl<A: Addr + Default> Default for _3dStateConstantBody<A> {
fn default() -> Self {
_3dStateConstantBody {
read_length: Default::default(),
mocs: Default::default(),
buffer: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for _3dStateConstantBody<A> {
type Out = [u32; 6];
fn pack_into(&self, out: &mut [u32; 6]) {
out[0] = __gen_uint(self.read_length[0], 0, 15) |
__gen_uint(self.read_length[1], 16, 31);
out[1] = __gen_uint(self.read_length[2], 0, 15) |
__gen_uint(self.read_length[3], 16, 31);
let v2 = __gen_uint(self.mocs, 0, 4);
let v2_address = self.buffer[0].combine(v2);
out[2] = v2_address as u32;
out[3] = (v2_address >> 32) as u32;
let v3_address = self.buffer[1].combine(0);
out[3] = v3_address as u32;
out[4] = (v3_address >> 32) as u32;
let v4_address = self.buffer[2].combine(0);
out[4] = v4_address as u32;
out[5] = (v4_address >> 32) as u32;
let v5_address = self.buffer[3].combine(0);
out[5] = v5_address as u32;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 6];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 6] as *const [u8; 24]) })
}
}
impl From<&[u32; 6]> for _3dStateConstantBody<u64> {
fn from(input: &[u32; 6]) -> Self {
_3dStateConstantBody {
read_length: [
__gen_unuint(input[0], 0, 15),
__gen_unuint(input[0], 16, 31),
__gen_unuint(input[1], 0, 15),
__gen_unuint(input[1], 16, 31)
],
mocs: __gen_unuint(input[2], 0, 4),
buffer: [
(__gen_unuint(input[2], 5, 31) as u64) << 5,
(__gen_unuint(input[3], 5, 31) as u64) << 5,
(__gen_unuint(input[4], 5, 31) as u64) << 5,
(__gen_unuint(input[5], 5, 31) as u64) << 5
],
}
}
}
impl Deserialize for _3dStateConstantBody<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 6];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 6] as *mut [u8; 24]) })?;
Ok((&input).into())
}
}
pub struct _3dStateConstantDs<A: Addr + Default> {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub constant_body: _3dStateConstantBody<A>,
}
impl<A: Addr + Default> _3dStateConstantDs<A> {
pub const DWORD_LENGTH: u32 = 7;
}
impl<A: Addr + Default> Default for _3dStateConstantDs<A> {
fn default() -> Self {
_3dStateConstantDs {
dword_length: 5,
_3d_command_sub_opcode: 26,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
constant_body: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for _3dStateConstantDs<A> {
type Out = [u32; 7];
fn pack_into(&self, out: &mut [u32; 7]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
{
let [_, ref mut out1_6 @ ..] = out;
self.constant_body.pack_into(out1_6);
}
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 7];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 7] as *const [u8; 28]) })
}
}
impl From<&[u32; 7]> for _3dStateConstantDs<u64> {
fn from(input: &[u32; 7]) -> Self {
_3dStateConstantDs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
constant_body: {{
let [_, ref in1_6 @ ..] = input;
in1_6.into()
}},
}
}
}
impl Deserialize for _3dStateConstantDs<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 7];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 7] as *mut [u8; 28]) })?;
Ok((&input).into())
}
}
pub struct _3dStateConstantGs<A: Addr + Default> {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub constant_body: _3dStateConstantBody<A>,
}
impl<A: Addr + Default> _3dStateConstantGs<A> {
pub const DWORD_LENGTH: u32 = 7;
}
impl<A: Addr + Default> Default for _3dStateConstantGs<A> {
fn default() -> Self {
_3dStateConstantGs {
dword_length: 5,
_3d_command_sub_opcode: 22,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
constant_body: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for _3dStateConstantGs<A> {
type Out = [u32; 7];
fn pack_into(&self, out: &mut [u32; 7]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
{
let [_, ref mut out1_6 @ ..] = out;
self.constant_body.pack_into(out1_6);
}
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 7];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 7] as *const [u8; 28]) })
}
}
impl From<&[u32; 7]> for _3dStateConstantGs<u64> {
fn from(input: &[u32; 7]) -> Self {
_3dStateConstantGs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
constant_body: {{
let [_, ref in1_6 @ ..] = input;
in1_6.into()
}},
}
}
}
impl Deserialize for _3dStateConstantGs<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 7];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 7] as *mut [u8; 28]) })?;
Ok((&input).into())
}
}
pub struct _3dStateConstantHs<A: Addr + Default> {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub constant_body: _3dStateConstantBody<A>,
}
impl<A: Addr + Default> _3dStateConstantHs<A> {
pub const DWORD_LENGTH: u32 = 7;
}
impl<A: Addr + Default> Default for _3dStateConstantHs<A> {
fn default() -> Self {
_3dStateConstantHs {
dword_length: 5,
_3d_command_sub_opcode: 25,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
constant_body: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for _3dStateConstantHs<A> {
type Out = [u32; 7];
fn pack_into(&self, out: &mut [u32; 7]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
{
let [_, ref mut out1_6 @ ..] = out;
self.constant_body.pack_into(out1_6);
}
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 7];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 7] as *const [u8; 28]) })
}
}
impl From<&[u32; 7]> for _3dStateConstantHs<u64> {
fn from(input: &[u32; 7]) -> Self {
_3dStateConstantHs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
constant_body: {{
let [_, ref in1_6 @ ..] = input;
in1_6.into()
}},
}
}
}
impl Deserialize for _3dStateConstantHs<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 7];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 7] as *mut [u8; 28]) })?;
Ok((&input).into())
}
}
pub struct _3dStateConstantPs<A: Addr + Default> {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub constant_body: _3dStateConstantBody<A>,
}
impl<A: Addr + Default> _3dStateConstantPs<A> {
pub const DWORD_LENGTH: u32 = 7;
}
impl<A: Addr + Default> Default for _3dStateConstantPs<A> {
fn default() -> Self {
_3dStateConstantPs {
dword_length: 5,
_3d_command_sub_opcode: 23,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
constant_body: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for _3dStateConstantPs<A> {
type Out = [u32; 7];
fn pack_into(&self, out: &mut [u32; 7]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
{
let [_, ref mut out1_6 @ ..] = out;
self.constant_body.pack_into(out1_6);
}
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 7];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 7] as *const [u8; 28]) })
}
}
impl From<&[u32; 7]> for _3dStateConstantPs<u64> {
fn from(input: &[u32; 7]) -> Self {
_3dStateConstantPs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
constant_body: {{
let [_, ref in1_6 @ ..] = input;
in1_6.into()
}},
}
}
}
impl Deserialize for _3dStateConstantPs<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 7];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 7] as *mut [u8; 28]) })?;
Ok((&input).into())
}
}
pub struct _3dStateConstantVs<A: Addr + Default> {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub constant_body: _3dStateConstantBody<A>,
}
impl<A: Addr + Default> _3dStateConstantVs<A> {
pub const DWORD_LENGTH: u32 = 7;
}
impl<A: Addr + Default> Default for _3dStateConstantVs<A> {
fn default() -> Self {
_3dStateConstantVs {
dword_length: 5,
_3d_command_sub_opcode: 21,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
constant_body: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for _3dStateConstantVs<A> {
type Out = [u32; 7];
fn pack_into(&self, out: &mut [u32; 7]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
{
let [_, ref mut out1_6 @ ..] = out;
self.constant_body.pack_into(out1_6);
}
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 7];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 7] as *const [u8; 28]) })
}
}
impl From<&[u32; 7]> for _3dStateConstantVs<u64> {
fn from(input: &[u32; 7]) -> Self {
_3dStateConstantVs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
constant_body: {{
let [_, ref in1_6 @ ..] = input;
in1_6.into()
}},
}
}
}
impl Deserialize for _3dStateConstantVs<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 7];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 7] as *mut [u8; 28]) })?;
Ok((&input).into())
}
}
pub struct _3dStateDepthBuffer<A: Addr + Default> {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub surface_pitch: u32,
pub surface_format: u32,
pub hierarchical_depth_buffer_enable: bool,
pub stencil_write_enable: bool,
pub depth_write_enable: bool,
pub surface_type: u32,
pub surface_base_address: A,
pub lod: u32,
pub width: u32,
pub height: u32,
pub mocs: u32,
pub minimum_array_element: u32,
pub depth: u32,
pub depth_coordinate_offset_x: i32,
pub depth_coordinate_offset_y: i32,
pub render_target_view_extent: u32,
}
impl<A: Addr + Default> _3dStateDepthBuffer<A> {
pub const DWORD_LENGTH: u32 = 7;
pub const D16_UNORM: u32 = 5;
pub const D24_UNORM_X8_UINT: u32 = 3;
pub const D32_FLOAT: u32 = 1;
pub const SURFTYPE_1D: u32 = 0;
pub const SURFTYPE_2D: u32 = 1;
pub const SURFTYPE_3D: u32 = 2;
pub const SURFTYPE_CUBE: u32 = 3;
pub const SURFTYPE_CUBE_MUST_BE_ZERO: u32 = 0;
pub const SURFTYPE_NULL: u32 = 7;
}
impl<A: Addr + Default> Default for _3dStateDepthBuffer<A> {
fn default() -> Self {
_3dStateDepthBuffer {
dword_length: 5,
_3d_command_sub_opcode: 5,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
surface_pitch: Default::default(),
surface_format: Default::default(),
hierarchical_depth_buffer_enable: Default::default(),
stencil_write_enable: Default::default(),
depth_write_enable: Default::default(),
surface_type: Default::default(),
surface_base_address: Default::default(),
lod: Default::default(),
width: Default::default(),
height: Default::default(),
mocs: Default::default(),
minimum_array_element: Default::default(),
depth: Default::default(),
depth_coordinate_offset_x: Default::default(),
depth_coordinate_offset_y: Default::default(),
render_target_view_extent: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for _3dStateDepthBuffer<A> {
type Out = [u32; 7];
fn pack_into(&self, out: &mut [u32; 7]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.surface_pitch, 0, 17) |
__gen_uint(self.surface_format, 18, 20) |
__gen_uint(self.hierarchical_depth_buffer_enable.into(), 22, 22) |
__gen_uint(self.stencil_write_enable.into(), 27, 27) |
__gen_uint(self.depth_write_enable.into(), 28, 28) |
__gen_uint(self.surface_type, 29, 31);
let v2_address = self.surface_base_address.combine(0);
out[2] = v2_address as u32;
out[3] = (v2_address >> 32) as u32;
out[3] = __gen_uint(self.lod, 0, 3) |
__gen_uint(self.width, 4, 17) |
__gen_uint(self.height, 18, 31);
out[4] = __gen_uint(self.mocs, 0, 3) |
__gen_uint(self.minimum_array_element, 10, 20) |
__gen_uint(self.depth, 21, 31);
out[5] = __gen_uint(self.depth_coordinate_offset_x as u32, 0, 15) |
__gen_uint(self.depth_coordinate_offset_y as u32, 16, 31);
out[6] = __gen_uint(self.render_target_view_extent, 21, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 7];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 7] as *const [u8; 28]) })
}
}
impl From<&[u32; 7]> for _3dStateDepthBuffer<u64> {
fn from(input: &[u32; 7]) -> Self {
_3dStateDepthBuffer {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
surface_pitch: __gen_unuint(input[1], 0, 17),
surface_format: __gen_unuint(input[1], 18, 20),
hierarchical_depth_buffer_enable: __gen_unuint(input[1], 22, 22) != 0,
stencil_write_enable: __gen_unuint(input[1], 27, 27) != 0,
depth_write_enable: __gen_unuint(input[1], 28, 28) != 0,
surface_type: __gen_unuint(input[1], 29, 31),
surface_base_address: (__gen_unuint(input[2], 0, 31) as u64),
lod: __gen_unuint(input[3], 0, 3),
width: __gen_unuint(input[3], 4, 17),
height: __gen_unuint(input[3], 18, 31),
mocs: __gen_unuint(input[4], 0, 3),
minimum_array_element: __gen_unuint(input[4], 10, 20),
depth: __gen_unuint(input[4], 21, 31),
depth_coordinate_offset_x: (__gen_unuint(input[5], 0, 15)) as i32,
depth_coordinate_offset_y: (__gen_unuint(input[5], 16, 31)) as i32,
render_target_view_extent: __gen_unuint(input[6], 21, 31),
}
}
}
impl Deserialize for _3dStateDepthBuffer<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 7];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 7] as *mut [u8; 28]) })?;
Ok((&input).into())
}
}
pub struct _3dStateDepthStencilStatePointers {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub pointer_to_depth_stencil_state: u64,
}
impl _3dStateDepthStencilStatePointers {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for _3dStateDepthStencilStatePointers {
fn default() -> Self {
_3dStateDepthStencilStatePointers {
dword_length: 0,
_3d_command_sub_opcode: 37,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
pointer_to_depth_stencil_state: Default::default(),
}
}
}
impl Serialize for _3dStateDepthStencilStatePointers {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_mbo(0, 0) |
__gen_offset(self.pointer_to_depth_stencil_state as u32, 6, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStateDepthStencilStatePointers {
fn from(input: &[u32; 2]) -> Self {
_3dStateDepthStencilStatePointers {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
pointer_to_depth_stencil_state: (__gen_unuint(input[1], 6, 31) as u64) << 6,
}
}
}
impl Deserialize for _3dStateDepthStencilStatePointers {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStateDrawingRectangle {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub clipped_drawing_rectangle_x_min: u32,
pub clipped_drawing_rectangle_y_min: u32,
pub clipped_drawing_rectangle_x_max: u32,
pub clipped_drawing_rectangle_y_max: u32,
pub drawing_rectangle_origin_x: i32,
pub drawing_rectangle_origin_y: i32,
}
impl _3dStateDrawingRectangle {
pub const DWORD_LENGTH: u32 = 4;
}
impl Default for _3dStateDrawingRectangle {
fn default() -> Self {
_3dStateDrawingRectangle {
dword_length: 2,
_3d_command_sub_opcode: 0,
_3d_command_opcode: 1,
command_subtype: 3,
command_type: 3,
clipped_drawing_rectangle_x_min: Default::default(),
clipped_drawing_rectangle_y_min: Default::default(),
clipped_drawing_rectangle_x_max: Default::default(),
clipped_drawing_rectangle_y_max: Default::default(),
drawing_rectangle_origin_x: Default::default(),
drawing_rectangle_origin_y: Default::default(),
}
}
}
impl Serialize for _3dStateDrawingRectangle {
type Out = [u32; 4];
fn pack_into(&self, out: &mut [u32; 4]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.clipped_drawing_rectangle_x_min, 0, 15) |
__gen_uint(self.clipped_drawing_rectangle_y_min, 16, 31);
out[2] = __gen_uint(self.clipped_drawing_rectangle_x_max, 0, 15) |
__gen_uint(self.clipped_drawing_rectangle_y_max, 16, 31);
out[3] = __gen_uint(self.drawing_rectangle_origin_x as u32, 0, 15) |
__gen_uint(self.drawing_rectangle_origin_y as u32, 16, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 4];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 4] as *const [u8; 16]) })
}
}
impl From<&[u32; 4]> for _3dStateDrawingRectangle {
fn from(input: &[u32; 4]) -> Self {
_3dStateDrawingRectangle {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
clipped_drawing_rectangle_x_min: __gen_unuint(input[1], 0, 15),
clipped_drawing_rectangle_y_min: __gen_unuint(input[1], 16, 31),
clipped_drawing_rectangle_x_max: __gen_unuint(input[2], 0, 15),
clipped_drawing_rectangle_y_max: __gen_unuint(input[2], 16, 31),
drawing_rectangle_origin_x: (__gen_unuint(input[3], 0, 15)) as i32,
drawing_rectangle_origin_y: (__gen_unuint(input[3], 16, 31)) as i32,
}
}
}
impl Deserialize for _3dStateDrawingRectangle {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 4];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 4] as *mut [u8; 16]) })?;
Ok((&input).into())
}
}
pub struct _3dStateDs<A: Addr + Default> {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub kernel_start_pointer: u64,
pub software_exception_enable: bool,
pub illegal_opcode_exception_enable: bool,
pub floating_point_mode: u32,
pub binding_table_entry_count: u32,
pub sampler_count: u32,
pub vector_mask_enable: bool,
pub single_domain_point_dispatch: u32,
pub per_thread_scratch_space: u32,
pub scratch_space_base_pointer: A,
pub patch_urb_entry_read_offset: u32,
pub patch_urb_entry_read_length: u32,
pub dispatch_grf_start_register_for_urb_data: u32,
pub enable: bool,
pub ds_cache_disable: bool,
pub compute_w_coordinate_enable: bool,
pub statistics_enable: bool,
pub maximum_number_of_threads: u32,
}
impl<A: Addr + Default> _3dStateDs<A> {
pub const DWORD_LENGTH: u32 = 6;
pub const ALTERNATE: u32 = 1;
pub const IEEE_754: u32 = 0;
pub const NO_SAMPLERS: u32 = 0;
pub const _13_16_SAMPLERS: u32 = 4;
pub const _1_4_SAMPLERS: u32 = 1;
pub const _5_8_SAMPLERS: u32 = 2;
pub const _9_12_SAMPLERS: u32 = 3;
}
impl<A: Addr + Default> Default for _3dStateDs<A> {
fn default() -> Self {
_3dStateDs {
dword_length: 4,
_3d_command_sub_opcode: 29,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
kernel_start_pointer: Default::default(),
software_exception_enable: Default::default(),
illegal_opcode_exception_enable: Default::default(),
floating_point_mode: Default::default(),
binding_table_entry_count: Default::default(),
sampler_count: Default::default(),
vector_mask_enable: Default::default(),
single_domain_point_dispatch: Default::default(),
per_thread_scratch_space: Default::default(),
scratch_space_base_pointer: Default::default(),
patch_urb_entry_read_offset: Default::default(),
patch_urb_entry_read_length: Default::default(),
dispatch_grf_start_register_for_urb_data: Default::default(),
enable: Default::default(),
ds_cache_disable: Default::default(),
compute_w_coordinate_enable: Default::default(),
statistics_enable: Default::default(),
maximum_number_of_threads: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for _3dStateDs<A> {
type Out = [u32; 6];
fn pack_into(&self, out: &mut [u32; 6]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_offset(self.kernel_start_pointer as u32, 6, 31);
out[2] = __gen_uint(self.software_exception_enable.into(), 7, 7) |
__gen_uint(self.illegal_opcode_exception_enable.into(), 13, 13) |
__gen_uint(self.floating_point_mode, 16, 16) |
__gen_uint(self.binding_table_entry_count, 18, 25) |
__gen_uint(self.sampler_count, 27, 29) |
__gen_uint(self.vector_mask_enable.into(), 30, 30) |
__gen_uint(self.single_domain_point_dispatch, 31, 31);
let v3 = __gen_uint(self.per_thread_scratch_space, 0, 3);
let v3_address = self.scratch_space_base_pointer.combine(v3);
out[3] = v3_address as u32;
out[4] = (v3_address >> 32) as u32;
out[4] = __gen_uint(self.patch_urb_entry_read_offset, 4, 9) |
__gen_uint(self.patch_urb_entry_read_length, 11, 17) |
__gen_uint(self.dispatch_grf_start_register_for_urb_data, 20, 24);
out[5] = __gen_uint(self.enable.into(), 0, 0) |
__gen_uint(self.ds_cache_disable.into(), 1, 1) |
__gen_uint(self.compute_w_coordinate_enable.into(), 2, 2) |
__gen_uint(self.statistics_enable.into(), 10, 10) |
__gen_uint(self.maximum_number_of_threads, 25, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 6];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 6] as *const [u8; 24]) })
}
}
impl From<&[u32; 6]> for _3dStateDs<u64> {
fn from(input: &[u32; 6]) -> Self {
_3dStateDs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
kernel_start_pointer: (__gen_unuint(input[1], 6, 31) as u64) << 6,
software_exception_enable: __gen_unuint(input[2], 7, 7) != 0,
illegal_opcode_exception_enable: __gen_unuint(input[2], 13, 13) != 0,
floating_point_mode: __gen_unuint(input[2], 16, 16),
binding_table_entry_count: __gen_unuint(input[2], 18, 25),
sampler_count: __gen_unuint(input[2], 27, 29),
vector_mask_enable: __gen_unuint(input[2], 30, 30) != 0,
single_domain_point_dispatch: __gen_unuint(input[2], 31, 31),
per_thread_scratch_space: __gen_unuint(input[3], 0, 3),
scratch_space_base_pointer: (__gen_unuint(input[3], 10, 31) as u64) << 10,
patch_urb_entry_read_offset: __gen_unuint(input[4], 4, 9),
patch_urb_entry_read_length: __gen_unuint(input[4], 11, 17),
dispatch_grf_start_register_for_urb_data: __gen_unuint(input[4], 20, 24),
enable: __gen_unuint(input[5], 0, 0) != 0,
ds_cache_disable: __gen_unuint(input[5], 1, 1) != 0,
compute_w_coordinate_enable: __gen_unuint(input[5], 2, 2) != 0,
statistics_enable: __gen_unuint(input[5], 10, 10) != 0,
maximum_number_of_threads: __gen_unuint(input[5], 25, 31),
}
}
}
impl Deserialize for _3dStateDs<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 6];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 6] as *mut [u8; 24]) })?;
Ok((&input).into())
}
}
pub struct _3dStateGs<A: Addr + Default> {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub kernel_start_pointer: u64,
pub software_exception_enable: bool,
pub mask_stack_exception_enable: bool,
pub illegal_opcode_exception_enable: bool,
pub floating_point_mode: u32,
pub thread_priority: u32,
pub binding_table_entry_count: u32,
pub sampler_count: u32,
pub vector_mask_enable: bool,
pub single_program_flow: bool,
pub per_thread_scratch_space: u32,
pub scratch_space_base_pointer: A,
pub dispatch_grf_start_register_for_urb_data: u32,
pub vertex_urb_entry_read_offset: u32,
pub include_vertex_handles: bool,
pub vertex_urb_entry_read_length: u32,
pub output_topology: _3dPrimTopoType,
pub output_vertex_size: u32,
pub enable: bool,
pub discard_adjacency: bool,
pub reorder_mode: u32,
pub hint: u32,
pub include_primitive_id: bool,
pub gs_invocations_increment_value: u32,
pub statistics_enable: u32,
pub dispatch_mode: u32,
pub default_streamid: u32,
pub instance_control: u32,
pub control_data_header_size: u32,
pub control_data_format: u32,
pub maximum_number_of_threads: u32,
pub semaphore_handle: u64,
}
impl<A: Addr + Default> _3dStateGs<A> {
pub const DWORD_LENGTH: u32 = 7;
pub const ALTERNATE: u32 = 1;
pub const DUAL_INSTANCE: u32 = 1;
pub const DUAL_OBJECT: u32 = 2;
pub const GSCTL_CUT: u32 = 0;
pub const GSCTL_SID: u32 = 1;
pub const HIGH_PRIORITY: u32 = 1;
pub const IEEE_754: u32 = 0;
pub const LEADING: u32 = 0;
pub const NORMAL_PRIORITY: u32 = 0;
pub const NO_SAMPLERS: u32 = 0;
pub const SINGLE: u32 = 0;
pub const TRAILING: u32 = 1;
pub const _13_16_SAMPLERS: u32 = 4;
pub const _1_4_SAMPLERS: u32 = 1;
pub const _5_8_SAMPLERS: u32 = 2;
pub const _9_12_SAMPLERS: u32 = 3;
}
impl<A: Addr + Default> Default for _3dStateGs<A> {
fn default() -> Self {
_3dStateGs {
dword_length: 5,
_3d_command_sub_opcode: 17,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
kernel_start_pointer: Default::default(),
software_exception_enable: Default::default(),
mask_stack_exception_enable: Default::default(),
illegal_opcode_exception_enable: Default::default(),
floating_point_mode: Default::default(),
thread_priority: Default::default(),
binding_table_entry_count: Default::default(),
sampler_count: Default::default(),
vector_mask_enable: Default::default(),
single_program_flow: Default::default(),
per_thread_scratch_space: Default::default(),
scratch_space_base_pointer: Default::default(),
dispatch_grf_start_register_for_urb_data: Default::default(),
vertex_urb_entry_read_offset: Default::default(),
include_vertex_handles: Default::default(),
vertex_urb_entry_read_length: Default::default(),
output_topology: Default::default(),
output_vertex_size: Default::default(),
enable: Default::default(),
discard_adjacency: Default::default(),
reorder_mode: Default::default(),
hint: Default::default(),
include_primitive_id: Default::default(),
gs_invocations_increment_value: Default::default(),
statistics_enable: Default::default(),
dispatch_mode: Default::default(),
default_streamid: Default::default(),
instance_control: Default::default(),
control_data_header_size: Default::default(),
control_data_format: Default::default(),
maximum_number_of_threads: Default::default(),
semaphore_handle: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for _3dStateGs<A> {
type Out = [u32; 7];
fn pack_into(&self, out: &mut [u32; 7]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_offset(self.kernel_start_pointer as u32, 6, 31);
out[2] = __gen_uint(self.software_exception_enable.into(), 7, 7) |
__gen_uint(self.mask_stack_exception_enable.into(), 11, 11) |
__gen_uint(self.illegal_opcode_exception_enable.into(), 13, 13) |
__gen_uint(self.floating_point_mode, 16, 16) |
__gen_uint(self.thread_priority, 17, 17) |
__gen_uint(self.binding_table_entry_count, 18, 25) |
__gen_uint(self.sampler_count, 27, 29) |
__gen_uint(self.vector_mask_enable.into(), 30, 30) |
__gen_uint(self.single_program_flow.into(), 31, 31);
let v3 = __gen_uint(self.per_thread_scratch_space, 0, 3);
let v3_address = self.scratch_space_base_pointer.combine(v3);
out[3] = v3_address as u32;
out[4] = (v3_address >> 32) as u32;
out[4] = __gen_uint(self.dispatch_grf_start_register_for_urb_data, 0, 3) |
__gen_uint(self.vertex_urb_entry_read_offset, 4, 9) |
__gen_uint(self.include_vertex_handles.into(), 10, 10) |
__gen_uint(self.vertex_urb_entry_read_length, 11, 16) |
__gen_uint(self.output_topology.into(), 17, 22) |
__gen_uint(self.output_vertex_size, 23, 28);
out[5] = __gen_uint(self.enable.into(), 0, 0) |
__gen_uint(self.discard_adjacency.into(), 1, 1) |
__gen_uint(self.reorder_mode, 2, 2) |
__gen_uint(self.hint, 3, 3) |
__gen_uint(self.include_primitive_id.into(), 4, 4) |
__gen_uint(self.gs_invocations_increment_value, 5, 9) |
__gen_uint(self.statistics_enable, 10, 10) |
__gen_uint(self.dispatch_mode, 11, 12) |
__gen_uint(self.default_streamid, 13, 14) |
__gen_uint(self.instance_control, 15, 19) |
__gen_uint(self.control_data_header_size, 20, 23) |
__gen_uint(self.control_data_format, 24, 24) |
__gen_uint(self.maximum_number_of_threads, 25, 31);
out[6] = __gen_offset(self.semaphore_handle as u32, 0, 11);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 7];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 7] as *const [u8; 28]) })
}
}
impl From<&[u32; 7]> for _3dStateGs<u64> {
fn from(input: &[u32; 7]) -> Self {
_3dStateGs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
kernel_start_pointer: (__gen_unuint(input[1], 6, 31) as u64) << 6,
software_exception_enable: __gen_unuint(input[2], 7, 7) != 0,
mask_stack_exception_enable: __gen_unuint(input[2], 11, 11) != 0,
illegal_opcode_exception_enable: __gen_unuint(input[2], 13, 13) != 0,
floating_point_mode: __gen_unuint(input[2], 16, 16),
thread_priority: __gen_unuint(input[2], 17, 17),
binding_table_entry_count: __gen_unuint(input[2], 18, 25),
sampler_count: __gen_unuint(input[2], 27, 29),
vector_mask_enable: __gen_unuint(input[2], 30, 30) != 0,
single_program_flow: __gen_unuint(input[2], 31, 31) != 0,
per_thread_scratch_space: __gen_unuint(input[3], 0, 3),
scratch_space_base_pointer: (__gen_unuint(input[3], 10, 31) as u64) << 10,
dispatch_grf_start_register_for_urb_data: __gen_unuint(input[4], 0, 3),
vertex_urb_entry_read_offset: __gen_unuint(input[4], 4, 9),
include_vertex_handles: __gen_unuint(input[4], 10, 10) != 0,
vertex_urb_entry_read_length: __gen_unuint(input[4], 11, 16),
output_topology: (__gen_unuint(input[4], 17, 22)).into(),
output_vertex_size: __gen_unuint(input[4], 23, 28),
enable: __gen_unuint(input[5], 0, 0) != 0,
discard_adjacency: __gen_unuint(input[5], 1, 1) != 0,
reorder_mode: __gen_unuint(input[5], 2, 2),
hint: __gen_unuint(input[5], 3, 3),
include_primitive_id: __gen_unuint(input[5], 4, 4) != 0,
gs_invocations_increment_value: __gen_unuint(input[5], 5, 9),
statistics_enable: __gen_unuint(input[5], 10, 10),
dispatch_mode: __gen_unuint(input[5], 11, 12),
default_streamid: __gen_unuint(input[5], 13, 14),
instance_control: __gen_unuint(input[5], 15, 19),
control_data_header_size: __gen_unuint(input[5], 20, 23),
control_data_format: __gen_unuint(input[5], 24, 24),
maximum_number_of_threads: __gen_unuint(input[5], 25, 31),
semaphore_handle: (__gen_unuint(input[6], 0, 11) as u64),
}
}
}
impl Deserialize for _3dStateGs<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 7];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 7] as *mut [u8; 28]) })?;
Ok((&input).into())
}
}
pub struct _3dStateHierDepthBuffer<A: Addr + Default> {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub surface_pitch: u32,
pub mocs: u32,
pub surface_base_address: A,
}
impl<A: Addr + Default> _3dStateHierDepthBuffer<A> {
pub const DWORD_LENGTH: u32 = 3;
}
impl<A: Addr + Default> Default for _3dStateHierDepthBuffer<A> {
fn default() -> Self {
_3dStateHierDepthBuffer {
dword_length: 1,
_3d_command_sub_opcode: 7,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
surface_pitch: Default::default(),
mocs: Default::default(),
surface_base_address: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for _3dStateHierDepthBuffer<A> {
type Out = [u32; 3];
fn pack_into(&self, out: &mut [u32; 3]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.surface_pitch, 0, 16) |
__gen_uint(self.mocs, 25, 28);
let v2_address = self.surface_base_address.combine(0);
out[2] = v2_address as u32;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 3];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 3] as *const [u8; 12]) })
}
}
impl From<&[u32; 3]> for _3dStateHierDepthBuffer<u64> {
fn from(input: &[u32; 3]) -> Self {
_3dStateHierDepthBuffer {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
surface_pitch: __gen_unuint(input[1], 0, 16),
mocs: __gen_unuint(input[1], 25, 28),
surface_base_address: (__gen_unuint(input[2], 0, 31) as u64),
}
}
}
impl Deserialize for _3dStateHierDepthBuffer<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 3];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 3] as *mut [u8; 12]) })?;
Ok((&input).into())
}
}
pub struct _3dStateHs<A: Addr + Default> {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub maximum_number_of_threads: u32,
pub software_exception_enable: bool,
pub illegal_opcode_exception_enable: bool,
pub floating_point_mode: u32,
pub binding_table_entry_count: u32,
pub sampler_count: u32,
pub instance_count: u32,
pub statistics_enable: bool,
pub enable: bool,
pub kernel_start_pointer: u64,
pub per_thread_scratch_space: u32,
pub scratch_space_base_pointer: A,
pub vertex_urb_entry_read_offset: u32,
pub vertex_urb_entry_read_length: u32,
pub dispatch_grf_start_register_for_urb_data: u32,
pub include_vertex_handles: bool,
pub vector_mask_enable: bool,
pub single_program_flow: bool,
pub semaphore_handle: u64,
}
impl<A: Addr + Default> _3dStateHs<A> {
pub const DWORD_LENGTH: u32 = 7;
pub const ALTERNATE: u32 = 1;
pub const IEEE_754: u32 = 0;
pub const NO_SAMPLERS: u32 = 0;
pub const _13_16_SAMPLERS: u32 = 4;
pub const _1_4_SAMPLERS: u32 = 1;
pub const _5_8_SAMPLERS: u32 = 2;
pub const _9_12_SAMPLERS: u32 = 3;
}
impl<A: Addr + Default> Default for _3dStateHs<A> {
fn default() -> Self {
_3dStateHs {
dword_length: 5,
_3d_command_sub_opcode: 27,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
maximum_number_of_threads: Default::default(),
software_exception_enable: Default::default(),
illegal_opcode_exception_enable: Default::default(),
floating_point_mode: Default::default(),
binding_table_entry_count: Default::default(),
sampler_count: Default::default(),
instance_count: Default::default(),
statistics_enable: Default::default(),
enable: Default::default(),
kernel_start_pointer: Default::default(),
per_thread_scratch_space: Default::default(),
scratch_space_base_pointer: Default::default(),
vertex_urb_entry_read_offset: Default::default(),
vertex_urb_entry_read_length: Default::default(),
dispatch_grf_start_register_for_urb_data: Default::default(),
include_vertex_handles: Default::default(),
vector_mask_enable: Default::default(),
single_program_flow: Default::default(),
semaphore_handle: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for _3dStateHs<A> {
type Out = [u32; 7];
fn pack_into(&self, out: &mut [u32; 7]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.maximum_number_of_threads, 0, 6) |
__gen_uint(self.software_exception_enable.into(), 7, 7) |
__gen_uint(self.illegal_opcode_exception_enable.into(), 13, 13) |
__gen_uint(self.floating_point_mode, 16, 16) |
__gen_uint(self.binding_table_entry_count, 18, 25) |
__gen_uint(self.sampler_count, 27, 29);
out[2] = __gen_uint(self.instance_count, 0, 3) |
__gen_uint(self.statistics_enable.into(), 29, 29) |
__gen_uint(self.enable.into(), 31, 31);
out[3] = __gen_offset(self.kernel_start_pointer as u32, 6, 31);
let v4 = __gen_uint(self.per_thread_scratch_space, 0, 3);
let v4_address = self.scratch_space_base_pointer.combine(v4);
out[4] = v4_address as u32;
out[5] = (v4_address >> 32) as u32;
out[5] = __gen_uint(self.vertex_urb_entry_read_offset, 4, 9) |
__gen_uint(self.vertex_urb_entry_read_length, 11, 16) |
__gen_uint(self.dispatch_grf_start_register_for_urb_data, 19, 23) |
__gen_uint(self.include_vertex_handles.into(), 24, 24) |
__gen_uint(self.vector_mask_enable.into(), 26, 26) |
__gen_uint(self.single_program_flow.into(), 27, 27);
out[6] = __gen_offset(self.semaphore_handle as u32, 0, 11);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 7];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 7] as *const [u8; 28]) })
}
}
impl From<&[u32; 7]> for _3dStateHs<u64> {
fn from(input: &[u32; 7]) -> Self {
_3dStateHs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
maximum_number_of_threads: __gen_unuint(input[1], 0, 6),
software_exception_enable: __gen_unuint(input[1], 7, 7) != 0,
illegal_opcode_exception_enable: __gen_unuint(input[1], 13, 13) != 0,
floating_point_mode: __gen_unuint(input[1], 16, 16),
binding_table_entry_count: __gen_unuint(input[1], 18, 25),
sampler_count: __gen_unuint(input[1], 27, 29),
instance_count: __gen_unuint(input[2], 0, 3),
statistics_enable: __gen_unuint(input[2], 29, 29) != 0,
enable: __gen_unuint(input[2], 31, 31) != 0,
kernel_start_pointer: (__gen_unuint(input[3], 6, 31) as u64) << 6,
per_thread_scratch_space: __gen_unuint(input[4], 0, 3),
scratch_space_base_pointer: (__gen_unuint(input[4], 10, 31) as u64) << 10,
vertex_urb_entry_read_offset: __gen_unuint(input[5], 4, 9),
vertex_urb_entry_read_length: __gen_unuint(input[5], 11, 16),
dispatch_grf_start_register_for_urb_data: __gen_unuint(input[5], 19, 23),
include_vertex_handles: __gen_unuint(input[5], 24, 24) != 0,
vector_mask_enable: __gen_unuint(input[5], 26, 26) != 0,
single_program_flow: __gen_unuint(input[5], 27, 27) != 0,
semaphore_handle: (__gen_unuint(input[6], 0, 11) as u64),
}
}
}
impl Deserialize for _3dStateHs<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 7];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 7] as *mut [u8; 28]) })?;
Ok((&input).into())
}
}
pub struct _3dStateIndexBuffer<A: Addr + Default> {
pub dword_length: u32,
pub index_format: u32,
pub cut_index_enable: bool,
pub mocs: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub buffer_starting_address: A,
pub buffer_ending_address: A,
}
impl<A: Addr + Default> _3dStateIndexBuffer<A> {
pub const DWORD_LENGTH: u32 = 3;
pub const BYTE: u32 = 0;
pub const DWORD: u32 = 2;
pub const WORD: u32 = 1;
}
impl<A: Addr + Default> Default for _3dStateIndexBuffer<A> {
fn default() -> Self {
_3dStateIndexBuffer {
dword_length: 1,
index_format: Default::default(),
cut_index_enable: Default::default(),
mocs: Default::default(),
_3d_command_sub_opcode: 10,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
buffer_starting_address: Default::default(),
buffer_ending_address: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for _3dStateIndexBuffer<A> {
type Out = [u32; 3];
fn pack_into(&self, out: &mut [u32; 3]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self.index_format, 8, 9) |
__gen_uint(self.cut_index_enable.into(), 10, 10) |
__gen_uint(self.mocs, 12, 15) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
let v1_address = self.buffer_starting_address.combine(0);
out[1] = v1_address as u32;
out[2] = (v1_address >> 32) as u32;
let v2_address = self.buffer_ending_address.combine(0);
out[2] = v2_address as u32;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 3];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 3] as *const [u8; 12]) })
}
}
impl From<&[u32; 3]> for _3dStateIndexBuffer<u64> {
fn from(input: &[u32; 3]) -> Self {
_3dStateIndexBuffer {
dword_length: __gen_unuint(input[0], 0, 7),
index_format: __gen_unuint(input[0], 8, 9),
cut_index_enable: __gen_unuint(input[0], 10, 10) != 0,
mocs: __gen_unuint(input[0], 12, 15),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
buffer_starting_address: (__gen_unuint(input[1], 0, 31) as u64),
buffer_ending_address: (__gen_unuint(input[2], 0, 31) as u64),
}
}
}
impl Deserialize for _3dStateIndexBuffer<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 3];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 3] as *mut [u8; 12]) })?;
Ok((&input).into())
}
}
pub struct _3dStateLineStipple {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub line_stipple_pattern: u32,
pub current_stipple_index: u32,
pub current_repeat_counter: u32,
pub modify_enable_current_repeat_counter_current_stipple_index: bool,
pub line_stipple_repeat_count: u32,
pub line_stipple_inverse_repeat_count: f32,
}
impl _3dStateLineStipple {
pub const DWORD_LENGTH: u32 = 3;
}
impl Default for _3dStateLineStipple {
fn default() -> Self {
_3dStateLineStipple {
dword_length: 1,
_3d_command_sub_opcode: 8,
_3d_command_opcode: 1,
command_subtype: 3,
command_type: 3,
line_stipple_pattern: Default::default(),
current_stipple_index: Default::default(),
current_repeat_counter: Default::default(),
modify_enable_current_repeat_counter_current_stipple_index: Default::default(),
line_stipple_repeat_count: Default::default(),
line_stipple_inverse_repeat_count: Default::default(),
}
}
}
impl Serialize for _3dStateLineStipple {
type Out = [u32; 3];
fn pack_into(&self, out: &mut [u32; 3]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.line_stipple_pattern, 0, 15) |
__gen_uint(self.current_stipple_index, 16, 19) |
__gen_uint(self.current_repeat_counter, 21, 29) |
__gen_uint(self.modify_enable_current_repeat_counter_current_stipple_index.into(), 31, 31);
out[2] = __gen_uint(self.line_stipple_repeat_count, 0, 8) |
__gen_ufixed(self.line_stipple_inverse_repeat_count, 15, 31, 16);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 3];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 3] as *const [u8; 12]) })
}
}
impl From<&[u32; 3]> for _3dStateLineStipple {
fn from(input: &[u32; 3]) -> Self {
_3dStateLineStipple {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
line_stipple_pattern: __gen_unuint(input[1], 0, 15),
current_stipple_index: __gen_unuint(input[1], 16, 19),
current_repeat_counter: __gen_unuint(input[1], 21, 29),
modify_enable_current_repeat_counter_current_stipple_index: __gen_unuint(input[1], 31, 31) != 0,
line_stipple_repeat_count: __gen_unuint(input[2], 0, 8),
line_stipple_inverse_repeat_count: __gen_unufixed(input[2], 15, 31, 16),
}
}
}
impl Deserialize for _3dStateLineStipple {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 3];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 3] as *mut [u8; 12]) })?;
Ok((&input).into())
}
}
pub struct _3dStateMonofilterSize {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub monochrome_filter_height: u32,
pub monochrome_filter_width: u32,
}
impl _3dStateMonofilterSize {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for _3dStateMonofilterSize {
fn default() -> Self {
_3dStateMonofilterSize {
dword_length: 0,
_3d_command_sub_opcode: 17,
_3d_command_opcode: 1,
command_subtype: 3,
command_type: 3,
monochrome_filter_height: Default::default(),
monochrome_filter_width: Default::default(),
}
}
}
impl Serialize for _3dStateMonofilterSize {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.monochrome_filter_height, 0, 2) |
__gen_uint(self.monochrome_filter_width, 3, 5);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStateMonofilterSize {
fn from(input: &[u32; 2]) -> Self {
_3dStateMonofilterSize {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
monochrome_filter_height: __gen_unuint(input[1], 0, 2),
monochrome_filter_width: __gen_unuint(input[1], 3, 5),
}
}
}
impl Deserialize for _3dStateMonofilterSize {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStateMultisample {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub number_of_multisamples: u32,
pub pixel_location: u32,
pub sample0_y_offset: f32,
pub sample0_x_offset: f32,
pub sample1_y_offset: f32,
pub sample1_x_offset: f32,
pub sample2_y_offset: f32,
pub sample2_x_offset: f32,
pub sample3_y_offset: f32,
pub sample3_x_offset: f32,
pub sample4_y_offset: f32,
pub sample4_x_offset: f32,
pub sample5_y_offset: f32,
pub sample5_x_offset: f32,
pub sample6_y_offset: f32,
pub sample6_x_offset: f32,
pub sample7_y_offset: f32,
pub sample7_x_offset: f32,
}
impl _3dStateMultisample {
pub const DWORD_LENGTH: u32 = 4;
pub const CENTER: u32 = 0;
pub const NUMSAMPLES_1: u32 = 0;
pub const NUMSAMPLES_4: u32 = 2;
pub const NUMSAMPLES_8: u32 = 3;
pub const UL_CORNER: u32 = 1;
}
impl Default for _3dStateMultisample {
fn default() -> Self {
_3dStateMultisample {
dword_length: 2,
_3d_command_sub_opcode: 13,
_3d_command_opcode: 1,
command_subtype: 3,
command_type: 3,
number_of_multisamples: Default::default(),
pixel_location: Default::default(),
sample0_y_offset: Default::default(),
sample0_x_offset: Default::default(),
sample1_y_offset: Default::default(),
sample1_x_offset: Default::default(),
sample2_y_offset: Default::default(),
sample2_x_offset: Default::default(),
sample3_y_offset: Default::default(),
sample3_x_offset: Default::default(),
sample4_y_offset: Default::default(),
sample4_x_offset: Default::default(),
sample5_y_offset: Default::default(),
sample5_x_offset: Default::default(),
sample6_y_offset: Default::default(),
sample6_x_offset: Default::default(),
sample7_y_offset: Default::default(),
sample7_x_offset: Default::default(),
}
}
}
impl Serialize for _3dStateMultisample {
type Out = [u32; 4];
fn pack_into(&self, out: &mut [u32; 4]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.number_of_multisamples, 1, 3) |
__gen_uint(self.pixel_location, 4, 4);
out[2] = __gen_ufixed(self.sample0_y_offset, 0, 3, 4) |
__gen_ufixed(self.sample0_x_offset, 4, 7, 4) |
__gen_ufixed(self.sample1_y_offset, 8, 11, 4) |
__gen_ufixed(self.sample1_x_offset, 12, 15, 4) |
__gen_ufixed(self.sample2_y_offset, 16, 19, 4) |
__gen_ufixed(self.sample2_x_offset, 20, 23, 4) |
__gen_ufixed(self.sample3_y_offset, 24, 27, 4) |
__gen_ufixed(self.sample3_x_offset, 28, 31, 4);
out[3] = __gen_ufixed(self.sample4_y_offset, 0, 3, 4) |
__gen_ufixed(self.sample4_x_offset, 4, 7, 4) |
__gen_ufixed(self.sample5_y_offset, 8, 11, 4) |
__gen_ufixed(self.sample5_x_offset, 12, 15, 4) |
__gen_ufixed(self.sample6_y_offset, 16, 19, 4) |
__gen_ufixed(self.sample6_x_offset, 20, 23, 4) |
__gen_ufixed(self.sample7_y_offset, 24, 27, 4) |
__gen_ufixed(self.sample7_x_offset, 28, 31, 4);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 4];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 4] as *const [u8; 16]) })
}
}
impl From<&[u32; 4]> for _3dStateMultisample {
fn from(input: &[u32; 4]) -> Self {
_3dStateMultisample {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
number_of_multisamples: __gen_unuint(input[1], 1, 3),
pixel_location: __gen_unuint(input[1], 4, 4),
sample0_y_offset: __gen_unufixed(input[2], 0, 3, 4),
sample0_x_offset: __gen_unufixed(input[2], 4, 7, 4),
sample1_y_offset: __gen_unufixed(input[2], 8, 11, 4),
sample1_x_offset: __gen_unufixed(input[2], 12, 15, 4),
sample2_y_offset: __gen_unufixed(input[2], 16, 19, 4),
sample2_x_offset: __gen_unufixed(input[2], 20, 23, 4),
sample3_y_offset: __gen_unufixed(input[2], 24, 27, 4),
sample3_x_offset: __gen_unufixed(input[2], 28, 31, 4),
sample4_y_offset: __gen_unufixed(input[3], 0, 3, 4),
sample4_x_offset: __gen_unufixed(input[3], 4, 7, 4),
sample5_y_offset: __gen_unufixed(input[3], 8, 11, 4),
sample5_x_offset: __gen_unufixed(input[3], 12, 15, 4),
sample6_y_offset: __gen_unufixed(input[3], 16, 19, 4),
sample6_x_offset: __gen_unufixed(input[3], 20, 23, 4),
sample7_y_offset: __gen_unufixed(input[3], 24, 27, 4),
sample7_x_offset: __gen_unufixed(input[3], 28, 31, 4),
}
}
}
impl Deserialize for _3dStateMultisample {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 4];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 4] as *mut [u8; 16]) })?;
Ok((&input).into())
}
}
pub struct _3dStatePolyStippleOffset {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub polygon_stipple_y_offset: u32,
pub polygon_stipple_x_offset: u32,
}
impl _3dStatePolyStippleOffset {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for _3dStatePolyStippleOffset {
fn default() -> Self {
_3dStatePolyStippleOffset {
dword_length: 0,
_3d_command_sub_opcode: 6,
_3d_command_opcode: 1,
command_subtype: 3,
command_type: 3,
polygon_stipple_y_offset: Default::default(),
polygon_stipple_x_offset: Default::default(),
}
}
}
impl Serialize for _3dStatePolyStippleOffset {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.polygon_stipple_y_offset, 0, 4) |
__gen_uint(self.polygon_stipple_x_offset, 8, 12);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStatePolyStippleOffset {
fn from(input: &[u32; 2]) -> Self {
_3dStatePolyStippleOffset {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
polygon_stipple_y_offset: __gen_unuint(input[1], 0, 4),
polygon_stipple_x_offset: __gen_unuint(input[1], 8, 12),
}
}
}
impl Deserialize for _3dStatePolyStippleOffset {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStatePolyStipplePattern {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub pattern_row: [u32; 32],
}
impl _3dStatePolyStipplePattern {
pub const DWORD_LENGTH: u32 = 33;
}
impl Default for _3dStatePolyStipplePattern {
fn default() -> Self {
_3dStatePolyStipplePattern {
dword_length: 31,
_3d_command_sub_opcode: 7,
_3d_command_opcode: 1,
command_subtype: 3,
command_type: 3,
pattern_row: Default::default(),
}
}
}
impl Serialize for _3dStatePolyStipplePattern {
type Out = [u32; 33];
fn pack_into(&self, out: &mut [u32; 33]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.pattern_row[0], 0, 31);
out[2] = __gen_uint(self.pattern_row[1], 0, 31);
out[3] = __gen_uint(self.pattern_row[2], 0, 31);
out[4] = __gen_uint(self.pattern_row[3], 0, 31);
out[5] = __gen_uint(self.pattern_row[4], 0, 31);
out[6] = __gen_uint(self.pattern_row[5], 0, 31);
out[7] = __gen_uint(self.pattern_row[6], 0, 31);
out[8] = __gen_uint(self.pattern_row[7], 0, 31);
out[9] = __gen_uint(self.pattern_row[8], 0, 31);
out[10] = __gen_uint(self.pattern_row[9], 0, 31);
out[11] = __gen_uint(self.pattern_row[10], 0, 31);
out[12] = __gen_uint(self.pattern_row[11], 0, 31);
out[13] = __gen_uint(self.pattern_row[12], 0, 31);
out[14] = __gen_uint(self.pattern_row[13], 0, 31);
out[15] = __gen_uint(self.pattern_row[14], 0, 31);
out[16] = __gen_uint(self.pattern_row[15], 0, 31);
out[17] = __gen_uint(self.pattern_row[16], 0, 31);
out[18] = __gen_uint(self.pattern_row[17], 0, 31);
out[19] = __gen_uint(self.pattern_row[18], 0, 31);
out[20] = __gen_uint(self.pattern_row[19], 0, 31);
out[21] = __gen_uint(self.pattern_row[20], 0, 31);
out[22] = __gen_uint(self.pattern_row[21], 0, 31);
out[23] = __gen_uint(self.pattern_row[22], 0, 31);
out[24] = __gen_uint(self.pattern_row[23], 0, 31);
out[25] = __gen_uint(self.pattern_row[24], 0, 31);
out[26] = __gen_uint(self.pattern_row[25], 0, 31);
out[27] = __gen_uint(self.pattern_row[26], 0, 31);
out[28] = __gen_uint(self.pattern_row[27], 0, 31);
out[29] = __gen_uint(self.pattern_row[28], 0, 31);
out[30] = __gen_uint(self.pattern_row[29], 0, 31);
out[31] = __gen_uint(self.pattern_row[30], 0, 31);
out[32] = __gen_uint(self.pattern_row[31], 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 33];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 33] as *const [u8; 132]) })
}
}
impl From<&[u32; 33]> for _3dStatePolyStipplePattern {
fn from(input: &[u32; 33]) -> Self {
_3dStatePolyStipplePattern {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
pattern_row: [
__gen_unuint(input[1], 0, 31),
__gen_unuint(input[2], 0, 31),
__gen_unuint(input[3], 0, 31),
__gen_unuint(input[4], 0, 31),
__gen_unuint(input[5], 0, 31),
__gen_unuint(input[6], 0, 31),
__gen_unuint(input[7], 0, 31),
__gen_unuint(input[8], 0, 31),
__gen_unuint(input[9], 0, 31),
__gen_unuint(input[10], 0, 31),
__gen_unuint(input[11], 0, 31),
__gen_unuint(input[12], 0, 31),
__gen_unuint(input[13], 0, 31),
__gen_unuint(input[14], 0, 31),
__gen_unuint(input[15], 0, 31),
__gen_unuint(input[16], 0, 31),
__gen_unuint(input[17], 0, 31),
__gen_unuint(input[18], 0, 31),
__gen_unuint(input[19], 0, 31),
__gen_unuint(input[20], 0, 31),
__gen_unuint(input[21], 0, 31),
__gen_unuint(input[22], 0, 31),
__gen_unuint(input[23], 0, 31),
__gen_unuint(input[24], 0, 31),
__gen_unuint(input[25], 0, 31),
__gen_unuint(input[26], 0, 31),
__gen_unuint(input[27], 0, 31),
__gen_unuint(input[28], 0, 31),
__gen_unuint(input[29], 0, 31),
__gen_unuint(input[30], 0, 31),
__gen_unuint(input[31], 0, 31),
__gen_unuint(input[32], 0, 31)
],
}
}
}
impl Deserialize for _3dStatePolyStipplePattern {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 33];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 33] as *mut [u8; 132]) })?;
Ok((&input).into())
}
}
pub struct _3dStatePs<A: Addr + Default> {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub kernel_start_pointer_0: u64,
pub software_exception_enable: bool,
pub mask_stack_exception_enable: bool,
pub illegal_opcode_exception_enable: bool,
pub rounding_mode: u32,
pub floating_point_mode: u32,
pub binding_table_entry_count: u32,
pub denormal_mode: u32,
pub sampler_count: u32,
pub vector_mask_enable: bool,
pub single_program_flow: bool,
pub per_thread_scratch_space: u32,
pub scratch_space_base_pointer: A,
pub _8_pixel_dispatch_enable: bool,
pub _16_pixel_dispatch_enable: bool,
pub _32_pixel_dispatch_enable: bool,
pub position_xy_offset_select: u32,
pub render_target_resolve_enable: bool,
pub dual_source_blend_enable: bool,
pub render_target_fast_clear_enable: bool,
pub omask_present_to_rendertarget: bool,
pub attribute_enable: bool,
pub push_constant_enable: bool,
pub maximum_number_of_threads: u32,
pub dispatch_grf_start_register_for_constant_setup_data_2: u32,
pub dispatch_grf_start_register_for_constant_setup_data_1: u32,
pub dispatch_grf_start_register_for_constant_setup_data_0: u32,
pub kernel_start_pointer_1: u64,
pub kernel_start_pointer_2: u64,
}
impl<A: Addr + Default> _3dStatePs<A> {
pub const DWORD_LENGTH: u32 = 8;
pub const ALT: u32 = 1;
pub const FTZ: u32 = 0;
pub const IEEE_745: u32 = 0;
pub const POSOFFSET_CENTROID: u32 = 2;
pub const POSOFFSET_NONE: u32 = 0;
pub const POSOFFSET_SAMPLE: u32 = 3;
pub const RD: u32 = 2;
pub const RET: u32 = 1;
pub const RTNE: u32 = 0;
pub const RTZ: u32 = 3;
pub const RU: u32 = 1;
}
impl<A: Addr + Default> Default for _3dStatePs<A> {
fn default() -> Self {
_3dStatePs {
dword_length: 6,
_3d_command_sub_opcode: 32,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
kernel_start_pointer_0: Default::default(),
software_exception_enable: Default::default(),
mask_stack_exception_enable: Default::default(),
illegal_opcode_exception_enable: Default::default(),
rounding_mode: Default::default(),
floating_point_mode: Default::default(),
binding_table_entry_count: Default::default(),
denormal_mode: Default::default(),
sampler_count: Default::default(),
vector_mask_enable: Default::default(),
single_program_flow: Default::default(),
per_thread_scratch_space: Default::default(),
scratch_space_base_pointer: Default::default(),
_8_pixel_dispatch_enable: Default::default(),
_16_pixel_dispatch_enable: Default::default(),
_32_pixel_dispatch_enable: Default::default(),
position_xy_offset_select: Default::default(),
render_target_resolve_enable: Default::default(),
dual_source_blend_enable: Default::default(),
render_target_fast_clear_enable: Default::default(),
omask_present_to_rendertarget: Default::default(),
attribute_enable: Default::default(),
push_constant_enable: Default::default(),
maximum_number_of_threads: Default::default(),
dispatch_grf_start_register_for_constant_setup_data_2: Default::default(),
dispatch_grf_start_register_for_constant_setup_data_1: Default::default(),
dispatch_grf_start_register_for_constant_setup_data_0: Default::default(),
kernel_start_pointer_1: Default::default(),
kernel_start_pointer_2: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for _3dStatePs<A> {
type Out = [u32; 8];
fn pack_into(&self, out: &mut [u32; 8]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_offset(self.kernel_start_pointer_0 as u32, 6, 31);
out[2] = __gen_uint(self.software_exception_enable.into(), 7, 7) |
__gen_uint(self.mask_stack_exception_enable.into(), 11, 11) |
__gen_uint(self.illegal_opcode_exception_enable.into(), 13, 13) |
__gen_uint(self.rounding_mode, 14, 15) |
__gen_uint(self.floating_point_mode, 16, 16) |
__gen_uint(self.binding_table_entry_count, 18, 25) |
__gen_uint(self.denormal_mode, 26, 26) |
__gen_uint(self.sampler_count, 27, 29) |
__gen_uint(self.vector_mask_enable.into(), 30, 30) |
__gen_uint(self.single_program_flow.into(), 31, 31);
let v3 = __gen_uint(self.per_thread_scratch_space, 0, 3);
let v3_address = self.scratch_space_base_pointer.combine(v3);
out[3] = v3_address as u32;
out[4] = (v3_address >> 32) as u32;
out[4] = __gen_uint(self._8_pixel_dispatch_enable.into(), 0, 0) |
__gen_uint(self._16_pixel_dispatch_enable.into(), 1, 1) |
__gen_uint(self._32_pixel_dispatch_enable.into(), 2, 2) |
__gen_uint(self.position_xy_offset_select, 3, 4) |
__gen_uint(self.render_target_resolve_enable.into(), 6, 6) |
__gen_uint(self.dual_source_blend_enable.into(), 7, 7) |
__gen_uint(self.render_target_fast_clear_enable.into(), 8, 8) |
__gen_uint(self.omask_present_to_rendertarget.into(), 9, 9) |
__gen_uint(self.attribute_enable.into(), 10, 10) |
__gen_uint(self.push_constant_enable.into(), 11, 11) |
__gen_uint(self.maximum_number_of_threads, 24, 31);
out[5] = __gen_uint(self.dispatch_grf_start_register_for_constant_setup_data_2, 0, 6) |
__gen_uint(self.dispatch_grf_start_register_for_constant_setup_data_1, 8, 14) |
__gen_uint(self.dispatch_grf_start_register_for_constant_setup_data_0, 16, 22);
out[6] = __gen_offset(self.kernel_start_pointer_1 as u32, 6, 31);
out[7] = __gen_offset(self.kernel_start_pointer_2 as u32, 6, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 8];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 8] as *const [u8; 32]) })
}
}
impl From<&[u32; 8]> for _3dStatePs<u64> {
fn from(input: &[u32; 8]) -> Self {
_3dStatePs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
kernel_start_pointer_0: (__gen_unuint(input[1], 6, 31) as u64) << 6,
software_exception_enable: __gen_unuint(input[2], 7, 7) != 0,
mask_stack_exception_enable: __gen_unuint(input[2], 11, 11) != 0,
illegal_opcode_exception_enable: __gen_unuint(input[2], 13, 13) != 0,
rounding_mode: __gen_unuint(input[2], 14, 15),
floating_point_mode: __gen_unuint(input[2], 16, 16),
binding_table_entry_count: __gen_unuint(input[2], 18, 25),
denormal_mode: __gen_unuint(input[2], 26, 26),
sampler_count: __gen_unuint(input[2], 27, 29),
vector_mask_enable: __gen_unuint(input[2], 30, 30) != 0,
single_program_flow: __gen_unuint(input[2], 31, 31) != 0,
per_thread_scratch_space: __gen_unuint(input[3], 0, 3),
scratch_space_base_pointer: (__gen_unuint(input[3], 10, 31) as u64) << 10,
_8_pixel_dispatch_enable: __gen_unuint(input[4], 0, 0) != 0,
_16_pixel_dispatch_enable: __gen_unuint(input[4], 1, 1) != 0,
_32_pixel_dispatch_enable: __gen_unuint(input[4], 2, 2) != 0,
position_xy_offset_select: __gen_unuint(input[4], 3, 4),
render_target_resolve_enable: __gen_unuint(input[4], 6, 6) != 0,
dual_source_blend_enable: __gen_unuint(input[4], 7, 7) != 0,
render_target_fast_clear_enable: __gen_unuint(input[4], 8, 8) != 0,
omask_present_to_rendertarget: __gen_unuint(input[4], 9, 9) != 0,
attribute_enable: __gen_unuint(input[4], 10, 10) != 0,
push_constant_enable: __gen_unuint(input[4], 11, 11) != 0,
maximum_number_of_threads: __gen_unuint(input[4], 24, 31),
dispatch_grf_start_register_for_constant_setup_data_2: __gen_unuint(input[5], 0, 6),
dispatch_grf_start_register_for_constant_setup_data_1: __gen_unuint(input[5], 8, 14),
dispatch_grf_start_register_for_constant_setup_data_0: __gen_unuint(input[5], 16, 22),
kernel_start_pointer_1: (__gen_unuint(input[6], 6, 31) as u64) << 6,
kernel_start_pointer_2: (__gen_unuint(input[7], 6, 31) as u64) << 6,
}
}
}
impl Deserialize for _3dStatePs<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 8];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 8] as *mut [u8; 32]) })?;
Ok((&input).into())
}
}
pub struct _3dStatePushConstantAllocDs {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub constant_buffer_size: u32,
pub constant_buffer_offset: u32,
}
impl _3dStatePushConstantAllocDs {
pub const DWORD_LENGTH: u32 = 2;
pub const _0KB: u32 = 0;
}
impl Default for _3dStatePushConstantAllocDs {
fn default() -> Self {
_3dStatePushConstantAllocDs {
dword_length: 0,
_3d_command_sub_opcode: 20,
_3d_command_opcode: 1,
command_subtype: 3,
command_type: 3,
constant_buffer_size: Default::default(),
constant_buffer_offset: Default::default(),
}
}
}
impl Serialize for _3dStatePushConstantAllocDs {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.constant_buffer_size, 0, 4) |
__gen_uint(self.constant_buffer_offset, 16, 19);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStatePushConstantAllocDs {
fn from(input: &[u32; 2]) -> Self {
_3dStatePushConstantAllocDs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
constant_buffer_size: __gen_unuint(input[1], 0, 4),
constant_buffer_offset: __gen_unuint(input[1], 16, 19),
}
}
}
impl Deserialize for _3dStatePushConstantAllocDs {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStatePushConstantAllocGs {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub constant_buffer_size: u32,
pub constant_buffer_offset: u32,
}
impl _3dStatePushConstantAllocGs {
pub const DWORD_LENGTH: u32 = 2;
pub const _0KB: u32 = 0;
}
impl Default for _3dStatePushConstantAllocGs {
fn default() -> Self {
_3dStatePushConstantAllocGs {
dword_length: 0,
_3d_command_sub_opcode: 21,
_3d_command_opcode: 1,
command_subtype: 3,
command_type: 3,
constant_buffer_size: Default::default(),
constant_buffer_offset: Default::default(),
}
}
}
impl Serialize for _3dStatePushConstantAllocGs {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.constant_buffer_size, 0, 4) |
__gen_uint(self.constant_buffer_offset, 16, 19);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStatePushConstantAllocGs {
fn from(input: &[u32; 2]) -> Self {
_3dStatePushConstantAllocGs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
constant_buffer_size: __gen_unuint(input[1], 0, 4),
constant_buffer_offset: __gen_unuint(input[1], 16, 19),
}
}
}
impl Deserialize for _3dStatePushConstantAllocGs {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStatePushConstantAllocHs {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub constant_buffer_size: u32,
pub constant_buffer_offset: u32,
}
impl _3dStatePushConstantAllocHs {
pub const DWORD_LENGTH: u32 = 2;
pub const _0KB: u32 = 0;
}
impl Default for _3dStatePushConstantAllocHs {
fn default() -> Self {
_3dStatePushConstantAllocHs {
dword_length: 0,
_3d_command_sub_opcode: 19,
_3d_command_opcode: 1,
command_subtype: 3,
command_type: 3,
constant_buffer_size: Default::default(),
constant_buffer_offset: Default::default(),
}
}
}
impl Serialize for _3dStatePushConstantAllocHs {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.constant_buffer_size, 0, 4) |
__gen_uint(self.constant_buffer_offset, 16, 19);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStatePushConstantAllocHs {
fn from(input: &[u32; 2]) -> Self {
_3dStatePushConstantAllocHs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
constant_buffer_size: __gen_unuint(input[1], 0, 4),
constant_buffer_offset: __gen_unuint(input[1], 16, 19),
}
}
}
impl Deserialize for _3dStatePushConstantAllocHs {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStatePushConstantAllocPs {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub constant_buffer_size: u32,
pub constant_buffer_offset: u32,
}
impl _3dStatePushConstantAllocPs {
pub const DWORD_LENGTH: u32 = 2;
pub const _0KB: u32 = 0;
}
impl Default for _3dStatePushConstantAllocPs {
fn default() -> Self {
_3dStatePushConstantAllocPs {
dword_length: 0,
_3d_command_sub_opcode: 22,
_3d_command_opcode: 1,
command_subtype: 3,
command_type: 3,
constant_buffer_size: Default::default(),
constant_buffer_offset: Default::default(),
}
}
}
impl Serialize for _3dStatePushConstantAllocPs {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.constant_buffer_size, 0, 4) |
__gen_uint(self.constant_buffer_offset, 16, 19);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStatePushConstantAllocPs {
fn from(input: &[u32; 2]) -> Self {
_3dStatePushConstantAllocPs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
constant_buffer_size: __gen_unuint(input[1], 0, 4),
constant_buffer_offset: __gen_unuint(input[1], 16, 19),
}
}
}
impl Deserialize for _3dStatePushConstantAllocPs {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStatePushConstantAllocVs {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub constant_buffer_size: u32,
pub constant_buffer_offset: u32,
}
impl _3dStatePushConstantAllocVs {
pub const DWORD_LENGTH: u32 = 2;
pub const _0KB: u32 = 0;
}
impl Default for _3dStatePushConstantAllocVs {
fn default() -> Self {
_3dStatePushConstantAllocVs {
dword_length: 0,
_3d_command_sub_opcode: 18,
_3d_command_opcode: 1,
command_subtype: 3,
command_type: 3,
constant_buffer_size: Default::default(),
constant_buffer_offset: Default::default(),
}
}
}
impl Serialize for _3dStatePushConstantAllocVs {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.constant_buffer_size, 0, 4) |
__gen_uint(self.constant_buffer_offset, 16, 19);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStatePushConstantAllocVs {
fn from(input: &[u32; 2]) -> Self {
_3dStatePushConstantAllocVs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
constant_buffer_size: __gen_unuint(input[1], 0, 4),
constant_buffer_offset: __gen_unuint(input[1], 16, 19),
}
}
}
impl Deserialize for _3dStatePushConstantAllocVs {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStateSampleMask {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub sample_mask: u32,
}
impl _3dStateSampleMask {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for _3dStateSampleMask {
fn default() -> Self {
_3dStateSampleMask {
dword_length: 0,
_3d_command_sub_opcode: 24,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
sample_mask: Default::default(),
}
}
}
impl Serialize for _3dStateSampleMask {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.sample_mask, 0, 7);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStateSampleMask {
fn from(input: &[u32; 2]) -> Self {
_3dStateSampleMask {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
sample_mask: __gen_unuint(input[1], 0, 7),
}
}
}
impl Deserialize for _3dStateSampleMask {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStateSamplerPaletteLoad0 {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
}
impl _3dStateSamplerPaletteLoad0 {
pub const DWORD_LENGTH: u32 = 1;
}
impl Default for _3dStateSamplerPaletteLoad0 {
fn default() -> Self {
_3dStateSamplerPaletteLoad0 {
dword_length: Default::default(),
_3d_command_sub_opcode: 2,
_3d_command_opcode: 1,
command_subtype: 3,
command_type: 3,
}
}
}
impl Serialize for _3dStateSamplerPaletteLoad0 {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for _3dStateSamplerPaletteLoad0 {
fn from(input: &[u32; 1]) -> Self {
_3dStateSamplerPaletteLoad0 {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
}
}
}
impl Deserialize for _3dStateSamplerPaletteLoad0 {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct _3dStateSamplerPaletteLoad1 {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
}
impl _3dStateSamplerPaletteLoad1 {
pub const DWORD_LENGTH: u32 = 1;
}
impl Default for _3dStateSamplerPaletteLoad1 {
fn default() -> Self {
_3dStateSamplerPaletteLoad1 {
dword_length: 0,
_3d_command_sub_opcode: 12,
_3d_command_opcode: 1,
command_subtype: 3,
command_type: 3,
}
}
}
impl Serialize for _3dStateSamplerPaletteLoad1 {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for _3dStateSamplerPaletteLoad1 {
fn from(input: &[u32; 1]) -> Self {
_3dStateSamplerPaletteLoad1 {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
}
}
}
impl Deserialize for _3dStateSamplerPaletteLoad1 {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct _3dStateSamplerStatePointersDs {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub pointer_to_ds_sampler_state: u64,
}
impl _3dStateSamplerStatePointersDs {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for _3dStateSamplerStatePointersDs {
fn default() -> Self {
_3dStateSamplerStatePointersDs {
dword_length: 0,
_3d_command_sub_opcode: 45,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
pointer_to_ds_sampler_state: Default::default(),
}
}
}
impl Serialize for _3dStateSamplerStatePointersDs {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_offset(self.pointer_to_ds_sampler_state as u32, 5, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStateSamplerStatePointersDs {
fn from(input: &[u32; 2]) -> Self {
_3dStateSamplerStatePointersDs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
pointer_to_ds_sampler_state: (__gen_unuint(input[1], 5, 31) as u64) << 5,
}
}
}
impl Deserialize for _3dStateSamplerStatePointersDs {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStateSamplerStatePointersGs {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub pointer_to_gs_sampler_state: u64,
}
impl _3dStateSamplerStatePointersGs {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for _3dStateSamplerStatePointersGs {
fn default() -> Self {
_3dStateSamplerStatePointersGs {
dword_length: 0,
_3d_command_sub_opcode: 46,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
pointer_to_gs_sampler_state: Default::default(),
}
}
}
impl Serialize for _3dStateSamplerStatePointersGs {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_offset(self.pointer_to_gs_sampler_state as u32, 5, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStateSamplerStatePointersGs {
fn from(input: &[u32; 2]) -> Self {
_3dStateSamplerStatePointersGs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
pointer_to_gs_sampler_state: (__gen_unuint(input[1], 5, 31) as u64) << 5,
}
}
}
impl Deserialize for _3dStateSamplerStatePointersGs {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStateSamplerStatePointersHs {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub pointer_to_hs_sampler_state: u64,
}
impl _3dStateSamplerStatePointersHs {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for _3dStateSamplerStatePointersHs {
fn default() -> Self {
_3dStateSamplerStatePointersHs {
dword_length: 0,
_3d_command_sub_opcode: 44,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
pointer_to_hs_sampler_state: Default::default(),
}
}
}
impl Serialize for _3dStateSamplerStatePointersHs {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_offset(self.pointer_to_hs_sampler_state as u32, 5, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStateSamplerStatePointersHs {
fn from(input: &[u32; 2]) -> Self {
_3dStateSamplerStatePointersHs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
pointer_to_hs_sampler_state: (__gen_unuint(input[1], 5, 31) as u64) << 5,
}
}
}
impl Deserialize for _3dStateSamplerStatePointersHs {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStateSamplerStatePointersPs {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub pointer_to_ps_sampler_state: u64,
}
impl _3dStateSamplerStatePointersPs {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for _3dStateSamplerStatePointersPs {
fn default() -> Self {
_3dStateSamplerStatePointersPs {
dword_length: 0,
_3d_command_sub_opcode: 47,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
pointer_to_ps_sampler_state: Default::default(),
}
}
}
impl Serialize for _3dStateSamplerStatePointersPs {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_offset(self.pointer_to_ps_sampler_state as u32, 5, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStateSamplerStatePointersPs {
fn from(input: &[u32; 2]) -> Self {
_3dStateSamplerStatePointersPs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
pointer_to_ps_sampler_state: (__gen_unuint(input[1], 5, 31) as u64) << 5,
}
}
}
impl Deserialize for _3dStateSamplerStatePointersPs {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStateSamplerStatePointersVs {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub pointer_to_vs_sampler_state: u64,
}
impl _3dStateSamplerStatePointersVs {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for _3dStateSamplerStatePointersVs {
fn default() -> Self {
_3dStateSamplerStatePointersVs {
dword_length: 0,
_3d_command_sub_opcode: 43,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
pointer_to_vs_sampler_state: Default::default(),
}
}
}
impl Serialize for _3dStateSamplerStatePointersVs {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_offset(self.pointer_to_vs_sampler_state as u32, 5, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStateSamplerStatePointersVs {
fn from(input: &[u32; 2]) -> Self {
_3dStateSamplerStatePointersVs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
pointer_to_vs_sampler_state: (__gen_unuint(input[1], 5, 31) as u64) << 5,
}
}
}
impl Deserialize for _3dStateSamplerStatePointersVs {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStateSbe {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub vertex_urb_entry_read_offset: u32,
pub vertex_urb_entry_read_length: u32,
pub point_sprite_texture_coordinate_origin: u32,
pub attribute_swizzle_enable: bool,
pub number_of_sf_output_attributes: u32,
pub attribute_swizzle_control_mode: u32,
pub attribute: [SfOutputAttributeDetail; 16],
pub point_sprite_texture_coordinate_enable: u32,
pub constant_interpolation_enable: u32,
pub attribute_0_wrapshortest_enables: u32,
pub attribute_1_wrapshortest_enables: u32,
pub attribute_2_wrapshortest_enables: u32,
pub attribute_3_wrapshortest_enables: u32,
pub attribute_4_wrapshortest_enables: u32,
pub attribute_5_wrapshortest_enables: u32,
pub attribute_6_wrapshortest_enables: u32,
pub attribute_7_wrapshortest_enables: u32,
pub attribute_8_wrapshortest_enables: u32,
pub attribute_9_wrapshortest_enables: u32,
pub attribute_10_wrapshortest_enables: u32,
pub attribute_11_wrapshortest_enables: u32,
pub attribute_12_wrapshortest_enables: u32,
pub attribute_13_wrapshortest_enables: u32,
pub attribute_14_wrapshortest_enables: u32,
pub attribute_15_wrapshortest_enables: u32,
}
impl _3dStateSbe {
pub const DWORD_LENGTH: u32 = 14;
pub const LOWERLEFT: u32 = 1;
pub const SWIZ_0_15: u32 = 0;
pub const SWIZ_16_31: u32 = 1;
pub const UPPERLEFT: u32 = 0;
}
impl Default for _3dStateSbe {
fn default() -> Self {
_3dStateSbe {
dword_length: 12,
_3d_command_sub_opcode: 31,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
vertex_urb_entry_read_offset: Default::default(),
vertex_urb_entry_read_length: Default::default(),
point_sprite_texture_coordinate_origin: Default::default(),
attribute_swizzle_enable: Default::default(),
number_of_sf_output_attributes: Default::default(),
attribute_swizzle_control_mode: Default::default(),
attribute: Default::default(),
point_sprite_texture_coordinate_enable: Default::default(),
constant_interpolation_enable: Default::default(),
attribute_0_wrapshortest_enables: Default::default(),
attribute_1_wrapshortest_enables: Default::default(),
attribute_2_wrapshortest_enables: Default::default(),
attribute_3_wrapshortest_enables: Default::default(),
attribute_4_wrapshortest_enables: Default::default(),
attribute_5_wrapshortest_enables: Default::default(),
attribute_6_wrapshortest_enables: Default::default(),
attribute_7_wrapshortest_enables: Default::default(),
attribute_8_wrapshortest_enables: Default::default(),
attribute_9_wrapshortest_enables: Default::default(),
attribute_10_wrapshortest_enables: Default::default(),
attribute_11_wrapshortest_enables: Default::default(),
attribute_12_wrapshortest_enables: Default::default(),
attribute_13_wrapshortest_enables: Default::default(),
attribute_14_wrapshortest_enables: Default::default(),
attribute_15_wrapshortest_enables: Default::default(),
}
}
}
impl Serialize for _3dStateSbe {
type Out = [u32; 14];
fn pack_into(&self, out: &mut [u32; 14]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.vertex_urb_entry_read_offset, 4, 9) |
__gen_uint(self.vertex_urb_entry_read_length, 11, 15) |
__gen_uint(self.point_sprite_texture_coordinate_origin, 20, 20) |
__gen_uint(self.attribute_swizzle_enable.into(), 21, 21) |
__gen_uint(self.number_of_sf_output_attributes, 22, 27) |
__gen_uint(self.attribute_swizzle_control_mode, 28, 28);
let mut v2_0 = [0_u32; 1];
self.attribute[0].pack_into(&mut v2_0);
let mut v2_1 = [0_u32; 1];
self.attribute[1].pack_into(&mut v2_1);
out[2] = __gen_uint(v2_0[0], 0, 15) |
__gen_uint(v2_1[0], 16, 31);
let mut v3_0 = [0_u32; 1];
self.attribute[2].pack_into(&mut v3_0);
let mut v3_1 = [0_u32; 1];
self.attribute[3].pack_into(&mut v3_1);
out[3] = __gen_uint(v3_0[0], 0, 15) |
__gen_uint(v3_1[0], 16, 31);
let mut v4_0 = [0_u32; 1];
self.attribute[4].pack_into(&mut v4_0);
let mut v4_1 = [0_u32; 1];
self.attribute[5].pack_into(&mut v4_1);
out[4] = __gen_uint(v4_0[0], 0, 15) |
__gen_uint(v4_1[0], 16, 31);
let mut v5_0 = [0_u32; 1];
self.attribute[6].pack_into(&mut v5_0);
let mut v5_1 = [0_u32; 1];
self.attribute[7].pack_into(&mut v5_1);
out[5] = __gen_uint(v5_0[0], 0, 15) |
__gen_uint(v5_1[0], 16, 31);
let mut v6_0 = [0_u32; 1];
self.attribute[8].pack_into(&mut v6_0);
let mut v6_1 = [0_u32; 1];
self.attribute[9].pack_into(&mut v6_1);
out[6] = __gen_uint(v6_0[0], 0, 15) |
__gen_uint(v6_1[0], 16, 31);
let mut v7_0 = [0_u32; 1];
self.attribute[10].pack_into(&mut v7_0);
let mut v7_1 = [0_u32; 1];
self.attribute[11].pack_into(&mut v7_1);
out[7] = __gen_uint(v7_0[0], 0, 15) |
__gen_uint(v7_1[0], 16, 31);
let mut v8_0 = [0_u32; 1];
self.attribute[12].pack_into(&mut v8_0);
let mut v8_1 = [0_u32; 1];
self.attribute[13].pack_into(&mut v8_1);
out[8] = __gen_uint(v8_0[0], 0, 15) |
__gen_uint(v8_1[0], 16, 31);
let mut v9_0 = [0_u32; 1];
self.attribute[14].pack_into(&mut v9_0);
let mut v9_1 = [0_u32; 1];
self.attribute[15].pack_into(&mut v9_1);
out[9] = __gen_uint(v9_0[0], 0, 15) |
__gen_uint(v9_1[0], 16, 31);
out[10] = __gen_uint(self.point_sprite_texture_coordinate_enable, 0, 31);
out[11] = __gen_uint(self.constant_interpolation_enable, 0, 31);
out[12] = __gen_uint(self.attribute_0_wrapshortest_enables, 0, 3) |
__gen_uint(self.attribute_1_wrapshortest_enables, 4, 7) |
__gen_uint(self.attribute_2_wrapshortest_enables, 8, 11) |
__gen_uint(self.attribute_3_wrapshortest_enables, 12, 15) |
__gen_uint(self.attribute_4_wrapshortest_enables, 16, 19) |
__gen_uint(self.attribute_5_wrapshortest_enables, 20, 23) |
__gen_uint(self.attribute_6_wrapshortest_enables, 24, 27) |
__gen_uint(self.attribute_7_wrapshortest_enables, 28, 31);
out[13] = __gen_uint(self.attribute_8_wrapshortest_enables, 0, 3) |
__gen_uint(self.attribute_9_wrapshortest_enables, 4, 7) |
__gen_uint(self.attribute_10_wrapshortest_enables, 8, 11) |
__gen_uint(self.attribute_11_wrapshortest_enables, 12, 15) |
__gen_uint(self.attribute_12_wrapshortest_enables, 16, 19) |
__gen_uint(self.attribute_13_wrapshortest_enables, 20, 23) |
__gen_uint(self.attribute_14_wrapshortest_enables, 24, 27) |
__gen_uint(self.attribute_15_wrapshortest_enables, 28, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 14];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 14] as *const [u8; 56]) })
}
}
impl From<&[u32; 14]> for _3dStateSbe {
fn from(input: &[u32; 14]) -> Self {
_3dStateSbe {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
vertex_urb_entry_read_offset: __gen_unuint(input[1], 4, 9),
vertex_urb_entry_read_length: __gen_unuint(input[1], 11, 15),
point_sprite_texture_coordinate_origin: __gen_unuint(input[1], 20, 20),
attribute_swizzle_enable: __gen_unuint(input[1], 21, 21) != 0,
number_of_sf_output_attributes: __gen_unuint(input[1], 22, 27),
attribute_swizzle_control_mode: __gen_unuint(input[1], 28, 28),
attribute: [
{{
let [_, _, ref in2 @ .., _, _, _, _, _, _, _, _, _, _, _] = input;
in2.into()
}},
{{
let i: [u32; 1] = [__gen_unuint(input[2], 16, 31)];
(&i).into()
}},
{{
let [_, _, _, ref in3 @ .., _, _, _, _, _, _, _, _, _, _] = input;
in3.into()
}},
{{
let i: [u32; 1] = [__gen_unuint(input[3], 16, 31)];
(&i).into()
}},
{{
let [_, _, _, _, ref in4 @ .., _, _, _, _, _, _, _, _, _] = input;
in4.into()
}},
{{
let i: [u32; 1] = [__gen_unuint(input[4], 16, 31)];
(&i).into()
}},
{{
let [_, _, _, _, _, ref in5 @ .., _, _, _, _, _, _, _, _] = input;
in5.into()
}},
{{
let i: [u32; 1] = [__gen_unuint(input[5], 16, 31)];
(&i).into()
}},
{{
let [_, _, _, _, _, _, ref in6 @ .., _, _, _, _, _, _, _] = input;
in6.into()
}},
{{
let i: [u32; 1] = [__gen_unuint(input[6], 16, 31)];
(&i).into()
}},
{{
let [_, _, _, _, _, _, _, ref in7 @ .., _, _, _, _, _, _] = input;
in7.into()
}},
{{
let i: [u32; 1] = [__gen_unuint(input[7], 16, 31)];
(&i).into()
}},
{{
let [_, _, _, _, _, _, _, _, ref in8 @ .., _, _, _, _, _] = input;
in8.into()
}},
{{
let i: [u32; 1] = [__gen_unuint(input[8], 16, 31)];
(&i).into()
}},
{{
let [_, _, _, _, _, _, _, _, _, ref in9 @ .., _, _, _, _] = input;
in9.into()
}},
{{
let i: [u32; 1] = [__gen_unuint(input[9], 16, 31)];
(&i).into()
}}
],
point_sprite_texture_coordinate_enable: __gen_unuint(input[10], 0, 31),
constant_interpolation_enable: __gen_unuint(input[11], 0, 31),
attribute_0_wrapshortest_enables: __gen_unuint(input[12], 0, 3),
attribute_1_wrapshortest_enables: __gen_unuint(input[12], 4, 7),
attribute_2_wrapshortest_enables: __gen_unuint(input[12], 8, 11),
attribute_3_wrapshortest_enables: __gen_unuint(input[12], 12, 15),
attribute_4_wrapshortest_enables: __gen_unuint(input[12], 16, 19),
attribute_5_wrapshortest_enables: __gen_unuint(input[12], 20, 23),
attribute_6_wrapshortest_enables: __gen_unuint(input[12], 24, 27),
attribute_7_wrapshortest_enables: __gen_unuint(input[12], 28, 31),
attribute_8_wrapshortest_enables: __gen_unuint(input[13], 0, 3),
attribute_9_wrapshortest_enables: __gen_unuint(input[13], 4, 7),
attribute_10_wrapshortest_enables: __gen_unuint(input[13], 8, 11),
attribute_11_wrapshortest_enables: __gen_unuint(input[13], 12, 15),
attribute_12_wrapshortest_enables: __gen_unuint(input[13], 16, 19),
attribute_13_wrapshortest_enables: __gen_unuint(input[13], 20, 23),
attribute_14_wrapshortest_enables: __gen_unuint(input[13], 24, 27),
attribute_15_wrapshortest_enables: __gen_unuint(input[13], 28, 31),
}
}
}
impl Deserialize for _3dStateSbe {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 14];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 14] as *mut [u8; 56]) })?;
Ok((&input).into())
}
}
pub struct _3dStateScissorStatePointers {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub scissor_rect_pointer: u64,
}
impl _3dStateScissorStatePointers {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for _3dStateScissorStatePointers {
fn default() -> Self {
_3dStateScissorStatePointers {
dword_length: 0,
_3d_command_sub_opcode: 15,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
scissor_rect_pointer: Default::default(),
}
}
}
impl Serialize for _3dStateScissorStatePointers {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_offset(self.scissor_rect_pointer as u32, 5, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStateScissorStatePointers {
fn from(input: &[u32; 2]) -> Self {
_3dStateScissorStatePointers {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
scissor_rect_pointer: (__gen_unuint(input[1], 5, 31) as u64) << 5,
}
}
}
impl Deserialize for _3dStateScissorStatePointers {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStateSf {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub front_winding: u32,
pub viewport_transform_enable: bool,
pub backface_fill_mode: u32,
pub frontface_fill_mode: u32,
pub global_depth_offset_enable_point: bool,
pub global_depth_offset_enable_wireframe: bool,
pub global_depth_offset_enable_solid: bool,
pub statistics_enable: bool,
pub legacy_global_depth_bias_enable: bool,
pub depth_buffer_surface_format: u32,
pub multisample_rasterization_mode: u32,
pub scissor_rectangle_enable: bool,
pub line_end_cap_antialiasing_region_width: u32,
pub line_width: f32,
pub cull_mode: u32,
pub antialiasing_enable: bool,
pub point_width: f32,
pub point_width_source: u32,
pub vertex_sub_pixel_precision_select: u32,
pub aa_line_distance_mode: u32,
pub triangle_fan_provoking_vertex_select: u32,
pub line_strip_list_provoking_vertex_select: u32,
pub triangle_strip_list_provoking_vertex_select: u32,
pub last_pixel_enable: bool,
pub global_depth_offset_constant: f32,
pub global_depth_offset_scale: f32,
pub global_depth_offset_clamp: f32,
}
impl _3dStateSf {
pub const DWORD_LENGTH: u32 = 7;
pub const AALINEDISTANCE_TRUE: u32 = 1;
pub const BACK: u32 = 3;
pub const BOTH: u32 = 0;
pub const D16_UNORM: u32 = 5;
pub const D24_UNORM_S8_UINT: u32 = 2;
pub const D24_UNORM_X8_UINT: u32 = 3;
pub const D32_FLOAT: u32 = 1;
pub const D32_FLOAT_S8X24_UINT: u32 = 0;
pub const FRONT: u32 = 2;
pub const MSRASTMODE_OFF_PATTERN: u32 = 1;
pub const MSRASTMODE_OFF_PIXEL: u32 = 0;
pub const MSRASTMODE_ON_PATTERN: u32 = 3;
pub const MSRASTMODE_ON_PIXEL: u32 = 2;
pub const NONE: u32 = 1;
pub const POINT: u32 = 2;
pub const SOLID: u32 = 0;
pub const STATE: u32 = 1;
pub const VERTEX: u32 = 0;
pub const VERTEX_0: u32 = 0;
pub const VERTEX_1: u32 = 1;
pub const VERTEX_2: u32 = 2;
pub const WIREFRAME: u32 = 1;
pub const _0_5_PIXELS: u32 = 0;
pub const _1_0_PIXELS: u32 = 1;
pub const _2_0_PIXELS: u32 = 2;
pub const _4_0_PIXELS: u32 = 3;
pub const _4_BIT: u32 = 1;
pub const _8_BIT: u32 = 0;
}
impl Default for _3dStateSf {
fn default() -> Self {
_3dStateSf {
dword_length: 5,
_3d_command_sub_opcode: 19,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
front_winding: Default::default(),
viewport_transform_enable: Default::default(),
backface_fill_mode: Default::default(),
frontface_fill_mode: Default::default(),
global_depth_offset_enable_point: Default::default(),
global_depth_offset_enable_wireframe: Default::default(),
global_depth_offset_enable_solid: Default::default(),
statistics_enable: Default::default(),
legacy_global_depth_bias_enable: Default::default(),
depth_buffer_surface_format: Default::default(),
multisample_rasterization_mode: Default::default(),
scissor_rectangle_enable: Default::default(),
line_end_cap_antialiasing_region_width: Default::default(),
line_width: Default::default(),
cull_mode: Default::default(),
antialiasing_enable: Default::default(),
point_width: Default::default(),
point_width_source: Default::default(),
vertex_sub_pixel_precision_select: Default::default(),
aa_line_distance_mode: Default::default(),
triangle_fan_provoking_vertex_select: Default::default(),
line_strip_list_provoking_vertex_select: Default::default(),
triangle_strip_list_provoking_vertex_select: Default::default(),
last_pixel_enable: Default::default(),
global_depth_offset_constant: Default::default(),
global_depth_offset_scale: Default::default(),
global_depth_offset_clamp: Default::default(),
}
}
}
impl Serialize for _3dStateSf {
type Out = [u32; 7];
fn pack_into(&self, out: &mut [u32; 7]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.front_winding, 0, 0) |
__gen_uint(self.viewport_transform_enable.into(), 1, 1) |
__gen_uint(self.backface_fill_mode, 3, 4) |
__gen_uint(self.frontface_fill_mode, 5, 6) |
__gen_uint(self.global_depth_offset_enable_point.into(), 7, 7) |
__gen_uint(self.global_depth_offset_enable_wireframe.into(), 8, 8) |
__gen_uint(self.global_depth_offset_enable_solid.into(), 9, 9) |
__gen_uint(self.statistics_enable.into(), 10, 10) |
__gen_uint(self.legacy_global_depth_bias_enable.into(), 11, 11) |
__gen_uint(self.depth_buffer_surface_format, 12, 14);
out[2] = __gen_uint(self.multisample_rasterization_mode, 8, 9) |
__gen_uint(self.scissor_rectangle_enable.into(), 11, 11) |
__gen_uint(self.line_end_cap_antialiasing_region_width, 16, 17) |
__gen_ufixed(self.line_width, 18, 27, 7) |
__gen_uint(self.cull_mode, 29, 30) |
__gen_uint(self.antialiasing_enable.into(), 31, 31);
out[3] = __gen_ufixed(self.point_width, 0, 10, 3) |
__gen_uint(self.point_width_source, 11, 11) |
__gen_uint(self.vertex_sub_pixel_precision_select, 12, 12) |
__gen_uint(self.aa_line_distance_mode, 14, 14) |
__gen_uint(self.triangle_fan_provoking_vertex_select, 25, 26) |
__gen_uint(self.line_strip_list_provoking_vertex_select, 27, 28) |
__gen_uint(self.triangle_strip_list_provoking_vertex_select, 29, 30) |
__gen_uint(self.last_pixel_enable.into(), 31, 31);
out[4] = self.global_depth_offset_constant.to_bits();
out[5] = self.global_depth_offset_scale.to_bits();
out[6] = self.global_depth_offset_clamp.to_bits();
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 7];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 7] as *const [u8; 28]) })
}
}
impl From<&[u32; 7]> for _3dStateSf {
fn from(input: &[u32; 7]) -> Self {
_3dStateSf {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
front_winding: __gen_unuint(input[1], 0, 0),
viewport_transform_enable: __gen_unuint(input[1], 1, 1) != 0,
backface_fill_mode: __gen_unuint(input[1], 3, 4),
frontface_fill_mode: __gen_unuint(input[1], 5, 6),
global_depth_offset_enable_point: __gen_unuint(input[1], 7, 7) != 0,
global_depth_offset_enable_wireframe: __gen_unuint(input[1], 8, 8) != 0,
global_depth_offset_enable_solid: __gen_unuint(input[1], 9, 9) != 0,
statistics_enable: __gen_unuint(input[1], 10, 10) != 0,
legacy_global_depth_bias_enable: __gen_unuint(input[1], 11, 11) != 0,
depth_buffer_surface_format: __gen_unuint(input[1], 12, 14),
multisample_rasterization_mode: __gen_unuint(input[2], 8, 9),
scissor_rectangle_enable: __gen_unuint(input[2], 11, 11) != 0,
line_end_cap_antialiasing_region_width: __gen_unuint(input[2], 16, 17),
line_width: __gen_unufixed(input[2], 18, 27, 7),
cull_mode: __gen_unuint(input[2], 29, 30),
antialiasing_enable: __gen_unuint(input[2], 31, 31) != 0,
point_width: __gen_unufixed(input[3], 0, 10, 3),
point_width_source: __gen_unuint(input[3], 11, 11),
vertex_sub_pixel_precision_select: __gen_unuint(input[3], 12, 12),
aa_line_distance_mode: __gen_unuint(input[3], 14, 14),
triangle_fan_provoking_vertex_select: __gen_unuint(input[3], 25, 26),
line_strip_list_provoking_vertex_select: __gen_unuint(input[3], 27, 28),
triangle_strip_list_provoking_vertex_select: __gen_unuint(input[3], 29, 30),
last_pixel_enable: __gen_unuint(input[3], 31, 31) != 0,
global_depth_offset_constant: f32::from_bits(input[4]),
global_depth_offset_scale: f32::from_bits(input[5]),
global_depth_offset_clamp: f32::from_bits(input[6]),
}
}
}
impl Deserialize for _3dStateSf {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 7];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 7] as *mut [u8; 28]) })?;
Ok((&input).into())
}
}
pub struct _3dStateSoBuffer<A: Addr + Default> {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub surface_pitch: u32,
pub mocs: u32,
pub so_buffer_index: u32,
pub surface_base_address: A,
pub surface_end_address: A,
}
impl<A: Addr + Default> _3dStateSoBuffer<A> {
pub const DWORD_LENGTH: u32 = 4;
}
impl<A: Addr + Default> Default for _3dStateSoBuffer<A> {
fn default() -> Self {
_3dStateSoBuffer {
dword_length: 2,
_3d_command_sub_opcode: 24,
_3d_command_opcode: 1,
command_subtype: 3,
command_type: 3,
surface_pitch: Default::default(),
mocs: Default::default(),
so_buffer_index: Default::default(),
surface_base_address: Default::default(),
surface_end_address: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for _3dStateSoBuffer<A> {
type Out = [u32; 4];
fn pack_into(&self, out: &mut [u32; 4]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.surface_pitch, 0, 11) |
__gen_uint(self.mocs, 25, 28) |
__gen_uint(self.so_buffer_index, 29, 30);
let v2_address = self.surface_base_address.combine(0);
out[2] = v2_address as u32;
out[3] = (v2_address >> 32) as u32;
let v3_address = self.surface_end_address.combine(0);
out[3] = v3_address as u32;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 4];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 4] as *const [u8; 16]) })
}
}
impl From<&[u32; 4]> for _3dStateSoBuffer<u64> {
fn from(input: &[u32; 4]) -> Self {
_3dStateSoBuffer {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
surface_pitch: __gen_unuint(input[1], 0, 11),
mocs: __gen_unuint(input[1], 25, 28),
so_buffer_index: __gen_unuint(input[1], 29, 30),
surface_base_address: (__gen_unuint(input[2], 2, 31) as u64) << 2,
surface_end_address: (__gen_unuint(input[3], 2, 31) as u64) << 2,
}
}
}
impl Deserialize for _3dStateSoBuffer<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 4];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 4] as *mut [u8; 16]) })?;
Ok((&input).into())
}
}
pub struct _3dStateSoDeclList {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub stream_to_buffer_selects_0: u32,
pub stream_to_buffer_selects_1: u32,
pub stream_to_buffer_selects_2: u32,
pub stream_to_buffer_selects_3: u32,
pub num_entries_0: u32,
pub num_entries_1: u32,
pub num_entries_2: u32,
pub num_entries_3: u32,
}
impl _3dStateSoDeclList {
pub const DWORD_LENGTH: u32 = 3;
}
impl Default for _3dStateSoDeclList {
fn default() -> Self {
_3dStateSoDeclList {
dword_length: Default::default(),
_3d_command_sub_opcode: 23,
_3d_command_opcode: 1,
command_subtype: 3,
command_type: 3,
stream_to_buffer_selects_0: Default::default(),
stream_to_buffer_selects_1: Default::default(),
stream_to_buffer_selects_2: Default::default(),
stream_to_buffer_selects_3: Default::default(),
num_entries_0: Default::default(),
num_entries_1: Default::default(),
num_entries_2: Default::default(),
num_entries_3: Default::default(),
}
}
}
impl Serialize for _3dStateSoDeclList {
type Out = [u32; 3];
fn pack_into(&self, out: &mut [u32; 3]) {
out[0] = __gen_uint(self.dword_length, 0, 8) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.stream_to_buffer_selects_0, 0, 3) |
__gen_uint(self.stream_to_buffer_selects_1, 4, 7) |
__gen_uint(self.stream_to_buffer_selects_2, 8, 11) |
__gen_uint(self.stream_to_buffer_selects_3, 12, 15);
out[2] = __gen_uint(self.num_entries_0, 0, 7) |
__gen_uint(self.num_entries_1, 8, 15) |
__gen_uint(self.num_entries_2, 16, 23) |
__gen_uint(self.num_entries_3, 24, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 3];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 3] as *const [u8; 12]) })
}
}
impl From<&[u32; 3]> for _3dStateSoDeclList {
fn from(input: &[u32; 3]) -> Self {
_3dStateSoDeclList {
dword_length: __gen_unuint(input[0], 0, 8),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
stream_to_buffer_selects_0: __gen_unuint(input[1], 0, 3),
stream_to_buffer_selects_1: __gen_unuint(input[1], 4, 7),
stream_to_buffer_selects_2: __gen_unuint(input[1], 8, 11),
stream_to_buffer_selects_3: __gen_unuint(input[1], 12, 15),
num_entries_0: __gen_unuint(input[2], 0, 7),
num_entries_1: __gen_unuint(input[2], 8, 15),
num_entries_2: __gen_unuint(input[2], 16, 23),
num_entries_3: __gen_unuint(input[2], 24, 31),
}
}
}
impl Deserialize for _3dStateSoDeclList {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 3];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 3] as *mut [u8; 12]) })?;
Ok((&input).into())
}
}
pub struct _3dStateStencilBuffer<A: Addr + Default> {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub surface_pitch: u32,
pub mocs: u32,
pub surface_base_address: A,
}
impl<A: Addr + Default> _3dStateStencilBuffer<A> {
pub const DWORD_LENGTH: u32 = 3;
}
impl<A: Addr + Default> Default for _3dStateStencilBuffer<A> {
fn default() -> Self {
_3dStateStencilBuffer {
dword_length: 1,
_3d_command_sub_opcode: 6,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
surface_pitch: Default::default(),
mocs: Default::default(),
surface_base_address: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for _3dStateStencilBuffer<A> {
type Out = [u32; 3];
fn pack_into(&self, out: &mut [u32; 3]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.surface_pitch, 0, 16) |
__gen_uint(self.mocs, 25, 28);
let v2_address = self.surface_base_address.combine(0);
out[2] = v2_address as u32;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 3];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 3] as *const [u8; 12]) })
}
}
impl From<&[u32; 3]> for _3dStateStencilBuffer<u64> {
fn from(input: &[u32; 3]) -> Self {
_3dStateStencilBuffer {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
surface_pitch: __gen_unuint(input[1], 0, 16),
mocs: __gen_unuint(input[1], 25, 28),
surface_base_address: (__gen_unuint(input[2], 0, 31) as u64),
}
}
}
impl Deserialize for _3dStateStencilBuffer<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 3];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 3] as *mut [u8; 12]) })?;
Ok((&input).into())
}
}
pub struct _3dStateStreamout {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub so_buffer_enable_0: bool,
pub so_buffer_enable_1: bool,
pub so_buffer_enable_2: bool,
pub so_buffer_enable_3: bool,
pub so_statistics_enable: bool,
pub reorder_mode: u32,
pub render_stream_select: u32,
pub rendering_disable: bool,
pub so_function_enable: bool,
pub stream_0_vertex_read_length: u32,
pub stream_0_vertex_read_offset: u32,
pub stream_1_vertex_read_length: u32,
pub stream_1_vertex_read_offset: u32,
pub stream_2_vertex_read_length: u32,
pub stream_2_vertex_read_offset: u32,
pub stream_3_vertex_read_length: u32,
pub stream_3_vertex_read_offset: u32,
}
impl _3dStateStreamout {
pub const DWORD_LENGTH: u32 = 3;
pub const LEADING: u32 = 0;
pub const TRAILING: u32 = 1;
}
impl Default for _3dStateStreamout {
fn default() -> Self {
_3dStateStreamout {
dword_length: 1,
_3d_command_sub_opcode: 30,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
so_buffer_enable_0: Default::default(),
so_buffer_enable_1: Default::default(),
so_buffer_enable_2: Default::default(),
so_buffer_enable_3: Default::default(),
so_statistics_enable: Default::default(),
reorder_mode: Default::default(),
render_stream_select: Default::default(),
rendering_disable: Default::default(),
so_function_enable: Default::default(),
stream_0_vertex_read_length: Default::default(),
stream_0_vertex_read_offset: Default::default(),
stream_1_vertex_read_length: Default::default(),
stream_1_vertex_read_offset: Default::default(),
stream_2_vertex_read_length: Default::default(),
stream_2_vertex_read_offset: Default::default(),
stream_3_vertex_read_length: Default::default(),
stream_3_vertex_read_offset: Default::default(),
}
}
}
impl Serialize for _3dStateStreamout {
type Out = [u32; 3];
fn pack_into(&self, out: &mut [u32; 3]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.so_buffer_enable_0.into(), 8, 8) |
__gen_uint(self.so_buffer_enable_1.into(), 9, 9) |
__gen_uint(self.so_buffer_enable_2.into(), 10, 10) |
__gen_uint(self.so_buffer_enable_3.into(), 11, 11) |
__gen_uint(self.so_statistics_enable.into(), 25, 25) |
__gen_uint(self.reorder_mode, 26, 26) |
__gen_uint(self.render_stream_select, 27, 28) |
__gen_uint(self.rendering_disable.into(), 30, 30) |
__gen_uint(self.so_function_enable.into(), 31, 31);
out[2] = __gen_uint(self.stream_0_vertex_read_length, 0, 4) |
__gen_uint(self.stream_0_vertex_read_offset, 5, 5) |
__gen_uint(self.stream_1_vertex_read_length, 8, 12) |
__gen_uint(self.stream_1_vertex_read_offset, 13, 13) |
__gen_uint(self.stream_2_vertex_read_length, 16, 20) |
__gen_uint(self.stream_2_vertex_read_offset, 21, 21) |
__gen_uint(self.stream_3_vertex_read_length, 24, 28) |
__gen_uint(self.stream_3_vertex_read_offset, 29, 29);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 3];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 3] as *const [u8; 12]) })
}
}
impl From<&[u32; 3]> for _3dStateStreamout {
fn from(input: &[u32; 3]) -> Self {
_3dStateStreamout {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
so_buffer_enable_0: __gen_unuint(input[1], 8, 8) != 0,
so_buffer_enable_1: __gen_unuint(input[1], 9, 9) != 0,
so_buffer_enable_2: __gen_unuint(input[1], 10, 10) != 0,
so_buffer_enable_3: __gen_unuint(input[1], 11, 11) != 0,
so_statistics_enable: __gen_unuint(input[1], 25, 25) != 0,
reorder_mode: __gen_unuint(input[1], 26, 26),
render_stream_select: __gen_unuint(input[1], 27, 28),
rendering_disable: __gen_unuint(input[1], 30, 30) != 0,
so_function_enable: __gen_unuint(input[1], 31, 31) != 0,
stream_0_vertex_read_length: __gen_unuint(input[2], 0, 4),
stream_0_vertex_read_offset: __gen_unuint(input[2], 5, 5),
stream_1_vertex_read_length: __gen_unuint(input[2], 8, 12),
stream_1_vertex_read_offset: __gen_unuint(input[2], 13, 13),
stream_2_vertex_read_length: __gen_unuint(input[2], 16, 20),
stream_2_vertex_read_offset: __gen_unuint(input[2], 21, 21),
stream_3_vertex_read_length: __gen_unuint(input[2], 24, 28),
stream_3_vertex_read_offset: __gen_unuint(input[2], 29, 29),
}
}
}
impl Deserialize for _3dStateStreamout {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 3];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 3] as *mut [u8; 12]) })?;
Ok((&input).into())
}
}
pub struct _3dStateTe {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub te_enable: bool,
pub te_mode: u32,
pub te_domain: u32,
pub output_topology: u32,
pub partitioning: u32,
pub maximum_tessellation_factor_odd: f32,
pub maximum_tessellation_factor_not_odd: f32,
}
impl _3dStateTe {
pub const DWORD_LENGTH: u32 = 4;
pub const EVEN_FRACTIONAL: u32 = 2;
pub const HW_TESS: u32 = 0;
pub const INTEGER: u32 = 0;
pub const ISOLINE: u32 = 2;
pub const LINE: u32 = 1;
pub const ODD_FRACTIONAL: u32 = 1;
pub const POINT: u32 = 0;
pub const QUAD: u32 = 0;
pub const SW_TESS: u32 = 1;
pub const TRI: u32 = 1;
pub const TRI_CCW: u32 = 3;
pub const TRI_CW: u32 = 2;
}
impl Default for _3dStateTe {
fn default() -> Self {
_3dStateTe {
dword_length: 2,
_3d_command_sub_opcode: 28,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
te_enable: Default::default(),
te_mode: Default::default(),
te_domain: Default::default(),
output_topology: Default::default(),
partitioning: Default::default(),
maximum_tessellation_factor_odd: Default::default(),
maximum_tessellation_factor_not_odd: Default::default(),
}
}
}
impl Serialize for _3dStateTe {
type Out = [u32; 4];
fn pack_into(&self, out: &mut [u32; 4]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.te_enable.into(), 0, 0) |
__gen_uint(self.te_mode, 1, 2) |
__gen_uint(self.te_domain, 4, 5) |
__gen_uint(self.output_topology, 8, 9) |
__gen_uint(self.partitioning, 12, 13);
out[2] = self.maximum_tessellation_factor_odd.to_bits();
out[3] = self.maximum_tessellation_factor_not_odd.to_bits();
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 4];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 4] as *const [u8; 16]) })
}
}
impl From<&[u32; 4]> for _3dStateTe {
fn from(input: &[u32; 4]) -> Self {
_3dStateTe {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
te_enable: __gen_unuint(input[1], 0, 0) != 0,
te_mode: __gen_unuint(input[1], 1, 2),
te_domain: __gen_unuint(input[1], 4, 5),
output_topology: __gen_unuint(input[1], 8, 9),
partitioning: __gen_unuint(input[1], 12, 13),
maximum_tessellation_factor_odd: f32::from_bits(input[2]),
maximum_tessellation_factor_not_odd: f32::from_bits(input[3]),
}
}
}
impl Deserialize for _3dStateTe {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 4];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 4] as *mut [u8; 16]) })?;
Ok((&input).into())
}
}
pub struct _3dStateUrbDs {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub ds_number_of_urb_entries: u32,
pub ds_urb_entry_allocation_size: u32,
pub ds_urb_starting_address: u32,
}
impl _3dStateUrbDs {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for _3dStateUrbDs {
fn default() -> Self {
_3dStateUrbDs {
dword_length: 0,
_3d_command_sub_opcode: 50,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
ds_number_of_urb_entries: Default::default(),
ds_urb_entry_allocation_size: Default::default(),
ds_urb_starting_address: Default::default(),
}
}
}
impl Serialize for _3dStateUrbDs {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.ds_number_of_urb_entries, 0, 15) |
__gen_uint(self.ds_urb_entry_allocation_size, 16, 24) |
__gen_uint(self.ds_urb_starting_address, 25, 29);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStateUrbDs {
fn from(input: &[u32; 2]) -> Self {
_3dStateUrbDs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
ds_number_of_urb_entries: __gen_unuint(input[1], 0, 15),
ds_urb_entry_allocation_size: __gen_unuint(input[1], 16, 24),
ds_urb_starting_address: __gen_unuint(input[1], 25, 29),
}
}
}
impl Deserialize for _3dStateUrbDs {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStateUrbGs {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub gs_number_of_urb_entries: u32,
pub gs_urb_entry_allocation_size: u32,
pub gs_urb_starting_address: u32,
}
impl _3dStateUrbGs {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for _3dStateUrbGs {
fn default() -> Self {
_3dStateUrbGs {
dword_length: 0,
_3d_command_sub_opcode: 51,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
gs_number_of_urb_entries: Default::default(),
gs_urb_entry_allocation_size: Default::default(),
gs_urb_starting_address: Default::default(),
}
}
}
impl Serialize for _3dStateUrbGs {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.gs_number_of_urb_entries, 0, 15) |
__gen_uint(self.gs_urb_entry_allocation_size, 16, 24) |
__gen_uint(self.gs_urb_starting_address, 25, 29);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStateUrbGs {
fn from(input: &[u32; 2]) -> Self {
_3dStateUrbGs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
gs_number_of_urb_entries: __gen_unuint(input[1], 0, 15),
gs_urb_entry_allocation_size: __gen_unuint(input[1], 16, 24),
gs_urb_starting_address: __gen_unuint(input[1], 25, 29),
}
}
}
impl Deserialize for _3dStateUrbGs {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStateUrbHs {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub hs_number_of_urb_entries: u32,
pub hs_urb_entry_allocation_size: u32,
pub hs_urb_starting_address: u32,
}
impl _3dStateUrbHs {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for _3dStateUrbHs {
fn default() -> Self {
_3dStateUrbHs {
dword_length: 0,
_3d_command_sub_opcode: 49,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
hs_number_of_urb_entries: Default::default(),
hs_urb_entry_allocation_size: Default::default(),
hs_urb_starting_address: Default::default(),
}
}
}
impl Serialize for _3dStateUrbHs {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.hs_number_of_urb_entries, 0, 15) |
__gen_uint(self.hs_urb_entry_allocation_size, 16, 24) |
__gen_uint(self.hs_urb_starting_address, 25, 29);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStateUrbHs {
fn from(input: &[u32; 2]) -> Self {
_3dStateUrbHs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
hs_number_of_urb_entries: __gen_unuint(input[1], 0, 15),
hs_urb_entry_allocation_size: __gen_unuint(input[1], 16, 24),
hs_urb_starting_address: __gen_unuint(input[1], 25, 29),
}
}
}
impl Deserialize for _3dStateUrbHs {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStateUrbVs {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub vs_number_of_urb_entries: u32,
pub vs_urb_entry_allocation_size: u32,
pub vs_urb_starting_address: u32,
}
impl _3dStateUrbVs {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for _3dStateUrbVs {
fn default() -> Self {
_3dStateUrbVs {
dword_length: 0,
_3d_command_sub_opcode: 48,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
vs_number_of_urb_entries: Default::default(),
vs_urb_entry_allocation_size: Default::default(),
vs_urb_starting_address: Default::default(),
}
}
}
impl Serialize for _3dStateUrbVs {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.vs_number_of_urb_entries, 0, 15) |
__gen_uint(self.vs_urb_entry_allocation_size, 16, 24) |
__gen_uint(self.vs_urb_starting_address, 25, 29);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStateUrbVs {
fn from(input: &[u32; 2]) -> Self {
_3dStateUrbVs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
vs_number_of_urb_entries: __gen_unuint(input[1], 0, 15),
vs_urb_entry_allocation_size: __gen_unuint(input[1], 16, 24),
vs_urb_starting_address: __gen_unuint(input[1], 25, 29),
}
}
}
impl Deserialize for _3dStateUrbVs {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStateVertexBuffers {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
}
impl _3dStateVertexBuffers {
pub const DWORD_LENGTH: u32 = 1;
}
impl Default for _3dStateVertexBuffers {
fn default() -> Self {
_3dStateVertexBuffers {
dword_length: 3,
_3d_command_sub_opcode: 8,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
}
}
}
impl Serialize for _3dStateVertexBuffers {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for _3dStateVertexBuffers {
fn from(input: &[u32; 1]) -> Self {
_3dStateVertexBuffers {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
}
}
}
impl Deserialize for _3dStateVertexBuffers {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct _3dStateVertexElements {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
}
impl _3dStateVertexElements {
pub const DWORD_LENGTH: u32 = 1;
}
impl Default for _3dStateVertexElements {
fn default() -> Self {
_3dStateVertexElements {
dword_length: 1,
_3d_command_sub_opcode: 9,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
}
}
}
impl Serialize for _3dStateVertexElements {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for _3dStateVertexElements {
fn from(input: &[u32; 1]) -> Self {
_3dStateVertexElements {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
}
}
}
impl Deserialize for _3dStateVertexElements {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct _3dStateVfStatistics {
pub statistics_enable: bool,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
}
impl _3dStateVfStatistics {
pub const DWORD_LENGTH: u32 = 1;
}
impl Default for _3dStateVfStatistics {
fn default() -> Self {
_3dStateVfStatistics {
statistics_enable: Default::default(),
_3d_command_sub_opcode: 11,
_3d_command_opcode: 0,
command_subtype: 1,
command_type: 3,
}
}
}
impl Serialize for _3dStateVfStatistics {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.statistics_enable.into(), 0, 0) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 1];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 1] as *const [u8; 4]) })
}
}
impl From<&[u32; 1]> for _3dStateVfStatistics {
fn from(input: &[u32; 1]) -> Self {
_3dStateVfStatistics {
statistics_enable: __gen_unuint(input[0], 0, 0) != 0,
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
}
}
}
impl Deserialize for _3dStateVfStatistics {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 1];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 1] as *mut [u8; 4]) })?;
Ok((&input).into())
}
}
pub struct _3dStateViewportStatePointersCc {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub cc_viewport_pointer: u64,
}
impl _3dStateViewportStatePointersCc {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for _3dStateViewportStatePointersCc {
fn default() -> Self {
_3dStateViewportStatePointersCc {
dword_length: 0,
_3d_command_sub_opcode: 35,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
cc_viewport_pointer: Default::default(),
}
}
}
impl Serialize for _3dStateViewportStatePointersCc {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_offset(self.cc_viewport_pointer as u32, 5, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStateViewportStatePointersCc {
fn from(input: &[u32; 2]) -> Self {
_3dStateViewportStatePointersCc {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
cc_viewport_pointer: (__gen_unuint(input[1], 5, 31) as u64) << 5,
}
}
}
impl Deserialize for _3dStateViewportStatePointersCc {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStateViewportStatePointersSfClip {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub sf_clip_viewport_pointer: u64,
}
impl _3dStateViewportStatePointersSfClip {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for _3dStateViewportStatePointersSfClip {
fn default() -> Self {
_3dStateViewportStatePointersSfClip {
dword_length: 0,
_3d_command_sub_opcode: 33,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
sf_clip_viewport_pointer: Default::default(),
}
}
}
impl Serialize for _3dStateViewportStatePointersSfClip {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_offset(self.sf_clip_viewport_pointer as u32, 6, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 2];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 2] as *const [u8; 8]) })
}
}
impl From<&[u32; 2]> for _3dStateViewportStatePointersSfClip {
fn from(input: &[u32; 2]) -> Self {
_3dStateViewportStatePointersSfClip {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
sf_clip_viewport_pointer: (__gen_unuint(input[1], 6, 31) as u64) << 6,
}
}
}
impl Deserialize for _3dStateViewportStatePointersSfClip {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 2];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 2] as *mut [u8; 8]) })?;
Ok((&input).into())
}
}
pub struct _3dStateVs<A: Addr + Default> {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub kernel_start_pointer: u64,
pub software_exception_enable: bool,
pub illegal_opcode_exception_enable: bool,
pub floating_point_mode: u32,
pub binding_table_entry_count: u32,
pub sampler_count: u32,
pub vector_mask_enable: bool,
pub single_vertex_dispatch: bool,
pub per_thread_scratch_space: u32,
pub scratch_space_base_pointer: A,
pub vertex_urb_entry_read_offset: u32,
pub vertex_urb_entry_read_length: u32,
pub dispatch_grf_start_register_for_urb_data: u32,
pub enable: bool,
pub vertex_cache_disable: bool,
pub statistics_enable: bool,
pub maximum_number_of_threads: u32,
}
impl<A: Addr + Default> _3dStateVs<A> {
pub const DWORD_LENGTH: u32 = 6;
pub const ALTERNATE: u32 = 1;
pub const IEEE_754: u32 = 0;
pub const NO_SAMPLERS: u32 = 0;
pub const _13_16_SAMPLERS: u32 = 4;
pub const _1_4_SAMPLERS: u32 = 1;
pub const _5_8_SAMPLERS: u32 = 2;
pub const _9_12_SAMPLERS: u32 = 3;
}
impl<A: Addr + Default> Default for _3dStateVs<A> {
fn default() -> Self {
_3dStateVs {
dword_length: 4,
_3d_command_sub_opcode: 16,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
kernel_start_pointer: Default::default(),
software_exception_enable: Default::default(),
illegal_opcode_exception_enable: Default::default(),
floating_point_mode: Default::default(),
binding_table_entry_count: Default::default(),
sampler_count: Default::default(),
vector_mask_enable: Default::default(),
single_vertex_dispatch: Default::default(),
per_thread_scratch_space: Default::default(),
scratch_space_base_pointer: Default::default(),
vertex_urb_entry_read_offset: Default::default(),
vertex_urb_entry_read_length: Default::default(),
dispatch_grf_start_register_for_urb_data: Default::default(),
enable: Default::default(),
vertex_cache_disable: Default::default(),
statistics_enable: Default::default(),
maximum_number_of_threads: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for _3dStateVs<A> {
type Out = [u32; 6];
fn pack_into(&self, out: &mut [u32; 6]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_offset(self.kernel_start_pointer as u32, 6, 31);
out[2] = __gen_uint(self.software_exception_enable.into(), 7, 7) |
__gen_uint(self.illegal_opcode_exception_enable.into(), 13, 13) |
__gen_uint(self.floating_point_mode, 16, 16) |
__gen_uint(self.binding_table_entry_count, 18, 25) |
__gen_uint(self.sampler_count, 27, 29) |
__gen_uint(self.vector_mask_enable.into(), 30, 30) |
__gen_uint(self.single_vertex_dispatch.into(), 31, 31);
let v3 = __gen_uint(self.per_thread_scratch_space, 0, 3);
let v3_address = self.scratch_space_base_pointer.combine(v3);
out[3] = v3_address as u32;
out[4] = (v3_address >> 32) as u32;
out[4] = __gen_uint(self.vertex_urb_entry_read_offset, 4, 9) |
__gen_uint(self.vertex_urb_entry_read_length, 11, 16) |
__gen_uint(self.dispatch_grf_start_register_for_urb_data, 20, 24);
out[5] = __gen_uint(self.enable.into(), 0, 0) |
__gen_uint(self.vertex_cache_disable.into(), 1, 1) |
__gen_uint(self.statistics_enable.into(), 10, 10) |
__gen_uint(self.maximum_number_of_threads, 25, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 6];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 6] as *const [u8; 24]) })
}
}
impl From<&[u32; 6]> for _3dStateVs<u64> {
fn from(input: &[u32; 6]) -> Self {
_3dStateVs {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
kernel_start_pointer: (__gen_unuint(input[1], 6, 31) as u64) << 6,
software_exception_enable: __gen_unuint(input[2], 7, 7) != 0,
illegal_opcode_exception_enable: __gen_unuint(input[2], 13, 13) != 0,
floating_point_mode: __gen_unuint(input[2], 16, 16),
binding_table_entry_count: __gen_unuint(input[2], 18, 25),
sampler_count: __gen_unuint(input[2], 27, 29),
vector_mask_enable: __gen_unuint(input[2], 30, 30) != 0,
single_vertex_dispatch: __gen_unuint(input[2], 31, 31) != 0,
per_thread_scratch_space: __gen_unuint(input[3], 0, 3),
scratch_space_base_pointer: (__gen_unuint(input[3], 10, 31) as u64) << 10,
vertex_urb_entry_read_offset: __gen_unuint(input[4], 4, 9),
vertex_urb_entry_read_length: __gen_unuint(input[4], 11, 16),
dispatch_grf_start_register_for_urb_data: __gen_unuint(input[4], 20, 24),
enable: __gen_unuint(input[5], 0, 0) != 0,
vertex_cache_disable: __gen_unuint(input[5], 1, 1) != 0,
statistics_enable: __gen_unuint(input[5], 10, 10) != 0,
maximum_number_of_threads: __gen_unuint(input[5], 25, 31),
}
}
}
impl Deserialize for _3dStateVs<u64> {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 6];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 6] as *mut [u8; 24]) })?;
Ok((&input).into())
}
}
pub struct _3dStateWm {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub multisample_rasterization_mode: u32,
pub point_rasterization_rule: u32,
pub line_stipple_enable: bool,
pub polygon_stipple_enable: bool,
pub line_antialiasing_region_width: u32,
pub line_end_cap_antialiasing_region_width: u32,
pub pixel_shader_uses_input_coverage_mask: bool,
pub barycentric_interpolation_mode: u32,
pub position_zw_interpolation_mode: u32,
pub pixel_shader_uses_source_w: bool,
pub pixel_shader_uses_source_depth: bool,
pub early_depth_stencil_control: u32,
pub pixel_shader_computed_depth_mode: u32,
pub pixel_shader_kills_pixel: bool,
pub legacy_diamond_line_rasterization: bool,
pub hierarchical_depth_buffer_resolve_enable: bool,
pub depth_buffer_resolve_enable: bool,
pub thread_dispatch_enable: bool,
pub depth_buffer_clear: bool,
pub statistics_enable: bool,
pub multisample_dispatch_mode: u32,
}
impl _3dStateWm {
pub const DWORD_LENGTH: u32 = 3;
pub const BIM_LINEAR_CENTROID: u32 = 16;
pub const BIM_LINEAR_PIXEL: u32 = 8;
pub const BIM_LINEAR_SAMPLE: u32 = 32;
pub const BIM_PERSPECTIVE_CENTROID: u32 = 2;
pub const BIM_PERSPECTIVE_PIXEL: u32 = 1;
pub const BIM_PERSPECTIVE_SAMPLE: u32 = 4;
pub const EDSC_NORMAL: u32 = 0;
pub const EDSC_PREPS: u32 = 2;
pub const EDSC_PSEXEC: u32 = 1;
pub const INTERP_CENTROID: u32 = 2;
pub const INTERP_PIXEL: u32 = 0;
pub const INTERP_SAMPLE: u32 = 3;
pub const MSDISPMODE_PERPIXEL: u32 = 1;
pub const MSDISPMODE_PERSAMPLE: u32 = 0;
pub const MSRASTMODE_OFF_PATTERN: u32 = 1;
pub const MSRASTMODE_OFF_PIXEL: u32 = 0;
pub const MSRASTMODE_ON_PATTERN: u32 = 3;
pub const MSRASTMODE_ON_PIXEL: u32 = 2;
pub const PSCDEPTH_OFF: u32 = 0;
pub const PSCDEPTH_ON: u32 = 1;
pub const PSCDEPTH_ON_GE: u32 = 2;
pub const PSCDEPTH_ON_LE: u32 = 3;
pub const RASTRULE_UPPER_LEFT: u32 = 0;
pub const RASTRULE_UPPER_RIGHT: u32 = 1;
pub const _0_5_PIXELS: u32 = 0;
pub const _1_0_PIXELS: u32 = 1;
pub const _2_0_PIXELS: u32 = 2;
pub const _4_0_PIXELS: u32 = 3;
}
impl Default for _3dStateWm {
fn default() -> Self {
_3dStateWm {
dword_length: 1,
_3d_command_sub_opcode: 20,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
multisample_rasterization_mode: Default::default(),
point_rasterization_rule: Default::default(),
line_stipple_enable: Default::default(),
polygon_stipple_enable: Default::default(),
line_antialiasing_region_width: Default::default(),
line_end_cap_antialiasing_region_width: Default::default(),
pixel_shader_uses_input_coverage_mask: Default::default(),
barycentric_interpolation_mode: Default::default(),
position_zw_interpolation_mode: Default::default(),
pixel_shader_uses_source_w: Default::default(),
pixel_shader_uses_source_depth: Default::default(),
early_depth_stencil_control: Default::default(),
pixel_shader_computed_depth_mode: Default::default(),
pixel_shader_kills_pixel: Default::default(),
legacy_diamond_line_rasterization: Default::default(),
hierarchical_depth_buffer_resolve_enable: Default::default(),
depth_buffer_resolve_enable: Default::default(),
thread_dispatch_enable: Default::default(),
depth_buffer_clear: Default::default(),
statistics_enable: Default::default(),
multisample_dispatch_mode: Default::default(),
}
}
}
impl Serialize for _3dStateWm {
type Out = [u32; 3];
fn pack_into(&self, out: &mut [u32; 3]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self._3d_command_sub_opcode, 16, 23) |
__gen_uint(self._3d_command_opcode, 24, 26) |
__gen_uint(self.command_subtype, 27, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.multisample_rasterization_mode, 0, 1) |
__gen_uint(self.point_rasterization_rule, 2, 2) |
__gen_uint(self.line_stipple_enable.into(), 3, 3) |
__gen_uint(self.polygon_stipple_enable.into(), 4, 4) |
__gen_uint(self.line_antialiasing_region_width, 6, 7) |
__gen_uint(self.line_end_cap_antialiasing_region_width, 8, 9) |
__gen_uint(self.pixel_shader_uses_input_coverage_mask.into(), 10, 10) |
__gen_uint(self.barycentric_interpolation_mode, 11, 16) |
__gen_uint(self.position_zw_interpolation_mode, 17, 18) |
__gen_uint(self.pixel_shader_uses_source_w.into(), 19, 19) |
__gen_uint(self.pixel_shader_uses_source_depth.into(), 20, 20) |
__gen_uint(self.early_depth_stencil_control, 21, 22) |
__gen_uint(self.pixel_shader_computed_depth_mode, 23, 24) |
__gen_uint(self.pixel_shader_kills_pixel.into(), 25, 25) |
__gen_uint(self.legacy_diamond_line_rasterization.into(), 26, 26) |
__gen_uint(self.hierarchical_depth_buffer_resolve_enable.into(), 27, 27) |
__gen_uint(self.depth_buffer_resolve_enable.into(), 28, 28) |
__gen_uint(self.thread_dispatch_enable.into(), 29, 29) |
__gen_uint(self.depth_buffer_clear.into(), 30, 30) |
__gen_uint(self.statistics_enable.into(), 31, 31);
out[2] = __gen_uint(self.multisample_dispatch_mode, 31, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 3];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 3] as *const [u8; 12]) })
}
}
impl From<&[u32; 3]> for _3dStateWm {
fn from(input: &[u32; 3]) -> Self {
_3dStateWm {
dword_length: __gen_unuint(input[0], 0, 7),
_3d_command_sub_opcode: __gen_unuint(input[0], 16, 23),
_3d_command_opcode: __gen_unuint(input[0], 24, 26),
command_subtype: __gen_unuint(input[0], 27, 28),
command_type: __gen_unuint(input[0], 29, 31),
multisample_rasterization_mode: __gen_unuint(input[1], 0, 1),
point_rasterization_rule: __gen_unuint(input[1], 2, 2),
line_stipple_enable: __gen_unuint(input[1], 3, 3) != 0,
polygon_stipple_enable: __gen_unuint(input[1], 4, 4) != 0,
line_antialiasing_region_width: __gen_unuint(input[1], 6, 7),
line_end_cap_antialiasing_region_width: __gen_unuint(input[1], 8, 9),
pixel_shader_uses_input_coverage_mask: __gen_unuint(input[1], 10, 10) != 0,
barycentric_interpolation_mode: __gen_unuint(input[1], 11, 16),
position_zw_interpolation_mode: __gen_unuint(input[1], 17, 18),
pixel_shader_uses_source_w: __gen_unuint(input[1], 19, 19) != 0,
pixel_shader_uses_source_depth: __gen_unuint(input[1], 20, 20) != 0,
early_depth_stencil_control: __gen_unuint(input[1], 21, 22),
pixel_shader_computed_depth_mode: __gen_unuint(input[1], 23, 24),
pixel_shader_kills_pixel: __gen_unuint(input[1], 25, 25) != 0,
legacy_diamond_line_rasterization: __gen_unuint(input[1], 26, 26) != 0,
hierarchical_depth_buffer_resolve_enable: __gen_unuint(input[1], 27, 27) != 0,
depth_buffer_resolve_enable: __gen_unuint(input[1], 28, 28) != 0,
thread_dispatch_enable: __gen_unuint(input[1], 29, 29) != 0,
depth_buffer_clear: __gen_unuint(input[1], 30, 30) != 0,
statistics_enable: __gen_unuint(input[1], 31, 31) != 0,
multisample_dispatch_mode: __gen_unuint(input[2], 31, 31),
}
}
}
impl Deserialize for _3dStateWm {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 3];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 3] as *mut [u8; 12]) })?;
Ok((&input).into())
}
}
}