MIDIOPENDESC

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode)]
public struct MIDIOPENSTRMID
{
    public uint dwStreamID;
    public uint uDeviceID;
}

[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode)]
public struct MIDIOPENDESC
{
    public IntPtr hMidi;
    public UIntPtr dwCallback;
    public UIntPtr dwInstance;
    public UIntPtr dnDevNode;
    public uint cIds;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)] public MIDIOPENSTRMID[] rgIds;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, Pack:=1, CharSet:=CharSet.Unicode)>
Public Structure MIDIOPENSTRMID
    Public dwStreamID As UInteger
    Public uDeviceID As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, Pack:=1, CharSet:=CharSet.Unicode)>
Public Structure MIDIOPENDESC
    Public hMidi As IntPtr
    Public dwCallback As UIntPtr
    Public dwInstance As UIntPtr
    Public dnDevNode As UIntPtr
    Public cIds As UInteger
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=1)> Public rgIds() As MIDIOPENSTRMID
End Structure

import ctypes
from ctypes import wintypes

class MIDIOPENSTRMID(ctypes.Structure):
    _pack_ = 1
    _fields_ = [
        ("dwStreamID", wintypes.DWORD),
        ("uDeviceID", wintypes.DWORD),
    ]

class MIDIOPENDESC(ctypes.Structure):
    _pack_ = 1
    _fields_ = [
        ("hMidi", ctypes.c_void_p),
        ("dwCallback", ctypes.c_size_t),
        ("dwInstance", ctypes.c_size_t),
        ("dnDevNode", ctypes.c_size_t),
        ("cIds", wintypes.DWORD),
        ("rgIds", MIDIOPENSTRMID * 1),
    ]

#[repr(C, packed(1))]
pub struct MIDIOPENSTRMID {
    pub dwStreamID: u32,
    pub uDeviceID: u32,
}

#[repr(C, packed(1))]
pub struct MIDIOPENDESC {
    pub hMidi: *mut core::ffi::c_void,
    pub dwCallback: usize,
    pub dwInstance: usize,
    pub dnDevNode: usize,
    pub cIds: u32,
    pub rgIds: [MIDIOPENSTRMID; 1],
}

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

type MIDIOPENSTRMID struct {
	dwStreamID uint32
	uDeviceID uint32
}

type MIDIOPENDESC struct {
	hMidi uintptr
	dwCallback uintptr
	dwInstance uintptr
	dnDevNode uintptr
	cIds uint32
	rgIds [1]MIDIOPENSTRMID
}

type
  MIDIOPENSTRMID = packed record
    dwStreamID: DWORD;
    uDeviceID: DWORD;
  end;

  MIDIOPENDESC = packed record
    hMidi: Pointer;
    dwCallback: NativeUInt;
    dwInstance: NativeUInt;
    dnDevNode: NativeUInt;
    cIds: DWORD;
    rgIds: array[0..0] of MIDIOPENSTRMID;
  end;

const MIDIOPENSTRMID = extern struct {
    dwStreamID: u32,
    uDeviceID: u32,
};

const MIDIOPENDESC = extern struct {
    hMidi: ?*anyopaque,
    dwCallback: usize,
    dwInstance: usize,
    dnDevNode: usize,
    cIds: u32,
    rgIds: [1]MIDIOPENSTRMID,
};

type
  MIDIOPENSTRMID {.packed.} = object
    dwStreamID: uint32
    uDeviceID: uint32

  MIDIOPENDESC {.packed.} = object
    hMidi: pointer
    dwCallback: uint
    dwInstance: uint
    dnDevNode: uint
    cIds: uint32
    rgIds: array[1, MIDIOPENSTRMID]

align(1)
struct MIDIOPENSTRMID
{
    uint dwStreamID;
    uint uDeviceID;
}

align(1)
struct MIDIOPENDESC
{
    void* hMidi;
    size_t dwCallback;
    size_t dwInstance;
    size_t dnDevNode;
    uint cIds;
    MIDIOPENSTRMID[1] rgIds;
}