DXVA_DeinterlaceBlt

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 DXVA_VideoSample
{
    public long rtStart;
    public long rtEnd;
    public int SampleFormat;
    public IntPtr lpDDSSrcSurface;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DXVA_DeinterlaceBlt
{
    public uint Size;
    public uint Reserved;
    public long rtTarget;
    public RECT DstRect;
    public RECT SrcRect;
    public uint NumSourceSurfaces;
    public float Alpha;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)] public DXVA_VideoSample[] Source;
}

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 DXVA_VideoSample
    Public rtStart As Long
    Public rtEnd As Long
    Public SampleFormat As Integer
    Public lpDDSSrcSurface As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DXVA_DeinterlaceBlt
    Public Size As UInteger
    Public Reserved As UInteger
    Public rtTarget As Long
    Public DstRect As RECT
    Public SrcRect As RECT
    Public NumSourceSurfaces As UInteger
    Public Alpha As Single
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=32)> Public Source() As DXVA_VideoSample
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 DXVA_VideoSample(ctypes.Structure):
    _fields_ = [
        ("rtStart", ctypes.c_longlong),
        ("rtEnd", ctypes.c_longlong),
        ("SampleFormat", ctypes.c_int),
        ("lpDDSSrcSurface", ctypes.c_void_p),
    ]

class DXVA_DeinterlaceBlt(ctypes.Structure):
    _fields_ = [
        ("Size", wintypes.DWORD),
        ("Reserved", wintypes.DWORD),
        ("rtTarget", ctypes.c_longlong),
        ("DstRect", RECT),
        ("SrcRect", RECT),
        ("NumSourceSurfaces", wintypes.DWORD),
        ("Alpha", ctypes.c_float),
        ("Source", DXVA_VideoSample * 32),
    ]

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

#[repr(C)]
pub struct DXVA_VideoSample {
    pub rtStart: i64,
    pub rtEnd: i64,
    pub SampleFormat: i32,
    pub lpDDSSrcSurface: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct DXVA_DeinterlaceBlt {
    pub Size: u32,
    pub Reserved: u32,
    pub rtTarget: i64,
    pub DstRect: RECT,
    pub SrcRect: RECT,
    pub NumSourceSurfaces: u32,
    pub Alpha: f32,
    pub Source: [DXVA_VideoSample; 32],
}

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

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

type DXVA_VideoSample struct {
	rtStart int64
	rtEnd int64
	SampleFormat int32
	lpDDSSrcSurface uintptr
}

type DXVA_DeinterlaceBlt struct {
	Size uint32
	Reserved uint32
	rtTarget int64
	DstRect RECT
	SrcRect RECT
	NumSourceSurfaces uint32
	Alpha float32
	Source [32]DXVA_VideoSample
}

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

  DXVA_VideoSample = record
    rtStart: Int64;
    rtEnd: Int64;
    SampleFormat: Integer;
    lpDDSSrcSurface: Pointer;
  end;

  DXVA_DeinterlaceBlt = record
    Size: DWORD;
    Reserved: DWORD;
    rtTarget: Int64;
    DstRect: RECT;
    SrcRect: RECT;
    NumSourceSurfaces: DWORD;
    Alpha: Single;
    Source: array[0..31] of DXVA_VideoSample;
  end;

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

const DXVA_VideoSample = extern struct {
    rtStart: i64,
    rtEnd: i64,
    SampleFormat: i32,
    lpDDSSrcSurface: ?*anyopaque,
};

const DXVA_DeinterlaceBlt = extern struct {
    Size: u32,
    Reserved: u32,
    rtTarget: i64,
    DstRect: RECT,
    SrcRect: RECT,
    NumSourceSurfaces: u32,
    Alpha: f32,
    Source: [32]DXVA_VideoSample,
};

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

  DXVA_VideoSample {.bycopy.} = object
    rtStart: int64
    rtEnd: int64
    SampleFormat: int32
    lpDDSSrcSurface: pointer

  DXVA_DeinterlaceBlt {.bycopy.} = object
    Size: uint32
    Reserved: uint32
    rtTarget: int64
    DstRect: RECT
    SrcRect: RECT
    NumSourceSurfaces: uint32
    Alpha: float32
    Source: array[32, DXVA_VideoSample]

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

struct DXVA_VideoSample
{
    long rtStart;
    long rtEnd;
    int SampleFormat;
    void* lpDDSSrcSurface;
}

struct DXVA_DeinterlaceBlt
{
    uint Size;
    uint Reserved;
    long rtTarget;
    RECT DstRect;
    RECT SrcRect;
    uint NumSourceSurfaces;
    float Alpha;
    DXVA_VideoSample[32] Source;
}