GstPad

Gst.Pad

GObject.Object
    ╰──GObject.InitiallyUnowned
        ╰──Gst.Object
            ╰──Gst.Pad
                ╰──Gst.ProxyPad

Gst.Pad.prototype.new

function Gst.Pad.prototype.new(name: String, direction: Gst.PadDirection): {
    // javascript wrapper for 'gst_pad_new'
}

Creates a new pad with the given name in the given direction. If name is null, a guaranteed unique name (across all pads) will be assigned. This function makes a copy of the name so you can safely free the name.

Gst.Pad.prototype.new_from_static_template

function Gst.Pad.prototype.new_from_static_template(templ: Gst.StaticPadTemplate, name: String): {
    // javascript wrapper for 'gst_pad_new_from_static_template'
}

Creates a new pad with the given name from the given static template. If name is null, a guaranteed unique name (across all pads) will be assigned. This function makes a copy of the name so you can safely free the name.

Gst.Pad.prototype.new_from_template

function Gst.Pad.prototype.new_from_template(templ: Gst.PadTemplate, name: String): {
    // javascript wrapper for 'gst_pad_new_from_template'
}

Creates a new pad with the given name from the given template. If name is null, a guaranteed unique name (across all pads) will be assigned. This function makes a copy of the name so you can safely free the name.

Gst.Pad.prototype.activate_mode

function Gst.Pad.prototype.activate_mode(mode: Gst.PadMode, active: Number): {
    // javascript wrapper for 'gst_pad_activate_mode'
}

Activates or deactivates the given pad in mode via dispatching to the pad's activatemodefunc. For use from within pad activation functions only.

If you don't know what this is, you probably don't want to call it.

Gst.Pad.prototype.add_probe

function Gst.Pad.prototype.add_probe(mask: Gst.PadProbeType, callback: Gst.PadProbeCallback, user_data: Object): {
    // javascript wrapper for 'gst_pad_add_probe'
}

Be notified of different states of pads. The provided callback is called for every state that matches mask.

Probes are called in groups: First GST_PAD_PROBE_TYPE_BLOCK probes are called, then others, then finally GST_PAD_PROBE_TYPE_IDLE. The only exception here are GST_PAD_PROBE_TYPE_IDLE probes that are called immediately if the pad is already idle while calling Gst.Pad.prototype.add_probe. In each of the groups, probes are called in the order in which they were added.

Gst.Pad.prototype.can_link

function Gst.Pad.prototype.can_link(sinkpad: Gst.Pad): {
    // javascript wrapper for 'gst_pad_can_link'
}

Checks if the source pad and the sink pad are compatible so they can be linked.

Gst.Pad.prototype.chain

function Gst.Pad.prototype.chain(buffer: Gst.Buffer): {
    // javascript wrapper for 'gst_pad_chain'
}

Chain a buffer to pad.

The function returns Gst.FlowReturn.FLUSHING if the pad was flushing.

If the buffer type is not acceptable for pad (as negotiated with a preceding GST_EVENT_CAPS event), this function returns Gst.FlowReturn.NOT_NEGOTIATED.

The function proceeds calling the chain function installed on pad (see gst_pad_set_chain_function (not introspectable)) and the return value of that function is returned to the caller. Gst.FlowReturn.NOT_SUPPORTED is returned if pad has no chain function.

In all cases, success or failure, the caller loses its reference to buffer after calling this function.

Gst.Pad.prototype.chain_list

function Gst.Pad.prototype.chain_list(list: Gst.BufferList): {
    // javascript wrapper for 'gst_pad_chain_list'
}

Chain a bufferlist to pad.

The function returns Gst.FlowReturn.FLUSHING if the pad was flushing.

If pad was not negotiated properly with a CAPS event, this function returns Gst.FlowReturn.NOT_NEGOTIATED.

The function proceeds calling the chainlist function installed on pad (see gst_pad_set_chain_list_function (not introspectable)) and the return value of that function is returned to the caller. Gst.FlowReturn.NOT_SUPPORTED is returned if pad has no chainlist function.

In all cases, success or failure, the caller loses its reference to list after calling this function.

MT safe.

Gst.Pad.prototype.check_reconfigure

