【已实现】两路sensor图像叠加编码

qn1540561804 · 发表于 2018-12-27 18:44:15

本帖最后由 qn1540561804 于 2019-4-12 11:20 编辑

如题，hi3519接入可见和红外摄像头，怎么实现两幅图像透明叠加成一幅图？

谢谢

补充内容 (2018-12-29 14:13):
红外光640*480，可见光1080P
第一步，数据覆盖；
第二步，半透明叠加。

补充内容 (2019-1-22 10:35):
代码实现见16楼的附件

qn1540561804 · 发表于 2019-1-22 10:08:46

本帖最后由 qn1540561804 于 2019-1-22 10:34 编辑

gongyounan 发表于 2019-1-21 17:54
牛啊！楼主做下来有多少帧啊

使用memcpy的方式只有5帧；
缩放使用VGS，数据搬移和透明叠加使用IVE实现之后，25帧没有问题；
需要注意的是缩放超过8192的问题，可以先抠图再缩放
代码实现见附件

qn1540561804 · 发表于 2019-1-7 16:04:12

本帖最后由 qn1540561804 于 2019-4-12 11:11 编辑

缩放使用VGS，数据搬移和透明叠加使用IVE实现

qn1540561804 · 发表于 2018-12-27 21:04:24

本帖最后由 qn1540561804 于 2018-12-27 21:05 编辑

各自从VPSS ch取帧，合并成一帧，然后送venc编码？

AOC · 发表于 2018-12-27 21:56:34

融合，这个一般不好做啊

qn1540561804 · 发表于 2018-12-28 10:39:19

顶一下，别沉

qn1540561804 · 发表于 2018-12-28 19:46:49

本帖最后由 qn1540561804 于 2019-4-12 11:05 编辑

