# GstMiniObject

GstMiniObject is a simple structure that can be used to implement refcounted types.

Subclasses will include GstMiniObject as the first member in their structure and then call gst_mini_object_init to initialize the GstMiniObject fields.

gst_mini_object_ref and gst_mini_object_unref increment and decrement the refcount respectively. When the refcount of a mini-object reaches 0, the dispose function is called first and when this returns TRUE, the free function of the miniobject is called.

A copy can be made with gst_mini_object_copy.

gst_mini_object_is_writable will return TRUE when the refcount of the object is exactly 1 and there is no parent or a single parent exists and is writable itself, meaning the current caller has the only reference to the object. gst_mini_object_make_writable will return a writable version of the object, which might be a new copy when the refcount was not 1.

Opaque data can be associated with a GstMiniObject with gst_mini_object_set_qdata and gst_mini_object_get_qdata. The data is meant to be specific to the particular object and is not automatically copied with gst_mini_object_copy or similar methods.

A weak reference can be added and remove with gst_mini_object_weak_ref and gst_mini_object_weak_unref respectively.

## GstMiniObject

Base class for refcounted lightweight objects.

### Members

`type` (GType) –

the GType of the object

`refcount` (gint) –

atomic refcount

`lockstate` (gint) –

atomic state of the locks

`flags` (guint) –

extra flags.

`copy` (GstMiniObjectCopyFunction) –

a copy function

`dispose` (GstMiniObjectDisposeFunction) –

a dispose function

`free` (GstMiniObjectFreeFunction) –

the free function

## Gst.MiniObject

Base class for refcounted lightweight objects.

### Members

`type` (GObject.Type) –

the GType of the object

`refcount` (Number) –

atomic refcount

`lockstate` (Number) –

atomic state of the locks

`flags` (Number) –

extra flags.

`copy` (Gst.MiniObjectCopyFunction) –

a copy function

`dispose` (Gst.MiniObjectDisposeFunction) –

a dispose function

`free` (Gst.MiniObjectFreeFunction) –

the free function

## Gst.MiniObject

Base class for refcounted lightweight objects.

### Members

`type` (GObject.Type) –

the GType of the object

`refcount` (int) –

atomic refcount

`lockstate` (int) –

atomic state of the locks

`flags` (int) –

extra flags.

`copy` (Gst.MiniObjectCopyFunction) –

a copy function

`dispose` (Gst.MiniObjectDisposeFunction) –

a dispose function

`free` (Gst.MiniObjectFreeFunction) –

the free function

### Methods

#### gst_mini_object_add_parent

    gst_mini_object_add_parent (GstMiniObject * object,
                                GstMiniObject * parent)

This adds parent as a parent for object. Having one ore more parents affects the writability of object: if a parent is not writable, object is also not writable, regardless of its refcount. object is only writable if all the parents are writable and its own refcount is exactly 1.

Note: This function does not take ownership of parent and also does not take an additional reference. It is the responsibility of the caller to remove the parent again at a later time.

Parameters:

`object` –

a GstMiniObject

`parent` –

a parent GstMiniObject

Since : 1.16

#### Gst.MiniObject.prototype.add_parent

    function Gst.MiniObject.prototype.add_parent(parent: Gst.MiniObject): {
        // javascript wrapper for 'gst_mini_object_add_parent'
    }

This adds parent as a parent for object. Having one ore more parents affects the writability of object: if a parent is not writable, object is also not writable, regardless of its refcount. object is only writable if all the parents are writable and its own refcount is exactly 1.

Note: This function does not take ownership of parent and also does not take an additional reference. It is the responsibility of the caller to remove the parent again at a later time.

Parameters:

`object` (Gst.MiniObject) –

a Gst.MiniObject

`parent` (Gst.MiniObject) –

a parent Gst.MiniObject

Since : 1.16

#### Gst.MiniObject.add_parent

    def Gst.MiniObject.add_parent (self, parent):
        #python wrapper for 'gst_mini_object_add_parent'

This adds parent as a parent for object. Having one ore more parents affects the writability of object: if a parent is not writable, object is also not writable, regardless of its refcount. object is only writable if all the parents are writable and its own refcount is exactly 1.

Note: This function does not take ownership of parent and also does not take an additional reference. It is the responsibility of the caller to remove the parent again at a later time.

Parameters:

`object` (Gst.MiniObject) –

a Gst.MiniObject

`parent` (Gst.MiniObject) –

a parent Gst.MiniObject

Since : 1.16

#### gst_mini_object_copy

    GstMiniObject *
    gst_mini_object_copy (const GstMiniObject * mini_object)

