@mediaway/ffi 0.1.4 → 0.1.6

package/dist/index.d.ts

@@ -13,33 +13,46 @@
  *     buffers, polled device frames) MUST be released through the matching
  *     `_free` — the public packages do this automatically.
  */
+import { type TypeObject } from "koffi";
 export declare function findLibrary(name: string): string;
 export declare const containerLib: import("koffi").LibraryHandle;
 export declare const pipelineLib: import("koffi").LibraryHandle;
 export declare const deviceLib: import("koffi").LibraryHandle;
-export declare const MwRational: import("koffi").TypeObject;
-export declare const MwVideoTrackInfo: import("koffi").TypeObject;
-export declare const MwAudioTrackInfo: import("koffi").TypeObject;
-export declare const MwPacketView: import("koffi").TypeObject;
-export declare const MwPacket: import("koffi").TypeObject;
-export declare const MwStreamInfo: import("koffi").TypeObject;
-export declare const MwGpuDeviceHandle: import("koffi").TypeObject;
-export declare const MwGpuBufferHandle: import("koffi").TypeObject;
-export declare const MwEncConfig: import("koffi").TypeObject;
-export declare const MwPipelineFrame: import("koffi").TypeObject;
-export declare const MwCameraConfig: import("koffi").TypeObject;
-export declare const MwCameraFrame: import("koffi").TypeObject;
-export declare const MwDesktopConfig: import("koffi").TypeObject;
-export declare const MwDesktopFrame: import("koffi").TypeObject;
-export declare const MwAudioConfig: import("koffi").TypeObject;
-export declare const MwAudioFrame: import("koffi").TypeObject;
-export declare const MwAudioEncodeConfig: import("koffi").TypeObject;
-export declare const MwAudioFrameView: import("koffi").TypeObject;
-export declare const MwAudioPacket: import("koffi").TypeObject;
-export declare const MwAudioStreamInfo: import("koffi").TypeObject;
+export declare const MwRational: TypeObject;
+export declare const MwVideoTrackInfo: TypeObject;
+export declare const MwAudioTrackInfo: TypeObject;
+export declare const MwPacketView: TypeObject;
+export declare const MwPacket: TypeObject;
+export declare const MwTsElementaryStream: TypeObject;
+export declare const MwMp3FrameHeader: TypeObject;
+export declare const MwWaveFormat: TypeObject;
+export declare const MwStreamInfo: TypeObject;
+export declare const MwGpuDeviceHandle: TypeObject;
+export declare const MwGpuBufferHandle: TypeObject;
+export declare const MwEncConfig: TypeObject;
+export declare const MwPipelineFrame: TypeObject;
+export declare const MwCameraConfig: TypeObject;
+export declare const MwCameraFrame: TypeObject;
+export declare const MwDesktopConfig: TypeObject;
+export declare const MwDesktopFrame: TypeObject;
+export declare const MwGpuAdapterInfo: TypeObject;
+export declare const MwGpuAdapterSelect: TypeObject;
+export declare const MwGpuDeviceOptions: TypeObject;
+export declare const MwAudioConfig: TypeObject;
+export declare const MwAudioFrame: TypeObject;
+export declare const MwAudioEncodeConfig: TypeObject;
+export declare const MwAudioFrameView: TypeObject;
+export declare const MwAudioPacket: TypeObject;
+export declare const MwAudioStreamInfo: TypeObject;
+export declare const MwDecodePacketView: TypeObject;
+export declare const MwAutoVideoDecodeConfig: TypeObject;
+export declare const MwDecodedVideoFrame: TypeObject;
+export declare const MwAudioDecodeConfig: TypeObject;
+export declare const MwDecodedAudioFrame: TypeObject;
 export declare const container: {
     abiVersion: import("koffi").Callable;
     muxerCreate: import("koffi").Callable;
+    muxerCreateForFormat: import("koffi").Callable;
     muxerCreateWithBatch: import("koffi").Callable;
     muxerAddVideoTrack: import("koffi").Callable;
     muxerAddAudioTrack: import("koffi").Callable;
@@ -49,6 +62,7 @@ export declare const container: {
     muxerPollBytes: import("koffi").Callable;
     muxerClose: import("koffi").Callable;
     demuxerCreate: import("koffi").Callable;
+    demuxerCreateForFormat: import("koffi").Callable;
     demuxerPushBytes: import("koffi").Callable;
     demuxerStreamCount: import("koffi").Callable;
     demuxerStreamAt: import("koffi").Callable;
@@ -59,6 +73,67 @@ export declare const container: {
     bufferFree: import("koffi").Callable;
     packetFree: import("koffi").Callable;
     streamInfoFree: import("koffi").Callable;
+    oggMuxerCreate: import("koffi").Callable;
+    oggMuxerPushPacket: import("koffi").Callable;
+    oggMuxerFlush: import("koffi").Callable;
+    oggMuxerPollBytes: import("koffi").Callable;
+    oggMuxerClose: import("koffi").Callable;
+    oggDemuxerCreate: import("koffi").Callable;
+    oggDemuxerPushBytes: import("koffi").Callable;
+    oggDemuxerStreamCount: import("koffi").Callable;
+    oggDemuxerStreamAt: import("koffi").Callable;
+    oggDemuxerPollPacket: import("koffi").Callable;
+    oggDemuxerClose: import("koffi").Callable;
+    adtsMuxerCreate: import("koffi").Callable;
+    adtsMuxerPushPacket: import("koffi").Callable;
+    adtsMuxerFlush: import("koffi").Callable;
+    adtsMuxerPollBytes: import("koffi").Callable;
+    adtsMuxerClose: import("koffi").Callable;
+    adtsDemuxerCreate: import("koffi").Callable;
+    adtsDemuxerPushBytes: import("koffi").Callable;
+    adtsDemuxerStreamCount: import("koffi").Callable;
+    adtsDemuxerStreamAt: import("koffi").Callable;
+    adtsDemuxerPollPacket: import("koffi").Callable;
+    adtsDemuxerClose: import("koffi").Callable;
+    flvMuxerCreate: import("koffi").Callable;
+    flvMuxerWriteHeader: import("koffi").Callable;
+    flvMuxerAddVideoTrack: import("koffi").Callable;
+    flvMuxerAddAudioTrack: import("koffi").Callable;
+    flvMuxerPushPacket: import("koffi").Callable;
+    flvMuxerClose: import("koffi").Callable;
+    flvDemuxerCreate: import("koffi").Callable;
+    flvDemuxerPushBytes: import("koffi").Callable;
+    flvDemuxerStreamCount: import("koffi").Callable;
+    flvDemuxerStreamAt: import("koffi").Callable;
+    flvDemuxerPollPacket: import("koffi").Callable;
+    flvDemuxerClose: import("koffi").Callable;
+    tsMuxerCreate: import("koffi").Callable;
+    tsMuxerWritePatPmt: import("koffi").Callable;
+    tsMuxerWriteAccessUnit: import("koffi").Callable;
+    tsMuxerClose: import("koffi").Callable;
+    tsDemuxerCreate: import("koffi").Callable;
+    tsDemuxerPushBytes: import("koffi").Callable;
+    tsDemuxerStreamCount: import("koffi").Callable;
+    tsDemuxerStreamAt: import("koffi").Callable;
+    tsDemuxerPollPacket: import("koffi").Callable;
+    tsDemuxerFinish: import("koffi").Callable;
+    tsDemuxerFinishFree: import("koffi").Callable;
+    tsDemuxerClose: import("koffi").Callable;
+    mp3MuxerCreate: import("koffi").Callable;
+    mp3MuxerWriteFrame: import("koffi").Callable;
+    mp3MuxerClose: import("koffi").Callable;
+    mp3DemuxerCreate: import("koffi").Callable;
+    mp3DemuxerPushBytes: import("koffi").Callable;
+    mp3DemuxerStreamCount: import("koffi").Callable;
+    mp3DemuxerStreamAt: import("koffi").Callable;
+    mp3DemuxerPollPacket: import("koffi").Callable;
+    mp3DemuxerClose: import("koffi").Callable;
+    wavMuxerCreate: import("koffi").Callable;
+    wavMuxerCreateWithFormat: import("koffi").Callable;
+    wavMuxerPushPacket: import("koffi").Callable;
+    wavMuxerFinish: import("koffi").Callable;
+    wavMuxerClose: import("koffi").Callable;
+    wavParse: import("koffi").Callable;
 };
 export declare const pipeline: {
     abiVersion: import("koffi").Callable;
@@ -80,6 +155,22 @@ export declare const pipeline: {
     audioSessionClose: import("koffi").Callable;
     pipelinePacketFree: import("koffi").Callable;
     pipelineStreamInfoFree: import("koffi").Callable;
+    decodeConfigNew: import("koffi").Callable;
+    decodeSessionOpen: import("koffi").Callable;
+    decodeSessionPushPacket: import("koffi").Callable;
+    decodeSessionPollFrame: import("koffi").Callable;
+    decodeSessionFlush: import("koffi").Callable;
+    decodeSessionClose: import("koffi").Callable;
+    decodedVideoFrameFree: import("koffi").Callable;
+    audioDecodeConfigOpus: import("koffi").Callable;
+    audioDecodeSessionOpen: import("koffi").Callable;
+    audioDecodeSessionPushPacket: import("koffi").Callable;
+    audioDecodeSessionPollFrame: import("koffi").Callable;
+    audioDecodeSessionFlush: import("koffi").Callable;
+    audioDecodeSessionClose: import("koffi").Callable;
+    decodedAudioFrameFree: import("koffi").Callable;
+    sessionWriteFrameFromCameraCapture: import("koffi").Callable;
+    sessionWriteFrameFromDesktopCapture: import("koffi").Callable;
 };
 export declare const device: {
     abiVersion: import("koffi").Callable;
@@ -104,9 +195,21 @@ export declare const device: {
     audioPollFrame: import("koffi").Callable;
     audioClose: import("koffi").Callable;
     audioFrameFree: import("koffi").Callable;
+    gpuAdapterList: import("koffi").Callable;
+    gpuAdapterListFree: import("koffi").Callable;
+    gpuDeviceCreate: import("koffi").Callable;
+    gpuDeviceHandle: import("koffi").Callable;
+    gpuDeviceClose: import("koffi").Callable;
 };
 /** Copy `len` bytes out of a koffi pointer/opaque handle. */
 export declare function copyBytes(ptr: unknown, len: number): Buffer;
+/**
+ * Decode `count` consecutive struct instances out of a pointer to an owned
+ * native array (e.g. `mediaway_ts_demuxer_finish`'s `out_packets`) — the only
+ * multi-element owned-array output shape in this crate. Free the underlying
+ * array with the matching `_finish_free` after copying out what's needed.
+ */
+export declare function decodeArray<T>(ptr: unknown, type: TypeObject, count: number): T[];
 /** `mediaway_rational_t` (u64 num / u32 den). */
 export interface RawRational {
     num: bigint | number;
@@ -159,12 +262,32 @@ export interface RawStreamInfo {
 export interface RawPacket {
     stream_id: number;
     pts: bigint | number;
+    dts: bigint | number;
     duration: bigint | number;
     is_keyframe: boolean;
     is_discard: boolean;
     payload: unknown;
     payload_len: number;
 }
+/** `mediaway_ts_elementary_stream_t` (MPEG-TS muxer construction input). */
+export interface RawTsElementaryStream {
+    pid: number;
+    codec: number;
+}
+/** `mediaway_mp3_frame_header_t` (MP3 muxer construction input). */
+export interface RawMp3FrameHeader {
+    version: number;
+    bitrate_kbps: number;
+    sample_rate: number;
+    channel_mode: number;
+}
+/** `mediaway_wave_format_t` (WAV muxer construction input). */
+export interface RawWaveFormat {
+    sample_format: number;
+    channels: number;
+    sample_rate: number;
+    bits_per_sample: number;
+}
 /** ABI output structs — fields are filled by the ABI call; callers construct
  * them empty (`{} as RawX`) and read the fields after the call. */
 /** `mediaway_camera_frame_t` / `mediaway_audio_frame_t` (device outputs). */
@@ -177,6 +300,20 @@ export interface RawCameraFrame {
     data: unknown;
     data_len: number;
 }
+/** `mediaway_desktop_frame_t` (Screen output) — unlike `RawCameraFrame`, GPU
+ * storage (`storage_kind == 1`) leaves `data`/`data_len` empty and carries the
+ * frame in `gpu_buffer` instead (borrowed — never freed by the caller). */
+export interface RawDesktopFrame {
+    pts: bigint | number;
+    duration: bigint | number;
+    width: number;
+    height: number;
+    pixel_format: number;
+    storage_kind: number;
+    data: unknown;
+    data_len: number;
+    gpu_buffer: RawGpuBufferHandle;
+}
 export interface RawAudioFrame {
     pts: bigint | number;
     duration: bigint | number;
@@ -198,6 +335,13 @@ export interface RawPipelineFrame {
     raw_bytes_len: number;
     gpu_buffer: RawGpuBufferHandle;
 }
+/** `mediaway_gpu_device_handle_t` (Screen capture / GPU-input encode input,
+ * mediaway_gpu_device_handle()'s output). */
+export interface RawGpuDeviceHandle {
+    kind: number;
+    native: number | bigint;
+    webgpu_device_id: number | bigint;
+}
 /** `mediaway_gpu_buffer_handle_t`. */
 export interface RawGpuBufferHandle {
     kind: number;
@@ -242,3 +386,71 @@ export interface RawAudioPacket {
     payload: unknown;
     payload_len: number;
 }
+/** `mediaway_decode_packet_view_t` (decode session input; shared by video + audio). */
+export interface RawDecodePacketView {
+    stream_id: number;
+    pts: bigint | number;
+    dts: bigint | number;
+    duration: bigint | number;
+    is_keyframe: boolean;
+    is_discard: boolean;
+    payload: unknown;
+    payload_len: number;
+}
+/** `mediaway_auto_video_decode_config_t`. */
+export interface RawAutoVideoDecodeConfig {
+    codec: number;
+    width: number;
+    height: number;
+    time_base: RawRational;
+    pixel_format: number;
+    extra_data: unknown;
+    extra_data_len: number;
+}
+/** `mediaway_decoded_video_frame_t` (decode session output). */
+export interface RawDecodedVideoFrame {
+    pts: bigint | number;
+    duration: bigint | number;
+    width: number;
+    height: number;
+    pixel_format: number;
+    data: unknown;
+    data_len: number;
+}
+/** `mediaway_audio_decode_config_t` (Opus only today). */
+export interface RawAudioDecodeConfig {
+    codec: number;
+    sample_rate: number;
+    channels: number;
+    time_base: RawRational;
+}
+/** `mediaway_decoded_audio_frame_t` (audio decode session output; always F32). */
+export interface RawDecodedAudioFrame {
+    pts: bigint | number;
+    duration: bigint | number;
+    sample_rate: number;
+    channels: number;
+    sample_format: number;
+    data: unknown;
+    data_len: number;
+}
+/** `mediaway_gpu_adapter_info_t` (mediaway-device ADR-0007). */
+export interface RawGpuAdapterInfo {
+    index: number;
+    name: string;
+    vendor_id: number;
+    device_id: number;
+    dedicated_video_memory: bigint | number;
+    is_hardware: boolean;
+}
+/** `mediaway_gpu_adapter_select_t`. */
+export interface RawGpuAdapterSelect {
+    kind: number;
+    index: number;
+}
+/** `mediaway_gpu_device_options_t`. */
+export interface RawGpuDeviceOptions {
+    adapter: RawGpuAdapterSelect;
+    video_support: boolean;
+    debug_layer: boolean;
+}

package/dist/index.js

@@ -13,7 +13,7 @@
  *     buffers, polled device frames) MUST be released through the matching
  *     `_free` — the public packages do this automatically.
  */
-import koffi from "koffi";
+import koffi, {} from "koffi";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -43,12 +43,29 @@ export function findLibrary(name) {
     }
     throw new Error(`cannot find ${name}; set $MEDIAWAY_FFI_DIR or build the -ffi crates`);
 }
+/**
+ * cdylib filename Cargo produces for this platform. Windows and Linux only —
+ * the workspace's own hardware/CI coverage is limited to those two (see
+ * docs/ai/wiki/platform/order.md); macOS support is not claimed here since
+ * it has never been built or run.
+ */
+function libraryFilename() {
+    switch (process.platform) {
+        case "win32":
+            return "mediaway_ffi.dll";
+        case "linux":
+            return "libmediaway_ffi.so";
+        default:
+            throw new Error(`mediaway: unsupported platform ${process.platform} (Windows and Linux only)`);
+    }
+}
 function load(name) {
     return koffi.load(findLibrary(name));
 }
-export const containerLib = load("mediaway_ffi.dll");
-export const pipelineLib = load("mediaway_ffi.dll");
-export const deviceLib = load("mediaway_ffi.dll");
+const libraryName = libraryFilename();
+export const containerLib = load(libraryName);
+export const pipelineLib = load(libraryName);
+export const deviceLib = load(libraryName);
 // ── Structs (layouts mirror the headers exactly) ───────────────────────────────
 export const MwRational = koffi.struct("MwRational", {
     num: "uint64",
@@ -92,6 +109,22 @@ export const MwPacket = koffi.struct("MwPacket", {
     payload: "uint8_t *",
     payload_len: "size_t",
 });
+export const MwTsElementaryStream = koffi.struct("MwTsElementaryStream", {
+    pid: "uint16",
+    codec: "int32",
+});
+export const MwMp3FrameHeader = koffi.struct("MwMp3FrameHeader", {
+    version: "int32",
+    bitrate_kbps: "uint16",
+    sample_rate: "uint32",
+    channel_mode: "int32",
+});
+export const MwWaveFormat = koffi.struct("MwWaveFormat", {
+    sample_format: "int32",
+    channels: "uint16",
+    sample_rate: "uint32",
+    bits_per_sample: "uint16",
+});
 export const MwStreamInfo = koffi.struct("MwStreamInfo", {
     id: "uint32",
     codec: "int32",
@@ -166,6 +199,23 @@ export const MwDesktopFrame = koffi.struct("MwDesktopFrame", {
     data_len: "size_t",
     gpu_buffer: MwGpuBufferHandle,
 });
+export const MwGpuAdapterInfo = koffi.struct("MwGpuAdapterInfo", {
+    index: "uint32",
+    name: "str", // owned NUL-terminated UTF-8; freed via gpuAdapterListFree, not per-entry
+    vendor_id: "uint32",
+    device_id: "uint32",
+    dedicated_video_memory: "uint64",
+    is_hardware: "bool",
+});
+export const MwGpuAdapterSelect = koffi.struct("MwGpuAdapterSelect", {
+    kind: "int32", // 0 = Default, 1 = Index
+    index: "uint32", // meaningful only when kind == Index
+});
+export const MwGpuDeviceOptions = koffi.struct("MwGpuDeviceOptions", {
+    adapter: MwGpuAdapterSelect,
+    video_support: "bool",
+    debug_layer: "bool",
+});
 export const MwAudioConfig = koffi.struct("MwAudioConfig", {
     device_index: "uint32",
     time_base: MwRational,
@@ -214,10 +264,57 @@ export const MwAudioStreamInfo = koffi.struct("MwAudioStreamInfo", {
     extra_data: "uint8_t *",
     extra_data_len: "size_t",
 });
+// ── Decode (adr/0004-auto-decode-c-abi.md, adr/pipeline/0006) ──────────────────
+// MwDecodePacketView is shared by both video and audio decode push_packet
+// calls — a new, pipeline-scoped type, not MwPacketView above.
+export const MwDecodePacketView = koffi.struct("MwDecodePacketView", {
+    stream_id: "uint32", // unused by decode; kept for call-site symmetry
+    pts: "int64",
+    dts: "int64",
+    duration: "uint64",
+    is_keyframe: "bool",
+    is_discard: "bool",
+    payload: "uint8_t *",
+    payload_len: "size_t",
+});
+export const MwAutoVideoDecodeConfig = koffi.struct("MwAutoVideoDecodeConfig", {
+    codec: "int32",
+    width: "uint32",
+    height: "uint32",
+    time_base: MwRational,
+    pixel_format: "int32",
+    extra_data: "uint8_t *", // borrowed, open-call only
+    extra_data_len: "size_t",
+});
+export const MwDecodedVideoFrame = koffi.struct("MwDecodedVideoFrame", {
+    pts: "int64",
+    duration: "uint64",
+    width: "uint32",
+    height: "uint32",
+    pixel_format: "int32",
+    data: "uint8_t *", // owned
+    data_len: "size_t",
+});
+export const MwAudioDecodeConfig = koffi.struct("MwAudioDecodeConfig", {
+    codec: "int32", // Opus only today
+    sample_rate: "uint32",
+    channels: "uint16",
+    time_base: MwRational,
+});
+export const MwDecodedAudioFrame = koffi.struct("MwDecodedAudioFrame", {
+    pts: "int64",
+    duration: "uint64",
+    sample_rate: "uint32",
+    channels: "uint16",
+    sample_format: "int32", // always F32 for Opus
+    data: "uint8_t *", // owned interleaved PCM
+    data_len: "size_t",
+});
 // ── Container functions ────────────────────────────────────────────────────────
 export const container = {
     abiVersion: containerLib.func("uint32_t mediaway_container_ffi_abi_version()"),
     muxerCreate: containerLib.func("void *mediaway_muxer_create()"),
+    muxerCreateForFormat: containerLib.func("void *mediaway_muxer_create_for_format(int format)"),
     muxerCreateWithBatch: containerLib.func("void *mediaway_muxer_create_with_fragment_batch(size_t batch)"),
     muxerAddVideoTrack: containerLib.func("int mediaway_muxer_add_video_track(void *muxer, MwVideoTrackInfo *info)"),
     muxerAddAudioTrack: containerLib.func("int mediaway_muxer_add_audio_track(void *muxer, MwAudioTrackInfo *info)"),
@@ -227,6 +324,7 @@ export const container = {
     muxerPollBytes: containerLib.func("int mediaway_muxer_poll_bytes(void *muxer, _Out_ uint8_t **out_data, _Out_ size_t *out_len)"),
     muxerClose: containerLib.func("void mediaway_muxer_close(void *muxer)"),
     demuxerCreate: containerLib.func("void *mediaway_demuxer_create()"),
+    demuxerCreateForFormat: containerLib.func("void *mediaway_demuxer_create_for_format(int format)"),
     demuxerPushBytes: containerLib.func("int mediaway_demuxer_push_bytes(void *demuxer, uint8_t *data, size_t len)"),
     demuxerStreamCount: containerLib.func("size_t mediaway_demuxer_stream_count(void *demuxer)"),
     demuxerStreamAt: containerLib.func("int mediaway_demuxer_stream_at(void *demuxer, size_t index, _Out_ MwStreamInfo *out_info)"),
@@ -237,6 +335,73 @@ export const container = {
     bufferFree: containerLib.func("void mediaway_buffer_free(uint8_t *data, size_t len)"),
     packetFree: containerLib.func("void mediaway_packet_free(MwPacket *packet)"),
     streamInfoFree: containerLib.func("void mediaway_stream_info_free(MwStreamInfo *info)"),
+    // ── Ogg (adr/container/0004) ──────────────────────────────────────────────
+    oggMuxerCreate: containerLib.func("void *mediaway_ogg_muxer_create(uint32_t serial)"),
+    oggMuxerPushPacket: containerLib.func("int mediaway_ogg_muxer_push_packet(void *muxer, MwPacketView *packet)"),
+    oggMuxerFlush: containerLib.func("int mediaway_ogg_muxer_flush(void *muxer)"),
+    oggMuxerPollBytes: containerLib.func("int mediaway_ogg_muxer_poll_bytes(void *muxer, _Out_ uint8_t **out_data, _Out_ size_t *out_len)"),
+    oggMuxerClose: containerLib.func("void mediaway_ogg_muxer_close(void *muxer)"),
+    oggDemuxerCreate: containerLib.func("void *mediaway_ogg_demuxer_create()"),
+    oggDemuxerPushBytes: containerLib.func("int mediaway_ogg_demuxer_push_bytes(void *demuxer, uint8_t *data, size_t len)"),
+    oggDemuxerStreamCount: containerLib.func("size_t mediaway_ogg_demuxer_stream_count(void *demuxer)"),
+    oggDemuxerStreamAt: containerLib.func("int mediaway_ogg_demuxer_stream_at(void *demuxer, size_t index, _Out_ MwStreamInfo *out_info)"),
+    oggDemuxerPollPacket: containerLib.func("int mediaway_ogg_demuxer_poll_packet(void *demuxer, _Out_ MwPacket *out_packet, _Out_ bool *out_has)"),
+    oggDemuxerClose: containerLib.func("void mediaway_ogg_demuxer_close(void *demuxer)"),
+    // ── ADTS (adr/container/0004) ─────────────────────────────────────────────
+    adtsMuxerCreate: containerLib.func("void *mediaway_adts_muxer_create(uint32_t sample_rate, uint8_t channels)"),
+    adtsMuxerPushPacket: containerLib.func("int mediaway_adts_muxer_push_packet(void *muxer, MwPacketView *packet)"),
+    adtsMuxerFlush: containerLib.func("int mediaway_adts_muxer_flush(void *muxer)"),
+    adtsMuxerPollBytes: containerLib.func("int mediaway_adts_muxer_poll_bytes(void *muxer, _Out_ uint8_t **out_data, _Out_ size_t *out_len)"),
+    adtsMuxerClose: containerLib.func("void mediaway_adts_muxer_close(void *muxer)"),
+    adtsDemuxerCreate: containerLib.func("void *mediaway_adts_demuxer_create()"),
+    adtsDemuxerPushBytes: containerLib.func("int mediaway_adts_demuxer_push_bytes(void *demuxer, uint8_t *data, size_t len)"),
+    adtsDemuxerStreamCount: containerLib.func("size_t mediaway_adts_demuxer_stream_count(void *demuxer)"),
+    adtsDemuxerStreamAt: containerLib.func("int mediaway_adts_demuxer_stream_at(void *demuxer, size_t index, _Out_ MwStreamInfo *out_info)"),
+    adtsDemuxerPollPacket: containerLib.func("int mediaway_adts_demuxer_poll_packet(void *demuxer, _Out_ MwPacket *out_packet, _Out_ bool *out_has)"),
+    adtsDemuxerClose: containerLib.func("void mediaway_adts_demuxer_close(void *demuxer)"),
+    // ── FLV (adr/container/0005) ──────────────────────────────────────────────
+    flvMuxerCreate: containerLib.func("void *mediaway_flv_muxer_create()"),
+    flvMuxerWriteHeader: containerLib.func("int mediaway_flv_muxer_write_header(void *muxer, bool has_audio, bool has_video, _Out_ uint8_t **out_data, _Out_ size_t *out_len)"),
+    flvMuxerAddVideoTrack: containerLib.func("int mediaway_flv_muxer_add_video_track(void *muxer, MwVideoTrackInfo *info)"),
+    flvMuxerAddAudioTrack: containerLib.func("int mediaway_flv_muxer_add_audio_track(void *muxer, MwAudioTrackInfo *info)"),
+    flvMuxerPushPacket: containerLib.func("int mediaway_flv_muxer_push_packet(void *muxer, MwPacketView *packet, _Out_ uint8_t **out_data, _Out_ size_t *out_len)"),
+    flvMuxerClose: containerLib.func("void mediaway_flv_muxer_close(void *muxer)"),
+    flvDemuxerCreate: containerLib.func("void *mediaway_flv_demuxer_create()"),
+    flvDemuxerPushBytes: containerLib.func("int mediaway_flv_demuxer_push_bytes(void *demuxer, uint8_t *data, size_t len)"),
+    flvDemuxerStreamCount: containerLib.func("size_t mediaway_flv_demuxer_stream_count(void *demuxer)"),
+    flvDemuxerStreamAt: containerLib.func("int mediaway_flv_demuxer_stream_at(void *demuxer, size_t index, _Out_ MwStreamInfo *out_info)"),
+    flvDemuxerPollPacket: containerLib.func("int mediaway_flv_demuxer_poll_packet(void *demuxer, _Out_ MwPacket *out_packet, _Out_ bool *out_has)"),
+    flvDemuxerClose: containerLib.func("void mediaway_flv_demuxer_close(void *demuxer)"),
+    // ── MPEG-TS (adr/container/0006) ──────────────────────────────────────────
+    tsMuxerCreate: containerLib.func("void *mediaway_ts_muxer_create(uint16_t program_number, uint16_t pmt_pid, MwTsElementaryStream *streams, size_t stream_count)"),
+    tsMuxerWritePatPmt: containerLib.func("int mediaway_ts_muxer_write_pat_pmt(void *muxer, _Out_ uint8_t **out_data, _Out_ size_t *out_len)"),
+    tsMuxerWriteAccessUnit: containerLib.func("int mediaway_ts_muxer_write_access_unit(void *muxer, uint16_t pid, uint8_t *data, size_t data_len, uint64_t pts_90k, bool has_dts, uint64_t dts_90k, bool random_access, _Out_ uint8_t **out_data, _Out_ size_t *out_len)"),
+    tsMuxerClose: containerLib.func("void mediaway_ts_muxer_close(void *muxer)"),
+    tsDemuxerCreate: containerLib.func("void *mediaway_ts_demuxer_create()"),
+    tsDemuxerPushBytes: containerLib.func("int mediaway_ts_demuxer_push_bytes(void *demuxer, uint8_t *data, size_t len)"),
+    tsDemuxerStreamCount: containerLib.func("size_t mediaway_ts_demuxer_stream_count(void *demuxer)"),
+    tsDemuxerStreamAt: containerLib.func("int mediaway_ts_demuxer_stream_at(void *demuxer, size_t index, _Out_ MwStreamInfo *out_info)"),
+    tsDemuxerPollPacket: containerLib.func("int mediaway_ts_demuxer_poll_packet(void *demuxer, _Out_ MwPacket *out_packet, _Out_ bool *out_has)"),
+    tsDemuxerFinish: containerLib.func("int mediaway_ts_demuxer_finish(void *demuxer, _Out_ MwPacket **out_packets, _Out_ size_t *out_count)"),
+    tsDemuxerFinishFree: containerLib.func("void mediaway_ts_demuxer_finish_free(MwPacket *packets, size_t count)"),
+    tsDemuxerClose: containerLib.func("void mediaway_ts_demuxer_close(void *demuxer)"),
+    // ── MP3 (adr/container/0007) ──────────────────────────────────────────────
+    mp3MuxerCreate: containerLib.func("void *mediaway_mp3_muxer_create(MwMp3FrameHeader *header)"),
+    mp3MuxerWriteFrame: containerLib.func("int mediaway_mp3_muxer_write_frame(void *muxer, uint8_t *frame_body, size_t frame_body_len, bool padding, _Out_ uint8_t **out_data, _Out_ size_t *out_len)"),
+    mp3MuxerClose: containerLib.func("void mediaway_mp3_muxer_close(void *muxer)"),
+    mp3DemuxerCreate: containerLib.func("void *mediaway_mp3_demuxer_create()"),
+    mp3DemuxerPushBytes: containerLib.func("int mediaway_mp3_demuxer_push_bytes(void *demuxer, uint8_t *data, size_t len)"),
+    mp3DemuxerStreamCount: containerLib.func("size_t mediaway_mp3_demuxer_stream_count(void *demuxer)"),
+    mp3DemuxerStreamAt: containerLib.func("int mediaway_mp3_demuxer_stream_at(void *demuxer, size_t index, _Out_ MwStreamInfo *out_info)"),
+    mp3DemuxerPollPacket: containerLib.func("int mediaway_mp3_demuxer_poll_packet(void *demuxer, _Out_ MwPacket *out_packet, _Out_ bool *out_has)"),
+    mp3DemuxerClose: containerLib.func("void mediaway_mp3_demuxer_close(void *demuxer)"),
+    // ── WAV (adr/container/0008) ──────────────────────────────────────────────
+    wavMuxerCreate: containerLib.func("void *mediaway_wav_muxer_create(uint32_t sample_rate, uint16_t channels, uint16_t bits_per_sample)"),
+    wavMuxerCreateWithFormat: containerLib.func("void *mediaway_wav_muxer_create_with_format(MwWaveFormat *format)"),
+    wavMuxerPushPacket: containerLib.func("int mediaway_wav_muxer_push_packet(void *muxer, MwPacketView *packet)"),
+    wavMuxerFinish: containerLib.func("int mediaway_wav_muxer_finish(void *muxer, _Out_ uint8_t **out_data, _Out_ size_t *out_len)"),
+    wavMuxerClose: containerLib.func("void mediaway_wav_muxer_close(void *muxer)"),
+    wavParse: containerLib.func("int mediaway_wav_parse(uint8_t *data, size_t data_len, _Out_ MwStreamInfo *out_info, _Out_ MwPacket *out_packet)"),
 };
 // ── Pipeline functions ─────────────────────────────────────────────────────────
 export const pipeline = {
@@ -259,6 +424,26 @@ export const pipeline = {
     audioSessionClose: pipelineLib.func("void mediaway_audio_encode_session_close(void *session)"),
     pipelinePacketFree: pipelineLib.func("void mediaway_pipeline_ffi_packet_free(MwAudioPacket *packet)"),
     pipelineStreamInfoFree: pipelineLib.func("void mediaway_pipeline_ffi_stream_info_free(MwAudioStreamInfo *info)"),
+    // ── Decode (adr/0004-auto-decode-c-abi.md, adr/pipeline/0006) ────────────
+    decodeConfigNew: pipelineLib.func("MwAutoVideoDecodeConfig mediaway_auto_video_decode_config_new(int codec, uint32_t width, uint32_t height, MwRational time_base, uint8_t *extra_data, size_t extra_data_len)"),
+    decodeSessionOpen: pipelineLib.func("int mediaway_decode_session_open(MwAutoVideoDecodeConfig *config, _Out_ void **out_session)"),
+    decodeSessionPushPacket: pipelineLib.func("int mediaway_decode_session_push_packet(void *session, MwDecodePacketView *packet)"),
+    decodeSessionPollFrame: pipelineLib.func("int mediaway_decode_session_poll_frame(void *session, _Out_ MwDecodedVideoFrame *out_frame, _Out_ bool *out_has)"),
+    decodeSessionFlush: pipelineLib.func("int mediaway_decode_session_flush(void *session)"),
+    decodeSessionClose: pipelineLib.func("void mediaway_decode_session_close(void *session)"),
+    decodedVideoFrameFree: pipelineLib.func("void mediaway_decoded_video_frame_free(MwDecodedVideoFrame *frame)"),
+    audioDecodeConfigOpus: pipelineLib.func("MwAudioDecodeConfig mediaway_audio_decode_config_opus(uint32_t sample_rate, uint16_t channels, MwRational time_base)"),
+    audioDecodeSessionOpen: pipelineLib.func("int mediaway_audio_decode_session_open(MwAudioDecodeConfig *config, _Out_ void **out_session)"),
+    audioDecodeSessionPushPacket: pipelineLib.func("int mediaway_audio_decode_session_push_packet(void *session, MwDecodePacketView *packet)"),
+    audioDecodeSessionPollFrame: pipelineLib.func("int mediaway_audio_decode_session_poll_frame(void *session, _Out_ MwDecodedAudioFrame *out_frame, _Out_ bool *out_has)"),
+    audioDecodeSessionFlush: pipelineLib.func("int mediaway_audio_decode_session_flush(void *session)"),
+    audioDecodeSessionClose: pipelineLib.func("void mediaway_audio_decode_session_close(void *session)"),
+    decodedAudioFrameFree: pipelineLib.func("void mediaway_decoded_audio_frame_free(MwDecodedAudioFrame *frame)"),
+    // ── Capture-to-encode bridge (adr/pipeline/0005-capture-encode-bridge-c-abi.md) ──
+    // Pushes one polled frame from a device.h capture handle straight into a
+    // session — no intermediate MwCameraFrame/MwDesktopFrame, no extra copy.
+    sessionWriteFrameFromCameraCapture: pipelineLib.func("int mediaway_encode_session_write_frame_from_camera_capture(void *session, void *capture, _Out_ bool *out_wrote_frame)"),
+    sessionWriteFrameFromDesktopCapture: pipelineLib.func("int mediaway_encode_session_write_frame_from_desktop_capture(void *session, void *capture, _Out_ bool *out_wrote_frame)"),
 };
 // ── Device functions ───────────────────────────────────────────────────────────
 export const device = {
@@ -284,6 +469,12 @@ export const device = {
     audioPollFrame: deviceLib.func("int mediaway_audio_capture_poll_frame(void *capture, _Out_ MwAudioFrame *out_frame, _Out_ bool *out_has)"),
     audioClose: deviceLib.func("int mediaway_audio_capture_close(void *capture)"),
     audioFrameFree: deviceLib.func("void mediaway_audio_frame_free(MwAudioFrame *frame)"),
+    // ── GPU device factory (mediaway-device ADR-0007) ─────────────────────────
+    gpuAdapterList: deviceLib.func("int mediaway_gpu_adapter_list(_Out_ MwGpuAdapterInfo **out_adapters, _Out_ size_t *out_count)"),
+    gpuAdapterListFree: deviceLib.func("void mediaway_gpu_adapter_list_free(MwGpuAdapterInfo *adapters, size_t count)"),
+    gpuDeviceCreate: deviceLib.func("int mediaway_gpu_device_create(MwGpuDeviceOptions *options, _Out_ void **out_device)"),
+    gpuDeviceHandle: deviceLib.func("int mediaway_gpu_device_handle(void *device, _Out_ MwGpuDeviceHandle *out_handle)"),
+    gpuDeviceClose: deviceLib.func("void mediaway_gpu_device_close(void *device)"),
 };
 // ── Copy helpers ───────────────────────────────────────────────────────────────
 /** Copy `len` bytes out of a koffi pointer/opaque handle. */
@@ -292,3 +483,14 @@ export function copyBytes(ptr, len) {
         return Buffer.alloc(0);
     return Buffer.from(koffi.decode(ptr, "uint8_t", len));
 }
+/**
+ * Decode `count` consecutive struct instances out of a pointer to an owned
+ * native array (e.g. `mediaway_ts_demuxer_finish`'s `out_packets`) — the only
+ * multi-element owned-array output shape in this crate. Free the underlying
+ * array with the matching `_finish_free` after copying out what's needed.
+ */
+export function decodeArray(ptr, type, count) {
+    if (!ptr || count <= 0)
+        return [];
+    return koffi.decode(ptr, type, count);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mediaway/ffi",
-  "version": "0.1.4",
-  "description": "Mediaway native C ABI bindings for Node.js — the shared DLL behind the @mediaway packages",
+  "version": "0.1.6",
+  "description": "Rust-based, lightweight, fast — Mediaway native C ABI bindings for Node.js — the shared DLL behind the @mediaway packages",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",