1 /*
2 * Copyright (c) 2022, 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_packet_reuse_manager.h
24 //! \brief    Defines the classes for vp packet reuse
25 //!           this file is for the base interface which is shared by all features.
26 //!
27 
28 #ifndef __VP_PACKET_REUSE_MANAGER_H__
29 #define __VP_PACKET_REUSE_MANAGER_H__
30 
31 #include "mos_defs.h"
32 #include "media_class_trace.h"
33 #include "sw_filter.h"
34 #include "vp_packet_pipe.h"
35 
36 namespace vp
37 {
38 
39 class VpCmdPacket;
40 class PacketPipeFactory;
41 class Policy;
42 class PacketPipe;
43 class SwFilterPipe;
44 class VpResourceManager;
45 
46 class VpFeatureReuseBase
47 {
48 public:
49     virtual ~VpFeatureReuseBase();
50     virtual MOS_STATUS UpdateFeatureParams(bool reusable, bool &reused, SwFilter *filter);
51     virtual MOS_STATUS UpdatePacket(SwFilter *filter, VpCmdPacket *packet);
52     virtual MOS_STATUS CheckTeamsParams(bool reusable, bool &reused, SwFilter *filter, uint32_t index);
53     virtual MOS_STATUS StoreTeamsParams(SwFilter *filter, uint32_t index);
54 
HandleNullSwFilter(bool reusableOfLastPipe,bool & isPacketPipeReused,SwFilter * filter,bool & ignoreUpdateFeatureParams)55     MOS_STATUS HandleNullSwFilter(bool reusableOfLastPipe, bool &isPacketPipeReused, SwFilter *filter, bool &ignoreUpdateFeatureParams)
56     {
57         if (filter == nullptr)
58         {
59             if (!reusableOfLastPipe || m_paramsAvailable)
60             {
61                 isPacketPipeReused = false;
62             }
63             m_paramsAvailable = false;
64             ignoreUpdateFeatureParams = true;
65         }
66         else if (reusableOfLastPipe && m_paramsAvailable)
67         {
68             m_paramsAvailable = true;
69         }
70         else
71         {
72             isPacketPipeReused = false;
73             m_paramsAvailable  = true;
74         }
75 
76         return MOS_STATUS_SUCCESS;
77     }
78 
79 protected:
80     bool m_paramsAvailable = true;
81     MEDIA_CLASS_DEFINE_END(vp__VpFeatureReuseBase)
82 };
83 
84 class VpScalingReuse : public VpFeatureReuseBase
85 {
86 public:
87     VpScalingReuse();
88     virtual ~VpScalingReuse();
89 
90     MOS_STATUS UpdateFeatureParams(bool reusable, bool &reused, SwFilter *filter);
91 
92     MOS_STATUS UpdatePacket(SwFilter *filter, VpCmdPacket *packet);
93 
94     MOS_STATUS CheckTeamsParams(bool reusable, bool &reused, SwFilter *filter, uint32_t index);
95 
96     MOS_STATUS StoreTeamsParams(SwFilter *filter, uint32_t index);
97 
98 protected:
99     MOS_STATUS UpdateFeatureParams(FeatureParamScaling &params);
100 
101     FeatureParamScaling         m_params          = {};
102     VPHAL_COLORFILL_PARAMS      m_colorFillParams = {};     //!< ColorFill - BG only
103     VPHAL_ALPHA_PARAMS          m_compAlpha       = {};     //!< Alpha for composited surfaces
104     std::map<uint32_t, FeatureParamScaling> m_params_Teams;
105 
106 MEDIA_CLASS_DEFINE_END(vp__VpScalingReuse)
107 };
108 
109 class VpCscReuse : public VpFeatureReuseBase
110 {
111 public:
112     VpCscReuse();
113     virtual ~VpCscReuse() ;
114 
115     MOS_STATUS UpdateFeatureParams(bool reusable, bool &reused, SwFilter *filter);
116 
117     MOS_STATUS UpdatePacket(SwFilter *filter, VpCmdPacket *packet);
118 
119     MOS_STATUS CheckTeamsParams(bool reusable, bool &reused, SwFilter *filter, uint32_t index);
120 
121     MOS_STATUS StoreTeamsParams(SwFilter *filter, uint32_t index);
122 
123 protected:
124     MOS_STATUS UpdateFeatureParams(FeatureParamCsc &params);
125 
126     FeatureParamCsc             m_params            = {};
127     VPHAL_ALPHA_PARAMS          m_alphaParams       = {};     //!< Alpha for composited surfaces
128     VPHAL_IEF_PARAMS            m_iefParams         = {};
129     std::map<uint32_t, FeatureParamCsc> m_params_Teams;
130 
131 MEDIA_CLASS_DEFINE_END(vp__VpCscReuse)
132 };
133 
134 class VpRotMirReuse : public VpFeatureReuseBase
135 {
136 public:
137     VpRotMirReuse();
138     virtual ~VpRotMirReuse();
139     MOS_STATUS UpdateFeatureParams(bool reusable, bool &reused, SwFilter *filter);
140 
141     MOS_STATUS UpdatePacket(SwFilter *filter, VpCmdPacket *packet);
142 
143     MOS_STATUS CheckTeamsParams(bool reusable, bool &reused, SwFilter *filter, uint32_t index);
144 
145     MOS_STATUS StoreTeamsParams(SwFilter *filter, uint32_t index);
146 
147 protected:
148     MOS_STATUS UpdateFeatureParams(FeatureParamRotMir &params);
149     FeatureParamRotMir m_params = {};
150     std::map<uint32_t, FeatureParamRotMir> m_params_Teams;
151 
152 MEDIA_CLASS_DEFINE_END(vp__VpRotMirReuse)
153 };
154 
155 class VpColorFillReuse : public VpFeatureReuseBase
156 {
157 public:
158     VpColorFillReuse();
159     virtual ~VpColorFillReuse();
160     MOS_STATUS UpdateFeatureParams(bool reusable, bool &reused, SwFilter *filter);
161     MOS_STATUS UpdatePacket(SwFilter *filter, VpCmdPacket *packet);
162 protected:
163     MOS_STATUS UpdateFeatureParams(FeatureParamColorFill &params);
164 
165     FeatureParamColorFill m_params = {};
166     VPHAL_COLORFILL_PARAMS m_colorFillParams = {};
167 
168 MEDIA_CLASS_DEFINE_END(vp__VpColorFillReuse)
169 };
170 
171 class VpAlphaReuse : public VpFeatureReuseBase
172 {
173 public:
174     VpAlphaReuse();
175     virtual ~VpAlphaReuse();
176     MOS_STATUS UpdateFeatureParams(bool reusable, bool &reused, SwFilter *filter);
177     MOS_STATUS UpdatePacket(SwFilter *filter, VpCmdPacket *packet);
178 
179 protected:
180     MOS_STATUS UpdateFeatureParams(FeatureParamAlpha &params);
181 
182     FeatureParamAlpha m_params = {};
183     VPHAL_ALPHA_PARAMS m_compAlpha = {};
184 
185 MEDIA_CLASS_DEFINE_END(vp__VpAlphaReuse)
186 };
187 
188 class VpDenoiseReuse : public VpFeatureReuseBase
189 {
190 public:
191     VpDenoiseReuse();
192     virtual ~VpDenoiseReuse();
193     MOS_STATUS UpdateFeatureParams(bool reusable, bool &reused, SwFilter *filter);
194     MOS_STATUS UpdatePacket(SwFilter *filter, VpCmdPacket *packet);
195 
196 protected:
197     MOS_STATUS UpdateFeatureParams(FeatureParamDenoise &params);
198 
199     FeatureParamDenoise m_params = {};
200 
201     MEDIA_CLASS_DEFINE_END(vp__VpDenoiseReuse)
202 };
203 
204 class VpTccReuse : public VpFeatureReuseBase
205 {
206 public:
207     VpTccReuse();
208     virtual ~VpTccReuse();
209     MOS_STATUS UpdateFeatureParams(bool reusable, bool &reused, SwFilter *filter);
210     MOS_STATUS UpdatePacket(SwFilter *filter, VpCmdPacket *packet);
211 
212 protected:
213     MOS_STATUS UpdateFeatureParams(FeatureParamTcc &params);
214 
215     FeatureParamTcc m_params = {};
216 
217 MEDIA_CLASS_DEFINE_END(vp__VpTccReuse)
218 };
219 
220 class VpSteReuse : public VpFeatureReuseBase
221 {
222 public:
223     VpSteReuse();
224     virtual ~VpSteReuse();
225     MOS_STATUS UpdateFeatureParams(bool reusable, bool &reused, SwFilter *filter);
226     MOS_STATUS UpdatePacket(SwFilter *filter, VpCmdPacket *packet);
227 
228 protected:
229     MOS_STATUS UpdateFeatureParams(FeatureParamSte &params);
230 
231     FeatureParamSte m_params = {};
232 
233 MEDIA_CLASS_DEFINE_END(vp__VpSteReuse)
234 };
235 
236 class VpProcampReuse : public VpFeatureReuseBase
237 {
238 public:
239     VpProcampReuse();
240     virtual ~VpProcampReuse();
241     MOS_STATUS UpdateFeatureParams(bool reusable, bool &reused, SwFilter *filter);
242     MOS_STATUS UpdatePacket(SwFilter *filter, VpCmdPacket *packet);
243 
244 protected:
245     MOS_STATUS UpdateFeatureParams(FeatureParamProcamp &params);
246 
247     FeatureParamProcamp  m_params = {};
248     VPHAL_PROCAMP_PARAMS m_procampParams = {};
249 
250     MEDIA_CLASS_DEFINE_END(vp__VpProcampReuse)
251 };
252 
253 class VpPacketReuseManager
254 {
255 public:
256     VpPacketReuseManager(PacketPipeFactory &packetPipeFactory, VpUserFeatureControl &userFeatureControl);
257     virtual ~VpPacketReuseManager();
258     virtual MOS_STATUS RegisterFeatures();
259     MOS_STATUS PreparePacketPipeReuse(SwFilterPipe *&swFilterPipes, Policy &policy, VpResourceManager &resMgr, bool &isPacketPipeReused, bool &isTeamsWL);
260     // Be called for not reused case before packet pipe execution.
261     MOS_STATUS UpdatePacketPipeConfig(PacketPipe *&pipe);
GetPacketPipeReused()262     PacketPipe *GetPacketPipeReused()
263     {
264         return m_pipeReused;
265     }
266 
267 protected:
268     bool m_reusable = false;    // Current parameter can be reused.
269     PacketPipe *m_pipeReused = nullptr;
270     std::map<FeatureType, VpFeatureReuseBase *> m_features;
271     PacketPipeFactory &m_packetPipeFactory;
272     bool m_disablePacketReuse = false;
273     uint32_t curIndex = 0;
274     uint32_t MaxTeamsPacketSize = 16;    // max 16 Teams Packet stored
275     bool m_TeamsPacket = false;
276     bool m_TeamsPacket_reuse = false;
277     bool m_enablePacketReuseTeamsAlways = false;
278     std::map<uint32_t, PacketPipe *> m_pipeReused_TeamsPacket;
279 MEDIA_CLASS_DEFINE_END(vp__VpPacketReuseManager)
280 };
281 
282 }  // namespace vp
283 
284 #endif
285