mirror of
https://github.com/nyanmisaka/mpp.git
synced 2025-10-05 09:06:50 +08:00
f1f76e83c5
Signed-off-by: Herman Chen <herman.chen@rock-chips.com> Change-Id: Iaccde5929bcb72c407e1efc5c7e78f362e69eeed
380 lines
10 KiB
C++
380 lines
10 KiB
C++
/*
|
|
* Copyright 2015 Rockchip Electronics Co. LTD
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#define MODULE_TAG "mpp_buffer"
|
|
|
|
#include <string.h>
|
|
|
|
#include "mpp_log.h"
|
|
#include "mpp_mem.h"
|
|
#include "mpp_buffer_impl.h"
|
|
|
|
MPP_RET mpp_buffer_import_with_tag(MppBufferGroup group, MppBufferInfo *info, MppBuffer *buffer,
|
|
const char *tag, const char *caller)
|
|
{
|
|
if (NULL == info) {
|
|
mpp_err("mpp_buffer_commit invalid input: info NULL from %s\n", caller);
|
|
return MPP_ERR_NULL_PTR;
|
|
}
|
|
|
|
MppBufferGroupImpl *p = (MppBufferGroupImpl *)group;
|
|
|
|
if (p) {
|
|
// if group is specified we need to check the parameter
|
|
if ((p->type & MPP_BUFFER_TYPE_MASK) != info->type ||
|
|
(p->type & MPP_BUFFER_TYPE_MASK) >= MPP_BUFFER_TYPE_BUTT ||
|
|
p->mode != MPP_BUFFER_EXTERNAL) {
|
|
mpp_err("mpp_buffer_commit invalid type found group %d info %d group mode %d from %s\n",
|
|
p->type, info->type, p->mode, caller);
|
|
return MPP_ERR_UNKNOW;
|
|
}
|
|
} else {
|
|
// otherwise use default external group to manage them
|
|
p = mpp_buffer_get_misc_group(MPP_BUFFER_EXTERNAL, info->type);
|
|
}
|
|
|
|
mpp_assert(p);
|
|
|
|
MPP_RET ret = MPP_OK;
|
|
if (buffer) {
|
|
MppBufferImpl *buf = NULL;
|
|
ret = mpp_buffer_create(tag, caller, p, info, &buf);
|
|
*buffer = buf;
|
|
} else {
|
|
ret = mpp_buffer_create(tag, caller, p, info, NULL);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
MPP_RET mpp_buffer_get_with_tag(MppBufferGroup group, MppBuffer *buffer, size_t size,
|
|
const char *tag, const char *caller)
|
|
{
|
|
if (NULL == buffer || 0 == size) {
|
|
mpp_err("mpp_buffer_get invalid input: group %p buffer %p size %u from %s\n",
|
|
group, buffer, size, caller);
|
|
return MPP_ERR_UNKNOW;
|
|
}
|
|
|
|
if (NULL == group) {
|
|
// deprecated, only for libvpu support
|
|
group = mpp_buffer_get_misc_group(MPP_BUFFER_INTERNAL, MPP_BUFFER_TYPE_ION);
|
|
}
|
|
|
|
mpp_assert(group);
|
|
|
|
MppBufferGroupImpl *p = (MppBufferGroupImpl *)group;
|
|
// try unused buffer first
|
|
MppBufferImpl *buf = mpp_buffer_get_unused(p, size);
|
|
if (NULL == buf && MPP_BUFFER_INTERNAL == p->mode) {
|
|
MppBufferInfo info = {
|
|
p->type,
|
|
size,
|
|
NULL,
|
|
NULL,
|
|
-1,
|
|
-1,
|
|
};
|
|
// if failed try init a new buffer
|
|
mpp_buffer_create(tag, caller, p, &info, &buf);
|
|
}
|
|
*buffer = buf;
|
|
return (buf) ? (MPP_OK) : (MPP_NOK);
|
|
}
|
|
|
|
|
|
MPP_RET mpp_buffer_put_with_caller(MppBuffer buffer, const char *caller)
|
|
{
|
|
if (NULL == buffer) {
|
|
mpp_err("mpp_buffer_put invalid input: buffer NULL from %s\n", caller);
|
|
return MPP_ERR_UNKNOW;
|
|
}
|
|
|
|
return mpp_buffer_ref_dec((MppBufferImpl*)buffer, caller);
|
|
}
|
|
|
|
MPP_RET mpp_buffer_inc_ref_with_caller(MppBuffer buffer, const char *caller)
|
|
{
|
|
if (NULL == buffer) {
|
|
mpp_err("mpp_buffer_inc_ref invalid input: buffer NULL from %s\n", caller);
|
|
return MPP_ERR_UNKNOW;
|
|
}
|
|
|
|
return mpp_buffer_ref_inc((MppBufferImpl*)buffer, caller);
|
|
}
|
|
|
|
MPP_RET mpp_buffer_read_with_caller(MppBuffer buffer, size_t offset, void *data, size_t size, const char *caller)
|
|
{
|
|
if (NULL == buffer || NULL == data) {
|
|
mpp_err("mpp_buffer_read invalid input: buffer %p data %p from %s\n",
|
|
buffer, data, caller);
|
|
return MPP_ERR_UNKNOW;
|
|
}
|
|
|
|
if (0 == size)
|
|
return MPP_OK;
|
|
|
|
MppBufferImpl *p = (MppBufferImpl*)buffer;
|
|
if (NULL == p->info.ptr)
|
|
mpp_buffer_mmap(p, caller);
|
|
|
|
void *src = p->info.ptr;
|
|
mpp_assert(src != NULL);
|
|
if (src)
|
|
memcpy(data, (char*)src + offset, size);
|
|
|
|
return MPP_OK;
|
|
}
|
|
|
|
MPP_RET mpp_buffer_write_with_caller(MppBuffer buffer, size_t offset, void *data, size_t size, const char *caller)
|
|
{
|
|
if (NULL == buffer || NULL == data) {
|
|
mpp_err("mpp_buffer_write invalid input: buffer %p data %p from %s\n",
|
|
buffer, data, caller);
|
|
return MPP_ERR_UNKNOW;
|
|
}
|
|
|
|
if (0 == size)
|
|
return MPP_OK;
|
|
|
|
MppBufferImpl *p = (MppBufferImpl*)buffer;
|
|
if (offset + size > p->info.size)
|
|
return MPP_ERR_VALUE;
|
|
if (NULL == p->info.ptr)
|
|
mpp_buffer_mmap(p, caller);
|
|
|
|
void *dst = p->info.ptr;
|
|
mpp_assert(dst != NULL);
|
|
if (dst)
|
|
memcpy((char*)dst + offset, data, size);
|
|
|
|
return MPP_OK;
|
|
}
|
|
|
|
void *mpp_buffer_get_ptr_with_caller(MppBuffer buffer, const char *caller)
|
|
{
|
|
if (NULL == buffer) {
|
|
mpp_err("mpp_buffer_get_ptr invalid NULL input from %s\n", caller);
|
|
return NULL;
|
|
}
|
|
|
|
MppBufferImpl *p = (MppBufferImpl*)buffer;
|
|
if (NULL == p->info.ptr)
|
|
mpp_buffer_mmap(p, caller);
|
|
|
|
mpp_assert(p->info.ptr != NULL);
|
|
if (NULL == p->info.ptr)
|
|
mpp_err("mpp_buffer_get_ptr buffer %p ret NULL from %s\n", buffer, caller);
|
|
|
|
return p->info.ptr;
|
|
}
|
|
|
|
int mpp_buffer_get_fd_with_caller(MppBuffer buffer, const char *caller)
|
|
{
|
|
if (NULL == buffer) {
|
|
mpp_err("mpp_buffer_get_fd invalid NULL input from %s\n", caller);
|
|
return -1;
|
|
}
|
|
|
|
MppBufferImpl *p = (MppBufferImpl*)buffer;
|
|
int fd = p->info.fd;
|
|
mpp_assert(fd >= 0);
|
|
if (fd < 0)
|
|
mpp_err("mpp_buffer_get_fd buffer %p fd %d from %s\n", buffer, fd, caller);
|
|
|
|
return fd;
|
|
}
|
|
|
|
size_t mpp_buffer_get_size_with_caller(MppBuffer buffer, const char *caller)
|
|
{
|
|
if (NULL == buffer) {
|
|
mpp_err("mpp_buffer_get_size invalid NULL input from %s\n", caller);
|
|
return 0;
|
|
}
|
|
|
|
MppBufferImpl *p = (MppBufferImpl*)buffer;
|
|
if (p->info.size == 0)
|
|
mpp_err("mpp_buffer_get_size buffer %p ret zero size from %s\n", buffer, caller);
|
|
|
|
return p->info.size;
|
|
}
|
|
|
|
int mpp_buffer_get_index_with_caller(MppBuffer buffer, const char *caller)
|
|
{
|
|
if (NULL == buffer) {
|
|
mpp_err("mpp_buffer_get_index invalid NULL input from %s\n", caller);
|
|
return -1;
|
|
}
|
|
|
|
MppBufferImpl *p = (MppBufferImpl*)buffer;
|
|
return p->info.index;
|
|
}
|
|
|
|
MPP_RET mpp_buffer_set_index_with_caller(MppBuffer buffer, int index,
|
|
const char *caller)
|
|
{
|
|
if (NULL == buffer) {
|
|
mpp_err("mpp_buffer_set_index invalid NULL input from %s\n", caller);
|
|
return MPP_ERR_UNKNOW;
|
|
}
|
|
|
|
MppBufferImpl *p = (MppBufferImpl*)buffer;
|
|
p->info.index = index;
|
|
return MPP_OK;
|
|
}
|
|
|
|
size_t mpp_buffer_get_offset_with_caller(MppBuffer buffer, const char *caller)
|
|
{
|
|
if (NULL == buffer) {
|
|
mpp_err("mpp_buffer_get_offset invalid NULL input from %s\n", caller);
|
|
return -1;
|
|
}
|
|
|
|
MppBufferImpl *p = (MppBufferImpl*)buffer;
|
|
return p->offset;
|
|
}
|
|
|
|
MPP_RET mpp_buffer_set_offset_with_caller(MppBuffer buffer, size_t offset, const char *caller)
|
|
{
|
|
if (NULL == buffer) {
|
|
mpp_err("mpp_buffer_set_offset invalid NULL input from %s\n", caller);
|
|
return MPP_ERR_UNKNOW;
|
|
}
|
|
|
|
MppBufferImpl *p = (MppBufferImpl*)buffer;
|
|
p->offset = offset;
|
|
return MPP_OK;
|
|
}
|
|
|
|
MPP_RET mpp_buffer_info_get_with_caller(MppBuffer buffer, MppBufferInfo *info, const char *caller)
|
|
{
|
|
if (NULL == buffer || NULL == info) {
|
|
mpp_err("mpp_buffer_info_get invalid input buffer %p info %p from %s\n",
|
|
buffer, info, caller);
|
|
return MPP_ERR_UNKNOW;
|
|
}
|
|
|
|
MppBufferImpl *p = (MppBufferImpl*)buffer;
|
|
if (NULL == p->info.ptr)
|
|
mpp_buffer_mmap(p, caller);
|
|
|
|
*info = p->info;
|
|
(void)caller;
|
|
return MPP_OK;
|
|
}
|
|
|
|
MPP_RET mpp_buffer_group_get(MppBufferGroup *group, MppBufferType type, MppBufferMode mode,
|
|
const char *tag, const char *caller)
|
|
{
|
|
if (NULL == group ||
|
|
mode >= MPP_BUFFER_MODE_BUTT ||
|
|
(type & MPP_BUFFER_TYPE_MASK) >= MPP_BUFFER_TYPE_BUTT) {
|
|
mpp_err_f("input invalid group %p mode %d type %d from %s\n",
|
|
group, mode, type, caller);
|
|
return MPP_ERR_UNKNOW;
|
|
}
|
|
|
|
return mpp_buffer_group_init((MppBufferGroupImpl**)group, tag, caller, mode, type);
|
|
}
|
|
|
|
MPP_RET mpp_buffer_group_put(MppBufferGroup group)
|
|
{
|
|
if (NULL == group) {
|
|
mpp_err_f("input invalid group %p\n", group);
|
|
return MPP_NOK;
|
|
}
|
|
|
|
return mpp_buffer_group_deinit((MppBufferGroupImpl *)group);
|
|
}
|
|
|
|
MPP_RET mpp_buffer_group_clear(MppBufferGroup group)
|
|
{
|
|
if (NULL == group) {
|
|
mpp_err_f("input invalid group %p\n", group);
|
|
return MPP_NOK;
|
|
}
|
|
|
|
return mpp_buffer_group_reset((MppBufferGroupImpl *)group);
|
|
}
|
|
|
|
RK_S32 mpp_buffer_group_unused(MppBufferGroup group)
|
|
{
|
|
if (NULL == group) {
|
|
mpp_err_f("input invalid group %p\n", group);
|
|
return MPP_NOK;
|
|
}
|
|
|
|
MppBufferGroupImpl *p = (MppBufferGroupImpl *)group;
|
|
RK_S32 unused = 0;
|
|
|
|
if (p->mode == MPP_BUFFER_INTERNAL) {
|
|
if (p->limit_count)
|
|
unused = p->limit_count - p->count_used;
|
|
else
|
|
unused = 3; /* NOTE: 3 for 1 decoding 2 deinterlace buffer */
|
|
} else
|
|
unused = p->count_unused;
|
|
|
|
return unused;
|
|
}
|
|
|
|
size_t mpp_buffer_group_usage(MppBufferGroup group)
|
|
{
|
|
if (NULL == group) {
|
|
mpp_err_f("input invalid group %p\n", group);
|
|
return MPP_BUFFER_MODE_BUTT;
|
|
}
|
|
|
|
MppBufferGroupImpl *p = (MppBufferGroupImpl *)group;
|
|
return p->usage;
|
|
}
|
|
|
|
MppBufferMode mpp_buffer_group_mode(MppBufferGroup group)
|
|
{
|
|
if (NULL == group) {
|
|
mpp_err_f("input invalid group %p\n", group);
|
|
return MPP_BUFFER_MODE_BUTT;
|
|
}
|
|
|
|
MppBufferGroupImpl *p = (MppBufferGroupImpl *)group;
|
|
return p->mode;
|
|
}
|
|
|
|
MppBufferType mpp_buffer_group_type(MppBufferGroup group)
|
|
{
|
|
if (NULL == group) {
|
|
mpp_err_f("input invalid group %p\n", group);
|
|
return MPP_BUFFER_TYPE_BUTT;
|
|
}
|
|
|
|
MppBufferGroupImpl *p = (MppBufferGroupImpl *)group;
|
|
return p->type;
|
|
}
|
|
|
|
MPP_RET mpp_buffer_group_limit_config(MppBufferGroup group, size_t size, RK_S32 count)
|
|
{
|
|
if (NULL == group) {
|
|
mpp_err_f("input invalid group %p\n", group);
|
|
return MPP_NOK;
|
|
}
|
|
|
|
MppBufferGroupImpl *p = (MppBufferGroupImpl *)group;
|
|
mpp_assert(p->mode == MPP_BUFFER_INTERNAL);
|
|
p->limit_size = size;
|
|
p->limit_count = count;
|
|
return MPP_OK;
|
|
}
|
|
|