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 #ifndef __VP_RENDER_VEBOX_HDR_3DLUT_H__
23 #define __VP_RENDER_VEBOX_HDR_3DLUT_H__
24 
25 //!
26 //! \brief Kernel Name for HDR 3DLut kernel
27 //!
28 #define VP_HDR_KERNEL_NAME_L0 "hdr_3dlut_l0"
29 #define VP_HDR_KERNEL_NAME    "hdr_3dlut"
30 
31 #include "vp_render_cmd_packet.h"
32 namespace vp
33 {
34 // Defined in "VEBOX HDR 3DLut Kernel"
35 struct VEBOX_HDR_3DLUT_CM_STATIC_DATA
36 {
37 
38     //0 - GRF R1.0
39     union
40     {
41         struct
42         {
43             uint32_t hdr3DLutSurface;  // HDR 3D Lut Surface
44         };
45         uint32_t Value;
46     } DW00;
47 
48     //1 - GRF R1.1
49     union
50     {
51         struct
52         {
53             uint32_t hdrCoefSurface;  // HDR Coef Surface
54         };
55         uint32_t Value;
56     } DW01;
57 
58     //2 - GRF R1.2
59     union
60     {
61         struct
62         {
63             uint16_t hdr3DLutSurfaceWidth   : 16;
64             uint16_t hdr3DLutSurfaceHeight  : 16;
65         };
66         uint32_t Value;
67     } DW03;
68 };
69 C_ASSERT(SIZE32(VEBOX_HDR_3DLUT_CM_STATIC_DATA) == 3);
70 
71 struct VEBOX_HDR_3DLUT_STATIC_DATA
72 {
73     union
74     {
75         struct
76         {
77             uint32_t hdr3DLutPrivateBaseUp;  // Offset
78         };
79 
80         uint32_t Value;
81     } DW00;
82     union
83     {
84         struct
85         {
86             uint32_t hdr3DLutPrivateBaseDown;  // Offset
87         };
88 
89         uint32_t Value;
90     } DW01;
91     union
92     {
93         struct
94         {
95             uint32_t hdr3DLutSurface;  // HDR 3D Lut Surface
96         };
97         uint32_t Value;
98     } DW02;
99     union
100     {
101         struct
102         {
103             uint32_t hdr3DLutSurfaceOffset;  // HDR 3D Lut Surface Offset
104         };
105         uint32_t Value;
106     } DW03;
107 
108     union
109     {
110         struct
111         {
112             uint32_t hdrCoefSurface;  // HDR Coef Surface
113         };
114         uint32_t Value;
115     } DW04;
116     union
117     {
118         struct
119         {
120             uint32_t hdrCoefSurfaceOffset;  // HDR Coef Surface Offset
121         };
122         uint32_t Value;
123     } DW05;
124     union
125     {
126         struct
127         {
128             uint16_t hdr3DLutSurfaceWidth : 16;
129             uint16_t hdr3DLutSurfaceHeight : 16;
130         };
131         uint32_t Value;
132     } DW06;
133 
134 };
135 C_ASSERT(SIZE32(VEBOX_HDR_3DLUT_STATIC_DATA) == 7);
136 
137 //!
138 //! \brief    Tone Mapping Source Type, Please don't change the Enmu Value.
139 //! \details  These Enmu Values are passed to media kernel for further processing.
140 //!
141 typedef enum _TONE_MAPPING_SOURCE_TYPE
142 {
143     TONE_MAPPING_SOURCE_NONE            = 0,
144     TONE_MAPPING_SOURCE_RGB             = 1,
145     TONE_MAPPING_SOURCE_PSEUDO_Y_BT2020 = 2,
146     TONE_MAPPING_SOURCE_FULL_Y_BT2020   = 3,
147     TONE_MAPPING_SOURCE_FULL_Y_BT709    = 4,
148     TONE_MAPPING_SOURCE_PSEUDO_Y_BT709  = 5
149 } TONE_MAPPING_SOURCE_TYPE;
150 
151 //!
152 //! \brief    Tone Mapping Mode.
153 //! \details  These Enmu Values are passed to media kernel for further processing.
154 //!
155 typedef enum _TONE_MAPPING_MODE
156 {
157     TONE_MAPPING_MODE_H2H = 0,
158     TONE_MAPPING_MODE_H2S = 1
159 } TONE_MAPPING_MODE;
160 
161 //!
162 //! \brief    OETF Type.
163 //! \details  These Enmu Values are passed to media kernel for further processing.
164 //!
165 typedef enum _OETF_CURVE_TYPE
166 {
167     OETF_CURVE_SDR_709  = 0,
168     OETF_CURVE_HDR_2084 = 1,
169     OETF_SRGB           = 2
170 } OETF_CURVE_TYPE;
171 
172 // VpRenderHdr3DLutKernel::InitCoefSurface need be updated if value of VP_CCM_MATRIX_SIZE
173 // being modified.
174 #define VP_CCM_MATRIX_SIZE  12
175 
176 class VpRenderHdr3DLutKernel : public VpRenderKernelObj
177 {
178 public:
179     VpRenderHdr3DLutKernel(PVP_MHWINTERFACE hwInterface, PVpAllocator allocator);
180     VpRenderHdr3DLutKernel(PVP_MHWINTERFACE hwInterface, VpKernelID kernelID, uint32_t kernelIndex, std::string kernelName = "", PVpAllocator allocator = nullptr);
181     virtual ~VpRenderHdr3DLutKernel();
182 
183     virtual MOS_STATUS GetCurbeState(void *&curbe, uint32_t &curbeLength) override;
184 
FreeCurbe(void * & curbe)185     virtual MOS_STATUS FreeCurbe(void*& curbe) override
186     {
187         return MOS_STATUS_SUCCESS;
188     }
189 
GetInlineDataSize()190     virtual uint32_t   GetInlineDataSize() override
191     {
192         return 0;
193     }
194 
IsKernelCached()195     virtual bool IsKernelCached() override
196     {
197         return true;
198     }
199     virtual MOS_STATUS GetWalkerSetting(KERNEL_WALKER_PARAMS &walkerParam, KERNEL_PACKET_RENDER_DATA &renderData) override;
200     virtual MOS_STATUS InitCoefSurface(const uint32_t maxDLL, const uint32_t maxCLL, const VPHAL_HDR_MODE hdrMode);
201 
202 protected:
203     virtual MOS_STATUS SetupSurfaceState() override;
204     virtual MOS_STATUS CpPrepareResources() override;
205     virtual MOS_STATUS SetKernelConfigs(KERNEL_CONFIGS &kernelConfigs) override;
206 
207     //kernel Arguments
208     KERNEL_ARGS          m_kernelArgs  = {};
209     KERNEL_WALKER_PARAMS m_walkerParam = {};
210 
211     VEBOX_HDR_3DLUT_STATIC_DATA m_curbe = {};
212 
213     float           m_ccmMatrix[VP_CCM_MATRIX_SIZE] = {0.0};
214     uint32_t        m_maxDisplayLum         = 1000;         //!< Maximum Display Luminance
215     uint32_t        m_maxContentLevelLum    = 4000;         //!< Maximum Content Level Luminance
216     VPHAL_HDR_MODE  m_hdrMode               = VPHAL_HDR_MODE_NONE;
217     uint32_t        m_hdrLutSize            = LUT65_SEG_SIZE;
218 
219     MEDIA_CLASS_DEFINE_END(vp__VpRenderHdr3DLutKernel)
220 };
221 
222 class VpRenderHdr3DLutKernelCM : public VpRenderHdr3DLutKernel
223 {
224 public:
225     VpRenderHdr3DLutKernelCM(PVP_MHWINTERFACE hwInterface, VpKernelID kernelID, uint32_t kernelIndex, PVpAllocator allocator);
226     virtual ~VpRenderHdr3DLutKernelCM();
227 
228     virtual MOS_STATUS Init(VpRenderKernel &kernel) override;
229     virtual MOS_STATUS GetCurbeState(void *&curbe, uint32_t &curbeLength) override;
230 
FreeCurbe(void * & curbe)231     virtual MOS_STATUS FreeCurbe(void *&curbe) override
232     {
233         return MOS_STATUS_SUCCESS;
234     }
235 
GetInlineDataSize()236     virtual uint32_t GetInlineDataSize() override
237     {
238         return 0;
239     }
240 
IsKernelCached()241     virtual bool IsKernelCached() override
242     {
243         return true;
244     }
245 
246     virtual MOS_STATUS GetWalkerSetting(KERNEL_WALKER_PARAMS &walkerParam, KERNEL_PACKET_RENDER_DATA &renderData) override;
247 
248 protected:
249     virtual MOS_STATUS SetupSurfaceState() override;
250     virtual MOS_STATUS CpPrepareResources() override;
251     virtual MOS_STATUS SetWalkerSetting(KERNEL_THREAD_SPACE &threadSpace, bool bSyncFlag, bool flushL1 = false) override;
252     virtual MOS_STATUS SetKernelArgs(KERNEL_ARGS &kernelArgs, VP_PACKET_SHARED_CONTEXT *sharedContext) override;
253     virtual MOS_STATUS SetKernelConfigs(KERNEL_CONFIGS &kernelConfigs) override;
254 
255     //kernel Arguments
256     KERNEL_ARGS          m_kernelArgs  = {};
257     KERNEL_WALKER_PARAMS m_walkerParam = {};
258 
259     VEBOX_HDR_3DLUT_CM_STATIC_DATA m_curbe = {};
260 
261     float          m_ccmMatrix[VP_CCM_MATRIX_SIZE] = {0.0};
262     uint32_t       m_maxDisplayLum                 = 1000;  //!< Maximum Display Luminance
263     uint32_t       m_maxContentLevelLum            = 4000;  //!< Maximum Content Level Luminance
264     VPHAL_HDR_MODE m_hdrMode                       = VPHAL_HDR_MODE_NONE;
265 
266     MEDIA_CLASS_DEFINE_END(vp__VpRenderHdr3DLutKernelCM)
267 };
268 
269 }  // namespace vp
270 
271 #endif //__VP_RENDER_VEBOX_HDR_3DLUT_H__