# GstVideoEncoder

This base class is for video encoders turning raw video into encoded video data.

GstVideoEncoder and subclass should cooperate as follows.

## Configuration

- Initially, GstVideoEncoder calls start when the encoder element is activated, which allows subclass to perform any global setup.
- GstVideoEncoder calls set_format to inform subclass of the format of input video data that it is about to receive. Subclass should setup for encoding and configure base class as appropriate (e.g. latency). While unlikely, it might be called more than once, if changing input parameters require reconfiguration. Baseclass will ensure that processing of current configuration is finished.
- GstVideoEncoder calls stop at end of all processing.

## Data processing

     * Base class collects input data and metadata into a frame and hands
       this to subclass' @handle_frame.

     * If codec processing results in encoded data, subclass should call
       @gst_video_encoder_finish_frame to have encoded data pushed
       downstream.

     * If implemented, baseclass calls subclass @pre_push just prior to
       pushing to allow subclasses to modify some metadata on the buffer.
       If it returns GST_FLOW_OK, the buffer is pushed downstream.

     * GstVideoEncoderClass will handle both srcpad and sinkpad events.
       Sink events will be passed to subclass if @event callback has been
       provided.

## Shutdown phase

- GstVideoEncoder class calls 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 should also be able to provide fixed src pad caps in getcaps by the time it calls gst_video_encoder_finish_frame.

Things that subclass need to take care of:

- Provide pad templates
- Provide source pad caps before pushing the first buffer
- Accept data in handle_frame and provide encoded results to gst_video_encoder_finish_frame.

## Adaptive Presets

GstVideoEncoder supports adaptive presets, where property values in a preset file can vary based on the input video resolution and framerate. This is done using GKeyFile's locale string syntax to define alternative values for properties.

For example, a preset file can specify different bitrates for different resolutions:

    [Profile YouTube]
    bitrate=2500
    bitrate[1920x1080]=8000
    bitrate[1920x1080@48]=12000
    bitrate[3840x2160]=40000
    bitrate[3840x2160@48]=60000

When a preset with alternatives is loaded, the best matching alternative is applied each time the input format changes, before the subclass set_format method runs.

Alternative keys use the format `WxH` (matches when the actual pixel count >= W*H) or `WxH@FPS` (additionally requires actual fps >= FPS). The most specific match wins (highest pixel count, then highest fps threshold). If no alternative matches, the base property value set by gst_preset_load_preset remains.

The qos property will enable the Quality-of-Service features of the encoder which gather statistics about the real-time performance of the downstream elements. If enabled, subclasses can use gst_video_encoder_get_max_encode_time to check if input frames are already late and drop them right away to give a chance to the pipeline to catch up.

## GstVideoEncoder

    GObject
        ╰──GInitiallyUnowned
            ╰──GstObject
                ╰──GstElement
                    ╰──GstVideoEncoder

The opaque GstVideoEncoder data structure.

### Class structure

#### GstVideoEncoderClass

Subclasses can override any of the available virtual methods or not, as needed. At minimum handle_frame needs to be overridden, and set_format and get_caps are likely needed as well.

### GstVideo.VideoEncoderClass

Subclasses can override any of the available virtual methods or not, as needed. At minimum handle_frame needs to be overridden, and set_format and get_caps are likely needed as well.

### GstVideo.VideoEncoderClass

Subclasses can override any of the available virtual methods or not, as needed. At minimum handle_frame needs to be overridden, and set_format and get_caps are likely needed as well.

## GstVideo.VideoEncoder

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

The opaque GstVideo.VideoEncoder data structure.

## GstVideo.VideoEncoder

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

The opaque GstVideo.VideoEncoder data structure.

### Methods

#### gst_video_encoder_allocate_output_buffer

    GstBuffer *
    gst_video_encoder_allocate_output_buffer (GstVideoEncoder * encoder,
                                              gsize size)

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

Parameters:

`encoder` –

a GstVideoEncoder

`size` –

size of the buffer

Returns ( [transfer: full]) –

allocated buffer

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`size` (Number) –

size of the buffer

Returns (Gst.Buffer) –

allocated buffer

#### GstVideo.VideoEncoder.allocate_output_buffer

    def GstVideo.VideoEncoder.allocate_output_buffer (self, size):
        #python 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`size` (int) –

size of the buffer

Returns (Gst.Buffer) –

allocated buffer

#### gst_video_encoder_allocate_output_frame

    GstFlowReturn
    gst_video_encoder_allocate_output_frame (GstVideoEncoder * encoder,
                                             GstVideoCodecFrame * frame,
                                             gsize size)

Helper function that allocates a buffer to hold an encoded video frame for encoder's current GstVideoCodecState. 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.

Parameters:

`encoder` –

a GstVideoEncoder

`frame` –

a GstVideoCodecFrame

`size` –

size of the buffer

Returns –

GST_FLOW_OK if an output buffer could be allocated

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`frame` (GstVideo.VideoCodecFrame) –

a GstVideo.VideoCodecFrame

`size` (Number) –

size of the buffer

