GstAggregator

GstBase.Aggregator

GObject.Object
    ╰──GObject.InitiallyUnowned
        ╰──Gst.Object
            ╰──Gst.Element
                ╰──GstBase.Aggregator

Since : 1.14

GstBase.Aggregator.prototype.finish_buffer

function GstBase.Aggregator.prototype.finish_buffer(buffer: Gst.Buffer): {
    // javascript wrapper for 'gst_aggregator_finish_buffer'
}

This method will push the provided output buffer downstream. If needed, mandatory events such as stream-start, caps, and segment events will be sent before pushing the buffer.

GstBase.Aggregator.prototype.finish_buffer_list

function GstBase.Aggregator.prototype.finish_buffer_list(bufferlist: Gst.BufferList): {
    // javascript wrapper for 'gst_aggregator_finish_buffer_list'
}

This method will push the provided output buffer list downstream. If needed, mandatory events such as stream-start, caps, and segment events will be sent before pushing the buffer.

Since : 1.18

GstBase.Aggregator.prototype.get_allocator

function GstBase.Aggregator.prototype.get_allocator(): {
    // javascript wrapper for 'gst_aggregator_get_allocator'
}

Lets GstBase.Aggregator sub-classes get the memory allocator acquired by the base class and its params.

Unref the allocator after use it.

GstBase.Aggregator.prototype.get_buffer_pool

function GstBase.Aggregator.prototype.get_buffer_pool(): {
    // javascript wrapper for 'gst_aggregator_get_buffer_pool'
}

GstBase.Aggregator.prototype.get_force_live

function GstBase.Aggregator.prototype.get_force_live(): {
    // javascript wrapper for 'gst_aggregator_get_force_live'
}

Subclasses may use the return value to inform whether they should return Gst.FlowReturn.EOS from their aggregate implementation.

Since : 1.22

GstBase.Aggregator.prototype.get_ignore_inactive_pads

function GstBase.Aggregator.prototype.get_ignore_inactive_pads(): {
    // javascript wrapper for 'gst_aggregator_get_ignore_inactive_pads'
}

Since : 1.20

GstBase.Aggregator.prototype.get_latency

function GstBase.Aggregator.prototype.get_latency(): {
    // javascript wrapper for 'gst_aggregator_get_latency'
}

Retrieves the latency values reported by self in response to the latency query, or Gst.CLOCK_TIME_NONE if there is not live source connected and the element will not wait for the clock.

Typically only called by subclasses.

GstBase.Aggregator.prototype.negotiate

function GstBase.Aggregator.prototype.negotiate(): {
    // javascript wrapper for 'gst_aggregator_negotiate'
}

Negotiates src pad caps with downstream elements. Unmarks GST_PAD_FLAG_NEED_RECONFIGURE in any case. But marks it again if vfunc_negotiate fails.

Since : 1.18

GstBase.Aggregator.prototype.peek_next_sample

function GstBase.Aggregator.prototype.peek_next_sample(pad: GstBase.AggregatorPad): {
    // javascript wrapper for 'gst_aggregator_peek_next_sample'
}

Use this function to determine what input buffers will be aggregated to produce the next output buffer. This should only be called from a samples-selected handler, and can be used to precisely control aggregating parameters for a given set of input samples.

Since : 1.18

GstBase.Aggregator.prototype.push_src_event

function GstBase.Aggregator.prototype.push_src_event(event: Gst.Event): {
    // javascript wrapper for 'gst_aggregator_push_src_event'
}

This method will push the provided event downstream. If needed, mandatory events such as stream-start, caps, and segment events will be sent before pushing the event.

This API does not allow pushing stream-start, caps, segment and EOS events. Specific API like GstBase.Aggregator.prototype.set_src_caps should be used for these.

Since : 1.26

GstBase.Aggregator.prototype.selected_samples

function GstBase.Aggregator.prototype.selected_samples(pts: Number, dts: Number, duration: Number, info: Gst.Structure): {
    // javascript wrapper for 'gst_aggregator_selected_samples'
}

Subclasses should call this when they have prepared the buffers they will aggregate for each of their sink pads, but before using any of the properties of the pads that govern how aggregation should be performed, for example z-index for video aggregators.

If GstBase.Aggregator.prototype.update_segment is used by the subclass, it MUST be called before GstBase.Aggregator.prototype.selected_samples.

This function MUST only be called from the vfunc_aggregate() function.

Since : 1.18

GstBase.Aggregator.prototype.set_force_live

function GstBase.Aggregator.prototype.set_force_live(force_live: Number): {
    // javascript wrapper for 'gst_aggregator_set_force_live'
}

