X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gst%2Fgstminiobject.h;h=736e7b447292d7d60dab2c6b95e113edf210d484;hb=ce4698487e2650ee9b365d6cf41a254483349bc0;hp=eef6dd9faae530f2ffb21135228b1d9e27cc14a7;hpb=b108e3b9992e7f31fdc84b6cf2344d87502bbd2d;p=platform%2Fupstream%2Fgstreamer.git diff --git a/gst/gstminiobject.h b/gst/gstminiobject.h index eef6dd9..736e7b4 100644 --- a/gst/gstminiobject.h +++ b/gst/gstminiobject.h @@ -15,8 +15,8 @@ * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. */ @@ -52,26 +52,40 @@ typedef GstMiniObject * (*GstMiniObjectCopyFunction) (const 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 memory associated with the - * object is freed. + * revived after the dispose function, the function should return %TRUE + * and the memory associated with the object is freed. + * + * Returns: %TRUE if the object should be cleaned up. */ -typedef void (*GstMiniObjectDisposeFunction) (GstMiniObject *obj); +typedef gboolean (*GstMiniObjectDisposeFunction) (GstMiniObject *obj); /** * GstMiniObjectFreeFunction: * @obj: MiniObject to free * - * Virtual function prototype for methods to free ressources used by + * Virtual function prototype for methods to free resources used by * mini-objects. */ typedef void (*GstMiniObjectFreeFunction) (GstMiniObject *obj); + /** + * GstMiniObjectNotify: + * @user_data: data that was provided when the notify was added + * @obj: the mini object + * + * 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. + */ +typedef void (*GstMiniObjectNotify) (gpointer user_data, GstMiniObject * obj); + /** - * GST_MINI_OBJECT_FLAGS: - * @obj: MiniObject to return flags for. + * GST_MINI_OBJECT_TYPE: + * @obj: MiniObject to return type for. * - * This macro returns the entire set of flags for the mini-object. + * This macro returns the type of the mini-object. */ #define GST_MINI_OBJECT_TYPE(obj) (GST_MINI_OBJECT_CAST(obj)->type) + /** * GST_MINI_OBJECT_FLAGS: * @obj: MiniObject to return flags for. @@ -100,25 +114,66 @@ typedef void (*GstMiniObjectFreeFunction) (GstMiniObject *obj); * @obj: MiniObject to unset flag in. * @flag: Flag to set, must be a single bit in guint32. * - * This macro usets the given bits. + * This macro unsets the given bits. */ #define GST_MINI_OBJECT_FLAG_UNSET(obj,flag) (GST_MINI_OBJECT_FLAGS (obj) &= ~(flag)) /** * GstMiniObjectFlags: - * @GST_MINI_OBJECT_FLAG_READONLY: is the miniobject readonly or writable + * @GST_MINI_OBJECT_FLAG_LOCKABLE: the object can be locked and unlocked with + * gst_mini_object_lock() and gst_mini_object_unlock(). + * @GST_MINI_OBJECT_FLAG_LOCK_READONLY: the object is permanently locked in + * READONLY mode. Only read locks can be performed on the object. + * @GST_MINI_OBJECT_FLAG_MAY_BE_LEAKED: 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: first flag that can be used by subclasses. * * Flags for the mini object */ typedef enum { - GST_MINI_OBJECT_FLAG_READONLY = (1<<0), + GST_MINI_OBJECT_FLAG_LOCKABLE = (1 << 0), + GST_MINI_OBJECT_FLAG_LOCK_READONLY = (1 << 1), + GST_MINI_OBJECT_FLAG_MAY_BE_LEAKED = (1 << 2), /* padding */ - GST_MINI_OBJECT_FLAG_LAST = (1<<4) + GST_MINI_OBJECT_FLAG_LAST = (1 << 4) } GstMiniObjectFlags; /** + * GST_MINI_OBJECT_IS_LOCKABLE: + * @obj: a #GstMiniObject + * + * Check if @obj is lockable. A lockable object can be locked and unlocked with + * gst_mini_object_lock() and gst_mini_object_unlock(). + */ +#define GST_MINI_OBJECT_IS_LOCKABLE(obj) GST_MINI_OBJECT_FLAG_IS_SET(obj, GST_MINI_OBJECT_FLAG_LOCKABLE) + +/** + * GstLockFlags: + * @GST_LOCK_FLAG_READ: lock for read access + * @GST_LOCK_FLAG_WRITE: lock for write access + * @GST_LOCK_FLAG_EXCLUSIVE: lock for exclusive access + * @GST_LOCK_FLAG_LAST: first flag that can be used for custom purposes + * + * Flags used when locking miniobjects + */ +typedef enum { + GST_LOCK_FLAG_READ = (1 << 0), + GST_LOCK_FLAG_WRITE = (1 << 1), + GST_LOCK_FLAG_EXCLUSIVE = (1 << 2), + + GST_LOCK_FLAG_LAST = (1 << 8) +} GstLockFlags; + +/** + * GST_LOCK_FLAG_READWRITE: (value 3) (type GstLockFlags) + * + * GstLockFlags value alias for GST_LOCK_FLAG_READ | GST_LOCK_FLAG_WRITE + */ +#define GST_LOCK_FLAG_READWRITE ((GstLockFlags) (GST_LOCK_FLAG_READ | GST_LOCK_FLAG_WRITE)) + +/** * GST_MINI_OBJECT_REFCOUNT: * @obj: a #GstMiniObject * @@ -134,56 +189,114 @@ typedef enum #define GST_MINI_OBJECT_REFCOUNT_VALUE(obj) (g_atomic_int_get (&(GST_MINI_OBJECT_CAST(obj))->refcount)) /** - * GST_MINI_OBJECT_SIZE: - * @obj: a #GstMiniObject - * - * Get the allocated size of @obj. - */ -#define GST_MINI_OBJECT_SIZE(obj) ((GST_MINI_OBJECT_CAST(obj))->size) - -/** - * GstMiniObject: - * @instance: type instance + * GstMiniObject: (ref-func gst_mini_object_ref) (unref-func gst_mini_object_unref) (set-value-func g_value_set_boxed) (get-value-func g_value_get_boxed) + * @type: the GType of the object * @refcount: atomic refcount + * @lockstate: atomic state of the locks * @flags: extra flags. * @copy: a copy function * @dispose: a dispose function * @free: the free function - * + * * 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 */ struct _GstMiniObject { GType type; /*< public >*/ /* with COW */ gint refcount; + gint lockstate; guint flags; - gsize size; GstMiniObjectCopyFunction copy; GstMiniObjectDisposeFunction dispose; GstMiniObjectFreeFunction free; -}; -GType gst_mini_object_register (const gchar *name); + /* < private > */ + /* Used to keep track of parents, weak ref notifies and qdata */ + guint priv_uint; + gpointer priv_pointer; +}; -void gst_mini_object_init (GstMiniObject *mini_object, - GType type, gsize size); +GST_API +void gst_mini_object_init (GstMiniObject *mini_object, + guint flags, GType type, + GstMiniObjectCopyFunction copy_func, + GstMiniObjectDisposeFunction dispose_func, + GstMiniObjectFreeFunction free_func); -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); /* refcounting */ -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); +GST_API +GstMiniObject * gst_mini_object_ref (GstMiniObject *mini_object); + +GST_API +void gst_mini_object_unref (GstMiniObject *mini_object); + +GST_API +void gst_mini_object_weak_ref (GstMiniObject *object, + GstMiniObjectNotify notify, + gpointer data); +GST_API +void gst_mini_object_weak_unref (GstMiniObject *object, + GstMiniObjectNotify notify, + gpointer data); + +/* locking */ + +GST_API +gboolean gst_mini_object_lock (GstMiniObject *object, GstLockFlags flags); + +GST_API +void gst_mini_object_unlock (GstMiniObject *object, GstLockFlags flags); + +GST_API +gboolean gst_mini_object_is_writable (const GstMiniObject *mini_object); + +GST_API +GstMiniObject * gst_mini_object_make_writable (GstMiniObject *mini_object) G_GNUC_WARN_UNUSED_RESULT; +/* copy */ + +GST_API +GstMiniObject * gst_mini_object_copy (const GstMiniObject *mini_object) G_GNUC_MALLOC G_GNUC_WARN_UNUSED_RESULT; + + +GST_API +void gst_mini_object_set_qdata (GstMiniObject *object, GQuark quark, + gpointer data, GDestroyNotify destroy); +GST_API +gpointer gst_mini_object_get_qdata (GstMiniObject *object, GQuark quark); + +GST_API +gpointer gst_mini_object_steal_qdata (GstMiniObject *object, GQuark quark); + +GST_API +void gst_mini_object_add_parent (GstMiniObject *object, GstMiniObject *parent); +GST_API +void gst_mini_object_remove_parent (GstMiniObject *object, GstMiniObject *parent); + +GST_API +gboolean gst_mini_object_replace (GstMiniObject **olddata, GstMiniObject *newdata); + +GST_API +gboolean gst_mini_object_take (GstMiniObject **olddata, GstMiniObject *newdata); + +GST_API +GstMiniObject * gst_mini_object_steal (GstMiniObject **olddata) G_GNUC_WARN_UNUSED_RESULT; + +/** + * GST_DEFINE_MINI_OBJECT_TYPE: + * @TypeName: name of the new type in CamelCase + * @type_name: name of the new type + * + * Define a new mini-object type with the given name + */ +#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) G_END_DECLS