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_8x8MbEnc.cpp
24 //! \brief HEVC FEI PB 8x8 MbEnc class for GEN9 SKL.
25 //!
26
27 #include "CMRTKernel_PB_8x8MbEnc.h"
28 #include "CMRTKernel_PB_Kernel_def.h"
29
CMRTKernelPB8x8MbEnc(uint16_t picCodingType)30 CMRTKernelPB8x8MbEnc::CMRTKernelPB8x8MbEnc(uint16_t picCodingType): m_pictureCodingType(picCodingType)
31 {
32
33 m_isaName = HEVCENCFEI_PB_GEN9;
34 m_isaSize = HEVCENCFEI_PB_GEN9_SIZE;
35
36 if (m_pictureCodingType == P_TYPE)
37 {
38 m_kernelName = HEVCENCKERNELNAME_P_MB;
39 }
40 else if (m_pictureCodingType == B_TYPE)
41 {
42 m_kernelName = HEVCENCKERNELNAME_PB_MB;
43 }
44
45 m_cmSurface2DCount = 17;
46 m_cmBufferCount = 10;
47 m_cmVmeSurfCount = 2;
48 m_cmSurfaceRef0Count = 8;
49 m_cmSurfaceRef1Count = 8;
50
51 if (m_cmSurface2DCount > 0)
52 {
53 m_cmSurface2D = (CmSurface2D **)malloc(sizeof(CmSurface2D *) * m_cmSurface2DCount);
54 if (m_cmSurface2D != nullptr)
55 {
56 memset(m_cmSurface2D, 0, sizeof(CmSurface2D *) * m_cmSurface2DCount);
57 }
58 }
59 if (m_cmSurfaceRef0Count > 0)
60 {
61 m_cmSurfaceRef0 = (CmSurface2D **)malloc(sizeof(CmSurface2D *) * m_cmSurfaceRef0Count);
62 if (m_cmSurfaceRef0 != nullptr)
63 {
64 memset(m_cmSurfaceRef0, 0, sizeof(CmSurface2D *) * m_cmSurfaceRef0Count);
65 }
66 }
67 if (m_cmSurfaceRef1Count > 0)
68 {
69 m_cmSurfaceRef1 = (CmSurface2D **)malloc(sizeof(CmSurface2D *) * m_cmSurfaceRef1Count);
70 if (m_cmSurfaceRef1 != nullptr)
71 {
72 memset(m_cmSurfaceRef1, 0, sizeof(CmSurface2D *) * m_cmSurfaceRef1Count);
73 }
74 }
75 if (m_cmBufferCount > 0)
76 {
77 m_cmBuffer = (CmBuffer **)malloc(sizeof(CmBuffer *) * m_cmBufferCount);
78 if (m_cmBuffer != nullptr)
79 {
80 memset(m_cmBuffer, 0, sizeof(CmBuffer *) * m_cmBufferCount);
81 }
82 }
83 if (m_cmVmeSurfCount > 0)
84 {
85 m_cmVmeSurf = (SurfaceIndex **)malloc(sizeof(SurfaceIndex *) * m_cmVmeSurfCount);
86 if (m_cmVmeSurf != nullptr)
87 {
88 memset(m_cmVmeSurf, 0, sizeof(SurfaceIndex *) * m_cmVmeSurfCount);
89 }
90 }
91
92 m_surfIndex = (SurfaceIndex **)malloc(sizeof(SurfaceIndex *) * (m_cmSurface2DCount + m_cmBufferCount + m_cmVmeSurfCount));
93 if (m_surfIndex != nullptr)
94 {
95 memset(m_surfIndex, 0, sizeof(SurfaceIndex *) * (m_cmSurface2DCount + m_cmBufferCount + m_cmVmeSurfCount));
96 }
97 }
98
~CMRTKernelPB8x8MbEnc()99 CMRTKernelPB8x8MbEnc::~CMRTKernelPB8x8MbEnc()
100 {
101 if (m_cmSurface2D != nullptr)
102 {
103 free(m_cmSurface2D);
104 }
105 if (m_cmSurfaceRef0 != nullptr)
106 {
107 free(m_cmSurfaceRef0);
108 }
109 if (m_cmSurfaceRef1 != nullptr)
110 {
111 free(m_cmSurfaceRef1);
112 }
113 if (m_cmBuffer != nullptr)
114 {
115 free(m_cmBuffer);
116 }
117 if (m_cmVmeSurf != nullptr)
118 {
119 free(m_cmVmeSurf);
120 }
121 if (m_surfIndex != nullptr)
122 {
123 free(m_surfIndex);
124 }
125 }
126
SetupCurbe(void * curbe)127 CM_RETURN_CODE CMRTKernelPB8x8MbEnc::SetupCurbe(void *curbe)
128 {
129 m_curbe = curbe;
130 return CM_SUCCESS;
131 }
132
CreateAndDispatchKernel(CmEvent * & cmEvent,bool destroyEvent,bool isEnqueue)133 CM_RETURN_CODE CMRTKernelPB8x8MbEnc::CreateAndDispatchKernel(CmEvent *&cmEvent, bool destroyEvent, bool isEnqueue)
134 {
135 CM_RETURN_CODE r = CM_SUCCESS;
136 int32_t result;
137 uint8_t i, numSurfaces, idx = 0;
138 uint8_t *curbe = (uint8_t *)m_curbe;
139 uint32_t width, height, width_padded, height_padded, threadSpaceWidth, threadSpaceHeight, colorCount, splitCount, tempHeight;
140 PBMbEncWalkParams mbEncWalkParams;
141
142 memset(&mbEncWalkParams, 0, sizeof(PBMbEncWalkParams));
143
144 width = ((curbe[25] & 0xFF) << 8) | (curbe[24] & 0xFF);
145 height = ((curbe[27] & 0xFF) << 8) | (curbe[26] & 0xFF);
146 width_padded = ((width + 16) >> 5) << 5;
147 height_padded = ((height + 16) >> 5) << 5;
148
149 colorCount = (curbe[191] >> 2) + 1;
150 splitCount = (curbe[188] & 0x0F);
151 if (splitCount == 0)
152 {
153 splitCount = 1;
154 }
155
156 threadSpaceWidth = width_padded >> 4;
157 threadSpaceHeight = (colorCount > 1) ? ((curbe[211] << 8) + (curbe[210] & 0xFF)) : (height_padded >> 4);
158
159 CM_CHK_STATUS_RETURN(m_cmKernel->SetKernelArg(idx++, CURBEDATA_SIZE_PB_MB, m_curbe));
160
161 numSurfaces = m_pictureCodingType == P_TYPE ? NUM_MBENC_P_MB_SURFACES: NUM_MBENC_PB_MB_SURFACES;
162
163 for (i = 0; i < numSurfaces; i++)
164 {
165 CM_CHK_STATUS_RETURN(m_cmKernel->SetKernelArg(idx++, sizeof(SurfaceIndex), m_surfIndex[i]));
166 }
167
168 if ((curbe[189] & 0x0F) == 1)
169 {
170 CM_CHK_STATUS_RETURN(m_cmKernel->SetThreadCount(((threadSpaceWidth + 1) & 0xFFFE) * threadSpaceHeight * colorCount));
171 //create Thread Space
172 result = CreateThreadSpace(((threadSpaceWidth + 1) & 0xFFFE), threadSpaceHeight);
173 if (result != CM_SUCCESS)
174 {
175 printf("CM Create ThreadSpace error : %d", result);
176 return (CM_RETURN_CODE)result;
177 }
178 SetupMwScoreboard26(mbEncWalkParams.m_walkParams, mbEncWalkParams.m_scoreboardParams, threadSpaceWidth, threadSpaceHeight, splitCount, colorCount);
179 }
180 else if ((curbe[189]&0x0F) == 0)
181 {
182 tempHeight = ((threadSpaceWidth + 3) >> 2) + (((threadSpaceWidth + 1) >> 1) + 2 * (((threadSpaceHeight + 1) >> 1) - 1) + (2 * splitCount - 1)) / (2 * splitCount);
183 CM_CHK_STATUS_RETURN(m_cmKernel->SetThreadCount(((threadSpaceWidth + 3) & 0xFFFC) * 2 * tempHeight * colorCount));
184 //create Thread Space
185 result = CreateThreadSpace(((threadSpaceWidth + 3) & 0xFFFC) >> 1, 4 * tempHeight);
186 SetupMwScoreboard26Zig(mbEncWalkParams.m_walkParams, mbEncWalkParams.m_scoreboardParams, threadSpaceWidth, threadSpaceHeight, splitCount, colorCount);
187 }
188
189 if (m_cmThreadSpace != nullptr)
190 {
191 CM_CHK_STATUS_RETURN(m_cmThreadSpace->SelectThreadDependencyVectors(mbEncWalkParams.m_scoreboardParams));
192 CM_CHK_STATUS_RETURN(m_cmThreadSpace->SetThreadSpaceColorCount(colorCount));
193 CM_CHK_STATUS_RETURN(m_cmThreadSpace->SelectMediaWalkingParameters(mbEncWalkParams.m_walkParams));
194 }
195
196 r = AddKernel(cmEvent, destroyEvent, isEnqueue);
197 return r;
198 }
199
SetupMwScoreboard26(CM_WALKING_PARAMETERS & walkParams,CM_DEPENDENCY & scoreboardParams,uint32_t width,uint32_t height,uint32_t splitCount,uint32_t colorCount)200 void CMRTKernelPB8x8MbEnc::SetupMwScoreboard26(CM_WALKING_PARAMETERS& walkParams, CM_DEPENDENCY& scoreboardParams, uint32_t width, uint32_t height, uint32_t splitCount, uint32_t colorCount)
201 {
202 uint8_t n = 0;
203 uint32_t *pDW5 = &walkParams.Value[n++];
204 uint32_t *pDW6 = &walkParams.Value[n++];
205 uint32_t *pDW7 = &walkParams.Value[n++];
206 uint32_t *pDW8 = &walkParams.Value[n++];
207 uint32_t *pDW9 = &walkParams.Value[n++];
208 uint32_t *pDW10 = &walkParams.Value[n++];
209 uint32_t *pDW11 = &walkParams.Value[n++];
210 uint32_t *pDW12 = &walkParams.Value[n++];
211 uint32_t *pDW13 = &walkParams.Value[n++];
212 uint32_t *pDW14 = &walkParams.Value[n++];
213 uint32_t *pDW15 = &walkParams.Value[n++];
214 uint32_t *pDW16 = &walkParams.Value[n++];
215
216 int32_t scoreBoardMask;
217 int32_t globalResolutionX;
218 int32_t globalResolutionY;
219 int32_t globalStartX;
220 int32_t globalStartY;
221 int32_t globalOuterLoopStrideX;
222 int32_t globalOuterLoopStrideY;
223 int32_t globalInnerLoopUnitX;
224 int32_t globalInnerLoopUnitY;
225 int32_t blockResolutionX;
226 int32_t blockResolutionY;
227 int32_t localInitialStartPointX;
228 int32_t localInitialStartPointY;
229 int32_t localEndX;
230 int32_t localEndY;
231 int32_t outerLoopUnitX;
232 int32_t outerLoopUnitY;
233 int32_t innerLoopUnitX;
234 int32_t innerLoopUnitY;
235 int32_t middleLoopExtraSteps;
236 int32_t middleLoopUnitX;
237 int32_t middleLoopUnitY;
238 int32_t globalOuterLoopExecCount;
239 int32_t localOuterLoopExecCount;
240 int32_t ts_width = (width + 1) & 0xfffe;
241 int32_t ts_height = (height + 1) & 0xfffe;
242
243 int32_t tmp1 = ((ts_width + 1) >> 1) + ((ts_width + ((ts_height - 1) << 1)) + (2 * splitCount - 1)) / (2 * splitCount);
244
245 scoreBoardMask = 0x0F;
246 globalResolutionX = ts_width;
247 globalResolutionY = tmp1; // ts_height;
248 globalStartX = 0;
249 globalStartY = 0;
250 globalOuterLoopStrideX = ts_width;
251 globalOuterLoopStrideY = 0;
252 globalInnerLoopUnitX = 0;
253 globalInnerLoopUnitY = tmp1; // 2;
254 blockResolutionX = ts_width;
255 blockResolutionY = tmp1;
256 localInitialStartPointX = ts_width;
257 localInitialStartPointY = 0;
258 localEndX = 0;
259 localEndY = 0;
260 outerLoopUnitX = 1;
261 outerLoopUnitY = 0;
262 innerLoopUnitX = -2;
263 innerLoopUnitY = 1;
264 middleLoopExtraSteps = 0;
265 middleLoopUnitX = 0;
266 middleLoopUnitY = 0;
267 globalOuterLoopExecCount = 0;
268 localOuterLoopExecCount = (width + (height - 1) * 2 + splitCount - 1) / splitCount;
269
270 *pDW5 = scoreBoardMask;
271 *pDW6 = ((middleLoopUnitX & 0x3) << 8) | ((middleLoopUnitY & 0x3) << 12) | ((middleLoopExtraSteps & 0x1F) << 16) | (((colorCount - 1) & 0x0F) << 24);
272 *pDW7 = (localOuterLoopExecCount & 0x0FFF) | ((globalOuterLoopExecCount & 0x0FFF) << 16);
273 *pDW8 = (blockResolutionX & 0x7FF) | ((blockResolutionY & 0x7FF) << 16);
274 *pDW9 = (localInitialStartPointX & 0x7FF) | ((localInitialStartPointY & 0x7FF) << 16);
275 *pDW10 = (localEndX & 0xFFFF) | ((localEndY & 0xFFFF) << 16);
276 *pDW11 = (outerLoopUnitX & 0x0FFF) | ((outerLoopUnitY & 0x0FFF) << 16);
277 *pDW12 = (innerLoopUnitX & 0x0FFF) | ((innerLoopUnitY & 0x0FFF) << 16);
278 *pDW13 = (globalResolutionX & 0x7FF) | ((globalResolutionY & 0x7FF) << 16);
279 *pDW14 = (globalStartX & 0x0FFF) | ((globalStartY & 0x0FFF) << 16);
280 *pDW15 = (globalOuterLoopStrideX & 0x0FFF) | ((globalOuterLoopStrideY & 0x0FFF) << 16);
281 *pDW16 = (globalInnerLoopUnitX & 0x0FFF) | ((globalInnerLoopUnitY & 0x0FFF) << 16);
282
283 scoreboardParams.count = 4;
284
285 scoreboardParams.deltaX[0] = -1;
286 scoreboardParams.deltaY[0] = 0;
287
288 scoreboardParams.deltaX[1] = -1;
289 scoreboardParams.deltaY[1] = -1;
290
291 scoreboardParams.deltaX[2] = 0;
292 scoreboardParams.deltaY[2] = -1;
293
294 scoreboardParams.deltaX[3] = 1;
295 scoreboardParams.deltaY[3] = -1;
296 }
297
SetupMwScoreboard26Zig(CM_WALKING_PARAMETERS & walkParams,CM_DEPENDENCY & scoreboardParams,uint32_t width,uint32_t height,uint32_t splitCount,uint32_t colorCount)298 void CMRTKernelPB8x8MbEnc::SetupMwScoreboard26Zig(CM_WALKING_PARAMETERS& walkParams, CM_DEPENDENCY& scoreboardParams, uint32_t width, uint32_t height, uint32_t splitCount, uint32_t colorCount)
299 {
300 uint8_t n = 0;
301 uint32_t *pDW5 = &walkParams.Value[n++];
302 uint32_t *pDW6 = &walkParams.Value[n++];
303 uint32_t *pDW7 = &walkParams.Value[n++];
304 uint32_t *pDW8 = &walkParams.Value[n++];
305 uint32_t *pDW9 = &walkParams.Value[n++];
306 uint32_t *pDW10 = &walkParams.Value[n++];
307 uint32_t *pDW11 = &walkParams.Value[n++];
308 uint32_t *pDW12 = &walkParams.Value[n++];
309 uint32_t *pDW13 = &walkParams.Value[n++];
310 uint32_t *pDW14 = &walkParams.Value[n++];
311 uint32_t *pDW15 = &walkParams.Value[n++];
312 uint32_t *pDW16 = &walkParams.Value[n++];
313
314 int32_t scoreBoardMask;
315 int32_t globalResolutionX;
316 int32_t globalResolutionY;
317 int32_t globalStartX;
318 int32_t globalStartY;
319 int32_t globalOuterLoopStrideX;
320 int32_t globalOuterLoopStrideY;
321 int32_t globalInnerLoopUnitX;
322 int32_t globalInnerLoopUnitY;
323 int32_t blockResolutionX;
324 int32_t blockResolutionY;
325 int32_t localInitialStartPointX;
326 int32_t localInitialStartPointY;
327 int32_t localEndX;
328 int32_t localEndY;
329 int32_t outerLoopUnitX;
330 int32_t outerLoopUnitY;
331 int32_t innerLoopUnitX;
332 int32_t innerLoopUnitY;
333 int32_t middleLoopExtraSteps;
334 int32_t middleLoopUnitX;
335 int32_t middleLoopUnitY;
336 int32_t globalOuterLoopExecCount;
337 int32_t localOuterLoopExecCount;
338 int32_t ts_width = ((width + 3) & 0xFFFC) >> 1;
339 int32_t LCU_width = (width + 1) >> 1;
340 int32_t LCU_height = (height + 1) >> 1;
341
342 int32_t tmp1 = ((LCU_width + 1) >> 1) + ((LCU_width + ((LCU_height - 1) << 1)) + (2 * splitCount - 1)) / (2 * splitCount);
343
344 scoreBoardMask = 0x0FF;
345 globalResolutionX = ts_width;
346 globalResolutionY = 4 * tmp1;
347 globalStartX = 0;
348 globalStartY = 0;
349 globalOuterLoopStrideX = ts_width;
350 globalOuterLoopStrideY = 0;
351 globalInnerLoopUnitX = 0;
352 globalInnerLoopUnitY = 4 * tmp1;
353 blockResolutionX = ts_width;
354 blockResolutionY = 4 * tmp1;
355 localInitialStartPointX = ts_width;
356 localInitialStartPointY = 0;
357 localEndX = 0;
358 localEndY = 0;
359 outerLoopUnitX = 1;
360 outerLoopUnitY = 0;
361 innerLoopUnitX = -2;
362 innerLoopUnitY = 4;
363 middleLoopExtraSteps = 3;
364 middleLoopUnitX = 0;
365 middleLoopUnitY = 1;
366 globalOuterLoopExecCount = 0;
367 localOuterLoopExecCount = 2 * ((LCU_width + (LCU_height - 1) * 2 + 2 * splitCount - 1) / (2 * splitCount)) - 1;
368
369 *pDW5 = scoreBoardMask;
370 *pDW6 = ((middleLoopUnitX & 0x3) << 8) | ((middleLoopUnitY & 0x3) << 12) | ((middleLoopExtraSteps & 0x1F) << 16) | (((colorCount - 1) & 0x0F) << 24);
371 *pDW7 = (localOuterLoopExecCount & 0x0FFF) | ((globalOuterLoopExecCount & 0x0FFF) << 16);
372 *pDW8 = (blockResolutionX & 0x7FF) | ((blockResolutionY & 0x7FF) << 16);
373 *pDW9 = (localInitialStartPointX & 0x7FF) | ((localInitialStartPointY & 0x7FF) << 16);
374 *pDW10 = (localEndX & 0xFFFF) | ((localEndY & 0xFFFF) << 16);
375 *pDW11 = (outerLoopUnitX & 0x0FFF) | ((outerLoopUnitY & 0x0FFF) << 16);
376 *pDW12 = (innerLoopUnitX & 0x0FFF) | ((innerLoopUnitY & 0x0FFF) << 16);
377 *pDW13 = (globalResolutionX & 0x7FF) | ((globalResolutionY & 0x7FF) << 16);
378 *pDW14 = (globalStartX & 0x0FFF) | ((globalStartY & 0x0FFF) << 16);
379 *pDW15 = (globalOuterLoopStrideX & 0x0FFF) | ((globalOuterLoopStrideY & 0x0FFF) << 16);
380 *pDW16 = (globalInnerLoopUnitX & 0x0FFF) | ((globalInnerLoopUnitY & 0x0FFF) << 16);
381
382 scoreboardParams.count = 8;
383
384 scoreboardParams.deltaX[0] = -1;
385 scoreboardParams.deltaY[0] = 3;
386
387 scoreboardParams.deltaX[1] = -1;
388 scoreboardParams.deltaY[1] = 1;
389
390 scoreboardParams.deltaX[2] = -1;
391 scoreboardParams.deltaY[2] = -1;
392
393 scoreboardParams.deltaX[3] = 0;
394 scoreboardParams.deltaY[3] = -1;
395
396 scoreboardParams.deltaX[4] = 0;
397 scoreboardParams.deltaY[4] = -2;
398
399 scoreboardParams.deltaX[5] = 0;
400 scoreboardParams.deltaY[5] = -3;
401
402 scoreboardParams.deltaX[6] = 1;
403 scoreboardParams.deltaY[6] = -2;
404
405 scoreboardParams.deltaX[7] = 1;
406 scoreboardParams.deltaY[7] = -3;
407 }
408
AllocateSurfaces(void * params)409 CM_RETURN_CODE CMRTKernelB8x8MbEncUMD::AllocateSurfaces(void *params)
410 {
411 PBFrameKernelParams *PB8x8MbEncParams = (PBFrameKernelParams *)params;
412
413 uint8_t i, idx = 0;
414
415 CM_VME_SURFACE_STATE_PARAM surfaceParams;
416 memset(&surfaceParams, 0, sizeof(CM_VME_SURFACE_STATE_PARAM));
417 surfaceParams.width = PB8x8MbEncParams->m_width;
418 surfaceParams.height = PB8x8MbEncParams->m_height;
419
420 CM_BUFFER_STATE_PARAM bufParams;
421 memset(&bufParams, 0, sizeof(CM_BUFFER_STATE_PARAM));
422 bufParams.uiSize = PB8x8MbEncParams->m_bufSize;
423 bufParams.uiBaseAddressOffset = PB8x8MbEncParams->m_bufOffset;
424
425 CM_CHK_STATUS_RETURN(m_cmDev->CreateBuffer((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfPOCDbuf, m_cmBuffer[0]));
426 CM_CHK_STATUS_RETURN(m_cmDev->CreateBufferAlias(m_cmBuffer[0], m_surfIndex[idx++]));
427 CM_CHK_STATUS_RETURN(m_cmBuffer[0]->SetSurfaceStateParam(m_surfIndex[0], &bufParams));
428 CM_CHK_STATUS_RETURN(m_cmBuffer[0]->GetIndex(m_surfIndex[idx++]));
429 CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfCurrY, m_cmSurface2D[0]));
430 CM_CHK_STATUS_RETURN(m_cmSurface2D[0]->GetIndex(m_surfIndex[idx++]));
431 CM_CHK_STATUS_RETURN(m_cmDev->CreateBuffer((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfIntraDist, m_cmBuffer[1]));
432 CM_CHK_STATUS_RETURN(m_cmBuffer[1]->GetIndex(m_surfIndex[idx++]));
433 CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfMinDist, m_cmSurface2D[1]));
434 CM_CHK_STATUS_RETURN(m_cmSurface2D[1]->GetIndex(m_surfIndex[idx++]));
435 m_surfIndex[idx++] = (SurfaceIndex *)CM_NULL_SURFACE;
436 m_surfIndex[idx++] = (SurfaceIndex *)CM_NULL_SURFACE;
437 CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfSliceMap, m_cmSurface2D[4]));
438 CM_CHK_STATUS_RETURN(m_cmSurface2D[4]->GetIndex(m_surfIndex[idx++]));
439 CM_CHK_STATUS_RETURN(m_cmDev->CreateBuffer((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfVMEIN, m_cmBuffer[2]));
440 CM_CHK_STATUS_RETURN(m_cmBuffer[2]->GetIndex(m_surfIndex[idx++]));
441 CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfSIF, m_cmSurface2D[5]));
442 CM_CHK_STATUS_RETURN(m_cmSurface2D[5]->GetIndex(m_surfIndex[idx++]));
443
444 if (PB8x8MbEncParams->m_cmSurfColRefData == nullptr)
445 {
446 m_surfIndex[idx++] = (SurfaceIndex *)CM_NULL_SURFACE;
447 }
448 else
449 {
450 CM_CHK_STATUS_RETURN(m_cmDev->CreateBuffer((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfColRefData, m_cmBuffer[3]));
451 CM_CHK_STATUS_RETURN(m_cmBuffer[3]->GetIndex(m_surfIndex[idx++]));
452 }
453
454 m_surfIndex[idx++] = (SurfaceIndex *)CM_NULL_SURFACE;
455 CM_CHK_STATUS_RETURN(m_cmDev->CreateBuffer((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfCombinedQP, m_cmBuffer[4]));
456 CM_CHK_STATUS_RETURN(m_cmBuffer[4]->GetIndex(m_surfIndex[idx++]));
457 CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)PB8x8MbEncParams->m_cmLCUQPSurf, m_cmSurface2D[6]));
458 CM_CHK_STATUS_RETURN(m_cmSurface2D[6]->GetIndex(m_surfIndex[idx++]));
459 CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)PB8x8MbEncParams->m_cmBRCConstSurf, m_cmSurface2D[7]));
460 CM_CHK_STATUS_RETURN(m_cmSurface2D[7]->GetIndex(m_surfIndex[idx++]));
461
462 for (i = 0; i < PB8x8MbEncParams->m_ucRefNum0; i++)
463 {
464 CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfRef0[i], m_cmSurfaceRef0[i]));
465 }
466 for (i = 0; i < PB8x8MbEncParams->m_ucRefNum1; i++)
467 {
468 CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfRef1[i], m_cmSurfaceRef1[i]));
469 }
470
471 CM_CHK_STATUS_RETURN(m_cmDev->CreateVmeSurfaceG7_5(m_cmSurface2D[0],
472 m_cmSurfaceRef0, m_cmSurfaceRef1,
473 PB8x8MbEncParams->m_ucRefNum0, PB8x8MbEncParams->m_ucRefNum1,
474 m_cmVmeSurf[0]));
475 CM_CHK_STATUS_RETURN(m_cmDev->SetVmeSurfaceStateParam(m_cmVmeSurf[0], &surfaceParams));
476 m_surfIndex[idx++] = m_cmVmeSurf[0];
477
478 CM_CHK_STATUS_RETURN(m_cmDev->CreateVmeSurfaceG7_5(m_cmSurface2D[0],
479 m_cmSurfaceRef1, m_cmSurfaceRef1,
480 PB8x8MbEncParams->m_ucRefNum1, PB8x8MbEncParams->m_ucRefNum1,
481 m_cmVmeSurf[1]));
482 CM_CHK_STATUS_RETURN(m_cmDev->SetVmeSurfaceStateParam(m_cmVmeSurf[1], &surfaceParams));
483 m_surfIndex[idx++] = m_cmVmeSurf[1];
484
485 CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)PB8x8MbEncParams->m_cmWaveFrontMap, m_cmSurface2D[8]));
486 CM_CHK_STATUS_RETURN(m_cmSurface2D[8]->GetIndex(m_surfIndex[idx++]));
487 CM_CHK_STATUS_RETURN(m_cmDev->CreateBuffer((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfMVIndex, m_cmBuffer[5]));
488 CM_CHK_STATUS_RETURN(m_cmBuffer[5]->GetIndex(m_surfIndex[idx++]));
489 CM_CHK_STATUS_RETURN(m_cmDev->CreateBuffer((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfMVPred, m_cmBuffer[6]));
490 CM_CHK_STATUS_RETURN(m_cmBuffer[6]->GetIndex(m_surfIndex[idx++]));
491 m_surfIndex[idx++] = (SurfaceIndex *)CM_NULL_SURFACE;
492 m_surfIndex[idx++] = (SurfaceIndex *)CM_NULL_SURFACE;
493 m_surfIndex[idx++] = (SurfaceIndex *)CM_NULL_SURFACE;
494 if (PB8x8MbEncParams->m_cmSurfMVPredictor == nullptr)
495 {
496 m_surfIndex[idx++] = (SurfaceIndex *)CM_NULL_SURFACE;
497 }
498 else
499 {
500 CM_CHK_STATUS_RETURN(m_cmDev->CreateBuffer((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfMVPredictor, m_cmBuffer[7]));
501 CM_CHK_STATUS_RETURN(m_cmBuffer[7]->GetIndex(m_surfIndex[idx++]));
502 }
503 if (PB8x8MbEncParams->m_cmSurfPerCTBInput == nullptr)
504 {
505 m_surfIndex[idx++] = (SurfaceIndex *)CM_NULL_SURFACE;
506 }
507 else
508 {
509 CM_CHK_STATUS_RETURN(m_cmDev->CreateBuffer((MOS_RESOURCE*)PB8x8MbEncParams->m_cmSurfPerCTBInput, m_cmBuffer[8]));
510 CM_CHK_STATUS_RETURN(m_cmBuffer[8]->GetIndex(m_surfIndex[idx++]));
511 }
512
513 for (; idx < NUM_MBENC_PB_MB_SURFACES; idx++)
514 {
515 m_surfIndex[idx] = (SurfaceIndex *)CM_NULL_SURFACE;
516 }
517
518 return CM_SUCCESS;
519 }
520
AllocateSurfaces(void * params)521 CM_RETURN_CODE CMRTKernelP8x8MbEncUMD::AllocateSurfaces(void *params)
522 {
523 PBFrameKernelParams *PB8x8MbEncParams = (PBFrameKernelParams *)params;
524
525 uint8_t i, idx = 0;
526
527 CM_VME_SURFACE_STATE_PARAM surfaceParams;
528 memset(&surfaceParams, 0, sizeof(CM_VME_SURFACE_STATE_PARAM));
529 surfaceParams.width = PB8x8MbEncParams->m_width;
530 surfaceParams.height = PB8x8MbEncParams->m_height;
531
532 CM_BUFFER_STATE_PARAM bufParams;
533 memset(&bufParams, 0, sizeof(CM_BUFFER_STATE_PARAM));
534 bufParams.uiSize = PB8x8MbEncParams->m_bufSize;
535 bufParams.uiBaseAddressOffset = PB8x8MbEncParams->m_bufOffset;
536
537 CM_CHK_STATUS_RETURN(m_cmDev->CreateBuffer((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfPOCDbuf, m_cmBuffer[0]));
538 CM_CHK_STATUS_RETURN(m_cmDev->CreateBufferAlias(m_cmBuffer[0], m_surfIndex[idx++]));
539 CM_CHK_STATUS_RETURN(m_cmBuffer[0]->SetSurfaceStateParam(m_surfIndex[0], &bufParams));
540 CM_CHK_STATUS_RETURN(m_cmBuffer[0]->GetIndex(m_surfIndex[idx++]));
541 CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfCurrY, m_cmSurface2D[0]));
542 CM_CHK_STATUS_RETURN(m_cmSurface2D[0]->GetIndex(m_surfIndex[idx++]));
543 CM_CHK_STATUS_RETURN(m_cmDev->CreateBuffer((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfIntraDist, m_cmBuffer[1]));
544 CM_CHK_STATUS_RETURN(m_cmBuffer[1]->GetIndex(m_surfIndex[idx++]));
545 CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfMinDist, m_cmSurface2D[1]));
546 CM_CHK_STATUS_RETURN(m_cmSurface2D[1]->GetIndex(m_surfIndex[idx++]));
547 m_surfIndex[idx++] = (SurfaceIndex *)CM_NULL_SURFACE;
548 m_surfIndex[idx++] = (SurfaceIndex *)CM_NULL_SURFACE;
549 CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfSliceMap, m_cmSurface2D[4]));
550 CM_CHK_STATUS_RETURN(m_cmSurface2D[4]->GetIndex(m_surfIndex[idx++]));
551 CM_CHK_STATUS_RETURN(m_cmDev->CreateBuffer((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfVMEIN, m_cmBuffer[2]));
552 CM_CHK_STATUS_RETURN(m_cmBuffer[2]->GetIndex(m_surfIndex[idx++]));
553 CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfSIF, m_cmSurface2D[5]));
554 CM_CHK_STATUS_RETURN(m_cmSurface2D[5]->GetIndex(m_surfIndex[idx++]));
555
556 if (PB8x8MbEncParams->m_cmSurfColRefData == nullptr)
557 {
558 m_surfIndex[idx++] = (SurfaceIndex *)CM_NULL_SURFACE;
559 }
560 else
561 {
562 CM_CHK_STATUS_RETURN(m_cmDev->CreateBuffer((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfColRefData, m_cmBuffer[3]));
563 CM_CHK_STATUS_RETURN(m_cmBuffer[3]->GetIndex(m_surfIndex[idx++]));
564 }
565
566 m_surfIndex[idx++] = (SurfaceIndex *)CM_NULL_SURFACE;
567 CM_CHK_STATUS_RETURN(m_cmDev->CreateBuffer((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfCombinedQP, m_cmBuffer[4]));
568 CM_CHK_STATUS_RETURN(m_cmBuffer[4]->GetIndex(m_surfIndex[idx++]));
569 CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)PB8x8MbEncParams->m_cmLCUQPSurf, m_cmSurface2D[6]));
570 CM_CHK_STATUS_RETURN(m_cmSurface2D[6]->GetIndex(m_surfIndex[idx++]));
571 CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)PB8x8MbEncParams->m_cmBRCConstSurf, m_cmSurface2D[7]));
572 CM_CHK_STATUS_RETURN(m_cmSurface2D[7]->GetIndex(m_surfIndex[idx++]));
573
574 for (i = 0; i < PB8x8MbEncParams->m_ucRefNum0; i++)
575 {
576 CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfRef0[i], m_cmSurfaceRef0[i]));
577 }
578 for (i = 0; i < PB8x8MbEncParams->m_ucRefNum1; i++)
579 {
580 CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfRef1[i], m_cmSurfaceRef1[i]));
581 }
582
583 CM_CHK_STATUS_RETURN(m_cmDev->CreateVmeSurfaceG7_5(m_cmSurface2D[0],
584 m_cmSurfaceRef0, m_cmSurfaceRef1,
585 PB8x8MbEncParams->m_ucRefNum0, PB8x8MbEncParams->m_ucRefNum1,
586 m_cmVmeSurf[0]));
587 CM_CHK_STATUS_RETURN(m_cmDev->SetVmeSurfaceStateParam(m_cmVmeSurf[0], &surfaceParams));
588 m_surfIndex[idx++] = m_cmVmeSurf[0];
589
590 CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)PB8x8MbEncParams->m_cmWaveFrontMap, m_cmSurface2D[8]));
591 CM_CHK_STATUS_RETURN(m_cmSurface2D[8]->GetIndex(m_surfIndex[idx++]));
592 CM_CHK_STATUS_RETURN(m_cmDev->CreateBuffer((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfMVIndex, m_cmBuffer[5]));
593 CM_CHK_STATUS_RETURN(m_cmBuffer[5]->GetIndex(m_surfIndex[idx++]));
594 CM_CHK_STATUS_RETURN(m_cmDev->CreateBuffer((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfMVPred, m_cmBuffer[6]));
595 CM_CHK_STATUS_RETURN(m_cmBuffer[6]->GetIndex(m_surfIndex[idx++]));
596 m_surfIndex[idx++] = (SurfaceIndex *)CM_NULL_SURFACE;
597 m_surfIndex[idx++] = (SurfaceIndex *)CM_NULL_SURFACE;
598 m_surfIndex[idx++] = (SurfaceIndex *)CM_NULL_SURFACE;
599 if (PB8x8MbEncParams->m_cmSurfMVPredictor == nullptr)
600 {
601 m_surfIndex[idx++] = (SurfaceIndex *)CM_NULL_SURFACE;
602 }
603 else
604 {
605 CM_CHK_STATUS_RETURN(m_cmDev->CreateBuffer((MOS_RESOURCE *)PB8x8MbEncParams->m_cmSurfMVPredictor, m_cmBuffer[7]));
606 CM_CHK_STATUS_RETURN(m_cmBuffer[7]->GetIndex(m_surfIndex[idx++]));
607 }
608 if (PB8x8MbEncParams->m_cmSurfPerCTBInput == nullptr)
609 {
610 m_surfIndex[idx++] = (SurfaceIndex *)CM_NULL_SURFACE;
611 }
612 else
613 {
614 CM_CHK_STATUS_RETURN(m_cmDev->CreateBuffer((MOS_RESOURCE*)PB8x8MbEncParams->m_cmSurfPerCTBInput, m_cmBuffer[8]));
615 CM_CHK_STATUS_RETURN(m_cmBuffer[8]->GetIndex(m_surfIndex[idx++]));
616 }
617
618 for (; idx < NUM_MBENC_P_MB_SURFACES; idx++)
619 {
620 m_surfIndex[idx] = (SurfaceIndex *)CM_NULL_SURFACE;
621 }
622
623 return CM_SUCCESS;
624 }
625