static GstAllocTrace *_gst_mini_object_trace;
#endif
-#define GST_MINI_OBJECT_GET_CLASS_UNCHECKED(obj) \
- ((GstMiniObjectClass *) (((GTypeInstance*)(obj))->g_class))
-
-/* boxed copy and free functions. Don't real copy or free but simply
- * change the refcount */
-static GstMiniObject *
-_gst_mini_object_boxed_copy (GstMiniObject * mini_object)
-{
- if (mini_object)
- return gst_mini_object_ref (mini_object);
- else
- return NULL;
-}
-
-static void
-_gst_mini_object_boxed_free (GstMiniObject * mini_object)
-{
- if (mini_object)
- gst_mini_object_unref (mini_object);
-}
-
-/**
- * gst_mini_object_register:
- * @name: name of the new boxed type
- *
- * This function creates a new G_TYPE_BOXED derived type id for a new boxed type
- * with name @name. The default miniobject refcounting copy and free function
- * are used for the boxed type.
- *
- * Returns: a new G_TYPE_BOXED derived type id for @name.
- */
-GType
-gst_mini_object_register (const gchar * name)
-{
- GType type;
-
- g_return_val_if_fail (name != NULL, 0);
-
- type = g_boxed_type_register_static (name,
- (GBoxedCopyFunc) _gst_mini_object_boxed_copy,
- (GBoxedFreeFunc) _gst_mini_object_boxed_free);
-
- return type;
-}
+/* Mutex used for weak referencing */
+G_LOCK_DEFINE_STATIC (weak_refs_mutex);
/**
* gst_mini_object_init:
mini_object->refcount = 1;
mini_object->flags = 0;
mini_object->size = size;
+ mini_object->n_weak_refs = 0;
+ mini_object->weak_refs = NULL;
}
/**
if (gst_mini_object_is_writable (mini_object)) {
ret = mini_object;
} else {
- GST_CAT_DEBUG (GST_CAT_PERFORMANCE, "copy %s miniobject",
- g_type_name (G_TYPE_FROM_INSTANCE (mini_object)));
ret = gst_mini_object_copy (mini_object);
+ GST_CAT_DEBUG (GST_CAT_PERFORMANCE, "copy %s miniobject %p -> %p",
+ g_type_name (GST_MINI_OBJECT_TYPE (mini_object)), mini_object, ret);
gst_mini_object_unref (mini_object);
}
* of memcpy operations in a pipeline, especially if the miniobject
* is a #GstBuffer.
*
- * Returns: the mini-object.
+ * Returns: (transfer full): the mini-object.
*/
GstMiniObject *
gst_mini_object_ref (GstMiniObject * mini_object)
return mini_object;
}
+static void
+weak_refs_notify (GstMiniObject * obj)
+{
+ guint i;
+
+ for (i = 0; i < obj->n_weak_refs; i++)
+ obj->weak_refs[i].notify (obj->weak_refs[i].data, obj);
+ g_free (obj->weak_refs);
+}
+
/**
* gst_mini_object_unref:
* @mini_object: the mini-object
GST_MINI_OBJECT_REFCOUNT_VALUE (mini_object) - 1);
if (G_UNLIKELY (g_atomic_int_dec_and_test (&mini_object->refcount))) {
- /* At this point, the refcount of the object is 0. We increase the refcount
- * here because if a subclass recycles the object and gives out a new
- * reference we don't want to free the instance anymore. */
- gst_mini_object_ref (mini_object);
+ gboolean do_free;
if (mini_object->dispose)
- mini_object->dispose (mini_object);
+ do_free = mini_object->dispose (mini_object);
+ else
+ do_free = TRUE;
- /* decrement the refcount again, if the subclass recycled the object we don't
+ /* if the subclass recycled the object (and returned FALSE) we don't
* want to free the instance anymore */
- if (G_LIKELY (g_atomic_int_dec_and_test (&mini_object->refcount))) {
+ if (G_LIKELY (do_free)) {
+ /* The weak reference stack is freed in the notification function */
+ if (mini_object->n_weak_refs)
+ weak_refs_notify (mini_object);
+
#ifndef GST_DISABLE_TRACE
gst_alloc_trace_free (_gst_mini_object_trace, mini_object);
#endif
* be replaced
* @newdata: pointer to new mini-object
*
- * Modifies a pointer to point to a new mini-object. The modification
- * is done atomically, and the reference counts are updated correctly.
+ * 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.
+ *
+ * Returns: TRUE if @newdata was different from @olddata
*/
-void
+gboolean
gst_mini_object_replace (GstMiniObject ** olddata, GstMiniObject * newdata)
{
GstMiniObject *olddata_val;
- g_return_if_fail (olddata != NULL);
+ g_return_val_if_fail (olddata != NULL, FALSE);
GST_CAT_TRACE (GST_CAT_REFCOUNTING, "replace %p (%d) with %p (%d)",
*olddata, *olddata ? (*olddata)->refcount : 0,
olddata_val = g_atomic_pointer_get ((gpointer *) olddata);
- if (olddata_val == newdata)
- return;
+ if (G_UNLIKELY (olddata_val == newdata))
+ return FALSE;
if (newdata)
gst_mini_object_ref (newdata);
- while (!g_atomic_pointer_compare_and_exchange ((gpointer *) olddata,
- olddata_val, newdata)) {
+ while (G_UNLIKELY (!g_atomic_pointer_compare_and_exchange ((gpointer *)
+ olddata, olddata_val, newdata))) {
olddata_val = g_atomic_pointer_get ((gpointer *) olddata);
+ if (G_UNLIKELY (olddata_val == newdata))
+ break;
}
if (olddata_val)
gst_mini_object_unref (olddata_val);
+
+ return olddata_val != newdata;
+}
+
+/**
+ * gst_mini_object_steal:
+ * @olddata: (inout) (transfer full): pointer to a pointer to a mini-object to
+ * be stolen
+ *
+ * Replace the current #GstMiniObject pointer to by @olddata with NULL and
+ * return the old value.
+ *
+ * Returns: the #GstMiniObject at @oldata
+ */
+GstMiniObject *
+gst_mini_object_steal (GstMiniObject ** olddata)
+{
+ GstMiniObject *olddata_val;
+
+ g_return_val_if_fail (olddata != NULL, NULL);
+
+ GST_CAT_TRACE (GST_CAT_REFCOUNTING, "steal %p (%d)",
+ *olddata, *olddata ? (*olddata)->refcount : 0);
+
+ do {
+ olddata_val = g_atomic_pointer_get ((gpointer *) olddata);
+ if (olddata_val == NULL)
+ break;
+ } while (G_UNLIKELY (!g_atomic_pointer_compare_and_exchange ((gpointer *)
+ olddata, olddata_val, NULL)));
+
+ return olddata_val;
+}
+
+/**
+ * gst_mini_object_take:
+ * @olddata: (inout) (transfer full): pointer to a pointer to a mini-object to
+ * be replaced
+ * @newdata: pointer to new mini-object
+ *
+ * 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.
+ *
+ * Returns: TRUE if @newdata was different from @olddata
+ */
+gboolean
+gst_mini_object_take (GstMiniObject ** olddata, GstMiniObject * newdata)
+{
+ GstMiniObject *olddata_val;
+
+ g_return_val_if_fail (olddata != NULL, FALSE);
+
+ GST_CAT_TRACE (GST_CAT_REFCOUNTING, "take %p (%d) with %p (%d)",
+ *olddata, *olddata ? (*olddata)->refcount : 0,
+ newdata, newdata ? newdata->refcount : 0);
+
+ do {
+ olddata_val = g_atomic_pointer_get ((gpointer *) olddata);
+ if (G_UNLIKELY (olddata_val == newdata))
+ break;
+ } while (G_UNLIKELY (!g_atomic_pointer_compare_and_exchange ((gpointer *)
+ olddata, olddata_val, newdata)));
+
+ if (olddata_val)
+ gst_mini_object_unref (olddata_val);
+
+ return olddata_val != newdata;
+}
+
+/**
+ * gst_mini_object_weak_ref: (skip)
+ * @object: #GstMiniObject to reference weakly
+ * @notify: callback to invoke before the mini object is freed
+ * @data: extra data to pass to notify
+ *
+ * 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).
+ *
+ * Since: 0.10.35
+ */
+void
+gst_mini_object_weak_ref (GstMiniObject * object,
+ GstMiniObjectWeakNotify notify, gpointer data)
+{
+ guint i;
+
+ g_return_if_fail (object != NULL);
+ g_return_if_fail (notify != NULL);
+ g_return_if_fail (GST_MINI_OBJECT_REFCOUNT_VALUE (object) >= 1);
+
+ G_LOCK (weak_refs_mutex);
+
+ if (object->n_weak_refs) {
+ /* Don't add the weak reference if it already exists. */
+ for (i = 0; i < object->n_weak_refs; i++) {
+ if (object->weak_refs[i].notify == notify &&
+ object->weak_refs[i].data == data) {
+ g_warning ("%s: Attempt to re-add existing weak ref %p(%p) failed.",
+ G_STRFUNC, notify, data);
+ goto found;
+ }
+ }
+
+ i = object->n_weak_refs++;
+ object->weak_refs =
+ g_realloc (object->weak_refs, sizeof (object->weak_refs[0]) * i);
+ } else {
+ object->weak_refs = g_malloc0 (sizeof (object->weak_refs[0]));
+ object->n_weak_refs = 1;
+ i = 0;
+ }
+ object->weak_refs[i].notify = notify;
+ object->weak_refs[i].data = data;
+found:
+ G_UNLOCK (weak_refs_mutex);
+}
+
+/**
+ * gst_mini_object_weak_unref: (skip)
+ * @object: #GstMiniObject to remove a weak reference from
+ * @notify: callback to search for
+ * @data: data to search for
+ *
+ * Removes a weak reference callback to a mini object.
+ *
+ * Since: 0.10.35
+ */
+void
+gst_mini_object_weak_unref (GstMiniObject * object,
+ GstMiniObjectWeakNotify notify, gpointer data)
+{
+ gboolean found_one = FALSE;
+
+ g_return_if_fail (object != NULL);
+ g_return_if_fail (notify != NULL);
+
+ G_LOCK (weak_refs_mutex);
+
+ if (object->n_weak_refs) {
+ guint i;
+
+ for (i = 0; i < object->n_weak_refs; i++)
+ if (object->weak_refs[i].notify == notify &&
+ object->weak_refs[i].data == data) {
+ found_one = TRUE;
+ object->n_weak_refs -= 1;
+ if (i != object->n_weak_refs)
+ object->weak_refs[i] = object->weak_refs[object->n_weak_refs];
+
+ break;
+ }
+ }
+ G_UNLOCK (weak_refs_mutex);
+ if (!found_one)
+ g_warning ("%s: couldn't find weak ref %p(%p)", G_STRFUNC, notify, data);
}
projects / platform / upstream / gstreamer.git / blobdiff