SPVTEXTFRAG

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SPVPITCH
{
    public int MiddleAdj;
    public int RangeAdj;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SPVCONTEXT
{
    public IntPtr pCategory;
    public IntPtr pBefore;
    public IntPtr pAfter;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SPVSTATE
{
    public int eAction;
    public ushort LangID;
    public ushort wReserved;
    public int EmphAdj;
    public int RateAdj;
    public uint Volume;
    public SPVPITCH PitchAdj;
    public uint SilenceMSecs;
    public IntPtr pPhoneIds;
    public int ePartOfSpeech;
    public SPVCONTEXT Context;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SPVTEXTFRAG
{
    public IntPtr pNext;
    public SPVSTATE State;
    public IntPtr pTextStart;
    public uint ulTextLen;
    public uint ulTextSrcOffset;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SPVPITCH
    Public MiddleAdj As Integer
    Public RangeAdj As Integer
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SPVCONTEXT
    Public pCategory As IntPtr
    Public pBefore As IntPtr
    Public pAfter As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SPVSTATE
    Public eAction As Integer
    Public LangID As UShort
    Public wReserved As UShort
    Public EmphAdj As Integer
    Public RateAdj As Integer
    Public Volume As UInteger
    Public PitchAdj As SPVPITCH
    Public SilenceMSecs As UInteger
    Public pPhoneIds As IntPtr
    Public ePartOfSpeech As Integer
    Public Context As SPVCONTEXT
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SPVTEXTFRAG
    Public pNext As IntPtr
    Public State As SPVSTATE
    Public pTextStart As IntPtr
    Public ulTextLen As UInteger
    Public ulTextSrcOffset As UInteger
End Structure

import ctypes
from ctypes import wintypes

class SPVPITCH(ctypes.Structure):
    _fields_ = [
        ("MiddleAdj", ctypes.c_int),
        ("RangeAdj", ctypes.c_int),
    ]

class SPVCONTEXT(ctypes.Structure):
    _fields_ = [
        ("pCategory", ctypes.c_void_p),
        ("pBefore", ctypes.c_void_p),
        ("pAfter", ctypes.c_void_p),
    ]

class SPVSTATE(ctypes.Structure):
    _fields_ = [
        ("eAction", ctypes.c_int),
        ("LangID", ctypes.c_ushort),
        ("wReserved", ctypes.c_ushort),
        ("EmphAdj", ctypes.c_int),
        ("RateAdj", ctypes.c_int),
        ("Volume", wintypes.DWORD),
        ("PitchAdj", SPVPITCH),
        ("SilenceMSecs", wintypes.DWORD),
        ("pPhoneIds", ctypes.c_void_p),
        ("ePartOfSpeech", ctypes.c_int),
        ("Context", SPVCONTEXT),
    ]

class SPVTEXTFRAG(ctypes.Structure):
    _fields_ = [
        ("pNext", ctypes.c_void_p),
        ("State", SPVSTATE),
        ("pTextStart", ctypes.c_void_p),
        ("ulTextLen", wintypes.DWORD),
        ("ulTextSrcOffset", wintypes.DWORD),
    ]

#[repr(C)]
pub struct SPVPITCH {
    pub MiddleAdj: i32,
    pub RangeAdj: i32,
}

#[repr(C)]
pub struct SPVCONTEXT {
    pub pCategory: *mut core::ffi::c_void,
    pub pBefore: *mut core::ffi::c_void,
    pub pAfter: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct SPVSTATE {
    pub eAction: i32,
    pub LangID: u16,
    pub wReserved: u16,
    pub EmphAdj: i32,
    pub RateAdj: i32,
    pub Volume: u32,
    pub PitchAdj: SPVPITCH,
    pub SilenceMSecs: u32,
    pub pPhoneIds: *mut core::ffi::c_void,
    pub ePartOfSpeech: i32,
    pub Context: SPVCONTEXT,
}

#[repr(C)]
pub struct SPVTEXTFRAG {
    pub pNext: *mut core::ffi::c_void,
    pub State: SPVSTATE,
    pub pTextStart: *mut core::ffi::c_void,
    pub ulTextLen: u32,
    pub ulTextSrcOffset: u32,
}

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

type SPVPITCH struct {
	MiddleAdj int32
	RangeAdj int32
}

type SPVCONTEXT struct {
	pCategory uintptr
	pBefore uintptr
	pAfter uintptr
}

type SPVSTATE struct {
	eAction int32
	LangID uint16
	wReserved uint16
	EmphAdj int32
	RateAdj int32
	Volume uint32
	PitchAdj SPVPITCH
	SilenceMSecs uint32
	pPhoneIds uintptr
	ePartOfSpeech int32
	Context SPVCONTEXT
}

type SPVTEXTFRAG struct {
	pNext uintptr
	State SPVSTATE
	pTextStart uintptr
	ulTextLen uint32
	ulTextSrcOffset uint32
}

type
  SPVPITCH = record
    MiddleAdj: Integer;
    RangeAdj: Integer;
  end;

  SPVCONTEXT = record
    pCategory: Pointer;
    pBefore: Pointer;
    pAfter: Pointer;
  end;

  SPVSTATE = record
    eAction: Integer;
    LangID: Word;
    wReserved: Word;
    EmphAdj: Integer;
    RateAdj: Integer;
    Volume: DWORD;
    PitchAdj: SPVPITCH;
    SilenceMSecs: DWORD;
    pPhoneIds: Pointer;
    ePartOfSpeech: Integer;
    Context: SPVCONTEXT;
  end;

  SPVTEXTFRAG = record
    pNext: Pointer;
    State: SPVSTATE;
    pTextStart: Pointer;
    ulTextLen: DWORD;
    ulTextSrcOffset: DWORD;
  end;

const SPVPITCH = extern struct {
    MiddleAdj: i32,
    RangeAdj: i32,
};

const SPVCONTEXT = extern struct {
    pCategory: ?*anyopaque,
    pBefore: ?*anyopaque,
    pAfter: ?*anyopaque,
};

const SPVSTATE = extern struct {
    eAction: i32,
    LangID: u16,
    wReserved: u16,
    EmphAdj: i32,
    RateAdj: i32,
    Volume: u32,
    PitchAdj: SPVPITCH,
    SilenceMSecs: u32,
    pPhoneIds: ?*anyopaque,
    ePartOfSpeech: i32,
    Context: SPVCONTEXT,
};

const SPVTEXTFRAG = extern struct {
    pNext: ?*anyopaque,
    State: SPVSTATE,
    pTextStart: ?*anyopaque,
    ulTextLen: u32,
    ulTextSrcOffset: u32,
};

type
  SPVPITCH {.bycopy.} = object
    MiddleAdj: int32
    RangeAdj: int32

  SPVCONTEXT {.bycopy.} = object
    pCategory: pointer
    pBefore: pointer
    pAfter: pointer

  SPVSTATE {.bycopy.} = object
    eAction: int32
    LangID: uint16
    wReserved: uint16
    EmphAdj: int32
    RateAdj: int32
    Volume: uint32
    PitchAdj: SPVPITCH
    SilenceMSecs: uint32
    pPhoneIds: pointer
    ePartOfSpeech: int32
    Context: SPVCONTEXT

  SPVTEXTFRAG {.bycopy.} = object
    pNext: pointer
    State: SPVSTATE
    pTextStart: pointer
    ulTextLen: uint32
    ulTextSrcOffset: uint32

struct SPVPITCH
{
    int MiddleAdj;
    int RangeAdj;
}

struct SPVCONTEXT
{
    void* pCategory;
    void* pBefore;
    void* pAfter;
}

struct SPVSTATE
{
    int eAction;
    ushort LangID;
    ushort wReserved;
    int EmphAdj;
    int RateAdj;
    uint Volume;
    SPVPITCH PitchAdj;
    uint SilenceMSecs;
    void* pPhoneIds;
    int ePartOfSpeech;
    SPVCONTEXT Context;
}

struct SPVTEXTFRAG
{
    void* pNext;
    SPVSTATE State;
    void* pTextStart;
    uint ulTextLen;
    uint ulTextSrcOffset;
}