[−][src]Trait gstreamer_editing_services::prelude::PadExt

pub trait PadExt: 'static {
    fn activate_mode(
        &self, 
        mode: PadMode, 
        active: bool
    ) -> Result<(), BoolError>;

    fn can_link<P>(&self, sinkpad: &P) -> bool
    where
        P: IsA<Pad>;

    fn check_reconfigure(&self) -> bool;

    fn create_stream_id<P>(
        &self, 
        parent: &P, 
        stream_id: Option<&str>
    ) -> Option<GString>
    where
        P: IsA<Element>;

    fn forward<P>(&self, forward: P) -> bool
    where
        P: FnMut(&Pad) -> bool;

    fn get_allowed_caps(&self) -> Option<Caps>;

    fn get_current_caps(&self) -> Option<Caps>;

    fn get_direction(&self) -> PadDirection;

    fn get_offset(&self) -> i64;

    fn get_pad_template(&self) -> Option<PadTemplate>;

    fn get_pad_template_caps(&self) -> Option<Caps>;

    fn get_parent_element(&self) -> Option<Element>;

    fn get_peer(&self) -> Option<Pad>;

    fn get_single_internal_link(&self) -> Option<Pad>;

    fn get_sticky_event(&self, event_type: EventType, idx: u32) -> Option<Event>;

    fn get_stream(&self) -> Option<Stream>;

    fn get_stream_id(&self) -> Option<GString>;

    fn get_task_state(&self) -> TaskState;

    fn has_current_caps(&self) -> bool;

    fn is_active(&self) -> bool;

    fn is_blocked(&self) -> bool;

    fn is_blocking(&self) -> bool;

    fn is_linked(&self) -> bool;

    fn link_maybe_ghosting<P>(&self, sink: &P) -> Result<(), BoolError>
    where
        P: IsA<Pad>;

    fn link_maybe_ghosting_full<P>(
        &self, 
        sink: &P, 
        flags: PadLinkCheck
    ) -> Result<(), BoolError>
    where
        P: IsA<Pad>;

    fn mark_reconfigure(&self);

    fn needs_reconfigure(&self) -> bool;

    fn pause_task(&self) -> Result<(), BoolError>;

    fn peer_query_accept_caps(&self, caps: &Caps) -> bool;

    fn peer_query_caps(&self, filter: Option<&Caps>) -> Option<Caps>;

    fn query_accept_caps(&self, caps: &Caps) -> bool;

    fn query_caps(&self, filter: Option<&Caps>) -> Option<Caps>;

    fn set_active(&self, active: bool) -> Result<(), BoolError>;

    fn set_offset(&self, offset: i64);

    fn stop_task(&self) -> Result<(), BoolError>;

    fn unlink<P>(&self, sinkpad: &P) -> Result<(), BoolError>
    where
        P: IsA<Pad>;

    fn use_fixed_caps(&self);

    fn get_property_caps(&self) -> Option<Caps>;

    fn connect_linked<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Send + Sync + Fn(&Self, &Pad);

    fn connect_unlinked<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Send + Sync + Fn(&Self, &Pad);

    fn connect_property_caps_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Send + Sync + Fn(&Self);

    fn connect_property_offset_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Send + Sync + Fn(&Self);
}

Trait containing all Pad methods.

Implementors

Pad, ProxyPad

Required methods

fn activate_mode(&self, mode: PadMode, active: bool) -> Result<(), BoolError>

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

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

mode

the requested activation mode

active

whether or not the pad should be active.

Returns

true if the operation was successful.

MT safe.

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

sinkpad

the sink Pad.

Returns

true if the pads can be linked.

fn check_reconfigure(&self) -> bool

Check and clear the PadFlags::NeedReconfigure flag on self and return true if the flag was set.

Returns

true is the GST_PAD_FLAG_NEED_RECONFIGURE flag was set on self.

