AM_MPEGSYSTEMTYPE

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct AM_MEDIA_TYPE
{
    public Guid majortype;
    public Guid subtype;
    [MarshalAs(UnmanagedType.Bool)] public bool bFixedSizeSamples;
    [MarshalAs(UnmanagedType.Bool)] public bool bTemporalCompression;
    public uint lSampleSize;
    public Guid formattype;
    public IntPtr pUnk;
    public uint cbFormat;
    public IntPtr pbFormat;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct AM_MPEGSTREAMTYPE
{
    public uint dwStreamId;
    public uint dwReserved;
    public AM_MEDIA_TYPE mt;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)] public byte[] bFormat;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct AM_MPEGSYSTEMTYPE
{
    public uint dwBitRate;
    public uint cStreams;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)] public AM_MPEGSTREAMTYPE[] Streams;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure AM_MEDIA_TYPE
    Public majortype As Guid
    Public subtype As Guid
    <MarshalAs(UnmanagedType.Bool)> Public bFixedSizeSamples As Boolean
    <MarshalAs(UnmanagedType.Bool)> Public bTemporalCompression As Boolean
    Public lSampleSize As UInteger
    Public formattype As Guid
    Public pUnk As IntPtr
    Public cbFormat As UInteger
    Public pbFormat As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure AM_MPEGSTREAMTYPE
    Public dwStreamId As UInteger
    Public dwReserved As UInteger
    Public mt As AM_MEDIA_TYPE
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=1)> Public bFormat() As Byte
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure AM_MPEGSYSTEMTYPE
    Public dwBitRate As UInteger
    Public cStreams As UInteger
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=1)> Public Streams() As AM_MPEGSTREAMTYPE
End Structure

import ctypes
from ctypes import wintypes

class AM_MEDIA_TYPE(ctypes.Structure):
    _fields_ = [
        ("majortype", GUID),
        ("subtype", GUID),
        ("bFixedSizeSamples", wintypes.BOOL),
        ("bTemporalCompression", wintypes.BOOL),
        ("lSampleSize", wintypes.DWORD),
        ("formattype", GUID),
        ("pUnk", ctypes.c_void_p),
        ("cbFormat", wintypes.DWORD),
        ("pbFormat", ctypes.c_void_p),
    ]

class AM_MPEGSTREAMTYPE(ctypes.Structure):
    _fields_ = [
        ("dwStreamId", wintypes.DWORD),
        ("dwReserved", wintypes.DWORD),
        ("mt", AM_MEDIA_TYPE),
        ("bFormat", ctypes.c_ubyte * 1),
    ]

class AM_MPEGSYSTEMTYPE(ctypes.Structure):
    _fields_ = [
        ("dwBitRate", wintypes.DWORD),
        ("cStreams", wintypes.DWORD),
        ("Streams", AM_MPEGSTREAMTYPE * 1),
    ]

#[repr(C)]
pub struct AM_MEDIA_TYPE {
    pub majortype: GUID,
    pub subtype: GUID,
    pub bFixedSizeSamples: i32,
    pub bTemporalCompression: i32,
    pub lSampleSize: u32,
    pub formattype: GUID,
    pub pUnk: *mut core::ffi::c_void,
    pub cbFormat: u32,
    pub pbFormat: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct AM_MPEGSTREAMTYPE {
    pub dwStreamId: u32,
    pub dwReserved: u32,
    pub mt: AM_MEDIA_TYPE,
    pub bFormat: [u8; 1],
}

#[repr(C)]
pub struct AM_MPEGSYSTEMTYPE {
    pub dwBitRate: u32,
    pub cStreams: u32,
    pub Streams: [AM_MPEGSTREAMTYPE; 1],
}

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

type AM_MEDIA_TYPE struct {
	majortype windows.GUID
	subtype windows.GUID
	bFixedSizeSamples int32
	bTemporalCompression int32
	lSampleSize uint32
	formattype windows.GUID
	pUnk uintptr
	cbFormat uint32
	pbFormat uintptr
}

type AM_MPEGSTREAMTYPE struct {
	dwStreamId uint32
	dwReserved uint32
	mt AM_MEDIA_TYPE
	bFormat [1]byte
}

type AM_MPEGSYSTEMTYPE struct {
	dwBitRate uint32
	cStreams uint32
	Streams [1]AM_MPEGSTREAMTYPE
}

type
  AM_MEDIA_TYPE = record
    majortype: TGUID;
    subtype: TGUID;
    bFixedSizeSamples: BOOL;
    bTemporalCompression: BOOL;
    lSampleSize: DWORD;
    formattype: TGUID;
    pUnk: Pointer;
    cbFormat: DWORD;
    pbFormat: Pointer;
  end;

  AM_MPEGSTREAMTYPE = record
    dwStreamId: DWORD;
    dwReserved: DWORD;
    mt: AM_MEDIA_TYPE;
    bFormat: array[0..0] of Byte;
  end;

  AM_MPEGSYSTEMTYPE = record
    dwBitRate: DWORD;
    cStreams: DWORD;
    Streams: array[0..0] of AM_MPEGSTREAMTYPE;
  end;

const AM_MEDIA_TYPE = extern struct {
    majortype: GUID,
    subtype: GUID,
    bFixedSizeSamples: i32,
    bTemporalCompression: i32,
    lSampleSize: u32,
    formattype: GUID,
    pUnk: ?*anyopaque,
    cbFormat: u32,
    pbFormat: ?*anyopaque,
};

const AM_MPEGSTREAMTYPE = extern struct {
    dwStreamId: u32,
    dwReserved: u32,
    mt: AM_MEDIA_TYPE,
    bFormat: [1]u8,
};

const AM_MPEGSYSTEMTYPE = extern struct {
    dwBitRate: u32,
    cStreams: u32,
    Streams: [1]AM_MPEGSTREAMTYPE,
};

type
  AM_MEDIA_TYPE {.bycopy.} = object
    majortype: GUID
    subtype: GUID
    bFixedSizeSamples: int32
    bTemporalCompression: int32
    lSampleSize: uint32
    formattype: GUID
    pUnk: pointer
    cbFormat: uint32
    pbFormat: pointer

  AM_MPEGSTREAMTYPE {.bycopy.} = object
    dwStreamId: uint32
    dwReserved: uint32
    mt: AM_MEDIA_TYPE
    bFormat: array[1, uint8]

  AM_MPEGSYSTEMTYPE {.bycopy.} = object
    dwBitRate: uint32
    cStreams: uint32
    Streams: array[1, AM_MPEGSTREAMTYPE]

struct AM_MEDIA_TYPE
{
    GUID majortype;
    GUID subtype;
    int bFixedSizeSamples;
    int bTemporalCompression;
    uint lSampleSize;
    GUID formattype;
    void* pUnk;
    uint cbFormat;
    void* pbFormat;
}

struct AM_MPEGSTREAMTYPE
{
    uint dwStreamId;
    uint dwReserved;
    AM_MEDIA_TYPE mt;
    ubyte[1] bFormat;
}

struct AM_MPEGSYSTEMTYPE
{
    uint dwBitRate;
    uint cStreams;
    AM_MPEGSTREAMTYPE[1] Streams;
}