gstreamer/subprojects/gstreamer-vaapi/gst-libs/gst/vaapi/gstvaapiminiobject.c
Tim-Philipp Müller 1c7003f95f gstreamer-vaapi: drop use of GSlice allocator
Some code incorrectly relied on GstVideoDecoder/Encoder base
class implementation details.

Follow-up to !3695.

Fixes #1742.

Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/3783>
2023-01-24 22:30:10 +00:00

201 lines
5.7 KiB
C

/*
* gstvaapiminiobject.c - A lightweight reference counted object
*
* Copyright (C) 2012-2014 Intel Corporation
* Author: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2.1
* of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301 USA
*/
#include <string.h>
#include "gstvaapiminiobject.h"
static void
gst_vaapi_mini_object_free (GstVaapiMiniObject * object)
{
const GstVaapiMiniObjectClass *const klass = object->object_class;
g_atomic_int_inc (&object->ref_count);
if (klass->finalize)
klass->finalize (object);
if (G_LIKELY (g_atomic_int_dec_and_test (&object->ref_count)))
g_free (object);
}
/**
* gst_vaapi_mini_object_new:
* @object_class: (optional): The object class
*
* Creates a new #GstVaapiMiniObject. If @object_class is NULL, then the
* size of the allocated object is the same as sizeof(GstVaapiMiniObject).
* If @object_class is not NULL, typically when a sub-class is implemented,
* that pointer shall reference a statically allocated descriptor.
*
* This function does *not* zero-initialize the derived object data,
* use gst_vaapi_mini_object_new0() to fill this purpose.
*
* Returns: The newly allocated #GstVaapiMiniObject
*/
GstVaapiMiniObject *
gst_vaapi_mini_object_new (const GstVaapiMiniObjectClass * object_class)
{
GstVaapiMiniObject *object;
static const GstVaapiMiniObjectClass default_object_class = {
.size = sizeof (GstVaapiMiniObject),
};
if (G_UNLIKELY (!object_class))
object_class = &default_object_class;
g_return_val_if_fail (object_class->size >= sizeof (*object), NULL);
object = g_malloc (object_class->size);
if (!object)
return NULL;
object->object_class = object_class;
g_atomic_int_set (&object->ref_count, 1);
object->flags = 0;
return object;
}
/**
* gst_vaapi_mini_object_new0:
* @object_class: (optional): The object class
*
* Creates a new #GstVaapiMiniObject. This function is similar to
* gst_vaapi_mini_object_new() but derived object data is initialized
* to zeroes.
*
* Returns: The newly allocated #GstVaapiMiniObject
*/
GstVaapiMiniObject *
gst_vaapi_mini_object_new0 (const GstVaapiMiniObjectClass * object_class)
{
GstVaapiMiniObject *object;
guint sub_size;
object = gst_vaapi_mini_object_new (object_class);
if (!object)
return NULL;
object_class = object->object_class;
sub_size = object_class->size - sizeof (*object);
if (sub_size > 0)
memset (((guchar *) object) + sizeof (*object), 0, sub_size);
return object;
}
/**
* gst_vaapi_mini_object_ref_internal:
* @object: a #GstVaapiMiniObject
*
* Atomically increases the reference count of the given @object by one.
* This is an internal function that does not do any run-time type check.
*
* Returns: The same @object argument
*/
static inline GstVaapiMiniObject *
gst_vaapi_mini_object_ref_internal (GstVaapiMiniObject * object)
{
g_atomic_int_inc (&object->ref_count);
return object;
}
/**
* gst_vaapi_mini_object_ref:
* @object: a #GstVaapiMiniObject
*
* Atomically increases the reference count of the given @object by one.
*
* Returns: The same @object argument
*/
GstVaapiMiniObject *
gst_vaapi_mini_object_ref (GstVaapiMiniObject * object)
{
g_return_val_if_fail (object != NULL, NULL);
return gst_vaapi_mini_object_ref_internal (object);
}
/**
* gst_vaapi_mini_object_unref_internal:
* @object: a #GstVaapiMiniObject
*
* Atomically decreases the reference count of the @object by one. If
* the reference count reaches zero, the object will be free'd.
*
* This is an internal function that does not do any run-time type check.
*/
static inline void
gst_vaapi_mini_object_unref_internal (GstVaapiMiniObject * object)
{
if (g_atomic_int_dec_and_test (&object->ref_count))
gst_vaapi_mini_object_free (object);
}
/**
* gst_vaapi_mini_object_unref:
* @object: a #GstVaapiMiniObject
*
* Atomically decreases the reference count of the @object by one. If
* the reference count reaches zero, the object will be free'd.
*/
void
gst_vaapi_mini_object_unref (GstVaapiMiniObject * object)
{
g_return_if_fail (object != NULL);
g_return_if_fail (object->ref_count > 0);
gst_vaapi_mini_object_unref_internal (object);
}
/**
* gst_vaapi_mini_object_replace:
* @old_object_ptr: a pointer to a #GstVaapiMiniObject
* @new_object: a #GstVaapiMiniObject
*
* Atomically replaces the object held in @old_object_ptr with
* @new_object. This means that @old_object_ptr shall reference a
* valid object. However, @new_object can be NULL.
*/
void
gst_vaapi_mini_object_replace (GstVaapiMiniObject ** old_object_ptr,
GstVaapiMiniObject * new_object)
{
GstVaapiMiniObject *old_object;
g_return_if_fail (old_object_ptr != NULL);
old_object = g_atomic_pointer_get ((gpointer *) old_object_ptr);
if (old_object == new_object)
return;
if (new_object)
gst_vaapi_mini_object_ref_internal (new_object);
while (!g_atomic_pointer_compare_and_exchange ((gpointer *) old_object_ptr,
(gpointer) old_object, new_object))
old_object = g_atomic_pointer_get ((gpointer *) old_object_ptr);
if (old_object)
gst_vaapi_mini_object_unref_internal (old_object);
}