@bun-win32/avifil32 1.0.0

package/AI.md

@@ -0,0 +1,71 @@
+# AI Guide for @bun-win32/avifil32
+
+How to use this package, not what the Win32 API does.
+
+## Usage
+
+```ts
+import Avifil32, { SomeFlag } from '@bun-win32/avifil32';
+
+// Methods bind lazily on first call
+const result = Avifil32.SomeFunctionW(arg1, arg2);
+
+// Preload: array, single string, or no args (all symbols)
+Avifil32.Preload(['SomeFunctionW', 'AnotherFunction']);
+Avifil32.Preload('SomeFunctionW');
+Avifil32.Preload();
+```
+
+## Where To Look
+
+| Need                              | Read                 |
+| --------------------------------- | -------------------- |
+| Find a method or its MS Docs link | `structs/Avifil32.ts` |
+| Find types, enums, constants      | `types/Avifil32.ts`   |
+| Quick examples                    | `README.md`          |
+
+`index.ts` re-exports the class and all types — import from `@bun-win32/avifil32` directly.
+
+## Calling Convention
+
+All documented `avifil32.dll` exports are bound. Each method maps 1:1 to its DLL export. Names, parameter names, and order match Microsoft Docs.
+
+### Strings
+
+`W` methods take UTF-16LE NUL-terminated buffers. `A` methods take ANSI strings.
+
+```ts
+const wide = Buffer.from('Hello\0', 'utf16le');  // LPCWSTR
+Avifil32.SomeFunctionW(wide.ptr);
+
+// Reading a wide string back from a buffer:
+const text = new TextDecoder('utf-16').decode(buf).replace(/\0.*$/, '');
+```
+
+### Return types
+
+- `HANDLE`, `HWND`, etc. → `bigint`
+- `DWORD`, `UINT`, `BOOL`, `INT`, `LONG` → `number`
+- `LPVOID`, `LPWSTR`, etc. → `Pointer`
+- Win32 `BOOL` is `number` (0 or non-zero), **not** JS `boolean`. Do not compare with `=== true`.
+
+### Pointers, handles, out-parameters
+
+- **Pointer** params (`LP*`, `P*`, `Pointer`): pass `buffer.ptr` from a caller-allocated `Buffer`.
+- **Handle** params (`HANDLE`, `HWND`, etc.): pass a `bigint` value.
+- **Out-parameters**: allocate a `Buffer`, pass `.ptr`, read the result after the call.
+
+```ts
+const out = Buffer.alloc(4);
+Avifil32.SomeFunction(out.ptr);
+const value = out.readUInt32LE(0);
+```
+
+### Nullability
+
+- `| NULL` in a signature → pass `null` (optional pointer).
+- `| 0n` in a signature → pass `0n` (optional handle).
+
+## Errors and Cleanup
+
+Return values are raw. If the Win32 function uses last-error semantics, read via `GetLastError()`. Resource cleanup is your responsibility — same as raw Win32.

package/README.md