Returns (Gst.FlowReturn) –

Gst.FlowReturn.OK if an output buffer could be allocated

#### GstVideo.VideoEncoder.allocate_output_frame

    def GstVideo.VideoEncoder.allocate_output_frame (self, frame, size):
        #python 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`frame` (GstVideo.VideoCodecFrame) –

a GstVideo.VideoCodecFrame

`size` (int) –

size of the buffer

Returns (Gst.FlowReturn) –

Gst.FlowReturn.OK if an output buffer could be allocated

#### gst_video_encoder_drop_frame

    gst_video_encoder_drop_frame (GstVideoEncoder * encoder,
                                  GstVideoCodecFrame * 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 gst_video_encoder_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 gst_video_encoder_finish_frame.

Parameters:

`encoder` –

a GstVideoEncoder

`frame` ( [transfer: full]) –

a GstVideoCodecFrame

Since : 1.26

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`frame` (GstVideo.VideoCodecFrame) –

a GstVideo.VideoCodecFrame

Since : 1.26

#### GstVideo.VideoEncoder.drop_frame

    def GstVideo.VideoEncoder.drop_frame (self, frame):
        #python 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.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.finish_frame.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`frame` (GstVideo.VideoCodecFrame) –

a GstVideo.VideoCodecFrame

Since : 1.26

#### gst_video_encoder_finish_frame

    GstFlowReturn
    gst_video_encoder_finish_frame (GstVideoEncoder * encoder,
                                    GstVideoCodecFrame * 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.

Parameters:

`encoder` –

a GstVideoEncoder

`frame` ( [transfer: full]) –

an encoded GstVideoCodecFrame

Returns –

a GstFlowReturn resulting from sending data downstream

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`frame` (GstVideo.VideoCodecFrame) –

an encoded GstVideo.VideoCodecFrame

Returns (Gst.FlowReturn) –

a Gst.FlowReturn resulting from sending data downstream

#### GstVideo.VideoEncoder.finish_frame

    def GstVideo.VideoEncoder.finish_frame (self, frame):
        #python 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`frame` (GstVideo.VideoCodecFrame) –

an encoded GstVideo.VideoCodecFrame

Returns (Gst.FlowReturn) –

a Gst.FlowReturn resulting from sending data downstream

#### gst_video_encoder_finish_subframe

    GstFlowReturn
    gst_video_encoder_finish_subframe (GstVideoEncoder * encoder,
                                       GstVideoCodecFrame * frame)

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 gst_video_encoder_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.

Parameters:

`encoder` –

a GstVideoEncoder

`frame` ( [transfer: none]) –

a GstVideoCodecFrame being encoded

Returns –

a GstFlowReturn resulting from pushing the buffer downstream.

Since : 1.18

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`frame` (GstVideo.VideoCodecFrame) –

a GstVideo.VideoCodecFrame being encoded

Returns (Gst.FlowReturn) –

a Gst.FlowReturn resulting from pushing the buffer downstream.

Since : 1.18

#### GstVideo.VideoEncoder.finish_subframe

    def GstVideo.VideoEncoder.finish_subframe (self, frame):
        #python 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.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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`frame` (GstVideo.VideoCodecFrame) –

a GstVideo.VideoCodecFrame being encoded

Returns (Gst.FlowReturn) –

a Gst.FlowReturn resulting from pushing the buffer downstream.

Since : 1.18

#### gst_video_encoder_get_allocator

    gst_video_encoder_get_allocator (GstVideoEncoder * encoder,
                                     GstAllocator ** allocator,
                                     GstAllocationParams * params)

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

Unref the allocator after use it.

Parameters:

`encoder` –

a GstVideoEncoder

`allocator` ( [out][optional][nullable][transfer: full]) –

the GstAllocator used

`params` ( [out][optional][transfer: full]) –

the GstAllocationParams of allocator

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

#### GstVideo.VideoEncoder.get_allocator

    def GstVideo.VideoEncoder.get_allocator (self):
        #python 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

#### gst_video_encoder_get_frame

    GstVideoCodecFrame *
    gst_video_encoder_get_frame (GstVideoEncoder * encoder,
                                 int frame_number)

Get a pending unfinished GstVideoCodecFrame

Parameters:

`encoder` –

a GstVideoEncoder

`frame_number` –

system_frame_number of a frame

Returns ( [transfer: full][nullable]) –

pending unfinished GstVideoCodecFrame identified by frame_number.

#### 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

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`frame_number` (Number) –

system_frame_number of a frame

Returns (GstVideo.VideoCodecFrame) –

pending unfinished GstVideo.VideoCodecFrame identified by frame_number.

#### GstVideo.VideoEncoder.get_frame

    def GstVideo.VideoEncoder.get_frame (self, frame_number):
        #python wrapper for 'gst_video_encoder_get_frame'

Get a pending unfinished GstVideo.VideoCodecFrame

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`frame_number` (int) –

system_frame_number of a frame

Returns (GstVideo.VideoCodecFrame) –

pending unfinished GstVideo.VideoCodecFrame identified by frame_number.

#### gst_video_encoder_get_frames

    GList *
    gst_video_encoder_get_frames (GstVideoEncoder * encoder)

Get all pending unfinished GstVideoCodecFrame

Parameters:

`encoder` –

a GstVideoEncoder

Returns ( [transfer: full][element-type GstVideoCodecFrame]) –

pending unfinished GstVideoCodecFrame.

#### 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

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

Returns ([ GstVideo.VideoCodecFrame ]) –

pending unfinished GstVideo.VideoCodecFrame.

#### GstVideo.VideoEncoder.get_frames

    def GstVideo.VideoEncoder.get_frames (self):
        #python wrapper for 'gst_video_encoder_get_frames'

Get all pending unfinished GstVideo.VideoCodecFrame

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

Returns ([ GstVideo.VideoCodecFrame ]) –

pending unfinished GstVideo.VideoCodecFrame.

#### gst_video_encoder_get_latency

    gst_video_encoder_get_latency (GstVideoEncoder * encoder,
                                   GstClockTime * min_latency,
                                   GstClockTime * max_latency)

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

Parameters:

`encoder` –

a GstVideoEncoder

`min_latency` ( [out][optional]) –

address of variable in which to store the configured minimum latency, or NULL

`max_latency` ( [out][optional]) –

address of variable in which to store the configured maximum latency, or NULL

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

#### GstVideo.VideoEncoder.get_latency

    def GstVideo.VideoEncoder.get_latency (self):
        #python wrapper for 'gst_video_encoder_get_latency'

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

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

#### gst_video_encoder_get_max_encode_time

    GstClockTimeDiff
    gst_video_encoder_get_max_encode_time (GstVideoEncoder * encoder,
                                           GstVideoCodecFrame * frame)

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 G_MAXINT64.

Parameters:

`encoder` –

a GstVideoEncoder

`frame` –

a GstVideoCodecFrame

Returns –

max decoding time.

Since : 1.14

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`frame` (GstVideo.VideoCodecFrame) –

a GstVideo.VideoCodecFrame

Returns (Number) –

max decoding time.

Since : 1.14

#### GstVideo.VideoEncoder.get_max_encode_time

    def GstVideo.VideoEncoder.get_max_encode_time (self, frame):
        #python 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`frame` (GstVideo.VideoCodecFrame) –

a GstVideo.VideoCodecFrame

Returns (int) –

max decoding time.

Since : 1.14

#### gst_video_encoder_get_min_force_key_unit_interval

    GstClockTime
    gst_video_encoder_get_min_force_key_unit_interval (GstVideoEncoder * encoder)

Returns the minimum force-keyunit interval, see gst_video_encoder_set_min_force_key_unit_interval for more details.

Parameters:

`encoder` –

the encoder

Returns –

the minimum force-keyunit interval

Since : 1.18

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

the encoder

Returns (Number) –

the minimum force-keyunit interval

Since : 1.18

#### GstVideo.VideoEncoder.get_min_force_key_unit_interval

    def GstVideo.VideoEncoder.get_min_force_key_unit_interval (self):
        #python wrapper for 'gst_video_encoder_get_min_force_key_unit_interval'

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

Parameters:

`encoder` (GstVideo.VideoEncoder) –

the encoder

Returns (int) –

the minimum force-keyunit interval

Since : 1.18

#### gst_video_encoder_get_oldest_frame

    GstVideoCodecFrame *
    gst_video_encoder_get_oldest_frame (GstVideoEncoder * encoder)

Get the oldest unfinished pending GstVideoCodecFrame

Parameters:

`encoder` –

a GstVideoEncoder

Returns ( [transfer: full][nullable]) –

oldest unfinished pending GstVideoCodecFrame

#### 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

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

Returns (GstVideo.VideoCodecFrame) –

oldest unfinished pending GstVideo.VideoCodecFrame

#### GstVideo.VideoEncoder.get_oldest_frame

    def GstVideo.VideoEncoder.get_oldest_frame (self):
        #python wrapper for 'gst_video_encoder_get_oldest_frame'

Get the oldest unfinished pending GstVideo.VideoCodecFrame

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

Returns (GstVideo.VideoCodecFrame) –

oldest unfinished pending GstVideo.VideoCodecFrame

#### gst_video_encoder_get_output_state

    GstVideoCodecState *
    gst_video_encoder_get_output_state (GstVideoEncoder * encoder)

Get the current GstVideoCodecState

Parameters:

`encoder` –

a GstVideoEncoder

Returns ( [transfer: full][nullable]) –

GstVideoCodecState describing format of video data.

#### 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

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

Returns (GstVideo.VideoCodecState) –

GstVideo.VideoCodecState describing format of video data.

#### GstVideo.VideoEncoder.get_output_state

    def GstVideo.VideoEncoder.get_output_state (self):
        #python wrapper for 'gst_video_encoder_get_output_state'

Get the current GstVideo.VideoCodecState

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

Returns (GstVideo.VideoCodecState) –

GstVideo.VideoCodecState describing format of video data.

#### gst_video_encoder_is_qos_enabled

    gboolean
    gst_video_encoder_is_qos_enabled (GstVideoEncoder * encoder)

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

Parameters:

`encoder` –

the encoder

Returns –

TRUE if the encoder is configured to perform Quality-of-Service.

Since : 1.14

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

the encoder

Returns (Number) –

true if the encoder is configured to perform Quality-of-Service.

Since : 1.14

#### GstVideo.VideoEncoder.is_qos_enabled

    def GstVideo.VideoEncoder.is_qos_enabled (self):
        #python wrapper for 'gst_video_encoder_is_qos_enabled'

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

Parameters:

`encoder` (GstVideo.VideoEncoder) –

the encoder

Returns (bool) –

True if the encoder is configured to perform Quality-of-Service.

Since : 1.14

#### gst_video_encoder_merge_tags

    gst_video_encoder_merge_tags (GstVideoEncoder * encoder,
                                  const GstTagList * tags,
                                  GstTagMergeMode mode)

Sets the video encoder tags and how they should be merged with any upstream stream tags. This will override any tags previously-set with gst_video_encoder_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.

Parameters:

`encoder` –

a GstVideoEncoder

`tags` ( [nullable]) –

a GstTagList to merge, or NULL to unset previously-set tags

`mode` –

the GstTagMergeMode to use, usually GST_TAG_MERGE_REPLACE

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`tags` (Gst.TagList) –

a Gst.TagList to merge, or NULL to unset previously-set tags

`mode` (Gst.TagMergeMode) –

the Gst.TagMergeMode to use, usually Gst.TagMergeMode.REPLACE

#### GstVideo.VideoEncoder.merge_tags

    def GstVideo.VideoEncoder.merge_tags (self, tags, mode):
        #python 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.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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`tags` (Gst.TagList) –

a Gst.TagList to merge, or NULL to unset previously-set tags

`mode` (Gst.TagMergeMode) –

the Gst.TagMergeMode to use, usually Gst.TagMergeMode.REPLACE

#### gst_video_encoder_negotiate

    gboolean
    gst_video_encoder_negotiate (GstVideoEncoder * encoder)

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

Parameters:

`encoder` –

a GstVideoEncoder

Returns –

TRUE if the negotiation succeeded, else FALSE.

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

Returns (Number) –

true if the negotiation succeeded, else false.

#### GstVideo.VideoEncoder.negotiate

    def GstVideo.VideoEncoder.negotiate (self):
        #python 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

Returns (bool) –

True if the negotiation succeeded, else False.

#### gst_video_encoder_proxy_getcaps

    GstCaps *
    gst_video_encoder_proxy_getcaps (GstVideoEncoder * enc,
                                     GstCaps * caps,
                                     GstCaps * filter)

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

Parameters:

`enc` –

a GstVideoEncoder

`caps` ( [nullable]) –

initial caps

`filter` ( [nullable]) –

filter caps

Returns ( [transfer: full]) –

a GstCaps owned by caller

#### 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).

Parameters:

`enc` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`caps` (Gst.Caps) –

initial caps

`filter` (Gst.Caps) –

filter caps

Returns (Gst.Caps) –

a Gst.Caps owned by caller

#### GstVideo.VideoEncoder.proxy_getcaps

    def GstVideo.VideoEncoder.proxy_getcaps (self, caps, filter):
        #python 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).

Parameters:

`enc` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`caps` (Gst.Caps) –

initial caps

`filter` (Gst.Caps) –

filter caps

Returns (Gst.Caps) –

a Gst.Caps owned by caller

#### gst_video_encoder_release_frame

    gst_video_encoder_release_frame (GstVideoEncoder * encoder,
                                     GstVideoCodecFrame * frame)

Removes frame from list of pending frames and releases it, similar to calling gst_video_encoder_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.

Parameters:

`encoder` –

a GstVideoEncoder

`frame` ( [transfer: full]) –

a GstVideoCodecFrame

Since : 1.26

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`frame` (GstVideo.VideoCodecFrame) –

a GstVideo.VideoCodecFrame

Since : 1.26

#### GstVideo.VideoEncoder.release_frame

    def GstVideo.VideoEncoder.release_frame (self, frame):
        #python wrapper for 'gst_video_encoder_release_frame'

Removes frame from list of pending frames and releases it, similar to calling GstVideo.VideoEncoder.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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`frame` (GstVideo.VideoCodecFrame) –

a GstVideo.VideoCodecFrame

Since : 1.26

#### gst_video_encoder_set_allocator

    gst_video_encoder_set_allocator (GstVideoEncoder * encoder,
                                     GstAllocator * allocator,
                                     const GstAllocationParams * params)

Allows GstVideoEncoder sub-classes to set the memory allocator and its params.

Parameters:

`encoder` –

a GstVideoEncoder

`allocator` ( [transfer: full][nullable]) –

the GstAllocator

`params` ( [transfer: none][nullable]) –

the GstAllocationParams of allocator

Since : 1.30

#### GstVideo.VideoEncoder.prototype.set_allocator

    function GstVideo.VideoEncoder.prototype.set_allocator(allocator: Gst.Allocator, params: Gst.AllocationParams): {
        // javascript wrapper for 'gst_video_encoder_set_allocator'
    }

Allows GstVideo.VideoEncoder sub-classes to set the memory allocator and its params.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`allocator` (Gst.Allocator) –

the Gst.Allocator

`params` (Gst.AllocationParams) –

the Gst.AllocationParams of allocator

Since : 1.30

#### GstVideo.VideoEncoder.set_allocator

    def GstVideo.VideoEncoder.set_allocator (self, allocator, params):
        #python wrapper for 'gst_video_encoder_set_allocator'

Allows GstVideo.VideoEncoder sub-classes to set the memory allocator and its params.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`allocator` (Gst.Allocator) –

the Gst.Allocator

`params` (Gst.AllocationParams) –

the Gst.AllocationParams of allocator

Since : 1.30

#### gst_video_encoder_set_headers

    gst_video_encoder_set_headers (GstVideoEncoder * encoder,
                                   GList * headers)

Set the codec headers to be sent downstream whenever requested.

Parameters:

`encoder` –

a GstVideoEncoder

`headers` ( [transfer: full][element-type GstBuffer]) –

a list of GstBuffer containing the codec header

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`headers` ([ Gst.Buffer ]) –

a list of Gst.Buffer containing the codec header

#### GstVideo.VideoEncoder.set_headers

    def GstVideo.VideoEncoder.set_headers (self, headers):
        #python wrapper for 'gst_video_encoder_set_headers'

Set the codec headers to be sent downstream whenever requested.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`headers` ([ Gst.Buffer ]) –

a list of Gst.Buffer containing the codec header

#### gst_video_encoder_set_latency

    gst_video_encoder_set_latency (GstVideoEncoder * encoder,
                                   GstClockTime min_latency,
                                   GstClockTime max_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.

Parameters:

`encoder` –

a GstVideoEncoder

`min_latency` –

minimum latency

`max_latency` –

maximum latency

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`min_latency` (Number) –

minimum latency

`max_latency` (Number) –

maximum latency

#### GstVideo.VideoEncoder.set_latency

    def GstVideo.VideoEncoder.set_latency (self, min_latency, max_latency):
        #python 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`min_latency` (int) –

minimum latency

`max_latency` (int) –

maximum latency

#### gst_video_encoder_set_min_force_key_unit_interval

    gst_video_encoder_set_min_force_key_unit_interval (GstVideoEncoder * encoder,
                                                       GstClockTime 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.

Parameters:

`encoder` –

the encoder

`interval` –

minimum interval

Since : 1.18

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

the encoder

`interval` (Number) –

minimum interval

Since : 1.18

#### GstVideo.VideoEncoder.set_min_force_key_unit_interval

    def GstVideo.VideoEncoder.set_min_force_key_unit_interval (self, interval):
        #python 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

the encoder

`interval` (int) –

minimum interval

Since : 1.18

#### gst_video_encoder_set_min_pts

    gst_video_encoder_set_min_pts (GstVideoEncoder * encoder,
                                   GstClockTime 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

Parameters:

`encoder` –

a GstVideoEncoder

`min_pts` –

minimal PTS that will be passed to handle_frame

Since : 1.6

#### 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

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`min_pts` (Number) –

minimal PTS that will be passed to handle_frame

Since : 1.6

#### GstVideo.VideoEncoder.set_min_pts

    def GstVideo.VideoEncoder.set_min_pts (self, min_pts):
        #python 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

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`min_pts` (int) –

minimal PTS that will be passed to handle_frame

Since : 1.6

#### gst_video_encoder_set_output_state

    GstVideoCodecState *
    gst_video_encoder_set_output_state (GstVideoEncoder * encoder,
                                        GstCaps * caps,
                                        GstVideoCodecState * reference)

Creates a new GstVideoCodecState 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 GstVideoCodecState.

If the subclass wishes to copy over existing fields (like pixel aspect ratio, or framerate) from an existing GstVideoCodecState, 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 GstVideoCodecState.

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

Parameters:

`encoder` –

a GstVideoEncoder

`caps` ( [transfer: full]) –

the GstCaps to use for the output

`reference` ( [nullable][transfer: none]) –

An optional reference GstVideoCodecState

Returns ( [transfer: full][nullable]) –

the newly configured output state.

#### 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().

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`caps` (Gst.Caps) –

the Gst.Caps to use for the output

`reference` (GstVideo.VideoCodecState) –

An optional reference GstVideoCodecState

Returns (GstVideo.VideoCodecState) –

the newly configured output state.

#### GstVideo.VideoEncoder.set_output_state

    def GstVideo.VideoEncoder.set_output_state (self, caps, reference):
        #python 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.finish_frame().

Parameters:

`encoder` (GstVideo.VideoEncoder) –

a GstVideo.VideoEncoder

`caps` (Gst.Caps) –

the Gst.Caps to use for the output

`reference` (GstVideo.VideoCodecState) –

An optional reference GstVideoCodecState

Returns (GstVideo.VideoCodecState) –

the newly configured output state.

#### gst_video_encoder_set_qos_enabled

    gst_video_encoder_set_qos_enabled (GstVideoEncoder * encoder,
                                       gboolean enabled)

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

Parameters:

`encoder` –

the encoder

`enabled` –

the new qos value.

Since : 1.14

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

the encoder

`enabled` (Number) –

the new qos value.

Since : 1.14

#### GstVideo.VideoEncoder.set_qos_enabled

    def GstVideo.VideoEncoder.set_qos_enabled (self, enabled):
        #python wrapper for 'gst_video_encoder_set_qos_enabled'

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

Parameters:

`encoder` (GstVideo.VideoEncoder) –

the encoder

`enabled` (bool) –

the new qos value.

Since : 1.14

### Properties

#### min-force-key-unit-interval

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

Minimum interval between force-keyunit requests in nanoseconds. See gst_video_encoder_set_min_force_key_unit_interval for more details.

Flags : Read / Write

Since : 1.18

#### 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

#### min_force_key_unit_interval

    “self.props.min_force_key_unit_interval” int

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

Flags : Read / Write

Since : 1.18

#### qos

    “qos” gboolean

Flags : Read / Write

#### qos

    “qos” Number

Flags : Read / Write

#### qos

    “self.props.qos” bool

Flags : Read / Write

### Virtual Methods

#### close

    gboolean
    close (GstVideoEncoder * encoder)

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

Parameters:

`encoder` –
No description available
Returns –
No description available

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
Returns (Number) –
No description available

#### do_close

    def do_close (encoder):
        #python implementation of the 'close' virtual method

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

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
Returns (bool) –
No description available

#### decide_allocation

    gboolean
    decide_allocation (GstVideoEncoder * encoder,
                       GstQuery * query)

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.

Parameters:

`encoder` –
No description available
`query` –
No description available
Returns –
No description available

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
`query` (Gst.Query) –
No description available
Returns (Number) –
No description available

#### do_decide_allocation

    def do_decide_allocation (encoder, query):
        #python 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
`query` (Gst.Query) –
No description available
Returns (bool) –
No description available

#### finish

    GstFlowReturn
    finish (GstVideoEncoder * encoder)

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

Parameters:

`encoder` –
No description available
Returns –
No description available

#### 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).

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
Returns (Gst.FlowReturn) –
No description available

#### do_finish

    def do_finish (encoder):
        #python implementation of the 'finish' virtual method

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

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
Returns (Gst.FlowReturn) –
No description available

#### flush

    gboolean
    flush (GstVideoEncoder * encoder)

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

Parameters:

`encoder` –
No description available
Returns –
No description available

#### 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

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
Returns (Number) –
No description available

#### do_flush

    def do_flush (encoder):
        #python implementation of the 'flush' virtual method

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

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
Returns (bool) –
No description available

#### getcaps

    GstCaps *
    getcaps (GstVideoEncoder * enc,
             GstCaps * filter)

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.

Parameters:

`enc` –
No description available
`filter` –
No description available
Returns –
No description available

#### 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.

Parameters:

`enc` (GstVideo.VideoEncoder) –
No description available
`filter` (Gst.Caps) –
No description available
Returns (Gst.Caps) –
No description available

#### do_getcaps

    def do_getcaps (enc, filter):
        #python 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.

Parameters:

`enc` (GstVideo.VideoEncoder) –
No description available
`filter` (Gst.Caps) –
No description available
Returns (Gst.Caps) –
No description available

#### handle_frame

    GstFlowReturn
    handle_frame (GstVideoEncoder * encoder,
                  GstVideoCodecFrame * frame)

Provides input frame to subclass.

Parameters:

`encoder` –
No description available
`frame` –
No description available
Returns –
No description available

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
`frame` (GstVideo.VideoCodecFrame) –
No description available
Returns (Gst.FlowReturn) –
No description available

#### do_handle_frame

    def do_handle_frame (encoder, frame):
        #python implementation of the 'handle_frame' virtual method

Provides input frame to subclass.

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
`frame` (GstVideo.VideoCodecFrame) –
No description available
Returns (Gst.FlowReturn) –
No description available

#### negotiate

    gboolean
    negotiate (GstVideoEncoder * encoder)

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

Parameters:

`encoder` –
No description available
Returns –
No description available

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
Returns (Number) –
No description available

#### do_negotiate

    def do_negotiate (encoder):
        #python 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
Returns (bool) –
No description available

#### open

    gboolean
    open (GstVideoEncoder * encoder)

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

Parameters:

`encoder` –
No description available
Returns –
No description available

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
Returns (Number) –
No description available

#### do_open

    def do_open (encoder):
        #python implementation of the 'open' virtual method

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

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
Returns (bool) –
No description available

#### pre_push

    GstFlowReturn
    pre_push (GstVideoEncoder * encoder,
              GstVideoCodecFrame * frame)

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.

Parameters:

`encoder` –
No description available
`frame` –
No description available
Returns –
No description available

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
`frame` (GstVideo.VideoCodecFrame) –
No description available
Returns (Gst.FlowReturn) –
No description available

#### do_pre_push

    def do_pre_push (encoder, frame):
        #python 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
`frame` (GstVideo.VideoCodecFrame) –
No description available
Returns (Gst.FlowReturn) –
No description available

#### prepare_allocator

    gboolean
    prepare_allocator (GstVideoEncoder * encoder,
                       GstCaps * caps)

Orchestrates GstAllocator configuration for the negotiated caps. Default implementation relies on an Allocation GstQuery & calls `decide_allocation()`.

Parameters:

`encoder` –

the GstVideoEncoder

`caps` –

the negotiated GstCaps

Returns –

whether the GstAllocator could be configured.

Since : 1.30

#### vfunc_prepare_allocator

    function vfunc_prepare_allocator(encoder: GstVideo.VideoEncoder, caps: Gst.Caps): {
        // javascript implementation of the 'prepare_allocator' virtual method
    }

Orchestrates Gst.Allocator configuration for the negotiated caps. Default implementation relies on an Allocation Gst.Query & calls `decide_allocation()`.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

the GstVideo.VideoEncoder

`caps` (Gst.Caps) –

the negotiated Gst.Caps

Returns (Number) –

whether the Gst.Allocator could be configured.

Since : 1.30

#### do_prepare_allocator

    def do_prepare_allocator (encoder, caps):
        #python implementation of the 'prepare_allocator' virtual method

Orchestrates Gst.Allocator configuration for the negotiated caps. Default implementation relies on an Allocation Gst.Query & calls `decide_allocation()`.

Parameters:

`encoder` (GstVideo.VideoEncoder) –

the GstVideo.VideoEncoder

`caps` (Gst.Caps) –

the negotiated Gst.Caps

Returns (bool) –

whether the Gst.Allocator could be configured.

Since : 1.30

#### propose_allocation

    gboolean
    propose_allocation (GstVideoEncoder * encoder,
                        GstQuery * query)

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

Parameters:

`encoder` –
No description available
`query` –
No description available
Returns –
No description available

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
`query` (Gst.Query) –
No description available
Returns (Number) –
No description available

#### do_propose_allocation

    def do_propose_allocation (encoder, query):
        #python 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
`query` (Gst.Query) –
No description available
Returns (bool) –
No description available

#### reset

    gboolean
    reset (GstVideoEncoder * encoder,
           gboolean hard)

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

Parameters:

`encoder` –
No description available
`hard` –
No description available
Returns –
No description available

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
`hard` (Number) –
No description available
Returns (Number) –
No description available

#### do_reset

    def do_reset (encoder, hard):
        #python implementation of the 'reset' virtual method

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

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
`hard` (bool) –
No description available
Returns (bool) –
No description available

#### set_format

    gboolean
    set_format (GstVideoEncoder * encoder,
                GstVideoCodecState * state)

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

Parameters:

`encoder` –
No description available
`state` –
No description available
Returns –
No description available

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
`state` (GstVideo.VideoCodecState) –
No description available
Returns (Number) –
No description available

#### do_set_format

    def do_set_format (encoder, state):
        #python implementation of the 'set_format' virtual method

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

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
`state` (GstVideo.VideoCodecState) –
No description available
Returns (bool) –
No description available

#### sink_event

    gboolean
    sink_event (GstVideoEncoder * encoder,
                GstEvent * event)

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.

Parameters:

`encoder` –
No description available
`event` –
No description available
Returns –
No description available

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
`event` (Gst.Event) –
No description available
Returns (Number) –
No description available

#### do_sink_event

    def do_sink_event (encoder, event):
        #python 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
`event` (Gst.Event) –
No description available
Returns (bool) –
No description available

#### sink_query

    gboolean
    sink_query (GstVideoEncoder * encoder,
                GstQuery * query)

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

Parameters:

`encoder` –
No description available
`query` –
No description available
Returns –
No description available

#### 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

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
`query` (Gst.Query) –
No description available
Returns (Number) –
No description available

#### do_sink_query

    def do_sink_query (encoder, query):
        #python 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

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
`query` (Gst.Query) –
No description available
Returns (bool) –
No description available

#### src_event

    gboolean
    src_event (GstVideoEncoder * encoder,
               GstEvent * event)

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.

Parameters:

`encoder` –
No description available
`event` –
No description available
Returns –
No description available

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
`event` (Gst.Event) –
No description available
Returns (Number) –
No description available

#### do_src_event

    def do_src_event (encoder, event):
        #python 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
`event` (Gst.Event) –
No description available
Returns (bool) –
No description available

#### src_query

    gboolean
    src_query (GstVideoEncoder * encoder,
               GstQuery * query)

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

Parameters:

`encoder` –
No description available
`query` –
No description available
Returns –
No description available

#### 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

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
`query` (Gst.Query) –
No description available
Returns (Number) –
No description available

#### do_src_query

    def do_src_query (encoder, query):
        #python 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

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
`query` (Gst.Query) –
No description available
Returns (bool) –
No description available

#### start

    gboolean
    start (GstVideoEncoder * encoder)

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

Parameters:

`encoder` –
No description available
Returns –
No description available

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
Returns (Number) –
No description available

#### do_start

    def do_start (encoder):
        #python implementation of the 'start' virtual method

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

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
Returns (bool) –
No description available

#### stop

    gboolean
    stop (GstVideoEncoder * encoder)

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

Parameters:

`encoder` –
No description available
Returns –
No description available

#### 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.

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
Returns (Number) –
No description available

#### do_stop

    def do_stop (encoder):
        #python implementation of the 'stop' virtual method

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

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
Returns (bool) –
No description available

#### transform_meta

    gboolean
    transform_meta (GstVideoEncoder * encoder,
                    GstVideoCodecFrame * frame,
                    GstMeta * meta)

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

Parameters:

`encoder` –
No description available
`frame` –
No description available
`meta` –
No description available
Returns –
No description available

#### 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

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
`frame` (GstVideo.VideoCodecFrame) –
No description available
`meta` (Gst.Meta) –
No description available
Returns (Number) –
No description available

#### do_transform_meta

    def do_transform_meta (encoder, frame, meta):
        #python 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

Parameters:

`encoder` (GstVideo.VideoEncoder) –
No description available
`frame` (GstVideo.VideoCodecFrame) –
No description available
`meta` (Gst.Meta) –
No description available
Returns (bool) –
No description available

## Function Macros

### GST_VIDEO_ENCODER_CAST

    #define GST_VIDEO_ENCODER_CAST(enc) ((GstVideoEncoder*)enc)

### GST_VIDEO_ENCODER_INPUT_SEGMENT

    #define GST_VIDEO_ENCODER_INPUT_SEGMENT(obj)     (GST_VIDEO_ENCODER_CAST (obj)->input_segment)

Gives the segment of the element.

Parameters:

`obj` –

base parse instance

### GST_VIDEO_ENCODER_OUTPUT_SEGMENT

    #define GST_VIDEO_ENCODER_OUTPUT_SEGMENT(obj)     (GST_VIDEO_ENCODER_CAST (obj)->output_segment)

Gives the segment of the element.

Parameters:

`obj` –

base parse instance

### GST_VIDEO_ENCODER_SINK_PAD

    #define GST_VIDEO_ENCODER_SINK_PAD(obj)        (((GstVideoEncoder *) (obj))->sinkpad)

Gives the pointer to the sink GstPad object of the element.

Parameters:

`obj` –

a GstVideoEncoder

### GST_VIDEO_ENCODER_SRC_PAD

    #define GST_VIDEO_ENCODER_SRC_PAD(obj)         (((GstVideoEncoder *) (obj))->srcpad)

Gives the pointer to the source GstPad object of the element.

Parameters:

`obj` –

a GstVideoEncoder

### GST_VIDEO_ENCODER_STREAM_LOCK

    #define GST_VIDEO_ENCODER_STREAM_LOCK(encoder) g_rec_mutex_lock (&GST_VIDEO_ENCODER (encoder)->stream_lock)

Obtain a lock to protect the encoder function from concurrent access.

Parameters:

`encoder` –

video encoder instance

### GST_VIDEO_ENCODER_STREAM_UNLOCK

    #define GST_VIDEO_ENCODER_STREAM_UNLOCK(encoder) g_rec_mutex_unlock (&GST_VIDEO_ENCODER (encoder)->stream_lock)

Release the lock that protects the encoder function from concurrent access.

Parameters:

`encoder` –

video encoder instance

## Constants

### GST_TYPE_VIDEO_ENCODER

    #define GST_TYPE_VIDEO_ENCODER \
      (gst_video_encoder_get_type())

### GST_VIDEO_ENCODER_FLOW_DROPPED

    #define GST_VIDEO_ENCODER_FLOW_DROPPED GST_FLOW_CUSTOM_SUCCESS_1

Returned when the event/buffer should be dropped.

deprecated : since 1.8. use gst_video_encoder_finish_frame with a %NULL frame->output_buffer to drop the frame instead.

### GST_VIDEO_ENCODER_FLOW_NEED_DATA

    #define GST_VIDEO_ENCODER_FLOW_NEED_DATA GST_FLOW_CUSTOM_SUCCESS

Returned while parsing to indicate more data is needed.

### GST_VIDEO_ENCODER_SINK_NAME

    #define GST_VIDEO_ENCODER_SINK_NAME    "sink"

The name of the templates for the sink pad.

### GstVideo.VIDEO_ENCODER_SINK_NAME

The name of the templates for the sink pad.

### GstVideo.VIDEO_ENCODER_SINK_NAME

The name of the templates for the sink pad.

### GST_VIDEO_ENCODER_SRC_NAME

    #define GST_VIDEO_ENCODER_SRC_NAME     "src"

The name of the templates for the source pad.

### GstVideo.VIDEO_ENCODER_SRC_NAME

The name of the templates for the source pad.

### GstVideo.VIDEO_ENCODER_SRC_NAME

The name of the templates for the source pad.

The results of the search are