static int AF_PIPCombineFrame(VIDEO_FRAME_INFO_S *pstFrameDst, VIDEO_FRAME_INFO_S *pstFrameSrc)
{
if (pstFrameDst == NULL || pstFrameSrc == NULL)
return -1;
int nStartX = 0;
int nStartY = pstFrameDst->stVFrame.u32Height - pstFrameSrc->stVFrame.u32Height;
int i = 0;
// YUV 420SP
for (i = 0; i < pstFrameSrc->stVFrame.u32Height; i++)
{
int nY = i + nStartY;
// Y分量
void *pDst = pstFrameDst->stVFrame.pVirAddr[0] + (nY * pstFrameDst->stVFrame.u32Stride[0]) + nStartX;
void *pSrc = pstFrameSrc->stVFrame.pVirAddr[0] + (i * pstFrameSrc->stVFrame.u32Stride[0]);
memcpy(pDst, pSrc, pstFrameSrc->stVFrame.u32Stride[0]);
// UV分量
if ((i % 2) == 0)
{
pDst = pstFrameDst->stVFrame.pVirAddr[0] + (pstFrameDst->stVFrame.u32Height * pstFrameDst->stVFrame.u32Stride[0]) + ((nY * pstFrameDst->stVFrame.u32Stride[0]) + nStartX) / 2;
pSrc = pstFrameSrc->stVFrame.pVirAddr[0] + (pstFrameSrc->stVFrame.u32Height * pstFrameSrc->stVFrame.u32Stride[0]) + (i * pstFrameSrc->stVFrame.u32Stride[0]) / 2;
memcpy(pDst, pSrc, pstFrameSrc->stVFrame.u32Stride[0] / 2);
}
}
return 0;
}
static void *AF_PIPThread(void *p)
{
AF_PIPThreadParam *pstPara = (AF_PIPThreadParam*)p;
VENC_CHN VencChn = pstPara->nVencCh;
VPSS_GRP nVpssGrpMain = pstPara->nVpssGrpMain;
VPSS_CHN nVpssChMain = pstPara->nVpssChMain;
VPSS_GRP nVpssGrpSub = pstPara->nVpssGrpSub;
VPSS_CHN nVpssChSub = pstPara->nVpssChSub;
VIDEO_FRAME_INFO_S stFrameMain;
VIDEO_FRAME_INFO_S stFrameSub;
VIDEO_FRAME_INFO_S stFramePIP;
VB_BLK VbBlk = VB_INVALID_HANDLE;
while (HI_TRUE == pstPara->bThreadRun) {
memset(&stFrameMain, 0, sizeof(stFrameMain));
memset(&stFrameSub, 0, sizeof(stFrameSub));
memset(&stFramePIP, 0, sizeof(stFramePIP));
// printf("nVpssGrpMain %d nVpssChMain %d nVpssGrpSub %d nVpssChSub %d, VencChn %d\n", nVpssGrpMain, nVpssChMain, nVpssGrpSub, nVpssChSub, VencChn);
HI_S32 s32Ret = HI_MPI_VPSS_GetChnFrame(nVpssGrpMain, nVpssChMain, &stFrameMain, -1);
if (HI_SUCCESS != s32Ret) {
printf("HI_MPI_VPSS_GetChnFrame failed s32ret[%#x]\n", s32Ret);
break;
}
s32Ret = HI_MPI_VPSS_GetChnFrame(nVpssGrpSub, nVpssChSub, &stFrameSub, -1);
if (HI_SUCCESS != s32Ret) {
printf("HI_MPI_VPSS_GetChnFrame failed s32ret[%#x]\n", s32Ret);
break;
}
do {
VbBlk = HI_MPI_VB_GetBlock(VB_INVALID_POOLID, stFrameMain.stVFrame.u32Stride[0] * stFrameMain.stVFrame.u32Height * 3 / 2, NULL);
} while (VB_INVALID_HANDLE == VbBlk);
VB_POOL poolID = HI_MPI_VB_Handle2PoolId(VbBlk);
stFramePIP.stVFrame.u32PhyAddr[0] = HI_MPI_VB_Handle2PhysAddr(VbBlk);
if (stFramePIP.stVFrame.u32PhyAddr[0] == 0) {
printf("HI_MPI_VB_Handle2PhysAddr for VbBlk failed\n");
break;
}
stFramePIP.u32PoolId = poolID;
stFramePIP.stVFrame.u32Width = stFrameMain.stVFrame.u32Width;
stFramePIP.stVFrame.u32Height = stFrameMain.stVFrame.u32Height;
stFramePIP.stVFrame.u32Field = stFrameMain.stVFrame.u32Field;
stFramePIP.stVFrame.enPixelFormat = stFrameMain.stVFrame.enPixelFormat;
stFramePIP.stVFrame.enVideoFormat = stFrameMain.stVFrame.enVideoFormat;
stFramePIP.stVFrame.enCompressMode = stFrameMain.stVFrame.enCompressMode;
stFramePIP.stVFrame.pVirAddr[0] = (HI_U32*)HI_MPI_SYS_Mmap(stFramePIP.stVFrame.u32PhyAddr[0], stFrameMain.stVFrame.u32Stride[0] * stFrameMain.stVFrame.u32Height * 3 / 2);
stFramePIP.stVFrame.pVirAddr[1] = stFramePIP.stVFrame.pVirAddr[0] + stFrameMain.stVFrame.u32Stride[0] * stFrameMain.stVFrame.u32Height;
// stFramePIP.stVFrame.pVirAddr[2] = stFramePIP.stVFrame.pVirAddr[1];
stFramePIP.stVFrame.u32Stride[0] = stFrameMain.stVFrame.u32Stride[0];
stFramePIP.stVFrame.u32Stride[1] = stFrameMain.stVFrame.u32Stride[1];
stFramePIP.stVFrame.u32Stride[2] = stFrameMain.stVFrame.u32Stride[2];
// stFramePIP.stVFrame.u32HeaderPhyAddr[0];
// stFramePIP.stVFrame.u32HeaderPhyAddr[1];
// stFramePIP.stVFrame.u32HeaderPhyAddr[2];
// stFramePIP.stVFrame.pHeaderVirAddr[0];
// stFramePIP.stVFrame.pHeaderVirAddr[1];
// stFramePIP.stVFrame.pHeaderVirAddr[2];
// stFramePIP.stVFrame.u32HeaderStride[0];
// stFramePIP.stVFrame.u32HeaderStride[1];
// stFramePIP.stVFrame.u32HeaderStride[2];
stFramePIP.stVFrame.s16OffsetTop = stFrameMain.stVFrame.s16OffsetTop;
stFramePIP.stVFrame.s16OffsetBottom = stFrameMain.stVFrame.s16OffsetBottom;
stFramePIP.stVFrame.s16OffsetLeft = stFrameMain.stVFrame.s16OffsetLeft;
stFramePIP.stVFrame.s16OffsetRight = stFrameMain.stVFrame.s16OffsetRight;
stFramePIP.stVFrame.u64pts = stFrameMain.stVFrame.u64pts;
stFramePIP.stVFrame.u32TimeRef = stFrameMain.stVFrame.u32TimeRef;
// stFramePIP.stVFrame.u32PrivateData;
// stFramePIP.stVFrame.stSupplement;
stFrameMain.stVFrame.pVirAddr[0] = (HI_U32*)HI_MPI_SYS_Mmap(stFrameMain.stVFrame.u32PhyAddr[0], stFrameMain.stVFrame.u32Stride[0] * stFrameMain.stVFrame.u32Height * 3 / 2);
stFrameSub.stVFrame.pVirAddr[0] = (HI_U32*)HI_MPI_SYS_Mmap(stFrameSub.stVFrame.u32PhyAddr[0], stFrameSub.stVFrame.u32Stride[0] * stFrameSub.stVFrame.u32Height * 3 / 2);
memcpy(stFramePIP.stVFrame.pVirAddr[0], stFrameMain.stVFrame.pVirAddr[0], stFrameMain.stVFrame.u32Stride[0] * stFrameMain.stVFrame.u32Height * 3 / 2);
AF_PIPCombineFrame(&stFramePIP, &stFrameSub);
// s32Ret = HI_MPI_VENC_SendFrame(VencChn, &stFramePIP, -1);
s32Ret = HI_MPI_VENC_SendFrame(5, &stFramePIP, -1);
if (HI_SUCCESS != s32Ret) {
printf("HI_MPI_VENC_SendFrame VencChn %d failed s32ret[%#x]\n", VencChn, s32Ret);
// break;
}
HI_MPI_SYS_Munmap(stFramePIP.stVFrame.pVirAddr[0], stFramePIP.stVFrame.u32Stride[0] * stFramePIP.stVFrame.u32Height * 3 / 2);
HI_MPI_SYS_Munmap(stFrameMain.stVFrame.pVirAddr[0], stFrameMain.stVFrame.u32Stride[0] * stFrameMain.stVFrame.u32Height * 3 / 2);
HI_MPI_SYS_Munmap(stFrameSub.stVFrame.pVirAddr[0], stFrameSub.stVFrame.u32Stride[0] * stFrameSub.stVFrame.u32Height * 3 / 2);
s32Ret = HI_MPI_VB_ReleaseBlock(VbBlk);
if (HI_SUCCESS != s32Ret) {
printf("vb release block failed![%#x]\n", s32Ret);
break;
}
HI_MPI_VPSS_ReleaseChnFrame(nVpssGrpSub, nVpssChSub, &stFrameSub);
HI_MPI_VPSS_ReleaseChnFrame(nVpssGrpMain, nVpssChMain, &stFrameMain);
pthread_mutex_lock(&pstPara->atrrMutex);
nVpssGrpMain = pstPara->nVpssGrpMain;
nVpssChMain = pstPara->nVpssChMain;
nVpssGrpSub = pstPara->nVpssGrpSub;
nVpssChSub = pstPara->nVpssChSub;
pthread_mutex_unlock(&pstPara->atrrMutex);
}
return NULL;
}

