@gtkx/ffi 0.9.4 → 0.10.0

package/dist/generated/gstbase/bit-writer.js

@@ -0,0 +1,381 @@
+import { alloc, read, write } from "@gtkx/native";
+import { call } from "../../batch.js";
+import { getNativeObject } from "../../native/object.js";
+import { NativeObject } from "../../native/base.js";
+import * as Gst from "../gst/index.js";
+/**
+ * #GstBitWriter provides a bit writer that can write any number of
+ * bits into a memory buffer. It provides functions for writing any
+ * number of bits into 8, 16, 32 and 64 bit variables.
+ */
+export class BitWriter extends NativeObject {
+    static objectType = "struct";
+    constructor(init = {}) {
+        super();
+        this.id = this.createPtr(init);
+    }
+    createPtr(init) {
+        const ptr = alloc(24);
+        if (init.data !== undefined)
+            write(ptr, { type: "int", size: 8, unsigned: true }, 0, init.data);
+        if (init.bitSize !== undefined)
+            write(ptr, { type: "int", size: 32, unsigned: true }, 4, init.bitSize);
+        return ptr;
+    }
+    static fromPtr(ptr) {
+        const instance = Object.create(BitWriter.prototype);
+        instance.id = ptr;
+        return instance;
+    }
+    /**
+     * Write trailing bit to align last byte of `data`. `trailing_bit` can
+     * only be 1 or 0.
+     * @param trailingBit - trailing bits of last byte, 0 or 1
+     */
+    alignBytes(trailingBit) {
+        return call("libgstbase-1.0.so.0", "gst_bit_writer_align_bytes", [
+            {
+                type: {
+                    type: "boxed",
+                    borrowed: true,
+                    innerType: "BitWriter",
+                    lib: "libgstbase-1.0.so.0",
+                },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 8, unsigned: true },
+                value: trailingBit,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Frees `bitwriter` and the allocated data inside.
+     */
+    free() {
+        call("libgstbase-1.0.so.0", "gst_bit_writer_free", [
+            {
+                type: {
+                    type: "boxed",
+                    borrowed: true,
+                    innerType: "BitWriter",
+                    lib: "libgstbase-1.0.so.0",
+                },
+                value: this.id,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Frees `bitwriter` without destroying the internal data, which is
+     * returned as #GstBuffer.
+     *
+     * Free-function: gst_buffer_unref
+     */
+    freeAndGetBuffer() {
+        const ptr = call("libgstbase-1.0.so.0", "gst_bit_writer_free_and_get_buffer", [
+            {
+                type: {
+                    type: "boxed",
+                    borrowed: true,
+                    innerType: "BitWriter",
+                    lib: "libgstbase-1.0.so.0",
+                },
+                value: this.id,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GstBuffer",
+            lib: "libgstreamer-1.0.so.0",
+            getTypeFn: "gst_buffer_get_type",
+        });
+        return getNativeObject(ptr, Gst.Buffer);
+    }
+    /**
+     * Frees `bitwriter` without destroying the internal data, which is
+     * returned.
+     *
+     * Free-function: g_free
+     */
+    freeAndGetData() {
+        return call("libgstbase-1.0.so.0", "gst_bit_writer_free_and_get_data", [
+            {
+                type: {
+                    type: "boxed",
+                    borrowed: true,
+                    innerType: "BitWriter",
+                    lib: "libgstbase-1.0.so.0",
+                },
+                value: this.id,
+            },
+        ], { type: "array", itemType: { type: "int", size: 8, unsigned: true } });
+    }
+    /**
+     * Get written data pointer
+     */
+    getData() {
+        return call("libgstbase-1.0.so.0", "gst_bit_writer_get_data", [
+            {
+                type: {
+                    type: "boxed",
+                    borrowed: true,
+                    innerType: "BitWriter",
+                    lib: "libgstbase-1.0.so.0",
+                },
+                value: this.id,
+            },
+        ], { type: "array", itemType: { type: "int", size: 8, unsigned: true } });
+    }
+    getRemaining() {
+        return call("libgstbase-1.0.so.0", "gst_bit_writer_get_remaining", [
+            {
+                type: {
+                    type: "boxed",
+                    borrowed: true,
+                    innerType: "BitWriter",
+                    lib: "libgstbase-1.0.so.0",
+                },
+                value: this.id,
+            },
+        ], { type: "int", size: 32, unsigned: true });
+    }
+    /**
+     * Get size of written `data`
+     */
+    getSize() {
+        return call("libgstbase-1.0.so.0", "gst_bit_writer_get_size", [
+            {
+                type: {
+                    type: "boxed",
+                    borrowed: true,
+                    innerType: "BitWriter",
+                    lib: "libgstbase-1.0.so.0",
+                },
+                value: this.id,
+            },
+        ], { type: "int", size: 32, unsigned: true });
+    }
+    /**
+     * Write `nbits` bits of `value` to #GstBitWriter.
+     * @param value - value of #guint16 to write
+     * @param nbits - number of bits to write
+     */
+    putBitsUint16(value, nbits) {
+        return call("libgstbase-1.0.so.0", "gst_bit_writer_put_bits_uint16", [
+            {
+                type: {
+                    type: "boxed",
+                    borrowed: true,
+                    innerType: "BitWriter",
+                    lib: "libgstbase-1.0.so.0",
+                },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 16, unsigned: true },
+                value: value,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: true },
+                value: nbits,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Write `nbits` bits of `value` to #GstBitWriter.
+     * @param value - value of #guint32 to write
+     * @param nbits - number of bits to write
+     */
+    putBitsUint32(value, nbits) {
+        return call("libgstbase-1.0.so.0", "gst_bit_writer_put_bits_uint32", [
+            {
+                type: {
+                    type: "boxed",
+                    borrowed: true,
+                    innerType: "BitWriter",
+                    lib: "libgstbase-1.0.so.0",
+                },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: true },
+                value: value,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: true },
+                value: nbits,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Write `nbits` bits of `value` to #GstBitWriter.
+     * @param value - value of #guint64 to write
+     * @param nbits - number of bits to write
+     */
+    putBitsUint64(value, nbits) {
+        return call("libgstbase-1.0.so.0", "gst_bit_writer_put_bits_uint64", [
+            {
+                type: {
+                    type: "boxed",
+                    borrowed: true,
+                    innerType: "BitWriter",
+                    lib: "libgstbase-1.0.so.0",
+                },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 64, unsigned: true },
+                value: value,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: true },
+                value: nbits,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Write `nbits` bits of `value` to #GstBitWriter.
+     * @param value - value of #guint8 to write
+     * @param nbits - number of bits to write
+     */
+    putBitsUint8(value, nbits) {
+        return call("libgstbase-1.0.so.0", "gst_bit_writer_put_bits_uint8", [
+            {
+                type: {
+                    type: "boxed",
+                    borrowed: true,
+                    innerType: "BitWriter",
+                    lib: "libgstbase-1.0.so.0",
+                },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 8, unsigned: true },
+                value: value,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: true },
+                value: nbits,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Write `nbytes` bytes of `data` to #GstBitWriter.
+     * @param data - pointer of data to write
+     * @param nbytes - number of bytes to write
+     */
+    putBytes(data, nbytes) {
+        return call("libgstbase-1.0.so.0", "gst_bit_writer_put_bytes", [
+            {
+                type: {
+                    type: "boxed",
+                    borrowed: true,
+                    innerType: "BitWriter",
+                    lib: "libgstbase-1.0.so.0",
+                },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "array",
+                    itemType: { type: "int", size: 8, unsigned: true },
+                },
+                value: data,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: true },
+                value: nbytes,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Resets `bitwriter` and frees the data if it's owned by `bitwriter`.
+     */
+    reset() {
+        call("libgstbase-1.0.so.0", "gst_bit_writer_reset", [
+            {
+                type: {
+                    type: "boxed",
+                    borrowed: true,
+                    innerType: "BitWriter",
+                    lib: "libgstbase-1.0.so.0",
+                },
+                value: this.id,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Resets `bitwriter` and returns the current data as #GstBuffer.
+     *
+     * Free-function: gst_buffer_unref
+     */
+    resetAndGetBuffer() {
+        const ptr = call("libgstbase-1.0.so.0", "gst_bit_writer_reset_and_get_buffer", [
+            {
+                type: {
+                    type: "boxed",
+                    borrowed: true,
+                    innerType: "BitWriter",
+                    lib: "libgstbase-1.0.so.0",
+                },
+                value: this.id,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GstBuffer",
+            lib: "libgstreamer-1.0.so.0",
+            getTypeFn: "gst_buffer_get_type",
+        });
+        return getNativeObject(ptr, Gst.Buffer);
+    }
+    /**
+     * Resets `bitwriter` and returns the current data.
+     *
+     * Free-function: g_free
+     */
+    resetAndGetData() {
+        return call("libgstbase-1.0.so.0", "gst_bit_writer_reset_and_get_data", [
+            {
+                type: {
+                    type: "boxed",
+                    borrowed: true,
+                    innerType: "BitWriter",
+                    lib: "libgstbase-1.0.so.0",
+                },
+                value: this.id,
+            },
+        ], { type: "array", itemType: { type: "int", size: 8, unsigned: true } });
+    }
+    setPos(pos) {
+        return call("libgstbase-1.0.so.0", "gst_bit_writer_set_pos", [
+            {
+                type: {
+                    type: "boxed",
+                    borrowed: true,
+                    innerType: "BitWriter",
+                    lib: "libgstbase-1.0.so.0",
+                },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: true },
+                value: pos,
+            },
+        ], { type: "boolean" });
+    }
+    /** Allocated `data` for bit writer to write */
+    get data() {
+        return read(this.id, { type: "int", size: 8, unsigned: true }, 0);
+    }
+    set data(value) {
+        write(this.id, { type: "int", size: 8, unsigned: true }, 0, value);
+    }
+    /** Size of written `data` in bits */
+    get bitSize() {
+        return read(this.id, { type: "int", size: 32, unsigned: true }, 4);
+    }
+    set bitSize(value) {
+        write(this.id, { type: "int", size: 32, unsigned: true }, 4, value);
+    }
+}

package/dist/generated/gstbase/collect-pads.js

@@ -57,7 +57,7 @@ export class CollectPads extends Gst.GstObject {
             setInstantiating(false);
             this.id = call("libgstbase-1.0.so.0", "gst_collect_pads_new", [], {
                 type: "gobject",
-                borrowed: true,
+                borrowed: false,
             });
         }
         else {
@@ -495,7 +495,9 @@ export class CollectPads extends Gst.GstObject {
         const returnType = undefined;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
-            return handler(self, ...args.slice(1));
+            const callbackArgs = args.slice(1);
+            const result = handler(self, ...callbackArgs);
+            return result;
         };
         return call("libgstbase-1.0.so.0", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.id },

package/dist/generated/gstbase/data-queue-size.d.ts

@@ -0,0 +1,22 @@
+import { NativeObject } from "../../native/base.js";
+export interface DataQueueSizeInit {
+    visible?: number;
+    bytes?: number;
+    time?: number;
+}
+/** Structure describing the size of a queue. */
+export declare class DataQueueSize extends NativeObject {
+    static readonly objectType: "struct";
+    constructor(init?: DataQueueSizeInit);
+    protected createPtr(init: DataQueueSizeInit): unknown;
+    static fromPtr(ptr: unknown): DataQueueSize;
+    /** number of buffers */
+    get visible(): number;
+    set visible(value: number);
+    /** number of bytes */
+    get bytes(): number;
+    set bytes(value: number);
+    /** amount of time */
+    get time(): number;
+    set time(value: number);
+}

package/dist/generated/gstbase/data-queue-size.js

@@ -0,0 +1,46 @@
+import { alloc, read, write } from "@gtkx/native";
+import { NativeObject } from "../../native/base.js";
+/** Structure describing the size of a queue. */
+export class DataQueueSize extends NativeObject {
+    static objectType = "struct";
+    constructor(init = {}) {
+        super();
+        this.id = this.createPtr(init);
+    }
+    createPtr(init) {
+        const ptr = alloc(16);
+        if (init.visible !== undefined)
+            write(ptr, { type: "int", size: 32, unsigned: true }, 0, init.visible);
+        if (init.bytes !== undefined)
+            write(ptr, { type: "int", size: 32, unsigned: true }, 4, init.bytes);
+        if (init.time !== undefined)
+            write(ptr, { type: "int", size: 64, unsigned: true }, 8, init.time);
+        return ptr;
+    }
+    static fromPtr(ptr) {
+        const instance = Object.create(DataQueueSize.prototype);
+        instance.id = ptr;
+        return instance;
+    }
+    /** number of buffers */
+    get visible() {
+        return read(this.id, { type: "int", size: 32, unsigned: true }, 0);
+    }
+    set visible(value) {
+        write(this.id, { type: "int", size: 32, unsigned: true }, 0, value);
+    }
+    /** number of bytes */
+    get bytes() {
+        return read(this.id, { type: "int", size: 32, unsigned: true }, 4);
+    }
+    set bytes(value) {
+        write(this.id, { type: "int", size: 32, unsigned: true }, 4, value);
+    }
+    /** amount of time */
+    get time() {
+        return read(this.id, { type: "int", size: 64, unsigned: true }, 8);
+    }
+    set time(value) {
+        write(this.id, { type: "int", size: 64, unsigned: true }, 8, value);
+    }
+}

package/dist/generated/gstbase/data-queue.js

@@ -29,7 +29,7 @@ export class DataQueue extends GObject.GObject {
             this.id = call("libgobject-2.0.so.0", "g_object_new", [
                 { type: { type: "int", size: 64, unsigned: true }, value: gtype },
                 { type: { type: "null" }, value: null },
-            ], { type: "gobject", borrowed: true });
+            ], { type: "gobject", borrowed: false });
         }
         else {
             // @ts-ignore
@@ -43,16 +43,17 @@ export class DataQueue extends GObject.GObject {
         const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
-            const signalArgs = args.slice(1);
+            const callbackArgs = args.slice(1);
             if (!meta)
-                return handler(self, ...signalArgs);
-            const wrapped = meta.params.map((m, i) => {
-                if (m.type === "gobject" && signalArgs[i] != null) {
-                    return getNativeObject(signalArgs[i]);
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
                 }
-                return signalArgs[i];
+                return callbackArgs[i];
             });
-            return handler(self, ...wrapped);
+            const result = handler(self, ...wrapped);
+            return result;
         };
         return call("libgstbase-1.0.so.0", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.id },

package/dist/generated/gstbase/index.d.ts

@@ -1,5 +1,7 @@
 export * from "./enums.js";
 export * from "./base-parse-frame.js";
+export * from "./bit-writer.js";
+export * from "./data-queue-size.js";
 export * from "./flow-combiner.js";
 export * from "./adapter.js";
 export * from "./aggregator.js";

package/dist/generated/gstbase/index.js

@@ -1,5 +1,7 @@
 export * from "./enums.js";
 export * from "./base-parse-frame.js";
+export * from "./bit-writer.js";
+export * from "./data-queue-size.js";
 export * from "./flow-combiner.js";
 export * from "./adapter.js";
 export * from "./aggregator.js";

package/dist/generated/gstbase/push-src.js

@@ -41,7 +41,7 @@ export class PushSrc extends BaseSrc {
             this.id = call("libgobject-2.0.so.0", "g_object_new", [
                 { type: { type: "int", size: 64, unsigned: true }, value: gtype },
                 { type: { type: "null" }, value: null },
-            ], { type: "gobject", borrowed: true });
+            ], { type: "gobject", borrowed: false });
         }
         else {
             // @ts-ignore
@@ -54,7 +54,9 @@ export class PushSrc extends BaseSrc {
         const returnType = undefined;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
-            return handler(self, ...args.slice(1));
+            const callbackArgs = args.slice(1);
+            const result = handler(self, ...callbackArgs);
+            return result;
         };
         return call("libgstbase-1.0.so.0", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.id },

package/dist/generated/gtk/about-dialog.js

@@ -649,16 +649,17 @@ export class AboutDialog extends Window {
         const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
-            const signalArgs = args.slice(1);
+            const callbackArgs = args.slice(1);
             if (!meta)
-                return handler(self, ...signalArgs);
-            const wrapped = meta.params.map((m, i) => {
-                if (m.type === "gobject" && signalArgs[i] != null) {
-                    return getNativeObject(signalArgs[i]);
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
                 }
-                return signalArgs[i];
+                return callbackArgs[i];
             });
-            return handler(self, ...wrapped);
+            const result = handler(self, ...wrapped);
+            return result;
         };
         return call("libgtk-4.so.1", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.id },

package/dist/generated/gtk/accessible-list.js

@@ -31,8 +31,14 @@ export class AccessibleList extends NativeObject {
                 },
                 value: list,
             },
-        ], { type: "boxed", borrowed: true, innerType: "AccessibleList" });
-        return getNativeObject(ptr);
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GtkAccessibleList",
+            lib: "libgtk-4.so.1",
+            getTypeFn: "gtk_accessible_list_get_type",
+        });
+        return getNativeObject(ptr, AccessibleList);
     }
     createPtr(_args) {
         const [accessibles, nAccessibles] = _args;