GstVideoEncoder

GstVideo.VideoEncoder

GObject.Object
    ╰──GObject.InitiallyUnowned
        ╰──Gst.Object
            ╰──Gst.Element
                ╰──GstVideo.VideoEncoder

GstVideo.VideoEncoder.prototype.allocate_output_buffer

function GstVideo.VideoEncoder.prototype.allocate_output_buffer(size: Number): {
    // javascript wrapper for 'gst_video_encoder_allocate_output_buffer'
}

Helper function that allocates a buffer to hold an encoded video frame for encoder's current GstVideo.VideoCodecState.

GstVideo.VideoEncoder.prototype.allocate_output_frame

function GstVideo.VideoEncoder.prototype.allocate_output_frame(frame: GstVideo.VideoCodecFrame, size: Number): {
    // javascript wrapper for 'gst_video_encoder_allocate_output_frame'
}

Helper function that allocates a buffer to hold an encoded video frame for encoder's current GstVideo.VideoCodecState. Subclass should already have configured video state and set src pad caps.

The buffer allocated here is owned by the frame and you should only keep references to the frame, not the buffer.

GstVideo.VideoEncoder.prototype.drop_frame

function GstVideo.VideoEncoder.prototype.drop_frame(frame: GstVideo.VideoCodecFrame): {
    // javascript wrapper for 'gst_video_encoder_drop_frame'
}

Removes frame from the list of pending frames, releases it and posts a QoS message with the frame's details on the bus. Similar to calling GstVideo.VideoEncoder.prototype.finish_frame without a buffer attached to frame, but this function additionally stores events from frame as pending, to be pushed out alongside the next frame submitted via GstVideo.VideoEncoder.prototype.finish_frame.

Since : 1.26

GstVideo.VideoEncoder.prototype.finish_frame

function GstVideo.VideoEncoder.prototype.finish_frame(frame: GstVideo.VideoCodecFrame): {
    // javascript wrapper for 'gst_video_encoder_finish_frame'
}

frame must have a valid encoded data buffer, whose metadata fields are then appropriately set according to frame data or no buffer at all if the frame should be dropped. It is subsequently pushed downstream or provided to pre_push. In any case, the frame is considered finished and released.

If frame does not have a buffer attached, it will be dropped, and a QoS message will be posted on the bus. Events from frame will be pushed out immediately.

After calling this function the output buffer of the frame is to be considered read-only. This function will also change the metadata of the buffer.

GstVideo.VideoEncoder.prototype.finish_subframe

function GstVideo.VideoEncoder.prototype.finish_subframe(frame: GstVideo.VideoCodecFrame): {
    // javascript wrapper for 'gst_video_encoder_finish_subframe'
}

If multiple subframes are produced for one input frame then use this method for each subframe, except for the last one. Before calling this function, you need to fill frame->output_buffer with the encoded buffer to push.

You must call GstVideo.VideoEncoder.prototype.finish_frame() for the last sub-frame to tell the encoder that the frame has been fully encoded.

This function will change the metadata of frame and frame->output_buffer will be pushed downstream.

Since : 1.18

GstVideo.VideoEncoder.prototype.get_allocator

function GstVideo.VideoEncoder.prototype.get_allocator(): {
    // javascript wrapper for 'gst_video_encoder_get_allocator'
}

Lets GstVideo.VideoEncoder sub-classes to know the memory allocator used by the base class and its params.

Unref the allocator after use it.

GstVideo.VideoEncoder.prototype.get_frame

function GstVideo.VideoEncoder.prototype.get_frame(frame_number: Number): {
    // javascript wrapper for 'gst_video_encoder_get_frame'
}

Get a pending unfinished GstVideo.VideoCodecFrame

GstVideo.VideoEncoder.prototype.get_frames

function GstVideo.VideoEncoder.prototype.get_frames(): {
    // javascript wrapper for 'gst_video_encoder_get_frames'
}

Get all pending unfinished GstVideo.VideoCodecFrame

GstVideo.VideoEncoder.prototype.get_latency

function GstVideo.VideoEncoder.prototype.get_latency(): {
    // javascript wrapper for 'gst_video_encoder_get_latency'
}

Query the configured encoding latency. Results will be returned via min_latency and max_latency.

GstVideo.VideoEncoder.prototype.get_max_encode_time

