ACMSTREAMHEADER

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode)]
public struct ACMSTREAMHEADER
{
    public uint cbStruct;
    public uint fdwStatus;
    public UIntPtr dwUser;
    public IntPtr pbSrc;
    public uint cbSrcLength;
    public uint cbSrcLengthUsed;
    public UIntPtr dwSrcUser;
    public IntPtr pbDst;
    public uint cbDstLength;
    public uint cbDstLengthUsed;
    public UIntPtr dwDstUser;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 10)] public uint[] dwReservedDriver;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, Pack:=1, CharSet:=CharSet.Unicode)>
Public Structure ACMSTREAMHEADER
    Public cbStruct As UInteger
    Public fdwStatus As UInteger
    Public dwUser As UIntPtr
    Public pbSrc As IntPtr
    Public cbSrcLength As UInteger
    Public cbSrcLengthUsed As UInteger
    Public dwSrcUser As UIntPtr
    Public pbDst As IntPtr
    Public cbDstLength As UInteger
    Public cbDstLengthUsed As UInteger
    Public dwDstUser As UIntPtr
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=10)> Public dwReservedDriver() As UInteger
End Structure

import ctypes
from ctypes import wintypes

class ACMSTREAMHEADER(ctypes.Structure):
    _pack_ = 1
    _fields_ = [
        ("cbStruct", wintypes.DWORD),
        ("fdwStatus", wintypes.DWORD),
        ("dwUser", ctypes.c_size_t),
        ("pbSrc", ctypes.c_void_p),
        ("cbSrcLength", wintypes.DWORD),
        ("cbSrcLengthUsed", wintypes.DWORD),
        ("dwSrcUser", ctypes.c_size_t),
        ("pbDst", ctypes.c_void_p),
        ("cbDstLength", wintypes.DWORD),
        ("cbDstLengthUsed", wintypes.DWORD),
        ("dwDstUser", ctypes.c_size_t),
        ("dwReservedDriver", wintypes.DWORD * 10),
    ]

#[repr(C, packed(1))]
pub struct ACMSTREAMHEADER {
    pub cbStruct: u32,
    pub fdwStatus: u32,
    pub dwUser: usize,
    pub pbSrc: *mut core::ffi::c_void,
    pub cbSrcLength: u32,
    pub cbSrcLengthUsed: u32,
    pub dwSrcUser: usize,
    pub pbDst: *mut core::ffi::c_void,
    pub cbDstLength: u32,
    pub cbDstLengthUsed: u32,
    pub dwDstUser: usize,
    pub dwReservedDriver: [u32; 10],
}

import "golang.org/x/sys/windows"

type ACMSTREAMHEADER struct {
	cbStruct uint32
	fdwStatus uint32
	dwUser uintptr
	pbSrc uintptr
	cbSrcLength uint32
	cbSrcLengthUsed uint32
	dwSrcUser uintptr
	pbDst uintptr
	cbDstLength uint32
	cbDstLengthUsed uint32
	dwDstUser uintptr
	dwReservedDriver [10]uint32
}

type
  ACMSTREAMHEADER = packed record
    cbStruct: DWORD;
    fdwStatus: DWORD;
    dwUser: NativeUInt;
    pbSrc: Pointer;
    cbSrcLength: DWORD;
    cbSrcLengthUsed: DWORD;
    dwSrcUser: NativeUInt;
    pbDst: Pointer;
    cbDstLength: DWORD;
    cbDstLengthUsed: DWORD;
    dwDstUser: NativeUInt;
    dwReservedDriver: array[0..9] of DWORD;
  end;

const ACMSTREAMHEADER = extern struct {
    cbStruct: u32,
    fdwStatus: u32,
    dwUser: usize,
    pbSrc: ?*anyopaque,
    cbSrcLength: u32,
    cbSrcLengthUsed: u32,
    dwSrcUser: usize,
    pbDst: ?*anyopaque,
    cbDstLength: u32,
    cbDstLengthUsed: u32,
    dwDstUser: usize,
    dwReservedDriver: [10]u32,
};

type
  ACMSTREAMHEADER {.packed.} = object
    cbStruct: uint32
    fdwStatus: uint32
    dwUser: uint
    pbSrc: pointer
    cbSrcLength: uint32
    cbSrcLengthUsed: uint32
    dwSrcUser: uint
    pbDst: pointer
    cbDstLength: uint32
    cbDstLengthUsed: uint32
    dwDstUser: uint
    dwReservedDriver: array[10, uint32]

align(1)
struct ACMSTREAMHEADER
{
    uint cbStruct;
    uint fdwStatus;
    size_t dwUser;
    void* pbSrc;
    uint cbSrcLength;
    uint cbSrcLengthUsed;
    size_t dwSrcUser;
    void* pbDst;
    uint cbDstLength;
    uint cbDstLengthUsed;
    size_t dwDstUser;
    uint[10] dwReservedDriver;
}