## GstMiniObject GstMiniObject — Lightweight base class for the GStreamer object hierarchy |

## Synopsis

    #include <gst/gst.h>

                        GstMiniObject;
    enum                GstMiniObjectFlags;
    GstMiniObject *     (*GstMiniObjectCopyFunction)        (const GstMiniObject *obj);
    void                (*GstMiniObjectFinalizeFunction)    (GstMiniObject *obj);
    #define             GST_MINI_OBJECT_FLAGS               (obj)
    #define             GST_MINI_OBJECT_FLAG_IS_SET         (obj,
                                                             flag)
    #define             GST_MINI_OBJECT_FLAG_SET            (obj,
                                                             flag)
    #define             GST_MINI_OBJECT_FLAG_UNSET          (obj,
                                                             flag)
    #define             GST_MINI_OBJECT_REFCOUNT            (obj)
    #define             GST_MINI_OBJECT_REFCOUNT_VALUE      (obj)
    GstMiniObject*      gst_mini_object_new                 (GType type);
    GstMiniObject*      gst_mini_object_copy                (const GstMiniObject *mini_object);
    gboolean            gst_mini_object_is_writable         (const GstMiniObject *mini_object);
    GstMiniObject*      gst_mini_object_make_writable       (GstMiniObject *mini_object);
    GstMiniObject*      gst_mini_object_ref                 (GstMiniObject *mini_object);
    void                gst_mini_object_unref               (GstMiniObject *mini_object);
    void                gst_mini_object_replace             (GstMiniObject **olddata,
                                                             GstMiniObject *newdata);
                        GstParamSpecMiniObject;
    GParamSpec*         gst_param_spec_mini_object          (const char *name,
                                                             const char *nick,
                                                             const char *blurb,
                                                             GType object_type,
                                                             GParamFlags flags);
    void                gst_value_set_mini_object           (GValue *value,
                                                             GstMiniObject *mini_object);
    void                gst_value_take_mini_object          (GValue *value,
                                                             GstMiniObject *mini_object);
    GstMiniObject*      gst_value_get_mini_object           (const GValue *value);
    GstMiniObject*      gst_value_dup_mini_object           (const GValue *value);

## Description

GstMiniObject is a baseclass like GObject, but has been stripped down of features to be fast and small. It offers sub-classing and ref-counting in the same way as GObject does. It has no properties and no signal-support though.

Last reviewed on 2005-11-23 (0.9.5)

## Details

### GstMiniObject

    typedef struct {
      GTypeInstance instance;
      gint refcount;
      guint flags;
    } GstMiniObject;

Base class for refcounted lightweight objects. Ref Func: gst_mini_object_ref Unref Func: gst_mini_object_unref Set Value Func: gst_value_set_mini_object Get Value Func: gst_value_get_mini_object

GTypeInstance `instance`; | type instance
gint `refcount`; | atomic refcount
guint `flags`; | extra flags.

### enum GstMiniObjectFlags

    typedef enum
    {
      GST_MINI_OBJECT_FLAG_READONLY = (1<<0),
      /* padding */
      GST_MINI_OBJECT_FLAG_LAST = (1<<4)
    } GstMiniObjectFlags;

Flags for the padtemplate

`GST_MINI_OBJECT_FLAG_READONLY` | is the miniobject readonly or writable
`GST_MINI_OBJECT_FLAG_LAST` | first flag that can be used by subclasses.

### GstMiniObjectCopyFunction ()

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

Virtual function prototype for methods to create copies of instances.

`obj` : | MiniObject to copy
Returns : | reference to cloned instance.

### GstMiniObjectFinalizeFunction ()

    void                (*GstMiniObjectFinalizeFunction)    (GstMiniObject *obj);

Virtual function prototype for methods to free ressources used by mini-objects. Subclasses 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 finalize function, the memory associated with the object is freed.

`obj` : | MiniObject to finalize

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

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

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

