@gtkx/ffi 0.15.0 → 0.17.1

package/dist/generated/gstbase/byte-reader.js

@@ -1,5 +1,1935 @@
+import { alloc, call, read, write } from "../../native/lifecycle.js";
 import { NativeObject } from "../../native/base.js";
-/** Stub class for ByteReader (opaque type not fully generated) */
+/**
+ * #GstByteReader provides a byte reader that can read different integer and
+ * floating point types from a memory buffer. It provides functions for reading
+ * signed/unsigned, little/big endian integers of 8, 16, 24, 32 and 64 bits
+ * and functions for reading little/big endian floating points numbers of
+ * 32 and 64 bits. It also provides functions to read NUL-terminated strings
+ * in various character encodings.
+ */
 export class ByteReader extends NativeObject {
-    static objectType = "boxed";
+    static objectType = "struct";
+    constructor(init = {}) {
+        super();
+        this.handle = alloc(48);
+        if (init.size !== undefined)
+            write(this.handle, {
+                type: "int",
+                size: 32,
+                unsigned: true,
+            }, 8, init.size);
+        if (init.byte !== undefined)
+            write(this.handle, {
+                type: "int",
+                size: 32,
+                unsigned: true,
+            }, 12, init.byte);
+    }
+    /**
+     * Free-function: g_free
+     *
+     * Returns a newly-allocated copy of the current data
+     * position if at least `size` bytes are left and
+     * updates the current position. Free with g_free() when no longer needed.
+     */
+    dupData(size, val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_dup_data", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: true,
+                    },
+                },
+                value: size,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "array",
+                        itemType: {
+                            type: "int",
+                            size: 8,
+                            unsigned: true,
+                        },
+                        kind: "sized",
+                        sizeParamIndex: 1,
+                        ownership: "full",
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Free-function: g_free
+     *
+     * Returns a newly-allocated copy of the current data position if there is
+     * a NUL-terminated UTF-16 string in the data (this could be an empty string
+     * as well), and advances the current position.
+     *
+     * No input checking for valid UTF-16 is done. This function is endianness
+     * agnostic - you should not assume the UTF-16 characters are in host
+     * endianness.
+     *
+     * This function will fail if no NUL-terminator was found in in the data.
+     *
+     * Note: there is no peek or get variant of this function to ensure correct
+     * byte alignment of the UTF-16 string.
+     */
+    dupStringUtf16(str) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_dup_string_utf16", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "array",
+                        itemType: {
+                            type: "int",
+                            size: 16,
+                            unsigned: true,
+                        },
+                        kind: "array",
+                        ownership: "full",
+                    },
+                },
+                value: str,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Free-function: g_free
+     *
+     * Returns a newly-allocated copy of the current data position if there is
+     * a NUL-terminated UTF-32 string in the data (this could be an empty string
+     * as well), and advances the current position.
+     *
+     * No input checking for valid UTF-32 is done. This function is endianness
+     * agnostic - you should not assume the UTF-32 characters are in host
+     * endianness.
+     *
+     * This function will fail if no NUL-terminator was found in in the data.
+     *
+     * Note: there is no peek or get variant of this function to ensure correct
+     * byte alignment of the UTF-32 string.
+     */
+    dupStringUtf32(str) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_dup_string_utf32", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "array",
+                        itemType: {
+                            type: "int",
+                            size: 32,
+                            unsigned: true,
+                        },
+                        kind: "array",
+                        ownership: "full",
+                    },
+                },
+                value: str,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Free-function: g_free
+     *
+     * FIXME:Reads (copies) a NUL-terminated string in the #GstByteReader instance,
+     * advancing the current position to the byte after the string. This will work
+     * for any NUL-terminated string with a character width of 8 bits, so ASCII,
+     * UTF-8, ISO-8859-N etc. No input checking for valid UTF-8 is done.
+     *
+     * This function will fail if no NUL-terminator was found in in the data.
+     */
+    dupStringUtf8(str) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_dup_string_utf8", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "array",
+                        itemType: {
+                            type: "string",
+                            ownership: "full",
+                        },
+                        kind: "array",
+                        ownership: "full",
+                    },
+                },
+                value: str,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Frees a #GstByteReader instance, which was previously allocated by
+     * gst_byte_reader_new().
+     */
+    free() {
+        call("libgstbase-1.0.so.0", "gst_byte_reader_free", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * Returns a constant pointer to the current data
+     * position if at least `size` bytes are left and
+     * updates the current position.
+     */
+    getData(size, val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_data", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: true,
+                    },
+                },
+                value: size,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "array",
+                        itemType: {
+                            type: "int",
+                            size: 8,
+                            unsigned: true,
+                        },
+                        kind: "sized",
+                        sizeParamIndex: 1,
+                        ownership: "borrowed",
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read a 32 bit big endian floating point value into `val`
+     * and update the current position.
+     */
+    getFloat32Be(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_float32_be", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "float",
+                        size: 32,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read a 32 bit little endian floating point value into `val`
+     * and update the current position.
+     */
+    getFloat32Le(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_float32_le", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "float",
+                        size: 32,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read a 64 bit big endian floating point value into `val`
+     * and update the current position.
+     */
+    getFloat64Be(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_float64_be", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "float",
+                        size: 64,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read a 64 bit little endian floating point value into `val`
+     * and update the current position.
+     */
+    getFloat64Le(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_float64_le", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "float",
+                        size: 64,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read a signed 16 bit big endian integer into `val`
+     * and update the current position.
+     */
+    getInt16Be(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_int16_be", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 16,
+                        unsigned: false,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read a signed 16 bit little endian integer into `val`
+     * and update the current position.
+     */
+    getInt16Le(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_int16_le", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 16,
+                        unsigned: false,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read a signed 24 bit big endian integer into `val`
+     * and update the current position.
+     */
+    getInt24Be(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_int24_be", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read a signed 24 bit little endian integer into `val`
+     * and update the current position.
+     */
+    getInt24Le(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_int24_le", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read a signed 32 bit big endian integer into `val`
+     * and update the current position.
+     */
+    getInt32Be(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_int32_be", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read a signed 32 bit little endian integer into `val`
+     * and update the current position.
+     */
+    getInt32Le(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_int32_le", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read a signed 64 bit big endian integer into `val`
+     * and update the current position.
+     */
+    getInt64Be(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_int64_be", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: false,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read a signed 64 bit little endian integer into `val`
+     * and update the current position.
+     */
+    getInt64Le(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_int64_le", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: false,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /** Read a signed 8 bit integer into `val` and update the current position. */
+    getInt8(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_int8", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 8,
+                        unsigned: false,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /** Returns the current position of a #GstByteReader instance in bytes. */
+    getPos() {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_pos", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        });
+    }
+    /** Returns the remaining number of bytes of a #GstByteReader instance. */
+    getRemaining() {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_remaining", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        });
+    }
+    /** Returns the total number of bytes of a #GstByteReader instance. */
+    getSize() {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_size", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        });
+    }
+    /**
+     * Returns a constant pointer to the current data position if there is
+     * a NUL-terminated string in the data (this could be just a NUL terminator),
+     * advancing the current position to the byte after the string. This will work
+     * for any NUL-terminated string with a character width of 8 bits, so ASCII,
+     * UTF-8, ISO-8859-N etc.
+     *
+     * No input checking for valid UTF-8 is done.
+     *
+     * This function will fail if no NUL-terminator was found in in the data.
+     */
+    getStringUtf8(str) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_string_utf8", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "array",
+                        itemType: {
+                            type: "string",
+                            ownership: "borrowed",
+                        },
+                        kind: "array",
+                        ownership: "borrowed",
+                    },
+                },
+                value: str,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read an unsigned 16 bit big endian integer into `val`
+     * and update the current position.
+     */
+    getUint16Be(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_uint16_be", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 16,
+                        unsigned: true,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read an unsigned 16 bit little endian integer into `val`
+     * and update the current position.
+     */
+    getUint16Le(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_uint16_le", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 16,
+                        unsigned: true,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read an unsigned 24 bit big endian integer into `val`
+     * and update the current position.
+     */
+    getUint24Be(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_uint24_be", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: true,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read an unsigned 24 bit little endian integer into `val`
+     * and update the current position.
+     */
+    getUint24Le(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_uint24_le", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: true,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read an unsigned 32 bit big endian integer into `val`
+     * and update the current position.
+     */
+    getUint32Be(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_uint32_be", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: true,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read an unsigned 32 bit little endian integer into `val`
+     * and update the current position.
+     */
+    getUint32Le(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_uint32_le", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: true,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read an unsigned 64 bit big endian integer into `val`
+     * and update the current position.
+     */
+    getUint64Be(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_uint64_be", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: true,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read an unsigned 64 bit little endian integer into `val`
+     * and update the current position.
+     */
+    getUint64Le(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_uint64_le", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: true,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /** Read an unsigned 8 bit integer into `val` and update the current position. */
+    getUint8(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_get_uint8", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 8,
+                        unsigned: true,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Initializes a #GstByteReader instance to read from `data`. This function
+     * can be called on already initialized instances.
+     */
+    init(data, size) {
+        call("libgstbase-1.0.so.0", "gst_byte_reader_init", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "array",
+                    itemType: {
+                        type: "int",
+                        size: 8,
+                        unsigned: true,
+                    },
+                    kind: "sized",
+                    sizeParamIndex: 2,
+                    ownership: "borrowed",
+                },
+                value: data,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: size,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * Scan for pattern `pattern` with applied mask `mask` in the byte reader data,
+     * starting from offset `offset` relative to the current position.
+     *
+     * The bytes in `pattern` and `mask` are interpreted left-to-right, regardless
+     * of endianness.  All four bytes of the pattern must be present in the
+     * byte reader data for it to match, even if the first or last bytes are masked
+     * out.
+     *
+     * It is an error to call this function without making sure that there is
+     * enough data (offset+size bytes) in the byte reader.
+     */
+    maskedScanUint32(mask, pattern, offset, size) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_masked_scan_uint32", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: mask,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: pattern,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: offset,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: size,
+            },
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        });
+    }
+    /**
+     * Scan for pattern `pattern` with applied mask `mask` in the byte reader data,
+     * starting from offset `offset` relative to the current position.
+     *
+     * The bytes in `pattern` and `mask` are interpreted left-to-right, regardless
+     * of endianness.  All four bytes of the pattern must be present in the
+     * byte reader data for it to match, even if the first or last bytes are masked
+     * out.
+     *
+     * It is an error to call this function without making sure that there is
+     * enough data (offset+size bytes) in the byte reader.
+     */
+    maskedScanUint32Peek(mask, pattern, offset, size, value) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_masked_scan_uint32_peek", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: mask,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: pattern,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: offset,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: size,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: true,
+                    },
+                },
+                value: value,
+            },
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        });
+    }
+    /**
+     * Returns a constant pointer to the current data
+     * position if at least `size` bytes are left and
+     * keeps the current position.
+     */
+    peekData(size, val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_peek_data", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: true,
+                    },
+                },
+                value: size,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "array",
+                        itemType: {
+                            type: "int",
+                            size: 8,
+                            unsigned: true,
+                        },
+                        kind: "sized",
+                        sizeParamIndex: 1,
+                        ownership: "borrowed",
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read a 32 bit big endian floating point value into `val`
+     * but keep the current position.
+     */
+    peekFloat32Be(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_peek_float32_be", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "float",
+                        size: 32,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read a 32 bit little endian floating point value into `val`
+     * but keep the current position.
+     */
+    peekFloat32Le(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_peek_float32_le", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "float",
+                        size: 32,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read a 64 bit big endian floating point value into `val`
+     * but keep the current position.
+     */
+    peekFloat64Be(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_peek_float64_be", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "float",
+                        size: 64,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read a 64 bit little endian floating point value into `val`
+     * but keep the current position.
+     */
+    peekFloat64Le(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_peek_float64_le", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "float",
+                        size: 64,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read a signed 16 bit big endian integer into `val`
+     * but keep the current position.
+     */
+    peekInt16Be(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_peek_int16_be", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 16,
+                        unsigned: false,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read a signed 16 bit little endian integer into `val`
+     * but keep the current position.
+     */
+    peekInt16Le(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_peek_int16_le", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 16,
+                        unsigned: false,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read a signed 24 bit big endian integer into `val`
+     * but keep the current position.
+     */
+    peekInt24Be(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_peek_int24_be", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read a signed 24 bit little endian integer into `val`
+     * but keep the current position.
+     */
+    peekInt24Le(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_peek_int24_le", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read a signed 32 bit big endian integer into `val`
+     * but keep the current position.
+     */
+    peekInt32Be(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_peek_int32_be", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read a signed 32 bit little endian integer into `val`
+     * but keep the current position.
+     */
+    peekInt32Le(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_peek_int32_le", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read a signed 64 bit big endian integer into `val`
+     * but keep the current position.
+     */
+    peekInt64Be(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_peek_int64_be", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: false,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read a signed 64 bit little endian integer into `val`
+     * but keep the current position.
+     */
+    peekInt64Le(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_peek_int64_le", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: false,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /** Read a signed 8 bit integer into `val` but keep the current position. */
+    peekInt8(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_peek_int8", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 8,
+                        unsigned: false,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Returns a constant pointer to the current data position if there is
+     * a NUL-terminated string in the data (this could be just a NUL terminator).
+     * The current position will be maintained. This will work for any
+     * NUL-terminated string with a character width of 8 bits, so ASCII,
+     * UTF-8, ISO-8859-N etc.
+     *
+     * No input checking for valid UTF-8 is done.
+     *
+     * This function will fail if no NUL-terminator was found in in the data.
+     */
+    peekStringUtf8(str) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_peek_string_utf8", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "array",
+                        itemType: {
+                            type: "string",
+                            ownership: "borrowed",
+                        },
+                        kind: "array",
+                        ownership: "borrowed",
+                    },
+                },
+                value: str,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read an unsigned 16 bit big endian integer into `val`
+     * but keep the current position.
+     */
+    peekUint16Be(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_peek_uint16_be", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 16,
+                        unsigned: true,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read an unsigned 16 bit little endian integer into `val`
+     * but keep the current position.
+     */
+    peekUint16Le(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_peek_uint16_le", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 16,
+                        unsigned: true,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read an unsigned 24 bit big endian integer into `val`
+     * but keep the current position.
+     */
+    peekUint24Be(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_peek_uint24_be", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: true,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read an unsigned 24 bit little endian integer into `val`
+     * but keep the current position.
+     */
+    peekUint24Le(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_peek_uint24_le", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: true,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read an unsigned 32 bit big endian integer into `val`
+     * but keep the current position.
+     */
+    peekUint32Be(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_peek_uint32_be", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: true,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read an unsigned 32 bit little endian integer into `val`
+     * but keep the current position.
+     */
+    peekUint32Le(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_peek_uint32_le", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: true,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read an unsigned 64 bit big endian integer into `val`
+     * but keep the current position.
+     */
+    peekUint64Be(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_peek_uint64_be", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: true,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Read an unsigned 64 bit little endian integer into `val`
+     * but keep the current position.
+     */
+    peekUint64Le(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_peek_uint64_le", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: true,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /** Read an unsigned 8 bit integer into `val` but keep the current position. */
+    peekUint8(val) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_peek_uint8", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 8,
+                        unsigned: true,
+                    },
+                },
+                value: val,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /** Sets the new position of a #GstByteReader instance to `pos` in bytes. */
+    setPos(pos) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_set_pos", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: pos,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /** Skips `nbytes` bytes of the #GstByteReader instance. */
+    skip(nbytes) {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_skip", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: nbytes,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Skips a NUL-terminated UTF-16 string in the #GstByteReader instance,
+     * advancing the current position to the byte after the string.
+     *
+     * No input checking for valid UTF-16 is done.
+     *
+     * This function will fail if no NUL-terminator was found in in the data.
+     */
+    skipStringUtf16() {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_skip_string_utf16", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Skips a NUL-terminated UTF-32 string in the #GstByteReader instance,
+     * advancing the current position to the byte after the string.
+     *
+     * No input checking for valid UTF-32 is done.
+     *
+     * This function will fail if no NUL-terminator was found in in the data.
+     */
+    skipStringUtf32() {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_skip_string_utf32", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Skips a NUL-terminated string in the #GstByteReader instance, advancing
+     * the current position to the byte after the string. This will work for
+     * any NUL-terminated string with a character width of 8 bits, so ASCII,
+     * UTF-8, ISO-8859-N etc. No input checking for valid UTF-8 is done.
+     *
+     * This function will fail if no NUL-terminator was found in in the data.
+     */
+    skipStringUtf8() {
+        return call("libgstbase-1.0.so.0", "gst_byte_reader_skip_string_utf8", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "borrowed",
+                },
+                value: this.handle,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /** Current byte position */
+    getByte() {
+        return read(this.handle, {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        }, 12);
+    }
 }