Creates a copy of the mini-object.

MT safe

Parameters:

`mini_object` –

the mini-object to copy

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

the new mini-object if copying is possible, NULL otherwise.

#### gst_mini_object_get_qdata

    gpointer
    gst_mini_object_get_qdata (GstMiniObject * object,
                               GQuark quark)

This function gets back user data pointers stored via gst_mini_object_set_qdata.

Parameters:

`object` –

The GstMiniObject to get a stored user data pointer from

`quark` –

A GQuark, naming the user data pointer

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

The user data pointer set, or NULL

#### Gst.MiniObject.prototype.get_qdata

    function Gst.MiniObject.prototype.get_qdata(quark: GLib.Quark): {
        // javascript wrapper for 'gst_mini_object_get_qdata'
    }

This function gets back user data pointers stored via Gst.MiniObject.prototype.set_qdata.

Parameters:

`object` (Gst.MiniObject) –

The GstMiniObject to get a stored user data pointer from

`quark` (GLib.Quark) –

A GLib.Quark, naming the user data pointer

Returns (Object) –

The user data pointer set, or null

#### Gst.MiniObject.get_qdata

    def Gst.MiniObject.get_qdata (self, quark):
        #python wrapper for 'gst_mini_object_get_qdata'

This function gets back user data pointers stored via Gst.MiniObject.set_qdata.

Parameters:

`object` (Gst.MiniObject) –

The GstMiniObject to get a stored user data pointer from

`quark` (GLib.Quark) –

A GLib.Quark, naming the user data pointer

Returns (object) –

The user data pointer set, or None

#### gst_mini_object_init

    gst_mini_object_init (GstMiniObject * mini_object,
                          guint flags,
                          GType type,
                          GstMiniObjectCopyFunction copy_func,
                          GstMiniObjectDisposeFunction dispose_func,
                          GstMiniObjectFreeFunction free_func)

Initializes a mini-object with the desired type and copy/dispose/free functions.

Parameters:

`mini_object` –

a GstMiniObject

`flags` –

initial GstMiniObjectFlags

`type` –

the GType of the mini-object to create

`copy_func` ( [allow-none]) –

the copy function, or NULL

`dispose_func` ( [allow-none]) –

the dispose function, or NULL

`free_func` ( [allow-none]) –

the free function or NULL

#### gst_mini_object_is_writable

    gboolean
    gst_mini_object_is_writable (const GstMiniObject * mini_object)

If mini_object has the LOCKABLE flag set, check if the current EXCLUSIVE lock on object is the only one, this means that changes to the object will not be visible to any other object.

If the LOCKABLE flag is not set, check if the refcount of mini_object is exactly 1, meaning that no other reference exists to the object and that the object is therefore writable.

Modification of a mini-object should only be done after verifying that it is writable.

Parameters:

`mini_object` –

the mini-object to check

Returns –

TRUE if the object is writable.

#### Gst.MiniObject.prototype.is_writable

    function Gst.MiniObject.prototype.is_writable(): {
        // javascript wrapper for 'gst_mini_object_is_writable'
    }

If mini_object has the LOCKABLE flag set, check if the current EXCLUSIVE lock on object is the only one, this means that changes to the object will not be visible to any other object.

If the LOCKABLE flag is not set, check if the refcount of mini_object is exactly 1, meaning that no other reference exists to the object and that the object is therefore writable.

Modification of a mini-object should only be done after verifying that it is writable.

Parameters:

`mini_object` (Gst.MiniObject) –

the mini-object to check

Returns (Number) –

true if the object is writable.

#### Gst.MiniObject.is_writable

    def Gst.MiniObject.is_writable (self):
        #python wrapper for 'gst_mini_object_is_writable'

If mini_object has the LOCKABLE flag set, check if the current EXCLUSIVE lock on object is the only one, this means that changes to the object will not be visible to any other object.

If the LOCKABLE flag is not set, check if the refcount of mini_object is exactly 1, meaning that no other reference exists to the object and that the object is therefore writable.

Modification of a mini-object should only be done after verifying that it is writable.

Parameters:

`mini_object` (Gst.MiniObject) –

the mini-object to check

Returns (bool) –

True if the object is writable.

#### gst_mini_object_lock

    gboolean
    gst_mini_object_lock (GstMiniObject * object,
                          GstLockFlags flags)

Lock the mini-object with the specified access mode in flags.

Parameters:

`object` –

the mini-object to lock

`flags` –

GstLockFlags

Returns –

TRUE if object could be locked.

