pub mod gen6 {
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,
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::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,
_ => 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: true,
gab_idle: true,
bcs_done: true,
}
}
}
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 ClipViewport {
pub xmin_clip_guardband: f32,
pub xmax_clip_guardband: f32,
pub ymin_clip_guardband: f32,
pub ymax_clip_guardband: f32,
}
impl ClipViewport {
pub const DWORD_LENGTH: u32 = 4;
}
impl Default for ClipViewport {
fn default() -> Self {
ClipViewport {
xmin_clip_guardband: Default::default(),
xmax_clip_guardband: Default::default(),
ymin_clip_guardband: Default::default(),
ymax_clip_guardband: Default::default(),
}
}
}
impl Serialize for ClipViewport {
type Out = [u32; 4];
fn pack_into(&self, out: &mut [u32; 4]) {
out[0] = self.xmin_clip_guardband.to_bits();
out[1] = self.xmax_clip_guardband.to_bits();
out[2] = self.ymin_clip_guardband.to_bits();
out[3] = self.ymax_clip_guardband.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 ClipViewport {
fn from(input: &[u32; 4]) -> Self {
ClipViewport {
xmin_clip_guardband: f32::from_bits(input[0]),
xmax_clip_guardband: f32::from_bits(input[1]),
ymin_clip_guardband: f32::from_bits(input[2]),
ymax_clip_guardband: f32::from_bits(input[3]),
}
}
}
impl Deserialize for ClipViewport {
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 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 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 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 Instdone1 {
pub prb0_ring_enable: bool,
pub avs_done: bool,
pub hiz_done: bool,
pub gw_done: bool,
pub ts_done: bool,
pub td_done: bool,
pub vfe_done: bool,
pub ief_done: bool,
pub vsc_done: bool,
pub isc2_3_done: bool,
pub isc1_0_done: bool,
pub ic0_done: bool,
pub ic1_done: bool,
pub ic2_done: bool,
pub ic3_done: bool,
pub eu00_done: bool,
pub eu01_done: bool,
pub eu02_done: bool,
pub ma0_done: bool,
pub eu10_done: bool,
pub eu11_done: bool,
pub eu12_done: bool,
pub ma1_done: bool,
pub eu20_done: bool,
pub eu21_done: bool,
pub eu22_done: bool,
pub ma2_done: bool,
pub eu30_done: bool,
pub eu31_done: bool,
pub eu32_done: bool,
pub ma3_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(),
avs_done: Default::default(),
hiz_done: Default::default(),
gw_done: Default::default(),
ts_done: Default::default(),
td_done: Default::default(),
vfe_done: Default::default(),
ief_done: Default::default(),
vsc_done: Default::default(),
isc2_3_done: Default::default(),
isc1_0_done: Default::default(),
ic0_done: Default::default(),
ic1_done: Default::default(),
ic2_done: Default::default(),
ic3_done: Default::default(),
eu00_done: Default::default(),
eu01_done: Default::default(),
eu02_done: Default::default(),
ma0_done: Default::default(),
eu10_done: Default::default(),
eu11_done: Default::default(),
eu12_done: Default::default(),
ma1_done: Default::default(),
eu20_done: Default::default(),
eu21_done: Default::default(),
eu22_done: Default::default(),
ma2_done: Default::default(),
eu30_done: Default::default(),
eu31_done: Default::default(),
eu32_done: Default::default(),
ma3_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.avs_done.into(), 1, 1) |
__gen_uint(self.hiz_done.into(), 2, 2) |
__gen_uint(self.gw_done.into(), 3, 3) |
__gen_uint(self.ts_done.into(), 4, 4) |
__gen_uint(self.td_done.into(), 6, 6) |
__gen_uint(self.vfe_done.into(), 7, 7) |
__gen_uint(self.ief_done.into(), 8, 8) |
__gen_uint(self.vsc_done.into(), 9, 9) |
__gen_uint(self.isc2_3_done.into(), 10, 10) |
__gen_uint(self.isc1_0_done.into(), 11, 11) |
__gen_uint(self.ic0_done.into(), 12, 12) |
__gen_uint(self.ic1_done.into(), 13, 13) |
__gen_uint(self.ic2_done.into(), 14, 14) |
__gen_uint(self.ic3_done.into(), 15, 15) |
__gen_uint(self.eu00_done.into(), 16, 16) |
__gen_uint(self.eu01_done.into(), 17, 17) |
__gen_uint(self.eu02_done.into(), 18, 18) |
__gen_uint(self.ma0_done.into(), 19, 19) |
__gen_uint(self.eu10_done.into(), 20, 20) |
__gen_uint(self.eu11_done.into(), 21, 21) |
__gen_uint(self.eu12_done.into(), 22, 22) |
__gen_uint(self.ma1_done.into(), 23, 23) |
__gen_uint(self.eu20_done.into(), 24, 24) |
__gen_uint(self.eu21_done.into(), 25, 25) |
__gen_uint(self.eu22_done.into(), 26, 26) |
__gen_uint(self.ma2_done.into(), 27, 27) |
__gen_uint(self.eu30_done.into(), 28, 28) |
__gen_uint(self.eu31_done.into(), 29, 29) |
__gen_uint(self.eu32_done.into(), 30, 30) |
__gen_uint(self.ma3_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 Instdone1 {
fn from(input: &[u32; 1]) -> Self {
Instdone1 {
prb0_ring_enable: __gen_unuint(input[0], 0, 0) != 0,
avs_done: __gen_unuint(input[0], 1, 1) != 0,
hiz_done: __gen_unuint(input[0], 2, 2) != 0,
gw_done: __gen_unuint(input[0], 3, 3) != 0,
ts_done: __gen_unuint(input[0], 4, 4) != 0,
td_done: __gen_unuint(input[0], 6, 6) != 0,
vfe_done: __gen_unuint(input[0], 7, 7) != 0,
ief_done: __gen_unuint(input[0], 8, 8) != 0,
vsc_done: __gen_unuint(input[0], 9, 9) != 0,
isc2_3_done: __gen_unuint(input[0], 10, 10) != 0,
isc1_0_done: __gen_unuint(input[0], 11, 11) != 0,
ic0_done: __gen_unuint(input[0], 12, 12) != 0,
ic1_done: __gen_unuint(input[0], 13, 13) != 0,
ic2_done: __gen_unuint(input[0], 14, 14) != 0,
ic3_done: __gen_unuint(input[0], 15, 15) != 0,
eu00_done: __gen_unuint(input[0], 16, 16) != 0,
eu01_done: __gen_unuint(input[0], 17, 17) != 0,
eu02_done: __gen_unuint(input[0], 18, 18) != 0,
ma0_done: __gen_unuint(input[0], 19, 19) != 0,
eu10_done: __gen_unuint(input[0], 20, 20) != 0,
eu11_done: __gen_unuint(input[0], 21, 21) != 0,
eu12_done: __gen_unuint(input[0], 22, 22) != 0,
ma1_done: __gen_unuint(input[0], 23, 23) != 0,
eu20_done: __gen_unuint(input[0], 24, 24) != 0,
eu21_done: __gen_unuint(input[0], 25, 25) != 0,
eu22_done: __gen_unuint(input[0], 26, 26) != 0,
ma2_done: __gen_unuint(input[0], 27, 27) != 0,
eu30_done: __gen_unuint(input[0], 28, 28) != 0,
eu31_done: __gen_unuint(input[0], 29, 29) != 0,
eu32_done: __gen_unuint(input[0], 30, 30) != 0,
ma3_done: __gen_unuint(input[0], 31, 31) != 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 Instdone2 {
pub vf_done: bool,
pub vs0_done: bool,
pub gs_done: bool,
pub cl_done: bool,
pub sf_done: bool,
pub vme_done: bool,
pub pl_done: bool,
pub so_done: bool,
pub si_done: bool,
pub dg_done: bool,
pub ft_done: bool,
pub dm_done: bool,
pub sc_done: bool,
pub fl_done: bool,
pub qc_done: bool,
pub svsm_done: bool,
pub wmfe_done: bool,
pub iz_done: bool,
pub psd_done: bool,
pub dap_done: bool,
pub rcz_done: bool,
pub vdi_done: bool,
pub rcpbe_done: bool,
pub rcpfe_done: bool,
pub mt_done: bool,
pub isc_done: bool,
pub svg_done: bool,
pub rcc_done: bool,
pub svrw_done: bool,
pub wmbe_done: bool,
pub cs_done: bool,
pub gam_done: bool,
}
impl Instdone2 {
pub const DWORD_LENGTH: u32 = 1;
pub const NUM: u64 = 0x207c;
}
impl Default for Instdone2 {
fn default() -> Self {
Instdone2 {
vf_done: Default::default(),
vs0_done: Default::default(),
gs_done: Default::default(),
cl_done: Default::default(),
sf_done: Default::default(),
vme_done: Default::default(),
pl_done: Default::default(),
so_done: Default::default(),
si_done: Default::default(),
dg_done: Default::default(),
ft_done: Default::default(),
dm_done: Default::default(),
sc_done: Default::default(),
fl_done: Default::default(),
qc_done: Default::default(),
svsm_done: Default::default(),
wmfe_done: Default::default(),
iz_done: Default::default(),
psd_done: Default::default(),
dap_done: Default::default(),
rcz_done: Default::default(),
vdi_done: Default::default(),
rcpbe_done: Default::default(),
rcpfe_done: Default::default(),
mt_done: Default::default(),
isc_done: Default::default(),
svg_done: Default::default(),
rcc_done: Default::default(),
svrw_done: Default::default(),
wmbe_done: Default::default(),
cs_done: Default::default(),
gam_done: Default::default(),
}
}
}
impl Serialize for Instdone2 {
type Out = [u32; 1];
fn pack_into(&self, out: &mut [u32; 1]) {
out[0] = __gen_uint(self.vf_done.into(), 0, 0) |
__gen_uint(self.vs0_done.into(), 1, 1) |
__gen_uint(self.gs_done.into(), 2, 2) |
__gen_uint(self.cl_done.into(), 3, 3) |
__gen_uint(self.sf_done.into(), 4, 4) |
__gen_uint(self.vme_done.into(), 5, 5) |
__gen_uint(self.pl_done.into(), 6, 6) |
__gen_uint(self.so_done.into(), 7, 7) |
__gen_uint(self.si_done.into(), 8, 8) |
__gen_uint(self.dg_done.into(), 9, 9) |
__gen_uint(self.ft_done.into(), 10, 10) |
__gen_uint(self.dm_done.into(), 11, 11) |
__gen_uint(self.sc_done.into(), 12, 12) |
__gen_uint(self.fl_done.into(), 13, 13) |
__gen_uint(self.qc_done.into(), 14, 14) |
__gen_uint(self.svsm_done.into(), 15, 15) |
__gen_uint(self.wmfe_done.into(), 16, 16) |
__gen_uint(self.iz_done.into(), 17, 17) |
__gen_uint(self.psd_done.into(), 18, 18) |
__gen_uint(self.dap_done.into(), 19, 19) |
__gen_uint(self.rcz_done.into(), 20, 20) |
__gen_uint(self.vdi_done.into(), 21, 21) |
__gen_uint(self.rcpbe_done.into(), 22, 22) |
__gen_uint(self.rcpfe_done.into(), 23, 23) |
__gen_uint(self.mt_done.into(), 24, 24) |
__gen_uint(self.isc_done.into(), 25, 25) |
__gen_uint(self.svg_done.into(), 26, 26) |
__gen_uint(self.rcc_done.into(), 27, 27) |
__gen_uint(self.svrw_done.into(), 28, 28) |
__gen_uint(self.wmbe_done.into(), 29, 29) |
__gen_uint(self.cs_done.into(), 30, 30) |
__gen_uint(self.gam_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 Instdone2 {
fn from(input: &[u32; 1]) -> Self {
Instdone2 {
vf_done: __gen_unuint(input[0], 0, 0) != 0,
vs0_done: __gen_unuint(input[0], 1, 1) != 0,
gs_done: __gen_unuint(input[0], 2, 2) != 0,
cl_done: __gen_unuint(input[0], 3, 3) != 0,
sf_done: __gen_unuint(input[0], 4, 4) != 0,
vme_done: __gen_unuint(input[0], 5, 5) != 0,
pl_done: __gen_unuint(input[0], 6, 6) != 0,
so_done: __gen_unuint(input[0], 7, 7) != 0,
si_done: __gen_unuint(input[0], 8, 8) != 0,
dg_done: __gen_unuint(input[0], 9, 9) != 0,
ft_done: __gen_unuint(input[0], 10, 10) != 0,
dm_done: __gen_unuint(input[0], 11, 11) != 0,
sc_done: __gen_unuint(input[0], 12, 12) != 0,
fl_done: __gen_unuint(input[0], 13, 13) != 0,
qc_done: __gen_unuint(input[0], 14, 14) != 0,
svsm_done: __gen_unuint(input[0], 15, 15) != 0,
wmfe_done: __gen_unuint(input[0], 16, 16) != 0,
iz_done: __gen_unuint(input[0], 17, 17) != 0,
psd_done: __gen_unuint(input[0], 18, 18) != 0,
dap_done: __gen_unuint(input[0], 19, 19) != 0,
rcz_done: __gen_unuint(input[0], 20, 20) != 0,
vdi_done: __gen_unuint(input[0], 21, 21) != 0,
rcpbe_done: __gen_unuint(input[0], 22, 22) != 0,
rcpfe_done: __gen_unuint(input[0], 23, 23) != 0,
mt_done: __gen_unuint(input[0], 24, 24) != 0,
isc_done: __gen_unuint(input[0], 25, 25) != 0,
svg_done: __gen_unuint(input[0], 26, 26) != 0,
rcc_done: __gen_unuint(input[0], 27, 27) != 0,
svrw_done: __gen_unuint(input[0], 28, 28) != 0,
wmbe_done: __gen_unuint(input[0], 29, 29) != 0,
cs_done: __gen_unuint(input[0], 30, 30) != 0,
gam_done: __gen_unuint(input[0], 31, 31) != 0,
}
}
}
impl Deserialize for Instdone2 {
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 barrier_id: u32,
pub barrier_return_byte: u32,
pub barrier_return_grf_offset: 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;
}
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(),
barrier_id: Default::default(),
barrier_return_byte: Default::default(),
barrier_return_grf_offset: 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, 31);
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.barrier_id, 0, 3) |
__gen_uint(self.barrier_return_byte, 8, 15) |
__gen_uint(self.barrier_return_grf_offset, 24, 31);
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, 31) 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),
barrier_id: __gen_unuint(input[5], 0, 3),
barrier_return_byte: __gen_unuint(input[5], 8, 15),
barrier_return_grf_offset: __gen_unuint(input[5], 24, 31),
}
}
}
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 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 MediaGatewayState {
pub dword_length: u32,
pub subopcode: u32,
pub media_command_opcode: u32,
pub pipeline: u32,
pub command_type: u32,
pub barrier_threadcount: u32,
pub barrier_byte: u32,
pub barrierid: u32,
}
impl MediaGatewayState {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for MediaGatewayState {
fn default() -> Self {
MediaGatewayState {
dword_length: 0,
subopcode: 3,
media_command_opcode: 0,
pipeline: 2,
command_type: 3,
barrier_threadcount: Default::default(),
barrier_byte: Default::default(),
barrierid: Default::default(),
}
}
}
impl Serialize for MediaGatewayState {
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.barrier_threadcount, 0, 7) |
__gen_uint(self.barrier_byte, 8, 15) |
__gen_uint(self.barrierid, 16, 23);
}
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 MediaGatewayState {
fn from(input: &[u32; 2]) -> Self {
MediaGatewayState {
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),
barrier_threadcount: __gen_unuint(input[1], 0, 7),
barrier_byte: __gen_unuint(input[1], 8, 15),
barrierid: __gen_unuint(input[1], 16, 23),
}
}
}
impl Deserialize for MediaGatewayState {
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 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 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 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(),
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.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),
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 barrier_mask: u32,
pub thread_count_watermark: u32,
}
impl MediaStateFlush {
pub const DWORD_LENGTH: u32 = 2;
pub const NOT_WAITING: u32 = 0;
pub const WAITING: u32 = 1;
}
impl Default for MediaStateFlush {
fn default() -> Self {
MediaStateFlush {
dword_length: 0,
subopcode: 4,
media_command_opcode: 0,
pipeline: 2,
command_type: 3,
barrier_mask: Default::default(),
thread_count_watermark: 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.barrier_mask, 0, 15) |
__gen_uint(self.thread_count_watermark, 16, 23);
}
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),
barrier_mask: __gen_unuint(input[1], 0, 15),
thread_count_watermark: __gen_unuint(input[1], 16, 23),
}
}
}
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 fast_preempt: 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 PREEMPT_ONLY_PRT: 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(),
fast_preempt: 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.fast_preempt, 5, 5) |
__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,
fast_preempt: __gen_unuint(input[2], 5, 5),
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 cacheability_control: u32,
pub graphics_data_type_gfdt: u32,
}
impl MemoryObjectControlState {
pub const DWORD_LENGTH: u32 = 1;
}
impl Default for MemoryObjectControlState {
fn default() -> Self {
MemoryObjectControlState {
cacheability_control: 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.cacheability_control, 0, 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 {
cacheability_control: __gen_unuint(input[0], 0, 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 MfcAvcFqmState {
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 luma4x4_intra_invweightscale: [u32; 8],
pub cb4x4_intra_invweightscale: [u32; 8],
pub cr4x4_intra_invweightscale: [u32; 8],
pub luma4x4_inter_invweightscale: [u32; 6],
pub cb4x4_inter_invweightscale: [u32; 10],
pub cr4x4_inter_invweightscale: [u32; 8],
pub luma8x8_intra_invweightscale: [u32; 32],
pub luma8x8_inter_invweightscale: [u32; 32],
}
impl MfcAvcFqmState {
pub const DWORD_LENGTH: u32 = 113;
}
impl Default for MfcAvcFqmState {
fn default() -> Self {
MfcAvcFqmState {
dword_length: 111,
subopcode_b: 2,
subopcode_a: 2,
media_command_opcode: 1,
pipeline: 2,
command_type: 3,
luma4x4_intra_invweightscale: Default::default(),
cb4x4_intra_invweightscale: Default::default(),
cr4x4_intra_invweightscale: Default::default(),
luma4x4_inter_invweightscale: Default::default(),
cb4x4_inter_invweightscale: Default::default(),
cr4x4_inter_invweightscale: Default::default(),
luma8x8_intra_invweightscale: Default::default(),
luma8x8_inter_invweightscale: Default::default(),
}
}
}
impl Serialize for MfcAvcFqmState {
type Out = [u32; 113];
fn pack_into(&self, out: &mut [u32; 113]) {
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.luma4x4_intra_invweightscale[0], 0, 31);
out[2] = __gen_uint(self.luma4x4_intra_invweightscale[1], 0, 31);
out[3] = __gen_uint(self.luma4x4_intra_invweightscale[2], 0, 31);
out[4] = __gen_uint(self.luma4x4_intra_invweightscale[3], 0, 31);
out[5] = __gen_uint(self.luma4x4_intra_invweightscale[4], 0, 31);
out[6] = __gen_uint(self.luma4x4_intra_invweightscale[5], 0, 31);
out[7] = __gen_uint(self.luma4x4_intra_invweightscale[6], 0, 31);
out[8] = __gen_uint(self.luma4x4_intra_invweightscale[7], 0, 31);
out[9] = __gen_uint(self.cb4x4_intra_invweightscale[0], 0, 31);
out[10] = __gen_uint(self.cb4x4_intra_invweightscale[1], 0, 31);
out[11] = __gen_uint(self.cb4x4_intra_invweightscale[2], 0, 31);
out[12] = __gen_uint(self.cb4x4_intra_invweightscale[3], 0, 31);
out[13] = __gen_uint(self.cb4x4_intra_invweightscale[4], 0, 31);
out[14] = __gen_uint(self.cb4x4_intra_invweightscale[5], 0, 31);
out[15] = __gen_uint(self.cb4x4_intra_invweightscale[6], 0, 31);
out[16] = __gen_uint(self.cb4x4_intra_invweightscale[7], 0, 31);
out[17] = __gen_uint(self.cr4x4_intra_invweightscale[0], 0, 31);
out[18] = __gen_uint(self.cr4x4_intra_invweightscale[1], 0, 31);
out[19] = __gen_uint(self.cr4x4_intra_invweightscale[2], 0, 31);
out[20] = __gen_uint(self.cr4x4_intra_invweightscale[3], 0, 31);
out[21] = __gen_uint(self.cr4x4_intra_invweightscale[4], 0, 31);
out[22] = __gen_uint(self.cr4x4_intra_invweightscale[5], 0, 31);
out[23] = __gen_uint(self.cr4x4_intra_invweightscale[6], 0, 31);
out[24] = __gen_uint(self.cr4x4_intra_invweightscale[7], 0, 31);
out[25] = __gen_uint(self.luma4x4_inter_invweightscale[0], 0, 31);
out[26] = __gen_uint(self.luma4x4_inter_invweightscale[1], 0, 31);
out[27] = __gen_uint(self.luma4x4_inter_invweightscale[2], 0, 31);
out[28] = __gen_uint(self.luma4x4_inter_invweightscale[3], 0, 31);
out[29] = __gen_uint(self.luma4x4_inter_invweightscale[4], 0, 31);
out[30] = __gen_uint(self.luma4x4_inter_invweightscale[5], 0, 31);
out[31] = __gen_uint(self.cb4x4_inter_invweightscale[0], 0, 31);
out[32] = __gen_uint(self.cb4x4_inter_invweightscale[1], 0, 31);
out[33] = __gen_uint(self.cb4x4_inter_invweightscale[2], 0, 31);
out[34] = __gen_uint(self.cb4x4_inter_invweightscale[3], 0, 31);
out[35] = __gen_uint(self.cb4x4_inter_invweightscale[4], 0, 31);
out[36] = __gen_uint(self.cb4x4_inter_invweightscale[5], 0, 31);
out[37] = __gen_uint(self.cb4x4_inter_invweightscale[6], 0, 31);
out[38] = __gen_uint(self.cb4x4_inter_invweightscale[7], 0, 31);
out[39] = __gen_uint(self.cb4x4_inter_invweightscale[8], 0, 31);
out[40] = __gen_uint(self.cb4x4_inter_invweightscale[9], 0, 31);
out[41] = __gen_uint(self.cr4x4_inter_invweightscale[0], 0, 31);
out[42] = __gen_uint(self.cr4x4_inter_invweightscale[1], 0, 31);
out[43] = __gen_uint(self.cr4x4_inter_invweightscale[2], 0, 31);
out[44] = __gen_uint(self.cr4x4_inter_invweightscale[3], 0, 31);
out[45] = __gen_uint(self.cr4x4_inter_invweightscale[4], 0, 31);
out[46] = __gen_uint(self.cr4x4_inter_invweightscale[5], 0, 31);
out[47] = __gen_uint(self.cr4x4_inter_invweightscale[6], 0, 31);
out[48] = __gen_uint(self.cr4x4_inter_invweightscale[7], 0, 31);
out[49] = __gen_uint(self.luma8x8_intra_invweightscale[0], 0, 31);
out[50] = __gen_uint(self.luma8x8_intra_invweightscale[1], 0, 31);
out[51] = __gen_uint(self.luma8x8_intra_invweightscale[2], 0, 31);
out[52] = __gen_uint(self.luma8x8_intra_invweightscale[3], 0, 31);
out[53] = __gen_uint(self.luma8x8_intra_invweightscale[4], 0, 31);
out[54] = __gen_uint(self.luma8x8_intra_invweightscale[5], 0, 31);
out[55] = __gen_uint(self.luma8x8_intra_invweightscale[6], 0, 31);
out[56] = __gen_uint(self.luma8x8_intra_invweightscale[7], 0, 31);
out[57] = __gen_uint(self.luma8x8_intra_invweightscale[8], 0, 31);
out[58] = __gen_uint(self.luma8x8_intra_invweightscale[9], 0, 31);
out[59] = __gen_uint(self.luma8x8_intra_invweightscale[10], 0, 31);
out[60] = __gen_uint(self.luma8x8_intra_invweightscale[11], 0, 31);
out[61] = __gen_uint(self.luma8x8_intra_invweightscale[12], 0, 31);
out[62] = __gen_uint(self.luma8x8_intra_invweightscale[13], 0, 31);
out[63] = __gen_uint(self.luma8x8_intra_invweightscale[14], 0, 31);
out[64] = __gen_uint(self.luma8x8_intra_invweightscale[15], 0, 31);
out[65] = __gen_uint(self.luma8x8_intra_invweightscale[16], 0, 31);
out[66] = __gen_uint(self.luma8x8_intra_invweightscale[17], 0, 31);
out[67] = __gen_uint(self.luma8x8_intra_invweightscale[18], 0, 31);
out[68] = __gen_uint(self.luma8x8_intra_invweightscale[19], 0, 31);
out[69] = __gen_uint(self.luma8x8_intra_invweightscale[20], 0, 31);
out[70] = __gen_uint(self.luma8x8_intra_invweightscale[21], 0, 31);
out[71] = __gen_uint(self.luma8x8_intra_invweightscale[22], 0, 31);
out[72] = __gen_uint(self.luma8x8_intra_invweightscale[23], 0, 31);
out[73] = __gen_uint(self.luma8x8_intra_invweightscale[24], 0, 31);
out[74] = __gen_uint(self.luma8x8_intra_invweightscale[25], 0, 31);
out[75] = __gen_uint(self.luma8x8_intra_invweightscale[26], 0, 31);
out[76] = __gen_uint(self.luma8x8_intra_invweightscale[27], 0, 31);
out[77] = __gen_uint(self.luma8x8_intra_invweightscale[28], 0, 31);
out[78] = __gen_uint(self.luma8x8_intra_invweightscale[29], 0, 31);
out[79] = __gen_uint(self.luma8x8_intra_invweightscale[30], 0, 31);
out[80] = __gen_uint(self.luma8x8_intra_invweightscale[31], 0, 31);
out[81] = __gen_uint(self.luma8x8_inter_invweightscale[0], 0, 31);
out[82] = __gen_uint(self.luma8x8_inter_invweightscale[1], 0, 31);
out[83] = __gen_uint(self.luma8x8_inter_invweightscale[2], 0, 31);
out[84] = __gen_uint(self.luma8x8_inter_invweightscale[3], 0, 31);
out[85] = __gen_uint(self.luma8x8_inter_invweightscale[4], 0, 31);
out[86] = __gen_uint(self.luma8x8_inter_invweightscale[5], 0, 31);
out[87] = __gen_uint(self.luma8x8_inter_invweightscale[6], 0, 31);
out[88] = __gen_uint(self.luma8x8_inter_invweightscale[7], 0, 31);
out[89] = __gen_uint(self.luma8x8_inter_invweightscale[8], 0, 31);
out[90] = __gen_uint(self.luma8x8_inter_invweightscale[9], 0, 31);
out[91] = __gen_uint(self.luma8x8_inter_invweightscale[10], 0, 31);
out[92] = __gen_uint(self.luma8x8_inter_invweightscale[11], 0, 31);
out[93] = __gen_uint(self.luma8x8_inter_invweightscale[12], 0, 31);
out[94] = __gen_uint(self.luma8x8_inter_invweightscale[13], 0, 31);
out[95] = __gen_uint(self.luma8x8_inter_invweightscale[14], 0, 31);
out[96] = __gen_uint(self.luma8x8_inter_invweightscale[15], 0, 31);
out[97] = __gen_uint(self.luma8x8_inter_invweightscale[16], 0, 31);
out[98] = __gen_uint(self.luma8x8_inter_invweightscale[17], 0, 31);
out[99] = __gen_uint(self.luma8x8_inter_invweightscale[18], 0, 31);
out[100] = __gen_uint(self.luma8x8_inter_invweightscale[19], 0, 31);
out[101] = __gen_uint(self.luma8x8_inter_invweightscale[20], 0, 31);
out[102] = __gen_uint(self.luma8x8_inter_invweightscale[21], 0, 31);
out[103] = __gen_uint(self.luma8x8_inter_invweightscale[22], 0, 31);
out[104] = __gen_uint(self.luma8x8_inter_invweightscale[23], 0, 31);
out[105] = __gen_uint(self.luma8x8_inter_invweightscale[24], 0, 31);
out[106] = __gen_uint(self.luma8x8_inter_invweightscale[25], 0, 31);
out[107] = __gen_uint(self.luma8x8_inter_invweightscale[26], 0, 31);
out[108] = __gen_uint(self.luma8x8_inter_invweightscale[27], 0, 31);
out[109] = __gen_uint(self.luma8x8_inter_invweightscale[28], 0, 31);
out[110] = __gen_uint(self.luma8x8_inter_invweightscale[29], 0, 31);
out[111] = __gen_uint(self.luma8x8_inter_invweightscale[30], 0, 31);
out[112] = __gen_uint(self.luma8x8_inter_invweightscale[31], 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 113];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 113] as *const [u8; 452]) })
}
}
impl From<&[u32; 113]> for MfcAvcFqmState {
fn from(input: &[u32; 113]) -> Self {
MfcAvcFqmState {
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),
luma4x4_intra_invweightscale: [
__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)
],
cb4x4_intra_invweightscale: [
__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)
],
cr4x4_intra_invweightscale: [
__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)
],
luma4x4_inter_invweightscale: [
__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)
],
cb4x4_inter_invweightscale: [
__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)
],
cr4x4_inter_invweightscale: [
__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)
],
luma8x8_intra_invweightscale: [
__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)
],
luma8x8_inter_invweightscale: [
__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),
__gen_unuint(input[98], 0, 31),
__gen_unuint(input[99], 0, 31),
__gen_unuint(input[100], 0, 31),
__gen_unuint(input[101], 0, 31),
__gen_unuint(input[102], 0, 31),
__gen_unuint(input[103], 0, 31),
__gen_unuint(input[104], 0, 31),
__gen_unuint(input[105], 0, 31),
__gen_unuint(input[106], 0, 31),
__gen_unuint(input[107], 0, 31),
__gen_unuint(input[108], 0, 31),
__gen_unuint(input[109], 0, 31),
__gen_unuint(input[110], 0, 31),
__gen_unuint(input[111], 0, 31),
__gen_unuint(input[112], 0, 31)
],
}
}
}
impl Deserialize for MfcAvcFqmState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 113];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 113] as *mut [u8; 452]) })?;
Ok((&input).into())
}
}
pub struct MfcAvcPakInsertObject {
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 data_byte_offset: u32,
}
impl MfcAvcPakInsertObject {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for MfcAvcPakInsertObject {
fn default() -> Self {
MfcAvcPakInsertObject {
dword_length: 0,
subopcode_b: 8,
subopcode_a: 2,
media_command_opcode: 1,
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(),
data_byte_offset: Default::default(),
}
}
}
impl Serialize for MfcAvcPakInsertObject {
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.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 MfcAvcPakInsertObject {
fn from(input: &[u32; 2]) -> Self {
MfcAvcPakInsertObject {
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),
data_byte_offset: __gen_unuint(input[1], 16, 17),
}
}
}
impl Deserialize for MfcAvcPakInsertObject {
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 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],
}
impl MfcAvcPakObject {
pub const DWORD_LENGTH: u32 = 11;
}
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(),
}
}
}
impl Serialize for MfcAvcPakObject {
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.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);
}
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 MfcAvcPakObject {
fn from(input: &[u32; 11]) -> 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)
],
}
}
}
impl Deserialize for MfcAvcPakObject {
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 MfcStitchObject<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 last_dst_data_insert_command: bool,
pub last_src_header_data_insert_command: bool,
pub src_data_ending_bit_inclusion: u32,
pub src_data_starting_byte_offset: u32,
pub indirect_data_length: u32,
pub indirect_data_start_address: A,
}
impl<A: Addr + Default> MfcStitchObject<A> {
pub const DWORD_LENGTH: u32 = 4;
}
impl<A: Addr + Default> Default for MfcStitchObject<A> {
fn default() -> Self {
MfcStitchObject {
dword_length: Default::default(),
subopcode_b: 10,
subopcode_a: 2,
media_command_opcode: 1,
pipeline: 2,
command_type: 3,
last_dst_data_insert_command: Default::default(),
last_src_header_data_insert_command: Default::default(),
src_data_ending_bit_inclusion: Default::default(),
src_data_starting_byte_offset: Default::default(),
indirect_data_length: Default::default(),
indirect_data_start_address: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for MfcStitchObject<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);
out[1] = __gen_uint(self.last_dst_data_insert_command.into(), 1, 1) |
__gen_uint(self.last_src_header_data_insert_command.into(), 2, 2) |
__gen_uint(self.src_data_ending_bit_inclusion, 8, 13) |
__gen_uint(self.src_data_starting_byte_offset, 16, 17);
out[2] = __gen_uint(self.indirect_data_length, 0, 18);
let v3_address = self.indirect_data_start_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 MfcStitchObject<u64> {
fn from(input: &[u32; 4]) -> Self {
MfcStitchObject {
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),
last_dst_data_insert_command: __gen_unuint(input[1], 1, 1) != 0,
last_src_header_data_insert_command: __gen_unuint(input[1], 2, 2) != 0,
src_data_ending_bit_inclusion: __gen_unuint(input[1], 8, 13),
src_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 MfcStitchObject<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 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: [u32; 3],
}
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, 21);
let v2_address = self.indirect_bsd_data_start_address.combine(0);
out[2] = v2_address as u32;
out[3] = (v2_address >> 32) as u32;
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);
}
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, 21),
indirect_bsd_data_start_address: (__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)
],
}
}
}
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 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: 12,
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 MfdMpeg2BsdObject<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_data_length: u32,
pub indirect_data_start_address: A,
pub inline_data: [u32; 2],
}
impl<A: Addr + Default> MfdMpeg2BsdObject<A> {
pub const DWORD_LENGTH: u32 = 5;
}
impl<A: Addr + Default> Default for MfdMpeg2BsdObject<A> {
fn default() -> Self {
MfdMpeg2BsdObject {
dword_length: 3,
subopcode_b: 8,
subopcode_a: 1,
media_command_opcode: 3,
pipeline: 2,
command_type: 3,
indirect_data_length: Default::default(),
indirect_data_start_address: Default::default(),
inline_data: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for MfdMpeg2BsdObject<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);
out[1] = __gen_uint(self.indirect_data_length, 0, 16);
let v2_address = self.indirect_data_start_address.combine(0);
out[2] = v2_address as u32;
out[3] = (v2_address >> 32) as u32;
out[3] = __gen_uint(self.inline_data[0], 0, 31);
out[4] = __gen_uint(self.inline_data[1], 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 MfdMpeg2BsdObject<u64> {
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_data_length: __gen_unuint(input[1], 0, 16),
indirect_data_start_address: (__gen_unuint(input[2], 0, 28) as u64),
inline_data: [
__gen_unuint(input[3], 0, 31),
__gen_unuint(input[4], 0, 31)
],
}
}
}
impl Deserialize for MfdMpeg2BsdObject<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 MfdVc1BsdObject<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_data_length: u32,
pub indirect_data_start_address: A,
pub first_mb_bit_offset: u32,
pub next_slice_start_vertical_position: u32,
pub slice_start_vertical_position: u32,
}
impl<A: Addr + Default> MfdVc1BsdObject<A> {
pub const DWORD_LENGTH: u32 = 4;
}
impl<A: Addr + Default> Default for MfdVc1BsdObject<A> {
fn default() -> Self {
MfdVc1BsdObject {
dword_length: 2,
subopcode_b: 8,
subopcode_a: 1,
media_command_opcode: 2,
pipeline: 2,
command_type: 3,
indirect_data_length: Default::default(),
indirect_data_start_address: Default::default(),
first_mb_bit_offset: Default::default(),
next_slice_start_vertical_position: Default::default(),
slice_start_vertical_position: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for MfdVc1BsdObject<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);
out[1] = __gen_uint(self.indirect_data_length, 0, 21);
let v2_address = self.indirect_data_start_address.combine(0);
out[2] = v2_address as u32;
out[3] = (v2_address >> 32) as u32;
out[3] = __gen_uint(self.first_mb_bit_offset, 0, 2) |
__gen_uint(self.next_slice_start_vertical_position, 16, 23) |
__gen_uint(self.slice_start_vertical_position, 24, 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 MfdVc1BsdObject<u64> {
fn from(input: &[u32; 4]) -> 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_data_length: __gen_unuint(input[1], 0, 21),
indirect_data_start_address: (__gen_unuint(input[2], 0, 28) as u64),
first_mb_bit_offset: __gen_unuint(input[3], 0, 2),
next_slice_start_vertical_position: __gen_unuint(input[3], 16, 23),
slice_start_vertical_position: __gen_unuint(input[3], 24, 31),
}
}
}
impl Deserialize for MfdVc1BsdObject<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 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);
let v1 = __gen_uint(self.direct_mv_buffer_cacheability_control[0], 0, 1) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[0], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[0], 4, 5);
let v1_address = self.direct_mv_buffer_address[0].combine(v1);
out[1] = v1_address as u32;
out[2] = (v1_address >> 32) as u32;
let v2 = __gen_uint(self.direct_mv_buffer_cacheability_control[1], 0, 1) |
__gen_uint(self.direct_mv_buffer_graphics_data_type[1], 2, 2) |
__gen_uint(self.direct_mv_buffer_arbitration_priority_control[1], 4, 5);
let v2_address = self.direct_mv_buffer_address[1].combine(v2);
out[2] = v2_address as u32;
out[3] = (v2_address >> 32) as u32;
let v3 = __gen_uint(self.direct_mv_buffer_cacheability_control[2], 0, 1) |
__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 v3_address = self.direct_mv_buffer_address[2].combine(v3);
out[3] = v3_address as u32;
out[4] = (v3_address >> 32) as u32;
let v4 = __gen_uint(self.direct_mv_buffer_cacheability_control[3], 0, 1) |
__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 v4_address = self.direct_mv_buffer_address[3].combine(v4);
out[4] = v4_address as u32;
out[5] = (v4_address >> 32) as u32;
let v5 = __gen_uint(self.direct_mv_buffer_cacheability_control[4], 0, 1) |
__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 v5_address = self.direct_mv_buffer_address[4].combine(v5);
out[5] = v5_address as u32;
out[6] = (v5_address >> 32) as u32;
let v6 = __gen_uint(self.direct_mv_buffer_cacheability_control[5], 0, 1) |
__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 v6_address = self.direct_mv_buffer_address[5].combine(v6);
out[6] = v6_address as u32;
out[7] = (v6_address >> 32) as u32;
let v7 = __gen_uint(self.direct_mv_buffer_cacheability_control[6], 0, 1) |
__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 v7_address = self.direct_mv_buffer_address[6].combine(v7);
out[7] = v7_address as u32;
out[8] = (v7_address >> 32) as u32;
let v8 = __gen_uint(self.direct_mv_buffer_cacheability_control[7], 0, 1) |
__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 v8_address = self.direct_mv_buffer_address[7].combine(v8);
out[8] = v8_address as u32;
out[9] = (v8_address >> 32) as u32;
let v9 = __gen_uint(self.direct_mv_buffer_cacheability_control[8], 0, 1) |
__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 v9_address = self.direct_mv_buffer_address[8].combine(v9);
out[9] = v9_address as u32;
out[10] = (v9_address >> 32) as u32;
let v10 = __gen_uint(self.direct_mv_buffer_cacheability_control[9], 0, 1) |
__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 v10_address = self.direct_mv_buffer_address[9].combine(v10);
out[10] = v10_address as u32;
out[11] = (v10_address >> 32) as u32;
let v11 = __gen_uint(self.direct_mv_buffer_cacheability_control[10], 0, 1) |
__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 v11_address = self.direct_mv_buffer_address[10].combine(v11);
out[11] = v11_address as u32;
out[12] = (v11_address >> 32) as u32;
let v12 = __gen_uint(self.direct_mv_buffer_cacheability_control[11], 0, 1) |
__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 v12_address = self.direct_mv_buffer_address[11].combine(v12);
out[12] = v12_address as u32;
out[13] = (v12_address >> 32) as u32;
let v13 = __gen_uint(self.direct_mv_buffer_cacheability_control[12], 0, 1) |
__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 v13_address = self.direct_mv_buffer_address[12].combine(v13);
out[13] = v13_address as u32;
out[14] = (v13_address >> 32) as u32;
let v14 = __gen_uint(self.direct_mv_buffer_cacheability_control[13], 0, 1) |
__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 v14_address = self.direct_mv_buffer_address[13].combine(v14);
out[14] = v14_address as u32;
out[15] = (v14_address >> 32) as u32;
let v15 = __gen_uint(self.direct_mv_buffer_cacheability_control[14], 0, 1) |
__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 v15_address = self.direct_mv_buffer_address[14].combine(v15);
out[15] = v15_address as u32;
out[16] = (v15_address >> 32) as u32;
let v16 = __gen_uint(self.direct_mv_buffer_cacheability_control[15], 0, 1) |
__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 v16_address = self.direct_mv_buffer_address[15].combine(v16);
out[16] = v16_address as u32;
out[17] = (v16_address >> 32) as u32;
let v17 = __gen_uint(self.direct_mv_buffer_cacheability_control[16], 0, 1) |
__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 v17_address = self.direct_mv_buffer_address[16].combine(v17);
out[17] = v17_address as u32;
out[18] = (v17_address >> 32) as u32;
let v18 = __gen_uint(self.direct_mv_buffer_cacheability_control[17], 0, 1) |
__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 v18_address = self.direct_mv_buffer_address[17].combine(v18);
out[18] = v18_address as u32;
out[19] = (v18_address >> 32) as u32;
let v19 = __gen_uint(self.direct_mv_buffer_cacheability_control[18], 0, 1) |
__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 v19_address = self.direct_mv_buffer_address[18].combine(v19);
out[19] = v19_address as u32;
out[20] = (v19_address >> 32) as u32;
let v20 = __gen_uint(self.direct_mv_buffer_cacheability_control[19], 0, 1) |
__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 v20_address = self.direct_mv_buffer_address[19].combine(v20);
out[20] = v20_address as u32;
out[21] = (v20_address >> 32) as u32;
let v21 = __gen_uint(self.direct_mv_buffer_cacheability_control[20], 0, 1) |
__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 v21_address = self.direct_mv_buffer_address[20].combine(v21);
out[21] = v21_address as u32;
out[22] = (v21_address >> 32) as u32;
let v22 = __gen_uint(self.direct_mv_buffer_cacheability_control[21], 0, 1) |
__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 v22_address = self.direct_mv_buffer_address[21].combine(v22);
out[22] = v22_address as u32;
out[23] = (v22_address >> 32) as u32;
let v23 = __gen_uint(self.direct_mv_buffer_cacheability_control[22], 0, 1) |
__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 v23_address = self.direct_mv_buffer_address[22].combine(v23);
out[23] = v23_address as u32;
out[24] = (v23_address >> 32) as u32;
let v24 = __gen_uint(self.direct_mv_buffer_cacheability_control[23], 0, 1) |
__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 v24_address = self.direct_mv_buffer_address[23].combine(v24);
out[24] = v24_address as u32;
out[25] = (v24_address >> 32) as u32;
let v25 = __gen_uint(self.direct_mv_buffer_cacheability_control[24], 0, 1) |
__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 v25_address = self.direct_mv_buffer_address[24].combine(v25);
out[25] = v25_address as u32;
out[26] = (v25_address >> 32) as u32;
let v26 = __gen_uint(self.direct_mv_buffer_cacheability_control[25], 0, 1) |
__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 v26_address = self.direct_mv_buffer_address[25].combine(v26);
out[26] = v26_address as u32;
out[27] = (v26_address >> 32) as u32;
let v27 = __gen_uint(self.direct_mv_buffer_cacheability_control[26], 0, 1) |
__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 v27_address = self.direct_mv_buffer_address[26].combine(v27);
out[27] = v27_address as u32;
out[28] = (v27_address >> 32) as u32;
let v28 = __gen_uint(self.direct_mv_buffer_cacheability_control[27], 0, 1) |
__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 v28_address = self.direct_mv_buffer_address[27].combine(v28);
out[28] = v28_address as u32;
out[29] = (v28_address >> 32) as u32;
let v29 = __gen_uint(self.direct_mv_buffer_cacheability_control[28], 0, 1) |
__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 v29_address = self.direct_mv_buffer_address[28].combine(v29);
out[29] = v29_address as u32;
out[30] = (v29_address >> 32) as u32;
let v30 = __gen_uint(self.direct_mv_buffer_cacheability_control[29], 0, 1) |
__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 v30_address = self.direct_mv_buffer_address[29].combine(v30);
out[30] = v30_address as u32;
out[31] = (v30_address >> 32) as u32;
let v31 = __gen_uint(self.direct_mv_buffer_cacheability_control[30], 0, 1) |
__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 v31_address = self.direct_mv_buffer_address[30].combine(v31);
out[31] = v31_address as u32;
out[32] = (v31_address >> 32) as u32;
let v32 = __gen_uint(self.direct_mv_buffer_cacheability_control[31], 0, 1) |
__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 v32_address = self.direct_mv_buffer_address[31].combine(v32);
out[32] = v32_address as u32;
out[33] = (v32_address >> 32) as u32;
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;
out[35] = __gen_uint(self.poc_list[0], 0, 31);
out[36] = __gen_uint(self.poc_list[1], 0, 31);
out[37] = __gen_uint(self.poc_list[2], 0, 31);
out[38] = __gen_uint(self.poc_list[3], 0, 31);
out[39] = __gen_uint(self.poc_list[4], 0, 31);
out[40] = __gen_uint(self.poc_list[5], 0, 31);
out[41] = __gen_uint(self.poc_list[6], 0, 31);
out[42] = __gen_uint(self.poc_list[7], 0, 31);
out[43] = __gen_uint(self.poc_list[8], 0, 31);
out[44] = __gen_uint(self.poc_list[9], 0, 31);
out[45] = __gen_uint(self.poc_list[10], 0, 31);
out[46] = __gen_uint(self.poc_list[11], 0, 31);
out[47] = __gen_uint(self.poc_list[12], 0, 31);
out[48] = __gen_uint(self.poc_list[13], 0, 31);
out[49] = __gen_uint(self.poc_list[14], 0, 31);
out[50] = __gen_uint(self.poc_list[15], 0, 31);
out[51] = __gen_uint(self.poc_list[16], 0, 31);
out[52] = __gen_uint(self.poc_list[17], 0, 31);
out[53] = __gen_uint(self.poc_list[18], 0, 31);
out[54] = __gen_uint(self.poc_list[19], 0, 31);
out[55] = __gen_uint(self.poc_list[20], 0, 31);
out[56] = __gen_uint(self.poc_list[21], 0, 31);
out[57] = __gen_uint(self.poc_list[22], 0, 31);
out[58] = __gen_uint(self.poc_list[23], 0, 31);
out[59] = __gen_uint(self.poc_list[24], 0, 31);
out[60] = __gen_uint(self.poc_list[25], 0, 31);
out[61] = __gen_uint(self.poc_list[26], 0, 31);
out[62] = __gen_uint(self.poc_list[27], 0, 31);
out[63] = __gen_uint(self.poc_list[28], 0, 31);
out[64] = __gen_uint(self.poc_list[29], 0, 31);
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[1], 6, 31) as u64) << 6,
(__gen_unuint(input[2], 6, 31) as u64) << 6,
(__gen_unuint(input[3], 6, 31) as u64) << 6,
(__gen_unuint(input[4], 6, 31) as u64) << 6,
(__gen_unuint(input[5], 6, 31) as u64) << 6,
(__gen_unuint(input[6], 6, 31) as u64) << 6,
(__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,
(__gen_unuint(input[23], 6, 31) as u64) << 6,
(__gen_unuint(input[24], 6, 31) as u64) << 6,
(__gen_unuint(input[25], 6, 31) as u64) << 6,
(__gen_unuint(input[26], 6, 31) as u64) << 6,
(__gen_unuint(input[27], 6, 31) as u64) << 6,
(__gen_unuint(input[28], 6, 31) as u64) << 6,
(__gen_unuint(input[29], 6, 31) as u64) << 6,
(__gen_unuint(input[30], 6, 31) as u64) << 6,
(__gen_unuint(input[31], 6, 31) as u64) << 6,
(__gen_unuint(input[32], 6, 31) as u64) << 6
],
direct_mv_buffer_arbitration_priority_control: [
__gen_unuint(input[1], 4, 5),
__gen_unuint(input[2], 4, 5),
__gen_unuint(input[3], 4, 5),
__gen_unuint(input[4], 4, 5),
__gen_unuint(input[5], 4, 5),
__gen_unuint(input[6], 4, 5),
__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),
__gen_unuint(input[23], 4, 5),
__gen_unuint(input[24], 4, 5),
__gen_unuint(input[25], 4, 5),
__gen_unuint(input[26], 4, 5),
__gen_unuint(input[27], 4, 5),
__gen_unuint(input[28], 4, 5),
__gen_unuint(input[29], 4, 5),
__gen_unuint(input[30], 4, 5),
__gen_unuint(input[31], 4, 5),
__gen_unuint(input[32], 4, 5)
],
direct_mv_buffer_graphics_data_type: [
__gen_unuint(input[1], 2, 2),
__gen_unuint(input[2], 2, 2),
__gen_unuint(input[3], 2, 2),
__gen_unuint(input[4], 2, 2),
__gen_unuint(input[5], 2, 2),
__gen_unuint(input[6], 2, 2),
__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),
__gen_unuint(input[23], 2, 2),
__gen_unuint(input[24], 2, 2),
__gen_unuint(input[25], 2, 2),
__gen_unuint(input[26], 2, 2),
__gen_unuint(input[27], 2, 2),
__gen_unuint(input[28], 2, 2),
__gen_unuint(input[29], 2, 2),
__gen_unuint(input[30], 2, 2),
__gen_unuint(input[31], 2, 2),
__gen_unuint(input[32], 2, 2)
],
direct_mv_buffer_cacheability_control: [
__gen_unuint(input[1], 0, 1),
__gen_unuint(input[2], 0, 1),
__gen_unuint(input[3], 0, 1),
__gen_unuint(input[4], 0, 1),
__gen_unuint(input[5], 0, 1),
__gen_unuint(input[6], 0, 1),
__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),
__gen_unuint(input[23], 0, 1),
__gen_unuint(input[24], 0, 1),
__gen_unuint(input[25], 0, 1),
__gen_unuint(input[26], 0, 1),
__gen_unuint(input[27], 0, 1),
__gen_unuint(input[28], 0, 1),
__gen_unuint(input[29], 0, 1),
__gen_unuint(input[30], 0, 1),
__gen_unuint(input[31], 0, 1),
__gen_unuint(input[32], 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 current_decoded_image_frame_store_id: u32,
pub image_structure: u32,
pub qm_present: bool,
pub monochrome_pwt_decoding_mode: bool,
pub inter_mb_conformance: bool,
pub intra_mb_conformance: bool,
pub second_chroma_qp_offset: u32,
pub field_picture: 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: bool,
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 inter_mb_force_cbp_to_zero_control: bool,
pub frame_size_rate_control: 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: 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: u32,
pub frame_bitrate_max: u32,
pub frame_bitrate_max_unit: u32,
pub frame_bitrate_min_delta: u32,
pub frame_bitrate_max_delta: u32,
}
impl MfxAvcImgState {
pub const DWORD_LENGTH: u32 = 13;
pub const BOTTOM_FIELD_PICTURE: u32 = 3;
pub const FRAME_PICTURE: u32 = 0;
pub const INVALID_NOT_ALLOWED: u32 = 2;
pub const MONOCHROME_PICTURE: u32 = 0;
pub const TOP_FIELD_PICTURE: u32 = 1;
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: 11,
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(),
current_decoded_image_frame_store_id: Default::default(),
image_structure: Default::default(),
qm_present: Default::default(),
monochrome_pwt_decoding_mode: Default::default(),
inter_mb_conformance: Default::default(),
intra_mb_conformance: Default::default(),
second_chroma_qp_offset: Default::default(),
field_picture: 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: 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(),
inter_mb_force_cbp_to_zero_control: Default::default(),
frame_size_rate_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: Default::default(),
frame_bitrate_max: Default::default(),
frame_bitrate_max_unit: Default::default(),
frame_bitrate_min_delta: Default::default(),
frame_bitrate_max_delta: Default::default(),
}
}
}
impl Serialize for MfxAvcImgState {
type Out = [u32; 13];
fn pack_into(&self, out: &mut [u32; 13]) {
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.current_decoded_image_frame_store_id, 0, 7) |
__gen_uint(self.image_structure, 8, 9) |
__gen_uint(self.qm_present.into(), 10, 10) |
__gen_uint(self.monochrome_pwt_decoding_mode.into(), 12, 12) |
__gen_uint(self.inter_mb_conformance.into(), 13, 13) |
__gen_uint(self.intra_mb_conformance.into(), 14, 14) |
__gen_uint(self.second_chroma_qp_offset, 24, 28);
out[4] = __gen_uint(self.field_picture.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.into(), 7, 7) |
__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.inter_mb_force_cbp_to_zero_control.into(), 12, 12) |
__gen_uint(self.frame_size_rate_control.into(), 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, 11) |
__gen_uint(self.frame_bitrate_min_unit, 15, 15) |
__gen_uint(self.frame_bitrate_max, 16, 27) |
__gen_uint(self.frame_bitrate_max_unit, 31, 31);
out[11] = __gen_uint(self.frame_bitrate_min_delta, 0, 11) |
__gen_uint(self.frame_bitrate_max_delta, 16, 27);
out[12] = 0;
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 13];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 13] as *const [u8; 52]) })
}
}
impl From<&[u32; 13]> for MfxAvcImgState {
fn from(input: &[u32; 13]) -> 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),
current_decoded_image_frame_store_id: __gen_unuint(input[3], 0, 7),
image_structure: __gen_unuint(input[3], 8, 9),
qm_present: __gen_unuint(input[3], 10, 10) != 0,
monochrome_pwt_decoding_mode: __gen_unuint(input[3], 12, 12) != 0,
inter_mb_conformance: __gen_unuint(input[3], 13, 13) != 0,
intra_mb_conformance: __gen_unuint(input[3], 14, 14) != 0,
second_chroma_qp_offset: __gen_unuint(input[3], 24, 28),
field_picture: __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: __gen_unuint(input[4], 7, 7) != 0,
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,
inter_mb_force_cbp_to_zero_control: __gen_unuint(input[5], 12, 12) != 0,
frame_size_rate_control: __gen_unuint(input[5], 16, 16) != 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)) 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, 11),
frame_bitrate_min_unit: __gen_unuint(input[10], 15, 15),
frame_bitrate_max: __gen_unuint(input[10], 16, 27),
frame_bitrate_max_unit: __gen_unuint(input[10], 31, 31),
frame_bitrate_min_delta: __gen_unuint(input[11], 0, 11),
frame_bitrate_max_delta: __gen_unuint(input[11], 16, 27),
}
}
}
impl Deserialize for MfxAvcImgState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 13];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 13] as *mut [u8; 52]) })?;
Ok((&input).into())
}
}
pub struct MfxAvcQmState {
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 qm_list_present_flags_for_the_current_slice: u32,
pub use_built_in_default_qm_flags_for_the_current_slice: u32,
pub luma4x4_intra_weight_scale: [u32; 4],
pub cb4x4_intra_weight_scale: [u32; 4],
pub cr4x4_intra_weight_scale: [u32; 4],
pub luma4x4_inter_weight_scale: [u32; 4],
pub cb4x4_inter_weight_scale: [u32; 4],
pub cr4x4_inter_weight_scale: [u32; 4],
pub luma8x8_intra_weight_scale: [u8; 64],
pub luma8x8_inter_weight_scale: [u8; 64],
}
impl MfxAvcQmState {
pub const DWORD_LENGTH: u32 = 58;
}
impl Default for MfxAvcQmState {
fn default() -> Self {
MfxAvcQmState {
dword_length: 0,
subopcode_b: 1,
subopcode_a: 0,
media_command_opcode: 1,
pipeline: 2,
command_type: 3,
qm_list_present_flags_for_the_current_slice: Default::default(),
use_built_in_default_qm_flags_for_the_current_slice: Default::default(),
luma4x4_intra_weight_scale: Default::default(),
cb4x4_intra_weight_scale: Default::default(),
cr4x4_intra_weight_scale: Default::default(),
luma4x4_inter_weight_scale: Default::default(),
cb4x4_inter_weight_scale: Default::default(),
cr4x4_inter_weight_scale: Default::default(),
luma8x8_intra_weight_scale: [0; 64],
luma8x8_inter_weight_scale: [0; 64],
}
}
}
impl Serialize for MfxAvcQmState {
type Out = [u32; 58];
fn pack_into(&self, out: &mut [u32; 58]) {
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.qm_list_present_flags_for_the_current_slice, 0, 7) |
__gen_uint(self.use_built_in_default_qm_flags_for_the_current_slice, 8, 15);
out[2] = __gen_uint(self.luma4x4_intra_weight_scale[0], 0, 31);
out[3] = __gen_uint(self.luma4x4_intra_weight_scale[1], 0, 31);
out[4] = __gen_uint(self.luma4x4_intra_weight_scale[2], 0, 31);
out[5] = __gen_uint(self.luma4x4_intra_weight_scale[3], 0, 31);
out[6] = __gen_uint(self.cb4x4_intra_weight_scale[0], 0, 31);
out[7] = __gen_uint(self.cb4x4_intra_weight_scale[1], 0, 31);
out[8] = __gen_uint(self.cb4x4_intra_weight_scale[2], 0, 31);
out[9] = __gen_uint(self.cb4x4_intra_weight_scale[3], 0, 31);
out[10] = __gen_uint(self.cr4x4_intra_weight_scale[0], 0, 31);
out[11] = __gen_uint(self.cr4x4_intra_weight_scale[1], 0, 31);
out[12] = __gen_uint(self.cr4x4_intra_weight_scale[2], 0, 31);
out[13] = __gen_uint(self.cr4x4_intra_weight_scale[3], 0, 31);
out[14] = __gen_uint(self.luma4x4_inter_weight_scale[0], 0, 31);
out[15] = __gen_uint(self.luma4x4_inter_weight_scale[1], 0, 31);
out[16] = __gen_uint(self.luma4x4_inter_weight_scale[2], 0, 31);
out[17] = __gen_uint(self.luma4x4_inter_weight_scale[3], 0, 31);
out[18] = __gen_uint(self.cb4x4_inter_weight_scale[0], 0, 31);
out[19] = __gen_uint(self.cb4x4_inter_weight_scale[1], 0, 31);
out[20] = __gen_uint(self.cb4x4_inter_weight_scale[2], 0, 31);
out[21] = __gen_uint(self.cb4x4_inter_weight_scale[3], 0, 31);
out[22] = __gen_uint(self.cr4x4_inter_weight_scale[0], 0, 31);
out[23] = __gen_uint(self.cr4x4_inter_weight_scale[1], 0, 31);
out[24] = __gen_uint(self.cr4x4_inter_weight_scale[2], 0, 31);
out[25] = __gen_uint(self.cr4x4_inter_weight_scale[3], 0, 31);
out[26] = __gen_uint(self.luma8x8_intra_weight_scale[0].into(), 0, 7) |
__gen_uint(self.luma8x8_intra_weight_scale[1].into(), 8, 15) |
__gen_uint(self.luma8x8_intra_weight_scale[2].into(), 16, 23) |
__gen_uint(self.luma8x8_intra_weight_scale[3].into(), 24, 31);
out[27] = __gen_uint(self.luma8x8_intra_weight_scale[4].into(), 0, 7) |
__gen_uint(self.luma8x8_intra_weight_scale[5].into(), 8, 15) |
__gen_uint(self.luma8x8_intra_weight_scale[6].into(), 16, 23) |
__gen_uint(self.luma8x8_intra_weight_scale[7].into(), 24, 31);
out[28] = __gen_uint(self.luma8x8_intra_weight_scale[8].into(), 0, 7) |
__gen_uint(self.luma8x8_intra_weight_scale[9].into(), 8, 15) |
__gen_uint(self.luma8x8_intra_weight_scale[10].into(), 16, 23) |
__gen_uint(self.luma8x8_intra_weight_scale[11].into(), 24, 31);
out[29] = __gen_uint(self.luma8x8_intra_weight_scale[12].into(), 0, 7) |
__gen_uint(self.luma8x8_intra_weight_scale[13].into(), 8, 15) |
__gen_uint(self.luma8x8_intra_weight_scale[14].into(), 16, 23) |
__gen_uint(self.luma8x8_intra_weight_scale[15].into(), 24, 31);
out[30] = __gen_uint(self.luma8x8_intra_weight_scale[16].into(), 0, 7) |
__gen_uint(self.luma8x8_intra_weight_scale[17].into(), 8, 15) |
__gen_uint(self.luma8x8_intra_weight_scale[18].into(), 16, 23) |
__gen_uint(self.luma8x8_intra_weight_scale[19].into(), 24, 31);
out[31] = __gen_uint(self.luma8x8_intra_weight_scale[20].into(), 0, 7) |
__gen_uint(self.luma8x8_intra_weight_scale[21].into(), 8, 15) |
__gen_uint(self.luma8x8_intra_weight_scale[22].into(), 16, 23) |
__gen_uint(self.luma8x8_intra_weight_scale[23].into(), 24, 31);
out[32] = __gen_uint(self.luma8x8_intra_weight_scale[24].into(), 0, 7) |
__gen_uint(self.luma8x8_intra_weight_scale[25].into(), 8, 15) |
__gen_uint(self.luma8x8_intra_weight_scale[26].into(), 16, 23) |
__gen_uint(self.luma8x8_intra_weight_scale[27].into(), 24, 31);
out[33] = __gen_uint(self.luma8x8_intra_weight_scale[28].into(), 0, 7) |
__gen_uint(self.luma8x8_intra_weight_scale[29].into(), 8, 15) |
__gen_uint(self.luma8x8_intra_weight_scale[30].into(), 16, 23) |
__gen_uint(self.luma8x8_intra_weight_scale[31].into(), 24, 31);
out[34] = __gen_uint(self.luma8x8_intra_weight_scale[32].into(), 0, 7) |
__gen_uint(self.luma8x8_intra_weight_scale[33].into(), 8, 15) |
__gen_uint(self.luma8x8_intra_weight_scale[34].into(), 16, 23) |
__gen_uint(self.luma8x8_intra_weight_scale[35].into(), 24, 31);
out[35] = __gen_uint(self.luma8x8_intra_weight_scale[36].into(), 0, 7) |
__gen_uint(self.luma8x8_intra_weight_scale[37].into(), 8, 15) |
__gen_uint(self.luma8x8_intra_weight_scale[38].into(), 16, 23) |
__gen_uint(self.luma8x8_intra_weight_scale[39].into(), 24, 31);
out[36] = __gen_uint(self.luma8x8_intra_weight_scale[40].into(), 0, 7) |
__gen_uint(self.luma8x8_intra_weight_scale[41].into(), 8, 15) |
__gen_uint(self.luma8x8_intra_weight_scale[42].into(), 16, 23) |
__gen_uint(self.luma8x8_intra_weight_scale[43].into(), 24, 31);
out[37] = __gen_uint(self.luma8x8_intra_weight_scale[44].into(), 0, 7) |
__gen_uint(self.luma8x8_intra_weight_scale[45].into(), 8, 15) |
__gen_uint(self.luma8x8_intra_weight_scale[46].into(), 16, 23) |
__gen_uint(self.luma8x8_intra_weight_scale[47].into(), 24, 31);
out[38] = __gen_uint(self.luma8x8_intra_weight_scale[48].into(), 0, 7) |
__gen_uint(self.luma8x8_intra_weight_scale[49].into(), 8, 15) |
__gen_uint(self.luma8x8_intra_weight_scale[50].into(), 16, 23) |
__gen_uint(self.luma8x8_intra_weight_scale[51].into(), 24, 31);
out[39] = __gen_uint(self.luma8x8_intra_weight_scale[52].into(), 0, 7) |
__gen_uint(self.luma8x8_intra_weight_scale[53].into(), 8, 15) |
__gen_uint(self.luma8x8_intra_weight_scale[54].into(), 16, 23) |
__gen_uint(self.luma8x8_intra_weight_scale[55].into(), 24, 31);
out[40] = __gen_uint(self.luma8x8_intra_weight_scale[56].into(), 0, 7) |
__gen_uint(self.luma8x8_intra_weight_scale[57].into(), 8, 15) |
__gen_uint(self.luma8x8_intra_weight_scale[58].into(), 16, 23) |
__gen_uint(self.luma8x8_intra_weight_scale[59].into(), 24, 31);
out[41] = __gen_uint(self.luma8x8_intra_weight_scale[60].into(), 0, 7) |
__gen_uint(self.luma8x8_intra_weight_scale[61].into(), 8, 15) |
__gen_uint(self.luma8x8_intra_weight_scale[62].into(), 16, 23) |
__gen_uint(self.luma8x8_intra_weight_scale[63].into(), 24, 31);
out[42] = __gen_uint(self.luma8x8_inter_weight_scale[0].into(), 0, 7) |
__gen_uint(self.luma8x8_inter_weight_scale[1].into(), 8, 15) |
__gen_uint(self.luma8x8_inter_weight_scale[2].into(), 16, 23) |
__gen_uint(self.luma8x8_inter_weight_scale[3].into(), 24, 31);
out[43] = __gen_uint(self.luma8x8_inter_weight_scale[4].into(), 0, 7) |
__gen_uint(self.luma8x8_inter_weight_scale[5].into(), 8, 15) |
__gen_uint(self.luma8x8_inter_weight_scale[6].into(), 16, 23) |
__gen_uint(self.luma8x8_inter_weight_scale[7].into(), 24, 31);
out[44] = __gen_uint(self.luma8x8_inter_weight_scale[8].into(), 0, 7) |
__gen_uint(self.luma8x8_inter_weight_scale[9].into(), 8, 15) |
__gen_uint(self.luma8x8_inter_weight_scale[10].into(), 16, 23) |
__gen_uint(self.luma8x8_inter_weight_scale[11].into(), 24, 31);
out[45] = __gen_uint(self.luma8x8_inter_weight_scale[12].into(), 0, 7) |
__gen_uint(self.luma8x8_inter_weight_scale[13].into(), 8, 15) |
__gen_uint(self.luma8x8_inter_weight_scale[14].into(), 16, 23) |
__gen_uint(self.luma8x8_inter_weight_scale[15].into(), 24, 31);
out[46] = __gen_uint(self.luma8x8_inter_weight_scale[16].into(), 0, 7) |
__gen_uint(self.luma8x8_inter_weight_scale[17].into(), 8, 15) |
__gen_uint(self.luma8x8_inter_weight_scale[18].into(), 16, 23) |
__gen_uint(self.luma8x8_inter_weight_scale[19].into(), 24, 31);
out[47] = __gen_uint(self.luma8x8_inter_weight_scale[20].into(), 0, 7) |
__gen_uint(self.luma8x8_inter_weight_scale[21].into(), 8, 15) |
__gen_uint(self.luma8x8_inter_weight_scale[22].into(), 16, 23) |
__gen_uint(self.luma8x8_inter_weight_scale[23].into(), 24, 31);
out[48] = __gen_uint(self.luma8x8_inter_weight_scale[24].into(), 0, 7) |
__gen_uint(self.luma8x8_inter_weight_scale[25].into(), 8, 15) |
__gen_uint(self.luma8x8_inter_weight_scale[26].into(), 16, 23) |
__gen_uint(self.luma8x8_inter_weight_scale[27].into(), 24, 31);
out[49] = __gen_uint(self.luma8x8_inter_weight_scale[28].into(), 0, 7) |
__gen_uint(self.luma8x8_inter_weight_scale[29].into(), 8, 15) |
__gen_uint(self.luma8x8_inter_weight_scale[30].into(), 16, 23) |
__gen_uint(self.luma8x8_inter_weight_scale[31].into(), 24, 31);
out[50] = __gen_uint(self.luma8x8_inter_weight_scale[32].into(), 0, 7) |
__gen_uint(self.luma8x8_inter_weight_scale[33].into(), 8, 15) |
__gen_uint(self.luma8x8_inter_weight_scale[34].into(), 16, 23) |
__gen_uint(self.luma8x8_inter_weight_scale[35].into(), 24, 31);
out[51] = __gen_uint(self.luma8x8_inter_weight_scale[36].into(), 0, 7) |
__gen_uint(self.luma8x8_inter_weight_scale[37].into(), 8, 15) |
__gen_uint(self.luma8x8_inter_weight_scale[38].into(), 16, 23) |
__gen_uint(self.luma8x8_inter_weight_scale[39].into(), 24, 31);
out[52] = __gen_uint(self.luma8x8_inter_weight_scale[40].into(), 0, 7) |
__gen_uint(self.luma8x8_inter_weight_scale[41].into(), 8, 15) |
__gen_uint(self.luma8x8_inter_weight_scale[42].into(), 16, 23) |
__gen_uint(self.luma8x8_inter_weight_scale[43].into(), 24, 31);
out[53] = __gen_uint(self.luma8x8_inter_weight_scale[44].into(), 0, 7) |
__gen_uint(self.luma8x8_inter_weight_scale[45].into(), 8, 15) |
__gen_uint(self.luma8x8_inter_weight_scale[46].into(), 16, 23) |
__gen_uint(self.luma8x8_inter_weight_scale[47].into(), 24, 31);
out[54] = __gen_uint(self.luma8x8_inter_weight_scale[48].into(), 0, 7) |
__gen_uint(self.luma8x8_inter_weight_scale[49].into(), 8, 15) |
__gen_uint(self.luma8x8_inter_weight_scale[50].into(), 16, 23) |
__gen_uint(self.luma8x8_inter_weight_scale[51].into(), 24, 31);
out[55] = __gen_uint(self.luma8x8_inter_weight_scale[52].into(), 0, 7) |
__gen_uint(self.luma8x8_inter_weight_scale[53].into(), 8, 15) |
__gen_uint(self.luma8x8_inter_weight_scale[54].into(), 16, 23) |
__gen_uint(self.luma8x8_inter_weight_scale[55].into(), 24, 31);
out[56] = __gen_uint(self.luma8x8_inter_weight_scale[56].into(), 0, 7) |
__gen_uint(self.luma8x8_inter_weight_scale[57].into(), 8, 15) |
__gen_uint(self.luma8x8_inter_weight_scale[58].into(), 16, 23) |
__gen_uint(self.luma8x8_inter_weight_scale[59].into(), 24, 31);
out[57] = __gen_uint(self.luma8x8_inter_weight_scale[60].into(), 0, 7) |
__gen_uint(self.luma8x8_inter_weight_scale[61].into(), 8, 15) |
__gen_uint(self.luma8x8_inter_weight_scale[62].into(), 16, 23) |
__gen_uint(self.luma8x8_inter_weight_scale[63].into(), 24, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 58];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 58] as *const [u8; 232]) })
}
}
impl From<&[u32; 58]> for MfxAvcQmState {
fn from(input: &[u32; 58]) -> Self {
MfxAvcQmState {
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),
qm_list_present_flags_for_the_current_slice: __gen_unuint(input[1], 0, 7),
use_built_in_default_qm_flags_for_the_current_slice: __gen_unuint(input[1], 8, 15),
luma4x4_intra_weight_scale: [
__gen_unuint(input[2], 0, 31),
__gen_unuint(input[3], 0, 31),
__gen_unuint(input[4], 0, 31),
__gen_unuint(input[5], 0, 31)
],
cb4x4_intra_weight_scale: [
__gen_unuint(input[6], 0, 31),
__gen_unuint(input[7], 0, 31),
__gen_unuint(input[8], 0, 31),
__gen_unuint(input[9], 0, 31)
],
cr4x4_intra_weight_scale: [
__gen_unuint(input[10], 0, 31),
__gen_unuint(input[11], 0, 31),
__gen_unuint(input[12], 0, 31),
__gen_unuint(input[13], 0, 31)
],
luma4x4_inter_weight_scale: [
__gen_unuint(input[14], 0, 31),
__gen_unuint(input[15], 0, 31),
__gen_unuint(input[16], 0, 31),
__gen_unuint(input[17], 0, 31)
],
cb4x4_inter_weight_scale: [
__gen_unuint(input[18], 0, 31),
__gen_unuint(input[19], 0, 31),
__gen_unuint(input[20], 0, 31),
__gen_unuint(input[21], 0, 31)
],
cr4x4_inter_weight_scale: [
__gen_unuint(input[22], 0, 31),
__gen_unuint(input[23], 0, 31),
__gen_unuint(input[24], 0, 31),
__gen_unuint(input[25], 0, 31)
],
luma8x8_intra_weight_scale: [
(__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,
(__gen_unuint(input[34], 0, 7)) as u8,
(__gen_unuint(input[34], 8, 15)) as u8,
(__gen_unuint(input[34], 16, 23)) as u8,
(__gen_unuint(input[34], 24, 31)) as u8,
(__gen_unuint(input[35], 0, 7)) as u8,
(__gen_unuint(input[35], 8, 15)) as u8,
(__gen_unuint(input[35], 16, 23)) as u8,
(__gen_unuint(input[35], 24, 31)) as u8,
(__gen_unuint(input[36], 0, 7)) as u8,
(__gen_unuint(input[36], 8, 15)) as u8,
(__gen_unuint(input[36], 16, 23)) as u8,
(__gen_unuint(input[36], 24, 31)) as u8,
(__gen_unuint(input[37], 0, 7)) as u8,
(__gen_unuint(input[37], 8, 15)) as u8,
(__gen_unuint(input[37], 16, 23)) as u8,
(__gen_unuint(input[37], 24, 31)) as u8,
(__gen_unuint(input[38], 0, 7)) as u8,
(__gen_unuint(input[38], 8, 15)) as u8,
(__gen_unuint(input[38], 16, 23)) as u8,
(__gen_unuint(input[38], 24, 31)) as u8,
(__gen_unuint(input[39], 0, 7)) as u8,
(__gen_unuint(input[39], 8, 15)) as u8,
(__gen_unuint(input[39], 16, 23)) as u8,
(__gen_unuint(input[39], 24, 31)) as u8,
(__gen_unuint(input[40], 0, 7)) as u8,
(__gen_unuint(input[40], 8, 15)) as u8,
(__gen_unuint(input[40], 16, 23)) as u8,
(__gen_unuint(input[40], 24, 31)) as u8,
(__gen_unuint(input[41], 0, 7)) as u8,
(__gen_unuint(input[41], 8, 15)) as u8,
(__gen_unuint(input[41], 16, 23)) as u8,
(__gen_unuint(input[41], 24, 31)) as u8
],
luma8x8_inter_weight_scale: [
(__gen_unuint(input[42], 0, 7)) as u8,
(__gen_unuint(input[42], 8, 15)) as u8,
(__gen_unuint(input[42], 16, 23)) as u8,
(__gen_unuint(input[42], 24, 31)) as u8,
(__gen_unuint(input[43], 0, 7)) as u8,
(__gen_unuint(input[43], 8, 15)) as u8,
(__gen_unuint(input[43], 16, 23)) as u8,
(__gen_unuint(input[43], 24, 31)) as u8,
(__gen_unuint(input[44], 0, 7)) as u8,
(__gen_unuint(input[44], 8, 15)) as u8,
(__gen_unuint(input[44], 16, 23)) as u8,
(__gen_unuint(input[44], 24, 31)) as u8,
(__gen_unuint(input[45], 0, 7)) as u8,
(__gen_unuint(input[45], 8, 15)) as u8,
(__gen_unuint(input[45], 16, 23)) as u8,
(__gen_unuint(input[45], 24, 31)) as u8,
(__gen_unuint(input[46], 0, 7)) as u8,
(__gen_unuint(input[46], 8, 15)) as u8,
(__gen_unuint(input[46], 16, 23)) as u8,
(__gen_unuint(input[46], 24, 31)) as u8,
(__gen_unuint(input[47], 0, 7)) as u8,
(__gen_unuint(input[47], 8, 15)) as u8,
(__gen_unuint(input[47], 16, 23)) as u8,
(__gen_unuint(input[47], 24, 31)) as u8,
(__gen_unuint(input[48], 0, 7)) as u8,
(__gen_unuint(input[48], 8, 15)) as u8,
(__gen_unuint(input[48], 16, 23)) as u8,
(__gen_unuint(input[48], 24, 31)) as u8,
(__gen_unuint(input[49], 0, 7)) as u8,
(__gen_unuint(input[49], 8, 15)) as u8,
(__gen_unuint(input[49], 16, 23)) as u8,
(__gen_unuint(input[49], 24, 31)) as u8,
(__gen_unuint(input[50], 0, 7)) as u8,
(__gen_unuint(input[50], 8, 15)) as u8,
(__gen_unuint(input[50], 16, 23)) as u8,
(__gen_unuint(input[50], 24, 31)) as u8,
(__gen_unuint(input[51], 0, 7)) as u8,
(__gen_unuint(input[51], 8, 15)) as u8,
(__gen_unuint(input[51], 16, 23)) as u8,
(__gen_unuint(input[51], 24, 31)) as u8,
(__gen_unuint(input[52], 0, 7)) as u8,
(__gen_unuint(input[52], 8, 15)) as u8,
(__gen_unuint(input[52], 16, 23)) as u8,
(__gen_unuint(input[52], 24, 31)) as u8,
(__gen_unuint(input[53], 0, 7)) as u8,
(__gen_unuint(input[53], 8, 15)) as u8,
(__gen_unuint(input[53], 16, 23)) as u8,
(__gen_unuint(input[53], 24, 31)) as u8,
(__gen_unuint(input[54], 0, 7)) as u8,
(__gen_unuint(input[54], 8, 15)) as u8,
(__gen_unuint(input[54], 16, 23)) as u8,
(__gen_unuint(input[54], 24, 31)) as u8,
(__gen_unuint(input[55], 0, 7)) as u8,
(__gen_unuint(input[55], 8, 15)) as u8,
(__gen_unuint(input[55], 16, 23)) as u8,
(__gen_unuint(input[55], 24, 31)) as u8,
(__gen_unuint(input[56], 0, 7)) as u8,
(__gen_unuint(input[56], 8, 15)) as u8,
(__gen_unuint(input[56], 16, 23)) as u8,
(__gen_unuint(input[56], 24, 31)) as u8,
(__gen_unuint(input[57], 0, 7)) as u8,
(__gen_unuint(input[57], 8, 15)) as u8,
(__gen_unuint(input[57], 16, 23)) as u8,
(__gen_unuint(input[57], 24, 31)) as u8
],
}
}
}
impl Deserialize for MfxAvcQmState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 58];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 58] as *mut [u8; 232]) })?;
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: 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 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;
}
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(),
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.into(), 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);
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) != 0,
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),
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: 48,
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 bsp_row_store_scratch_buffer_cacheability_control: u32,
pub bsp_row_store_scratch_buffer_graphics_data_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_cacheability_control: u32,
pub mpr_row_store_scratch_buffer_graphics_data_type: u32,
pub mpr_row_store_scratch_buffer_arbitration_priority_control: u32,
pub mpr_row_store_scratch_buffer_address: A,
pub bitplane_read_buffer_cacheability_control: u32,
pub bitplane_read_buffer_graphics_data_type: u32,
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 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 MfxBspBufBaseAddrState<A> {
fn default() -> Self {
MfxBspBufBaseAddrState {
dword_length: 2,
subopcode_b: 4,
subopcode_a: 0,
media_command_opcode: 0,
pipeline: 2,
command_type: 3,
bsp_row_store_scratch_buffer_cacheability_control: Default::default(),
bsp_row_store_scratch_buffer_graphics_data_type: Default::default(),
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_cacheability_control: Default::default(),
mpr_row_store_scratch_buffer_graphics_data_type: Default::default(),
mpr_row_store_scratch_buffer_arbitration_priority_control: Default::default(),
mpr_row_store_scratch_buffer_address: Default::default(),
bitplane_read_buffer_cacheability_control: Default::default(),
bitplane_read_buffer_graphics_data_type: 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.bsp_row_store_scratch_buffer_cacheability_control, 0, 1) |
__gen_uint(self.bsp_row_store_scratch_buffer_graphics_data_type, 2, 2) |
__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_cacheability_control, 0, 1) |
__gen_uint(self.mpr_row_store_scratch_buffer_graphics_data_type, 2, 2) |
__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_cacheability_control, 0, 1) |
__gen_uint(self.bitplane_read_buffer_graphics_data_type, 2, 2) |
__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),
bsp_row_store_scratch_buffer_cacheability_control: __gen_unuint(input[1], 0, 1),
bsp_row_store_scratch_buffer_graphics_data_type: __gen_unuint(input[1], 2, 2),
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_cacheability_control: __gen_unuint(input[2], 0, 1),
mpr_row_store_scratch_buffer_graphics_data_type: __gen_unuint(input[2], 2, 2),
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_cacheability_control: __gen_unuint(input[3], 0, 1),
bitplane_read_buffer_graphics_data_type: __gen_unuint(input[3], 2, 2),
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 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 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 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 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 picture_coding_type: u32,
pub frame_width_in_mbs: u32,
pub frame_height_in_mbs: u32,
}
impl MfxMpeg2PicState {
pub const DWORD_LENGTH: u32 = 4;
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;
}
impl Default for MfxMpeg2PicState {
fn default() -> Self {
MfxMpeg2PicState {
dword_length: 1,
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(),
picture_coding_type: Default::default(),
frame_width_in_mbs: Default::default(),
frame_height_in_mbs: Default::default(),
}
}
}
impl Serialize for MfxMpeg2PicState {
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.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.picture_coding_type, 0, 10);
out[3] = __gen_uint(self.frame_width_in_mbs, 0, 7) |
__gen_uint(self.frame_height_in_mbs, 16, 23);
}
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 MfxMpeg2PicState {
fn from(input: &[u32; 4]) -> 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),
picture_coding_type: __gen_unuint(input[2], 0, 10),
frame_width_in_mbs: __gen_unuint(input[3], 0, 7),
frame_height_in_mbs: __gen_unuint(input[3], 16, 23),
}
}
}
impl Deserialize for MfxMpeg2PicState {
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 MfxMpeg2QmState {
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 qm_type: u32,
pub quantizer_matrix: [u32; 16],
}
impl MfxMpeg2QmState {
pub const DWORD_LENGTH: u32 = 18;
pub const MPEG_INTRA_QUANTIZER_MATRIX: u32 = 0;
pub const MPEG_NON_INTRA_QUANTIZER_MATRIX: u32 = 1;
}
impl Default for MfxMpeg2QmState {
fn default() -> Self {
MfxMpeg2QmState {
dword_length: 16,
subopcode_b: 1,
subopcode_a: 0,
media_command_opcode: 3,
pipeline: 2,
command_type: 3,
qm_type: Default::default(),
quantizer_matrix: Default::default(),
}
}
}
impl Serialize for MfxMpeg2QmState {
type Out = [u32; 18];
fn pack_into(&self, out: &mut [u32; 18]) {
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.qm_type, 0, 0);
out[2] = __gen_uint(self.quantizer_matrix[0], 0, 31);
out[3] = __gen_uint(self.quantizer_matrix[1], 0, 31);
out[4] = __gen_uint(self.quantizer_matrix[2], 0, 31);
out[5] = __gen_uint(self.quantizer_matrix[3], 0, 31);
out[6] = __gen_uint(self.quantizer_matrix[4], 0, 31);
out[7] = __gen_uint(self.quantizer_matrix[5], 0, 31);
out[8] = __gen_uint(self.quantizer_matrix[6], 0, 31);
out[9] = __gen_uint(self.quantizer_matrix[7], 0, 31);
out[10] = __gen_uint(self.quantizer_matrix[8], 0, 31);
out[11] = __gen_uint(self.quantizer_matrix[9], 0, 31);
out[12] = __gen_uint(self.quantizer_matrix[10], 0, 31);
out[13] = __gen_uint(self.quantizer_matrix[11], 0, 31);
out[14] = __gen_uint(self.quantizer_matrix[12], 0, 31);
out[15] = __gen_uint(self.quantizer_matrix[13], 0, 31);
out[16] = __gen_uint(self.quantizer_matrix[14], 0, 31);
out[17] = __gen_uint(self.quantizer_matrix[15], 0, 31);
}
fn write_to<W: std::io::Write>(&self, write: &mut W) -> std::io::Result<()> {
let mut out = [0_u32; 18];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 18] as *const [u8; 72]) })
}
}
impl From<&[u32; 18]> for MfxMpeg2QmState {
fn from(input: &[u32; 18]) -> Self {
MfxMpeg2QmState {
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),
qm_type: __gen_unuint(input[1], 0, 0),
quantizer_matrix: [
__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)
],
}
}
}
impl Deserialize for MfxMpeg2QmState {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 18];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 18] as *mut [u8; 72]) })?;
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_cacheability_control: u32,
pub pre_deblocking_graphics_data_type: u32,
pub pre_deblocking_arbitration_priority_control: u32,
pub pre_deblocking_address: A,
pub post_deblocking_cacheability_control: u32,
pub post_deblocking_graphics_data_type: u32,
pub post_deblocking_arbitration_priority_control: u32,
pub post_deblocking_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: u64,
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_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 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_cacheability_control: Default::default(),
pre_deblocking_graphics_data_type: Default::default(),
pre_deblocking_arbitration_priority_control: Default::default(),
pre_deblocking_address: Default::default(),
post_deblocking_cacheability_control: Default::default(),
post_deblocking_graphics_data_type: Default::default(),
post_deblocking_arbitration_priority_control: Default::default(),
post_deblocking_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_cacheability_control, 0, 1) |
__gen_uint(self.pre_deblocking_graphics_data_type, 2, 2) |
__gen_uint(self.pre_deblocking_arbitration_priority_control, 4, 5);
let v1_address = self.pre_deblocking_address.combine(v1);
out[1] = v1_address as u32;
out[2] = (v1_address >> 32) as u32;
let v2 = __gen_uint(self.post_deblocking_cacheability_control, 0, 1) |
__gen_uint(self.post_deblocking_graphics_data_type, 2, 2) |
__gen_uint(self.post_deblocking_arbitration_priority_control, 4, 5);
let v2_address = self.post_deblocking_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;
out[4] = __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) |
__gen_offset(self.stream_out_data_destination_address as u32, 6, 31);
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_cacheability_control: __gen_unuint(input[1], 0, 1),
pre_deblocking_graphics_data_type: __gen_unuint(input[1], 2, 2),
pre_deblocking_arbitration_priority_control: __gen_unuint(input[1], 4, 5),
pre_deblocking_address: (__gen_unuint(input[1], 6, 31) as u64) << 6,
post_deblocking_cacheability_control: __gen_unuint(input[2], 0, 1),
post_deblocking_graphics_data_type: __gen_unuint(input[2], 2, 2),
post_deblocking_arbitration_priority_control: __gen_unuint(input[2], 4, 5),
post_deblocking_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 zlr_tlb_prefetch_enable: bool,
pub pre_deblocking_output_enable: bool,
pub post_deblocking_output_enable: bool,
pub stream_out_enable: bool,
pub decoder_mode_select: u32,
pub avc_ildb_boundary_strength_calculation: u32,
pub avc_long_field_mv: u32,
pub avc_cabac_cavlc_decode_error_disable: u32,
pub avc_mbdata_error_disable: u32,
pub avc_mv_poc_table_error_disable: u32,
pub clock_gate_enable_at_slice_level: bool,
pub intra_8x8_rounding: u32,
pub slice_pb_rounding: u32,
}
impl MfxPipeModeSelect {
pub const DWORD_LENGTH: u32 = 4;
pub const AVC: u32 = 2;
pub const CALCULATED_ALL_THE_TIME: u32 = 1;
pub const CALCULATED_ONLY_WHEN_POST_FILTER_IS_ON: u32 = 0;
pub const DECODE: u32 = 0;
pub const ENCODE: u32 = 1;
pub const IT_MODE: u32 = 1;
pub const LD_MODE: u32 = 0;
pub const TERMINATE: u32 = 0;
pub const TERMINATES: u32 = 0;
pub const VC1: u32 = 1;
pub const WILL_NOT_TERMINATE: u32 = 1;
pub const _12_BITS_PRECISION: u32 = 1;
pub const _13_BITS_PRECISION: u32 = 0;
}
impl Default for MfxPipeModeSelect {
fn default() -> Self {
MfxPipeModeSelect {
dword_length: 2,
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(),
zlr_tlb_prefetch_enable: Default::default(),
pre_deblocking_output_enable: Default::default(),
post_deblocking_output_enable: Default::default(),
stream_out_enable: Default::default(),
decoder_mode_select: Default::default(),
avc_ildb_boundary_strength_calculation: Default::default(),
avc_long_field_mv: Default::default(),
avc_cabac_cavlc_decode_error_disable: Default::default(),
avc_mbdata_error_disable: Default::default(),
avc_mv_poc_table_error_disable: Default::default(),
clock_gate_enable_at_slice_level: Default::default(),
intra_8x8_rounding: Default::default(),
slice_pb_rounding: Default::default(),
}
}
}
impl Serialize for MfxPipeModeSelect {
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.standard_select, 0, 1) |
__gen_uint(self.codec_select, 4, 4) |
__gen_uint(self.stitch_mode.into(), 5, 5) |
__gen_uint(self.zlr_tlb_prefetch_enable.into(), 7, 7) |
__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.decoder_mode_select, 16, 16);
out[2] = __gen_uint(self.avc_ildb_boundary_strength_calculation, 0, 0) |
__gen_uint(self.avc_long_field_mv, 1, 1) |
__gen_uint(self.avc_cabac_cavlc_decode_error_disable, 2, 2) |
__gen_uint(self.avc_mbdata_error_disable, 3, 3) |
__gen_uint(self.avc_mv_poc_table_error_disable, 4, 4) |
__gen_uint(self.clock_gate_enable_at_slice_level.into(), 6, 6) |
__gen_uint(self.intra_8x8_rounding, 19, 19) |
__gen_uint(self.slice_pb_rounding, 20, 20);
out[3] = 0;
}
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 MfxPipeModeSelect {
fn from(input: &[u32; 4]) -> 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, 1),
codec_select: __gen_unuint(input[1], 4, 4),
stitch_mode: __gen_unuint(input[1], 5, 5) != 0,
zlr_tlb_prefetch_enable: __gen_unuint(input[1], 7, 7) != 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,
decoder_mode_select: __gen_unuint(input[1], 16, 16),
avc_ildb_boundary_strength_calculation: __gen_unuint(input[2], 0, 0),
avc_long_field_mv: __gen_unuint(input[2], 1, 1),
avc_cabac_cavlc_decode_error_disable: __gen_unuint(input[2], 2, 2),
avc_mbdata_error_disable: __gen_unuint(input[2], 3, 3),
avc_mv_poc_table_error_disable: __gen_unuint(input[2], 4, 4),
clock_gate_enable_at_slice_level: __gen_unuint(input[2], 6, 6) != 0,
intra_8x8_rounding: __gen_unuint(input[2], 19, 19),
slice_pb_rounding: __gen_unuint(input[2], 20, 20),
}
}
}
impl Deserialize for MfxPipeModeSelect {
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 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;
pub const INDIRECT_STATE_POINTER_0: u32 = 0;
pub const INDIRECT_STATE_POINTER_1: u32 = 1;
pub const INDIRECT_STATE_POINTER_2: u32 = 2;
pub const INDIRECT_STATE_POINTER_3: u32 = 3;
}
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 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: 2,
subopcode_a: 0,
media_command_opcode: 0,
pipeline: 0,
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, 6, 18) |
__gen_uint(self.height, 19, 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, 12) |
__gen_uint(self.x_offset_for_u_cb, 16, 28);
out[5] = __gen_uint(self.y_offset_for_v_cr, 0, 12) |
__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], 6, 18),
height: __gen_unuint(input[2], 19, 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, 12),
x_offset_for_u_cb: __gen_unuint(input[4], 16, 28),
y_offset_for_v_cr: __gen_unuint(input[5], 0, 12),
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_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 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 MfxVc1PicState {
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 frame_coding_mode: u32,
pub picture_type: u32,
pub second_field: bool,
pub condover: u32,
pub pq_uniform: bool,
pub half_qp: u32,
pub alternative_pq_configuration: u32,
pub alternative_pq_edge_mask: u32,
pub pq_value: u32,
pub implicit_quantizer: bool,
pub overlap_smoothing_enable: bool,
pub loop_filter_enable: bool,
pub alternative_pq_value: u32,
pub concealment_enable: bool,
pub sync_marker: bool,
pub frfd_reference_distance: u32,
pub number_of_references: u32,
pub reference_field_picture_polarity: u32,
pub unified_mv_mode: u32,
pub fast_uv_motion_compensation: u32,
pub four_mv_switch: u32,
pub extended_mv_range: u32,
pub extended_dmv_range: 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,
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: u32,
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 scale_factor: u32,
pub bitplane_buffer_pitch: u32,
pub brfd_reference_distance: u32,
pub dmv_surface_valid: bool,
}
impl MfxVc1PicState {
pub const DWORD_LENGTH: u32 = 6;
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 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 MfxVc1PicState {
fn default() -> Self {
MfxVc1PicState {
dword_length: 4,
subopcode_b: 0,
subopcode_a: 0,
media_command_opcode: 2,
pipeline: 2,
command_type: 3,
picture_width_in_mbs: Default::default(),
picture_height_in_mbs: Default::default(),
frame_coding_mode: Default::default(),
picture_type: Default::default(),
second_field: Default::default(),
condover: Default::default(),
pq_uniform: Default::default(),
half_qp: Default::default(),
alternative_pq_configuration: Default::default(),
alternative_pq_edge_mask: Default::default(),
pq_value: Default::default(),
implicit_quantizer: Default::default(),
overlap_smoothing_enable: Default::default(),
loop_filter_enable: Default::default(),
alternative_pq_value: Default::default(),
concealment_enable: Default::default(),
sync_marker: Default::default(),
frfd_reference_distance: Default::default(),
number_of_references: Default::default(),
reference_field_picture_polarity: Default::default(),
unified_mv_mode: Default::default(),
fast_uv_motion_compensation: Default::default(),
four_mv_switch: Default::default(),
extended_mv_range: Default::default(),
extended_dmv_range: 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(),
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(),
scale_factor: Default::default(),
bitplane_buffer_pitch: Default::default(),
brfd_reference_distance: Default::default(),
dmv_surface_valid: Default::default(),
}
}
}
impl Serialize for MfxVc1PicState {
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.frame_coding_mode, 0, 1) |
__gen_uint(self.picture_type, 2, 4) |
__gen_uint(self.second_field.into(), 5, 5) |
__gen_uint(self.condover, 6, 7) |
__gen_uint(self.pq_uniform.into(), 8, 8) |
__gen_uint(self.half_qp, 9, 9) |
__gen_uint(self.alternative_pq_configuration, 10, 11) |
__gen_uint(self.alternative_pq_edge_mask, 12, 15) |
__gen_uint(self.pq_value, 16, 20) |
__gen_uint(self.implicit_quantizer.into(), 21, 21) |
__gen_uint(self.overlap_smoothing_enable.into(), 22, 22) |
__gen_uint(self.loop_filter_enable.into(), 23, 23) |
__gen_uint(self.alternative_pq_value, 24, 28) |
__gen_uint(self.concealment_enable.into(), 29, 29) |
__gen_uint(self.sync_marker.into(), 31, 31);
out[3] = __gen_uint(self.frfd_reference_distance, 0, 4) |
__gen_uint(self.number_of_references, 5, 5) |
__gen_uint(self.reference_field_picture_polarity, 6, 6) |
__gen_uint(self.unified_mv_mode, 8, 9) |
__gen_uint(self.fast_uv_motion_compensation, 10, 10) |
__gen_uint(self.four_mv_switch, 11, 11) |
__gen_uint(self.extended_mv_range, 12, 13) |
__gen_uint(self.extended_dmv_range, 14, 15) |
__gen_uint(self.fieldtx_raw.into(), 16, 16) |
__gen_uint(self.acpred_raw.into(), 17, 17) |
__gen_uint(self.overflags_raw.into(), 18, 18) |
__gen_uint(self.directmb_raw.into(), 19, 19) |
__gen_uint(self.skipmb_raw.into(), 20, 20) |
__gen_uint(self.mvtypemb_raw.into(), 21, 21) |
__gen_uint(self.forwardmb_raw.into(), 22, 22) |
__gen_uint(self.bitplane_buffer_present.into(), 23, 23);
out[4] = __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, 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.scale_factor, 24, 31);
out[5] = __gen_uint(self.bitplane_buffer_pitch, 0, 7) |
__gen_uint(self.brfd_reference_distance, 8, 12) |
__gen_uint(self.dmv_surface_valid.into(), 13, 13);
}
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 MfxVc1PicState {
fn from(input: &[u32; 6]) -> Self {
MfxVc1PicState {
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),
frame_coding_mode: __gen_unuint(input[2], 0, 1),
picture_type: __gen_unuint(input[2], 2, 4),
second_field: __gen_unuint(input[2], 5, 5) != 0,
condover: __gen_unuint(input[2], 6, 7),
pq_uniform: __gen_unuint(input[2], 8, 8) != 0,
half_qp: __gen_unuint(input[2], 9, 9),
alternative_pq_configuration: __gen_unuint(input[2], 10, 11),
alternative_pq_edge_mask: __gen_unuint(input[2], 12, 15),
pq_value: __gen_unuint(input[2], 16, 20),
implicit_quantizer: __gen_unuint(input[2], 21, 21) != 0,
overlap_smoothing_enable: __gen_unuint(input[2], 22, 22) != 0,
loop_filter_enable: __gen_unuint(input[2], 23, 23) != 0,
alternative_pq_value: __gen_unuint(input[2], 24, 28),
concealment_enable: __gen_unuint(input[2], 29, 29) != 0,
sync_marker: __gen_unuint(input[2], 31, 31) != 0,
frfd_reference_distance: __gen_unuint(input[3], 0, 4),
number_of_references: __gen_unuint(input[3], 5, 5),
reference_field_picture_polarity: __gen_unuint(input[3], 6, 6),
unified_mv_mode: __gen_unuint(input[3], 8, 9),
fast_uv_motion_compensation: __gen_unuint(input[3], 10, 10),
four_mv_switch: __gen_unuint(input[3], 11, 11),
extended_mv_range: __gen_unuint(input[3], 12, 13),
extended_dmv_range: __gen_unuint(input[3], 14, 15),
fieldtx_raw: __gen_unuint(input[3], 16, 16) != 0,
acpred_raw: __gen_unuint(input[3], 17, 17) != 0,
overflags_raw: __gen_unuint(input[3], 18, 18) != 0,
directmb_raw: __gen_unuint(input[3], 19, 19) != 0,
skipmb_raw: __gen_unuint(input[3], 20, 20) != 0,
mvtypemb_raw: __gen_unuint(input[3], 21, 21) != 0,
forwardmb_raw: __gen_unuint(input[3], 22, 22) != 0,
bitplane_buffer_present: __gen_unuint(input[3], 23, 23) != 0,
coded_block_pattern_table: __gen_unuint(input[4], 0, 2),
intra_transform_dc_table: __gen_unuint(input[4], 3, 3),
picture_level_transform_chroma_ac_coding_set_index: __gen_unuint(input[4], 4, 5),
picture_level_transform_luma_ac_coding_set_index: __gen_unuint(input[4], 6, 7),
mb_mode_table: __gen_unuint(input[4], 8, 10),
mb_transform_type: __gen_unuint(input[4], 11, 11),
picture_level_transform_type: __gen_unuint(input[4], 12, 13),
_2_mv_block_pattern_table: __gen_unuint(input[4], 16, 17),
_4_mv_block_pattern_table: __gen_unuint(input[4], 18, 19),
mv_table: __gen_unuint(input[4], 20, 22),
scale_factor: __gen_unuint(input[4], 24, 31),
bitplane_buffer_pitch: __gen_unuint(input[5], 0, 7),
brfd_reference_distance: __gen_unuint(input[5], 8, 12),
dmv_surface_valid: __gen_unuint(input[5], 13, 13) != 0,
}
}
}
impl Deserialize for MfxVc1PicState {
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 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 vc1_profile: u32,
pub interpolation_rounder_control: u32,
pub reference_frame_boundary_replication_mode: 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,
pub vin_intensity_compensation_single_backward_enable: u32,
pub vin_intensity_compensation_single_forward_enable: u32,
pub vin_intensity_compensation_double_backward_enable: u32,
pub vin_intensity_compensation_double_forward_enable: u32,
pub range_reduction: bool,
pub range_reduction_scale: u32,
pub fast_uv_compensation: bool,
pub mv_mode: u32,
}
impl MfxVc1PredPipeState {
pub const DWORD_LENGTH: u32 = 7;
pub const ADVANCED_PROFILE: u32 = 2;
pub const HALF_PEL_BICUBIC: u32 = 0;
pub const INTERLACE_FRAME_REPLICATION: u32 = 1;
pub const MAIN_PROFILE: u32 = 1;
pub const PROGRESSIVE_FRAME_REPLICATION: u32 = 0;
pub const QUARTER_PEL_BICUBIC: u32 = 1;
pub const SIMPLE_PROFILE: u32 = 0;
}
impl Default for MfxVc1PredPipeState {
fn default() -> Self {
MfxVc1PredPipeState {
dword_length: 2,
subopcode_b: 1,
subopcode_a: 0,
media_command_opcode: 2,
pipeline: 2,
command_type: 3,
vc1_profile: Default::default(),
interpolation_rounder_control: Default::default(),
reference_frame_boundary_replication_mode: 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(),
vin_intensity_compensation_single_backward_enable: Default::default(),
vin_intensity_compensation_single_forward_enable: Default::default(),
vin_intensity_compensation_double_backward_enable: Default::default(),
vin_intensity_compensation_double_forward_enable: Default::default(),
range_reduction: Default::default(),
range_reduction_scale: Default::default(),
fast_uv_compensation: Default::default(),
mv_mode: Default::default(),
}
}
}
impl Serialize for MfxVc1PredPipeState {
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.vc1_profile, 2, 3) |
__gen_uint(self.interpolation_rounder_control, 4, 4) |
__gen_uint(self.reference_frame_boundary_replication_mode, 8, 11);
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);
out[6] = __gen_uint(self.vin_intensity_compensation_single_backward_enable, 0, 1) |
__gen_uint(self.vin_intensity_compensation_single_forward_enable, 2, 3) |
__gen_uint(self.vin_intensity_compensation_double_backward_enable, 4, 5) |
__gen_uint(self.vin_intensity_compensation_double_forward_enable, 6, 7) |
__gen_uint(self.range_reduction.into(), 16, 16) |
__gen_uint(self.range_reduction_scale, 17, 17) |
__gen_uint(self.fast_uv_compensation.into(), 18, 18) |
__gen_uint(self.mv_mode, 19, 20);
}
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 MfxVc1PredPipeState {
fn from(input: &[u32; 7]) -> 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),
vc1_profile: __gen_unuint(input[1], 2, 3),
interpolation_rounder_control: __gen_unuint(input[1], 4, 4),
reference_frame_boundary_replication_mode: __gen_unuint(input[1], 8, 11),
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),
vin_intensity_compensation_single_backward_enable: __gen_unuint(input[6], 0, 1),
vin_intensity_compensation_single_forward_enable: __gen_unuint(input[6], 2, 3),
vin_intensity_compensation_double_backward_enable: __gen_unuint(input[6], 4, 5),
vin_intensity_compensation_double_forward_enable: __gen_unuint(input[6], 6, 7),
range_reduction: __gen_unuint(input[6], 16, 16) != 0,
range_reduction_scale: __gen_unuint(input[6], 17, 17),
fast_uv_compensation: __gen_unuint(input[6], 18, 18) != 0,
mv_mode: __gen_unuint(input[6], 19, 20),
}
}
}
impl Deserialize for MfxVc1PredPipeState {
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 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,
}
impl<A: Addr + Default> MiClflush<A> {
pub const DWORD_LENGTH: u32 = 2;
}
impl<A: Addr + Default> Default for MiClflush<A> {
fn default() -> Self {
MiClflush {
dword_length: 0,
use_global_gtt: Default::default(),
mi_command_opcode: 39,
command_type: 0,
starting_cacheline_offset: Default::default(),
page_base_address: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for MiClflush<A> {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
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);
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;
}
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 MiClflush<u64> {
fn from(input: &[u32; 2]) -> Self {
MiClflush {
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),
starting_cacheline_offset: __gen_unuint(input[1], 6, 11),
page_base_address: (__gen_unuint(input[1], 12, 31) as u64) << 12,
}
}
}
impl Deserialize for MiClflush<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 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 MiLoadScanLinesExcl {
pub dword_length: u32,
pub display_plane_select: u32,
pub mi_command_opcode: u32,
pub command_type: u32,
pub end_scan_line_number: u32,
pub start_scan_line_number: u32,
}
impl MiLoadScanLinesExcl {
pub const DWORD_LENGTH: u32 = 2;
pub const DISPLAY_PLANE_A: u32 = 0;
pub const DISPLAY_PLANE_B: u32 = 1;
pub const DISPLAY_PLANE_C: u32 = 4;
}
impl Default for MiLoadScanLinesExcl {
fn default() -> Self {
MiLoadScanLinesExcl {
dword_length: 0,
display_plane_select: Default::default(),
mi_command_opcode: 19,
command_type: 0,
end_scan_line_number: Default::default(),
start_scan_line_number: Default::default(),
}
}
}
impl Serialize for MiLoadScanLinesExcl {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 5) |
__gen_uint(self.display_plane_select, 19, 21) |
__gen_uint(self.mi_command_opcode, 23, 28) |
__gen_uint(self.command_type, 29, 31);
out[1] = __gen_uint(self.end_scan_line_number, 0, 12) |
__gen_uint(self.start_scan_line_number, 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 MiLoadScanLinesExcl {
fn from(input: &[u32; 2]) -> Self {
MiLoadScanLinesExcl {
dword_length: __gen_unuint(input[0], 0, 5),
display_plane_select: __gen_unuint(input[0], 19, 21),
mi_command_opcode: __gen_unuint(input[0], 23, 28),
command_type: __gen_unuint(input[0], 29, 31),
end_scan_line_number: __gen_unuint(input[1], 0, 12),
start_scan_line_number: __gen_unuint(input[1], 16, 28),
}
}
}
impl Deserialize for MiLoadScanLinesExcl {
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 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 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 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 hd_dvd_context: bool,
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(),
hd_dvd_context: 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) |
__gen_uint(self.hd_dvd_context.into(), 9, 9);
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),
hd_dvd_context: __gen_unuint(input[1], 9, 9) != 0,
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 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 condition_code_wait_select: u32,
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(),
condition_code_wait_select: 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.condition_code_wait_select, 16, 19) |
__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,
condition_code_wait_select: __gen_unuint(input[0], 16, 19),
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 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 synchronize_gfdt_surface: bool,
pub tlb_invalidate: bool,
pub global_snapshot_count_reset: bool,
pub command_streamer_stall_enable: bool,
pub store_data_index: 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 NO_WRITE: 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(),
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(),
synchronize_gfdt_surface: Default::default(),
tlb_invalidate: Default::default(),
global_snapshot_count_reset: Default::default(),
command_streamer_stall_enable: Default::default(),
store_data_index: 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.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.synchronize_gfdt_surface.into(), 17, 17) |
__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);
let v2 = __gen_uint(self.destination_address_type, 2, 2);
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 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,
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,
synchronize_gfdt_surface: __gen_unuint(input[1], 17, 17) != 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),
destination_address_type: __gen_unuint(input[2], 2, 2),
address: (__gen_unuint(input[2], 3, 31) as u64) << 3,
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 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 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 cube_map_corner_mode: u32,
pub mip_map_layout_mode: u32,
pub vertical_line_stride_offset: u32,
pub vertical_line_stride: u32,
pub surface_format: u32,
pub data_return_format: u32,
pub surface_type: u32,
pub surface_base_address: A,
pub render_target_rotation: u32,
pub mip_count_lod: u32,
pub width: u32,
pub height: u32,
pub tile_walk: u32,
pub tiled_surface: bool,
pub surface_pitch: u32,
pub depth: u32,
pub multisample_position_palette_index: u32,
pub number_of_multisamples: u32,
pub render_target_view_extent: u32,
pub minimum_array_element: u32,
pub surface_min_lod: u32,
pub mocs: u32,
pub y_offset: u32,
pub surface_vertical_alignment: u32,
pub x_offset: u32,
}
impl<A: Addr + Default> RenderSurfaceState<A> {
pub const DWORD_LENGTH: u32 = 6;
pub const CUBE_AVERAGE: u32 = 1;
pub const CUBE_REPLICATE: u32 = 0;
pub const DATA_RETURN_FLOAT32: u32 = 0;
pub const INTERLACED_FRAME: u32 = 3;
pub const MIPLAYOUT_BELOW: u32 = 0;
pub const MIPLAYOUT_RIGHT: u32 = 1;
pub const MULTISAMPLECOUNT_1: u32 = 0;
pub const MULTISAMPLECOUNT_4: u32 = 2;
pub const NORMAL_MODE: u32 = 0;
pub const PROGRESSIVE_FRAME: u32 = 2;
pub const READ_WRITE: u32 = 1;
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 TILEWALK_XMAJOR: u32 = 0;
pub const TILEWALK_YMAJOR: u32 = 1;
pub const VALIGN_2: u32 = 0;
pub const VALIGN_4: u32 = 1;
pub const WRITE_ONLY: u32 = 0;
}
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(),
cube_map_corner_mode: Default::default(),
mip_map_layout_mode: Default::default(),
vertical_line_stride_offset: Default::default(),
vertical_line_stride: Default::default(),
surface_format: Default::default(),
data_return_format: Default::default(),
surface_type: Default::default(),
surface_base_address: Default::default(),
render_target_rotation: Default::default(),
mip_count_lod: Default::default(),
width: Default::default(),
height: Default::default(),
tile_walk: Default::default(),
tiled_surface: Default::default(),
surface_pitch: Default::default(),
depth: Default::default(),
multisample_position_palette_index: Default::default(),
number_of_multisamples: Default::default(),
render_target_view_extent: Default::default(),
minimum_array_element: Default::default(),
surface_min_lod: Default::default(),
mocs: Default::default(),
y_offset: Default::default(),
surface_vertical_alignment: Default::default(),
x_offset: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for RenderSurfaceState<A> {
type Out = [u32; 6];
fn pack_into(&self, out: &mut [u32; 6]) {
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.cube_map_corner_mode, 9, 9) |
__gen_uint(self.mip_map_layout_mode, 10, 10) |
__gen_uint(self.vertical_line_stride_offset, 11, 11) |
__gen_uint(self.vertical_line_stride, 12, 12) |
__gen_uint(self.surface_format, 18, 26) |
__gen_uint(self.data_return_format, 27, 27) |
__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.render_target_rotation, 0, 1) |
__gen_uint(self.mip_count_lod, 2, 5) |
__gen_uint(self.width, 6, 18) |
__gen_uint(self.height, 19, 31);
out[3] = __gen_uint(self.tile_walk, 0, 0) |
__gen_uint(self.tiled_surface.into(), 1, 1) |
__gen_uint(self.surface_pitch, 3, 19) |
__gen_uint(self.depth, 21, 31);
out[4] = __gen_uint(self.multisample_position_palette_index, 0, 2) |
__gen_uint(self.number_of_multisamples, 4, 6) |
__gen_uint(self.render_target_view_extent, 8, 16) |
__gen_uint(self.minimum_array_element, 17, 27) |
__gen_uint(self.surface_min_lod, 28, 31);
out[5] = __gen_uint(self.mocs, 16, 19) |
__gen_uint(self.y_offset, 20, 23) |
__gen_uint(self.surface_vertical_alignment, 24, 24) |
__gen_uint(self.x_offset, 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 RenderSurfaceState<u64> {
fn from(input: &[u32; 6]) -> 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),
cube_map_corner_mode: __gen_unuint(input[0], 9, 9),
mip_map_layout_mode: __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),
surface_format: __gen_unuint(input[0], 18, 26),
data_return_format: __gen_unuint(input[0], 27, 27),
surface_type: __gen_unuint(input[0], 29, 31),
surface_base_address: (__gen_unuint(input[1], 0, 31) as u64),
render_target_rotation: __gen_unuint(input[2], 0, 1),
mip_count_lod: __gen_unuint(input[2], 2, 5),
width: __gen_unuint(input[2], 6, 18),
height: __gen_unuint(input[2], 19, 31),
tile_walk: __gen_unuint(input[3], 0, 0),
tiled_surface: __gen_unuint(input[3], 1, 1) != 0,
surface_pitch: __gen_unuint(input[3], 3, 19),
depth: __gen_unuint(input[3], 21, 31),
multisample_position_palette_index: __gen_unuint(input[4], 0, 2),
number_of_multisamples: __gen_unuint(input[4], 4, 6),
render_target_view_extent: __gen_unuint(input[4], 8, 16),
minimum_array_element: __gen_unuint(input[4], 17, 27),
surface_min_lod: __gen_unuint(input[4], 28, 31),
mocs: __gen_unuint(input[5], 16, 19),
y_offset: __gen_unuint(input[5], 20, 23),
surface_vertical_alignment: __gen_unuint(input[5], 24, 24),
x_offset: __gen_unuint(input[5], 25, 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; 6];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 6] as *mut [u8; 24]) })?;
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_unorm_green: u32,
pub border_color_unorm_blue: u32,
pub border_color_unorm_alpha: u32,
pub border_color_float_red: f32,
pub border_color_float_green: f32,
pub border_color_float_blue: f32,
pub border_color_float_alpha: f32,
pub border_color_float16_red: u32,
pub border_color_float16_green: u32,
pub border_color_float16_blue: u32,
pub border_color_float16_alpha: u32,
pub border_color_unorm16_red: u32,
pub border_color_unorm16_green: u32,
pub border_color_unorm16_blue: u32,
pub border_color_unorm16_alpha: u32,
pub border_color_snorm16_red: i32,
pub border_color_snorm16_green: i32,
pub border_color_snorm16_blue: i32,
pub border_color_snorm16_alpha: i32,
pub border_color_snorm8_red: i32,
pub border_color_snorm8_green: i32,
pub border_color_snorm8_blue: i32,
pub border_color_snorm8_alpha: i32,
}
impl SamplerBorderColorState {
pub const DWORD_LENGTH: u32 = 12;
}
impl Default for SamplerBorderColorState {
fn default() -> Self {
SamplerBorderColorState {
border_color_unorm_red: Default::default(),
border_color_unorm_green: Default::default(),
border_color_unorm_blue: Default::default(),
border_color_unorm_alpha: Default::default(),
border_color_float_red: Default::default(),
border_color_float_green: Default::default(),
border_color_float_blue: Default::default(),
border_color_float_alpha: Default::default(),
border_color_float16_red: Default::default(),
border_color_float16_green: Default::default(),
border_color_float16_blue: Default::default(),
border_color_float16_alpha: Default::default(),
border_color_unorm16_red: Default::default(),
border_color_unorm16_green: Default::default(),
border_color_unorm16_blue: Default::default(),
border_color_unorm16_alpha: Default::default(),
border_color_snorm16_red: Default::default(),
border_color_snorm16_green: Default::default(),
border_color_snorm16_blue: Default::default(),
border_color_snorm16_alpha: Default::default(),
border_color_snorm8_red: Default::default(),
border_color_snorm8_green: Default::default(),
border_color_snorm8_blue: Default::default(),
border_color_snorm8_alpha: Default::default(),
}
}
}
impl Serialize for SamplerBorderColorState {
type Out = [u32; 12];
fn pack_into(&self, out: &mut [u32; 12]) {
out[0] = __gen_uint(self.border_color_unorm_red, 0, 7) |
__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_red.to_bits();
out[2] = self.border_color_float_green.to_bits();
out[3] = self.border_color_float_blue.to_bits();
out[4] = self.border_color_float_alpha.to_bits();
out[5] = __gen_uint(self.border_color_float16_red, 0, 15) |
__gen_uint(self.border_color_float16_green, 16, 31);
out[6] = __gen_uint(self.border_color_float16_blue, 0, 15) |
__gen_uint(self.border_color_float16_alpha, 16, 31);
out[7] = __gen_uint(self.border_color_unorm16_red, 0, 15) |
__gen_uint(self.border_color_unorm16_green, 16, 31);
out[8] = __gen_uint(self.border_color_unorm16_blue, 0, 15) |
__gen_uint(self.border_color_unorm16_alpha, 16, 31);
out[9] = __gen_uint(self.border_color_snorm16_red as u32, 0, 15) |
__gen_uint(self.border_color_snorm16_green as u32, 16, 31);
out[10] = __gen_uint(self.border_color_snorm16_blue as u32, 0, 15) |
__gen_uint(self.border_color_snorm16_alpha as u32, 16, 31);
out[11] = __gen_uint(self.border_color_snorm8_red as u32, 0, 7) |
__gen_uint(self.border_color_snorm8_green as u32, 8, 15) |
__gen_uint(self.border_color_snorm8_blue as u32, 16, 23) |
__gen_uint(self.border_color_snorm8_alpha as u32, 24, 31);
}
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 SamplerBorderColorState {
fn from(input: &[u32; 12]) -> Self {
SamplerBorderColorState {
border_color_unorm_red: __gen_unuint(input[0], 0, 7),
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_red: f32::from_bits(input[1]),
border_color_float_green: f32::from_bits(input[2]),
border_color_float_blue: f32::from_bits(input[3]),
border_color_float_alpha: f32::from_bits(input[4]),
border_color_float16_red: __gen_unuint(input[5], 0, 15),
border_color_float16_green: __gen_unuint(input[5], 16, 31),
border_color_float16_blue: __gen_unuint(input[6], 0, 15),
border_color_float16_alpha: __gen_unuint(input[6], 16, 31),
border_color_unorm16_red: __gen_unuint(input[7], 0, 15),
border_color_unorm16_green: __gen_unuint(input[7], 16, 31),
border_color_unorm16_blue: __gen_unuint(input[8], 0, 15),
border_color_unorm16_alpha: __gen_unuint(input[8], 16, 31),
border_color_snorm16_red: (__gen_unuint(input[9], 0, 15)) as i32,
border_color_snorm16_green: (__gen_unuint(input[9], 16, 31)) as i32,
border_color_snorm16_blue: (__gen_unuint(input[10], 0, 15)) as i32,
border_color_snorm16_alpha: (__gen_unuint(input[10], 16, 31)) as i32,
border_color_snorm8_red: (__gen_unuint(input[11], 0, 7)) as i32,
border_color_snorm8_green: (__gen_unuint(input[11], 8, 15)) as i32,
border_color_snorm8_blue: (__gen_unuint(input[11], 16, 23)) as i32,
border_color_snorm8_alpha: (__gen_unuint(input[11], 24, 31)) as i32,
}
}
}
impl Deserialize for SamplerBorderColorState {
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 SamplerState {
pub shadow_function: 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 min_and_mag_state_not_equal: u32,
pub lod_preclamp_enable: u32,
pub texture_border_color_mode: u32,
pub sampler_disable: bool,
pub tcz_address_control_mode: TextureCoordinateMode,
pub tcy_address_control_mode: TextureCoordinateMode,
pub tcx_address_control_mode: TextureCoordinateMode,
pub cube_surface_control_mode: u32,
pub max_lod: f32,
pub min_lod: f32,
pub border_color_pointer: u64,
pub non_normalized_coordinate_enable: bool,
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,
pub monochrome_filter_width: u32,
pub monochrome_filter_height_reserved: u32,
}
impl SamplerState {
pub const DWORD_LENGTH: u32 = 4;
pub const ANISOTROPIC: u32 = 2;
pub const CUBECTRLMODE_OVERRIDE: u32 = 1;
pub const CUBECTRLMODE_PROGRAMMED: u32 = 0;
pub const DX10_OGL: u32 = 0;
pub const DX9: u32 = 1;
pub const KEYFILTER_KILL_ON_ANY_MATCH: u32 = 0;
pub const KEYFILTER_REPLACE_BLACK: u32 = 1;
pub const MIN_MAG_EQ: u32 = 0;
pub const MIN_MAG_NEQ: u32 = 1;
pub const MONO: u32 = 6;
pub const NONE: u32 = 0;
pub const OGL: 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 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 {
shadow_function: 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(),
min_and_mag_state_not_equal: Default::default(),
lod_preclamp_enable: Default::default(),
texture_border_color_mode: Default::default(),
sampler_disable: Default::default(),
tcz_address_control_mode: Default::default(),
tcy_address_control_mode: Default::default(),
tcx_address_control_mode: Default::default(),
cube_surface_control_mode: Default::default(),
max_lod: Default::default(),
min_lod: Default::default(),
border_color_pointer: Default::default(),
non_normalized_coordinate_enable: 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(),
monochrome_filter_width: Default::default(),
monochrome_filter_height_reserved: Default::default(),
}
}
}
impl Serialize for SamplerState {
type Out = [u32; 4];
fn pack_into(&self, out: &mut [u32; 4]) {
out[0] = __gen_uint(self.shadow_function, 0, 2) |
__gen_sfixed(self.texture_lod_bias, 3, 13, 6) |
__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.min_and_mag_state_not_equal, 27, 27) |
__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.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.cube_surface_control_mode, 9, 9) |
__gen_ufixed(self.max_lod, 12, 21, 6) |
__gen_ufixed(self.min_lod, 22, 31, 6);
out[2] = __gen_offset(self.border_color_pointer as u32, 5, 31);
out[3] = __gen_uint(self.non_normalized_coordinate_enable.into(), 0, 0) |
__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) |
__gen_uint(self.monochrome_filter_width, 26, 28) |
__gen_uint(self.monochrome_filter_height_reserved, 29, 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 SamplerState {
fn from(input: &[u32; 4]) -> Self {
SamplerState {
shadow_function: __gen_unuint(input[0], 0, 2),
texture_lod_bias: __gen_unsfixed(input[0], 3, 13, 6),
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),
min_and_mag_state_not_equal: __gen_unuint(input[0], 27, 27),
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,
tcz_address_control_mode: (__gen_unuint(input[1], 0, 2)).into(),
tcy_address_control_mode: (__gen_unuint(input[1], 3, 5)).into(),
tcx_address_control_mode: (__gen_unuint(input[1], 6, 8)).into(),
cube_surface_control_mode: __gen_unuint(input[1], 9, 9),
max_lod: __gen_unufixed(input[1], 12, 21, 6),
min_lod: __gen_unufixed(input[1], 22, 31, 6),
border_color_pointer: (__gen_unuint(input[2], 5, 31) as u64) << 5,
non_normalized_coordinate_enable: __gen_unuint(input[3], 0, 0) != 0,
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,
monochrome_filter_width: __gen_unuint(input[3], 26, 28),
monochrome_filter_height_reserved: __gen_unuint(input[3], 29, 31),
}
}
}
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 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 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 SfViewport {
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,
}
impl SfViewport {
pub const DWORD_LENGTH: u32 = 8;
pub const EXCLUDES_DWORD_0_1: f32 = 0.0;
}
impl Default for SfViewport {
fn default() -> Self {
SfViewport {
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(),
}
}
}
impl Serialize for SfViewport {
type Out = [u32; 8];
fn pack_into(&self, out: &mut [u32; 8]) {
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;
}
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 SfViewport {
fn from(input: &[u32; 8]) -> Self {
SfViewport {
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]),
}
}
}
impl Deserialize for SfViewport {
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 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 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 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(),
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.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,
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 _3dPrimitive {
pub dword_length: u32,
pub internal_vertex_count: u32,
pub primitive_topology_type: _3dPrimTopoType,
pub vertex_access_type: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
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 = 6;
pub const NON_INSTANCED_OPERATION: u32 = 1;
pub const RANDOM: u32 = 1;
pub const SEQUENTIAL: u32 = 0;
pub const UNDEFINED: u32 = 0;
}
impl Default for _3dPrimitive {
fn default() -> Self {
_3dPrimitive {
dword_length: 4,
internal_vertex_count: Default::default(),
primitive_topology_type: Default::default(),
vertex_access_type: Default::default(),
_3d_command_sub_opcode: 0,
_3d_command_opcode: 3,
command_subtype: 3,
command_type: 3,
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; 6];
fn pack_into(&self, out: &mut [u32; 6]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self.internal_vertex_count, 9, 9) |
__gen_uint(self.primitive_topology_type.into(), 10, 14) |
__gen_uint(self.vertex_access_type, 15, 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);
out[1] = __gen_uint(self.vertex_count_per_instance, 0, 31);
out[2] = __gen_uint(self.start_vertex_location, 0, 31);
out[3] = __gen_uint(self.instance_count, 0, 31);
out[4] = __gen_uint(self.start_instance_location, 0, 31);
out[5] = __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; 6];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 6] as *const [u8; 24]) })
}
}
impl From<&[u32; 6]> for _3dPrimitive {
fn from(input: &[u32; 6]) -> Self {
_3dPrimitive {
dword_length: __gen_unuint(input[0], 0, 7),
internal_vertex_count: __gen_unuint(input[0], 9, 9),
primitive_topology_type: (__gen_unuint(input[0], 10, 14)).into(),
vertex_access_type: __gen_unuint(input[0], 15, 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),
vertex_count_per_instance: __gen_unuint(input[1], 0, 31),
start_vertex_location: __gen_unuint(input[2], 0, 31),
instance_count: __gen_unuint(input[3], 0, 31),
start_instance_location: __gen_unuint(input[4], 0, 31),
base_vertex_location: (__gen_unuint(input[5], 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; 6];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 6] as *mut [u8; 24]) })?;
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 _3dStateBindingTablePointers {
pub dword_length: u32,
pub vs_binding_table_change: bool,
pub gs_binding_table_change: bool,
pub ps_binding_table_change: bool,
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,
pub pointer_to_gs_binding_table: u64,
pub pointer_to_ps_binding_table: u64,
}
impl _3dStateBindingTablePointers {
pub const DWORD_LENGTH: u32 = 4;
}
impl Default for _3dStateBindingTablePointers {
fn default() -> Self {
_3dStateBindingTablePointers {
dword_length: 2,
vs_binding_table_change: Default::default(),
gs_binding_table_change: Default::default(),
ps_binding_table_change: Default::default(),
_3d_command_sub_opcode: 1,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
pointer_to_vs_binding_table: Default::default(),
pointer_to_gs_binding_table: Default::default(),
pointer_to_ps_binding_table: Default::default(),
}
}
}
impl Serialize for _3dStateBindingTablePointers {
type Out = [u32; 4];
fn pack_into(&self, out: &mut [u32; 4]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self.vs_binding_table_change.into(), 8, 8) |
__gen_uint(self.gs_binding_table_change.into(), 9, 9) |
__gen_uint(self.ps_binding_table_change.into(), 12, 12) |
__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, 31);
out[2] = __gen_offset(self.pointer_to_gs_binding_table as u32, 5, 31);
out[3] = __gen_offset(self.pointer_to_ps_binding_table as u32, 5, 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 _3dStateBindingTablePointers {
fn from(input: &[u32; 4]) -> Self {
_3dStateBindingTablePointers {
dword_length: __gen_unuint(input[0], 0, 7),
vs_binding_table_change: __gen_unuint(input[0], 8, 8) != 0,
gs_binding_table_change: __gen_unuint(input[0], 9, 9) != 0,
ps_binding_table_change: __gen_unuint(input[0], 12, 12) != 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),
pointer_to_vs_binding_table: (__gen_unuint(input[1], 5, 31) as u64) << 5,
pointer_to_gs_binding_table: (__gen_unuint(input[2], 5, 31) as u64) << 5,
pointer_to_ps_binding_table: (__gen_unuint(input[3], 5, 31) as u64) << 5,
}
}
}
impl Deserialize for _3dStateBindingTablePointers {
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 _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 blend_state_change: bool,
pub pointer_to_blend_state: u64,
pub depth_stencil_state_change: bool,
pub pointer_to_depth_stencil_state: u64,
pub color_calc_state_pointer_valid: bool,
pub color_calc_state_pointer: u64,
}
impl _3dStateCcStatePointers {
pub const DWORD_LENGTH: u32 = 4;
}
impl Default for _3dStateCcStatePointers {
fn default() -> Self {
_3dStateCcStatePointers {
dword_length: 2,
_3d_command_sub_opcode: 14,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
blend_state_change: Default::default(),
pointer_to_blend_state: Default::default(),
depth_stencil_state_change: Default::default(),
pointer_to_depth_stencil_state: Default::default(),
color_calc_state_pointer_valid: Default::default(),
color_calc_state_pointer: Default::default(),
}
}
}
impl Serialize for _3dStateCcStatePointers {
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.blend_state_change.into(), 0, 0) |
__gen_offset(self.pointer_to_blend_state as u32, 6, 31);
out[2] = __gen_uint(self.depth_stencil_state_change.into(), 0, 0) |
__gen_offset(self.pointer_to_depth_stencil_state as u32, 6, 31);
out[3] = __gen_uint(self.color_calc_state_pointer_valid.into(), 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; 4];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 4] as *const [u8; 16]) })
}
}
impl From<&[u32; 4]> for _3dStateCcStatePointers {
fn from(input: &[u32; 4]) -> 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),
blend_state_change: __gen_unuint(input[1], 0, 0) != 0,
pointer_to_blend_state: (__gen_unuint(input[1], 6, 31) as u64) << 6,
depth_stencil_state_change: __gen_unuint(input[2], 0, 0) != 0,
pointer_to_depth_stencil_state: (__gen_unuint(input[2], 6, 31) as u64) << 6,
color_calc_state_pointer_valid: __gen_unuint(input[3], 0, 0) != 0,
color_calc_state_pointer: (__gen_unuint(input[3], 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; 4];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 4] as *mut [u8; 16]) })?;
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 depth_clear_value_valid: bool,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub depth_clear_value: u32,
}
impl _3dStateClearParams {
pub const DWORD_LENGTH: u32 = 2;
}
impl Default for _3dStateClearParams {
fn default() -> Self {
_3dStateClearParams {
dword_length: 0,
depth_clear_value_valid: Default::default(),
_3d_command_sub_opcode: 16,
_3d_command_opcode: 1,
command_subtype: 3,
command_type: 3,
depth_clear_value: Default::default(),
}
}
}
impl Serialize for _3dStateClearParams {
type Out = [u32; 2];
fn pack_into(&self, out: &mut [u32; 2]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self.depth_clear_value_valid.into(), 15, 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);
out[1] = __gen_uint(self.depth_clear_value, 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 _3dStateClearParams {
fn from(input: &[u32; 2]) -> Self {
_3dStateClearParams {
dword_length: __gen_unuint(input[0], 0, 7),
depth_clear_value_valid: __gen_unuint(input[0], 15, 15) != 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),
depth_clear_value: __gen_unuint(input[1], 0, 31),
}
}
}
impl Deserialize for _3dStateClearParams {
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 _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 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 CLIPMODE_ACCEPT_ALL: u32 = 4;
pub const CLIPMODE_NORMAL: u32 = 0;
pub const CLIPMODE_REJECT_ALL: u32 = 3;
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(),
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);
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,
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 constant_buffer_0_read_length: u32,
pub pointer_to_constant_buffer_0: u64,
pub constant_buffer_1_read_length: u32,
pub pointer_to_constant_buffer_1: A,
pub constant_buffer_2_read_length: u32,
pub pointer_to_constant_buffer_2: A,
pub constant_buffer_3_read_length: u32,
pub pointer_to_constant_buffer_3: A,
}
impl<A: Addr + Default> _3dStateConstantBody<A> {
pub const DWORD_LENGTH: u32 = 4;
}
impl<A: Addr + Default> Default for _3dStateConstantBody<A> {
fn default() -> Self {
_3dStateConstantBody {
constant_buffer_0_read_length: Default::default(),
pointer_to_constant_buffer_0: Default::default(),
constant_buffer_1_read_length: Default::default(),
pointer_to_constant_buffer_1: Default::default(),
constant_buffer_2_read_length: Default::default(),
pointer_to_constant_buffer_2: Default::default(),
constant_buffer_3_read_length: Default::default(),
pointer_to_constant_buffer_3: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for _3dStateConstantBody<A> {
type Out = [u32; 4];
fn pack_into(&self, out: &mut [u32; 4]) {
out[0] = __gen_uint(self.constant_buffer_0_read_length, 0, 4) |
__gen_offset(self.pointer_to_constant_buffer_0 as u32, 5, 31);
let v1 = __gen_uint(self.constant_buffer_1_read_length, 0, 4);
let v1_address = self.pointer_to_constant_buffer_1.combine(v1);
out[1] = v1_address as u32;
out[2] = (v1_address >> 32) as u32;
let v2 = __gen_uint(self.constant_buffer_2_read_length, 0, 4);
let v2_address = self.pointer_to_constant_buffer_2.combine(v2);
out[2] = v2_address as u32;
out[3] = (v2_address >> 32) as u32;
let v3 = __gen_uint(self.constant_buffer_3_read_length, 0, 4);
let v3_address = self.pointer_to_constant_buffer_3.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 _3dStateConstantBody<u64> {
fn from(input: &[u32; 4]) -> Self {
_3dStateConstantBody {
constant_buffer_0_read_length: __gen_unuint(input[0], 0, 4),
pointer_to_constant_buffer_0: (__gen_unuint(input[0], 5, 31) as u64) << 5,
constant_buffer_1_read_length: __gen_unuint(input[1], 0, 4),
pointer_to_constant_buffer_1: (__gen_unuint(input[1], 5, 31) as u64) << 5,
constant_buffer_2_read_length: __gen_unuint(input[2], 0, 4),
pointer_to_constant_buffer_2: (__gen_unuint(input[2], 5, 31) as u64) << 5,
constant_buffer_3_read_length: __gen_unuint(input[3], 0, 4),
pointer_to_constant_buffer_3: (__gen_unuint(input[3], 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; 4];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 4] as *mut [u8; 16]) })?;
Ok((&input).into())
}
}
pub struct _3dStateConstantGs<A: Addr + Default> {
pub dword_length: u32,
pub mocs: u32,
pub buffer_0_valid: bool,
pub buffer_1_valid: bool,
pub buffer_2_valid: bool,
pub buffer_3_valid: bool,
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 = 5;
}
impl<A: Addr + Default> Default for _3dStateConstantGs<A> {
fn default() -> Self {
_3dStateConstantGs {
dword_length: 3,
mocs: Default::default(),
buffer_0_valid: Default::default(),
buffer_1_valid: Default::default(),
buffer_2_valid: Default::default(),
buffer_3_valid: Default::default(),
_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; 5];
fn pack_into(&self, out: &mut [u32; 5]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self.mocs, 8, 11) |
__gen_uint(self.buffer_0_valid.into(), 12, 12) |
__gen_uint(self.buffer_1_valid.into(), 13, 13) |
__gen_uint(self.buffer_2_valid.into(), 14, 14) |
__gen_uint(self.buffer_3_valid.into(), 15, 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 [_, ref mut out1_4 @ ..] = out;
self.constant_body.pack_into(out1_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 _3dStateConstantGs<u64> {
fn from(input: &[u32; 5]) -> Self {
_3dStateConstantGs {
dword_length: __gen_unuint(input[0], 0, 7),
mocs: __gen_unuint(input[0], 8, 11),
buffer_0_valid: __gen_unuint(input[0], 12, 12) != 0,
buffer_1_valid: __gen_unuint(input[0], 13, 13) != 0,
buffer_2_valid: __gen_unuint(input[0], 14, 14) != 0,
buffer_3_valid: __gen_unuint(input[0], 15, 15) != 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),
constant_body: {{
let [_, ref in1_4 @ ..] = input;
in1_4.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; 5];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 5] as *mut [u8; 20]) })?;
Ok((&input).into())
}
}
pub struct _3dStateConstantPs<A: Addr + Default> {
pub dword_length: u32,
pub mocs: u32,
pub buffer_0_valid: bool,
pub buffer_1_valid: bool,
pub buffer_2_valid: bool,
pub buffer_3_valid: bool,
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 = 5;
}
impl<A: Addr + Default> Default for _3dStateConstantPs<A> {
fn default() -> Self {
_3dStateConstantPs {
dword_length: 3,
mocs: Default::default(),
buffer_0_valid: Default::default(),
buffer_1_valid: Default::default(),
buffer_2_valid: Default::default(),
buffer_3_valid: Default::default(),
_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; 5];
fn pack_into(&self, out: &mut [u32; 5]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self.mocs, 8, 11) |
__gen_uint(self.buffer_0_valid.into(), 12, 12) |
__gen_uint(self.buffer_1_valid.into(), 13, 13) |
__gen_uint(self.buffer_2_valid.into(), 14, 14) |
__gen_uint(self.buffer_3_valid.into(), 15, 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 [_, ref mut out1_4 @ ..] = out;
self.constant_body.pack_into(out1_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 _3dStateConstantPs<u64> {
fn from(input: &[u32; 5]) -> Self {
_3dStateConstantPs {
dword_length: __gen_unuint(input[0], 0, 7),
mocs: __gen_unuint(input[0], 8, 11),
buffer_0_valid: __gen_unuint(input[0], 12, 12) != 0,
buffer_1_valid: __gen_unuint(input[0], 13, 13) != 0,
buffer_2_valid: __gen_unuint(input[0], 14, 14) != 0,
buffer_3_valid: __gen_unuint(input[0], 15, 15) != 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),
constant_body: {{
let [_, ref in1_4 @ ..] = input;
in1_4.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; 5];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 5] as *mut [u8; 20]) })?;
Ok((&input).into())
}
}
pub struct _3dStateConstantVs<A: Addr + Default> {
pub dword_length: u32,
pub mocs: u32,
pub buffer_0_valid: bool,
pub buffer_1_valid: bool,
pub buffer_2_valid: bool,
pub buffer_3_valid: bool,
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 = 5;
}
impl<A: Addr + Default> Default for _3dStateConstantVs<A> {
fn default() -> Self {
_3dStateConstantVs {
dword_length: 3,
mocs: Default::default(),
buffer_0_valid: Default::default(),
buffer_1_valid: Default::default(),
buffer_2_valid: Default::default(),
buffer_3_valid: Default::default(),
_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; 5];
fn pack_into(&self, out: &mut [u32; 5]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self.mocs, 8, 11) |
__gen_uint(self.buffer_0_valid.into(), 12, 12) |
__gen_uint(self.buffer_1_valid.into(), 13, 13) |
__gen_uint(self.buffer_2_valid.into(), 14, 14) |
__gen_uint(self.buffer_3_valid.into(), 15, 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 [_, ref mut out1_4 @ ..] = out;
self.constant_body.pack_into(out1_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 _3dStateConstantVs<u64> {
fn from(input: &[u32; 5]) -> Self {
_3dStateConstantVs {
dword_length: __gen_unuint(input[0], 0, 7),
mocs: __gen_unuint(input[0], 8, 11),
buffer_0_valid: __gen_unuint(input[0], 12, 12) != 0,
buffer_1_valid: __gen_unuint(input[0], 13, 13) != 0,
buffer_2_valid: __gen_unuint(input[0], 14, 14) != 0,
buffer_3_valid: __gen_unuint(input[0], 15, 15) != 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),
constant_body: {{
let [_, ref in1_4 @ ..] = input;
in1_4.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; 5];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 5] as *mut [u8; 20]) })?;
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 separate_stencil_buffer_enable: bool,
pub hierarchical_depth_buffer_enable: bool,
pub software_tiled_rendering_mode: u32,
pub tile_walk: u32,
pub tiled_surface: bool,
pub surface_type: u32,
pub surface_base_address: A,
pub mip_map_layout_mode: u32,
pub lod: u32,
pub width: u32,
pub height: u32,
pub render_target_view_extent: u32,
pub minimum_array_element: u32,
pub depth: u32,
pub depth_coordinate_offset_x: i32,
pub depth_coordinate_offset_y: i32,
pub mocs: u32,
}
impl<A: Addr + Default> _3dStateDepthBuffer<A> {
pub const DWORD_LENGTH: u32 = 7;
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 MIPLAYOUT_BELOW: u32 = 0;
pub const MIPLAYOUT_RIGHT: u32 = 1;
pub const NORMAL: u32 = 0;
pub const STR1: u32 = 1;
pub const STR2: u32 = 3;
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_NULL: u32 = 7;
pub const TILEWALK_YMAJOR: u32 = 1;
}
impl<A: Addr + Default> Default for _3dStateDepthBuffer<A> {
fn default() -> Self {
_3dStateDepthBuffer {
dword_length: 5,
_3d_command_sub_opcode: 5,
_3d_command_opcode: 1,
command_subtype: 3,
command_type: 3,
surface_pitch: Default::default(),
surface_format: Default::default(),
separate_stencil_buffer_enable: Default::default(),
hierarchical_depth_buffer_enable: Default::default(),
software_tiled_rendering_mode: Default::default(),
tile_walk: Default::default(),
tiled_surface: Default::default(),
surface_type: Default::default(),
surface_base_address: Default::default(),
mip_map_layout_mode: Default::default(),
lod: Default::default(),
width: Default::default(),
height: Default::default(),
render_target_view_extent: Default::default(),
minimum_array_element: Default::default(),
depth: Default::default(),
depth_coordinate_offset_x: Default::default(),
depth_coordinate_offset_y: Default::default(),
mocs: 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, 16) |
__gen_uint(self.surface_format, 18, 20) |
__gen_uint(self.separate_stencil_buffer_enable.into(), 21, 21) |
__gen_uint(self.hierarchical_depth_buffer_enable.into(), 22, 22) |
__gen_uint(self.software_tiled_rendering_mode, 23, 24) |
__gen_uint(self.tile_walk, 26, 26) |
__gen_uint(self.tiled_surface.into(), 27, 27) |
__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.mip_map_layout_mode, 1, 1) |
__gen_uint(self.lod, 2, 5) |
__gen_uint(self.width, 6, 18) |
__gen_uint(self.height, 19, 31);
out[4] = __gen_uint(self.render_target_view_extent, 1, 9) |
__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.mocs, 27, 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, 16),
surface_format: __gen_unuint(input[1], 18, 20),
separate_stencil_buffer_enable: __gen_unuint(input[1], 21, 21) != 0,
hierarchical_depth_buffer_enable: __gen_unuint(input[1], 22, 22) != 0,
software_tiled_rendering_mode: __gen_unuint(input[1], 23, 24),
tile_walk: __gen_unuint(input[1], 26, 26),
tiled_surface: __gen_unuint(input[1], 27, 27) != 0,
surface_type: __gen_unuint(input[1], 29, 31),
surface_base_address: (__gen_unuint(input[2], 0, 31) as u64),
mip_map_layout_mode: __gen_unuint(input[3], 1, 1),
lod: __gen_unuint(input[3], 2, 5),
width: __gen_unuint(input[3], 6, 18),
height: __gen_unuint(input[3], 19, 31),
render_target_view_extent: __gen_unuint(input[4], 1, 9),
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,
mocs: __gen_unuint(input[6], 27, 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 _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 _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 vertex_urb_entry_read_length: u32,
pub rendering_enabled: u32,
pub so_statistics_enable: bool,
pub statistics_enable: bool,
pub maximum_number_of_threads: u32,
pub enable: bool,
pub svbi_post_increment_value: u32,
pub svbi_post_increment_enable: bool,
pub svbi_payload_enable: bool,
pub discard_adjacency: bool,
pub reorder_mode: u32,
}
impl<A: Addr + Default> _3dStateGs<A> {
pub const DWORD_LENGTH: u32 = 7;
pub const ALTERNATE: 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 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(),
vertex_urb_entry_read_length: Default::default(),
rendering_enabled: Default::default(),
so_statistics_enable: Default::default(),
statistics_enable: Default::default(),
maximum_number_of_threads: Default::default(),
enable: Default::default(),
svbi_post_increment_value: Default::default(),
svbi_post_increment_enable: Default::default(),
svbi_payload_enable: Default::default(),
discard_adjacency: Default::default(),
reorder_mode: 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.vertex_urb_entry_read_length, 11, 16);
out[5] = __gen_uint(self.rendering_enabled, 8, 8) |
__gen_uint(self.so_statistics_enable.into(), 9, 9) |
__gen_uint(self.statistics_enable.into(), 10, 10) |
__gen_uint(self.maximum_number_of_threads, 25, 31);
out[6] = __gen_uint(self.enable.into(), 15, 15) |
__gen_uint(self.svbi_post_increment_value, 16, 25) |
__gen_uint(self.svbi_post_increment_enable.into(), 27, 27) |
__gen_uint(self.svbi_payload_enable.into(), 28, 28) |
__gen_uint(self.discard_adjacency.into(), 29, 29) |
__gen_uint(self.reorder_mode, 30, 30);
}
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),
vertex_urb_entry_read_length: __gen_unuint(input[4], 11, 16),
rendering_enabled: __gen_unuint(input[5], 8, 8),
so_statistics_enable: __gen_unuint(input[5], 9, 9) != 0,
statistics_enable: __gen_unuint(input[5], 10, 10) != 0,
maximum_number_of_threads: __gen_unuint(input[5], 25, 31),
enable: __gen_unuint(input[6], 15, 15) != 0,
svbi_post_increment_value: __gen_unuint(input[6], 16, 25),
svbi_post_increment_enable: __gen_unuint(input[6], 27, 27) != 0,
svbi_payload_enable: __gen_unuint(input[6], 28, 28) != 0,
discard_adjacency: __gen_unuint(input[6], 29, 29) != 0,
reorder_mode: __gen_unuint(input[6], 30, 30),
}
}
}
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 _3dStateGsSvbIndex {
pub dword_length: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub load_internal_vertex_count: u32,
pub index_number: u32,
pub streamed_vertex_buffer_index: u32,
pub maximum_index: u32,
}
impl _3dStateGsSvbIndex {
pub const DWORD_LENGTH: u32 = 7;
}
impl Default for _3dStateGsSvbIndex {
fn default() -> Self {
_3dStateGsSvbIndex {
dword_length: 5,
_3d_command_sub_opcode: 11,
_3d_command_opcode: 1,
command_subtype: 3,
command_type: 3,
load_internal_vertex_count: Default::default(),
index_number: Default::default(),
streamed_vertex_buffer_index: Default::default(),
maximum_index: Default::default(),
}
}
}
impl Serialize for _3dStateGsSvbIndex {
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.load_internal_vertex_count, 0, 0) |
__gen_uint(self.index_number, 29, 30);
out[2] = __gen_uint(self.streamed_vertex_buffer_index, 0, 31);
out[3] = __gen_uint(self.maximum_index, 0, 31);
out[4] = 0;
out[5] = 0;
out[6] = 0;
}
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 _3dStateGsSvbIndex {
fn from(input: &[u32; 7]) -> Self {
_3dStateGsSvbIndex {
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),
load_internal_vertex_count: __gen_unuint(input[1], 0, 0),
index_number: __gen_unuint(input[1], 29, 30),
streamed_vertex_buffer_index: __gen_unuint(input[2], 0, 31),
maximum_index: __gen_unuint(input[3], 0, 31),
}
}
}
impl Deserialize for _3dStateGsSvbIndex {
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: 15,
_3d_command_opcode: 1,
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 _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, 16, 31, 13);
}
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], 16, 31, 13),
}
}
}
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,
}
impl _3dStateMultisample {
pub const DWORD_LENGTH: u32 = 3;
pub const CENTER: u32 = 0;
pub const NUMSAMPLES_1: u32 = 0;
pub const NUMSAMPLES_4: u32 = 2;
pub const UL_CORNER: u32 = 1;
}
impl Default for _3dStateMultisample {
fn default() -> Self {
_3dStateMultisample {
dword_length: 1,
_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(),
}
}
}
impl Serialize for _3dStateMultisample {
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.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);
}
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 _3dStateMultisample {
fn from(input: &[u32; 3]) -> 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),
}
}
}
impl Deserialize for _3dStateMultisample {
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 _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 _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, 3);
}
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, 3),
}
}
}
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 _3dStateSamplerStatePointers {
pub dword_length: u32,
pub vs_sampler_state_change: u32,
pub gs_sampler_state_change: u32,
pub ps_sampler_state_change: 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,
pub pointer_to_gs_sampler_state: u64,
pub pointer_to_ps_sampler_state: u64,
}
impl _3dStateSamplerStatePointers {
pub const DWORD_LENGTH: u32 = 4;
}
impl Default for _3dStateSamplerStatePointers {
fn default() -> Self {
_3dStateSamplerStatePointers {
dword_length: 2,
vs_sampler_state_change: Default::default(),
gs_sampler_state_change: Default::default(),
ps_sampler_state_change: Default::default(),
_3d_command_sub_opcode: 2,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
pointer_to_vs_sampler_state: Default::default(),
pointer_to_gs_sampler_state: Default::default(),
pointer_to_ps_sampler_state: Default::default(),
}
}
}
impl Serialize for _3dStateSamplerStatePointers {
type Out = [u32; 4];
fn pack_into(&self, out: &mut [u32; 4]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self.vs_sampler_state_change, 8, 8) |
__gen_uint(self.gs_sampler_state_change, 9, 9) |
__gen_uint(self.ps_sampler_state_change, 12, 12) |
__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);
out[2] = __gen_offset(self.pointer_to_gs_sampler_state as u32, 5, 31);
out[3] = __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; 4];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 4] as *const [u8; 16]) })
}
}
impl From<&[u32; 4]> for _3dStateSamplerStatePointers {
fn from(input: &[u32; 4]) -> Self {
_3dStateSamplerStatePointers {
dword_length: __gen_unuint(input[0], 0, 7),
vs_sampler_state_change: __gen_unuint(input[0], 8, 8),
gs_sampler_state_change: __gen_unuint(input[0], 9, 9),
ps_sampler_state_change: __gen_unuint(input[0], 12, 12),
_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,
pointer_to_gs_sampler_state: (__gen_unuint(input[2], 5, 31) as u64) << 5,
pointer_to_ps_sampler_state: (__gen_unuint(input[3], 5, 31) as u64) << 5,
}
}
}
impl Deserialize for _3dStateSamplerStatePointers {
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 _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 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 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 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,
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 _3dStateSf {
pub const DWORD_LENGTH: u32 = 20;
pub const AALINEDISTANCE_TRUE: u32 = 1;
pub const BACK: u32 = 3;
pub const BOTH: u32 = 0;
pub const FRONT: u32 = 2;
pub const FRONTWINDING_CCW: u32 = 1;
pub const FRONTWINDING_CW: u32 = 0;
pub const LOWERLEFT: u32 = 1;
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 UPPERLEFT: u32 = 0;
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_SUB_PIXEL_PRECISION_BITS: u32 = 1;
pub const _8_SUB_PIXEL_PRECISION_BITS: u32 = 0;
}
impl Default for _3dStateSf {
fn default() -> Self {
_3dStateSf {
dword_length: 18,
_3d_command_sub_opcode: 19,
_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(),
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(),
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(),
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 _3dStateSf {
type Out = [u32; 20];
fn pack_into(&self, out: &mut [u32; 20]) {
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);
out[2] = __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);
out[3] = __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[4] = __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[5] = self.global_depth_offset_constant.to_bits();
out[6] = self.global_depth_offset_scale.to_bits();
out[7] = self.global_depth_offset_clamp.to_bits();
let mut v8_0 = [0_u32; 1];
self.attribute[0].pack_into(&mut v8_0);
let mut v8_1 = [0_u32; 1];
self.attribute[1].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[2].pack_into(&mut v9_0);
let mut v9_1 = [0_u32; 1];
self.attribute[3].pack_into(&mut v9_1);
out[9] = __gen_uint(v9_0[0], 0, 15) |
__gen_uint(v9_1[0], 16, 31);
let mut v10_0 = [0_u32; 1];
self.attribute[4].pack_into(&mut v10_0);
let mut v10_1 = [0_u32; 1];
self.attribute[5].pack_into(&mut v10_1);
out[10] = __gen_uint(v10_0[0], 0, 15) |
__gen_uint(v10_1[0], 16, 31);
let mut v11_0 = [0_u32; 1];
self.attribute[6].pack_into(&mut v11_0);
let mut v11_1 = [0_u32; 1];
self.attribute[7].pack_into(&mut v11_1);
out[11] = __gen_uint(v11_0[0], 0, 15) |
__gen_uint(v11_1[0], 16, 31);
let mut v12_0 = [0_u32; 1];
self.attribute[8].pack_into(&mut v12_0);
let mut v12_1 = [0_u32; 1];
self.attribute[9].pack_into(&mut v12_1);
out[12] = __gen_uint(v12_0[0], 0, 15) |
__gen_uint(v12_1[0], 16, 31);
let mut v13_0 = [0_u32; 1];
self.attribute[10].pack_into(&mut v13_0);
let mut v13_1 = [0_u32; 1];
self.attribute[11].pack_into(&mut v13_1);
out[13] = __gen_uint(v13_0[0], 0, 15) |
__gen_uint(v13_1[0], 16, 31);
let mut v14_0 = [0_u32; 1];
self.attribute[12].pack_into(&mut v14_0);
let mut v14_1 = [0_u32; 1];
self.attribute[13].pack_into(&mut v14_1);
out[14] = __gen_uint(v14_0[0], 0, 15) |
__gen_uint(v14_1[0], 16, 31);
let mut v15_0 = [0_u32; 1];
self.attribute[14].pack_into(&mut v15_0);
let mut v15_1 = [0_u32; 1];
self.attribute[15].pack_into(&mut v15_1);
out[15] = __gen_uint(v15_0[0], 0, 15) |
__gen_uint(v15_1[0], 16, 31);
out[16] = __gen_uint(self.point_sprite_texture_coordinate_enable, 0, 31);
out[17] = __gen_uint(self.constant_interpolation_enable, 0, 31);
out[18] = __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[19] = __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; 20];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 20] as *const [u8; 80]) })
}
}
impl From<&[u32; 20]> for _3dStateSf {
fn from(input: &[u32; 20]) -> 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),
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),
front_winding: __gen_unuint(input[2], 0, 0),
viewport_transform_enable: __gen_unuint(input[2], 1, 1) != 0,
backface_fill_mode: __gen_unuint(input[2], 3, 4),
frontface_fill_mode: __gen_unuint(input[2], 5, 6),
global_depth_offset_enable_point: __gen_unuint(input[2], 7, 7) != 0,
global_depth_offset_enable_wireframe: __gen_unuint(input[2], 8, 8) != 0,
global_depth_offset_enable_solid: __gen_unuint(input[2], 9, 9) != 0,
statistics_enable: __gen_unuint(input[2], 10, 10) != 0,
legacy_global_depth_bias_enable: __gen_unuint(input[2], 11, 11) != 0,
multisample_rasterization_mode: __gen_unuint(input[3], 8, 9),
scissor_rectangle_enable: __gen_unuint(input[3], 11, 11) != 0,
line_end_cap_antialiasing_region_width: __gen_unuint(input[3], 16, 17),
line_width: __gen_unufixed(input[3], 18, 27, 7),
cull_mode: __gen_unuint(input[3], 29, 30),
antialiasing_enable: __gen_unuint(input[3], 31, 31) != 0,
point_width: __gen_unufixed(input[4], 0, 10, 3),
point_width_source: __gen_unuint(input[4], 11, 11),
vertex_sub_pixel_precision_select: __gen_unuint(input[4], 12, 12),
aa_line_distance_mode: __gen_unuint(input[4], 14, 14),
triangle_fan_provoking_vertex_select: __gen_unuint(input[4], 25, 26),
line_strip_list_provoking_vertex_select: __gen_unuint(input[4], 27, 28),
triangle_strip_list_provoking_vertex_select: __gen_unuint(input[4], 29, 30),
last_pixel_enable: __gen_unuint(input[4], 31, 31) != 0,
global_depth_offset_constant: f32::from_bits(input[5]),
global_depth_offset_scale: f32::from_bits(input[6]),
global_depth_offset_clamp: f32::from_bits(input[7]),
attribute: [
{{
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()
}},
{{
let [_, _, _, _, _, _, _, _, _, _, ref in10 @ .., _, _, _, _, _, _, _, _, _] = input;
in10.into()
}},
{{
let i: [u32; 1] = [__gen_unuint(input[10], 16, 31)];
(&i).into()
}},
{{
let [_, _, _, _, _, _, _, _, _, _, _, ref in11 @ .., _, _, _, _, _, _, _, _] = input;
in11.into()
}},
{{
let i: [u32; 1] = [__gen_unuint(input[11], 16, 31)];
(&i).into()
}},
{{
let [_, _, _, _, _, _, _, _, _, _, _, _, ref in12 @ .., _, _, _, _, _, _, _] = input;
in12.into()
}},
{{
let i: [u32; 1] = [__gen_unuint(input[12], 16, 31)];
(&i).into()
}},
{{
let [_, _, _, _, _, _, _, _, _, _, _, _, _, ref in13 @ .., _, _, _, _, _, _] = input;
in13.into()
}},
{{
let i: [u32; 1] = [__gen_unuint(input[13], 16, 31)];
(&i).into()
}},
{{
let [_, _, _, _, _, _, _, _, _, _, _, _, _, _, ref in14 @ .., _, _, _, _, _] = input;
in14.into()
}},
{{
let i: [u32; 1] = [__gen_unuint(input[14], 16, 31)];
(&i).into()
}},
{{
let [_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, ref in15 @ .., _, _, _, _] = input;
in15.into()
}},
{{
let i: [u32; 1] = [__gen_unuint(input[15], 16, 31)];
(&i).into()
}}
],
point_sprite_texture_coordinate_enable: __gen_unuint(input[16], 0, 31),
constant_interpolation_enable: __gen_unuint(input[17], 0, 31),
attribute_0_wrapshortest_enables: __gen_unuint(input[18], 0, 3),
attribute_1_wrapshortest_enables: __gen_unuint(input[18], 4, 7),
attribute_2_wrapshortest_enables: __gen_unuint(input[18], 8, 11),
attribute_3_wrapshortest_enables: __gen_unuint(input[18], 12, 15),
attribute_4_wrapshortest_enables: __gen_unuint(input[18], 16, 19),
attribute_5_wrapshortest_enables: __gen_unuint(input[18], 20, 23),
attribute_6_wrapshortest_enables: __gen_unuint(input[18], 24, 27),
attribute_7_wrapshortest_enables: __gen_unuint(input[18], 28, 31),
attribute_8_wrapshortest_enables: __gen_unuint(input[19], 0, 3),
attribute_9_wrapshortest_enables: __gen_unuint(input[19], 4, 7),
attribute_10_wrapshortest_enables: __gen_unuint(input[19], 8, 11),
attribute_11_wrapshortest_enables: __gen_unuint(input[19], 12, 15),
attribute_12_wrapshortest_enables: __gen_unuint(input[19], 16, 19),
attribute_13_wrapshortest_enables: __gen_unuint(input[19], 20, 23),
attribute_14_wrapshortest_enables: __gen_unuint(input[19], 24, 27),
attribute_15_wrapshortest_enables: __gen_unuint(input[19], 28, 31),
}
}
}
impl Deserialize for _3dStateSf {
fn read_from<R: std::io::Read>(read: &mut R) -> std::io::Result<Self> {
let mut input = [0_u32; 20];
read.read_exact(unsafe { &mut *(&mut input as *mut [u32; 20] as *mut [u8; 80]) })?;
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: 14,
_3d_command_opcode: 1,
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 _3dStateUrb {
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 gs_urb_entry_allocation_size: u32,
pub gs_number_of_urb_entries: u32,
}
impl _3dStateUrb {
pub const DWORD_LENGTH: u32 = 3;
}
impl Default for _3dStateUrb {
fn default() -> Self {
_3dStateUrb {
dword_length: 1,
_3d_command_sub_opcode: 5,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
vs_number_of_urb_entries: Default::default(),
vs_urb_entry_allocation_size: Default::default(),
gs_urb_entry_allocation_size: Default::default(),
gs_number_of_urb_entries: Default::default(),
}
}
}
impl Serialize for _3dStateUrb {
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.vs_number_of_urb_entries, 0, 15) |
__gen_uint(self.vs_urb_entry_allocation_size, 16, 23);
out[2] = __gen_uint(self.gs_urb_entry_allocation_size, 0, 2) |
__gen_uint(self.gs_number_of_urb_entries, 8, 17);
}
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 _3dStateUrb {
fn from(input: &[u32; 3]) -> Self {
_3dStateUrb {
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, 23),
gs_urb_entry_allocation_size: __gen_unuint(input[2], 0, 2),
gs_number_of_urb_entries: __gen_unuint(input[2], 8, 17),
}
}
}
impl Deserialize for _3dStateUrb {
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 _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 _3dStateViewportStatePointers {
pub dword_length: u32,
pub clip_viewport_state_change: u32,
pub sf_viewport_state_change: u32,
pub cc_viewport_state_change: u32,
pub _3d_command_sub_opcode: u32,
pub _3d_command_opcode: u32,
pub command_subtype: u32,
pub command_type: u32,
pub pointer_to_clip_viewport: u64,
pub pointer_to_sf_viewport: u64,
pub pointer_to_cc_viewport: u64,
}
impl _3dStateViewportStatePointers {
pub const DWORD_LENGTH: u32 = 4;
}
impl Default for _3dStateViewportStatePointers {
fn default() -> Self {
_3dStateViewportStatePointers {
dword_length: 2,
clip_viewport_state_change: Default::default(),
sf_viewport_state_change: Default::default(),
cc_viewport_state_change: Default::default(),
_3d_command_sub_opcode: 13,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
pointer_to_clip_viewport: Default::default(),
pointer_to_sf_viewport: Default::default(),
pointer_to_cc_viewport: Default::default(),
}
}
}
impl Serialize for _3dStateViewportStatePointers {
type Out = [u32; 4];
fn pack_into(&self, out: &mut [u32; 4]) {
out[0] = __gen_uint(self.dword_length, 0, 7) |
__gen_uint(self.clip_viewport_state_change, 10, 10) |
__gen_uint(self.sf_viewport_state_change, 11, 11) |
__gen_uint(self.cc_viewport_state_change, 12, 12) |
__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_clip_viewport as u32, 5, 31);
out[2] = __gen_offset(self.pointer_to_sf_viewport as u32, 5, 31);
out[3] = __gen_offset(self.pointer_to_cc_viewport as u32, 5, 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 _3dStateViewportStatePointers {
fn from(input: &[u32; 4]) -> Self {
_3dStateViewportStatePointers {
dword_length: __gen_unuint(input[0], 0, 7),
clip_viewport_state_change: __gen_unuint(input[0], 10, 10),
sf_viewport_state_change: __gen_unuint(input[0], 11, 11),
cc_viewport_state_change: __gen_unuint(input[0], 12, 12),
_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_clip_viewport: (__gen_unuint(input[1], 5, 31) as u64) << 5,
pointer_to_sf_viewport: (__gen_unuint(input[2], 5, 31) as u64) << 5,
pointer_to_cc_viewport: (__gen_unuint(input[3], 5, 31) as u64) << 5,
}
}
}
impl Deserialize for _3dStateViewportStatePointers {
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 _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<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 maskstack_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_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 hierarchical_depth_buffer_resolve_enable: bool,
pub depth_buffer_resolve_enable: bool,
pub depth_buffer_clear: bool,
pub statistics_enable: bool,
pub _8_pixel_dispatch_enable: bool,
pub _16_pixel_dispatch_enable: bool,
pub _32_pixel_dispatch_enable: bool,
pub dual_source_blend_enable: bool,
pub pixel_shader_uses_source_w: bool,
pub omask_present_to_rendertarget: bool,
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 thread_dispatch_enable: bool,
pub pixel_shader_uses_source_depth: bool,
pub pixel_shader_computed_depth: bool,
pub pixel_shader_kills_pixel: bool,
pub legacy_diamond_line_rasterization: bool,
pub maximum_number_of_threads: u32,
pub multisample_dispatch_mode: u32,
pub multisample_rasterization_mode: u32,
pub point_rasterization_rule: u32,
pub barycentric_interpolation_mode: u32,
pub position_zw_interpolation_mode: u32,
pub position_xy_offset_select: u32,
pub number_of_sf_output_attributes: u32,
pub kernel_start_pointer_1: u64,
pub kernel_start_pointer_2: u64,
}
impl<A: Addr + Default> _3dStateWm<A> {
pub const DWORD_LENGTH: u32 = 9;
pub const ALTERNATE: u32 = 1;
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 HIGH: u32 = 1;
pub const IEEE_745: u32 = 0;
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 POSOFFSET_CENTROID: u32 = 2;
pub const POSOFFSET_NONE: u32 = 0;
pub const POSOFFSET_SAMPLE: 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<A: Addr + Default> Default for _3dStateWm<A> {
fn default() -> Self {
_3dStateWm {
dword_length: 7,
_3d_command_sub_opcode: 20,
_3d_command_opcode: 0,
command_subtype: 3,
command_type: 3,
kernel_start_pointer_0: Default::default(),
software_exception_enable: Default::default(),
maskstack_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_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(),
hierarchical_depth_buffer_resolve_enable: Default::default(),
depth_buffer_resolve_enable: Default::default(),
depth_buffer_clear: Default::default(),
statistics_enable: Default::default(),
_8_pixel_dispatch_enable: Default::default(),
_16_pixel_dispatch_enable: Default::default(),
_32_pixel_dispatch_enable: Default::default(),
dual_source_blend_enable: Default::default(),
pixel_shader_uses_source_w: Default::default(),
omask_present_to_rendertarget: 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(),
thread_dispatch_enable: Default::default(),
pixel_shader_uses_source_depth: Default::default(),
pixel_shader_computed_depth: Default::default(),
pixel_shader_kills_pixel: Default::default(),
legacy_diamond_line_rasterization: Default::default(),
maximum_number_of_threads: Default::default(),
multisample_dispatch_mode: Default::default(),
multisample_rasterization_mode: Default::default(),
point_rasterization_rule: Default::default(),
barycentric_interpolation_mode: Default::default(),
position_zw_interpolation_mode: Default::default(),
position_xy_offset_select: Default::default(),
number_of_sf_output_attributes: Default::default(),
kernel_start_pointer_1: Default::default(),
kernel_start_pointer_2: Default::default(),
}
}
}
impl<A: Addr + Default> Serialize for _3dStateWm<A> {
type Out = [u32; 9];
fn pack_into(&self, out: &mut [u32; 9]) {
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.maskstack_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_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) |
__gen_uint(self.hierarchical_depth_buffer_resolve_enable.into(), 27, 27) |
__gen_uint(self.depth_buffer_resolve_enable.into(), 28, 28) |
__gen_uint(self.depth_buffer_clear.into(), 30, 30) |
__gen_uint(self.statistics_enable.into(), 31, 31);
out[5] = __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.dual_source_blend_enable.into(), 7, 7) |
__gen_uint(self.pixel_shader_uses_source_w.into(), 8, 8) |
__gen_uint(self.omask_present_to_rendertarget.into(), 9, 9) |
__gen_uint(self.line_stipple_enable.into(), 11, 11) |
__gen_uint(self.polygon_stipple_enable.into(), 13, 13) |
__gen_uint(self.line_antialiasing_region_width, 14, 15) |
__gen_uint(self.line_end_cap_antialiasing_region_width, 16, 17) |
__gen_uint(self.thread_dispatch_enable.into(), 19, 19) |
__gen_uint(self.pixel_shader_uses_source_depth.into(), 20, 20) |
__gen_uint(self.pixel_shader_computed_depth.into(), 21, 21) |
__gen_uint(self.pixel_shader_kills_pixel.into(), 22, 22) |
__gen_uint(self.legacy_diamond_line_rasterization.into(), 23, 23) |
__gen_uint(self.maximum_number_of_threads, 25, 31);
out[6] = __gen_uint(self.multisample_dispatch_mode, 0, 0) |
__gen_uint(self.multisample_rasterization_mode, 1, 2) |
__gen_uint(self.point_rasterization_rule, 9, 9) |
__gen_uint(self.barycentric_interpolation_mode, 10, 15) |
__gen_uint(self.position_zw_interpolation_mode, 16, 17) |
__gen_uint(self.position_xy_offset_select, 18, 19) |
__gen_uint(self.number_of_sf_output_attributes, 20, 25);
out[7] = __gen_offset(self.kernel_start_pointer_1 as u32, 6, 31);
out[8] = __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; 9];
self.pack_into(&mut out);
write.write_all(unsafe { &*(&out as *const [u32; 9] as *const [u8; 36]) })
}
}
impl From<&[u32; 9]> for _3dStateWm<u64> {
fn from(input: &[u32; 9]) -> 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),
kernel_start_pointer_0: (__gen_unuint(input[1], 6, 31) as u64) << 6,
software_exception_enable: __gen_unuint(input[2], 7, 7) != 0,
maskstack_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_constant_setup_data_2: __gen_unuint(input[4], 0, 6),
dispatch_grf_start_register_for_constant_setup_data_1: __gen_unuint(input[4], 8, 14),
dispatch_grf_start_register_for_constant_setup_data_0: __gen_unuint(input[4], 16, 22),
hierarchical_depth_buffer_resolve_enable: __gen_unuint(input[4], 27, 27) != 0,
depth_buffer_resolve_enable: __gen_unuint(input[4], 28, 28) != 0,
depth_buffer_clear: __gen_unuint(input[4], 30, 30) != 0,
statistics_enable: __gen_unuint(input[4], 31, 31) != 0,
_8_pixel_dispatch_enable: __gen_unuint(input[5], 0, 0) != 0,
_16_pixel_dispatch_enable: __gen_unuint(input[5], 1, 1) != 0,
_32_pixel_dispatch_enable: __gen_unuint(input[5], 2, 2) != 0,
dual_source_blend_enable: __gen_unuint(input[5], 7, 7) != 0,
pixel_shader_uses_source_w: __gen_unuint(input[5], 8, 8) != 0,
omask_present_to_rendertarget: __gen_unuint(input[5], 9, 9) != 0,
line_stipple_enable: __gen_unuint(input[5], 11, 11) != 0,
polygon_stipple_enable: __gen_unuint(input[5], 13, 13) != 0,
line_antialiasing_region_width: __gen_unuint(input[5], 14, 15),
line_end_cap_antialiasing_region_width: __gen_unuint(input[5], 16, 17),
thread_dispatch_enable: __gen_unuint(input[5], 19, 19) != 0,
pixel_shader_uses_source_depth: __gen_unuint(input[5], 20, 20) != 0,
pixel_shader_computed_depth: __gen_unuint(input[5], 21, 21) != 0,
pixel_shader_kills_pixel: __gen_unuint(input[5], 22, 22) != 0,
legacy_diamond_line_rasterization: __gen_unuint(input[5], 23, 23) != 0,
maximum_number_of_threads: __gen_unuint(input[5], 25, 31),
multisample_dispatch_mode: __gen_unuint(input[6], 0, 0),
multisample_rasterization_mode: __gen_unuint(input[6], 1, 2),
point_rasterization_rule: __gen_unuint(input[6], 9, 9),
barycentric_interpolation_mode: __gen_unuint(input[6], 10, 15),
position_zw_interpolation_mode: __gen_unuint(input[6], 16, 17),
position_xy_offset_select: __gen_unuint(input[6], 18, 19),
number_of_sf_output_attributes: __gen_unuint(input[6], 20, 25),
kernel_start_pointer_1: (__gen_unuint(input[7], 6, 31) as u64) << 6,
kernel_start_pointer_2: (__gen_unuint(input[8], 6, 31) as u64) << 6,
}
}
}
impl Deserialize for _3dStateWm<u64> {
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())
}
}
}