MIDIHDR

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode)]
public struct MIDIHDR
{
    public IntPtr lpData;
    public uint dwBufferLength;
    public uint dwBytesRecorded;
    public UIntPtr dwUser;
    public uint dwFlags;
    public IntPtr lpNext;
    public UIntPtr reserved;
    public uint dwOffset;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] public UIntPtr[] dwReserved;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, Pack:=1, CharSet:=CharSet.Unicode)>
Public Structure MIDIHDR
    Public lpData As IntPtr
    Public dwBufferLength As UInteger
    Public dwBytesRecorded As UInteger
    Public dwUser As UIntPtr
    Public dwFlags As UInteger
    Public lpNext As IntPtr
    Public reserved As UIntPtr
    Public dwOffset As UInteger
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=8)> Public dwReserved() As UIntPtr
End Structure

import ctypes
from ctypes import wintypes

class MIDIHDR(ctypes.Structure):
    _pack_ = 1
    _fields_ = [
        ("lpData", ctypes.c_void_p),
        ("dwBufferLength", wintypes.DWORD),
        ("dwBytesRecorded", wintypes.DWORD),
        ("dwUser", ctypes.c_size_t),
        ("dwFlags", wintypes.DWORD),
        ("lpNext", ctypes.c_void_p),
        ("reserved", ctypes.c_size_t),
        ("dwOffset", wintypes.DWORD),
        ("dwReserved", ctypes.c_size_t * 8),
    ]

#[repr(C, packed(1))]
pub struct MIDIHDR {
    pub lpData: *mut core::ffi::c_void,
    pub dwBufferLength: u32,
    pub dwBytesRecorded: u32,
    pub dwUser: usize,
    pub dwFlags: u32,
    pub lpNext: *mut core::ffi::c_void,
    pub reserved: usize,
    pub dwOffset: u32,
    pub dwReserved: [usize; 8],
}

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

type MIDIHDR struct {
	lpData uintptr
	dwBufferLength uint32
	dwBytesRecorded uint32
	dwUser uintptr
	dwFlags uint32
	lpNext uintptr
	reserved uintptr
	dwOffset uint32
	dwReserved [8]uintptr
}

type
  MIDIHDR = packed record
    lpData: Pointer;
    dwBufferLength: DWORD;
    dwBytesRecorded: DWORD;
    dwUser: NativeUInt;
    dwFlags: DWORD;
    lpNext: Pointer;
    reserved: NativeUInt;
    dwOffset: DWORD;
    dwReserved: array[0..7] of NativeUInt;
  end;

const MIDIHDR = extern struct {
    lpData: ?*anyopaque,
    dwBufferLength: u32,
    dwBytesRecorded: u32,
    dwUser: usize,
    dwFlags: u32,
    lpNext: ?*anyopaque,
    reserved: usize,
    dwOffset: u32,
    dwReserved: [8]usize,
};

type
  MIDIHDR {.packed.} = object
    lpData: pointer
    dwBufferLength: uint32
    dwBytesRecorded: uint32
    dwUser: uint
    dwFlags: uint32
    lpNext: pointer
    reserved: uint
    dwOffset: uint32
    dwReserved: array[8, uint]

align(1)
struct MIDIHDR
{
    void* lpData;
    uint dwBufferLength;
    uint dwBytesRecorded;
    size_t dwUser;
    uint dwFlags;
    void* lpNext;
    size_t reserved;
    uint dwOffset;
    size_t[8] dwReserved;
}