@@ -0,0 +1,78 @@
+# @bun-win32/avifil32
+
+Zero-dependency, zero-overhead Win32 Avifil32 bindings for [Bun](https://bun.sh) on Windows.
+
+## Overview
+
+`@bun-win32/avifil32` exposes the `avifil32.dll` exports using [Bun](https://bun.sh)'s FFI. It provides a single class, `Avifil32`, which lazily binds native symbols on first use. You can optionally preload a subset or all symbols up-front via `Preload()`.
+
+The bindings are strongly typed for a smooth DX in TypeScript.
+
+## Features
+
+- [Bun](https://bun.sh)-first ergonomics on Windows 10/11.
+- Direct FFI to `avifil32.dll` (Video for Windows AVIFile API: open/create `.avi` files, enumerate and read/write video, audio, MIDI, and text streams, decode frames to DIBs, mux files from streams, and edit streams).
+- In-source docs in `structs/Avifil32.ts` with links to Microsoft Docs.
+- Lazy binding on first call; optional eager preload (`Avifil32.Preload()`).
+- No wrapper overhead; calls map 1:1 to native APIs.
+- Strongly-typed Win32 aliases (see `types/Avifil32.ts`).
+
+## Requirements
+
+- [Bun](https://bun.sh) runtime
+- Windows 10 or later
+
+## Installation
+
+```sh
+bun add @bun-win32/avifil32
+```
+
+## Quick Start
+
+```ts
+import Avifil32, { OpenFileFlags, StreamType } from '@bun-win32/avifil32';
+
+// Optionally bind a subset up-front
+Avifil32.Preload(['AVIFileInit', 'AVIFileOpenW', 'AVIFileInfoW', 'AVIFileRelease', 'AVIFileExit']);
+
+Avifil32.AVIFileInit();
+
+// AVIFileOpenW writes the IAVIFile pointer into a caller-allocated buffer
+const ppfile = Buffer.alloc(8);
+const path = Buffer.from('C:\\\\sample.avi\0', 'utf16le');
+const hr = Avifil32.AVIFileOpenW(ppfile.ptr, path.ptr, OpenFileFlags.OF_READ | OpenFileFlags.OF_SHARE_DENY_NONE, null);
+
+if (hr === 0) {
+  const pfile = ppfile.readBigUInt64LE(0);
+
+  // AVIFILEINFOW is 172 bytes on x64; dwStreams is at offset 12
+  const info = Buffer.alloc(172);
+  Avifil32.AVIFileInfoW(pfile, info.ptr, info.byteLength);
+  console.log('Streams: %d', info.readUInt32LE(12));
+
+  Avifil32.AVIFileRelease(pfile);
+}
+
+Avifil32.AVIFileExit();
+```
+
+> [!NOTE]
+> AI agents: see `AI.md` for the package binding contract and source-navigation guidance. It explains how to use the package without scanning the entire implementation.
+
+## Examples
+
+Run the included examples:
+
+```sh
+# Decode a synthesized .avi and play it back in the terminal with 24-bit ANSI
+bun run example/terminal-cinema.ts
+
+# Thorough AVI container diagnostic (pass a path, or a sample is synthesized)
+bun run example/avi-inspector.ts [path-to.avi]
+```
+
+## Notes
+
+- Either rely on lazy binding or call `Avifil32.Preload()`.
+- Windows only. Bun runtime required.

package/index.ts

@@ -0,0 +1,4 @@
+import Avifil32 from './structs/Avifil32';
+
+export * from './types/Avifil32';
+export default Avifil32;

package/package.json

@@ -0,0 +1,58 @@
+{
+  "author": "Stev Peifer <stev@bell.net>",
+  "bugs": {
+    "url": "https://github.com/ObscuritySRL/bun-win32/issues"
+  },
+  "dependencies": {
+    "@bun-win32/core": "1.1.2"
+  },
+  "description": "Zero-dependency, zero-overhead Win32 AVIFIL32 bindings for Bun (FFI) on Windows.",
+  "devDependencies": {
+    "@bun-win32/kernel32": "1.0.21",
+    "@types/bun": "latest"
+  },
+  "exports": {
+    ".": "./index.ts"
+  },
+  "license": "MIT",
+  "module": "index.ts",
+  "name": "@bun-win32/avifil32",
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "private": false,
+  "homepage": "https://github.com/ObscuritySRL/bun-win32#readme",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/ObscuritySRL/bun-win32.git",
+    "directory": "packages/avifil32"
+  },
+  "type": "module",
+  "version": "1.0.0",
+  "main": "./index.ts",
+  "keywords": [
+    "bun",
+    "ffi",
+    "win32",
+    "windows",
+    "avifil32",
+    "bindings",
+    "typescript",
+    "dll"
+  ],
+  "files": [
+    "AI.md",
+    "README.md",
+    "index.ts",
+    "structs/*.ts",
+    "types/*.ts"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "bun": ">=1.1.0"
+  },
+  "scripts": {
+    "example:avi-inspector": "bun ./example/avi-inspector.ts",
+    "example:terminal-cinema": "bun ./example/terminal-cinema.ts"
+  }
+}

package/structs/Avifil32.ts

@@ -0,0 +1,490 @@
+import { type FFIFunction, FFIType, type Pointer } from 'bun:ffi';
+
+import { Win32 } from '@bun-win32/core';
+
+import type {
+  AVISAVECALLBACK,
+  BOOL,
+  DWORD,
+  HANDLE,
+  HRESULT,
+  HWND,
+  INT,
+  INT_PTR,
+  LONG,
+  LPAVICOMPRESSOPTIONS,
+  LPAVIFILEINFO,
+  LPAVIFILEINFOA,
+  LPAVIFILEINFOW,
+  LPAVISTREAMINFO,
+  LPAVISTREAMINFOA,
+  LPAVISTREAMINFOW,
+  LPBITMAPINFOHEADER,
+  LPCLSID,
+  LPCSTR,
+  LPCTSTR,
+  LPCWSTR,
+  LPLONG,
+  LPSTR,
+  LPTSTR,
+  LPVOID,
+  LPWSTR,
+  NULL,
+  PAVIFILE,
+  PAVISTREAM,
+  PGETFRAME,
+  UINT,
+  ULONG,
+} from '../types/Avifil32';
+
+/**
+ * Thin, lazy-loaded FFI bindings for `avifil32.dll`.
+ *
+ * Each static method corresponds one-to-one with a Win32 export declared in `Symbols`.
+ * The first call to a method binds the underlying native symbol via `bun:ffi` and
+ * memoizes it on the class for subsequent calls. For bulk, up-front binding, use `Preload`.
+ *
+ * Symbols are defined with explicit `FFIType` signatures and kept alphabetized.
+ * You normally do not access `Symbols` directly; call the static methods or preload
+ * a subset for hot paths.
+ *
+ * @example
+ * ```ts
+ * import Avifil32 from './structs/Avifil32';
+ *
+ * // Lazy: bind on first call
+ * const result = Avifil32.AVIFileOpenW(ppfile.ptr, szFile.ptr, OF_READ, null);
+ *
+ * // Or preload a subset to avoid per-symbol lazy binding cost
+ * Avifil32.Preload(['AVIFileInit', 'AVIFileOpenW', 'AVIFileGetStream']);
+ * ```
+ */
+class Avifil32 extends Win32 {
+  protected static override name = 'avifil32.dll';
+
+  /** @inheritdoc */
+  protected static override readonly Symbols = {
+    AVIBuildFilter: { args: [FFIType.ptr, FFIType.i32, FFIType.i32], returns: FFIType.i32 },
+    AVIBuildFilterA: { args: [FFIType.ptr, FFIType.i32, FFIType.i32], returns: FFIType.i32 },
+    AVIBuildFilterW: { args: [FFIType.ptr, FFIType.i32, FFIType.i32], returns: FFIType.i32 },
+    AVIClearClipboard: { args: [], returns: FFIType.i32 },
+    AVIFileAddRef: { args: [FFIType.u64], returns: FFIType.u32 },
+    AVIFileCreateStream: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+    AVIFileCreateStreamA: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+    AVIFileCreateStreamW: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+    AVIFileEndRecord: { args: [FFIType.u64], returns: FFIType.i32 },
+    AVIFileExit: { args: [], returns: FFIType.void },
+    AVIFileGetStream: { args: [FFIType.u64, FFIType.ptr, FFIType.u32, FFIType.i32], returns: FFIType.i32 },
+    AVIFileInfo: { args: [FFIType.u64, FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
+    AVIFileInfoA: { args: [FFIType.u64, FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
+    AVIFileInfoW: { args: [FFIType.u64, FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
+    AVIFileInit: { args: [], returns: FFIType.void },
+    AVIFileOpen: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
+    AVIFileOpenA: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
+    AVIFileOpenW: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
+    AVIFileReadData: { args: [FFIType.u64, FFIType.u32, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+    AVIFileRelease: { args: [FFIType.u64], returns: FFIType.u32 },
+    AVIFileWriteData: { args: [FFIType.u64, FFIType.u32, FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
+    AVIGetFromClipboard: { args: [FFIType.ptr], returns: FFIType.i32 },
+    AVIMakeCompressedStream: { args: [FFIType.ptr, FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+    AVIMakeFileFromStreams: { args: [FFIType.ptr, FFIType.i32, FFIType.ptr], returns: FFIType.i32 },
+    AVIMakeStreamFromClipboard: { args: [FFIType.u32, FFIType.u64, FFIType.ptr], returns: FFIType.i32 },
+    AVIPutFileOnClipboard: { args: [FFIType.u64], returns: FFIType.i32 },
+    AVISave: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.i32, FFIType.u64, FFIType.ptr], returns: FFIType.i32 },
+    AVISaveA: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.i32, FFIType.u64, FFIType.ptr], returns: FFIType.i32 },
+    AVISaveOptions: { args: [FFIType.u64, FFIType.u32, FFIType.i32, FFIType.ptr, FFIType.ptr], returns: FFIType.i64 },
+    AVISaveOptionsFree: { args: [FFIType.i32, FFIType.ptr], returns: FFIType.i32 },
+    AVISaveV: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.i32, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+    AVISaveVA: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.i32, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+    AVISaveVW: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.i32, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+    AVISaveW: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.i32, FFIType.u64, FFIType.ptr], returns: FFIType.i32 },
+    AVIStreamAddRef: { args: [FFIType.u64], returns: FFIType.u32 },
+    AVIStreamBeginStreaming: { args: [FFIType.u64, FFIType.i32, FFIType.i32, FFIType.i32], returns: FFIType.i32 },
+    AVIStreamCreate: { args: [FFIType.ptr, FFIType.i32, FFIType.i32, FFIType.ptr], returns: FFIType.i32 },
+    AVIStreamEndStreaming: { args: [FFIType.u64], returns: FFIType.i32 },
+    AVIStreamFindSample: { args: [FFIType.u64, FFIType.i32, FFIType.i32], returns: FFIType.i32 },
+    AVIStreamGetFrame: { args: [FFIType.u64, FFIType.i32], returns: FFIType.ptr },
+    AVIStreamGetFrameClose: { args: [FFIType.u64], returns: FFIType.i32 },
+    AVIStreamGetFrameOpen: { args: [FFIType.u64, FFIType.ptr], returns: FFIType.u64 },
+    AVIStreamInfo: { args: [FFIType.u64, FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
+    AVIStreamInfoA: { args: [FFIType.u64, FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
+    AVIStreamInfoW: { args: [FFIType.u64, FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
+    AVIStreamLength: { args: [FFIType.u64], returns: FFIType.i32 },
+    AVIStreamOpenFromFile: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.i32, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
+    AVIStreamOpenFromFileA: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.i32, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
+    AVIStreamOpenFromFileW: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.i32, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
+    AVIStreamRead: { args: [FFIType.u64, FFIType.i32, FFIType.i32, FFIType.ptr, FFIType.i32, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+    AVIStreamReadData: { args: [FFIType.u64, FFIType.u32, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+    AVIStreamReadFormat: { args: [FFIType.u64, FFIType.i32, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+    AVIStreamRelease: { args: [FFIType.u64], returns: FFIType.u32 },
+    AVIStreamSampleToTime: { args: [FFIType.u64, FFIType.i32], returns: FFIType.i32 },
+    AVIStreamSetFormat: { args: [FFIType.u64, FFIType.i32, FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
+    AVIStreamStart: { args: [FFIType.u64], returns: FFIType.i32 },
+    AVIStreamTimeToSample: { args: [FFIType.u64, FFIType.i32], returns: FFIType.i32 },
+    AVIStreamWrite: { args: [FFIType.u64, FFIType.i32, FFIType.i32, FFIType.ptr, FFIType.i32, FFIType.u32, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+    AVIStreamWriteData: { args: [FFIType.u64, FFIType.u32, FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
+    CreateEditableStream: { args: [FFIType.ptr, FFIType.u64], returns: FFIType.i32 },
+    EditStreamClone: { args: [FFIType.u64, FFIType.ptr], returns: FFIType.i32 },
+    EditStreamCopy: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+    EditStreamCut: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+    EditStreamPaste: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.u64, FFIType.i32, FFIType.i32], returns: FFIType.i32 },
+    EditStreamSetInfo: { args: [FFIType.u64, FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
+    EditStreamSetInfoA: { args: [FFIType.u64, FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
+    EditStreamSetInfoW: { args: [FFIType.u64, FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
+    EditStreamSetName: { args: [FFIType.u64, FFIType.ptr], returns: FFIType.i32 },
+    EditStreamSetNameA: { args: [FFIType.u64, FFIType.ptr], returns: FFIType.i32 },
+    EditStreamSetNameW: { args: [FFIType.u64, FFIType.ptr], returns: FFIType.i32 },
+  } as const satisfies Record<string, FFIFunction>;
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avibuildfilter
+  public static AVIBuildFilter(lpszFilter: LPTSTR, cbFilter: LONG, fSaving: BOOL): HRESULT {
+    return Avifil32.Load('AVIBuildFilter')(lpszFilter, cbFilter, fSaving);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avibuildfiltera
+  public static AVIBuildFilterA(lpszFilter: LPSTR, cbFilter: LONG, fSaving: BOOL): HRESULT {
+    return Avifil32.Load('AVIBuildFilterA')(lpszFilter, cbFilter, fSaving);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avibuildfilterw
+  public static AVIBuildFilterW(lpszFilter: LPWSTR, cbFilter: LONG, fSaving: BOOL): HRESULT {
+    return Avifil32.Load('AVIBuildFilterW')(lpszFilter, cbFilter, fSaving);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-aviclearclipboard
+  public static AVIClearClipboard(): HRESULT {
+    return Avifil32.Load('AVIClearClipboard')();
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avifileaddref
+  public static AVIFileAddRef(pfile: PAVIFILE): ULONG {
+    return Avifil32.Load('AVIFileAddRef')(pfile);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avifilecreatestream
+  public static AVIFileCreateStream(pfile: PAVIFILE, ppavi: Pointer, psi: LPAVISTREAMINFO): HRESULT {
+    return Avifil32.Load('AVIFileCreateStream')(pfile, ppavi, psi);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avifilecreatestreama
+  public static AVIFileCreateStreamA(pfile: PAVIFILE, ppavi: Pointer, psi: LPAVISTREAMINFOA): HRESULT {
+    return Avifil32.Load('AVIFileCreateStreamA')(pfile, ppavi, psi);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avifilecreatestreamw
+  public static AVIFileCreateStreamW(pfile: PAVIFILE, ppavi: Pointer, psi: LPAVISTREAMINFOW): HRESULT {
+    return Avifil32.Load('AVIFileCreateStreamW')(pfile, ppavi, psi);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avifileendrecord
+  public static AVIFileEndRecord(pfile: PAVIFILE): HRESULT {
+    return Avifil32.Load('AVIFileEndRecord')(pfile);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avifileexit
+  public static AVIFileExit(): void {
+    return Avifil32.Load('AVIFileExit')();
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avifilegetstream
+  public static AVIFileGetStream(pfile: PAVIFILE, ppavi: Pointer, fccType: DWORD, lParam: LONG): HRESULT {
+    return Avifil32.Load('AVIFileGetStream')(pfile, ppavi, fccType, lParam);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avifileinfo
+  public static AVIFileInfo(pfile: PAVIFILE, pfi: LPAVIFILEINFO, lSize: LONG): HRESULT {
+    return Avifil32.Load('AVIFileInfo')(pfile, pfi, lSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avifileinfoa
+  public static AVIFileInfoA(pfile: PAVIFILE, pfi: LPAVIFILEINFOA, lSize: LONG): HRESULT {
+    return Avifil32.Load('AVIFileInfoA')(pfile, pfi, lSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avifileinfow
+  public static AVIFileInfoW(pfile: PAVIFILE, pfi: LPAVIFILEINFOW, lSize: LONG): HRESULT {
+    return Avifil32.Load('AVIFileInfoW')(pfile, pfi, lSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avifileinit
+  public static AVIFileInit(): void {
+    return Avifil32.Load('AVIFileInit')();
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avifileopen
+  public static AVIFileOpen(ppfile: Pointer, szFile: LPCTSTR, uMode: UINT, lpHandler: LPCLSID | NULL): HRESULT {
+    return Avifil32.Load('AVIFileOpen')(ppfile, szFile, uMode, lpHandler);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avifileopena
+  public static AVIFileOpenA(ppfile: Pointer, szFile: LPCSTR, uMode: UINT, lpHandler: LPCLSID | NULL): HRESULT {
+    return Avifil32.Load('AVIFileOpenA')(ppfile, szFile, uMode, lpHandler);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avifileopenw
+  public static AVIFileOpenW(ppfile: Pointer, szFile: LPCWSTR, uMode: UINT, lpHandler: LPCLSID | NULL): HRESULT {
+    return Avifil32.Load('AVIFileOpenW')(ppfile, szFile, uMode, lpHandler);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avifilereaddata
+  public static AVIFileReadData(pfile: PAVIFILE, ckid: DWORD, lpData: LPVOID, lpcbData: LPLONG): HRESULT {
+    return Avifil32.Load('AVIFileReadData')(pfile, ckid, lpData, lpcbData);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avifilerelease
+  public static AVIFileRelease(pfile: PAVIFILE): ULONG {
+    return Avifil32.Load('AVIFileRelease')(pfile);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avifilewritedata
+  public static AVIFileWriteData(pfile: PAVIFILE, ckid: DWORD, lpData: LPVOID, cbData: LONG): HRESULT {
+    return Avifil32.Load('AVIFileWriteData')(pfile, ckid, lpData, cbData);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avigetfromclipboard
+  public static AVIGetFromClipboard(lppf: Pointer): HRESULT {
+    return Avifil32.Load('AVIGetFromClipboard')(lppf);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avimakecompressedstream
+  public static AVIMakeCompressedStream(ppsCompressed: Pointer, ppsSource: PAVISTREAM, lpOptions: LPAVICOMPRESSOPTIONS, pclsidHandler: LPCLSID | NULL): HRESULT {
+    return Avifil32.Load('AVIMakeCompressedStream')(ppsCompressed, ppsSource, lpOptions, pclsidHandler);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avimakefilefromstreams
+  public static AVIMakeFileFromStreams(ppfile: Pointer, nStreams: INT, papStreams: Pointer): HRESULT {
+    return Avifil32.Load('AVIMakeFileFromStreams')(ppfile, nStreams, papStreams);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avimakestreamfromclipboard
+  public static AVIMakeStreamFromClipboard(cfFormat: UINT, hGlobal: HANDLE, ppstream: Pointer): HRESULT {
+    return Avifil32.Load('AVIMakeStreamFromClipboard')(cfFormat, hGlobal, ppstream);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-aviputfileonclipboard
+  public static AVIPutFileOnClipboard(pf: PAVIFILE): HRESULT {
+    return Avifil32.Load('AVIPutFileOnClipboard')(pf);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avisave
+  public static AVISave(szFile: LPCTSTR, pclsidHandler: LPCLSID | NULL, lpfnCallback: AVISAVECALLBACK | NULL, nStreams: INT, pfile: PAVISTREAM, lpOptions: LPAVICOMPRESSOPTIONS | NULL): HRESULT {
+    return Avifil32.Load('AVISave')(szFile, pclsidHandler, lpfnCallback, nStreams, pfile, lpOptions);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avisavea
+  public static AVISaveA(szFile: LPCSTR, pclsidHandler: LPCLSID | NULL, lpfnCallback: AVISAVECALLBACK | NULL, nStreams: INT, pfile: PAVISTREAM, lpOptions: LPAVICOMPRESSOPTIONS | NULL): HRESULT {
+    return Avifil32.Load('AVISaveA')(szFile, pclsidHandler, lpfnCallback, nStreams, pfile, lpOptions);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avisaveoptions
+  public static AVISaveOptions(hwnd: HWND, uiFlags: UINT, nStreams: INT, ppavi: Pointer, plpOptions: Pointer): INT_PTR {
+    return Avifil32.Load('AVISaveOptions')(hwnd, uiFlags, nStreams, ppavi, plpOptions);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avisaveoptionsfree
+  public static AVISaveOptionsFree(nStreams: INT, plpOptions: Pointer): HRESULT {
+    return Avifil32.Load('AVISaveOptionsFree')(nStreams, plpOptions);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avisavev
+  public static AVISaveV(szFile: LPCTSTR, pclsidHandler: LPCLSID | NULL, lpfnCallback: AVISAVECALLBACK | NULL, nStreams: INT, ppavi: Pointer, plpOptions: Pointer): HRESULT {
+    return Avifil32.Load('AVISaveV')(szFile, pclsidHandler, lpfnCallback, nStreams, ppavi, plpOptions);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avisaveva
+  public static AVISaveVA(szFile: LPCSTR, pclsidHandler: LPCLSID | NULL, lpfnCallback: AVISAVECALLBACK | NULL, nStreams: INT, ppavi: Pointer, plpOptions: Pointer): HRESULT {
+    return Avifil32.Load('AVISaveVA')(szFile, pclsidHandler, lpfnCallback, nStreams, ppavi, plpOptions);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avisavevw
+  public static AVISaveVW(szFile: LPCWSTR, pclsidHandler: LPCLSID | NULL, lpfnCallback: AVISAVECALLBACK | NULL, nStreams: INT, ppavi: Pointer, plpOptions: Pointer): HRESULT {
+    return Avifil32.Load('AVISaveVW')(szFile, pclsidHandler, lpfnCallback, nStreams, ppavi, plpOptions);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avisavew
+  public static AVISaveW(szFile: LPCWSTR, pclsidHandler: LPCLSID | NULL, lpfnCallback: AVISAVECALLBACK | NULL, nStreams: INT, pfile: PAVISTREAM, lpOptions: LPAVICOMPRESSOPTIONS | NULL): HRESULT {
+    return Avifil32.Load('AVISaveW')(szFile, pclsidHandler, lpfnCallback, nStreams, pfile, lpOptions);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avistreamaddref
+  public static AVIStreamAddRef(pavi: PAVISTREAM): ULONG {
+    return Avifil32.Load('AVIStreamAddRef')(pavi);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avistreambeginstreaming
+  public static AVIStreamBeginStreaming(pavi: PAVISTREAM, lStart: LONG, lEnd: LONG, lRate: LONG): HRESULT {
+    return Avifil32.Load('AVIStreamBeginStreaming')(pavi, lStart, lEnd, lRate);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avistreamcreate
+  public static AVIStreamCreate(ppavi: Pointer, lParam1: LONG, lParam2: LONG, pclsidHandler: LPCLSID | NULL): HRESULT {
+    return Avifil32.Load('AVIStreamCreate')(ppavi, lParam1, lParam2, pclsidHandler);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avistreamendstreaming
+  public static AVIStreamEndStreaming(pavi: PAVISTREAM): HRESULT {
+    return Avifil32.Load('AVIStreamEndStreaming')(pavi);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avistreamfindsample
+  public static AVIStreamFindSample(pavi: PAVISTREAM, lPos: LONG, lFlags: LONG): LONG {
+    return Avifil32.Load('AVIStreamFindSample')(pavi, lPos, lFlags);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avistreamgetframe
+  public static AVIStreamGetFrame(pg: PGETFRAME, lPos: LONG): LPVOID {
+    return Avifil32.Load('AVIStreamGetFrame')(pg, lPos);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avistreamgetframeclose
+  public static AVIStreamGetFrameClose(pg: PGETFRAME): HRESULT {
+    return Avifil32.Load('AVIStreamGetFrameClose')(pg);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avistreamgetframeopen
+  public static AVIStreamGetFrameOpen(pavi: PAVISTREAM, lpbiWanted: LPBITMAPINFOHEADER | NULL): PGETFRAME {
+    return Avifil32.Load('AVIStreamGetFrameOpen')(pavi, lpbiWanted);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avistreaminfo
+  public static AVIStreamInfo(pavi: PAVISTREAM, psi: LPAVISTREAMINFO, lSize: LONG): HRESULT {
+    return Avifil32.Load('AVIStreamInfo')(pavi, psi, lSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avistreaminfoa
+  public static AVIStreamInfoA(pavi: PAVISTREAM, psi: LPAVISTREAMINFOA, lSize: LONG): HRESULT {
+    return Avifil32.Load('AVIStreamInfoA')(pavi, psi, lSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avistreaminfow
+  public static AVIStreamInfoW(pavi: PAVISTREAM, psi: LPAVISTREAMINFOW, lSize: LONG): HRESULT {
+    return Avifil32.Load('AVIStreamInfoW')(pavi, psi, lSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avistreamlength
+  public static AVIStreamLength(pavi: PAVISTREAM): LONG {
+    return Avifil32.Load('AVIStreamLength')(pavi);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avistreamopenfromfile
+  public static AVIStreamOpenFromFile(ppavi: Pointer, szFile: LPCTSTR, fccType: DWORD, lParam: LONG, mode: UINT, pclsidHandler: LPCLSID | NULL): HRESULT {
+    return Avifil32.Load('AVIStreamOpenFromFile')(ppavi, szFile, fccType, lParam, mode, pclsidHandler);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avistreamopenfromfilea
+  public static AVIStreamOpenFromFileA(ppavi: Pointer, szFile: LPCSTR, fccType: DWORD, lParam: LONG, mode: UINT, pclsidHandler: LPCLSID | NULL): HRESULT {
+    return Avifil32.Load('AVIStreamOpenFromFileA')(ppavi, szFile, fccType, lParam, mode, pclsidHandler);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avistreamopenfromfilew
+  public static AVIStreamOpenFromFileW(ppavi: Pointer, szFile: LPCWSTR, fccType: DWORD, lParam: LONG, mode: UINT, pclsidHandler: LPCLSID | NULL): HRESULT {
+    return Avifil32.Load('AVIStreamOpenFromFileW')(ppavi, szFile, fccType, lParam, mode, pclsidHandler);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avistreamread
+  public static AVIStreamRead(pavi: PAVISTREAM, lStart: LONG, lSamples: LONG, lpBuffer: LPVOID | NULL, cbBuffer: LONG, plBytes: LPLONG | NULL, plSamples: LPLONG | NULL): HRESULT {
+    return Avifil32.Load('AVIStreamRead')(pavi, lStart, lSamples, lpBuffer, cbBuffer, plBytes, plSamples);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avistreamreaddata
+  public static AVIStreamReadData(pavi: PAVISTREAM, fcc: DWORD, lp: LPVOID | NULL, lpcb: LPLONG): HRESULT {
+    return Avifil32.Load('AVIStreamReadData')(pavi, fcc, lp, lpcb);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avistreamreadformat
+  public static AVIStreamReadFormat(pavi: PAVISTREAM, lPos: LONG, lpFormat: LPVOID | NULL, lpcbFormat: LPLONG): HRESULT {
+    return Avifil32.Load('AVIStreamReadFormat')(pavi, lPos, lpFormat, lpcbFormat);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avistreamrelease
+  public static AVIStreamRelease(pavi: PAVISTREAM): ULONG {
+    return Avifil32.Load('AVIStreamRelease')(pavi);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avistreamsampletotime
+  public static AVIStreamSampleToTime(pavi: PAVISTREAM, lSample: LONG): LONG {
+    return Avifil32.Load('AVIStreamSampleToTime')(pavi, lSample);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avistreamsetformat
+  public static AVIStreamSetFormat(pavi: PAVISTREAM, lPos: LONG, lpFormat: LPVOID, cbFormat: LONG): HRESULT {
+    return Avifil32.Load('AVIStreamSetFormat')(pavi, lPos, lpFormat, cbFormat);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avistreamstart
+  public static AVIStreamStart(pavi: PAVISTREAM): LONG {
+    return Avifil32.Load('AVIStreamStart')(pavi);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avistreamtimetosample
+  public static AVIStreamTimeToSample(pavi: PAVISTREAM, lTime: LONG): LONG {
+    return Avifil32.Load('AVIStreamTimeToSample')(pavi, lTime);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avistreamwrite
+  public static AVIStreamWrite(pavi: PAVISTREAM, lStart: LONG, lSamples: LONG, lpBuffer: LPVOID, cbBuffer: LONG, dwFlags: DWORD, plSampWritten: LPLONG | NULL, plBytesWritten: LPLONG | NULL): HRESULT {
+    return Avifil32.Load('AVIStreamWrite')(pavi, lStart, lSamples, lpBuffer, cbBuffer, dwFlags, plSampWritten, plBytesWritten);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-avistreamwritedata
+  public static AVIStreamWriteData(pavi: PAVISTREAM, fcc: DWORD, lp: LPVOID, cb: LONG): HRESULT {
+    return Avifil32.Load('AVIStreamWriteData')(pavi, fcc, lp, cb);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-createeditablestream
+  public static CreateEditableStream(ppsEditable: Pointer, psSource: PAVISTREAM | 0n): HRESULT {
+    return Avifil32.Load('CreateEditableStream')(ppsEditable, psSource);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-editstreamclone
+  public static EditStreamClone(pavi: PAVISTREAM, ppResult: Pointer): HRESULT {
+    return Avifil32.Load('EditStreamClone')(pavi, ppResult);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-editstreamcopy
+  public static EditStreamCopy(pavi: PAVISTREAM, plStart: LPLONG, plLength: LPLONG, ppResult: Pointer): HRESULT {
+    return Avifil32.Load('EditStreamCopy')(pavi, plStart, plLength, ppResult);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-editstreamcut
+  public static EditStreamCut(pavi: PAVISTREAM, plStart: LPLONG, plLength: LPLONG, ppResult: Pointer): HRESULT {
+    return Avifil32.Load('EditStreamCut')(pavi, plStart, plLength, ppResult);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-editstreampaste
+  public static EditStreamPaste(pavi: PAVISTREAM, plPos: LPLONG, plLength: LPLONG, pstream: PAVISTREAM, lStart: LONG, lEnd: LONG): HRESULT {
+    return Avifil32.Load('EditStreamPaste')(pavi, plPos, plLength, pstream, lStart, lEnd);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-editstreamsetinfo
+  public static EditStreamSetInfo(pavi: PAVISTREAM, lpInfo: LPAVISTREAMINFO, cbInfo: LONG): HRESULT {
+    return Avifil32.Load('EditStreamSetInfo')(pavi, lpInfo, cbInfo);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-editstreamsetinfoa
+  public static EditStreamSetInfoA(pavi: PAVISTREAM, lpInfo: LPAVISTREAMINFOA, cbInfo: LONG): HRESULT {
+    return Avifil32.Load('EditStreamSetInfoA')(pavi, lpInfo, cbInfo);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-editstreamsetinfow
+  public static EditStreamSetInfoW(pavi: PAVISTREAM, lpInfo: LPAVISTREAMINFOW, cbInfo: LONG): HRESULT {
+    return Avifil32.Load('EditStreamSetInfoW')(pavi, lpInfo, cbInfo);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-editstreamsetname
+  public static EditStreamSetName(pavi: PAVISTREAM, lpszName: LPCTSTR): HRESULT {
+    return Avifil32.Load('EditStreamSetName')(pavi, lpszName);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-editstreamsetnamea
+  public static EditStreamSetNameA(pavi: PAVISTREAM, lpszName: LPCSTR): HRESULT {
+    return Avifil32.Load('EditStreamSetNameA')(pavi, lpszName);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/vfw/nf-vfw-editstreamsetnamew
+  public static EditStreamSetNameW(pavi: PAVISTREAM, lpszName: LPCWSTR): HRESULT {
+    return Avifil32.Load('EditStreamSetNameW')(pavi, lpszName);
+  }
+}
+
+export default Avifil32;

package/types/Avifil32.ts

@@ -0,0 +1,96 @@
+import type { Pointer } from 'bun:ffi';
+
+export type { BOOL, DWORD, HANDLE, HRESULT, HWND, INT, INT_PTR, LONG, LPCSTR, LPCWSTR, LPSTR, LPVOID, LPWSTR, NULL, UINT, ULONG } from '@bun-win32/core';
+
+export const AVISTREAMREAD_CONVENIENT = -1;
+
+export enum AviCompressFlags {
+  AVICOMPRESSF_DATARATE = 0x0000_0002,
+  AVICOMPRESSF_INTERLEAVE = 0x0000_0001,
+  AVICOMPRESSF_KEYFRAMES = 0x0000_0004,
+  AVICOMPRESSF_VALID = 0x0000_0008,
+}
+
+export enum AviFileCaps {
+  AVIFILECAPS_ALLKEYFRAMES = 0x0000_0010,
+  AVIFILECAPS_CANREAD = 0x0000_0001,
+  AVIFILECAPS_CANWRITE = 0x0000_0002,
+  AVIFILECAPS_NOCOMPRESSION = 0x0000_0020,
+}
+
+export enum AviFileInfoFlags {
+  AVIFILEINFO_COPYRIGHTED = 0x0002_0000,
+  AVIFILEINFO_HASINDEX = 0x0000_0010,
+  AVIFILEINFO_ISINTERLEAVED = 0x0000_0100,
+  AVIFILEINFO_MUSTUSEINDEX = 0x0000_0020,
+  AVIFILEINFO_WASCAPTUREFILE = 0x0001_0000,
+}
+
+export enum AviGetFrameFlags {
+  AVIGETFRAMEF_BESTDISPLAYFMT = 0x0000_0001,
+}
+
+export enum AviIndexFlags {
+  AVIIF_COMPUSE = 0x0fff_0000,
+  AVIIF_FIRSTPART = 0x0000_0020,
+  AVIIF_KEYFRAME = 0x0000_0010,
+  AVIIF_LASTPART = 0x0000_0040,
+  AVIIF_LIST = 0x0000_0001,
+  AVIIF_MIDPART = 0x0000_0060,
+  AVIIF_NOTIME = 0x0000_0100,
+}
+
+export enum AviStreamInfoFlags {
+  AVISTREAMINFO_DISABLED = 0x0000_0001,
+  AVISTREAMINFO_FORMATCHANGES = 0x0001_0000,
+}
+
+export enum FindSampleFlags {
+  FIND_ANY = 0x0000_0020,
+  FIND_DIR = 0x0000_000f,
+  FIND_FORMAT = 0x0000_0040,
+  FIND_FROM_START = 0x0000_0008,
+  FIND_INDEX = 0x0000_4000,
+  FIND_KEY = 0x0000_0010,
+  FIND_LENGTH = 0x0000_1000,
+  FIND_NEXT = 0x0000_0001,
+  FIND_OFFSET = 0x0000_2000,
+  FIND_POS = 0x0000_0000,
+  FIND_PREV = 0x0000_0004,
+  FIND_RET = 0x0000_f000,
+  FIND_SIZE = 0x0000_3000,
+  FIND_TYPE = 0x0000_00f0,
+}
+
+export enum OpenFileFlags {
+  OF_CREATE = 0x0000_1000,
+  OF_READ = 0x0000_0000,
+  OF_READWRITE = 0x0000_0002,
+  OF_SHARE_DENY_NONE = 0x0000_0040,
+  OF_SHARE_EXCLUSIVE = 0x0000_0010,
+  OF_WRITE = 0x0000_0001,
+}
+
+export enum StreamType {
+  streamtypeAUDIO = 0x7364_7561,
+  streamtypeMIDI = 0x7364_696d,
+  streamtypeTEXT = 0x7374_7874,
+  streamtypeVIDEO = 0x7364_6976,
+}
+
+export type AVISAVECALLBACK = Pointer;
+export type LPAVICOMPRESSOPTIONS = Pointer;
+export type LPAVIFILEINFO = Pointer;
+export type LPAVIFILEINFOA = Pointer;
+export type LPAVIFILEINFOW = Pointer;
+export type LPAVISTREAMINFO = Pointer;
+export type LPAVISTREAMINFOA = Pointer;
+export type LPAVISTREAMINFOW = Pointer;
+export type LPBITMAPINFOHEADER = Pointer;
+export type LPCLSID = Pointer;
+export type LPCTSTR = Pointer;
+export type LPLONG = Pointer;
+export type LPTSTR = Pointer;
+export type PAVIFILE = bigint;
+export type PAVISTREAM = bigint;
+export type PGETFRAME = bigint;