@gtkx/ffi 0.10.4 → 0.11.0

package/dist/generated/gstbase/base-parse.js

@@ -1,7 +1,5 @@
 import { call } from "../../batch.js";
-import { getNativeObject } from "../../native/object.js";
 import { registerNativeClass } from "../../registry.js";
-import * as GObject from "../gobject/index.js";
 import * as Gst from "../gst/index.js";
 /**
  * This base class is for parser elements that process data and splits it
@@ -9,13 +7,13 @@ import * as Gst from "../gst/index.js";
  *
  * It provides for:
  *
- * * provides one sink pad and one source pad
- * * handles state changes
- * * can operate in pull mode or push mode
- * * handles seeking in both modes
- * * handles events (SEGMENT/EOS/FLUSH)
- * * handles queries (POSITION/DURATION/SEEKING/FORMAT/CONVERT)
- * * handles flushing
+ *   * provides one sink pad and one source pad
+ *   * handles state changes
+ *   * can operate in pull mode or push mode
+ *   * handles seeking in both modes
+ *   * handles events (SEGMENT/EOS/FLUSH)
+ *   * handles queries (POSITION/DURATION/SEEKING/FORMAT/CONVERT)
+ *   * handles flushing
  *
  * The purpose of this base class is to provide the basic functionality of
  * a parser and share a lot of rather complex code.
@@ -24,77 +22,77 @@ import * as Gst from "../gst/index.js";
  *
  * ## Set-up phase
  *
- * * #GstBaseParse calls #GstBaseParseClass::start to inform subclass
- * that data processing is about to start now.
+ *  * #GstBaseParse calls #GstBaseParseClass::start to inform subclass
+ *    that data processing is about to start now.
  *
- * * #GstBaseParse class calls #GstBaseParseClass::set_sink_caps to
- * inform the subclass about incoming sinkpad caps. Subclass could
- * already set the srcpad caps accordingly, but this might be delayed
- * until calling gst_base_parse_finish_frame() with a non-queued frame.
+ *  * #GstBaseParse class calls #GstBaseParseClass::set_sink_caps to
+ *    inform the subclass about incoming sinkpad caps. Subclass could
+ *    already set the srcpad caps accordingly, but this might be delayed
+ *    until calling gst_base_parse_finish_frame() with a non-queued frame.
  *
- * * At least at this point subclass needs to tell the #GstBaseParse class
- * how big data chunks it wants to receive (minimum frame size ). It can
- * do this with gst_base_parse_set_min_frame_size().
+ *  * At least at this point subclass needs to tell the #GstBaseParse class
+ *    how big data chunks it wants to receive (minimum frame size ). It can
+ *    do this with gst_base_parse_set_min_frame_size().
  *
- * * #GstBaseParse class sets up appropriate data passing mode (pull/push)
- * and starts to process the data.
+ *  * #GstBaseParse class sets up appropriate data passing mode (pull/push)
+ *    and starts to process the data.
  *
  * ## Parsing phase
  *
- * * #GstBaseParse gathers at least min_frame_size bytes of data either
- * by pulling it from upstream or collecting buffers in an internal
- * #GstAdapter.
+ *  * #GstBaseParse gathers at least min_frame_size bytes of data either
+ *    by pulling it from upstream or collecting buffers in an internal
+ *    #GstAdapter.
  *
- * * A buffer of (at least) min_frame_size bytes is passed to subclass
- * with #GstBaseParseClass::handle_frame. Subclass checks the contents
- * and can optionally return #GST_FLOW_OK along with an amount of data
- * to be skipped to find a valid frame (which will result in a
- * subsequent DISCONT).  If, otherwise, the buffer does not hold a
- * complete frame, #GstBaseParseClass::handle_frame can merely return
- * and will be called again when additional data is available.  In push
- * mode this amounts to an additional input buffer (thus minimal
- * additional latency), in pull mode this amounts to some arbitrary
- * reasonable buffer size increase.
+ *  * A buffer of (at least) min_frame_size bytes is passed to subclass
+ *    with #GstBaseParseClass::handle_frame. Subclass checks the contents
+ *    and can optionally return #GST_FLOW_OK along with an amount of data
+ *    to be skipped to find a valid frame (which will result in a
+ *    subsequent DISCONT).  If, otherwise, the buffer does not hold a
+ *    complete frame, #GstBaseParseClass::handle_frame can merely return
+ *    and will be called again when additional data is available.  In push
+ *    mode this amounts to an additional input buffer (thus minimal
+ *    additional latency), in pull mode this amounts to some arbitrary
+ *    reasonable buffer size increase.
  *
- * Of course, gst_base_parse_set_min_frame_size() could also be used if
- * a very specific known amount of additional data is required.  If,
- * however, the buffer holds a complete valid frame, it can pass the
- * size of this frame to gst_base_parse_finish_frame().
+ *    Of course, gst_base_parse_set_min_frame_size() could also be used if
+ *    a very specific known amount of additional data is required.  If,
+ *    however, the buffer holds a complete valid frame, it can pass the
+ *    size of this frame to gst_base_parse_finish_frame().
  *
- * If acting as a converter, it can also merely indicate consumed input
- * data while simultaneously providing custom output data.  Note that
- * baseclass performs some processing (such as tracking overall consumed
- * data rate versus duration) for each finished frame, but other state
- * is only updated upon each call to #GstBaseParseClass::handle_frame
- * (such as tracking upstream input timestamp).
+ *    If acting as a converter, it can also merely indicate consumed input
+ *    data while simultaneously providing custom output data.  Note that
+ *    baseclass performs some processing (such as tracking overall consumed
+ *    data rate versus duration) for each finished frame, but other state
+ *    is only updated upon each call to #GstBaseParseClass::handle_frame
+ *    (such as tracking upstream input timestamp).
  *
- * Subclass is also responsible for setting the buffer metadata
- * (e.g. buffer timestamp and duration, or keyframe if applicable).
- * (although the latter can also be done by #GstBaseParse if it is
- * appropriately configured, see below).  Frame is provided with
- * timestamp derived from upstream (as much as generally possible),
- * duration obtained from configuration (see below), and offset
- * if meaningful (in pull mode).
+ *    Subclass is also responsible for setting the buffer metadata
+ *    (e.g. buffer timestamp and duration, or keyframe if applicable).
+ *    (although the latter can also be done by #GstBaseParse if it is
+ *    appropriately configured, see below).  Frame is provided with
+ *    timestamp derived from upstream (as much as generally possible),
+ *    duration obtained from configuration (see below), and offset
+ *    if meaningful (in pull mode).
  *
- * Note that #GstBaseParseClass::handle_frame might receive any small
- * amount of input data when leftover data is being drained (e.g. at
- * EOS).
+ *    Note that #GstBaseParseClass::handle_frame might receive any small
+ *    amount of input data when leftover data is being drained (e.g. at
+ *    EOS).
  *
- * * As part of finish frame processing, just prior to actually pushing
- * the buffer in question, it is passed to
- * #GstBaseParseClass::pre_push_frame which gives subclass yet one last
- * chance to examine buffer metadata, or to send some custom (tag)
- * events, or to perform custom (segment) filtering.
+ *  * As part of finish frame processing, just prior to actually pushing
+ *    the buffer in question, it is passed to
+ *    #GstBaseParseClass::pre_push_frame which gives subclass yet one last
+ *    chance to examine buffer metadata, or to send some custom (tag)
+ *    events, or to perform custom (segment) filtering.
  *
- * * During the parsing process #GstBaseParseClass will handle both srcpad
- * and sinkpad events. They will be passed to subclass if
- * #GstBaseParseClass::sink_event or #GstBaseParseClass::src_event
- * implementations have been provided.
+ *  * During the parsing process #GstBaseParseClass will handle both srcpad
+ *    and sinkpad events. They will be passed to subclass if
+ *    #GstBaseParseClass::sink_event or #GstBaseParseClass::src_event
+ *    implementations have been provided.
  *
  * ## Shutdown phase
  *
  * * #GstBaseParse class calls #GstBaseParseClass::stop to inform the
- * subclass that data parsing will be stopped.
+ *   subclass that data parsing will be stopped.
  *
  * Subclass is responsible for providing pad template caps for source and
  * sink pads. The pads need to be named "sink" and "src". It also needs to
@@ -117,35 +115,29 @@ import * as Gst from "../gst/index.js";
  * * Provide pad templates
  * * Fixate the source pad caps when appropriate
  * * Inform base class how big data chunks should be retrieved. This is
- * done with gst_base_parse_set_min_frame_size() function.
+ *   done with gst_base_parse_set_min_frame_size() function.
  * * Examine data chunks passed to subclass with
- * #GstBaseParseClass::handle_frame and pass proper frame(s) to
- * gst_base_parse_finish_frame(), and setting src pad caps and timestamps
- * on frame.
+ *   #GstBaseParseClass::handle_frame and pass proper frame(s) to
+ *   gst_base_parse_finish_frame(), and setting src pad caps and timestamps
+ *   on frame.
  * * Provide conversion functions
  * * Update the duration information with gst_base_parse_set_duration()
  * * Optionally passthrough using gst_base_parse_set_passthrough()
  * * Configure various baseparse parameters using
- * gst_base_parse_set_average_bitrate(), gst_base_parse_set_syncable()
- * and gst_base_parse_set_frame_rate().
+ *   gst_base_parse_set_average_bitrate(), gst_base_parse_set_syncable()
+ *   and gst_base_parse_set_frame_rate().
  *
  * * In particular, if subclass is unable to determine a duration, but
- * parsing (or specs) yields a frames per seconds rate, then this can be
- * provided to #GstBaseParse to enable it to cater for buffer time
- * metadata (which will be taken from upstream as much as
- * possible). Internally keeping track of frame durations and respective
- * sizes that have been pushed provides #GstBaseParse with an estimated
- * bitrate. A default #GstBaseParseClass::convert (used if not
- * overridden) will then use these rates to perform obvious conversions.
- * These rates are also used to update (estimated) duration at regular
- * frame intervals.
+ *   parsing (or specs) yields a frames per seconds rate, then this can be
+ *   provided to #GstBaseParse to enable it to cater for buffer time
+ *   metadata (which will be taken from upstream as much as
+ *   possible). Internally keeping track of frame durations and respective
+ *   sizes that have been pushed provides #GstBaseParse with an estimated
+ *   bitrate. A default #GstBaseParseClass::convert (used if not
+ *   overridden) will then use these rates to perform obvious conversions.
+ *   These rates are also used to update (estimated) duration at regular
+ *   frame intervals.
  */
