pipewire 1.4.0 → 2.1.0

package/src/bindings/node.ts

@@ -0,0 +1,92 @@
+import koffi from "koffi";
+import { spa_hook } from "./hook.js";
+import { spa_pod } from "./pod.js";
+import { spa_dict } from "./dict.js";
+import { spa_param_info } from "./param.js";
+
+const pipewire = koffi.load("libpipewire-0.3.so.0");
+
+export const PW_VERSION_NODE = 3;
+export const PW_VERSION_NODE_EVENTS = 0;
+
+export const PW_NODE_CHANGE_MASK = {
+    INPUT_PORTS: 1 << 0,
+    OUTPUT_PORTS: 1 << 1,
+    STATE: 1 << 2,
+    PROPS: 1 << 3,
+    PARAMS: 1 << 4
+};
+
+export enum pw_node_state {
+    PW_NODE_STATE_ERROR = -1,
+    PW_NODE_STATE_CREATING = 0,
+    PW_NODE_STATE_SUSPENDED = 1,
+    PW_NODE_STATE_IDLE = 2,
+    PW_NODE_STATE_RUNNING = 3
+}
+
+export const pw_node = koffi.opaque("pw_node");
+
+export const pw_node_state_enum = koffi.enumeration("pw_node_state", {
+    PW_NODE_STATE_ERROR: -1,
+    PW_NODE_STATE_CREATING: 0,
+    PW_NODE_STATE_SUSPENDED: 1,
+    PW_NODE_STATE_IDLE: 2,
+    PW_NODE_STATE_RUNNING: 3
+});
+
+export const pw_node_info = koffi.struct("pw_node_info", {
+    id: "uint32_t",
+    max_input_ports: "uint32_t",
+    max_output_ports: "uint32_t",
+    change_mask: "uint64_t",
+    n_input_ports: "uint32_t",
+    n_output_ports: "uint32_t",
+    state: pw_node_state_enum,
+    error: "const char*",
+    props: koffi.pointer(spa_dict),
+    params: koffi.pointer(spa_param_info),
+    n_params: "uint32_t"
+});
+
+export const pw_node_events_info = koffi.proto("void", [
+    "void*", // data
+    koffi.pointer(pw_node_info) // info
+]);
+
+export const pw_node_events_param = koffi.proto("void", [
+    "void*", // data
+    "int", // seq
+    "uint32_t", // id
+    "uint32_t", // index
+    "uint32_t", // next
+    koffi.pointer(spa_pod) // param
+]);
+
+export const pw_node_events = koffi.struct("pw_node_events", {
+    version: "uint32_t",
+    info: koffi.pointer(pw_node_events_info),
+    param: koffi.pointer(pw_node_events_param)
+});
+
+export const pw_node_add_listener = pipewire.func("pw_node_add_listener", "int", [
+    koffi.pointer(pw_node), // object
+    koffi.pointer(spa_hook), // listener
+    koffi.pointer(pw_node_events), // events
+    "void*" // data
+]);
+
+export const pw_node_enum_params = pipewire.func("pw_node_enum_params", "int", [
+    koffi.pointer(pw_node), // object
+    "int", // seq
+    "uint32_t", // id
+    "uint32_t", // start
+    "uint32_t", // num
+    koffi.pointer(spa_pod) // filter
+]);
+
+export const pw_node_subscribe_params = pipewire.func("pw_node_subscribe_params", "int", [
+    koffi.pointer(pw_node), // object
+    "uint32_t*", // ids
+    "uint32_t" // n_ids
+]);

package/src/bindings/param.ts

