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_8x8Pak.cpp
24 //! \brief    HEVC FEI PB 8x8 PAK class for GEN9 SKL.
25 //!
26 
27 #include "CMRTKernel_PB_8x8Pak.h"
28 #include "CMRTKernel_PB_Kernel_def.h"
29 
CMRTKernelPB8x8Pak()30 CMRTKernelPB8x8Pak::CMRTKernelPB8x8Pak()
31 {
32 
33     m_isaName         = HEVCENCFEI_PB_GEN9;
34     m_isaSize         = HEVCENCFEI_PB_GEN9_SIZE;
35     m_kernelName      = HEVCENCKERNELNAME_PB_PAK;
36 
37     m_cmSurface2DCount = 7;
38     m_cmBufferCount    = 4;
39     m_cmVmeSurfCount   = 0;
40 
41     if (m_cmSurface2DCount > 0)
42     {
43         m_cmSurface2D     = (CmSurface2D **)malloc(sizeof(CmSurface2D *) * m_cmSurface2DCount);
44         if (m_cmSurface2D != NULL)
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 != NULL)
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 != NULL)
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 != NULL)
68     {
69         memset(m_surfIndex, 0, sizeof(SurfaceIndex *) * (m_cmSurface2DCount + m_cmBufferCount + m_cmVmeSurfCount));
70     }
71 }
72 
~CMRTKernelPB8x8Pak()73 CMRTKernelPB8x8Pak::~CMRTKernelPB8x8Pak()
74 {
75     if (m_cmSurface2D != NULL)
76     {
77         free(m_cmSurface2D);
78     }
79     if (m_cmBuffer != NULL)
80     {
81         free(m_cmBuffer);
82     }
83     if (m_cmVmeSurf != NULL)
84     {
85         free(m_cmVmeSurf);
86     }
87     if (m_surfIndex != NULL)
88     {
89         free(m_surfIndex);
90     }
91 }
92 
SetupCurbe(void * curbe)93 CM_RETURN_CODE CMRTKernelPB8x8Pak::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 CMRTKernelPB8x8Pak::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, width_padded, height_padded, threadSpaceWidth, threadSpaceHeight;
105     uint32_t *curbe = (uint32_t *)m_curbe;
106 
107     width = curbe[0] & 0x0FFFF;
108     height = (curbe[0] >> 16) & 0x0FFFF;
109     width_padded = ((width + 16) >> 5) << 5;
110     height_padded = ((height + 16) >> 5) << 5;
111 
112     threadSpaceWidth = width_padded >> 5;
113     threadSpaceHeight = height_padded >> 5;
114 
115     CM_CHK_STATUS_RETURN(m_cmKernel->SetKernelArg(idx++, CURBEDATA_SIZE_PB_PAK, m_curbe));
116 
117     for (i = 0; i < NUM_MBENC_PB_PAK_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 CMRTKernelPB8x8PakUMD::AllocateSurfaces(void *params)
136 {
137     PBFrameKernelParams *PB8x8PakParams = (PBFrameKernelParams *)params;
138 
139     CM_BUFFER_STATE_PARAM bufParams;
140     memset(&bufParams, 0, sizeof(CM_BUFFER_STATE_PARAM));
141     bufParams.uiSize = PB8x8PakParams->m_bufSize;
142     bufParams.uiBaseAddressOffset = PB8x8PakParams->m_bufOffset;
143 
144     CM_CHK_STATUS_RETURN(m_cmDev->CreateBuffer((MOS_RESOURCE *)PB8x8PakParams->m_cmSurfPOCDbuf, m_cmBuffer[0]));
145     CM_CHK_STATUS_RETURN(m_cmDev->CreateBufferAlias(m_cmBuffer[0], m_surfIndex[0]));
146     CM_CHK_STATUS_RETURN(m_cmBuffer[0]->SetSurfaceStateParam(m_surfIndex[0], &bufParams));
147     CM_CHK_STATUS_RETURN(m_cmBuffer[0]->GetIndex(m_surfIndex[1]));
148     CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)PB8x8PakParams->m_cmSurfSliceMap, m_cmSurface2D[0]));
149     CM_CHK_STATUS_RETURN(m_cmSurface2D[0]->GetIndex(m_surfIndex[2]));
150     CM_CHK_STATUS_RETURN(m_cmDev->CreateBuffer((MOS_RESOURCE *)PB8x8PakParams->m_cmSurfCombinedQP, m_cmBuffer[1]));
151     CM_CHK_STATUS_RETURN(m_cmBuffer[1]->GetIndex(m_surfIndex[3]));
152     CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)PB8x8PakParams->m_cmLCUQPSurf, m_cmSurface2D[1]));
153     CM_CHK_STATUS_RETURN(m_cmSurface2D[1]->GetIndex(m_surfIndex[4]));
154     CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)PB8x8PakParams->m_cmBRCConstSurf, m_cmSurface2D[2]));
155     CM_CHK_STATUS_RETURN(m_cmSurface2D[2]->GetIndex(m_surfIndex[5]));
156     CM_CHK_STATUS_RETURN(m_cmDev->CreateBuffer((MOS_RESOURCE *)PB8x8PakParams->m_cmSurfMVIndex, m_cmBuffer[2]));
157     CM_CHK_STATUS_RETURN(m_cmBuffer[2]->GetIndex(m_surfIndex[6]));
158     CM_CHK_STATUS_RETURN(m_cmDev->CreateBuffer((MOS_RESOURCE *)PB8x8PakParams->m_cmSurfMVPred, m_cmBuffer[3]));
159     CM_CHK_STATUS_RETURN(m_cmBuffer[3]->GetIndex(m_surfIndex[7]));
160     m_surfIndex[8] = (SurfaceIndex *)CM_NULL_SURFACE;
161     m_surfIndex[9] = (SurfaceIndex *)CM_NULL_SURFACE;
162     m_surfIndex[10] = (SurfaceIndex *)CM_NULL_SURFACE;
163 
164     return CM_SUCCESS;
165 }
166 
167