mirror of
https://github.com/nyanmisaka/mpp.git
synced 2025-12-26 11:17:44 +01:00
7aece2c5d8
The HDR flag will not change the buffer size just ignore it. Signed-off-by: Herman Chen <herman.chen@rock-chips.com> Change-Id: Ibebe60b8c0961e87b2b84236dd28a23e05f9d58f
299 lines
7.8 KiB
C++
299 lines
7.8 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_frame"
|
|
|
|
#include <string.h>
|
|
|
|
#include "mpp_log.h"
|
|
#include "mpp_mem.h"
|
|
#include "mpp_common.h"
|
|
#include "mpp_frame_impl.h"
|
|
#include "mpp_meta_impl.h"
|
|
#include "mpp_mem_pool.h"
|
|
|
|
static const char *module_name = MODULE_TAG;
|
|
static MppMemPool mpp_frame_pool = mpp_mem_pool_init_f(module_name, sizeof(MppFrameImpl));
|
|
|
|
static void setup_mpp_frame_name(MppFrameImpl *frame)
|
|
{
|
|
frame->name = module_name;
|
|
}
|
|
|
|
#define check_is_mpp_frame(frame) _check_is_mpp_frame(__FUNCTION__, frame)
|
|
|
|
MPP_RET _check_is_mpp_frame(const char *func, void *frame)
|
|
{
|
|
if (frame && ((MppFrameImpl*)frame)->name == module_name)
|
|
return MPP_OK;
|
|
|
|
mpp_err("pointer %p failed on %s check mpp_frame\n", frame, func);
|
|
mpp_abort();
|
|
return MPP_NOK;
|
|
}
|
|
|
|
MPP_RET mpp_frame_init(MppFrame *frame)
|
|
{
|
|
if (NULL == frame) {
|
|
mpp_err_f("invalid NULL pointer input\n");
|
|
return MPP_ERR_NULL_PTR;
|
|
}
|
|
|
|
MppFrameImpl *p = (MppFrameImpl*)mpp_mem_pool_get(mpp_frame_pool);
|
|
if (NULL == p) {
|
|
mpp_err_f("malloc failed\n");
|
|
return MPP_ERR_NULL_PTR;
|
|
}
|
|
|
|
setup_mpp_frame_name(p);
|
|
*frame = p;
|
|
|
|
return MPP_OK;
|
|
}
|
|
|
|
MPP_RET mpp_frame_deinit(MppFrame *frame)
|
|
{
|
|
if (NULL == frame || check_is_mpp_frame(*frame)) {
|
|
mpp_err_f("invalid NULL pointer input\n");
|
|
return MPP_ERR_NULL_PTR;
|
|
}
|
|
|
|
MppFrameImpl *p = (MppFrameImpl *)*frame;
|
|
if (p->buffer)
|
|
mpp_buffer_put(p->buffer);
|
|
|
|
if (p->meta)
|
|
mpp_meta_put(p->meta);
|
|
|
|
if (p->stopwatch)
|
|
mpp_stopwatch_put(p->stopwatch);
|
|
|
|
mpp_mem_pool_put(mpp_frame_pool, *frame);
|
|
*frame = NULL;
|
|
return MPP_OK;
|
|
}
|
|
|
|
MppBuffer mpp_frame_get_buffer(MppFrame frame)
|
|
{
|
|
if (check_is_mpp_frame(frame))
|
|
return NULL;
|
|
|
|
MppFrameImpl *p = (MppFrameImpl *)frame;
|
|
return (MppFrame)p->buffer;
|
|
}
|
|
|
|
void mpp_frame_set_buffer(MppFrame frame, MppBuffer buffer)
|
|
{
|
|
if (check_is_mpp_frame(frame))
|
|
return ;
|
|
|
|
MppFrameImpl *p = (MppFrameImpl *)frame;
|
|
if (p->buffer != buffer) {
|
|
if (buffer)
|
|
mpp_buffer_inc_ref(buffer);
|
|
|
|
if (p->buffer)
|
|
mpp_buffer_put(p->buffer);
|
|
|
|
p->buffer = buffer;
|
|
}
|
|
}
|
|
|
|
RK_S32 mpp_frame_has_meta(const MppFrame frame)
|
|
{
|
|
if (check_is_mpp_frame(frame))
|
|
return 0;
|
|
|
|
MppFrameImpl *p = (MppFrameImpl *)frame;
|
|
|
|
return (NULL != p->meta);
|
|
}
|
|
|
|
MppMeta mpp_frame_get_meta(MppFrame frame)
|
|
{
|
|
if (check_is_mpp_frame(frame))
|
|
return NULL;
|
|
|
|
MppFrameImpl *p = (MppFrameImpl *)frame;
|
|
if (NULL == p->meta)
|
|
mpp_meta_get(&p->meta);
|
|
|
|
return p->meta;
|
|
}
|
|
|
|
void mpp_frame_set_meta(MppFrame frame, MppMeta meta)
|
|
{
|
|
if (check_is_mpp_frame(frame))
|
|
return ;
|
|
|
|
MppFrameImpl *p = (MppFrameImpl *)frame;
|
|
if (p->meta) {
|
|
mpp_meta_put(p->meta);
|
|
p->meta = NULL;
|
|
}
|
|
|
|
p->meta = meta;
|
|
}
|
|
|
|
MppFrameStatus *mpp_frame_get_status(MppFrame frame)
|
|
{
|
|
MppFrameImpl *p = (MppFrameImpl *)frame;
|
|
|
|
return &p->status;
|
|
}
|
|
|
|
void mpp_frame_set_stopwatch_enable(MppFrame frame, RK_S32 enable)
|
|
{
|
|
if (check_is_mpp_frame(frame))
|
|
return ;
|
|
|
|
MppFrameImpl *p = (MppFrameImpl *)frame;
|
|
if (enable && NULL == p->stopwatch) {
|
|
char name[32];
|
|
|
|
snprintf(name, sizeof(name) - 1, "frm %8llx", p->pts);
|
|
p->stopwatch = mpp_stopwatch_get(name);
|
|
if (p->stopwatch)
|
|
mpp_stopwatch_set_show_on_exit(p->stopwatch, 1);
|
|
} else if (!enable && p->stopwatch) {
|
|
mpp_stopwatch_put(p->stopwatch);
|
|
p->stopwatch = NULL;
|
|
}
|
|
}
|
|
|
|
MppStopwatch mpp_frame_get_stopwatch(const MppFrame frame)
|
|
{
|
|
if (check_is_mpp_frame(frame))
|
|
return NULL;
|
|
|
|
MppFrameImpl *p = (MppFrameImpl *)frame;
|
|
return p->stopwatch;
|
|
}
|
|
|
|
MPP_RET mpp_frame_copy(MppFrame dst, MppFrame src)
|
|
{
|
|
if (NULL == dst || check_is_mpp_frame(src)) {
|
|
mpp_err_f("invalid input dst %p src %p\n", dst, src);
|
|
return MPP_ERR_UNKNOW;
|
|
}
|
|
|
|
memcpy(dst, src, sizeof(MppFrameImpl));
|
|
MppFrameImpl *p = (MppFrameImpl *)src;
|
|
if (p->meta)
|
|
mpp_meta_inc_ref(p->meta);
|
|
|
|
return MPP_OK;
|
|
}
|
|
|
|
MPP_RET mpp_frame_info_cmp(MppFrame frame0, MppFrame frame1)
|
|
{
|
|
if (check_is_mpp_frame(frame0) || check_is_mpp_frame(frame0)) {
|
|
mpp_err_f("invalid NULL pointer input\n");
|
|
return MPP_ERR_NULL_PTR;
|
|
}
|
|
|
|
MppFrameImpl *f0 = (MppFrameImpl *)frame0;
|
|
MppFrameImpl *f1 = (MppFrameImpl *)frame1;
|
|
|
|
if ((f0->width == f1->width) &&
|
|
(f0->height == f1->height) &&
|
|
(f0->hor_stride == f1->hor_stride) &&
|
|
(f0->ver_stride == f1->ver_stride) &&
|
|
((f0->fmt & ~MPP_FRAME_HDR_MASK) == (f1->fmt & ~MPP_FRAME_HDR_MASK)) &&
|
|
(f0->buf_size == f1->buf_size)) {
|
|
return MPP_OK;
|
|
}
|
|
return MPP_NOK;
|
|
}
|
|
|
|
RK_U32 mpp_frame_get_fbc_offset(MppFrame frame)
|
|
{
|
|
if (check_is_mpp_frame(frame))
|
|
return 0;
|
|
|
|
MppFrameImpl *p = (MppFrameImpl *)frame;
|
|
|
|
if (MPP_FRAME_FMT_IS_FBC(p->fmt)) {
|
|
RK_U32 fbc_version = p->fmt & MPP_FRAME_FBC_MASK;
|
|
RK_U32 fbc_offset = 0;
|
|
|
|
if (fbc_version == MPP_FRAME_FBC_AFBC_V1) {
|
|
fbc_offset = MPP_ALIGN(MPP_ALIGN(p->width, 16) *
|
|
MPP_ALIGN(p->height, 16) / 16, SZ_4K);
|
|
} else if (fbc_version == MPP_FRAME_FBC_AFBC_V2) {
|
|
fbc_offset = 0;
|
|
}
|
|
p->fbc_offset = fbc_offset;
|
|
}
|
|
|
|
return p->fbc_offset;
|
|
}
|
|
|
|
RK_U32 mpp_frame_get_fbc_stride(MppFrame frame)
|
|
{
|
|
if (check_is_mpp_frame(frame))
|
|
return 0;
|
|
|
|
MppFrameImpl *p = (MppFrameImpl *)frame;
|
|
return MPP_ALIGN(p->width, 16);
|
|
}
|
|
|
|
/*
|
|
* object access function macro
|
|
*/
|
|
#define MPP_FRAME_ACCESSORS(type, field) \
|
|
type mpp_frame_get_##field(const MppFrame s) \
|
|
{ \
|
|
check_is_mpp_frame((MppFrameImpl*)s); \
|
|
return ((MppFrameImpl*)s)->field; \
|
|
} \
|
|
void mpp_frame_set_##field(MppFrame s, type v) \
|
|
{ \
|
|
check_is_mpp_frame((MppFrameImpl*)s); \
|
|
((MppFrameImpl*)s)->field = v; \
|
|
}
|
|
|
|
MPP_FRAME_ACCESSORS(RK_U32, width)
|
|
MPP_FRAME_ACCESSORS(RK_U32, height)
|
|
MPP_FRAME_ACCESSORS(RK_U32, hor_stride_pixel)
|
|
MPP_FRAME_ACCESSORS(RK_U32, hor_stride)
|
|
MPP_FRAME_ACCESSORS(RK_U32, ver_stride)
|
|
MPP_FRAME_ACCESSORS(RK_U32, fbc_hdr_stride)
|
|
MPP_FRAME_ACCESSORS(RK_U32, offset_x)
|
|
MPP_FRAME_ACCESSORS(RK_U32, offset_y)
|
|
MPP_FRAME_ACCESSORS(RK_U32, mode)
|
|
MPP_FRAME_ACCESSORS(RK_U32, discard)
|
|
MPP_FRAME_ACCESSORS(RK_U32, viewid)
|
|
MPP_FRAME_ACCESSORS(RK_U32, poc)
|
|
MPP_FRAME_ACCESSORS(RK_S64, pts)
|
|
MPP_FRAME_ACCESSORS(RK_S64, dts)
|
|
MPP_FRAME_ACCESSORS(RK_U32, eos)
|
|
MPP_FRAME_ACCESSORS(RK_U32, info_change)
|
|
MPP_FRAME_ACCESSORS(MppFrameColorRange, color_range)
|
|
MPP_FRAME_ACCESSORS(MppFrameColorPrimaries, color_primaries)
|
|
MPP_FRAME_ACCESSORS(MppFrameColorTransferCharacteristic, color_trc)
|
|
MPP_FRAME_ACCESSORS(MppFrameColorSpace, colorspace)
|
|
MPP_FRAME_ACCESSORS(MppFrameChromaLocation, chroma_location)
|
|
MPP_FRAME_ACCESSORS(MppFrameFormat, fmt)
|
|
MPP_FRAME_ACCESSORS(MppFrameRational, sar)
|
|
MPP_FRAME_ACCESSORS(MppFrameMasteringDisplayMetadata, mastering_display)
|
|
MPP_FRAME_ACCESSORS(MppFrameContentLightMetadata, content_light)
|
|
MPP_FRAME_ACCESSORS(MppFrameHdrDynamicMeta*, hdr_dynamic_meta)
|
|
MPP_FRAME_ACCESSORS(size_t, buf_size)
|
|
MPP_FRAME_ACCESSORS(RK_U32, errinfo)
|
|
MPP_FRAME_ACCESSORS(MppTask, task)
|
|
MPP_FRAME_ACCESSORS(RK_U32, thumbnail_en)
|
|
MPP_FRAME_ACCESSORS(size_t, fbc_size)
|