@@ -0,0 +1,33 @@
+import koffi from "koffi";
+
+export const spa_param_info = koffi.struct("spa_param_info", {
+    id: "uint32_t",
+    flags: "uint32_t",
+    user: "uint32_t",
+    seq: "int32_t",
+    padding: koffi.array("uint32_t", 4)
+});
+
+export enum spa_param_type {
+    SPA_PARAM_Invalid,
+    SPA_PARAM_PropInfo,
+    SPA_PARAM_Props,
+    SPA_PARAM_EnumFormat,
+    SPA_PARAM_Format,
+    SPA_PARAM_Buffers,
+    SPA_PARAM_Meta,
+    SPA_PARAM_IO,
+    SPA_PARAM_EnumProfile,
+    SPA_PARAM_Profile,
+    SPA_PARAM_EnumPortConfig,
+    SPA_PARAM_PortConfig,
+    SPA_PARAM_EnumRoute,
+    SPA_PARAM_Route,
+    SPA_PARAM_Control,
+    SPA_PARAM_Latency,
+    SPA_PARAM_ProcessLatency,
+    SPA_PARAM_Tag,
+    SPA_PARAM_PeerEnumFormat,
+    SPA_PARAM_Capability,
+    SPA_PARAM_PeerCapability
+}

package/src/bindings/pipewire.ts

@@ -0,0 +1,6 @@
+import koffi from "koffi";
+
+const pipewire = koffi.load("libpipewire-0.3.so.0");
+
+export const pw_init = pipewire.func("pw_init", "void", ["int**", "char***"]);
+export const pw_deinit = pipewire.func("pw_deinit", "void", []);

package/src/{registry.ts → bindings/registry.ts}

@@ -4,6 +4,8 @@ import { spa_hook } from "./hook.js";
 
 const pipewire = koffi.load("libpipewire-0.3.so.0");
 