Subclasses should call this at construction time in order for self to aggregate on a timeout even when no live source is connected.

Since : 1.22

GstBase.Aggregator.prototype.set_ignore_inactive_pads

function GstBase.Aggregator.prototype.set_ignore_inactive_pads(ignore: Number): {
    // javascript wrapper for 'gst_aggregator_set_ignore_inactive_pads'
}

Subclasses should call this when they don't want to time out waiting for a pad that hasn't yet received any buffers in live mode.

GstBase.Aggregator will still wait once on each newly-added pad, making sure upstream has had a fair chance to start up.

Since : 1.20

GstBase.Aggregator.prototype.set_latency

function GstBase.Aggregator.prototype.set_latency(min_latency: Number, max_latency: Number): {
    // javascript wrapper for 'gst_aggregator_set_latency'
}

Lets GstBase.Aggregator sub-classes tell the baseclass what their internal latency is. Will also post a LATENCY message on the bus so the pipeline can reconfigure its global latency if the values changed.

GstBase.Aggregator.prototype.set_src_caps

function GstBase.Aggregator.prototype.set_src_caps(caps: Gst.Caps): {
    // javascript wrapper for 'gst_aggregator_set_src_caps'
}

Sets the caps to be used on the src pad.

GstBase.Aggregator.prototype.simple_get_next_time

function GstBase.Aggregator.prototype.simple_get_next_time(): {
    // javascript wrapper for 'gst_aggregator_simple_get_next_time'
}

This is a simple vfunc_get_next_time implementation that just looks at the Gst.Segment on the srcpad of the aggregator and bases the next time on the running time there.

This is the desired behaviour in most cases where you have a live source and you have a dead line based aggregator subclass.

Since : 1.16

GstBase.Aggregator.prototype.update_segment

function GstBase.Aggregator.prototype.update_segment(segment: Gst.Segment): {
    // javascript wrapper for 'gst_aggregator_update_segment'
}

Subclasses should use this to update the segment on their source pad, instead of directly pushing new segment events downstream.

Subclasses MUST call this before GstBase.Aggregator.prototype.selected_samples, if it is used at all.

Since : 1.18

samples-selected

function samples_selected_callback(self: GstBase.Aggregator, segment: Gst.Segment, pts: Number, dts: Number, duration: Number, info: Gst.Structure, user_data: Object): {
    // javascript callback for the 'samples-selected' signal
}

Signals that the GstBase.Aggregator subclass has selected the next set of input samples it will aggregate. Handlers may call GstBase.Aggregator.prototype.peek_next_sample at that point.

Flags: Run First

Since : 1.18

emit-signals

“emit-signals” Number

Enables the emission of signals such as samples-selected

Flags : Read / Write

Since : 1.18

latency

“latency” Number

Flags : Read / Write

min-upstream-latency

“min-upstream-latency” Number

Force minimum upstream latency (in nanoseconds). When sources with a higher latency are expected to be plugged in dynamically after the aggregator has started playing, this allows overriding the minimum latency reported by the initial source(s). This is only taken into account when larger than the actually reported minimum latency.

Flags : Read / Write

Since : 1.16

start-time

“start-time” Number

Flags : Read / Write

start-time-selection

“start-time-selection” GstBase.AggregatorStartTimeSelection

Flags : Read / Write

vfunc_aggregate

function vfunc_aggregate(aggregator: GstBase.Aggregator, timeout: Number): {
    // javascript implementation of the 'aggregate' virtual method
}

Mandatory. Called when buffers are queued on all sinkpads. Classes should iterate the GstElement->sinkpads and peek or steal buffers from the GstBase.AggregatorPad. If the subclass returns GST_FLOW_EOS, sending of the eos event will be taken care of. Once / if a buffer has been constructed from the aggregated buffers, the subclass should call _finish_buffer.

vfunc_clip

function vfunc_clip(aggregator: GstBase.Aggregator, aggregator_pad: GstBase.AggregatorPad, buf: Gst.Buffer): {
    // javascript implementation of the 'clip' virtual method
}

Optional. Called when a buffer is received on a sink pad, the task of clipping it and translating it to the current segment falls on the subclass. The function should use the segment of data and the negotiated media type on the pad to perform clipping of input buffer. This function takes ownership of buf and should output a buffer or return NULL in if the buffer should be dropped.

vfunc_decide_allocation

function vfunc_decide_allocation(self: GstBase.Aggregator, query: Gst.Query): {
    // javascript implementation of the 'decide_allocation' virtual method
}