function GstVideo.VideoEncoder.prototype.get_max_encode_time(frame: GstVideo.VideoCodecFrame): {
    // javascript wrapper for 'gst_video_encoder_get_max_encode_time'
}

Determines maximum possible encoding time for frame that will allow it to encode and arrive in time (as determined by QoS events). In particular, a negative result means encoding in time is no longer possible and should therefore occur as soon/skippy as possible.

If no QoS events have been received from downstream, or if qos is disabled this function returns GLib.MAXINT64.

Since : 1.14

GstVideo.VideoEncoder.prototype.get_min_force_key_unit_interval

function GstVideo.VideoEncoder.prototype.get_min_force_key_unit_interval(): {
    // javascript wrapper for 'gst_video_encoder_get_min_force_key_unit_interval'
}

Returns the minimum force-keyunit interval, see GstVideo.VideoEncoder.prototype.set_min_force_key_unit_interval for more details.

Since : 1.18

GstVideo.VideoEncoder.prototype.get_oldest_frame

function GstVideo.VideoEncoder.prototype.get_oldest_frame(): {
    // javascript wrapper for 'gst_video_encoder_get_oldest_frame'
}

Get the oldest unfinished pending GstVideo.VideoCodecFrame

GstVideo.VideoEncoder.prototype.get_output_state

function GstVideo.VideoEncoder.prototype.get_output_state(): {
    // javascript wrapper for 'gst_video_encoder_get_output_state'
}

Get the current GstVideo.VideoCodecState

GstVideo.VideoEncoder.prototype.is_qos_enabled

function GstVideo.VideoEncoder.prototype.is_qos_enabled(): {
    // javascript wrapper for 'gst_video_encoder_is_qos_enabled'
}

Checks if encoder is currently configured to handle Quality-of-Service events from downstream.

Since : 1.14

GstVideo.VideoEncoder.prototype.merge_tags

function GstVideo.VideoEncoder.prototype.merge_tags(tags: Gst.TagList, mode: Gst.TagMergeMode): {
    // javascript wrapper for 'gst_video_encoder_merge_tags'
}

Sets the video encoder tags and how they should be merged with any upstream stream tags. This will override any tags previously-set with GstVideo.VideoEncoder.prototype.merge_tags.

Note that this is provided for convenience, and the subclass is not required to use this and can still do tag handling on its own.

MT safe.

GstVideo.VideoEncoder.prototype.negotiate

function GstVideo.VideoEncoder.prototype.negotiate(): {
    // javascript wrapper for 'gst_video_encoder_negotiate'
}

Negotiate with downstream elements to currently configured GstVideo.VideoCodecState. Unmark GST_PAD_FLAG_NEED_RECONFIGURE in any case. But mark it again if negotiate fails.

GstVideo.VideoEncoder.prototype.proxy_getcaps

function GstVideo.VideoEncoder.prototype.proxy_getcaps(caps: Gst.Caps, filter: Gst.Caps): {
    // javascript wrapper for 'gst_video_encoder_proxy_getcaps'
}

Returns caps that express caps (or sink template caps if caps == NULL) restricted to resolution/format/... combinations supported by downstream elements (e.g. muxers).

GstVideo.VideoEncoder.prototype.release_frame

function GstVideo.VideoEncoder.prototype.release_frame(frame: GstVideo.VideoCodecFrame): {
    // javascript wrapper for 'gst_video_encoder_release_frame'
}

Removes frame from list of pending frames and releases it, similar to calling GstVideo.VideoEncoder.prototype.finish_frame without a buffer attached to the frame, but does not post a QoS message or do any additional processing. Events from frame are moved to the pending events list.

Since : 1.26

GstVideo.VideoEncoder.prototype.set_headers

function GstVideo.VideoEncoder.prototype.set_headers(headers: [ Gst.Buffer ]): {
    // javascript wrapper for 'gst_video_encoder_set_headers'
}

Set the codec headers to be sent downstream whenever requested.

GstVideo.VideoEncoder.prototype.set_latency

function GstVideo.VideoEncoder.prototype.set_latency(min_latency: Number, max_latency: Number): {
    // javascript wrapper for 'gst_video_encoder_set_latency'
}

