From patchwork Tue Sep 19 19:57:18 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 43833 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:a886:b0:149:dfde:5c0a with SMTP id ca6csp187206pzb; Tue, 19 Sep 2023 13:00:53 -0700 (PDT) X-Google-Smtp-Source: AGHT+IEy3Uu52gs7+SrLGgJYvgV7McGApDMeI3WlJ4sZtX2XvoRac5uUV+hTyFjUz13D3eU1AhPI X-Received: by 2002:a17:906:8465:b0:9ad:8782:3d7 with SMTP id hx5-20020a170906846500b009ad878203d7mr302936ejc.51.1695153653603; Tue, 19 Sep 2023 13:00:53 -0700 (PDT) Return-Path: Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org. [79.124.17.100]) by mx.google.com with ESMTP id f15-20020a170906560f00b0099e0daaa531si11143292ejq.556.2023.09.19.13.00.52; Tue, 19 Sep 2023 13:00:53 -0700 (PDT) Received-SPF: pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) client-ip=79.124.17.100; Authentication-Results: mx.google.com; dkim=neutral (body hash did not verify) header.i=@outlook.com header.s=selector1 header.b=Ef0TAWl6; arc=fail (body hash mismatch); spf=pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) smtp.mailfrom=ffmpeg-devel-bounces@ffmpeg.org; dmarc=fail (p=NONE sp=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id BB50068C9CC; Tue, 19 Sep 2023 22:58:20 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR01-HE1-obe.outbound.protection.outlook.com (mail-he1eur01olkn2035.outbound.protection.outlook.com [40.92.65.35]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 14AE068C942 for ; Tue, 19 Sep 2023 22:58:18 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=B/BbDeg1KCI/KA7UBwy53VQptuQvCAOQ72f4fazAZZ/dGFF6irLAVzgrdpC74E+TUNS+kDJi2sNt0f6SIeXzu2GdkdxU9YbZpJv0bhxA6wUqVmkfKzOd/rfm+WbVoaqE++DJBJJ3Xx7y6yTcxmwtRFctJkVCEBiXziZc/mpyzIEtrXNv2e4eNFzA2EOC09x+HgGW53Ee+t2CE5WpckjZRpDbRSFySRruzeootFIclLU0w6Kvj/LKx+U0Z24q/aRlOxeuoscR83awW5LZGrerdnbIUztmeZVI/Uu3DYrFjvZLcqkvy6xJ5hwuZjGDYDPGBkO+1z15D19qFJzuPMD7MA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=4NaURpCT/S2fr5reCtwTIglpxxdIGGmD9Pbq8StZK2k=; b=SypVDE9YiGCzKmV/e/2h5helkCyJrT2FzFdZl9XzE6rIBSL8hYUd2S+OJbZQUuF7FhhRRz8dikmpHZyK6lpfX/H3ASdfBAmi3pTFvJmtiYPdvQfbxac/Gao6hFfyng6xqADM984nNgu7fqldWIxB2SVgPyPYWC+Qcs6dDVzsyfdp0kkl2TZV2BF88kwHrRTCSrRGDZ5hjjnYq1lDUB3u7SJ56Abmua+SxuS5lKb2rN1YJ+zQxI/YAxkW4wrRkH/6H4AzNKMLd5MHid1Ol1WIRSMStCouS6HTFjU51DKZl1pbKpyu4gGU3iSFCQMp41qXIHYp2MYDbXpps0VTnRf71w== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=4NaURpCT/S2fr5reCtwTIglpxxdIGGmD9Pbq8StZK2k=; b=Ef0TAWl65C3x1M7k2Ehn7OlwYyv8bc1GWXN0IEPVgcFR0VS4r6rHa9DQ6QuGeHo3/rgvegoxRe8m34mL/9729SZt+HX6y+rVvr/pn1tr1chVlwxNgSYSXVRVp92ULC4L5NpDYYQBs5F8246NM8t69ETcJneEFjoFIAbLebUng6W4Tep1PYaeIgLgBzMzuIPN9MjgQ2Kz5Q0iTv+dJIqpZ9R471Fc434FwhM0JNjO3QAlRUfQC7fdOnJsAmtbEWji9Cx1N7oKKeWV3UxzdV3p/UaN5Bh/plMIj9Q++kz1JUGcatHGAjUF43mlmOlFcBNW/6VQBjeXIYxFKk5Q+SjyhA== Received: from AS8P250MB0744.EURP250.PROD.OUTLOOK.COM (2603:10a6:20b:541::14) by DU2P250MB0237.EURP250.PROD.OUTLOOK.COM (2603:10a6:10:276::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6792.26; Tue, 19 Sep 2023 19:58:16 +0000 Received: from AS8P250MB0744.EURP250.PROD.OUTLOOK.COM ([fe80::5e01:aea5:d3a8:cafa]) by AS8P250MB0744.EURP250.PROD.OUTLOOK.COM ([fe80::5e01:aea5:d3a8:cafa%3]) with mapi id 15.20.6792.026; Tue, 19 Sep 2023 19:58:16 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Tue, 19 Sep 2023 21:57:18 +0200 Message-ID: X-Mailer: git-send-email 2.34.1 In-Reply-To: References: X-TMN: [pKHcfx4HiFA9ObEdxMwPq1aBOrYVdzs0] X-ClientProxiedBy: ZR0P278CA0086.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:22::19) To AS8P250MB0744.EURP250.PROD.OUTLOOK.COM (2603:10a6:20b:541::14) X-Microsoft-Original-Message-ID: <20230919195734.1005750-26-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: AS8P250MB0744:EE_|DU2P250MB0237:EE_ X-MS-Office365-Filtering-Correlation-Id: 600a96c6-66e8-4678-0044-08dbb94ac3c4 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: gDb2TA7Rram4ik+WpqCeqr7t2DlgHDlie4IC/344ZIRKuiRo4FOZ+8HTvw0POgnuqHW7HXU7ZvjNd1OjwZ3I2RCYZufAmxvtOEjaxEBmjSghCrNioLbk0n+fmTz/RgcJN8skenietPLpBv+Hh/iD18uwL6vQ0sYybmlBiud8gmKysCSEZpU2AGT69pKUew3PzEmYb1lcXjvPJMTFBfYiZJcWapPiw3PCp0HAY4nfKjArTXATGPY+QiH73cFxvCmEdYUsaCQfVEH3I4LATb+dqPGvxK/FMVldWh719I7/5l0NjmJFLvVvL9am36QEL0hDOoNekLikXfAoYA66jBfKXQmpGyxyvk3LsGE1xQEW6jbfWZYMetGcdEpqRnOPHJeYxEPCQy93m094Jxaa5njbWSVuSd5FWmz6tJ/IAIaMyazX1EXGgYiWsglvNHEiwNHa3cv/pf82Y8FzjVXuwfa6jJGYJoHHNiFO1c/GQpF9zKnFYFjTGR8O+YKeWaohq6gKPT7cugJgl1PNpQZqRcw9xZbozYoEnSVp0J+HaKFK95icTWsA0rDHLUEP6vr/nnJmxQG38wqFB80+SR91ZwRdhUG+46I4h2sX0xamSpZap9Q= X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: LLRFmjm7Pp8SIR5xin+EAj/fpZoJdV2kWu5i0aW3nUaOkfTJ7tYvbp/81MpMCXy3K6rjpG0fBVg11Fncort/tUpxx0+edaOWMBDNZhuHKMt7ZxIfMD/7Fitd+ITxIw2s2qJ26VH3PmVvxlgPaz0WPqfr7a7+9L+N3uOJ9w5UKWn2F9n46bY0sKIlUMhrjdaqGC2B9y9h3nmlPJ5YV7TgrGsfkj3nOvFK+q76EnOOqwXR1lMux6qDkMrEecdJk+qfwNSe2O4Ec3EJehwPGMtP3G7Ifdm+4MAxCk4WMkGT9Jy5wqbhMpWAWa0W5GQ+0C8B/RMq78d0e9OLlqk60pN4NIGH5ItW0pOekATTuOdTkm3t8Ce5Ce47O6xPRoAWSMUGucAz2bdnTupPrpaSA0csFzVwOVCj1eSG9xrSbtFAwuApEJvt3Y0daDlWMQCI+L/CtH4AneGgoeVL8T3W2ZdJvGu8JpzRgihQEnB6H+ZJ9lBJNxxl6Qwef8d2zXLlpnav/FKFHSwv3sifNJU1uTjS0udYjOZZY93xUiQrEeWDSZanlxWmH1O0g24gxbRM6K+kIJmaCX7cDchaEWAUbg7oH578hVh0ZfF6MLMXwZW8f/qhfbM9QWwaPCs0IF+DN74tXlcgTV0ekVNIQL2wmd2RchYLQKsHBWjtbr+EPiqyWMltJPF+XHzC8P7iR4PhggkrgD5tXRhpvnT8DV1pE1RT0PO9C3mxXCS3xT9kUVpIkDBd4zRI4hZ/qcXbybdPjhAcrNjw0RTskPJaNgZy0Vo0NNF11TcW3YP0T0geU27pAPI1iOMeBX1RF/MTz1r7/AOwBa8D611f/RsUh+heXTVaG1nUEKAiiHWY0XOIlW92ZKDHhFwJyikubFYtxtEQmrhJuvNU9zX1yJQ57JfRqI3BPurg34TnEQTxi6OTVSDxbMXvlaba0zJ0WsjSO+nPC4Gl8QyEBHdfJlokfS56aelHPK0MGamycBZwIySiXDNDIZvQAnBBqC2p1KQrrUkgahWjTbUnGgj2f1MWk+WsSged1O6fg8VgiZkuie34iQbb9y+8jx6X+KtfbVdXp3SBD9/s3dRrPfWRe4URF2A6qTF1zBeK8ws1SHeRGuW0f99Z10a6CrwKAfbWuc1H4XPTaet8BVMJJ3AR7Oo9YEANkEyowU2Ml9r2Zk3ssLv5uwJO1xwfeqmHSIg5qi5i50d52013zrSd7kIatSwvCtyyvN268sa4Y3AKH8ZSYmsRA0RKP6umysqI26boSFuNn/disEwF X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: 600a96c6-66e8-4678-0044-08dbb94ac3c4 X-MS-Exchange-CrossTenant-AuthSource: AS8P250MB0744.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 19 Sep 2023 19:58:16.9063 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: DU2P250MB0237 Subject: [FFmpeg-devel] [PATCH 26/42] avcodec/refstruct: Allow to use a dynamic opaque X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: FFmpeg development discussions and patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: FFmpeg development discussions and patches Cc: Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: WaVtUWochjkO This is in preparation for a new ThreadFrame-API based around RefStruct to allow to pass the AVCodecContext* to ff_thread_release_buffer(). Signed-off-by: Andreas Rheinhardt --- Now that thread-unsafe callbacks are no more, one could also just use av_frame_unref() instead of ff_thread_release_buffer(). But this is IMO more elegant. libavcodec/cbs.c | 8 ++-- libavcodec/refstruct.c | 83 +++++++++++++++++++++++++++++++++--------- libavcodec/refstruct.h | 83 ++++++++++++++++++++++++++++++++++++++---- 3 files changed, 146 insertions(+), 28 deletions(-) diff --git a/libavcodec/cbs.c b/libavcodec/cbs.c index 00c462b09d..40235ce647 100644 --- a/libavcodec/cbs.c +++ b/libavcodec/cbs.c @@ -903,11 +903,13 @@ static const CodedBitstreamUnitTypeDescriptor static void *cbs_alloc_content(const CodedBitstreamUnitTypeDescriptor *desc) { + FFRefStructUnrefCB unref_cb; + unref_cb.unref = desc->content_type == CBS_CONTENT_TYPE_COMPLEX + ? desc->type.complex.content_free + : cbs_default_free_unit_content; return ff_refstruct_alloc_ext_c(desc->content_size, 0, (FFRefStructOpaque){ .c = desc }, - desc->content_type == CBS_CONTENT_TYPE_COMPLEX - ? desc->type.complex.content_free - : cbs_default_free_unit_content); + unref_cb); } int ff_cbs_alloc_unit_content(CodedBitstreamContext *ctx, diff --git a/libavcodec/refstruct.c b/libavcodec/refstruct.c index 2108ff8163..817a8a455a 100644 --- a/libavcodec/refstruct.c +++ b/libavcodec/refstruct.c @@ -20,6 +20,8 @@ #include #include +#include "config.h" + #include "internal.h" #include "refstruct.h" @@ -37,8 +39,11 @@ typedef struct RefCount { */ atomic_uintptr_t refcount; FFRefStructOpaque opaque; - void (*free_cb)(FFRefStructOpaque opaque, void *obj); + FFRefStructUnrefCB free_cb; void (*free)(void *ref); +#if defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 1 + unsigned flags; +#endif } RefCount; #if __STDC_VERSION__ >= 201112L @@ -63,16 +68,19 @@ static void *get_userdata(void *buf) } static void refcount_init(RefCount *ref, FFRefStructOpaque opaque, - void (*free_cb)(FFRefStructOpaque opaque, void *obj)) + unsigned flags, FFRefStructUnrefCB free_cb) { atomic_init(&ref->refcount, 1); ref->opaque = opaque; ref->free_cb = free_cb; ref->free = av_free; +#if defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 1 + ref->flags = flags; +#endif } void *ff_refstruct_alloc_ext_c(size_t size, unsigned flags, FFRefStructOpaque opaque, - void (*free_cb)(FFRefStructOpaque opaque, void *obj)) + FFRefStructUnrefCB free_cb) { void *buf, *obj; @@ -81,7 +89,7 @@ void *ff_refstruct_alloc_ext_c(size_t size, unsigned flags, FFRefStructOpaque op buf = av_malloc(size + REFCOUNT_OFFSET); if (!buf) return NULL; - refcount_init(buf, opaque, free_cb); + refcount_init(buf, opaque, flags, free_cb); obj = get_userdata(buf); if (!(flags & FF_REFSTRUCT_FLAG_NO_ZEROING)) memset(obj, 0, size); @@ -105,9 +113,31 @@ void ff_refstruct_unref(void *objp) memcpy(objp, &(void *){ NULL }, sizeof(obj)); ref = get_refcount(obj); + av_assert1(!(ref->flags & FF_REFSTRUCT_FLAG_DYNAMIC_OPAQUE)); + if (atomic_fetch_sub_explicit(&ref->refcount, 1, memory_order_acq_rel) == 1) { + if (ref->free_cb.unref) + ref->free_cb.unref(ref->opaque, obj); + ref->free(ref); + } + + return; +} + +void ff_refstruct_unref_ext_c(FFRefStructOpaque opaque, void *objp) +{ + void *obj; + RefCount *ref; + + memcpy(&obj, objp, sizeof(obj)); + if (!obj) + return; + memcpy(objp, &(void *){ NULL }, sizeof(obj)); + + ref = get_refcount(obj); + av_assert1(ref->flags & FF_REFSTRUCT_FLAG_DYNAMIC_OPAQUE); if (atomic_fetch_sub_explicit(&ref->refcount, 1, memory_order_acq_rel) == 1) { - if (ref->free_cb) - ref->free_cb(ref->opaque, obj); + if (ref->free_cb.unref_ext) + ref->free_cb.unref_ext(opaque, ref->opaque, obj); ref->free(ref); } @@ -161,7 +191,7 @@ struct FFRefStructPool { size_t size; FFRefStructOpaque opaque; int (*init_cb)(FFRefStructOpaque opaque, void *obj); - void (*reset_cb)(FFRefStructOpaque opaque, void *obj); + FFRefStructUnrefCB reset_cb; void (*free_entry_cb)(FFRefStructOpaque opaque, void *obj); void (*free_cb)(FFRefStructOpaque opaque); @@ -221,14 +251,23 @@ static void pool_reset_entry(FFRefStructOpaque opaque, void *entry) { FFRefStructPool *pool = opaque.nc; - pool->reset_cb(pool->opaque, entry); + pool->reset_cb.unref(pool->opaque, entry); +} + +static void pool_reset_entry_ext(FFRefStructOpaque opaque, + FFRefStructOpaque initial_opaque, + void *entry) +{ + FFRefStructPool *pool = initial_opaque.nc; + + pool->reset_cb.unref_ext(opaque, pool->opaque, entry); } -static int refstruct_pool_get_ext(void *datap, FFRefStructPool *pool) +static int refstruct_pool_get_ext(void *objp, FFRefStructPool *pool) { void *ret = NULL; - memcpy(datap, &(void *){ NULL }, sizeof(void*)); + memcpy(objp, &(void *){ NULL }, sizeof(void*)); pthread_mutex_lock(&pool->mutex); av_assert1(!pool->uninited); @@ -243,8 +282,13 @@ static int refstruct_pool_get_ext(void *datap, FFRefStructPool *pool) if (!ret) { RefCount *ref; - ret = ff_refstruct_alloc_ext(pool->size, pool->entry_flags, pool, - pool->reset_cb ? pool_reset_entry : NULL); +#define CB_INIT(suffix) ((FFRefStructUnrefCB) { .unref ## suffix = pool->reset_cb.unref ## suffix ? \ + pool_reset_entry ## suffix : NULL }) + ret = ff_refstruct_alloc_ext_c(pool->size, pool->entry_flags, + (FFRefStructOpaque){ .nc = pool }, + (pool->pool_flags & FF_REFSTRUCT_FLAG_DYNAMIC_OPAQUE) ? + CB_INIT(_ext) : CB_INIT()); +#undef CB_INIT if (!ret) return AVERROR(ENOMEM); ref = get_refcount(ret); @@ -253,7 +297,7 @@ static int refstruct_pool_get_ext(void *datap, FFRefStructPool *pool) 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); + pool->reset_cb.unref(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); @@ -266,7 +310,7 @@ static int refstruct_pool_get_ext(void *datap, FFRefStructPool *pool) if (pool->pool_flags & FF_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME) memset(ret, 0, pool->size); - memcpy(datap, &ret, sizeof(ret)); + memcpy(objp, &ret, sizeof(ret)); return 0; } @@ -312,7 +356,7 @@ FFRefStructPool *ff_refstruct_pool_alloc(size_t size, unsigned flags) 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), + FFRefStructUnrefCB reset_cb, void (*free_entry_cb)(FFRefStructOpaque opaque, void *obj), void (*free_cb)(FFRefStructOpaque opaque)) { @@ -330,10 +374,15 @@ FFRefStructPool *ff_refstruct_pool_alloc_ext_c(size_t size, unsigned flags, 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 +#define COMMON_FLAGS (FF_REFSTRUCT_POOL_FLAG_NO_ZEROING | FF_REFSTRUCT_POOL_FLAG_DYNAMIC_OPAQUE) pool->entry_flags = flags & COMMON_FLAGS; + // Dynamic opaque and resetting-on-init-error are incompatible + // (there is no dynamic opaque available in ff_refstruct_pool_get()). + av_assert1(!(flags & FF_REFSTRUCT_POOL_FLAG_DYNAMIC_OPAQUE && + flags & FF_REFSTRUCT_POOL_FLAG_RESET_ON_INIT_ERROR)); // Filter out nonsense combinations to avoid checks later. - if (!pool->reset_cb) + if (flags & FF_REFSTRUCT_POOL_FLAG_RESET_ON_INIT_ERROR && + !pool->reset_cb.unref) flags &= ~FF_REFSTRUCT_POOL_FLAG_RESET_ON_INIT_ERROR; if (!pool->free_entry_cb) flags &= ~FF_REFSTRUCT_POOL_FLAG_FREE_ON_INIT_ERROR; diff --git a/libavcodec/refstruct.h b/libavcodec/refstruct.h index d525be61e8..b0a750e2f7 100644 --- a/libavcodec/refstruct.h +++ b/libavcodec/refstruct.h @@ -53,18 +53,42 @@ * * The functions provided by this API with an FFRefStructOpaque come in pairs * named foo_c and foo. The foo function accepts void* as opaque and is just - * a wrapper around the foo_c function; "_c" means "(potentially) const". + * a wrapper around the foo_c function for the common case of a non-const + * opaque ("_c" means "(potentially) const"). For the allocation functions + * the wrappers also accept the ordinary "unref" form of FFRefStructUnrefCB; + * only the "_c" versions accept the full union to set the unref_ext variant. */ typedef union { void *nc; const void *c; } FFRefStructOpaque; +typedef union FFRefStructUnrefCB { + void (*unref)(FFRefStructOpaque opaque, void *obj); + void (*unref_ext)(FFRefStructOpaque dynamic_opaque, + FFRefStructOpaque initial_opaque, + void *obj); +} FFRefStructUnrefCB; + /** * If this flag is set in ff_refstruct_alloc_ext_c(), the object will not * be initially zeroed. */ #define FF_REFSTRUCT_FLAG_NO_ZEROING (1 << 0) +/** + * This flag being set indicates that the free_cb union is in + * the unref_ext-state. + * In this case unreferencing the object has to be done + * via ff_refstruct_unref_ext() instead of ff_refstruct_unref(). + * Using the latter is forbidden and leads to undefined behaviour. + * + * The free_ext-callback will be called when the refcount reaches zero + * with the opaque given to ff_refstruct_unref_ext() passed along as + * the callback's dynamic_opaque parameter; the argument corresponding + * to the initial_opaque parameter will be the opaque provided to + * ff_refstruct_alloc_ext_c() and obj is the object to be unreferenced. + */ +#define FF_REFSTRUCT_FLAG_DYNAMIC_OPAQUE (1 << 1) /** * Allocate a refcounted object of usable size `size` managed via @@ -76,17 +100,19 @@ typedef union { * @param size Desired usable size of the returned object. * @param flags A bitwise combination of FF_REFSTRUCT_FLAG_* flags. * @param opaque A pointer that will be passed to the free_cb callback. - * @param free_cb A callback for freeing this object's content + * @param free_cb Contains the callback for freeing this object's content * when its reference count reaches zero; * it must not free the object itself. + * The state of free_cb is indicated by the + * FF_REFSTRUCT_FLAG_DYNAMIC_OPAQUE flag. * @return A pointer to an object of the desired size or NULL on failure. */ void *ff_refstruct_alloc_ext_c(size_t size, unsigned flags, FFRefStructOpaque opaque, - void (*free_cb)(FFRefStructOpaque opaque, void *obj)); + FFRefStructUnrefCB free_cb); /** * A wrapper around ff_refstruct_alloc_ext_c() for the common case - * of a non-const qualified opaque. + * of a non-const qualified and non-dynamic opaque. * * @see ff_refstruct_alloc_ext_c() */ @@ -95,7 +121,7 @@ void *ff_refstruct_alloc_ext(size_t size, unsigned flags, void *opaque, void (*free_cb)(FFRefStructOpaque opaque, void *obj)) { return ff_refstruct_alloc_ext_c(size, flags, (FFRefStructOpaque){.nc = opaque}, - free_cb); + (FFRefStructUnrefCB){ .unref = free_cb }); } /** @@ -107,6 +133,10 @@ void *ff_refstruct_allocz(size_t size); * Decrement the reference count of the underlying object and automatically * free the object if there are no more references to it. * + * This function must not be used if the object has been created + * with the dynamic opaque flags (FF_REFSTRUCT_FLAG_DYNAMIC_OPAQUE + * or FF_REFSTRUCT_POOL_FLAG_DYNAMIC_OPAQUE for objects from pools). + * * `*objp == NULL` is legal and a no-op. * * @param objp Pointer to a pointer that is either NULL or points to an object @@ -114,6 +144,32 @@ void *ff_refstruct_allocz(size_t size); */ void ff_refstruct_unref(void *objp); +/** + * Decrement the reference count of the underlying object and automatically + * free the object if there are no more references to it. + * + * This function may only be used of the object has been created + * with the dynamic opaque flags (FF_REFSTRUCT_FLAG_DYNAMIC_OPAQUE + * or FF_REFSTRUCT_POOL_FLAG_DYNAMIC_OPAQUE for objects from pools). + * + * `*objp == NULL` is legal and a no-op. + * + * @param objp Pointer to a pointer that is either NULL or points to an object + * managed via this API. `*objp` is set to NULL on return. + */ +void ff_refstruct_unref_ext_c(FFRefStructOpaque opaque, void *objp); +/** + * A wrapper around ff_refstruct_unref_ext_c() for the common case + * of a non-const qualified dynamic opaque. + * + * @see ff_refstruct_alloc_ext_c() + */ +static inline +void ff_refstruct_unref_ext(void *opaque, void *objp) +{ + ff_refstruct_unref_ext_c((FFRefStructOpaque){ .nc = opaque }, objp); +} + /** * Create a new reference to an object managed via this API, * i.e. increment the reference count of the underlying object @@ -215,6 +271,16 @@ typedef struct FFRefStructPool FFRefStructPool; * flag had been provided. */ #define FF_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME (1 << 18) +/** + * This flag being set indicates that the reset_cb union is in + * the unref_ext-state. The semantics of FF_REFSTRUCT_FLAG_DYNAMIC_OPAQUE + * apply with the opaque given to ff_refstruct_alloc_ext_c() + * corresponding to the opaque given to ff_refstruct_pool_alloc_ext_c(). + * + * This flag is incompatible with FF_REFSTRUCT_POOL_FLAG_RESET_ON_INIT_ERROR. + * Giving both to a pool allocation function leads to undefined behaviour. + */ +#define FF_REFSTRUCT_POOL_FLAG_DYNAMIC_OPAQUE FF_REFSTRUCT_FLAG_DYNAMIC_OPAQUE /** * Equivalent to ff_refstruct_pool_alloc(size, flags, NULL, NULL, NULL, NULL, NULL) @@ -240,13 +306,13 @@ FFRefStructPool *ff_refstruct_pool_alloc(size_t size, unsigned flags); 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), + FFRefStructUnrefCB reset_cb, void (*free_entry_cb)(FFRefStructOpaque opaque, void *obj), void (*free_cb)(FFRefStructOpaque opaque)); /** * A wrapper around ff_refstruct_pool_alloc_ext_c() for the common case - * of a non-const qualified opaque. + * of a non-const qualified and non-dynamic opaque. * * @see ff_refstruct_pool_alloc_ext_c() */ @@ -259,7 +325,8 @@ FFRefStructPool *ff_refstruct_pool_alloc_ext(size_t size, unsigned flags, void (*free_cb)(FFRefStructOpaque opaque)) { return ff_refstruct_pool_alloc_ext_c(size, flags, (FFRefStructOpaque){.nc = opaque}, - init_cb, reset_cb, free_entry_cb, free_cb); + init_cb, (FFRefStructUnrefCB){ .unref = reset_cb }, + free_entry_cb, free_cb); } /**