#### Gst.MiniObject.prototype.lock

    function Gst.MiniObject.prototype.lock(flags: Gst.LockFlags): {
        // javascript wrapper for 'gst_mini_object_lock'
    }

Lock the mini-object with the specified access mode in flags.

Parameters:

`object` (Gst.MiniObject) –

the mini-object to lock

`flags` (Gst.LockFlags) –

Gst.LockFlags

Returns (Number) –

true if object could be locked.

#### Gst.MiniObject.lock

    def Gst.MiniObject.lock (self, flags):
        #python wrapper for 'gst_mini_object_lock'

Lock the mini-object with the specified access mode in flags.

Parameters:

`object` (Gst.MiniObject) –

the mini-object to lock

`flags` (Gst.LockFlags) –

Gst.LockFlags

Returns (bool) –

True if object could be locked.

#### gst_mini_object_make_writable

    GstMiniObject *
    gst_mini_object_make_writable (GstMiniObject * mini_object)

Checks if a mini-object is writable. If not, a writable copy is made and returned. This gives away the reference to the original mini object, and returns a reference to the new object.

MT safe

Parameters:

`mini_object` ( [transfer: full]) –

the mini-object to make writable

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

a writable mini-object (which may or may not be the same as mini_object) or NULL if copying is required but not possible.

#### gst_mini_object_ref

    GstMiniObject *
    gst_mini_object_ref (GstMiniObject * mini_object)

Increase the reference count of the mini-object.

Note that the refcount affects the writability of mini-object, see gst_mini_object_is_writable. It is important to note that keeping additional references to GstMiniObject instances can potentially increase the number of memcpy operations in a pipeline, especially if the miniobject is a GstBuffer.

Parameters:

`mini_object` –

the mini-object

Returns ( [transfer: full]) –

the mini-object.

#### gst_mini_object_remove_parent

    gst_mini_object_remove_parent (GstMiniObject * object,
                                   GstMiniObject * parent)

This removes parent as a parent for object. See gst_mini_object_add_parent.

Parameters:

`object` –

a GstMiniObject

`parent` –

a parent GstMiniObject

Since : 1.16

#### Gst.MiniObject.prototype.remove_parent

    function Gst.MiniObject.prototype.remove_parent(parent: Gst.MiniObject): {
        // javascript wrapper for 'gst_mini_object_remove_parent'
    }

This removes parent as a parent for object. See Gst.MiniObject.prototype.add_parent.

Parameters:

`object` (Gst.MiniObject) –

a Gst.MiniObject

`parent` (Gst.MiniObject) –

a parent Gst.MiniObject

Since : 1.16

#### Gst.MiniObject.remove_parent

    def Gst.MiniObject.remove_parent (self, parent):
        #python wrapper for 'gst_mini_object_remove_parent'

This removes parent as a parent for object. See Gst.MiniObject.add_parent.

Parameters:

`object` (Gst.MiniObject) –

a Gst.MiniObject

`parent` (Gst.MiniObject) –

a parent Gst.MiniObject

Since : 1.16

#### gst_mini_object_set_qdata

    gst_mini_object_set_qdata (GstMiniObject * object,
                               GQuark quark,
                               gpointer data,
                               GDestroyNotify destroy)

This sets an opaque, named pointer on a miniobject. The name is specified through a GQuark (retrieved e.g. via g_quark_from_static_string), and the pointer can be gotten back from the object with gst_mini_object_get_qdata until the object is disposed. Setting a previously set user data pointer, overrides (frees) the old pointer set, using NULL as pointer essentially removes the data stored.

destroy may be specified which is called with data as argument when the object is disposed, or the data is being overwritten by a call to gst_mini_object_set_qdata with the same quark.

Parameters:

`object` –

a GstMiniObject

`quark` –

A GQuark, naming the user data pointer

`data` –

An opaque user data pointer

`destroy` –

Function to invoke with data as argument, when data needs to be freed

#### Gst.MiniObject.prototype.set_qdata

    function Gst.MiniObject.prototype.set_qdata(quark: GLib.Quark, data: Object, destroy: GLib.DestroyNotify): {
        // javascript wrapper for 'gst_mini_object_set_qdata'
    }

This sets an opaque, named pointer on a miniobject. The name is specified through a GLib.Quark (retrieved e.g. via GLib.prototype.quark_from_static_string), and the pointer can be gotten back from the object with Gst.MiniObject.prototype.get_qdata until the object is disposed. Setting a previously set user data pointer, overrides (frees) the old pointer set, using null as pointer essentially removes the data stored.

destroy may be specified which is called with data as argument when the object is disposed, or the data is being overwritten by a call to Gst.MiniObject.prototype.set_qdata with the same quark.

