@gtkx/ffi 0.9.4 → 0.10.1

package/dist/generated/gstbase/aggregator-pad.js

@@ -2,6 +2,7 @@ import { call } from "../../batch.js";
 import { getNativeObject } from "../../native/object.js";
 import { isInstantiating, setInstantiating } from "../../native/base.js";
 import { registerNativeClass, getNativeClass } from "../../registry.js";
+import * as GObject from "../gobject/index.js";
 import * as Gst from "../gst/index.js";
 /**
  * Pads managed by a #GstAggregator subclass.
@@ -21,6 +22,10 @@ const SIGNAL_META = {
         ],
         returnType: { type: "undefined" },
     },
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
 };
 export class AggregatorPad extends Gst.Pad {
     static glibTypeName = "GstAggregatorPad";
@@ -35,7 +40,7 @@ export class AggregatorPad extends Gst.Pad {
             this.id = call("libgobject-2.0.so.0", "g_object_new", [
                 { type: { type: "int", size: 64, unsigned: true }, value: gtype },
                 { type: { type: "null" }, value: null },
-            ], { type: "gobject", borrowed: true });
+            ], { type: "gobject", borrowed: false });
         }
         else {
             // @ts-ignore
@@ -129,20 +134,24 @@ export class AggregatorPad extends Gst.Pad {
         const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
-            const signalArgs = args.slice(1);
+            const callbackArgs = args.slice(1);
             if (!meta)
-                return handler(self, ...signalArgs);
-            const wrapped = meta.params.map((m, i) => {
-                if (m.type === "gobject" && signalArgs[i] != null) {
-                    return getNativeObject(signalArgs[i]);
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
                 }
-                if (m.type === "boxed" && signalArgs[i] != null) {
-                    const cls = getNativeClass(m.innerType);
-                    return cls ? getNativeObject(signalArgs[i], cls) : signalArgs[i];
+                if (t?.type === "boxed" && callbackArgs[i] != null) {
+                    const cls = getNativeClass(t.innerType);
+                    return cls ? getNativeObject(callbackArgs[i], cls) : callbackArgs[i];
                 }
-                return signalArgs[i];
+                return callbackArgs[i];
             });
-            return handler(self, ...wrapped);
+            const result = handler(self, ...wrapped);
+            return result;
         };
         return call("libgstbase-1.0.so.0", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.id },

package/dist/generated/gstbase/aggregator.js

@@ -1,6 +1,7 @@
 import { call } from "../../batch.js";
 import { getNativeObject } from "../../native/object.js";
 import { registerNativeClass, getNativeClass } from "../../registry.js";
+import * as GObject from "../gobject/index.js";
 import * as Gst from "../gst/index.js";
 /**
  * Manages a set of pads with the purpose of aggregating their buffers.
@@ -88,6 +89,10 @@ const SIGNAL_META = {
         ],
         returnType: { type: "undefined" },
     },
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
 };
 export class Aggregator extends Gst.Element {
     static glibTypeName = "GstAggregator";
@@ -466,20 +471,24 @@ export class Aggregator extends Gst.Element {
         const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
-            const signalArgs = args.slice(1);
+            const callbackArgs = args.slice(1);
             if (!meta)
-                return handler(self, ...signalArgs);
-            const wrapped = meta.params.map((m, i) => {
-                if (m.type === "gobject" && signalArgs[i] != null) {
-                    return getNativeObject(signalArgs[i]);
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
                 }
-                if (m.type === "boxed" && signalArgs[i] != null) {
-                    const cls = getNativeClass(m.innerType);
-                    return cls ? getNativeObject(signalArgs[i], cls) : signalArgs[i];
+                if (t?.type === "boxed" && callbackArgs[i] != null) {
+                    const cls = getNativeClass(t.innerType);
+                    return cls ? getNativeObject(callbackArgs[i], cls) : callbackArgs[i];
                 }
-                return signalArgs[i];
+                return callbackArgs[i];
             });
-            return handler(self, ...wrapped);
+            const result = handler(self, ...wrapped);
+            return result;
         };
         return call("libgstbase-1.0.so.0", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.id },

package/dist/generated/gstbase/base-parse.d.ts

@@ -2,143 +2,6 @@ import { Ref } from "@gtkx/native";
 import { BaseParseFrame } from "./base-parse-frame.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
- * into separate audio/video/whatever frames.
- *
- * 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
- *
- * The purpose of this base class is to provide the basic functionality of
- * a parser and share a lot of rather complex code.
- *
- * # Description of the parsing mechanism:
- *
- * ## Set-up phase
- *
- * * #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.
- *
- * * 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.
- *
- * ## 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.
- *
- * * 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().
- *
- * 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).
- *
- * 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.
- *
- * * 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 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
- * set the fixed caps on srcpad, when the format is ensured (e.g.  when
- * base class calls subclass' #GstBaseParseClass::set_sink_caps function).
- *
- * This base class uses %GST_FORMAT_DEFAULT as a meaning of frames. So,
- * subclass conversion routine needs to know that conversion from
- * %GST_FORMAT_TIME to %GST_FORMAT_DEFAULT must return the
- * frame number that can be found from the given byte position.
- *
- * #GstBaseParse uses subclasses conversion methods also for seeking (or
- * otherwise uses its own default one, see also below).
- *
- * Subclass `start` and `stop` functions will be called to inform the beginning
- * and end of data processing.
- *
- * Things that subclass need to take care of:
- *
- * * 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.
- * * 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.
- * * 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().
- *
- * * 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.
- */
 export declare class BaseParse extends Gst.Element {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

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

@@ -1,6 +1,7 @@
 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
@@ -139,6 +140,12 @@ import * as Gst from "../gst/index.js";
  * 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";
@@ -576,12 +583,26 @@ export class BaseParse extends Gst.Element {
         ], { type: "undefined" });
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
-            return handler(self, ...args.slice(1));
+            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 },