fn create_stream_id<P>(
    &self,
    parent: &P,
    stream_id: Option<&str>
) -> Option<GString> where
    P: IsA<Element>, 

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

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

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

parent

Parent Element of self

stream_id

The stream-id

Returns

A stream-id for self. g_free after usage.

fn forward<P>(&self, forward: P) -> bool where
    P: FnMut(&Pad) -> bool, 

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

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

forward

a GstPadForwardFunction

user_data

user data passed to forward

Returns

true if one of the dispatcher functions returned true.

fn get_allowed_caps(&self) -> Option<Caps>

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

The allowed capabilities is calculated as the intersection of the results of calling PadExt::query_caps on self and its peer. The caller owns a reference on the resulting caps.

Returns

the allowed Caps of the pad link. Unref the caps when you no longer need it. This function returns None when self has no peer.

MT safe.

fn get_current_caps(&self) -> Option<Caps>

Gets the capabilities currently configured on self with the last EventType::Caps event.

Returns

the current caps of the pad with incremented ref-count or None when pad has no caps. Unref after usage.

fn get_direction(&self) -> PadDirection

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

Returns

the PadDirection of the pad.

MT safe.

fn get_offset(&self) -> i64

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

Returns

the offset.

fn get_pad_template(&self) -> Option<PadTemplate>

Gets the template for self.

Returns

the PadTemplate from which this pad was instantiated, or None if this pad has no template. Unref after usage.

fn get_pad_template_caps(&self) -> Option<Caps>

Gets the capabilities for self's template.

Returns

the Caps of this pad template. Unref after usage.

fn get_parent_element(&self) -> Option<Element>

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

Returns

the parent of the pad. The caller has a reference on the parent, so unref when you're finished with it.

MT safe.

fn get_peer(&self) -> Option<Pad>

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

Returns

the peer Pad. Unref after usage.

MT safe.

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

Feature: v1_18

Returns

a Pad, or None if self has none or more than one internal links. Unref returned pad with GstObjectExt::unref.

fn get_sticky_event(&self, event_type: EventType, idx: u32) -> Option<Event>

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

event_type

the EventType that should be retrieved.

idx

the index of the event

Returns

a Event of type event_type or None when no event of event_type was on self. Unref after usage.

fn get_stream(&self) -> Option<Stream>

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

This is a convenience wrapper around PadExt::get_sticky_event and Event::parse_stream.

Feature: v1_10

Returns

the current Stream for self, or None. unref the returned stream when no longer needed.

fn get_stream_id(&self) -> Option<GString>

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

This is a convenience wrapper around PadExt::get_sticky_event and Event::parse_stream_start.

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

Returns

a newly-allocated copy of the stream-id for self, or None. g_free the returned string when no longer needed.

fn get_task_state(&self) -> TaskState

Get self task state. If no task is currently set, TaskState::Stopped is returned.

Feature: v1_12

Returns

The current state of self's task.

fn has_current_caps(&self) -> bool

Check if self has caps set on it with a EventType::Caps event.

Returns

true when self has caps associated with it.

fn is_active(&self) -> bool

Query if a pad is active

Returns

true if the pad is active.

MT safe.

fn is_blocked(&self) -> bool

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

Returns

true if the pad is blocked.

MT safe.

fn is_blocking(&self) -> bool

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

Returns

true if the pad is blocking.

MT safe.

fn is_linked(&self) -> bool

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

Returns

true if the pad is linked, false otherwise.

MT safe.

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

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

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

Feature: v1_10

sink

a Pad

Returns

whether the link succeeded.

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

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

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

Calling PadExt::link_maybe_ghosting_full with flags == PadLinkCheck::Default is the recommended way of linking pads with safety checks applied.

Feature: v1_10

sink

a Pad

flags

some PadLinkCheck flags

Returns

whether the link succeeded.

fn mark_reconfigure(&self)

Mark a pad for needing reconfiguration. The next call to PadExt::check_reconfigure will return true after this call.

