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