Informs baseclass of encoding latency. If the provided values changed from previously provided ones, this will also post a LATENCY message on the bus so the pipeline can reconfigure its global latency.

GstVideo.VideoEncoder.prototype.set_min_force_key_unit_interval

function GstVideo.VideoEncoder.prototype.set_min_force_key_unit_interval(interval: Number): {
    // javascript wrapper for 'gst_video_encoder_set_min_force_key_unit_interval'
}

Sets the minimum interval for requesting keyframes based on force-keyunit events. Setting this to 0 will allow to handle every event, setting this to Gst.CLOCK_TIME_NONE causes force-keyunit events to be ignored.

Since : 1.18

GstVideo.VideoEncoder.prototype.set_min_pts

function GstVideo.VideoEncoder.prototype.set_min_pts(min_pts: Number): {
    // javascript wrapper for 'gst_video_encoder_set_min_pts'
}

Request minimal value for PTS passed to handle_frame.

For streams with reordered frames this can be used to ensure that there is enough time to accommodate first DTS, which may be less than first PTS

Since : 1.6

GstVideo.VideoEncoder.prototype.set_output_state

function GstVideo.VideoEncoder.prototype.set_output_state(caps: Gst.Caps, reference: GstVideo.VideoCodecState): {
    // javascript wrapper for 'gst_video_encoder_set_output_state'
}

Creates a new GstVideo.VideoCodecState with the specified caps as the output state for the encoder. Any previously set output state on encoder will be replaced by the newly created one.

The specified caps should not contain any resolution, pixel-aspect-ratio, framerate, codec-data, .... Those should be specified instead in the returned GstVideo.VideoCodecState.

If the subclass wishes to copy over existing fields (like pixel aspect ratio, or framerate) from an existing GstVideo.VideoCodecState, it can be provided as a reference.

If the subclass wishes to override some fields from the output state (like pixel-aspect-ratio or framerate) it can do so on the returned GstVideo.VideoCodecState.

The new output state will only take effect (set on pads and buffers) starting from the next call to GstVideo.VideoEncoder.prototype.finish_frame().

GstVideo.VideoEncoder.prototype.set_qos_enabled

function GstVideo.VideoEncoder.prototype.set_qos_enabled(enabled: Number): {
    // javascript wrapper for 'gst_video_encoder_set_qos_enabled'
}

Configures encoder to handle Quality-of-Service events from downstream.

Since : 1.14

min-force-key-unit-interval

“min-force-key-unit-interval” Number

Minimum interval between force-keyunit requests in nanoseconds. See GstVideo.VideoEncoder.prototype.set_min_force_key_unit_interval for more details.

Flags : Read / Write

Since : 1.18

qos

“qos” Number

Flags : Read / Write

vfunc_close

function vfunc_close(encoder: GstVideo.VideoEncoder): {
    // javascript implementation of the 'close' virtual method
}

Optional. Called when the element changes to GST_STATE_NULL. Allows closing external resources.

vfunc_decide_allocation

function vfunc_decide_allocation(encoder: GstVideo.VideoEncoder, query: Gst.Query): {
    // javascript implementation of the 'decide_allocation' virtual method
}

Optional. Setup the allocation parameters for allocating output buffers. The passed in query contains the result of the downstream allocation query. Subclasses should chain up to the parent implementation to invoke the default handler.

vfunc_finish

function vfunc_finish(encoder: GstVideo.VideoEncoder): {
    // javascript implementation of the 'finish' virtual method
}

Optional. Called to request subclass to dispatch any pending remaining data (e.g. at EOS).

vfunc_flush

function vfunc_flush(encoder: GstVideo.VideoEncoder): {
    // javascript implementation of the 'flush' virtual method
}

Optional. Flush all remaining data from the encoder without pushing it downstream. Since: 1.2

vfunc_getcaps

function vfunc_getcaps(enc: GstVideo.VideoEncoder, filter: Gst.Caps): {
    // javascript implementation of the 'getcaps' virtual method
}

Optional. Allows for a custom sink getcaps implementation (e.g. for multichannel input specification). If not implemented, default returns gst_video_encoder_proxy_getcaps applied to sink template caps.

vfunc_handle_frame

function vfunc_handle_frame(encoder: GstVideo.VideoEncoder, frame: GstVideo.VideoCodecFrame): {
    // javascript implementation of the 'handle_frame' virtual method
}