`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 usets the given bits.

`obj` : | MiniObject to unset flag in.
`flag` : | Flag to set, must be a single bit in guint32.

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

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

`obj` : | a GstMiniObject

### gst_mini_object_new ()

    GstMiniObject*      gst_mini_object_new                 (GType type);

Creates a new mini-object of the desired type.

MT safe

`type` : | the GType of the mini-object to create
Returns : | the new mini-object.

### gst_mini_object_copy ()

    GstMiniObject*      gst_mini_object_copy                (const GstMiniObject *mini_object);

Creates a copy of the mini-object.

MT safe

`mini_object` : | the mini-object to copy
Returns : | the new mini-object.

### gst_mini_object_is_writable ()

    gboolean            gst_mini_object_is_writable         (const GstMiniObject *mini_object);

Checks if a mini-object is writable. A mini-object is writable if the reference count is one and the GST_MINI_OBJECT_FLAG_READONLY flag is not set. Modification of a mini-object should only be done after verifying that it is writable.

MT safe

`mini_object` : | the mini-object to check
Returns : | TRUE if the object is writable.

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

`mini_object` : | the mini-object to make writable
Returns : | a mini-object (possibly the same pointer) that is writable.

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

`mini_object` : | the mini-object
Returns : | the mini-object.

### gst_mini_object_unref ()

    void                gst_mini_object_unref               (GstMiniObject *mini_object);

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

`mini_object` : | the mini-object

### gst_mini_object_replace ()

    void                gst_mini_object_replace             (GstMiniObject **olddata,
                                                             GstMiniObject *newdata);

Modifies a pointer to point to a new mini-object. The modification is done atomically, and the reference counts are updated correctly. Either `newdata` and the value pointed to by `olddata` may be NULL.

`olddata` : | pointer to a pointer to a mini-object to be replaced
`newdata` : | pointer to new mini-object

### GstParamSpecMiniObject

    typedef struct {
      GParamSpec parent_instance;
    } GstParamSpecMiniObject;

A `GParamSpec` derived structure that contains the meta data for `GstMiniObject` properties.

GParamSpec `parent_instance`; | private `GParamSpec` portion

### gst_param_spec_mini_object ()

    GParamSpec*         gst_param_spec_mini_object          (const char *name,
                                                             const char *nick,
                                                             const char *blurb,
                                                             GType object_type,
                                                             GParamFlags flags);

Creates a new GParamSpec instance that hold GstMiniObject references.

`name` : | the canonical name of the property
`nick` : | the nickname of the property
`blurb` : | a short description of the property
`object_type` : | the GstMiniObject GType for the property
`flags` : | a combination of GParamFlags
Returns : | a newly allocated GParamSpec instance

### gst_value_set_mini_object ()

    void                gst_value_set_mini_object           (GValue *value,
                                                             GstMiniObject *mini_object);

Set the contents of a `GST_TYPE_MINI_OBJECT` derived GValue to `mini_object`. The caller retains ownership of the reference.

`value` : | a valid GValue of `GST_TYPE_MINI_OBJECT` derived type
`mini_object` : | mini object value to set

### gst_value_take_mini_object ()

    void                gst_value_take_mini_object          (GValue *value,
                                                             GstMiniObject *mini_object);

Set the contents of a `GST_TYPE_MINI_OBJECT` derived GValue to `mini_object`. Takes over the ownership of the caller's reference to `mini_object`; the caller doesn't have to unref it any more.

`value` : | a valid GValue of `GST_TYPE_MINI_OBJECT` derived type
`mini_object` : | mini object value to take

### gst_value_get_mini_object ()

    GstMiniObject*      gst_value_get_mini_object           (const GValue *value);

Get the contents of a `GST_TYPE_MINI_OBJECT` derived GValue. Does not increase the refcount of the returned object.

`value` : | a valid GValue of `GST_TYPE_MINI_OBJECT` derived type
Returns : | mini object contents of `value`

### gst_value_dup_mini_object ()

    GstMiniObject*      gst_value_dup_mini_object           (const GValue *value);

Get the contents of a `GST_TYPE_MINI_OBJECT` derived GValue, increasing its reference count.

`value` : | a valid GValue of `GST_TYPE_MINI_OBJECT` derived type
Returns : | mini object contents of `value`

Since 0.10.20