| /* |
| * Copyright (c) 2017, Intel Corporation |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| * and/or sell copies of the Software, and to permit persons to whom the |
| * Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included |
| * in all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
| * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR |
| * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
| * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
| * OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| //! |
| //! \file CMRTKernel_DownScaling.cpp |
| //! \brief HEVC FEI 2xScaling class for GEN9 SKL. |
| //! |
| |
| #include "CMRTKernel_DownScaling.h" |
| #include "CMRTKernel_DS_Kernel_def.h" |
| |
| CMRTKernelDownScaling::CMRTKernelDownScaling() |
| { |
| |
| m_isaName = HME_DOWNSCALE_GEN9; |
| m_isaSize = HME_DOWNSCALE_GEN9_SIZE; |
| m_kernelName = HEVCENCKERNELNAME_2xDS_FRAME; |
| |
| m_cmSurface2DCount = 2; |
| m_cmBufferCount = 1; |
| m_cmVmeSurfCount = 0; |
| |
| if (m_cmSurface2DCount > 0) |
| { |
| m_cmSurface2D = (CmSurface2D **)malloc(sizeof(CmSurface2D *) * m_cmSurface2DCount); |
| if (m_cmSurface2D != NULL) |
| { |
| memset(m_cmSurface2D, 0, sizeof(CmSurface2D *) * m_cmSurface2DCount); |
| } |
| } |
| |
| if (m_cmBufferCount > 0) |
| { |
| m_cmBuffer = (CmBuffer **)malloc(sizeof(CmBuffer *) * m_cmBufferCount); |
| if (m_cmBuffer != NULL) |
| { |
| memset(m_cmBuffer, 0, sizeof(CmBuffer *) * m_cmBufferCount); |
| } |
| } |
| |
| if (m_cmVmeSurfCount > 0) |
| { |
| m_cmVmeSurf = (SurfaceIndex **)malloc(sizeof(SurfaceIndex *) * m_cmVmeSurfCount); |
| if (m_cmVmeSurf != NULL) |
| { |
| memset(m_cmVmeSurf, 0, sizeof(SurfaceIndex *) * m_cmVmeSurfCount); |
| } |
| } |
| |
| m_surfIndex = (SurfaceIndex **)malloc(sizeof(SurfaceIndex *) * (m_cmSurface2DCount + m_cmBufferCount + m_cmVmeSurfCount)); |
| if (m_surfIndex != NULL) |
| { |
| memset(m_surfIndex, 0, sizeof(SurfaceIndex *) * (m_cmSurface2DCount + m_cmBufferCount + m_cmVmeSurfCount)); |
| } |
| } |
| |
| CMRTKernelDownScaling::~CMRTKernelDownScaling() |
| { |
| if (m_cmSurface2D != nullptr) |
| { |
| free(m_cmSurface2D); |
| } |
| |
| if (m_cmBuffer != nullptr) |
| { |
| free(m_cmBuffer); |
| } |
| |
| if (m_cmVmeSurf != nullptr) |
| { |
| free(m_cmVmeSurf); |
| } |
| |
| if (m_surfIndex != nullptr) |
| { |
| free(m_surfIndex); |
| } |
| } |
| |
| CM_RETURN_CODE CMRTKernelDownScaling::SetupCurbe(void *curbe) |
| { |
| m_curbe = curbe; |
| return CM_SUCCESS; |
| } |
| |
| CM_RETURN_CODE CMRTKernelDownScaling::CreateAndDispatchKernel(CmEvent *&cmEvent, bool destroyEvent, bool isEnqueue) |
| { |
| CM_RETURN_CODE r = CM_SUCCESS; |
| int32_t result; |
| uint32_t *curbe = (uint32_t *)m_curbe; |
| uint32_t reserved[7]; |
| uint32_t width, height, scaling2xWidth, scaling2xHeight, threadSpaceWidth, threadSpaceHeight; |
| |
| width = curbe[0] & 0x0FFFF; |
| height = (curbe[0] >> 16) & 0x0FFFF; |
| |
| scaling2xWidth = (16 * MOS_ROUNDUP_DIVIDE(width , 32)); |
| scaling2xHeight = (16 * MOS_ROUNDUP_DIVIDE(height , 32)); |
| |
| if (scaling2xWidth < 48) |
| { |
| scaling2xWidth = 48; |
| } |
| |
| if (scaling2xHeight < 48) |
| { |
| scaling2xHeight = 48; |
| } |
| |
| threadSpaceWidth = MOS_ROUNDUP_DIVIDE(scaling2xWidth, 16); // Each 16x16 pixel output is completed by 1 thread |
| threadSpaceHeight = MOS_ROUNDUP_DIVIDE(scaling2xHeight, 16); // Each 16x16 pixel output is completed by 1 thread |
| |
| m_cmKernel->SetKernelArg(0, sizeof(uint16_t), &width); // DW0 |
| m_cmKernel->SetKernelArg(1, sizeof(uint16_t), &height); // DW0 |
| m_cmKernel->SetKernelArg(2, 7 * sizeof(uint32_t), reserved); |
| m_cmKernel->SetKernelArg(3, sizeof(SurfaceIndex), m_surfIndex[0]); // DW8 |
| m_cmKernel->SetKernelArg(4, sizeof(SurfaceIndex), m_surfIndex[1]); // DW9 |
| |
| CM_CHK_STATUS_RETURN(m_cmKernel->SetThreadCount(threadSpaceWidth * threadSpaceHeight)); |
| //create Thread Space |
| result = CreateThreadSpace(threadSpaceWidth, threadSpaceHeight); |
| if (result != CM_SUCCESS) |
| { |
| printf("CM Create ThreadSpace error : %d", result); |
| return (CM_RETURN_CODE)result; |
| } |
| |
| r = AddKernel(cmEvent, destroyEvent, isEnqueue); |
| return r; |
| } |
| |
| CM_RETURN_CODE CMRTKernelDownScalingUMD::AllocateSurfaces(void *params) |
| { |
| DownScalingKernelParams *scalingParams=(DownScalingKernelParams *)params; |
| |
| CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)scalingParams->m_cmSurfDS_TopIn, m_cmSurface2D[0])); |
| CM_CHK_STATUS_RETURN(m_cmSurface2D[0]->GetIndex(m_surfIndex[0])); |
| |
| CM_CHK_STATUS_RETURN(m_cmDev->CreateSurface2D((MOS_RESOURCE *)scalingParams->m_cmSurfDS_TopOut, m_cmSurface2D[1])); |
| CM_CHK_STATUS_RETURN(m_cmSurface2D[1]->GetIndex(m_surfIndex[1])); |
| |
| if (scalingParams->m_cmSurfTopVProc != nullptr) |
| { |
| CM_CHK_STATUS_RETURN(m_cmDev->CreateBuffer((MOS_RESOURCE *)scalingParams->m_cmSurfTopVProc, m_cmBuffer[0])); |
| CM_CHK_STATUS_RETURN(m_cmBuffer[0]->GetIndex(m_surfIndex[2])); |
| } |
| else |
| { |
| m_surfIndex[2] = nullptr; |
| } |
| |
| return CM_SUCCESS; |
| } |
| |