sdk-hwV1.3/external/eyesee-mpp/middleware/sun8iw21/media/librender/video_render_linux.cpp

378 lines
14 KiB
C++
Raw Normal View History

2024-05-07 10:09:20 +00:00
/*******************************************************************************
-- --
-- CedarX Multimedia Framework --
-- --
-- the Multimedia Framework for Linux/Android System --
-- --
-- This software is confidential and proprietary and may be used --
-- only as expressly authorized by a licensing agreement from --
-- Softwinner Products. --
-- --
-- (C) COPYRIGHT 2011 SOFTWINNER PRODUCTS --
-- ALL RIGHTS RESERVED --
-- --
-- The entire notice above must be reproduced --
-- on all copies and should not be removed. --
-- --
*******************************************************************************/
//#define LOG_NDEBUG 0
#define LOG_TAG "video_render_linux"
#include <utils/plat_log.h>
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <CdxANativeWindowBuffer.h>
//#include <CDX_CallbackType.h>
#include <memoryAdapter.h>
#include <vdecoder.h>
#include <vencoder.h>
#include "video_render.h"
#include <CedarXNativeRenderer.h>
#include <hwdisplay.h>
#include <CDX_ErrorType.h>
#include <MetaData.h>
#include <CedarXMetaData.h>
#include <mm_comm_video.h>
#include <ConfigOption.h>
using namespace EyeseeLinux;
class VR4LData
{
public:
CedarXRenderer *mVideoRenderer;
bool mbFirstFrame; //wait first frame.
bool mbShowFlag;
//struct ScMemOpsS *mMemOps;
VR4LData()
{
mVideoRenderer = NULL;
mbFirstFrame = true;
mbShowFlag = true;
//mMemOps = MemAdapterGetOpsS();
};
};
CdxPixelFormat convertPixelFormatVdec2Cdx(EPIXELFORMAT format)
{
if(format == PIXEL_FORMAT_YUV_MB32_422)
{
return CDX_PIXEL_FORMAT_AW_MB422; //VIRTUAL_HWC_FORMAT_MBYUV422
}
else if (format == PIXEL_FORMAT_YUV_MB32_420)
{
return CDX_PIXEL_FORMAT_AW_MB420; //VIRTUAL_HWC_FORMAT_MBYUV420
}
else if(format == PIXEL_FORMAT_YV12)
{
return CDX_PIXEL_FORMAT_YV12;//(int32_t)HAL_PIXEL_FORMAT_YV12; VIRTUAL_HWC_FORMAT_YUV420PLANAR
}
else if(format == PIXEL_FORMAT_YUV_PLANER_420)
{
return CDX_PIXEL_FORMAT_AW_YUV_PLANNER420;
}
else if(format == PIXEL_FORMAT_NV21)
{
return CDX_PIXEL_FORMAT_YCrCb_420_SP;//(int32_t)HAL_PIXEL_FORMAT_YV12; VIRTUAL_HWC_FORMAT_YUV420VUC
}
else if(format == PIXEL_FORMAT_NV12)
{
return CDX_PIXEL_FORMAT_AW_NV12;
}
else if(format == PIXEL_FORMAT_PLANARUV_422)
{
return CDX_PIXEL_FORMAT_YCbCr_422_SP;
}
else if(format == PIXEL_FORMAT_PLANARVU_422)
{
return CDX_PIXEL_FORMAT_AW_NV61;
}
else if(format == PIXEL_FORMAT_YUYV)
{
return CDX_PIXEL_FORMAT_YCbCr_422_I;
}
else if(format == PIXEL_FORMAT_ARGB)
{
return CDX_PIXEL_FORMAT_AW_ARGB_8888;
}
else
{
alogw("fatal error! format=0x%x", format);
return CDX_PIXEL_FORMAT_AW_MB420; //* format should be CEDARV_PIXEL_FORMAT_MB_UV_COMBINED_YUV420, VIRTUAL_HWC_FORMAT_MBYUV420
}
}
int config_libhwclayerpara_t(libhwclayerpara_t *pHwcPara, VIDEO_FRAME_INFO_S *pVPic/*, struct ScMemOpsS *pMemOps*/)
{
memset(pHwcPara, 0, sizeof(libhwclayerpara_t));
//ALOGD("(f:%s, l:%d) printVideoPicture:[%d][%p][%p][%p][%p]", __FUNCTION__, __LINE__, pVPic->ePixelFormat, pVPic->pData0, pVPic->pData1, pVPic->pData2, pVPic->pData3);
pHwcPara->number = pVPic->mId;
// pHwcPara->top_y = (unsigned long)(intptr_t)CdcMemGetPhysicAddressCpu(pMemOps, pVPic->pData0);
// pHwcPara->top_c = (unsigned long)(intptr_t)CdcMemGetPhysicAddressCpu(pMemOps, pVPic->pData1);
// if(pVPic->pData2)
// {
// pHwcPara->bottom_y = (unsigned long)(intptr_t)CdcMemGetPhysicAddressCpu(pMemOps, pVPic->pData2);
// }
// if(pVPic->pData3)
// {
// pHwcPara->bottom_c = (unsigned long)(intptr_t)CdcMemGetPhysicAddressCpu(pMemOps, pVPic->pData2);
// }
pHwcPara->top_y = pVPic->VFrame.mPhyAddr[0];
pHwcPara->top_c = pVPic->VFrame.mPhyAddr[1];
pHwcPara->bottom_y = pVPic->VFrame.mPhyAddr[2];
if (VIDEO_FIELD_FRAME == pVPic->VFrame.mField)
{
pHwcPara->bProgressiveSrc = 1;
}
else
{
pHwcPara->bProgressiveSrc = 0;
}
pHwcPara->bTopFieldFirst = 1;
#if 1 //deinterlace support
// pHwcPara->flag_addr = (unsigned long)(intptr_t)pVPic->pMafData;
// pHwcPara->flag_stride = pVPic->nMafFlagStride;
// pHwcPara->maf_valid = pVPic->bMafValid;
// pHwcPara->pre_frame_valid = pVPic->bPreFrmValid;
pHwcPara->flag_addr = 0;
pHwcPara->flag_stride = 0;
pHwcPara->maf_valid = 0;
pHwcPara->pre_frame_valid = 0;
#endif
return 0;
}
static int vr4l_init(struct CDX_VideoRenderHAL *handle, int nRenderMode, void *pIn, void *pOut)
{
if(handle->mPriv != NULL)
{
aloge("fatal error! CDX_VideoRenderHAL->mPriv[%p] is not null!", handle->mPriv);
delete (VR4LData*)handle->mPriv;
handle->mPriv = NULL;
}
VR4LData *pVR4LData = new VR4LData;
handle->mPriv = (void*)pVR4LData;
int nDisplayTopX = 0;
int nDisplayTopY = 0;
int nDisplayWidth;
int nDisplayHeight;
int nFrameBufWidth;
int nFrameBufHeight;
int nFrameCount = -1;
int nGUIInitRotation = 0;
CdxPixelFormat nDisplayFormat; //CDX_PIXEL_FORMAT_YV12
VENC_COLOR_SPACE nColorSpace = VENC_BT601;
VO_LAYER nVideoLayerId = -1;
//int nVideoScalingMode;
if(nRenderMode == VideoRender_HW)
{
CdxVRHwcLayerInitPara *pHwInitPara = (CdxVRHwcLayerInitPara*)pIn;
nDisplayTopX = pHwInitPara->mnDisplayTopX;
nDisplayTopY = pHwInitPara->mnDisplayTopY;
nDisplayWidth = pHwInitPara->mnDisplayWidth;
nDisplayHeight = pHwInitPara->mnDisplayHeight;
nFrameBufWidth = pHwInitPara->mnBufWidth;
nFrameBufHeight = pHwInitPara->mnBufHeight;
nDisplayFormat = convertPixelFormatVdec2Cdx((EPIXELFORMAT)pHwInitPara->mePixelFormat);
nColorSpace = (VENC_COLOR_SPACE)pHwInitPara->mColorSpace;
nVideoLayerId = pHwInitPara->mVoLayer;
}
else if(nRenderMode == VideoRender_SW)
{
CdxVRSWANWInitPara *pSwInitPara = (CdxVRSWANWInitPara*)pIn;
nDisplayWidth = pSwInitPara->mnDisplayWidth;
nDisplayHeight = pSwInitPara->mnDisplayHeight;
nFrameBufWidth = pSwInitPara->mnBufWidth;
nFrameBufHeight = pSwInitPara->mnBufHeight;
nDisplayFormat = convertPixelFormatVdec2Cdx((EPIXELFORMAT)pSwInitPara->mePixelFormat);
}
else if(nRenderMode == VideoRender_GUI)
{
CdxVRANWInitPara *pAnwInitPara = (CdxVRANWInitPara*)pIn;
nDisplayWidth = -1;
nDisplayHeight = -1;
nFrameBufWidth = pAnwInitPara->mnBufWidth;
nFrameBufHeight = pAnwInitPara->mnBufHeight;
nFrameCount = pAnwInitPara->mnBufNum;
nDisplayFormat = convertPixelFormatVdec2Cdx((EPIXELFORMAT)pAnwInitPara->mePixelFormat);
}
else
{
aloge("fatal error! what render mode[%d]?", nRenderMode);
return CDX_ERROR;
}
MetaData *meta = new MetaData;
meta->setInt32(kKeyColorFormat, nDisplayFormat);
meta->setInt32(kKeyWidth, nFrameBufWidth);
meta->setInt32(kKeyHeight, nFrameBufHeight);
meta->setInt32(kCedarXKeyDisplayTopX, nDisplayTopX);
meta->setInt32(kCedarXKeyDisplayTopY, nDisplayTopY);
meta->setInt32(kKeyDisplayWidth, nDisplayWidth);
meta->setInt32(kKeyDisplayHeight, nDisplayHeight);
meta->setInt32(kKeyRotation, nGUIInitRotation);
//meta->setInt32(kKeyIsDRM, mIsDRMMedia);
meta->setInt32(kCedarXKeyFrameCount, nFrameCount);
meta->setInt32(kCedarXKeyColorSpace, nColorSpace);
meta->setInt32(kCedarXKeyVideoLayer, nVideoLayerId);
if(nRenderMode == VideoRender_HW)//HWC_FORMAT_YUV420PLANAR, HAL_PIXEL_FORMAT_YV12)
{
#if (CDXCFG_HW_DISPLAY == OPTION_HW_DISPLAY_ENABLE)
alogd("mDisplayFormat[0x%x], new CedarXNativeRenderer", nDisplayFormat);
pVR4LData->mVideoRenderer = new CedarXNativeRenderer(nVideoLayerId, meta);
#else
aloge("fatal error! renderMode is HW, why CDXCFG HW DISPLAY is not OPTION_HW_DISPLAY_ENABLE?");
assert(0);
#endif
}
else if(nRenderMode == VideoRender_SW)
{
#if (CDXCFG_HW_DISPLAY == OPTION_HW_DISPLAY_DISABLE)
alogd("mDisplayFormat[0x%x], new CedarXSoftwareRenderer", nDisplayFormat);
pVR4LData->mVideoRenderer = new CedarXSoftwareRenderer(mNativeWindow, meta);
#else
aloge("fatal error! renderMode is SW, why CDXCFG HW DISPLAY is not OPTION_HW_DISPLAY_DISABLE?");
assert(0);
#endif
}
else if(nRenderMode == VideoRender_GUI)
{
#if (CDXCFG_HW_DISPLAY == OPTION_HW_DISPLAY_DISABLE)
alogd("mDisplayFormat[0x%x], new CedarXNativeWindowRenderer", mDisplayFormat);
pVR4LData->mVideoRenderer = new CedarXNativeWindowRenderer(mNativeWindow, meta, mIonFd);
pVR4LData->mVideoRenderer->control(VIDEORENDER_CMD_GET_ANATIVEWINDOWBUFFERS, 0, pOut);
#else
aloge("fatal error! renderMode is GUI, why CDXCFG HW DISPLAY is not OPTION_HW_DISPLAY_DISABLE?");
assert(0);
#endif
}
else
{
aloge("fatal error! unknown renderMode[%d]", nRenderMode);
assert(0);
}
//pVR4LData->mVideoRenderer->control(VIDEORENDER_CMD_SET_SCALING_MODE, nVideoScalingMode, NULL);
return CDX_OK;
}
static void vr4l_exit(struct CDX_VideoRenderHAL *handle)
{
if(handle->mPriv)
{
VR4LData *pVR4LData = (VR4LData*)handle->mPriv;
pVR4LData->mVideoRenderer->control(VIDEORENDER_CMD_SHOW, 0, NULL);
delete pVR4LData->mVideoRenderer;
pVR4LData->mVideoRenderer = NULL;
delete pVR4LData;
handle->mPriv = NULL;
}
else
{
alogd("VideoRenderHal not init when exit.");
}
}
static int vr4l_render(struct CDX_VideoRenderHAL *handle, void *frame_info, int frame_id)
{
VR4LData *pVR4LData = (VR4LData*)handle->mPriv;
#if (CDXCFG_HW_DISPLAY == OPTION_HW_DISPLAY_ENABLE)
if(pVR4LData->mVideoRenderer != NULL)
{
VIDEO_FRAME_INFO_S *frm_inf = (VIDEO_FRAME_INFO_S*) frame_info;
libhwclayerpara_t hwcLayerPara;
config_libhwclayerpara_t(&hwcLayerPara, frm_inf/*, pVR4LData->mMemOps*/);
pVR4LData->mVideoRenderer->render(&hwcLayerPara, 0);
if(pVR4LData->mbFirstFrame)
{
if(pVR4LData->mbShowFlag)
{
pVR4LData->mVideoRenderer->control(VIDEORENDER_CMD_SHOW, 1, NULL);
}
pVR4LData->mbFirstFrame = false;
}
}
else
{
alogd("mVideoRenderer=NULL");
}
#else
//#error "renderMode is GUI, why call StagefrightVideoRenderData()?"
aloge("fatal error! renderMode is GUI, why call StagefrightVideoRenderData()?");
#endif
return 0;
}
static int vr4l_set_showflag(struct CDX_VideoRenderHAL *handle, int bShowFlag)
{
VR4LData *pVR4LData = (VR4LData*)handle->mPriv;
pVR4LData->mbShowFlag = bShowFlag!=0?true:false;
#if (CDXCFG_HW_DISPLAY == OPTION_HW_DISPLAY_ENABLE)
if(pVR4LData->mVideoRenderer != NULL)
{
if(false == pVR4LData->mbFirstFrame)
{
pVR4LData->mVideoRenderer->control(VIDEORENDER_CMD_SHOW, bShowFlag, NULL);
}
}
else
{
alogd("mVideoRenderer=NULL");
}
#else
//#error "renderMode is GUI, why call StagefrightVideoRenderData()?"
aloge("fatal error! renderMode is GUI, why call StagefrightVideoRenderData()?");
#endif
return 0;
}
static int vr4l_update_display_size(struct CDX_VideoRenderHAL *handle, void *pFrameInfo)
{
VR4LData *pVR4LData = (VR4LData*)handle->mPriv;
#if (CDXCFG_HW_DISPLAY == OPTION_HW_DISPLAY_ENABLE)
if(pVR4LData->mVideoRenderer != NULL)
{
CdxVRFrameInfo *pDisplayRect = (CdxVRFrameInfo*)pFrameInfo;
//RECT_S crop = {pDisplayRect->mnDisplayTopX, pDisplayRect->mnDisplayTopY, (unsigned int)pDisplayRect->mnDisplayWidth, (unsigned int)pDisplayRect->mnDisplayHeight};
pVR4LData->mVideoRenderer->control(VIDEORENDER_CMD_SET_CROP, 0, pDisplayRect);
}
else
{
alogd("mVideoRenderer=NULL");
}
#else
aloge("fatal error! renderMode is GUI, not implement");
#endif
return CDX_OK;
}
//extern "C" {
CDX_VideoRenderHAL video_render_linux_hal = {
info: "video render hal for linux",
callback_info: NULL,
mPriv: NULL,
init: vr4l_init,
exit: vr4l_exit,
render: vr4l_render,
get_disp_frame_id: NULL,
set_showflag: vr4l_set_showflag,
dequeue_frame: NULL, //request frame from gpu
enqueue_frame: NULL, //release frame to gpu
cancel_frame: NULL,
update_display_size: vr4l_update_display_size,
};
//}