Parameters:

`object` (Gst.MiniObject) –

a Gst.MiniObject

`quark` (GLib.Quark) –

A GLib.Quark, naming the user data pointer

`data` (Object) –

An opaque user data pointer

`destroy` (GLib.DestroyNotify) –

Function to invoke with data as argument, when data needs to be freed

#### Gst.MiniObject.set_qdata

    def Gst.MiniObject.set_qdata (self, quark, data, destroy):
        #python wrapper for 'gst_mini_object_set_qdata'

This sets an opaque, named pointer on a miniobject. The name is specified through a GLib.Quark (retrieved e.g. via GLib.quark_from_static_string), and the pointer can be gotten back from the object with Gst.MiniObject.get_qdata until the object is disposed. Setting a previously set user data pointer, overrides (frees) the old pointer set, using None as pointer essentially removes the data stored.

destroy may be specified which is called with data as argument when the object is disposed, or the data is being overwritten by a call to Gst.MiniObject.set_qdata with the same quark.

Parameters:

`object` (Gst.MiniObject) –

a Gst.MiniObject

`quark` (GLib.Quark) –

A GLib.Quark, naming the user data pointer

`data` (object) –

An opaque user data pointer

`destroy` (GLib.DestroyNotify) –

Function to invoke with data as argument, when data needs to be freed

#### gst_mini_object_steal_qdata

    gpointer
    gst_mini_object_steal_qdata (GstMiniObject * object,
                                 GQuark quark)

This function gets back user data pointers stored via gst_mini_object_set_qdata and removes the data from object without invoking its `destroy()` function (if any was set).

Parameters:

`object` –

The GstMiniObject to get a stored user data pointer from

`quark` –

A GQuark, naming the user data pointer

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

The user data pointer set, or NULL

#### Gst.MiniObject.prototype.steal_qdata

    function Gst.MiniObject.prototype.steal_qdata(quark: GLib.Quark): {
        // javascript wrapper for 'gst_mini_object_steal_qdata'
    }

This function gets back user data pointers stored via Gst.MiniObject.prototype.set_qdata and removes the data from object without invoking its `destroy()` function (if any was set).

Parameters:

`object` (Gst.MiniObject) –

The GstMiniObject to get a stored user data pointer from

`quark` (GLib.Quark) –

A GLib.Quark, naming the user data pointer

Returns (Object) –

The user data pointer set, or null

#### Gst.MiniObject.steal_qdata

    def Gst.MiniObject.steal_qdata (self, quark):
        #python wrapper for 'gst_mini_object_steal_qdata'

This function gets back user data pointers stored via Gst.MiniObject.set_qdata and removes the data from object without invoking its `destroy()` function (if any was set).

Parameters:

`object` (Gst.MiniObject) –

The GstMiniObject to get a stored user data pointer from

`quark` (GLib.Quark) –

A GLib.Quark, naming the user data pointer

Returns (object) –

The user data pointer set, or None

#### gst_mini_object_unlock

    gst_mini_object_unlock (GstMiniObject * object,
                            GstLockFlags flags)

Unlock the mini-object with the specified access mode in flags.

Parameters:

`object` –

the mini-object to unlock

`flags` –

GstLockFlags

#### Gst.MiniObject.prototype.unlock

    function Gst.MiniObject.prototype.unlock(flags: Gst.LockFlags): {
        // javascript wrapper for 'gst_mini_object_unlock'
    }

Unlock the mini-object with the specified access mode in flags.

Parameters:

`object` (Gst.MiniObject) –

the mini-object to unlock

`flags` (Gst.LockFlags) –

Gst.LockFlags

#### Gst.MiniObject.unlock

    def Gst.MiniObject.unlock (self, flags):
        #python wrapper for 'gst_mini_object_unlock'

Unlock the mini-object with the specified access mode in flags.

Parameters:

`object` (Gst.MiniObject) –

the mini-object to unlock

`flags` (Gst.LockFlags) –

Gst.LockFlags

#### gst_mini_object_unref

    gst_mini_object_unref (GstMiniObject * mini_object)

Decreases the reference count of the mini-object, possibly freeing the mini-object.

Parameters:

`mini_object` –

the mini-object

#### gst_mini_object_weak_ref

    gst_mini_object_weak_ref (GstMiniObject * object,
                              GstMiniObjectNotify notify,
                              gpointer data)

Adds a weak reference callback to a mini object. Weak references are used for notification when a mini object is finalized. They are called "weak references" because they allow you to safely hold a pointer to the mini object without calling gst_mini_object_ref (gst_mini_object_ref adds a strong reference, that is, forces the object to stay alive).

