BITMAPV4HEADER

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct CIEXYZ
{
    public int ciexyzX;
    public int ciexyzY;
    public int ciexyzZ;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct CIEXYZTRIPLE
{
    public CIEXYZ ciexyzRed;
    public CIEXYZ ciexyzGreen;
    public CIEXYZ ciexyzBlue;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct BITMAPV4HEADER
{
    public uint bV4Size;
    public int bV4Width;
    public int bV4Height;
    public ushort bV4Planes;
    public ushort bV4BitCount;
    public uint bV4V4Compression;
    public uint bV4SizeImage;
    public int bV4XPelsPerMeter;
    public int bV4YPelsPerMeter;
    public uint bV4ClrUsed;
    public uint bV4ClrImportant;
    public uint bV4RedMask;
    public uint bV4GreenMask;
    public uint bV4BlueMask;
    public uint bV4AlphaMask;
    public uint bV4CSType;
    public CIEXYZTRIPLE bV4Endpoints;
    public uint bV4GammaRed;
    public uint bV4GammaGreen;
    public uint bV4GammaBlue;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure CIEXYZ
    Public ciexyzX As Integer
    Public ciexyzY As Integer
    Public ciexyzZ As Integer
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure CIEXYZTRIPLE
    Public ciexyzRed As CIEXYZ
    Public ciexyzGreen As CIEXYZ
    Public ciexyzBlue As CIEXYZ
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure BITMAPV4HEADER
    Public bV4Size As UInteger
    Public bV4Width As Integer
    Public bV4Height As Integer
    Public bV4Planes As UShort
    Public bV4BitCount As UShort
    Public bV4V4Compression As UInteger
    Public bV4SizeImage As UInteger
    Public bV4XPelsPerMeter As Integer
    Public bV4YPelsPerMeter As Integer
    Public bV4ClrUsed As UInteger
    Public bV4ClrImportant As UInteger
    Public bV4RedMask As UInteger
    Public bV4GreenMask As UInteger
    Public bV4BlueMask As UInteger
    Public bV4AlphaMask As UInteger
    Public bV4CSType As UInteger
    Public bV4Endpoints As CIEXYZTRIPLE
    Public bV4GammaRed As UInteger
    Public bV4GammaGreen As UInteger
    Public bV4GammaBlue As UInteger
End Structure

import ctypes
from ctypes import wintypes

class CIEXYZ(ctypes.Structure):
    _fields_ = [
        ("ciexyzX", ctypes.c_int),
        ("ciexyzY", ctypes.c_int),
        ("ciexyzZ", ctypes.c_int),
    ]

class CIEXYZTRIPLE(ctypes.Structure):
    _fields_ = [
        ("ciexyzRed", CIEXYZ),
        ("ciexyzGreen", CIEXYZ),
        ("ciexyzBlue", CIEXYZ),
    ]

class BITMAPV4HEADER(ctypes.Structure):
    _fields_ = [
        ("bV4Size", wintypes.DWORD),
        ("bV4Width", ctypes.c_int),
        ("bV4Height", ctypes.c_int),
        ("bV4Planes", ctypes.c_ushort),
        ("bV4BitCount", ctypes.c_ushort),
        ("bV4V4Compression", wintypes.DWORD),
        ("bV4SizeImage", wintypes.DWORD),
        ("bV4XPelsPerMeter", ctypes.c_int),
        ("bV4YPelsPerMeter", ctypes.c_int),
        ("bV4ClrUsed", wintypes.DWORD),
        ("bV4ClrImportant", wintypes.DWORD),
        ("bV4RedMask", wintypes.DWORD),
        ("bV4GreenMask", wintypes.DWORD),
        ("bV4BlueMask", wintypes.DWORD),
        ("bV4AlphaMask", wintypes.DWORD),
        ("bV4CSType", wintypes.DWORD),
        ("bV4Endpoints", CIEXYZTRIPLE),
        ("bV4GammaRed", wintypes.DWORD),
        ("bV4GammaGreen", wintypes.DWORD),
        ("bV4GammaBlue", wintypes.DWORD),
    ]

#[repr(C)]
pub struct CIEXYZ {
    pub ciexyzX: i32,
    pub ciexyzY: i32,
    pub ciexyzZ: i32,
}

#[repr(C)]
pub struct CIEXYZTRIPLE {
    pub ciexyzRed: CIEXYZ,
    pub ciexyzGreen: CIEXYZ,
    pub ciexyzBlue: CIEXYZ,
}

#[repr(C)]
pub struct BITMAPV4HEADER {
    pub bV4Size: u32,
    pub bV4Width: i32,
    pub bV4Height: i32,
    pub bV4Planes: u16,
    pub bV4BitCount: u16,
    pub bV4V4Compression: u32,
    pub bV4SizeImage: u32,
    pub bV4XPelsPerMeter: i32,
    pub bV4YPelsPerMeter: i32,
    pub bV4ClrUsed: u32,
    pub bV4ClrImportant: u32,
    pub bV4RedMask: u32,
    pub bV4GreenMask: u32,
    pub bV4BlueMask: u32,
    pub bV4AlphaMask: u32,
    pub bV4CSType: u32,
    pub bV4Endpoints: CIEXYZTRIPLE,
    pub bV4GammaRed: u32,
    pub bV4GammaGreen: u32,
    pub bV4GammaBlue: u32,
}

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

type CIEXYZ struct {
	ciexyzX int32
	ciexyzY int32
	ciexyzZ int32
}

type CIEXYZTRIPLE struct {
	ciexyzRed CIEXYZ
	ciexyzGreen CIEXYZ
	ciexyzBlue CIEXYZ
}

type BITMAPV4HEADER struct {
	bV4Size uint32
	bV4Width int32
	bV4Height int32
	bV4Planes uint16
	bV4BitCount uint16
	bV4V4Compression uint32
	bV4SizeImage uint32
	bV4XPelsPerMeter int32
	bV4YPelsPerMeter int32
	bV4ClrUsed uint32
	bV4ClrImportant uint32
	bV4RedMask uint32
	bV4GreenMask uint32
	bV4BlueMask uint32
	bV4AlphaMask uint32
	bV4CSType uint32
	bV4Endpoints CIEXYZTRIPLE
	bV4GammaRed uint32
	bV4GammaGreen uint32
	bV4GammaBlue uint32
}

type
  CIEXYZ = record
    ciexyzX: Integer;
    ciexyzY: Integer;
    ciexyzZ: Integer;
  end;

  CIEXYZTRIPLE = record
    ciexyzRed: CIEXYZ;
    ciexyzGreen: CIEXYZ;
    ciexyzBlue: CIEXYZ;
  end;

  BITMAPV4HEADER = record
    bV4Size: DWORD;
    bV4Width: Integer;
    bV4Height: Integer;
    bV4Planes: Word;
    bV4BitCount: Word;
    bV4V4Compression: DWORD;
    bV4SizeImage: DWORD;
    bV4XPelsPerMeter: Integer;
    bV4YPelsPerMeter: Integer;
    bV4ClrUsed: DWORD;
    bV4ClrImportant: DWORD;
    bV4RedMask: DWORD;
    bV4GreenMask: DWORD;
    bV4BlueMask: DWORD;
    bV4AlphaMask: DWORD;
    bV4CSType: DWORD;
    bV4Endpoints: CIEXYZTRIPLE;
    bV4GammaRed: DWORD;
    bV4GammaGreen: DWORD;
    bV4GammaBlue: DWORD;
  end;

const CIEXYZ = extern struct {
    ciexyzX: i32,
    ciexyzY: i32,
    ciexyzZ: i32,
};

const CIEXYZTRIPLE = extern struct {
    ciexyzRed: CIEXYZ,
    ciexyzGreen: CIEXYZ,
    ciexyzBlue: CIEXYZ,
};

const BITMAPV4HEADER = extern struct {
    bV4Size: u32,
    bV4Width: i32,
    bV4Height: i32,
    bV4Planes: u16,
    bV4BitCount: u16,
    bV4V4Compression: u32,
    bV4SizeImage: u32,
    bV4XPelsPerMeter: i32,
    bV4YPelsPerMeter: i32,
    bV4ClrUsed: u32,
    bV4ClrImportant: u32,
    bV4RedMask: u32,
    bV4GreenMask: u32,
    bV4BlueMask: u32,
    bV4AlphaMask: u32,
    bV4CSType: u32,
    bV4Endpoints: CIEXYZTRIPLE,
    bV4GammaRed: u32,
    bV4GammaGreen: u32,
    bV4GammaBlue: u32,
};

type
  CIEXYZ {.bycopy.} = object
    ciexyzX: int32
    ciexyzY: int32
    ciexyzZ: int32

  CIEXYZTRIPLE {.bycopy.} = object
    ciexyzRed: CIEXYZ
    ciexyzGreen: CIEXYZ
    ciexyzBlue: CIEXYZ

  BITMAPV4HEADER {.bycopy.} = object
    bV4Size: uint32
    bV4Width: int32
    bV4Height: int32
    bV4Planes: uint16
    bV4BitCount: uint16
    bV4V4Compression: uint32
    bV4SizeImage: uint32
    bV4XPelsPerMeter: int32
    bV4YPelsPerMeter: int32
    bV4ClrUsed: uint32
    bV4ClrImportant: uint32
    bV4RedMask: uint32
    bV4GreenMask: uint32
    bV4BlueMask: uint32
    bV4AlphaMask: uint32
    bV4CSType: uint32
    bV4Endpoints: CIEXYZTRIPLE
    bV4GammaRed: uint32
    bV4GammaGreen: uint32
    bV4GammaBlue: uint32

struct CIEXYZ
{
    int ciexyzX;
    int ciexyzY;
    int ciexyzZ;
}

struct CIEXYZTRIPLE
{
    CIEXYZ ciexyzRed;
    CIEXYZ ciexyzGreen;
    CIEXYZ ciexyzBlue;
}

struct BITMAPV4HEADER
{
    uint bV4Size;
    int bV4Width;
    int bV4Height;
    ushort bV4Planes;
    ushort bV4BitCount;
    uint bV4V4Compression;
    uint bV4SizeImage;
    int bV4XPelsPerMeter;
    int bV4YPelsPerMeter;
    uint bV4ClrUsed;
    uint bV4ClrImportant;
    uint bV4RedMask;
    uint bV4GreenMask;
    uint bV4BlueMask;
    uint bV4AlphaMask;
    uint bV4CSType;
    CIEXYZTRIPLE bV4Endpoints;
    uint bV4GammaRed;
    uint bV4GammaGreen;
    uint bV4GammaBlue;
}