1 /*
2 * Copyright (c) 2017-2020, 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     codechal_encode_csc_ds_mdf_g12.cpp
24 //! \brief    This file implements the Csc feature using MDF RT
25 //!
26 
27 
28 #include "codechal_encode_csc_ds_mdf_g12.h"
29 #include "Gen12LP_DS_Convert_genx.h"
30 
31 
SetCurbeCscforMDF(CMRT_UMD::vector<uint32_t,10> & curbeData)32 MOS_STATUS CodechalEncodeCscDsMdfG12::SetCurbeCscforMDF(CMRT_UMD::vector<uint32_t, 10> & curbeData)
33 {
34     CODECHAL_ENCODE_FUNCTION_ENTER;
35 
36     CscKernelCurbeData curbe;
37 
38     curbe.DW0_OutputBitDepthForChroma = m_curbeParams.ucEncBitDepthChroma;
39     curbe.DW0_OutputBitDepthForLuma = m_curbeParams.ucEncBitDepthLuma;
40     curbe.DW0_RoundingEnable = 1;
41 
42     curbe.DW1_PictureFormat = (uint8_t)((m_colorRawSurface == cscColorABGR) ? cscColorARGB : m_colorRawSurface); // Use cscColorARGB for ABGR CSC, just switch B and R coefficients
43     curbe.DW1_ConvertFlag = m_curbeParams.bConvertFlag;
44     curbe.DW1_DownscaleStage = (uint8_t)m_curbeParams.downscaleStage;
45     curbe.DW1_MbStatisticsDumpFlag = (m_curbeParams.downscaleStage == dsStage4x || m_curbeParams.downscaleStage == dsStage2x4x);
46     curbe.DW1_YUY2ConversionFlag = (m_colorRawSurface == cscColorYUY2) && m_cscRequireColor;
47     curbe.DW1_HevcEncHistorySum = m_curbeParams.bHevcEncHistorySum;
48     curbe.DW1_LCUSize = m_curbeParams.bUseLCU32;
49 
50     curbe.DW2_OriginalPicWidthInSamples = m_curbeParams.dwInputPictureWidth;
51     curbe.DW2_OriginalPicHeightInSamples = m_curbeParams.dwInputPictureHeight;
52 
53     // RGB->YUV CSC coefficients
54     if (m_curbeParams.inputColorSpace == ECOLORSPACE_P709)
55     {
56         curbe.DW4_CSC_Coefficient_C0 = 0xFFCD;
57         curbe.DW5_CSC_Coefficient_C3 = 0x0080;
58         curbe.DW6_CSC_Coefficient_C4 = 0x004F;
59         curbe.DW7_CSC_Coefficient_C7 = 0x0010;
60         curbe.DW8_CSC_Coefficient_C8 = 0xFFD5;
61         curbe.DW9_CSC_Coefficient_C11 = 0x0080;
62         if (cscColorARGB == m_colorRawSurface)
63         {
64             curbe.DW4_CSC_Coefficient_C1 = 0xFFFB;
65             curbe.DW5_CSC_Coefficient_C2 = 0x0038;
66             curbe.DW6_CSC_Coefficient_C5 = 0x0008;
67             curbe.DW7_CSC_Coefficient_C6 = 0x0017;
68             curbe.DW8_CSC_Coefficient_C9 = 0x0038;
69             curbe.DW9_CSC_Coefficient_C10 = 0xFFF3;
70         }
71         else // cscColorABGR == m_colorRawSurface
72         {
73             curbe.DW4_CSC_Coefficient_C1 = 0x0038;
74             curbe.DW5_CSC_Coefficient_C2 = 0xFFFB;
75             curbe.DW6_CSC_Coefficient_C5 = 0x0017;
76             curbe.DW7_CSC_Coefficient_C6 = 0x0008;
77             curbe.DW8_CSC_Coefficient_C9 = 0xFFF3;
78             curbe.DW9_CSC_Coefficient_C10 = 0x0038;
79         }
80     }
81     else if (m_curbeParams.inputColorSpace == ECOLORSPACE_P601)
82     {
83         curbe.DW4_CSC_Coefficient_C0 = 0xFFD1;
84         curbe.DW5_CSC_Coefficient_C3 = 0x0080;
85         curbe.DW6_CSC_Coefficient_C4 = 0x0041;
86         curbe.DW7_CSC_Coefficient_C7 = 0x0010;
87         curbe.DW8_CSC_Coefficient_C8 = 0xFFDB;
88         curbe.DW9_CSC_Coefficient_C11 = 0x0080;
89         if (cscColorARGB == m_colorRawSurface)
90         {
91             curbe.DW4_CSC_Coefficient_C1 = 0xFFF7;
92             curbe.DW5_CSC_Coefficient_C2 = 0x0038;
93             curbe.DW6_CSC_Coefficient_C5 = 0x000D;
94             curbe.DW7_CSC_Coefficient_C6 = 0x0021;
95             curbe.DW8_CSC_Coefficient_C9 = 0x0038;
96             curbe.DW9_CSC_Coefficient_C10 = 0xFFED;
97         }
98         else // cscColorABGR == m_colorRawSurface
99         {
100             curbe.DW4_CSC_Coefficient_C1 = 0x0038;
101             curbe.DW5_CSC_Coefficient_C2 = 0xFFF7;
102             curbe.DW6_CSC_Coefficient_C5 = 0x0021;
103             curbe.DW7_CSC_Coefficient_C6 = 0x000D;
104             curbe.DW8_CSC_Coefficient_C9 = 0xFFED;
105             curbe.DW9_CSC_Coefficient_C10 = 0x0038;
106         }
107     }
108     else
109     {
110         CODECHAL_ENCODE_ASSERTMESSAGE("Unsupported ARGB input color space = %d!", m_curbeParams.inputColorSpace);
111         return MOS_STATUS_INVALID_PARAMETER;
112     }
113 
114     curbeData[0] = curbe.DW0;
115     curbeData[1] = curbe.DW1;
116     curbeData[2] = curbe.DW2;
117     curbeData[3] = curbe.DW3_MBFlatnessThreshold;
118     curbeData[4] = curbe.DW4;
119     curbeData[5] = curbe.DW5;
120     curbeData[6] = curbe.DW6;
121     curbeData[7] = curbe.DW7;
122     curbeData[8] = curbe.DW8;
123     curbeData[9] = curbe.DW9;
124 
125     return MOS_STATUS_SUCCESS;
126 }
127 
SetupKernelArgsCSC(CmKernel * cmKrnCSCDS,SurfaceParamsCscMdf * surfaceparams)128 MOS_STATUS CodechalEncodeCscDsMdfG12::SetupKernelArgsCSC(CmKernel *cmKrnCSCDS, SurfaceParamsCscMdf* surfaceparams)
129 {
130     int idx = 0;
131     CMRT_UMD::vector<uint32_t, 10> curbeData;
132 
133     SetCurbeCscforMDF(curbeData);
134 
135     cmKrnCSCDS->SetKernelArg(idx++, curbeData.get_size_data(), curbeData.get_addr_data());
136 
137     SurfaceIndex * pSurfIndex = nullptr;
138 
139     CODECHAL_ENCODE_ASSERT(surfaceparams->psInputSurface != nullptr)
140 
141     CODECHAL_ENCODE_CHK_STATUS_RETURN(surfaceparams->psInputSurface->GetIndex(pSurfIndex));
142     cmKrnCSCDS->SetKernelArg(idx++, sizeof(SurfaceIndex), pSurfIndex);
143 
144     if (surfaceparams->psOutputCopiedSurface)
145     {
146         CODECHAL_ENCODE_CHK_STATUS_RETURN(surfaceparams->psOutputCopiedSurface->GetIndex(pSurfIndex));
147     }
148     cmKrnCSCDS->SetKernelArg(idx++, sizeof(SurfaceIndex), pSurfIndex);
149 
150     if (surfaceparams->psOutput4xDsSurface)
151     {
152         CODECHAL_ENCODE_CHK_STATUS_RETURN(surfaceparams->psOutput4xDsSurface->GetIndex(pSurfIndex));
153     }
154     cmKrnCSCDS->SetKernelArg(idx++, sizeof(SurfaceIndex), pSurfIndex);
155 
156     if (surfaceparams->presMBVProcStatsBuffer)
157     {
158         CODECHAL_ENCODE_CHK_STATUS_RETURN(surfaceparams->presMBVProcStatsBuffer->GetIndex(pSurfIndex));
159     }
160     cmKrnCSCDS->SetKernelArg(idx++, sizeof(SurfaceIndex), pSurfIndex);
161 
162     if (surfaceparams->psOutput2xDsSurface)
163     {
164         CODECHAL_ENCODE_CHK_STATUS_RETURN(surfaceparams->psOutput2xDsSurface->GetIndex(pSurfIndex));
165     }
166 
167     cmKrnCSCDS->SetKernelArg(idx++, sizeof(SurfaceIndex), pSurfIndex);
168 
169     if (m_surfaceParamsCsc.hevcExtParams)
170     {
171         cmKrnCSCDS->SetKernelArg(idx++, sizeof(SurfaceIndex), surfaceparams->pHistBufSurfIdx);
172         cmKrnCSCDS->SetKernelArg(idx++, sizeof(SurfaceIndex), surfaceparams->pHistSumBufSurfIdx);
173         cmKrnCSCDS->SetKernelArg(idx++, sizeof(SurfaceIndex), surfaceparams->pMTTaskSumBufSurfIdx);
174     }
175     else
176     {
177         cmKrnCSCDS->SetKernelArg(idx++, sizeof(SurfaceIndex), pSurfIndex);
178         cmKrnCSCDS->SetKernelArg(idx++, sizeof(SurfaceIndex), pSurfIndex);
179         cmKrnCSCDS->SetKernelArg(idx++, sizeof(SurfaceIndex), pSurfIndex);
180     }
181 
182     return  MOS_STATUS_SUCCESS;
183 }
184 
DestroySurfaces(SurfaceParamsCscMdf & SurfaceParamsCsc)185 MOS_STATUS CodechalEncodeCscDsMdfG12::DestroySurfaces(SurfaceParamsCscMdf& SurfaceParamsCsc)
186 {
187     CmDevice* &cmDev = m_encoder->m_cmDev;
188     // Input YUV
189     if (SurfaceParamsCsc.psInputSurface)
190     {
191         CODECHAL_ENCODE_CHK_STATUS_RETURN(
192             DestroyCmSurface2D(cmDev, &SurfaceParamsCsc.psInputSurface));
193         SurfaceParamsCsc.psInputSurface = nullptr;
194     }
195     if (SurfaceParamsCsc.psOutputCopiedSurface)
196     {
197         CODECHAL_ENCODE_CHK_STATUS_RETURN(
198             DestroyCmSurface2D(cmDev, &SurfaceParamsCsc.psOutputCopiedSurface));
199         SurfaceParamsCsc.psOutputCopiedSurface = nullptr;
200     }
201     if (SurfaceParamsCsc.psOutput4xDsSurface)
202     {
203         CODECHAL_ENCODE_CHK_STATUS_RETURN(
204             DestroyCmSurface2D(cmDev, &SurfaceParamsCsc.psOutput4xDsSurface));
205         SurfaceParamsCsc.psOutput4xDsSurface = nullptr;
206     }
207     if (SurfaceParamsCsc.psOutput2xDsSurface)
208     {
209         CODECHAL_ENCODE_CHK_STATUS_RETURN(
210             DestroyCmSurface2D(cmDev, &SurfaceParamsCsc.psOutput2xDsSurface));
211         SurfaceParamsCsc.psOutput2xDsSurface = nullptr;
212     }
213     if (SurfaceParamsCsc.presMBVProcStatsBuffer)
214     {
215         CODECHAL_ENCODE_CHK_STATUS_RETURN(cmDev->DestroySurface(SurfaceParamsCsc.presMBVProcStatsBuffer));
216         SurfaceParamsCsc.presMBVProcStatsBuffer = nullptr;
217     }
218     if (SurfaceParamsCsc.presHistoryBuffer)
219     {
220         CODECHAL_ENCODE_CHK_STATUS_RETURN(cmDev->DestroySurface(SurfaceParamsCsc.presHistoryBuffer));
221         SurfaceParamsCsc.presHistoryBuffer = nullptr;
222     }
223     if (SurfaceParamsCsc.presHistorySumBuffer)
224     {
225         CODECHAL_ENCODE_CHK_STATUS_RETURN(cmDev->DestroySurface(SurfaceParamsCsc.presHistorySumBuffer));
226         SurfaceParamsCsc.presHistorySumBuffer = nullptr;
227     }
228     if (SurfaceParamsCsc.presMultiThreadTaskBuffer)
229     {
230         CODECHAL_ENCODE_CHK_STATUS_RETURN(cmDev->DestroySurface(SurfaceParamsCsc.presMultiThreadTaskBuffer));
231         SurfaceParamsCsc.presMultiThreadTaskBuffer = nullptr;
232     }
233     return  MOS_STATUS_SUCCESS;
234 }
235 
ReleaseResources()236 MOS_STATUS CodechalEncodeCscDsMdfG12::ReleaseResources()
237 {
238     CODECHAL_ENCODE_FUNCTION_ENTER;
239     CmDevice* &cmDev = m_encoder->m_cmDev;
240     DestroySurfaces(m_cmSurfParamsCscDs4x);
241     DestroySurfaces(m_cmSurfParamsCscDs16x);
242     DestroySurfaces(m_cmSurfParamsCscDs32x);
243 
244     if (m_cmKrnCSCDS4x)
245     {
246         CODECHAL_ENCODE_CHK_STATUS_RETURN(cmDev->DestroyKernel(m_cmKrnCSCDS4x));
247         m_cmKrnCSCDS4x = nullptr;
248     }
249 
250     if (m_cmKrnCSCDS16x)
251     {
252         CODECHAL_ENCODE_CHK_STATUS_RETURN(cmDev->DestroyKernel(m_cmKrnCSCDS16x));
253         m_cmKrnCSCDS16x = nullptr;
254     }
255 
256     if (m_cmKrnCSCDS32x)
257     {
258         CODECHAL_ENCODE_CHK_STATUS_RETURN(cmDev->DestroyKernel(m_cmKrnCSCDS32x));
259         m_cmKrnCSCDS32x = nullptr;
260     }
261 
262     if (m_cmProgramCSCDS)
263     {
264         CODECHAL_ENCODE_CHK_STATUS_RETURN(cmDev->DestroyProgram(m_cmProgramCSCDS));
265         m_cmProgramCSCDS = nullptr;
266     }
267     if (m_threadSpace4x)
268     {
269         CODECHAL_ENCODE_CHK_STATUS_RETURN(cmDev->DestroyThreadSpace(m_threadSpace4x));
270         m_threadSpace4x = nullptr;
271     }
272 
273     if (m_threadSpace16x)
274     {
275         CODECHAL_ENCODE_CHK_STATUS_RETURN(cmDev->DestroyThreadSpace(m_threadSpace16x));
276         m_threadSpace16x = nullptr;
277     }
278 
279     if (m_threadSpace32x)
280     {
281         CODECHAL_ENCODE_CHK_STATUS_RETURN(cmDev->DestroyThreadSpace(m_threadSpace32x));
282         m_threadSpace32x = nullptr;
283     }
284 
285     return MOS_STATUS_SUCCESS;
286 }
287 
SetupSurfacesCSC(SurfaceParamsCscMdf & SurfaceParamsCsc)288 MOS_STATUS CodechalEncodeCscDsMdfG12::SetupSurfacesCSC(SurfaceParamsCscMdf& SurfaceParamsCsc)
289 {
290     CmDevice* &cmDev = m_encoder->m_cmDev;
291     // Input YUV
292     CODECHAL_ENCODE_CHK_STATUS_RETURN(
293         UpdateCmSurface2D(cmDev,
294                           &m_surfaceParamsCsc.psInputSurface->OsResource,
295                           &SurfaceParamsCsc.psInputSurface));
296 
297     if (Format_NV12 == m_surfaceParamsCsc.psInputSurface->Format)
298     {
299         uint32_t   width = 0, height = 0;
300         MOS_FORMAT format = Format_Invalid;
301         m_encoder->m_cscDsState->GetCscAllocation(width, height, format);
302 
303         CM_SURFACE2D_STATE_PARAM param;
304         MOS_ZeroMemory(&param, sizeof(param));
305         param.width  = width;
306         param.height = MOS_TILE_LINEAR == m_surfaceParamsCsc.psInputSurface->TileType ? (height * 3) / 2 : height;
307         param.format = format;
308         CODECHAL_ENCODE_CHK_STATUS_RETURN(SurfaceParamsCsc.psInputSurface->SetSurfaceStateParam(nullptr, &param));
309     }
310 
311     // Output to Enc
312     if (m_surfaceParamsCsc.psOutputCopiedSurface)
313     {
314         CODECHAL_ENCODE_CHK_STATUS_RETURN(
315             UpdateCmSurface2D(cmDev,
316                               &m_surfaceParamsCsc.psOutputCopiedSurface->OsResource,
317                               &SurfaceParamsCsc.psOutputCopiedSurface));
318     }
319 
320     if (m_surfaceParamsCsc.psOutput4xDsSurface)
321     {
322         CODECHAL_ENCODE_CHK_STATUS_RETURN(
323             UpdateCmSurface2D(cmDev,
324             &m_surfaceParamsCsc.psOutput4xDsSurface->OsResource,
325             &SurfaceParamsCsc.psOutput4xDsSurface));
326     }
327 
328     if (m_surfaceParamsCsc.psOutput2xDsSurface)
329     {
330         CODECHAL_ENCODE_CHK_STATUS_RETURN(
331             UpdateCmSurface2D(cmDev,
332                               &m_surfaceParamsCsc.psOutput2xDsSurface->OsResource,
333                               &SurfaceParamsCsc.psOutput2xDsSurface));
334     }
335 
336     if (m_surfaceParamsCsc.presMBVProcStatsBuffer)
337     {
338         CODECHAL_ENCODE_CHK_STATUS_RETURN(cmDev->UpdateBuffer(
339             m_surfaceParamsCsc.presMBVProcStatsBuffer,
340             SurfaceParamsCsc.presMBVProcStatsBuffer));
341     }
342 
343     if (m_surfaceParamsCsc.hevcExtParams)
344     {
345         auto hevcExtParams = (HevcExtKernelParams*)m_surfaceParamsCsc.hevcExtParams;
346         CM_BUFFER_STATE_PARAM bufParams;
347 
348         if (SurfaceParamsCsc.presHistoryBuffer)
349         {
350             CODECHAL_ENCODE_CHK_STATUS_RETURN(cmDev->DestroySurface(SurfaceParamsCsc.presHistoryBuffer));
351             SurfaceParamsCsc.presHistoryBuffer = nullptr;
352         }
353 
354         CODECHAL_ENCODE_CHK_STATUS_RETURN(cmDev->CreateBuffer(
355             hevcExtParams->presHistoryBuffer,
356             SurfaceParamsCsc.presHistoryBuffer));
357         CODECHAL_ENCODE_CHK_STATUS_RETURN(cmDev->CreateBufferAlias(
358             SurfaceParamsCsc.presHistoryBuffer,
359             SurfaceParamsCsc.pHistBufSurfIdx));
360         bufParams.uiBaseAddressOffset = hevcExtParams->dwOffsetHistoryBuffer;
361         bufParams.uiSize              = hevcExtParams->dwSizeHistoryBuffer;
362         CODECHAL_ENCODE_CHK_STATUS_RETURN(SurfaceParamsCsc.presHistoryBuffer->SetSurfaceStateParam(
363             SurfaceParamsCsc.pHistBufSurfIdx,
364             &bufParams));
365 
366         if (SurfaceParamsCsc.presHistorySumBuffer)
367         {
368             CODECHAL_ENCODE_CHK_STATUS_RETURN(cmDev->DestroySurface(SurfaceParamsCsc.presHistorySumBuffer));
369             SurfaceParamsCsc.presHistorySumBuffer = nullptr;
370         }
371         CODECHAL_ENCODE_CHK_STATUS_RETURN(cmDev->CreateBuffer(
372             hevcExtParams->presHistorySumBuffer,
373             SurfaceParamsCsc.presHistorySumBuffer));
374         CODECHAL_ENCODE_CHK_STATUS_RETURN(cmDev->CreateBufferAlias(
375             SurfaceParamsCsc.presHistorySumBuffer,
376             SurfaceParamsCsc.pHistSumBufSurfIdx));
377         bufParams.uiBaseAddressOffset = hevcExtParams->dwOffsetHistorySumBuffer;
378         bufParams.uiSize = hevcExtParams->dwSizeHistorySumBuffer;
379         CODECHAL_ENCODE_CHK_STATUS_RETURN(SurfaceParamsCsc.presHistorySumBuffer->SetSurfaceStateParam(
380             SurfaceParamsCsc.pHistSumBufSurfIdx,
381             &bufParams));
382 
383         if (SurfaceParamsCsc.presMultiThreadTaskBuffer)
384         {
385             CODECHAL_ENCODE_CHK_STATUS_RETURN(cmDev->DestroySurface(SurfaceParamsCsc.presMultiThreadTaskBuffer));
386             SurfaceParamsCsc.presMultiThreadTaskBuffer = nullptr;
387         }
388         CODECHAL_ENCODE_CHK_STATUS_RETURN(cmDev->CreateBuffer(
389             hevcExtParams->presMultiThreadTaskBuffer,
390             SurfaceParamsCsc.presMultiThreadTaskBuffer));
391         CODECHAL_ENCODE_CHK_STATUS_RETURN(cmDev->CreateBufferAlias(
392             SurfaceParamsCsc.presMultiThreadTaskBuffer,
393             SurfaceParamsCsc.pMTTaskSumBufSurfIdx));
394         bufParams.uiBaseAddressOffset = hevcExtParams->dwOffsetMultiThreadTaskBuffer;
395         bufParams.uiSize = hevcExtParams->dwSizeMultiThreadTaskBuffer;
396         CODECHAL_ENCODE_CHK_STATUS_RETURN(SurfaceParamsCsc.presMultiThreadTaskBuffer->SetSurfaceStateParam(
397             SurfaceParamsCsc.pMTTaskSumBufSurfIdx,
398             &bufParams));
399     }
400 
401     return MOS_STATUS_SUCCESS;
402 }
403 
InitKernelStateCsc(KernelParams * pParams)404 MOS_STATUS CodechalEncodeCscDsMdfG12::InitKernelStateCsc(KernelParams* pParams)
405 {
406 
407     CODECHAL_ENCODE_FUNCTION_ENTER;
408     CmDevice* &cmDev = m_encoder->m_cmDev;
409 
410     CODECHAL_ENCODE_CHK_STATUS_RETURN(cmDev->LoadProgram((void *)GEN12LP_DS_CONVERT_GENX,
411         GEN12LP_DS_CONVERT_GENX_SIZE,
412         m_cmProgramCSCDS,
413         "-nojitter"));
414 
415     if (!m_cmKrnCSCDS4x)
416     {
417         CODECHAL_ENCODE_CHK_STATUS_RETURN(cmDev->CreateKernel(m_cmProgramCSCDS,
418             "DS_Convert",
419             m_cmKrnCSCDS4x));
420     }
421 
422     if (m_16xMeSupported && !m_cmKrnCSCDS16x)
423     {
424         CODECHAL_ENCODE_CHK_STATUS_RETURN(cmDev->CreateKernel(m_cmProgramCSCDS,
425             "DS_Convert",
426             m_cmKrnCSCDS16x));
427     }
428 
429     if (m_32xMeSupported && !m_cmKrnCSCDS32x)
430     {
431         CODECHAL_ENCODE_CHK_STATUS_RETURN(cmDev->CreateKernel(m_cmProgramCSCDS,
432             "DS_Convert",
433             m_cmKrnCSCDS32x));
434     }
435     return MOS_STATUS_SUCCESS;
436 }
437 
CscKernel(KernelParams * pParams)438 MOS_STATUS CodechalEncodeCscDsMdfG12::CscKernel(
439     KernelParams* pParams)
440 {
441     CODECHAL_ENCODE_FUNCTION_ENTER;
442 
443     CODECHAL_ENCODE_CHK_NULL_RETURN(pParams);
444 
445     if (!m_cscKernelState)
446     {
447         CODECHAL_ENCODE_CHK_NULL_RETURN(m_cscKernelState = MOS_New(MHW_KERNEL_STATE));
448         CODECHAL_ENCODE_CHK_STATUS_RETURN(InitKernelStateCsc(pParams));
449     }
450 
451     // allocate CSC surface (existing surfaces will be re-used when associated frame goes out of RefList)
452     CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateSurfaceCsc());
453 
454     if (m_scalingEnabled)
455     {
456         CODECHAL_ENCODE_CHK_STATUS_RETURN(m_encoder->m_trackedBuf->AllocateSurfaceDS());
457     }
458 
459     if (m_2xScalingEnabled)
460     {
461         CODECHAL_ENCODE_CHK_STATUS_RETURN(m_encoder->m_trackedBuf->AllocateSurface2xDS());
462     }
463 
464     if (m_encoder->m_trackedBuf->GetWaitCsc())
465     {
466         // in case PAK hasn't yet consumed a surface sent earlier, wait before we can re-use
467         CODECHAL_ENCODE_CHK_STATUS_RETURN(WaitCscSurface(m_renderContext, false));
468     }
469     // setup kernel params
470     CODECHAL_ENCODE_CHK_STATUS_RETURN(SetKernelParamsCsc(pParams));
471 
472     PerfTagSetting perfTag;
473     perfTag.Value = 0;
474     perfTag.Mode = (uint16_t)m_mode & CODECHAL_ENCODE_MODE_BIT_MASK;
475     perfTag.CallType = CODECHAL_ENCODE_PERFTAG_CALL_DS_CONVERSION_KERNEL;
476     perfTag.PictureCodingType = m_encoder->m_pictureCodingType;
477     m_osInterface->pfnSetPerfTag(m_osInterface, perfTag.Value);
478     // Each scaling kernel buffer counts as a separate perf task
479     m_osInterface->pfnResetPerfBufferID(m_osInterface);
480 
481 
482     uint32_t threadCount = m_walkerResolutionX * m_walkerResolutionY;
483     CmThreadSpace          *threadSpace = nullptr;
484     CmKernel               *cmKrnCSCDS = nullptr;
485     SurfaceParamsCscMdf     *surfaceparams = nullptr;
486 
487     if (pParams->stageDsConversion == dsStage16x)
488     {
489         // MDf surface states
490         CODECHAL_ENCODE_CHK_STATUS_RETURN(SetupSurfacesCSC(m_cmSurfParamsCscDs16x));
491         CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cmKrnCSCDS16x->SetThreadCount(threadCount));
492         if(m_encoder->m_resolutionChanged && m_threadSpace16x != nullptr)
493         {
494             CODECHAL_ENCODE_CHK_STATUS_RETURN(m_encoder->m_cmDev->DestroyThreadSpace(m_threadSpace16x));
495             m_threadSpace16x = nullptr;
496         }
497         if(m_threadSpace16x == nullptr)
498         {
499             CODECHAL_ENCODE_CHK_STATUS_RETURN(m_encoder->m_cmDev->CreateThreadSpace(
500                                                   m_walkerResolutionX,
501                                                   m_walkerResolutionY,
502                                                   m_threadSpace16x));
503         }
504         threadSpace = m_threadSpace16x;
505         cmKrnCSCDS = m_cmKrnCSCDS16x;
506         surfaceparams = &m_cmSurfParamsCscDs16x;
507     }
508     else if(pParams->stageDsConversion == dsStage32x)
509     {
510         CODECHAL_ENCODE_CHK_STATUS_RETURN(SetupSurfacesCSC(m_cmSurfParamsCscDs32x));
511         CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cmKrnCSCDS32x->SetThreadCount(threadCount));
512         if(m_encoder->m_resolutionChanged && m_threadSpace32x != nullptr)
513         {
514             CODECHAL_ENCODE_CHK_STATUS_RETURN(m_encoder->m_cmDev->DestroyThreadSpace(m_threadSpace32x));
515             m_threadSpace32x = nullptr;
516         }
517         if(m_threadSpace32x == nullptr)
518         {
519             CODECHAL_ENCODE_CHK_STATUS_RETURN(m_encoder->m_cmDev->CreateThreadSpace(
520                                                   m_walkerResolutionX,
521                                                   m_walkerResolutionY,
522                                                   m_threadSpace32x));
523         }
524         threadSpace = m_threadSpace32x;
525         cmKrnCSCDS = m_cmKrnCSCDS32x;
526         surfaceparams = &m_cmSurfParamsCscDs32x;
527     }
528     else
529     {
530         CODECHAL_ENCODE_CHK_STATUS_RETURN(SetupSurfacesCSC(m_cmSurfParamsCscDs4x));
531         CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cmKrnCSCDS4x->SetThreadCount(threadCount));
532 
533         if(m_encoder->m_resolutionChanged && m_threadSpace4x != nullptr)
534         {
535             CODECHAL_ENCODE_CHK_STATUS_RETURN(m_encoder->m_cmDev->DestroyThreadSpace(m_threadSpace4x));
536             m_threadSpace4x = nullptr;
537         }
538 
539         if(m_threadSpace4x == nullptr)
540         {
541             CODECHAL_ENCODE_CHK_STATUS_RETURN(m_encoder->m_cmDev->CreateThreadSpace(
542                                                   m_walkerResolutionX,
543                                                   m_walkerResolutionY,
544                                                   m_threadSpace4x));
545         }
546         threadSpace = m_threadSpace4x;
547         cmKrnCSCDS = m_cmKrnCSCDS4x;
548         surfaceparams = &m_cmSurfParamsCscDs4x;
549     }
550 
551     CODECHAL_ENCODE_CHK_NULL_RETURN(threadSpace);
552 
553     if (m_groupIdSelectSupported)
554     {
555         threadSpace->SetMediaWalkerGroupSelect((CM_MW_GROUP_SELECT)m_groupId);
556     }
557     CODECHAL_ENCODE_CHK_STATUS_RETURN(cmKrnCSCDS->AssociateThreadSpace(threadSpace));
558 
559     CODECHAL_ENCODE_CHK_STATUS_RETURN(SetupKernelArgsCSC(cmKrnCSCDS,surfaceparams));
560 
561     CODECHAL_ENCODE_CHK_STATUS_RETURN(m_encoder->m_cmTask->AddKernel(cmKrnCSCDS));
562 
563     if (!m_singleTaskPhaseSupported || m_lastTaskInPhase)
564     {
565         CmEvent * event = CM_NO_EVENT;
566         CODECHAL_ENCODE_CHK_STATUS_RETURN(m_encoder->m_cmQueue->EnqueueFast(m_encoder->m_cmTask, event));
567 
568         CODECHAL_ENCODE_CHK_STATUS_RETURN(m_encoder->m_cmTask->Reset());
569 
570         m_lastTaskInPhase = false;
571     }
572     else
573     {
574         m_encoder->m_cmTask->AddSync();
575     }
576 
577     if (dsDisabled == pParams->stageDsConversion)
578     {
579         // send appropriate surface to Enc/Pak depending on different CSC operation type
580         CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesToEncPak());
581     }
582 
583     return MOS_STATUS_SUCCESS;
584 }
585 
CodechalEncodeCscDsMdfG12(CodechalEncoderState * encoder)586 CodechalEncodeCscDsMdfG12::CodechalEncodeCscDsMdfG12(CodechalEncoderState* encoder)
587     : CodechalEncodeCscDsG12(encoder)
588 {
589 }
590 
~CodechalEncodeCscDsMdfG12()591 CodechalEncodeCscDsMdfG12::~CodechalEncodeCscDsMdfG12()
592 {
593     ReleaseResources();
594 }
595