KSSTREAM_HEADER

using System;
using System.Runtime.InteropServices;

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

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct KSSTREAM_HEADER
{
    public uint Size;
    public uint TypeSpecificFlags;
    public KSTIME PresentationTime;
    public long Duration;
    public uint FrameExtent;
    public uint DataUsed;
    public IntPtr Data;
    public uint OptionsFlags;
}

Imports System.Runtime.InteropServices

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

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure KSSTREAM_HEADER
    Public Size As UInteger
    Public TypeSpecificFlags As UInteger
    Public PresentationTime As KSTIME
    Public Duration As Long
    Public FrameExtent As UInteger
    Public DataUsed As UInteger
    Public Data As IntPtr
    Public OptionsFlags As UInteger
End Structure

import ctypes
from ctypes import wintypes

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

class KSSTREAM_HEADER(ctypes.Structure):
    _fields_ = [
        ("Size", wintypes.DWORD),
        ("TypeSpecificFlags", wintypes.DWORD),
        ("PresentationTime", KSTIME),
        ("Duration", ctypes.c_longlong),
        ("FrameExtent", wintypes.DWORD),
        ("DataUsed", wintypes.DWORD),
        ("Data", ctypes.c_void_p),
        ("OptionsFlags", wintypes.DWORD),
    ]

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

#[repr(C)]
pub struct KSSTREAM_HEADER {
    pub Size: u32,
    pub TypeSpecificFlags: u32,
    pub PresentationTime: KSTIME,
    pub Duration: i64,
    pub FrameExtent: u32,
    pub DataUsed: u32,
    pub Data: *mut core::ffi::c_void,
    pub OptionsFlags: u32,
}

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

type KSTIME struct {
	Time int64
	Numerator uint32
	Denominator uint32
}

type KSSTREAM_HEADER struct {
	Size uint32
	TypeSpecificFlags uint32
	PresentationTime KSTIME
	Duration int64
	FrameExtent uint32
	DataUsed uint32
	Data uintptr
	OptionsFlags uint32
}

type
  KSTIME = record
    Time: Int64;
    Numerator: DWORD;
    Denominator: DWORD;
  end;

  KSSTREAM_HEADER = record
    Size: DWORD;
    TypeSpecificFlags: DWORD;
    PresentationTime: KSTIME;
    Duration: Int64;
    FrameExtent: DWORD;
    DataUsed: DWORD;
    Data: Pointer;
    OptionsFlags: DWORD;
  end;

const KSTIME = extern struct {
    Time: i64,
    Numerator: u32,
    Denominator: u32,
};

const KSSTREAM_HEADER = extern struct {
    Size: u32,
    TypeSpecificFlags: u32,
    PresentationTime: KSTIME,
    Duration: i64,
    FrameExtent: u32,
    DataUsed: u32,
    Data: ?*anyopaque,
    OptionsFlags: u32,
};

type
  KSTIME {.bycopy.} = object
    Time: int64
    Numerator: uint32
    Denominator: uint32

  KSSTREAM_HEADER {.bycopy.} = object
    Size: uint32
    TypeSpecificFlags: uint32
    PresentationTime: KSTIME
    Duration: int64
    FrameExtent: uint32
    DataUsed: uint32
    Data: pointer
    OptionsFlags: uint32

struct KSTIME
{
    long Time;
    uint Numerator;
    uint Denominator;
}

struct KSSTREAM_HEADER
{
    uint Size;
    uint TypeSpecificFlags;
    KSTIME PresentationTime;
    long Duration;
    uint FrameExtent;
    uint DataUsed;
    void* Data;
    uint OptionsFlags;
}