1 /*
2 * Copyright (c) 2020-2024, 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 //!
24 //! \file     sw_filter_handle.cpp
25 //! \brief    Factories for vp sw filter handle creation.
26 //!
27 
28 #include "sw_filter_handle.h"
29 
30 using namespace vp;
31 /****************************************************************************************************/
32 /*                                      SwFilterFeatureHandler                                      */
33 /****************************************************************************************************/
34 
SwFilterFeatureHandler(VpInterface & vpInterface,FeatureType type)35 SwFilterFeatureHandler::SwFilterFeatureHandler(VpInterface& vpInterface, FeatureType type) : m_vpInterface(vpInterface), m_type(type)
36 {}
37 
~SwFilterFeatureHandler()38 SwFilterFeatureHandler::~SwFilterFeatureHandler()
39 {}
40 
IsFeatureEnabled(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex,SwFilterPipeType pipeType)41 bool SwFilterFeatureHandler::IsFeatureEnabled(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex, SwFilterPipeType pipeType)
42 {
43     VP_FUNC_CALL();
44 
45     if (isInputSurf && (uint32_t)surfIndex >= params.uSrcCount ||
46         !isInputSurf && (uint32_t)surfIndex >= params.uDstCount)
47     {
48         // Invalid parameters.
49         VP_PUBLIC_ASSERTMESSAGE("Surface index is bigger than surface count!");
50         return false;
51     }
52     return true;
53 }
54 
CreateSwFilter(SwFilter * & swFilter,VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex,SwFilterPipeType pipeType)55 MOS_STATUS SwFilterFeatureHandler::CreateSwFilter(SwFilter*& swFilter, VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex, SwFilterPipeType pipeType)
56 {
57     VP_FUNC_CALL();
58 
59     swFilter = nullptr;
60     if (!IsFeatureEnabled(params, isInputSurf, surfIndex, pipeType))
61     {
62         // nullptr == swFilter means no such feature in params, which is also the valid case.
63         return MOS_STATUS_SUCCESS;
64     }
65     swFilter = CreateSwFilter();
66     VP_PUBLIC_CHK_NULL_RETURN(swFilter);
67     MOS_STATUS status = swFilter->Configure(params, isInputSurf, surfIndex);
68     if (MOS_FAILED(status))
69     {
70         Destory(swFilter);
71         VP_PUBLIC_CHK_STATUS_RETURN(status);
72     }
73     return MOS_STATUS_SUCCESS;
74 }
75 
IsFeatureEnabled(VEBOX_SFC_PARAMS & params)76 bool SwFilterFeatureHandler::IsFeatureEnabled(VEBOX_SFC_PARAMS& params)
77 {
78     VP_FUNC_CALL();
79 
80     return false;
81 }
82 
CreateSwFilter(SwFilter * & swFilter,VEBOX_SFC_PARAMS & params)83 MOS_STATUS SwFilterFeatureHandler::CreateSwFilter(SwFilter*& swFilter, VEBOX_SFC_PARAMS& params)
84 {
85     VP_FUNC_CALL();
86 
87     swFilter = nullptr;
88     if (!IsFeatureEnabled(params))
89     {
90         // nullptr == swFilter means no such feature in params, which is also the valid case.
91         return MOS_STATUS_SUCCESS;
92     }
93     swFilter = CreateSwFilter();
94     VP_PUBLIC_CHK_NULL_RETURN(swFilter);
95     MOS_STATUS status = swFilter->Configure(params);
96     if (MOS_FAILED(status))
97     {
98         Destory(swFilter);
99         VP_PUBLIC_CHK_STATUS_RETURN(status);
100     }
101     return MOS_STATUS_SUCCESS;
102 }
103 
104 /****************************************************************************************************/
105 /*                                      SwFilterCscHandler                                          */
106 /****************************************************************************************************/
107 
SwFilterCscHandler(VpInterface & vpInterface)108 SwFilterCscHandler::SwFilterCscHandler(VpInterface& vpInterface) :
109     SwFilterFeatureHandler(vpInterface, FeatureTypeCsc),
110     m_swFilterFactory(vpInterface)
111 {
112 }
113 
~SwFilterCscHandler()114 SwFilterCscHandler::~SwFilterCscHandler()
115 {
116 }
117 
IsFeatureEnabled(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex,SwFilterPipeType pipeType)118 bool SwFilterCscHandler::IsFeatureEnabled(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex, SwFilterPipeType pipeType)
119 {
120     VP_FUNC_CALL();
121 
122     if (!SwFilterFeatureHandler::IsFeatureEnabled(params, isInputSurf, surfIndex, pipeType))
123     {
124         return false;
125     }
126 
127     if (isInputSurf && (SwFilterPipeType1To1 == pipeType || SwFilterPipeTypeNTo1 == pipeType) ||
128         !isInputSurf && SwFilterPipeType1ToN == pipeType)
129     {
130         return true;
131     }
132     return false;
133 }
134 
CreateSwFilter()135 SwFilter* SwFilterCscHandler::CreateSwFilter()
136 {
137     VP_FUNC_CALL();
138 
139     SwFilterCsc* swFilter = nullptr;
140     swFilter = dynamic_cast<SwFilterCsc*>(m_swFilterFactory.Create());
141     if (swFilter)
142     {
143         MOS_STATUS status = swFilter->SetFeatureType(FeatureTypeCsc);
144         if (MOS_FAILED(status))
145         {
146             m_swFilterFactory.Destory(swFilter);
147             return nullptr;
148         }
149         return swFilter;
150     }
151     return nullptr;
152 }
153 
IsFeatureEnabled(VEBOX_SFC_PARAMS & params)154 bool SwFilterCscHandler::IsFeatureEnabled(VEBOX_SFC_PARAMS& params)
155 {
156     VP_FUNC_CALL();
157 
158     return true;
159 }
160 
Destory(SwFilter * & swFilter)161 void SwFilterCscHandler::Destory(SwFilter*& swFilter)
162 {
163     VP_FUNC_CALL();
164 
165     SwFilterCsc* filter = nullptr;
166     filter = dynamic_cast<SwFilterCsc*>(swFilter);
167     m_swFilterFactory.Destory(filter);
168     return;
169 }
170 
171 /****************************************************************************************************/
172 /*                                      SwFilterRotMirHandler                                       */
173 /****************************************************************************************************/
174 
SwFilterRotMirHandler(VpInterface & vpInterface)175 SwFilterRotMirHandler::SwFilterRotMirHandler(VpInterface& vpInterface) :
176     SwFilterFeatureHandler(vpInterface, FeatureTypeRotMir),
177     m_swFilterFactory(vpInterface)
178 {}
~SwFilterRotMirHandler()179 SwFilterRotMirHandler::~SwFilterRotMirHandler()
180 {}
181 
IsFeatureEnabled(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex,SwFilterPipeType pipeType)182 bool SwFilterRotMirHandler::IsFeatureEnabled(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex, SwFilterPipeType pipeType)
183 {
184     VP_FUNC_CALL();
185 
186     if (!SwFilterFeatureHandler::IsFeatureEnabled(params, isInputSurf, surfIndex, pipeType))
187     {
188         return false;
189     }
190 
191     if (isInputSurf && (SwFilterPipeType1To1 == pipeType || SwFilterPipeTypeNTo1 == pipeType) ||
192         !isInputSurf && SwFilterPipeType1ToN == pipeType)
193     {
194         return true;
195     }
196     return false;
197 }
198 
CreateSwFilter()199 SwFilter* SwFilterRotMirHandler::CreateSwFilter()
200 {
201     VP_FUNC_CALL();
202 
203     SwFilter* swFilter = nullptr;
204     swFilter = m_swFilterFactory.Create();
205 
206     if (swFilter)
207     {
208         swFilter->SetFeatureType(FeatureTypeRotMir);
209     }
210 
211     return swFilter;
212 }
213 
IsFeatureEnabled(VEBOX_SFC_PARAMS & params)214 bool SwFilterRotMirHandler::IsFeatureEnabled(VEBOX_SFC_PARAMS& params)
215 {
216     VP_FUNC_CALL();
217 
218     return true;
219 }
220 
Destory(SwFilter * & swFilter)221 void SwFilterRotMirHandler::Destory(SwFilter*& swFilter)
222 {
223     VP_FUNC_CALL();
224 
225     SwFilterRotMir* filter = nullptr;
226     filter = dynamic_cast<SwFilterRotMir*>(swFilter);
227     m_swFilterFactory.Destory(filter);
228     return;
229 }
230 
231 /****************************************************************************************************/
232 /*                                      SwFilterScalingHandler                                      */
233 /****************************************************************************************************/
234 
SwFilterScalingHandler(VpInterface & vpInterface)235 SwFilterScalingHandler::SwFilterScalingHandler(VpInterface& vpInterface) :
236     SwFilterFeatureHandler(vpInterface, FeatureTypeScaling),
237     m_swFilterFactory(vpInterface)
238 {}
~SwFilterScalingHandler()239 SwFilterScalingHandler::~SwFilterScalingHandler()
240 {}
241 
IsFeatureEnabled(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex,SwFilterPipeType pipeType)242 bool SwFilterScalingHandler::IsFeatureEnabled(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex, SwFilterPipeType pipeType)
243 {
244     VP_FUNC_CALL();
245 
246     if (!SwFilterFeatureHandler::IsFeatureEnabled(params, isInputSurf, surfIndex, pipeType))
247     {
248         return false;
249     }
250 
251     if (isInputSurf && (SwFilterPipeType1To1 == pipeType || SwFilterPipeTypeNTo1 == pipeType) ||
252         !isInputSurf && SwFilterPipeType1ToN == pipeType)
253     {
254         return true;
255     }
256     return false;
257 }
258 
CreateSwFilter()259 SwFilter* SwFilterScalingHandler::CreateSwFilter()
260 {
261     VP_FUNC_CALL();
262 
263     SwFilter* swFilter = nullptr;
264     swFilter = m_swFilterFactory.Create();
265 
266     if (swFilter)
267     {
268         swFilter->SetFeatureType(FeatureTypeScaling);
269     }
270 
271     return swFilter;
272 }
273 
IsFeatureEnabled(VEBOX_SFC_PARAMS & params)274 bool SwFilterScalingHandler::IsFeatureEnabled(VEBOX_SFC_PARAMS& params)
275 {
276     VP_FUNC_CALL();
277 
278     return true;
279 }
280 
GetPipeCountForProcessing(VP_PIPELINE_PARAMS & params)281 int SwFilterScalingHandler::GetPipeCountForProcessing(VP_PIPELINE_PARAMS& params)
282 {
283     VP_FUNC_CALL();
284 
285     // For interlaced scaling field-to-interleave mode, need two submission for top field and bottom field,
286     // thus we need 2 pipe to handle it.
287     if (params.pSrc[0] && params.pSrc[0]->InterlacedScalingType == ISCALING_FIELD_TO_INTERLEAVED &&
288         params.pSrc[0]->pBwdRef != nullptr)
289     {
290         return 2;
291     }
292     return 1;
293 }
294 
UpdateParamsForProcessing(VP_PIPELINE_PARAMS & params,int index)295 MOS_STATUS SwFilterScalingHandler::UpdateParamsForProcessing(VP_PIPELINE_PARAMS& params, int index)
296 {
297     VP_FUNC_CALL();
298 
299     // For second submission of field-to-interleaved mode, we will take second field as input surface,
300     // second field is stored in pBwdRef.
301     if (params.pSrc[0] && params.pSrc[0]->InterlacedScalingType == ISCALING_FIELD_TO_INTERLEAVED && index == 1)
302     {
303         if (index >= GetPipeCountForProcessing(params))
304         {
305             VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
306         }
307 
308         if (params.pSrc[0] && params.pSrc[0]->pBwdRef)
309         {
310             params.pSrc[0]->pBwdRef->ScalingMode = params.pSrc[0]->ScalingMode;
311             params.pSrc[0]->pBwdRef->SurfType    = params.pSrc[0]->SurfType;
312             params.pSrc[0]->pBwdRef->InterlacedScalingType = params.pSrc[0]->InterlacedScalingType;
313             if (params.pSrc[0]->SampleType == SAMPLE_SINGLE_TOP_FIELD)
314             {
315                 params.pSrc[0]->pBwdRef->SampleType = SAMPLE_SINGLE_BOTTOM_FIELD;
316                 params.pTarget[0]->SampleType       = SAMPLE_INTERLEAVED_EVEN_FIRST_TOP_FIELD;
317             }
318             else
319             {
320                 params.pSrc[0]->pBwdRef->SampleType = SAMPLE_SINGLE_TOP_FIELD;
321                 params.pTarget[0]->SampleType       = SAMPLE_INTERLEAVED_ODD_FIRST_BOTTOM_FIELD;
322             }
323             if (params.pSrc[0]->pBwdRef->pDeinterlaceParams)
324             {
325                 MOS_FreeMemAndSetNull(params.pSrc[0]->pBwdRef->pDeinterlaceParams);
326             }
327             params.pSrc[0] = params.pSrc[0]->pBwdRef;
328         }
329     }
330 
331     return MOS_STATUS_SUCCESS;
332 }
333 
Destory(SwFilter * & swFilter)334 void SwFilterScalingHandler::Destory(SwFilter*& swFilter)
335 {
336     VP_FUNC_CALL();
337 
338     SwFilterScaling* filter = nullptr;
339     filter = dynamic_cast<SwFilterScaling*>(swFilter);
340     m_swFilterFactory.Destory(filter);
341     return;
342 }
343 
344 /****************************************************************************************************/
345 /*                                      SwFilterDnHandler                                      */
346 /****************************************************************************************************/
347 
SwFilterDnHandler(VpInterface & vpInterface)348 SwFilterDnHandler::SwFilterDnHandler(VpInterface& vpInterface) :
349     SwFilterFeatureHandler(vpInterface, FeatureTypeDn),
350     m_swFilterFactory(vpInterface)
351 {}
~SwFilterDnHandler()352 SwFilterDnHandler::~SwFilterDnHandler()
353 {}
354 
IsFeatureEnabled(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex,SwFilterPipeType pipeType)355 bool SwFilterDnHandler::IsFeatureEnabled(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex, SwFilterPipeType pipeType)
356 {
357     VP_FUNC_CALL();
358 
359     PVP_MHWINTERFACE hwInterface = m_vpInterface.GetHwInterface();
360     // secure mode
361     if (hwInterface->m_osInterface->osCpInterface &&
362         (hwInterface->m_osInterface->osCpInterface->IsHMEnabled()
363             || hwInterface->m_osInterface->osCpInterface->IsIDMEnabled()))
364     {
365         VP_PUBLIC_NORMALMESSAGE("Dn is disabled in secure mode.");
366         return false;
367     }
368     // clear mode
369     else
370     {
371         auto userFeatureControl = hwInterface->m_userFeatureControl;
372         if (userFeatureControl != nullptr)
373         {
374             bool disableDn = userFeatureControl->IsDisableDn();
375             if (disableDn)
376             {
377                 VP_PUBLIC_NORMALMESSAGE("Dn is disabled in clear mode.");
378                 return false;
379             }
380         }
381 
382     }
383 
384     if (!SwFilterFeatureHandler::IsFeatureEnabled(params, isInputSurf, surfIndex, pipeType))
385     {
386         return false;
387     }
388 
389     PVPHAL_SURFACE inputSurface = params.pSrc[surfIndex];
390 
391     if (inputSurface                               &&
392         (inputSurface->Format == Format_A8R8G8B8   ||
393         inputSurface->Format == Format_A16R16G16B16))
394     {
395         VP_PUBLIC_NORMALMESSAGE("Unsupported Format '0x%08x' which DN will not supported", inputSurface->Format);
396         return false;
397     }
398 
399     // Disable VP features DN for resolution > 4K
400     if (inputSurface &&
401         (inputSurface->rcSrc.bottom > inputSurface->rcSrc.top + VPHAL_RNDR_4K_MAX_HEIGHT ||
402          inputSurface->rcSrc.right > inputSurface->rcSrc.left + VPHAL_RNDR_4K_MAX_WIDTH))
403     {
404         VP_PUBLIC_NORMALMESSAGE("DN is disabled for 4K+ res");
405         return false;
406     }
407 
408     PVPHAL_SURFACE vphalSurf = isInputSurf ? params.pSrc[surfIndex] : params.pTarget[surfIndex];
409     if (vphalSurf && vphalSurf->pDenoiseParams &&
410         (vphalSurf->pDenoiseParams->bEnableLuma || vphalSurf->pDenoiseParams->bEnableHVSDenoise))
411     {
412         return true;
413     }
414 
415     return false;
416 }
417 
CreateSwFilter()418 SwFilter* SwFilterDnHandler::CreateSwFilter()
419 {
420     VP_FUNC_CALL();
421 
422     SwFilter* swFilter = nullptr;
423     swFilter = m_swFilterFactory.Create();
424 
425     if (swFilter)
426     {
427         swFilter->SetFeatureType(FeatureTypeDn);
428     }
429 
430     return swFilter;
431 }
432 
Destory(SwFilter * & swFilter)433 void SwFilterDnHandler::Destory(SwFilter*& swFilter)
434 {
435     VP_FUNC_CALL();
436 
437     SwFilterDenoise* filter = nullptr;
438     filter = dynamic_cast<SwFilterDenoise*>(swFilter);
439     m_swFilterFactory.Destory(filter);
440     return;
441 }
442 
443 /****************************************************************************************************/
444 /*                                      SwFilterDiHandler                                           */
445 /****************************************************************************************************/
446 
SwFilterDiHandler(VpInterface & vpInterface)447 SwFilterDiHandler::SwFilterDiHandler(VpInterface& vpInterface) :
448     SwFilterFeatureHandler(vpInterface, FeatureTypeDi),
449     m_swFilterFactory(vpInterface)
450 {}
~SwFilterDiHandler()451 SwFilterDiHandler::~SwFilterDiHandler()
452 {}
453 
IsFeatureEnabled(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex,SwFilterPipeType pipeType)454 bool SwFilterDiHandler::IsFeatureEnabled(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex, SwFilterPipeType pipeType)
455 {
456     VP_FUNC_CALL();
457 
458     if (!SwFilterFeatureHandler::IsFeatureEnabled(params, isInputSurf, surfIndex, pipeType))
459     {
460         return false;
461     }
462 
463     PVPHAL_SURFACE vphalSurf = isInputSurf ? params.pSrc[surfIndex] : params.pTarget[surfIndex];
464     if (vphalSurf && vphalSurf->pDeinterlaceParams && vphalSurf->SampleType != SAMPLE_PROGRESSIVE)
465     {
466         return true;
467     }
468 
469     if (vphalSurf && vphalSurf->bQueryVariance &&
470         vphalSurf->Format != Format_P010 &&
471         vphalSurf->Format != Format_P016)
472     {
473         VP_PUBLIC_NORMALMESSAGE("Query Variance is enabled, but APG didn't support this feature yet");
474     }
475 
476     return false;
477 }
478 
CreateSwFilter()479 SwFilter* SwFilterDiHandler::CreateSwFilter()
480 {
481     VP_FUNC_CALL();
482 
483     SwFilter* swFilter = nullptr;
484     swFilter = m_swFilterFactory.Create();
485 
486     if (swFilter)
487     {
488         swFilter->SetFeatureType(FeatureTypeDi);
489     }
490 
491     return swFilter;
492 }
493 
Destory(SwFilter * & swFilter)494 void SwFilterDiHandler::Destory(SwFilter*& swFilter)
495 {
496     VP_FUNC_CALL();
497 
498     SwFilterDeinterlace* filter = nullptr;
499     filter = dynamic_cast<SwFilterDeinterlace*>(swFilter);
500     m_swFilterFactory.Destory(filter);
501     return;
502 }
503 
504 /****************************************************************************************************/
505 /*                                      SwFilterSteHandler                                      */
506 /****************************************************************************************************/
507 
SwFilterSteHandler(VpInterface & vpInterface)508 SwFilterSteHandler::SwFilterSteHandler(VpInterface& vpInterface) :
509     SwFilterFeatureHandler(vpInterface, FeatureTypeSte),
510     m_swFilterFactory(vpInterface)
511 {}
~SwFilterSteHandler()512 SwFilterSteHandler::~SwFilterSteHandler()
513 {}
514 
IsFeatureEnabled(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex,SwFilterPipeType pipeType)515 bool SwFilterSteHandler::IsFeatureEnabled(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex, SwFilterPipeType pipeType)
516 {
517     VP_FUNC_CALL();
518 
519     if (!SwFilterFeatureHandler::IsFeatureEnabled(params, isInputSurf, surfIndex, pipeType))
520     {
521         return false;
522     }
523 
524     PVPHAL_SURFACE vphalSurf = isInputSurf ? params.pSrc[surfIndex] : params.pTarget[surfIndex];
525     if (vphalSurf && vphalSurf->pColorPipeParams &&
526             (vphalSurf->pColorPipeParams->bEnableSTE ||
527         vphalSurf->pColorPipeParams->bEnableSTD))
528     {
529         return true;
530     }
531 
532     return false;
533 }
534 
CreateSwFilter()535 SwFilter* SwFilterSteHandler::CreateSwFilter()
536 {
537     VP_FUNC_CALL();
538 
539     SwFilter* swFilter = nullptr;
540     swFilter = m_swFilterFactory.Create();
541 
542     if (swFilter)
543     {
544         swFilter->SetFeatureType(FeatureTypeSte);
545     }
546 
547     return swFilter;
548 }
549 
Destory(SwFilter * & swFilter)550 void SwFilterSteHandler::Destory(SwFilter*& swFilter)
551 {
552     VP_FUNC_CALL();
553 
554     SwFilterSte* filter = nullptr;
555     filter = dynamic_cast<SwFilterSte*>(swFilter);
556     m_swFilterFactory.Destory(filter);
557     return;
558 }
559 
560 /****************************************************************************************************/
561 /*                                      SwFilterTccHandler                                      */
562 /****************************************************************************************************/
563 
SwFilterTccHandler(VpInterface & vpInterface)564 SwFilterTccHandler::SwFilterTccHandler(VpInterface& vpInterface) :
565     SwFilterFeatureHandler(vpInterface, FeatureTypeTcc),
566     m_swFilterFactory(vpInterface)
567 {}
~SwFilterTccHandler()568 SwFilterTccHandler::~SwFilterTccHandler()
569 {}
570 
IsFeatureEnabled(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex,SwFilterPipeType pipeType)571 bool SwFilterTccHandler::IsFeatureEnabled(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex, SwFilterPipeType pipeType)
572 {
573     VP_FUNC_CALL();
574 
575     if (!SwFilterFeatureHandler::IsFeatureEnabled(params, isInputSurf, surfIndex, pipeType))
576     {
577         return false;
578     }
579 
580     PVPHAL_SURFACE vphalSurf = isInputSurf ? params.pSrc[surfIndex] : params.pTarget[surfIndex];
581     if (vphalSurf && vphalSurf->pColorPipeParams &&
582         vphalSurf->pColorPipeParams->bEnableTCC)
583     {
584         return true;
585     }
586 
587     return false;
588 }
589 
CreateSwFilter()590 SwFilter* SwFilterTccHandler::CreateSwFilter()
591 {
592     VP_FUNC_CALL();
593 
594     SwFilter* swFilter = nullptr;
595     swFilter = m_swFilterFactory.Create();
596 
597     if (swFilter)
598     {
599         swFilter->SetFeatureType(FeatureTypeTcc);
600     }
601 
602     return swFilter;
603 }
604 
Destory(SwFilter * & swFilter)605 void SwFilterTccHandler::Destory(SwFilter*& swFilter)
606 {
607     VP_FUNC_CALL();
608 
609     SwFilterTcc* filter = nullptr;
610     filter = dynamic_cast<SwFilterTcc*>(swFilter);
611     m_swFilterFactory.Destory(filter);
612     return;
613 }
614 
615 /****************************************************************************************************/
616 /*                                      SwFilterProcampHandler                                      */
617 /****************************************************************************************************/
618 
SwFilterProcampHandler(VpInterface & vpInterface)619 SwFilterProcampHandler::SwFilterProcampHandler(VpInterface& vpInterface) :
620     SwFilterFeatureHandler(vpInterface, FeatureTypeProcamp),
621     m_swFilterFactory(vpInterface)
622 {}
~SwFilterProcampHandler()623 SwFilterProcampHandler::~SwFilterProcampHandler()
624 {}
625 
IsFeatureEnabled(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex,SwFilterPipeType pipeType)626 bool SwFilterProcampHandler::IsFeatureEnabled(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex, SwFilterPipeType pipeType)
627 {
628     VP_FUNC_CALL();
629 
630     if (!SwFilterFeatureHandler::IsFeatureEnabled(params, isInputSurf, surfIndex, pipeType))
631     {
632         return false;
633     }
634 
635     PVPHAL_SURFACE vphalSurf = isInputSurf ? params.pSrc[surfIndex] : params.pTarget[surfIndex];
636     if (vphalSurf && vphalSurf->pProcampParams &&
637         !IS_RGB_FORMAT(vphalSurf->Format)      &&
638         vphalSurf->pProcampParams->bEnabled)
639     {
640         return true;
641     }
642 
643     return false;
644 }
645 
CreateSwFilter()646 SwFilter* SwFilterProcampHandler::CreateSwFilter()
647 {
648     VP_FUNC_CALL();
649 
650     SwFilter* swFilter = nullptr;
651     swFilter = m_swFilterFactory.Create();
652 
653     if (swFilter)
654     {
655         swFilter->SetFeatureType(FeatureTypeProcamp);
656     }
657 
658     return swFilter;
659 }
660 
Destory(SwFilter * & swFilter)661 void SwFilterProcampHandler::Destory(SwFilter*& swFilter)
662 {
663     VP_FUNC_CALL();
664 
665     SwFilterProcamp* filter = nullptr;
666     filter = dynamic_cast<SwFilterProcamp*>(swFilter);
667     m_swFilterFactory.Destory(filter);
668     return;
669 }
670 
671 /****************************************************************************************************/
672 /*                                      SwFilterHdrHandler                                          */
673 /****************************************************************************************************/
674 
SwFilterHdrHandler(VpInterface & vpInterface)675 SwFilterHdrHandler::SwFilterHdrHandler(VpInterface &vpInterface) :
676     SwFilterFeatureHandler(vpInterface, FeatureTypeHdr),
677     m_swFilterFactory(vpInterface)
678 {}
~SwFilterHdrHandler()679 SwFilterHdrHandler::~SwFilterHdrHandler()
680 {}
681 
IsFeatureEnabled(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex,SwFilterPipeType pipeType)682 bool SwFilterHdrHandler::IsFeatureEnabled(VP_PIPELINE_PARAMS &params, bool isInputSurf, int surfIndex, SwFilterPipeType pipeType)
683 {
684     VP_FUNC_CALL();
685 
686     // Avoid recheck when it is output or surfIndex > 0
687     if (!isInputSurf)
688     {
689         return false;
690     }
691     // if  target surf is invalid, return false;
692     PVPHAL_SURFACE pSrc            = params.pSrc[0];
693     PVPHAL_SURFACE pRenderTarget   = params.pTarget[0];
694     auto           userFeatureControl = m_vpInterface.GetHwInterface()->m_userFeatureControl;
695     if (!pSrc || !pRenderTarget)
696     {
697         return false;
698     }
699 
700     bool bBt2020Output       = false;
701     bool bToneMapping        = false;
702     bool bMultiLayerBt2020   = false;
703     bool bFP16Format         = false;
704     // Not all FP16 input / output need HDR processing, e.g, FP16 by pass, FP16 csc etc.
705     bool bFP16HdrProcessing  = false;
706     bool isExternal3DLutEnabled     = false;
707     if (pSrc->p3DLutParams && userFeatureControl->IsExternal3DLutSupport())
708     {
709         isExternal3DLutEnabled = true;
710     }
711     // Need to use HDR to process BT601/BT709->BT2020
712     if (IS_COLOR_SPACE_BT2020(pRenderTarget->ColorSpace) &&
713         !IS_COLOR_SPACE_BT2020(pSrc->ColorSpace))
714     {
715         bBt2020Output = true;
716     }
717 
718     if ((pSrc->pHDRParams && (pSrc->pHDRParams->EOTF != VPHAL_HDR_EOTF_TRADITIONAL_GAMMA_SDR)) ||
719         (pRenderTarget->pHDRParams && (pRenderTarget->pHDRParams->EOTF != VPHAL_HDR_EOTF_TRADITIONAL_GAMMA_SDR)))
720     {
721         bToneMapping = true;
722     }
723 
724     if ((pSrc->Format == Format_A16B16G16R16F) || (pSrc->Format == Format_A16R16G16B16F))
725     {
726         bFP16Format = true;
727     }
728 
729     bFP16Format = bFP16Format || (pRenderTarget->Format == Format_A16B16G16R16F) || (pRenderTarget->Format == Format_A16R16G16B16F);
730 
731     if (bFP16Format && !pSrc->p3DLutParams)
732     {
733         // Check if input/output gamma is same(TBD)
734         // Check if input/output color space is same
735         bool bColorSpaceConversion = true;
736         if (IS_COLOR_SPACE_BT2020(pRenderTarget->ColorSpace) &&
737             IS_COLOR_SPACE_BT2020(pSrc->ColorSpace))
738         {
739             bColorSpaceConversion = false;
740         }
741         if ((pRenderTarget->ColorSpace == CSpace_sRGB || pRenderTarget->ColorSpace == CSpace_stRGB) &&
742             (pSrc->ColorSpace == CSpace_BT709 || pSrc->ColorSpace == CSpace_BT709_FullRange))
743         {
744             bColorSpaceConversion = false;
745         }
746         if ((pRenderTarget->ColorSpace == CSpace_sRGB || pRenderTarget->ColorSpace == CSpace_stRGB) &&
747             (pSrc->ColorSpace == CSpace_BT601 || pSrc->ColorSpace == CSpace_BT601_FullRange))
748         {
749             bColorSpaceConversion = false;
750         }
751         bFP16HdrProcessing = bColorSpaceConversion;
752     }
753 
754     // Temorary solution for menu/FBI not show up : route all S2S uage to HDR kernel path, need to consider RenderBlockedFromCp
755 
756     return (bBt2020Output || bToneMapping || bMultiLayerBt2020 || bFP16HdrProcessing || isExternal3DLutEnabled);
757 }
758 
CreateSwFilter()759 SwFilter *SwFilterHdrHandler::CreateSwFilter()
760 {
761     VP_FUNC_CALL();
762 
763     SwFilter *swFilter = nullptr;
764     swFilter           = m_swFilterFactory.Create();
765 
766     if (swFilter)
767     {
768         swFilter->SetFeatureType(FeatureTypeHdr);
769     }
770 
771     return swFilter;
772 }
773 
Destory(SwFilter * & swFilter)774 void SwFilterHdrHandler::Destory(SwFilter *&swFilter)
775 {
776     VP_FUNC_CALL();
777 
778     SwFilterHdr *filter = nullptr;
779     filter              = dynamic_cast<SwFilterHdr *>(swFilter);
780     m_swFilterFactory.Destory(filter);
781     return;
782 }
783 
784 /****************************************************************************************************/
785 /*                                      SwFilterLumakeyHandler                                      */
786 /****************************************************************************************************/
787 
SwFilterLumakeyHandler(VpInterface & vpInterface,FeatureType featureType)788 SwFilterLumakeyHandler::SwFilterLumakeyHandler(VpInterface &vpInterface, FeatureType featureType) :
789     SwFilterFeatureHandler(vpInterface, FeatureTypeLumakey),
790     m_swFilterFactory(vpInterface)
791 {}
~SwFilterLumakeyHandler()792 SwFilterLumakeyHandler::~SwFilterLumakeyHandler()
793 {}
794 
IsFeatureEnabled(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex,SwFilterPipeType pipeType)795 bool SwFilterLumakeyHandler::IsFeatureEnabled(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex, SwFilterPipeType pipeType)
796 {
797     VP_FUNC_CALL();
798 
799     if (!SwFilterFeatureHandler::IsFeatureEnabled(params, isInputSurf, surfIndex, pipeType))
800     {
801         return false;
802     }
803 
804     PVPHAL_SURFACE surf = isInputSurf ? params.pSrc[surfIndex] : params.pTarget[surfIndex];
805     if (surf && surf->pLumaKeyParams)
806     {
807         return true;
808     }
809 
810     return false;
811 }
812 
CreateSwFilter()813 SwFilter* SwFilterLumakeyHandler::CreateSwFilter()
814 {
815     VP_FUNC_CALL();
816 
817     SwFilter* swFilter = nullptr;
818     swFilter = m_swFilterFactory.Create();
819 
820     if (swFilter)
821     {
822         swFilter->SetFeatureType(m_type);
823     }
824 
825     return swFilter;
826 }
827 
Destory(SwFilter * & swFilter)828 void SwFilterLumakeyHandler::Destory(SwFilter*& swFilter)
829 {
830     VP_FUNC_CALL();
831 
832     SwFilterLumakey* filter = nullptr;
833     filter = dynamic_cast<SwFilterLumakey*>(swFilter);
834     m_swFilterFactory.Destory(filter);
835     return;
836 }
837 
838 /****************************************************************************************************/
839 /*                                      SwFilterBlendingHandler                                     */
840 /****************************************************************************************************/
841 
SwFilterBlendingHandler(VpInterface & vpInterface,FeatureType featureType)842 SwFilterBlendingHandler::SwFilterBlendingHandler(VpInterface &vpInterface, FeatureType featureType) :
843     SwFilterFeatureHandler(vpInterface, FeatureTypeBlending),
844     m_swFilterFactory(vpInterface)
845 {}
~SwFilterBlendingHandler()846 SwFilterBlendingHandler::~SwFilterBlendingHandler()
847 {}
848 
IsFeatureEnabled(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex,SwFilterPipeType pipeType)849 bool SwFilterBlendingHandler::IsFeatureEnabled(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex, SwFilterPipeType pipeType)
850 {
851     VP_FUNC_CALL();
852 
853     if (!SwFilterFeatureHandler::IsFeatureEnabled(params, isInputSurf, surfIndex, pipeType))
854     {
855         return false;
856     }
857 
858     PVPHAL_SURFACE surf = isInputSurf ? params.pSrc[surfIndex] : params.pTarget[surfIndex];
859     if (surf && surf->pBlendingParams)
860     {
861         if (!isInputSurf)
862         {
863             VP_PUBLIC_NORMALMESSAGE("Skip blending parameters on target.");
864             return false;
865         }
866         return true;
867     }
868 
869     return false;
870 }
871 
CreateSwFilter()872 SwFilter* SwFilterBlendingHandler::CreateSwFilter()
873 {
874     VP_FUNC_CALL();
875 
876     SwFilter* swFilter = nullptr;
877     swFilter = m_swFilterFactory.Create();
878 
879     if (swFilter)
880     {
881         swFilter->SetFeatureType(m_type);
882     }
883 
884     return swFilter;
885 }
886 
Destory(SwFilter * & swFilter)887 void SwFilterBlendingHandler::Destory(SwFilter*& swFilter)
888 {
889     VP_FUNC_CALL();
890 
891     SwFilterBlending* filter = nullptr;
892     filter = dynamic_cast<SwFilterBlending*>(swFilter);
893     m_swFilterFactory.Destory(filter);
894     return;
895 }
896 
897 
898 /****************************************************************************************************/
899 /*                                      SwFilterColorFillHandler                                    */
900 /****************************************************************************************************/
901 
SwFilterColorFillHandler(VpInterface & vpInterface,FeatureType featureType)902 SwFilterColorFillHandler::SwFilterColorFillHandler(VpInterface &vpInterface, FeatureType featureType) :
903     SwFilterFeatureHandler(vpInterface, FeatureTypeColorFill),
904     m_swFilterFactory(vpInterface)
905 {}
~SwFilterColorFillHandler()906 SwFilterColorFillHandler::~SwFilterColorFillHandler()
907 {}
908 
IsFeatureEnabled(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex,SwFilterPipeType pipeType)909 bool SwFilterColorFillHandler::IsFeatureEnabled(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex, SwFilterPipeType pipeType)
910 {
911     VP_FUNC_CALL();
912 
913     if (!SwFilterFeatureHandler::IsFeatureEnabled(params, isInputSurf, surfIndex, pipeType))
914     {
915         return false;
916     }
917 
918     if (!isInputSurf && params.pColorFillParams)
919     {
920         return true;
921     }
922 
923     return false;
924 }
925 
CreateSwFilter()926 SwFilter* SwFilterColorFillHandler::CreateSwFilter()
927 {
928     VP_FUNC_CALL();
929 
930     SwFilter* swFilter = nullptr;
931     swFilter = m_swFilterFactory.Create();
932 
933     if (swFilter)
934     {
935         swFilter->SetFeatureType(m_type);
936     }
937 
938     return swFilter;
939 }
940 
Destory(SwFilter * & swFilter)941 void SwFilterColorFillHandler::Destory(SwFilter*& swFilter)
942 {
943     VP_FUNC_CALL();
944 
945     SwFilterColorFill* filter = nullptr;
946     filter = dynamic_cast<SwFilterColorFill*>(swFilter);
947     m_swFilterFactory.Destory(filter);
948     return;
949 }
950 
951 /****************************************************************************************************/
952 /*                                      SwFilterAlphaHandler                                        */
953 /****************************************************************************************************/
954 
SwFilterAlphaHandler(VpInterface & vpInterface,FeatureType featureType)955 SwFilterAlphaHandler::SwFilterAlphaHandler(VpInterface &vpInterface, FeatureType featureType) :
956     SwFilterFeatureHandler(vpInterface, FeatureTypeAlpha),
957     m_swFilterFactory(vpInterface)
958 {}
~SwFilterAlphaHandler()959 SwFilterAlphaHandler::~SwFilterAlphaHandler()
960 {}
961 
IsFeatureEnabled(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex,SwFilterPipeType pipeType)962 bool SwFilterAlphaHandler::IsFeatureEnabled(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex, SwFilterPipeType pipeType)
963 {
964     VP_FUNC_CALL();
965 
966     if (!SwFilterFeatureHandler::IsFeatureEnabled(params, isInputSurf, surfIndex, pipeType))
967     {
968         return false;
969     }
970 
971     if (!isInputSurf && params.pCompAlpha)
972     {
973         return true;
974     }
975 
976     return false;
977 }
978 
CreateSwFilter()979 SwFilter* SwFilterAlphaHandler::CreateSwFilter()
980 {
981     VP_FUNC_CALL();
982 
983     SwFilter* swFilter = nullptr;
984     swFilter = m_swFilterFactory.Create();
985 
986     if (swFilter)
987     {
988         swFilter->SetFeatureType(m_type);
989     }
990 
991     return swFilter;
992 }
993 
Destory(SwFilter * & swFilter)994 void SwFilterAlphaHandler::Destory(SwFilter*& swFilter)
995 {
996     VP_FUNC_CALL();
997 
998     SwFilterAlpha* filter = nullptr;
999     filter = dynamic_cast<SwFilterAlpha*>(swFilter);
1000     m_swFilterFactory.Destory(filter);
1001     return;
1002 }
1003 
1004 /****************************************************************************************************/
1005 /*                                      SwFilterCgcHandler                                          */
1006 /****************************************************************************************************/
1007 
SwFilterCgcHandler(VpInterface & vpInterface)1008 SwFilterCgcHandler::SwFilterCgcHandler(VpInterface& vpInterface) :
1009     SwFilterFeatureHandler(vpInterface, FeatureTypeCgc),
1010     m_swFilterFactory(vpInterface)
1011 {}
~SwFilterCgcHandler()1012 SwFilterCgcHandler::~SwFilterCgcHandler()
1013 {}
1014 
IsFeatureEnabled(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex,SwFilterPipeType pipeType)1015 bool SwFilterCgcHandler::IsFeatureEnabled(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex, SwFilterPipeType pipeType)
1016 {
1017     VP_FUNC_CALL();
1018 
1019     if (!SwFilterFeatureHandler::IsFeatureEnabled(params, isInputSurf, surfIndex, pipeType))
1020     {
1021         return false;
1022     }
1023 
1024     // BT2020YUV->BT601/709YUV enable GC in Vebox for BT2020 to RGB process
1025     // SFC for other format conversion. For such case, add Cgc only to input
1026     // pipe for 1 to 1 or N to 1 case.
1027     if (isInputSurf && (SwFilterPipeType1ToN == pipeType) ||
1028         !isInputSurf && (SwFilterPipeType1To1 == pipeType || SwFilterPipeTypeNTo1 == pipeType))
1029     {
1030         return false;
1031     }
1032 
1033     PVPHAL_SURFACE inputSurf  = static_cast<PVPHAL_SURFACE>(isInputSurf ? params.pSrc[surfIndex] : params.pSrc[0]);
1034     PVPHAL_SURFACE outputSurf = static_cast<PVPHAL_SURFACE>(isInputSurf ? params.pTarget[0] : params.pTarget[surfIndex]);
1035 
1036     if (inputSurf && outputSurf &&
1037         IS_COLOR_SPACE_BT2020_YUV(inputSurf->ColorSpace) &&
1038       (!(inputSurf->pHDRParams &&
1039         (inputSurf->pHDRParams->EOTF != VPHAL_HDR_EOTF_TRADITIONAL_GAMMA_SDR) &&
1040        !(outputSurf->pHDRParams &&
1041         (outputSurf->pHDRParams->EOTF != VPHAL_HDR_EOTF_TRADITIONAL_GAMMA_SDR))))) // When HDR Enabled, GC should always be turn off, not to create the sw filter
1042     {
1043         if ((outputSurf->ColorSpace == CSpace_BT601) ||
1044             (outputSurf->ColorSpace == CSpace_BT709) ||
1045             (outputSurf->ColorSpace == CSpace_BT601_FullRange) ||
1046             (outputSurf->ColorSpace == CSpace_BT709_FullRange) ||
1047             (outputSurf->ColorSpace == CSpace_stRGB) ||
1048             (outputSurf->ColorSpace == CSpace_sRGB))
1049         {
1050             return true;
1051         }
1052     }
1053 
1054     return false;
1055 }
1056 
CreateSwFilter()1057 SwFilter* SwFilterCgcHandler::CreateSwFilter()
1058 {
1059     VP_FUNC_CALL();
1060 
1061     SwFilter* swFilter = nullptr;
1062     swFilter = m_swFilterFactory.Create();
1063 
1064     if (swFilter)
1065     {
1066         swFilter->SetFeatureType(FeatureTypeCgc);
1067     }
1068 
1069     return swFilter;
1070 }
1071 
Destory(SwFilter * & swFilter)1072 void SwFilterCgcHandler::Destory(SwFilter*& swFilter)
1073 {
1074     VP_FUNC_CALL();
1075 
1076     SwFilterCgc* filter = nullptr;
1077     filter = dynamic_cast<SwFilterCgc*>(swFilter);
1078     m_swFilterFactory.Destory(filter);
1079     return;
1080 }
1081