summaryrefslogtreecommitdiffstats
path: root/media/ffvpx/libavcodec/refstruct.c
diff options
context:
space:
mode:
Diffstat (limited to 'media/ffvpx/libavcodec/refstruct.c')
-rw-r--r--media/ffvpx/libavcodec/refstruct.c386
1 files changed, 386 insertions, 0 deletions
diff --git a/media/ffvpx/libavcodec/refstruct.c b/media/ffvpx/libavcodec/refstruct.c
new file mode 100644
index 0000000000..7597f6d0ee
--- /dev/null
+++ b/media/ffvpx/libavcodec/refstruct.c
@@ -0,0 +1,386 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdatomic.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "internal.h"
+#include "refstruct.h"
+
+#include "libavutil/avassert.h"
+#include "libavutil/error.h"
+#include "libavutil/macros.h"
+#include "libavutil/mem.h"
+#include "libavutil/thread.h"
+
+#ifndef REFSTRUCT_CHECKED
+#ifndef ASSERT_LEVEL
+#define ASSERT_LEVEL 0
+#endif
+#define REFSTRUCT_CHECKED (ASSERT_LEVEL >= 1)
+#endif
+
+#if REFSTRUCT_CHECKED
+#define ff_assert(cond) av_assert0(cond)
+#else
+#define ff_assert(cond) ((void)0)
+#endif
+
+#define REFSTRUCT_COOKIE AV_NE((uint64_t)MKBETAG('R', 'e', 'f', 'S') << 32 | MKBETAG('t', 'r', 'u', 'c'), \
+ MKTAG('R', 'e', 'f', 'S') | (uint64_t)MKTAG('t', 'r', 'u', 'c') << 32)
+
+#if __STDC_VERSION__ >= 201112L
+#define REFCOUNT_OFFSET FFALIGN(sizeof(RefCount), FFMAX3(STRIDE_ALIGN, 16, _Alignof(max_align_t)))
+#else
+#define REFCOUNT_OFFSET FFALIGN(sizeof(RefCount), FFMAX(STRIDE_ALIGN, 16))
+#endif
+
+typedef struct RefCount {
+ /**
+ * An uintptr_t is big enough to hold the address of every reference,
+ * so no overflow can happen when incrementing the refcount as long as
+ * the user does not throw away references.
+ */
+ atomic_uintptr_t refcount;
+ FFRefStructOpaque opaque;
+ void (*free_cb)(FFRefStructOpaque opaque, void *obj);
+ void (*free)(void *ref);
+
+#if REFSTRUCT_CHECKED
+ uint64_t cookie;
+#endif
+} RefCount;
+
+static RefCount *get_refcount(void *obj)
+{
+ RefCount *ref = (RefCount*)((char*)obj - REFCOUNT_OFFSET);
+ ff_assert(ref->cookie == REFSTRUCT_COOKIE);
+ return ref;
+}
+
+static const RefCount *cget_refcount(const void *obj)
+{
+ const RefCount *ref = (const RefCount*)((const char*)obj - REFCOUNT_OFFSET);
+ ff_assert(ref->cookie == REFSTRUCT_COOKIE);
+ return ref;
+}
+
+static void *get_userdata(void *buf)
+{
+ return (char*)buf + REFCOUNT_OFFSET;
+}
+
+static void refcount_init(RefCount *ref, FFRefStructOpaque opaque,
+ void (*free_cb)(FFRefStructOpaque opaque, void *obj))
+{
+ atomic_init(&ref->refcount, 1);
+ ref->opaque = opaque;
+ ref->free_cb = free_cb;
+ ref->free = av_free;
+
+#if REFSTRUCT_CHECKED
+ ref->cookie = REFSTRUCT_COOKIE;
+#endif
+}
+
+void *ff_refstruct_alloc_ext_c(size_t size, unsigned flags, FFRefStructOpaque opaque,
+ void (*free_cb)(FFRefStructOpaque opaque, void *obj))
+{
+ void *buf, *obj;
+
+ if (size > SIZE_MAX - REFCOUNT_OFFSET)
+ return NULL;
+ buf = av_malloc(size + REFCOUNT_OFFSET);
+ if (!buf)
+ return NULL;
+ refcount_init(buf, opaque, free_cb);
+ obj = get_userdata(buf);
+ if (!(flags & FF_REFSTRUCT_FLAG_NO_ZEROING))
+ memset(obj, 0, size);
+
+ return obj;
+}
+
+void ff_refstruct_unref(void *objp)
+{
+ void *obj;
+ RefCount *ref;
+
+ memcpy(&obj, objp, sizeof(obj));
+ if (!obj)
+ return;
+ memcpy(objp, &(void *){ NULL }, sizeof(obj));
+
+ ref = get_refcount(obj);
+ if (atomic_fetch_sub_explicit(&ref->refcount, 1, memory_order_acq_rel) == 1) {
+ if (ref->free_cb)
+ ref->free_cb(ref->opaque, obj);
+ ref->free(ref);
+ }
+
+ return;
+}
+
+void *ff_refstruct_ref(void *obj)
+{
+ RefCount *ref = get_refcount(obj);
+
+ atomic_fetch_add_explicit(&ref->refcount, 1, memory_order_relaxed);
+
+ return obj;
+}
+
+const void *ff_refstruct_ref_c(const void *obj)
+{
+ /* Casting const away here is fine, as it is only supposed
+ * to apply to the user's data and not our bookkeeping data. */
+ RefCount *ref = get_refcount((void*)obj);
+
+ atomic_fetch_add_explicit(&ref->refcount, 1, memory_order_relaxed);
+
+ return obj;
+}
+
+void ff_refstruct_replace(void *dstp, const void *src)
+{
+ const void *dst;
+ memcpy(&dst, dstp, sizeof(dst));
+
+ if (src == dst)
+ return;
+ ff_refstruct_unref(dstp);
+ if (src) {
+ dst = ff_refstruct_ref_c(src);
+ memcpy(dstp, &dst, sizeof(dst));
+ }
+}
+
+int ff_refstruct_exclusive(const void *obj)
+{
+ const RefCount *ref = cget_refcount(obj);
+ /* Casting const away here is safe, because it is a load.
+ * It is necessary because atomic_load_explicit() does not
+ * accept const atomics in C11 (see also N1807). */
+ return atomic_load_explicit((atomic_uintptr_t*)&ref->refcount, memory_order_acquire) == 1;
+}
+
+struct FFRefStructPool {
+ size_t size;
+ FFRefStructOpaque opaque;
+ int (*init_cb)(FFRefStructOpaque opaque, void *obj);
+ void (*reset_cb)(FFRefStructOpaque opaque, void *obj);
+ void (*free_entry_cb)(FFRefStructOpaque opaque, void *obj);
+ void (*free_cb)(FFRefStructOpaque opaque);
+
+ int uninited;
+ unsigned entry_flags;
+ unsigned pool_flags;
+
+ /** The number of outstanding entries not in available_entries. */
+ atomic_uintptr_t refcount;
+ /**
+ * This is a linked list of available entries;
+ * the RefCount's opaque pointer is used as next pointer
+ * for available entries.
+ * While the entries are in use, the opaque is a pointer
+ * to the corresponding FFRefStructPool.
+ */
+ RefCount *available_entries;
+ AVMutex mutex;
+};
+
+static void pool_free(FFRefStructPool *pool)
+{
+ ff_mutex_destroy(&pool->mutex);
+ if (pool->free_cb)
+ pool->free_cb(pool->opaque);
+ av_free(get_refcount(pool));
+}
+
+static void pool_free_entry(FFRefStructPool *pool, RefCount *ref)
+{
+ if (pool->free_entry_cb)
+ pool->free_entry_cb(pool->opaque, get_userdata(ref));
+ av_free(ref);
+}
+
+static void pool_return_entry(void *ref_)
+{
+ RefCount *ref = ref_;
+ FFRefStructPool *pool = ref->opaque.nc;
+
+ ff_mutex_lock(&pool->mutex);
+ if (!pool->uninited) {
+ ref->opaque.nc = pool->available_entries;
+ pool->available_entries = ref;
+ ref = NULL;
+ }
+ ff_mutex_unlock(&pool->mutex);
+
+ if (ref)
+ pool_free_entry(pool, ref);
+
+ if (atomic_fetch_sub_explicit(&pool->refcount, 1, memory_order_acq_rel) == 1)
+ pool_free(pool);
+}
+
+static void pool_reset_entry(FFRefStructOpaque opaque, void *entry)
+{
+ FFRefStructPool *pool = opaque.nc;
+
+ pool->reset_cb(pool->opaque, entry);
+}
+
+static int refstruct_pool_get_ext(void *datap, FFRefStructPool *pool)
+{
+ void *ret = NULL;
+
+ memcpy(datap, &(void *){ NULL }, sizeof(void*));
+
+ ff_mutex_lock(&pool->mutex);
+ ff_assert(!pool->uninited);
+ if (pool->available_entries) {
+ RefCount *ref = pool->available_entries;
+ ret = get_userdata(ref);
+ pool->available_entries = ref->opaque.nc;
+ ref->opaque.nc = pool;
+ atomic_init(&ref->refcount, 1);
+ }
+ ff_mutex_unlock(&pool->mutex);
+
+ if (!ret) {
+ RefCount *ref;
+ ret = ff_refstruct_alloc_ext(pool->size, pool->entry_flags, pool,
+ pool->reset_cb ? pool_reset_entry : NULL);
+ if (!ret)
+ return AVERROR(ENOMEM);
+ ref = get_refcount(ret);
+ ref->free = pool_return_entry;
+ if (pool->init_cb) {
+ int err = pool->init_cb(pool->opaque, ret);
+ if (err < 0) {
+ if (pool->pool_flags & FF_REFSTRUCT_POOL_FLAG_RESET_ON_INIT_ERROR)
+ pool->reset_cb(pool->opaque, ret);
+ if (pool->pool_flags & FF_REFSTRUCT_POOL_FLAG_FREE_ON_INIT_ERROR)
+ pool->free_entry_cb(pool->opaque, ret);
+ av_free(ref);
+ return err;
+ }
+ }
+ }
+ atomic_fetch_add_explicit(&pool->refcount, 1, memory_order_relaxed);
+
+ if (pool->pool_flags & FF_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME)
+ memset(ret, 0, pool->size);
+
+ memcpy(datap, &ret, sizeof(ret));
+
+ return 0;
+}
+
+void *ff_refstruct_pool_get(FFRefStructPool *pool)
+{
+ void *ret;
+ refstruct_pool_get_ext(&ret, pool);
+ return ret;
+}
+
+/**
+ * Hint: The content of pool_unref() and refstruct_pool_uninit()
+ * could currently be merged; they are only separate functions
+ * in case we would ever introduce weak references.
+ */
+static void pool_unref(void *ref)
+{
+ FFRefStructPool *pool = get_userdata(ref);
+ if (atomic_fetch_sub_explicit(&pool->refcount, 1, memory_order_acq_rel) == 1)
+ pool_free(pool);
+}
+
+static void refstruct_pool_uninit(FFRefStructOpaque unused, void *obj)
+{
+ FFRefStructPool *pool = obj;
+ RefCount *entry;
+
+ ff_mutex_lock(&pool->mutex);
+ ff_assert(!pool->uninited);
+ pool->uninited = 1;
+ entry = pool->available_entries;
+ pool->available_entries = NULL;
+ ff_mutex_unlock(&pool->mutex);
+
+ while (entry) {
+ void *next = entry->opaque.nc;
+ pool_free_entry(pool, entry);
+ entry = next;
+ }
+}
+
+FFRefStructPool *ff_refstruct_pool_alloc(size_t size, unsigned flags)
+{
+ return ff_refstruct_pool_alloc_ext(size, flags, NULL, NULL, NULL, NULL, NULL);
+}
+
+FFRefStructPool *ff_refstruct_pool_alloc_ext_c(size_t size, unsigned flags,
+ FFRefStructOpaque opaque,
+ int (*init_cb)(FFRefStructOpaque opaque, void *obj),
+ void (*reset_cb)(FFRefStructOpaque opaque, void *obj),
+ void (*free_entry_cb)(FFRefStructOpaque opaque, void *obj),
+ void (*free_cb)(FFRefStructOpaque opaque))
+{
+ FFRefStructPool *pool = ff_refstruct_alloc_ext(sizeof(*pool), 0, NULL,
+ refstruct_pool_uninit);
+ int err;
+
+ if (!pool)
+ return NULL;
+ get_refcount(pool)->free = pool_unref;
+
+ pool->size = size;
+ pool->opaque = opaque;
+ pool->init_cb = init_cb;
+ pool->reset_cb = reset_cb;
+ pool->free_entry_cb = free_entry_cb;
+ pool->free_cb = free_cb;
+#define COMMON_FLAGS FF_REFSTRUCT_POOL_FLAG_NO_ZEROING
+ pool->entry_flags = flags & COMMON_FLAGS;
+ // Filter out nonsense combinations to avoid checks later.
+ if (!pool->reset_cb)
+ flags &= ~FF_REFSTRUCT_POOL_FLAG_RESET_ON_INIT_ERROR;
+ if (!pool->free_entry_cb)
+ flags &= ~FF_REFSTRUCT_POOL_FLAG_FREE_ON_INIT_ERROR;
+ pool->pool_flags = flags;
+
+ if (flags & FF_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME) {
+ // We will zero the buffer before every use, so zeroing
+ // upon allocating the buffer is unnecessary.
+ pool->entry_flags |= FF_REFSTRUCT_FLAG_NO_ZEROING;
+ }
+
+ atomic_init(&pool->refcount, 1);
+
+ err = ff_mutex_init(&pool->mutex, NULL);
+ if (err) {
+ // Don't call ff_refstruct_uninit() on pool, as it hasn't been properly
+ // set up and is just a POD right now.
+ av_free(get_refcount(pool));
+ return NULL;
+ }
+ return pool;
+}