[FFmpeg-cvslog] lavc/refstruct: move to lavu and make public
Anton Khirnov
git at videolan.org
Sun Dec 15 16:16:35 EET 2024
ffmpeg | branch: master | Anton Khirnov <anton at khirnov.net> | Tue Oct 15 22:37:56 2024 +0200| [56ba57b6725116d4439f672f92ad70b766ea198a] | committer: Anton Khirnov
lavc/refstruct: move to lavu and make public
It is highly versatile and generally useful.
> http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=56ba57b6725116d4439f672f92ad70b766ea198a
---
doc/APIchanges | 4 ++
libavcodec/Makefile | 1 -
libavcodec/av1dec.c | 28 ++++----
libavcodec/avcodec.c | 6 +-
libavcodec/bsf/dts2pts.c | 18 ++---
libavcodec/cbs.c | 22 +++---
libavcodec/cbs_av1.c | 18 ++---
libavcodec/cbs_h2645.c | 48 ++++++-------
libavcodec/cbs_h266_syntax_template.c | 2 +-
libavcodec/cbs_internal.h | 4 +-
libavcodec/cbs_sei.c | 24 +++----
libavcodec/container_fifo.c | 22 +++---
libavcodec/decode.c | 32 ++++-----
libavcodec/dovi_rpu.c | 20 +++---
libavcodec/dovi_rpudec.c | 10 +--
libavcodec/dovi_rpuenc.c | 12 ++--
libavcodec/ffv1.c | 10 +--
libavcodec/ffv1dec.c | 12 ++--
libavcodec/get_buffer.c | 10 +--
libavcodec/h2645_sei.c | 10 +--
libavcodec/h264_parser.c | 4 +-
libavcodec/h264_picture.c | 30 ++++----
libavcodec/h264_ps.c | 28 ++++----
libavcodec/h264_slice.c | 38 +++++------
libavcodec/h264dec.c | 14 ++--
libavcodec/h264dec.h | 10 +--
libavcodec/hevc/hevcdec.c | 46 ++++++-------
libavcodec/hevc/hevcdec.h | 4 +-
libavcodec/hevc/ps.c | 44 ++++++------
libavcodec/hevc/refs.c | 20 +++---
libavcodec/hwaccel_internal.h | 4 +-
libavcodec/internal.h | 2 +-
libavcodec/lcevcdec.c | 8 ++-
libavcodec/lcevcdec.h | 1 -
libavcodec/mpegpicture.c | 34 +++++-----
libavcodec/mpegpicture.h | 12 ++--
libavcodec/mpegvideo.c | 18 ++---
libavcodec/mpegvideo.h | 2 +-
libavcodec/mpegvideo_dec.c | 6 +-
libavcodec/mpegvideo_enc.c | 18 ++---
libavcodec/nvdec.c | 42 ++++++------
libavcodec/nvdec.h | 2 +-
libavcodec/pthread_frame.c | 14 ++--
libavcodec/qsv.c | 14 ++--
libavcodec/qsvdec.c | 4 +-
libavcodec/qsvenc.c | 4 +-
libavcodec/rkmppdec.c | 12 ++--
libavcodec/utils.c | 6 +-
libavcodec/v4l2_buffers.c | 6 +-
libavcodec/v4l2_m2m.c | 10 +--
libavcodec/vaapi_encode.c | 24 +++----
libavcodec/vaapi_encode.h | 2 +-
libavcodec/vp3.c | 10 +--
libavcodec/vp8.c | 14 ++--
libavcodec/vp9.c | 22 +++---
libavcodec/vp9dec.h | 2 +-
libavcodec/vulkan_av1.c | 2 +-
libavcodec/vulkan_decode.c | 14 ++--
libavcodec/vulkan_h264.c | 2 +-
libavcodec/vulkan_hevc.c | 2 +-
libavcodec/vvc/ctu.c | 10 +--
libavcodec/vvc/dec.c | 44 ++++++------
libavcodec/vvc/dec.h | 8 +--
libavcodec/vvc/ps.c | 78 ++++++++++-----------
libavcodec/vvc/refs.c | 32 ++++-----
libavcodec/wavpack.c | 32 ++++-----
libavutil/Makefile | 2 +
{libavcodec => libavutil}/refstruct.c | 112 +++++++++++++++---------------
{libavcodec => libavutil}/refstruct.h | 124 +++++++++++++++++-----------------
libavutil/version.h | 2 +-
70 files changed, 657 insertions(+), 651 deletions(-)
diff --git a/doc/APIchanges b/doc/APIchanges
index 3a75b803a9..f01e5bf7bf 100644
--- a/doc/APIchanges
+++ b/doc/APIchanges
@@ -2,6 +2,10 @@ The last version increases of all libraries were on 2024-03-07
API changes, most recent first:
+2024-12-15 - xxxxxxxxxx - lavu 59.51.100 - refstruct.h
+ Add a new public header refstruct.h with new API for
+ reference-counted objects.
+
2024-12-13 - xxxxxxxxxx - lavu 59.50.100 - channel_layout.h
Add AV_CH_LAYOUT_9POINT1POINT6 and AV_CHANNEL_LAYOUT_9POINT1POINT6.
diff --git a/libavcodec/Makefile b/libavcodec/Makefile
index 9a08a8441f..cd64013998 100644
--- a/libavcodec/Makefile
+++ b/libavcodec/Makefile
@@ -57,7 +57,6 @@ OBJS = ac3_parser.o \
profiles.o \
qsv_api.o \
raw.o \
- refstruct.o \
threadprogress.o \
utils.o \
version.o \
diff --git a/libavcodec/av1dec.c b/libavcodec/av1dec.c
index bc4ef63e68..17651e640f 100644
--- a/libavcodec/av1dec.c
+++ b/libavcodec/av1dec.c
@@ -39,7 +39,7 @@
#include "hwconfig.h"
#include "profiles.h"
#include "progressframe.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
/**< same with Div_Lut defined in spec 7.11.3.7 */
static const uint16_t div_lut[AV1_DIV_LUT_NUM] = {
@@ -687,8 +687,8 @@ static int get_pixel_format(AVCodecContext *avctx)
static void av1_frame_unref(AV1Frame *f)
{
ff_progress_frame_unref(&f->pf);
- ff_refstruct_unref(&f->hwaccel_picture_private);
- ff_refstruct_unref(&f->header_ref);
+ av_refstruct_unref(&f->hwaccel_picture_private);
+ av_refstruct_unref(&f->header_ref);
f->raw_frame_header = NULL;
f->spatial_id = f->temporal_id = 0;
memset(f->skip_mode_frame_idx, 0,
@@ -701,13 +701,13 @@ static void av1_frame_replace(AV1Frame *dst, const AV1Frame *src)
{
av_assert1(dst != src);
- ff_refstruct_replace(&dst->header_ref, src->header_ref);
+ av_refstruct_replace(&dst->header_ref, src->header_ref);
dst->raw_frame_header = src->raw_frame_header;
ff_progress_frame_replace(&dst->pf, &src->pf);
- ff_refstruct_replace(&dst->hwaccel_picture_private,
+ av_refstruct_replace(&dst->hwaccel_picture_private,
src->hwaccel_picture_private);
dst->spatial_id = src->spatial_id;
@@ -747,10 +747,10 @@ static av_cold int av1_decode_free(AVCodecContext *avctx)
av1_frame_unref(&s->ref[i]);
av1_frame_unref(&s->cur_frame);
av_buffer_unref(&s->seq_data_ref);
- ff_refstruct_unref(&s->seq_ref);
- ff_refstruct_unref(&s->header_ref);
- ff_refstruct_unref(&s->cll_ref);
- ff_refstruct_unref(&s->mdcv_ref);
+ av_refstruct_unref(&s->seq_ref);
+ av_refstruct_unref(&s->header_ref);
+ av_refstruct_unref(&s->cll_ref);
+ av_refstruct_unref(&s->mdcv_ref);
av_freep(&s->tile_group_info);
while (s->itut_t35_fifo && av_fifo_read(s->itut_t35_fifo, &itut_t35, 1) >= 0)
@@ -1218,7 +1218,7 @@ static int get_current_frame(AVCodecContext *avctx)
av1_frame_unref(&s->cur_frame);
- s->cur_frame.header_ref = ff_refstruct_ref(s->header_ref);
+ s->cur_frame.header_ref = av_refstruct_ref(s->header_ref);
s->cur_frame.raw_frame_header = s->raw_frame_header;
@@ -1306,7 +1306,7 @@ static int av1_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame)
s->seq_data_ref->data = unit->data;
s->seq_data_ref->size = unit->data_size;
- ff_refstruct_replace(&s->seq_ref, unit->content_ref);
+ av_refstruct_replace(&s->seq_ref, unit->content_ref);
s->raw_seq = &obu->obu.sequence_header;
@@ -1334,7 +1334,7 @@ static int av1_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame)
goto end;
}
- ff_refstruct_replace(&s->header_ref, unit->content_ref);
+ av_refstruct_replace(&s->header_ref, unit->content_ref);
if (unit->type == AV1_OBU_FRAME)
s->raw_frame_header = &obu->obu.frame.header;
@@ -1414,11 +1414,11 @@ static int av1_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame)
case AV1_OBU_METADATA:
switch (obu->obu.metadata.metadata_type) {
case AV1_METADATA_TYPE_HDR_CLL:
- ff_refstruct_replace(&s->cll_ref, unit->content_ref);
+ av_refstruct_replace(&s->cll_ref, unit->content_ref);
s->cll = &obu->obu.metadata.metadata.hdr_cll;
break;
case AV1_METADATA_TYPE_HDR_MDCV:
- ff_refstruct_replace(&s->mdcv_ref, unit->content_ref);
+ av_refstruct_replace(&s->mdcv_ref, unit->content_ref);
s->mdcv = &obu->obu.metadata.metadata.hdr_mdcv;
break;
case AV1_METADATA_TYPE_ITUT_T35: {
diff --git a/libavcodec/avcodec.c b/libavcodec/avcodec.c
index 1fa8704c9d..f91549ddba 100644
--- a/libavcodec/avcodec.c
+++ b/libavcodec/avcodec.c
@@ -45,7 +45,7 @@
#include "frame_thread_encoder.h"
#include "hwconfig.h"
#include "internal.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
#include "thread.h"
/**
@@ -453,8 +453,8 @@ av_cold void ff_codec_close(AVCodecContext *avctx)
av_frame_free(&avci->in_frame);
av_frame_free(&avci->recon_frame);
- ff_refstruct_unref(&avci->pool);
- ff_refstruct_pool_uninit(&avci->progress_frame_pool);
+ av_refstruct_unref(&avci->pool);
+ av_refstruct_pool_uninit(&avci->progress_frame_pool);
if (av_codec_is_decoder(avctx->codec))
ff_decode_internal_uninit(avctx);
diff --git a/libavcodec/bsf/dts2pts.c b/libavcodec/bsf/dts2pts.c
index 62838d4f7b..9d31d7dc08 100644
--- a/libavcodec/bsf/dts2pts.c
+++ b/libavcodec/bsf/dts2pts.c
@@ -34,7 +34,7 @@
#include "cbs_h264.h"
#include "h264_parse.h"
#include "h264_ps.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
typedef struct DTS2PTSNode {
int64_t dts;
@@ -62,7 +62,7 @@ typedef struct DTS2PTSH264Context {
typedef struct DTS2PTSContext {
struct AVTreeNode *root;
AVFifo *fifo;
- FFRefStructPool *node_pool;
+ AVRefStructPool *node_pool;
// Codec specific function pointers and constants
int (*init)(AVBSFContext *ctx);
@@ -112,7 +112,7 @@ static int dec_poc(void *opaque, void *elem)
static int free_node(void *opaque, void *elem)
{
DTS2PTSNode *node = elem;
- ff_refstruct_unref(&node);
+ av_refstruct_unref(&node);
return 0;
}
@@ -126,7 +126,7 @@ static int alloc_and_insert_node(AVBSFContext *ctx, int64_t ts, int64_t duration
DTS2PTSNode *poc_node, *ret;
if (!node)
return AVERROR(ENOMEM);
- poc_node = ff_refstruct_pool_get(s->node_pool);
+ poc_node = av_refstruct_pool_get(s->node_pool);
if (!poc_node) {
av_free(node);
return AVERROR(ENOMEM);
@@ -137,7 +137,7 @@ static int alloc_and_insert_node(AVBSFContext *ctx, int64_t ts, int64_t duration
ret = av_tree_insert(&s->root, poc_node, cmp_insert, &node);
if (ret && ret != poc_node) {
*ret = *poc_node;
- ff_refstruct_unref(&poc_node);
+ av_refstruct_unref(&poc_node);
av_free(node);
}
}
@@ -396,8 +396,8 @@ static int dts2pts_init(AVBSFContext *ctx)
if (!s->fifo)
return AVERROR(ENOMEM);
- s->node_pool = ff_refstruct_pool_alloc(sizeof(DTS2PTSNode),
- FF_REFSTRUCT_POOL_FLAG_NO_ZEROING);
+ s->node_pool = av_refstruct_pool_alloc(sizeof(DTS2PTSNode),
+ AV_REFSTRUCT_POOL_FLAG_NO_ZEROING);
if (!s->node_pool)
return AVERROR(ENOMEM);
@@ -467,7 +467,7 @@ static int dts2pts_filter(AVBSFContext *ctx, AVPacket *out)
if (!poc_node || poc_node->dts != out->pts)
continue;
av_tree_insert(&s->root, poc_node, cmp_insert, &node);
- ff_refstruct_unref(&poc_node);
+ av_refstruct_unref(&poc_node);
av_free(node);
poc_node = av_tree_find(s->root, &dup, cmp_find, NULL);
}
@@ -529,7 +529,7 @@ static void dts2pts_close(AVBSFContext *ctx)
dts2pts_flush(ctx);
av_fifo_freep2(&s->fifo);
- ff_refstruct_pool_uninit(&s->node_pool);
+ av_refstruct_pool_uninit(&s->node_pool);
ff_cbs_fragment_free(&s->au);
ff_cbs_close(&s->cbc);
}
diff --git a/libavcodec/cbs.c b/libavcodec/cbs.c
index b26e39eab4..01dd916d81 100644
--- a/libavcodec/cbs.c
+++ b/libavcodec/cbs.c
@@ -29,7 +29,7 @@
#include "avcodec.h"
#include "cbs.h"
#include "cbs_internal.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
static const CodedBitstreamType *const cbs_type_table[] = {
@@ -160,7 +160,7 @@ av_cold void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
static void cbs_unit_uninit(CodedBitstreamUnit *unit)
{
- ff_refstruct_unref(&unit->content_ref);
+ av_refstruct_unref(&unit->content_ref);
unit->content = NULL;
av_buffer_unref(&unit->data_ref);
@@ -208,7 +208,7 @@ static int cbs_read_fragment_content(CodedBitstreamContext *ctx,
continue;
}
- ff_refstruct_unref(&unit->content_ref);
+ av_refstruct_unref(&unit->content_ref);
unit->content = NULL;
av_assert0(unit->data && unit->data_ref);
@@ -222,7 +222,7 @@ static int cbs_read_fragment_content(CodedBitstreamContext *ctx,
av_log(ctx->log_ctx, AV_LOG_VERBOSE,
"Skipping decomposition of unit %d "
"(type %"PRIu32").\n", i, unit->type);
- ff_refstruct_unref(&unit->content_ref);
+ av_refstruct_unref(&unit->content_ref);
unit->content = NULL;
} else if (err < 0) {
av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to read unit %d "
@@ -799,7 +799,7 @@ int ff_cbs_insert_unit_content(CodedBitstreamFragment *frag,
if (content_ref) {
// Create our own reference out of the user-supplied one.
- content_ref = ff_refstruct_ref(content_ref);
+ content_ref = av_refstruct_ref(content_ref);
}
unit = &frag->units[position];
@@ -873,7 +873,7 @@ void ff_cbs_delete_unit(CodedBitstreamFragment *frag,
(frag->nb_units - position) * sizeof(*frag->units));
}
-static void cbs_default_free_unit_content(FFRefStructOpaque opaque, void *content)
+static void cbs_default_free_unit_content(AVRefStructOpaque opaque, void *content)
{
const CodedBitstreamUnitTypeDescriptor *desc = opaque.c;
@@ -913,8 +913,8 @@ static const CodedBitstreamUnitTypeDescriptor
static void *cbs_alloc_content(const CodedBitstreamUnitTypeDescriptor *desc)
{
- return ff_refstruct_alloc_ext_c(desc->content_size, 0,
- (FFRefStructOpaque){ .c = desc },
+ return av_refstruct_alloc_ext_c(desc->content_size, 0,
+ (AVRefStructOpaque){ .c = desc },
desc->content_type == CBS_CONTENT_TYPE_COMPLEX
? desc->type.complex.content_free
: cbs_default_free_unit_content);
@@ -989,7 +989,7 @@ static int cbs_clone_noncomplex_unit_content(void **clonep,
return 0;
fail:
- ff_refstruct_unref(©);
+ av_refstruct_unref(©);
return err;
}
@@ -1048,13 +1048,13 @@ int ff_cbs_make_unit_writable(CodedBitstreamContext *ctx,
int err;
av_assert0(unit->content);
- if (ref && ff_refstruct_exclusive(ref))
+ if (ref && av_refstruct_exclusive(ref))
return 0;
err = cbs_clone_unit_content(ctx, unit);
if (err < 0)
return err;
- ff_refstruct_unref(&ref);
+ av_refstruct_unref(&ref);
return 0;
}
diff --git a/libavcodec/cbs_av1.c b/libavcodec/cbs_av1.c
index 458381f038..be086b81cb 100644
--- a/libavcodec/cbs_av1.c
+++ b/libavcodec/cbs_av1.c
@@ -24,7 +24,7 @@
#include "cbs_internal.h"
#include "cbs_av1.h"
#include "defs.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
static int cbs_av1_read_uvlc(CodedBitstreamContext *ctx, GetBitContext *gbc,
@@ -878,7 +878,7 @@ static int cbs_av1_read_unit(CodedBitstreamContext *ctx,
priv->operating_point_idc = sequence_header->operating_point_idc[priv->operating_point];
}
- ff_refstruct_replace(&priv->sequence_header_ref, unit->content_ref);
+ av_refstruct_replace(&priv->sequence_header_ref, unit->content_ref);
priv->sequence_header = &obu->obu.sequence_header;
}
break;
@@ -997,7 +997,7 @@ static int cbs_av1_write_obu(CodedBitstreamContext *ctx,
av1ctx = *priv;
if (priv->sequence_header_ref) {
- av1ctx.sequence_header_ref = ff_refstruct_ref(priv->sequence_header_ref);
+ av1ctx.sequence_header_ref = av_refstruct_ref(priv->sequence_header_ref);
}
if (priv->frame_header_ref) {
@@ -1035,14 +1035,14 @@ static int cbs_av1_write_obu(CodedBitstreamContext *ctx,
if (err < 0)
goto error;
- ff_refstruct_unref(&priv->sequence_header_ref);
+ av_refstruct_unref(&priv->sequence_header_ref);
priv->sequence_header = NULL;
err = ff_cbs_make_unit_refcounted(ctx, unit);
if (err < 0)
goto error;
- priv->sequence_header_ref = ff_refstruct_ref(unit->content_ref);
+ priv->sequence_header_ref = av_refstruct_ref(unit->content_ref);
priv->sequence_header = &obu->obu.sequence_header;
}
break;
@@ -1146,7 +1146,7 @@ static int cbs_av1_write_obu(CodedBitstreamContext *ctx,
av_assert0(data_pos <= start_pos);
if (8 * obu->obu_size > put_bits_left(pbc)) {
- ff_refstruct_unref(&priv->sequence_header_ref);
+ av_refstruct_unref(&priv->sequence_header_ref);
av_buffer_unref(&priv->frame_header_ref);
*priv = av1ctx;
@@ -1175,7 +1175,7 @@ static int cbs_av1_write_obu(CodedBitstreamContext *ctx,
err = 0;
error:
- ff_refstruct_unref(&av1ctx.sequence_header_ref);
+ av_refstruct_unref(&av1ctx.sequence_header_ref);
av_buffer_unref(&av1ctx.frame_header_ref);
return err;
@@ -1227,11 +1227,11 @@ static void cbs_av1_close(CodedBitstreamContext *ctx)
{
CodedBitstreamAV1Context *priv = ctx->priv_data;
- ff_refstruct_unref(&priv->sequence_header_ref);
+ av_refstruct_unref(&priv->sequence_header_ref);
av_buffer_unref(&priv->frame_header_ref);
}
-static void cbs_av1_free_metadata(FFRefStructOpaque unused, void *content)
+static void cbs_av1_free_metadata(AVRefStructOpaque unused, void *content)
{
AV1RawOBU *obu = content;
AV1RawMetadata *md;
diff --git a/libavcodec/cbs_h2645.c b/libavcodec/cbs_h2645.c
index 2de74691cb..369e3ac876 100644
--- a/libavcodec/cbs_h2645.c
+++ b/libavcodec/cbs_h2645.c
@@ -28,7 +28,7 @@
#include "cbs_h266.h"
#include "h264.h"
#include "h2645_parse.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
#include "vvc.h"
#include "hevc/hevc.h"
@@ -345,7 +345,7 @@ static int cbs_h2645_read_more_rbsp_data(GetBitContext *gbc)
/* The CBS SEI code uses the refstruct API for the allocation
* of its child buffers. */
#define allocate(name, size) do { \
- name = ff_refstruct_allocz(size + \
+ name = av_refstruct_allocz(size + \
AV_INPUT_BUFFER_PADDING_SIZE); \
if (!name) \
return AVERROR(ENOMEM); \
@@ -769,7 +769,7 @@ static int cbs_h26 ## h26n ## _replace_ ## ps_var(CodedBitstreamContext *ctx, \
if (priv->ps_var[id] == priv->active_ ## ps_var) \
priv->active_ ## ps_var = NULL ; \
av_assert0(unit->content_ref); \
- ff_refstruct_replace(&priv->ps_var[id], unit->content_ref); \
+ av_refstruct_replace(&priv->ps_var[id], unit->content_ref); \
return 0; \
}
@@ -790,7 +790,7 @@ static int cbs_h26 ## h26n ## _replace_ ## ps_var(CodedBitstreamContext *ctx, \
if (err < 0) \
return err; \
av_assert0(unit->content_ref); \
- ff_refstruct_replace(&priv->ps_var[id], unit->content_ref); \
+ av_refstruct_replace(&priv->ps_var[id], unit->content_ref); \
return 0; \
}
@@ -810,10 +810,10 @@ static int cbs_h266_replace_sps(CodedBitstreamContext *ctx,
if (priv->sps[id] && memcmp(priv->sps[id], unit->content_ref, sizeof(*priv->sps[id]))) {
for (unsigned int i = 0; i < VVC_MAX_PPS_COUNT; i++) {
if (priv->pps[i] && priv->pps[i]->pps_seq_parameter_set_id == id)
- ff_refstruct_unref(&priv->pps[i]);
+ av_refstruct_unref(&priv->pps[i]);
}
}
- ff_refstruct_replace(&priv->sps[id], unit->content_ref);
+ av_refstruct_replace(&priv->sps[id], unit->content_ref);
return 0;
}
@@ -828,7 +828,7 @@ static int cbs_h266_replace_ph(CodedBitstreamContext *ctx,
if (err < 0)
return err;
av_assert0(unit->content_ref);
- ff_refstruct_replace(&h266->ph_ref, unit->content_ref);
+ av_refstruct_replace(&h266->ph_ref, unit->content_ref);
h266->ph = ph;
return 0;
}
@@ -1910,9 +1910,9 @@ static void cbs_h264_flush(CodedBitstreamContext *ctx)
CodedBitstreamH264Context *h264 = ctx->priv_data;
for (int i = 0; i < FF_ARRAY_ELEMS(h264->sps); i++)
- ff_refstruct_unref(&h264->sps[i]);
+ av_refstruct_unref(&h264->sps[i]);
for (int i = 0; i < FF_ARRAY_ELEMS(h264->pps); i++)
- ff_refstruct_unref(&h264->pps[i]);
+ av_refstruct_unref(&h264->pps[i]);
h264->active_sps = NULL;
h264->active_pps = NULL;
@@ -1927,9 +1927,9 @@ static void cbs_h264_close(CodedBitstreamContext *ctx)
ff_h2645_packet_uninit(&h264->common.read_packet);
for (i = 0; i < FF_ARRAY_ELEMS(h264->sps); i++)
- ff_refstruct_unref(&h264->sps[i]);
+ av_refstruct_unref(&h264->sps[i]);
for (i = 0; i < FF_ARRAY_ELEMS(h264->pps); i++)
- ff_refstruct_unref(&h264->pps[i]);
+ av_refstruct_unref(&h264->pps[i]);
}
static void cbs_h265_flush(CodedBitstreamContext *ctx)
@@ -1937,11 +1937,11 @@ static void cbs_h265_flush(CodedBitstreamContext *ctx)
CodedBitstreamH265Context *h265 = ctx->priv_data;
for (int i = 0; i < FF_ARRAY_ELEMS(h265->vps); i++)
- ff_refstruct_unref(&h265->vps[i]);
+ av_refstruct_unref(&h265->vps[i]);
for (int i = 0; i < FF_ARRAY_ELEMS(h265->sps); i++)
- ff_refstruct_unref(&h265->sps[i]);
+ av_refstruct_unref(&h265->sps[i]);
for (int i = 0; i < FF_ARRAY_ELEMS(h265->pps); i++)
- ff_refstruct_unref(&h265->pps[i]);
+ av_refstruct_unref(&h265->pps[i]);
h265->active_vps = NULL;
h265->active_sps = NULL;
@@ -1956,11 +1956,11 @@ static void cbs_h265_close(CodedBitstreamContext *ctx)
ff_h2645_packet_uninit(&h265->common.read_packet);
for (i = 0; i < FF_ARRAY_ELEMS(h265->vps); i++)
- ff_refstruct_unref(&h265->vps[i]);
+ av_refstruct_unref(&h265->vps[i]);
for (i = 0; i < FF_ARRAY_ELEMS(h265->sps); i++)
- ff_refstruct_unref(&h265->sps[i]);
+ av_refstruct_unref(&h265->sps[i]);
for (i = 0; i < FF_ARRAY_ELEMS(h265->pps); i++)
- ff_refstruct_unref(&h265->pps[i]);
+ av_refstruct_unref(&h265->pps[i]);
}
static void cbs_h266_flush(CodedBitstreamContext *ctx)
@@ -1968,12 +1968,12 @@ static void cbs_h266_flush(CodedBitstreamContext *ctx)
CodedBitstreamH266Context *h266 = ctx->priv_data;
for (int i = 0; i < FF_ARRAY_ELEMS(h266->vps); i++)
- ff_refstruct_unref(&h266->vps[i]);
+ av_refstruct_unref(&h266->vps[i]);
for (int i = 0; i < FF_ARRAY_ELEMS(h266->sps); i++)
- ff_refstruct_unref(&h266->sps[i]);
+ av_refstruct_unref(&h266->sps[i]);
for (int i = 0; i < FF_ARRAY_ELEMS(h266->pps); i++)
- ff_refstruct_unref(&h266->pps[i]);
- ff_refstruct_unref(&h266->ph_ref);
+ av_refstruct_unref(&h266->pps[i]);
+ av_refstruct_unref(&h266->ph_ref);
}
static void cbs_h266_close(CodedBitstreamContext *ctx)
@@ -1984,7 +1984,7 @@ static void cbs_h266_close(CodedBitstreamContext *ctx)
ff_h2645_packet_uninit(&h266->common.read_packet);
}
-static void cbs_h264_free_sei(FFRefStructOpaque unused, void *content)
+static void cbs_h264_free_sei(AVRefStructOpaque unused, void *content)
{
H264RawSEI *sei = content;
ff_cbs_sei_free_message_list(&sei->message_list);
@@ -2010,7 +2010,7 @@ static const CodedBitstreamUnitTypeDescriptor cbs_h264_unit_types[] = {
CBS_UNIT_TYPE_END_OF_LIST
};
-static void cbs_h265_free_sei(FFRefStructOpaque unused, void *content)
+static void cbs_h265_free_sei(AVRefStructOpaque unused, void *content)
{
H265RawSEI *sei = content;
ff_cbs_sei_free_message_list(&sei->message_list);
@@ -2037,7 +2037,7 @@ static const CodedBitstreamUnitTypeDescriptor cbs_h265_unit_types[] = {
CBS_UNIT_TYPE_END_OF_LIST
};
-static void cbs_h266_free_sei(FFRefStructOpaque unused, void *content)
+static void cbs_h266_free_sei(AVRefStructOpaque unused, void *content)
{
H266RawSEI *sei = content;
ff_cbs_sei_free_message_list(&sei->message_list);
diff --git a/libavcodec/cbs_h266_syntax_template.c b/libavcodec/cbs_h266_syntax_template.c
index 9a6e6f5e01..58211026bb 100644
--- a/libavcodec/cbs_h266_syntax_template.c
+++ b/libavcodec/cbs_h266_syntax_template.c
@@ -1078,7 +1078,7 @@ static int FUNC(sps)(CodedBitstreamContext *ctx, RWContext *rw,
ub(4, sps_seq_parameter_set_id);
ub(4, sps_video_parameter_set_id);
if (current->sps_video_parameter_set_id == 0 && !h266->vps[0]) {
- H266RawVPS *vps = ff_refstruct_allocz(sizeof(*vps));
+ H266RawVPS *vps = av_refstruct_allocz(sizeof(*vps));
if (!vps)
return AVERROR(ENOMEM);
vps->vps_max_layers_minus1 = 0;
diff --git a/libavcodec/cbs_internal.h b/libavcodec/cbs_internal.h
index d982262bd9..80cad2b162 100644
--- a/libavcodec/cbs_internal.h
+++ b/libavcodec/cbs_internal.h
@@ -28,7 +28,7 @@
#include "codec_id.h"
#include "get_bits.h"
#include "put_bits.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
enum CBSContentType {
@@ -93,7 +93,7 @@ typedef const struct CodedBitstreamUnitTypeDescriptor {
} ref;
struct {
- void (*content_free)(FFRefStructOpaque opaque, void *content);
+ void (*content_free)(AVRefStructOpaque opaque, void *content);
int (*content_clone)(void **new_content, CodedBitstreamUnit *unit);
} complex;
} type;
diff --git a/libavcodec/cbs_sei.c b/libavcodec/cbs_sei.c
index 458751d92e..acc3578aa9 100644
--- a/libavcodec/cbs_sei.c
+++ b/libavcodec/cbs_sei.c
@@ -23,24 +23,24 @@
#include "cbs_h265.h"
#include "cbs_h266.h"
#include "cbs_sei.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
-static void cbs_free_user_data_registered(FFRefStructOpaque unused, void *obj)
+static void cbs_free_user_data_registered(AVRefStructOpaque unused, void *obj)
{
SEIRawUserDataRegistered *udr = obj;
- ff_refstruct_unref(&udr->data);
+ av_refstruct_unref(&udr->data);
}
-static void cbs_free_user_data_unregistered(FFRefStructOpaque unused, void *obj)
+static void cbs_free_user_data_unregistered(AVRefStructOpaque unused, void *obj)
{
SEIRawUserDataUnregistered *udu = obj;
- ff_refstruct_unref(&udu->data);
+ av_refstruct_unref(&udu->data);
}
int ff_cbs_sei_alloc_message_payload(SEIRawMessage *message,
const SEIMessageTypeDescriptor *desc)
{
- void (*free_func)(FFRefStructOpaque, void*);
+ void (*free_func)(AVRefStructOpaque, void*);
av_assert0(message->payload == NULL &&
message->payload_ref == NULL);
@@ -54,7 +54,7 @@ int ff_cbs_sei_alloc_message_payload(SEIRawMessage *message,
free_func = NULL;
}
- message->payload_ref = ff_refstruct_alloc_ext(desc->size, 0,
+ message->payload_ref = av_refstruct_alloc_ext(desc->size, 0,
NULL, free_func);
if (!message->payload_ref)
return AVERROR(ENOMEM);
@@ -92,8 +92,8 @@ void ff_cbs_sei_free_message_list(SEIRawMessageList *list)
{
for (int i = 0; i < list->nb_messages; i++) {
SEIRawMessage *message = &list->messages[i];
- ff_refstruct_unref(&message->payload_ref);
- ff_refstruct_unref(&message->extension_data);
+ av_refstruct_unref(&message->payload_ref);
+ av_refstruct_unref(&message->extension_data);
}
av_free(list->messages);
}
@@ -299,7 +299,7 @@ int ff_cbs_sei_add_message(CodedBitstreamContext *ctx,
if (payload_ref) {
/* The following just increments payload_ref's refcount,
* so that payload_ref is now owned by us. */
- payload_ref = ff_refstruct_ref(payload_ref);
+ payload_ref = av_refstruct_ref(payload_ref);
}
message = &list->messages[list->nb_messages - 1];
@@ -352,8 +352,8 @@ static void cbs_sei_delete_message(SEIRawMessageList *list,
av_assert0(0 <= position && position < list->nb_messages);
message = &list->messages[position];
- ff_refstruct_unref(&message->payload_ref);
- ff_refstruct_unref(&message->extension_data);
+ av_refstruct_unref(&message->payload_ref);
+ av_refstruct_unref(&message->extension_data);
--list->nb_messages;
diff --git a/libavcodec/container_fifo.c b/libavcodec/container_fifo.c
index 82e86d9465..e1799e5eb7 100644
--- a/libavcodec/container_fifo.c
+++ b/libavcodec/container_fifo.c
@@ -22,11 +22,11 @@
#include "libavutil/mem.h"
#include "container_fifo.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
struct ContainerFifo {
AVFifo *fifo;
- FFRefStructPool *pool;
+ AVRefStructPool *pool;
void* (*container_alloc)(void);
void (*container_reset)(void *obj);
@@ -36,7 +36,7 @@ struct ContainerFifo {
};
-static int container_fifo_init_entry(FFRefStructOpaque opaque, void *obj)
+static int container_fifo_init_entry(AVRefStructOpaque opaque, void *obj)
{
ContainerFifo *cf = opaque.nc;
void **pobj = obj;
@@ -48,13 +48,13 @@ static int container_fifo_init_entry(FFRefStructOpaque opaque, void *obj)
return 0;
}
-static void container_fifo_reset_entry(FFRefStructOpaque opaque, void *obj)
+static void container_fifo_reset_entry(AVRefStructOpaque opaque, void *obj)
{
ContainerFifo *cf = opaque.nc;
cf->container_reset(*(void**)obj);
}
-static void container_fifo_free_entry(FFRefStructOpaque opaque, void *obj)
+static void container_fifo_free_entry(AVRefStructOpaque opaque, void *obj)
{
ContainerFifo *cf = opaque.nc;
cf->container_free(*(void**)obj);
@@ -83,7 +83,7 @@ ff_container_fifo_alloc(void* (*container_alloc)(void),
if (!cf->fifo)
goto fail;
- cf->pool = ff_refstruct_pool_alloc_ext(sizeof(void*), 0, cf,
+ cf->pool = av_refstruct_pool_alloc_ext(sizeof(void*), 0, cf,
container_fifo_init_entry,
container_fifo_reset_entry,
container_fifo_free_entry,
@@ -109,11 +109,11 @@ void ff_container_fifo_free(ContainerFifo **pcf)
if (cf->fifo) {
void *obj;
while (av_fifo_read(cf->fifo, &obj, 1) >= 0)
- ff_refstruct_unref(&obj);
+ av_refstruct_unref(&obj);
av_fifo_freep2(&cf->fifo);
}
- ff_refstruct_pool_uninit(&cf->pool);
+ av_refstruct_pool_uninit(&cf->pool);
av_freep(pcf);
}
@@ -128,7 +128,7 @@ int ff_container_fifo_read(ContainerFifo *cf, void *obj)
return ret;
ret = cf->fifo_read(obj, *psrc);
- ff_refstruct_unref(&psrc);
+ av_refstruct_unref(&psrc);
return ret;
}
@@ -138,7 +138,7 @@ int ff_container_fifo_write(ContainerFifo *cf, void *obj)
void **pdst;
int ret;
- pdst = ff_refstruct_pool_get(cf->pool);
+ pdst = av_refstruct_pool_get(cf->pool);
if (!pdst)
return AVERROR(ENOMEM);
@@ -152,7 +152,7 @@ int ff_container_fifo_write(ContainerFifo *cf, void *obj)
return 0;
fail:
- ff_refstruct_unref(&pdst);
+ av_refstruct_unref(&pdst);
return ret;
}
diff --git a/libavcodec/decode.c b/libavcodec/decode.c
index d1e10223f2..cac7e620d2 100644
--- a/libavcodec/decode.c
+++ b/libavcodec/decode.c
@@ -53,7 +53,7 @@
#include "lcevcdec.h"
#include "packet_internal.h"
#include "progressframe.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
#include "thread.h"
#include "threadprogress.h"
@@ -1684,7 +1684,7 @@ static void attach_post_process_data(AVCodecContext *avctx, AVFrame *frame)
if (dc->lcevc_frame) {
FrameDecodeData *fdd = (FrameDecodeData*)frame->private_ref->data;
- fdd->post_process_opaque = ff_refstruct_ref(dc->lcevc);
+ fdd->post_process_opaque = av_refstruct_ref(dc->lcevc);
fdd->post_process_opaque_free = ff_lcevc_unref;
fdd->post_process = ff_lcevc_process;
@@ -1833,11 +1833,11 @@ static void check_progress_consistency(const ProgressFrame *f)
int ff_progress_frame_alloc(AVCodecContext *avctx, ProgressFrame *f)
{
- FFRefStructPool *pool = avctx->internal->progress_frame_pool;
+ AVRefStructPool *pool = avctx->internal->progress_frame_pool;
av_assert1(!f->f && !f->progress);
- f->progress = ff_refstruct_pool_get(pool);
+ f->progress = av_refstruct_pool_get(pool);
if (!f->progress)
return AVERROR(ENOMEM);
@@ -1859,7 +1859,7 @@ int ff_progress_frame_get_buffer(AVCodecContext *avctx, ProgressFrame *f, int fl
ret = ff_thread_get_buffer(avctx, f->progress->f, flags);
if (ret < 0) {
f->f = NULL;
- ff_refstruct_unref(&f->progress);
+ av_refstruct_unref(&f->progress);
return ret;
}
return 0;
@@ -1870,14 +1870,14 @@ void ff_progress_frame_ref(ProgressFrame *dst, const ProgressFrame *src)
av_assert1(src->progress && src->f && src->f == src->progress->f);
av_assert1(!dst->f && !dst->progress);
dst->f = src->f;
- dst->progress = ff_refstruct_ref(src->progress);
+ dst->progress = av_refstruct_ref(src->progress);
}
void ff_progress_frame_unref(ProgressFrame *f)
{
check_progress_consistency(f);
f->f = NULL;
- ff_refstruct_unref(&f->progress);
+ av_refstruct_unref(&f->progress);
}
void ff_progress_frame_replace(ProgressFrame *dst, const ProgressFrame *src)
@@ -1907,7 +1907,7 @@ enum ThreadingStatus ff_thread_sync_ref(AVCodecContext *avctx, size_t offset)
}
#endif /* !HAVE_THREADS */
-static av_cold int progress_frame_pool_init_cb(FFRefStructOpaque opaque, void *obj)
+static av_cold int progress_frame_pool_init_cb(AVRefStructOpaque opaque, void *obj)
{
const AVCodecContext *avctx = opaque.nc;
ProgressInternal *progress = obj;
@@ -1924,7 +1924,7 @@ static av_cold int progress_frame_pool_init_cb(FFRefStructOpaque opaque, void *o
return 0;
}
-static void progress_frame_pool_reset_cb(FFRefStructOpaque unused, void *obj)
+static void progress_frame_pool_reset_cb(AVRefStructOpaque unused, void *obj)
{
ProgressInternal *progress = obj;
@@ -1932,7 +1932,7 @@ static void progress_frame_pool_reset_cb(FFRefStructOpaque unused, void *obj)
av_frame_unref(progress->f);
}
-static av_cold void progress_frame_pool_free_entry_cb(FFRefStructOpaque opaque, void *obj)
+static av_cold void progress_frame_pool_free_entry_cb(AVRefStructOpaque opaque, void *obj)
{
ProgressInternal *progress = obj;
@@ -2047,8 +2047,8 @@ int ff_decode_preinit(AVCodecContext *avctx)
if (ffcodec(avctx->codec)->caps_internal & FF_CODEC_CAP_USES_PROGRESSFRAMES) {
avci->progress_frame_pool =
- ff_refstruct_pool_alloc_ext(sizeof(ProgressInternal),
- FF_REFSTRUCT_POOL_FLAG_FREE_ON_INIT_ERROR,
+ av_refstruct_pool_alloc_ext(sizeof(ProgressInternal),
+ AV_REFSTRUCT_POOL_FLAG_FREE_ON_INIT_ERROR,
avctx, progress_frame_pool_init_cb,
progress_frame_pool_reset_cb,
progress_frame_pool_free_entry_cb, NULL);
@@ -2264,11 +2264,11 @@ int ff_hwaccel_frame_priv_alloc(AVCodecContext *avctx, void **hwaccel_picture_pr
return AVERROR(EINVAL);
frames_ctx = (AVHWFramesContext *) avctx->hw_frames_ctx->data;
- *hwaccel_picture_private = ff_refstruct_alloc_ext(hwaccel->frame_priv_data_size, 0,
+ *hwaccel_picture_private = av_refstruct_alloc_ext(hwaccel->frame_priv_data_size, 0,
frames_ctx->device_ctx,
hwaccel->free_frame_priv);
} else {
- *hwaccel_picture_private = ff_refstruct_allocz(hwaccel->frame_priv_data_size);
+ *hwaccel_picture_private = av_refstruct_allocz(hwaccel->frame_priv_data_size);
}
if (!*hwaccel_picture_private)
@@ -2305,7 +2305,7 @@ void ff_decode_internal_sync(AVCodecContext *dst, const AVCodecContext *src)
const DecodeContext *src_dc = decode_ctx(src->internal);
DecodeContext *dst_dc = decode_ctx(dst->internal);
- ff_refstruct_replace(&dst_dc->lcevc, src_dc->lcevc);
+ av_refstruct_replace(&dst_dc->lcevc, src_dc->lcevc);
}
void ff_decode_internal_uninit(AVCodecContext *avctx)
@@ -2313,5 +2313,5 @@ void ff_decode_internal_uninit(AVCodecContext *avctx)
AVCodecInternal *avci = avctx->internal;
DecodeContext *dc = decode_ctx(avci);
- ff_refstruct_unref(&dc->lcevc);
+ av_refstruct_unref(&dc->lcevc);
}
diff --git a/libavcodec/dovi_rpu.c b/libavcodec/dovi_rpu.c
index 5130a9598d..04e48d2b95 100644
--- a/libavcodec/dovi_rpu.c
+++ b/libavcodec/dovi_rpu.c
@@ -24,14 +24,14 @@
#include "libavutil/mem.h"
#include "dovi_rpu.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
void ff_dovi_ctx_unref(DOVIContext *s)
{
- ff_refstruct_unref(&s->dm);
+ av_refstruct_unref(&s->dm);
for (int i = 0; i < FF_ARRAY_ELEMS(s->vdr); i++)
- ff_refstruct_unref(&s->vdr[i]);
- ff_refstruct_unref(&s->ext_blocks);
+ av_refstruct_unref(&s->vdr[i]);
+ av_refstruct_unref(&s->ext_blocks);
av_free(s->rpu_buf);
*s = (DOVIContext) {
@@ -41,10 +41,10 @@ void ff_dovi_ctx_unref(DOVIContext *s)
void ff_dovi_ctx_flush(DOVIContext *s)
{
- ff_refstruct_unref(&s->dm);
+ av_refstruct_unref(&s->dm);
for (int i = 0; i < FF_ARRAY_ELEMS(s->vdr); i++)
- ff_refstruct_unref(&s->vdr[i]);
- ff_refstruct_unref(&s->ext_blocks);
+ av_refstruct_unref(&s->vdr[i]);
+ av_refstruct_unref(&s->ext_blocks);
*s = (DOVIContext) {
.logctx = s->logctx,
@@ -62,10 +62,10 @@ void ff_dovi_ctx_replace(DOVIContext *s, const DOVIContext *s0)
s->header = s0->header;
s->mapping = s0->mapping;
s->color = s0->color;
- ff_refstruct_replace(&s->dm, s0->dm);
+ av_refstruct_replace(&s->dm, s0->dm);
for (int i = 0; i <= DOVI_MAX_DM_ID; i++)
- ff_refstruct_replace(&s->vdr[i], s0->vdr[i]);
- ff_refstruct_replace(&s->ext_blocks, s0->ext_blocks);
+ av_refstruct_replace(&s->vdr[i], s0->vdr[i]);
+ av_refstruct_replace(&s->ext_blocks, s0->ext_blocks);
}
int ff_dovi_guess_profile_hevc(const AVDOVIRpuDataHeader *hdr)
diff --git a/libavcodec/dovi_rpudec.c b/libavcodec/dovi_rpudec.c
index 878950d66d..c231d1c492 100644
--- a/libavcodec/dovi_rpudec.c
+++ b/libavcodec/dovi_rpudec.c
@@ -28,7 +28,7 @@
#include "dovi_rpu.h"
#include "golomb.h"
#include "get_bits.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
int ff_dovi_get_metadata(DOVIContext *s, AVDOVIMetadata **out_metadata)
{
@@ -291,7 +291,7 @@ static int parse_ext_blocks(DOVIContext *s, GetBitContext *gb, int ver,
align_get_bits(gb);
if (num_ext_blocks && !ext) {
- ext = s->ext_blocks = ff_refstruct_allocz(sizeof(*s->ext_blocks));
+ ext = s->ext_blocks = av_refstruct_allocz(sizeof(*s->ext_blocks));
if (!ext)
return AVERROR(ENOMEM);
}
@@ -556,7 +556,7 @@ int ff_dovi_rpu_parse(DOVIContext *s, const uint8_t *rpu, size_t rpu_size,
int vdr_rpu_id = get_ue_golomb_31(gb);
VALIDATE(vdr_rpu_id, 0, DOVI_MAX_DM_ID);
if (!s->vdr[vdr_rpu_id]) {
- s->vdr[vdr_rpu_id] = ff_refstruct_allocz(sizeof(AVDOVIDataMapping));
+ s->vdr[vdr_rpu_id] = av_refstruct_allocz(sizeof(AVDOVIDataMapping));
if (!s->vdr[vdr_rpu_id]) {
ff_dovi_ctx_unref(s);
return AVERROR(ENOMEM);
@@ -675,7 +675,7 @@ int ff_dovi_rpu_parse(DOVIContext *s, const uint8_t *rpu, size_t rpu_size,
}
if (!s->dm) {
- s->dm = ff_refstruct_allocz(sizeof(AVDOVIColorMetadata));
+ s->dm = av_refstruct_allocz(sizeof(AVDOVIColorMetadata));
if (!s->dm) {
ff_dovi_ctx_unref(s);
return AVERROR(ENOMEM);
@@ -735,7 +735,7 @@ int ff_dovi_rpu_parse(DOVIContext *s, const uint8_t *rpu, size_t rpu_size,
}
} else {
s->color = &ff_dovi_color_default;
- ff_refstruct_unref(&s->ext_blocks);
+ av_refstruct_unref(&s->ext_blocks);
}
return 0;
diff --git a/libavcodec/dovi_rpuenc.c b/libavcodec/dovi_rpuenc.c
index 8113ec44bf..eb79a3af5d 100644
--- a/libavcodec/dovi_rpuenc.c
+++ b/libavcodec/dovi_rpuenc.c
@@ -29,7 +29,7 @@
#include "itut35.h"
#include "put_bits.h"
#include "put_golomb.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
static struct {
uint64_t pps; // maximum pixels per second
@@ -601,7 +601,7 @@ int ff_dovi_rpu_generate(DOVIContext *s, const AVDOVIMetadata *metadata,
use_prev_vdr_rpu = 0;
if (!s->vdr[vdr_rpu_id]) {
- s->vdr[vdr_rpu_id] = ff_refstruct_allocz(sizeof(AVDOVIDataMapping));
+ s->vdr[vdr_rpu_id] = av_refstruct_allocz(sizeof(AVDOVIDataMapping));
if (!s->vdr[vdr_rpu_id])
return AVERROR(ENOMEM);
}
@@ -625,12 +625,12 @@ int ff_dovi_rpu_generate(DOVIContext *s, const AVDOVIMetadata *metadata,
* references requires extended compression */
for (int i = 0; i <= DOVI_MAX_DM_ID; i++) {
if (i != vdr_rpu_id)
- ff_refstruct_unref(&s->vdr[i]);
+ av_refstruct_unref(&s->vdr[i]);
}
}
if (metadata->num_ext_blocks && !s->ext_blocks) {
- s->ext_blocks = ff_refstruct_allocz(sizeof(*s->ext_blocks));
+ s->ext_blocks = av_refstruct_allocz(sizeof(*s->ext_blocks));
if (!s->ext_blocks)
return AVERROR(ENOMEM);
}
@@ -640,7 +640,7 @@ int ff_dovi_rpu_generate(DOVIContext *s, const AVDOVIMetadata *metadata,
vdr_dm_metadata_present = 1;
if (vdr_dm_metadata_present && !s->dm) {
- s->dm = ff_refstruct_allocz(sizeof(AVDOVIColorMetadata));
+ s->dm = av_refstruct_allocz(sizeof(AVDOVIColorMetadata));
if (!s->dm)
return AVERROR(ENOMEM);
}
@@ -864,7 +864,7 @@ int ff_dovi_rpu_generate(DOVIContext *s, const AVDOVIMetadata *metadata,
}
} else {
s->color = &ff_dovi_color_default;
- ff_refstruct_unref(&s->ext_blocks);
+ av_refstruct_unref(&s->ext_blocks);
}
flush_put_bits(pb);
diff --git a/libavcodec/ffv1.c b/libavcodec/ffv1.c
index 6c953e860f..927763e24d 100644
--- a/libavcodec/ffv1.c
+++ b/libavcodec/ffv1.c
@@ -31,7 +31,7 @@
#include "avcodec.h"
#include "ffv1.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
av_cold int ff_ffv1_common_init(AVCodecContext *avctx)
{
@@ -53,7 +53,7 @@ av_cold int ff_ffv1_common_init(AVCodecContext *avctx)
return 0;
}
-static void planes_free(FFRefStructOpaque opaque, void *obj)
+static void planes_free(AVRefStructOpaque opaque, void *obj)
{
PlaneContext *planes = obj;
@@ -67,7 +67,7 @@ static void planes_free(FFRefStructOpaque opaque, void *obj)
PlaneContext* ff_ffv1_planes_alloc(void)
{
- return ff_refstruct_alloc_ext(sizeof(PlaneContext) * MAX_PLANES,
+ return av_refstruct_alloc_ext(sizeof(PlaneContext) * MAX_PLANES,
0, NULL, planes_free);
}
@@ -233,10 +233,10 @@ av_cold int ff_ffv1_close(AVCodecContext *avctx)
av_freep(&sc->sample_buffer);
av_freep(&sc->sample_buffer32);
- ff_refstruct_unref(&sc->plane);
+ av_refstruct_unref(&sc->plane);
}
- ff_refstruct_unref(&s->slice_damaged);
+ av_refstruct_unref(&s->slice_damaged);
av_freep(&avctx->stats_out);
for (j = 0; j < s->quant_table_count; j++) {
diff --git a/libavcodec/ffv1dec.c b/libavcodec/ffv1dec.c
index de5abfe9b4..7845815873 100644
--- a/libavcodec/ffv1dec.c
+++ b/libavcodec/ffv1dec.c
@@ -38,7 +38,7 @@
#include "mathops.h"
#include "ffv1.h"
#include "progressframe.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
#include "thread.h"
static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state,
@@ -780,8 +780,8 @@ static int read_header(FFV1Context *f)
return AVERROR_INVALIDDATA;
}
- ff_refstruct_unref(&f->slice_damaged);
- f->slice_damaged = ff_refstruct_allocz(f->slice_count * sizeof(*f->slice_damaged));
+ av_refstruct_unref(&f->slice_damaged);
+ f->slice_damaged = av_refstruct_allocz(f->slice_count * sizeof(*f->slice_damaged));
if (!f->slice_damaged)
return AVERROR(ENOMEM);
@@ -810,7 +810,7 @@ static int read_header(FFV1Context *f)
&& (unsigned)sc->slice_y + (uint64_t)sc->slice_height <= f->height);
}
- ff_refstruct_unref(&sc->plane);
+ av_refstruct_unref(&sc->plane);
sc->plane = ff_ffv1_planes_alloc();
if (!sc->plane)
return AVERROR(ENOMEM);
@@ -1059,7 +1059,7 @@ static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
FFV1SliceContext *sc = &fdst->slices[i];
const FFV1SliceContext *sc0 = &fsrc->slices[i];
- ff_refstruct_replace(&sc->plane, sc0->plane);
+ av_refstruct_replace(&sc->plane, sc0->plane);
if (fsrc->version < 3) {
sc->slice_x = sc0->slice_x;
@@ -1069,7 +1069,7 @@ static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
}
}
- ff_refstruct_replace(&fdst->slice_damaged, fsrc->slice_damaged);
+ av_refstruct_replace(&fdst->slice_damaged, fsrc->slice_damaged);
av_assert1(fdst->max_slice_count == fsrc->max_slice_count);
diff --git a/libavcodec/get_buffer.c b/libavcodec/get_buffer.c
index ff19f61e86..12aa543f67 100644
--- a/libavcodec/get_buffer.c
+++ b/libavcodec/get_buffer.c
@@ -32,7 +32,7 @@
#include "avcodec.h"
#include "internal.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
typedef struct FramePool {
/**
@@ -53,7 +53,7 @@ typedef struct FramePool {
int samples;
} FramePool;
-static void frame_pool_free(FFRefStructOpaque unused, void *obj)
+static void frame_pool_free(AVRefStructOpaque unused, void *obj)
{
FramePool *pool = obj;
int i;
@@ -77,7 +77,7 @@ static int update_frame_pool(AVCodecContext *avctx, AVFrame *frame)
return 0;
}
- pool = ff_refstruct_alloc_ext(sizeof(*pool), 0, NULL, frame_pool_free);
+ pool = av_refstruct_alloc_ext(sizeof(*pool), 0, NULL, frame_pool_free);
if (!pool)
return AVERROR(ENOMEM);
@@ -157,12 +157,12 @@ static int update_frame_pool(AVCodecContext *avctx, AVFrame *frame)
default: av_assert0(0);
}
- ff_refstruct_unref(&avctx->internal->pool);
+ av_refstruct_unref(&avctx->internal->pool);
avctx->internal->pool = pool;
return 0;
fail:
- ff_refstruct_unref(&pool);
+ av_refstruct_unref(&pool);
return ret;
}
diff --git a/libavcodec/h2645_sei.c b/libavcodec/h2645_sei.c
index 986d1d250a..c8fa975bf4 100644
--- a/libavcodec/h2645_sei.c
+++ b/libavcodec/h2645_sei.c
@@ -32,6 +32,7 @@
#include "libavutil/film_grain_params.h"
#include "libavutil/mastering_display_metadata.h"
#include "libavutil/mem.h"
+#include "libavutil/refstruct.h"
#include "libavutil/stereo3d.h"
#include "atsc_a53.h"
@@ -42,7 +43,6 @@
#include "golomb.h"
#include "h2645_sei.h"
#include "itut35.h"
-#include "refstruct.h"
#define IS_H264(codec_id) (CONFIG_H264_SEI && CONFIG_HEVC_SEI ? codec_id == AV_CODEC_ID_H264 : CONFIG_H264_SEI)
#define IS_HEVC(codec_id) (CONFIG_H264_SEI && CONFIG_HEVC_SEI ? codec_id == AV_CODEC_ID_HEVC : CONFIG_HEVC_SEI)
@@ -496,8 +496,8 @@ int ff_h2645_sei_message_decode(H2645SEI *h, enum SEIType type,
case SEI_TYPE_DISPLAY_ORIENTATION:
return decode_display_orientation(&h->display_orientation, gb);
case SEI_TYPE_FILM_GRAIN_CHARACTERISTICS:
- ff_refstruct_unref(&h->film_grain_characteristics);
- h->film_grain_characteristics = ff_refstruct_allocz(sizeof(*h->film_grain_characteristics));
+ av_refstruct_unref(&h->film_grain_characteristics);
+ h->film_grain_characteristics = av_refstruct_allocz(sizeof(*h->film_grain_characteristics));
if (!h->film_grain_characteristics)
return AVERROR(ENOMEM);
return decode_film_grain_characteristics(h->film_grain_characteristics, codec_id, gb);
@@ -559,7 +559,7 @@ int ff_h2645_sei_ctx_replace(H2645SEI *dst, const H2645SEI *src)
dst->mastering_display = src->mastering_display;
dst->content_light = src->content_light;
- ff_refstruct_replace(&dst->film_grain_characteristics,
+ av_refstruct_replace(&dst->film_grain_characteristics,
src->film_grain_characteristics);
return 0;
@@ -934,6 +934,6 @@ void ff_h2645_sei_reset(H2645SEI *s)
s->mastering_display.present = 0;
s->content_light.present = 0;
- ff_refstruct_unref(&s->film_grain_characteristics);
+ av_refstruct_unref(&s->film_grain_characteristics);
ff_aom_uninit_film_grain_params(&s->aom_film_grain);
}
diff --git a/libavcodec/h264_parser.c b/libavcodec/h264_parser.c
index 94cfbc481e..006f4059e8 100644
--- a/libavcodec/h264_parser.c
+++ b/libavcodec/h264_parser.c
@@ -47,7 +47,7 @@
#include "h264data.h"
#include "mpegutils.h"
#include "parser.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
#include "startcode.h"
typedef struct H264ParseContext {
@@ -374,7 +374,7 @@ static inline int parse_nal_units(AVCodecParserContext *s,
goto fail;
}
- ff_refstruct_replace(&p->ps.pps, p->ps.pps_list[pps_id]);
+ av_refstruct_replace(&p->ps.pps, p->ps.pps_list[pps_id]);
p->ps.sps = p->ps.pps->sps;
sps = p->ps.sps;
diff --git a/libavcodec/h264_picture.c b/libavcodec/h264_picture.c
index 3234141dbd..f5d2b31cd6 100644
--- a/libavcodec/h264_picture.c
+++ b/libavcodec/h264_picture.c
@@ -32,7 +32,7 @@
#include "h264dec.h"
#include "hwaccel_internal.h"
#include "mpegutils.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
#include "thread.h"
#include "threadframe.h"
@@ -46,35 +46,35 @@ void ff_h264_unref_picture(H264Picture *pic)
ff_thread_release_ext_buffer(&pic->tf);
av_frame_unref(pic->f_grain);
- ff_refstruct_unref(&pic->hwaccel_picture_private);
+ av_refstruct_unref(&pic->hwaccel_picture_private);
- ff_refstruct_unref(&pic->qscale_table_base);
- ff_refstruct_unref(&pic->mb_type_base);
- ff_refstruct_unref(&pic->pps);
+ av_refstruct_unref(&pic->qscale_table_base);
+ av_refstruct_unref(&pic->mb_type_base);
+ av_refstruct_unref(&pic->pps);
for (i = 0; i < 2; i++) {
- ff_refstruct_unref(&pic->motion_val_base[i]);
- ff_refstruct_unref(&pic->ref_index[i]);
+ av_refstruct_unref(&pic->motion_val_base[i]);
+ av_refstruct_unref(&pic->ref_index[i]);
}
- ff_refstruct_unref(&pic->decode_error_flags);
+ av_refstruct_unref(&pic->decode_error_flags);
memset((uint8_t*)pic + off, 0, sizeof(*pic) - off);
}
static void h264_copy_picture_params(H264Picture *dst, const H264Picture *src)
{
- ff_refstruct_replace(&dst->qscale_table_base, src->qscale_table_base);
- ff_refstruct_replace(&dst->mb_type_base, src->mb_type_base);
- ff_refstruct_replace(&dst->pps, src->pps);
+ av_refstruct_replace(&dst->qscale_table_base, src->qscale_table_base);
+ av_refstruct_replace(&dst->mb_type_base, src->mb_type_base);
+ av_refstruct_replace(&dst->pps, src->pps);
for (int i = 0; i < 2; i++) {
- ff_refstruct_replace(&dst->motion_val_base[i], src->motion_val_base[i]);
- ff_refstruct_replace(&dst->ref_index[i], src->ref_index[i]);
+ av_refstruct_replace(&dst->motion_val_base[i], src->motion_val_base[i]);
+ av_refstruct_replace(&dst->ref_index[i], src->ref_index[i]);
}
- ff_refstruct_replace(&dst->hwaccel_picture_private,
+ av_refstruct_replace(&dst->hwaccel_picture_private,
src->hwaccel_picture_private);
- ff_refstruct_replace(&dst->decode_error_flags, src->decode_error_flags);
+ av_refstruct_replace(&dst->decode_error_flags, src->decode_error_flags);
dst->qscale_table = src->qscale_table;
dst->mb_type = src->mb_type;
diff --git a/libavcodec/h264_ps.c b/libavcodec/h264_ps.c
index 3c8fc33c7f..c698f1b80d 100644
--- a/libavcodec/h264_ps.c
+++ b/libavcodec/h264_ps.c
@@ -34,7 +34,7 @@
#include "h2645_vui.h"
#include "h264_ps.h"
#include "golomb.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
#define MIN_LOG2_MAX_FRAME_NUM 4
@@ -86,7 +86,7 @@ static const int level_max_dpb_mbs[][2] = {
static void remove_pps(H264ParamSets *s, int id)
{
- ff_refstruct_unref(&s->pps_list[id]);
+ av_refstruct_unref(&s->pps_list[id]);
}
static void remove_sps(H264ParamSets *s, int id)
@@ -100,7 +100,7 @@ static void remove_sps(H264ParamSets *s, int id)
remove_pps(s, i);
}
#endif
- ff_refstruct_unref(&s->sps_list[id]);
+ av_refstruct_unref(&s->sps_list[id]);
}
static inline int decode_hrd_parameters(GetBitContext *gb, void *logctx,
@@ -272,12 +272,12 @@ void ff_h264_ps_uninit(H264ParamSets *ps)
int i;
for (i = 0; i < MAX_SPS_COUNT; i++)
- ff_refstruct_unref(&ps->sps_list[i]);
+ av_refstruct_unref(&ps->sps_list[i]);
for (i = 0; i < MAX_PPS_COUNT; i++)
- ff_refstruct_unref(&ps->pps_list[i]);
+ av_refstruct_unref(&ps->pps_list[i]);
- ff_refstruct_unref(&ps->pps);
+ av_refstruct_unref(&ps->pps);
ps->sps = NULL;
}
@@ -290,7 +290,7 @@ int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx,
SPS *sps;
int ret;
- sps = ff_refstruct_allocz(sizeof(*sps));
+ sps = av_refstruct_allocz(sizeof(*sps));
if (!sps)
return AVERROR(ENOMEM);
@@ -578,7 +578,7 @@ int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx,
* otherwise drop all PPSes that depend on it */
if (ps->sps_list[sps_id] &&
!memcmp(ps->sps_list[sps_id], sps, sizeof(*sps))) {
- ff_refstruct_unref(&sps);
+ av_refstruct_unref(&sps);
} else {
remove_sps(ps, sps_id);
ps->sps_list[sps_id] = sps;
@@ -587,7 +587,7 @@ int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx,
return 0;
fail:
- ff_refstruct_unref(&sps);
+ av_refstruct_unref(&sps);
return AVERROR_INVALIDDATA;
}
@@ -686,11 +686,11 @@ static int more_rbsp_data_in_pps(const SPS *sps, void *logctx)
return 1;
}
-static void pps_free(FFRefStructOpaque unused, void *obj)
+static void pps_free(AVRefStructOpaque unused, void *obj)
{
PPS *pps = obj;
- ff_refstruct_unref(&pps->sps);
+ av_refstruct_unref(&pps->sps);
}
int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avctx,
@@ -708,7 +708,7 @@ int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avct
return AVERROR_INVALIDDATA;
}
- pps = ff_refstruct_alloc_ext(sizeof(*pps), 0, NULL, pps_free);
+ pps = av_refstruct_alloc_ext(sizeof(*pps), 0, NULL, pps_free);
if (!pps)
return AVERROR(ENOMEM);
@@ -733,7 +733,7 @@ int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avct
ret = AVERROR_INVALIDDATA;
goto fail;
}
- pps->sps = ff_refstruct_ref_c(ps->sps_list[pps->sps_id]);
+ pps->sps = av_refstruct_ref_c(ps->sps_list[pps->sps_id]);
sps = pps->sps;
if (sps->bit_depth_luma > 14) {
@@ -840,6 +840,6 @@ int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avct
return 0;
fail:
- ff_refstruct_unref(&pps);
+ av_refstruct_unref(&pps);
return ret;
}
diff --git a/libavcodec/h264_slice.c b/libavcodec/h264_slice.c
index c35ad9b910..5108fa0921 100644
--- a/libavcodec/h264_slice.c
+++ b/libavcodec/h264_slice.c
@@ -45,7 +45,7 @@
#include "mathops.h"
#include "mpegutils.h"
#include "rectangle.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
#include "thread.h"
#include "threadframe.h"
@@ -166,19 +166,19 @@ static int init_table_pools(H264Context *h)
const int b4_stride = h->mb_width * 4 + 1;
const int b4_array_size = b4_stride * h->mb_height * 4;
- h->qscale_table_pool = ff_refstruct_pool_alloc(big_mb_num + h->mb_stride, 0);
- h->mb_type_pool = ff_refstruct_pool_alloc((big_mb_num + h->mb_stride) *
+ h->qscale_table_pool = av_refstruct_pool_alloc(big_mb_num + h->mb_stride, 0);
+ h->mb_type_pool = av_refstruct_pool_alloc((big_mb_num + h->mb_stride) *
sizeof(uint32_t), 0);
- h->motion_val_pool = ff_refstruct_pool_alloc(2 * (b4_array_size + 4) *
+ h->motion_val_pool = av_refstruct_pool_alloc(2 * (b4_array_size + 4) *
sizeof(int16_t), 0);
- h->ref_index_pool = ff_refstruct_pool_alloc(4 * mb_array_size, 0);
+ h->ref_index_pool = av_refstruct_pool_alloc(4 * mb_array_size, 0);
if (!h->qscale_table_pool || !h->mb_type_pool || !h->motion_val_pool ||
!h->ref_index_pool) {
- ff_refstruct_pool_uninit(&h->qscale_table_pool);
- ff_refstruct_pool_uninit(&h->mb_type_pool);
- ff_refstruct_pool_uninit(&h->motion_val_pool);
- ff_refstruct_pool_uninit(&h->ref_index_pool);
+ av_refstruct_pool_uninit(&h->qscale_table_pool);
+ av_refstruct_pool_uninit(&h->mb_type_pool);
+ av_refstruct_pool_uninit(&h->motion_val_pool);
+ av_refstruct_pool_uninit(&h->ref_index_pool);
return AVERROR(ENOMEM);
}
@@ -211,7 +211,7 @@ static int alloc_picture(H264Context *h, H264Picture *pic)
goto fail;
if (h->decode_error_flags_pool) {
- pic->decode_error_flags = ff_refstruct_pool_get(h->decode_error_flags_pool);
+ pic->decode_error_flags = av_refstruct_pool_get(h->decode_error_flags_pool);
if (!pic->decode_error_flags)
goto fail;
atomic_init(pic->decode_error_flags, 0);
@@ -236,8 +236,8 @@ static int alloc_picture(H264Context *h, H264Picture *pic)
goto fail;
}
- pic->qscale_table_base = ff_refstruct_pool_get(h->qscale_table_pool);
- pic->mb_type_base = ff_refstruct_pool_get(h->mb_type_pool);
+ pic->qscale_table_base = av_refstruct_pool_get(h->qscale_table_pool);
+ pic->mb_type_base = av_refstruct_pool_get(h->mb_type_pool);
if (!pic->qscale_table_base || !pic->mb_type_base)
goto fail;
@@ -245,15 +245,15 @@ static int alloc_picture(H264Context *h, H264Picture *pic)
pic->qscale_table = pic->qscale_table_base + 2 * h->mb_stride + 1;
for (i = 0; i < 2; i++) {
- pic->motion_val_base[i] = ff_refstruct_pool_get(h->motion_val_pool);
- pic->ref_index[i] = ff_refstruct_pool_get(h->ref_index_pool);
+ pic->motion_val_base[i] = av_refstruct_pool_get(h->motion_val_pool);
+ pic->ref_index[i] = av_refstruct_pool_get(h->ref_index_pool);
if (!pic->motion_val_base[i] || !pic->ref_index[i])
goto fail;
pic->motion_val[i] = pic->motion_val_base[i] + 4;
}
- pic->pps = ff_refstruct_ref_c(h->ps.pps);
+ pic->pps = av_refstruct_ref_c(h->ps.pps);
pic->mb_width = h->mb_width;
pic->mb_height = h->mb_height;
@@ -358,11 +358,11 @@ int ff_h264_update_thread_context(AVCodecContext *dst,
// SPS/PPS
for (int i = 0; i < FF_ARRAY_ELEMS(h->ps.sps_list); i++)
- ff_refstruct_replace(&h->ps.sps_list[i], h1->ps.sps_list[i]);
+ av_refstruct_replace(&h->ps.sps_list[i], h1->ps.sps_list[i]);
for (int i = 0; i < FF_ARRAY_ELEMS(h->ps.pps_list); i++)
- ff_refstruct_replace(&h->ps.pps_list[i], h1->ps.pps_list[i]);
+ av_refstruct_replace(&h->ps.pps_list[i], h1->ps.pps_list[i]);
- ff_refstruct_replace(&h->ps.pps, h1->ps.pps);
+ av_refstruct_replace(&h->ps.pps, h1->ps.pps);
h->ps.sps = h1->ps.sps;
if (need_reinit || !inited) {
@@ -1050,7 +1050,7 @@ static int h264_init_ps(H264Context *h, const H264SliceContext *sl, int first_sl
int needs_reinit = 0, must_reinit, ret;
if (first_slice)
- ff_refstruct_replace(&h->ps.pps, h->ps.pps_list[sl->pps_id]);
+ av_refstruct_replace(&h->ps.pps, h->ps.pps_list[sl->pps_id]);
if (h->ps.sps != h->ps.pps->sps) {
h->ps.sps = h->ps.pps->sps;
diff --git a/libavcodec/h264dec.c b/libavcodec/h264dec.c
index 0154fe17b6..8feb5558aa 100644
--- a/libavcodec/h264dec.c
+++ b/libavcodec/h264dec.c
@@ -52,7 +52,7 @@
#include "mpegutils.h"
#include "profiles.h"
#include "rectangle.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
#include "thread.h"
#include "threadframe.h"
@@ -156,10 +156,10 @@ void ff_h264_free_tables(H264Context *h)
av_freep(&h->mb2b_xy);
av_freep(&h->mb2br_xy);
- ff_refstruct_pool_uninit(&h->qscale_table_pool);
- ff_refstruct_pool_uninit(&h->mb_type_pool);
- ff_refstruct_pool_uninit(&h->motion_val_pool);
- ff_refstruct_pool_uninit(&h->ref_index_pool);
+ av_refstruct_pool_uninit(&h->qscale_table_pool);
+ av_refstruct_pool_uninit(&h->mb_type_pool);
+ av_refstruct_pool_uninit(&h->motion_val_pool);
+ av_refstruct_pool_uninit(&h->ref_index_pool);
#if CONFIG_ERROR_RESILIENCE
av_freep(&h->er.mb_index2xy);
@@ -313,7 +313,7 @@ static int h264_init_context(AVCodecContext *avctx, H264Context *h)
ff_h264_sei_uninit(&h->sei);
if (avctx->active_thread_type & FF_THREAD_FRAME) {
- h->decode_error_flags_pool = ff_refstruct_pool_alloc(sizeof(atomic_int), 0);
+ h->decode_error_flags_pool = av_refstruct_pool_alloc(sizeof(atomic_int), 0);
if (!h->decode_error_flags_pool)
return AVERROR(ENOMEM);
}
@@ -364,7 +364,7 @@ static av_cold int h264_decode_end(AVCodecContext *avctx)
h->cur_pic_ptr = NULL;
- ff_refstruct_pool_uninit(&h->decode_error_flags_pool);
+ av_refstruct_pool_uninit(&h->decode_error_flags_pool);
av_freep(&h->slice_ctx);
h->nb_slice_ctx = 0;
diff --git a/libavcodec/h264dec.h b/libavcodec/h264dec.h
index ccd7583bf4..5abc60c09d 100644
--- a/libavcodec/h264dec.h
+++ b/libavcodec/h264dec.h
@@ -570,11 +570,11 @@ typedef struct H264Context {
H264SEIContext sei;
- struct FFRefStructPool *qscale_table_pool;
- struct FFRefStructPool *mb_type_pool;
- struct FFRefStructPool *motion_val_pool;
- struct FFRefStructPool *ref_index_pool;
- struct FFRefStructPool *decode_error_flags_pool;
+ struct AVRefStructPool *qscale_table_pool;
+ struct AVRefStructPool *mb_type_pool;
+ struct AVRefStructPool *motion_val_pool;
+ struct AVRefStructPool *ref_index_pool;
+ struct AVRefStructPool *decode_error_flags_pool;
int ref2frm[MAX_SLICES][2][64]; ///< reference to frame number lists, used in the loop filter, the first 2 are for -2,-1
int non_gray; ///< Did we encounter a intra frame after a gray gap frame
diff --git a/libavcodec/hevc/hevcdec.c b/libavcodec/hevc/hevcdec.c
index be35a9de82..421579efe5 100644
--- a/libavcodec/hevc/hevcdec.c
+++ b/libavcodec/hevc/hevcdec.c
@@ -52,7 +52,7 @@
#include "internal.h"
#include "profiles.h"
#include "progressframe.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
#include "thread.h"
#include "threadprogress.h"
@@ -92,8 +92,8 @@ static void pic_arrays_free(HEVCLayerContext *l)
av_freep(&l->sao_pixel_buffer_v[i]);
}
- ff_refstruct_pool_uninit(&l->tab_mvf_pool);
- ff_refstruct_pool_uninit(&l->rpl_tab_pool);
+ av_refstruct_pool_uninit(&l->tab_mvf_pool);
+ av_refstruct_pool_uninit(&l->rpl_tab_pool);
}
/* allocate arrays that depend on frame dimensions */
@@ -139,8 +139,8 @@ static int pic_arrays_init(HEVCLayerContext *l, const HEVCSPS *sps)
if (!l->horizontal_bs || !l->vertical_bs)
goto fail;
- l->tab_mvf_pool = ff_refstruct_pool_alloc(min_pu_size * sizeof(MvField), 0);
- l->rpl_tab_pool = ff_refstruct_pool_alloc(ctb_count * sizeof(RefPicListTab), 0);
+ l->tab_mvf_pool = av_refstruct_pool_alloc(min_pu_size * sizeof(MvField), 0);
+ l->rpl_tab_pool = av_refstruct_pool_alloc(ctb_count * sizeof(RefPicListTab), 0);
if (!l->tab_mvf_pool || !l->rpl_tab_pool)
goto fail;
@@ -677,8 +677,8 @@ static int set_sps(HEVCContext *s, HEVCLayerContext *l, const HEVCSPS *sps)
int ret;
pic_arrays_free(l);
- ff_refstruct_unref(&l->sps);
- ff_refstruct_unref(&s->vps);
+ av_refstruct_unref(&l->sps);
+ av_refstruct_unref(&s->vps);
if (!sps)
return 0;
@@ -691,14 +691,14 @@ static int set_sps(HEVCContext *s, HEVCLayerContext *l, const HEVCSPS *sps)
ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
ff_videodsp_init (&s->vdsp, sps->bit_depth);
- l->sps = ff_refstruct_ref_c(sps);
- s->vps = ff_refstruct_ref_c(sps->vps);
+ l->sps = av_refstruct_ref_c(sps);
+ s->vps = av_refstruct_ref_c(sps->vps);
return 0;
fail:
pic_arrays_free(l);
- ff_refstruct_unref(&l->sps);
+ av_refstruct_unref(&l->sps);
return ret;
}
@@ -3162,7 +3162,7 @@ static int hevc_frame_start(HEVCContext *s, HEVCLayerContext *l,
return AVERROR_INVALIDDATA;
}
- ff_refstruct_replace(&s->pps, pps);
+ av_refstruct_replace(&s->pps, pps);
if (l->sps != sps) {
const HEVCSPS *sps_base = s->layers[0].sps;
enum AVPixelFormat pix_fmt = sps->pix_fmt;
@@ -3811,10 +3811,10 @@ static int hevc_ref_frame(HEVCFrame *dst, const HEVCFrame *src)
dst->needs_fg = 1;
}
- dst->pps = ff_refstruct_ref_c(src->pps);
- dst->tab_mvf = ff_refstruct_ref(src->tab_mvf);
- dst->rpl_tab = ff_refstruct_ref(src->rpl_tab);
- dst->rpl = ff_refstruct_ref(src->rpl);
+ dst->pps = av_refstruct_ref_c(src->pps);
+ dst->tab_mvf = av_refstruct_ref(src->tab_mvf);
+ dst->rpl_tab = av_refstruct_ref(src->rpl_tab);
+ dst->rpl = av_refstruct_ref(src->rpl);
dst->nb_rpl_elems = src->nb_rpl_elems;
dst->poc = src->poc;
@@ -3823,7 +3823,7 @@ static int hevc_ref_frame(HEVCFrame *dst, const HEVCFrame *src)
dst->base_layer_frame = src->base_layer_frame;
- ff_refstruct_replace(&dst->hwaccel_picture_private,
+ av_refstruct_replace(&dst->hwaccel_picture_private,
src->hwaccel_picture_private);
return 0;
@@ -3835,11 +3835,11 @@ static av_cold int hevc_decode_free(AVCodecContext *avctx)
for (int i = 0; i < FF_ARRAY_ELEMS(s->layers); i++) {
pic_arrays_free(&s->layers[i]);
- ff_refstruct_unref(&s->layers[i].sps);
+ av_refstruct_unref(&s->layers[i].sps);
}
- ff_refstruct_unref(&s->vps);
- ff_refstruct_unref(&s->pps);
+ av_refstruct_unref(&s->vps);
+ av_refstruct_unref(&s->pps);
ff_dovi_ctx_unref(&s->dovi_ctx);
av_buffer_unref(&s->rpu_buf);
@@ -3945,16 +3945,16 @@ static int hevc_update_thread_context(AVCodecContext *dst,
}
for (int i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++)
- ff_refstruct_replace(&s->ps.vps_list[i], s0->ps.vps_list[i]);
+ av_refstruct_replace(&s->ps.vps_list[i], s0->ps.vps_list[i]);
for (int i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++)
- ff_refstruct_replace(&s->ps.sps_list[i], s0->ps.sps_list[i]);
+ av_refstruct_replace(&s->ps.sps_list[i], s0->ps.sps_list[i]);
for (int i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++)
- ff_refstruct_replace(&s->ps.pps_list[i], s0->ps.pps_list[i]);
+ av_refstruct_replace(&s->ps.pps_list[i], s0->ps.pps_list[i]);
// PPS do not persist between frames
- ff_refstruct_unref(&s->pps);
+ av_refstruct_unref(&s->pps);
s->poc_tid0 = s0->poc_tid0;
s->eos = s0->eos;
diff --git a/libavcodec/hevc/hevcdec.h b/libavcodec/hevc/hevcdec.h
index 473709b4e8..b7a762089b 100644
--- a/libavcodec/hevc/hevcdec.h
+++ b/libavcodec/hevc/hevcdec.h
@@ -480,8 +480,8 @@ typedef struct HEVCLayerContext {
uint8_t *sao_pixel_buffer_h[3];
uint8_t *sao_pixel_buffer_v[3];
- struct FFRefStructPool *tab_mvf_pool;
- struct FFRefStructPool *rpl_tab_pool;
+ struct AVRefStructPool *tab_mvf_pool;
+ struct AVRefStructPool *rpl_tab_pool;
} HEVCLayerContext;
typedef struct HEVCContext {
diff --git a/libavcodec/hevc/ps.c b/libavcodec/hevc/ps.c
index a1d352eec5..285084685b 100644
--- a/libavcodec/hevc/ps.c
+++ b/libavcodec/hevc/ps.c
@@ -30,7 +30,7 @@
#include "data.h"
#include "ps.h"
#include "profiles.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
static const uint8_t default_scaling_list_intra[] = {
16, 16, 16, 16, 17, 18, 21, 24,
@@ -69,9 +69,9 @@ static void remove_sps(HEVCParamSets *s, int id)
/* drop all PPS that depend on this SPS */
for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
if (s->pps_list[i] && s->pps_list[i]->sps_id == id)
- ff_refstruct_unref(&s->pps_list[i]);
+ av_refstruct_unref(&s->pps_list[i]);
- ff_refstruct_unref(&s->sps_list[id]);
+ av_refstruct_unref(&s->sps_list[id]);
}
}
@@ -82,7 +82,7 @@ static void remove_vps(HEVCParamSets *s, int id)
for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
if (s->sps_list[i] && s->sps_list[i]->vps_id == id)
remove_sps(s, i);
- ff_refstruct_unref(&s->vps_list[id]);
+ av_refstruct_unref(&s->vps_list[id]);
}
}
@@ -442,7 +442,7 @@ static int decode_hrd(GetBitContext *gb, int common_inf_present,
return 0;
}
-static void hevc_vps_free(FFRefStructOpaque opaque, void *obj)
+static void hevc_vps_free(AVRefStructOpaque opaque, void *obj)
{
HEVCVPS *vps = obj;
@@ -730,7 +730,7 @@ int ff_hevc_decode_nal_vps(GetBitContext *gb, AVCodecContext *avctx,
return 0;
}
- vps = ff_refstruct_alloc_ext(sizeof(*vps), 0, NULL, hevc_vps_free);
+ vps = av_refstruct_alloc_ext(sizeof(*vps), 0, NULL, hevc_vps_free);
if (!vps)
return AVERROR(ENOMEM);
@@ -864,7 +864,7 @@ int ff_hevc_decode_nal_vps(GetBitContext *gb, AVCodecContext *avctx,
return 0;
err:
- ff_refstruct_unref(&vps);
+ av_refstruct_unref(&vps);
return ret;
}
@@ -1171,7 +1171,7 @@ int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
sps->vps_id);
return AVERROR_INVALIDDATA;
}
- sps->vps = ff_refstruct_ref_c(vps_list[sps->vps_id]);
+ sps->vps = av_refstruct_ref_c(vps_list[sps->vps_id]);
}
sps->max_sub_layers = get_bits(gb, 3) + 1;
@@ -1632,11 +1632,11 @@ int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
return 0;
}
-static void hevc_sps_free(FFRefStructOpaque opaque, void *obj)
+static void hevc_sps_free(AVRefStructOpaque opaque, void *obj)
{
HEVCSPS *sps = obj;
- ff_refstruct_unref(&sps->vps);
+ av_refstruct_unref(&sps->vps);
av_freep(&sps->data);
}
@@ -1651,7 +1651,7 @@ int ff_hevc_decode_nal_sps(GetBitContext *gb, AVCodecContext *avctx,
HEVCParamSets *ps, unsigned nuh_layer_id,
int apply_defdispwin)
{
- HEVCSPS *sps = ff_refstruct_alloc_ext(sizeof(*sps), 0, NULL, hevc_sps_free);
+ HEVCSPS *sps = av_refstruct_alloc_ext(sizeof(*sps), 0, NULL, hevc_sps_free);
unsigned int sps_id;
int ret;
@@ -1688,7 +1688,7 @@ int ff_hevc_decode_nal_sps(GetBitContext *gb, AVCodecContext *avctx,
* otherwise drop all PPSes that depend on it */
if (ps->sps_list[sps_id] &&
compare_sps(ps->sps_list[sps_id], sps)) {
- ff_refstruct_unref(&sps);
+ av_refstruct_unref(&sps);
} else {
remove_sps(ps, sps_id);
ps->sps_list[sps_id] = sps;
@@ -1696,15 +1696,15 @@ int ff_hevc_decode_nal_sps(GetBitContext *gb, AVCodecContext *avctx,
return 0;
err:
- ff_refstruct_unref(&sps);
+ av_refstruct_unref(&sps);
return ret;
}
-static void hevc_pps_free(FFRefStructOpaque unused, void *obj)
+static void hevc_pps_free(AVRefStructOpaque unused, void *obj)
{
HEVCPPS *pps = obj;
- ff_refstruct_unref(&pps->sps);
+ av_refstruct_unref(&pps->sps);
av_freep(&pps->column_width);
av_freep(&pps->row_height);
@@ -2134,7 +2134,7 @@ int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx,
return 0;
}
- pps = ff_refstruct_alloc_ext(sizeof(*pps), 0, NULL, hevc_pps_free);
+ pps = av_refstruct_alloc_ext(sizeof(*pps), 0, NULL, hevc_pps_free);
if (!pps)
return AVERROR(ENOMEM);
@@ -2171,7 +2171,7 @@ int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx,
sps = ps->sps_list[pps->sps_id];
vps = ps->vps_list[sps->vps_id];
- pps->sps = ff_refstruct_ref_c(sps);
+ pps->sps = av_refstruct_ref_c(sps);
pps->dependent_slice_segments_enabled_flag = get_bits1(gb);
pps->output_flag_present_flag = get_bits1(gb);
@@ -2371,13 +2371,13 @@ int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx,
"Overread PPS by %d bits\n", -get_bits_left(gb));
}
- ff_refstruct_unref(&ps->pps_list[pps_id]);
+ av_refstruct_unref(&ps->pps_list[pps_id]);
ps->pps_list[pps_id] = pps;
return 0;
err:
- ff_refstruct_unref(&pps);
+ av_refstruct_unref(&pps);
return ret;
}
@@ -2386,11 +2386,11 @@ void ff_hevc_ps_uninit(HEVCParamSets *ps)
int i;
for (i = 0; i < FF_ARRAY_ELEMS(ps->vps_list); i++)
- ff_refstruct_unref(&ps->vps_list[i]);
+ av_refstruct_unref(&ps->vps_list[i]);
for (i = 0; i < FF_ARRAY_ELEMS(ps->sps_list); i++)
- ff_refstruct_unref(&ps->sps_list[i]);
+ av_refstruct_unref(&ps->sps_list[i]);
for (i = 0; i < FF_ARRAY_ELEMS(ps->pps_list); i++)
- ff_refstruct_unref(&ps->pps_list[i]);
+ av_refstruct_unref(&ps->pps_list[i]);
}
int ff_hevc_compute_poc(const HEVCSPS *sps, int pocTid0, int poc_lsb, int nal_unit_type)
diff --git a/libavcodec/hevc/refs.c b/libavcodec/hevc/refs.c
index 6ba667e9f5..a467786f38 100644
--- a/libavcodec/hevc/refs.c
+++ b/libavcodec/hevc/refs.c
@@ -29,7 +29,7 @@
#include "hevc.h"
#include "hevcdec.h"
#include "progressframe.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
void ff_hevc_unref_frame(HEVCFrame *frame, int flags)
{
@@ -39,15 +39,15 @@ void ff_hevc_unref_frame(HEVCFrame *frame, int flags)
av_frame_unref(frame->frame_grain);
frame->needs_fg = 0;
- ff_refstruct_unref(&frame->pps);
- ff_refstruct_unref(&frame->tab_mvf);
+ av_refstruct_unref(&frame->pps);
+ av_refstruct_unref(&frame->tab_mvf);
- ff_refstruct_unref(&frame->rpl);
+ av_refstruct_unref(&frame->rpl);
frame->nb_rpl_elems = 0;
- ff_refstruct_unref(&frame->rpl_tab);
+ av_refstruct_unref(&frame->rpl_tab);
frame->refPicList = NULL;
- ff_refstruct_unref(&frame->hwaccel_picture_private);
+ av_refstruct_unref(&frame->hwaccel_picture_private);
}
}
@@ -135,16 +135,16 @@ static HEVCFrame *alloc_frame(HEVCContext *s, HEVCLayerContext *l)
if (ret < 0)
return NULL;
- frame->rpl = ff_refstruct_allocz(s->pkt.nb_nals * sizeof(*frame->rpl));
+ frame->rpl = av_refstruct_allocz(s->pkt.nb_nals * sizeof(*frame->rpl));
if (!frame->rpl)
goto fail;
frame->nb_rpl_elems = s->pkt.nb_nals;
- frame->tab_mvf = ff_refstruct_pool_get(l->tab_mvf_pool);
+ frame->tab_mvf = av_refstruct_pool_get(l->tab_mvf_pool);
if (!frame->tab_mvf)
goto fail;
- frame->rpl_tab = ff_refstruct_pool_get(l->rpl_tab_pool);
+ frame->rpl_tab = av_refstruct_pool_get(l->rpl_tab_pool);
if (!frame->rpl_tab)
goto fail;
frame->ctb_count = l->sps->ctb_width * l->sps->ctb_height;
@@ -161,7 +161,7 @@ static HEVCFrame *alloc_frame(HEVCContext *s, HEVCLayerContext *l)
if (ret < 0)
goto fail;
- frame->pps = ff_refstruct_ref_c(s->pps);
+ frame->pps = av_refstruct_ref_c(s->pps);
return frame;
fail:
diff --git a/libavcodec/hwaccel_internal.h b/libavcodec/hwaccel_internal.h
index b0cc22bb68..77df4e0904 100644
--- a/libavcodec/hwaccel_internal.h
+++ b/libavcodec/hwaccel_internal.h
@@ -26,7 +26,7 @@
#include <stdint.h>
#include "avcodec.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
#define HWACCEL_CAP_ASYNC_SAFE (1 << 0)
#define HWACCEL_CAP_THREAD_SAFE (1 << 1)
@@ -155,7 +155,7 @@ typedef struct FFHWAccel {
* @param hwctx a pointer to an AVHWDeviceContext.
* @param data the per-frame hardware accelerator private data to be freed.
*/
- void (*free_frame_priv)(FFRefStructOpaque hwctx, void *data);
+ void (*free_frame_priv)(AVRefStructOpaque hwctx, void *data);
/**
* Callback to flush the hwaccel state.
diff --git a/libavcodec/internal.h b/libavcodec/internal.h
index 98ab2797ce..62a37f473f 100644
--- a/libavcodec/internal.h
+++ b/libavcodec/internal.h
@@ -68,7 +68,7 @@ typedef struct AVCodecInternal {
struct FramePool *pool;
- struct FFRefStructPool *progress_frame_pool;
+ struct AVRefStructPool *progress_frame_pool;
void *thread_ctx;
diff --git a/libavcodec/lcevcdec.c b/libavcodec/lcevcdec.c
index ceeece3aa9..4ca5dfa0a6 100644
--- a/libavcodec/lcevcdec.c
+++ b/libavcodec/lcevcdec.c
@@ -23,6 +23,8 @@
#include "libavutil/imgutils.h"
#include "libavutil/log.h"
#include "libavutil/mem.h"
+#include "libavutil/refstruct.h"
+
#include "decode.h"
#include "lcevcdec.h"
@@ -233,7 +235,7 @@ static void event_callback(LCEVC_DecoderHandle dec, LCEVC_Event event,
}
}
-static void lcevc_free(FFRefStructOpaque unused, void *obj)
+static void lcevc_free(AVRefStructOpaque unused, void *obj)
{
FFLCEVCContext *lcevc = obj;
if (lcevc->initialized)
@@ -305,7 +307,7 @@ int ff_lcevc_alloc(FFLCEVCContext **plcevc)
{
FFLCEVCContext *lcevc = NULL;
#if CONFIG_LIBLCEVC_DEC
- lcevc = ff_refstruct_alloc_ext(sizeof(*lcevc), 0, NULL, lcevc_free);
+ lcevc = av_refstruct_alloc_ext(sizeof(*lcevc), 0, NULL, lcevc_free);
if (!lcevc)
return AVERROR(ENOMEM);
#endif
@@ -315,5 +317,5 @@ int ff_lcevc_alloc(FFLCEVCContext **plcevc)
void ff_lcevc_unref(void *opaque)
{
- ff_refstruct_unref(&opaque);
+ av_refstruct_unref(&opaque);
}
diff --git a/libavcodec/lcevcdec.h b/libavcodec/lcevcdec.h
index 7334d3a645..147491ae42 100644
--- a/libavcodec/lcevcdec.h
+++ b/libavcodec/lcevcdec.h
@@ -27,7 +27,6 @@
#else
typedef uintptr_t LCEVC_DecoderHandle;
#endif
-#include "refstruct.h"
typedef struct FFLCEVCContext {
LCEVC_DecoderHandle decoder;
diff --git a/libavcodec/mpegpicture.c b/libavcodec/mpegpicture.c
index cde060aa1f..6e96389c34 100644
--- a/libavcodec/mpegpicture.c
+++ b/libavcodec/mpegpicture.c
@@ -26,24 +26,24 @@
#include "avcodec.h"
#include "mpegpicture.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
-static void mpv_pic_reset(FFRefStructOpaque unused, void *obj)
+static void mpv_pic_reset(AVRefStructOpaque unused, void *obj)
{
MPVPicture *pic = obj;
av_frame_unref(pic->f);
ff_thread_progress_reset(&pic->progress);
- ff_refstruct_unref(&pic->hwaccel_picture_private);
+ av_refstruct_unref(&pic->hwaccel_picture_private);
- ff_refstruct_unref(&pic->mbskip_table);
- ff_refstruct_unref(&pic->qscale_table_base);
- ff_refstruct_unref(&pic->mb_type_base);
+ av_refstruct_unref(&pic->mbskip_table);
+ av_refstruct_unref(&pic->qscale_table_base);
+ av_refstruct_unref(&pic->mb_type_base);
for (int i = 0; i < 2; i++) {
- ff_refstruct_unref(&pic->motion_val_base[i]);
- ff_refstruct_unref(&pic->ref_index[i]);
+ av_refstruct_unref(&pic->motion_val_base[i]);
+ av_refstruct_unref(&pic->ref_index[i]);
pic->motion_val[i] = NULL;
}
@@ -64,7 +64,7 @@ static void mpv_pic_reset(FFRefStructOpaque unused, void *obj)
pic->coded_picture_number = 0;
}
-static int av_cold mpv_pic_init(FFRefStructOpaque opaque, void *obj)
+static int av_cold mpv_pic_init(AVRefStructOpaque opaque, void *obj)
{
MPVPicture *pic = obj;
int ret, init_progress = (uintptr_t)opaque.nc;
@@ -79,7 +79,7 @@ static int av_cold mpv_pic_init(FFRefStructOpaque opaque, void *obj)
return 0;
}
-static void av_cold mpv_pic_free(FFRefStructOpaque unused, void *obj)
+static void av_cold mpv_pic_free(AVRefStructOpaque unused, void *obj)
{
MPVPicture *pic = obj;
@@ -87,17 +87,17 @@ static void av_cold mpv_pic_free(FFRefStructOpaque unused, void *obj)
av_frame_free(&pic->f);
}
-av_cold FFRefStructPool *ff_mpv_alloc_pic_pool(int init_progress)
+av_cold AVRefStructPool *ff_mpv_alloc_pic_pool(int init_progress)
{
- return ff_refstruct_pool_alloc_ext(sizeof(MPVPicture),
- FF_REFSTRUCT_POOL_FLAG_FREE_ON_INIT_ERROR,
+ return av_refstruct_pool_alloc_ext(sizeof(MPVPicture),
+ AV_REFSTRUCT_POOL_FLAG_FREE_ON_INIT_ERROR,
(void*)(uintptr_t)init_progress,
mpv_pic_init, mpv_pic_reset, mpv_pic_free, NULL);
}
void ff_mpv_unref_picture(MPVWorkPicture *pic)
{
- ff_refstruct_unref(&pic->ptr);
+ av_refstruct_unref(&pic->ptr);
memset(pic, 0, sizeof(*pic));
}
@@ -121,13 +121,13 @@ static void set_workpic_from_pic(MPVWorkPicture *wpic, const MPVPicture *pic)
void ff_mpv_replace_picture(MPVWorkPicture *dst, const MPVWorkPicture *src)
{
av_assert1(dst != src);
- ff_refstruct_replace(&dst->ptr, src->ptr);
+ av_refstruct_replace(&dst->ptr, src->ptr);
memcpy(dst, src, sizeof(*dst));
}
void ff_mpv_workpic_from_pic(MPVWorkPicture *wpic, MPVPicture *pic)
{
- ff_refstruct_replace(&wpic->ptr, pic);
+ av_refstruct_replace(&wpic->ptr, pic);
if (!pic) {
memset(wpic, 0, sizeof(*wpic));
return;
@@ -207,7 +207,7 @@ static int alloc_picture_tables(BufferPoolContext *pools, MPVPicture *pic,
int mb_height)
{
#define GET_BUFFER(name, buf_suffix, idx_suffix) do { \
- pic->name ## buf_suffix idx_suffix = ff_refstruct_pool_get(pools->name ## _pool); \
+ pic->name ## buf_suffix idx_suffix = av_refstruct_pool_get(pools->name ## _pool); \
if (!pic->name ## buf_suffix idx_suffix) \
return AVERROR(ENOMEM); \
} while (0)
diff --git a/libavcodec/mpegpicture.h b/libavcodec/mpegpicture.h
index 196aa9b744..d24093656a 100644
--- a/libavcodec/mpegpicture.h
+++ b/libavcodec/mpegpicture.h
@@ -42,11 +42,11 @@ typedef struct ScratchpadContext {
} ScratchpadContext;
typedef struct BufferPoolContext {
- struct FFRefStructPool *mbskip_table_pool;
- struct FFRefStructPool *qscale_table_pool;
- struct FFRefStructPool *mb_type_pool;
- struct FFRefStructPool *motion_val_pool;
- struct FFRefStructPool *ref_index_pool;
+ struct AVRefStructPool *mbskip_table_pool;
+ struct AVRefStructPool *qscale_table_pool;
+ struct AVRefStructPool *mb_type_pool;
+ struct AVRefStructPool *motion_val_pool;
+ struct AVRefStructPool *ref_index_pool;
int alloc_mb_width; ///< mb_width used to allocate tables
int alloc_mb_height; ///< mb_height used to allocate tables
int alloc_mb_stride; ///< mb_stride used to allocate tables
@@ -114,7 +114,7 @@ typedef struct MPVWorkPicture {
/**
* Allocate a pool of MPVPictures.
*/
-struct FFRefStructPool *ff_mpv_alloc_pic_pool(int init_progress);
+struct AVRefStructPool *ff_mpv_alloc_pic_pool(int init_progress);
/**
* Allocate an MPVPicture's accessories (but not the AVFrame's buffer itself)
diff --git a/libavcodec/mpegvideo.c b/libavcodec/mpegvideo.c
index 01e310e483..804c8095b2 100644
--- a/libavcodec/mpegvideo.c
+++ b/libavcodec/mpegvideo.c
@@ -41,7 +41,7 @@
#include "mpegutils.h"
#include "mpegvideo.h"
#include "mpegvideodata.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
int16_t *block, int n, int qscale)
@@ -499,11 +499,11 @@ void ff_mpv_common_defaults(MpegEncContext *s)
static void free_buffer_pools(BufferPoolContext *pools)
{
- ff_refstruct_pool_uninit(&pools->mbskip_table_pool);
- ff_refstruct_pool_uninit(&pools->qscale_table_pool);
- ff_refstruct_pool_uninit(&pools->mb_type_pool);
- ff_refstruct_pool_uninit(&pools->motion_val_pool);
- ff_refstruct_pool_uninit(&pools->ref_index_pool);
+ av_refstruct_pool_uninit(&pools->mbskip_table_pool);
+ av_refstruct_pool_uninit(&pools->qscale_table_pool);
+ av_refstruct_pool_uninit(&pools->mb_type_pool);
+ av_refstruct_pool_uninit(&pools->motion_val_pool);
+ av_refstruct_pool_uninit(&pools->ref_index_pool);
pools->alloc_mb_height = pools->alloc_mb_width = pools->alloc_mb_stride = 0;
}
@@ -557,7 +557,7 @@ int ff_mpv_init_context_frame(MpegEncContext *s)
s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
#define ALLOC_POOL(name, size, flags) do { \
- pools->name ##_pool = ff_refstruct_pool_alloc((size), (flags)); \
+ pools->name ##_pool = av_refstruct_pool_alloc((size), (flags)); \
if (!pools->name ##_pool) \
return AVERROR(ENOMEM); \
} while (0)
@@ -578,7 +578,7 @@ int ff_mpv_init_context_frame(MpegEncContext *s)
}
if (s->codec_id == AV_CODEC_ID_MPEG4) {
ALLOC_POOL(mbskip_table, mb_array_size + 2,
- !s->encoding ? FF_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME : 0);
+ !s->encoding ? AV_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME : 0);
if (!s->encoding) {
/* cbp, pred_dir */
if (!(s->cbp_table = av_mallocz(mb_array_size)) ||
@@ -626,7 +626,7 @@ int ff_mpv_init_context_frame(MpegEncContext *s)
/* FIXME: The output of H.263 with OBMC depends upon
* the earlier content of the buffer; therefore we set
* the flags to always reset returned buffers here. */
- ALLOC_POOL(motion_val, mv_size, FF_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME);
+ ALLOC_POOL(motion_val, mv_size, AV_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME);
ALLOC_POOL(ref_index, ref_index_size, 0);
}
#undef ALLOC_POOL
diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h
index 8083299b66..eb71198190 100644
--- a/libavcodec/mpegvideo.h
+++ b/libavcodec/mpegvideo.h
@@ -128,7 +128,7 @@ typedef struct MpegEncContext {
int mb_num; ///< number of MBs of a picture
ptrdiff_t linesize; ///< line size, in bytes, may be different from width
ptrdiff_t uvlinesize; ///< line size, for chroma in bytes, may be different from width
- struct FFRefStructPool *picture_pool; ///< Pool for MPVPictures
+ struct AVRefStructPool *picture_pool; ///< Pool for MPVPictures
MPVPicture **input_picture;///< next pictures on display order for encoding
MPVPicture **reordered_input_picture; ///< pointer to the next pictures in coded order for encoding
diff --git a/libavcodec/mpegvideo_dec.c b/libavcodec/mpegvideo_dec.c
index 1cab108935..3684511fd7 100644
--- a/libavcodec/mpegvideo_dec.c
+++ b/libavcodec/mpegvideo_dec.c
@@ -38,7 +38,7 @@
#include "mpegvideo.h"
#include "mpegvideodec.h"
#include "mpeg4videodec.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
#include "thread.h"
#include "threadprogress.h"
#include "wmv2dec.h"
@@ -164,7 +164,7 @@ int ff_mpv_decode_close(AVCodecContext *avctx)
{
MpegEncContext *s = avctx->priv_data;
- ff_refstruct_pool_uninit(&s->picture_pool);
+ av_refstruct_pool_uninit(&s->picture_pool);
ff_mpv_common_end(s);
return 0;
}
@@ -216,7 +216,7 @@ int ff_mpv_common_frame_size_change(MpegEncContext *s)
static int alloc_picture(MpegEncContext *s, MPVWorkPicture *dst, int reference)
{
AVCodecContext *avctx = s->avctx;
- MPVPicture *pic = ff_refstruct_pool_get(s->picture_pool);
+ MPVPicture *pic = av_refstruct_pool_get(s->picture_pool);
int ret;
if (!pic)
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index a332edd1ae..c5f20c2d85 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -75,7 +75,7 @@
#include "wmv2enc.h"
#include "rv10enc.h"
#include "packet_internal.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
#include <limits.h>
#include "sp5x.h"
@@ -1033,12 +1033,12 @@ av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
ff_rate_control_uninit(&s->rc_context);
ff_mpv_common_end(s);
- ff_refstruct_pool_uninit(&s->picture_pool);
+ av_refstruct_pool_uninit(&s->picture_pool);
if (s->input_picture && s->reordered_input_picture) {
for (int i = 0; i < MAX_B_FRAMES + 1; i++) {
- ff_refstruct_unref(&s->input_picture[i]);
- ff_refstruct_unref(&s->reordered_input_picture[i]);
+ av_refstruct_unref(&s->input_picture[i]);
+ av_refstruct_unref(&s->reordered_input_picture[i]);
}
}
for (i = 0; i < FF_ARRAY_ELEMS(s->tmp_frames); i++)
@@ -1232,7 +1232,7 @@ static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
ff_dlog(s->avctx, "%d %d %"PTRDIFF_SPECIFIER" %"PTRDIFF_SPECIFIER"\n", pic_arg->linesize[0],
pic_arg->linesize[1], s->linesize, s->uvlinesize);
- pic = ff_refstruct_pool_get(s->picture_pool);
+ pic = av_refstruct_pool_get(s->picture_pool);
if (!pic)
return AVERROR(ENOMEM);
@@ -1311,7 +1311,7 @@ static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
return 0;
fail:
- ff_refstruct_unref(&pic);
+ av_refstruct_unref(&pic);
return ret;
}
@@ -1541,7 +1541,7 @@ static int set_bframe_chain_length(MpegEncContext *s)
s->next_pic.ptr &&
skip_check(s, s->input_picture[0], s->next_pic.ptr)) {
// FIXME check that the gop check above is +-1 correct
- ff_refstruct_unref(&s->input_picture[0]);
+ av_refstruct_unref(&s->input_picture[0]);
ff_vbv_update(s, 0);
@@ -1607,7 +1607,7 @@ static int set_bframe_chain_length(MpegEncContext *s)
} else if (s->b_frame_strategy == 2) {
b_frames = estimate_best_b_count(s);
if (b_frames < 0) {
- ff_refstruct_unref(&s->input_picture[0]);
+ av_refstruct_unref(&s->input_picture[0]);
return b_frames;
}
}
@@ -1714,7 +1714,7 @@ static int select_input_picture(MpegEncContext *s)
}
return 0;
fail:
- ff_refstruct_unref(&s->reordered_input_picture[0]);
+ av_refstruct_unref(&s->reordered_input_picture[0]);
return ret;
}
diff --git a/libavcodec/nvdec.c b/libavcodec/nvdec.c
index 932544564a..db9d353c61 100644
--- a/libavcodec/nvdec.c
+++ b/libavcodec/nvdec.c
@@ -36,7 +36,7 @@
#include "decode.h"
#include "nvdec.h"
#include "internal.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
#if !NVDECAPI_CHECK_VERSION(9, 0)
#define cudaVideoSurfaceFormat_YUV444 2
@@ -163,7 +163,7 @@ static int nvdec_test_capabilities(NVDECDecoder *decoder,
return 0;
}
-static void nvdec_decoder_free(FFRefStructOpaque unused, void *obj)
+static void nvdec_decoder_free(AVRefStructOpaque unused, void *obj)
{
NVDECDecoder *decoder = obj;
@@ -192,7 +192,7 @@ static int nvdec_decoder_create(NVDECDecoder **out, AVBufferRef *hw_device_ref,
CUcontext dummy;
int ret;
- decoder = ff_refstruct_alloc_ext(sizeof(*decoder), 0,
+ decoder = av_refstruct_alloc_ext(sizeof(*decoder), 0,
NULL, nvdec_decoder_free);
if (!decoder)
return AVERROR(ENOMEM);
@@ -234,11 +234,11 @@ static int nvdec_decoder_create(NVDECDecoder **out, AVBufferRef *hw_device_ref,
return 0;
fail:
- ff_refstruct_unref(&decoder);
+ av_refstruct_unref(&decoder);
return ret;
}
-static int nvdec_decoder_frame_init(FFRefStructOpaque opaque, void *obj)
+static int nvdec_decoder_frame_init(AVRefStructOpaque opaque, void *obj)
{
NVDECFramePool *pool = opaque.nc;
unsigned int *intp = obj;
@@ -251,7 +251,7 @@ static int nvdec_decoder_frame_init(FFRefStructOpaque opaque, void *obj)
return 0;
}
-static void nvdec_decoder_frame_pool_free(FFRefStructOpaque opaque)
+static void nvdec_decoder_frame_pool_free(AVRefStructOpaque opaque)
{
av_free(opaque.nc);
}
@@ -269,8 +269,8 @@ int ff_nvdec_decode_uninit(AVCodecContext *avctx)
ctx->nb_slices = 0;
ctx->slice_offsets_allocated = 0;
- ff_refstruct_unref(&ctx->decoder);
- ff_refstruct_pool_uninit(&ctx->decoder_pool);
+ av_refstruct_unref(&ctx->decoder);
+ av_refstruct_pool_uninit(&ctx->decoder_pool);
return 0;
}
@@ -426,7 +426,7 @@ int ff_nvdec_decode_init(AVCodecContext *avctx)
}
pool->dpb_size = frames_ctx->initial_pool_size;
- ctx->decoder_pool = ff_refstruct_pool_alloc_ext(sizeof(unsigned int), 0, pool,
+ ctx->decoder_pool = av_refstruct_pool_alloc_ext(sizeof(unsigned int), 0, pool,
nvdec_decoder_frame_init,
NULL, NULL, nvdec_decoder_frame_pool_free);
if (!ctx->decoder_pool) {
@@ -447,9 +447,9 @@ static void nvdec_fdd_priv_free(void *priv)
if (!cf)
return;
- ff_refstruct_unref(&cf->idx_ref);
- ff_refstruct_unref(&cf->ref_idx_ref);
- ff_refstruct_unref(&cf->decoder);
+ av_refstruct_unref(&cf->idx_ref);
+ av_refstruct_unref(&cf->ref_idx_ref);
+ av_refstruct_unref(&cf->decoder);
av_freep(&priv);
}
@@ -472,9 +472,9 @@ static void nvdec_unmap_mapped_frame(void *opaque, uint8_t *data)
CHECK_CU(decoder->cudl->cuCtxPopCurrent(&dummy));
finish:
- ff_refstruct_unref(&unmap_data->idx_ref);
- ff_refstruct_unref(&unmap_data->ref_idx_ref);
- ff_refstruct_unref(&unmap_data->decoder);
+ av_refstruct_unref(&unmap_data->idx_ref);
+ av_refstruct_unref(&unmap_data->ref_idx_ref);
+ av_refstruct_unref(&unmap_data->decoder);
av_free(unmap_data);
}
@@ -529,8 +529,8 @@ static int nvdec_retrieve_data(void *logctx, AVFrame *frame)
goto copy_fail;
unmap_data->idx = cf->idx;
- unmap_data->idx_ref = ff_refstruct_ref(cf->idx_ref);
- unmap_data->decoder = ff_refstruct_ref(cf->decoder);
+ unmap_data->idx_ref = av_refstruct_ref(cf->idx_ref);
+ unmap_data->decoder = av_refstruct_ref(cf->decoder);
av_pix_fmt_get_chroma_sub_sample(hwctx->sw_format, &shift_h, &shift_v);
for (i = 0; frame->linesize[i]; i++) {
@@ -575,9 +575,9 @@ int ff_nvdec_start_frame(AVCodecContext *avctx, AVFrame *frame)
if (!cf)
return AVERROR(ENOMEM);
- cf->decoder = ff_refstruct_ref(ctx->decoder);
+ cf->decoder = av_refstruct_ref(ctx->decoder);
- cf->idx_ref = ff_refstruct_pool_get(ctx->decoder_pool);
+ cf->idx_ref = av_refstruct_pool_get(ctx->decoder_pool);
if (!cf->idx_ref) {
av_log(avctx, AV_LOG_ERROR, "No decoder surfaces left\n");
ret = AVERROR(ENOMEM);
@@ -611,7 +611,7 @@ int ff_nvdec_start_frame_sep_ref(AVCodecContext *avctx, AVFrame *frame, int has_
if (has_sep_ref) {
if (!cf->ref_idx_ref) {
- cf->ref_idx_ref = ff_refstruct_pool_get(ctx->decoder_pool);
+ cf->ref_idx_ref = av_refstruct_pool_get(ctx->decoder_pool);
if (!cf->ref_idx_ref) {
av_log(avctx, AV_LOG_ERROR, "No decoder surfaces left\n");
ret = AVERROR(ENOMEM);
@@ -620,7 +620,7 @@ int ff_nvdec_start_frame_sep_ref(AVCodecContext *avctx, AVFrame *frame, int has_
}
cf->ref_idx = *cf->ref_idx_ref;
} else {
- ff_refstruct_unref(&cf->ref_idx_ref);
+ av_refstruct_unref(&cf->ref_idx_ref);
cf->ref_idx = cf->idx;
}
diff --git a/libavcodec/nvdec.h b/libavcodec/nvdec.h
index 555300d27d..5e22f672d1 100644
--- a/libavcodec/nvdec.h
+++ b/libavcodec/nvdec.h
@@ -52,7 +52,7 @@ typedef struct NVDECFrame {
typedef struct NVDECContext {
CUVIDPICPARAMS pic_params;
- struct FFRefStructPool *decoder_pool;
+ struct AVRefStructPool *decoder_pool;
struct NVDECDecoder *decoder; ///< RefStruct reference
diff --git a/libavcodec/pthread_frame.c b/libavcodec/pthread_frame.c
index 1b1b96623f..4960352307 100644
--- a/libavcodec/pthread_frame.c
+++ b/libavcodec/pthread_frame.c
@@ -34,7 +34,7 @@
#include "internal.h"
#include "packet_internal.h"
#include "pthread_internal.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
#include "thread.h"
#include "threadframe.h"
#include "version_major.h"
@@ -405,7 +405,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
dst->hwaccel_flags = src->hwaccel_flags;
- ff_refstruct_replace(&dst->internal->pool, src->internal->pool);
+ av_refstruct_replace(&dst->internal->pool, src->internal->pool);
ff_decode_internal_sync(dst, src);
}
@@ -780,7 +780,7 @@ void ff_frame_thread_free(AVCodecContext *avctx, int thread_count)
av_freep(&ctx->priv_data);
}
- ff_refstruct_unref(&ctx->internal->pool);
+ av_refstruct_unref(&ctx->internal->pool);
av_packet_free(&ctx->internal->in_pkt);
av_packet_free(&ctx->internal->last_pkt_props);
ff_decode_internal_uninit(ctx);
@@ -1062,7 +1062,7 @@ int ff_thread_get_ext_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
if (!(avctx->active_thread_type & FF_THREAD_FRAME))
return ff_get_buffer(avctx, f->f, flags);
- f->progress = ff_refstruct_allocz(sizeof(*f->progress));
+ f->progress = av_refstruct_allocz(sizeof(*f->progress));
if (!f->progress)
return AVERROR(ENOMEM);
@@ -1071,13 +1071,13 @@ int ff_thread_get_ext_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
ret = ff_thread_get_buffer(avctx, f->f, flags);
if (ret)
- ff_refstruct_unref(&f->progress);
+ av_refstruct_unref(&f->progress);
return ret;
}
void ff_thread_release_ext_buffer(ThreadFrame *f)
{
- ff_refstruct_unref(&f->progress);
+ av_refstruct_unref(&f->progress);
f->owner[0] = f->owner[1] = NULL;
if (f->f)
av_frame_unref(f->f);
@@ -1098,7 +1098,7 @@ enum ThreadingStatus ff_thread_sync_ref(AVCodecContext *avctx, size_t offset)
memcpy(&ref, (const char*)p->parent->threads[0].avctx->priv_data + offset, sizeof(ref));
av_assert1(ref);
- ff_refstruct_replace((char*)avctx->priv_data + offset, ref);
+ av_refstruct_replace((char*)avctx->priv_data + offset, ref);
return FF_THREAD_IS_COPY;
}
diff --git a/libavcodec/qsv.c b/libavcodec/qsv.c
index 8a3dc95706..cd5195a54b 100644
--- a/libavcodec/qsv.c
+++ b/libavcodec/qsv.c
@@ -35,7 +35,7 @@
#include "avcodec.h"
#include "qsv_internal.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
#define MFX_IMPL_VIA_MASK(impl) (0x0f00 & (impl))
#define QSV_HAVE_USER_PLUGIN !QSV_ONEVPL
@@ -745,7 +745,7 @@ int ff_qsv_init_internal_session(AVCodecContext *avctx, QSVSession *qs,
return 0;
}
-static void mids_buf_free(FFRefStructOpaque opaque, void *obj)
+static void mids_buf_free(AVRefStructOpaque opaque, void *obj)
{
AVBufferRef *hw_frames_ref = opaque.nc;
av_buffer_unref(&hw_frames_ref);
@@ -765,7 +765,7 @@ static QSVMid *qsv_create_mids(AVBufferRef *hw_frames_ref)
if (!hw_frames_ref1)
return NULL;
- mids = ff_refstruct_alloc_ext(nb_surfaces * sizeof(*mids), 0,
+ mids = av_refstruct_alloc_ext(nb_surfaces * sizeof(*mids), 0,
hw_frames_ref1, mids_buf_free);
if (!mids) {
av_buffer_unref(&hw_frames_ref1);
@@ -806,7 +806,7 @@ static int qsv_setup_mids(mfxFrameAllocResponse *resp, AVBufferRef *hw_frames_re
return AVERROR(ENOMEM);
}
- resp->mids[resp->NumFrameActual + 1] = ff_refstruct_ref(mids);
+ resp->mids[resp->NumFrameActual + 1] = av_refstruct_ref(mids);
return 0;
}
@@ -899,7 +899,7 @@ static mfxStatus qsv_frame_alloc(mfxHDL pthis, mfxFrameAllocRequest *req,
}
ret = qsv_setup_mids(resp, frames_ref, mids);
- ff_refstruct_unref(&mids);
+ av_refstruct_unref(&mids);
av_buffer_unref(&frames_ref);
if (ret < 0) {
av_log(ctx->logctx, AV_LOG_ERROR,
@@ -919,7 +919,7 @@ static mfxStatus qsv_frame_free(mfxHDL pthis, mfxFrameAllocResponse *resp)
return MFX_ERR_NONE;
av_buffer_unref((AVBufferRef**)&resp->mids[resp->NumFrameActual]);
- ff_refstruct_unref(&resp->mids[resp->NumFrameActual + 1]);
+ av_refstruct_unref(&resp->mids[resp->NumFrameActual + 1]);
av_freep(&resp->mids);
return MFX_ERR_NONE;
}
@@ -1139,7 +1139,7 @@ int ff_qsv_init_session_frames(AVCodecContext *avctx, mfxSession *psession,
/* allocate the memory ids for the external frames */
if (frames_hwctx->nb_surfaces) {
- ff_refstruct_unref(&qsv_frames_ctx->mids);
+ av_refstruct_unref(&qsv_frames_ctx->mids);
qsv_frames_ctx->mids = qsv_create_mids(qsv_frames_ctx->hw_frames_ctx);
if (!qsv_frames_ctx->mids)
return AVERROR(ENOMEM);
diff --git a/libavcodec/qsvdec.c b/libavcodec/qsvdec.c
index 039ba62484..19fa791c10 100644
--- a/libavcodec/qsvdec.c
+++ b/libavcodec/qsvdec.c
@@ -51,7 +51,7 @@
#include "hwconfig.h"
#include "qsv.h"
#include "qsv_internal.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
#if QSV_ONEVPL
#include <mfxdispatcher.h>
@@ -984,7 +984,7 @@ static void qsv_decode_close_qsvcontext(QSVContext *q)
ff_qsv_close_internal_session(&q->internal_qs);
av_buffer_unref(&q->frames_ctx.hw_frames_ctx);
- ff_refstruct_unref(&q->frames_ctx.mids);
+ av_refstruct_unref(&q->frames_ctx.mids);
av_buffer_pool_uninit(&q->pool);
}
diff --git a/libavcodec/qsvenc.c b/libavcodec/qsvenc.c
index 8200a14012..f0b572ec29 100644
--- a/libavcodec/qsvenc.c
+++ b/libavcodec/qsvenc.c
@@ -42,7 +42,7 @@
#include "qsv.h"
#include "qsv_internal.h"
#include "qsvenc.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
struct profile_names {
mfxU16 profile;
@@ -2716,7 +2716,7 @@ int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q)
ff_qsv_close_internal_session(&q->internal_qs);
av_buffer_unref(&q->frames_ctx.hw_frames_ctx);
- ff_refstruct_unref(&q->frames_ctx.mids);
+ av_refstruct_unref(&q->frames_ctx.mids);
cur = q->work_frames;
while (cur) {
diff --git a/libavcodec/rkmppdec.c b/libavcodec/rkmppdec.c
index 47b076dbd8..07d299f144 100644
--- a/libavcodec/rkmppdec.c
+++ b/libavcodec/rkmppdec.c
@@ -30,7 +30,7 @@
#include "codec_internal.h"
#include "decode.h"
#include "hwconfig.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
#include "libavutil/buffer.h"
#include "libavutil/common.h"
#include "libavutil/frame.h"
@@ -126,11 +126,11 @@ static int rkmpp_write_data(AVCodecContext *avctx, uint8_t *buffer, int size, in
static int rkmpp_close_decoder(AVCodecContext *avctx)
{
RKMPPDecodeContext *rk_context = avctx->priv_data;
- ff_refstruct_unref(&rk_context->decoder);
+ av_refstruct_unref(&rk_context->decoder);
return 0;
}
-static void rkmpp_release_decoder(FFRefStructOpaque unused, void *obj)
+static void rkmpp_release_decoder(AVRefStructOpaque unused, void *obj)
{
RKMPPDecoder *decoder = obj;
@@ -161,7 +161,7 @@ static int rkmpp_init_decoder(AVCodecContext *avctx)
avctx->pix_fmt = AV_PIX_FMT_DRM_PRIME;
// create a decoder and a ref to it
- decoder = ff_refstruct_alloc_ext(sizeof(*decoder), 0,
+ decoder = av_refstruct_alloc_ext(sizeof(*decoder), 0,
NULL, rkmpp_release_decoder);
if (!decoder) {
ret = AVERROR(ENOMEM);
@@ -304,7 +304,7 @@ static void rkmpp_release_frame(void *opaque, uint8_t *data)
RKMPPFrameContext *framecontext = opaque;
mpp_frame_deinit(&framecontext->frame);
- ff_refstruct_unref(&framecontext->decoder_ref);
+ av_refstruct_unref(&framecontext->decoder_ref);
av_free(desc);
}
@@ -449,7 +449,7 @@ static int rkmpp_retrieve_frame(AVCodecContext *avctx, AVFrame *frame)
ret = AVERROR(ENOMEM);
goto fail;
}
- framecontext->decoder_ref = ff_refstruct_ref(rk_context->decoder);
+ framecontext->decoder_ref = av_refstruct_ref(rk_context->decoder);
frame->hw_frames_ctx = av_buffer_ref(decoder->frames_ref);
if (!frame->hw_frames_ctx) {
diff --git a/libavcodec/utils.c b/libavcodec/utils.c
index 28023a4a4d..2dbd677920 100644
--- a/libavcodec/utils.c
+++ b/libavcodec/utils.c
@@ -40,7 +40,7 @@
#include "codec_par.h"
#include "decode.h"
#include "hwconfig.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
#include "thread.h"
#include "threadframe.h"
#include "internal.h"
@@ -856,7 +856,7 @@ int ff_thread_ref_frame(ThreadFrame *dst, const ThreadFrame *src)
av_assert0(!dst->progress);
if (src->progress)
- dst->progress = ff_refstruct_ref(src->progress);
+ dst->progress = av_refstruct_ref(src->progress);
return 0;
}
@@ -872,7 +872,7 @@ int ff_thread_replace_frame(ThreadFrame *dst, const ThreadFrame *src)
if (ret < 0)
return ret;
- ff_refstruct_replace(&dst->progress, src->progress);
+ av_refstruct_replace(&dst->progress, src->progress);
return 0;
}
diff --git a/libavcodec/v4l2_buffers.c b/libavcodec/v4l2_buffers.c
index 23474ee143..aba9cfad83 100644
--- a/libavcodec/v4l2_buffers.c
+++ b/libavcodec/v4l2_buffers.c
@@ -29,7 +29,7 @@
#include <poll.h>
#include "libavcodec/avcodec.h"
#include "libavutil/pixdesc.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
#include "v4l2_context.h"
#include "v4l2_buffers.h"
#include "v4l2_m2m.h"
@@ -230,7 +230,7 @@ static void v4l2_free_buffer(void *opaque, uint8_t *unused)
ff_v4l2_buffer_enqueue(avbuf);
}
- ff_refstruct_unref(&avbuf->context_ref);
+ av_refstruct_unref(&avbuf->context_ref);
}
}
@@ -241,7 +241,7 @@ static int v4l2_buf_increase_ref(V4L2Buffer *in)
if (in->context_ref)
atomic_fetch_add(&in->context_refcount, 1);
else {
- in->context_ref = ff_refstruct_ref(s->self_ref);
+ in->context_ref = av_refstruct_ref(s->self_ref);
in->context_refcount = 1;
}
diff --git a/libavcodec/v4l2_m2m.c b/libavcodec/v4l2_m2m.c
index 15415cfc4e..8f633e2aeb 100644
--- a/libavcodec/v4l2_m2m.c
+++ b/libavcodec/v4l2_m2m.c
@@ -32,7 +32,7 @@
#include "libavutil/pixdesc.h"
#include "libavutil/imgutils.h"
#include "libavutil/pixfmt.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
#include "v4l2_context.h"
#include "v4l2_fmt.h"
#include "v4l2_m2m.h"
@@ -248,7 +248,7 @@ int ff_v4l2_m2m_codec_reinit(V4L2m2mContext *s)
return 0;
}
-static void v4l2_m2m_destroy_context(FFRefStructOpaque unused, void *context)
+static void v4l2_m2m_destroy_context(AVRefStructOpaque unused, void *context)
{
V4L2m2mContext *s = context;
@@ -282,7 +282,7 @@ int ff_v4l2_m2m_codec_end(V4L2m2mPriv *priv)
ff_v4l2_context_release(&s->output);
s->self_ref = NULL;
- ff_refstruct_unref(&priv->context);
+ av_refstruct_unref(&priv->context);
return 0;
}
@@ -327,7 +327,7 @@ int ff_v4l2_m2m_codec_init(V4L2m2mPriv *priv)
int ff_v4l2_m2m_create_context(V4L2m2mPriv *priv, V4L2m2mContext **s)
{
- *s = ff_refstruct_alloc_ext(sizeof(**s), 0, NULL,
+ *s = av_refstruct_alloc_ext(sizeof(**s), 0, NULL,
&v4l2_m2m_destroy_context);
if (!*s)
return AVERROR(ENOMEM);
@@ -344,7 +344,7 @@ int ff_v4l2_m2m_create_context(V4L2m2mPriv *priv, V4L2m2mContext **s)
priv->context->frame = av_frame_alloc();
if (!priv->context->frame) {
- ff_refstruct_unref(&priv->context);
+ av_refstruct_unref(&priv->context);
*s = NULL; /* freed when unreferencing context */
return AVERROR(ENOMEM);
}
diff --git a/libavcodec/vaapi_encode.c b/libavcodec/vaapi_encode.c
index 16a9a364f0..b593d976ef 100644
--- a/libavcodec/vaapi_encode.c
+++ b/libavcodec/vaapi_encode.c
@@ -31,7 +31,7 @@
#include "vaapi_encode.h"
#include "encode.h"
#include "avcodec.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
const AVCodecHWConfigInternal *const ff_vaapi_encode_hw_configs[] = {
HW_CONFIG_ENCODER_FRAMES(VAAPI, VAAPI),
@@ -316,7 +316,7 @@ static int vaapi_encode_issue(AVCodecContext *avctx,
pic->recon_surface = (VASurfaceID)(uintptr_t)base_pic->recon_image->data[3];
av_log(avctx, AV_LOG_DEBUG, "Recon surface is %#x.\n", pic->recon_surface);
- pic->output_buffer_ref = ff_refstruct_pool_get(ctx->output_buffer_pool);
+ pic->output_buffer_ref = av_refstruct_pool_get(ctx->output_buffer_pool);
if (!pic->output_buffer_ref) {
err = AVERROR(ENOMEM);
goto fail;
@@ -649,7 +649,7 @@ fail_at_end:
av_freep(&pic->param_buffers);
av_freep(&pic->slices);
av_freep(&pic->roi);
- ff_refstruct_unref(&pic->output_buffer_ref);
+ av_refstruct_unref(&pic->output_buffer_ref);
pic->output_buffer = VA_INVALID_ID;
return err;
}
@@ -759,8 +759,8 @@ static int vaapi_encode_get_coded_data(AVCodecContext *avctx,
goto end;
end:
- ff_refstruct_unref(&ctx->coded_buffer_ref);
- ff_refstruct_unref(&pic->output_buffer_ref);
+ av_refstruct_unref(&ctx->coded_buffer_ref);
+ av_refstruct_unref(&pic->output_buffer_ref);
pic->output_buffer = VA_INVALID_ID;
return ret;
@@ -781,7 +781,7 @@ static int vaapi_encode_output(AVCodecContext *avctx,
if (pic->non_independent_frame) {
av_assert0(!ctx->coded_buffer_ref);
- ctx->coded_buffer_ref = ff_refstruct_ref(pic->output_buffer_ref);
+ ctx->coded_buffer_ref = av_refstruct_ref(pic->output_buffer_ref);
if (pic->tail_size) {
if (base_ctx->tail_pkt->size) {
@@ -809,7 +809,7 @@ static int vaapi_encode_output(AVCodecContext *avctx,
ctx->codec->flags & FLAG_TIMESTAMP_NO_DELAY);
end:
- ff_refstruct_unref(&pic->output_buffer_ref);
+ av_refstruct_unref(&pic->output_buffer_ref);
pic->output_buffer = VA_INVALID_ID;
return err;
}
@@ -825,7 +825,7 @@ static int vaapi_encode_discard(AVCodecContext *avctx, FFHWBaseEncodePicture *ba
"%"PRId64"/%"PRId64".\n",
base_pic->display_order, base_pic->encode_order);
- ff_refstruct_unref(&pic->output_buffer_ref);
+ av_refstruct_unref(&pic->output_buffer_ref);
pic->output_buffer = VA_INVALID_ID;
}
@@ -1987,7 +1987,7 @@ static av_cold int vaapi_encode_init_roi(AVCodecContext *avctx)
return 0;
}
-static void vaapi_encode_free_output_buffer(FFRefStructOpaque opaque,
+static void vaapi_encode_free_output_buffer(AVRefStructOpaque opaque,
void *obj)
{
AVCodecContext *avctx = opaque.nc;
@@ -2000,7 +2000,7 @@ static void vaapi_encode_free_output_buffer(FFRefStructOpaque opaque,
av_log(avctx, AV_LOG_DEBUG, "Freed output buffer %#x\n", buffer_id);
}
-static int vaapi_encode_alloc_output_buffer(FFRefStructOpaque opaque, void *obj)
+static int vaapi_encode_alloc_output_buffer(AVRefStructOpaque opaque, void *obj)
{
AVCodecContext *avctx = opaque.nc;
FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
@@ -2187,7 +2187,7 @@ av_cold int ff_vaapi_encode_init(AVCodecContext *avctx)
}
ctx->output_buffer_pool =
- ff_refstruct_pool_alloc_ext(sizeof(VABufferID), 0, avctx,
+ av_refstruct_pool_alloc_ext(sizeof(VABufferID), 0, avctx,
&vaapi_encode_alloc_output_buffer, NULL,
vaapi_encode_free_output_buffer, NULL);
if (!ctx->output_buffer_pool) {
@@ -2288,7 +2288,7 @@ av_cold int ff_vaapi_encode_close(AVCodecContext *avctx)
vaapi_encode_free(avctx, pic);
}
- ff_refstruct_pool_uninit(&ctx->output_buffer_pool);
+ av_refstruct_pool_uninit(&ctx->output_buffer_pool);
if (ctx->va_context != VA_INVALID_ID) {
if (ctx->hwctx)
diff --git a/libavcodec/vaapi_encode.h b/libavcodec/vaapi_encode.h
index c4f85397a2..40a3f4e064 100644
--- a/libavcodec/vaapi_encode.h
+++ b/libavcodec/vaapi_encode.h
@@ -202,7 +202,7 @@ typedef struct VAAPIEncodeContext {
AVVAAPIDeviceContext *hwctx;
// Pool of (reusable) bitstream output buffers.
- struct FFRefStructPool *output_buffer_pool;
+ struct AVRefStructPool *output_buffer_pool;
// Global parameters which will be applied at the start of the
// sequence (includes rate control parameters below).
diff --git a/libavcodec/vp3.c b/libavcodec/vp3.c
index d03a1c9dbc..3089499a0f 100644
--- a/libavcodec/vp3.c
+++ b/libavcodec/vp3.c
@@ -50,7 +50,7 @@
#include "jpegquanttables.h"
#include "mathops.h"
#include "progressframe.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
#include "thread.h"
#include "videodsp.h"
#include "vp3data.h"
@@ -370,7 +370,7 @@ static av_cold int vp3_decode_end(AVCodecContext *avctx)
/* release all frames */
vp3_decode_flush(avctx);
- ff_refstruct_unref(&s->coeff_vlc);
+ av_refstruct_unref(&s->coeff_vlc);
return 0;
}
@@ -2346,7 +2346,7 @@ static av_cold int allocate_tables(AVCodecContext *avctx)
}
-static av_cold void free_vlc_tables(FFRefStructOpaque unused, void *obj)
+static av_cold void free_vlc_tables(AVRefStructOpaque unused, void *obj)
{
CoeffVLCs *vlcs = obj;
@@ -2459,7 +2459,7 @@ static av_cold int vp3_decode_init(AVCodecContext *avctx)
}
if (!avctx->internal->is_copy) {
- CoeffVLCs *vlcs = ff_refstruct_alloc_ext(sizeof(*s->coeff_vlc), 0,
+ CoeffVLCs *vlcs = av_refstruct_alloc_ext(sizeof(*s->coeff_vlc), 0,
NULL, free_vlc_tables);
if (!vlcs)
return AVERROR(ENOMEM);
@@ -2527,7 +2527,7 @@ static int vp3_update_thread_context(AVCodecContext *dst, const AVCodecContext *
const Vp3DecodeContext *s1 = src->priv_data;
int qps_changed = 0;
- ff_refstruct_replace(&s->coeff_vlc, s1->coeff_vlc);
+ av_refstruct_replace(&s->coeff_vlc, s1->coeff_vlc);
// copy previous frame data
ref_frames(s, s1);
diff --git a/libavcodec/vp8.c b/libavcodec/vp8.c
index d6df018655..3651688c10 100644
--- a/libavcodec/vp8.c
+++ b/libavcodec/vp8.c
@@ -36,7 +36,7 @@
#include "hwconfig.h"
#include "mathops.h"
#include "progressframe.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
#include "thread.h"
#include "vp8.h"
#include "vp89_rac.h"
@@ -107,7 +107,7 @@ static int vp8_alloc_frame(VP8Context *s, VP8Frame *f, int ref)
ref ? AV_GET_BUFFER_FLAG_REF : 0);
if (ret < 0)
return ret;
- f->seg_map = ff_refstruct_allocz(s->mb_width * s->mb_height);
+ f->seg_map = av_refstruct_allocz(s->mb_width * s->mb_height);
if (!f->seg_map) {
ret = AVERROR(ENOMEM);
goto fail;
@@ -119,15 +119,15 @@ static int vp8_alloc_frame(VP8Context *s, VP8Frame *f, int ref)
return 0;
fail:
- ff_refstruct_unref(&f->seg_map);
+ av_refstruct_unref(&f->seg_map);
ff_progress_frame_unref(&f->tf);
return ret;
}
static void vp8_release_frame(VP8Frame *f)
{
- ff_refstruct_unref(&f->seg_map);
- ff_refstruct_unref(&f->hwaccel_picture_private);
+ av_refstruct_unref(&f->seg_map);
+ av_refstruct_unref(&f->hwaccel_picture_private);
ff_progress_frame_unref(&f->tf);
}
@@ -2905,8 +2905,8 @@ av_cold int ff_vp8_decode_init(AVCodecContext *avctx)
static void vp8_replace_frame(VP8Frame *dst, const VP8Frame *src)
{
ff_progress_frame_replace(&dst->tf, &src->tf);
- ff_refstruct_replace(&dst->seg_map, src->seg_map);
- ff_refstruct_replace(&dst->hwaccel_picture_private,
+ av_refstruct_replace(&dst->seg_map, src->seg_map);
+ av_refstruct_replace(&dst->hwaccel_picture_private,
src->hwaccel_picture_private);
}
diff --git a/libavcodec/vp9.c b/libavcodec/vp9.c
index 8ede2e2eb3..c867626b3f 100644
--- a/libavcodec/vp9.c
+++ b/libavcodec/vp9.c
@@ -31,7 +31,7 @@
#include "hwconfig.h"
#include "profiles.h"
#include "progressframe.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
#include "thread.h"
#include "pthread_internal.h"
@@ -97,8 +97,8 @@ static void vp9_tile_data_free(VP9TileData *td)
static void vp9_frame_unref(VP9Frame *f)
{
ff_progress_frame_unref(&f->tf);
- ff_refstruct_unref(&f->extradata);
- ff_refstruct_unref(&f->hwaccel_picture_private);
+ av_refstruct_unref(&f->extradata);
+ av_refstruct_unref(&f->hwaccel_picture_private);
f->segmentation_map = NULL;
}
@@ -113,9 +113,9 @@ static int vp9_frame_alloc(AVCodecContext *avctx, VP9Frame *f)
sz = 64 * s->sb_cols * s->sb_rows;
if (sz != s->frame_extradata_pool_size) {
- ff_refstruct_pool_uninit(&s->frame_extradata_pool);
- s->frame_extradata_pool = ff_refstruct_pool_alloc(sz * (1 + sizeof(VP9mvrefPair)),
- FF_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME);
+ av_refstruct_pool_uninit(&s->frame_extradata_pool);
+ s->frame_extradata_pool = av_refstruct_pool_alloc(sz * (1 + sizeof(VP9mvrefPair)),
+ AV_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME);
if (!s->frame_extradata_pool) {
s->frame_extradata_pool_size = 0;
ret = AVERROR(ENOMEM);
@@ -123,7 +123,7 @@ static int vp9_frame_alloc(AVCodecContext *avctx, VP9Frame *f)
}
s->frame_extradata_pool_size = sz;
}
- f->extradata = ff_refstruct_pool_get(s->frame_extradata_pool);
+ f->extradata = av_refstruct_pool_get(s->frame_extradata_pool);
if (!f->extradata) {
ret = AVERROR(ENOMEM);
goto fail;
@@ -147,13 +147,13 @@ static void vp9_frame_replace(VP9Frame *dst, const VP9Frame *src)
{
ff_progress_frame_replace(&dst->tf, &src->tf);
- ff_refstruct_replace(&dst->extradata, src->extradata);
+ av_refstruct_replace(&dst->extradata, src->extradata);
dst->segmentation_map = src->segmentation_map;
dst->mv = src->mv;
dst->uses_2pass = src->uses_2pass;
- ff_refstruct_replace(&dst->hwaccel_picture_private,
+ av_refstruct_replace(&dst->hwaccel_picture_private,
src->hwaccel_picture_private);
}
@@ -1239,7 +1239,7 @@ static av_cold int vp9_decode_free(AVCodecContext *avctx)
for (int i = 0; i < 3; i++)
vp9_frame_unref(&s->s.frames[i]);
- ff_refstruct_pool_uninit(&s->frame_extradata_pool);
+ av_refstruct_pool_uninit(&s->frame_extradata_pool);
for (i = 0; i < 8; i++) {
ff_progress_frame_unref(&s->s.refs[i]);
ff_progress_frame_unref(&s->next_refs[i]);
@@ -1802,7 +1802,7 @@ static int vp9_decode_update_thread_context(AVCodecContext *dst, const AVCodecCo
vp9_frame_replace(&s->s.frames[i], &ssrc->s.frames[i]);
for (int i = 0; i < 8; i++)
ff_progress_frame_replace(&s->s.refs[i], &ssrc->next_refs[i]);
- ff_refstruct_replace(&s->frame_extradata_pool, ssrc->frame_extradata_pool);
+ av_refstruct_replace(&s->frame_extradata_pool, ssrc->frame_extradata_pool);
s->frame_extradata_pool_size = ssrc->frame_extradata_pool_size;
s->s.h.invisible = ssrc->s.h.invisible;
diff --git a/libavcodec/vp9dec.h b/libavcodec/vp9dec.h
index 81dc801052..851ee9f6dd 100644
--- a/libavcodec/vp9dec.h
+++ b/libavcodec/vp9dec.h
@@ -160,7 +160,7 @@ typedef struct VP9Context {
uint8_t mvstep[3][2];
// frame specific buffer pools
- struct FFRefStructPool *frame_extradata_pool;
+ struct AVRefStructPool *frame_extradata_pool;
int frame_extradata_pool_size;
} VP9Context;
diff --git a/libavcodec/vulkan_av1.c b/libavcodec/vulkan_av1.c
index a0befb9c4e..290607d24c 100644
--- a/libavcodec/vulkan_av1.c
+++ b/libavcodec/vulkan_av1.c
@@ -606,7 +606,7 @@ static int vk_av1_end_frame(AVCodecContext *avctx)
return ff_vk_decode_frame(avctx, pic->f, vp, rav, rvp);
}
-static void vk_av1_free_frame_priv(FFRefStructOpaque _hwctx, void *data)
+static void vk_av1_free_frame_priv(AVRefStructOpaque _hwctx, void *data)
{
AVHWDeviceContext *hwctx = _hwctx.nc;
AV1VulkanDecodePicture *ap = data;
diff --git a/libavcodec/vulkan_decode.c b/libavcodec/vulkan_decode.c
index dc5d57ec67..5936c0bc4a 100644
--- a/libavcodec/vulkan_decode.c
+++ b/libavcodec/vulkan_decode.c
@@ -16,7 +16,7 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
#include "vulkan_video.h"
#include "vulkan_decode.h"
#include "config_components.h"
@@ -102,7 +102,7 @@ int ff_vk_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
return err;
}
- ff_refstruct_replace(&dst_ctx->shared_ctx, src_ctx->shared_ctx);
+ av_refstruct_replace(&dst_ctx->shared_ctx, src_ctx->shared_ctx);
if (src_ctx->session_params) {
err = av_buffer_replace(&dst_ctx->session_params, src_ctx->session_params);
@@ -571,7 +571,7 @@ void ff_vk_decode_free_frame(AVHWDeviceContext *dev_ctx, FFVulkanDecodePicture *
av_frame_free(&vp->dpb_frame);
}
-static void free_common(FFRefStructOpaque unused, void *obj)
+static void free_common(AVRefStructOpaque unused, void *obj)
{
FFVulkanDecodeShared *ctx = obj;
FFVulkanContext *s = &ctx->s;
@@ -605,7 +605,7 @@ static int vulkan_decode_bootstrap(AVCodecContext *avctx, AVBufferRef *frames_re
if (dec->shared_ctx)
return 0;
- dec->shared_ctx = ff_refstruct_alloc_ext(sizeof(*ctx), 0, NULL,
+ dec->shared_ctx = av_refstruct_alloc_ext(sizeof(*ctx), 0, NULL,
free_common);
if (!dec->shared_ctx)
return AVERROR(ENOMEM);
@@ -618,13 +618,13 @@ static int vulkan_decode_bootstrap(AVCodecContext *avctx, AVBufferRef *frames_re
if (!(ctx->s.extensions & FF_VK_EXT_VIDEO_DECODE_QUEUE)) {
av_log(avctx, AV_LOG_ERROR, "Device does not support the %s extension!\n",
VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME);
- ff_refstruct_unref(&dec->shared_ctx);
+ av_refstruct_unref(&dec->shared_ctx);
return AVERROR(ENOSYS);
}
err = ff_vk_load_functions(device, &ctx->s.vkfn, ctx->s.extensions, 1, 1);
if (err < 0) {
- ff_refstruct_unref(&dec->shared_ctx);
+ av_refstruct_unref(&dec->shared_ctx);
return err;
}
@@ -1073,7 +1073,7 @@ int ff_vk_decode_uninit(AVCodecContext *avctx)
av_freep(&dec->hevc_headers);
av_buffer_unref(&dec->session_params);
- ff_refstruct_unref(&dec->shared_ctx);
+ av_refstruct_unref(&dec->shared_ctx);
av_freep(&dec->slice_off);
return 0;
}
diff --git a/libavcodec/vulkan_h264.c b/libavcodec/vulkan_h264.c
index 05ac884138..79447dbb39 100644
--- a/libavcodec/vulkan_h264.c
+++ b/libavcodec/vulkan_h264.c
@@ -541,7 +541,7 @@ static int vk_h264_end_frame(AVCodecContext *avctx)
return ff_vk_decode_frame(avctx, pic->f, vp, rav, rvp);
}
-static void vk_h264_free_frame_priv(FFRefStructOpaque _hwctx, void *data)
+static void vk_h264_free_frame_priv(AVRefStructOpaque _hwctx, void *data)
{
AVHWDeviceContext *hwctx = _hwctx.nc;
H264VulkanDecodePicture *hp = data;
diff --git a/libavcodec/vulkan_hevc.c b/libavcodec/vulkan_hevc.c
index 0b20005687..e31e0fc8c5 100644
--- a/libavcodec/vulkan_hevc.c
+++ b/libavcodec/vulkan_hevc.c
@@ -897,7 +897,7 @@ static int vk_hevc_end_frame(AVCodecContext *avctx)
return ff_vk_decode_frame(avctx, pic->f, vp, rav, rvp);
}
-static void vk_hevc_free_frame_priv(FFRefStructOpaque _hwctx, void *data)
+static void vk_hevc_free_frame_priv(AVRefStructOpaque _hwctx, void *data)
{
AVHWDeviceContext *hwctx = _hwctx.nc;
HEVCVulkanDecodePicture *hp = data;
diff --git a/libavcodec/vvc/ctu.c b/libavcodec/vvc/ctu.c
index 3624337fd7..f80bce637c 100644
--- a/libavcodec/vvc/ctu.c
+++ b/libavcodec/vvc/ctu.c
@@ -20,7 +20,7 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
-#include "libavcodec/refstruct.h"
+#include "libavutil/refstruct.h"
#include "cabac.h"
#include "ctu.h"
@@ -209,7 +209,7 @@ static void set_qp_c(VVCLocalContext *lc)
static TransformUnit* alloc_tu(VVCFrameContext *fc, CodingUnit *cu)
{
- TransformUnit *tu = ff_refstruct_pool_get(fc->tu_pool);
+ TransformUnit *tu = av_refstruct_pool_get(fc->tu_pool);
if (!tu)
return NULL;
@@ -1184,7 +1184,7 @@ static CodingUnit* alloc_cu(VVCLocalContext *lc, const int x0, const int y0)
const int rx = x0 >> sps->ctb_log2_size_y;
const int ry = y0 >> sps->ctb_log2_size_y;
CodingUnit **cus = fc->tab.cus + ry * pps->ctb_width + rx;
- CodingUnit *cu = ff_refstruct_pool_get(fc->cu_pool);
+ CodingUnit *cu = av_refstruct_pool_get(fc->cu_pool);
if (!cu)
return NULL;
@@ -2550,11 +2550,11 @@ void ff_vvc_ctu_free_cus(CodingUnit **cus)
while (*head) {
TransformUnit *tu = *head;
*head = tu->next;
- ff_refstruct_unref(&tu);
+ av_refstruct_unref(&tu);
}
cu->tus.tail = NULL;
- ff_refstruct_unref(&cu);
+ av_refstruct_unref(&cu);
}
}
diff --git a/libavcodec/vvc/dec.c b/libavcodec/vvc/dec.c
index fef7339294..1cb168de7e 100644
--- a/libavcodec/vvc/dec.c
+++ b/libavcodec/vvc/dec.c
@@ -25,7 +25,7 @@
#include "libavcodec/hwaccel_internal.h"
#include "libavcodec/hwconfig.h"
#include "libavcodec/profiles.h"
-#include "libavcodec/refstruct.h"
+#include "libavutil/refstruct.h"
#include "libavutil/cpu.h"
#include "libavutil/mem.h"
#include "libavutil/thread.h"
@@ -352,8 +352,8 @@ static void pic_arrays_free(VVCFrameContext *fc)
{
free_cus(fc);
frame_context_for_each_tl(fc, tl_free);
- ff_refstruct_pool_uninit(&fc->rpl_tab_pool);
- ff_refstruct_pool_uninit(&fc->tab_dmvr_mvf_pool);
+ av_refstruct_pool_uninit(&fc->rpl_tab_pool);
+ av_refstruct_pool_uninit(&fc->tab_dmvr_mvf_pool);
memset(&fc->tab.sz, 0, sizeof(fc->tab.sz));
}
@@ -378,16 +378,16 @@ static int pic_arrays_init(VVCContext *s, VVCFrameContext *fc)
memset(fc->tab.slice_idx, -1, sizeof(*fc->tab.slice_idx) * ctu_count);
if (fc->tab.sz.ctu_count != ctu_count) {
- ff_refstruct_pool_uninit(&fc->rpl_tab_pool);
- fc->rpl_tab_pool = ff_refstruct_pool_alloc(ctu_count * sizeof(RefPicListTab), 0);
+ av_refstruct_pool_uninit(&fc->rpl_tab_pool);
+ fc->rpl_tab_pool = av_refstruct_pool_alloc(ctu_count * sizeof(RefPicListTab), 0);
if (!fc->rpl_tab_pool)
return AVERROR(ENOMEM);
}
if (fc->tab.sz.pic_size_in_min_pu != pic_size_in_min_pu) {
- ff_refstruct_pool_uninit(&fc->tab_dmvr_mvf_pool);
- fc->tab_dmvr_mvf_pool = ff_refstruct_pool_alloc(
- pic_size_in_min_pu * sizeof(MvField), FF_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME);
+ av_refstruct_pool_uninit(&fc->tab_dmvr_mvf_pool);
+ fc->tab_dmvr_mvf_pool = av_refstruct_pool_alloc(
+ pic_size_in_min_pu * sizeof(MvField), AV_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME);
if (!fc->tab_dmvr_mvf_pool)
return AVERROR(ENOMEM);
}
@@ -468,8 +468,8 @@ static void slices_free(VVCFrameContext *fc)
for (int i = 0; i < fc->nb_slices_allocated; i++) {
SliceContext *slice = fc->slices[i];
if (slice) {
- ff_refstruct_unref(&slice->ref);
- ff_refstruct_unref(&slice->sh.r);
+ av_refstruct_unref(&slice->ref);
+ av_refstruct_unref(&slice->sh.r);
eps_free(slice);
av_free(slice);
}
@@ -598,16 +598,16 @@ static int ref_frame(VVCFrame *dst, const VVCFrame *src)
if (ret < 0)
return ret;
- ff_refstruct_replace(&dst->sps, src->sps);
- ff_refstruct_replace(&dst->pps, src->pps);
+ av_refstruct_replace(&dst->sps, src->sps);
+ av_refstruct_replace(&dst->pps, src->pps);
- ff_refstruct_replace(&dst->progress, src->progress);
+ av_refstruct_replace(&dst->progress, src->progress);
- ff_refstruct_replace(&dst->tab_dmvr_mvf, src->tab_dmvr_mvf);
+ av_refstruct_replace(&dst->tab_dmvr_mvf, src->tab_dmvr_mvf);
- ff_refstruct_replace(&dst->rpl_tab, src->rpl_tab);
- ff_refstruct_replace(&dst->rpl, src->rpl);
- ff_refstruct_replace(&dst->hwaccel_picture_private,
+ av_refstruct_replace(&dst->rpl_tab, src->rpl_tab);
+ av_refstruct_replace(&dst->rpl, src->rpl);
+ av_refstruct_replace(&dst->hwaccel_picture_private,
src->hwaccel_picture_private);
dst->nb_rpl_elems = src->nb_rpl_elems;
@@ -628,8 +628,8 @@ static av_cold void frame_context_free(VVCFrameContext *fc)
{
slices_free(fc);
- ff_refstruct_pool_uninit(&fc->tu_pool);
- ff_refstruct_pool_uninit(&fc->cu_pool);
+ av_refstruct_pool_uninit(&fc->tu_pool);
+ av_refstruct_pool_uninit(&fc->cu_pool);
for (int i = 0; i < FF_ARRAY_ELEMS(fc->DPB); i++) {
ff_vvc_unref_frame(fc, &fc->DPB[i], ~0);
@@ -656,11 +656,11 @@ static av_cold int frame_context_init(VVCFrameContext *fc, AVCodecContext *avctx
if (!fc->DPB[j].frame)
return AVERROR(ENOMEM);
}
- fc->cu_pool = ff_refstruct_pool_alloc(sizeof(CodingUnit), 0);
+ fc->cu_pool = av_refstruct_pool_alloc(sizeof(CodingUnit), 0);
if (!fc->cu_pool)
return AVERROR(ENOMEM);
- fc->tu_pool = ff_refstruct_pool_alloc(sizeof(TransformUnit), 0);
+ fc->tu_pool = av_refstruct_pool_alloc(sizeof(TransformUnit), 0);
if (!fc->tu_pool)
return AVERROR(ENOMEM);
@@ -743,7 +743,7 @@ static int slice_start(SliceContext *sc, VVCContext *s, VVCFrameContext *fc,
if (ret < 0)
return ret;
- ff_refstruct_replace(&sc->ref, unit->content_ref);
+ av_refstruct_replace(&sc->ref, unit->content_ref);
if (is_first_slice) {
ret = frame_start(s, fc, sc);
diff --git a/libavcodec/vvc/dec.h b/libavcodec/vvc/dec.h
index 0f8f1f721d..382311e3be 100644
--- a/libavcodec/vvc/dec.h
+++ b/libavcodec/vvc/dec.h
@@ -138,11 +138,11 @@ typedef struct VVCFrameContext {
uint64_t decode_order;
- struct FFRefStructPool *tab_dmvr_mvf_pool;
- struct FFRefStructPool *rpl_tab_pool;
+ struct AVRefStructPool *tab_dmvr_mvf_pool;
+ struct AVRefStructPool *rpl_tab_pool;
- struct FFRefStructPool *cu_pool;
- struct FFRefStructPool *tu_pool;
+ struct AVRefStructPool *cu_pool;
+ struct AVRefStructPool *tu_pool;
struct {
int16_t *slice_idx;
diff --git a/libavcodec/vvc/ps.c b/libavcodec/vvc/ps.c
index 283a7440b7..a5cf1d74bd 100644
--- a/libavcodec/vvc/ps.c
+++ b/libavcodec/vvc/ps.c
@@ -24,7 +24,7 @@
#include "libavcodec/cbs_h266.h"
#include "libavutil/mem.h"
#include "libavutil/pixdesc.h"
-#include "libavcodec/refstruct.h"
+#include "libavutil/refstruct.h"
#include "data.h"
#include "ps.h"
#include "dec.h"
@@ -200,21 +200,21 @@ static int sps_derive(VVCSPS *sps, void *log_ctx)
return 0;
}
-static void sps_free(FFRefStructOpaque opaque, void *obj)
+static void sps_free(AVRefStructOpaque opaque, void *obj)
{
VVCSPS *sps = obj;
- ff_refstruct_unref(&sps->r);
+ av_refstruct_unref(&sps->r);
}
static const VVCSPS *sps_alloc(const H266RawSPS *rsps, void *log_ctx)
{
int ret;
- VVCSPS *sps = ff_refstruct_alloc_ext(sizeof(*sps), 0, NULL, sps_free);
+ VVCSPS *sps = av_refstruct_alloc_ext(sizeof(*sps), 0, NULL, sps_free);
if (!sps)
return NULL;
- ff_refstruct_replace(&sps->r, rsps);
+ av_refstruct_replace(&sps->r, rsps);
ret = sps_derive(sps, log_ctx);
if (ret < 0)
@@ -223,7 +223,7 @@ static const VVCSPS *sps_alloc(const H266RawSPS *rsps, void *log_ctx)
return sps;
fail:
- ff_refstruct_unref(&sps);
+ av_refstruct_unref(&sps);
return NULL;
}
@@ -248,7 +248,7 @@ static int decode_sps(VVCParamSets *ps, const H266RawSPS *rsps, void *log_ctx, i
if (!sps)
return AVERROR(ENOMEM);
- ff_refstruct_unref(&ps->sps_list[sps_id]);
+ av_refstruct_unref(&ps->sps_list[sps_id]);
ps->sps_list[sps_id] = sps;
ps->sps_id_used |= (1 << sps_id);
@@ -572,11 +572,11 @@ static int pps_derive(VVCPPS *pps, const VVCSPS *sps)
return 0;
}
-static void pps_free(FFRefStructOpaque opaque, void *obj)
+static void pps_free(AVRefStructOpaque opaque, void *obj)
{
VVCPPS *pps = obj;
- ff_refstruct_unref(&pps->r);
+ av_refstruct_unref(&pps->r);
av_freep(&pps->col_bd);
av_freep(&pps->row_bd);
@@ -588,12 +588,12 @@ static void pps_free(FFRefStructOpaque opaque, void *obj)
static const VVCPPS *pps_alloc(const H266RawPPS *rpps, const VVCSPS *sps)
{
int ret;
- VVCPPS *pps = ff_refstruct_alloc_ext(sizeof(*pps), 0, NULL, pps_free);
+ VVCPPS *pps = av_refstruct_alloc_ext(sizeof(*pps), 0, NULL, pps_free);
if (!pps)
return NULL;
- ff_refstruct_replace(&pps->r, rpps);
+ av_refstruct_replace(&pps->r, rpps);
ret = pps_derive(pps, sps);
if (ret < 0)
@@ -602,7 +602,7 @@ static const VVCPPS *pps_alloc(const H266RawPPS *rpps, const VVCSPS *sps)
return pps;
fail:
- ff_refstruct_unref(&pps);
+ av_refstruct_unref(&pps);
return NULL;
}
@@ -621,7 +621,7 @@ static int decode_pps(VVCParamSets *ps, const H266RawPPS *rpps)
if (!pps)
return AVERROR(ENOMEM);
- ff_refstruct_unref(&ps->pps_list[pps_id]);
+ av_refstruct_unref(&ps->pps_list[pps_id]);
ps->pps_list[pps_id] = pps;
return ret;
@@ -868,7 +868,7 @@ static int decode_ph(VVCFrameParamSets *fps, const H266RawPictureHeader *rph, vo
const H266RawPPS *pps = fps->pps->r;
ph->r = rph;
- ff_refstruct_replace(&ph->rref, rph_ref);
+ av_refstruct_replace(&ph->rref, rph_ref);
ret = ph_derive(ph, sps, pps, poc_tid0, is_clvss);
if (ret < 0)
return ret;
@@ -890,15 +890,15 @@ static int decode_frame_ps(VVCFrameParamSets *fps, const VVCParamSets *ps,
if (!rpps)
return AVERROR_INVALIDDATA;
- ff_refstruct_replace(&fps->sps, ps->sps_list[rpps->pps_seq_parameter_set_id]);
- ff_refstruct_replace(&fps->pps, ps->pps_list[rpps->pps_pic_parameter_set_id]);
+ av_refstruct_replace(&fps->sps, ps->sps_list[rpps->pps_seq_parameter_set_id]);
+ av_refstruct_replace(&fps->pps, ps->pps_list[rpps->pps_pic_parameter_set_id]);
ret = decode_ph(fps, ph, h266->ph_ref, poc_tid0, is_clvss);
if (ret < 0)
return ret;
if (ph->ph_explicit_scaling_list_enabled_flag)
- ff_refstruct_replace(&fps->sl, ps->scaling_list[ph->ph_scaling_list_aps_id]);
+ av_refstruct_replace(&fps->sl, ps->scaling_list[ph->ph_scaling_list_aps_id]);
if (ph->ph_lmcs_enabled_flag) {
ret = lmcs_derive_lut(&fps->lmcs, ps->lmcs_list[ph->ph_lmcs_aps_id], fps->sps->r);
@@ -907,7 +907,7 @@ static int decode_frame_ps(VVCFrameParamSets *fps, const VVCParamSets *ps,
}
for (int i = 0; i < FF_ARRAY_ELEMS(fps->alf_list); i++)
- ff_refstruct_replace(&fps->alf_list[i], ps->alf_list[i]);
+ av_refstruct_replace(&fps->alf_list[i], ps->alf_list[i]);
return 0;
}
@@ -951,26 +951,26 @@ int ff_vvc_decode_frame_ps(VVCFrameParamSets *fps, struct VVCContext *s)
void ff_vvc_frame_ps_free(VVCFrameParamSets *fps)
{
- ff_refstruct_unref(&fps->sps);
- ff_refstruct_unref(&fps->pps);
- ff_refstruct_unref(&fps->ph.rref);
- ff_refstruct_unref(&fps->sl);
+ av_refstruct_unref(&fps->sps);
+ av_refstruct_unref(&fps->pps);
+ av_refstruct_unref(&fps->ph.rref);
+ av_refstruct_unref(&fps->sl);
for (int i = 0; i < FF_ARRAY_ELEMS(fps->alf_list); i++)
- ff_refstruct_unref(&fps->alf_list[i]);
+ av_refstruct_unref(&fps->alf_list[i]);
}
void ff_vvc_ps_uninit(VVCParamSets *ps)
{
for (int i = 0; i < FF_ARRAY_ELEMS(ps->scaling_list); i++)
- ff_refstruct_unref(&ps->scaling_list[i]);
+ av_refstruct_unref(&ps->scaling_list[i]);
for (int i = 0; i < FF_ARRAY_ELEMS(ps->lmcs_list); i++)
- ff_refstruct_unref(&ps->lmcs_list[i]);
+ av_refstruct_unref(&ps->lmcs_list[i]);
for (int i = 0; i < FF_ARRAY_ELEMS(ps->alf_list); i++)
- ff_refstruct_unref(&ps->alf_list[i]);
+ av_refstruct_unref(&ps->alf_list[i]);
for (int i = 0; i < FF_ARRAY_ELEMS(ps->sps_list); i++)
- ff_refstruct_unref(&ps->sps_list[i]);
+ av_refstruct_unref(&ps->sps_list[i]);
for (int i = 0; i < FF_ARRAY_ELEMS(ps->pps_list); i++)
- ff_refstruct_unref(&ps->pps_list[i]);
+ av_refstruct_unref(&ps->pps_list[i]);
}
static void alf_coeff(int16_t *coeff,
@@ -1049,23 +1049,23 @@ static void alf_derive(VVCALF *alf, const H266RawAPS *aps)
alf_cc(alf, aps);
}
-static void alf_free(FFRefStructOpaque unused, void *obj)
+static void alf_free(AVRefStructOpaque unused, void *obj)
{
VVCALF *alf = obj;
- ff_refstruct_unref(&alf->r);
+ av_refstruct_unref(&alf->r);
}
static int aps_decode_alf(const VVCALF **alf, const H266RawAPS *aps)
{
- VVCALF *a = ff_refstruct_alloc_ext(sizeof(*a), 0, NULL, alf_free);
+ VVCALF *a = av_refstruct_alloc_ext(sizeof(*a), 0, NULL, alf_free);
if (!a)
return AVERROR(ENOMEM);
alf_derive(a, aps);
- ff_refstruct_replace(&a->r, aps);
- ff_refstruct_replace(alf, a);
- ff_refstruct_unref(&a);
+ av_refstruct_replace(&a->r, aps);
+ av_refstruct_replace(alf, a);
+ av_refstruct_unref(&a);
return 0;
}
@@ -1145,13 +1145,13 @@ static void scaling_derive(VVCScalingList *sl, const H266RawAPS *aps)
static int aps_decode_scaling(const VVCScalingList **scaling, const H266RawAPS *aps)
{
- VVCScalingList *sl = ff_refstruct_allocz(sizeof(*sl));
+ VVCScalingList *sl = av_refstruct_allocz(sizeof(*sl));
if (!sl)
return AVERROR(ENOMEM);
scaling_derive(sl, aps);
- ff_refstruct_replace(scaling, sl);
- ff_refstruct_unref(&sl);
+ av_refstruct_replace(scaling, sl);
+ av_refstruct_unref(&sl);
return 0;
}
@@ -1169,7 +1169,7 @@ int ff_vvc_decode_aps(VVCParamSets *ps, const CodedBitstreamUnit *unit)
ret = aps_decode_alf(&ps->alf_list[aps->aps_adaptation_parameter_set_id], aps);
break;
case VVC_ASP_TYPE_LMCS:
- ff_refstruct_replace(&ps->lmcs_list[aps->aps_adaptation_parameter_set_id], aps);
+ av_refstruct_replace(&ps->lmcs_list[aps->aps_adaptation_parameter_set_id], aps);
break;
case VVC_ASP_TYPE_SCALING:
ret = aps_decode_scaling(&ps->scaling_list[aps->aps_adaptation_parameter_set_id], aps);
@@ -1352,7 +1352,7 @@ int ff_vvc_decode_sh(VVCSH *sh, const VVCFrameParamSets *fps, const CodedBitstre
if (!fps->sps || !fps->pps)
return AVERROR_INVALIDDATA;
- ff_refstruct_replace(&sh->r, unit->content_ref);
+ av_refstruct_replace(&sh->r, unit->content_ref);
ret = sh_derive(sh, fps);
if (ret < 0)
diff --git a/libavcodec/vvc/refs.c b/libavcodec/vvc/refs.c
index 281410091e..bc3b3d0d13 100644
--- a/libavcodec/vvc/refs.c
+++ b/libavcodec/vvc/refs.c
@@ -24,7 +24,7 @@
#include "libavutil/mem.h"
#include "libavutil/thread.h"
-#include "libavcodec/refstruct.h"
+#include "libavutil/refstruct.h"
#include "libavcodec/thread.h"
#include "libavcodec/decode.h"
@@ -49,18 +49,18 @@ void ff_vvc_unref_frame(VVCFrameContext *fc, VVCFrame *frame, int flags)
frame->flags &= ~flags;
if (!frame->flags) {
av_frame_unref(frame->frame);
- ff_refstruct_unref(&frame->sps);
- ff_refstruct_unref(&frame->pps);
- ff_refstruct_unref(&frame->progress);
+ av_refstruct_unref(&frame->sps);
+ av_refstruct_unref(&frame->pps);
+ av_refstruct_unref(&frame->progress);
- ff_refstruct_unref(&frame->tab_dmvr_mvf);
+ av_refstruct_unref(&frame->tab_dmvr_mvf);
- ff_refstruct_unref(&frame->rpl);
+ av_refstruct_unref(&frame->rpl);
frame->nb_rpl_elems = 0;
- ff_refstruct_unref(&frame->rpl_tab);
+ av_refstruct_unref(&frame->rpl_tab);
frame->collocated_ref = NULL;
- ff_refstruct_unref(&frame->hwaccel_picture_private);
+ av_refstruct_unref(&frame->hwaccel_picture_private);
}
}
@@ -87,7 +87,7 @@ void ff_vvc_flush_dpb(VVCFrameContext *fc)
ff_vvc_unref_frame(fc, &fc->DPB[i], ~0);
}
-static void free_progress(FFRefStructOpaque unused, void *obj)
+static void free_progress(AVRefStructOpaque unused, void *obj)
{
FrameProgress *p = (FrameProgress *)obj;
@@ -99,13 +99,13 @@ static void free_progress(FFRefStructOpaque unused, void *obj)
static FrameProgress *alloc_progress(void)
{
- FrameProgress *p = ff_refstruct_alloc_ext(sizeof(*p), 0, NULL, free_progress);
+ FrameProgress *p = av_refstruct_alloc_ext(sizeof(*p), 0, NULL, free_progress);
if (p) {
p->has_lock = !ff_mutex_init(&p->lock, NULL);
p->has_cond = !ff_cond_init(&p->cond, NULL);
if (!p->has_lock || !p->has_cond)
- ff_refstruct_unref(&p);
+ av_refstruct_unref(&p);
}
return p;
}
@@ -121,23 +121,23 @@ static VVCFrame *alloc_frame(VVCContext *s, VVCFrameContext *fc)
if (frame->frame->buf[0])
continue;
- frame->sps = ff_refstruct_ref_c(fc->ps.sps);
- frame->pps = ff_refstruct_ref_c(fc->ps.pps);
+ frame->sps = av_refstruct_ref_c(fc->ps.sps);
+ frame->pps = av_refstruct_ref_c(fc->ps.pps);
ret = ff_thread_get_buffer(s->avctx, frame->frame, AV_GET_BUFFER_FLAG_REF);
if (ret < 0)
return NULL;
- frame->rpl = ff_refstruct_allocz(s->current_frame.nb_units * sizeof(RefPicListTab));
+ frame->rpl = av_refstruct_allocz(s->current_frame.nb_units * sizeof(RefPicListTab));
if (!frame->rpl)
goto fail;
frame->nb_rpl_elems = s->current_frame.nb_units;
- frame->tab_dmvr_mvf = ff_refstruct_pool_get(fc->tab_dmvr_mvf_pool);
+ frame->tab_dmvr_mvf = av_refstruct_pool_get(fc->tab_dmvr_mvf_pool);
if (!frame->tab_dmvr_mvf)
goto fail;
- frame->rpl_tab = ff_refstruct_pool_get(fc->rpl_tab_pool);
+ frame->rpl_tab = av_refstruct_pool_get(fc->rpl_tab_pool);
if (!frame->rpl_tab)
goto fail;
frame->ctb_count = pps->ctb_width * pps->ctb_height;
diff --git a/libavcodec/wavpack.c b/libavcodec/wavpack.c
index bf9aa0cdce..9c74967f74 100644
--- a/libavcodec/wavpack.c
+++ b/libavcodec/wavpack.c
@@ -28,7 +28,7 @@
#include "bytestream.h"
#include "codec_internal.h"
#include "get_bits.h"
-#include "refstruct.h"
+#include "libavutil/refstruct.h"
#include "thread.h"
#include "threadprogress.h"
#include "unary.h"
@@ -110,7 +110,7 @@ typedef struct WavpackContext {
DSDContext *dsdctx; ///< RefStruct reference
ThreadProgress *curr_progress, *prev_progress; ///< RefStruct references
- FFRefStructPool *progress_pool; ///< RefStruct reference
+ AVRefStructPool *progress_pool; ///< RefStruct reference
int dsd_channels;
} WavpackContext;
@@ -992,9 +992,9 @@ static int wv_dsd_reset(WavpackContext *s, int channels)
int i;
s->dsd_channels = 0;
- ff_refstruct_unref(&s->dsdctx);
- ff_refstruct_unref(&s->curr_progress);
- ff_refstruct_unref(&s->prev_progress);
+ av_refstruct_unref(&s->dsdctx);
+ av_refstruct_unref(&s->curr_progress);
+ av_refstruct_unref(&s->prev_progress);
if (!channels)
return 0;
@@ -1003,7 +1003,7 @@ static int wv_dsd_reset(WavpackContext *s, int channels)
channels > SIZE_MAX / sizeof(*s->dsdctx))
return AVERROR(EINVAL);
- s->dsdctx = ff_refstruct_allocz(channels * sizeof(*s->dsdctx));
+ s->dsdctx = av_refstruct_allocz(channels * sizeof(*s->dsdctx));
if (!s->dsdctx)
return AVERROR(ENOMEM);
s->dsd_channels = channels;
@@ -1022,26 +1022,26 @@ static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
WavpackContext *fsrc = src->priv_data;
WavpackContext *fdst = dst->priv_data;
- ff_refstruct_replace(&fdst->curr_progress, fsrc->curr_progress);
- ff_refstruct_replace(&fdst->dsdctx, fsrc->dsdctx);
+ av_refstruct_replace(&fdst->curr_progress, fsrc->curr_progress);
+ av_refstruct_replace(&fdst->dsdctx, fsrc->dsdctx);
fdst->dsd_channels = fsrc->dsd_channels;
return 0;
}
-static av_cold int progress_pool_init_cb(FFRefStructOpaque opaque, void *obj)
+static av_cold int progress_pool_init_cb(AVRefStructOpaque opaque, void *obj)
{
ThreadProgress *progress = obj;
return ff_thread_progress_init(progress, 1);
}
-static void progress_pool_reset_cb(FFRefStructOpaque opaque, void *obj)
+static void progress_pool_reset_cb(AVRefStructOpaque opaque, void *obj)
{
ThreadProgress *progress = obj;
ff_thread_progress_reset(progress);
}
-static av_cold void progress_pool_free_entry_cb(FFRefStructOpaque opaque, void *obj)
+static av_cold void progress_pool_free_entry_cb(AVRefStructOpaque opaque, void *obj)
{
ThreadProgress *progress = obj;
ff_thread_progress_destroy(progress);
@@ -1058,8 +1058,8 @@ static av_cold int wavpack_decode_init(AVCodecContext *avctx)
#if HAVE_THREADS
if (ff_thread_sync_ref(avctx, offsetof(WavpackContext, progress_pool)) == FF_THREAD_IS_FIRST_THREAD) {
- s->progress_pool = ff_refstruct_pool_alloc_ext(sizeof(*s->curr_progress),
- FF_REFSTRUCT_POOL_FLAG_FREE_ON_INIT_ERROR, NULL,
+ s->progress_pool = av_refstruct_pool_alloc_ext(sizeof(*s->curr_progress),
+ AV_REFSTRUCT_POOL_FLAG_FREE_ON_INIT_ERROR, NULL,
progress_pool_init_cb,
progress_pool_reset_cb,
progress_pool_free_entry_cb, NULL);
@@ -1080,7 +1080,7 @@ static av_cold int wavpack_decode_end(AVCodecContext *avctx)
av_freep(&s->fdec);
s->fdec_num = 0;
- ff_refstruct_pool_uninit(&s->progress_pool);
+ av_refstruct_pool_uninit(&s->progress_pool);
wv_dsd_reset(s, 0);
return 0;
@@ -1552,8 +1552,8 @@ static int wavpack_decode_block(AVCodecContext *avctx, AVFrame *frame, int block
av_assert1(!!wc->progress_pool == !!(avctx->active_thread_type & FF_THREAD_FRAME));
if (wc->progress_pool) {
if (wc->dsdctx) {
- ff_refstruct_unref(&wc->prev_progress);
- wc->prev_progress = ff_refstruct_pool_get(wc->progress_pool);
+ av_refstruct_unref(&wc->prev_progress);
+ wc->prev_progress = av_refstruct_pool_get(wc->progress_pool);
if (!wc->prev_progress)
return AVERROR(ENOMEM);
FFSWAP(ThreadProgress*, wc->prev_progress, wc->curr_progress);
diff --git a/libavutil/Makefile b/libavutil/Makefile
index 847878d7a4..ae1ad5199a 100644
--- a/libavutil/Makefile
+++ b/libavutil/Makefile
@@ -75,6 +75,7 @@ HEADERS = adler32.h \
random_seed.h \
rc4.h \
rational.h \
+ refstruct.h \
replaygain.h \
ripemd.h \
samplefmt.h \
@@ -163,6 +164,7 @@ OBJS = adler32.o \
pixelutils.o \
random_seed.o \
rational.o \
+ refstruct.o \
reverse.o \
rc4.o \
ripemd.o \
diff --git a/libavcodec/refstruct.c b/libavutil/refstruct.c
similarity index 74%
rename from libavcodec/refstruct.c
rename to libavutil/refstruct.c
index f89af156c2..ce804f781a 100644
--- a/libavcodec/refstruct.c
+++ b/libavutil/refstruct.c
@@ -22,12 +22,12 @@
#include "refstruct.h"
-#include "libavutil/avassert.h"
-#include "libavutil/error.h"
-#include "libavutil/macros.h"
-#include "libavutil/mem.h"
-#include "libavutil/mem_internal.h"
-#include "libavutil/thread.h"
+#include "avassert.h"
+#include "error.h"
+#include "macros.h"
+#include "mem.h"
+#include "mem_internal.h"
+#include "thread.h"
#ifndef REFSTRUCT_CHECKED
#ifndef ASSERT_LEVEL
@@ -58,8 +58,8 @@ typedef struct RefCount {
* the user does not throw away references.
*/
atomic_uintptr_t refcount;
- FFRefStructOpaque opaque;
- void (*free_cb)(FFRefStructOpaque opaque, void *obj);
+ AVRefStructOpaque opaque;
+ void (*free_cb)(AVRefStructOpaque opaque, void *obj);
void (*free)(void *ref);
#if REFSTRUCT_CHECKED
@@ -86,8 +86,8 @@ 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))
+static void refcount_init(RefCount *ref, AVRefStructOpaque opaque,
+ void (*free_cb)(AVRefStructOpaque opaque, void *obj))
{
atomic_init(&ref->refcount, 1);
ref->opaque = opaque;
@@ -99,8 +99,8 @@ static void refcount_init(RefCount *ref, FFRefStructOpaque opaque,
#endif
}
-void *ff_refstruct_alloc_ext_c(size_t size, unsigned flags, FFRefStructOpaque opaque,
- void (*free_cb)(FFRefStructOpaque opaque, void *obj))
+void *av_refstruct_alloc_ext_c(size_t size, unsigned flags, AVRefStructOpaque opaque,
+ void (*free_cb)(AVRefStructOpaque opaque, void *obj))
{
void *buf, *obj;
@@ -111,13 +111,13 @@ void *ff_refstruct_alloc_ext_c(size_t size, unsigned flags, FFRefStructOpaque op
return NULL;
refcount_init(buf, opaque, free_cb);
obj = get_userdata(buf);
- if (!(flags & FF_REFSTRUCT_FLAG_NO_ZEROING))
+ if (!(flags & AV_REFSTRUCT_FLAG_NO_ZEROING))
memset(obj, 0, size);
return obj;
}
-void ff_refstruct_unref(void *objp)
+void av_refstruct_unref(void *objp)
{
void *obj;
RefCount *ref;
@@ -137,7 +137,7 @@ void ff_refstruct_unref(void *objp)
return;
}
-void *ff_refstruct_ref(void *obj)
+void *av_refstruct_ref(void *obj)
{
RefCount *ref = get_refcount(obj);
@@ -146,7 +146,7 @@ void *ff_refstruct_ref(void *obj)
return obj;
}
-const void *ff_refstruct_ref_c(const void *obj)
+const void *av_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. */
@@ -157,21 +157,21 @@ const void *ff_refstruct_ref_c(const void *obj)
return obj;
}
-void ff_refstruct_replace(void *dstp, const void *src)
+void av_refstruct_replace(void *dstp, const void *src)
{
const void *dst;
memcpy(&dst, dstp, sizeof(dst));
if (src == dst)
return;
- ff_refstruct_unref(dstp);
+ av_refstruct_unref(dstp);
if (src) {
- dst = ff_refstruct_ref_c(src);
+ dst = av_refstruct_ref_c(src);
memcpy(dstp, &dst, sizeof(dst));
}
}
-int ff_refstruct_exclusive(const void *obj)
+int av_refstruct_exclusive(const void *obj)
{
const RefCount *ref = cget_refcount(obj);
/* Casting const away here is safe, because it is a load.
@@ -180,13 +180,13 @@ int ff_refstruct_exclusive(const void *obj)
return atomic_load_explicit((atomic_uintptr_t*)&ref->refcount, memory_order_acquire) == 1;
}
-struct FFRefStructPool {
+struct AVRefStructPool {
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);
+ AVRefStructOpaque opaque;
+ int (*init_cb)(AVRefStructOpaque opaque, void *obj);
+ void (*reset_cb)(AVRefStructOpaque opaque, void *obj);
+ void (*free_entry_cb)(AVRefStructOpaque opaque, void *obj);
+ void (*free_cb)(AVRefStructOpaque opaque);
int uninited;
unsigned entry_flags;
@@ -199,13 +199,13 @@ struct FFRefStructPool {
* 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.
+ * to the corresponding AVRefStructPool.
*/
RefCount *available_entries;
AVMutex mutex;
};
-static void pool_free(FFRefStructPool *pool)
+static void pool_free(AVRefStructPool *pool)
{
ff_mutex_destroy(&pool->mutex);
if (pool->free_cb)
@@ -213,7 +213,7 @@ static void pool_free(FFRefStructPool *pool)
av_free(get_refcount(pool));
}
-static void pool_free_entry(FFRefStructPool *pool, RefCount *ref)
+static void pool_free_entry(AVRefStructPool *pool, RefCount *ref)
{
if (pool->free_entry_cb)
pool->free_entry_cb(pool->opaque, get_userdata(ref));
@@ -223,7 +223,7 @@ static void pool_free_entry(FFRefStructPool *pool, RefCount *ref)
static void pool_return_entry(void *ref_)
{
RefCount *ref = ref_;
- FFRefStructPool *pool = ref->opaque.nc;
+ AVRefStructPool *pool = ref->opaque.nc;
ff_mutex_lock(&pool->mutex);
if (!pool->uninited) {
@@ -240,14 +240,14 @@ static void pool_return_entry(void *ref_)
pool_free(pool);
}
-static void pool_reset_entry(FFRefStructOpaque opaque, void *entry)
+static void pool_reset_entry(AVRefStructOpaque opaque, void *entry)
{
- FFRefStructPool *pool = opaque.nc;
+ AVRefStructPool *pool = opaque.nc;
pool->reset_cb(pool->opaque, entry);
}
-static int refstruct_pool_get_ext(void *datap, FFRefStructPool *pool)
+static int refstruct_pool_get_ext(void *datap, AVRefStructPool *pool)
{
void *ret = NULL;
@@ -266,7 +266,7 @@ 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,
+ ret = av_refstruct_alloc_ext(pool->size, pool->entry_flags, pool,
pool->reset_cb ? pool_reset_entry : NULL);
if (!ret)
return AVERROR(ENOMEM);
@@ -275,9 +275,9 @@ static int refstruct_pool_get_ext(void *datap, FFRefStructPool *pool)
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)
+ if (pool->pool_flags & AV_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)
+ if (pool->pool_flags & AV_REFSTRUCT_POOL_FLAG_FREE_ON_INIT_ERROR)
pool->free_entry_cb(pool->opaque, ret);
av_free(ref);
return err;
@@ -286,7 +286,7 @@ static int refstruct_pool_get_ext(void *datap, FFRefStructPool *pool)
}
atomic_fetch_add_explicit(&pool->refcount, 1, memory_order_relaxed);
- if (pool->pool_flags & FF_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME)
+ if (pool->pool_flags & AV_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME)
memset(ret, 0, pool->size);
memcpy(datap, &ret, sizeof(ret));
@@ -294,7 +294,7 @@ static int refstruct_pool_get_ext(void *datap, FFRefStructPool *pool)
return 0;
}
-void *ff_refstruct_pool_get(FFRefStructPool *pool)
+void *av_refstruct_pool_get(AVRefStructPool *pool)
{
void *ret;
refstruct_pool_get_ext(&ret, pool);
@@ -308,14 +308,14 @@ void *ff_refstruct_pool_get(FFRefStructPool *pool)
*/
static void pool_unref(void *ref)
{
- FFRefStructPool *pool = get_userdata(ref);
+ AVRefStructPool *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)
+static void refstruct_pool_uninit(AVRefStructOpaque unused, void *obj)
{
- FFRefStructPool *pool = obj;
+ AVRefStructPool *pool = obj;
RefCount *entry;
ff_mutex_lock(&pool->mutex);
@@ -332,19 +332,19 @@ static void refstruct_pool_uninit(FFRefStructOpaque unused, void *obj)
}
}
-FFRefStructPool *ff_refstruct_pool_alloc(size_t size, unsigned flags)
+AVRefStructPool *av_refstruct_pool_alloc(size_t size, unsigned flags)
{
- return ff_refstruct_pool_alloc_ext(size, flags, NULL, NULL, NULL, NULL, NULL);
+ return av_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))
+AVRefStructPool *av_refstruct_pool_alloc_ext_c(size_t size, unsigned flags,
+ AVRefStructOpaque opaque,
+ int (*init_cb)(AVRefStructOpaque opaque, void *obj),
+ void (*reset_cb)(AVRefStructOpaque opaque, void *obj),
+ void (*free_entry_cb)(AVRefStructOpaque opaque, void *obj),
+ void (*free_cb)(AVRefStructOpaque opaque))
{
- FFRefStructPool *pool = ff_refstruct_alloc_ext(sizeof(*pool), 0, NULL,
+ AVRefStructPool *pool = av_refstruct_alloc_ext(sizeof(*pool), 0, NULL,
refstruct_pool_uninit);
int err;
@@ -358,26 +358,26 @@ 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 AV_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;
+ flags &= ~AV_REFSTRUCT_POOL_FLAG_RESET_ON_INIT_ERROR;
if (!pool->free_entry_cb)
- flags &= ~FF_REFSTRUCT_POOL_FLAG_FREE_ON_INIT_ERROR;
+ flags &= ~AV_REFSTRUCT_POOL_FLAG_FREE_ON_INIT_ERROR;
pool->pool_flags = flags;
- if (flags & FF_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME) {
+ if (flags & AV_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;
+ pool->entry_flags |= AV_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
+ // Don't call av_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;
diff --git a/libavcodec/refstruct.h b/libavutil/refstruct.h
similarity index 71%
rename from libavcodec/refstruct.h
rename to libavutil/refstruct.h
index c64ad62b6b..644d888284 100644
--- a/libavcodec/refstruct.h
+++ b/libavutil/refstruct.h
@@ -16,8 +16,8 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
-#ifndef AVCODEC_REFSTRUCT_H
-#define AVCODEC_REFSTRUCT_H
+#ifndef AVUTIL_REFSTRUCT_H
+#define AVUTIL_REFSTRUCT_H
#include <stddef.h>
@@ -51,20 +51,20 @@
* This union is used for all opaque parameters in this API to spare the user
* to cast const away in case the opaque to use is const-qualified.
*
- * The functions provided by this API with an FFRefStructOpaque come in pairs
+ * The functions provided by this API with an AVRefStructOpaque 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".
*/
typedef union {
void *nc;
const void *c;
-} FFRefStructOpaque;
+} AVRefStructOpaque;
/**
- * If this flag is set in ff_refstruct_alloc_ext_c(), the object will not
+ * If this flag is set in av_refstruct_alloc_ext_c(), the object will not
* be initially zeroed.
*/
-#define FF_REFSTRUCT_FLAG_NO_ZEROING (1 << 0)
+#define AV_REFSTRUCT_FLAG_NO_ZEROING (1 << 0)
/**
* Allocate a refcounted object of usable size `size` managed via
@@ -74,37 +74,37 @@ typedef union {
* the returned object is initially zeroed.
*
* @param size Desired usable size of the returned object.
- * @param flags A bitwise combination of FF_REFSTRUCT_FLAG_* flags.
+ * @param flags A bitwise combination of av_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
* when its reference count reaches zero;
* it must not free the object itself.
* @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));
+void *av_refstruct_alloc_ext_c(size_t size, unsigned flags, AVRefStructOpaque opaque,
+ void (*free_cb)(AVRefStructOpaque opaque, void *obj));
/**
- * A wrapper around ff_refstruct_alloc_ext_c() for the common case
+ * A wrapper around av_refstruct_alloc_ext_c() for the common case
* of a non-const qualified opaque.
*
- * @see ff_refstruct_alloc_ext_c()
+ * @see av_refstruct_alloc_ext_c()
*/
static inline
-void *ff_refstruct_alloc_ext(size_t size, unsigned flags, void *opaque,
- void (*free_cb)(FFRefStructOpaque opaque, void *obj))
+void *av_refstruct_alloc_ext(size_t size, unsigned flags, void *opaque,
+ void (*free_cb)(AVRefStructOpaque opaque, void *obj))
{
- return ff_refstruct_alloc_ext_c(size, flags, (FFRefStructOpaque){.nc = opaque},
+ return av_refstruct_alloc_ext_c(size, flags, (AVRefStructOpaque){.nc = opaque},
free_cb);
}
/**
- * Equivalent to ff_refstruct_alloc_ext(size, 0, NULL, NULL)
+ * Equivalent to av_refstruct_alloc_ext(size, 0, NULL, NULL)
*/
static inline
-void *ff_refstruct_allocz(size_t size)
+void *av_refstruct_allocz(size_t size)
{
- return ff_refstruct_alloc_ext(size, 0, NULL, NULL);
+ return av_refstruct_alloc_ext(size, 0, NULL, NULL);
}
/**
@@ -116,7 +116,7 @@ void *ff_refstruct_allocz(size_t size)
* @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(void *objp);
+void av_refstruct_unref(void *objp);
/**
* Create a new reference to an object managed via this API,
@@ -124,13 +124,13 @@ void ff_refstruct_unref(void *objp);
* and return obj.
* @return a pointer equal to obj.
*/
-void *ff_refstruct_ref(void *obj);
+void *av_refstruct_ref(void *obj);
/**
- * Analog of ff_refstruct_ref(), but for constant objects.
- * @see ff_refstruct_ref()
+ * Analog of av_refstruct_ref(), but for constant objects.
+ * @see av_refstruct_ref()
*/
-const void *ff_refstruct_ref_c(const void *obj);
+const void *av_refstruct_ref_c(const void *obj);
/**
* Ensure `*dstp` refers to the same object as src.
@@ -144,7 +144,7 @@ const void *ff_refstruct_ref_c(const void *obj);
* managed via this API.
* @param src A pointer to an object managed via this API or NULL.
*/
-void ff_refstruct_replace(void *dstp, const void *src);
+void av_refstruct_replace(void *dstp, const void *src);
/**
* Check whether the reference count of an object managed
@@ -153,10 +153,10 @@ void ff_refstruct_replace(void *dstp, const void *src);
* @param obj A pointer to an object managed via this API.
* @return 1 if the reference count of obj is 1; 0 otherwise.
*/
-int ff_refstruct_exclusive(const void *obj);
+int av_refstruct_exclusive(const void *obj);
/**
- * FFRefStructPool is an API for a thread-safe pool of objects managed
+ * AVRefStructPool is an API for a thread-safe pool of objects managed
* via the RefStruct API.
*
* Frequently allocating and freeing large or complicated objects may be slow
@@ -164,16 +164,16 @@ int ff_refstruct_exclusive(const void *obj);
* needs a set of interchangable objects.
*
* At the beginning, the user must call allocate the pool via
- * ff_refstruct_pool_alloc() or its analogue ff_refstruct_pool_alloc_ext().
- * Then whenever an object is needed, call ff_refstruct_pool_get() to
+ * av_refstruct_pool_alloc() or its analogue av_refstruct_pool_alloc_ext().
+ * Then whenever an object is needed, call av_refstruct_pool_get() to
* get a new or reused object from the pool. This new object works in all
- * aspects the same way as the ones created by ff_refstruct_alloc_ext().
+ * aspects the same way as the ones created by av_refstruct_alloc_ext().
* However, when the last reference to this object is unreferenced, it is
* (optionally) reset and returned to the pool instead of being freed and
- * will be reused for subsequent ff_refstruct_pool_get() calls.
+ * will be reused for subsequent av_refstruct_pool_get() calls.
*
* When the caller is done with the pool and no longer needs to create any new
- * objects, ff_refstruct_pool_uninit() must be called to mark the pool as
+ * objects, av_refstruct_pool_uninit() must be called to mark the pool as
* freeable. Then entries returned to the pool will then be freed.
* Once all the entries are freed, the pool will automatically be freed.
*
@@ -184,56 +184,56 @@ int ff_refstruct_exclusive(const void *obj);
/**
* The buffer pool. This structure is opaque and not meant to be accessed
* directly. It is allocated with the allocators below and freed with
- * ff_refstruct_pool_uninit().
+ * av_refstruct_pool_uninit().
*/
-typedef struct FFRefStructPool FFRefStructPool;
+typedef struct AVRefStructPool AVRefStructPool;
/**
* If this flag is not set, every object in the pool will be zeroed before
* the init callback is called or before it is turned over to the user
* for the first time if no init callback has been provided.
*/
-#define FF_REFSTRUCT_POOL_FLAG_NO_ZEROING FF_REFSTRUCT_FLAG_NO_ZEROING
+#define AV_REFSTRUCT_POOL_FLAG_NO_ZEROING AV_REFSTRUCT_FLAG_NO_ZEROING
/**
* If this flag is set and both init_cb and reset_cb callbacks are provided,
* then reset_cb will be called if init_cb fails.
* The object passed to reset_cb will be in the state left by init_cb.
*/
-#define FF_REFSTRUCT_POOL_FLAG_RESET_ON_INIT_ERROR (1 << 16)
+#define AV_REFSTRUCT_POOL_FLAG_RESET_ON_INIT_ERROR (1 << 16)
/**
* If this flag is set and both init_cb and free_entry_cb callbacks are
* provided, then free_cb will be called if init_cb fails.
*
* It will be called after reset_cb in case reset_cb and the
- * FF_REFSTRUCT_POOL_FLAG_RESET_ON_INIT_ERROR flag are also set.
+ * av_refstruct_POOL_FLAG_RESET_ON_INIT_ERROR flag are also set.
*
* The object passed to free_cb will be in the state left by
* the callbacks applied earlier (init_cb potentially followed by reset_cb).
*/
-#define FF_REFSTRUCT_POOL_FLAG_FREE_ON_INIT_ERROR (1 << 17)
+#define AV_REFSTRUCT_POOL_FLAG_FREE_ON_INIT_ERROR (1 << 17)
/**
* If this flag is set, the entries will be zeroed before
* being returned to the user (after the init or reset callbacks
* have been called (if provided)). Furthermore, to avoid zeroing twice
- * it also makes the pool behave as if the FF_REFSTRUCT_POOL_FLAG_NO_ZEROING
+ * it also makes the pool behave as if the av_refstruct_POOL_FLAG_NO_ZEROING
* flag had been provided.
*/
-#define FF_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME (1 << 18)
+#define AV_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME (1 << 18)
/**
- * Equivalent to ff_refstruct_pool_alloc(size, flags, NULL, NULL, NULL, NULL, NULL)
+ * Equivalent to av_refstruct_pool_alloc(size, flags, NULL, NULL, NULL, NULL, NULL)
*/
-FFRefStructPool *ff_refstruct_pool_alloc(size_t size, unsigned flags);
+AVRefStructPool *av_refstruct_pool_alloc(size_t size, unsigned flags);
/**
- * Allocate an FFRefStructPool, potentially using complex callbacks.
+ * Allocate an AVRefStructPool, potentially using complex callbacks.
*
* @param size size of the entries of the pool
- * @param flags a bitwise combination of FF_REFSTRUCT_POOL_FLAG_* flags
+ * @param flags a bitwise combination of av_refstruct_POOL_FLAG_* flags
* @param opaque A pointer that will be passed to the callbacks below.
* @param init A callback that will be called directly after a new entry
* has been allocated. obj has already been zeroed unless
- * the FF_REFSTRUCT_POOL_FLAG_NO_ZEROING flag is in use.
+ * the av_refstruct_POOL_FLAG_NO_ZEROING flag is in use.
* @param reset A callback that will be called after an entry has been
* returned to the pool and before it is reused.
* @param free_entry A callback that will be called when an entry is freed
@@ -241,28 +241,28 @@ FFRefStructPool *ff_refstruct_pool_alloc(size_t size, unsigned flags);
* @param free A callback that will be called when the pool itself is
* freed (after the last entry has been returned and freed).
*/
-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));
+AVRefStructPool *av_refstruct_pool_alloc_ext_c(size_t size, unsigned flags,
+ AVRefStructOpaque opaque,
+ int (*init_cb)(AVRefStructOpaque opaque, void *obj),
+ void (*reset_cb)(AVRefStructOpaque opaque, void *obj),
+ void (*free_entry_cb)(AVRefStructOpaque opaque, void *obj),
+ void (*free_cb)(AVRefStructOpaque opaque));
/**
- * A wrapper around ff_refstruct_pool_alloc_ext_c() for the common case
+ * A wrapper around av_refstruct_pool_alloc_ext_c() for the common case
* of a non-const qualified opaque.
*
- * @see ff_refstruct_pool_alloc_ext_c()
+ * @see av_refstruct_pool_alloc_ext_c()
*/
static inline
-FFRefStructPool *ff_refstruct_pool_alloc_ext(size_t size, unsigned flags,
+AVRefStructPool *av_refstruct_pool_alloc_ext(size_t size, unsigned flags,
void *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 (*init_cb)(AVRefStructOpaque opaque, void *obj),
+ void (*reset_cb)(AVRefStructOpaque opaque, void *obj),
+ void (*free_entry_cb)(AVRefStructOpaque opaque, void *obj),
+ void (*free_cb)(AVRefStructOpaque opaque))
{
- return ff_refstruct_pool_alloc_ext_c(size, flags, (FFRefStructOpaque){.nc = opaque},
+ return av_refstruct_pool_alloc_ext_c(size, flags, (AVRefStructOpaque){.nc = opaque},
init_cb, reset_cb, free_entry_cb, free_cb);
}
@@ -270,13 +270,13 @@ FFRefStructPool *ff_refstruct_pool_alloc_ext(size_t size, unsigned flags,
* Get an object from the pool, reusing an old one from the pool when
* available.
*
- * Every call to this function must happen before ff_refstruct_pool_uninit().
+ * Every call to this function must happen before av_refstruct_pool_uninit().
* Otherwise undefined behaviour may occur.
*
* @param pool the pool from which to get the object
* @return a reference to the object on success, NULL on error.
*/
-void *ff_refstruct_pool_get(FFRefStructPool *pool);
+void *av_refstruct_pool_get(AVRefStructPool *pool);
/**
* Mark the pool as being available for freeing. It will actually be freed
@@ -289,9 +289,9 @@ void *ff_refstruct_pool_get(FFRefStructPool *pool);
* @param poolp pointer to a pointer to either NULL or a pool to be freed.
* `*poolp` will be set to NULL.
*/
-static inline void ff_refstruct_pool_uninit(FFRefStructPool **poolp)
+static inline void av_refstruct_pool_uninit(AVRefStructPool **poolp)
{
- ff_refstruct_unref(poolp);
+ av_refstruct_unref(poolp);
}
-#endif /* AVCODEC_REFSTRUCT_H */
+#endif /* AVUTIL_REFSTRUCT_H */
diff --git a/libavutil/version.h b/libavutil/version.h
index e8c50ea4b2..e515a95378 100644
--- a/libavutil/version.h
+++ b/libavutil/version.h
@@ -79,7 +79,7 @@
*/
#define LIBAVUTIL_VERSION_MAJOR 59
-#define LIBAVUTIL_VERSION_MINOR 50
+#define LIBAVUTIL_VERSION_MINOR 51
#define LIBAVUTIL_VERSION_MICRO 100
#define LIBAVUTIL_VERSION_INT AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
More information about the ffmpeg-cvslog
mailing list