WAVEHDR

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode)]
public struct WAVEHDR
{
    public IntPtr lpData;
    public uint dwBufferLength;
    public uint dwBytesRecorded;
    public UIntPtr dwUser;
    public uint dwFlags;
    public uint dwLoops;
    public IntPtr lpNext;
    public UIntPtr reserved;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, Pack:=1, CharSet:=CharSet.Unicode)>
Public Structure WAVEHDR
    Public lpData As IntPtr
    Public dwBufferLength As UInteger
    Public dwBytesRecorded As UInteger
    Public dwUser As UIntPtr
    Public dwFlags As UInteger
    Public dwLoops As UInteger
    Public lpNext As IntPtr
    Public reserved As UIntPtr
End Structure

import ctypes
from ctypes import wintypes

class WAVEHDR(ctypes.Structure):
    _pack_ = 1
    _fields_ = [
        ("lpData", ctypes.c_void_p),
        ("dwBufferLength", wintypes.DWORD),
        ("dwBytesRecorded", wintypes.DWORD),
        ("dwUser", ctypes.c_size_t),
        ("dwFlags", wintypes.DWORD),
        ("dwLoops", wintypes.DWORD),
        ("lpNext", ctypes.c_void_p),
        ("reserved", ctypes.c_size_t),
    ]

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

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

type WAVEHDR struct {
	lpData uintptr
	dwBufferLength uint32
	dwBytesRecorded uint32
	dwUser uintptr
	dwFlags uint32
	dwLoops uint32
	lpNext uintptr
	reserved uintptr
}

type
  WAVEHDR = packed record
    lpData: Pointer;
    dwBufferLength: DWORD;
    dwBytesRecorded: DWORD;
    dwUser: NativeUInt;
    dwFlags: DWORD;
    dwLoops: DWORD;
    lpNext: Pointer;
    reserved: NativeUInt;
  end;

const WAVEHDR = extern struct {
    lpData: ?*anyopaque,
    dwBufferLength: u32,
    dwBytesRecorded: u32,
    dwUser: usize,
    dwFlags: u32,
    dwLoops: u32,
    lpNext: ?*anyopaque,
    reserved: usize,
};

type
  WAVEHDR {.packed.} = object
    lpData: pointer
    dwBufferLength: uint32
    dwBytesRecorded: uint32
    dwUser: uint
    dwFlags: uint32
    dwLoops: uint32
    lpNext: pointer
    reserved: uint

align(1)
struct WAVEHDR
{
    void* lpData;
    uint dwBufferLength;
    uint dwBytesRecorded;
    size_t dwUser;
    uint dwFlags;
    uint dwLoops;
    void* lpNext;
    size_t reserved;
}