Optional. Allows the subclass to influence the allocation choices. Setup the allocation parameters for allocating output buffers. The passed in query contains the result of the downstream allocation query.

vfunc_finish_buffer

function vfunc_finish_buffer(aggregator: GstBase.Aggregator, buffer: Gst.Buffer): {
    // javascript implementation of the 'finish_buffer' virtual method
}

Optional. Called when a subclass calls GstBase.Aggregator.prototype.finish_buffer from their aggregate function to push out a buffer. Subclasses can override this to modify or decorate buffers before they get pushed out. This function takes ownership of the buffer passed. Subclasses that override this method should always chain up to the parent class virtual method.

vfunc_finish_buffer_list

function vfunc_finish_buffer_list(aggregator: GstBase.Aggregator, bufferlist: Gst.BufferList): {
    // javascript implementation of the 'finish_buffer_list' virtual method
}

Optional. Equivalent of vfunc_finish_buffer for buffer lists.

Since : 1.18

vfunc_fixate_src_caps

function vfunc_fixate_src_caps(self: GstBase.Aggregator, caps: Gst.Caps): {
    // javascript implementation of the 'fixate_src_caps' virtual method
}

Optional. Fixate and return the src pad caps provided. The function takes ownership of caps and returns a fixated version of caps. caps is not guaranteed to be writable.

vfunc_flush

function vfunc_flush(aggregator: GstBase.Aggregator): {
    // javascript implementation of the 'flush' virtual method
}

Optional. Called after a successful flushing seek, once all the flush stops have been received. Flush pad-specific data in GstBase.AggregatorPad->flush.

vfunc_get_next_time

function vfunc_get_next_time(aggregator: GstBase.Aggregator): {
    // javascript implementation of the 'get_next_time' virtual method
}

Optional. Called when the element needs to know the running time of the next rendered buffer for live pipelines. This causes deadline based aggregation to occur. Defaults to returning GST_CLOCK_TIME_NONE causing the element to wait for buffers on all sink pads before aggregating.

vfunc_negotiate

function vfunc_negotiate(self: GstBase.Aggregator): {
    // javascript implementation of the 'negotiate' virtual method
}

Optional. Negotiate the caps with the peer (Since: 1.18).

vfunc_negotiated_src_caps

function vfunc_negotiated_src_caps(self: GstBase.Aggregator, caps: Gst.Caps): {
    // javascript implementation of the 'negotiated_src_caps' virtual method
}

Optional. Notifies subclasses what caps format has been negotiated

vfunc_peek_next_sample

function vfunc_peek_next_sample(aggregator: GstBase.Aggregator, aggregator_pad: GstBase.AggregatorPad): {
    // javascript implementation of the 'peek_next_sample' virtual method
}

See GstBase.Aggregator.prototype.peek_next_sample.

Since : 1.18

vfunc_propose_allocation

function vfunc_propose_allocation(self: GstBase.Aggregator, pad: GstBase.AggregatorPad, decide_query: Gst.Query, query: Gst.Query): {
    // javascript implementation of the 'propose_allocation' virtual method
}

Optional. Allows the subclass to handle the allocation query from upstream.

vfunc_sink_event

function vfunc_sink_event(aggregator: GstBase.Aggregator, aggregator_pad: GstBase.AggregatorPad, event: Gst.Event): {
    // javascript implementation of the 'sink_event' virtual method
}

Optional. Called when an event is received on a sink pad, the subclass should always chain up.

vfunc_sink_event_pre_queue

function vfunc_sink_event_pre_queue(aggregator: GstBase.Aggregator, aggregator_pad: GstBase.AggregatorPad, event: Gst.Event): {
    // javascript implementation of the 'sink_event_pre_queue' virtual method
}

Optional. Called when an event is received on a sink pad before queueing up serialized events. The subclass should always chain up (Since: 1.18).

vfunc_sink_query

function vfunc_sink_query(aggregator: GstBase.Aggregator, aggregator_pad: GstBase.AggregatorPad, query: Gst.Query): {
    // javascript implementation of the 'sink_query' virtual method
}

Optional. Called when a query is received on a sink pad, the subclass should always chain up.

vfunc_sink_query_pre_queue

function vfunc_sink_query_pre_queue(aggregator: GstBase.Aggregator, aggregator_pad: GstBase.AggregatorPad, query: Gst.Query): {
    // javascript implementation of the 'sink_query_pre_queue' virtual method
}

Optional. Called when a query is received on a sink pad before queueing up serialized queries. The subclass should always chain up (Since: 1.18).

vfunc_src_activate

