MFVideoAlphaBitmap

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct RECT
{
    public int left;
    public int top;
    public int right;
    public int bottom;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct MFVideoNormalizedRect
{
    public float left;
    public float top;
    public float right;
    public float bottom;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct MFVideoAlphaBitmapParams
{
    public uint dwFlags;
    public uint clrSrcKey;
    public RECT rcSrc;
    public MFVideoNormalizedRect nrcDest;
    public float fAlpha;
    public uint dwFilterMode;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct MFVideoAlphaBitmap
{
    [MarshalAs(UnmanagedType.Bool)] public bool GetBitmapFromDC;
    public _bitmap_e__Union bitmap;
    public MFVideoAlphaBitmapParams params;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure RECT
    Public left As Integer
    Public top As Integer
    Public right As Integer
    Public bottom As Integer
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure MFVideoNormalizedRect
    Public left As Single
    Public top As Single
    Public right As Single
    Public bottom As Single
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure MFVideoAlphaBitmapParams
    Public dwFlags As UInteger
    Public clrSrcKey As UInteger
    Public rcSrc As RECT
    Public nrcDest As MFVideoNormalizedRect
    Public fAlpha As Single
    Public dwFilterMode As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure MFVideoAlphaBitmap
    <MarshalAs(UnmanagedType.Bool)> Public GetBitmapFromDC As Boolean
    Public bitmap As _bitmap_e__Union
    Public params As MFVideoAlphaBitmapParams
End Structure

import ctypes
from ctypes import wintypes

class RECT(ctypes.Structure):
    _fields_ = [
        ("left", ctypes.c_int),
        ("top", ctypes.c_int),
        ("right", ctypes.c_int),
        ("bottom", ctypes.c_int),
    ]

class MFVideoNormalizedRect(ctypes.Structure):
    _fields_ = [
        ("left", ctypes.c_float),
        ("top", ctypes.c_float),
        ("right", ctypes.c_float),
        ("bottom", ctypes.c_float),
    ]

class MFVideoAlphaBitmapParams(ctypes.Structure):
    _fields_ = [
        ("dwFlags", wintypes.DWORD),
        ("clrSrcKey", wintypes.DWORD),
        ("rcSrc", RECT),
        ("nrcDest", MFVideoNormalizedRect),
        ("fAlpha", ctypes.c_float),
        ("dwFilterMode", wintypes.DWORD),
    ]

class MFVideoAlphaBitmap(ctypes.Structure):
    _fields_ = [
        ("GetBitmapFromDC", wintypes.BOOL),
        ("bitmap", _bitmap_e__Union),
        ("params", MFVideoAlphaBitmapParams),
    ]

#[repr(C)]
pub struct RECT {
    pub left: i32,
    pub top: i32,
    pub right: i32,
    pub bottom: i32,
}

#[repr(C)]
pub struct MFVideoNormalizedRect {
    pub left: f32,
    pub top: f32,
    pub right: f32,
    pub bottom: f32,
}

#[repr(C)]
pub struct MFVideoAlphaBitmapParams {
    pub dwFlags: u32,
    pub clrSrcKey: u32,
    pub rcSrc: RECT,
    pub nrcDest: MFVideoNormalizedRect,
    pub fAlpha: f32,
    pub dwFilterMode: u32,
}

#[repr(C)]
pub struct MFVideoAlphaBitmap {
    pub GetBitmapFromDC: i32,
    pub bitmap: _bitmap_e__Union,
    pub params: MFVideoAlphaBitmapParams,
}

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

type RECT struct {
	left int32
	top int32
	right int32
	bottom int32
}

type MFVideoNormalizedRect struct {
	left float32
	top float32
	right float32
	bottom float32
}

type MFVideoAlphaBitmapParams struct {
	dwFlags uint32
	clrSrcKey uint32
	rcSrc RECT
	nrcDest MFVideoNormalizedRect
	fAlpha float32
	dwFilterMode uint32
}

type MFVideoAlphaBitmap struct {
	GetBitmapFromDC int32
	bitmap _bitmap_e__Union
	params MFVideoAlphaBitmapParams
}

type
  RECT = record
    left: Integer;
    top: Integer;
    right: Integer;
    bottom: Integer;
  end;

  MFVideoNormalizedRect = record
    left: Single;
    top: Single;
    right: Single;
    bottom: Single;
  end;

  MFVideoAlphaBitmapParams = record
    dwFlags: DWORD;
    clrSrcKey: DWORD;
    rcSrc: RECT;
    nrcDest: MFVideoNormalizedRect;
    fAlpha: Single;
    dwFilterMode: DWORD;
  end;

  MFVideoAlphaBitmap = record
    GetBitmapFromDC: BOOL;
    bitmap: _bitmap_e__Union;
    params: MFVideoAlphaBitmapParams;
  end;

const RECT = extern struct {
    left: i32,
    top: i32,
    right: i32,
    bottom: i32,
};

const MFVideoNormalizedRect = extern struct {
    left: f32,
    top: f32,
    right: f32,
    bottom: f32,
};

const MFVideoAlphaBitmapParams = extern struct {
    dwFlags: u32,
    clrSrcKey: u32,
    rcSrc: RECT,
    nrcDest: MFVideoNormalizedRect,
    fAlpha: f32,
    dwFilterMode: u32,
};

const MFVideoAlphaBitmap = extern struct {
    GetBitmapFromDC: i32,
    bitmap: _bitmap_e__Union,
    params: MFVideoAlphaBitmapParams,
};

type
  RECT {.bycopy.} = object
    left: int32
    top: int32
    right: int32
    bottom: int32

  MFVideoNormalizedRect {.bycopy.} = object
    left: float32
    top: float32
    right: float32
    bottom: float32

  MFVideoAlphaBitmapParams {.bycopy.} = object
    dwFlags: uint32
    clrSrcKey: uint32
    rcSrc: RECT
    nrcDest: MFVideoNormalizedRect
    fAlpha: float32
    dwFilterMode: uint32

  MFVideoAlphaBitmap {.bycopy.} = object
    GetBitmapFromDC: int32
    bitmap: _bitmap_e__Union
    params: MFVideoAlphaBitmapParams

struct RECT
{
    int left;
    int top;
    int right;
    int bottom;
}

struct MFVideoNormalizedRect
{
    float left;
    float top;
    float right;
    float bottom;
}

struct MFVideoAlphaBitmapParams
{
    uint dwFlags;
    uint clrSrcKey;
    RECT rcSrc;
    MFVideoNormalizedRect nrcDest;
    float fAlpha;
    uint dwFilterMode;
}

struct MFVideoAlphaBitmap
{
    int GetBitmapFromDC;
    _bitmap_e__Union bitmap;
    MFVideoAlphaBitmapParams params;
}