function Gst.Pad.prototype.check_reconfigure(): {
    // javascript wrapper for 'gst_pad_check_reconfigure'
}

Check and clear the Gst.PadFlags.NEED_RECONFIGURE flag on pad and return true if the flag was set.

Gst.Pad.prototype.create_stream_id

function Gst.Pad.prototype.create_stream_id(parent: Gst.Element, stream_id: String): {
    // javascript wrapper for 'gst_pad_create_stream_id'
}

Creates a stream-id for the source Gst.Pad pad by combining the upstream information with the optional stream_id of the stream of pad. pad must have a parent Gst.Element and which must have zero or one sinkpad. stream_id can only be null if the parent element of pad has only a single source pad.

This function generates an unique stream-id by getting the upstream stream-start event stream ID and appending stream_id to it. If the element has no sinkpad it will generate an upstream stream-id by doing an URI query on the element and in the worst case just uses a random number. Source elements that don't implement the URI handler interface should ideally generate a unique, deterministic stream-id manually instead.

Since stream IDs are sorted alphabetically, any numbers in the stream ID should be printed with a fixed number of characters, preceded by 0's, such as by using the format %03u instead of %u.

Gst.Pad.prototype.event_default

function Gst.Pad.prototype.event_default(parent: Gst.Object, event: Gst.Event): {
    // javascript wrapper for 'gst_pad_event_default'
}

Invokes the default event handler for the given pad.

The EOS event will pause the task associated with pad before it is forwarded to all internally linked pads,

The event is sent to all pads internally linked to pad. This function takes ownership of event.

Gst.Pad.prototype.forward

function Gst.Pad.prototype.forward(forward: Gst.PadForwardFunction, user_data: Object): {
    // javascript wrapper for 'gst_pad_forward'
}

Calls forward for all internally linked pads of pad. This function deals with dynamically changing internal pads and will make sure that the forward function is only called once for each pad.

When forward returns true, no further pads will be processed.

Gst.Pad.prototype.get_allowed_caps

function Gst.Pad.prototype.get_allowed_caps(): {
    // javascript wrapper for 'gst_pad_get_allowed_caps'
}

Gets the capabilities of the allowed media types that can flow through pad and its peer.

The allowed capabilities is calculated as the intersection of the results of calling Gst.Pad.prototype.query_caps on pad and its peer. The caller owns a reference on the resulting caps.

Gst.Pad.prototype.get_current_caps

function Gst.Pad.prototype.get_current_caps(): {
    // javascript wrapper for 'gst_pad_get_current_caps'
}

Gets the capabilities currently configured on pad with the last Gst.EventType.CAPS event.

Gst.Pad.prototype.get_direction

function Gst.Pad.prototype.get_direction(): {
    // javascript wrapper for 'gst_pad_get_direction'
}

Gets the direction of the pad. The direction of the pad is decided at construction time so this function does not take the LOCK.

Gst.Pad.prototype.get_element_private

function Gst.Pad.prototype.get_element_private(): {
    // javascript wrapper for 'gst_pad_get_element_private'
}

Gets the private data of a pad. No locking is performed in this function.

Gst.Pad.prototype.get_last_flow_return

function Gst.Pad.prototype.get_last_flow_return(): {
    // javascript wrapper for 'gst_pad_get_last_flow_return'
}

Gets the Gst.FlowReturn return from the last data passed by this pad.

Since : 1.4

Gst.Pad.prototype.get_offset

function Gst.Pad.prototype.get_offset(): {
    // javascript wrapper for 'gst_pad_get_offset'
}

Get the offset applied to the running time of pad. pad has to be a source pad.

Gst.Pad.prototype.get_pad_template

function Gst.Pad.prototype.get_pad_template(): {
    // javascript wrapper for 'gst_pad_get_pad_template'
}

Gets the template for pad.

Gst.Pad.prototype.get_pad_template_caps

function Gst.Pad.prototype.get_pad_template_caps(): {
    // javascript wrapper for 'gst_pad_get_pad_template_caps'
}

Gets the capabilities for pad's template.

Gst.Pad.prototype.get_parent_element

function Gst.Pad.prototype.get_parent_element(): {
    // javascript wrapper for 'gst_pad_get_parent_element'
}