Parameters:

`object` –

GstMiniObject to reference weakly

`notify` –

callback to invoke before the mini object is freed

`data` –

extra data to pass to notify

#### gst_mini_object_weak_unref

    gst_mini_object_weak_unref (GstMiniObject * object,
                                GstMiniObjectNotify notify,
                                gpointer data)

Removes a weak reference callback from a mini object.

Parameters:

`object` –

GstMiniObject to remove a weak reference from

`notify` –

callback to search for

`data` –

data to search for

### Functions

#### gst_mini_object_replace

    gboolean
    gst_mini_object_replace (GstMiniObject ** olddata,
                             GstMiniObject * newdata)

Atomically modifies a pointer to point to a new mini-object. The reference count of olddata is decreased and the reference count of newdata is increased.

Either newdata and the value pointed to by olddata may be NULL.

Parameters:

`olddata` ( [inout][transfer: full][nullable]) –

pointer to a pointer to a mini-object to be replaced

`newdata` ( [allow-none]) –

pointer to new mini-object

Returns –

TRUE if newdata was different from olddata

#### Gst.prototype.mini_object_replace

    function Gst.prototype.mini_object_replace(olddata: Gst.MiniObject, newdata: Gst.MiniObject): {
        // javascript wrapper for 'gst_mini_object_replace'
    }

Atomically modifies a pointer to point to a new mini-object. The reference count of olddata is decreased and the reference count of newdata is increased.

Either newdata and the value pointed to by olddata may be null.

Parameters:

`olddata` (Gst.MiniObject) –

pointer to a pointer to a mini-object to be replaced

`newdata` (Gst.MiniObject) –

pointer to new mini-object

Returns a tuple made of:

(Number ) –

true if newdata was different from olddata

`olddata` (Gst.MiniObject ) –

true if newdata was different from olddata

#### Gst.mini_object_replace

    def Gst.mini_object_replace (olddata, newdata):
        #python wrapper for 'gst_mini_object_replace'

Atomically modifies a pointer to point to a new mini-object. The reference count of olddata is decreased and the reference count of newdata is increased.

Either newdata and the value pointed to by olddata may be None.

Parameters:

`olddata` (Gst.MiniObject) –

pointer to a pointer to a mini-object to be replaced

`newdata` (Gst.MiniObject) –

pointer to new mini-object

Returns a tuple made of:

(bool ) –

True if newdata was different from olddata

`olddata` (Gst.MiniObject ) –

True if newdata was different from olddata

#### gst_mini_object_steal

    GstMiniObject *
    gst_mini_object_steal (GstMiniObject ** olddata)

Replace the current GstMiniObject pointer to by olddata with NULL and return the old value.

Parameters:

`olddata` ( [inout][transfer: full]) –

pointer to a pointer to a mini-object to be stolen

Returns ( [nullable]) –

the GstMiniObject at oldata

#### gst_mini_object_take

    gboolean
    gst_mini_object_take (GstMiniObject ** olddata,
                          GstMiniObject * newdata)

Modifies a pointer to point to a new mini-object. The modification is done atomically. This version is similar to gst_mini_object_replace except that it does not increase the refcount of newdata and thus takes ownership of newdata.

Either newdata and the value pointed to by olddata may be NULL.

Parameters:

`olddata` ( [inout][transfer: full]) –

pointer to a pointer to a mini-object to be replaced

`newdata` –

pointer to new mini-object

Returns –

TRUE if newdata was different from olddata

#### Gst.prototype.mini_object_take

    function Gst.prototype.mini_object_take(olddata: Gst.MiniObject, newdata: Gst.MiniObject): {
        // javascript wrapper for 'gst_mini_object_take'
    }

Modifies a pointer to point to a new mini-object. The modification is done atomically. This version is similar to Gst.prototype.mini_object_replace except that it does not increase the refcount of newdata and thus takes ownership of newdata.

Either newdata and the value pointed to by olddata may be null.

Parameters:

`olddata` (Gst.MiniObject) –

pointer to a pointer to a mini-object to be replaced

`newdata` (Gst.MiniObject) –

pointer to new mini-object

Returns a tuple made of:

(Number ) –

true if newdata was different from olddata

`olddata` (Gst.MiniObject ) –

true if newdata was different from olddata

#### Gst.mini_object_take

    def Gst.mini_object_take (olddata, newdata):
        #python wrapper for 'gst_mini_object_take'

Modifies a pointer to point to a new mini-object. The modification is done atomically. This version is similar to Gst.mini_object_replace except that it does not increase the refcount of newdata and thus takes ownership of newdata.

