mirror of
https://github.com/nyanmisaka/mpp.git
synced 2026-01-24 01:20:40 +01:00
2771f34e76
Add dup function for mpp_frame and mpp_meta. NOTE: The buffer in MppFrame is not dup. Signed-off-by: Herman Chen <herman.chen@rock-chips.com> Change-Id: I4965bc6016c8ffca4b72bbd49e2653eab06c7591
716 lines
21 KiB
C
716 lines
21 KiB
C
/* SPDX-License-Identifier: Apache-2.0 OR MIT */
|
|
/*
|
|
* Copyright (c) 2015 Rockchip Electronics Co., Ltd.
|
|
*/
|
|
|
|
#define MODULE_TAG "mpp_meta"
|
|
|
|
#include <string.h>
|
|
#include <endian.h>
|
|
|
|
#include "mpp_env.h"
|
|
#include "mpp_lock.h"
|
|
#include "mpp_debug.h"
|
|
#include "mpp_mem_pool.h"
|
|
#include "mpp_singleton.h"
|
|
|
|
#include "mpp_trie.h"
|
|
#include "mpp_meta_impl.h"
|
|
|
|
#define META_DBG_FLOW (0x00000001)
|
|
#define META_DBG_KEYS (0x00000002)
|
|
|
|
#define meta_dbg(flag, fmt, ...) _mpp_dbg(mpp_meta_debug, flag, fmt, ## __VA_ARGS__)
|
|
#define meta_dbg_f(flag, fmt, ...) _mpp_dbg_f(mpp_meta_debug, flag, fmt, ## __VA_ARGS__)
|
|
|
|
#define meta_dbg_flow(fmt, ...) meta_dbg(META_DBG_FLOW, fmt, ## __VA_ARGS__)
|
|
|
|
#define META_VAL_INVALID (0x00000000)
|
|
#define META_VAL_VALID (0x00000001)
|
|
#define META_VAL_READY (0x00000002)
|
|
|
|
#define WRITE_ONCE(x, val) ((*(volatile typeof(x) *) &(x)) = (val))
|
|
#define READ_ONCE(var) (*((volatile typeof(var) *)(&(var))))
|
|
|
|
#define get_srv_meta(caller) \
|
|
({ \
|
|
MppMetaSrv *__tmp; \
|
|
if (srv_meta || srv_finalized) { \
|
|
__tmp = srv_meta; \
|
|
} else { \
|
|
mpp_meta_srv_init(); \
|
|
__tmp = srv_meta; \
|
|
if (!__tmp) { \
|
|
mpp_err("mpp meta srv not init at %s : %s\n", __FUNCTION__, caller); \
|
|
} \
|
|
} \
|
|
__tmp; \
|
|
})
|
|
|
|
#define get_srv_meta_f() \
|
|
({ \
|
|
MppMetaSrv *__tmp; \
|
|
if (srv_meta || srv_finalized) { \
|
|
__tmp = srv_meta; \
|
|
} else { \
|
|
mpp_meta_srv_init(); \
|
|
__tmp = srv_meta; \
|
|
if (!__tmp) { \
|
|
mpp_err("mpp meta srv not init at %s\n", __FUNCTION__); \
|
|
} \
|
|
} \
|
|
__tmp; \
|
|
})
|
|
|
|
typedef enum MppMetaDataType_e {
|
|
/* mpp meta data of normal data type */
|
|
TYPE_VAL_32 = '3',
|
|
TYPE_VAL_64 = '6',
|
|
TYPE_KPTR = 'k',
|
|
TYPE_UPTR = 'u',
|
|
TYPE_SPTR = 's',
|
|
} MppMetaType;
|
|
|
|
static inline RK_U64 META_KEY_TO_U64(RK_U32 key, RK_U32 type)
|
|
{
|
|
return (RK_U64)((RK_U32)htobe32(key)) | ((RK_U64)type << 32);
|
|
}
|
|
|
|
#define EXPAND_AS_TRIE(key, type) \
|
|
do { \
|
|
RK_U64 val = META_KEY_TO_U64(key, type); \
|
|
mpp_trie_add_info(srv->trie, (const char *)&val, NULL, 0); \
|
|
meta_key_count++; \
|
|
} while (0);
|
|
|
|
#define EXPAND_AS_LOG(key, type) \
|
|
do { \
|
|
RK_U32 key_val = htobe32(key); \
|
|
char *str = (char *)&key_val; \
|
|
mpp_logi("%2d - %-24s (%c%c%c%c) : %-12s\n", \
|
|
i++, #key, str[0], str[1], str[2], str[3], #type); \
|
|
} while (0);
|
|
|
|
#define META_ENTRY_TABLE(ENTRY) \
|
|
/* categorized by type */ \
|
|
/* data flow type */ \
|
|
ENTRY(KEY_INPUT_FRAME, TYPE_SPTR) \
|
|
ENTRY(KEY_OUTPUT_FRAME, TYPE_SPTR) \
|
|
ENTRY(KEY_INPUT_PACKET, TYPE_SPTR) \
|
|
ENTRY(KEY_OUTPUT_PACKET, TYPE_SPTR) \
|
|
/* buffer for motion detection */ \
|
|
ENTRY(KEY_MOTION_INFO, TYPE_SPTR) \
|
|
/* buffer storing the HDR information for current frame*/ \
|
|
ENTRY(KEY_HDR_INFO, TYPE_SPTR) \
|
|
/* the offset of HDR meta data in frame buffer */ \
|
|
ENTRY(KEY_HDR_META_OFFSET, TYPE_VAL_32) \
|
|
ENTRY(KEY_HDR_META_SIZE, TYPE_VAL_32) \
|
|
\
|
|
ENTRY(KEY_OUTPUT_INTRA, TYPE_VAL_32) \
|
|
ENTRY(KEY_INPUT_BLOCK, TYPE_VAL_32) \
|
|
ENTRY(KEY_OUTPUT_BLOCK, TYPE_VAL_32) \
|
|
ENTRY(KEY_INPUT_IDR_REQ, TYPE_VAL_32) \
|
|
\
|
|
/* extra information for tsvc */ \
|
|
ENTRY(KEY_TEMPORAL_ID, TYPE_VAL_32) \
|
|
ENTRY(KEY_LONG_REF_IDX, TYPE_VAL_32) \
|
|
ENTRY(KEY_ENC_AVERAGE_QP, TYPE_VAL_32) \
|
|
ENTRY(KEY_ENC_START_QP, TYPE_VAL_32) \
|
|
ENTRY(KEY_ENC_BPS_RT, TYPE_VAL_32) \
|
|
\
|
|
ENTRY(KEY_ROI_DATA, TYPE_UPTR) \
|
|
ENTRY(KEY_ROI_DATA2, TYPE_UPTR) \
|
|
ENTRY(KEY_JPEG_ROI_DATA, TYPE_UPTR) \
|
|
ENTRY(KEY_OSD_DATA, TYPE_UPTR) \
|
|
ENTRY(KEY_OSD_DATA2, TYPE_UPTR) \
|
|
ENTRY(KEY_OSD_DATA3, TYPE_UPTR) \
|
|
ENTRY(KEY_USER_DATA, TYPE_UPTR) \
|
|
ENTRY(KEY_USER_DATAS, TYPE_UPTR) \
|
|
ENTRY(KEY_QPMAP0, TYPE_SPTR) \
|
|
/* buffer for super encode v3 */ \
|
|
ENTRY(KEY_NPU_SOBJ_FLAG, TYPE_SPTR) \
|
|
ENTRY(KEY_NPU_UOBJ_FLAG, TYPE_UPTR) \
|
|
ENTRY(KEY_BUFFER_UPSCALE, TYPE_SPTR) \
|
|
ENTRY(KEY_BUFFER_DOWNSCALE, TYPE_SPTR) \
|
|
\
|
|
ENTRY(KEY_LVL64_INTER_NUM, TYPE_VAL_32) \
|
|
ENTRY(KEY_LVL32_INTER_NUM, TYPE_VAL_32) \
|
|
ENTRY(KEY_LVL16_INTER_NUM, TYPE_VAL_32) \
|
|
ENTRY(KEY_LVL8_INTER_NUM, TYPE_VAL_32) \
|
|
ENTRY(KEY_LVL32_INTRA_NUM, TYPE_VAL_32) \
|
|
ENTRY(KEY_LVL16_INTRA_NUM, TYPE_VAL_32) \
|
|
ENTRY(KEY_LVL8_INTRA_NUM, TYPE_VAL_32) \
|
|
ENTRY(KEY_LVL4_INTRA_NUM, TYPE_VAL_32) \
|
|
ENTRY(KEY_INPUT_PSKIP, TYPE_VAL_32) \
|
|
ENTRY(KEY_OUTPUT_PSKIP, TYPE_VAL_32) \
|
|
ENTRY(KEY_INPUT_PSKIP_NON_REF, TYPE_VAL_32) \
|
|
ENTRY(KEY_ENC_SSE, TYPE_VAL_64) \
|
|
\
|
|
ENTRY(KEY_ENC_MARK_LTR, TYPE_VAL_32) \
|
|
ENTRY(KEY_ENC_USE_LTR, TYPE_VAL_32) \
|
|
ENTRY(KEY_ENC_FRAME_QP, TYPE_VAL_32) \
|
|
ENTRY(KEY_ENC_BASE_LAYER_PID, TYPE_VAL_32) \
|
|
\
|
|
ENTRY(KEY_DEC_TBN_EN, TYPE_VAL_32) \
|
|
ENTRY(KEY_DEC_TBN_Y_OFFSET, TYPE_VAL_32) \
|
|
ENTRY(KEY_DEC_TBN_UV_OFFSET, TYPE_VAL_32)
|
|
|
|
typedef struct MppMetaSrv_t {
|
|
spinlock_t lock;
|
|
struct list_head list_meta;
|
|
MppTrie trie;
|
|
|
|
RK_U32 meta_id;
|
|
RK_S32 meta_count;
|
|
} MppMetaSrv;
|
|
|
|
static MppMetaSrv *srv_meta = NULL;
|
|
static MppMemPool pool_meta = NULL;
|
|
static RK_U32 srv_finalized = 0;
|
|
static RK_U32 meta_key_count = 0;
|
|
static RK_U32 mpp_meta_debug = 0;
|
|
static RK_S32 user_data_index = -1;
|
|
static RK_S32 user_datas_index = -1;
|
|
|
|
RK_S32 meta_hdr_offset_index = -1;
|
|
RK_S32 meta_hdr_size_index = -1;
|
|
|
|
static void put_meta(MppMetaSrv *srv, MppMetaImpl *meta);
|
|
static inline RK_S32 get_index_of_key(MppMetaKey key, MppMetaType type, const char *caller);
|
|
#define get_index_of_key_f(key, type) get_index_of_key(key, type, __FUNCTION__);
|
|
|
|
static void mpp_meta_srv_init()
|
|
{
|
|
MppMetaSrv *srv = srv_meta;
|
|
|
|
mpp_env_get_u32("mpp_meta_debug", &mpp_meta_debug, 0);
|
|
|
|
if (srv)
|
|
return;
|
|
|
|
srv = mpp_calloc(MppMetaSrv, 1);
|
|
if (!srv) {
|
|
mpp_err_f("failed to malloc meta service\n");
|
|
return;
|
|
}
|
|
|
|
srv_meta = srv;
|
|
|
|
mpp_spinlock_init(&srv->lock);
|
|
INIT_LIST_HEAD(&srv->list_meta);
|
|
|
|
mpp_trie_init(&srv->trie, "MppMetaDef");
|
|
if (srv->trie) {
|
|
meta_key_count = 0;
|
|
META_ENTRY_TABLE(EXPAND_AS_TRIE)
|
|
mpp_trie_add_info(srv->trie, NULL, NULL, 0);
|
|
user_data_index = get_index_of_key_f(KEY_USER_DATA, TYPE_UPTR);
|
|
user_datas_index = get_index_of_key_f(KEY_USER_DATAS, TYPE_UPTR);
|
|
meta_hdr_offset_index = get_index_of_key_f(KEY_HDR_META_OFFSET, TYPE_VAL_32);
|
|
meta_hdr_size_index = get_index_of_key_f(KEY_HDR_META_SIZE, TYPE_VAL_32);
|
|
}
|
|
|
|
pool_meta = mpp_mem_pool_init_f("MppMeta", sizeof(MppMetaImpl) +
|
|
sizeof(MppMetaVal) * meta_key_count);
|
|
|
|
meta_dbg_flow("meta key count %d\n", meta_key_count);
|
|
if (mpp_meta_debug & META_DBG_KEYS) {
|
|
RK_S32 i = 0;
|
|
|
|
META_ENTRY_TABLE(EXPAND_AS_LOG)
|
|
}
|
|
}
|
|
|
|
static void mpp_meta_srv_deinit()
|
|
{
|
|
MppMetaSrv *srv = srv_meta;
|
|
|
|
if (!srv)
|
|
return;
|
|
|
|
if (!list_empty(&srv->list_meta)) {
|
|
MppMetaImpl *pos, *n;
|
|
|
|
mpp_log_f("cleaning leaked metadata\n");
|
|
|
|
list_for_each_entry_safe(pos, n, &srv->list_meta, MppMetaImpl, list_meta) {
|
|
put_meta(srv, pos);
|
|
}
|
|
}
|
|
|
|
mpp_assert(srv->meta_count == 0);
|
|
|
|
if (srv->trie) {
|
|
mpp_trie_deinit(srv->trie);
|
|
srv->trie = NULL;
|
|
}
|
|
|
|
MPP_FREE(srv_meta);
|
|
|
|
if (pool_meta) {
|
|
mpp_mem_pool_deinit_f(pool_meta);
|
|
pool_meta = NULL;
|
|
}
|
|
|
|
srv_finalized = 1;
|
|
|
|
meta_dbg_flow("meta srv deinited\n");
|
|
}
|
|
|
|
MPP_SINGLETON(MPP_SGLN_META, mpp_meta, mpp_meta_srv_init, mpp_meta_srv_deinit)
|
|
|
|
static inline RK_S32 get_index_of_key(MppMetaKey key, MppMetaType type, const char *caller)
|
|
{
|
|
MppMetaSrv *srv = get_srv_meta(caller);
|
|
MppTrieInfo *info = NULL;
|
|
|
|
if (srv) {
|
|
RK_U64 val = META_KEY_TO_U64(key, type);
|
|
|
|
info = mpp_trie_get_info(srv->trie, (const char *)&val);
|
|
}
|
|
|
|
return info ? info->index : -1;
|
|
}
|
|
|
|
static MppMetaImpl *get_meta(MppMetaSrv *srv, const char *tag, const char *caller)
|
|
{
|
|
MppMetaImpl *impl = (MppMetaImpl *)mpp_mem_pool_get(pool_meta, caller);
|
|
|
|
if (impl) {
|
|
const char *tag_src = (tag) ? (tag) : (MODULE_TAG);
|
|
RK_U32 i;
|
|
|
|
strncpy(impl->tag, tag_src, sizeof(impl->tag) - 1);
|
|
impl->caller = caller;
|
|
impl->meta_id = MPP_FETCH_ADD(&srv->meta_id, 1);
|
|
INIT_LIST_HEAD(&impl->list_meta);
|
|
impl->ref_count = 1;
|
|
impl->node_count = 0;
|
|
|
|
for (i = 0; i < meta_key_count; i++)
|
|
impl->vals[i].state = 0;
|
|
|
|
mpp_spinlock_lock(&srv->lock);
|
|
list_add_tail(&impl->list_meta, &srv->list_meta);
|
|
mpp_spinlock_unlock(&srv->lock);
|
|
MPP_FETCH_ADD(&srv->meta_count, 1);
|
|
} else {
|
|
mpp_err_f("failed to malloc meta data\n");
|
|
}
|
|
|
|
return impl;
|
|
}
|
|
|
|
static void clean_user_data(MppMetaImpl *impl)
|
|
{
|
|
MPP_FREE(impl->user_data.pdata);
|
|
impl->user_data.len = 0;
|
|
}
|
|
|
|
static void clean_user_datas(MppMetaImpl *impl)
|
|
{
|
|
MPP_FREE(impl->user_data_set.datas);
|
|
impl->user_data_set.count = 0;
|
|
impl->datas_buf_size = 0;
|
|
}
|
|
|
|
static void put_meta(MppMetaSrv *srv, MppMetaImpl *meta)
|
|
{
|
|
RK_S32 ref_count;
|
|
|
|
if (!srv)
|
|
return;
|
|
|
|
ref_count = MPP_SUB_FETCH(&meta->ref_count, 1);
|
|
if (ref_count > 0)
|
|
return;
|
|
|
|
if (ref_count < 0) {
|
|
mpp_err_f("invalid negative ref_count %d\n", ref_count);
|
|
return;
|
|
}
|
|
|
|
mpp_spinlock_lock(&srv->lock);
|
|
clean_user_data(meta);
|
|
clean_user_datas(meta);
|
|
list_del_init(&meta->list_meta);
|
|
mpp_spinlock_unlock(&srv->lock);
|
|
MPP_FETCH_SUB(&srv->meta_count, 1);
|
|
|
|
if (pool_meta)
|
|
mpp_mem_pool_put_f(pool_meta, meta);
|
|
}
|
|
|
|
MPP_RET mpp_meta_get_with_tag(MppMeta *meta, const char *tag, const char *caller)
|
|
{
|
|
MppMetaSrv *srv = get_srv_meta(caller);
|
|
MppMetaImpl *impl;
|
|
|
|
if (!srv)
|
|
return MPP_NOK;
|
|
|
|
if (!meta) {
|
|
mpp_err_f("found NULL input\n");
|
|
return MPP_ERR_NULL_PTR;
|
|
}
|
|
|
|
impl = get_meta(srv, tag, caller);
|
|
*meta = (MppMeta) impl;
|
|
return (impl) ? (MPP_OK) : (MPP_NOK);
|
|
}
|
|
|
|
MPP_RET mpp_meta_put(MppMeta meta)
|
|
{
|
|
MppMetaImpl *impl = (MppMetaImpl *)meta;
|
|
|
|
if (!impl) {
|
|
mpp_err_f("found NULL input\n");
|
|
return MPP_ERR_NULL_PTR;
|
|
}
|
|
|
|
put_meta(get_srv_meta_f(), impl);
|
|
return MPP_OK;
|
|
}
|
|
|
|
MPP_RET mpp_meta_inc_ref(MppMeta meta)
|
|
{
|
|
MppMetaImpl *impl = (MppMetaImpl *)meta;
|
|
|
|
if (!impl) {
|
|
mpp_err_f("found NULL input\n");
|
|
return MPP_ERR_NULL_PTR;
|
|
}
|
|
|
|
MPP_FETCH_ADD(&impl->ref_count, 1);
|
|
return MPP_OK;
|
|
}
|
|
|
|
RK_S32 mpp_meta_size(MppMeta meta)
|
|
{
|
|
MppMetaImpl *impl = (MppMetaImpl *)meta;
|
|
|
|
if (!impl) {
|
|
mpp_err_f("found NULL input\n");
|
|
return -1;
|
|
}
|
|
|
|
return MPP_FETCH_ADD(&impl->node_count, 0);
|
|
}
|
|
|
|
static MPP_RET set_user_data(MppMetaImpl *impl, void *user_data)
|
|
{
|
|
MppEncUserData *src = (MppEncUserData *)user_data;
|
|
|
|
if (!src) {
|
|
clean_user_data(impl);
|
|
return MPP_OK;
|
|
}
|
|
|
|
if (!src->pdata || !src->len) {
|
|
mpp_err_f("invalid user data %p pdata %p len %d\n", user_data, src->pdata, src->len);
|
|
return MPP_ERR_NULL_PTR;
|
|
}
|
|
|
|
if (impl->user_data.len < src->len) {
|
|
void *buf_ptr = mpp_realloc(impl->user_data.pdata, RK_U8, src->len);
|
|
|
|
if (!buf_ptr) {
|
|
mpp_err_f("failed to realloc user data buf size %d\n", src->len);
|
|
impl->user_data.len = 0;
|
|
return MPP_ERR_MALLOC;
|
|
}
|
|
impl->user_data.pdata = buf_ptr;
|
|
}
|
|
|
|
memcpy(impl->user_data.pdata, src->pdata, src->len);
|
|
impl->user_data.len = src->len;
|
|
|
|
return MPP_OK;
|
|
}
|
|
|
|
static MPP_RET set_user_datas(MppMetaImpl *impl, void *user_data)
|
|
{
|
|
MppEncUserDataSet *src_set = (MppEncUserDataSet *)user_data;
|
|
MppEncUserDataFull *dst_set = NULL;
|
|
void *buf_ptr = NULL;
|
|
RK_U32 data_size = 0;
|
|
RK_U32 struct_size = 0;
|
|
RK_U32 buf_size = 0;
|
|
RK_U32 i = 0;
|
|
|
|
if (!src_set) {
|
|
clean_user_datas(impl);
|
|
return MPP_OK;
|
|
}
|
|
|
|
if (!src_set->datas || !src_set->count) {
|
|
mpp_err_f("invalid user data %p datas %p count %d\n", src_set, src_set->datas, src_set->count);
|
|
return MPP_ERR_NULL_PTR;
|
|
}
|
|
|
|
struct_size = sizeof(MppEncUserDataFull) * src_set->count;
|
|
for (i = 0; i < src_set->count; i++) {
|
|
MppEncUserDataFull *src = &src_set->datas[i];
|
|
|
|
if (src->uuid)
|
|
data_size += strlen((const char *)src->uuid) + 1;
|
|
data_size += src->len;
|
|
}
|
|
buf_size = struct_size + data_size;
|
|
|
|
if (impl->datas_buf_size < buf_size) {
|
|
buf_ptr = mpp_realloc(impl->user_data_set.datas, RK_U8, buf_size);
|
|
if (!buf_ptr) {
|
|
mpp_err_f("failed to realloc user data buf size %d\n", buf_size);
|
|
impl->user_data_set.count = 0;
|
|
impl->datas_buf_size = 0;
|
|
return MPP_ERR_MALLOC;
|
|
}
|
|
impl->user_data_set.datas = (MppEncUserDataFull *)buf_ptr;
|
|
}
|
|
|
|
impl->datas_buf_size = buf_size;
|
|
dst_set = impl->user_data_set.datas;
|
|
buf_ptr = (void *)dst_set + struct_size;
|
|
|
|
for (i = 0; i < src_set->count; i++) {
|
|
MppEncUserDataFull *src = &src_set->datas[i];
|
|
MppEncUserDataFull *dst = &dst_set[i];
|
|
|
|
dst->len = src->len;
|
|
if (src->uuid) {
|
|
size_t uuid_len = strlen((const char *)src->uuid) + 1;
|
|
|
|
dst->uuid = (RK_U8 *)buf_ptr;
|
|
memcpy(buf_ptr, src->uuid, uuid_len);
|
|
buf_ptr += uuid_len;
|
|
} else {
|
|
dst->uuid = NULL;
|
|
}
|
|
if (src->pdata) {
|
|
dst->pdata = buf_ptr;
|
|
memcpy(buf_ptr, src->pdata, src->len);
|
|
buf_ptr += src->len;
|
|
} else {
|
|
dst->pdata = NULL;
|
|
}
|
|
}
|
|
impl->user_data_set.count = src_set->count;
|
|
|
|
return MPP_OK;
|
|
}
|
|
|
|
static MPP_RET get_user_data(MppMetaImpl *impl, void **val)
|
|
{
|
|
if (impl->user_data.pdata) {
|
|
*val = &impl->user_data;
|
|
return MPP_OK;
|
|
}
|
|
|
|
*val = NULL;
|
|
return MPP_NOK;
|
|
}
|
|
|
|
static MPP_RET get_user_datas(MppMetaImpl *impl, void **val)
|
|
{
|
|
if (impl->user_data_set.datas) {
|
|
*val = &impl->user_data_set;
|
|
return MPP_OK;
|
|
}
|
|
|
|
*val = NULL;
|
|
return MPP_NOK;
|
|
}
|
|
|
|
MppMeta mpp_meta_dup(MppMeta meta)
|
|
{
|
|
MppMetaSrv *srv = get_srv_meta_f();
|
|
MppMetaImpl *impl = (MppMetaImpl *)meta;
|
|
MppMetaImpl *ret;
|
|
|
|
if (!srv || !meta)
|
|
return NULL;
|
|
|
|
ret = get_meta(srv, impl->tag, __FUNCTION__);
|
|
if (ret) {
|
|
memcpy(ret->vals, impl->vals, meta_key_count * sizeof(MppMetaVal));
|
|
if (ret->user_data.len) {
|
|
memset(&ret->user_data, 0, sizeof(ret->user_data));
|
|
set_user_data(ret, (void *)(intptr_t)&impl->user_data);
|
|
}
|
|
if (ret->user_data_set.count) {
|
|
memset(&ret->user_data, 0, sizeof(ret->user_data));
|
|
set_user_datas(impl, (void *)(intptr_t)&impl->user_data_set);
|
|
}
|
|
ret->node_count = impl->node_count;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
MPP_RET mpp_meta_dump(MppMeta meta)
|
|
{
|
|
MppMetaSrv *srv = get_srv_meta_f();
|
|
MppMetaImpl *impl = (MppMetaImpl *)meta;
|
|
MppTrieInfo *root;
|
|
|
|
if (!impl) {
|
|
mpp_err_f("found NULL input\n");
|
|
return MPP_ERR_NULL_PTR;
|
|
}
|
|
|
|
mpp_logi("dumping meta %d node count %d\n", impl->meta_id, impl->node_count);
|
|
|
|
if (!srv || !srv->trie)
|
|
return MPP_NOK;
|
|
|
|
root = mpp_trie_get_info_first(srv->trie);
|
|
if (root) {
|
|
MppTrieInfo *node = root;
|
|
const char *key = NULL;
|
|
char log_str[256];
|
|
RK_S32 pos;
|
|
|
|
do {
|
|
if (mpp_trie_info_is_self(node))
|
|
continue;
|
|
|
|
key = mpp_trie_info_name(node);
|
|
|
|
pos = snprintf(log_str, sizeof(log_str) - 1, "key %c%c%c%c - ",
|
|
key[0], key[1], key[2], key[3]);
|
|
|
|
switch (key[4]) {
|
|
case '3' : {
|
|
snprintf(log_str + pos, sizeof(log_str) - pos - 1, "s32 - %d",
|
|
impl->vals[node->index].val_s32);
|
|
} break;
|
|
case '6' : {
|
|
snprintf(log_str + pos, sizeof(log_str) - pos - 1, "s64 - %lld",
|
|
impl->vals[node->index].val_s64);
|
|
} break;
|
|
case 'k' :
|
|
case 'u' :
|
|
case 's' : {
|
|
snprintf(log_str + pos, sizeof(log_str) - pos - 1, "ptr - %p",
|
|
impl->vals[node->index].val_ptr);
|
|
} break;
|
|
default : {
|
|
} break;
|
|
}
|
|
|
|
mpp_logi("%s\n", log_str);
|
|
} while ((node = mpp_trie_get_info_next(srv->trie, node)));
|
|
}
|
|
|
|
return MPP_OK;
|
|
}
|
|
|
|
#define MPP_META_ACCESSOR(func_type, arg_type, key_type, key_field) \
|
|
MPP_RET mpp_meta_set_##func_type(MppMeta meta, MppMetaKey key, arg_type val) \
|
|
{ \
|
|
MppMetaImpl *impl = (MppMetaImpl *)meta; \
|
|
MppMetaVal *meta_val; \
|
|
RK_S32 index; \
|
|
if (!impl) { \
|
|
mpp_err_f("found NULL input\n"); \
|
|
return MPP_ERR_NULL_PTR; \
|
|
} \
|
|
index = get_index_of_key_f(key, key_type); \
|
|
if (index < 0) \
|
|
return MPP_NOK; \
|
|
meta_val = &impl->vals[index]; \
|
|
if (MPP_BOOL_CAS(&meta_val->state, META_VAL_INVALID, META_VAL_VALID)) \
|
|
MPP_FETCH_ADD(&impl->node_count, 1); \
|
|
if (index == user_data_index) { \
|
|
set_user_data(impl, (void *)(intptr_t)val); \
|
|
} else if (index == user_datas_index) { \
|
|
set_user_datas(impl, (void *)(intptr_t)val); \
|
|
} else { \
|
|
meta_val->key_field = val; \
|
|
} \
|
|
MPP_FETCH_OR(&meta_val->state, META_VAL_READY); \
|
|
return MPP_OK; \
|
|
} \
|
|
MPP_RET mpp_meta_get_##func_type(MppMeta meta, MppMetaKey key, arg_type *val) \
|
|
{ \
|
|
MppMetaImpl *impl = (MppMetaImpl *)meta; \
|
|
MppMetaVal *meta_val; \
|
|
RK_S32 index; \
|
|
MPP_RET ret = MPP_NOK; \
|
|
if (!impl) { \
|
|
mpp_err_f("found NULL input\n"); \
|
|
return MPP_ERR_NULL_PTR; \
|
|
} \
|
|
index = get_index_of_key_f(key, key_type); \
|
|
if (index < 0) \
|
|
return MPP_NOK; \
|
|
meta_val = &impl->vals[index]; \
|
|
if (MPP_BOOL_CAS(&meta_val->state, META_VAL_VALID | META_VAL_READY, META_VAL_INVALID)) { \
|
|
if (index == user_data_index) \
|
|
get_user_data(impl, (void**)val); \
|
|
else if (index == user_datas_index) \
|
|
get_user_datas(impl, (void**)val); \
|
|
else \
|
|
*val = meta_val->key_field; \
|
|
MPP_FETCH_SUB(&impl->node_count, 1); \
|
|
ret = MPP_OK; \
|
|
} \
|
|
return ret; \
|
|
} \
|
|
MPP_RET mpp_meta_get_##func_type##_d(MppMeta meta, MppMetaKey key, arg_type *val, arg_type def) \
|
|
{ \
|
|
MppMetaImpl *impl = (MppMetaImpl *)meta; \
|
|
MppMetaVal *meta_val; \
|
|
RK_S32 index; \
|
|
MPP_RET ret = MPP_NOK; \
|
|
if (!impl) { \
|
|
mpp_err_f("found NULL input\n"); \
|
|
return MPP_ERR_NULL_PTR; \
|
|
} \
|
|
index = get_index_of_key_f(key, key_type); \
|
|
if (index < 0) \
|
|
return MPP_NOK; \
|
|
meta_val = &impl->vals[index]; \
|
|
if (MPP_BOOL_CAS(&meta_val->state, META_VAL_VALID | META_VAL_READY, META_VAL_INVALID)) { \
|
|
if (index == user_data_index) \
|
|
get_user_data(impl, (void**)val); \
|
|
else if (index == user_datas_index) \
|
|
get_user_datas(impl, (void**)val); \
|
|
else \
|
|
*val = meta_val->key_field; \
|
|
MPP_FETCH_SUB(&impl->node_count, 1); \
|
|
ret = MPP_OK; \
|
|
} else { \
|
|
*val = def; \
|
|
} \
|
|
return ret; \
|
|
}
|
|
|
|
MPP_META_ACCESSOR(s32, RK_S32, TYPE_VAL_32, val_s32)
|
|
MPP_META_ACCESSOR(s64, RK_S64, TYPE_VAL_64, val_s64)
|
|
MPP_META_ACCESSOR(ptr, void *, TYPE_UPTR, val_ptr)
|
|
MPP_META_ACCESSOR(frame, MppFrame, TYPE_SPTR, frame)
|
|
MPP_META_ACCESSOR(packet, MppPacket, TYPE_SPTR, packet)
|
|
MPP_META_ACCESSOR(buffer, MppBuffer, TYPE_SPTR, buffer)
|
|
|
|
RK_S32 mpp_meta_s32_read(MppMeta meta, RK_S32 index, RK_S32 *val)
|
|
{
|
|
MppMetaImpl *impl = (MppMetaImpl *)meta;
|
|
MppMetaVal *meta_val;
|
|
MPP_RET ret = MPP_NOK;
|
|
|
|
if (!impl || index < 0 || index >= meta_key_count) {
|
|
mpp_err_f("found NULL input meta %p index %d\n", meta, index);
|
|
return MPP_ERR_NULL_PTR;
|
|
}
|
|
|
|
meta_val = &impl->vals[index];
|
|
if (meta_val->state == (META_VAL_VALID | META_VAL_READY)) {
|
|
*val = meta_val->val_s32;
|
|
ret = MPP_OK;
|
|
}
|
|
|
|
return ret;
|
|
}
|