Gets the parent of pad, cast to a Gst.Element. If a pad has no parent or its parent is not an element, return null.

Gst.Pad.prototype.get_peer

function Gst.Pad.prototype.get_peer(): {
    // javascript wrapper for 'gst_pad_get_peer'
}

Gets the peer of pad. This function refs the peer pad so you need to unref it after use.

Gst.Pad.prototype.get_range

function Gst.Pad.prototype.get_range(offset: Number, size: Number): {
    // javascript wrapper for 'gst_pad_get_range'
}

When pad is flushing this function returns Gst.FlowReturn.FLUSHING immediately and buffer is null.

Calls the getrange function of pad, see Gst.PadGetRangeFunction for a description of a getrange function. If pad has no getrange function installed (see gst_pad_set_getrange_function (not introspectable)) this function returns Gst.FlowReturn.NOT_SUPPORTED.

If buffer points to a variable holding null, a valid new Gst.Buffer will be placed in buffer when this function returns Gst.FlowReturn.OK. The new buffer must be freed with gst_buffer_unref (not introspectable) after usage.

When buffer points to a variable that points to a valid Gst.Buffer, the buffer will be filled with the result data when this function returns Gst.FlowReturn.OK. If the provided buffer is larger than size, only size bytes will be filled in the result buffer and its size will be updated accordingly.

Note that less than size bytes can be returned in buffer when, for example, an EOS condition is near or when buffer is not large enough to hold size bytes. The caller should check the result buffer size to get the result size.

When this function returns any other result value than Gst.FlowReturn.OK, buffer will be unchanged.

This is a lowlevel function. Usually Gst.Pad.prototype.pull_range is used.

Gst.Pad.prototype.get_single_internal_link

function Gst.Pad.prototype.get_single_internal_link(): {
    // javascript wrapper for 'gst_pad_get_single_internal_link'
}

If there is a single internal link of the given pad, this function will return it. Otherwise, it will return NULL.

Since : 1.18

Gst.Pad.prototype.get_sticky_event

function Gst.Pad.prototype.get_sticky_event(event_type: Gst.EventType, idx: Number): {
    // javascript wrapper for 'gst_pad_get_sticky_event'
}

Returns a new reference of the sticky event of type event_type from the event.

Gst.Pad.prototype.get_stream

function Gst.Pad.prototype.get_stream(): {
    // javascript wrapper for 'gst_pad_get_stream'
}

Returns the current Gst.Stream for the pad, or null if none has been set yet, i.e. the pad has not received a stream-start event yet.

This is a convenience wrapper around Gst.Pad.prototype.get_sticky_event and Gst.Event.prototype.parse_stream.

Since : 1.10

Gst.Pad.prototype.get_stream_id

function Gst.Pad.prototype.get_stream_id(): {
    // javascript wrapper for 'gst_pad_get_stream_id'
}

Returns the current stream-id for the pad, or null if none has been set yet, i.e. the pad has not received a stream-start event yet.

This is a convenience wrapper around Gst.Pad.prototype.get_sticky_event and Gst.Event.prototype.parse_stream_start.

The returned stream-id string should be treated as an opaque string, its contents should not be interpreted.

Since : 1.2

Gst.Pad.prototype.get_task_state

function Gst.Pad.prototype.get_task_state(): {
    // javascript wrapper for 'gst_pad_get_task_state'
}

Get pad task state. If no task is currently set, Gst.TaskState.STOPPED is returned.

Since : 1.12

Gst.Pad.prototype.has_current_caps

function Gst.Pad.prototype.has_current_caps(): {
    // javascript wrapper for 'gst_pad_has_current_caps'
}

Check if pad has caps set on it with a Gst.EventType.CAPS event.

Gst.Pad.prototype.is_active

function Gst.Pad.prototype.is_active(): {
    // javascript wrapper for 'gst_pad_is_active'
}

Query if a pad is active

Gst.Pad.prototype.is_blocked

function Gst.Pad.prototype.is_blocked(): {
    // javascript wrapper for 'gst_pad_is_blocked'
}

Checks if the pad is blocked or not. This function returns the last requested state of the pad. It is not certain that the pad is actually blocking at this point (see Gst.Pad.prototype.is_blocking).