Either newdata and the value pointed to by olddata may be None.

Parameters:

`olddata` (Gst.MiniObject) –

pointer to a pointer to a mini-object to be replaced

`newdata` (Gst.MiniObject) –

pointer to new mini-object

Returns a tuple made of:

(bool ) –

True if newdata was different from olddata

`olddata` (Gst.MiniObject ) –

True if newdata was different from olddata

## Functions

### gst_clear_mini_object

    gst_clear_mini_object (GstMiniObject ** object_ptr)

Clears a reference to a GstMiniObject.

object_ptr must not be NULL.

If the reference is NULL then this function does nothing. Otherwise, the reference count of the object is decreased using gst_mini_object_unref and the pointer is set to NULL.

A macro is also included that allows this function to be used without pointer casts.

Parameters:

`object_ptr` –

a pointer to a GstMiniObject reference

Since : 1.16

## Function Macros

### GST_DEFINE_MINI_OBJECT_TYPE

    #define GST_DEFINE_MINI_OBJECT_TYPE(TypeName,type_name) \
       G_DEFINE_BOXED_TYPE(TypeName,type_name,              \
           (GBoxedCopyFunc) gst_mini_object_ref,            \
           (GBoxedFreeFunc) gst_mini_object_unref)

Define a new mini-object type with the given name

Parameters:

`TypeName` –

name of the new type in CamelCase

`type_name` –

name of the new type

### GST_IS_MINI_OBJECT_TYPE

    #define GST_IS_MINI_OBJECT_TYPE(obj,type)  ((obj) && GST_MINI_OBJECT_TYPE(obj) == (type))

### GST_MINI_OBJECT_CAST

    #define GST_MINI_OBJECT_CAST(obj)          ((GstMiniObject*)(obj))

### GST_MINI_OBJECT_CONST_CAST

    #define GST_MINI_OBJECT_CONST_CAST(obj)    ((const GstMiniObject*)(obj))

### GST_MINI_OBJECT_FLAGS

    #define GST_MINI_OBJECT_FLAGS(obj)  (GST_MINI_OBJECT_CAST(obj)->flags)

This macro returns the entire set of flags for the mini-object.

Parameters:

`obj` –

MiniObject to return flags for.

### GST_MINI_OBJECT_FLAG_IS_SET

    #define GST_MINI_OBJECT_FLAG_IS_SET(obj,flag)        !!(GST_MINI_OBJECT_FLAGS (obj) & (flag))

This macro checks to see if the given flag is set.

Parameters:

`obj` –

MiniObject to check for flags.

`flag` –

Flag to check for

### GST_MINI_OBJECT_FLAG_SET

    #define GST_MINI_OBJECT_FLAG_SET(obj,flag)           (GST_MINI_OBJECT_FLAGS (obj) |= (flag))

This macro sets the given bits.

Parameters:

`obj` –

MiniObject to set flag in.

`flag` –

Flag to set, can by any number of bits in guint32.

### GST_MINI_OBJECT_FLAG_UNSET

    #define GST_MINI_OBJECT_FLAG_UNSET(obj,flag)         (GST_MINI_OBJECT_FLAGS (obj) &= ~(flag))

This macro unsets the given bits.

Parameters:

`obj` –

MiniObject to unset flag in.

`flag` –

Flag to set, must be a single bit in guint32.

### GST_MINI_OBJECT_IS_LOCKABLE

    #define GST_MINI_OBJECT_IS_LOCKABLE(obj)  GST_MINI_OBJECT_FLAG_IS_SET(obj, GST_MINI_OBJECT_FLAG_LOCKABLE)

Check if obj is lockable. A lockable object can be locked and unlocked with gst_mini_object_lock and gst_mini_object_unlock.

Parameters:

`obj` –

a GstMiniObject

### GST_MINI_OBJECT_REFCOUNT

    #define GST_MINI_OBJECT_REFCOUNT(obj)           ((GST_MINI_OBJECT_CAST(obj))->refcount)

Get access to the reference count field of the mini-object.

Parameters:

`obj` –

a GstMiniObject

### GST_MINI_OBJECT_REFCOUNT_VALUE

    #define GST_MINI_OBJECT_REFCOUNT_VALUE(obj)     (g_atomic_int_get (&(GST_MINI_OBJECT_CAST(obj))->refcount))

Get the reference count value of the mini-object.

Parameters:

`obj` –

a GstMiniObject

### GST_MINI_OBJECT_TYPE

    #define GST_MINI_OBJECT_TYPE(obj)  (GST_MINI_OBJECT_CAST(obj)->type)

