COMPVARS

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct COMPVARS
{
    public int cbSize;
    public uint dwFlags;
    public IntPtr hic;
    public uint fccType;
    public uint fccHandler;
    public IntPtr lpbiIn;
    public IntPtr lpbiOut;
    public IntPtr lpBitsOut;
    public IntPtr lpBitsPrev;
    public int lFrame;
    public int lKey;
    public int lDataRate;
    public int lQ;
    public int lKeyCount;
    public IntPtr lpState;
    public int cbState;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure COMPVARS
    Public cbSize As Integer
    Public dwFlags As UInteger
    Public hic As IntPtr
    Public fccType As UInteger
    Public fccHandler As UInteger
    Public lpbiIn As IntPtr
    Public lpbiOut As IntPtr
    Public lpBitsOut As IntPtr
    Public lpBitsPrev As IntPtr
    Public lFrame As Integer
    Public lKey As Integer
    Public lDataRate As Integer
    Public lQ As Integer
    Public lKeyCount As Integer
    Public lpState As IntPtr
    Public cbState As Integer
End Structure

import ctypes
from ctypes import wintypes

class COMPVARS(ctypes.Structure):
    _fields_ = [
        ("cbSize", ctypes.c_int),
        ("dwFlags", wintypes.DWORD),
        ("hic", ctypes.c_void_p),
        ("fccType", wintypes.DWORD),
        ("fccHandler", wintypes.DWORD),
        ("lpbiIn", ctypes.c_void_p),
        ("lpbiOut", ctypes.c_void_p),
        ("lpBitsOut", ctypes.c_void_p),
        ("lpBitsPrev", ctypes.c_void_p),
        ("lFrame", ctypes.c_int),
        ("lKey", ctypes.c_int),
        ("lDataRate", ctypes.c_int),
        ("lQ", ctypes.c_int),
        ("lKeyCount", ctypes.c_int),
        ("lpState", ctypes.c_void_p),
        ("cbState", ctypes.c_int),
    ]

#[repr(C)]
pub struct COMPVARS {
    pub cbSize: i32,
    pub dwFlags: u32,
    pub hic: *mut core::ffi::c_void,
    pub fccType: u32,
    pub fccHandler: u32,
    pub lpbiIn: *mut core::ffi::c_void,
    pub lpbiOut: *mut core::ffi::c_void,
    pub lpBitsOut: *mut core::ffi::c_void,
    pub lpBitsPrev: *mut core::ffi::c_void,
    pub lFrame: i32,
    pub lKey: i32,
    pub lDataRate: i32,
    pub lQ: i32,
    pub lKeyCount: i32,
    pub lpState: *mut core::ffi::c_void,
    pub cbState: i32,
}

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

type COMPVARS struct {
	cbSize int32
	dwFlags uint32
	hic uintptr
	fccType uint32
	fccHandler uint32
	lpbiIn uintptr
	lpbiOut uintptr
	lpBitsOut uintptr
	lpBitsPrev uintptr
	lFrame int32
	lKey int32
	lDataRate int32
	lQ int32
	lKeyCount int32
	lpState uintptr
	cbState int32
}

type
  COMPVARS = record
    cbSize: Integer;
    dwFlags: DWORD;
    hic: Pointer;
    fccType: DWORD;
    fccHandler: DWORD;
    lpbiIn: Pointer;
    lpbiOut: Pointer;
    lpBitsOut: Pointer;
    lpBitsPrev: Pointer;
    lFrame: Integer;
    lKey: Integer;
    lDataRate: Integer;
    lQ: Integer;
    lKeyCount: Integer;
    lpState: Pointer;
    cbState: Integer;
  end;

const COMPVARS = extern struct {
    cbSize: i32,
    dwFlags: u32,
    hic: ?*anyopaque,
    fccType: u32,
    fccHandler: u32,
    lpbiIn: ?*anyopaque,
    lpbiOut: ?*anyopaque,
    lpBitsOut: ?*anyopaque,
    lpBitsPrev: ?*anyopaque,
    lFrame: i32,
    lKey: i32,
    lDataRate: i32,
    lQ: i32,
    lKeyCount: i32,
    lpState: ?*anyopaque,
    cbState: i32,
};

type
  COMPVARS {.bycopy.} = object
    cbSize: int32
    dwFlags: uint32
    hic: pointer
    fccType: uint32
    fccHandler: uint32
    lpbiIn: pointer
    lpbiOut: pointer
    lpBitsOut: pointer
    lpBitsPrev: pointer
    lFrame: int32
    lKey: int32
    lDataRate: int32
    lQ: int32
    lKeyCount: int32
    lpState: pointer
    cbState: int32

struct COMPVARS
{
    int cbSize;
    uint dwFlags;
    void* hic;
    uint fccType;
    uint fccHandler;
    void* lpbiIn;
    void* lpbiOut;
    void* lpBitsOut;
    void* lpBitsPrev;
    int lFrame;
    int lKey;
    int lDataRate;
    int lQ;
    int lKeyCount;
    void* lpState;
    int cbState;
}