function vfunc_src_activate(aggregator: GstBase.Aggregator, mode: Gst.PadMode, active: Number): {
    // javascript implementation of the 'src_activate' virtual method
}

Optional. Called when the src pad is activated, it will start/stop its pad task right after that call.

vfunc_src_event

function vfunc_src_event(aggregator: GstBase.Aggregator, event: Gst.Event): {
    // javascript implementation of the 'src_event' virtual method
}

Optional. Called when an event is received on the src pad, the subclass should always chain up.

vfunc_src_query

function vfunc_src_query(aggregator: GstBase.Aggregator, query: Gst.Query): {
    // javascript implementation of the 'src_query' virtual method
}

Optional. Called when a query is received on the src pad, the subclass should always chain up.

vfunc_start

function vfunc_start(aggregator: GstBase.Aggregator): {
    // javascript implementation of the 'start' virtual method
}

Optional. Called when the element goes from READY to PAUSED. The subclass should get ready to process aggregated buffers.

vfunc_stop

function vfunc_stop(aggregator: GstBase.Aggregator): {
    // javascript implementation of the 'stop' virtual method
}

Optional. Called when the element goes from PAUSED to READY. The subclass should free all resources and reset its state.

vfunc_update_src_caps

function vfunc_update_src_caps(self: GstBase.Aggregator, caps: Gst.Caps): {
    // javascript implementation of the 'update_src_caps' virtual method
}

Lets subclasses update the Gst.Caps representing the src pad caps before usage. The result should end up in ret. Return GST_AGGREGATOR_FLOW_NEED_DATA (not introspectable) to indicate that the element needs more information (caps, a buffer, etc) to choose the correct caps. Should return ANY caps if the stream has not caps at all.

GstBase.AggregatorPad

GObject.Object
    ╰──GObject.InitiallyUnowned
        ╰──Gst.Object
            ╰──Gst.Pad
                ╰──GstBase.AggregatorPad

Since : 1.14

GstBase.AggregatorPad.prototype.drop_buffer

function GstBase.AggregatorPad.prototype.drop_buffer(): {
    // javascript wrapper for 'gst_aggregator_pad_drop_buffer'
}

Drop the buffer currently queued in pad.

GstBase.AggregatorPad.prototype.has_buffer

function GstBase.AggregatorPad.prototype.has_buffer(): {
    // javascript wrapper for 'gst_aggregator_pad_has_buffer'
}

This checks if a pad has a buffer available that will be returned by a call to GstBase.AggregatorPad.prototype.peek_buffer or GstBase.AggregatorPad.prototype.pop_buffer.

Since : 1.14.1

GstBase.AggregatorPad.prototype.is_eos

function GstBase.AggregatorPad.prototype.is_eos(): {
    // javascript wrapper for 'gst_aggregator_pad_is_eos'
}

GstBase.AggregatorPad.prototype.is_inactive

function GstBase.AggregatorPad.prototype.is_inactive(): {
    // javascript wrapper for 'gst_aggregator_pad_is_inactive'
}

It is only valid to call this method from vfunc_aggregate()

Since : 1.20

GstBase.AggregatorPad.prototype.peek_buffer

function GstBase.AggregatorPad.prototype.peek_buffer(): {
    // javascript wrapper for 'gst_aggregator_pad_peek_buffer'
}

GstBase.AggregatorPad.prototype.pop_buffer

function GstBase.AggregatorPad.prototype.pop_buffer(): {
    // javascript wrapper for 'gst_aggregator_pad_pop_buffer'
}

Steal the ref to the buffer currently queued in pad.

buffer-consumed

function buffer_consumed_callback(self: GstBase.AggregatorPad, object: Gst.Buffer, user_data: Object): {
    // javascript callback for the 'buffer-consumed' signal
}

Flags: Run First

emit-signals

“emit-signals” Number

Enables the emission of signals such as buffer-consumed

Flags : Read / Write

Since : 1.16

vfunc_flush

function vfunc_flush(aggpad: GstBase.AggregatorPad, aggregator: GstBase.Aggregator): {
    // javascript implementation of the 'flush' virtual method
}

Optional Called when the pad has received a flush stop, this is the place to flush any information specific to the pad, it allows for individual pads to be flushed while others might not be.

vfunc_skip_buffer

function vfunc_skip_buffer(aggpad: GstBase.AggregatorPad, aggregator: GstBase.Aggregator, buffer: Gst.Buffer): {
    // javascript implementation of the 'skip_buffer' virtual method
}

Optional Called before input buffers are queued in the pad, return true if the buffer should be skipped.

GstBase.AggregatorStartTimeSelection

Since : 1.18