fn needs_reconfigure(&self) -> bool

Check the PadFlags::NeedReconfigure flag on self and return true if the flag was set.

Returns

true is the GST_PAD_FLAG_NEED_RECONFIGURE flag is set on self.

fn pause_task(&self) -> Result<(), BoolError>

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

Returns

a true if the task could be paused or false when the pad has no task.

fn peer_query_accept_caps(&self, caps: &Caps) -> bool

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

caps

a Caps to check on the pad

Returns

true if the peer of self can accept the caps or self has no peer.

fn peer_query_caps(&self, filter: Option<&Caps>) -> Option<Caps>

Gets the capabilities of the peer connected to this pad. Similar to PadExt::query_caps.

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

filter

a Caps filter, or None.

Returns

the caps of the peer pad with incremented ref-count. When there is no peer pad, this function returns filter or, when filter is None, ANY caps.

fn query_accept_caps(&self, caps: &Caps) -> bool

Check if the given pad accepts the caps.

caps

a Caps to check on the pad

Returns

true if the pad can accept the caps.

fn query_caps(&self, filter: Option<&Caps>) -> Option<Caps>

Gets the capabilities this pad can produce or consume. Note that this method doesn't necessarily return the caps set by sending a Event::new_caps - use PadExt::get_current_caps for that instead. gst_pad_query_caps returns all possible caps a pad can operate with, using the pad's CAPS query function, If the query fails, this function will return filter, if not None, otherwise ANY.

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

Note that this function does not return writable Caps, use gst_caps_make_writable before modifying the caps.

filter

suggested Caps, or None

Returns

the caps of the pad with incremented ref-count.

fn set_active(&self, active: bool) -> Result<(), BoolError>

Activates or deactivates the given pad. Normally called from within core state change functions.

If active, makes sure the pad is active. If it is already active, either in push or pull mode, just return. Otherwise dispatches to the pad's activate function to perform the actual activation.

If not active, calls PadExt::activate_mode with the pad's current mode and a false argument.

active

whether or not the pad should be active.

Returns

true if the operation was successful.

MT safe.

fn set_offset(&self, offset: i64)

Set the offset that will be applied to the running time of self.

offset

the offset

fn stop_task(&self) -> Result<(), BoolError>

Stop the task of self. This function will also make sure that the function executed by the task will effectively stop if not called from the GstTaskFunction.

This function will deadlock if called from the GstTaskFunction of the task. Use Task::pause instead.

Regardless of whether the pad has a task, the stream lock is acquired and released so as to ensure that streaming through this pad has finished.

Returns

a true if the task could be stopped or false on error.

Unlinks the source pad from the sink pad. Will emit the Pad::unlinked signal on both pads.

sinkpad

the sink Pad to unlink.

Returns

true if the pads were unlinked. This function returns false if the pads were not linked together.

MT safe.

fn use_fixed_caps(&self)

A helper function you can use that sets the FIXED_CAPS flag This way the default CAPS query will always return the negotiated caps or in case the pad is not negotiated, the padtemplate caps.

The negotiated caps are the caps of the last CAPS event that passed on the pad. Use this function on a pad that, once it negotiated to a CAPS, cannot be renegotiated to something else.

fn get_property_caps(&self) -> Option<Caps>

fn connect_linked<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Send + Sync + Fn(&Self, &Pad), 

Signals that a pad has been linked to the peer pad.

peer

the peer pad that has been connected

fn connect_unlinked<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Send + Sync + Fn(&Self, &Pad), 

Signals that a pad has been unlinked from the peer pad.

peer

the peer pad that has been disconnected

fn connect_property_caps_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Send + Sync + Fn(&Self), 

fn connect_property_offset_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Send + Sync + Fn(&Self), 

Loading content...

Implementors

impl<O> PadExt for O where
    O: IsA<Pad>, [src]

Loading content...