Provides input frame to subclass.

vfunc_negotiate

function vfunc_negotiate(encoder: GstVideo.VideoEncoder): {
    // javascript implementation of the 'negotiate' virtual method
}

Optional. Negotiate with downstream and configure buffer pools, etc. Subclasses should chain up to the parent implementation to invoke the default handler.

vfunc_open

function vfunc_open(encoder: GstVideo.VideoEncoder): {
    // javascript implementation of the 'open' virtual method
}

Optional. Called when the element changes to GST_STATE_READY. Allows opening external resources.

vfunc_pre_push

function vfunc_pre_push(encoder: GstVideo.VideoEncoder, frame: GstVideo.VideoCodecFrame): {
    // javascript implementation of the 'pre_push' virtual method
}

Optional. Allows subclass to push frame downstream in whatever shape or form it deems appropriate. If not provided, provided encoded frame data is simply pushed downstream.

vfunc_propose_allocation

function vfunc_propose_allocation(encoder: GstVideo.VideoEncoder, query: Gst.Query): {
    // javascript implementation of the 'propose_allocation' virtual method
}

Optional. Propose buffer allocation parameters for upstream elements. Subclasses should chain up to the parent implementation to invoke the default handler.

vfunc_reset

function vfunc_reset(encoder: GstVideo.VideoEncoder, hard: Number): {
    // javascript implementation of the 'reset' virtual method
}

Optional. Allows subclass (encoder) to perform post-seek semantics reset. Deprecated.

vfunc_set_format

function vfunc_set_format(encoder: GstVideo.VideoEncoder, state: GstVideo.VideoCodecState): {
    // javascript implementation of the 'set_format' virtual method
}

Optional. Notifies subclass of incoming data format. GstVideoCodecState fields have already been set according to provided caps.

vfunc_sink_event

function vfunc_sink_event(encoder: GstVideo.VideoEncoder, event: Gst.Event): {
    // javascript implementation of the 'sink_event' virtual method
}

Optional. Event handler on the sink pad. This function should return TRUE if the event was handled and should be discarded (i.e. not unref'ed). Subclasses should chain up to the parent implementation to invoke the default handler.

vfunc_sink_query

function vfunc_sink_query(encoder: GstVideo.VideoEncoder, query: Gst.Query): {
    // javascript implementation of the 'sink_query' virtual method
}

Optional. Query handler on the sink pad. This function should return TRUE if the query could be performed. Subclasses should chain up to the parent implementation to invoke the default handler. Since: 1.4

vfunc_src_event

function vfunc_src_event(encoder: GstVideo.VideoEncoder, event: Gst.Event): {
    // javascript implementation of the 'src_event' virtual method
}

Optional. Event handler on the source pad. This function should return TRUE if the event was handled and should be discarded (i.e. not unref'ed). Subclasses should chain up to the parent implementation to invoke the default handler.

vfunc_src_query

function vfunc_src_query(encoder: GstVideo.VideoEncoder, query: Gst.Query): {
    // javascript implementation of the 'src_query' virtual method
}

Optional. Query handler on the source pad. This function should return TRUE if the query could be performed. Subclasses should chain up to the parent implementation to invoke the default handler. Since: 1.4

vfunc_start

function vfunc_start(encoder: GstVideo.VideoEncoder): {
    // javascript implementation of the 'start' virtual method
}

Optional. Called when the element starts processing. Allows opening external resources.

vfunc_stop

function vfunc_stop(encoder: GstVideo.VideoEncoder): {
    // javascript implementation of the 'stop' virtual method
}

Optional. Called when the element stops processing. Allows closing external resources.

vfunc_transform_meta

function vfunc_transform_meta(encoder: GstVideo.VideoEncoder, frame: GstVideo.VideoCodecFrame, meta: Gst.Meta): {
    // javascript implementation of the 'transform_meta' virtual method
}

Optional. Transform the metadata on the input buffer to the output buffer. By default this method is copies all meta without tags and meta with only the "video" tag. subclasses can implement this method and return true if the metadata is to be copied. Since: 1.6

GstVideo.VIDEO_ENCODER_SINK_NAME

The name of the templates for the sink pad.

GstVideo.VIDEO_ENCODER_SRC_NAME

The name of the templates for the source pad.