| 1 |
/* |
| 2 |
* Copyright (c) 2017-2020, 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 codechal_kernel_base.cpp |
| 24 |
//! \brief Defines base class for all kernels |
| 25 |
//! \details Kernel base class abstracts all common functions and definitions |
| 26 |
//! for all kernels, each kernel class should inherit from kernel base |
| 27 |
//! |
| 28 |
|
| 29 |
#include "codechal_kernel_base.h" |
| 30 |
#include "codeckrnheader.h" |
| 31 |
#include "hal_oca_interface.h" |
| 32 |
|
| 33 |
CodechalKernelBase::CodechalKernelBase(CodechalEncoderState *encoder) : |
| 34 |
m_encoder(encoder), |
| 35 |
m_firstTaskInPhase(encoder->m_firstTaskInPhase), |
| 36 |
m_lastTaskInPhase(encoder->m_lastTaskInPhase), |
| 37 |
m_singleTaskPhaseSupported(encoder->m_singleTaskPhaseSupported), |
| 38 |
m_renderContextUsesNullHw(encoder->m_renderContextUsesNullHw), |
| 39 |
m_groupIdSelectSupported(encoder->m_groupIdSelectSupported), |
| 40 |
m_fieldScalingOutputInterleaved(encoder->m_fieldScalingOutputInterleaved), |
| 41 |
m_vdencEnabled(encoder->m_vdencEnabled), |
| 42 |
m_groupId(encoder->m_groupId), |
| 43 |
m_maxBtCount(encoder->m_maxBtCount), |
| 44 |
m_vmeStatesSize(encoder->m_vmeStatesSize), |
| 45 |
m_storeData(encoder->m_storeData), |
| 46 |
m_verticalLineStride(encoder->m_verticalLineStride), |
| 47 |
m_downscaledWidthInMb4x(encoder->m_downscaledWidthInMb4x), |
| 48 |
m_downscaledHeightInMb4x(encoder->m_downscaledHeightInMb4x), |
| 49 |
m_downscaledWidthInMb16x(encoder->m_downscaledWidthInMb16x), |
| 50 |
m_downscaledHeightInMb16x(encoder->m_downscaledHeightInMb16x), |
| 51 |
m_downscaledWidthInMb32x(encoder->m_downscaledWidthInMb32x), |
| 52 |
m_downscaledHeightInMb32x(encoder->m_downscaledHeightInMb32x), |
| 53 |
m_mode(encoder->m_mode), |
| 54 |
m_pictureCodingType(encoder->m_pictureCodingType), |
| 55 |
m_frameWidth(encoder->m_frameWidth), |
| 56 |
m_frameHeight(encoder->m_frameHeight), |
| 57 |
m_frameFieldHeight(encoder->m_frameFieldHeight), |
| 58 |
m_standard(encoder->m_standard), |
| 59 |
m_walkerMode(encoder->m_walkerMode) |
| 60 |
{ |
| 61 |
m_osInterface = encoder->GetOsInterface(); |
| 62 |
m_hwInterface = encoder->GetHwInterface(); |
| 63 |
m_debugInterface = encoder->GetDebugInterface(); |
| 64 |
m_miInterface = m_hwInterface->GetMiInterface(); |
| 65 |
m_renderInterface = m_hwInterface->GetRenderInterface(); |
| 66 |
m_stateHeapInterface = m_renderInterface->m_stateHeapInterface->pStateHeapInterface; |
| 67 |
} |
| 68 |
|
| 69 |
CodechalKernelBase::~CodechalKernelBase() |
| 70 |
{ |
| 71 |
for (auto &it : m_kernelStatePool) |
| 72 |
{ |
| 73 |
MOS_Delete(it.second); |
| 74 |
} |
| 75 |
m_kernelStatePool.clear(); |
| 76 |
|
| 77 |
for (auto &it : m_surfacePool) |
| 78 |
{ |
| 79 |
if (it.second != nullptr) |
| 80 |
{ |
| 81 |
m_osInterface->pfnFreeResource(m_osInterface, &it.second->OsResource); |
| 82 |
MOS_Delete(it.second); |
| 83 |
} |
| 84 |
} |
| 85 |
m_surfacePool.clear(); |
| 86 |
} |
| 87 |
|
| 88 |
MOS_STATUS CodechalKernelBase::GetKernelBinaryAndSize( |
| 89 |
uint8_t * kernelBase, |
| 90 |
uint32_t kernelUID, |
| 91 |
uint8_t **kernelBinary, |
| 92 |
uint32_t *size) |
| 93 |
{ |
| 94 |
CODECHAL_ENCODE_CHK_NULL_RETURN(kernelBase); |
| 95 |
CODECHAL_ENCODE_CHK_NULL_RETURN(kernelBinary); |
| 96 |
CODECHAL_ENCODE_CHK_NULL_RETURN(size); |
| 97 |
|
| 98 |
if (kernelUID >= IDR_CODEC_TOTAL_NUM_KERNELS) |
| 99 |
{ |
| 100 |
return MOS_STATUS_INVALID_PARAMETER; |
| 101 |
} |
| 102 |
|
| 103 |
auto kernelOffsetTable = (uint32_t *)kernelBase; |
| 104 |
auto binaryBase = (uint8_t *)(kernelOffsetTable + IDR_CODEC_TOTAL_NUM_KERNELS + 1); |
| 105 |
|
| 106 |
*size = kernelOffsetTable[kernelUID + 1] - kernelOffsetTable[kernelUID]; |
| 107 |
*kernelBinary = (*size) > 0 ? binaryBase + kernelOffsetTable[kernelUID] : nullptr; |
| 108 |
|
| 109 |
return MOS_STATUS_SUCCESS; |
| 110 |
} |
| 111 |
|
| 112 |
MOS_STATUS CodechalKernelBase::Initialize( |
| 113 |
KernelBinaryCallback callback, |
| 114 |
uint8_t * binaryBase, |
| 115 |
uint32_t kernelUID) |
| 116 |
{ |
| 117 |
CODECHAL_ENCODE_CHK_NULL_RETURN(callback); |
| 118 |
CODECHAL_ENCODE_CHK_NULL_RETURN(binaryBase); |
| 119 |
|
| 120 |
m_callback = callback; |
| 121 |
|
| 122 |
CODECHAL_ENCODE_CHK_NULL_RETURN(m_osInterface); |
| 123 |
CODECHAL_ENCODE_CHK_NULL_RETURN(m_hwInterface); |
| 124 |
CODECHAL_ENCODE_CHK_NULL_RETURN(m_miInterface); |
| 125 |
CODECHAL_ENCODE_CHK_NULL_RETURN(m_renderInterface); |
| 126 |
CODECHAL_ENCODE_CHK_NULL_RETURN(m_stateHeapInterface); |
| 127 |
|
| 128 |
uint32_t binarySize = 0; |
| 129 |
CODECHAL_ENCODE_CHK_STATUS_RETURN(GetKernelBinaryAndSize(binaryBase, kernelUID, &m_kernelBinary, &binarySize)); |
| 130 |
if (binarySize == 0) |
| 131 |
{ |
| 132 |
return MOS_STATUS_INVALID_PARAMETER; |
| 133 |
} |
| 134 |
|
| 135 |
return MOS_STATUS_SUCCESS; |
| 136 |
} |
| 137 |
|
| 138 |
MOS_STATUS CodechalKernelBase::CreateKernelState( |
| 139 |
MHW_KERNEL_STATE ** kernelState, |
| 140 |
uint32_t kernelIndex, |
| 141 |
EncOperation operation, |
| 142 |
uint32_t kernelOffset) |
| 143 |
{ |
| 144 |
CODECHAL_ENCODE_FUNCTION_ENTER; |
| 145 |
CODECHAL_ENCODE_CHK_NULL_RETURN(m_callback); |
| 146 |
CODECHAL_ENCODE_CHK_NULL_RETURN(m_kernelBinary); |
| 147 |
|
| 148 |
CODECHAL_ENCODE_CHK_NULL_RETURN((*kernelState) = MOS_New(MHW_KERNEL_STATE)); |
| 149 |
m_kernelStatePool.emplace(kernelIndex, *kernelState); |
| 150 |
|
| 151 |
CODECHAL_KERNEL_HEADER kernelHeader = {}; |
| 152 |
uint32_t kernelSize = 0; |
| 153 |
CODECHAL_ENCODE_CHK_STATUS_RETURN(m_callback(m_kernelBinary, operation, kernelOffset, &kernelHeader, &kernelSize)); |
| 154 |
|
| 155 |
(*kernelState)->KernelParams.iBTCount = GetBTCount(); |
| 156 |
(*kernelState)->KernelParams.iThreadCount = m_renderInterface->GetHwCaps()->dwMaxThreads; |
| 157 |
(*kernelState)->KernelParams.iCurbeLength = GetCurbeSize(); |
| 158 |
(*kernelState)->KernelParams.iBlockWidth = CODECHAL_MACROBLOCK_WIDTH; |
| 159 |
(*kernelState)->KernelParams.iBlockHeight = CODECHAL_MACROBLOCK_HEIGHT; |
| 160 |
(*kernelState)->KernelParams.iIdCount = 1; |
| 161 |
(*kernelState)->KernelParams.iInlineDataLength = GetInlineDataLength(); |
| 162 |
|
| 163 |
(*kernelState)->dwCurbeOffset = m_stateHeapInterface->GetSizeofCmdInterfaceDescriptorData(); |
| 164 |
(*kernelState)->KernelParams.pBinary = m_kernelBinary + (kernelHeader.KernelStartPointer << MHW_KERNEL_OFFSET_SHIFT); |
| 165 |
(*kernelState)->KernelParams.iSize = kernelSize; |
| 166 |
CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->CalculateSshAndBtSizesRequested( |
| 167 |
(*kernelState)->KernelParams.iBTCount, |
| 168 |
&(*kernelState)->dwSshSize, |
| 169 |
&(*kernelState)->dwBindingTableSize)); |
| 170 |
|
| 171 |
CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->MhwInitISH(m_renderInterface->m_stateHeapInterface, (*kernelState))); |
| 172 |
|
| 173 |
return MOS_STATUS_SUCCESS; |
| 174 |
} |
| 175 |
|
| 176 |
MOS_STATUS CodechalKernelBase::Run() |
| 177 |
{ |
| 178 |
CODECHAL_ENCODE_FUNCTION_ENTER; |
| 179 |
|
| 180 |
AddPerfTag(); |
| 181 |
|
| 182 |
MHW_KERNEL_STATE *kernelState = GetActiveKernelState(); |
| 183 |
CODECHAL_ENCODE_CHK_NULL_RETURN(kernelState); |
| 184 |
|
| 185 |
// If Single Task Phase is not enabled, use BT count for the kernel state. |
| 186 |
if (m_firstTaskInPhase == true || !m_singleTaskPhaseSupported) |
| 187 |
{ |
| 188 |
uint32_t maxBtCount = m_singleTaskPhaseSupported ? m_maxBtCount : kernelState->KernelParams.iBTCount; |
| 189 |
CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->RequestSshSpaceForCmdBuf(maxBtCount)); |
| 190 |
m_vmeStatesSize = m_hwInterface->GetKernelLoadCommandSize(maxBtCount); |
| 191 |
CODECHAL_ENCODE_CHK_STATUS_RETURN(m_encoder->VerifySpaceAvailable()); |
| 192 |
} |
| 193 |
|
| 194 |
auto stateHeapInterface = m_renderInterface->m_stateHeapInterface; |
| 195 |
CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->AssignDshAndSshSpace( |
| 196 |
stateHeapInterface, |
| 197 |
kernelState, |
| 198 |
false, |
| 199 |
0, |
| 200 |
false, |
| 201 |
m_storeData)); |
| 202 |
|
| 203 |
MHW_INTERFACE_DESCRIPTOR_PARAMS idParams; |
| 204 |
MOS_ZeroMemory(&idParams, sizeof(idParams)); |
| 205 |
idParams.pKernelState = kernelState; |
| 206 |
CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->SetInterfaceDescriptor(1, &idParams)); |
| 207 |
|
| 208 |
CODECHAL_MEDIA_STATE_TYPE encFunctionType = GetMediaStateType(); |
| 209 |
|
| 210 |
CODECHAL_ENCODE_CHK_STATUS_RETURN(SetCurbe(kernelState)); |
| 211 |
|
| 212 |
CODECHAL_DEBUG_TOOL( |
| 213 |
CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(encFunctionType, MHW_DSH_TYPE, kernelState)); |
| 214 |
CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(encFunctionType, MHW_ISH_TYPE, kernelState)); |
| 215 |
CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpCurbe(encFunctionType, kernelState))); |
| 216 |
|
| 217 |
MOS_COMMAND_BUFFER cmdBuffer; |
| 218 |
CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0)); |
| 219 |
|
| 220 |
SendKernelCmdsParams sendKernelCmdsParams = SendKernelCmdsParams(); |
| 221 |
sendKernelCmdsParams.EncFunctionType = encFunctionType; |
| 222 |
sendKernelCmdsParams.pKernelState = kernelState; |
| 223 |
CODECHAL_ENCODE_CHK_STATUS_RETURN(m_encoder->SendGenericKernelCmds(&cmdBuffer, &sendKernelCmdsParams)); |
| 224 |
|
| 225 |
// Add binding table |
| 226 |
CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->SetBindingTable(kernelState)); |
| 227 |
|
| 228 |
CODECHAL_ENCODE_CHK_STATUS_RETURN(SendSurfaces(&cmdBuffer, kernelState)); |
| 229 |
|
| 230 |
CODECHAL_DEBUG_TOOL( |
| 231 |
CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(encFunctionType, MHW_SSH_TYPE, kernelState))); |
| 232 |
|
| 233 |
CODECHAL_WALKER_CODEC_PARAMS walkerCodecParams; |
| 234 |
MOS_ZeroMemory(&walkerCodecParams, sizeof(walkerCodecParams)); |
| 235 |
|
| 236 |
InitWalkerCodecParams(walkerCodecParams); |
| 237 |
|
| 238 |
MHW_WALKER_PARAMS walkerParams; |
| 239 |
CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalInitMediaObjectWalkerParams( |
| 240 |
m_hwInterface, |
| 241 |
&walkerParams, |
| 242 |
&walkerCodecParams)); |
| 243 |
|
| 244 |
HalOcaInterface::TraceMessage(cmdBuffer, (MOS_CONTEXT_HANDLE)m_osInterface->pOsContext, __FUNCTION__, sizeof(__FUNCTION__)); |
| 245 |
HalOcaInterface::OnDispatch(cmdBuffer, *m_osInterface, *m_miInterface, *m_renderInterface->GetMmioRegisters()); |
| 246 |
|
| 247 |
CODECHAL_ENCODE_CHK_STATUS_RETURN(m_renderInterface->AddMediaObjectWalkerCmd( |
| 248 |
&cmdBuffer, |
| 249 |
&walkerParams)); |
| 250 |
|
| 251 |
CODECHAL_ENCODE_CHK_STATUS_RETURN(m_encoder->EndStatusReport(&cmdBuffer, encFunctionType)); |
| 252 |
|
| 253 |
CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->SubmitBlocks(kernelState)); |
| 254 |
if (!m_singleTaskPhaseSupported || m_lastTaskInPhase) |
| 255 |
{ |
| 256 |
CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->UpdateGlobalCmdBufId()); |
| 257 |
CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr)); |
| 258 |
} |
| 259 |
CODECHAL_DEBUG_TOOL(CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(&cmdBuffer, encFunctionType))); |
| 260 |
|
| 261 |
m_hwInterface->UpdateSSEuForCmdBuffer(&cmdBuffer, m_singleTaskPhaseSupported, m_lastTaskInPhase); |
| 262 |
m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0); |
| 263 |
|
| 264 |
if (!m_singleTaskPhaseSupported || m_lastTaskInPhase) |
| 265 |
{ |
| 266 |
HalOcaInterface::On1stLevelBBEnd(cmdBuffer, *m_osInterface); |
| 267 |
m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, m_renderContextUsesNullHw); |
| 268 |
m_lastTaskInPhase = false; |
| 269 |
} |
| 270 |
|
| 271 |
return MOS_STATUS_SUCCESS; |
| 272 |
} |
| 273 |
|
| 274 |
MOS_STATUS CodechalKernelBase::CleanUpResource(PMOS_RESOURCE resource, PMOS_ALLOC_GFXRES_PARAMS allocParam) |
| 275 |
{ |
| 276 |
CODECHAL_ENCODE_FUNCTION_ENTER; |
| 277 |
CODECHAL_ENCODE_CHK_NULL_RETURN(resource); |
| 278 |
CODECHAL_ENCODE_CHK_NULL_RETURN(allocParam); |
| 279 |
|
| 280 |
MOS_LOCK_PARAMS lockFlag; |
| 281 |
memset(&lockFlag, 0, sizeof(lockFlag)); |
| 282 |
lockFlag.WriteOnly = true; |
| 283 |
|
| 284 |
uint8_t *data = (uint8_t *)m_osInterface->pfnLockResource(m_osInterface, resource, &lockFlag); |
| 285 |
if (data == 0) |
| 286 |
{ |
| 287 |
return MOS_STATUS_NULL_POINTER; |
| 288 |
} |
| 289 |
|
| 290 |
if (allocParam->Format == Format_Buffer) |
| 291 |
{ |
| 292 |
memset(data, 0, allocParam->dwBytes); |
| 293 |
} |
| 294 |
else if (allocParam->Format == Format_Buffer_2D) |
| 295 |
{ |
| 296 |
memset(data, 0, allocParam->dwHeight * allocParam->dwWidth); |
| 297 |
} |
| 298 |
else |
| 299 |
{ |
| 300 |
return MOS_STATUS_INVALID_PARAMETER; |
| 301 |
} |
| 302 |
|
| 303 |
m_osInterface->pfnUnlockResource(m_osInterface, resource); |
| 304 |
|
| 305 |
return MOS_STATUS_SUCCESS; |
| 306 |
} |
| 307 |
|
| 308 |
PMOS_SURFACE CodechalKernelBase::GetSurface( uint32_t surfaceId ) |
| 309 |
{ |
| 310 |
auto it = m_surfacePool.find(surfaceId); |
| 311 |
if (it != m_surfacePool.end()) |
| 312 |
{ |
| 313 |
return it->second; |
| 314 |
} |
| 315 |
return nullptr; |
| 316 |
} |
| 317 |
|
| 318 |
MOS_STATUS CodechalKernelBase::AllocateSurface(PMOS_ALLOC_GFXRES_PARAMS param, PMOS_SURFACE surface, uint32_t surfaceId) |
| 319 |
{ |
| 320 |
CODECHAL_ENCODE_CHK_NULL_RETURN(param); |
| 321 |
CODECHAL_ENCODE_CHK_NULL_RETURN(surface); |
| 322 |
m_surfacePool.emplace(surfaceId, surface); |
| 323 |
|
| 324 |
CODECHAL_ENCODE_CHK_STATUS_RETURN( |
| 325 |
m_osInterface->pfnAllocateResource( |
| 326 |
m_osInterface, |
| 327 |
param, |
| 328 |
&surface->OsResource)); |
| 329 |
CleanUpResource(&surface->OsResource, param); |
| 330 |
|
| 331 |
return MOS_STATUS_SUCCESS; |
| 332 |
} |