This macro returns the type of the mini-object.

Parameters:

`obj` –

MiniObject to return type for.

## Enumerations

### GstLockFlags

Flags used when locking miniobjects

##### Members

`GST_LOCK_FLAG_READ` (1) –

lock for read access

`GST_LOCK_FLAG_WRITE` (2) –

lock for write access

`GST_LOCK_FLAG_EXCLUSIVE` (4) –

lock for exclusive access

`GST_LOCK_FLAG_LAST` (256) –

first flag that can be used for custom purposes

### Gst.LockFlags

Flags used when locking miniobjects

##### Members

`Gst.LockFlags.READ` (1) –

lock for read access

`Gst.LockFlags.WRITE` (2) –

lock for write access

`Gst.LockFlags.EXCLUSIVE` (4) –

lock for exclusive access

`Gst.LockFlags.LAST` (256) –

first flag that can be used for custom purposes

### Gst.LockFlags

Flags used when locking miniobjects

##### Members

`Gst.LockFlags.READ` (1) –

lock for read access

`Gst.LockFlags.WRITE` (2) –

lock for write access

`Gst.LockFlags.EXCLUSIVE` (4) –

lock for exclusive access

`Gst.LockFlags.LAST` (256) –

first flag that can be used for custom purposes

### GstMiniObjectFlags

Flags for the mini object

##### Members

`GST_MINI_OBJECT_FLAG_LOCKABLE` (1) –

the object can be locked and unlocked with gst_mini_object_lock and gst_mini_object_unlock.

`GST_MINI_OBJECT_FLAG_LOCK_READONLY` (2) –

the object is permanently locked in READONLY mode. Only read locks can be performed on the object.

`GST_MINI_OBJECT_FLAG_MAY_BE_LEAKED` (4) –

the object is expected to stay alive even after gst_deinit has been called and so should be ignored by leak detection tools. (Since: 1.10)

`GST_MINI_OBJECT_FLAG_LAST` (16) –

first flag that can be used by subclasses.

### Gst.MiniObjectFlags

Flags for the mini object

##### Members

`Gst.MiniObjectFlags.LOCKABLE` (1) –

the object can be locked and unlocked with Gst.MiniObject.prototype.lock and Gst.MiniObject.prototype.unlock.

`Gst.MiniObjectFlags.LOCK_READONLY` (2) –

the object is permanently locked in READONLY mode. Only read locks can be performed on the object.

`Gst.MiniObjectFlags.MAY_BE_LEAKED` (4) –

the object is expected to stay alive even after Gst.prototype.deinit has been called and so should be ignored by leak detection tools. (Since: 1.10)

`Gst.MiniObjectFlags.LAST` (16) –

first flag that can be used by subclasses.

### Gst.MiniObjectFlags

Flags for the mini object

##### Members

`Gst.MiniObjectFlags.LOCKABLE` (1) –

the object can be locked and unlocked with Gst.MiniObject.lock and Gst.MiniObject.unlock.

`Gst.MiniObjectFlags.LOCK_READONLY` (2) –

the object is permanently locked in READONLY mode. Only read locks can be performed on the object.

`Gst.MiniObjectFlags.MAY_BE_LEAKED` (4) –

the object is expected to stay alive even after Gst.deinit has been called and so should be ignored by leak detection tools. (Since: 1.10)

`Gst.MiniObjectFlags.LAST` (16) –

first flag that can be used by subclasses.

## Constants

### GST_LOCK_FLAG_READWRITE

    #define GST_LOCK_FLAG_READWRITE  ((GstLockFlags) (GST_LOCK_FLAG_READ | GST_LOCK_FLAG_WRITE))

GstLockFlags value alias for GST_LOCK_FLAG_READ | GST_LOCK_FLAG_WRITE

### Gst.LOCK_FLAG_READWRITE

GstLockFlags value alias for GST_LOCK_FLAG_READ | GST_LOCK_FLAG_WRITE

### Gst.LOCK_FLAG_READWRITE

GstLockFlags value alias for GST_LOCK_FLAG_READ | GST_LOCK_FLAG_WRITE

### GST_TYPE_MINI_OBJECT

    #define GST_TYPE_MINI_OBJECT               (_gst_mini_object_type)

The GType associated with GstMiniObject.

## Callbacks

### GstMiniObjectCopyFunction

    GstMiniObject *
    (*GstMiniObjectCopyFunction) (const GstMiniObject * obj)

Function prototype for methods to create copies of instances.

Parameters:

`obj` –

MiniObject to copy

Returns –

reference to cloned instance.