复制代码

// ----------------------------------------------------------------
// 如题，
// 数据都是YUV420SP的，stFrameMain.stVFrame.u32Stride[0] = 1920; stFrameMain.stVFrame.u32Height = 1080;
// stFrameSub.stVFrame.u32Stride[0] = 640; stFrameSub.stVFrame.u32Height = 360;
// s32Ret = HI_MPI_VENC_SendFrame(5, &stFramePIP, -1);报错0xa0088003
// 修改为s32Ret = HI_MPI_VENC_SendFrame(5, &stFrameMain, -1);编码正常
// 不太清楚哪里出现问题，求大神指点下

qn1540561804 · 发表于 2018-12-29 11:22:48

本帖最后由 qn1540561804 于 2019-4-12 11:05 编辑

// 代码修改如下：

static void *AF_PIPThread(void *p)
{
AF_PIPThreadParam *pstPara = (AF_PIPThreadParam*)p;
VENC_CHN VencChn = pstPara->nVencCh;
VPSS_GRP nVpssGrpMain = pstPara->nVpssGrpMain;
VPSS_CHN nVpssChMain = pstPara->nVpssChMain;
VPSS_GRP nVpssGrpSub = pstPara->nVpssGrpSub;
VPSS_CHN nVpssChSub = pstPara->nVpssChSub;
VIDEO_FRAME_INFO_S stFrameMain;
VIDEO_FRAME_INFO_S stFrameSub;
VIDEO_FRAME_INFO_S stFramePIP;
VB_BLK VbBlk = VB_INVALID_HANDLE;
while (HI_TRUE == pstPara->bThreadRun) {
memset(&stFrameMain, 0, sizeof(stFrameMain));
memset(&stFrameSub, 0, sizeof(stFrameSub));
memset(&stFramePIP, 0, sizeof(stFramePIP));
HI_S32 s32Ret = HI_MPI_VPSS_GetChnFrame(nVpssGrpMain, nVpssChMain, &stFrameMain, -1);
if (HI_SUCCESS != s32Ret) {
printf("HI_MPI_VPSS_GetChnFrame failed s32ret[%#x]\n", s32Ret);
break;
}
s32Ret = HI_MPI_VPSS_GetChnFrame(nVpssGrpSub, nVpssChSub, &stFrameSub, -1);
if (HI_SUCCESS != s32Ret) {
printf("HI_MPI_VPSS_GetChnFrame failed s32ret[%#x]\n", s32Ret);
break;
}
do {
VbBlk = HI_MPI_VB_GetBlock(VB_INVALID_POOLID, (stFrameMain.stVFrame.u32Stride[0] + stFrameMain.stVFrame.u32HeaderStride[0]) * stFrameMain.stVFrame.u32Height * 3 / 2, NULL);
} while (VB_INVALID_HANDLE == VbBlk);
VB_POOL poolID = HI_MPI_VB_Handle2PoolId(VbBlk);
stFramePIP.stVFrame.u32HeaderPhyAddr[0] = HI_MPI_VB_Handle2PhysAddr(VbBlk);
stFramePIP.stVFrame.u32HeaderPhyAddr[1] = stFramePIP.stVFrame.u32HeaderPhyAddr[0] + stFrameMain.stVFrame.u32HeaderStride[0] * stFrameMain.stVFrame.u32Height;
// stFramePIP.stVFrame.u32HeaderPhyAddr[2] = stFramePIP.stVFrame.u32HeaderPhyAddr[1];
stFramePIP.stVFrame.u32PhyAddr[0] = stFramePIP.stVFrame.u32HeaderPhyAddr[0] + stFrameMain.stVFrame.u32HeaderStride[0] * stFrameMain.stVFrame.u32Height * 3 / 2;
stFramePIP.stVFrame.u32PhyAddr[1] = stFramePIP.stVFrame.u32PhyAddr[0] + stFrameMain.stVFrame.u32Stride[0] * stFrameMain.stVFrame.u32Height;
stFramePIP.stVFrame.u32PhyAddr[2] = stFramePIP.stVFrame.u32PhyAddr[1];
stFramePIP.u32PoolId = poolID;
stFramePIP.stVFrame.u32Width = stFrameMain.stVFrame.u32Width;
stFramePIP.stVFrame.u32Height = stFrameMain.stVFrame.u32Height;
stFramePIP.stVFrame.u32Field = stFrameMain.stVFrame.u32Field;
stFramePIP.stVFrame.enPixelFormat = stFrameMain.stVFrame.enPixelFormat;
stFramePIP.stVFrame.enVideoFormat = stFrameMain.stVFrame.enVideoFormat;
stFramePIP.stVFrame.enCompressMode = stFrameMain.stVFrame.enCompressMode;
stFramePIP.stVFrame.pHeaderVirAddr[0] = (HI_U32*)HI_MPI_SYS_Mmap(stFramePIP.stVFrame.u32HeaderPhyAddr[0], (stFrameMain.stVFrame.u32Stride[0] + stFrameMain.stVFrame.u32HeaderStride[0]) * stFrameMain.stVFrame.u32Height * 3 / 2);
stFramePIP.stVFrame.pHeaderVirAddr[1] = stFramePIP.stVFrame.pHeaderVirAddr[0] + stFrameMain.stVFrame.u32HeaderStride[0] * stFrameMain.stVFrame.u32Height;
// stFramePIP.stVFrame.pHeaderVirAddr[2] = stFramePIP.stVFrame.pHeaderVirAddr[1];
stFramePIP.stVFrame.pVirAddr[0] = stFramePIP.stVFrame.pHeaderVirAddr[0] + stFrameMain.stVFrame.u32HeaderStride[0] * stFrameMain.stVFrame.u32Height * 3 / 2;
stFramePIP.stVFrame.pVirAddr[1] = stFramePIP.stVFrame.pVirAddr[0] + stFrameMain.stVFrame.u32Stride[0] * stFrameMain.stVFrame.u32Height;
stFramePIP.stVFrame.pVirAddr[2] = stFramePIP.stVFrame.pVirAddr[1];
stFramePIP.stVFrame.u32Stride[0] = stFrameMain.stVFrame.u32Stride[0];
stFramePIP.stVFrame.u32Stride[1] = stFrameMain.stVFrame.u32Stride[1];
stFramePIP.stVFrame.u32Stride[2] = stFrameMain.stVFrame.u32Stride[2];
stFramePIP.stVFrame.u32HeaderStride[0] = stFrameMain.stVFrame.u32HeaderStride[0];
stFramePIP.stVFrame.u32HeaderStride[1] = stFrameMain.stVFrame.u32HeaderStride[1];
stFramePIP.stVFrame.u32HeaderStride[2] = stFrameMain.stVFrame.u32HeaderStride[2];
stFramePIP.stVFrame.s16OffsetTop = stFrameMain.stVFrame.s16OffsetTop;
stFramePIP.stVFrame.s16OffsetBottom = stFrameMain.stVFrame.s16OffsetBottom;
stFramePIP.stVFrame.s16OffsetLeft = stFrameMain.stVFrame.s16OffsetLeft;
stFramePIP.stVFrame.s16OffsetRight = stFrameMain.stVFrame.s16OffsetRight;
stFramePIP.stVFrame.u64pts = stFrameMain.stVFrame.u64pts;
stFramePIP.stVFrame.u32TimeRef = stFrameMain.stVFrame.u32TimeRef;
stFrameMain.stVFrame.pHeaderVirAddr[0] = (HI_U32*)HI_MPI_SYS_Mmap(stFrameMain.stVFrame.u32HeaderPhyAddr[0], (stFrameMain.stVFrame.u32Stride[0] + stFrameMain.stVFrame.u32HeaderStride[0]) * stFrameMain.stVFrame.u32Height * 3 / 2);
stFrameMain.stVFrame.pHeaderVirAddr[1] = stFrameMain.stVFrame.pHeaderVirAddr[0] + stFrameMain.stVFrame.u32HeaderStride[0] * stFrameMain.stVFrame.u32Height;
// stFrameMain.stVFrame.pHeaderVirAddr[2] = stFrameMain.stVFrame.pHeaderVirAddr[1];
stFrameMain.stVFrame.pVirAddr[0] = stFrameMain.stVFrame.pHeaderVirAddr[0] + stFrameMain.stVFrame.u32HeaderStride[0] * stFrameMain.stVFrame.u32Height * 3 / 2;
stFrameMain.stVFrame.pVirAddr[1] = stFrameMain.stVFrame.pVirAddr[0] + stFrameMain.stVFrame.u32Stride[0] * stFrameMain.stVFrame.u32Height;
stFrameMain.stVFrame.pVirAddr[2] = stFrameMain.stVFrame.pVirAddr[1];
stFrameSub.stVFrame.pHeaderVirAddr[0] = (HI_U32*)HI_MPI_SYS_Mmap(stFrameSub.stVFrame.u32HeaderPhyAddr[0], (stFrameSub.stVFrame.u32Stride[0] + stFrameSub.stVFrame.u32HeaderStride[0]) * stFrameSub.stVFrame.u32Height * 3 / 2);
stFrameSub.stVFrame.pHeaderVirAddr[1] = stFrameSub.stVFrame.pHeaderVirAddr[0] + stFrameSub.stVFrame.u32HeaderStride[0] * stFrameSub.stVFrame.u32Height;
// stFrameSub.stVFrame.pHeaderVirAddr[2] = stFrameSub.stVFrame.pHeaderVirAddr[1];
stFrameSub.stVFrame.pVirAddr[0] = stFrameSub.stVFrame.pHeaderVirAddr[0] + stFrameSub.stVFrame.u32HeaderStride[0] * stFrameSub.stVFrame.u32Height * 3 / 2;
stFrameSub.stVFrame.pVirAddr[1] = stFrameSub.stVFrame.pVirAddr[0] + stFrameSub.stVFrame.u32Stride[0] * stFrameSub.stVFrame.u32Height;
stFrameSub.stVFrame.pVirAddr[2] = stFrameSub.stVFrame.pVirAddr[1];
memcpy(stFramePIP.stVFrame.pHeaderVirAddr[0], stFrameMain.stVFrame.pHeaderVirAddr[0], (stFrameMain.stVFrame.u32Stride[0] + stFrameMain.stVFrame.u32HeaderStride[0]) * stFrameMain.stVFrame.u32Height * 3 / 2);
AF_PIPCombineFrame(&stFramePIP, &stFrameSub);
s32Ret = HI_MPI_VENC_SendFrame(VencChn, &stFramePIP, -1);
// s32Ret = HI_MPI_VENC_SendFrame(5, &stFramePIP, -1);
if (HI_SUCCESS != s32Ret) {
printf("HI_MPI_VENC_SendFrame VencChn %d failed s32ret[%#x]\n", VencChn, s32Ret);
// break;
}
HI_MPI_SYS_Munmap(stFramePIP.stVFrame.pHeaderVirAddr[0], (stFramePIP.stVFrame.u32Stride[0] + stFramePIP.stVFrame.u32HeaderStride[0]) * stFramePIP.stVFrame.u32Height * 3 / 2);
HI_MPI_SYS_Munmap(stFrameMain.stVFrame.pHeaderVirAddr[0], (stFrameMain.stVFrame.u32Stride[0] + stFrameMain.stVFrame.u32HeaderStride[0]) * stFrameMain.stVFrame.u32Height * 3 / 2);
HI_MPI_SYS_Munmap(stFrameSub.stVFrame.pHeaderVirAddr[0], (stFrameSub.stVFrame.u32Stride[0] + stFrameSub.stVFrame.u32HeaderStride[0]) * stFrameSub.stVFrame.u32Height * 3 / 2);
s32Ret = HI_MPI_VB_ReleaseBlock(VbBlk);
if (HI_SUCCESS != s32Ret) {
printf("vb release block failed![%#x]\n", s32Ret);
break;
}
HI_MPI_VPSS_ReleaseChnFrame(nVpssGrpSub, nVpssChSub, &stFrameSub);
HI_MPI_VPSS_ReleaseChnFrame(nVpssGrpMain, nVpssChMain, &stFrameMain);
pthread_mutex_lock(&pstPara->atrrMutex);
nVpssGrpMain = pstPara->nVpssGrpMain;
nVpssChMain = pstPara->nVpssChMain;
nVpssGrpSub = pstPara->nVpssGrpSub;
nVpssChSub = pstPara->nVpssChSub;
pthread_mutex_unlock(&pstPara->atrrMutex);
usleep(10 * 1000);
}
return NULL;
}

