1 /*
2 * Copyright (c) 2020-2021, 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 vp_ste_filter.cpp
24 //! \brief Defines the common interface for Skin Tone Enhancement
25 //! this file is for the base interface which is shared by all STE in driver.
26 //!
27 #include "vp_ste_filter.h"
28 #include "vp_vebox_cmd_packet.h"
29 #include "hw_filter.h"
30 #include "sw_filter_pipe.h"
31
32 namespace vp {
VpSteFilter(PVP_MHWINTERFACE vpMhwInterface)33 VpSteFilter::VpSteFilter(PVP_MHWINTERFACE vpMhwInterface) :
34 VpFilter(vpMhwInterface)
35 {
36
37 }
38
Init()39 MOS_STATUS VpSteFilter::Init()
40 {
41 VP_FUNC_CALL();
42
43 return MOS_STATUS_SUCCESS;
44 }
45
Prepare()46 MOS_STATUS VpSteFilter::Prepare()
47 {
48 VP_FUNC_CALL();
49
50 return MOS_STATUS_SUCCESS;
51 }
52
Destroy()53 MOS_STATUS VpSteFilter::Destroy()
54 {
55 VP_FUNC_CALL();
56
57 if (m_pVeboxSteParams)
58 {
59 MOS_FreeMemAndSetNull(m_pVeboxSteParams);
60 }
61
62 return MOS_STATUS_SUCCESS;
63 }
64
SetExecuteEngineCaps(FeatureParamSte & steParams,VP_EXECUTE_CAPS vpExecuteCaps)65 MOS_STATUS VpSteFilter::SetExecuteEngineCaps(
66 FeatureParamSte &steParams,
67 VP_EXECUTE_CAPS vpExecuteCaps)
68 {
69 VP_FUNC_CALL();
70
71 m_steParams = steParams;
72 m_executeCaps = vpExecuteCaps;
73
74 return MOS_STATUS_SUCCESS;
75 }
76
CalculateEngineParams()77 MOS_STATUS VpSteFilter::CalculateEngineParams()
78 {
79 VP_FUNC_CALL();
80 if (m_executeCaps.bVebox)
81 {
82 // create a filter Param buffer
83 if (!m_pVeboxSteParams)
84 {
85 m_pVeboxSteParams = (PVEBOX_STE_PARAMS)MOS_AllocAndZeroMemory(sizeof(VEBOX_STE_PARAMS));
86
87 if (m_pVeboxSteParams == nullptr)
88 {
89 VP_PUBLIC_ASSERTMESSAGE("Vebox Ste Pamas buffer allocate failed, return nullpointer");
90 return MOS_STATUS_NO_SPACE;
91 }
92 }
93 else
94 {
95 MOS_ZeroMemory(m_pVeboxSteParams, sizeof(VEBOX_STE_PARAMS));
96 }
97
98 m_pVeboxSteParams->bEnableSTE = m_steParams.bEnableSTE;
99 m_pVeboxSteParams->dwSTEFactor = m_steParams.dwSTEFactor;
100 }
101 else
102 {
103 VP_PUBLIC_ASSERTMESSAGE("Wrong engine caps! Vebox should be used for STE");
104 return MOS_STATUS_INVALID_PARAMETER;
105 }
106
107 return MOS_STATUS_SUCCESS;
108 }
109
110
111 /****************************************************************************************************/
112 /* HwFilter Ste Parameter */
113 /****************************************************************************************************/
Create(HW_FILTER_STE_PARAM & param,FeatureType featureType)114 HwFilterParameter *HwFilterSteParameter::Create(HW_FILTER_STE_PARAM ¶m, FeatureType featureType)
115 {
116 VP_FUNC_CALL();
117
118 HwFilterSteParameter *p = MOS_New(HwFilterSteParameter, featureType);
119 if (p)
120 {
121 if (MOS_FAILED(p->Initialize(param)))
122 {
123 MOS_Delete(p);
124 return nullptr;
125 }
126 }
127 return p;
128 }
129
HwFilterSteParameter(FeatureType featureType)130 HwFilterSteParameter::HwFilterSteParameter(FeatureType featureType) : HwFilterParameter(featureType)
131 {
132 }
133
~HwFilterSteParameter()134 HwFilterSteParameter::~HwFilterSteParameter()
135 {
136 }
137
ConfigParams(HwFilter & hwFilter)138 MOS_STATUS HwFilterSteParameter::ConfigParams(HwFilter &hwFilter)
139 {
140 VP_FUNC_CALL();
141
142 return hwFilter.ConfigParam(m_Params);
143 }
144
Initialize(HW_FILTER_STE_PARAM & param)145 MOS_STATUS HwFilterSteParameter::Initialize(HW_FILTER_STE_PARAM ¶m)
146 {
147 VP_FUNC_CALL();
148
149 m_Params = param;
150 return MOS_STATUS_SUCCESS;
151 }
152
153 /****************************************************************************************************/
154 /* Packet Vebox Ste Parameter */
155 /****************************************************************************************************/
Create(HW_FILTER_STE_PARAM & param)156 VpPacketParameter *VpVeboxSteParameter::Create(HW_FILTER_STE_PARAM ¶m)
157 {
158 VP_FUNC_CALL();
159
160 if (nullptr == param.pPacketParamFactory)
161 {
162 return nullptr;
163 }
164 VpVeboxSteParameter *p = dynamic_cast<VpVeboxSteParameter *>(param.pPacketParamFactory->GetPacketParameter(param.pHwInterface));
165 if (p)
166 {
167 if (MOS_FAILED(p->Initialize(param)))
168 {
169 VpPacketParameter *pParam = p;
170 param.pPacketParamFactory->ReturnPacketParameter(pParam);
171 return nullptr;
172 }
173 }
174 return p;
175 }
176
VpVeboxSteParameter(PVP_MHWINTERFACE pHwInterface,PacketParamFactoryBase * packetParamFactory)177 VpVeboxSteParameter::VpVeboxSteParameter(PVP_MHWINTERFACE pHwInterface, PacketParamFactoryBase *packetParamFactory) :
178 VpPacketParameter(packetParamFactory), m_steFilter(pHwInterface)
179 {
180 }
~VpVeboxSteParameter()181 VpVeboxSteParameter::~VpVeboxSteParameter() {}
182
SetPacketParam(VpCmdPacket * pPacket)183 bool VpVeboxSteParameter::SetPacketParam(VpCmdPacket *pPacket)
184 {
185 VP_FUNC_CALL();
186
187 VpVeboxCmdPacket *pVeboxPacket = dynamic_cast<VpVeboxCmdPacket *>(pPacket);
188 if (nullptr == pVeboxPacket)
189 {
190 return false;
191 }
192
193 VEBOX_STE_PARAMS *pParams = m_steFilter.GetVeboxParams();
194 if (nullptr == pParams)
195 {
196 return false;
197 }
198 return MOS_SUCCEEDED(pVeboxPacket->SetSteParams(pParams));
199 }
200
Initialize(HW_FILTER_STE_PARAM & params)201 MOS_STATUS VpVeboxSteParameter::Initialize(HW_FILTER_STE_PARAM ¶ms)
202 {
203 VP_FUNC_CALL();
204
205 VP_PUBLIC_CHK_STATUS_RETURN(m_steFilter.Init());
206 VP_PUBLIC_CHK_STATUS_RETURN(m_steFilter.SetExecuteEngineCaps(params.steParams, params.vpExecuteCaps));
207 VP_PUBLIC_CHK_STATUS_RETURN(m_steFilter.CalculateEngineParams());
208 return MOS_STATUS_SUCCESS;
209 }
210
211 /****************************************************************************************************/
212 /* Policy Vebox Ste Handler */
213 /****************************************************************************************************/
PolicyVeboxSteHandler(VP_HW_CAPS & hwCaps)214 PolicyVeboxSteHandler::PolicyVeboxSteHandler(VP_HW_CAPS &hwCaps) : PolicyFeatureHandler(hwCaps)
215 {
216 m_Type = FeatureTypeSteOnVebox;
217 }
~PolicyVeboxSteHandler()218 PolicyVeboxSteHandler::~PolicyVeboxSteHandler()
219 {
220 }
221
IsFeatureEnabled(VP_EXECUTE_CAPS vpExecuteCaps)222 bool PolicyVeboxSteHandler::IsFeatureEnabled(VP_EXECUTE_CAPS vpExecuteCaps)
223 {
224 VP_FUNC_CALL();
225
226 return vpExecuteCaps.bSTE;
227 }
228
CreateHwFilterParam(VP_EXECUTE_CAPS vpExecuteCaps,SwFilterPipe & swFilterPipe,PVP_MHWINTERFACE pHwInterface)229 HwFilterParameter* PolicyVeboxSteHandler::CreateHwFilterParam(VP_EXECUTE_CAPS vpExecuteCaps, SwFilterPipe& swFilterPipe, PVP_MHWINTERFACE pHwInterface)
230 {
231
232 VP_FUNC_CALL();
233
234 if (IsFeatureEnabled(vpExecuteCaps))
235 {
236 if (SwFilterPipeType1To1 != swFilterPipe.GetSwFilterPipeType())
237 {
238 VP_PUBLIC_ASSERTMESSAGE("Invalid parameter! Sfc only support 1To1 swFilterPipe!");
239 return nullptr;
240 }
241
242 SwFilterSte *swFilter = dynamic_cast<SwFilterSte *>(swFilterPipe.GetSwFilter(true, 0, FeatureTypeSteOnVebox));
243
244 if (nullptr == swFilter)
245 {
246 VP_PUBLIC_ASSERTMESSAGE("Invalid parameter! Feature enabled in vpExecuteCaps but no swFilter exists!");
247 return nullptr;
248 }
249
250 FeatureParamSte ¶m = swFilter->GetSwFilterParams();
251
252 HW_FILTER_STE_PARAM paramSte = {};
253 paramSte.type = m_Type;
254 paramSte.pHwInterface = pHwInterface;
255 paramSte.vpExecuteCaps = vpExecuteCaps;
256 paramSte.pPacketParamFactory = &m_PacketParamFactory;
257 paramSte.steParams = param;
258 paramSte.pfnCreatePacketParam = PolicyVeboxSteHandler::CreatePacketParam;
259
260 HwFilterParameter *pHwFilterParam = GetHwFeatureParameterFromPool();
261
262 if (pHwFilterParam)
263 {
264 if (MOS_FAILED(((HwFilterSteParameter*)pHwFilterParam)->Initialize(paramSte)))
265 {
266 ReleaseHwFeatureParameter(pHwFilterParam);
267 }
268 }
269 else
270 {
271 pHwFilterParam = HwFilterSteParameter::Create(paramSte, m_Type);
272 }
273
274 return pHwFilterParam;
275 }
276 else
277 {
278 return nullptr;
279 }
280 }
281 }
282