### Gst.MiniObjectCopyFunction

    function Gst.MiniObjectCopyFunction(obj: Gst.MiniObject): {
        // javascript wrapper for 'GstMiniObjectCopyFunction'
    }

Function prototype for methods to create copies of instances.

Parameters:

`obj` (Gst.MiniObject) –

MiniObject to copy

Returns (Gst.MiniObject) –

reference to cloned instance.

### Gst.MiniObjectCopyFunction

    def Gst.MiniObjectCopyFunction (obj):
        #python wrapper for 'GstMiniObjectCopyFunction'

Function prototype for methods to create copies of instances.

Parameters:

`obj` (Gst.MiniObject) –

MiniObject to copy

Returns (Gst.MiniObject) –

reference to cloned instance.

### GstMiniObjectDisposeFunction

    gboolean
    (*GstMiniObjectDisposeFunction) (GstMiniObject * obj)

Function prototype for when a miniobject has lost its last refcount. Implementation of the mini object are allowed to revive the passed object by doing a gst_mini_object_ref. If the object is not revived after the dispose function, the function should return TRUE and the memory associated with the object is freed.

Parameters:

`obj` –

MiniObject to dispose

Returns –

TRUE if the object should be cleaned up.

### Gst.MiniObjectDisposeFunction

    function Gst.MiniObjectDisposeFunction(obj: Gst.MiniObject): {
        // javascript wrapper for 'GstMiniObjectDisposeFunction'
    }

Function prototype for when a miniobject has lost its last refcount. Implementation of the mini object are allowed to revive the passed object by doing a gst_mini_object_ref (not introspectable). If the object is not revived after the dispose function, the function should return true and the memory associated with the object is freed.

Parameters:

`obj` (Gst.MiniObject) –

MiniObject to dispose

Returns (Number) –

true if the object should be cleaned up.

### Gst.MiniObjectDisposeFunction

    def Gst.MiniObjectDisposeFunction (obj):
        #python wrapper for 'GstMiniObjectDisposeFunction'

Function prototype for when a miniobject has lost its last refcount. Implementation of the mini object are allowed to revive the passed object by doing a gst_mini_object_ref (not introspectable). If the object is not revived after the dispose function, the function should return True and the memory associated with the object is freed.

Parameters:

`obj` (Gst.MiniObject) –

MiniObject to dispose

Returns (bool) –

True if the object should be cleaned up.

### GstMiniObjectFreeFunction

    (*GstMiniObjectFreeFunction) (GstMiniObject * obj)

Virtual function prototype for methods to free resources used by mini-objects.

Parameters:

`obj` –

MiniObject to free

### Gst.MiniObjectFreeFunction

    function Gst.MiniObjectFreeFunction(obj: Gst.MiniObject): {
        // javascript wrapper for 'GstMiniObjectFreeFunction'
    }

Virtual function prototype for methods to free resources used by mini-objects.

Parameters:

`obj` (Gst.MiniObject) –

MiniObject to free

### Gst.MiniObjectFreeFunction

    def Gst.MiniObjectFreeFunction (obj):
        #python wrapper for 'GstMiniObjectFreeFunction'

Virtual function prototype for methods to free resources used by mini-objects.

Parameters:

`obj` (Gst.MiniObject) –

MiniObject to free

### GstMiniObjectNotify

    (*GstMiniObjectNotify) (gpointer user_data,
                            GstMiniObject * obj)

A GstMiniObjectNotify function can be added to a mini object as a callback that gets triggered when gst_mini_object_unref drops the last ref and obj is about to be freed.

Parameters:

`user_data` –

data that was provided when the notify was added

`obj` –

the mini object

### Gst.MiniObjectNotify

    function Gst.MiniObjectNotify(user_data: Object, obj: Gst.MiniObject): {
        // javascript wrapper for 'GstMiniObjectNotify'
    }

A Gst.MiniObjectNotify function can be added to a mini object as a callback that gets triggered when gst_mini_object_unref (not introspectable) drops the last ref and obj is about to be freed.

Parameters:

`user_data` (Object) –

data that was provided when the notify was added

`obj` (Gst.MiniObject) –

the mini object

### Gst.MiniObjectNotify

    def Gst.MiniObjectNotify (*user_data, obj):
        #python wrapper for 'GstMiniObjectNotify'

A Gst.MiniObjectNotify function can be added to a mini object as a callback that gets triggered when gst_mini_object_unref (not introspectable) drops the last ref and obj is about to be freed.

Parameters:

`user_data` (variadic) –

data that was provided when the notify was added

`obj` (Gst.MiniObject) –

the mini object

The results of the search are