@gtkx/ffi 0.10.5 → 0.11.1

package/dist/generated/gst/event.d.ts

@@ -37,21 +37,21 @@ import { StreamCollection } from "./stream-collection.js";
  * To do that gst_event_new_seek() is used to create a seek event. It takes
  * the needed parameters to specify seeking time and mode.
  * |[<!-- language="C" -->
- * GstEvent *event;
- * gboolean result;
- * ...
- * // construct a seek event to play the media from second 2 to 5, flush
- * // the pipeline to decrease latency.
- * event = gst_event_new_seek (1.0,
- * GST_FORMAT_TIME,
- * GST_SEEK_FLAG_FLUSH,
- * GST_SEEK_TYPE_SET, 2 * GST_SECOND,
- * GST_SEEK_TYPE_SET, 5 * GST_SECOND);
- * ...
- * result = gst_element_send_event (pipeline, event);
- * if (!result)
- * g_warning ("seek failed");
- * ...
+ *   GstEvent *event;
+ *   gboolean result;
+ *   ...
+ *   // construct a seek event to play the media from second 2 to 5, flush
+ *   // the pipeline to decrease latency.
+ *   event = gst_event_new_seek (1.0,
+ *      GST_FORMAT_TIME,
+ *      GST_SEEK_FLAG_FLUSH,
+ *      GST_SEEK_TYPE_SET, 2 * GST_SECOND,
+ *      GST_SEEK_TYPE_SET, 5 * GST_SECOND);
+ *   ...
+ *   result = gst_element_send_event (pipeline, event);
+ *   if (!result)
+ *     g_warning ("seek failed");
+ *   ...
  * ]|
  */
 export declare class Event extends NativeObject {
@@ -62,18 +62,12 @@ export declare class Event extends NativeObject {
      * elements that they should provide a buffer of the specified dimensions.
      *
      * When the `async` flag is set, a thread boundary is preferred.
-     * @param format - buffer format
-     * @param minsize - minimum buffer size
-     * @param maxsize - maximum buffer size
-     * @param _async - thread behavior
      */
-    constructor(format: Format, minsize: number, maxsize: number, _async: boolean);
-    constructor(_args: unknown[]);
+    constructor(format: Format, minsize: number, maxsize: number, async_: boolean);
     /**
      * Create a new CAPS event for `caps`. The caps event can only travel downstream
      * synchronized with the buffer flow and contains the format of the buffers
      * that will follow after the event.
-     * @param caps - a #GstCaps
      */
     static newCaps(caps: Caps): Event;
     /**
@@ -87,8 +81,6 @@ export declare class Event extends NativeObject {
      *
      * New custom events can also be created by subclassing the event type if
      * needed.
-     * @param type - The type of the new event
-     * @param structure - the structure for the event. The event will
      */
     static newCustom(type: EventType, structure: Structure): Event;
     /**
@@ -135,7 +127,6 @@ export declare class Event extends NativeObject {
      *
      * This event is typically generated to complete a seek and to resume
      * dataflow.
-     * @param resetTime - if time should be reset
      */
     static newFlushStop(resetTime: boolean): Event;
     /**
@@ -144,8 +135,6 @@ export declare class Event extends NativeObject {
      * amount of time. This is useful to signal a gap to downstream elements
      * which may wait for data, such as muxers or mixers or overlays, especially
      * for sparse streams such as subtitle streams.
-     * @param timestamp - the start time (pts) of the gap
-     * @param duration - the duration of the gap
      */
     static newGap(timestamp: number, duration: number): Event;
     /**
@@ -158,8 +147,6 @@ export declare class Event extends NativeObject {
      * The flags provided replace any flags in the existing segment, for the
      * flags within the %GST_SEGMENT_INSTANT_FLAGS set. Other GstSegmentFlags
      * are ignored and not transferred in the event.
-     * @param rateMultiplier - the multiplier to be applied to the playback rate
-     * @param newFlags - A new subset of segment flags to replace in segments
      */
     static newInstantRateChange(rateMultiplier: number, newFlags: SegmentFlags): Event;
     /**
@@ -175,9 +162,6 @@ export declare class Event extends NativeObject {
      * is the first instant-rate adjustment, but will differ for later ones
      * to compensate for the accumulated offset due to playing at a rate
      * different to the one indicated in the playback segments.
-     * @param rateMultiplier - the new playback rate multiplier to be applied
-     * @param runningTime - Running time when the rate change should be applied
-     * @param upstreamRunningTime - The upstream-centric running-time when the
      */
     static newInstantRateSyncTime(rateMultiplier: number, runningTime: number, upstreamRunningTime: number): Event;
     /**
@@ -187,13 +171,9 @@ export declare class Event extends NativeObject {
      *
      * The latency is mostly used in live sinks and is always expressed in
      * the time format.
-     * @param latency - the new latency value
      */
     static newLatency(latency: number): Event;
-    /**
-     * Create a new navigation event from the given description.
-     * @param structure - description of the event. The event will take
-     */
+    /** Create a new navigation event from the given description. */
     static newNavigation(structure: Structure): Event;
     /**
      * Creates a new event containing information specific to a particular
@@ -225,9 +205,6 @@ export declare class Event extends NativeObject {
      * in such a way as to ensure that the most recently-pushed protection info
      * event of a particular `origin` and `system_id` will
      * be stuck to the output pad of the sending element.
-     * @param systemId - a string holding a UUID that uniquely
-     * @param data - a #GstBuffer holding protection system specific
-     * @param origin - a string indicating where the protection
      */
     static newProtection(systemId: string, data: Buffer, origin: string): Event;
     /**
@@ -273,10 +250,6 @@ export declare class Event extends NativeObject {
      *
      * The application can use general event probes to intercept the QoS
      * event and implement custom application specific QoS handling.
-     * @param type - the QoS type
-     * @param proportion - the proportion of the qos message
-     * @param diff - The time difference of the last Clock sync
-     * @param timestamp - The timestamp of the buffer
      */
     static newQos(type: QOSType, proportion: number, diff: number, timestamp: number): Event;
     /**
@@ -318,13 +291,6 @@ export declare class Event extends NativeObject {
      * this, PAUSE the pipeline, query the current playback position with
      * #GST_QUERY_POSITION and update the playback segment current position with a
      * #GST_SEEK_TYPE_SET to the desired position.
-     * @param rate - The new playback rate
-     * @param format - The format of the seek values
-     * @param flags - The optional seek flags
-     * @param startType - The type and flags for the new start position
-     * @param start - The value of the new start position
-     * @param stopType - The type and flags for the new stop position
-     * @param stop - The value of the new stop position
      */
     static newSeek(rate: number, format: Format, flags: SeekFlags, startType: SeekType, start: number, stopType: SeekType, stop: number): Event;
     /**
@@ -358,15 +324,12 @@ export declare class Event extends NativeObject {
      *
      * After a segment event, the buffer stream time is calculated with:
      *
-     * time + (TIMESTAMP(buf) - start) * ABS (rate * applied_rate)
-     * @param segment - a #GstSegment
+     *   time + (TIMESTAMP(buf) - start) * ABS (rate * applied_rate)
      */
     static newSegment(segment: Segment): Event;
     /**
      * Create a new segment-done event. This event is sent by elements that
      * finish playback of a segment as a result of a segment seek.
-     * @param format - The format of the position being done
-     * @param position - The position of the segment being done
      */
     static newSegmentDone(format: Format, position: number): Event;
     /**
@@ -380,7 +343,6 @@ export declare class Event extends NativeObject {
      * #GST_MESSAGE_STREAM_COLLECTION.
      *
      * Note: The list of `streams` can not be empty.
-     * @param streams - the list of streams to
      */
     static newSelectStreams(streams: string[]): Event;
     /**
@@ -389,8 +351,6 @@ export declare class Event extends NativeObject {
      * with the stream.
      *
      * `name` is used to store multiple sticky events on one pad.
-     * @param name - a name for the event
-     * @param msg - the #GstMessage to be posted
      */
     static newSinkMessage(name: string, msg: Message): Event;
     /**
@@ -407,11 +367,6 @@ export declare class Event extends NativeObject {
      *
      * The `intermediate` flag instructs the pipeline that this step operation is
      * part of a larger step operation.
-     * @param format - the format of `amount`
-     * @param amount - the amount of data to step
-     * @param rate - the step rate
-     * @param flush - flushing steps
-     * @param intermediate - intermediate steps
      */
     static newStep(format: Format, amount: number, rate: number, flush: boolean, intermediate: boolean): Event;
     /**
@@ -423,7 +378,6 @@ export declare class Event extends NativeObject {
      * this event downstream on each pad involved in the collection, so that
      * activation of a new collection can be tracked through the downstream
      * data flow.
-     * @param collection - Active collection for this data flow
      */
     static newStreamCollection(collection: StreamCollection): Event;
     /**
@@ -436,7 +390,6 @@ export declare class Event extends NativeObject {
      * This event is followed by EOS at some point in the future, and is
      * generally used when switching pads - to unblock downstream so that
      * new pads can be exposed before sending EOS on the existing pads.
-     * @param groupId - the group id of the stream group which is ending
      */
     static newStreamGroupDone(groupId: number): Event;
     /**
@@ -461,7 +414,6 @@ export declare class Event extends NativeObject {
      * stream-id, though it should be deterministic (to support stream matching)
      * and it might be used to order streams (besides any information conveyed by
      * stream flags).
-     * @param streamId - Identifier for this stream
      */
     static newStreamStart(streamId: string): Event;
     /**
@@ -472,29 +424,22 @@ export declare class Event extends NativeObject {
      * is a sticky event, elements should merge tags received from
      * upstream with a given scope with their own tags with the same
      * scope and create a new tag event from it.
-     * @param taglist - metadata list. The event will take ownership
      */
     static newTag(taglist: TagList): Event;
     /**
      * Generate a TOC event from the given `toc`. The purpose of the TOC event is to
      * inform elements that some kind of the TOC was found.
-     * @param toc - #GstToc structure.
-     * @param updated - whether `toc` was updated or not.
      */
     static newToc(toc: Toc, updated: boolean): Event;
     /**
      * Generate a TOC select event with the given `uid`. The purpose of the
      * TOC select event is to start playback based on the TOC's entry with the
      * given `uid`.
-     * @param uid - UID in the TOC to start playback from.
      */
     static newTocSelect(uid: string): Event;
-    protected createPtr(_args: unknown[]): unknown;
-    static fromPtr(ptr: unknown): Event;
     /**
      * Parses a segment `event` and copies the #GstSegment into the location
      * given by `segment`.
-     * @param segment - a pointer to a #GstSegment
      */
     copySegment(segment: Segment): void;
     /**
@@ -524,195 +469,106 @@ export declare class Event extends NativeObject {
      * that correspondence was made explicitly.
      */
     getSeqnum(): number;
-    /**
-     * Access the structure of the event.
-     */
+    /** Access the structure of the event. */
     getStructure(): Structure | null;
     /**
      * Checks if `event` has the given `name`. This function is usually used to
      * check the name of a custom event.
-     * @param name - name to check
      */
     hasName(name: string): boolean;
     /**
      * Checks if `event` has the given `name`. This function is usually used to
      * check the name of a custom event.
-     * @param name - name to check as a GQuark
      */
     hasNameId(name: number): boolean;
-    /**
-     * Get the format, minsize, maxsize and async-flag in the buffersize event.
-     * @param format - A pointer to store the format in
-     * @param minsize - A pointer to store the minsize in
-     * @param maxsize - A pointer to store the maxsize in
-     * @param _async - A pointer to store the async-flag in
-     */
-    parseBufferSize(format?: Ref<Format>, minsize?: Ref<number>, maxsize?: Ref<number>, _async?: Ref<boolean>): void;
+    /** Get the format, minsize, maxsize and async-flag in the buffersize event. */
+    parseBufferSize(format?: Ref<Format> | null, minsize?: Ref<number> | null, maxsize?: Ref<number> | null, async_?: Ref<boolean> | null): void;
     /**
      * Get the caps from `event`. The caps remains valid as long as `event` remains
      * valid.
-     * @param caps - A pointer to the caps
      */
-    parseCaps(caps?: Ref<Caps>): void;
-    /**
-     * Parse the FLUSH_STOP event and retrieve the `reset_time` member.
-     * @param resetTime - if time should be reset
-     */
-    parseFlushStop(resetTime?: Ref<boolean>): void;
-    /**
-     * Extract timestamp and duration from a new GAP event.
-     * @param timestamp - location where to store the
-     * @param duration - location where to store the duration of
-     */
-    parseGap(timestamp?: Ref<number>, duration?: Ref<number>): void;
+    parseCaps(caps?: Ref<Caps> | null): void;
+    /** Parse the FLUSH_STOP event and retrieve the `reset_time` member. */
+    parseFlushStop(resetTime?: Ref<boolean> | null): void;
+    /** Extract timestamp and duration from a new GAP event. */
+    parseGap(timestamp?: Ref<number> | null, duration?: Ref<number> | null): void;
     /**
      * Retrieve the gap flags that may have been set on a gap event with
      * gst_event_set_gap_flags().
-     * @param flags - a #GstGapFlags or %NULL
-     */
-    parseGapFlags(flags?: Ref<GapFlags>): void;
-    /**
-     * @param groupId - address of variable where to store the group id
-     */
-    parseGroupId(groupId?: Ref<number>): boolean;
-    /**
-     * Extract rate and flags from an instant-rate-change event.
-     * @param rateMultiplier - location in which to store the rate
-     * @param newFlags - location in which to store the new
      */
-    parseInstantRateChange(rateMultiplier?: Ref<number>, newFlags?: Ref<SegmentFlags>): void;
-    /**
-     * Extract the rate multiplier and running times from an instant-rate-sync-time event.
-     * @param rateMultiplier - location where to store the rate of
-     * @param runningTime - location in which to store the running time
-     * @param upstreamRunningTime - location in which to store the
-     */
-    parseInstantRateSyncTime(rateMultiplier?: Ref<number>, runningTime?: Ref<number>, upstreamRunningTime?: Ref<number>): void;
-    /**
-     * Get the latency in the latency event.
-     * @param latency - A pointer to store the latency in.
-     */
-    parseLatency(latency?: Ref<number>): void;
+    parseGapFlags(flags?: Ref<GapFlags> | null): void;
+    parseGroupId(groupId?: Ref<number> | null): boolean;
+    /** Extract rate and flags from an instant-rate-change event. */
+    parseInstantRateChange(rateMultiplier?: Ref<number> | null, newFlags?: Ref<SegmentFlags> | null): void;
+    /** Extract the rate multiplier and running times from an instant-rate-sync-time event. */
+    parseInstantRateSyncTime(rateMultiplier?: Ref<number> | null, runningTime?: Ref<number> | null, upstreamRunningTime?: Ref<number> | null): void;
+    /** Get the latency in the latency event. */
+    parseLatency(latency?: Ref<number> | null): void;
     /**
      * Parses an event containing protection system specific information and stores
      * the results in `system_id`, `data` and `origin`. The data stored in `system_id`,
      * `origin` and `data` are valid until `event` is released.
-     * @param systemId - pointer to store the UUID
-     * @param data - pointer to store a #GstBuffer
-     * @param origin - pointer to store a value that
      */
-    parseProtection(systemId?: Ref<string>, data?: Ref<Buffer>, origin?: Ref<string>): void;
+    parseProtection(systemId?: Ref<string> | null, data?: Ref<Buffer> | null, origin?: Ref<string> | null): void;
     /**
      * Get the type, proportion, diff and timestamp in the qos event. See
      * gst_event_new_qos() for more information about the different QoS values.
      *
      * `timestamp` will be adjusted for any pad offsets of pads it was passing through.
-     * @param type - A pointer to store the QoS type in
-     * @param proportion - A pointer to store the proportion in
-     * @param diff - A pointer to store the diff in
-     * @param timestamp - A pointer to store the timestamp in
-     */
-    parseQos(type?: Ref<QOSType>, proportion?: Ref<number>, diff?: Ref<number>, timestamp?: Ref<number>): void;
-    /**
-     * Parses a seek `event` and stores the results in the given result locations.
-     * @param rate - result location for the rate
-     * @param format - result location for the stream format
-     * @param flags - result location for the #GstSeekFlags
-     * @param startType - result location for the #GstSeekType of the start position
-     * @param start - result location for the start position expressed in `format`
-     * @param stopType - result location for the #GstSeekType of the stop position
-     * @param stop - result location for the stop position expressed in `format`
      */
-    parseSeek(rate?: Ref<number>, format?: Ref<Format>, flags?: Ref<SeekFlags>, startType?: Ref<SeekType>, start?: Ref<number>, stopType?: Ref<SeekType>, stop?: Ref<number>): void;
+    parseQos(type?: Ref<QOSType> | null, proportion?: Ref<number> | null, diff?: Ref<number> | null, timestamp?: Ref<number> | null): void;
+    /** Parses a seek `event` and stores the results in the given result locations. */
+    parseSeek(rate?: Ref<number> | null, format?: Ref<Format> | null, flags?: Ref<SeekFlags> | null, startType?: Ref<SeekType> | null, start?: Ref<number> | null, stopType?: Ref<SeekType> | null, stop?: Ref<number> | null): void;
     /**
      * Retrieve the trickmode interval that may have been set on a
      * seek event with gst_event_set_seek_trickmode_interval().
-     * @param interval - interval
      */
-    parseSeekTrickmodeInterval(interval?: Ref<number>): void;
+    parseSeekTrickmodeInterval(interval?: Ref<number> | null): void;
     /**
      * Parses a segment `event` and stores the result in the given `segment` location.
      * `segment` remains valid only until the `event` is freed. Don't modify the segment
      * and make a copy if you want to modify it or store it for later use.
-     * @param segment - a pointer to a #GstSegment
-     */
-    parseSegment(segment?: Ref<Segment>): void;
-    /**
-     * Extracts the position and format from the segment done message.
-     * @param format - Result location for the format, or %NULL
-     * @param position - Result location for the position, or %NULL
      */
-    parseSegmentDone(format?: Ref<Format>, position?: Ref<number>): void;
-    /**
-     * Parse the SELECT_STREAMS event and retrieve the contained streams.
-     * @param streams - the streams
-     */
-    parseSelectStreams(streams?: Ref<string[]>): void;
-    /**
-     * Parse the sink-message event. Unref `msg` after usage.
-     * @param msg - a pointer to store the #GstMessage in.
-     */
-    parseSinkMessage(msg?: Ref<Message>): void;
-    /**
-     * Parse the step event.
-     * @param format - a pointer to store the format in
-     * @param amount - a pointer to store the amount in
-     * @param rate - a pointer to store the rate in
-     * @param flush - a pointer to store the flush boolean in
-     * @param intermediate - a pointer to store the intermediate
-     */
-    parseStep(format?: Ref<Format>, amount?: Ref<number>, rate?: Ref<number>, flush?: Ref<boolean>, intermediate?: Ref<boolean>): void;
-    /**
-     * Parse a stream-start `event` and extract the #GstStream from it.
-     * @param stream - address of variable to store the stream
-     */
-    parseStream(stream?: Ref<Stream>): void;
-    /**
-     * Retrieve new #GstStreamCollection from STREAM_COLLECTION event `event`.
-     * @param collection - pointer to store the collection.
-     */
-    parseStreamCollection(collection?: Ref<StreamCollection>): void;
-    /**
-     * @param flags - address of variable where to store the stream flags
-     */
-    parseStreamFlags(flags?: Ref<StreamFlags>): void;
+    parseSegment(segment?: Ref<Segment> | null): void;
+    /** Extracts the position and format from the segment done message. */
+    parseSegmentDone(format?: Ref<Format> | null, position?: Ref<number> | null): void;
+    /** Parse the SELECT_STREAMS event and retrieve the contained streams. */
+    parseSelectStreams(streams?: Ref<string[]> | null): void;
+    /** Parse the sink-message event. Unref `msg` after usage. */
+    parseSinkMessage(msg?: Ref<Message> | null): void;
+    /** Parse the step event. */
+    parseStep(format?: Ref<Format> | null, amount?: Ref<number> | null, rate?: Ref<number> | null, flush?: Ref<boolean> | null, intermediate?: Ref<boolean> | null): void;
+    /** Parse a stream-start `event` and extract the #GstStream from it. */
+    parseStream(stream?: Ref<Stream> | null): void;
+    /** Retrieve new #GstStreamCollection from STREAM_COLLECTION event `event`. */
+    parseStreamCollection(collection?: Ref<StreamCollection> | null): void;
+    parseStreamFlags(flags?: Ref<StreamFlags> | null): void;
     /**
      * Parse a stream-group-done `event` and store the result in the given
      * `group_id` location.
-     * @param groupId - address of variable to store the group id into
      */
-    parseStreamGroupDone(groupId?: Ref<number>): void;
+    parseStreamGroupDone(groupId?: Ref<number> | null): void;
     /**
      * Parse a stream-id `event` and store the result in the given `stream_id`
      * location. The string stored in `stream_id` must not be modified and will
      * remain valid only until `event` gets freed. Make a copy if you want to
      * modify it or store it for later use.
-     * @param streamId - pointer to store the stream-id
      */
-    parseStreamStart(streamId?: Ref<string>): void;
+    parseStreamStart(streamId?: Ref<string> | null): void;
     /**
      * Parses a tag `event` and stores the results in the given `taglist` location.
      * No reference to the taglist will be returned, it remains valid only until
      * the `event` is freed. Don't modify or free the taglist, make a copy if you
      * want to modify it or store it for later use.
-     * @param taglist - pointer to metadata list
-     */
-    parseTag(taglist?: Ref<TagList>): void;
-    /**
-     * Parse a TOC `event` and store the results in the given `toc` and `updated` locations.
-     * @param toc - pointer to #GstToc structure.
-     * @param updated - pointer to store TOC updated flag.
      */
-    parseToc(toc?: Ref<Toc>, updated?: Ref<boolean>): void;
-    /**
-     * Parse a TOC select `event` and store the results in the given `uid` location.
-     * @param uid - storage for the selection UID.
-     */
-    parseTocSelect(uid?: Ref<string>): void;
+    parseTag(taglist?: Ref<TagList> | null): void;
+    /** Parse a TOC `event` and store the results in the given `toc` and `updated` locations. */
+    parseToc(toc?: Ref<Toc> | null, updated?: Ref<boolean> | null): void;
+    /** Parse a TOC select `event` and store the results in the given `uid` location. */
+    parseTocSelect(uid?: Ref<string> | null): void;
     /**
      * Sets `flags` on `event` to give additional information about the reason for
      * the #GST_EVENT_GAP.
-     * @param flags - a #GstGapFlags
      */
     setGapFlags(flags: GapFlags): void;
     /**
@@ -723,7 +579,6 @@ export declare class Event extends NativeObject {
      * each time a file is played for example.
      *
      * Use gst_util_group_id_next() to get a new group id.
-     * @param groupId - the group id to set
      */
     setGroupId(groupId: number): void;
     /**
@@ -731,7 +586,6 @@ export declare class Event extends NativeObject {
      * gst_event_get_running_time_offset() for more information.
      *
      * MT safe.
-     * @param offset - A the new running time offset
      */
     setRunningTimeOffset(offset: number): void;
     /**
@@ -748,21 +602,12 @@ export declare class Event extends NativeObject {
      * more information.
      *
      * MT safe.
-     * @param seqnum - A sequence number.
      */
     setSeqnum(seqnum: number): void;
-    /**
-     * Set the `stream` on the stream-start `event`
-     * @param stream - the stream object to set
-     */
+    /** Set the `stream` on the stream-start `event` */
     setStream(stream: Stream): void;
-    /**
-     * @param flags - the stream flags to set
-     */
     setStreamFlags(flags: StreamFlags): void;
-    /**
-     * Get a writable version of the structure.
-     */
+    /** Get a writable version of the structure. */
     writableStructure(): Structure;
     /** the parent structure */
     get miniObject(): MiniObject;