X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gst%2Fgstminiobject.h;h=b931e76e7a647589da0bb41cbfb49f26799dd7d1;hb=0c6f5b3e4c3dc55e684bca1e3fc9a2a9b74407b9;hp=f718a570e820bfd54386d3fea78e07ff2faadd47;hpb=bb18ca7fa47c69edbed53d6cab7f4635aac8e297;p=platform%2Fupstream%2Fgstreamer.git diff --git a/gst/gstminiobject.h b/gst/gstminiobject.h index f718a57..b931e76 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. */ @@ -62,34 +62,30 @@ 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); /** - * GstMiniObjectWeakNotify: - * @data: data that was provided when the weak reference was established - * @where_the_mini_object_was: the mini object being finalized + * GstMiniObjectNotify: + * @user_data: data that was provided when the notify was added + * @obj: the mini object * - * A #GstMiniObjectWeakNotify function can be added to a mini object as a - * callback that gets triggered when the mini object is finalized. Since the - * mini object is already being finalized when the #GstMiniObjectWeakNotify is - * called, there's not much you could do with the object, apart from e.g. using - * its adress as hash-index or the like. - * - * Since: 0.10.35 + * 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 (*GstMiniObjectWeakNotify) (gpointer data, - GstMiniObject * where_the_mini_object_was); +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. @@ -118,23 +114,66 @@ typedef void (*GstMiniObjectWeakNotify) (gpointer data, * @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_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_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 * @@ -150,77 +189,118 @@ 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: + * 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. - * @size: the size of the structure * @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: g_value_set_boxed - * Get Value Func: g_value_get_boxed */ struct _GstMiniObject { GType type; /*< public >*/ /* with COW */ gint refcount; + gint lockstate; guint flags; - gsize size; GstMiniObjectCopyFunction copy; GstMiniObjectDisposeFunction dispose; GstMiniObjectFreeFunction free; /* < private > */ - /* Used to keep track of weak ref notifies */ - guint n_weak_refs; - struct - { - GstMiniObjectWeakNotify notify; - gpointer data; - } *weak_refs; + /* 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 */ + +GST_API GstMiniObject * gst_mini_object_ref (GstMiniObject *mini_object); + +GST_API void gst_mini_object_unref (GstMiniObject *mini_object); +GST_API +void gst_clear_mini_object (GstMiniObject **object_ptr); +#define gst_clear_mini_object(object_ptr) g_clear_pointer ((object_ptr), gst_mini_object_unref) + +GST_API void gst_mini_object_weak_ref (GstMiniObject *object, - GstMiniObjectWeakNotify notify, + GstMiniObjectNotify notify, gpointer data); +GST_API void gst_mini_object_weak_unref (GstMiniObject *object, - GstMiniObjectWeakNotify notify, + 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); -GstMiniObject * gst_mini_object_steal (GstMiniObject **olddata); +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) + (GBoxedFreeFunc) gst_mini_object_unref) G_END_DECLS