package/dist/generated/gstbase/base-sink.d.ts

@@ -1,121 +1,6 @@
 import { Ref } from "@gtkx/native";
 import * as GObject from "../gobject/index.js";
 import * as Gst from "../gst/index.js";
-/**
- * #GstBaseSink is the base class for sink elements in GStreamer, such as
- * xvimagesink or filesink. It is a layer on top of #GstElement that provides a
- * simplified interface to plugin writers. #GstBaseSink handles many details
- * for you, for example: preroll, clock synchronization, state changes,
- * activation in push or pull mode, and queries.
- *
- * In most cases, when writing sink elements, there is no need to implement
- * class methods from #GstElement or to set functions on pads, because the
- * #GstBaseSink infrastructure should be sufficient.
- *
- * #GstBaseSink provides support for exactly one sink pad, which should be
- * named "sink". A sink implementation (subclass of #GstBaseSink) should
- * install a pad template in its class_init function, like so:
- * |[<!-- language="C" -->
- * static void
- * my_element_class_init (GstMyElementClass *klass)
- * {
- * GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
- *
- * // sinktemplate should be a #GstStaticPadTemplate with direction
- * // %GST_PAD_SINK and name "sink"
- * gst_element_class_add_static_pad_template (gstelement_class, &sinktemplate);
- *
- * gst_element_class_set_static_metadata (gstelement_class,
- * "Sink name",
- * "Sink",
- * "My Sink element",
- * "The author <my.sink`my`.email>");
- * }
- * ]|
- *
- * #GstBaseSink will handle the prerolling correctly. This means that it will
- * return %GST_STATE_CHANGE_ASYNC from a state change to PAUSED until the first
- * buffer arrives in this element. The base class will call the
- * #GstBaseSinkClass::preroll vmethod with this preroll buffer and will then
- * commit the state change to the next asynchronously pending state.
- *
- * When the element is set to PLAYING, #GstBaseSink will synchronise on the
- * clock using the times returned from #GstBaseSinkClass::get_times. If this
- * function returns %GST_CLOCK_TIME_NONE for the start time, no synchronisation
- * will be done. Synchronisation can be disabled entirely by setting the object
- * #GstBaseSink:sync property to %FALSE.
- *
- * After synchronisation the virtual method #GstBaseSinkClass::render will be
- * called. Subclasses should minimally implement this method.
- *
- * Subclasses that synchronise on the clock in the #GstBaseSinkClass::render
- * method are supported as well. These classes typically receive a buffer in
- * the render method and can then potentially block on the clock while
- * rendering. A typical example is an audiosink.
- * These subclasses can use gst_base_sink_wait_preroll() to perform the
- * blocking wait.
- *
- * Upon receiving the EOS event in the PLAYING state, #GstBaseSink will wait
- * for the clock to reach the time indicated by the stop time of the last
- * #GstBaseSinkClass::get_times call before posting an EOS message. When the
- * element receives EOS in PAUSED, preroll completes, the event is queued and an
- * EOS message is posted when going to PLAYING.
- *
- * #GstBaseSink will internally use the %GST_EVENT_SEGMENT events to schedule
- * synchronisation and clipping of buffers. Buffers that fall completely outside
- * of the current segment are dropped. Buffers that fall partially in the
- * segment are rendered (and prerolled). Subclasses should do any subbuffer
- * clipping themselves when needed.
- *
- * #GstBaseSink will by default report the current playback position in
- * %GST_FORMAT_TIME based on the current clock time and segment information.
- * If no clock has been set on the element, the query will be forwarded
- * upstream.
- *
- * The #GstBaseSinkClass::set_caps function will be called when the subclass
- * should configure itself to process a specific media type.
- *
- * The #GstBaseSinkClass::start and #GstBaseSinkClass::stop virtual methods
- * will be called when resources should be allocated. Any
- * #GstBaseSinkClass::preroll, #GstBaseSinkClass::render and
- * #GstBaseSinkClass::set_caps function will be called between the
- * #GstBaseSinkClass::start and #GstBaseSinkClass::stop calls.
- *
- * The #GstBaseSinkClass::event virtual method will be called when an event is
- * received by #GstBaseSink. Normally this method should only be overridden by
- * very specific elements (such as file sinks) which need to handle the
- * newsegment event specially.
- *
- * The #GstBaseSinkClass::unlock method is called when the elements should
- * unblock any blocking operations they perform in the
- * #GstBaseSinkClass::render method. This is mostly useful when the
- * #GstBaseSinkClass::render method performs a blocking write on a file
- * descriptor, for example.
- *
- * The #GstBaseSink:max-lateness property affects how the sink deals with
- * buffers that arrive too late in the sink. A buffer arrives too late in the
- * sink when the presentation time (as a combination of the last segment, buffer
- * timestamp and element base_time) plus the duration is before the current
- * time of the clock.
- * If the frame is later than max-lateness, the sink will drop the buffer
- * without calling the render method.
- * This feature is disabled if sync is disabled, the
- * #GstBaseSinkClass::get_times method does not return a valid start time or
- * max-lateness is set to -1 (the default).
- * Subclasses can use gst_base_sink_set_max_lateness() to configure the
- * max-lateness value.
- *
- * The #GstBaseSink:qos property will enable the quality-of-service features of
- * the basesink which gather statistics about the real-time performance of the
- * clock synchronisation. For each buffer received in the sink, statistics are
- * gathered and a QOS event is sent upstream with these numbers. This
- * information can then be used by upstream elements to reduce their processing
- * rate, for example.
- *
- * The #GstBaseSink:async property can be used to instruct the sink to never
- * perform an ASYNC state change. This feature is mostly usable when dealing
- * with non-synchronized streams or sparse streams.
- */
 export declare class BaseSink extends Gst.Element {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

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

@@ -1,6 +1,7 @@
 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";
 /**
  * #GstBaseSink is the base class for sink elements in GStreamer, such as
@@ -117,6 +118,12 @@ import * as Gst from "../gst/index.js";
  * perform an ASYNC state change. This feature is mostly usable when dealing
  * with non-synchronized streams or sparse streams.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class BaseSink extends Gst.Element {
     static glibTypeName = "GstBaseSink";
     static objectType = "gobject";
@@ -726,12 +733,26 @@ export class BaseSink extends Gst.Element {
         ], { type: "int", size: 32, unsigned: false });
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
-            return handler(self, ...args.slice(1));
+            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 },

package/dist/generated/gstbase/base-src.d.ts

@@ -1,120 +1,6 @@
 import { Ref } from "@gtkx/native";
 import * as GObject from "../gobject/index.js";
 import * as Gst from "../gst/index.js";
-/**
- * This is a generic base class for source elements. The following
- * types of sources are supported:
- *
- * * random access sources like files
- * * seekable sources
- * * live sources
- *
- * The source can be configured to operate in any #GstFormat with the
- * gst_base_src_set_format() method. The currently set format determines
- * the format of the internal #GstSegment and any %GST_EVENT_SEGMENT
- * events. The default format for #GstBaseSrc is %GST_FORMAT_BYTES.
- *
- * #GstBaseSrc always supports push mode scheduling. If the following
- * conditions are met, it also supports pull mode scheduling:
- *
- * * The format is set to %GST_FORMAT_BYTES (default).
- * * #GstBaseSrcClass::is_seekable returns %TRUE.
- *
- * If all the conditions are met for operating in pull mode, #GstBaseSrc is
- * automatically seekable in push mode as well. The following conditions must
- * be met to make the element seekable in push mode when the format is not
- * %GST_FORMAT_BYTES:
- *
- * * #GstBaseSrcClass::is_seekable returns %TRUE.
- * * #GstBaseSrcClass::query can convert all supported seek formats to the
- * internal format as set with gst_base_src_set_format().
- * * #GstBaseSrcClass::do_seek is implemented, performs the seek and returns
- * %TRUE.
- *
- * When the element does not meet the requirements to operate in pull mode, the
- * offset and length in the #GstBaseSrcClass::create method should be ignored.
- * It is recommended to subclass #GstPushSrc instead, in this situation. If the
- * element can operate in pull mode but only with specific offsets and
- * lengths, it is allowed to generate an error when the wrong values are passed
- * to the #GstBaseSrcClass::create function.
- *
- * #GstBaseSrc has support for live sources. Live sources are sources that when
- * paused discard data, such as audio or video capture devices. A typical live
- * source also produces data at a fixed rate and thus provides a clock to publish
- * this rate.
- * Use gst_base_src_set_live() to activate the live source mode.
- *
- * A live source does not produce data in the PAUSED state. This means that the
- * #GstBaseSrcClass::create method will not be called in PAUSED but only in
- * PLAYING. To signal the pipeline that the element will not produce data, the
- * return value from the READY to PAUSED state will be
- * %GST_STATE_CHANGE_NO_PREROLL.
- *
- * A typical live source will timestamp the buffers it creates with the
- * current running time of the pipeline. This is one reason why a live source
- * can only produce data in the PLAYING state, when the clock is actually
- * distributed and running.
- *
- * Live sources that synchronize and block on the clock (an audio source, for
- * example) can use gst_base_src_wait_playing() when the
- * #GstBaseSrcClass::create function was interrupted by a state change to
- * PAUSED.
- *
- * The #GstBaseSrcClass::get_times method can be used to implement pseudo-live
- * sources. It only makes sense to implement the #GstBaseSrcClass::get_times
- * function if the source is a live source. The #GstBaseSrcClass::get_times
- * function should return timestamps starting from 0, as if it were a non-live
- * source. The base class will make sure that the timestamps are transformed
- * into the current running_time. The base source will then wait for the
- * calculated running_time before pushing out the buffer.
- *
- * For live sources, the base class will by default report a latency of 0.
- * For pseudo live sources, the base class will by default measure the difference
- * between the first buffer timestamp and the start time of get_times and will
- * report this value as the latency.
- * Subclasses should override the query function when this behaviour is not
- * acceptable.
- *
- * There is only support in #GstBaseSrc for exactly one source pad, which
- * should be named "src". A source implementation (subclass of #GstBaseSrc)
- * should install a pad template in its class_init function, like so:
- * |[<!-- language="C" -->
- * static void
- * my_element_class_init (GstMyElementClass *klass)
- * {
- * GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
- * // srctemplate should be a #GstStaticPadTemplate with direction
- * // %GST_PAD_SRC and name "src"
- * gst_element_class_add_static_pad_template (gstelement_class, &srctemplate);
- *
- * gst_element_class_set_static_metadata (gstelement_class,
- * "Source name",
- * "Source",
- * "My Source element",
- * "The author <my.sink`my`.email>");
- * }
- * ]|
- *
- * ## Controlled shutdown of live sources in applications
- *
- * Applications that record from a live source may want to stop recording
- * in a controlled way, so that the recording is stopped, but the data
- * already in the pipeline is processed to the end (remember that many live
- * sources would go on recording forever otherwise). For that to happen the
- * application needs to make the source stop recording and send an EOS
- * event down the pipeline. The application would then wait for an
- * EOS message posted on the pipeline's bus to know when all data has
- * been processed and the pipeline can safely be stopped.
- *
- * An application may send an EOS event to a source element to make it
- * perform the EOS logic (send EOS event downstream or post a
- * %GST_MESSAGE_SEGMENT_DONE on the bus). This can typically be done
- * with the gst_element_send_event() function on the element or its parent bin.
- *
- * After the EOS has been sent to the element, the application should wait for
- * an EOS message to be posted on the pipeline's bus. Once this EOS message is
- * received, it may safely shut down the entire pipeline.
- */
 export declare class BaseSrc extends Gst.Element {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

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

@@ -1,6 +1,7 @@
 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 is a generic base class for source elements. The following
@@ -116,6 +117,12 @@ import * as Gst from "../gst/index.js";
  * an EOS message to be posted on the pipeline's bus. Once this EOS message is
  * received, it may safely shut down the entire pipeline.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class BaseSrc extends Gst.Element {
     static glibTypeName = "GstBaseSrc";
     static objectType = "gobject";
@@ -613,12 +620,26 @@ export class BaseSrc extends Gst.Element {
         ], { type: "int", size: 32, unsigned: false });
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
-            return handler(self, ...args.slice(1));
+            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 },