1 /*
2 * Copyright (c) 2021-2023, 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_render_vebox_update_cmd_packet.cpp
24 //! \brief render packet which used in by mediapipline.
25 //! \details render packet provide the structures and generate the cmd buffer which mediapipline will used.
26 //!
27 #include "vp_render_fc_kernel.h"
28 #include "vp_render_kernel_obj.h"
29 #include "hal_kerneldll_next.h"
30 #include "hal_oca_interface_next.h"
31 #include "vp_user_feature_control.h"
32 #include "vp_hal_ddi_utils.h"
33
34 using namespace vp;
35
36 #define VP_COMP_SOURCE_DEPTH 16
37 #define VP_COMP_P010_DEPTH 0
38
39 // Compositing surface binding table index
40 #define VP_COMP_BTINDEX_LAYER0 0
41 #define VP_COMP_BTINDEX_LAYER0_FIELD0 0
42 #define VP_COMP_BTINDEX_LAYER1 3
43 #define VP_COMP_BTINDEX_LAYER2 6
44 #define VP_COMP_BTINDEX_LAYER3 9
45 #define VP_COMP_BTINDEX_LAYER4 12
46 #define VP_COMP_BTINDEX_LAYER5 15
47 #define VP_COMP_BTINDEX_LAYER6 18
48 #define VP_COMP_BTINDEX_LAYER7 21
49 #define VP_COMP_BTINDEX_RENDERTARGET 24
50 #define VP_COMP_BTINDEX_RT_SECOND 27 // Pre-SKL
51 #define VP_COMP_BTINDEX_L0_FIELD1_DUAL 48 // Pre-SKL
52
53 // CMFC macro
54 #define VP_COMP_BTINDEX_CSC_COEFF 34
55
56 const int32_t VpRenderFcKernel::s_bindingTableIndex[] =
57 {
58 VP_COMP_BTINDEX_LAYER0,
59 VP_COMP_BTINDEX_LAYER1,
60 VP_COMP_BTINDEX_LAYER2,
61 VP_COMP_BTINDEX_LAYER3,
62 VP_COMP_BTINDEX_LAYER4,
63 VP_COMP_BTINDEX_LAYER5,
64 VP_COMP_BTINDEX_LAYER6,
65 VP_COMP_BTINDEX_LAYER7
66 };
67
68 const int32_t VpRenderFcKernel::s_bindingTableIndexField[] =
69 {
70 VP_COMP_BTINDEX_L0_FIELD1_DUAL,
71 VP_COMP_BTINDEX_L0_FIELD1_DUAL + 1,
72 VP_COMP_BTINDEX_L0_FIELD1_DUAL + 2,
73 VP_COMP_BTINDEX_L0_FIELD1_DUAL + 3,
74 VP_COMP_BTINDEX_L0_FIELD1_DUAL + 4,
75 VP_COMP_BTINDEX_L0_FIELD1_DUAL + 5,
76 VP_COMP_BTINDEX_L0_FIELD1_DUAL + 6,
77 VP_COMP_BTINDEX_L0_FIELD1_DUAL + 7
78 };
79
VpRenderFcKernel(PVP_MHWINTERFACE hwInterface,PVpAllocator allocator)80 VpRenderFcKernel::VpRenderFcKernel(PVP_MHWINTERFACE hwInterface, PVpAllocator allocator) :
81 VpRenderKernelObj(hwInterface, (VpKernelID)kernelCombinedFc, 0, VpRenderKernel::s_kernelNameNonAdvKernels, allocator)
82 {
83 m_kernelBinaryID = IDR_VP_EOT;
84
85 if (m_hwInterface && m_hwInterface->m_vpPlatformInterface &&
86 m_hwInterface->m_vpPlatformInterface->GetKernelPool().end() != m_hwInterface->m_vpPlatformInterface->GetKernelPool().find(VpRenderKernel::s_kernelNameNonAdvKernels))
87 {
88 m_kernelDllState = m_hwInterface->m_vpPlatformInterface->GetKernelPool().find(VpRenderKernel::s_kernelNameNonAdvKernels)->second.GetKdllState();
89
90 // Setup Procamp Parameters
91 KernelDll_SetupProcampParameters(m_kernelDllState,
92 m_Procamp,
93 m_maxProcampEntries);
94 }
95 else
96 {
97 VP_RENDER_ASSERTMESSAGE("VpRenderFcKernel::VpRenderFcKernel, m_kernelDllState is nullptr!");
98 }
99
100 m_renderHal = m_hwInterface ? m_hwInterface->m_renderHal : nullptr;
101 if (m_renderHal)
102 {
103 if (m_kernelDllState && m_kernelDllState->bEnableCMFC)
104 {
105 m_renderHal->bEnableP010SinglePass = true;
106 }
107 else
108 {
109 m_renderHal->bEnableP010SinglePass = false;
110 }
111 VP_RENDER_NORMALMESSAGE("m_renderHal->bEnableP010SinglePass %d", m_renderHal->bEnableP010SinglePass);
112 }
113
114 if (m_renderHal && m_renderHal->pRenderHalPltInterface && m_hwInterface->m_vpPlatformInterface)
115 {
116 VpKernelConfig *vpKernelConfig = m_hwInterface->m_vpPlatformInterface->GetKernelConfig();
117 if (vpKernelConfig == nullptr)
118 {
119 VP_RENDER_ASSERTMESSAGE("vpKernelConfig is nullptr");
120 }
121 else
122 {
123 m_cscCoeffPatchModeEnabled = vpKernelConfig->IsFcCscCoeffPatchModeEnabled();
124 }
125
126 if (m_hwInterface->m_osInterface)
127 {
128 m_userSettingPtr = m_hwInterface->m_osInterface->pfnGetUserSettingInstance(m_hwInterface->m_osInterface);
129 }
130 auto userFeatureControl = m_hwInterface->m_userFeatureControl;
131 if (userFeatureControl != nullptr)
132 {
133 m_cscCoeffPatchModeEnabled = !userFeatureControl->IsCscCosffPatchModeDisabled();
134 }
135
136 m_computeWalkerEnabled = true;
137 }
138 }
139
SetCacheCntl(PVP_RENDER_CACHE_CNTL surfMemCacheCtl)140 MOS_STATUS VpRenderFcKernel::SetCacheCntl(PVP_RENDER_CACHE_CNTL surfMemCacheCtl)
141 {
142 VP_FUNC_CALL();
143 VP_RENDER_CHK_NULL_RETURN(surfMemCacheCtl);
144
145 if (!surfMemCacheCtl->bCompositing)
146 {
147 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
148 }
149 m_surfMemCacheCtl = surfMemCacheCtl->Composite;
150
151 return MOS_STATUS_SUCCESS;
152 }
153
IsNV12SamplerLumakeyNeeded()154 bool IsNV12SamplerLumakeyNeeded()
155 {
156 return false;
157 }
158
SetSurfaceParams(KERNEL_SURFACE_STATE_PARAM & surfParam,VP_FC_LAYER & layer,bool is32MWColorFillKern)159 MOS_STATUS VpRenderFcKernel::SetSurfaceParams(KERNEL_SURFACE_STATE_PARAM &surfParam, VP_FC_LAYER &layer, bool is32MWColorFillKern)
160 {
161 VP_FUNC_CALL();
162
163 auto &renderSurfParams = surfParam.surfaceOverwriteParams.renderSurfaceParams;
164 MOS_ZeroMemory(&renderSurfParams, sizeof(renderSurfParams));
165
166 surfParam.surfaceOverwriteParams.updatedRenderSurfaces = true;
167
168 // Render target or private surface
169 if (layer.surf->SurfType == SURF_OUT_RENDERTARGET)
170 {
171 // Disable AVS, IEF
172 layer.scalingMode = VPHAL_SCALING_BILINEAR;
173 layer.iefEnabled = false;
174
175 // Set flags for RT
176 surfParam.isOutput = true;
177 renderSurfParams.isOutput = true;
178 renderSurfParams.bWidthInDword_Y = true;
179 renderSurfParams.bWidthInDword_UV = true;
180 renderSurfParams.Boundary = RENDERHAL_SS_BOUNDARY_DSTRECT;
181 }
182 // other surfaces
183 else
184 {
185 surfParam.isOutput = false;
186 renderSurfParams.isOutput = false;
187 renderSurfParams.bWidthInDword_Y = false;
188 renderSurfParams.bWidthInDword_UV = false;
189 renderSurfParams.Boundary = RENDERHAL_SS_BOUNDARY_SRCRECT;
190 }
191
192 renderSurfParams.b32MWColorFillKern = is32MWColorFillKern;
193
194 // Set surface type based on scaling mode
195 if (layer.scalingMode == VPHAL_SCALING_AVS)
196 {
197 renderSurfParams.Type = m_renderHal->SurfaceTypeAdvanced;
198 renderSurfParams.bAVS = true;
199 }
200 else
201 {
202 renderSurfParams.Type = m_renderHal->SurfaceTypeDefault;
203 renderSurfParams.bAVS = false;
204 }
205
206 if (layer.iscalingEnabled)
207 {
208 // Top Input Field
209 renderSurfParams.bVertStrideOffs = false;
210 renderSurfParams.bVertStride = true;
211 }
212 else if (layer.fieldWeaving)
213 {
214 // Top Input Field
215 renderSurfParams.bVertStrideOffs = false;
216 renderSurfParams.bVertStride = false;
217 }
218 else
219 {
220 // Set interlacing flags
221 switch (layer.surf->SampleType)
222 {
223 case SAMPLE_INTERLEAVED_EVEN_FIRST_TOP_FIELD:
224 case SAMPLE_INTERLEAVED_ODD_FIRST_TOP_FIELD:
225 renderSurfParams.bVertStride = true;
226 renderSurfParams.bVertStrideOffs = 0;
227 break;
228 case SAMPLE_INTERLEAVED_EVEN_FIRST_BOTTOM_FIELD:
229 case SAMPLE_INTERLEAVED_ODD_FIRST_BOTTOM_FIELD:
230 renderSurfParams.bVertStride = true;
231 renderSurfParams.bVertStrideOffs = 1;
232 break;
233 default:
234 renderSurfParams.bVertStride = false;
235 renderSurfParams.bVertStrideOffs = 0;
236 break;
237 }
238 }
239
240 if (layer.layerID && IsNV12SamplerLumakeyNeeded())
241 {
242 renderSurfParams.b2PlaneNV12NeededByKernel = true;
243 }
244
245 surfParam.surfaceEntries = layer.surfaceEntries;
246 surfParam.iCapcityOfSurfaceEntry = MHW_MAX_SURFACE_PLANES;
247 surfParam.sizeOfSurfaceEntries = &layer.numOfSurfaceEntries;
248
249 VP_RENDER_NORMALMESSAGE("SurfaceTYpe %d, bAVS %d, b2PlaneNV12NeededByKernel %d",
250 renderSurfParams.Type,
251 renderSurfParams.bAVS,
252 renderSurfParams.b2PlaneNV12NeededByKernel);
253
254 return MOS_STATUS_SUCCESS;
255 }
256
SetupSurfaceState()257 MOS_STATUS VpRenderFcKernel::SetupSurfaceState()
258 {
259 VP_FUNC_CALL();
260
261 VP_RENDER_CHK_NULL_RETURN(m_hwInterface);
262 VP_RENDER_CHK_NULL_RETURN(m_renderHal);
263
264 uint32_t i = 0;
265 VP_COMPOSITE_PARAMS &compParams = m_fcParams->compParams;
266
267 m_surfaceState.clear();
268 m_surfaceBindingIndex.clear();
269
270 for (i = 0; i < compParams.sourceCount; ++i)
271 {
272 KERNEL_SURFACE_STATE_PARAM surfParam = {};
273 VP_FC_LAYER *layer = &compParams.source[i];
274
275 surfParam.surfaceOverwriteParams.updatedSurfaceParams = true;
276
277 // Only need to specify binding index in surface parameters.
278 surfParam.surfaceOverwriteParams.bindedKernel = true;
279 if (layer->layerID >= VP_COMP_MAX_LAYERS || layer->layerID < 0)
280 {
281 VP_RENDER_ASSERTMESSAGE("layer->layerID = d% is out of range!", layer->layerID);
282 return MOS_STATUS_INVALID_PARAMETER;
283 }
284
285 VpUserFeatureControl *userFeatureControl = m_hwInterface->m_userFeatureControl;
286
287 if (nullptr != userFeatureControl && userFeatureControl->IsDecompForInterlacedSurfWaEnabled())
288 {
289 auto decompressionSycSurfaceID = m_surfaceGroup->find(SurfaceTypeDecompressionSync);
290 VP_SURFACE *pDecompressionSycSurface = (m_surfaceGroup->end() != decompressionSycSurfaceID) ? decompressionSycSurfaceID->second : nullptr;
291 auto pSrcID = m_surfaceGroup->find(SurfaceType(SurfaceTypeFcInputLayer0 + i));
292 VP_SURFACE *pSrc = (m_surfaceGroup->end() != pSrcID) ? pSrcID->second : nullptr;
293 // Interlaced surface in the compression mode needs to decompress
294 if (pDecompressionSycSurface && pSrc && pSrc->SampleType != SAMPLE_PROGRESSIVE && (pSrc->osSurface->CompressionMode == MOS_MMC_MC || pSrc->osSurface->CompressionMode == MOS_MMC_RC))
295 {
296 VP_RENDER_CHK_STATUS_RETURN(m_hwInterface->m_osInterface->pfnSetDecompSyncRes(m_hwInterface->m_osInterface, &pDecompressionSycSurface->osSurface->OsResource))
297 VP_RENDER_CHK_STATUS_RETURN(m_hwInterface->m_osInterface->pfnDecompResource(m_hwInterface->m_osInterface, &pSrc->osSurface->OsResource));
298 VP_RENDER_CHK_STATUS_RETURN(m_hwInterface->m_osInterface->pfnSetDecompSyncRes(m_hwInterface->m_osInterface, nullptr));
299 VP_RENDER_CHK_STATUS_RETURN(m_hwInterface->m_osInterface->pfnRegisterResource(m_hwInterface->m_osInterface, &pDecompressionSycSurface->osSurface->OsResource, true, true));
300
301 MOS_SURFACE osSurface = {};
302 VP_RENDER_CHK_STATUS_RETURN(m_hwInterface->m_osInterface->pfnGetResourceInfo(m_hwInterface->m_osInterface, &pSrc->osSurface->OsResource, &osSurface));
303 pSrc->osSurface->bIsCompressed = osSurface.bIsCompressed;
304 pSrc->osSurface->CompressionMode = osSurface.CompressionMode;
305 pSrc->osSurface->CompressionFormat = osSurface.CompressionFormat;
306 pSrc->osSurface->MmcState = osSurface.MmcState;
307 }
308 }
309
310 UpdateCurbeBindingIndex(SurfaceType(SurfaceTypeFcInputLayer0 + layer->layerID), s_bindingTableIndex[layer->layerID]);
311
312 SetSurfaceParams(surfParam, *layer, false);
313 surfParam.surfaceOverwriteParams.renderSurfaceParams.bChromasiting = layer->calculatedParams.chromaSitingEnabled;
314
315 surfParam.surfaceOverwriteParams.renderSurfaceParams.MemObjCtl = (layer->surf->SurfType == SURF_IN_PRIMARY) ?
316 m_surfMemCacheCtl.PrimaryInputSurfMemObjCtl :
317 m_surfMemCacheCtl.InputSurfMemObjCtl;
318
319 m_surfaceState.insert(std::make_pair(SurfaceType(SurfaceTypeFcInputLayer0 + layer->layerID), surfParam));
320
321 //update render GMM resource usage type
322 m_allocator->UpdateResourceUsageType(&layer->surf->osSurface->OsResource, MOS_HW_RESOURCE_USAGE_VP_INPUT_PICTURE_RENDER);
323
324 if (layer->surfField)
325 {
326 // Configure for Bottom Input Field
327 KERNEL_SURFACE_STATE_PARAM surfParamField = surfParam;
328
329 if (layer->iscalingEnabled)
330 {
331 surfParamField.surfaceOverwriteParams.renderSurfaceParams.bVertStrideOffs = true;
332 }
333
334 UpdateCurbeBindingIndex(SurfaceType(SurfaceTypeFcInputLayer0Field1Dual + layer->layerID), s_bindingTableIndexField[layer->layerID]);
335 m_surfaceState.insert(std::make_pair(SurfaceType(SurfaceTypeFcInputLayer0Field1Dual + layer->layerID), surfParamField));
336
337 //update render GMM resource usage type
338 m_allocator->UpdateResourceUsageType(&layer->surfField->osSurface->OsResource, MOS_HW_RESOURCE_USAGE_VP_INPUT_PICTURE_RENDER);
339 }
340
341 // Ensure the input is ready to be read
342 // Currently, mos RegisterResourcere cannot sync the 3d resource.
343 // Temporaly, call sync resource to do the sync explicitly.
344 // Sync need be done after switching context.
345 #if MOS_MEDIASOLO_SUPPORTED
346 if (!m_hwInterface->m_osInterface->bSoloInUse)
347 #endif
348 {
349 m_allocator->SyncOnResource(
350 &layer->surf->osSurface->OsResource,
351 false);
352 }
353 }
354
355 // Used for 32x32 Media walker kernel + Color fill kernel
356 // Not valid for media object.
357 bool is32MWColorFillKern =
358 (compParams.pColorFillParams != nullptr &&
359 compParams.sourceCount == 0 &&
360 m_renderHal->pHwSizes->dwSizeMediaWalkerBlock == 32);
361
362 for (i = 0; i < compParams.targetCount; ++i)
363 {
364 KERNEL_SURFACE_STATE_PARAM surfParam = {};
365
366 surfParam.surfaceOverwriteParams.updatedSurfaceParams = true;
367
368 // Only need to specify binding index in surface parameters.
369 surfParam.surfaceOverwriteParams.bindedKernel = true;
370 if (compParams.targetCount > 1 && 0 == i)
371 {
372 UpdateCurbeBindingIndex(SurfaceType(SurfaceTypeFcTarget0 + i), VP_COMP_BTINDEX_RT_SECOND);
373 }
374 else
375 {
376 UpdateCurbeBindingIndex(SurfaceType(SurfaceTypeFcTarget0 + i), VP_COMP_BTINDEX_RENDERTARGET);
377 }
378
379 SetSurfaceParams(surfParam, compParams.target[i], is32MWColorFillKern);
380
381 surfParam.surfaceOverwriteParams.renderSurfaceParams.MemObjCtl = m_surfMemCacheCtl.TargetSurfMemObjCtl;
382
383 m_surfaceState.insert(std::make_pair(SurfaceType(SurfaceTypeFcTarget0 + i), surfParam));
384
385 //update render GMM resource usage type
386 m_allocator->UpdateResourceUsageType(&compParams.target[i].surf->osSurface->OsResource, MOS_HW_RESOURCE_USAGE_VP_OUTPUT_PICTURE_RENDER);
387
388 // Ensure the output is ready to be written.
389 #if MOS_MEDIASOLO_SUPPORTED
390 if (!m_hwInterface->m_osInterface->bSoloInUse)
391 #endif
392 {
393 m_allocator->SyncOnResource(
394 &compParams.target[i].surf->osSurface->OsResource,
395 true);
396 }
397 }
398
399 if (m_kernelDllState->bEnableCMFC && m_cscCoeffPatchModeEnabled)
400 {
401 KERNEL_SURFACE_STATE_PARAM surfParam = {};
402
403 surfParam.surfaceOverwriteParams.updatedSurfaceParams = true;
404 // Only need to specify binding index in surface parameters.
405 surfParam.surfaceOverwriteParams.bindedKernel = true;
406 UpdateCurbeBindingIndex(SurfaceTypeFcCscCoeff, VP_COMP_BTINDEX_CSC_COEFF);
407
408 surfParam.surfaceOverwriteParams.updatedRenderSurfaces = true;
409 surfParam.surfaceOverwriteParams.renderSurfaceParams.Type = RENDERHAL_SURFACE_TYPE_G10;
410 surfParam.surfaceOverwriteParams.renderSurfaceParams.isOutput = false;
411 surfParam.surfaceOverwriteParams.renderSurfaceParams.Boundary = RENDERHAL_SS_BOUNDARY_ORIGINAL;
412 surfParam.surfaceOverwriteParams.renderSurfaceParams.bWidth16Align = false;
413 surfParam.surfaceOverwriteParams.renderSurfaceParams.MemObjCtl = m_surfMemCacheCtl.InputSurfMemObjCtl;
414 m_surfaceState.insert(std::make_pair(SurfaceTypeFcCscCoeff, surfParam));
415 }
416
417 return MOS_STATUS_SUCCESS;
418 }
419
PrintSearchFilter(Kdll_FilterEntry * filter,int32_t filterSize)420 MOS_STATUS VpRenderFcKernel::PrintSearchFilter(Kdll_FilterEntry *filter, int32_t filterSize)
421 {
422 VP_RENDER_CHK_NULL_RETURN(filter);
423 // Log for debug
424 for (int32_t i = 0; i < filterSize; i++)
425 {
426 VP_RENDER_NORMALMESSAGE("Kernel Search Filter %d: layer %d, format %d, cspace %d, \
427 bEnableDscale %d, bIsDitherNeeded %d, chromasiting %d, colorfill %d, dualout %d, \
428 lumakey %d, procamp %d, RenderMethod %d, sampler %d, samplerlumakey %d ",
429 i, filter[i].layer, filter[i].format, filter[i].cspace,
430 filter[i].bEnableDscale, filter[i].bIsDitherNeeded,
431 filter[i].chromasiting, filter[i].colorfill, filter[i].dualout,
432 filter[i].lumakey, filter[i].procamp, filter[i].RenderMethod, filter[i].sampler, filter[i].samplerlumakey);
433 }
434
435 return MOS_STATUS_SUCCESS;
436 }
437
438 const Kdll_Layer g_surfaceType_Layer[] =
439 {
440 Layer_None , //!< SURF_NONE
441 Layer_Background , //!< SURF_IN_BACKGROUND
442 Layer_MainVideo , //!< SURF_IN_PRIMARY
443 Layer_SubVideo , //!< SURF_IN_SECONDARY
444 Layer_SubPicture1 , //!< SURF_IN_SUBSTREAM
445 Layer_Graphics , //!< SURF_IN_GRAPHICS
446 Layer_Invalid , //!< SURF_IN_REFERENCE
447 Layer_RenderTarget //!< SURF_OUT_RENDERTARGET
448 };
449
ConvertVpSurfaceTypeToRenderSurfType(VPHAL_SURFACE_TYPE vpSurfType)450 static inline RENDERHAL_SURFACE_TYPE ConvertVpSurfaceTypeToRenderSurfType(VPHAL_SURFACE_TYPE vpSurfType)
451 {
452 switch (vpSurfType)
453 {
454 case SURF_IN_BACKGROUND:
455 return RENDERHAL_SURF_IN_BACKGROUND;
456
457 case SURF_IN_PRIMARY:
458 return RENDERHAL_SURF_IN_PRIMARY;
459
460 case SURF_IN_SUBSTREAM:
461 return RENDERHAL_SURF_IN_SUBSTREAM;
462
463 case SURF_IN_REFERENCE:
464 return RENDERHAL_SURF_IN_REFERENCE;
465
466 case SURF_OUT_RENDERTARGET:
467 return RENDERHAL_SURF_OUT_RENDERTARGET;
468
469 case SURF_NONE:
470 default:
471 return RENDERHAL_SURF_NONE;
472 }
473 }
474
ConvertVpScalingModeToRenderScalingMode(VPHAL_SCALING_MODE vpScalingMode)475 static inline RENDERHAL_SCALING_MODE ConvertVpScalingModeToRenderScalingMode(VPHAL_SCALING_MODE vpScalingMode)
476 {
477 switch (vpScalingMode)
478 {
479 case VPHAL_SCALING_NEAREST:
480 return RENDERHAL_SCALING_NEAREST;
481
482 case VPHAL_SCALING_BILINEAR:
483 return RENDERHAL_SCALING_BILINEAR;
484
485 case VPHAL_SCALING_AVS:
486 return RENDERHAL_SCALING_AVS;
487
488 default:
489 VP_RENDER_ASSERTMESSAGE("Invalid VPHAL_SCALING_MODE %d, force to nearest mode.", vpScalingMode);
490 return RENDERHAL_SCALING_NEAREST;
491 }
492 }
493
ConvertVpSampleTypeToRenderSampleType(VPHAL_SAMPLE_TYPE SampleType)494 static inline RENDERHAL_SAMPLE_TYPE ConvertVpSampleTypeToRenderSampleType(VPHAL_SAMPLE_TYPE SampleType)
495 {
496 switch (SampleType)
497 {
498 case SAMPLE_PROGRESSIVE:
499 return RENDERHAL_SAMPLE_PROGRESSIVE;
500
501 case SAMPLE_SINGLE_TOP_FIELD:
502 return RENDERHAL_SAMPLE_SINGLE_TOP_FIELD;
503
504 case SAMPLE_SINGLE_BOTTOM_FIELD:
505 return RENDERHAL_SAMPLE_SINGLE_BOTTOM_FIELD;
506
507 case SAMPLE_INTERLEAVED_EVEN_FIRST_TOP_FIELD:
508 return RENDERHAL_SAMPLE_INTERLEAVED_EVEN_FIRST_TOP_FIELD;
509
510 case SAMPLE_INTERLEAVED_EVEN_FIRST_BOTTOM_FIELD:
511 return RENDERHAL_SAMPLE_INTERLEAVED_EVEN_FIRST_BOTTOM_FIELD;
512
513 case SAMPLE_INTERLEAVED_ODD_FIRST_TOP_FIELD:
514 return RENDERHAL_SAMPLE_INTERLEAVED_ODD_FIRST_TOP_FIELD;
515
516 case SAMPLE_INTERLEAVED_ODD_FIRST_BOTTOM_FIELD:
517 return RENDERHAL_SAMPLE_INTERLEAVED_ODD_FIRST_BOTTOM_FIELD;
518
519 case SAMPLE_INVALID:
520 default:
521 VP_RENDER_ASSERTMESSAGE("Invalid VPHAL_SAMPLE_TYPE %d.\n", SampleType);
522 return RENDERHAL_SAMPLE_INVALID;
523 }
524 }
525
VpRotationModeToRenderRotationMode(VPHAL_ROTATION Rotation)526 static inline MHW_ROTATION VpRotationModeToRenderRotationMode(VPHAL_ROTATION Rotation)
527 {
528 MHW_ROTATION Mode = MHW_ROTATION_IDENTITY;
529
530 switch (Rotation)
531 {
532 case VPHAL_ROTATION_IDENTITY:
533 Mode = MHW_ROTATION_IDENTITY;
534 break;
535
536 case VPHAL_ROTATION_90:
537 Mode = MHW_ROTATION_90;
538 break;
539
540 case VPHAL_ROTATION_180:
541 Mode = MHW_ROTATION_180;
542 break;
543
544 case VPHAL_ROTATION_270:
545 Mode = MHW_ROTATION_270;
546 break;
547
548 case VPHAL_MIRROR_HORIZONTAL:
549 Mode = MHW_MIRROR_HORIZONTAL;
550 break;
551
552 case VPHAL_MIRROR_VERTICAL:
553 Mode = MHW_MIRROR_VERTICAL;
554 break;
555
556 case VPHAL_ROTATE_90_MIRROR_VERTICAL:
557 Mode = MHW_ROTATE_90_MIRROR_VERTICAL;
558 break;
559
560 case VPHAL_ROTATE_90_MIRROR_HORIZONTAL:
561 Mode = MHW_ROTATE_90_MIRROR_HORIZONTAL;
562 break;
563
564 default:
565 VP_RENDER_ASSERTMESSAGE("Invalid Rotation Angle.");
566 break;
567 }
568
569 return Mode;
570 }
571
InitRenderHalSurface(VP_FC_LAYER * src,PRENDERHAL_SURFACE renderHalSurface)572 MOS_STATUS VpRenderFcKernel::InitRenderHalSurface(
573 VP_FC_LAYER *src,
574 PRENDERHAL_SURFACE renderHalSurface)
575 {
576 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
577 //---------------------------------------
578 VP_RENDER_CHK_NULL_RETURN(src);
579 VP_RENDER_CHK_NULL_RETURN(src->surf);
580 VP_RENDER_CHK_NULL_RETURN(renderHalSurface);
581 VP_RENDER_CHK_NULL_RETURN(m_hwInterface);
582 //---------------------------------------
583
584 auto osInterface = m_hwInterface->m_osInterface;
585
586 VP_RENDER_CHK_NULL_RETURN(osInterface);
587 VP_RENDER_CHK_NULL_RETURN(osInterface->pfnGetMemoryCompressionMode);
588 VP_RENDER_CHK_NULL_RETURN(osInterface->pfnGetMemoryCompressionFormat);
589
590 MOS_ZeroMemory(renderHalSurface, sizeof(*renderHalSurface));
591
592 renderHalSurface->OsSurface = *src->surf->osSurface;
593
594 if (0 == renderHalSurface->OsSurface.dwQPitch)
595 {
596 renderHalSurface->OsSurface.dwQPitch = renderHalSurface->OsSurface.dwHeight;
597 }
598
599 VP_RENDER_CHK_STATUS_RETURN(osInterface->pfnGetMemoryCompressionMode(osInterface,
600 &src->surf->osSurface->OsResource, &renderHalSurface->OsSurface.MmcState));
601
602 if (m_hwInterface->m_waTable && MEDIA_IS_WA(m_hwInterface->m_waTable, Wa_16023363837))
603 {
604 VP_RENDER_CHK_STATUS_RETURN(InitRenderHalSurfaceCMF(src->surf->osSurface, renderHalSurface));
605 }
606 else
607 {
608 VP_RENDER_CHK_STATUS_RETURN(osInterface->pfnGetMemoryCompressionFormat(osInterface,
609 &src->surf->osSurface->OsResource, &renderHalSurface->OsSurface.CompressionFormat));
610 }
611
612 renderHalSurface->rcSrc = src->surf->rcSrc;
613 renderHalSurface->rcDst = src->surf->rcDst;
614 renderHalSurface->rcMaxSrc = src->surf->rcMaxSrc;
615 renderHalSurface->SurfType =
616 ConvertVpSurfaceTypeToRenderSurfType(src->surf->SurfType);
617 renderHalSurface->ScalingMode =
618 ConvertVpScalingModeToRenderScalingMode(src->scalingMode);
619 renderHalSurface->ChromaSiting = src->surf->ChromaSiting;
620
621 if (src->diParams != nullptr)
622 {
623 renderHalSurface->bDeinterlaceEnable = true;
624 }
625 else
626 {
627 renderHalSurface->bDeinterlaceEnable = false;
628 }
629
630 renderHalSurface->iPaletteID = src->paletteID;
631 renderHalSurface->bQueryVariance = src->queryVariance;
632 renderHalSurface->bInterlacedScaling = src->iscalingEnabled;
633 renderHalSurface->pDeinterlaceParams = (void *)src->diParams;
634 renderHalSurface->SampleType =
635 ConvertVpSampleTypeToRenderSampleType(src->surf->SampleType);
636
637 renderHalSurface->Rotation =
638 VpRotationModeToRenderRotationMode(src->rotation);
639
640 return eStatus;
641 }
642
InitRenderHalSurface(SurfaceType type,VP_SURFACE * surf,PRENDERHAL_SURFACE renderHalSurface)643 MOS_STATUS VpRenderFcKernel::InitRenderHalSurface(
644 SurfaceType type,
645 VP_SURFACE *surf,
646 PRENDERHAL_SURFACE renderHalSurface)
647 {
648 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
649
650 VP_RENDER_CHK_NULL_RETURN(surf);
651 VP_RENDER_CHK_NULL_RETURN(m_fcParams);
652
653 auto &compParams = m_fcParams->compParams;
654
655 if (type >= SurfaceTypeFcInputLayer0 && type <= SurfaceTypeFcInputLayerMax)
656 {
657 int32_t layerID = (int32_t)type - (int32_t)SurfaceTypeFcInputLayer0;
658 for (int32_t i = 0; i < (int32_t)compParams.sourceCount; ++i)
659 {
660 if (layerID != compParams.source[i].layerID)
661 {
662 continue;
663 }
664 VP_RENDER_CHK_STATUS_RETURN(InitRenderHalSurface(&compParams.source[i], renderHalSurface));
665 return MOS_STATUS_SUCCESS;
666 }
667 }
668 else if (SurfaceTypeFcTarget0 == type)
669 {
670 VP_RENDER_CHK_STATUS_RETURN(InitRenderHalSurface(&compParams.target[0], renderHalSurface));
671 return MOS_STATUS_SUCCESS;
672 }
673
674 return MOS_STATUS_UNIMPLEMENTED;
675 }
676
OcaDumpKernelInfo(MOS_COMMAND_BUFFER & cmdBuffer,MOS_CONTEXT & mosContext)677 void VpRenderFcKernel::OcaDumpKernelInfo(MOS_COMMAND_BUFFER &cmdBuffer, MOS_CONTEXT &mosContext)
678 {
679 HalOcaInterfaceNext::DumpVpKernelInfo(cmdBuffer, (MOS_CONTEXT_HANDLE)&mosContext, m_kernelId, m_kernelSearch.KernelCount, m_kernelSearch.KernelID);
680 }
681
IsRenderAlignmentWANeeded(VP_SURFACE * surface)682 bool IsRenderAlignmentWANeeded(VP_SURFACE *surface)
683 {
684 if (nullptr == surface || nullptr == surface->osSurface)
685 {
686 return false;
687 }
688
689 if (!(MOS_IS_ALIGNED(MOS_MIN((uint32_t)surface->osSurface->dwHeight, (uint32_t)surface->rcMaxSrc.bottom), 4)) &&
690 (surface->osSurface->Format == Format_NV12))
691 {
692 return true;
693 }
694 else
695 {
696 return false;
697 }
698 }
699
IsBobDiEnabled(VP_FC_LAYER * layer)700 bool IsBobDiEnabled(VP_FC_LAYER *layer)
701 {
702 if (nullptr == layer || nullptr == layer->surf || nullptr == layer->surf->osSurface)
703 {
704 return false;
705 }
706
707 // Kernel don't support inderlaced Y410/Y210 as input format
708 return (layer->diParams &&
709 (layer->surf->osSurface->Format != Format_Y410 &&
710 layer->surf->osSurface->Format != Format_Y210 &&
711 layer->surf->osSurface->Format != Format_Y216 &&
712 layer->surf->osSurface->Format != Format_Y416) &&
713 !IsRenderAlignmentWANeeded(layer->surf));
714 }
715
CalculateScale(float & scaleX,float & scaleY,RECT & rcSrc,RECT & rcDst,VPHAL_ROTATION rot)716 void CalculateScale(float &scaleX, float &scaleY, RECT &rcSrc, RECT &rcDst, VPHAL_ROTATION rot)
717 {
718 scaleX = 1.0;
719 scaleY = 1.0;
720
721 if (rcSrc.bottom - rcSrc.top == 0 || rcSrc.right - rcSrc.left == 0)
722 {
723 return;
724 }
725
726 // Source rectangle is pre-rotated, destination rectangle is post-rotated.
727 if (rot == VPHAL_ROTATION_IDENTITY ||
728 rot == VPHAL_ROTATION_180 ||
729 rot == VPHAL_MIRROR_HORIZONTAL ||
730 rot == VPHAL_MIRROR_VERTICAL)
731 {
732 scaleX = (float)(rcDst.right - rcDst.left) /
733 (float)(rcSrc.right - rcSrc.left);
734 scaleY = (float)(rcDst.bottom - rcDst.top) /
735 (float)(rcSrc.bottom - rcSrc.top);
736 }
737 else
738 {
739 // VPHAL_ROTATION_90 || VPHAL_ROTATION_270 ||
740 // VPHAL_ROTATE_90_MIRROR_HORIZONTAL || VPHAL_ROTATE_90_MIRROR_VERTICAL
741 scaleX = (float)(rcDst.right - rcDst.left) /
742 (float)(rcSrc.bottom - rcSrc.top);
743 scaleY = (float)(rcDst.bottom - rcDst.top) /
744 (float)(rcSrc.right - rcSrc.left);
745 }
746 }
747
BuildFilter(VP_COMPOSITE_PARAMS * compParams,PKdll_FilterEntry pFilter,int32_t * piFilterSize)748 MOS_STATUS VpRenderFcKernel::BuildFilter(
749 VP_COMPOSITE_PARAMS *compParams,
750 PKdll_FilterEntry pFilter,
751 int32_t* piFilterSize)
752 {
753 VP_FC_LAYER *src = nullptr;
754 VPHAL_CSPACE cspace_main = CSpace_sRGB;
755 int32_t iMaxFilterSize = 0;
756 bool bColorFill = false, bLumaKey = false;
757 int32_t i = 0;
758 PRECT pTargetRect = nullptr;
759 RENDERHAL_SURFACE RenderHalSurface = {};
760 bool bNeed = false;
761 int32_t procampCount = 0;
762 float scaleX = 1.0;
763 float scaleY = 1.0;
764 bool bPrimary = false;
765 bool bRotation = false;
766 VPHAL_PERFTAG perfTag = VPHAL_NONE;
767
768 VP_RENDER_CHK_NULL_RETURN(m_hwInterface);
769 VP_RENDER_CHK_NULL_RETURN(m_hwInterface->m_waTable);
770
771 VP_RENDER_CHK_NULL_RETURN(compParams);
772 VP_RENDER_CHK_NULL_RETURN(pFilter);
773 VP_RENDER_CHK_NULL_RETURN(piFilterSize);
774
775 cspace_main = CSpace_sRGB; // Default colorspace
776 *piFilterSize = 0;
777 iMaxFilterSize = DL_MAX_SEARCH_FILTER_SIZE - 1; // Save one entry for Render Target
778 pTargetRect = &(compParams->target[0].surf->rcDst);
779
780 // Initialize ColorFill flag
781 bColorFill = (compParams->pColorFillParams != nullptr);
782
783 for (i = 0; (i < (int)compParams->sourceCount) && (iMaxFilterSize > 0); i++)
784 {
785 if (i > 0)
786 {
787 if (!RECT1_CONTAINS_RECT2(compParams->source[0].surf->rcDst, compParams->source[i].surf->rcDst))
788 {
789 pFilter->forceToTargetColorSpace = true;
790 }
791 }
792 src = &compParams->source[i];
793
794 //--------------------------------
795 // Skip non-visible layers
796 //--------------------------------
797 if (src->layerID < 0)
798 {
799 continue;
800 }
801
802 //--------------------------------
803 // Composition path does not support conversions: BT2020->BT601/BT709, BT601/BT709 -> BT2020
804 //--------------------------------
805 if (IS_COLOR_SPACE_BT2020(src->surf->ColorSpace) &&
806 !IS_COLOR_SPACE_BT2020(compParams->target[0].surf->ColorSpace)) //BT2020->BT601/BT709
807 {
808 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_UNIMPLEMENTED);
809 }
810 else if (!IS_COLOR_SPACE_BT2020(src->surf->ColorSpace) &&
811 IS_COLOR_SPACE_BT2020(compParams->target[0].surf->ColorSpace)) //BT601/BT709 -> BT2020
812 {
813 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_UNIMPLEMENTED);
814 }
815
816 //--------------------------------
817 // Set render method
818 //--------------------------------
819 pFilter->RenderMethod = RenderMethod_MediaObjectWalker;
820
821 //--------------------------------
822 // Set CSC coefficient setting method for CoeffID_0
823 //--------------------------------
824 pFilter->SetCSCCoeffMode = m_cscCoeffPatchModeEnabled ? SetCSCCoeffMethod_Patch : SetCSCCoeffMethod_Curbe;
825
826 //--------------------------------
827 // Set current layer
828 //--------------------------------
829 pFilter->layer = g_surfaceType_Layer[src->surf->SurfType];
830
831 //--------------------------------
832 // Set layer format
833 //--------------------------------
834 pFilter->format = src->surf->osSurface->Format;
835
836 // On G8, NV12 format needs the width and Height to be a multiple of 4 for both
837 // 3D sampler and 8x8 sampler; G75 needs the width of NV12 input surface to be
838 // a multiple of 4 for 3D sampler; G9 does not has such restriction; to simplify the
839 // implementation, we enable 2 plane NV12 for all of the platform when the width
840 // or Height is not a multiple of 4. Here to set the filter format in order to select
841 // the PL2 kernel when building the combined kernel.
842 VP_RENDER_CHK_STATUS_RETURN(InitRenderHalSurface(src, &RenderHalSurface));
843 bNeed = m_renderHal->pfnIs2PlaneNV12Needed(
844 m_renderHal,
845 &RenderHalSurface,
846 RENDERHAL_SS_BOUNDARY_SRCRECT) ? true : false;
847
848 if (bNeed)
849 {
850 if (pFilter->format == Format_NV12)
851 {
852 pFilter->format = Format_NV12_UnAligned;
853 }
854 else if (pFilter->format == Format_P208)
855 {
856 pFilter->format = Format_P208_UnAligned;
857 }
858 else if (pFilter->format == Format_NV11)
859 {
860 pFilter->format = Format_NV11_UnAligned;
861 }
862 else if (pFilter->format == Format_PL2)
863 {
864 pFilter->format = Format_PL2_UnAligned;
865 }
866 }
867
868 // Y_Uoffset(Height*2 + Height/2) of RENDERHAL_PLANES_YV12 define Bitfield_Range(0, 13) on gen9+.
869 // The max value is 16383. So use PL3 kernel to avoid out of range when Y_Uoffset is larger than 16383.
870 // Use PL3 plane to avoid YV12 blending issue with DI enabled and U channel shift issue with not 4-aligned height
871 if (pFilter->format == Format_YV12)
872 {
873 if (m_renderHal->pOsInterface != nullptr &&
874 m_renderHal->pOsInterface->trinityPath == TRINITY9_ENABLED)
875 {
876 pFilter->format = Format_PL3;
877 }
878 else if (
879 (src->scalingMode != VPHAL_SCALING_AVS) &&
880 (src->iefEnabled != true) &&
881 (src->surf->SurfType != SURF_OUT_RENDERTARGET) &&
882 m_renderHal->bEnableYV12SinglePass &&
883 !src->diParams &&
884 !src->iscalingEnabled &&
885 MOS_IS_ALIGNED(src->surf->osSurface->dwHeight, 4) &&
886 ((src->surf->osSurface->dwHeight * 2 + src->surf->osSurface->dwHeight / 2) < RENDERHAL_MAX_YV12_PLANE_Y_U_OFFSET_G9))
887 {
888 pFilter->format = Format_YV12_Planar;
889 }
890 }
891
892 if (pFilter->format == Format_A8R8G8B8 ||
893 pFilter->format == Format_X8R8G8B8 ||
894 pFilter->format == Format_A8B8G8R8 ||
895 pFilter->format == Format_X8B8G8R8 ||
896 pFilter->format == Format_R5G6B5)
897 {
898 pFilter->format = Format_RGB;
899 }
900
901 //--------------------------------
902 // Set layer rotation
903 //--------------------------------
904 pFilter->rotation = src->rotation;
905 if (src->rotation != VPHAL_ROTATION_IDENTITY)
906 {
907 bRotation = true;
908 }
909
910 //--------------------------------
911 // Set layer color space
912 //--------------------------------
913 // Source is palletized, leave CSC to software (driver)
914 if (IS_PAL_FORMAT(pFilter->format))
915 {
916 pFilter->cspace = CSpace_Any;
917 }
918 // Source is YUV or RGB, set primaries
919 else
920 {
921 pFilter->cspace = src->surf->ColorSpace;
922 }
923
924 // Save color space of main video
925 if (src->surf->SurfType == SURF_IN_PRIMARY)
926 {
927 cspace_main = pFilter->cspace;
928 bPrimary = true;
929 }
930
931 //--------------------------------
932 // Set sampling mode
933 //--------------------------------
934 bLumaKey = (src->lumaKeyParams != nullptr);
935
936 // Progressive main video (except RGB format) or for RGB10, use AVS
937 if (src->useSampleUnorm)
938 {
939 pFilter->sampler = (src->iscalingEnabled || src->fieldWeaving) ? Sample_iScaling : Sample_Scaling;
940 }
941 else
942 {
943 pFilter->sampler = (src->scalingMode == VPHAL_SCALING_AVS && !IsBobDiEnabled(src)) ?
944 (src->iscalingEnabled ? Sample_iScaling_AVS : Sample_Scaling_AVS) :
945 (src->iscalingEnabled || src->fieldWeaving) ? Sample_iScaling_034x : Sample_Scaling_034x;
946 }
947
948 // When input format is Format_R10G10B10A2/Format_B10G10R10A2/Y410(kernel regards Y410 as Format_R10G10B10A2)
949 // Dscale kernel should be used
950 if (src->surf->osSurface->Format == Format_R10G10B10A2 ||
951 src->surf->osSurface->Format == Format_B10G10R10A2 ||
952 src->surf->osSurface->Format == Format_Y410 ||
953 src->surf->osSurface->Format == Format_Y416)
954 {
955 pFilter->bEnableDscale = true;
956 }
957 else
958 {
959 pFilter->bEnableDscale = false;
960 }
961
962 if (m_computeWalkerEnabled)
963 {
964 pFilter->bWaEnableDscale = true;
965 }
966 else
967 {
968 pFilter->bWaEnableDscale = MEDIA_IS_WA(m_hwInterface->m_waTable, WaEnableDscale);
969 }
970
971 //--------------------------------
972 // Set Luma key
973 //--------------------------------
974 if (bLumaKey)
975 {
976 pFilter->lumakey = LumaKey_True;
977 pFilter->samplerlumakey = src->useSamplerLumakey ? LumaKey_True : LumaKey_False;
978 }
979 else
980 {
981 pFilter->lumakey = LumaKey_False;
982 pFilter->samplerlumakey = LumaKey_False;
983 }
984
985 //--------------------------------
986 // Select function
987 //--------------------------------
988 if (src->blendingParams != nullptr)
989 {
990 switch (src->blendingParams->BlendType)
991 {
992 case BLEND_SOURCE:
993 if (IS_ALPHA4_FORMAT(src->surf->osSurface->Format))
994 {
995 pFilter->process = Process_SBlend_4bits;
996 }
997 else
998 {
999 pFilter->process = Process_SBlend;
1000 }
1001 break;
1002
1003 case BLEND_PARTIAL:
1004 pFilter->process = Process_PBlend;
1005 break;
1006
1007 case BLEND_CONSTANT:
1008 pFilter->process = Process_CBlend;
1009 break;
1010
1011 case BLEND_CONSTANT_SOURCE:
1012 pFilter->process = Process_CSBlend;
1013 break;
1014
1015 case BLEND_CONSTANT_PARTIAL:
1016 pFilter->process = Process_CPBlend;
1017 break;
1018
1019 case BLEND_XOR_MONO:
1020 pFilter->process = Process_XORComposite;
1021 break;
1022
1023 case BLEND_NONE:
1024 default:
1025 pFilter->process = Process_Composite;
1026 break;
1027 }
1028 }
1029 else
1030 {
1031 pFilter->process = Process_Composite;
1032 }
1033
1034 if (pFilter->samplerlumakey && pFilter->process != Process_Composite)
1035 {
1036 VP_RENDER_ASSERTMESSAGE("Invalid kll processing for sampler lumakey! Sampler lumakey can only work with composition.");
1037 pFilter->samplerlumakey = LumaKey_False;
1038 }
1039
1040 //--------------------------------
1041 // Set color fill
1042 //--------------------------------
1043 if (*piFilterSize == 0 &&
1044 (bLumaKey ||
1045 (bColorFill && (!RECT1_CONTAINS_RECT2(src->surf->rcDst, compParams->target[0].surf->rcDst))) ||
1046 ((pFilter->process == Process_PBlend) ||
1047 (pFilter->process == Process_CBlend) ||
1048 (pFilter->process == Process_SBlend) ||
1049 (pFilter->process == Process_CSBlend))))
1050 {
1051 pFilter->colorfill = ColorFill_True;
1052 }
1053 else
1054 {
1055 pFilter->colorfill = ColorFill_False;
1056 }
1057
1058 //--------------------------------
1059 // Set Procamp parameters
1060 //--------------------------------
1061 if (src->procampParams && src->procampParams->bEnabled)
1062 {
1063 pFilter->procamp = 0;
1064
1065 if (procampCount < VP_COMP_MAX_PROCAMP)
1066 {
1067 Kdll_Procamp procamp = {};
1068 procamp.iProcampVersion = m_Procamp[procampCount].iProcampVersion;
1069 procamp.bEnabled = true;
1070 procamp.fBrightness = src->procampParams->fBrightness;
1071 procamp.fContrast = src->procampParams->fContrast ;
1072 procamp.fHue = src->procampParams->fHue ;
1073 procamp.fSaturation = src->procampParams->fSaturation;
1074
1075 // Update procamp version and values only if changed
1076 if (memcmp(&m_Procamp[procampCount], &procamp, sizeof(procamp)))
1077 {
1078 ++procamp.iProcampVersion;
1079 m_Procamp[procampCount] = procamp;
1080 }
1081
1082 procampCount++;
1083 }
1084 else
1085 {
1086 VP_RENDER_ASSERTMESSAGE("procamp count exceed limit!");
1087 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
1088 }
1089 }
1090 else
1091 {
1092 pFilter->procamp = DL_PROCAMP_DISABLED;
1093 }
1094
1095 //--------------------------------
1096 // Set chromasiting parameters
1097 //--------------------------------
1098 pFilter->chromasiting = DL_CHROMASITING_DISABLE;
1099 if (src->calculatedParams.chromaSitingEnabled)
1100 {
1101 pFilter->chromasiting = 0;
1102 }
1103
1104 //--------------------------------
1105 // reset CSC
1106 //--------------------------------
1107 pFilter->matrix = DL_CSC_DISABLED;
1108
1109 if (0 == src->layerID)
1110 {
1111 //set first layer's scalingRatio
1112 CalculateScale(scaleX, scaleY, src->surf->rcSrc, src->surf->rcDst, src->rotation);
1113 VpKernelConfig *vpKernelConfig = m_hwInterface->m_vpPlatformInterface->GetKernelConfig();
1114 if (vpKernelConfig == nullptr)
1115 {
1116 VP_RENDER_ASSERTMESSAGE("vpKernelConfig is nullptr");
1117 }
1118 else
1119 {
1120 pFilter->ScalingRatio = vpKernelConfig->GetFilterScalingRatio(scaleX, scaleY);
1121 }
1122 }
1123
1124 // Update filter
1125 pFilter++;
1126 (*piFilterSize)++;
1127 iMaxFilterSize--;
1128 }
1129
1130 //-----------------------------------------
1131 // Set Render Target parameters
1132 //-----------------------------------------
1133 if (compParams->targetCount == 2)
1134 {
1135 pFilter->dualout = true;
1136 }
1137 auto &target = compParams->target[0];
1138 pFilter->RenderMethod = RenderMethod_MediaObjectWalker;
1139 pFilter->SetCSCCoeffMode = m_cscCoeffPatchModeEnabled ? SetCSCCoeffMethod_Patch : SetCSCCoeffMethod_Curbe;
1140 pFilter->layer = Layer_RenderTarget;
1141 pFilter->format = target.surf->osSurface->Format;
1142 pFilter->tiletype = target.surf->osSurface->TileType;
1143 pFilter->sampler = Sample_None;
1144 pFilter->process = Process_None;
1145 pFilter->procamp = DL_PROCAMP_DISABLED;
1146 pFilter->matrix = DL_CSC_DISABLED;
1147 pFilter->bFillOutputAlphaWithConstant = true;
1148
1149 //set rendertarget's scalingRatio
1150 CalculateScale(scaleX, scaleY, target.surf->rcSrc, target.surf->rcDst, target.rotation);
1151 VpKernelConfig *vpKernelConfig = m_hwInterface->m_vpPlatformInterface->GetKernelConfig();
1152 if (vpKernelConfig == nullptr)
1153 {
1154 VP_RENDER_ASSERTMESSAGE("vpKernelConfig is nullptr");
1155 }
1156 else
1157 {
1158 pFilter->ScalingRatio = vpKernelConfig->GetFilterScalingRatio(scaleX, scaleY);
1159 }
1160
1161 if (compParams->sourceCount > 0 &&
1162 compParams->source[0].surf->osSurface->Format == Format_R5G6B5 &&
1163 compParams->target[0].surf->osSurface->Format == Format_R5G6B5)
1164 {
1165 pFilter->bIsDitherNeeded = false;
1166 }else
1167 {
1168 pFilter->bIsDitherNeeded = true;
1169 }
1170
1171 if (pFilter->format == Format_A8R8G8B8 ||
1172 pFilter->format == Format_A8B8G8R8 ||
1173 pFilter->format == Format_R10G10B10A2 ||
1174 pFilter->format == Format_B10G10R10A2 ||
1175 pFilter->format == Format_AYUV ||
1176 pFilter->format == Format_Y416 ||
1177 pFilter->format == Format_Y410)
1178 {
1179 if (compParams->pCompAlpha != nullptr && compParams->sourceCount > 0 &&
1180 (compParams->pCompAlpha->AlphaMode == VPHAL_ALPHA_FILL_MODE_NONE ||
1181 compParams->pCompAlpha->AlphaMode == VPHAL_ALPHA_FILL_MODE_SOURCE_STREAM))
1182 {
1183 // When layer 0 does not have alpha channel, Save_RGB will be linked instead of
1184 // Save_ARGB, to avoid output alpha value corruption.
1185 switch (compParams->source[0].surf->osSurface->Format)
1186 {
1187 case Format_AYUV:
1188 case Format_AUYV:
1189 case Format_AI44:
1190 case Format_IA44:
1191 case Format_A8R8G8B8:
1192 case Format_A8B8G8R8:
1193 case Format_R10G10B10A2:
1194 case Format_B10G10R10A2:
1195 case Format_A8P8:
1196 case Format_A8:
1197 case Format_Y416:
1198 case Format_Y410:
1199 pFilter->bFillOutputAlphaWithConstant = false;
1200 break;
1201
1202 default:
1203 break;
1204 }
1205 }
1206 }
1207
1208 VP_RENDER_NORMALMESSAGE("pFilter->bFillOutputAlphaWithConstant = %d",
1209 pFilter->bFillOutputAlphaWithConstant ? 1 : 0);
1210
1211 //-------------------------------------------------------
1212 // Set color fill for RT. Valid for colorfill only cases
1213 //-------------------------------------------------------
1214 // If filter size is zero i.e. number of layers is zero, set colorfill to true.
1215 if (*piFilterSize == 0)
1216 {
1217 if(bColorFill)
1218 {
1219 pFilter->colorfill = ColorFill_True;
1220 }
1221 else
1222 {
1223 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_UNIMPLEMENTED);
1224 }
1225 }
1226 else
1227 {
1228 pFilter->colorfill = ColorFill_False;
1229 }
1230
1231 // Get App supplied RT format
1232 pFilter->cspace = target.surf->ColorSpace;
1233
1234 // Set performance tag for current phase
1235 // Set rotation perftag if there is a layer that needs to be rotated in
1236 // the current phase, regardless of primary or non-primary.
1237 if (bRotation)
1238 {
1239 perfTag = (VPHAL_PERFTAG)((int)VPHAL_ROT + i - 1);
1240 }
1241 else if (bPrimary)
1242 {
1243 perfTag = (VPHAL_PERFTAG)((int)VPHAL_PRI + i - 1);
1244 }
1245 else
1246 {
1247 perfTag = (VPHAL_PERFTAG)((int)VPHAL_NONE + i);
1248 }
1249
1250 auto osInterface = m_hwInterface->m_osInterface;
1251 VP_RENDER_CHK_NULL_RETURN(osInterface);
1252 VP_RENDER_CHK_NULL_RETURN(osInterface->pfnSetPerfTag);
1253
1254 osInterface->pfnSetPerfTag(osInterface, perfTag);
1255
1256 // Update filter
1257 (*piFilterSize)++;
1258
1259 return MOS_STATUS_SUCCESS;
1260 }
1261
GetKernelEntry(Kdll_CacheEntry & entry)1262 MOS_STATUS VpRenderFcKernel::GetKernelEntry(Kdll_CacheEntry &entry)
1263 {
1264 bool kernelEntryUpdate = false;
1265 VP_COMPOSITE_PARAMS &compParams = m_fcParams->compParams;
1266
1267 //============================
1268 // Create search filter for Dynamic Linking
1269 //============================
1270 MOS_ZeroMemory(m_searchFilter, sizeof(m_searchFilter));
1271
1272 // Init search filter.
1273 Kdll_FilterEntry *filter = m_searchFilter;
1274 int32_t filterSize = 0;
1275
1276 VP_RENDER_CHK_STATUS_RETURN(BuildFilter(
1277 &compParams,
1278 m_searchFilter,
1279 &filterSize));
1280
1281 PrintSearchFilter(m_searchFilter, filterSize);
1282
1283 //============================
1284 // KERNEL SEARCH
1285 //============================
1286 Kdll_State *kernelDllState = m_kernelDllState;
1287
1288 VP_RENDER_CHK_NULL_RETURN(kernelDllState);
1289
1290 uint32_t kernelHash = KernelDll_SimpleHash(filter, filterSize * sizeof(Kdll_FilterEntry));
1291 Kdll_CacheEntry *kernelEntry = KernelDll_GetCombinedKernel(kernelDllState, filter, filterSize, kernelHash);
1292
1293 if (kernelEntry)
1294 {
1295 // Update ColorFill color space.
1296 kernelDllState->colorfill_cspace = kernelEntry->colorfill_cspace;
1297
1298 // Check whether kenrel entry update needed by procamp version.
1299 auto pCscParams = kernelEntry->pCscParams;
1300 // CoeffID_0 may not be used if no csc needed for both main video and RT.
1301 auto matrixId = (uint8_t)DL_CSC_DISABLED == pCscParams->MatrixID[CoeffID_0] ?
1302 pCscParams->MatrixID[CoeffID_1] : pCscParams->MatrixID[CoeffID_0];
1303 if ((uint8_t)DL_CSC_DISABLED != matrixId && matrixId < DL_CSC_MAX)
1304 {
1305 auto pMatrix = &pCscParams->Matrix[matrixId];
1306
1307 if ((pMatrix->iProcampID != DL_PROCAMP_DISABLED) &&
1308 (pMatrix->iProcampID < VP_MAX_PROCAMP))
1309 {
1310 kernelEntryUpdate = (m_Procamp[pMatrix->iProcampID].iProcampVersion != pMatrix->iProcampVersion) ? true : false;
1311 }
1312 }
1313 else
1314 {
1315 VP_RENDER_NORMALMESSAGE("Array Index Out of Bounds.");
1316 }
1317 }
1318
1319 if (!kernelEntry || kernelEntryUpdate)
1320 {
1321 Kdll_SearchState *pSearchState = &m_kernelSearch;
1322
1323 // Remove kernel entry from kernel caches
1324 if (kernelEntryUpdate)
1325 {
1326 KernelDll_ReleaseHashEntry(&(kernelDllState->KernelHashTable), kernelEntry->wHashEntry);
1327 KernelDll_ReleaseCacheEntry(&(kernelDllState->KernelCache), kernelEntry);
1328 }
1329
1330 // Setup kernel search
1331 kernelDllState->pfnStartKernelSearch(
1332 kernelDllState,
1333 pSearchState,
1334 m_searchFilter,
1335 filterSize,
1336 1);
1337
1338 // Search kernel
1339 if (!kernelDllState->pfnSearchKernel(kernelDllState, pSearchState))
1340 {
1341 VP_RENDER_ASSERTMESSAGE("Failed to find a kernel.");
1342 return MOS_STATUS_UNKNOWN;
1343 }
1344
1345 // Build kernel
1346 if (!kernelDllState->pfnBuildKernel(kernelDllState, pSearchState))
1347 {
1348 VP_RENDER_ASSERTMESSAGE("Failed to build kernel.");
1349 return MOS_STATUS_UNKNOWN;
1350 }
1351
1352 // Load resulting kernel into kernel cache
1353 kernelEntry = KernelDll_AddKernel(
1354 kernelDllState,
1355 pSearchState,
1356 m_searchFilter,
1357 filterSize,
1358 kernelHash);
1359
1360 if (!kernelEntry)
1361 {
1362 VP_RENDER_ASSERTMESSAGE("Failed to store kernel in local cache.");
1363 return MOS_STATUS_UNKNOWN;
1364 }
1365 }
1366 else
1367 {
1368 VP_RENDER_NORMALMESSAGE("Use previous kernel list.");
1369 }
1370 m_kernelEntry = kernelEntry;
1371 entry = *kernelEntry;
1372
1373 return MOS_STATUS_SUCCESS;
1374 }
1375
GetChromaSitting(VP_SURFACE & surf)1376 VPHAL_CHROMA_SUBSAMPLING VpRenderFcKernel::GetChromaSitting(VP_SURFACE &surf)
1377 {
1378 VPHAL_CHROMA_SUBSAMPLING chromaSitingLocation = CHROMA_SUBSAMPLING_TOP_LEFT;
1379
1380 if (nullptr == surf.osSurface)
1381 {
1382 return chromaSitingLocation;
1383 }
1384
1385 // If there is no DDI setting, we use the Horizontal Left Vertical Center as default for PL2 surface.
1386 if (surf.ChromaSiting == CHROMA_SITING_NONE)
1387 {
1388 // PL2 default to Horizontal Left, Vertical Center
1389 if (IS_PL2_FORMAT(surf.osSurface->Format) || IS_PL2_FORMAT_UnAligned(surf.osSurface->Format))
1390 {
1391 chromaSitingLocation = CHROMA_SUBSAMPLING_CENTER_LEFT;
1392 }
1393 }
1394 else
1395 {
1396 // PL2, 6 positions are avalibale
1397 if (IS_PL2_FORMAT(surf.osSurface->Format) || IS_PL2_FORMAT_UnAligned(surf.osSurface->Format))
1398 {
1399 // Horizontal Left
1400 if (surf.ChromaSiting & CHROMA_SITING_HORZ_LEFT)
1401 {
1402 if (surf.ChromaSiting & CHROMA_SITING_VERT_TOP)
1403 {
1404 chromaSitingLocation = CHROMA_SUBSAMPLING_TOP_LEFT;
1405 }
1406 else if (surf.ChromaSiting & CHROMA_SITING_VERT_CENTER)
1407 {
1408 chromaSitingLocation = CHROMA_SUBSAMPLING_CENTER_LEFT;
1409 }
1410 else if (surf.ChromaSiting & CHROMA_SITING_VERT_BOTTOM)
1411 {
1412 chromaSitingLocation = CHROMA_SUBSAMPLING_BOTTOM_LEFT;
1413 }
1414 }
1415 // Horizontal Center
1416 else if (surf.ChromaSiting & CHROMA_SITING_HORZ_CENTER)
1417 {
1418 if (surf.ChromaSiting & CHROMA_SITING_VERT_TOP)
1419 {
1420 chromaSitingLocation = CHROMA_SUBSAMPLING_TOP_CENTER;
1421 }
1422 else if (surf.ChromaSiting & CHROMA_SITING_VERT_CENTER)
1423 {
1424 chromaSitingLocation = CHROMA_SUBSAMPLING_CENTER_CENTER;
1425 }
1426 else if (surf.ChromaSiting & CHROMA_SITING_VERT_BOTTOM)
1427 {
1428 chromaSitingLocation = CHROMA_SUBSAMPLING_BOTTOM_CENTER;
1429 }
1430 }
1431 }
1432 else if (IS_PA_FORMAT(surf.osSurface->Format))
1433 {
1434 // For PA surface, only (H Left, V Top) and (H Center, V top) are needed.
1435 if (surf.ChromaSiting & (CHROMA_SITING_HORZ_CENTER))
1436 {
1437 chromaSitingLocation = CHROMA_SUBSAMPLING_TOP_CENTER;
1438 }
1439 }
1440 }
1441
1442 return chromaSitingLocation;
1443 }
1444
1445 //!
1446 //! \brief calculate the Horiz Gap and Vert Gap with different sample location
1447 //! \param [in] pTarget
1448 //! Pointer to Source Surface
1449 //! \Param [in] pHorzGap
1450 //! Pointer to Horzontal Gap
1451 //! \Param [in] pVertGap
1452 //! Pointer to Vertital Gap
1453 //!
GetOffsetChromasiting(VP_SURFACE & source,float & horizGap,float & vertGap)1454 static MOS_STATUS GetOffsetChromasiting(
1455 VP_SURFACE &source,
1456 float &horizGap,
1457 float &vertGap
1458 )
1459 {
1460 horizGap = 0.0f;
1461 vertGap = 0.0f;
1462
1463 // If there is no DDI setting, we use the Horizontal Left Vertical Center as default for PL2 surface.
1464 if (source.ChromaSiting == CHROMA_SITING_NONE)
1465 {
1466 // PL2 default to Horizontal Left, Vertical Center
1467 if (IS_PL2_FORMAT(source.osSurface->Format) || IS_PL2_FORMAT_UnAligned(source.osSurface->Format))
1468 {
1469 vertGap = (float)(0.5f / source.osSurface->dwHeight);
1470 }
1471 }
1472 else
1473 {
1474 // PL2, 6 positions are available
1475 if (IS_PL2_FORMAT(source.osSurface->Format) || IS_PL2_FORMAT_UnAligned(source.osSurface->Format))
1476 {
1477 // Horizontal Left
1478 if (source.ChromaSiting & CHROMA_SITING_HORZ_LEFT)
1479 {
1480 if (source.ChromaSiting & CHROMA_SITING_VERT_CENTER)
1481 {
1482 vertGap = (float)(0.5f / source.osSurface->dwHeight);
1483 }
1484 else if (source.ChromaSiting & CHROMA_SITING_VERT_BOTTOM)
1485 {
1486 vertGap = (float)(1.0f / source.osSurface->dwHeight);
1487 }
1488 }
1489 // Horizontal Center
1490 else if (source.ChromaSiting & CHROMA_SITING_HORZ_CENTER)
1491 {
1492 horizGap = (float)(0.5f / source.osSurface->dwWidth);
1493 if (source.ChromaSiting & CHROMA_SITING_VERT_CENTER)
1494 {
1495 vertGap = (float)(0.5f / source.osSurface->dwHeight);
1496 }
1497 else if (source.ChromaSiting & CHROMA_SITING_VERT_BOTTOM)
1498 {
1499 vertGap = (float)(1.0f / source.osSurface->dwHeight);
1500 }
1501 }
1502 }
1503 else if (IS_PA_FORMAT(source.osSurface->Format))
1504 {
1505 // For PA surface, only (H Left, V Top) and (H Center, V top) are needed.
1506 if (source.ChromaSiting & (CHROMA_SITING_HORZ_CENTER))
1507 {
1508 horizGap = (float)(0.5f / source.osSurface->dwWidth);
1509 }
1510 }
1511 }
1512
1513 return MOS_STATUS_SUCCESS;
1514 }
1515
Set3DSamplerStatus(VP_FC_LAYER & layer,VP_FC_CURBE_DATA & curbeData)1516 MOS_STATUS Set3DSamplerStatus(
1517 VP_FC_LAYER &layer,
1518 VP_FC_CURBE_DATA &curbeData)
1519 {
1520 if (layer.layerID > 7)
1521 {
1522 VP_RENDER_ASSERTMESSAGE("Invalid parameter.");
1523 return MOS_STATUS_INVALID_PARAMETER;
1524 }
1525
1526 if (VPHAL_SCALING_AVS == layer.scalingMode)
1527 {
1528 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
1529 }
1530
1531 // When the bit being set to 1, the items of samplerIndex 4, 5, 6 will be used, otherwise
1532 // the items of samplerIndex 1, 2, 3 will be used.
1533 if (VPHAL_SCALING_BILINEAR == layer.scalingMode)
1534 {
1535 curbeData.DW14.Sampler3DStateSetSelection |= (1 << layer.layerID);
1536 }
1537
1538 return MOS_STATUS_SUCCESS;
1539 }
1540
InitCscInCurbeData()1541 MOS_STATUS VpRenderFcKernel::InitCscInCurbeData()
1542 {
1543 Kdll_CSC_Matrix *matrix = nullptr;
1544 for (uint32_t i = 0; i < DL_CSC_MAX; i++)
1545 {
1546 if (m_kernelEntry->pCscParams->Matrix[i].iCoeffID == CoeffID_0)
1547 {
1548 matrix = &m_kernelEntry->pCscParams->Matrix[i];
1549 break;
1550 }
1551 }
1552
1553 // Load CSC matrix
1554 if (matrix && matrix->bInUse && !m_cscCoeffPatchModeEnabled)
1555 {
1556 // Procamp is present
1557 if (matrix->iProcampID != DL_PROCAMP_DISABLED &&
1558 matrix->iProcampID < m_maxProcampEntries)
1559 {
1560 // Get Procamp parameter - update matrix only if Procamp is changed
1561 auto procamp = &m_Procamp[matrix->iProcampID];
1562 if (matrix->iProcampVersion != procamp->iProcampVersion)
1563 {
1564 KernelDll_UpdateCscCoefficients(m_kernelDllState, matrix);
1565 }
1566 }
1567
1568 // CSC coeff from static parameter only applies to primary layer
1569 if (matrix->iCoeffID == CoeffID_0)
1570 {
1571 int16_t* pCoeff = matrix->Coeff;
1572
1573 m_curbeData.DW00.CscConstantC0 = *(pCoeff++);
1574 m_curbeData.DW00.CscConstantC1 = *(pCoeff++);
1575 m_curbeData.DW01.CscConstantC2 = *(pCoeff++);
1576 m_curbeData.DW01.CscConstantC3 = *(pCoeff++);
1577 m_curbeData.DW02.CscConstantC4 = *(pCoeff++);
1578 m_curbeData.DW02.CscConstantC5 = *(pCoeff++);
1579 m_curbeData.DW03.CscConstantC6 = *(pCoeff++);
1580 m_curbeData.DW03.CscConstantC7 = *(pCoeff++);
1581 m_curbeData.DW04.CscConstantC8 = *(pCoeff++);
1582 m_curbeData.DW04.CscConstantC9 = *(pCoeff++);
1583 m_curbeData.DW05.CscConstantC10 = *(pCoeff++);
1584 m_curbeData.DW05.CscConstantC11 = *pCoeff;
1585 }
1586 else
1587 {
1588 VP_RENDER_ASSERTMESSAGE("CSC matrix coefficient id is non-zero.");
1589 return MOS_STATUS_INVALID_PARAMETER;
1590 }
1591 }
1592 return MOS_STATUS_SUCCESS;
1593 }
1594
InitLayerInCurbeData(VP_FC_LAYER * layer)1595 MOS_STATUS VpRenderFcKernel::InitLayerInCurbeData(VP_FC_LAYER *layer)
1596 {
1597 VP_PUBLIC_CHK_NULL_RETURN(layer);
1598 VP_RENDER_CHK_NULL_RETURN(layer->surfaceEntries[0]);
1599
1600 float horizgap = 0;
1601 float vertgap = 0;
1602 uint32_t bitDepth = 0;
1603 uint16_t &alpha = layer->calculatedParams.alpha;
1604 float &fStepX = layer->calculatedParams2.fStepX;
1605 float &fStepY = layer->calculatedParams2.fStepY;
1606 float &fOriginX = layer->calculatedParams2.fOriginX;
1607 float &fOriginY = layer->calculatedParams2.fOriginY;
1608 RECT &clipedDstRect = layer->calculatedParams.clipedDstRect; // Clipped dest rectangle
1609
1610 if (layer->lumaKeyParams != nullptr)
1611 {
1612 VP_RENDER_NORMALMESSAGE("LumaLow %d, LumaHigh %d",
1613 layer->lumaKeyParams->LumaLow,
1614 layer->lumaKeyParams->LumaHigh);
1615
1616 m_curbeData.DW14.LumakeyLowThreshold = layer->lumaKeyParams->LumaLow;
1617 m_curbeData.DW14.LumakeyHighThreshold = layer->lumaKeyParams->LumaHigh;
1618
1619 }
1620
1621 if (layer->xorComp)
1622 {
1623 // set mono-chroma XOR composite specific curbe data. re-calculate fStep due to 1 bit = 1 pixel.
1624 m_curbeData.DW10.MonoXORCompositeMask = layer->surf->rcDst.left & 0x7;
1625 }
1626
1627 VP_RENDER_NORMALMESSAGE("Scaling Info: layer %d, width %d, height, %d, rotation %d, alpha %d, shiftX %f, shiftY %f, scaleX %f, scaleY %f, offsetX %f, offsetY %f, stepX %f, stepY %f, originX %f, originY %f",
1628 layer->layerID, layer->surfaceEntries[0]->dwWidth, layer->surfaceEntries[0]->dwHeight, layer->rotation, alpha, layer->calculatedParams.fShiftX, layer->calculatedParams.fShiftY,
1629 layer->calculatedParams.fScaleX, layer->calculatedParams.fScaleY, layer->calculatedParams.fOffsetX, layer->calculatedParams.fOffsetY, fStepX, fStepY, fOriginX, fOriginY);
1630
1631 VP_RENDER_NORMALMESSAGE("Scaling Info: layer %d, DestXTopLeft %d, DestYTopLeft %d, DestXBottomRight %d, DestYBottomRight %d",
1632 layer->layerID, clipedDstRect.left, clipedDstRect.top, clipedDstRect.right - 1, clipedDstRect.bottom - 1);
1633
1634 VP_RENDER_NORMALMESSAGE("Scaling Info: layer %d, chromaSitingEnabled %d, isChromaUpSamplingNeeded %d, isChromaDownSamplingNeeded %d",
1635 layer->layerID, layer->calculatedParams.chromaSitingEnabled, layer->calculatedParams.isChromaUpSamplingNeeded, layer->calculatedParams.isChromaDownSamplingNeeded);
1636
1637 MT_LOG6(MT_VP_HAL_FC_SCALINGINFO, MT_NORMAL, MT_VP_HAL_FC_LAYER, layer->layerID, MT_RECT_LEFT, clipedDstRect.left, MT_RECT_TOP, clipedDstRect.top, MT_RECT_RIGHT, clipedDstRect.right - 1, MT_RECT_BOTTOM, clipedDstRect.bottom - 1, MT_VP_BLT_CHROMASITING, layer->calculatedParams.chromaSitingEnabled);
1638
1639 switch (layer->layerID)
1640 {
1641 case 0:
1642 // Gen9+ uses HW based Rotation
1643 m_curbeData.DW10.RotationAngleofLayer0 = layer->rotation;
1644 m_curbeData.DW13.ColorFill_A = alpha;
1645 m_curbeData.DW16.HorizontalScalingStepRatioLayer0 = fStepX;
1646 m_curbeData.DW24.VerticalScalingStepRatioLayer0 = fStepY;
1647 m_curbeData.DW40.HorizontalFrameOriginLayer0 = fOriginX;
1648 m_curbeData.DW32.VerticalFrameOriginLayer0 = fOriginY;
1649 // GRF7.0
1650 m_curbeData.DW48.DestXTopLeftLayer0 = clipedDstRect.left;
1651 m_curbeData.DW48.DestYTopLeftLayer0 = clipedDstRect.top;
1652 // GRF8.0
1653 m_curbeData.DW56.DestXBottomRightLayer0 = clipedDstRect.right - 1;
1654 m_curbeData.DW56.DestYBottomRightLayer0 = clipedDstRect.bottom - 1;
1655 // GRF9.0
1656 m_curbeData.DW64.MainVideoXScalingStepLeft = fStepX;
1657
1658 // ChromasitingUOffset and ChromasitingVOffset are only for 3D Sampler use case
1659 horizgap = 0;
1660 vertgap = 0;
1661 GetOffsetChromasiting(*layer->surf, horizgap, vertgap);
1662 if (IS_PL2_FORMAT(layer->surf->osSurface->Format))
1663 {
1664
1665 m_curbeData.DW11.ChromasitingUOffset = (float)((0.5f / (layer->surf->osSurface->dwWidth)) - horizgap);
1666 m_curbeData.DW12.ChromasitingVOffset = (float)((1.0f / (layer->surf->osSurface->dwHeight)) - vertgap);
1667 }
1668 else if (layer->surf->osSurface->Format == Format_YUY2)
1669 {
1670 m_curbeData.DW11.ChromasitingUOffset = (float)((1.0f / (layer->surf->osSurface->dwWidth)) - horizgap);
1671 m_curbeData.DW12.ChromasitingVOffset = (float)((0.5f / (layer->surf->osSurface->dwHeight)) - vertgap);
1672 }
1673
1674 VP_RENDER_NORMALMESSAGE("Scaling Info: layer 0, ChromasitingUOffset %f, ChromasitingVOffset %f",
1675 m_curbeData.DW11.ChromasitingUOffset, m_curbeData.DW12.ChromasitingVOffset);
1676
1677 // Set output depth.
1678 bitDepth = VpHalDDIUtils::GetSurfaceBitDepth(layer->surf->osSurface->Format);
1679 m_curbeData.DW07.OutputDepth = VP_COMP_P010_DEPTH;
1680 if (bitDepth && !(layer->surf->osSurface->Format == Format_P010 || layer->surf->osSurface->Format == Format_Y210))
1681 {
1682 m_curbeData.DW07.OutputDepth = VP_COMP_SOURCE_DEPTH - bitDepth;
1683 }
1684
1685 if (layer->iscalingEnabled)
1686 {
1687 m_curbeData.DW12.TopBottomDelta = (float)(1.0 / (layer->surf->rcSrc.bottom - layer->surf->rcSrc.top) -
1688 1.0 / (layer->surf->rcDst.bottom - layer->surf->rcDst.top));
1689 if (layer->surf->SampleType == SAMPLE_INTERLEAVED_EVEN_FIRST_TOP_FIELD ||
1690 layer->surf->SampleType == SAMPLE_INTERLEAVED_ODD_FIRST_TOP_FIELD)
1691 {
1692 //use the cropping size, not the surface size
1693 m_curbeData.DW12.TopBottomDelta = 0 - m_curbeData.DW12.TopBottomDelta;
1694 }
1695 }
1696 break;
1697 case 1:
1698 m_curbeData.DW10.RotationAngleofLayer1 = layer->rotation;
1699 m_curbeData.DW06.ConstantBlendingAlphaLayer1 = alpha;
1700 m_curbeData.DW17.HorizontalScalingStepRatioLayer1 = fStepX;
1701 m_curbeData.DW25.VerticalScalingStepRatioLayer1 = fStepY;
1702 m_curbeData.DW41.HorizontalFrameOriginLayer1 = fOriginX;
1703 m_curbeData.DW33.VerticalFrameOriginLayer1 = fOriginY;
1704 // GRF7.1
1705 m_curbeData.DW49.DestXTopLeftLayer1 = clipedDstRect.left;
1706 m_curbeData.DW49.DestYTopLeftLayer1 = clipedDstRect.top;
1707 // GRF8.1
1708 m_curbeData.DW57.DestXBottomRightLayer1 = clipedDstRect.right - 1;
1709 m_curbeData.DW57.DestYBottomRightLayer1 = clipedDstRect.bottom - 1;
1710 break;
1711 case 2:
1712 m_curbeData.DW10.RotationAngleofLayer2 = layer->rotation;
1713 m_curbeData.DW06.ConstantBlendingAlphaLayer2 = alpha;
1714 m_curbeData.DW18.HorizontalScalingStepRatioLayer2 = fStepX;
1715 m_curbeData.DW26.VerticalScalingStepRatioLayer2 = fStepY;
1716 m_curbeData.DW42.HorizontalFrameOriginLayer2 = fOriginX;
1717 m_curbeData.DW34.VerticalFrameOriginLayer2 = fOriginY;
1718 // GRF7.2
1719 m_curbeData.DW50.DestXTopLeftLayer2 = clipedDstRect.left;
1720 m_curbeData.DW50.DestYTopLeftLayer2 = clipedDstRect.top;
1721 // GRF8.2
1722 m_curbeData.DW58.DestXBottomRightLayer2 = clipedDstRect.right - 1;
1723 m_curbeData.DW58.DestYBottomRightLayer2 = clipedDstRect.bottom - 1;
1724 break;
1725 case 3:
1726 m_curbeData.DW10.RotationAngleofLayer3 = layer->rotation;
1727 m_curbeData.DW06.ConstantBlendingAlphaLayer3 = alpha;
1728 m_curbeData.DW19.HorizontalScalingStepRatioLayer3 = fStepX;
1729 m_curbeData.DW27.VerticalScalingStepRatioLayer3 = fStepY;
1730 m_curbeData.DW43.HorizontalFrameOriginLayer3 = fOriginX;
1731 m_curbeData.DW35.VerticalFrameOriginLayer3 = fOriginY;
1732 // GRF7.3
1733 m_curbeData.DW51.DestXTopLeftLayer3 = clipedDstRect.left;
1734 m_curbeData.DW51.DestYTopLeftLayer3 = clipedDstRect.top;
1735 // GRF8.3
1736 m_curbeData.DW59.DestXBottomRightLayer3 = clipedDstRect.right - 1;
1737 m_curbeData.DW59.DestYBottomRightLayer3 = clipedDstRect.bottom - 1;
1738 break;
1739 case 4:
1740 m_curbeData.DW10.RotationAngleofLayer4 = layer->rotation;
1741 m_curbeData.DW06.ConstantBlendingAlphaLayer4 = alpha;
1742 m_curbeData.DW20.HorizontalScalingStepRatioLayer4 = fStepX;
1743 m_curbeData.DW28.VerticalScalingStepRatioLayer4 = fStepY;
1744 m_curbeData.DW44.HorizontalFrameOriginLayer4 = fOriginX;
1745 m_curbeData.DW36.VerticalFrameOriginLayer4 = fOriginY;
1746 // GRF7.4
1747 m_curbeData.DW52.DestXTopLeftLayer4 = clipedDstRect.left;
1748 m_curbeData.DW52.DestYTopLeftLayer4 = clipedDstRect.top;
1749 // GRF8.4
1750 m_curbeData.DW60.DestXBottomRightLayer4 = clipedDstRect.right - 1;
1751 m_curbeData.DW60.DestYBottomRightLayer4 = clipedDstRect.bottom - 1;
1752 break;
1753 case 5:
1754 m_curbeData.DW10.RotationAngleofLayer5 = layer->rotation;
1755 m_curbeData.DW07.ConstantBlendingAlphaLayer5 = alpha;
1756 m_curbeData.DW21.HorizontalScalingStepRatioLayer5 = fStepX;
1757 m_curbeData.DW29.VerticalScalingStepRatioLayer5 = fStepY;
1758 m_curbeData.DW45.HorizontalFrameOriginLayer5 = fOriginX;
1759 m_curbeData.DW37.VerticalFrameOriginLayer5 = fOriginY;
1760 // GRF7.5
1761 m_curbeData.DW53.DestXTopLeftLayer5 = clipedDstRect.left;
1762 m_curbeData.DW53.DestYTopLeftLayer5 = clipedDstRect.top;
1763 // GRF8.5
1764 m_curbeData.DW61.DestXBottomRightLayer5 = clipedDstRect.right - 1;
1765 m_curbeData.DW61.DestYBottomRightLayer5 = clipedDstRect.bottom - 1;
1766 break;
1767 case 6:
1768 m_curbeData.DW10.RotationAngleofLayer6 = layer->rotation;
1769 m_curbeData.DW07.ConstantBlendingAlphaLayer6 = alpha;
1770 m_curbeData.DW22.HorizontalScalingStepRatioLayer6 = fStepX;
1771 m_curbeData.DW30.VerticalScalingStepRatioLayer6 = fStepY;
1772 m_curbeData.DW46.HorizontalFrameOriginLayer6 = fOriginX;
1773 m_curbeData.DW38.VerticalFrameOriginLayer6 = fOriginY;
1774 // GRF7.6
1775 m_curbeData.DW54.DestXTopLeftLayer6 = clipedDstRect.left;
1776 m_curbeData.DW54.DestYTopLeftLayer6 = clipedDstRect.top;
1777 // GRF8.6
1778 m_curbeData.DW62.DestXBottomRightLayer6 = clipedDstRect.right - 1;
1779 m_curbeData.DW62.DestYBottomRightLayer6 = clipedDstRect.bottom - 1;
1780 break;
1781 case 7:
1782 m_curbeData.DW10.RotationAngleofLayer7 = layer->rotation;
1783 m_curbeData.DW07.ConstantBlendingAlphaLayer7 = alpha;
1784 m_curbeData.DW23.HorizontalScalingStepRatioLayer7 = fStepX;
1785 m_curbeData.DW31.VerticalScalingStepRatioLayer7 = fStepY;
1786 m_curbeData.DW47.HorizontalFrameOriginLayer7 = fOriginX;
1787 m_curbeData.DW39.VerticalFrameOriginLayer7 = fOriginY;
1788 // GRF7.7
1789 m_curbeData.DW55.DestXTopLeftLayer7 = clipedDstRect.left;
1790 m_curbeData.DW55.DestYTopLeftLayer7 = clipedDstRect.top;
1791 // GRF8.7
1792 m_curbeData.DW63.DestXBottomRightLayer7 = clipedDstRect.right - 1;
1793 m_curbeData.DW63.DestYBottomRightLayer7 = clipedDstRect.bottom - 1;
1794 break;
1795 default:
1796 VP_RENDER_ASSERTMESSAGE("Invalid layer.");
1797 break;
1798 }
1799
1800 Set3DSamplerStatus(*layer, m_curbeData);
1801
1802 return MOS_STATUS_SUCCESS;
1803 }
1804
InitFcCurbeData()1805 MOS_STATUS VpRenderFcKernel::InitFcCurbeData()
1806 {
1807 VP_COMPOSITE_PARAMS &compParams = m_fcParams->compParams;
1808
1809 MOS_ZeroMemory(&m_curbeData, sizeof(m_curbeData));
1810 m_curbeData.DW07.PointerToInlineParameters = 7;
1811
1812 uint32_t destRectWidth = 0, destRectHeight = 0;
1813
1814 // set destination width and height
1815 destRectWidth = compParams.target[0].surf->osSurface->dwWidth;
1816 destRectHeight = compParams.target[0].surf->osSurface->dwHeight;
1817
1818 m_curbeData.DW08.DestinationRectangleWidth = destRectWidth;
1819 m_curbeData.DW08.DestinationRectangleHeight = destRectHeight;
1820
1821 uint32_t layerCount = 0;
1822 for (uint32_t i = 0; i < compParams.sourceCount; ++i)
1823 {
1824 auto &layer = compParams.source[i];
1825
1826 if (-1 == layer.layerID)
1827 {
1828 VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
1829 }
1830
1831 VP_PUBLIC_CHK_STATUS_RETURN(InitLayerInCurbeData(&layer));
1832 }
1833
1834 // Normalize scaling factors for all layers
1835 // Ratio of Horizontal Scaling Step to Video X Scaling Step
1836 // Since NLAS is ZBBed, CM FC kernels simplified scaling factor calculation, no need to normalize here
1837 if (!m_kernelDllState->bEnableCMFC)
1838 {
1839 float stepXLayer0 = m_curbeData.DW16.HorizontalScalingStepRatioLayer0;
1840 m_curbeData.DW16.HorizontalScalingStepRatioLayer0 = 1;
1841 m_curbeData.DW17.HorizontalScalingStepRatioLayer1 /= stepXLayer0;
1842 m_curbeData.DW18.HorizontalScalingStepRatioLayer2 /= stepXLayer0;
1843 m_curbeData.DW19.HorizontalScalingStepRatioLayer3 /= stepXLayer0;
1844 m_curbeData.DW20.HorizontalScalingStepRatioLayer4 /= stepXLayer0;
1845 m_curbeData.DW21.HorizontalScalingStepRatioLayer5 /= stepXLayer0;
1846 m_curbeData.DW22.HorizontalScalingStepRatioLayer6 /= stepXLayer0;
1847 m_curbeData.DW23.HorizontalScalingStepRatioLayer7 /= stepXLayer0;
1848 }
1849
1850 auto &target = compParams.target[0];
1851
1852 // Set ChromaSitting
1853 m_curbeData.DW10.ChromaSitingLocation = GetChromaSitting(*target.surf);
1854
1855 if (compParams.sourceCount > 0)
1856 {
1857 // "IEF Bypass" bit is changed to "MBZ" bit for Gen12 in HW interface, so driver should always set "Bypass IEF" to be 0 in CURBE.
1858 m_curbeData.DW09.IEFByPassEnable = false;
1859 }
1860
1861 // Set alpha calculation flag. The bit definitions are different for GEN8 and GEN9+.
1862 // Set Bit-18
1863 m_curbeData.DW09.AlphaChannelCalculation = compParams.bAlphaCalculateEnable ? true : false;
1864 // Set flag to swap R and B in Save_RGB/ARGB if target format is Format_A8B8G8R8/Format_X8B8G8R8/Format_B10G10R10A2.
1865 // No need for RGBP/BGRP, since they are 3 plane format, kenel change the RB channel by different plane order
1866 m_curbeData.DW09.ChannelSwap = ((target.surf->osSurface->Format == Format_A8B8G8R8) ||
1867 (target.surf->osSurface->Format == Format_X8B8G8R8) ||
1868 (target.surf->osSurface->Format == Format_B10G10R10A2)) ? 1 : 0;
1869
1870 VP_PUBLIC_CHK_STATUS_RETURN(InitCscInCurbeData());
1871 VP_PUBLIC_CHK_STATUS_RETURN(InitColorFillInCurbeData());
1872 VP_PUBLIC_CHK_STATUS_RETURN(InitOutputFormatInCurbeData());
1873
1874 if (compParams.targetCount > 1)
1875 {
1876 m_curbeData.DW09.DualOutputMode = 1;
1877 }
1878
1879 // GRF 9.1-4
1880 m_curbeData.DW65.VideoStepDeltaForNonLinearRegion = 0;
1881 m_curbeData.DW66.StartofLinearScalingInPixelPositionC0 = 0;
1882 m_curbeData.DW66.StartofRHSNonLinearScalingInPixelPositionC1 = 0;
1883 m_curbeData.DW67.MainVideoXScalingStepCenter = 0;
1884 m_curbeData.DW68.MainVideoXScalingStepRight = 0;
1885
1886 if (compParams.targetCount > 1)
1887 {
1888 // Horizontal and Vertical base on non-rotated in case of dual output
1889 m_curbeData.DW69.DestHorizontalBlockOrigin =
1890 (uint16_t)compParams.target[1].surf->rcDst.left;
1891 m_curbeData.DW69.DestVerticalBlockOrigin =
1892 (uint16_t)compParams.target[1].surf->rcDst.top;
1893 }
1894 else
1895 {
1896 m_curbeData.DW69.DestHorizontalBlockOrigin =
1897 (uint16_t)compParams.target[0].surf->rcDst.left;
1898 m_curbeData.DW69.DestVerticalBlockOrigin =
1899 (uint16_t)compParams.target[0].surf->rcDst.top;
1900 }
1901
1902 if (!MOS_IS_ALIGNED(m_curbeData.DW69.DestHorizontalBlockOrigin, 4) || !MOS_IS_ALIGNED(m_curbeData.DW69.DestVerticalBlockOrigin, 4))
1903 {
1904 VP_RENDER_NORMALMESSAGE("Block_start_x or Block_start_y is not DW align, Block_start_x = %d, Block_start_y = %d",
1905 m_curbeData.DW69.DestHorizontalBlockOrigin,
1906 m_curbeData.DW69.DestVerticalBlockOrigin);
1907 }
1908
1909
1910 PrintCurbeData(m_curbeData);
1911 return MOS_STATUS_SUCCESS;
1912 }
1913
InitColorFillInCurbeData()1914 MOS_STATUS VpRenderFcKernel::InitColorFillInCurbeData()
1915 {
1916 Kdll_FilterEntry *filter = m_kernelEntry->pFilter;
1917 int32_t filterSize = m_kernelEntry->iFilterSize;
1918 int32_t i = 0;
1919 VPHAL_COLOR_SAMPLE_8 srcColor = {};
1920 MEDIA_CSPACE srcCspace = CSpace_None;
1921 MEDIA_CSPACE dstCspace = CSpace_None;
1922 VP_COMPOSITE_PARAMS &compParams = m_fcParams->compParams;
1923 // Set Background color (use cspace of first layer)
1924 if (compParams.pColorFillParams)
1925 {
1926 srcColor.dwValue = compParams.pColorFillParams->Color;
1927
1928 // get src and dst colorspaces
1929 srcCspace = compParams.pColorFillParams->CSpace;
1930
1931 // if iscale enabled, set colorspace to render target color space
1932 if (filter->sampler == Sample_iScaling || filter->sampler == Sample_iScaling_034x || filter->sampler == Sample_iScaling_AVS)
1933 {
1934 dstCspace = CSpace_None;
1935 // find the filter of render target and set dstCspace to render target color space
1936 if (Layer_RenderTarget != filter[filterSize - 1].layer)
1937 {
1938 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
1939 }
1940 dstCspace = filter[filterSize - 1].cspace;
1941
1942 if (dstCspace == CSpace_None) // if color space is invalid return false
1943 {
1944 VP_RENDER_ASSERTMESSAGE("Failed to assign dst color spcae for iScale case.");
1945 return MOS_STATUS_INVALID_PARAMETER;
1946 }
1947 }
1948 else // use selected cspace by kdll
1949 {
1950 dstCspace = m_kernelDllState->colorfill_cspace;
1951 }
1952
1953 // Convert BG color only if not done before. CSC is expensive!
1954 if ((m_srcColor.dwValue != srcColor.dwValue) ||
1955 (m_srcCspace != srcCspace) ||
1956 (m_dstCspace != dstCspace))
1957 {
1958 VpUtils::GetCscMatrixForRender8Bit(&m_dstColor, &srcColor, srcCspace, dstCspace);
1959
1960 // store the values for next iteration
1961 m_srcColor = srcColor;
1962 m_srcCspace = srcCspace;
1963 m_dstCspace = dstCspace;
1964 }
1965
1966 // Set BG color
1967 if (KernelDll_IsCspace(dstCspace, CSpace_RGB))
1968 {
1969 m_curbeData.DW13.ColorFill_R = m_dstColor.R;
1970 m_curbeData.DW13.ColorFill_G = m_dstColor.G;
1971 m_curbeData.DW13.ColorFill_B = m_dstColor.B;
1972 }
1973 else
1974 {
1975 m_curbeData.DW13.ColorFill_Y = m_dstColor.Y;
1976 m_curbeData.DW13.ColorFill_U = m_dstColor.U;
1977 m_curbeData.DW13.ColorFill_V = m_dstColor.V;
1978 }
1979 }
1980 return MOS_STATUS_SUCCESS;
1981 }
1982
1983 //!
1984 //! \brief Set packed YUV component offsets
1985 //! \details Accoring to the format of the surface, set packed YUV component offsets
1986 //! \param [in] format
1987 //! The format of the surface
1988 //! \param [in,out] pOffsetY
1989 //! The offset of Y
1990 //! \param [in,out] pOffsetU
1991 //! The offset of U
1992 //! \param [in,out] pOffsetV
1993 //! The offset of V
1994 //! \return MOS_STATUS
1995 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
1996 //!
VpSetYUVComponents(MOS_FORMAT format,uint8_t * pOffsetY,uint8_t * pOffsetU,uint8_t * pOffsetV)1997 MOS_STATUS VpSetYUVComponents(
1998 MOS_FORMAT format,
1999 uint8_t* pOffsetY,
2000 uint8_t* pOffsetU,
2001 uint8_t* pOffsetV)
2002 {
2003 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2004
2005 switch (format)
2006 {
2007 case Format_PA:
2008 case Format_YUY2:
2009 case Format_YUYV:
2010 *pOffsetY = 0;
2011 *pOffsetU = 1;
2012 *pOffsetV = 3;
2013 break;
2014
2015 case Format_UYVY:
2016 *pOffsetY = 1;
2017 *pOffsetU = 0;
2018 *pOffsetV = 2;
2019 break;
2020
2021 case Format_YVYU:
2022 *pOffsetY = 0;
2023 *pOffsetU = 3;
2024 *pOffsetV = 1;
2025 break;
2026
2027 case Format_VYUY:
2028 *pOffsetY = 1;
2029 *pOffsetU = 2;
2030 *pOffsetV = 0;
2031 break;
2032
2033 case Format_Y210:
2034 *pOffsetY = 0;
2035 *pOffsetU = 2;
2036 *pOffsetV = 6;
2037 break;
2038
2039 default:
2040 VP_RENDER_ASSERTMESSAGE("Unknown Packed YUV Format.");
2041 eStatus = MOS_STATUS_UNKNOWN;
2042 }
2043
2044 return eStatus;
2045 }
2046
2047 /*
2048 | |---------------------------------------------------------------------|
2049 | | Alpha fill mode table |
2050 | |---------------------------------------------------------------------|
2051 | | ALPHA_FILL_MODE_NONE |
2052 | |---------------------------------------------------------------------|
2053 | | Input | Output | Kernel used |
2054 | | Has Alpha | Has Alpha | Save_ARGB |
2055 | | No Alpha | Has Alpha |Save_RGB(ALpha frm app)|
2056 | | Has Alpha | No Alpha | Save_RGB(0xff) |
2057 | | No Alpha | No Alpha | Save_RGB(0xff) |
2058 | |---------------------------------------------------------------------|
2059 | | ALPHA_FILL_MODE_OPAQUE |
2060 | |---------------------------------------------------------------------|
2061 | | Input | Output | Kernel used |
2062 | | Has Alpha | Has Alpha | Save_RGB(0xff) |
2063 | | No Alpha | Has Alpha | Save_RGB(0xff) |
2064 | | Has Alpha | No Alpha | Save_RGB(0xff) |
2065 | | No Alpha | No Alpha | Save_RGB(0xff) |
2066 | |---------------------------------------------------------------------|
2067 | | ALPHA_FILL_MODE_BACKGROUND |
2068 | |---------------------------------------------------------------------|
2069 | | Input | Output | Kernel used |
2070 | | Has Alpha | Has Alpha | Save_RGB(BG Alpha) |
2071 | | No Alpha | Has Alpha | Save_RGB(BG Alpha) |
2072 | | Has Alpha | No Alpha | Save_RGB(0xff) |
2073 | | No Alpha | No Alpha | Save_RGB(0xff) |
2074 | |---------------------------------------------------------------------|
2075 | | ALPHA_FILL_MODE_SOURCE_STREAM |
2076 | |---------------------------------------------------------------------|
2077 | | Input | Output | Kernel used |
2078 | | Has Alpha | Has Alpha | Save_ARGB |
2079 | | No Alpha | Has Alpha | Save_RGB(0xff) |
2080 | | Has Alpha | No Alpha | Save_RGB(0xff) |
2081 | | No Alpha | No Alpha | Save_RGB(0xff) |
2082 | |---------------------------------------------------------------------|
2083 */
2084
InitOutputFormatInCurbeData()2085 MOS_STATUS VpRenderFcKernel::InitOutputFormatInCurbeData()
2086 {
2087 VP_COMPOSITE_PARAMS &compParams = m_fcParams->compParams;
2088 // Set output format
2089 MOS_FORMAT outputFormat = compParams.target[0].surf->osSurface->Format;
2090 Kdll_FilterEntry *filter = m_kernelEntry->pFilter;
2091 int32_t filterSize = m_kernelEntry->iFilterSize;
2092
2093 filter = filter + filterSize - 1;
2094
2095 if (Layer_RenderTarget != filter->layer)
2096 {
2097 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
2098 }
2099
2100 if (IS_PA_FORMAT(outputFormat) &&
2101 outputFormat != Format_Y410 &&
2102 outputFormat != Format_Y416)
2103 {
2104 VpSetYUVComponents(
2105 outputFormat,
2106 &(m_curbeData.DW15.DestinationPackedYOffset),
2107 &(m_curbeData.DW15.DestinationPackedUOffset),
2108 &(m_curbeData.DW15.DestinationPackedVOffset));
2109 }
2110 else if (filter->bFillOutputAlphaWithConstant && compParams.pCompAlpha != nullptr)
2111 {
2112 if (Format_Y416 == filter->format)
2113 {
2114 // DestinationRGBFormat is 8 bits while aplha channel of Y416 is 16 bits. High
2115 // 8 bits will be ignored for Y416. Support need be added if real use case exists.
2116 VP_RENDER_NORMALMESSAGE("Alpha data in high 8 bits will be ignored for Y416.");
2117 }
2118
2119 switch (compParams.pCompAlpha->AlphaMode)
2120 {
2121 case VPHAL_ALPHA_FILL_MODE_NONE:
2122 if (filter->format == Format_A8R8G8B8 ||
2123 filter->format == Format_A8B8G8R8 ||
2124 filter->format == Format_R10G10B10A2 ||
2125 filter->format == Format_B10G10R10A2 ||
2126 filter->format == Format_AYUV ||
2127 filter->format == Format_Y410 ||
2128 filter->format == Format_Y416)
2129 {
2130 m_curbeData.DW15.DestinationRGBFormat = (uint8_t)(0xff * compParams.pCompAlpha->fAlpha);
2131 }
2132 else
2133 {
2134 m_curbeData.DW15.DestinationRGBFormat = 0xff;
2135 }
2136 // For color fill only case, pass through alpha value
2137 if (compParams.pColorFillParams && 0 == compParams.sourceCount)
2138 {
2139 m_curbeData.DW15.DestinationRGBFormat = m_dstColor.A;
2140 }
2141 break;
2142
2143 case VPHAL_ALPHA_FILL_MODE_BACKGROUND:
2144 m_curbeData.DW15.DestinationRGBFormat = m_dstColor.A;
2145 break;
2146
2147 // For VPHAL_ALPHA_FILL_MODE_SOURCE_STREAM, bFillOutputAlphaWithConstant is set to false
2148 // during VpRenderFcKernel::BuildFilter.
2149 case VPHAL_ALPHA_FILL_MODE_SOURCE_STREAM:
2150 case VPHAL_ALPHA_FILL_MODE_OPAQUE:
2151 default:
2152 m_curbeData.DW15.DestinationRGBFormat = 0xff;
2153 break;
2154 }
2155 }
2156 else
2157 {
2158 m_curbeData.DW15.DestinationRGBFormat = 0xff;
2159 }
2160
2161 return MOS_STATUS_SUCCESS;
2162 }
2163
InitCscInDpCurbeData()2164 MOS_STATUS VpRenderFcKernel::InitCscInDpCurbeData()
2165 {
2166 Kdll_CSC_Matrix *matrix = nullptr;
2167 for (uint32_t i = 0; i < DL_CSC_MAX; i++)
2168 {
2169 if (m_kernelEntry->pCscParams->Matrix[i].iCoeffID == CoeffID_0)
2170 {
2171 matrix = &m_kernelEntry->pCscParams->Matrix[i];
2172 break;
2173 }
2174 }
2175
2176 // Load CSC matrix
2177 if (matrix && matrix->bInUse && !m_cscCoeffPatchModeEnabled)
2178 {
2179 // Procamp is present
2180 if (matrix->iProcampID != DL_PROCAMP_DISABLED &&
2181 matrix->iProcampID < m_maxProcampEntries)
2182 {
2183 // Get Procamp parameter - update matrix only if Procamp is changed
2184 auto procamp = &m_Procamp[matrix->iProcampID];
2185 if (matrix->iProcampVersion != procamp->iProcampVersion)
2186 {
2187 KernelDll_UpdateCscCoefficients(m_kernelDllState, matrix);
2188 }
2189 }
2190
2191 // CSC coeff from static parameter only applies to primary layer
2192 if (matrix->iCoeffID == CoeffID_0)
2193 {
2194 int16_t* pCoeff = matrix->Coeff;
2195
2196 m_curbeDataDp.DW0.CscConstantC0 = *(pCoeff++);
2197 m_curbeDataDp.DW0.CscConstantC1 = *(pCoeff++);
2198
2199 m_curbeDataDp.DW1.CscConstantC2 = *(pCoeff++);
2200 m_curbeDataDp.DW1.CscConstantC3 = *(pCoeff++);
2201 m_curbeDataDp.DW2.CscConstantC4 = *(pCoeff++);
2202 m_curbeDataDp.DW2.CscConstantC5 = *(pCoeff++);
2203 m_curbeDataDp.DW3.CscConstantC6 = *(pCoeff++);
2204 m_curbeDataDp.DW3.CscConstantC7 = *(pCoeff++);
2205 m_curbeDataDp.DW4.CscConstantC8 = *(pCoeff++);
2206 m_curbeDataDp.DW4.CscConstantC9 = *(pCoeff++);
2207 m_curbeDataDp.DW5.CscConstantC10 = *(pCoeff++);
2208 m_curbeDataDp.DW5.CscConstantC11 = *pCoeff;
2209 }
2210 else
2211 {
2212 VP_RENDER_ASSERTMESSAGE("CSC matrix coefficient id is non-zero.");
2213 return MOS_STATUS_INVALID_PARAMETER;
2214 }
2215 }
2216 return MOS_STATUS_SUCCESS;
2217 }
2218
InitFcDpBasedCurbeData()2219 MOS_STATUS VpRenderFcKernel::InitFcDpBasedCurbeData()
2220 {
2221 VP_COMPOSITE_PARAMS &compParams = m_fcParams->compParams;
2222
2223 if (compParams.sourceCount != 1 || compParams.targetCount != 1)
2224 {
2225 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
2226 }
2227
2228 MOS_ZeroMemory(&m_curbeDataDp, sizeof(m_curbeDataDp));
2229
2230 uint32_t destRectWidth = 0, destRectHeight = 0;
2231
2232 // set destination width and height
2233 destRectWidth = compParams.target[0].surf->osSurface->dwWidth;
2234 destRectHeight = compParams.target[0].surf->osSurface->dwHeight;
2235
2236 auto &layer = compParams.source[0];
2237 layer.layerID = 0;
2238
2239 VP_RENDER_CHK_NULL_RETURN(layer.surfaceEntries[0]);
2240
2241 if (layer.numOfSurfaceEntries > 0)
2242 {
2243 m_curbeDataDp.DW6.InputPictureWidth = layer.surfaceEntries[0]->dwWidth -1;
2244 m_curbeDataDp.DW6.InputPictureHeight = layer.surfaceEntries[0]->dwHeight -1;
2245 }
2246
2247 float &fStepX = layer.calculatedParams2.fStepX;
2248 float &fStepY = layer.calculatedParams2.fStepY;
2249 float &fOriginX = layer.calculatedParams2.fOriginX;
2250 float &fOriginY = layer.calculatedParams2.fOriginY;
2251 RECT &clipedDstRect = layer.calculatedParams.clipedDstRect; // Clipped dest rectangle
2252
2253 m_curbeDataDp.DW7.DestinationRectangleWidth = destRectWidth;
2254 m_curbeDataDp.DW7.DestinationRectangleHeight = destRectHeight;
2255 m_curbeDataDp.DW9.HorizontalScalingStepRatioLayer0 = m_kernelDllState->bEnableCMFC ? fStepX : 1;
2256 m_curbeDataDp.DW10.VerticalScalingStepRatioLayer0 = fStepY;
2257 m_curbeDataDp.DW11.HorizontalFrameOriginLayer0 = fOriginX;
2258 m_curbeDataDp.DW12.VerticalFrameOriginLayer0 = fOriginY;
2259 // GRF7.0
2260 m_curbeDataDp.DW13.DestXTopLeftLayer0 = clipedDstRect.left;
2261 m_curbeDataDp.DW13.DestYTopLeftLayer0 = clipedDstRect.top;
2262 // GRF8.0
2263 m_curbeDataDp.DW14.DestXBottomRightLayer0 = clipedDstRect.right - 1;
2264 m_curbeDataDp.DW14.DestYBottomRightLayer0 = clipedDstRect.bottom - 1;
2265
2266 // Load CSC matrix
2267 VP_RENDER_CHK_STATUS_RETURN(InitCscInDpCurbeData());
2268
2269 auto target = compParams.target[0];
2270
2271 if (target.surf->osSurface->Format == Format_A8R8G8B8)
2272 {
2273 m_curbeDataDp.DW15.waFlag = 1;
2274 }
2275 return MOS_STATUS_SUCCESS;
2276 }
2277
GetCurbeState(void * & curbe,uint32_t & curbeLength)2278 MOS_STATUS VpRenderFcKernel::GetCurbeState(void*& curbe, uint32_t& curbeLength)
2279 {
2280 VP_FUNC_CALL();
2281 MT_LOG1(MT_VP_HAL_FC_GET_CURBE_STATE, MT_NORMAL, MT_FUNC_START, 1);
2282
2283 VpKernelConfig *vpKernelConfig = m_hwInterface->m_vpPlatformInterface->GetKernelConfig();
2284 VP_RENDER_CHK_NULL_RETURN(vpKernelConfig);
2285
2286 if (vpKernelConfig->IsDpFcKernelEnabled())
2287 {
2288 VP_RENDER_CHK_STATUS_RETURN(InitFcDpBasedCurbeData());
2289 // DataPort used FC kernel case
2290 curbe = &m_curbeDataDp;
2291 curbeLength = sizeof(VP_FC_DP_BASED_CURBE_DATA);
2292 }
2293 else
2294 {
2295 VP_RENDER_CHK_STATUS_RETURN(InitFcCurbeData());
2296 curbe = &m_curbeData;
2297 curbeLength = sizeof(VP_FC_CURBE_DATA);
2298 }
2299 MT_LOG2(MT_VP_HAL_FC_GET_CURBE_STATE, MT_NORMAL, MT_FUNC_END, 1, MT_MOS_STATUS, MOS_STATUS_SUCCESS);
2300
2301 return MOS_STATUS_SUCCESS;
2302 }
2303
GetInlineDataSize()2304 uint32_t VpRenderFcKernel::GetInlineDataSize()
2305 {
2306 VP_FUNC_CALL();
2307 int32_t inlineDataSize = 0;
2308 VP_COMPOSITE_PARAMS &compParams = m_fcParams->compParams;
2309
2310 // Set Inline Data Size
2311 if (compParams.sourceCount <= 3)
2312 {
2313 // compParams.sourceCount == 0 case is only for colorfill only cases.
2314 // Colorfill uses inverted layer 0 block mask to determine colorfill region.
2315 inlineDataSize = 8 * sizeof(uint32_t);
2316 }
2317 else if (compParams.sourceCount <= 8)
2318 {
2319 inlineDataSize = (compParams.sourceCount + 5) * sizeof(uint32_t);
2320 }
2321 else
2322 {
2323 VP_RENDER_ASSERTMESSAGE("%s, Invalid Number of Layers.");
2324 }
2325
2326 return inlineDataSize;
2327 }
2328
GetWalkerSetting(KERNEL_WALKER_PARAMS & walkerParam,KERNEL_PACKET_RENDER_DATA & renderData)2329 MOS_STATUS VpRenderFcKernel::GetWalkerSetting(KERNEL_WALKER_PARAMS& walkerParam, KERNEL_PACKET_RENDER_DATA &renderData)
2330 {
2331 VP_FUNC_CALL();
2332
2333 MOS_ZeroMemory(&walkerParam, sizeof(walkerParam));
2334
2335 walkerParam.iBindingTable = renderData.bindingTable;
2336 walkerParam.iMediaID = renderData.mediaID;
2337 walkerParam.iCurbeOffset = renderData.iCurbeOffset;
2338 walkerParam.iCurbeLength = renderData.iCurbeLength;
2339 // iBlocksX/iBlocksY will be calculated during prepare walker parameters in RenderCmdPacket
2340 walkerParam.calculateBlockXYByAlignedRect = true;
2341
2342 if (0 == m_fcParams->compParams.targetCount || m_fcParams->compParams.targetCount > 1)
2343 {
2344 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
2345 }
2346
2347 walkerParam.alignedRect = m_fcParams->compParams.target[0].surf->rcDst;
2348
2349 if (m_fcParams->compParams.sourceCount == 1 &&
2350 m_fcParams->compParams.source[0].surf->osSurface->TileType == MOS_TILE_LINEAR &&
2351 (m_fcParams->compParams.source[0].rotation == VPHAL_ROTATION_90 ||
2352 m_fcParams->compParams.source[0].rotation == VPHAL_ROTATION_270))
2353 {
2354 walkerParam.isVerticalPattern = true;
2355 }
2356
2357 walkerParam.bSyncFlag = 0;
2358 walkerParam.isGroupStartInvolvedInGroupSize = true;
2359
2360 return MOS_STATUS_SUCCESS;
2361 }
2362
IsEufusionBypassed()2363 bool VpRenderFcKernel::IsEufusionBypassed()
2364 {
2365 VP_COMPOSITE_PARAMS &compParams = m_fcParams->compParams;
2366 VpUserFeatureControl *userFeatureControl = m_hwInterface->m_userFeatureControl;
2367
2368 if (nullptr == userFeatureControl || !userFeatureControl->IsEufusionBypassWaEnabled())
2369 {
2370 VP_RENDER_NORMALMESSAGE("EufusionBypass is not needed.");
2371 return false;
2372 }
2373
2374 if (compParams.sourceCount > 1)
2375 {
2376 VP_RENDER_NORMALMESSAGE("EufusionBypass is needed for multi-layer composition case.");
2377 return true;
2378 }
2379 else if (1 == compParams.sourceCount)
2380 {
2381 VP_FC_LAYER &layer = compParams.source[0];
2382 bool bColorFill = false;
2383 bool bRotation = false;
2384 bool bLumakey = false;
2385 if (compParams.pColorFillParams != nullptr)
2386 {
2387 // To avoid colorfill + rotation output cropution when Eu fusion is on.
2388 bColorFill = (!RECT1_CONTAINS_RECT2(layer.surf->rcDst, compParams.target->surf->rcDst)) ? true : false;
2389 bRotation = (layer.rotation != VPHAL_ROTATION_IDENTITY) ? true : false;
2390 bLumakey = layer.lumaKeyParams ? true : false;
2391
2392 if ((bColorFill && bRotation) || bLumakey)
2393 {
2394 VP_RENDER_NORMALMESSAGE("EufusionBypass is needed for colorfill + rotation case or lumakey case.");
2395 return true;
2396 }
2397 else
2398 {
2399 return false;
2400 }
2401 }
2402 else
2403 {
2404 return false;
2405 }
2406 }
2407 else
2408 {
2409 return false;
2410 }
2411
2412 return false;
2413 }
2414
PrintCurbeData(VP_FC_CURBE_DATA & curbeData)2415 void VpRenderFcKernel::PrintCurbeData(VP_FC_CURBE_DATA &curbeData)
2416 {
2417 #if (_DEBUG || _RELEASE_INTERNAL)
2418 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW00.Value = %x", curbeData.DW00.Value);
2419 VP_RENDER_VERBOSEMESSAGE("CurbeData: CscConstantC0 = %x, CscConstantC1 = %x, LocalDifferenceThresholdU = %x, LocalDifferenceThresholdV = %x, SobelEdgeThresholdU = %x, SobelEdgeThresholdV = %x",
2420 curbeData.DW00.CscConstantC0,
2421 curbeData.DW00.CscConstantC1,
2422 curbeData.DW00.LocalDifferenceThresholdU,
2423 curbeData.DW00.LocalDifferenceThresholdV,
2424 curbeData.DW00.SobelEdgeThresholdU,
2425 curbeData.DW00.SobelEdgeThresholdV);
2426 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW01.Value = %x", curbeData.DW01.Value);
2427 VP_RENDER_VERBOSEMESSAGE("CurbeData: CscConstantC2 = %x, CscConstantC3 = %x, HistoryInitialValueU = %x, HistoryInitialValueV = %x, HistoryMaxU = %x, HistoryMaxV = %x",
2428 curbeData.DW01.CscConstantC2,
2429 curbeData.DW01.CscConstantC3,
2430 curbeData.DW01.HistoryInitialValueU,
2431 curbeData.DW01.HistoryInitialValueV,
2432 curbeData.DW01.HistoryMaxU,
2433 curbeData.DW01.HistoryMaxV);
2434 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW02.Value = %x", curbeData.DW02.Value);
2435 VP_RENDER_VERBOSEMESSAGE("CurbeData: CscConstantC4 = %x, CscConstantC5 = %x, HistoryDeltaU = %x, HistoryDeltaV = %x, NSADThresholdU = %x, DNSADThresholdV = %x",
2436 curbeData.DW02.CscConstantC4,
2437 curbeData.DW02.CscConstantC5,
2438 curbeData.DW02.HistoryDeltaU,
2439 curbeData.DW02.HistoryDeltaV,
2440 curbeData.DW02.DNSADThresholdU,
2441 curbeData.DW02.DNSADThresholdV);
2442 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW03.Value = %x", curbeData.DW03.Value);
2443 VP_RENDER_VERBOSEMESSAGE("CurbeData: CscConstantC6 = %x, CscConstantC7 = %x, DNTDThresholdU = %x, HistoryDeltaV = %x, DNLTDThresholdU = %x, DNLTDThresholdV = %x",
2444 curbeData.DW03.CscConstantC6,
2445 curbeData.DW03.CscConstantC7,
2446 curbeData.DW03.DNTDThresholdU,
2447 curbeData.DW03.DNTDThresholdV,
2448 curbeData.DW03.DNLTDThresholdU,
2449 curbeData.DW03.DNLTDThresholdV);
2450 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW04.Value = %x", curbeData.DW04.Value);
2451 VP_RENDER_VERBOSEMESSAGE("CurbeData: CscConstantC8 = %x, CscConstantC9 = %x",
2452 curbeData.DW04.CscConstantC8,
2453 curbeData.DW04.CscConstantC9);
2454 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW05.Value = %x", curbeData.DW05.Value);
2455 VP_RENDER_VERBOSEMESSAGE("CurbeData: CscConstantC10 = %x, CscConstantC11 = %x",
2456 curbeData.DW05.CscConstantC10,
2457 curbeData.DW05.CscConstantC11);
2458 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW06.Value = %x", curbeData.DW06.Value);
2459 VP_RENDER_VERBOSEMESSAGE("CurbeData: ConstantBlendingAlphaLayer1 = %d, ConstantBlendingAlphaLayer2 = %d, ConstantBlendingAlphaLayer3 = %d, ConstantBlendingAlphaLayer4 = %d, HalfStatisticsSurfacePitch = %d, StatisticsSurfaceHeight = %d",
2460 curbeData.DW06.ConstantBlendingAlphaLayer1,
2461 curbeData.DW06.ConstantBlendingAlphaLayer2,
2462 curbeData.DW06.ConstantBlendingAlphaLayer3,
2463 curbeData.DW06.ConstantBlendingAlphaLayer4,
2464 curbeData.DW06.HalfStatisticsSurfacePitch,
2465 curbeData.DW06.StatisticsSurfaceHeight);
2466 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW07.Value = %x", curbeData.DW07.Value);
2467 VP_RENDER_VERBOSEMESSAGE("CurbeData: ConstantBlendingAlphaLayer5 = %d, ConstantBlendingAlphaLayer6 = %d, ConstantBlendingAlphaLayer7 = %d, PointerToInlineParameters = %d, ConstantBlendingAlphaLayer51 = %d, ConstantBlendingAlphaLayer61 = %d, ConstantBlendingAlphaLayer71 = %d, OutputDepth = %d, TopFieldFirst = %d",
2468 curbeData.DW07.ConstantBlendingAlphaLayer5,
2469 curbeData.DW07.ConstantBlendingAlphaLayer6,
2470 curbeData.DW07.ConstantBlendingAlphaLayer7,
2471 curbeData.DW07.PointerToInlineParameters,
2472 curbeData.DW07.ConstantBlendingAlphaLayer51,
2473 curbeData.DW07.ConstantBlendingAlphaLayer61,
2474 curbeData.DW07.ConstantBlendingAlphaLayer71,
2475 curbeData.DW07.OutputDepth,
2476 curbeData.DW07.TopFieldFirst);
2477 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW08.Value = %x", curbeData.DW08.Value);
2478 VP_RENDER_VERBOSEMESSAGE("CurbeData: DestinationRectangleWidth = %d, DestinationRectangleHeight = %d",
2479 curbeData.DW08.DestinationRectangleWidth,
2480 curbeData.DW08.DestinationRectangleHeight);
2481 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW09.Value = %x", curbeData.DW09.Value);
2482 VP_RENDER_VERBOSEMESSAGE("CurbeData: RotationMirrorMode = %d, RotationMirrorAllLayer = %d, DualOutputMode = %d, ChannelSwap = %d",
2483 curbeData.DW09.RotationMirrorMode,
2484 curbeData.DW09.RotationMirrorAllLayer,
2485 curbeData.DW09.DualOutputMode,
2486 curbeData.DW09.ChannelSwap);
2487 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW10.Value = %x", curbeData.DW10.Value);
2488 VP_RENDER_VERBOSEMESSAGE("CurbeData: ChromaSitingLocation = %d",
2489 curbeData.DW10.ChromaSitingLocation);
2490 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW11.Value = %x", curbeData.DW11.Value);
2491 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW12.Value = %x", curbeData.DW12.Value);
2492 VP_RENDER_VERBOSEMESSAGE("CurbeData: ColorProcessingEnable = %d, MessageFormat = %d, ColorProcessingStatePointer = %x",
2493 curbeData.DW12.ColorProcessingEnable,
2494 curbeData.DW12.MessageFormat,
2495 curbeData.DW12.ColorProcessingStatePointer);
2496 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW13.Value = %x", curbeData.DW13.Value);
2497 VP_RENDER_VERBOSEMESSAGE("CurbeData: ColorFill_R = %x, ColorFill_G = %x, ColorFill_B = %x, ColorFill_A = %x, ColorFill_V = %x, ColorFill_Y = %x, ColorFill_U = %x",
2498 curbeData.DW13.ColorFill_R,
2499 curbeData.DW13.ColorFill_G,
2500 curbeData.DW13.ColorFill_B,
2501 curbeData.DW13.ColorFill_A,
2502 curbeData.DW13.ColorFill_V,
2503 curbeData.DW13.ColorFill_Y,
2504 curbeData.DW13.ColorFill_U);
2505 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW14.Value = %x", curbeData.DW14.Value);
2506 VP_RENDER_VERBOSEMESSAGE("CurbeData: LumakeyLowThreshold = %x, LumakeyHighThreshold = %x, NLASEnable = %d, Reserved = %d",
2507 curbeData.DW14.LumakeyLowThreshold,
2508 curbeData.DW14.LumakeyHighThreshold,
2509 curbeData.DW14.NLASEnable,
2510 curbeData.DW14.Sampler3DStateSetSelection);
2511 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW15.Value = %x", curbeData.DW15.Value);
2512 VP_RENDER_VERBOSEMESSAGE("CurbeData: DestinationPackedYOffset = %d, DestinationPackedUOffset = %d, DestinationPackedVOffset = %d, DestinationRGBFormat = %d",
2513 curbeData.DW15.DestinationPackedYOffset,
2514 curbeData.DW15.DestinationPackedUOffset,
2515 curbeData.DW15.DestinationPackedVOffset,
2516 curbeData.DW15.DestinationRGBFormat);
2517 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW16.Value = %x", curbeData.DW16.Value);
2518 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalScalingStepRatioLayer0 = 0x%x",
2519 curbeData.DW16.HorizontalScalingStepRatioLayer0);
2520 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW17.Value = %x", curbeData.DW17.Value);
2521 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalScalingStepRatioLayer1 = 0x%x",
2522 curbeData.DW17.HorizontalScalingStepRatioLayer1);
2523 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW18.Value = %x", curbeData.DW18.Value);
2524 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalScalingStepRatioLayer2 = 0x%x",
2525 curbeData.DW18.HorizontalScalingStepRatioLayer2);
2526 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW19.Value = %x", curbeData.DW19.Value);
2527 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalScalingStepRatioLayer3 = 0x%x",
2528 curbeData.DW19.HorizontalScalingStepRatioLayer3);
2529 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW20.Value = %x", curbeData.DW20.Value);
2530 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalScalingStepRatioLayer4 = 0x%x",
2531 curbeData.DW20.HorizontalScalingStepRatioLayer4);
2532 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW21.Value = %x", curbeData.DW21.Value);
2533 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalScalingStepRatioLayer5 = 0x%x",
2534 curbeData.DW21.HorizontalScalingStepRatioLayer5);
2535 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW22.Value = %x", curbeData.DW22.Value);
2536 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalScalingStepRatioLayer6 = 0x%x",
2537 curbeData.DW22.HorizontalScalingStepRatioLayer6);
2538 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW23.Value = %x", curbeData.DW23.Value);
2539 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalScalingStepRatioLayer7 = 0x%x",
2540 curbeData.DW23.HorizontalScalingStepRatioLayer7);
2541 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW24.Value = %x", curbeData.DW24.Value);
2542 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalScalingStepRatioLayer0 = 0x%x, SourcePackedYOffset = %d, SourcePackedUOffset = %d, SourcePackedVOffset = %d, Reserved = %d",
2543 curbeData.DW24.VerticalScalingStepRatioLayer0,
2544 curbeData.DW24.SourcePackedYOffset,
2545 curbeData.DW24.SourcePackedUOffset,
2546 curbeData.DW24.SourcePackedVOffset,
2547 curbeData.DW24.Reserved);
2548 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW25.Value = %x", curbeData.DW25.Value);
2549 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalScalingStepRatioLayer1 = 0x%x",
2550 curbeData.DW25.VerticalScalingStepRatioLayer1);
2551 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW26.Value = %x", curbeData.DW26.Value);
2552 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalScalingStepRatioLayer2 = 0x%x, HorizontalFrameOriginOffset = %d, VerticalFrameOriginOffset = %d",
2553 curbeData.DW26.VerticalScalingStepRatioLayer2,
2554 curbeData.DW26.HorizontalFrameOriginOffset,
2555 curbeData.DW26.VerticalFrameOriginOffset);
2556 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW27.Value = %x", curbeData.DW27.Value);
2557 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalScalingStepRatioLayer3 = 0x%x",
2558 curbeData.DW27.VerticalScalingStepRatioLayer3);
2559 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW28.Value = %x", curbeData.DW28.Value);
2560 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalScalingStepRatioLayer4 = 0x%x",
2561 curbeData.DW28.VerticalScalingStepRatioLayer4);
2562 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW29.Value = %x", curbeData.DW29.Value);
2563 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalScalingStepRatioLayer5 = 0x%x",
2564 curbeData.DW29.VerticalScalingStepRatioLayer5);
2565 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW30.Value = %x", curbeData.DW30.Value);
2566 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalScalingStepRatioLayer6 = 0x%x",
2567 curbeData.DW30.VerticalScalingStepRatioLayer6);
2568 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW31.Value = %x", curbeData.DW31.Value);
2569 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalScalingStepRatioLayer7 = 0x%x",
2570 curbeData.DW31.VerticalScalingStepRatioLayer7);
2571 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW32.Value = %x", curbeData.DW32.Value);
2572 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalFrameOriginLayer0 = 0x%x",
2573 curbeData.DW32.VerticalFrameOriginLayer0);
2574 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW33.Value = %x", curbeData.DW33.Value);
2575 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalFrameOriginLayer1 = 0x%x",
2576 curbeData.DW33.VerticalFrameOriginLayer1);
2577 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW34.Value = %x", curbeData.DW34.Value);
2578 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalFrameOriginLayer2 = 0x%x",
2579 curbeData.DW34.VerticalFrameOriginLayer2);
2580 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW35.Value = %x", curbeData.DW35.Value);
2581 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalFrameOriginLayer3 = 0x%x",
2582 curbeData.DW35.VerticalFrameOriginLayer3);
2583 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW36.Value = %x", curbeData.DW36.Value);
2584 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalFrameOriginLayer4 = 0x%x",
2585 curbeData.DW36.VerticalFrameOriginLayer4);
2586 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW37.Value = %x", curbeData.DW37.Value);
2587 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalFrameOriginLayer5 = 0x%x",
2588 curbeData.DW37.VerticalFrameOriginLayer5);
2589 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW38.Value = %x", curbeData.DW38.Value);
2590 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalFrameOriginLayer6 = 0x%x",
2591 curbeData.DW38.VerticalFrameOriginLayer6);
2592 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW39.Value = %x", curbeData.DW39.Value);
2593 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalFrameOriginLayer7 = 0x%x",
2594 curbeData.DW39.VerticalFrameOriginLayer7);
2595 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW40.Value = %x", curbeData.DW40.Value);
2596 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalFrameOriginLayer0 = 0x%x",
2597 curbeData.DW40.HorizontalFrameOriginLayer0);
2598 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW41.Value = %x", curbeData.DW41.Value);
2599 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalFrameOriginLayer1 = 0x%x",
2600 curbeData.DW41.HorizontalFrameOriginLayer1);
2601 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW42.Value = %x", curbeData.DW42.Value);
2602 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalFrameOriginLayer2 = 0x%x",
2603 curbeData.DW42.HorizontalFrameOriginLayer2);
2604 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW43.Value = %x", curbeData.DW43.Value);
2605 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalFrameOriginLayer3 = 0x%x",
2606 curbeData.DW43.HorizontalFrameOriginLayer3);
2607 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW44.Value = %x", curbeData.DW44.Value);
2608 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalFrameOriginLayer4 = 0x%x",
2609 curbeData.DW44.HorizontalFrameOriginLayer4);
2610 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW45.Value = %x", curbeData.DW45.Value);
2611 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalFrameOriginLayer5 = 0x%x",
2612 curbeData.DW45.HorizontalFrameOriginLayer5);
2613 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW46.Value = %x", curbeData.DW46.Value);
2614 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalFrameOriginLayer6 = 0x%x",
2615 curbeData.DW46.HorizontalFrameOriginLayer6);
2616 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW47.Value = %x", curbeData.DW47.Value);
2617 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalFrameOriginLayer7 = 0x%x",
2618 curbeData.DW47.HorizontalFrameOriginLayer7);
2619 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW48.Value = %x", curbeData.DW48.Value);
2620 VP_RENDER_VERBOSEMESSAGE("CurbeData: DestXTopLeftLayer0 = %d, DestYTopLeftLayer0 = %d",
2621 curbeData.DW48.DestXTopLeftLayer0,
2622 curbeData.DW48.DestYTopLeftLayer0);
2623 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW49.Value = %x", curbeData.DW49.Value);
2624 VP_RENDER_VERBOSEMESSAGE("CurbeData: DestXTopLeftLayer1 = %d, DestYTopLeftLayer1 = %d",
2625 curbeData.DW49.DestXTopLeftLayer1,
2626 curbeData.DW49.DestYTopLeftLayer1);
2627 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW50.Value = %x", curbeData.DW50.Value);
2628 VP_RENDER_VERBOSEMESSAGE("CurbeData: DestXTopLeftLayer2 = %d, DestYTopLeftLayer2 = %d",
2629 curbeData.DW50.DestXTopLeftLayer2,
2630 curbeData.DW50.DestYTopLeftLayer2);
2631 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW51.Value = %x", curbeData.DW51.Value);
2632 VP_RENDER_VERBOSEMESSAGE("CurbeData: DestXTopLeftLayer3 = %d, DestYTopLeftLayer3 = %d",
2633 curbeData.DW51.DestXTopLeftLayer3,
2634 curbeData.DW51.DestYTopLeftLayer3);
2635 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW52.Value = %x", curbeData.DW52.Value);
2636 VP_RENDER_VERBOSEMESSAGE("CurbeData: DestXTopLeftLayer4 = %d, DestYTopLeftLayer4 = %d",
2637 curbeData.DW52.DestXTopLeftLayer4,
2638 curbeData.DW52.DestYTopLeftLayer4);
2639 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW53.Value = %x", curbeData.DW53.Value);
2640 VP_RENDER_VERBOSEMESSAGE("CurbeData: DestXTopLeftLayer5 = %d, DestYTopLeftLayer5 = %d",
2641 curbeData.DW53.DestXTopLeftLayer5,
2642 curbeData.DW53.DestYTopLeftLayer5);
2643 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW54.Value = %x", curbeData.DW54.Value);
2644 VP_RENDER_VERBOSEMESSAGE("CurbeData: DestXTopLeftLayer6 = %d, DestYTopLeftLayer6 = %d",
2645 curbeData.DW54.DestXTopLeftLayer6,
2646 curbeData.DW54.DestYTopLeftLayer6);
2647 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW55.Value = %x", curbeData.DW55.Value);
2648 VP_RENDER_VERBOSEMESSAGE("CurbeData: DestXTopLeftLayer7 = %d, DestYTopLeftLaye7 = %d",
2649 curbeData.DW55.DestXTopLeftLayer7,
2650 curbeData.DW55.DestYTopLeftLayer7);
2651 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW56.Value = %x", curbeData.DW56.Value);
2652 VP_RENDER_VERBOSEMESSAGE("CurbeData: DestXBottomRightLayer0 = %d, DestXBottomRightLayer0 = %d",
2653 curbeData.DW56.DestXBottomRightLayer0,
2654 curbeData.DW56.DestXBottomRightLayer0);
2655 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW57.Value = %x", curbeData.DW57.Value);
2656 VP_RENDER_VERBOSEMESSAGE("CurbeData: DestXBottomRightLayer1 = %d, DestXBottomRightLayer1 = %d",
2657 curbeData.DW57.DestXBottomRightLayer1,
2658 curbeData.DW57.DestXBottomRightLayer1);
2659 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW58.Value = %x", curbeData.DW58.Value);
2660 VP_RENDER_VERBOSEMESSAGE("CurbeData: DestXBottomRightLayer2 = %d, DestXBottomRightLayer2 = %d",
2661 curbeData.DW58.DestXBottomRightLayer2,
2662 curbeData.DW58.DestXBottomRightLayer2);
2663 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW59.Value = %x", curbeData.DW59.Value);
2664 VP_RENDER_VERBOSEMESSAGE("CurbeData: DestXBottomRightLayer3 = %d, DestXBottomRightLayer3 = %d",
2665 curbeData.DW59.DestXBottomRightLayer3,
2666 curbeData.DW59.DestXBottomRightLayer3);
2667 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW60.Value = %x", curbeData.DW60.Value);
2668 VP_RENDER_VERBOSEMESSAGE("CurbeData: DestXBottomRightLayer4 = %d, DestXBottomRightLayer4 = %d",
2669 curbeData.DW60.DestXBottomRightLayer4,
2670 curbeData.DW60.DestXBottomRightLayer4);
2671 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW61.Value = %x", curbeData.DW61.Value);
2672 VP_RENDER_VERBOSEMESSAGE("CurbeData: DestXBottomRightLayer5 = %d, DestXBottomRightLayer5 = %d",
2673 curbeData.DW61.DestXBottomRightLayer5,
2674 curbeData.DW61.DestXBottomRightLayer5);
2675 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW62.Value = %x", curbeData.DW62.Value);
2676 VP_RENDER_VERBOSEMESSAGE("CurbeData: DestXBottomRightLayer6 = %d, DestXBottomRightLayer6 = %d",
2677 curbeData.DW62.DestXBottomRightLayer6,
2678 curbeData.DW62.DestXBottomRightLayer6);
2679 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW63.Value = %x", curbeData.DW63.Value);
2680 VP_RENDER_VERBOSEMESSAGE("CurbeData: DestXBottomRightLayer7 = %d, DestXBottomRightLayer7 = %d",
2681 curbeData.DW63.DestXBottomRightLayer7,
2682 curbeData.DW63.DestXBottomRightLayer7);
2683 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW64.Value = %x", curbeData.DW64.Value);
2684 VP_RENDER_VERBOSEMESSAGE("CurbeData: MainVideoXScalingStepLeft = %x",
2685 curbeData.DW64.MainVideoXScalingStepLeft);
2686 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW65.Value = %x", curbeData.DW65.Value);
2687 VP_RENDER_VERBOSEMESSAGE("CurbeData: VideoStepDeltaForNonLinearRegion = %x",
2688 curbeData.DW65.VideoStepDeltaForNonLinearRegion);
2689 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW66.Value = %x", curbeData.DW66.Value);
2690 VP_RENDER_VERBOSEMESSAGE("CurbeData: StartofLinearScalingInPixelPositionC0 = %x, StartofRHSNonLinearScalingInPixelPositionC1 = %x",
2691 curbeData.DW66.StartofLinearScalingInPixelPositionC0,
2692 curbeData.DW66.StartofRHSNonLinearScalingInPixelPositionC1);
2693 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW67.Value = %x", curbeData.DW67.Value);
2694 VP_RENDER_VERBOSEMESSAGE("CurbeData: MainVideoXScalingStepCenter = %x",
2695 curbeData.DW67.MainVideoXScalingStepCenter);
2696 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW68.Value = %x", curbeData.DW68.Value);
2697 VP_RENDER_VERBOSEMESSAGE("CurbeData: MainVideoXScalingStepRight = %x",
2698 curbeData.DW68.MainVideoXScalingStepRight);
2699 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW69.Value = %x", curbeData.DW69.Value);
2700 VP_RENDER_VERBOSEMESSAGE("CurbeData: DestHorizontalBlockOrigin = %x, DestVerticalBlockOrigin = %x",
2701 curbeData.DW69.DestHorizontalBlockOrigin,
2702 curbeData.DW69.DestVerticalBlockOrigin);
2703 VP_RENDER_VERBOSEMESSAGE("CurbeData: dwPad[0] = %x, dwPad[1] = %x",
2704 curbeData.dwPad[0],
2705 curbeData.dwPad[1]);
2706 #endif
2707 }
2708
UpdateCompParams()2709 MOS_STATUS VpRenderFcKernel::UpdateCompParams()
2710 {
2711 VP_COMPOSITE_PARAMS &compParams = m_fcParams->compParams;
2712
2713 m_renderHal->eufusionBypass = IsEufusionBypassed();
2714
2715 VP_RENDER_NORMALMESSAGE("eufusionBypass = %d", m_renderHal->eufusionBypass ? 1 : 0);
2716 MT_LOG1(MT_VP_HAL_FC_UPDATE_COMP_PARAM, MT_NORMAL, MT_VP_HAL_EUFUSION_BYPASS, m_renderHal->eufusionBypass);
2717 for (uint32_t i = 0; i < compParams.sourceCount; ++i)
2718 {
2719 VP_FC_LAYER &layer = compParams.source[i];
2720 auto ¶ms = layer.calculatedParams;
2721 auto ¶ms2 = layer.calculatedParams2;
2722
2723 if (nullptr == layer.surfaceEntries[0])
2724 {
2725 VP_RENDER_ASSERTMESSAGE("layer.surfaceEntries[0] == nullptr!");
2726 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_NULL_POINTER);
2727 }
2728
2729 if (0 == layer.surfaceEntries[0]->dwWidth || 0 == layer.surfaceEntries[0]->dwWidth)
2730 {
2731 VP_RENDER_ASSERTMESSAGE("width or height in surface entry is 0!");
2732 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
2733 }
2734
2735 // Frame origins for the current layer
2736 params2.fOriginX = (params.fOffsetX + params.fShiftX * params2.fStepX) / layer.surfaceEntries[0]->dwWidth;
2737 params2.fOriginY = (params.fOffsetY + params.fShiftY * params2.fStepY) / layer.surfaceEntries[0]->dwHeight;
2738
2739 // Normalized block step for the current layer (block increment)
2740 params2.fStepX /= layer.surfaceEntries[0]->dwWidth;
2741 params2.fStepY /= layer.surfaceEntries[0]->dwHeight;
2742
2743 if (layer.xorComp)
2744 {
2745 // set mono-chroma XOR composite specific curbe data. re-calculate fStep due to 1 bit = 1 pixel.
2746 params2.fStepX /= 8;
2747 params2.fOriginX /= 8;
2748 }
2749 }
2750
2751 return MOS_STATUS_SUCCESS;
2752 }
2753
2754
2755 #define VP_SAMPLER_INDEX_Y_NEAREST 1
2756 #define VP_SAMPLER_INDEX_U_NEAREST 2
2757 #define VP_SAMPLER_INDEX_V_NEAREST 3
2758
2759 #define VP_SAMPLER_INDEX_Y_BILINEAR 4
2760 #define VP_SAMPLER_INDEX_U_BILINEAR 5
2761 #define VP_SAMPLER_INDEX_V_BILINEAR 6
2762
GetSamplerIndex(VPHAL_SCALING_MODE scalingMode,uint32_t yuvPlane,int32_t & samplerIndex,MHW_SAMPLER_TYPE & samplerType)2763 MOS_STATUS VpRenderFcKernel::GetSamplerIndex(
2764 VPHAL_SCALING_MODE scalingMode,
2765 uint32_t yuvPlane,
2766 int32_t &samplerIndex,
2767 MHW_SAMPLER_TYPE &samplerType)
2768 {
2769 const int32_t samplerindex[2][3] = { {VP_SAMPLER_INDEX_Y_NEAREST, VP_SAMPLER_INDEX_U_NEAREST, VP_SAMPLER_INDEX_V_NEAREST },
2770 {VP_SAMPLER_INDEX_Y_BILINEAR, VP_SAMPLER_INDEX_U_BILINEAR, VP_SAMPLER_INDEX_V_BILINEAR}};
2771
2772 if (scalingMode == VPHAL_SCALING_AVS)
2773 {
2774 VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
2775 }
2776
2777 // if Scalingmode is BILINEAR, use the 4,5,6. if NEAREST, use 1,2,3
2778 samplerType = MHW_SAMPLER_TYPE_3D;
2779 samplerIndex = samplerindex[scalingMode][yuvPlane];
2780
2781 return MOS_STATUS_SUCCESS;
2782 }
2783
2784 // Need be called after SetupSurfaceState.
SetSamplerStates(KERNEL_SAMPLER_STATE_GROUP & samplerStateGroup)2785 MOS_STATUS VpRenderFcKernel::SetSamplerStates(KERNEL_SAMPLER_STATE_GROUP& samplerStateGroup)
2786 {
2787 VP_COMPOSITE_PARAMS &compParams = m_fcParams->compParams;
2788
2789 samplerStateGroup.clear();
2790
2791 for (uint32_t i = 0; i < compParams.sourceCount; ++i)
2792 {
2793 auto &layer = compParams.source[i];
2794
2795 if (0 == layer.numOfSurfaceEntries)
2796 {
2797 VP_RENDER_ASSERTMESSAGE("0 == layer.numOfSurfaceEntries!");
2798 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
2799 }
2800
2801 VP_RENDER_CHK_NULL_RETURN(layer.surf);
2802 VP_RENDER_CHK_NULL_RETURN(layer.surf->osSurface);
2803
2804 for (uint32_t entryIndex = 0; entryIndex < layer.numOfSurfaceEntries; ++entryIndex)
2805 {
2806 int32_t samplerIndex = 0;
2807 MHW_SAMPLER_TYPE samplerType = MHW_SAMPLER_TYPE_INVALID;
2808 PRENDERHAL_SURFACE_STATE_ENTRY entry = layer.surfaceEntries[entryIndex];
2809 MHW_SAMPLER_STATE_PARAM samplerStateParam = {};
2810
2811 VP_RENDER_CHK_NULL_RETURN(entry);
2812
2813 // Obtain Sampler ID and Type
2814 VP_RENDER_CHK_STATUS_RETURN(GetSamplerIndex(layer.scalingMode,
2815 entry->YUVPlane,
2816 samplerIndex,
2817 samplerType));
2818
2819 if (samplerType != MHW_SAMPLER_TYPE_3D)
2820 {
2821 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
2822 }
2823
2824 samplerStateParam.bInUse = true;
2825 samplerStateParam.SamplerType = samplerType;
2826 samplerStateParam.Unorm.SamplerFilterMode = layer.calculatedParams.samplerFilterMode;
2827 samplerStateParam.Unorm.AddressU = MHW_GFX3DSTATE_TEXCOORDMODE_CLAMP;
2828 samplerStateParam.Unorm.AddressV = MHW_GFX3DSTATE_TEXCOORDMODE_CLAMP;
2829 samplerStateParam.Unorm.AddressW = MHW_GFX3DSTATE_TEXCOORDMODE_CLAMP;
2830
2831 samplerStateGroup.insert(std::make_pair(samplerIndex, samplerStateParam));
2832
2833 VP_RENDER_NORMALMESSAGE("Scaling Info: layer %d, layerOrigin %d, entry %d, format %d, scalingMode %d, samplerType %d, samplerFilterMode %d, samplerIndex %d, yuvPlane %d",
2834 layer.layerID, layer.layerIDOrigin, entryIndex, layer.surf->osSurface->Format, layer.scalingMode, samplerType, samplerStateParam.Unorm.SamplerFilterMode, samplerIndex, entry->YUVPlane);
2835 MT_LOG7(MT_VP_HAL_FC_SCALINGINFO, MT_NORMAL, MT_VP_HAL_FC_LAYER, layer.layerID, MT_VP_HAL_FC_LAYER_SURFENTRY, entryIndex, MT_SURF_MOS_FORMAT, layer.surf->osSurface->Format,
2836 MT_VP_HAL_SCALING_MODE, layer.scalingMode, MT_VP_HAL_SAMPLER_TYPE, samplerType, MT_VP_HAL_SAMPLER_FILTERMODE, samplerStateParam.Unorm.SamplerFilterMode, MT_VP_HAL_SAMPLER_INDEX, samplerIndex);
2837 }
2838 }
2839
2840 return MOS_STATUS_SUCCESS;
2841 }
2842
SetKernelConfigs(KERNEL_CONFIGS & kernelConfigs)2843 MOS_STATUS VpRenderFcKernel::SetKernelConfigs(KERNEL_CONFIGS &kernelConfigs)
2844 {
2845 VP_FUNC_CALL();
2846
2847 if (m_fcParams == nullptr)
2848 {
2849 m_fcParams = (PRENDER_FC_PARAMS)MOS_AllocAndZeroMemory(sizeof(RENDER_FC_PARAMS));
2850 }
2851 VP_RENDER_CHK_NULL_RETURN(m_fcParams);
2852
2853 PRENDER_FC_PARAMS fcParams = nullptr;
2854 if (kernelConfigs.find(m_kernelId) != kernelConfigs.end())
2855 {
2856 fcParams = (PRENDER_FC_PARAMS)kernelConfigs.find(m_kernelId)->second;
2857 }
2858
2859 VP_RENDER_CHK_NULL_RETURN(fcParams);
2860
2861 MOS_SecureMemcpy(m_fcParams, sizeof(RENDER_FC_PARAMS), fcParams, sizeof(RENDER_FC_PARAMS));
2862
2863 return MOS_STATUS_SUCCESS;
2864 }
2865