Class: Gst::Object

Inherits:
GObject::InitiallyUnowned
  • Object
show all
Defined in:
(unknown)

Overview

GStreamer base object class.

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.check_uniqueness(list, name) ⇒ Boolean

Checks to see if there is any object named name in list. This function does not do any locking of any kind. You might want to protect the provided list with the lock of the owner of the list. This function will lock each Gst::Object in the list to compare the name, so be careful when passing a list with a locked object. false if it does.

MT safe. Grabs and releases the LOCK of each object in the list.

Parameters:

  • list (GLib::List<Gst::Object>) —

    a list of Gst::Object to check through

  • name (String) —

    the name to search for

Returns:

  • (Boolean) —

    true if a Gst::Object named name does not appear in list,

.default_deep_notify(object, orig, pspec, excluded_props) ⇒ nil

A default deep_notify signal callback for an object. The user data should contain a pointer to an array of strings that should be excluded from the notify. The default handler will print the new value of the property using g_print.

MT safe. This function grabs and releases object's LOCK for getting its path string.

Parameters:

  • object (GObject::Object) —

    the #GObject that signalled the notify.

  • orig (Gst::Object) —

    a Gst::Object that initiated the notify.

  • pspec (GObject::ParamSpec) —

    a GParam::Spec of the property.

  • excluded_props (Array<String>) —

    a set of user-specified properties to exclude or nil to show all changes.

Returns:

  • (nil)

.ref_sink(object) ⇒ GObject

Increase the reference count of object, and possibly remove the floating reference, if object has a floating reference.

In other words, if the object is floating, then this call "assumes ownership" of the floating reference, converting it to a normal reference by clearing the floating flag while leaving the reference count unchanged. If the object is not floating, then this call adds a new normal reference increasing the reference count by one.

For more background on "floating references" please see the #GObject documentation.

Parameters:

  • object (GObject) —

    a Gst::Object to sink

Returns:

  • (GObject)

.replace(oldobj, newobj) ⇒ Boolean

Atomically modifies a pointer to point to a new object. The reference count of oldobj is decreased and the reference count of newobj is increased.

Either newobj and the value pointed to by oldobj may be nil.

Parameters:

  • oldobj (Gst::Object) —

    pointer to a place of a Gst::Object to replace

  • newobj (Gst::Object) —

    a new Gst::Object

Returns:

  • (Boolean) —

    true if newobj was different from oldobj

Instance Method Details

#add_control_binding(binding) ⇒ Boolean

Attach the Gst::ControlBinding to the object. If there already was a Gst::ControlBinding for this property it will be replaced.

The object's reference count will be incremented, and any floating reference will be removed (see gst_object_ref_sink()) has been setup for a non suitable property, true otherwise.

Parameters:

Returns:

  • (Boolean) —

    false if the given binding has not been setup for this object or

#control_bindings_disabled=(disabled) ⇒ nil

This function is used to disable all controlled properties of the object for some time, i.e. gst_object_sync_values() will do nothing. or not.

Parameters:

  • disabled (Boolean) —

    boolean that specifies whether to disable the controller

Returns:

  • (nil)

#control_rate ⇒ Gst::ClockTime

Obtain the control-rate for this object. Audio processing Gst::Element objects will use this rate to sub-divide their processing loop and call gst_object_sync_values() in between. The length of the processing segment should be up to control-rate nanoseconds.

If the object is not under property control, this will return %GST_CLOCK_TIME_NONE. This allows the element to avoid the sub-dividing.

The control-rate is not expected to change if the element is in %GST_STATE_PAUSED or %GST_STATE_PLAYING.

Returns:

  • (Gst::ClockTime) —

    the control rate in nanoseconds

#control_rate=(control_rate) ⇒ nil

Change the control-rate for this object. Audio processing Gst::Element objects will use this rate to sub-divide their processing loop and call gst_object_sync_values() in between. The length of the processing segment should be up to control-rate nanoseconds.

The control-rate should not change if the element is in %GST_STATE_PAUSED or %GST_STATE_PLAYING.

Parameters:

  • control_rate (Gst::ClockTime) —

    the new control-rate in nanoseconds.

Returns:

  • (nil)

#default_error(error, debug) ⇒ nil

A default error function that uses g_printerr() to display the error message and the optional debug string..

The default handler will simply print the error string using g_print.

Parameters:

  • error (GLib::Error) —

    the GError.

  • debug (String) —

    an additional debug information string, or nil

Returns:

  • (nil)

#get_control_binding(property_name) ⇒ Gst::ControlBinding

Gets the corresponding Gst::ControlBinding for the property. This should be unreferenced again after use. property_name or nil if the property is not controlled.

Parameters:

  • property_name (String) —

    name of the property

Returns:

#get_g_value_array(property_name, timestamp, interval, n_values, values) ⇒ Boolean

Gets a number of #GValues for the given controlled property starting at the requested time. The array values need to hold enough space for n_values of #GValue.

This function is useful if one wants to e.g. draw a graph of the control curve or apply a control curve sample by sample.

Parameters:

  • property_name (String) —

    the name of the property to get

  • timestamp (Gst::ClockTime) —

    the time that should be processed

  • interval (Gst::ClockTime) —

    the time spacing between subsequent values

  • n_values (Integer) —

    the number of values

  • values (Array<GObject::Value>) —

    array to put control-values in

Returns:

  • (Boolean) —

    true if the given array could be filled, false otherwise

#get_value(property_name, timestamp) ⇒ GObject::Value