Gst.Pad.prototype.is_blocking

function Gst.Pad.prototype.is_blocking(): {
    // javascript wrapper for 'gst_pad_is_blocking'
}

Checks if the pad is blocking or not. This is a guaranteed state of whether the pad is actually blocking on a Gst.Buffer or a Gst.Event.

Gst.Pad.prototype.is_linked

function Gst.Pad.prototype.is_linked(): {
    // javascript wrapper for 'gst_pad_is_linked'
}

Checks if a pad is linked to another pad or not.

Gst.Pad.prototype.iterate_internal_links

function Gst.Pad.prototype.iterate_internal_links(): {
    // javascript wrapper for 'gst_pad_iterate_internal_links'
}

Gets an iterator for the pads to which the given pad is linked to inside of the parent element.

Each Gst.Pad element yielded by the iterator will have its refcount increased, so unref after use.

Free-function: gst_iterator_free

Gst.Pad.prototype.iterate_internal_links_default

function Gst.Pad.prototype.iterate_internal_links_default(parent: Gst.Object): {
    // javascript wrapper for 'gst_pad_iterate_internal_links_default'
}

Iterate the list of pads to which the given pad is linked to inside of the parent element. This is the default handler, and thus returns an iterator of all of the pads inside the parent element with opposite direction.

The caller must free this iterator after use with Gst.Iterator.prototype.free.

Gst.Pad.prototype.link

function Gst.Pad.prototype.link(sinkpad: Gst.Pad): {
    // javascript wrapper for 'gst_pad_link'
}

Links the source pad and the sink pad.

Gst.Pad.prototype.link_full

function Gst.Pad.prototype.link_full(sinkpad: Gst.Pad, flags: Gst.PadLinkCheck): {
    // javascript wrapper for 'gst_pad_link_full'
}

Links the source pad and the sink pad.

This variant of Gst.Pad.prototype.link provides a more granular control on the checks being done when linking. While providing some considerable speedups the caller of this method must be aware that wrong usage of those flags can cause severe issues. Refer to the documentation of Gst.PadLinkCheck for more information.

MT Safe.

Gst.Pad.prototype.link_maybe_ghosting

function Gst.Pad.prototype.link_maybe_ghosting(sink: Gst.Pad): {
    // javascript wrapper for 'gst_pad_link_maybe_ghosting'
}

Links src to sink, creating any Gst.GhostPad's in between as necessary.

This is a convenience function to save having to create and add intermediate Gst.GhostPad's as required for linking across Gst.Bin boundaries.

If src or sink pads don't have parent elements or do not share a common ancestor, the link will fail.

Since : 1.10

Gst.Pad.prototype.link_maybe_ghosting_full

function Gst.Pad.prototype.link_maybe_ghosting_full(sink: Gst.Pad, flags: Gst.PadLinkCheck): {
    // javascript wrapper for 'gst_pad_link_maybe_ghosting_full'
}

Links src to sink, creating any Gst.GhostPad's in between as necessary.

This is a convenience function to save having to create and add intermediate Gst.GhostPad's as required for linking across Gst.Bin boundaries.

If src or sink pads don't have parent elements or do not share a common ancestor, the link will fail.

Calling Gst.Pad.prototype.link_maybe_ghosting_full with flags == Gst.PadLinkCheck.DEFAULT is the recommended way of linking pads with safety checks applied.

Since : 1.10

Gst.Pad.prototype.mark_reconfigure

function Gst.Pad.prototype.mark_reconfigure(): {
    // javascript wrapper for 'gst_pad_mark_reconfigure'
}

Mark a pad for needing reconfiguration. The next call to Gst.Pad.prototype.check_reconfigure will return true after this call.

Gst.Pad.prototype.needs_reconfigure

function Gst.Pad.prototype.needs_reconfigure(): {
    // javascript wrapper for 'gst_pad_needs_reconfigure'
}

Check the Gst.PadFlags.NEED_RECONFIGURE flag on pad and return true if the flag was set.

Gst.Pad.prototype.pause_task

function Gst.Pad.prototype.pause_task(): {
    // javascript wrapper for 'gst_pad_pause_task'
}