复制代码

// 目前该线程HI_MPI_VENC_SendFrame成功，另一个线程select取流一直返回0
// s32Ret = select(maxfd + 1, &read_fds, NULL, NULL, &TimeoutVal);

qn1540561804 · 发表于 2018-12-29 11:52:12

qn1540561804 发表于 2018-12-29 11:22
// 代码修改如下：
static void *AF_PIPThread(void *p)
{

注释掉接口AF_PIPCombineFrame，select正常

qn1540561804 · 发表于 2018-12-29 12:19:23

qn1540561804 发表于 2018-12-29 11:52
注释掉接口AF_PIPCombineFrame，select正常

注释掉接口AF_PIPCombineFrame
修改
memcpy(stFramePIP.stVFrame.pHeaderVirAddr[0], stFrameMain.stVFrame.pHeaderVirAddr[0], (stFrameMain.stVFrame.u32Stride[0] + stFrameMain.stVFrame.u32HeaderStride[0]) * stFrameMain.stVFrame.u32Height * 3 / 2);
// AF_PIPCombineFrame(&stFramePIP, &stFrameSub);
为
memcpy(stFramePIP.stVFrame.pVirAddr[0], stFrameMain.stVFrame.pVirAddr[0], stFrameMain.stVFrame.u32Stride[0] * stFrameMain.stVFrame.u32Height * 3 / 2);
// AF_PIPCombineFrame(&stFramePIP, &stFrameSub);

select返回0

qn1540561804 · 发表于 2018-12-29 13:25:24

本帖最后由 qn1540561804 于 2019-4-12 11:16 编辑

qn1540561804 发表于 2018-12-29 12:19
注释掉接口AF_PIPCombineFrame
修改
memcpy(stFramePIP.stVFrame.pHeaderVirAddr[0], stFrameMain.st ...

修改stVpssChnMode.enCompressMode = COMPRESS_MODE_NONE;//COMPRESS_MODE_SEG;
AF_PIPThread去掉对u32HeaderPhyAddr的操作，代码修改如下：

static void *AF_PIPThread(void *p)
{
AF_PIPThreadParam *pstPara = (AF_PIPThreadParam*)p;
VENC_CHN VencChn = pstPara->nVencCh;
VPSS_GRP nVpssGrpMain = pstPara->nVpssGrpMain;
VPSS_CHN nVpssChMain = pstPara->nVpssChMain;
VPSS_GRP nVpssGrpSub = pstPara->nVpssGrpSub;
VPSS_CHN nVpssChSub = pstPara->nVpssChSub;
VIDEO_FRAME_INFO_S stFrameMain;
VIDEO_FRAME_INFO_S stFrameSub;
VIDEO_FRAME_INFO_S stFramePIP;
VB_BLK VbBlk = VB_INVALID_HANDLE;
while (HI_TRUE == pstPara->bThreadRun) {
memset(&stFrameMain, 0, sizeof(stFrameMain));
memset(&stFrameSub, 0, sizeof(stFrameSub));
memset(&stFramePIP, 0, sizeof(stFramePIP));
usleep(10 * 1000);
pthread_mutex_lock(&pstPara->atrrMutex);
nVpssGrpMain = pstPara->nVpssGrpMain;
nVpssChMain = pstPara->nVpssChMain;
nVpssGrpSub = pstPara->nVpssGrpSub;
nVpssChSub = pstPara->nVpssChSub;
pthread_mutex_unlock(&pstPara->atrrMutex);
HI_S32 s32Ret = HI_MPI_VPSS_GetChnFrame(nVpssGrpMain, nVpssChMain, &stFrameMain, -1);
if (HI_SUCCESS != s32Ret) {
AFERR("HI_MPI_VPSS_GetChnFrame nVpssGrpMain %d nVpssChMain %d s32ret[%#x]\n", nVpssGrpMain, nVpssChMain, s32Ret);
continue;
}
s32Ret = HI_MPI_VPSS_GetChnFrame(nVpssGrpSub, nVpssChSub, &stFrameSub, -1);
if (HI_SUCCESS != s32Ret) {
AFERR("HI_MPI_VPSS_GetChnFrame nVpssGrpSub %d nVpssChSub %d s32ret[%#x]\n", nVpssGrpSub, nVpssChSub, s32Ret);
HI_MPI_VPSS_ReleaseChnFrame(nVpssGrpMain, nVpssChMain, &stFrameMain);
continue;
}
if ((stFrameMain.stVFrame.u32Width < stFrameSub.stVFrame.u32Width) || (stFrameMain.stVFrame.u32Height < stFrameSub.stVFrame.u32Height)) {
AFERR("Main.W %d Main.H %d Sub.W %d Sub.H %d\n",
stFrameMain.stVFrame.u32Width, stFrameMain.stVFrame.u32Height, stFrameSub.stVFrame.u32Width, stFrameSub.stVFrame.u32Height);
HI_MPI_VPSS_ReleaseChnFrame(nVpssGrpSub, nVpssChSub, &stFrameSub);
HI_MPI_VPSS_ReleaseChnFrame(nVpssGrpMain, nVpssChMain, &stFrameMain);
continue;
}
do {
VbBlk = HI_MPI_VB_GetBlock(VB_INVALID_POOLID, stFrameMain.stVFrame.u32Stride[0] * stFrameMain.stVFrame.u32Height * 3 / 2, NULL);
} while (VB_INVALID_HANDLE == VbBlk);
VB_POOL poolID = HI_MPI_VB_Handle2PoolId(VbBlk);
stFramePIP.stVFrame.u32PhyAddr[0] = HI_MPI_VB_Handle2PhysAddr(VbBlk);
stFramePIP.stVFrame.u32PhyAddr[1] = stFramePIP.stVFrame.u32PhyAddr[0] + stFrameMain.stVFrame.u32Stride[0] * stFrameMain.stVFrame.u32Height;
stFramePIP.stVFrame.u32PhyAddr[2] = stFramePIP.stVFrame.u32PhyAddr[1];
stFramePIP.u32PoolId = poolID;
stFramePIP.stVFrame.u32Width = stFrameMain.stVFrame.u32Width;
stFramePIP.stVFrame.u32Height = stFrameMain.stVFrame.u32Height;
stFramePIP.stVFrame.u32Field = stFrameMain.stVFrame.u32Field;
stFramePIP.stVFrame.enPixelFormat = stFrameMain.stVFrame.enPixelFormat;
stFramePIP.stVFrame.enVideoFormat = stFrameMain.stVFrame.enVideoFormat;
stFramePIP.stVFrame.enCompressMode = stFrameMain.stVFrame.enCompressMode;
stFramePIP.stVFrame.pVirAddr[0] = (HI_U32*)HI_MPI_SYS_Mmap(stFramePIP.stVFrame.u32PhyAddr[0], stFrameMain.stVFrame.u32Stride[0] * stFrameMain.stVFrame.u32Height * 3 / 2);
stFramePIP.stVFrame.pVirAddr[1] = stFramePIP.stVFrame.pVirAddr[0] + stFrameMain.stVFrame.u32Stride[0] * stFrameMain.stVFrame.u32Height;
stFramePIP.stVFrame.pVirAddr[2] = stFramePIP.stVFrame.pVirAddr[1];
stFramePIP.stVFrame.u32Stride[0] = stFrameMain.stVFrame.u32Stride[0];
stFramePIP.stVFrame.u32Stride[1] = stFrameMain.stVFrame.u32Stride[1];
stFramePIP.stVFrame.u32Stride[2] = stFrameMain.stVFrame.u32Stride[2];
stFramePIP.stVFrame.u32HeaderStride[0] = stFrameMain.stVFrame.u32HeaderStride[0];
stFramePIP.stVFrame.u32HeaderStride[1] = stFrameMain.stVFrame.u32HeaderStride[1];
stFramePIP.stVFrame.u32HeaderStride[2] = stFrameMain.stVFrame.u32HeaderStride[2];
stFramePIP.stVFrame.s16OffsetTop = stFrameMain.stVFrame.s16OffsetTop;
stFramePIP.stVFrame.s16OffsetBottom = stFrameMain.stVFrame.s16OffsetBottom;
stFramePIP.stVFrame.s16OffsetLeft = stFrameMain.stVFrame.s16OffsetLeft;
stFramePIP.stVFrame.s16OffsetRight = stFrameMain.stVFrame.s16OffsetRight;
stFramePIP.stVFrame.u64pts = stFrameMain.stVFrame.u64pts;
stFramePIP.stVFrame.u32TimeRef = stFrameMain.stVFrame.u32TimeRef;
stFrameMain.stVFrame.pVirAddr[0] = (HI_U32*)HI_MPI_SYS_Mmap(stFrameMain.stVFrame.u32PhyAddr[0], stFrameMain.stVFrame.u32Stride[0] * stFrameMain.stVFrame.u32Height * 3 / 2);
stFrameMain.stVFrame.pVirAddr[1] = stFrameMain.stVFrame.pVirAddr[0] + stFrameMain.stVFrame.u32Stride[0] * stFrameMain.stVFrame.u32Height;
stFrameMain.stVFrame.pVirAddr[2] = stFrameMain.stVFrame.pVirAddr[1];
stFrameSub.stVFrame.pVirAddr[0] = (HI_U32*)HI_MPI_SYS_Mmap(stFrameSub.stVFrame.u32PhyAddr[0], stFrameSub.stVFrame.u32Stride[0] * stFrameSub.stVFrame.u32Height * 3 / 2);
stFrameSub.stVFrame.pVirAddr[1] = stFrameSub.stVFrame.pVirAddr[0] + stFrameSub.stVFrame.u32Stride[0] * stFrameSub.stVFrame.u32Height;
stFrameSub.stVFrame.pVirAddr[2] = stFrameSub.stVFrame.pVirAddr[1];
memcpy(stFramePIP.stVFrame.pVirAddr[0], stFrameMain.stVFrame.pVirAddr[0], stFrameMain.stVFrame.u32Stride[0] * stFrameMain.stVFrame.u32Height * 3 / 2);
AF_PIPCombineFrame(&stFramePIP, &stFrameSub);
s32Ret = HI_MPI_VENC_SendFrame(VencChn, &stFramePIP, -1);
if (HI_SUCCESS != s32Ret) {
AFWARN("HI_MPI_VENC_SendFrame VencChn %d failed s32Ret[%#x]\n", VencChn, s32Ret);
}
HI_MPI_SYS_Munmap(stFramePIP.stVFrame.pVirAddr[0], stFramePIP.stVFrame.u32Stride[0] * stFramePIP.stVFrame.u32Height * 3 / 2);
HI_MPI_SYS_Munmap(stFrameMain.stVFrame.pVirAddr[0], stFrameMain.stVFrame.u32Stride[0] * stFrameMain.stVFrame.u32Height * 3 / 2);
HI_MPI_SYS_Munmap(stFrameSub.stVFrame.pVirAddr[0], stFrameSub.stVFrame.u32Stride[0] * stFrameSub.stVFrame.u32Height * 3 / 2);
s32Ret = HI_MPI_VB_ReleaseBlock(VbBlk);
if (HI_SUCCESS != s32Ret) {
AFWARN("HI_MPI_VB_ReleaseBlock failed s32Ret[%#x]\n", s32Ret);
}
HI_MPI_VPSS_ReleaseChnFrame(nVpssGrpSub, nVpssChSub, &stFrameSub);
HI_MPI_VPSS_ReleaseChnFrame(nVpssGrpMain, nVpssChMain, &stFrameMain);
}
return NULL;
}

复制代码

编码正常。
PS：头部的数据是和hisi压缩有关的。
PPS：

海思的压缩不是一般意义的压缩，我们可以理解为一种特定格式，不是真正的yuv420，只有非压缩的才是我们通常认识的yuv420，才能用你那个函数去拷贝数据

谢谢某位大神的耐心指导

qn1540561804 · 发表于 2018-12-29 14:11:42

qn1540561804 发表于 2018-12-29 13:25
修改stVpssChnMode.enCompressMode = COMPRESS_MODE_NONE;//COMPRESS_MODE_SEG;
AF_PIPThread去掉对u ...

下一步，将数据搬移用HI_MPI_IVE_DMA去做，用硬件搬数据性能应该会好很多；
下下一步，将红外光640*480半透明叠加到可见光1080P。

qn1540561804 · 发表于 2018-12-29 18:13:45

本帖最后由 qn1540561804 于 2019-4-12 11:12 编辑

数据拷贝UV代码有个错误：

//memcpy(pDst, pSrc, pstFrameSrc->stVFrame.u32Stride[0] / 2);
memcpy(pDst, pSrc, pstFrameSrc->stVFrame.u32Stride[0]);

复制代码

qn1540561804 · 发表于 2018-12-31 15:09:27

本帖最后由 qn1540561804 于 2019-4-12 11:18 编辑

qn1540561804 发表于 2018-12-29 18:13
数据拷贝UV代码有个错误
将
memcpy(pDst, pSrc, pstFrameSrc->stVFrame.u32Stride[0] / 2);

if ((i % 2) == 0) {
pDst = pstFrameDst->stVFrame.pVirAddr[0] + (pstFrameDst->stVFrame.u32Height * pstFrameDst->stVFrame.u32Stride[0]) + (nY * pstFrameDst->stVFrame.u32Stride[0]) / 2 + nStartX;
pSrc = pstFrameSrc->stVFrame.pVirAddr[0] + (pstFrameSrc->stVFrame.u32Height * pstFrameSrc->stVFrame.u32Stride[0]) + (i * pstFrameSrc->stVFrame.u32Stride[0]) / 2;
memcpy(pDst, pSrc, pstFrameSrc->stVFrame.u32Stride[0]);
}

复制代码

qn1540561804 · 发表于 2018-12-31 15:57:56

YUV透明叠加
公式：z=alpha*x+(1-alpha)*y
应用时，注意不要用浮点参与运算，Y和UV分开运算

初步调试效果见图片，后期还需要根据视场角做缩放

gongyounan · 发表于 2019-1-21 17:54:40

牛啊！楼主做下来有多少帧啊

[视频处理] 【已实现】两路sensor图像叠加编码

本帖子中包含更多资源

本帖子中包含更多资源

本帖子中包含更多资源