Gets the value for the given controlled property at the requested time. or nil if the property isn't controlled.

Parameters:

  • property_name (String) —

    the name of the property to get

  • timestamp (Gst::ClockTime) —

    the time the control-change should be read from

Returns:

  • (GObject::Value) —

    the GValue of the property at the given time,

#get_value_array(property_name, timestamp, interval, n_values, values) ⇒ Boolean

Gets a number of values for the given controlled property starting at the requested time. The array values need to hold enough space for n_values of the same type as the objects property's type.

This function is useful if one wants to e.g. draw a graph of the control curve or apply a control curve sample by sample.

The values are unboxed and ready to be used. The similar function gst_object_get_g_value_array() returns the array as #GValues and is better suites for bindings.

Parameters:

  • property_name (String) —

    the name of the property to get

  • timestamp (Gst::ClockTime) —

    the time that should be processed

  • interval (Gst::ClockTime) —

    the time spacing between subsequent values

  • n_values (Integer) —

    the number of values

  • values (Array<GObject>) —

    array to put control-values in

Returns:

  • (Boolean) —

    true if the given array could be filled, false otherwise

#has_active_control_bindings ⇒ Boolean

Check if the object has active controlled properties.

Returns:

  • (Boolean) —

    true if the object has active controlled properties

#has_ancestor(ancestor) ⇒ Boolean

Check if object has an ancestor ancestor somewhere up in the hierarchy. One can e.g. check if a Gst::Element is inside a #GstPipeline.

Parameters:

  • ancestor (Gst::Object) —

    a Gst::Object to check as ancestor

Returns:

  • (Boolean) —

    true if ancestor is an ancestor of object.

#has_as_ancestor(ancestor) ⇒ Boolean

Check if object has an ancestor ancestor somewhere up in the hierarchy. One can e.g. check if a Gst::Element is inside a #GstPipeline. MT safe. Grabs and releases object's locks.

Parameters:

  • ancestor (Gst::Object) —

    a Gst::Object to check as ancestor

Returns:

  • (Boolean) —

    true if ancestor is an ancestor of object.

#has_as_parent(parent) ⇒ Boolean

Check if parent is the parent of object. E.g. a Gst::Element can check if it owns a given #GstPad. MT safe. Grabs and releases object's locks.

Parameters:

  • parent (Gst::Object) —

    a Gst::Object to check as parent

Returns:

  • (Boolean) —

    false if either object or parent is nil. true if parent is the parent of object. Otherwise false.

#name ⇒ String

Returns name.

Returns:

  • (String) —

    name

#name=(name) ⇒ String

Parameters:

  • name (String)

Returns:

  • (String) —

    name

  • (String) —

    name

#parent ⇒ Gst::Object

The parent of the object. Please note, that when changing the 'parent' property, we don't emit #GObject::notify and Gst::Object::deep-notify signals due to locking issues. In some cases one can use Gst::Bin::element-added or #GstBin::element-removed signals on the parent to achieve a similar effect.

Returns:

#parent=(parent) ⇒ Gst::Object

The parent of the object. Please note, that when changing the 'parent' property, we don't emit #GObject::notify and Gst::Object::deep-notify signals due to locking issues. In some cases one can use Gst::Bin::element-added or #GstBin::element-removed signals on the parent to achieve a similar effect.

Parameters:

Returns:

#path_string ⇒ String

Generates a string describing the path of object in the object hierarchy. Only useful (or used) for debugging.

Free-function: g_free MT safe. Grabs and releases the Gst::Object's LOCK for all objects in the hierarchy.

Returns:

  • (String) —

    a string describing the path of object. You must g_free() the string after usage.

#ref ⇒ Gst::Object

Increments the reference count on object. This function does not take the lock on object because it relies on atomic refcounting.

This object returns the input parameter to ease writing constructs like : result = gst_object_ref (object->parent);

Returns:

#remove_control_binding(binding) ⇒ Boolean

Removes the corresponding Gst::ControlBinding. If it was the last ref of the binding, it will be disposed.

Parameters:

Returns:

  • (Boolean) —

    true if the binding could be removed.

#set_control_binding_disabled(property_name, disabled) ⇒ nil

This function is used to disable the control bindings on a property for some time, i.e. gst_object_sync_values() will do nothing for the property. or not.

Parameters:

  • property_name (String) —

    property to disable

  • disabled (Boolean) —

    boolean that specifies whether to disable the controller

Returns:

  • (nil)

#suggest_next_sync ⇒ Gst::ClockTime

Returns a suggestion for timestamps where buffers should be split to get best controller results. if no control-rate was set.

Returns:

  • (Gst::ClockTime) —

    Returns the suggested timestamp or %GST_CLOCK_TIME_NONE

#sync_values(timestamp) ⇒ Boolean

Sets the properties of the object, according to the Gst::ControlSources that (maybe) handle them and for the given timestamp.

If this function fails, it is most likely the application developers fault. Most probably the control sources are not setup correctly. properties, false otherwise

Parameters:

  • timestamp (Gst::ClockTime) —

    the time that should be processed

Returns:

  • (Boolean) —

    true if the controller values could be applied to the object

#unparent ⇒ nil

Clear the parent of object, removing the associated reference. This function decreases the refcount of object.

MT safe. Grabs and releases object's lock.

Returns:

  • (nil)

#unref ⇒ nil

Decrements the reference count on object. If reference count hits zero, destroy object. This function does not take the lock on object as it relies on atomic refcounting.

The unref method should never be called with the LOCK held since this might deadlock the dispose function.

Returns:

  • (nil)