1 /*
2 * Copyright (c) 2017, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file CMRTKernel_PB_32x32.cpp
24 //! \brief HEVC FEI PB 32x32 class for GEN9 SKL.
25 //!
26
27 #include "CMRTKernel_PB_32x32.h"
28 #include "CMRTKernel_PB_Kernel_def.h"
29
CMRTKernelPB32x32()30 CMRTKernelPB32x32::CMRTKernelPB32x32()
31 {
32
33 m_isaName = HEVCENCFEI_PB_GEN9;
34 m_isaSize = HEVCENCFEI_PB_GEN9_SIZE;
35 m_kernelName = HEVCENCKERNELNAME_PB_32x32;
36
37 m_cmSurface2DCount = 7;
38 m_cmBufferCount = 2;
39 m_cmVmeSurfCount = 1;
40
41 if (m_cmSurface2DCount > 0)
42 {
43 m_cmSurface2D = (CmSurface2D **)malloc(sizeof(CmSurface2D *) * m_cmSurface2DCount);
44 if (m_cmSurface2D !=nullptr)
45 {
46 memset(m_cmSurface2D, 0, sizeof(CmSurface2D *) * m_cmSurface2DCount);
47 }
48 }
49 if (m_cmBufferCount > 0)
50 {
51 m_cmBuffer = (CmBuffer **)malloc(sizeof(CmBuffer *) * m_cmBufferCount);
52 if (m_cmBuffer != nullptr)
53 {
54 memset(m_cmBuffer, 0, sizeof(CmBuffer *) * m_cmBufferCount);
55 }
56 }
57 if (m_cmVmeSurfCount > 0)
58 {
59 m_cmVmeSurf = (SurfaceIndex **)malloc(sizeof(SurfaceIndex *) * m_cmVmeSurfCount);
60 if (m_cmVmeSurf != nullptr)
61 {
62 memset(m_cmVmeSurf, 0, sizeof(SurfaceIndex *) * m_cmVmeSurfCount);
63 }
64 }
65
66 m_surfIndex = (SurfaceIndex **)malloc(sizeof(SurfaceIndex *) * (m_cmSurface2DCount + m_cmBufferCount + m_cmVmeSurfCount));
67 if (m_surfIndex != nullptr)
68 {
69 memset(m_surfIndex, 0, sizeof(SurfaceIndex *) * (m_cmSurface2DCount + m_cmBufferCount + m_cmVmeSurfCount));
70 }
71 }
72
~CMRTKernelPB32x32()73 CMRTKernelPB32x32::~CMRTKernelPB32x32()
74 {
75 if (m_cmSurface2D != nullptr)
76 {
77 free(m_cmSurface2D);
78 }
79 if (m_cmBuffer != nullptr)
80 {
81 free(m_cmBuffer);
82 }
83 if (m_cmVmeSurf != nullptr)
84 {
85 free(m_cmVmeSurf);
86 }
87 if (m_surfIndex != nullptr)
88 {
89 free(m_surfIndex);
90 }
91 }
92
SetupCurbe(void * curbe)93 CM_RETURN_CODE CMRTKernelPB32x32::SetupCurbe(void *curbe)
94 {
95 m_curbe = curbe;
96 return CM_SUCCESS;
97 }
98
CreateAndDispatchKernel(CmEvent * & cmEvent,bool destroyEvent,bool isEnqueue)99 CM_RETURN_CODE CMRTKernelPB32x32::CreateAndDispatchKernel(CmEvent *&cmEvent, bool destroyEvent, bool isEnqueue)
100 {
101 CM_RETURN_CODE r = CM_SUCCESS;
102 int32_t result;
103 uint8_t i, idx = 0;
104 uint32_t width, height, widthPadded, heightPadded, threadSpaceWidth, threadSpaceHeight;
105 uint32_t *curbe = (uint32_t *)m_curbe;
106
107 width = curbe[0] & 0x0FFFF;
108 height = (curbe[0] >> 16) & 0x0FFFF;
109 widthPadded = ((width + 16) >> 5) << 5;
110 heightPadded = ((height + 16) >> 5) << 5;
111
112 threadSpaceWidth = widthPadded >> 5;
113 threadSpaceHeight = heightPadded >> 5;
114
115 CM_CHK_STATUS_RETURN(m_cmKernel->SetKernelArg(idx++, CURBEDATA_SIZE_PB_32X32_IC, m_curbe));
116
117 for (i = 0; i < NUM_MBENC_PB_32X32_IC_SURFACES; i++)
118 {
119 CM_CHK_STATUS_RETURN(m_cmKernel->SetKernelArg(idx++, sizeof(SurfaceIndex), m_surfIndex[i]));
120 }
121
122 CM_CHK_STATUS_RETURN(m_cmKernel->SetThreadCount(threadSpaceWidth * threadSpaceHeight));
123 //create Thread Space
124 result = CreateThreadSpace(threadSpaceWidth, threadSpaceHeight);
125 if (result != CM_SUCCESS)
126 {
127 printf("CM Create ThreadSpace error : %d", result);
128 return (CM_RETURN_CODE)result;
129 }
130
131 r = AddKernel(cmEvent, destroyEvent, isEnqueue);
132 return r;
133 }
134
AllocateSurfaces(void * params)135 CM_RETURN_CODE CMRTKernelPB32x32UMD::AllocateSurfaces(void *params)
136 {
137 PBFrameKernelParams *PB32x32Params = (PBFrameKernelParams *)params;
138
139 CM_CHK_STATUS_RETURN(m_cmDev->CreateBuffer((MOS_RESOURCE *)PB32x32Params->m_cmSurfPer32x32ICOut, m_cmBuffer[0]));
140 CM_CHK_STATUS_RETURN(m_cmBuffer[0]->GetIndex(m_surfIndex[0]));
141 CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)PB32x32Params->m_cmSurfCurrY, m_cmSurface2D[0]));
142 CM_CHK_STATUS_RETURN(m_cmSurface2D[0]->GetIndex(m_surfIndex[1]));
143 CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)PB32x32Params->m_cmSurfCurrY2, m_cmSurface2D[1]));
144 CM_CHK_STATUS_RETURN(m_cmSurface2D[1]->GetIndex(m_surfIndex[2]));
145 CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)PB32x32Params->m_cmSurfSliceMap, m_cmSurface2D[2]));
146 CM_CHK_STATUS_RETURN(m_cmSurface2D[2]->GetIndex(m_surfIndex[3]));
147 CM_CHK_STATUS_RETURN(m_cmDev->CreateVmeSurfaceG7_5(m_cmSurface2D[1], nullptr, nullptr, 0, 0, m_cmVmeSurf[0]));
148 m_surfIndex[4] = m_cmVmeSurf[0];
149 CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)PB32x32Params->m_cmSurfSIF, m_cmSurface2D[3]));
150 CM_CHK_STATUS_RETURN(m_cmSurface2D[3]->GetIndex(m_surfIndex[5]));
151 m_surfIndex[6] = (SurfaceIndex *)CM_NULL_SURFACE;
152 m_surfIndex[7] = (SurfaceIndex *)CM_NULL_SURFACE;
153 CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)PB32x32Params->m_cmLCUQPSurf, m_cmSurface2D[6]));
154 CM_CHK_STATUS_RETURN(m_cmSurface2D[6]->GetIndex(m_surfIndex[8]));
155 m_surfIndex[9] = (SurfaceIndex *)CM_NULL_SURFACE;
156
157 return CM_SUCCESS;
158 }
159
160