+export const PW_VERSION_REGISTRY_EVENTS = 0;
+
 export const pw_registry_add_listener = pipewire.func("pw_registry_add_listener", "int", [
     koffi.pointer(pw_registry), // registry
     koffi.pointer(spa_hook), // listener

package/src/index.ts

@@ -1,16 +1,6 @@
-import * as context from "./context.js";
-import * as core from "./core.js";
-import * as dict from "./dict.js";
-import * as hook from "./hook.js";
-import * as loop from "./loop.js";
-import * as main_loop from "./main-loop.js";
-import * as node from "./node.js";
-import * as param from "./param.js";
-import * as pipewire from "./pipewire.js";
-import * as pod from "./pod.js";
-import * as props from "./props.js";
-import * as proxy from "./proxy.js";
-import * as registry from "./registry.js";
-import * as thread_loop from "./thread-loop.js";
+import Pipewire from "./pipewire.js";
+import PipewireObject from "./object.js";
+import PipewireNode from "./node.js";
+import bindings from "./bindings/index.js";
 
-export { context, core, dict, hook, loop, main_loop, node, param, pod, props, pipewire, proxy, registry, thread_loop };
+export { Pipewire, PipewireObject, PipewireNode, bindings };

package/src/node.ts

@@ -1,81 +1,181 @@
 import koffi from "koffi";
-import { spa_hook } from "./hook.js";
-import { spa_pod } from "./pod.js";
-import { spa_dict } from "./dict.js";
-import { spa_param_info } from "./param.js";
-
-const pipewire = koffi.load("libpipewire-0.3.so.0");
-
-export const pw_node = koffi.opaque("pw_node");
-
-export const pw_node_state = koffi.enumeration("pw_node_state", {
-    PW_NODE_STATE_ERROR: -1,
-    PW_NODE_STATE_CREATING: 0,
-    PW_NODE_STATE_SUSPENDED: 1,
-    PW_NODE_STATE_IDLE: 2,
-    PW_NODE_STATE_RUNNING: 3
-});
-
-export const PW_NODE_CHANGE_MASK = {
-    INPUT_PORTS: 1 << 0,
-    OUTPUT_PORTS: 1 << 1,
-    STATE: 1 << 2,
-    PROPS: 1 << 3,
-    PARAMS: 1 << 4
+import type Pipewire from "./pipewire.js";
+import type { pw_node_state } from "./bindings/node.js";
+import type { spa_param_type } from "./bindings/param.js";
+import PipewireObject from "./object.js";
+import pw from "./bindings/index.js";
+
+export default class PipewireNode extends PipewireObject {
+    static readonly pw_node_state = pw.node.pw_node_state_enum;
+    static readonly spa_param_type = pw.param.spa_param_type;
+
+    nodeName: string;
+    factoryId: number;
+
+    nodeProxy: unknown | null = null;
+    nodeListener: Buffer | null = null;
+    nodeEvents: Buffer | null = null;
+    nodeEventInfoRegister: bigint | null = null;
+    nodeEventParamRegister: bigint | null = null;
+
+    constructor(
+        pipewire: Pipewire,
+        id: number,
+        permissions: number,
+        type: string,
+        version: number,
+        props: { [key: string]: string }
+    ) {
+        super(pipewire, id, permissions, type, version, props);
+        this.nodeName = props["node.name"]!;
+        this.factoryId = Number(props["factory.id"]);
+    }
+
+    attachListener(): void {
+        if (this.removed) return;
+        if (this.nodeProxy) throw new Error(`Listener already attached to node ${this.id}`);
+
+        this.nodeProxy = pw.registry.pw_registry_bind(
+            this.pipewire.registry,
+            this.id,
+            this.type,
+            pw.node.PW_VERSION_NODE,
+            0
+        );
+        this.nodeListener = Buffer.alloc(koffi.sizeof(pw.hook.spa_hook));
+        this.nodeEvents = Buffer.alloc(koffi.sizeof(pw.node.pw_node_events));
+        this.nodeEventInfoRegister = koffi.register(
+            this.nodeEventInfo.bind(this),
+            koffi.pointer(pw.node.pw_node_events_info)
+        );
+        this.nodeEventParamRegister = koffi.register(
+            this.nodeEventParam.bind(this),
+            koffi.pointer(pw.node.pw_node_events_param)
+        );
+        koffi.encode(this.nodeEvents, pw.node.pw_node_events, {
+            version: pw.node.PW_VERSION_NODE_EVENTS,
+            info: this.nodeEventInfoRegister,
+            param: this.nodeEventParamRegister
+        });
+        pw.node.pw_node_add_listener(this.nodeProxy, this.nodeListener, this.nodeEvents, null);
+    }
+
+    detachListener(): void {
+        if (!this.nodeProxy) throw new Error(`Listener not attached to node ${this.id}`);
+
+        if (!this.removed) pw.proxy.pw_proxy_destroy(this.nodeProxy);
+        koffi.unregister(this.nodeEventParamRegister!);
+        koffi.unregister(this.nodeEventInfoRegister!);
+        this.nodeEventInfoRegister = null;
+        this.nodeEventParamRegister = null;
+        this.nodeEvents = null;
+        this.nodeListener = null;
+        this.nodeProxy = null;
+    }
+
+    subscribeParams(params: spa_param_type[]) {
+        if (this.removed) return;
+        if (!this.nodeProxy) throw new Error(`Listener not attached to node ${this.id}`);
+        pw.node.pw_node_subscribe_params(this.nodeProxy, params, params.length);
+    }
+
+    nodeEventInfo(_data: unknown, info: unknown): void {
+        this.emit("rawNodeInfo", { info });
+
+        const nodeInfo = koffi.decode(info, pw.node.pw_node_info);
+
+        const changesMasks = Object.keys(pw.node.PW_NODE_CHANGE_MASK) as (keyof typeof pw.node.PW_NODE_CHANGE_MASK)[];
+        const changes = changesMasks.filter((key) => nodeInfo.change_mask & pw.node.PW_NODE_CHANGE_MASK[key]);
+
+        const props = koffi.decode(nodeInfo.props, pw.dict.spa_dict);
+        if (changes.includes("PROPS") !== !!props.items) throw new Error(`Node ${this.id} props change mismatch`);
+
+        const propsObj: { [key: string]: string } | null = changes.includes("PROPS") ? {} : null;
+        if (propsObj) {
+            const propsArray = koffi.decode(props.items, pw.dict.spa_dict_item, props.n_items);
+            for (const item of propsArray) propsObj[item.key] = item.value;
+        }
+
+        const paramsObj: spa_param_type[] = [];
+        if (nodeInfo.params) {
+            const params = koffi.decode(nodeInfo.params, pw.param.spa_param_info, nodeInfo.n_params);
+            for (const param of params) paramsObj.push(param.id as spa_param_type);
+        }
+
+        const nodeInfoObj: NodeInfo = {
+            id: nodeInfo.id,
+            maxInputPorts: nodeInfo.max_input_ports,
+            maxOutputPorts: nodeInfo.max_output_ports,
+            changes: changes,
+            inputPortsCount: nodeInfo.n_input_ports,
+            outputPortsCount: nodeInfo.n_output_ports,
+            state: nodeInfo.state as pw_node_state,
+            error: nodeInfo.error ? koffi.decode(nodeInfo.error, "string") : null,
+            props: propsObj,
+            params: paramsObj
+        };
+
+        this.emit("nodeInfo", nodeInfoObj);
+    }
+
+    nodeEventParam(_data: unknown, seq: number, id: number, index: number, next: number, param: unknown): void {
+        this.emit("rawNodeParam", { seq, id, index, next, param });
+    }
+
+    on(event: "nodeInfo", listener: (info: NodeInfo) => void): this;
+    on(event: "rawNodeInfo", listener: (data: RawNodeInfo) => void): this;
+    on(event: "rawNodeParam", listener: (data: RawNodeParam) => void): this;
+    on(event: string | symbol, listener: (...args: any[]) => void): this;
+    on(event: string | symbol, listener: (...args: any[]) => void): this {
+        return super.on(event, listener);
+    }
+
+    once(event: "nodeInfo", listener: (info: NodeInfo) => void): this;
+    once(event: "rawNodeInfo", listener: (data: RawNodeInfo) => void): this;
+    once(event: "rawNodeParam", listener: (data: RawNodeParam) => void): this;
+    once(event: string | symbol, listener: (...args: any[]) => void): this;
+    once(event: string | symbol, listener: (...args: any[]) => void): this {
+        return super.once(event, listener);
+    }
+
+    off(event: "nodeInfo", listener: (info: NodeInfo) => void): this;
+    off(event: "rawNodeInfo", listener: (data: RawNodeInfo) => void): this;
+    off(event: "rawNodeParam", listener: (data: RawNodeParam) => void): this;
+    off(event: string | symbol, listener: (...args: any[]) => void): this;
+    off(event: string | symbol, listener: (...args: any[]) => void): this {
+        return super.off(event, listener);
+    }
+
+    emit(event: "nodeInfo", info: NodeInfo): boolean;
+    emit(event: "rawNodeInfo", data: RawNodeInfo): boolean;
+    emit(event: "rawNodeParam", data: RawNodeParam): boolean;
+    emit(event: string | symbol, ...args: any[]): boolean;
+    emit(event: string | symbol, ...args: any[]): boolean {
+        return super.emit(event, ...args);
+    }
+}
+
+export type RawNodeInfo = {
+    info: unknown;
 };
 
-export const pw_node_info = koffi.struct("pw_node_info", {
-    id: "uint32_t",
-    max_input_ports: "uint32_t",
-    max_output_ports: "uint32_t",
-    change_mask: "uint64_t",
-    n_input_ports: "uint32_t",
-    n_output_ports: "uint32_t",
-    state: pw_node_state,
-    error: "const char*",
-    props: koffi.pointer(spa_dict),
-    params: koffi.pointer(spa_param_info),
-    n_params: "uint32_t"
-});
-
-export const pw_node_events_info = koffi.proto("void", [
-    "void*", // data
-    koffi.pointer(pw_node_info) // info
-]);
-
-export const pw_node_events_param = koffi.proto("void", [
-    "void*", // data
-    "int", // seq
-    "uint32_t", // id
-    "uint32_t", // index
-    "uint32_t", // next
-    koffi.pointer(spa_pod) // param
-]);
-
-export const pw_node_events = koffi.struct("pw_node_events", {
-    version: "uint32_t",
-    info: koffi.pointer(pw_node_events_info),
-    param: koffi.pointer(pw_node_events_param)
-});
-
-export const pw_node_add_listener = pipewire.func("pw_node_add_listener", "int", [
-    koffi.pointer(pw_node), // object
-    koffi.pointer(spa_hook), // listener
-    koffi.pointer(pw_node_events), // events
-    "void*" // data
-]);
-
-export const pw_node_enum_params = pipewire.func("pw_node_enum_params", "int", [
-    koffi.pointer(pw_node), // object
-    "int", // seq
-    "uint32_t", // id
-    "uint32_t", // start
-    "uint32_t", // num
-    koffi.pointer(spa_pod) // filter
-]);
-
-export const pw_node_subscribe_params = pipewire.func("pw_node_subscribe_params", "int", [
-    koffi.pointer(pw_node), // object
-    "uint32_t*", // ids
-    "uint32_t" // n_ids
-]);
+export type NodeInfo = {
+    id: number;
+    maxInputPorts: number;
+    maxOutputPorts: number;
+    changes: (keyof typeof pw.node.PW_NODE_CHANGE_MASK)[];
+    inputPortsCount: number;
+    outputPortsCount: number;
+    state: pw_node_state;
+    error: string | null;
+    props: { [key: string]: string } | null;
+    params: spa_param_type[];
+};
+
+export type RawNodeParam = {
+    seq: number;
+    id: number;
+    index: number;
+    next: number;
+    param: unknown;
+};

package/src/object.ts

@@ -0,0 +1,36 @@
+import EventEmitter from "node:events";
+import type Pipewire from "./pipewire.js";
+
+export default class PipewireObject extends EventEmitter {
+    pipewire: Pipewire;
+    removed: boolean = false;
+
+    id: number;
+    permissions: number;
+    type: string;
+    version: number;
+    props: { [key: string]: string };
+
+    objectSerial: number;
+
+    constructor(
+        pipewire: Pipewire,
+        id: number,
+        permissions: number,
+        type: string,
+        version: number,
+        props: { [key: string]: string }
+    ) {
+        super();
+
+        this.pipewire = pipewire;
+
+        this.id = id;
+        this.permissions = permissions;
+        this.type = type;
+        this.version = version;
+        this.props = props;
+
+        this.objectSerial = Number(props["object.serial"]);
+    }
+}

package/src/pipewire.ts

@@ -1,6 +1,157 @@
+import EventEmitter from "node:events";
 import koffi from "koffi";
+import pw from "./bindings/index.js";
+import PipewireObject from "./object.js";
+import PipewireNode from "./node.js";
 
-const pipewire = koffi.load("libpipewire-0.3.so.0");
+export default class Pipewire extends EventEmitter {
+    mainLoop: unknown;
+    loop: unknown;
+    context: unknown;
+    core: unknown;
+    registry: unknown;
 
-export const pw_init = pipewire.func("pw_init", "void", ["int**", "char***"]);
-export const pw_deinit = pipewire.func("pw_deinit", "void", []);
+    registry_listener: Buffer;
+    registryEvents: Buffer;
+    registryEventGlobalRegister: bigint;
+    registryEventGlobalRemoveRegister: bigint;
+
+    loopInterval: NodeJS.Timeout | null = null;
+
+    objects: { [id: number]: PipewireObject } = {};
+
+    constructor() {
+        super();
+
+        pw.pipewire.pw_init(0, null);
+
+        this.mainLoop = pw.main_loop.pw_main_loop_new(null);
+        this.loop = pw.main_loop.pw_main_loop_get_loop(this.mainLoop);
+        this.context = pw.context.pw_context_new(this.loop, null, 0);
+        this.core = pw.core.pw_context_connect(this.context, null, 0);
+        this.registry = pw.core.pw_core_get_registry(this.core, pw.core.PW_VERSION_REGISTRY, 0);
+
+        this.registry_listener = Buffer.alloc(koffi.sizeof(pw.hook.spa_hook));
+        this.registryEvents = Buffer.alloc(koffi.sizeof(pw.core.pw_registry_events));
+        this.registryEventGlobalRegister = koffi.register(
+            this.registryEventGlobal.bind(this),
+            koffi.pointer(pw.core.pw_registry_events_global)
+        );
+        this.registryEventGlobalRemoveRegister = koffi.register(
+            this.registryEventGlobalRemove.bind(this),
+            koffi.pointer(pw.core.pw_registry_events_global_remove)
+        );
+        koffi.encode(this.registryEvents, pw.core.pw_registry_events, {
+            version: pw.registry.PW_VERSION_REGISTRY_EVENTS,
+            global: this.registryEventGlobalRegister,
+            global_remove: this.registryEventGlobalRemoveRegister
+        });
+        pw.registry.pw_registry_add_listener(this.registry, this.registry_listener, this.registryEvents, null);
+    }
+
+    registryEventGlobal(
+        _data: unknown,
+        id: number,
+        permissions: number,
+        type: string,
+        version: number,
+        props: unknown
+    ): void {
+        this.emit("rawObjectAdded", { id, permissions, type, version, props });
+
+        if (this.objects[id]) throw new Error(`Object with id ${id} already exists`);
+
+        const propsDict = koffi.decode(props, pw.dict.spa_dict);
+        const propsArray = koffi.decode(propsDict.items, pw.dict.spa_dict_item, propsDict.n_items);
+
+        const propsObj: { [key: string]: string } = {};
+        for (const item of propsArray) propsObj[item.key] = item.value;
+
+        if (type === "PipeWire:Interface:Node")
+            this.objects[id] = new PipewireNode(this, id, permissions, type, version, propsObj);
+        else this.objects[id] = new PipewireObject(this, id, permissions, type, version, propsObj);
+        this.emit("objectAdded", this.objects[id]);
+    }
+
+    registryEventGlobalRemove(_data: unknown, id: number): void {
+        this.emit("rawObjectRemoved", { id });
+
+        if (!this.objects[id]) throw new Error(`Object with id ${id} does not exist`);
+        this.objects[id].removed = true;
+
+        if (this.objects[id] instanceof PipewireNode && this.objects[id].nodeProxy) this.objects[id].detachListener();
+
+        this.emit("objectRemoved", this.objects[id]);
+        delete this.objects[id];
+    }
+
+    startLoop(pollInterval: number = 10, pollTimeout: number = 1): void {
+        if (this.loopInterval) throw new Error("Loop already started");
+        pw.loop.pw_loop_enter(this.loop);
+        this.loopInterval = setInterval(() => pw.loop.pw_loop_iterate(this.loop, pollTimeout), pollInterval);
+    }
+
+    stopLoop(): void {
+        if (!this.loopInterval) throw new Error("Loop not started");
+        clearInterval(this.loopInterval);
+        this.loopInterval = null;
+        pw.loop.pw_loop_leave(this.loop);
+    }
+
+    on(event: "objectAdded", listener: (object: PipewireObject) => void): this;
+    on(event: "objectRemoved", listener: (object: PipewireObject) => void): this;
+    on(event: "rawObjectAdded", listener: (data: RawObjectAdded) => void): this;
+    on(event: "rawObjectRemoved", listener: (data: RawObjectRemoved) => void): this;
+    on(event: string | symbol, listener: (...args: any[]) => void): this;
+    on(event: string | symbol, listener: (...args: any[]) => void): this {
+        return super.on(event, listener);
+    }
+
+    once(event: "objectAdded", listener: (object: PipewireObject) => void): this;
+    once(event: "objectRemoved", listener: (object: PipewireObject) => void): this;
+    once(event: "rawObjectAdded", listener: (data: RawObjectAdded) => void): this;
+    once(event: "rawObjectRemoved", listener: (data: RawObjectRemoved) => void): this;
+    once(event: string | symbol, listener: (...args: any[]) => void): this;
+    once(event: string | symbol, listener: (...args: any[]) => void): this {
+        return super.once(event, listener);
+    }
+
+    off(event: "objectAdded", listener: (object: PipewireObject) => void): this;
+    off(event: "objectRemoved", listener: (object: PipewireObject) => void): this;
+    off(event: "rawObjectAdded", listener: (data: RawObjectAdded) => void): this;
+    off(event: "rawObjectRemoved", listener: (data: RawObjectRemoved) => void): this;
+    off(event: string | symbol, listener: (...args: any[]) => void): this;
+    off(event: string | symbol, listener: (...args: any[]) => void): this {
+        return super.off(event, listener);
+    }
+
+    emit(event: "objectAdded", object: PipewireObject): boolean;
+    emit(event: "objectRemoved", object: PipewireObject): boolean;
+    emit(event: "rawObjectAdded", data: RawObjectAdded): boolean;
+    emit(event: "rawObjectRemoved", data: RawObjectRemoved): boolean;
+    emit(event: string | symbol, ...args: any[]): boolean;
+    emit(event: string | symbol, ...args: any[]): boolean {
+        return super.emit(event, ...args);
+    }
+
+    deinit(): void {
+        pw.proxy.pw_proxy_destroy(this.registry);
+        koffi.unregister(this.registryEventGlobalRegister);
+        koffi.unregister(this.registryEventGlobalRemoveRegister);
+        pw.core.pw_core_disconnect(this.core);
+        pw.context.pw_context_destroy(this.context);
+        pw.main_loop.pw_main_loop_destroy(this.mainLoop);
+    }
+}
+
+export type RawObjectAdded = {
+    id: number;
+    permissions: number;
+    type: string;
+    version: number;
+    props: unknown;
+};
+
+export type RawObjectRemoved = {
+    id: number;
+};

package/src/param.ts

@@ -1,33 +0,0 @@
-import koffi from "koffi";
-
-export const spa_param_info = koffi.struct("spa_param_info", {
-    id: "uint32_t",
-    flags: "uint32_t",
-    user: "uint32_t",
-    seq: "int32_t",
-    padding: koffi.array("uint32_t", 4)
-});
-
-export const spa_param_type = {
-    SPA_PARAM_Invalid: 0,
-    SPA_PARAM_PropInfo: 1,
-    SPA_PARAM_Props: 2,
-    SPA_PARAM_EnumFormat: 3,
-    SPA_PARAM_Format: 4,
-    SPA_PARAM_Buffers: 5,
-    SPA_PARAM_Meta: 6,
-    SPA_PARAM_IO: 7,
-    SPA_PARAM_EnumProfile: 8,
-    SPA_PARAM_Profile: 9,
-    SPA_PARAM_EnumPortConfig: 10,
-    SPA_PARAM_PortConfig: 11,
-    SPA_PARAM_EnumRoute: 12,
-    SPA_PARAM_Route: 13,
-    SPA_PARAM_Control: 14,
-    SPA_PARAM_Latency: 15,
-    SPA_PARAM_ProcessLatency: 16,
-    SPA_PARAM_Tag: 17,
-    SPA_PARAM_PeerEnumFormat: 18,
-    SPA_PARAM_Capability: 19,
-    SPA_PARAM_PeerCapability: 20
-};