new/external/rockit/mpi/example/common/test_comm_rgn.cpp
2025-05-10 21:58:58 +08:00

413 lines
14 KiB
C++

/*
* Copyright 2021 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.
*/
#ifdef __cplusplus
#if __cplusplus
extern "C" {
#endif
#endif /* End of #ifdef __cplusplus */
#include <stdlib.h>
#include <string.h>
#include "test_comm_rgn.h"
#include "test_comm_bmp.h"
#include "test_comm_imgproc.h"
#include "rk_mpi_rgn.h"
#include "rk_mpi_cal.h"
#include "rk_comm_rgn.h"
#include "rk_common.h"
#include "rk_debug.h"
RK_S32 TEST_RGN_CreateOverlayAndAttach(
RGN_HANDLE RgnHandle, RK_U32 u32Width, RK_U32 u32Height,
PIXEL_FORMAT_E enFmt, const MPP_CHN_S *pstChn, RK_U32 u32ChnNum) {
RGN_ATTR_S stRgnAttr;
RGN_CHN_ATTR_S stRgnChnAttr;
RK_S32 s32Ret = RK_SUCCESS;
memset(&stRgnAttr, 0, sizeof(RGN_ATTR_S));
memset(&stRgnChnAttr, 0, sizeof(RGN_CHN_ATTR_S));
stRgnAttr.enType = OVERLAY_RGN;
stRgnAttr.unAttr.stOverlay.enPixelFmt = enFmt;
stRgnAttr.unAttr.stOverlay.stSize.u32Width = u32Width;
stRgnAttr.unAttr.stOverlay.stSize.u32Height = u32Height;
s32Ret = RK_MPI_RGN_Create(RgnHandle, &stRgnAttr);
if (RK_SUCCESS != s32Ret) {
RK_LOGE("RK_MPI_RGN_Create (%d) failed with %#x!", RgnHandle, s32Ret);
RK_MPI_RGN_Destroy(RgnHandle);
return RK_FAILURE;
}
for (RK_S32 i = 0; i < u32ChnNum; i++) {
stRgnChnAttr.bShow = RK_TRUE;
stRgnChnAttr.enType = OVERLAY_RGN;
stRgnChnAttr.unChnAttr.stOverlayChn.stPoint.s32X = 0;
stRgnChnAttr.unChnAttr.stOverlayChn.stPoint.s32Y = 0;
stRgnChnAttr.unChnAttr.stOverlayChn.u32BgAlpha = 0;
stRgnChnAttr.unChnAttr.stOverlayChn.u32FgAlpha = 255;
stRgnChnAttr.unChnAttr.stOverlayChn.u32Layer = i;
s32Ret = RK_MPI_RGN_AttachToChn(RgnHandle, &(pstChn[i]), &stRgnChnAttr);
if (RK_SUCCESS != s32Ret) {
RK_LOGE("RK_MPI_RGN_AttachToChn (%d) failed with %#x!", RgnHandle, s32Ret);
return RK_FAILURE;
}
}
return s32Ret;
}
RK_S32 TEST_RGN_CreateCoverAndAttach(
RGN_HANDLE RgnHandle, const COVER_CHN_ATTR_S *pstCoverAttr,
const MPP_CHN_S *pstChn, RK_U32 u32ChnNum) {
RGN_ATTR_S stRgnAttr;
RGN_CHN_ATTR_S stRgnChnAttr;
RK_S32 s32Ret = RK_SUCCESS;
memset(&stRgnAttr, 0, sizeof(RGN_ATTR_S));
memset(&stRgnChnAttr, 0, sizeof(RGN_CHN_ATTR_S));
stRgnAttr.enType = COVER_RGN;
s32Ret = RK_MPI_RGN_Create(RgnHandle, &stRgnAttr);
if (RK_SUCCESS != s32Ret) {
RK_LOGE("RK_MPI_RGN_Create (%d) failed with %#x!", RgnHandle, s32Ret);
RK_MPI_RGN_Destroy(RgnHandle);
return RK_FAILURE;
}
for (RK_S32 i = 0; i < u32ChnNum; i++) {
stRgnChnAttr.bShow = RK_TRUE;
stRgnChnAttr.enType = COVER_RGN;
memcpy(&(stRgnChnAttr.unChnAttr.stCoverChn), pstCoverAttr, sizeof(COVER_CHN_ATTR_S));
s32Ret = RK_MPI_RGN_AttachToChn(RgnHandle, &(pstChn[i]), &stRgnChnAttr);
if (RK_SUCCESS != s32Ret) {
RK_LOGE("RK_MPI_RGN_AttachToChn (%d) failed with %#x!", RgnHandle, s32Ret);
return RK_FAILURE;
}
}
return s32Ret;
}
RK_S32 TEST_RGN_CreateMosaicAndAttach(
RGN_HANDLE RgnHandle, const MOSAIC_CHN_ATTR_S *pstMosaicAttr,
const MPP_CHN_S *pstChn, RK_U32 u32ChnNum) {
RGN_ATTR_S stRgnAttr;
RGN_CHN_ATTR_S stRgnChnAttr;
RK_S32 s32Ret = RK_SUCCESS;
memset(&stRgnAttr, 0, sizeof(RGN_ATTR_S));
memset(&stRgnChnAttr, 0, sizeof(RGN_CHN_ATTR_S));
stRgnAttr.enType = MOSAIC_RGN;
s32Ret = RK_MPI_RGN_Create(RgnHandle, &stRgnAttr);
if (RK_SUCCESS != s32Ret) {
RK_LOGE("RK_MPI_RGN_Create (%d) failed with %#x!", RgnHandle, s32Ret);
RK_MPI_RGN_Destroy(RgnHandle);
return RK_FAILURE;
}
for (RK_S32 i = 0; i < u32ChnNum; i++) {
stRgnChnAttr.bShow = RK_TRUE;
stRgnChnAttr.enType = MOSAIC_RGN;
memcpy(&(stRgnChnAttr.unChnAttr.stMosaicChn), pstMosaicAttr, sizeof(MOSAIC_CHN_ATTR_S));
s32Ret = RK_MPI_RGN_AttachToChn(RgnHandle, &(pstChn[i]), &stRgnChnAttr);
if (RK_SUCCESS != s32Ret) {
RK_LOGE("RK_MPI_RGN_AttachToChn (%d) failed with %#x!", RgnHandle, s32Ret);
return RK_FAILURE;
}
}
return s32Ret;
}
RK_S32 TEST_RGN_CreateLineAndAttach(
RGN_HANDLE RgnHandle, const LINE_CHN_ATTR_S *pstLineAttr,
const MPP_CHN_S *pstChn, RK_U32 u32ChnNum) {
RGN_ATTR_S stRgnAttr;
RGN_CHN_ATTR_S stRgnChnAttr;
RK_S32 s32Ret = RK_SUCCESS;
memset(&stRgnAttr, 0, sizeof(RGN_ATTR_S));
memset(&stRgnChnAttr, 0, sizeof(RGN_CHN_ATTR_S));
stRgnAttr.enType = LINE_RGN;
s32Ret = RK_MPI_RGN_Create(RgnHandle, &stRgnAttr);
if (RK_SUCCESS != s32Ret) {
RK_LOGE("RK_MPI_RGN_Create (%d) failed with %#x!", RgnHandle, s32Ret);
RK_MPI_RGN_Destroy(RgnHandle);
return RK_FAILURE;
}
for (RK_S32 i = 0; i < u32ChnNum; i++) {
stRgnChnAttr.bShow = RK_TRUE;
stRgnChnAttr.enType = LINE_RGN;
memcpy(&(stRgnChnAttr.unChnAttr.stLineChn), pstLineAttr, sizeof(LINE_CHN_ATTR_S));
s32Ret = RK_MPI_RGN_AttachToChn(RgnHandle, &(pstChn[i]), &stRgnChnAttr);
if (RK_SUCCESS != s32Ret) {
RK_LOGE("RK_MPI_RGN_AttachToChn (%d) failed with %#x!", RgnHandle, s32Ret);
return RK_FAILURE;
}
}
return s32Ret;
}
RK_S32 TEST_RGN_DestroyAndDetach(
RGN_HANDLE RgnHandle, const MPP_CHN_S *pstChn, RK_U32 u32ChnNum) {
RK_S32 s32Ret = RK_SUCCESS;
for (RK_S32 i = 0; i < u32ChnNum; i++) {
s32Ret = RK_MPI_RGN_DetachFromChn(RgnHandle, &(pstChn[i]));
if (RK_SUCCESS != s32Ret) {
RK_LOGE("RK_MPI_RGN_DetachFrmChn (%d) failed with %#x!", RgnHandle, s32Ret);
return RK_FAILURE;
}
}
s32Ret = RK_MPI_RGN_Destroy(RgnHandle);
if (RK_SUCCESS != s32Ret) {
RK_LOGE("RK_MPI_RGN_Destroy [%d] failed with %#x", RgnHandle, s32Ret);
}
return s32Ret;
}
RK_S32 TEST_RGN_ChangePosition(
RGN_HANDLE RgnHandle, const MPP_CHN_S *pstChn, RK_S32 s32X, RK_S32 s32Y) {
RGN_CHN_ATTR_S stChnAttr;
RK_S32 s32Ret = RK_SUCCESS;
if (RK_NULL == pstChn) {
RK_LOGE("input parameter is null. it is invaild!");
return RK_FAILURE;
}
s32Ret = RK_MPI_RGN_GetDisplayAttr(RgnHandle, pstChn, &stChnAttr);
if (RK_SUCCESS != s32Ret) {
RK_LOGE("RK_MPI_RGN_GetDisplayAttr (%d)) failed with %#x!", RgnHandle, s32Ret);
return RK_FAILURE;
}
switch (stChnAttr.enType) {
case OVERLAY_RGN: {
stChnAttr.unChnAttr.stOverlayChn.stPoint.s32X = s32X;
stChnAttr.unChnAttr.stOverlayChn.stPoint.s32Y = s32Y;
} break;
case COVER_RGN: {
stChnAttr.unChnAttr.stCoverChn.stRect.s32X = s32X;
stChnAttr.unChnAttr.stCoverChn.stRect.s32Y = s32Y;
} break;
case MOSAIC_RGN: {
stChnAttr.unChnAttr.stMosaicChn.stRect.s32X = s32X;
stChnAttr.unChnAttr.stMosaicChn.stRect.s32Y = s32Y;
} break;
case LINE_RGN: {
stChnAttr.unChnAttr.stLineChn.stStartPoint.s32X = s32X;
stChnAttr.unChnAttr.stLineChn.stStartPoint.s32Y = s32Y;
} break;
default:
break;
}
s32Ret = RK_MPI_RGN_SetDisplayAttr(RgnHandle, pstChn, &stChnAttr);
if (RK_SUCCESS != s32Ret) {
RK_LOGE("RK_MPI_RGN_SetDisplayAttr (%d)) failed with %#x!", RgnHandle, s32Ret);
return RK_FAILURE;
}
return s32Ret;
}
/******************************************************************************
* funciton : osd region show or hide
******************************************************************************/
RK_S32 TEST_RGN_ShowOrHide(RGN_HANDLE RgnHandle, const MPP_CHN_S *pstChn, RK_BOOL bShow) {
RGN_CHN_ATTR_S stChnAttr;
RK_S32 s32Ret = RK_SUCCESS;
if (RK_NULL == pstChn) {
RK_LOGE("input parameter is null. it is invaild!");
return RK_FAILURE;
}
s32Ret = RK_MPI_RGN_GetDisplayAttr(RgnHandle, pstChn, &stChnAttr);
if (RK_SUCCESS != s32Ret) {
RK_LOGE("RK_MPI_RGN_GetDisplayAttr (%d)) failed with %#x!", RgnHandle, s32Ret);
return RK_FAILURE;
}
stChnAttr.bShow = bShow;
s32Ret = RK_MPI_RGN_SetDisplayAttr(RgnHandle, pstChn, &stChnAttr);
if (RK_SUCCESS != s32Ret) {
RK_LOGE("RK_MPI_RGN_SetDisplayAttr (%d)) failed with %#x!", RgnHandle, s32Ret);
return RK_FAILURE;
}
return RK_SUCCESS;
}
RK_S32 TEST_RGN_ChangeAlpha(
RGN_HANDLE RgnHandle, const MPP_CHN_S *pstChn, RK_U32 u32FgAlpha, RK_U32 u32BgAlpha) {
RGN_CHN_ATTR_S stChnAttr;
RK_S32 s32Ret = RK_SUCCESS;
if (RK_NULL == pstChn) {
RK_LOGE("input parameter is null. it is invaild!");
return RK_FAILURE;
}
s32Ret = RK_MPI_RGN_GetDisplayAttr(RgnHandle, pstChn, &stChnAttr);
if (RK_SUCCESS != s32Ret) {
RK_LOGE("RK_MPI_RGN_GetDisplayAttr (%d)) failed with %#x!", RgnHandle, s32Ret);
return RK_FAILURE;
}
stChnAttr.unChnAttr.stOverlayChn.u32FgAlpha = u32FgAlpha;
stChnAttr.unChnAttr.stOverlayChn.u32BgAlpha = u32BgAlpha;
s32Ret = RK_MPI_RGN_SetDisplayAttr(RgnHandle, pstChn, &stChnAttr);
if (RK_SUCCESS != s32Ret) {
RK_LOGE("RK_MPI_RGN_SetDisplayAttr (%d)) failed with %#x!", RgnHandle, s32Ret);
return RK_FAILURE;
}
return RK_SUCCESS;
}
RK_S32 TEST_RGN_ChangeColor(
RGN_HANDLE RgnHandle, const MPP_CHN_S *pstChn, RK_U32 u32Color) {
RGN_CHN_ATTR_S stChnAttr;
RK_S32 s32Ret = RK_SUCCESS;
if (RK_NULL == pstChn) {
RK_LOGE("input parameter is null. it is invaild!");
return RK_FAILURE;
}
s32Ret = RK_MPI_RGN_GetDisplayAttr(RgnHandle, pstChn, &stChnAttr);
if (RK_SUCCESS != s32Ret) {
RK_LOGE("RK_MPI_RGN_GetDisplayAttr (%d)) failed with %#x!", RgnHandle, s32Ret);
return RK_FAILURE;
}
if (stChnAttr.enType == COVER_RGN) {
stChnAttr.unChnAttr.stCoverChn.u32Color = u32Color;
} else if (stChnAttr.enType == LINE_RGN) {
stChnAttr.unChnAttr.stLineChn.u32Color = u32Color;
}
s32Ret = RK_MPI_RGN_SetDisplayAttr(RgnHandle, pstChn, &stChnAttr);
if (RK_SUCCESS != s32Ret) {
RK_LOGE("RK_MPI_RGN_SetDisplayAttr (%d)) failed with %#x!", RgnHandle, s32Ret);
return RK_FAILURE;
}
return RK_SUCCESS;
}
RK_S32 TEST_RGN_LoadBmp(const RK_CHAR *filename, BITMAP_S *pstBitmap, PIXEL_FORMAT_E enBmpFmt) {
OSD_SURFACE_S Surface;
OSD_BITMAPFILEHEADER bmpFileHeader;
OSD_BITMAPINFO bmpInfo;
if (TEST_COMM_GetBmpInfo(filename, &bmpFileHeader, &bmpInfo) < 0) {
RK_LOGE("GetBmpInfo err!\n");
return RK_FAILURE;
}
switch (enBmpFmt) {
case RK_FMT_ARGB8888:
Surface.enColorFmt = OSD_COLOR_FMT_ARGB8888;
break;
case RK_FMT_BGRA8888:
Surface.enColorFmt = OSD_COLOR_FMT_BGRA8888;
break;
case RK_FMT_ARGB1555:
Surface.enColorFmt = OSD_COLOR_FMT_ARGB1555;
break;
case RK_FMT_BGRA5551:
Surface.enColorFmt = OSD_COLOR_FMT_BGRA5551;
break;
case RK_FMT_ARGB4444:
Surface.enColorFmt = OSD_COLOR_FMT_ARGB4444;
break;
case RK_FMT_BGRA4444:
Surface.enColorFmt = OSD_COLOR_FMT_BGRA4444;
break;
default:
return RK_FAILURE;
}
pstBitmap->pData = malloc(4 * (bmpInfo.bmiHeader.biWidth) * (bmpInfo.bmiHeader.biHeight));
if (RK_NULL == pstBitmap->pData) {
RK_LOGE("malloc osd memroy err!");
return RK_FAILURE;
}
TEST_COMM_CreateSurfaceByBitmap(filename, &Surface, reinterpret_cast<RK_U8 *>(pstBitmap->pData));
pstBitmap->u32Width = Surface.u16Width;
pstBitmap->u32Height = Surface.u16Height;
pstBitmap->enPixelFormat = (PIXEL_FORMAT_E)enBmpFmt;
return RK_SUCCESS;
}
RK_S32 TEST_RGN_CreateBmp(RK_U32 u32Width, RK_U32 u32Height, PIXEL_FORMAT_E enBmpFmt, BITMAP_S *pstBitmap) {
RK_S32 s32Ret = RK_SUCCESS;
PIC_BUF_ATTR_S stBuffAttr;
MB_PIC_CAL_S stPicCal;
RK_U8 *pu8Data = RK_NULL;
stBuffAttr.u32Width = u32Width;
stBuffAttr.u32Height = u32Height;
stBuffAttr.enPixelFormat = enBmpFmt;
stBuffAttr.enCompMode = COMPRESS_MODE_NONE;
s32Ret = RK_MPI_CAL_COMM_GetPicBufferSize(&stBuffAttr, &stPicCal);
if (RK_SUCCESS != s32Ret) {
RK_LOGE("RK_MPI_CAL_COMM_GetPicBufferSize failed with %#x!", s32Ret);
return s32Ret;
}
pu8Data = (RK_U8 *)malloc(stPicCal.u32MBSize);
// in order to diff raw map data, set 64 frame cnt
s32Ret = TEST_COMM_FillImage(pu8Data, u32Width, u32Height,
u32Width, u32Height, enBmpFmt, 64);
if (RK_SUCCESS != s32Ret) {
RK_LOGE("TEST_COMM_FillImage failed with %#x!", s32Ret);
return s32Ret;
}
pstBitmap->u32Width = u32Width;
pstBitmap->u32Height = u32Height;
pstBitmap->enPixelFormat = enBmpFmt;
pstBitmap->pData = (RK_VOID *)pu8Data;
return s32Ret;
}
#ifdef __cplusplus
#if __cplusplus
}
#endif
#endif /* End of #ifdef __cplusplus */