Pause the task of pad. This function will also wait until the function executed by the task is finished if this function is not called from the task function.

Gst.Pad.prototype.peer_query

function Gst.Pad.prototype.peer_query(query: Gst.Query): {
    // javascript wrapper for 'gst_pad_peer_query'
}

Performs Gst.Pad.prototype.query on the peer of pad.

The caller is responsible for both the allocation and deallocation of the query structure.

Gst.Pad.prototype.peer_query_accept_caps

function Gst.Pad.prototype.peer_query_accept_caps(caps: Gst.Caps): {
    // javascript wrapper for 'gst_pad_peer_query_accept_caps'
}

Check if the peer of pad accepts caps. If pad has no peer, this function returns true.

Gst.Pad.prototype.peer_query_caps

function Gst.Pad.prototype.peer_query_caps(filter: Gst.Caps): {
    // javascript wrapper for 'gst_pad_peer_query_caps'
}

Gets the capabilities of the peer connected to this pad. Similar to Gst.Pad.prototype.query_caps.

When called on srcpads filter contains the caps that upstream could produce in the order preferred by upstream. When called on sinkpads filter contains the caps accepted by downstream in the preferred order. filter might be null but if it is not null the returned caps will be a subset of filter.

Gst.Pad.prototype.peer_query_convert

function Gst.Pad.prototype.peer_query_convert(src_format: Gst.Format, src_val: Number, dest_format: Gst.Format): {
    // javascript wrapper for 'gst_pad_peer_query_convert'
}

Queries the peer pad of a given sink pad to convert src_val in src_format to dest_format.

Gst.Pad.prototype.peer_query_duration

function Gst.Pad.prototype.peer_query_duration(format: Gst.Format): {
    // javascript wrapper for 'gst_pad_peer_query_duration'
}

Queries the peer pad of a given sink pad for the total stream duration.

Gst.Pad.prototype.peer_query_position

function Gst.Pad.prototype.peer_query_position(format: Gst.Format): {
    // javascript wrapper for 'gst_pad_peer_query_position'
}

Queries the peer of a given sink pad for the stream position.

Gst.Pad.prototype.proxy_query_accept_caps

function Gst.Pad.prototype.proxy_query_accept_caps(query: Gst.Query): {
    // javascript wrapper for 'gst_pad_proxy_query_accept_caps'
}

Checks if all internally linked pads of pad accepts the caps in query and returns the intersection of the results.

This function is useful as a default accept caps query function for an element that can handle any stream format, but requires caps that are acceptable for all opposite pads.

Gst.Pad.prototype.proxy_query_caps

function Gst.Pad.prototype.proxy_query_caps(query: Gst.Query): {
    // javascript wrapper for 'gst_pad_proxy_query_caps'
}

Calls Gst.Pad.prototype.query_caps for all internally linked pads of pad and returns the intersection of the results.

This function is useful as a default caps query function for an element that can handle any stream format, but requires all its pads to have the same caps. Two such elements are tee and adder.

Gst.Pad.prototype.pull_range

function Gst.Pad.prototype.pull_range(offset: Number, size: Number): {
    // javascript wrapper for 'gst_pad_pull_range'
}

Pulls a buffer from the peer pad or fills up a provided buffer.

This function will first trigger the pad block signal if it was installed.

When pad is not linked Gst.FlowReturn.NOT_LINKED is returned else this function returns the result of Gst.Pad.prototype.get_range on the peer pad. See Gst.Pad.prototype.get_range for a list of return values and for the semantics of the arguments of this function.

If buffer points to a variable holding null, a valid new Gst.Buffer will be placed in buffer when this function returns Gst.FlowReturn.OK. The new buffer must be freed with gst_buffer_unref (not introspectable) after usage. When this function returns any other result value, buffer will still point to null.

When buffer points to a variable that points to a valid Gst.Buffer, the buffer will be filled with the result data when this function returns Gst.FlowReturn.OK. When this function returns any other result value, buffer will be unchanged. If the provided buffer is larger than size, only size bytes will be filled in the result buffer and its size will be updated accordingly.

Note that less than size bytes can be returned in buffer when, for example, an EOS condition is near or when buffer is not large enough to hold size bytes. The caller should check the result buffer size to get the result size.