-const SIGNAL_META = {
-    notify: {
-        params: [{ type: "gparam", borrowed: true }],
-        returnType: { type: "undefined" },
-    },
-};
 export class BaseParse extends Gst.Element {
     static glibTypeName = "GstBaseParse";
     static objectType = "gobject";
@@ -157,68 +149,96 @@ export class BaseParse extends Gst.Element {
      * to only add keyframe entries.  `force` allows to bypass checks, such as
      * whether the stream is (upstream) seekable, another entry is already "close"
      * to the new entry, etc.
-     * @param offset - offset of entry
-     * @param ts - timestamp associated with offset
-     * @param key - whether entry refers to keyframe
-     * @param force - add entry disregarding sanity checks
      */
     addIndexEntry(offset, ts, key, force) {
         return call("libgstbase-1.0.so.0", "gst_base_parse_add_index_entry", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: offset,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: ts,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: key,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: force,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Default implementation of #GstBaseParseClass::convert.
-     * @param srcFormat - #GstFormat describing the source format.
-     * @param srcValue - Source value to be converted.
-     * @param destFormat - #GstFormat defining the converted format.
-     * @param destValue - Pointer where the conversion result will be put.
-     */
+    /** Default implementation of #GstBaseParseClass::convert. */
     convertDefault(srcFormat, srcValue, destFormat, destValue) {
         return call("libgstbase-1.0.so.0", "gst_base_parse_convert_default", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: srcFormat,
             },
             {
-                type: { type: "int", size: 64, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: false,
+                },
                 value: srcValue,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: destFormat,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 64, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: false,
+                    },
                 },
                 value: destValue,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Drains the adapter until it is empty. It decreases the min_frame_size to
@@ -228,10 +248,15 @@ export class BaseParse extends Gst.Element {
     drain() {
         call("libgstbase-1.0.so.0", "gst_base_parse_drain", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Collects parsed data and pushes it downstream.
@@ -248,30 +273,39 @@ export class BaseParse extends Gst.Element {
      *
      * Note that the latter buffer is invalidated by this call, whereas the
      * caller retains ownership of `frame`.
-     * @param frame - a #GstBaseParseFrame
-     * @param size - consumed input data represented by frame
      */
     finishFrame(frame, size) {
         return call("libgstbase-1.0.so.0", "gst_base_parse_finish_frame", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstBaseParseFrame",
                     lib: "libgstbase-1.0.so.0",
                     getTypeFn: "gst_base_parse_frame_get_type",
                 },
-                value: frame?.id ?? frame,
+                value: frame.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: size,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Sets the parser subclass's tags and how they should be merged with any
@@ -280,31 +314,38 @@ export class BaseParse extends Gst.Element {
      *
      * Note that this is provided for convenience, and the subclass is
      * not required to use this and can still do tag handling on its own.
-     * @param tags - a #GstTagList to merge, or NULL to unset
-     * @param mode - the #GstTagMergeMode to use, usually #GST_TAG_MERGE_REPLACE
      */
     mergeTags(mode, tags) {
         call("libgstbase-1.0.so.0", "gst_base_parse_merge_tags", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstTagList",
                     lib: "libgstreamer-1.0.so.0",
                     getTypeFn: "gst_tag_list_get_type",
                 },
-                value: tags?.id ?? tags,
+                value: tags?.id,
                 optional: true,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: mode,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Pushes the frame's buffer downstream, sends any pending events and
@@ -312,25 +353,31 @@ export class BaseParse extends Gst.Element {
      * frame's buffer, though caller retains ownership of `frame`.
      *
      * This must be called with sinkpad STREAM_LOCK held.
-     * @param frame - a #GstBaseParseFrame
      */
     pushFrame(frame) {
         return call("libgstbase-1.0.so.0", "gst_base_parse_push_frame", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstBaseParseFrame",
                     lib: "libgstbase-1.0.so.0",
                     getTypeFn: "gst_base_parse_frame_get_type",
                 },
-                value: frame?.id ?? frame,
+                value: frame.id,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Optionally sets the average bitrate detected in media (if non-zero),
@@ -340,19 +387,27 @@ export class BaseParse extends Gst.Element {
      * is used to estimate the total duration of the stream and to estimate
      * a seek position, if there's no index and the format is syncable
      * (see gst_base_parse_set_syncable()).
-     * @param bitrate - average bitrate in bits/second
      */
     setAverageBitrate(bitrate) {
         call("libgstbase-1.0.so.0", "gst_base_parse_set_average_bitrate", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: bitrate,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the duration of the currently playing media. Subclass can use this
@@ -360,29 +415,43 @@ export class BaseParse extends Gst.Element {
      * duration.  Alternatively, if `interval` is non-zero (default), then stream
      * duration is determined based on estimated bitrate, and updated every `interval`
      * frames.
-     * @param fmt - #GstFormat.
-     * @param duration - duration value.
-     * @param interval - how often to update the duration estimate based on bitrate, or 0.
      */
     setDuration(fmt, duration, interval) {
         call("libgstbase-1.0.so.0", "gst_base_parse_set_duration", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: fmt,
             },
             {
-                type: { type: "int", size: 64, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: false,
+                },
                 value: duration,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: interval,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * If frames per second is configured, parser can take care of buffer duration
@@ -390,71 +459,100 @@ export class BaseParse extends Gst.Element {
      * location, a corresponding decoder might need an initial `lead_in` and a
      * following `lead_out` number of frames to ensure the desired segment is
      * entirely filled upon decoding.
-     * @param fpsNum - frames per second (numerator).
-     * @param fpsDen - frames per second (denominator).
-     * @param leadIn - frames needed before a segment for subsequent decode
-     * @param leadOut - frames needed after a segment
      */
     setFrameRate(fpsNum, fpsDen, leadIn, leadOut) {
         call("libgstbase-1.0.so.0", "gst_base_parse_set_frame_rate", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: fpsNum,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: fpsDen,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: leadIn,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: leadOut,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Set if frames carry timing information which the subclass can (generally)
      * parse and provide.  In particular, intrinsic (rather than estimated) time
      * can be obtained following a seek.
-     * @param hasTiming - whether frames carry timing information
      */
     setHasTimingInfo(hasTiming) {
         call("libgstbase-1.0.so.0", "gst_base_parse_set_has_timing_info", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: hasTiming,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * By default, the base class might try to infer PTS from DTS and vice
      * versa.  While this is generally correct for audio data, it may not
      * be otherwise. Sub-classes implementing such formats should disable
      * timestamp inferring.
-     * @param inferTs - %TRUE if parser should infer DTS/PTS from each other
      */
     setInferTs(inferTs) {
         call("libgstbase-1.0.so.0", "gst_base_parse_set_infer_ts", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: inferTs,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the minimum and maximum (which may likely be equal) latency introduced
@@ -464,41 +562,60 @@ export class BaseParse extends Gst.Element {
      * If the provided values changed from previously provided ones, this will
      * also post a LATENCY message on the bus so the pipeline can reconfigure its
      * global latency.
-     * @param minLatency - minimum parse latency
-     * @param maxLatency - maximum parse latency
      */
     setLatency(minLatency, maxLatency) {
         call("libgstbase-1.0.so.0", "gst_base_parse_set_latency", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: minLatency,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: maxLatency,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Subclass can use this function to tell the base class that it needs to
      * be given buffers of at least `min_size` bytes.
-     * @param minSize - Minimum size in bytes of the data that this base class should
      */
     setMinFrameSize(minSize) {
         call("libgstbase-1.0.so.0", "gst_base_parse_set_min_frame_size", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: minSize,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Set if the nature of the format or configuration does not allow (much)
@@ -508,56 +625,74 @@ export class BaseParse extends Gst.Element {
      * will be invoked, but #GstBaseParseClass::pre_push_frame will still be
      * invoked, so subclass can perform as much or as little is appropriate for
      * passthrough semantics in #GstBaseParseClass::pre_push_frame.
-     * @param passthrough - %TRUE if parser should run in passthrough mode
      */
     setPassthrough(passthrough) {
         call("libgstbase-1.0.so.0", "gst_base_parse_set_passthrough", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: passthrough,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * By default, the base class will guess PTS timestamps using a simple
      * interpolation (previous timestamp + duration), which is incorrect for
      * data streams with reordering, where PTS can go backward. Sub-classes
      * implementing such formats should disable PTS interpolation.
-     * @param ptsInterpolate - %TRUE if parser should interpolate PTS timestamps
      */
     setPtsInterpolation(ptsInterpolate) {
         call("libgstbase-1.0.so.0", "gst_base_parse_set_pts_interpolation", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: ptsInterpolate,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Set if frame starts can be identified. This is set by default and
      * determines whether seeking based on bitrate averages
      * is possible for a format/stream.
-     * @param syncable - set if frame starts can be identified
      */
     setSyncable(syncable) {
         call("libgstbase-1.0.so.0", "gst_base_parse_set_syncable", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: syncable,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * This function should only be called from a `handle_frame` implementation.
@@ -568,51 +703,27 @@ export class BaseParse extends Gst.Element {
      * start of the frame, but before the start of the actual picture data.
      * This function can be used to set the timestamps based on the offset
      * into the frame data that the picture starts.
-     * @param offset - offset into current buffer
      */
     setTsAtOffset(offset) {
         call("libgstbase-1.0.so.0", "gst_base_parse_set_ts_at_offset", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: offset,
             },
-        ], { type: "undefined" });
-    }
-    connect(signal, handler, after = false) {
-        const meta = SIGNAL_META[signal];
-        const selfType = { type: "gobject", borrowed: true };
-        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
-        const returnType = meta?.returnType;
-        const wrappedHandler = (...args) => {
-            const self = getNativeObject(args[0]);
-            const callbackArgs = args.slice(1);
-            if (!meta)
-                return handler(self, ...callbackArgs);
-            const wrapped = meta.params.map((t, i) => {
-                if (t?.type === "gobject" && callbackArgs[i] != null) {
-                    return getNativeObject(callbackArgs[i]);
-                }
-                if (t?.type === "gparam" && callbackArgs[i] != null) {
-                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
-                }
-                return callbackArgs[i];
-            });
-            const result = handler(self, ...wrapped);
-            return result;
-        };
-        return call("libgstbase-1.0.so.0", "g_signal_connect_closure", [
-            { type: { type: "gobject" }, value: this.id },
-            { type: { type: "string" }, value: signal },
-            {
-                type: { type: "callback", argTypes, returnType },
-                value: wrappedHandler,
-            },
-            { type: { type: "boolean" }, value: after },
-        ], { type: "int", size: 64, unsigned: true });
+        ], {
+            type: "undefined",
+        });
     }
 }
 registerNativeClass(BaseParse);