MFVideoInfo

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct MFRatio
{
    public uint Numerator;
    public uint Denominator;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct MFOffset
{
    public ushort fract;
    public short value;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SIZE
{
    public int cx;
    public int cy;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct MFVideoArea
{
    public MFOffset OffsetX;
    public MFOffset OffsetY;
    public SIZE Area;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct MFVideoInfo
{
    public uint dwWidth;
    public uint dwHeight;
    public MFRatio PixelAspectRatio;
    public int SourceChromaSubsampling;
    public int InterlaceMode;
    public int TransferFunction;
    public int ColorPrimaries;
    public int TransferMatrix;
    public int SourceLighting;
    public MFRatio FramesPerSecond;
    public int NominalRange;
    public MFVideoArea GeometricAperture;
    public MFVideoArea MinimumDisplayAperture;
    public MFVideoArea PanScanAperture;
    public ulong VideoFlags;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure MFRatio
    Public Numerator As UInteger
    Public Denominator As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure MFOffset
    Public fract As UShort
    Public value As Short
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SIZE
    Public cx As Integer
    Public cy As Integer
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure MFVideoArea
    Public OffsetX As MFOffset
    Public OffsetY As MFOffset
    Public Area As SIZE
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure MFVideoInfo
    Public dwWidth As UInteger
    Public dwHeight As UInteger
    Public PixelAspectRatio As MFRatio
    Public SourceChromaSubsampling As Integer
    Public InterlaceMode As Integer
    Public TransferFunction As Integer
    Public ColorPrimaries As Integer
    Public TransferMatrix As Integer
    Public SourceLighting As Integer
    Public FramesPerSecond As MFRatio
    Public NominalRange As Integer
    Public GeometricAperture As MFVideoArea
    Public MinimumDisplayAperture As MFVideoArea
    Public PanScanAperture As MFVideoArea
    Public VideoFlags As ULong
End Structure

import ctypes
from ctypes import wintypes

class MFRatio(ctypes.Structure):
    _fields_ = [
        ("Numerator", wintypes.DWORD),
        ("Denominator", wintypes.DWORD),
    ]

class MFOffset(ctypes.Structure):
    _fields_ = [
        ("fract", ctypes.c_ushort),
        ("value", ctypes.c_short),
    ]

class SIZE(ctypes.Structure):
    _fields_ = [
        ("cx", ctypes.c_int),
        ("cy", ctypes.c_int),
    ]

class MFVideoArea(ctypes.Structure):
    _fields_ = [
        ("OffsetX", MFOffset),
        ("OffsetY", MFOffset),
        ("Area", SIZE),
    ]

class MFVideoInfo(ctypes.Structure):
    _fields_ = [
        ("dwWidth", wintypes.DWORD),
        ("dwHeight", wintypes.DWORD),
        ("PixelAspectRatio", MFRatio),
        ("SourceChromaSubsampling", ctypes.c_int),
        ("InterlaceMode", ctypes.c_int),
        ("TransferFunction", ctypes.c_int),
        ("ColorPrimaries", ctypes.c_int),
        ("TransferMatrix", ctypes.c_int),
        ("SourceLighting", ctypes.c_int),
        ("FramesPerSecond", MFRatio),
        ("NominalRange", ctypes.c_int),
        ("GeometricAperture", MFVideoArea),
        ("MinimumDisplayAperture", MFVideoArea),
        ("PanScanAperture", MFVideoArea),
        ("VideoFlags", ctypes.c_ulonglong),
    ]

#[repr(C)]
pub struct MFRatio {
    pub Numerator: u32,
    pub Denominator: u32,
}

#[repr(C)]
pub struct MFOffset {
    pub fract: u16,
    pub value: i16,
}

#[repr(C)]
pub struct SIZE {
    pub cx: i32,
    pub cy: i32,
}

#[repr(C)]
pub struct MFVideoArea {
    pub OffsetX: MFOffset,
    pub OffsetY: MFOffset,
    pub Area: SIZE,
}

#[repr(C)]
pub struct MFVideoInfo {
    pub dwWidth: u32,
    pub dwHeight: u32,
    pub PixelAspectRatio: MFRatio,
    pub SourceChromaSubsampling: i32,
    pub InterlaceMode: i32,
    pub TransferFunction: i32,
    pub ColorPrimaries: i32,
    pub TransferMatrix: i32,
    pub SourceLighting: i32,
    pub FramesPerSecond: MFRatio,
    pub NominalRange: i32,
    pub GeometricAperture: MFVideoArea,
    pub MinimumDisplayAperture: MFVideoArea,
    pub PanScanAperture: MFVideoArea,
    pub VideoFlags: u64,
}

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

type MFRatio struct {
	Numerator uint32
	Denominator uint32
}

type MFOffset struct {
	fract uint16
	value int16
}

type SIZE struct {
	cx int32
	cy int32
}

type MFVideoArea struct {
	OffsetX MFOffset
	OffsetY MFOffset
	Area SIZE
}

type MFVideoInfo struct {
	dwWidth uint32
	dwHeight uint32
	PixelAspectRatio MFRatio
	SourceChromaSubsampling int32
	InterlaceMode int32
	TransferFunction int32
	ColorPrimaries int32
	TransferMatrix int32
	SourceLighting int32
	FramesPerSecond MFRatio
	NominalRange int32
	GeometricAperture MFVideoArea
	MinimumDisplayAperture MFVideoArea
	PanScanAperture MFVideoArea
	VideoFlags uint64
}

type
  MFRatio = record
    Numerator: DWORD;
    Denominator: DWORD;
  end;

  MFOffset = record
    fract: Word;
    value: Smallint;
  end;

  SIZE = record
    cx: Integer;
    cy: Integer;
  end;

  MFVideoArea = record
    OffsetX: MFOffset;
    OffsetY: MFOffset;
    Area: SIZE;
  end;

  MFVideoInfo = record
    dwWidth: DWORD;
    dwHeight: DWORD;
    PixelAspectRatio: MFRatio;
    SourceChromaSubsampling: Integer;
    InterlaceMode: Integer;
    TransferFunction: Integer;
    ColorPrimaries: Integer;
    TransferMatrix: Integer;
    SourceLighting: Integer;
    FramesPerSecond: MFRatio;
    NominalRange: Integer;
    GeometricAperture: MFVideoArea;
    MinimumDisplayAperture: MFVideoArea;
    PanScanAperture: MFVideoArea;
    VideoFlags: UInt64;
  end;

const MFRatio = extern struct {
    Numerator: u32,
    Denominator: u32,
};

const MFOffset = extern struct {
    fract: u16,
    value: i16,
};

const SIZE = extern struct {
    cx: i32,
    cy: i32,
};

const MFVideoArea = extern struct {
    OffsetX: MFOffset,
    OffsetY: MFOffset,
    Area: SIZE,
};

const MFVideoInfo = extern struct {
    dwWidth: u32,
    dwHeight: u32,
    PixelAspectRatio: MFRatio,
    SourceChromaSubsampling: i32,
    InterlaceMode: i32,
    TransferFunction: i32,
    ColorPrimaries: i32,
    TransferMatrix: i32,
    SourceLighting: i32,
    FramesPerSecond: MFRatio,
    NominalRange: i32,
    GeometricAperture: MFVideoArea,
    MinimumDisplayAperture: MFVideoArea,
    PanScanAperture: MFVideoArea,
    VideoFlags: u64,
};

type
  MFRatio {.bycopy.} = object
    Numerator: uint32
    Denominator: uint32

  MFOffset {.bycopy.} = object
    fract: uint16
    value: int16

  SIZE {.bycopy.} = object
    cx: int32
    cy: int32

  MFVideoArea {.bycopy.} = object
    OffsetX: MFOffset
    OffsetY: MFOffset
    Area: SIZE

  MFVideoInfo {.bycopy.} = object
    dwWidth: uint32
    dwHeight: uint32
    PixelAspectRatio: MFRatio
    SourceChromaSubsampling: int32
    InterlaceMode: int32
    TransferFunction: int32
    ColorPrimaries: int32
    TransferMatrix: int32
    SourceLighting: int32
    FramesPerSecond: MFRatio
    NominalRange: int32
    GeometricAperture: MFVideoArea
    MinimumDisplayAperture: MFVideoArea
    PanScanAperture: MFVideoArea
    VideoFlags: uint64

struct MFRatio
{
    uint Numerator;
    uint Denominator;
}

struct MFOffset
{
    ushort fract;
    short value;
}

struct SIZE
{
    int cx;
    int cy;
}

struct MFVideoArea
{
    MFOffset OffsetX;
    MFOffset OffsetY;
    SIZE Area;
}

struct MFVideoInfo
{
    uint dwWidth;
    uint dwHeight;
    MFRatio PixelAspectRatio;
    int SourceChromaSubsampling;
    int InterlaceMode;
    int TransferFunction;
    int ColorPrimaries;
    int TransferMatrix;
    int SourceLighting;
    MFRatio FramesPerSecond;
    int NominalRange;
    MFVideoArea GeometricAperture;
    MFVideoArea MinimumDisplayAperture;
    MFVideoArea PanScanAperture;
    ulong VideoFlags;
}