1 /*
2 * Copyright (c) 2018-2024, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file vp_resource_manager.cpp
24 //! \brief The source file of the base class of vp resource manager
25 //! \details all the vp resources will be traced here for usages using intermeida
26 //! surfaces.
27 //!
28 #include "vp_resource_manager.h"
29 #include "vp_vebox_cmd_packet.h"
30 #include "sw_filter_pipe.h"
31 #include "vp_utils.h"
32 #include "vp_platform_interface.h"
33
34 using namespace std;
35 namespace vp
36 {
37
38 #define VP_SAME_SAMPLE_THRESHOLD 0
39 #define VP_COMP_CMFC_COEFF_WIDTH 64
40 #define VP_COMP_CMFC_COEFF_HEIGHT 8
41
IsInterleaveFirstField(VPHAL_SAMPLE_TYPE sampleType)42 inline bool IsInterleaveFirstField(VPHAL_SAMPLE_TYPE sampleType)
43 {
44 VP_FUNC_CALL();
45 return ((sampleType == SAMPLE_INTERLEAVED_ODD_FIRST_BOTTOM_FIELD) ||
46 (sampleType == SAMPLE_INTERLEAVED_EVEN_FIRST_TOP_FIELD) ||
47 (sampleType == SAMPLE_SINGLE_TOP_FIELD));
48 }
49
50 extern const VEBOX_SPATIAL_ATTRIBUTES_CONFIGURATION g_cInit_VEBOX_SPATIAL_ATTRIBUTES_CONFIGURATIONS =
51 {
52 // DWORD 0
53 {
54 {NOISE_BLF_RANGE_THRESHOLD_S0_DEFAULT}, // RangeThrStart0
55 },
56
57 // DWORD 1
58 {
59 {NOISE_BLF_RANGE_THRESHOLD_S1_DEFAULT}, // RangeThrStart1
60 },
61
62 // DWORD 2
63 {
64 {NOISE_BLF_RANGE_THRESHOLD_S2_DEFAULT}, // RangeThrStart2
65 },
66
67 // DWORD 3
68 {
69 {NOISE_BLF_RANGE_THRESHOLD_S3_DEFAULT}, // RangeThrStart3
70 },
71
72 // DWORD 4
73 {
74 {NOISE_BLF_RANGE_THRESHOLD_S4_DEFAULT}, // RangeThrStart4
75 },
76
77 // DWORD 5
78 {
79 {NOISE_BLF_RANGE_THRESHOLD_S5_DEFAULT}, // RangeThrStart5
80 },
81
82 // DWORD 6
83 {
84 {0}, // Reserved
85 },
86
87 // DWORD 7
88 {
89 {0}, // Reserved
90 },
91
92 // DWORD 8
93 {
94 {NOISE_BLF_RANGE_WGTS0_DEFAULT}, // RangeWgt0
95 },
96
97 // DWORD 9
98 {
99 {NOISE_BLF_RANGE_WGTS1_DEFAULT}, // RangeWgt1
100 },
101
102 // DWORD 10
103 {
104 {NOISE_BLF_RANGE_WGTS2_DEFAULT}, // RangeWgt2
105 },
106
107 // DWORD 11
108 {
109 {NOISE_BLF_RANGE_WGTS3_DEFAULT}, // RangeWgt3
110 },
111
112 // DWORD 12
113 {
114 {NOISE_BLF_RANGE_WGTS4_DEFAULT}, // RangeWgt4
115 },
116
117 // DWORD 13
118 {
119 {NOISE_BLF_RANGE_WGTS5_DEFAULT}, // RangeWgt5
120 },
121
122 // DWORD 14
123 {
124 {0}, // Reserved
125 },
126
127 // DWORD 15
128 {
129 {0}, // Reserved
130 },
131
132 // DWORD 16 - 41: DistWgt[5][5]
133 {
134 {NOISE_BLF_DISTANCE_WGTS00_DEFAULT, NOISE_BLF_DISTANCE_WGTS01_DEFAULT, NOISE_BLF_DISTANCE_WGTS02_DEFAULT, NOISE_BLF_DISTANCE_WGTS01_DEFAULT, NOISE_BLF_DISTANCE_WGTS00_DEFAULT},
135 {NOISE_BLF_DISTANCE_WGTS10_DEFAULT, NOISE_BLF_DISTANCE_WGTS11_DEFAULT, NOISE_BLF_DISTANCE_WGTS12_DEFAULT, NOISE_BLF_DISTANCE_WGTS11_DEFAULT, NOISE_BLF_DISTANCE_WGTS10_DEFAULT},
136 {NOISE_BLF_DISTANCE_WGTS20_DEFAULT, NOISE_BLF_DISTANCE_WGTS21_DEFAULT, NOISE_BLF_DISTANCE_WGTS22_DEFAULT, NOISE_BLF_DISTANCE_WGTS21_DEFAULT, NOISE_BLF_DISTANCE_WGTS20_DEFAULT},
137 {NOISE_BLF_DISTANCE_WGTS10_DEFAULT, NOISE_BLF_DISTANCE_WGTS11_DEFAULT, NOISE_BLF_DISTANCE_WGTS12_DEFAULT, NOISE_BLF_DISTANCE_WGTS11_DEFAULT, NOISE_BLF_DISTANCE_WGTS10_DEFAULT},
138 {NOISE_BLF_DISTANCE_WGTS00_DEFAULT, NOISE_BLF_DISTANCE_WGTS01_DEFAULT, NOISE_BLF_DISTANCE_WGTS02_DEFAULT, NOISE_BLF_DISTANCE_WGTS01_DEFAULT, NOISE_BLF_DISTANCE_WGTS00_DEFAULT},
139 },
140
141 // Padding
142 {
143 0, // Padding
144 0, // Padding
145 0, // Padding
146 0, // Padding
147 0, // Padding
148 0, // Padding
149 0, // Padding
150 }
151 };
152
VpResourceManager(MOS_INTERFACE & osInterface,VpAllocator & allocator,VphalFeatureReport & reporting,vp::VpPlatformInterface & vpPlatformInterface,MediaCopyWrapper * mediaCopyWrapper,vp::VpUserFeatureControl * vpUserFeatureControl)153 VpResourceManager::VpResourceManager(MOS_INTERFACE &osInterface, VpAllocator &allocator, VphalFeatureReport &reporting, vp::VpPlatformInterface &vpPlatformInterface, MediaCopyWrapper *mediaCopyWrapper, vp::VpUserFeatureControl *vpUserFeatureControl)
154 : m_osInterface(osInterface), m_allocator(allocator), m_reporting(reporting), m_vpPlatformInterface(vpPlatformInterface), m_mediaCopyWrapper(mediaCopyWrapper)
155 {
156 InitSurfaceConfigMap();
157 m_userSettingPtr = m_osInterface.pfnGetUserSettingInstance(&m_osInterface);
158 m_vpUserFeatureControl = vpUserFeatureControl;
159 }
160
~VpResourceManager()161 VpResourceManager::~VpResourceManager()
162 {
163 // Clean all intermedia Resource
164 DestoryVeboxOutputSurface();
165 DestoryVeboxDenoiseOutputSurface();
166
167 for (uint32_t i = 0; i < VP_NUM_STMM_SURFACES; i++)
168 {
169 if (m_veboxSTMMSurface[i])
170 {
171 m_allocator.DestroyVpSurface(m_veboxSTMMSurface[i]);
172 }
173 }
174
175 if (m_veboxStatisticsSurface)
176 {
177 m_allocator.DestroyVpSurface(m_veboxStatisticsSurface);
178 }
179
180 if (m_veboxStatisticsSurfacefor1stPassofSfc2Pass)
181 {
182 m_allocator.DestroyVpSurface(m_veboxStatisticsSurfacefor1stPassofSfc2Pass);
183 }
184
185 if (m_veboxRgbHistogram)
186 {
187 m_allocator.DestroyVpSurface(m_veboxRgbHistogram);
188 }
189
190 if (m_veboxDNTempSurface)
191 {
192 m_allocator.DestroyVpSurface(m_veboxDNTempSurface);
193 }
194
195 if (m_veboxDNSpatialConfigSurface)
196 {
197 m_allocator.DestroyVpSurface(m_veboxDNSpatialConfigSurface);
198 }
199
200 if (m_vebox3DLookUpTables)
201 {
202 m_allocator.DestroyVpSurface(m_vebox3DLookUpTables);
203 }
204
205 if (m_vebox3DLookUpTables2D)
206 {
207 m_allocator.DestroyVpSurface(m_vebox3DLookUpTables2D);
208 }
209
210 if (m_3DLutKernelCoefSurface)
211 {
212 m_allocator.DestroyVpSurface(m_3DLutKernelCoefSurface);
213 }
214
215 if (m_veboxDnHVSTables)
216 {
217 m_allocator.DestroyVpSurface(m_veboxDnHVSTables);
218 }
219
220 if (m_vebox1DLookUpTables)
221 {
222 m_allocator.DestroyVpSurface(m_vebox1DLookUpTables);
223 }
224
225 if (m_innerTileConvertInput)
226 {
227 m_allocator.DestroyVpSurface(m_innerTileConvertInput);
228 }
229
230 if (m_temperalInput)
231 {
232 m_allocator.DestroyVpSurface(m_temperalInput);
233 }
234
235 if (m_hdrResourceManager)
236 {
237 MOS_Delete(m_hdrResourceManager);
238 }
239
240 while (!m_intermediaSurfaces.empty())
241 {
242 VP_SURFACE * surf = m_intermediaSurfaces.back();
243 m_allocator.DestroyVpSurface(surf);
244 m_intermediaSurfaces.pop_back();
245 }
246
247 for (int i = 0; i < VP_NUM_FC_INTERMEDIA_SURFACES; ++i)
248 {
249 m_allocator.DestroyVpSurface(m_fcIntermediateSurface[i]);
250 }
251
252 m_allocator.DestroyVpSurface(m_cmfcCoeff);
253 m_allocator.DestroyVpSurface(m_decompressionSyncSurface);
254 for (int i = 0; i < 8; ++i)
255 {
256 if (m_fcIntermediaSurfaceInput[i])
257 {
258 m_allocator.DestroyVpSurface(m_fcIntermediaSurfaceInput[i]);
259 }
260 }
261
262 m_allocator.CleanRecycler();
263 }
264
CleanTempSurfaces()265 void VpResourceManager::CleanTempSurfaces()
266 {
267 VP_FUNC_CALL();
268
269 while (!m_tempSurface.empty())
270 {
271 auto it = m_tempSurface.begin();
272 m_allocator.DestroyVpSurface(it->second);
273 m_tempSurface.erase(it);
274 }
275 }
276
OnNewFrameProcessStart(SwFilterPipe & pipe)277 MOS_STATUS VpResourceManager::OnNewFrameProcessStart(SwFilterPipe &pipe)
278 {
279 VP_FUNC_CALL();
280
281 MT_LOG1(MT_VP_HAL_ONNEWFRAME_PROC_START, MT_NORMAL, MT_FUNC_START, 1);
282 VP_SURFACE *inputSurface = pipe.GetSurface(true, 0);
283 VP_SURFACE *outputSurface = pipe.GetSurface(false, 0);
284 SwFilter *diFilter = pipe.GetSwFilter(true, 0, FeatureTypeDi);
285
286 if (nullptr == inputSurface && nullptr == outputSurface)
287 {
288 VP_PUBLIC_ASSERTMESSAGE("Both input and output surface being nullptr!");
289 VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
290 }
291
292 if (0 != m_currentPipeIndex)
293 {
294 VP_PUBLIC_ASSERTMESSAGE("m_currentPipeIndex(%d) is not 0. May caused by OnNewFrameProcessEnd not paired with OnNewFrameProcessStart!");
295 VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
296 }
297
298 VP_SURFACE *pastSurface = pipe.GetPastSurface(0);
299 VP_SURFACE *futureSurface = pipe.GetFutureSurface(0);
300
301 int32_t currentFrameId = inputSurface ? inputSurface->FrameID : outputSurface->FrameID;
302 int32_t pastFrameId = pastSurface ? pastSurface->FrameID : 0;
303 int32_t futureFrameId = futureSurface ? futureSurface->FrameID : 0;
304
305 m_currentFrameIds.valid = true;
306 m_currentFrameIds.diEnabled = nullptr != diFilter;
307 m_currentFrameIds.currentFrameId = currentFrameId;
308 m_currentFrameIds.pastFrameId = pastFrameId;
309 m_currentFrameIds.futureFrameId = futureFrameId;
310 m_currentFrameIds.pastFrameAvailable = pastSurface ? true : false;
311 m_currentFrameIds.futureFrameAvailable = futureSurface ? true : false;
312
313 // Only set sameSamples flag DI enabled frames.
314 if (m_pastFrameIds.valid && m_currentFrameIds.pastFrameAvailable &&
315 m_pastFrameIds.diEnabled && m_currentFrameIds.diEnabled && m_isPastFrameVeboxDiUsed)
316 {
317 m_sameSamples =
318 WITHIN_BOUNDS(
319 m_currentFrameIds.currentFrameId - m_pastFrameIds.currentFrameId,
320 -VP_SAME_SAMPLE_THRESHOLD,
321 VP_SAME_SAMPLE_THRESHOLD) &&
322 WITHIN_BOUNDS(
323 m_currentFrameIds.pastFrameId - m_pastFrameIds.pastFrameId,
324 -VP_SAME_SAMPLE_THRESHOLD,
325 VP_SAME_SAMPLE_THRESHOLD);
326
327 if (m_sameSamples)
328 {
329 m_outOfBound = false;
330 }
331 else
332 {
333 m_outOfBound =
334 OUT_OF_BOUNDS(
335 m_currentFrameIds.pastFrameId - m_pastFrameIds.currentFrameId,
336 -VP_SAME_SAMPLE_THRESHOLD,
337 VP_SAME_SAMPLE_THRESHOLD);
338 }
339 }
340 // bSameSamples flag also needs to be set for no reference case
341 else if (m_pastFrameIds.valid && !m_currentFrameIds.pastFrameAvailable &&
342 m_pastFrameIds.diEnabled && m_currentFrameIds.diEnabled && m_isPastFrameVeboxDiUsed)
343 {
344 m_sameSamples =
345 WITHIN_BOUNDS(
346 m_currentFrameIds.currentFrameId - m_pastFrameIds.currentFrameId,
347 -VP_SAME_SAMPLE_THRESHOLD,
348 VP_SAME_SAMPLE_THRESHOLD);
349 m_outOfBound = false;
350 }
351 else
352 {
353 m_sameSamples = false;
354 m_outOfBound = false;
355 }
356
357 if (inputSurface)
358 {
359 m_maxSrcRect.right = MOS_MAX(m_maxSrcRect.right, inputSurface->rcSrc.right);
360 m_maxSrcRect.bottom = MOS_MAX(m_maxSrcRect.bottom, inputSurface->rcSrc.bottom);
361 }
362
363 // Swap buffers for next iteration
364 if (!m_sameSamples)
365 {
366 m_currentDnOutput = (m_currentDnOutput + 1) & 1;
367 m_currentStmmIndex = (m_currentStmmIndex + 1) & 1;
368 }
369
370 m_pastFrameIds = m_currentFrameIds;
371
372 m_isFcIntermediateSurfacePrepared = false;
373
374 return MOS_STATUS_SUCCESS;
375 }
376
GetFormatForFcIntermediaSurface(MOS_FORMAT & format,MEDIA_CSPACE & colorSpace,SwFilterPipe & featurePipe)377 MOS_STATUS VpResourceManager::GetFormatForFcIntermediaSurface(MOS_FORMAT& format,
378 MEDIA_CSPACE &colorSpace, SwFilterPipe &featurePipe)
379 {
380 VP_FUNC_CALL();
381
382 PVP_SURFACE target = nullptr;
383 int32_t surfCount = (int32_t)featurePipe.GetSurfaceCount(true);
384 PVP_SURFACE src = nullptr;
385 int32_t i = 0, j = 0;
386 int32_t csc_count = 0;
387 int32_t csc_min = surfCount + 1;
388 int32_t cspace_in_use[CSpace_Count] = {};
389 bool bYUVTarget = false;
390 MEDIA_CSPACE cs = CSpace_Any;
391 MEDIA_CSPACE tempColorSpace = CSpace_Any;
392 MEDIA_CSPACE mainColorSpace = CSpace_None;
393
394 auto PostProcess = [&](MOS_STATUS status)
395 {
396 VP_PUBLIC_NORMALMESSAGE("Main_ColorSpace %d, Temp_ColorSpace %d, csc_count %d.",
397 mainColorSpace, tempColorSpace, csc_count);
398 colorSpace = tempColorSpace;
399 // Set AYUV or ARGB output depending on intermediate cspace
400 if (KernelDll_IsCspace(colorSpace, CSpace_RGB))
401 {
402 format = Format_A8R8G8B8;
403 }
404 else
405 {
406 format = Format_AYUV;
407 }
408 return status;
409 };
410
411 // Check if target is YUV
412 target = featurePipe.GetSurface(false, 0);
413
414 VP_PUBLIC_CHK_NULL_RETURN(target);
415 VP_PUBLIC_CHK_NULL_RETURN(target->osSurface);
416
417 bYUVTarget = IS_RGB_FORMAT(target->osSurface->Format) ? false : true;
418
419 // Gets primary video cspace
420 // Implements xvYCC passthrough mode
421 // Set Color Spaces in use
422 MOS_ZeroMemory(cspace_in_use, sizeof(cspace_in_use));
423 for (i = 0; i < surfCount; i++)
424 {
425 // Get current source
426 src = featurePipe.GetSurface(true, i);
427 VP_PUBLIC_CHK_NULL_RETURN(src);
428 VP_PUBLIC_CHK_NULL_RETURN(src->osSurface);
429
430 // Save Main Video color space
431 if (src->SurfType == SURF_IN_PRIMARY &&
432 mainColorSpace == CSpace_None)
433 {
434 mainColorSpace = src->ColorSpace;
435 }
436
437 // Set xvYCC pass through mode
438 if (bYUVTarget &&
439 (src->ColorSpace == CSpace_xvYCC709 ||
440 src->ColorSpace == CSpace_xvYCC601))
441 {
442 tempColorSpace = src->ColorSpace;
443 return PostProcess(MOS_STATUS_SUCCESS);
444 }
445
446 // Don't take PAL formats into consideration
447 if ((!IS_PAL_FORMAT(src->osSurface->Format)) &&
448 src->ColorSpace > CSpace_Any &&
449 src->ColorSpace < CSpace_Count)
450 {
451 cs = KernelDll_TranslateCspace(src->ColorSpace);
452 if (cs >= CSpace_Any)
453 {
454 cspace_in_use[cs]++;
455 }
456 }
457 }
458
459 // For every CS in use, iterate through source CS and keep a
460 // count of number of CSC operation needed. Determine the Temporary
461 // color space as the one requiring min. # of CSC ops.
462 for (j = (CSpace_Any + 1); j < CSpace_Count; j++)
463 {
464 // Skip color spaces not in use
465 if (!cspace_in_use[j])
466 {
467 continue;
468 }
469
470 // Count # of CS conversions
471 cs = (MEDIA_CSPACE) j;
472 csc_count = 0;
473 for (i = 0; i < surfCount; i++)
474 {
475 // Get current source
476 src = featurePipe.GetSurface(true, i);
477 VP_PUBLIC_CHK_NULL_RETURN(src);
478 VP_PUBLIC_CHK_NULL_RETURN(src->osSurface);
479
480 auto featureSubPipe = featurePipe.GetSwFilterSubPipe(true, i);
481 VP_PUBLIC_CHK_NULL_RETURN(featureSubPipe);
482
483 // Ignore palletized layers
484 if (IS_PAL_FORMAT(src->osSurface->Format) ||
485 src->ColorSpace == CSpace_Any)
486 {
487 continue;
488 }
489
490 auto procamp = dynamic_cast<SwFilterProcamp *>(featureSubPipe->GetSwFilter(FeatureTypeProcamp));
491 // Check if CSC/PA is required
492 if (KernelDll_TranslateCspace(src->ColorSpace) != cs ||
493 (procamp &&
494 procamp->GetSwFilterParams().procampParams &&
495 procamp->GetSwFilterParams().procampParams->bEnabled))
496 {
497 csc_count++;
498 }
499 }
500
501 // Save best choice as requiring minimum number of CSC operations
502 // Use main cspace as default if same CSC count
503 if ((csc_count < csc_min) ||
504 (csc_count == csc_min && cs == mainColorSpace))
505 {
506 tempColorSpace = cs;
507 csc_min = csc_count;
508 }
509 }
510
511 // If all layers are palletized, use the CS from first layer (as good as any other)
512 if (tempColorSpace == CSpace_Any && surfCount > 0)
513 {
514 src = featurePipe.GetSurface(true, 0);
515 VP_PUBLIC_CHK_NULL_RETURN(src);
516 tempColorSpace = src->ColorSpace;
517 }
518
519 return PostProcess(MOS_STATUS_SUCCESS);
520 }
521
PrepareFcIntermediateSurface(SwFilterPipe & featurePipe)522 MOS_STATUS VpResourceManager::PrepareFcIntermediateSurface(SwFilterPipe &featurePipe)
523 {
524 VP_FUNC_CALL();
525
526 if (m_isFcIntermediateSurfacePrepared)
527 {
528 return MOS_STATUS_SUCCESS;
529 }
530
531 m_isFcIntermediateSurfacePrepared = true;
532
533 MOS_FORMAT format = Format_Any;
534 MEDIA_CSPACE colorSpace = CSpace_Any;
535
536 VP_PUBLIC_CHK_STATUS_RETURN(GetFormatForFcIntermediaSurface(format, colorSpace, featurePipe));
537
538 auto target = featurePipe.GetSurface(false, 0);
539 VP_PUBLIC_CHK_NULL_RETURN(target);
540 VP_PUBLIC_CHK_NULL_RETURN(target->osSurface);
541
542 uint32_t tempWidth = target->osSurface->dwWidth;
543 uint32_t tempHeight = target->osSurface->dwHeight;
544
545 uint32_t curWidth = 0;
546 uint32_t curHeight = 0;
547
548 if (m_fcIntermediateSurface[0])
549 {
550 VP_PUBLIC_CHK_NULL_RETURN(m_fcIntermediateSurface[0]->osSurface);
551 curWidth = m_fcIntermediateSurface[0]->osSurface->dwWidth;
552 curHeight = m_fcIntermediateSurface[0]->osSurface->dwHeight;
553 }
554
555 // Allocate buffer in fixed increments
556 tempWidth = MOS_ALIGN_CEIL(tempWidth , VPHAL_BUFFER_SIZE_INCREMENT);
557 tempHeight = MOS_ALIGN_CEIL(tempHeight, VPHAL_BUFFER_SIZE_INCREMENT);
558
559 for (int i = 0; i < VP_NUM_FC_INTERMEDIA_SURFACES; ++i)
560 {
561 if (tempWidth > curWidth || tempHeight > curHeight)
562 {
563 bool allocated = false;
564 // Get surface parameter.
565 // Use A8R8G8B8 instead of real surface format to ensure the surface can be reused for both AYUV and A8R8G8B8,
566 // since for A8R8G8B8, tile64 is used, while for AYUV, both tile4 and tile64 is ok.
567 if (m_fcIntermediateSurface[i] && m_fcIntermediateSurface[i]->osSurface)
568 {
569 m_fcIntermediateSurface[i]->osSurface->Format = Format_A8R8G8B8;
570 }
571 VP_PUBLIC_CHK_STATUS_RETURN(m_allocator.ReAllocateSurface(
572 m_fcIntermediateSurface[i],
573 "fcIntermediaSurface",
574 Format_A8R8G8B8,
575 MOS_GFXRES_2D,
576 MOS_TILE_Y,
577 tempWidth,
578 tempHeight,
579 false,
580 MOS_MMC_DISABLED,
581 allocated,
582 false,
583 IsDeferredResourceDestroyNeeded(),
584 MOS_HW_RESOURCE_USAGE_VP_INTERNAL_READ_WRITE_RENDER,
585 MOS_TILE_UNSET_GMM,
586 MOS_MEMPOOL_DEVICEMEMORY,
587 true));
588 m_fcIntermediateSurface[i]->osSurface->Format = format;
589 m_fcIntermediateSurface[i]->ColorSpace = colorSpace;
590 }
591 else
592 {
593 m_fcIntermediateSurface[i]->osSurface->dwWidth = tempWidth;
594 m_fcIntermediateSurface[i]->osSurface->dwHeight = tempHeight;
595 m_fcIntermediateSurface[i]->osSurface->Format = format;
596 m_fcIntermediateSurface[i]->ColorSpace = colorSpace;
597 }
598 m_fcIntermediateSurface[i]->rcSrc = target->rcSrc;
599 m_fcIntermediateSurface[i]->rcDst = target->rcDst;
600 }
601
602 return MOS_STATUS_SUCCESS;
603 }
604
OnNewFrameProcessEnd()605 void VpResourceManager::OnNewFrameProcessEnd()
606 {
607 VP_FUNC_CALL();
608 MT_LOG1(MT_VP_HAL_ONNEWFRAME_PROC_END, MT_NORMAL, MT_FUNC_END, 1);
609 m_allocator.CleanRecycler();
610 m_currentPipeIndex = 0;
611 CleanTempSurfaces();
612 }
613
InitSurfaceConfigMap()614 void VpResourceManager::InitSurfaceConfigMap()
615 {
616 VP_FUNC_CALL();
617 ///* _b64DI
618 // | _sfcEnable
619 // | | _sameSample
620 // | | | _outOfBound
621 // | | | | _pastRefAvailable
622 // | | | | | _futureRefAvailable
623 // | | | | | | _firstDiField
624 // | | | | | | | _currentInputSurface
625 // | | | | | | | | _pastInputSurface
626 // | | | | | | | | | _currentOutputSurface
627 // | | | | | | | | | | _pastOutputSurface*/
628 // | | | | | | | | | | | */
629 // sfc Enable
630 AddSurfaceConfig(true, true, false, false, true, false, true, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_PAST_REF, VEBOX_SURFACE_FRAME1, VEBOX_SURFACE_FRAME0);
631 AddSurfaceConfig(true, true, true, false, true, false, false, VEBOX_SURFACE_FRAME1, VEBOX_SURFACE_NULL, VEBOX_SURFACE_NULL, VEBOX_SURFACE_NULL);
632 AddSurfaceConfig(true, true, false, false, false, false, true, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_NULL, VEBOX_SURFACE_FRAME1, VEBOX_SURFACE_NULL);
633 AddSurfaceConfig(true, true, false, false, false, false, false, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_NULL, VEBOX_SURFACE_FRAME1, VEBOX_SURFACE_NULL);
634 AddSurfaceConfig(true, true, false, false, true, false, false, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_PAST_REF, VEBOX_SURFACE_FRAME1, VEBOX_SURFACE_FRAME0);
635 AddSurfaceConfig(true, true, true, false, false, false, true, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_NULL, VEBOX_SURFACE_FRAME1, VEBOX_SURFACE_NULL);
636 AddSurfaceConfig(true, true, true, false, false, false, false, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_NULL, VEBOX_SURFACE_FRAME1, VEBOX_SURFACE_NULL);
637 AddSurfaceConfig(true, true, true, false, true, false, true, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_PAST_REF, VEBOX_SURFACE_FRAME1, VEBOX_SURFACE_FRAME0);
638
639 // outOfBound
640 AddSurfaceConfig(true, true, false, true, true, false, true, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_PAST_REF, VEBOX_SURFACE_FRAME1, VEBOX_SURFACE_FRAME0);
641 AddSurfaceConfig(true, true, false, true, true, false, false, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_NULL, VEBOX_SURFACE_FRAME1, VEBOX_SURFACE_NULL);
642
643 // sfc disable
644 AddSurfaceConfig(true, false, false, false, true, false, true, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_PAST_REF, VEBOX_SURFACE_FRAME1, VEBOX_SURFACE_OUTPUT);
645 AddSurfaceConfig(true, false, true, false, true, false, false, VEBOX_SURFACE_FRAME1, VEBOX_SURFACE_NULL, VEBOX_SURFACE_NULL, VEBOX_SURFACE_NULL);
646 AddSurfaceConfig(true, false, false, false, false, false, true, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_NULL, VEBOX_SURFACE_OUTPUT, VEBOX_SURFACE_NULL);
647 AddSurfaceConfig(true, false, false, false, false, false, false, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_NULL, VEBOX_SURFACE_FRAME1, VEBOX_SURFACE_NULL);
648 AddSurfaceConfig(true, false, false, false, true, false, false, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_PAST_REF, VEBOX_SURFACE_FRAME1, VEBOX_SURFACE_FRAME0);
649 AddSurfaceConfig(true, false, true, false, false, false, true, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_NULL, VEBOX_SURFACE_OUTPUT, VEBOX_SURFACE_NULL);
650 AddSurfaceConfig(true, false, true, false, false, false, false, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_NULL, VEBOX_SURFACE_FRAME1, VEBOX_SURFACE_NULL);
651
652 //30i -> 30p sfc Enable
653 AddSurfaceConfig(false, true, false, false, false, false, true, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_NULL, VEBOX_SURFACE_FRAME1, VEBOX_SURFACE_NULL);
654 AddSurfaceConfig(false, true, false, false, true, false, false, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_PAST_REF, VEBOX_SURFACE_FRAME1, VEBOX_SURFACE_FRAME0);
655 AddSurfaceConfig(false, true, false, false, true, false, true, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_PAST_REF, VEBOX_SURFACE_FRAME1, VEBOX_SURFACE_FRAME0);
656 AddSurfaceConfig(false, true, false, true, true, false, true, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_PAST_REF, VEBOX_SURFACE_FRAME1, VEBOX_SURFACE_FRAME0);
657 AddSurfaceConfig(false, true, false, true, true, false, false, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_PAST_REF, VEBOX_SURFACE_FRAME1, VEBOX_SURFACE_FRAME0);
658
659 //30i -> 30p sfc disable
660 AddSurfaceConfig(false, false, false, false, true, false, true, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_NULL, VEBOX_SURFACE_OUTPUT, VEBOX_SURFACE_NULL);
661 AddSurfaceConfig(false, false, false, true, true, false, true, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_NULL, VEBOX_SURFACE_OUTPUT, VEBOX_SURFACE_NULL);
662 AddSurfaceConfig(false, false, false, false, false, false, true, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_NULL, VEBOX_SURFACE_OUTPUT, VEBOX_SURFACE_NULL);
663 }
664
GetHistogramSurfaceSize(VP_EXECUTE_CAPS & caps,uint32_t inputWidth,uint32_t inputHeight)665 uint32_t VpResourceManager::GetHistogramSurfaceSize(VP_EXECUTE_CAPS& caps, uint32_t inputWidth, uint32_t inputHeight)
666 {
667 VP_FUNC_CALL();
668
669 // Allocate Rgb Histogram surface----------------------------------------------
670 // Size of RGB histograms, 1 set for each slice. For single slice, other set will be 0
671 uint32_t dwSize = VP_VEBOX_RGB_HISTOGRAM_SIZE;
672 dwSize += VP_VEBOX_RGB_ACE_HISTOGRAM_SIZE_RESERVED;
673 // Size of ACE histograms, 1 set for each slice. For single slice, other set will be 0
674 dwSize += VP_VEBOX_ACE_HISTOGRAM_SIZE_PER_FRAME_PER_SLICE * // Ace histogram size per slice
675 VP_NUM_FRAME_PREVIOUS_CURRENT * // Ace for Prev + Curr
676 VP_VEBOX_HISTOGRAM_SLICES_COUNT; // Total number of slices
677 return dwSize;
678 }
679
GetResourceHint(std::vector<FeatureType> & featurePool,SwFilterPipe & executedFilters,RESOURCE_ASSIGNMENT_HINT & hint)680 MOS_STATUS VpResourceManager::GetResourceHint(std::vector<FeatureType> &featurePool, SwFilterPipe& executedFilters, RESOURCE_ASSIGNMENT_HINT &hint)
681 {
682 VP_FUNC_CALL();
683
684 uint32_t index = 0;
685 SwFilterSubPipe *inputPipe = executedFilters.GetSwFilterSubPipe(true, index);
686
687 // only process Primary surface
688 if (inputPipe == nullptr)
689 {
690 VP_PUBLIC_NORMALMESSAGE("No inputPipe, so there is no hint message!");
691 return MOS_STATUS_SUCCESS;
692 }
693 for (auto filterID : featurePool)
694 {
695 SwFilter* feature = (SwFilter*)inputPipe->GetSwFilter(FeatureType(filterID));
696 if (feature)
697 {
698 VP_PUBLIC_CHK_STATUS_RETURN(feature->SetResourceAssignmentHint(hint));
699 }
700 }
701 return MOS_STATUS_SUCCESS;
702 }
703
GetIntermediaColorAndFormat3DLutOutput(VPHAL_CSPACE & colorSpace,MOS_FORMAT & format,SwFilterPipe & executedFilters)704 MOS_STATUS VpResourceManager::GetIntermediaColorAndFormat3DLutOutput(VPHAL_CSPACE &colorSpace, MOS_FORMAT &format, SwFilterPipe &executedFilters)
705 {
706 SwFilterHdr *hdr = dynamic_cast<SwFilterHdr *>(executedFilters.GetSwFilter(true, 0, FeatureType::FeatureTypeHdr));
707 if (hdr)
708 {
709 colorSpace = hdr->GetSwFilterParams().dstColorSpace;
710 format = hdr->GetSwFilterParams().formatOutput;
711 }
712 else
713 { // caps.b3DlutOutput =1, in hdr tests hdr flag should not be false.
714 VP_PUBLIC_ASSERTMESSAGE("It is unexcepted for HDR case with caps.b3DlutOutput as true, return INVALID_PARAMETER");
715 VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
716
717 }
718 return MOS_STATUS_SUCCESS;
719 }
720
GetIntermediaColorAndFormatBT2020toRGB(VP_EXECUTE_CAPS & caps,VPHAL_CSPACE & colorSpace,MOS_FORMAT & format,SwFilterPipe & executedFilters)721 MOS_STATUS VpResourceManager::GetIntermediaColorAndFormatBT2020toRGB(VP_EXECUTE_CAPS &caps, VPHAL_CSPACE &colorSpace, MOS_FORMAT &format, SwFilterPipe &executedFilters)
722 {
723 SwFilterCsc *cscOnSfc = dynamic_cast<SwFilterCsc *>(executedFilters.GetSwFilter(true, 0, FeatureType::FeatureTypeCscOnSfc));
724 SwFilterCgc *cgc = dynamic_cast<SwFilterCgc *>(executedFilters.GetSwFilter(true, 0, FeatureType::FeatureTypeCgc));
725
726 if (caps.bSFC && nullptr == cscOnSfc)
727 {
728 VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
729 }
730
731 if (cscOnSfc)
732 {
733 colorSpace = cscOnSfc->GetSwFilterParams().output.colorSpace;
734 format = cscOnSfc->GetSwFilterParams().formatOutput;
735 }
736 else
737 {
738 VP_PUBLIC_CHK_NULL_RETURN(cgc);
739 colorSpace = cgc->GetSwFilterParams().dstColorSpace;
740 format = cgc->GetSwFilterParams().formatOutput;
741 }
742
743 return MOS_STATUS_SUCCESS;
744 }
745
746
GetIntermediaOutputSurfaceColorAndFormat(VP_EXECUTE_CAPS & caps,SwFilterPipe & executedFilters,MOS_FORMAT & format,VPHAL_CSPACE & colorSpace)747 MOS_STATUS VpResourceManager::GetIntermediaOutputSurfaceColorAndFormat(VP_EXECUTE_CAPS &caps, SwFilterPipe &executedFilters, MOS_FORMAT &format, VPHAL_CSPACE &colorSpace)
748 {
749 VP_SURFACE *inputSurface = executedFilters.GetSurface(true, 0);
750 VP_PUBLIC_CHK_NULL_RETURN(inputSurface);
751 if (caps.bRender)
752 {
753 SwFilterCsc *csc = dynamic_cast<SwFilterCsc *>(executedFilters.GetSwFilter(true, 0, FeatureType::FeatureTypeCscOnRender));
754 if (csc)
755 {
756 format = csc->GetSwFilterParams().formatOutput;
757 colorSpace = csc->GetSwFilterParams().output.colorSpace;
758 return MOS_STATUS_SUCCESS;
759 }
760
761 }
762 else if (caps.bSFC)
763 {
764 SwFilterCsc *csc = dynamic_cast<SwFilterCsc *>(executedFilters.GetSwFilter(true, 0, FeatureType::FeatureTypeCscOnSfc));
765 if (csc)
766 {
767 format = csc->GetSwFilterParams().formatOutput;
768 colorSpace = csc->GetSwFilterParams().output.colorSpace;
769 return MOS_STATUS_SUCCESS;
770 }
771 }
772 else if (caps.b3DlutOutput)
773 {
774 VP_PUBLIC_CHK_STATUS_RETURN(GetIntermediaColorAndFormat3DLutOutput(colorSpace, format, executedFilters));
775 return MOS_STATUS_SUCCESS;
776 }
777 else if (caps.bBt2020ToRGB)
778 {
779 VP_PUBLIC_CHK_STATUS_RETURN(GetIntermediaColorAndFormatBT2020toRGB(caps, colorSpace, format, executedFilters));
780 return MOS_STATUS_SUCCESS;
781 }
782 else if (caps.bVebox)
783 {
784 SwFilterCsc *csc = dynamic_cast<SwFilterCsc *>(executedFilters.GetSwFilter(true, 0, FeatureType::FeatureTypeCscOnVebox));
785 if (csc)
786 {
787 format = csc->GetSwFilterParams().formatOutput;
788 colorSpace = csc->GetSwFilterParams().output.colorSpace;
789 return MOS_STATUS_SUCCESS;
790 }
791 }
792
793 format = inputSurface->osSurface->Format;
794 colorSpace = inputSurface->ColorSpace;
795 return MOS_STATUS_SUCCESS;
796 }
797
GetIntermediaOutputSurfaceParams(VP_EXECUTE_CAPS & caps,VP_SURFACE_PARAMS & params,SwFilterPipe & executedFilters)798 MOS_STATUS VpResourceManager::GetIntermediaOutputSurfaceParams(VP_EXECUTE_CAPS& caps, VP_SURFACE_PARAMS ¶ms, SwFilterPipe &executedFilters)
799 {
800 VP_FUNC_CALL();
801
802 SwFilterScaling *scaling = dynamic_cast<SwFilterScaling *>(executedFilters.GetSwFilter(true, 0, FeatureType::FeatureTypeScaling));
803 SwFilterRotMir *rotMir = dynamic_cast<SwFilterRotMir *>(executedFilters.GetSwFilter(true, 0, FeatureType::FeatureTypeRotMir));
804 SwFilterDeinterlace *di = dynamic_cast<SwFilterDeinterlace *>(executedFilters.GetSwFilter(true, 0, FeatureType::FeatureTypeDi));
805 VP_SURFACE *inputSurface = executedFilters.GetSurface(true, 0);
806
807 VP_PUBLIC_CHK_NULL_RETURN(inputSurface);
808
809 if (scaling)
810 {
811 params.width = scaling->GetSwFilterParams().output.dwWidth;
812 params.height = scaling->GetSwFilterParams().output.dwHeight;
813 params.sampleType = scaling->GetSwFilterParams().output.sampleType;
814 params.rcSrc = scaling->GetSwFilterParams().output.rcSrc;
815 params.rcDst = scaling->GetSwFilterParams().output.rcDst;
816 params.rcMaxSrc = scaling->GetSwFilterParams().output.rcMaxSrc;
817
818 if (scaling->GetSwFilterParams().interlacedScalingType == ISCALING_INTERLEAVED_TO_FIELD)
819 {
820 params.height = scaling->GetSwFilterParams().output.dwHeight / 2;
821 params.rcDst.bottom = params.rcDst.bottom / 2;
822 params.rcMaxSrc.bottom = params.rcMaxSrc.bottom / 2;
823 }
824 }
825 else
826 {
827 params.width = inputSurface->osSurface->dwWidth;
828 params.height = inputSurface->osSurface->dwHeight;
829 params.sampleType = di ? SAMPLE_PROGRESSIVE : inputSurface->SampleType;
830 params.rcSrc = inputSurface->rcSrc;
831 params.rcDst = inputSurface->rcDst;
832 params.rcMaxSrc = inputSurface->rcMaxSrc;
833 }
834
835 // Do not use rotatoin flag in scaling swfilter as it has not been initialized here.
836 // It will be initialized during pipe update after resource being assigned.
837 if (rotMir &&
838 (rotMir->GetSwFilterParams().rotation == VPHAL_ROTATION_90 ||
839 rotMir->GetSwFilterParams().rotation == VPHAL_ROTATION_270 ||
840 rotMir->GetSwFilterParams().rotation == VPHAL_ROTATE_90_MIRROR_VERTICAL ||
841 rotMir->GetSwFilterParams().rotation == VPHAL_ROTATE_90_MIRROR_HORIZONTAL))
842 {
843 swap(params.width, params.height);
844 RECT tmp = params.rcSrc;
845 RECT_ROTATE(params.rcSrc, tmp);
846 tmp = params.rcDst;
847 RECT_ROTATE(params.rcDst, tmp);
848 tmp = params.rcMaxSrc;
849 RECT_ROTATE(params.rcMaxSrc, tmp);
850 }
851
852 VP_PUBLIC_CHK_STATUS_RETURN(GetIntermediaOutputSurfaceColorAndFormat(caps, executedFilters, params.format, params.colorSpace));
853
854 params.tileType = MOS_TILE_Y;
855
856 if (SAMPLE_PROGRESSIVE == params.sampleType)
857 {
858 params.surfCompressionMode = caps.bRender ? MOS_MMC_RC : MOS_MMC_MC;
859 params.surfCompressible = true;
860 }
861 else
862 {
863 // MMC does not support interleaved surface.
864 VP_PUBLIC_NORMALMESSAGE("Disable MMC for interleaved intermedia surface, sampleType = %d.", params.sampleType);
865 params.surfCompressionMode = MOS_MMC_DISABLED;
866 params.surfCompressible = false;
867 }
868
869 return MOS_STATUS_SUCCESS;
870 }
871
GetFcIntermediateSurfaceForOutput(VP_SURFACE * & intermediaSurface,SwFilterPipe & executedFilters)872 MOS_STATUS VpResourceManager::GetFcIntermediateSurfaceForOutput(VP_SURFACE *&intermediaSurface, SwFilterPipe &executedFilters)
873 {
874 VP_FUNC_CALL();
875
876 if (!m_isFcIntermediateSurfacePrepared)
877 {
878 VP_PUBLIC_ASSERTMESSAGE("Fc intermediate surface is not allocated.");
879 VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
880 }
881
882 intermediaSurface = nullptr;
883
884 for (uint32_t i = 0; i < executedFilters.GetSurfaceCount(true); ++i)
885 {
886 uint32_t j = 0;
887 auto surf = executedFilters.GetSurface(true, i);
888 VP_PUBLIC_CHK_NULL_RETURN(surf);
889 for (j = 0; j < VP_NUM_FC_INTERMEDIA_SURFACES; ++j)
890 {
891 auto intermediateSurface = m_fcIntermediateSurface[j];
892 VP_PUBLIC_CHK_NULL_RETURN(intermediateSurface);
893 if (surf->GetAllocationHandle(&m_osInterface) == intermediateSurface->GetAllocationHandle(&m_osInterface))
894 {
895 uint32_t selIndex = (j + 1) % VP_NUM_FC_INTERMEDIA_SURFACES;
896 intermediaSurface = m_fcIntermediateSurface[selIndex];
897 break;
898 }
899 }
900 if (j < VP_NUM_FC_INTERMEDIA_SURFACES)
901 {
902 break;
903 }
904 }
905 // If intermediate surface not in use in current pipe, use first one by default.
906 if (nullptr == intermediaSurface)
907 {
908 intermediaSurface = m_fcIntermediateSurface[0];
909 }
910
911 return MOS_STATUS_SUCCESS;
912 }
913
AssignIntermediaSurface(VP_EXECUTE_CAPS & caps,SwFilterPipe & executedFilters)914 MOS_STATUS VpResourceManager::AssignIntermediaSurface(VP_EXECUTE_CAPS& caps, SwFilterPipe &executedFilters)
915 {
916 VP_FUNC_CALL();
917
918 VP_SURFACE *outputSurface = executedFilters.GetSurface(false, 0);
919 VP_SURFACE *intermediaSurface = nullptr;
920 VP_SURFACE_PARAMS params = {};
921 if (outputSurface)
922 {
923 // No need intermedia surface.
924 return MOS_STATUS_SUCCESS;
925 }
926
927 if (caps.bComposite)
928 {
929 VP_PUBLIC_CHK_STATUS_RETURN(GetFcIntermediateSurfaceForOutput(intermediaSurface, executedFilters));
930 }
931 else
932 {
933 while (m_currentPipeIndex >= m_intermediaSurfaces.size())
934 {
935 m_intermediaSurfaces.push_back(nullptr);
936 }
937 bool allocated = false;
938 // Get surface parameter.
939 GetIntermediaOutputSurfaceParams(caps, params, executedFilters);
940
941 VP_PUBLIC_CHK_STATUS_RETURN(m_allocator.ReAllocateSurface(
942 m_intermediaSurfaces[m_currentPipeIndex],
943 "IntermediaSurface",
944 params.format,
945 MOS_GFXRES_2D,
946 params.tileType,
947 params.width,
948 params.height,
949 params.surfCompressible,
950 params.surfCompressionMode,
951 allocated,
952 false,
953 IsDeferredResourceDestroyNeeded(),
954 MOS_HW_RESOURCE_USAGE_VP_INTERNAL_READ_WRITE_RENDER));
955
956 VP_PUBLIC_CHK_NULL_RETURN(m_intermediaSurfaces[m_currentPipeIndex]);
957
958 m_intermediaSurfaces[m_currentPipeIndex]->ColorSpace = params.colorSpace;
959 m_intermediaSurfaces[m_currentPipeIndex]->rcDst = params.rcDst;
960 m_intermediaSurfaces[m_currentPipeIndex]->rcSrc = params.rcSrc;
961 m_intermediaSurfaces[m_currentPipeIndex]->rcMaxSrc = params.rcMaxSrc;
962 m_intermediaSurfaces[m_currentPipeIndex]->SampleType = params.sampleType;
963
964 intermediaSurface = m_intermediaSurfaces[m_currentPipeIndex];
965 }
966
967 VP_PUBLIC_CHK_NULL_RETURN(intermediaSurface);
968 VP_SURFACE *output = m_allocator.AllocateVpSurface(*intermediaSurface);
969 VP_PUBLIC_CHK_NULL_RETURN(output);
970 output->SurfType = SURF_OUT_RENDERTARGET;
971
972 executedFilters.AddSurface(output, false, 0);
973
974 return MOS_STATUS_SUCCESS;
975 }
976
GetCopyInstOfExtSurface(VP_SURFACE * surf)977 VP_SURFACE * VpResourceManager::GetCopyInstOfExtSurface(VP_SURFACE* surf)
978 {
979 VP_FUNC_CALL();
980
981 if (nullptr == surf || 0 == surf->GetAllocationHandle(&m_osInterface))
982 {
983 return nullptr;
984 }
985 // Do not use allocation handle as key as some parameters in VP_SURFACE
986 // may be different for same allocation, e.g. SurfType for intermedia surface.
987 auto it = m_tempSurface.find((uint64_t)surf);
988 if (it != m_tempSurface.end())
989 {
990 return it->second;
991 }
992 VP_SURFACE *surface = m_allocator.AllocateVpSurface(*surf);
993 if (surface)
994 {
995 m_tempSurface.insert(make_pair((uint64_t)surf, surface));
996 }
997 else
998 {
999 VP_PUBLIC_ASSERTMESSAGE("Allocate temp surface faild!");
1000 }
1001
1002 return surface;
1003 }
1004
AssignFcResources(VP_EXECUTE_CAPS & caps,std::vector<VP_SURFACE * > & inputSurfaces,VP_SURFACE * outputSurface,std::vector<VP_SURFACE * > & pastSurfaces,std::vector<VP_SURFACE * > & futureSurfaces,RESOURCE_ASSIGNMENT_HINT resHint,VP_SURFACE_SETTING & surfSetting)1005 MOS_STATUS VpResourceManager::AssignFcResources(VP_EXECUTE_CAPS &caps, std::vector<VP_SURFACE *> &inputSurfaces, VP_SURFACE *outputSurface,
1006 std::vector<VP_SURFACE *> &pastSurfaces, std::vector<VP_SURFACE *> &futureSurfaces,
1007 RESOURCE_ASSIGNMENT_HINT resHint, VP_SURFACE_SETTING &surfSetting)
1008 {
1009 VP_FUNC_CALL();
1010
1011 bool allocated = false;
1012 auto *skuTable = m_osInterface.pfnGetSkuTable(&m_osInterface);
1013 Mos_MemPool memTypeSurfVideoMem = MOS_MEMPOOL_VIDEOMEMORY;
1014
1015 if (skuTable && MEDIA_IS_SKU(skuTable, FtrLimitedLMemBar))
1016 {
1017 memTypeSurfVideoMem = MOS_MEMPOOL_DEVICEMEMORY;
1018 }
1019
1020 if (caps.bTemperalInputInuse)
1021 {
1022 if (inputSurfaces.size() > 1)
1023 {
1024 VP_PUBLIC_ASSERTMESSAGE("Temperal input only has 1 layer, do not support multi-layer case!");
1025 return MOS_STATUS_INVALID_PARAMETER;
1026 }
1027 surfSetting.surfGroup.insert(std::make_pair((SurfaceType)(SurfaceTypeFcInputLayer0), m_temperalInput));
1028 }
1029 else
1030 {
1031 for (size_t i = 0; i < inputSurfaces.size(); ++i)
1032 {
1033 surfSetting.surfGroup.insert(std::make_pair((SurfaceType)(SurfaceTypeFcInputLayer0 + i), inputSurfaces[i]));
1034
1035 if (!resHint.isIScalingTypeNone)
1036 {
1037 // For Interlaced scaling, 2nd field is part of the same frame.
1038 // For Field weaving, 2nd field is passed in as a ref.
1039 VP_SURFACE *surfField1Dual = nullptr;
1040 if (resHint.isFieldWeaving)
1041 {
1042 surfField1Dual = pastSurfaces[i];
1043 VP_PUBLIC_NORMALMESSAGE("Field weaving case. 2nd field is passed in as a ref.");
1044 }
1045 else
1046 {
1047 surfField1Dual = GetCopyInstOfExtSurface(inputSurfaces[i]);
1048 VP_PUBLIC_NORMALMESSAGE("Interlaced scaling. 2nd field is part of the same frame.");
1049 }
1050 VP_PUBLIC_CHK_NULL_RETURN(surfField1Dual);
1051 surfSetting.surfGroup.insert(std::make_pair((SurfaceType)(SurfaceTypeFcInputLayer0Field1Dual + i), surfField1Dual));
1052 }
1053 }
1054 }
1055 surfSetting.surfGroup.insert(std::make_pair(SurfaceTypeFcTarget0, outputSurface));
1056
1057 // Allocate auto CSC Coeff Surface
1058 VP_PUBLIC_CHK_STATUS_RETURN(m_allocator.ReAllocateSurface(
1059 m_cmfcCoeff,
1060 "CSCCoeffSurface",
1061 Format_L8,
1062 MOS_GFXRES_2D,
1063 MOS_TILE_LINEAR,
1064 VP_COMP_CMFC_COEFF_WIDTH,
1065 VP_COMP_CMFC_COEFF_HEIGHT,
1066 false,
1067 MOS_MMC_DISABLED,
1068 allocated,
1069 false,
1070 IsDeferredResourceDestroyNeeded(),
1071 MOS_HW_RESOURCE_USAGE_VP_INTERNAL_READ_RENDER,
1072 MOS_TILE_UNSET_GMM,
1073 memTypeSurfVideoMem,
1074 VPP_INTER_RESOURCE_NOTLOCKABLE));
1075
1076 surfSetting.surfGroup.insert(std::make_pair(SurfaceTypeFcCscCoeff, m_cmfcCoeff));
1077
1078 //for decompreesion sync on interlace input of FC
1079 VP_PUBLIC_CHK_STATUS_RETURN(m_allocator.ReAllocateSurface(
1080 m_decompressionSyncSurface,
1081 "AuxDecompressSyncSurface",
1082 Format_Buffer,
1083 MOS_GFXRES_BUFFER,
1084 MOS_TILE_LINEAR,
1085 32,
1086 1,
1087 false,
1088 MOS_MMC_DISABLED,
1089 allocated));
1090 surfSetting.surfGroup.insert(std::make_pair(SurfaceTypeDecompressionSync, m_decompressionSyncSurface));
1091
1092 // Allocate L0 fc inter media Surface Input
1093 for (uint32_t i = 0; i < inputSurfaces.size(); ++i)
1094 {
1095 if (inputSurfaces[i]->osSurface->Format == Format_RGBP ||
1096 inputSurfaces[i]->osSurface->Format == Format_BGRP)
1097 {
1098 VP_PUBLIC_CHK_STATUS_RETURN(m_allocator.ReAllocateSurface(
1099 m_fcIntermediaSurfaceInput[i],
1100 "fcIntermediaSurfaceInput",
1101 Format_A8R8G8B8,
1102 MOS_GFXRES_2D,
1103 MOS_TILE_Y,
1104 inputSurfaces[i]->osSurface->dwWidth,
1105 inputSurfaces[i]->osSurface->dwHeight,
1106 false,
1107 MOS_MMC_DISABLED,
1108 allocated,
1109 false,
1110 IsDeferredResourceDestroyNeeded(),
1111 MOS_HW_RESOURCE_USAGE_VP_INTERNAL_READ_WRITE_RENDER));
1112 m_fcIntermediaSurfaceInput[i]->osSurface->Format = Format_A8R8G8B8;
1113 }
1114 else if (inputSurfaces[i]->osSurface->Format == Format_444P)
1115 {
1116 VP_PUBLIC_CHK_STATUS_RETURN(m_allocator.ReAllocateSurface(
1117 m_fcIntermediaSurfaceInput[i],
1118 "fcIntermediaSurfaceInput",
1119 Format_AYUV,
1120 MOS_GFXRES_2D,
1121 MOS_TILE_Y,
1122 inputSurfaces[i]->osSurface->dwWidth,
1123 inputSurfaces[i]->osSurface->dwHeight,
1124 false,
1125 MOS_MMC_DISABLED,
1126 allocated,
1127 false,
1128 IsDeferredResourceDestroyNeeded(),
1129 MOS_HW_RESOURCE_USAGE_VP_INTERNAL_READ_WRITE_RENDER));
1130 m_fcIntermediaSurfaceInput[i]->osSurface->Format = Format_AYUV;
1131 }
1132
1133 surfSetting.surfGroup.insert(std::make_pair((SurfaceType)(SurfaceTypeFcIntermediaInput + i), m_fcIntermediaSurfaceInput[i]));
1134 }
1135 return MOS_STATUS_SUCCESS;
1136 }
1137
AssignRenderResource(VP_EXECUTE_CAPS & caps,std::vector<VP_SURFACE * > & inputSurfaces,VP_SURFACE * outputSurface,std::vector<VP_SURFACE * > & pastSurfaces,std::vector<VP_SURFACE * > & futureSurfaces,RESOURCE_ASSIGNMENT_HINT resHint,VP_SURFACE_SETTING & surfSetting,SwFilterPipe & executedFilters)1138 MOS_STATUS VpResourceManager::AssignRenderResource(VP_EXECUTE_CAPS &caps, std::vector<VP_SURFACE *> &inputSurfaces, VP_SURFACE *outputSurface,
1139 std::vector<VP_SURFACE *> &pastSurfaces, std::vector<VP_SURFACE *> &futureSurfaces, RESOURCE_ASSIGNMENT_HINT resHint, VP_SURFACE_SETTING &surfSetting, SwFilterPipe& executedFilters)
1140 {
1141 VP_FUNC_CALL();
1142
1143 if (caps.bComposite)
1144 {
1145 VP_PUBLIC_CHK_STATUS_RETURN(AssignFcResources(caps, inputSurfaces, outputSurface, pastSurfaces, futureSurfaces, resHint, surfSetting));
1146 }
1147 else if (caps.b3DLutCalc)
1148 {
1149 VP_PUBLIC_CHK_STATUS_RETURN(Assign3DLutKernelResource(caps, resHint, surfSetting));
1150 }
1151 else if (caps.bHVSCalc)
1152 {
1153 VP_PUBLIC_CHK_STATUS_RETURN(AssignHVSKernelResource(caps, resHint, surfSetting));
1154 }
1155 else if (caps.bRenderHdr)
1156 {
1157 VP_PUBLIC_CHK_STATUS_RETURN(AssignHdrResource(caps, inputSurfaces, outputSurface, resHint, surfSetting, executedFilters));
1158 }
1159 else
1160 {
1161 if (1 != inputSurfaces.size())
1162 {
1163 VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
1164 }
1165 surfSetting.surfGroup.insert(std::make_pair(SurfaceTypeRenderInput, inputSurfaces[0]));
1166 VP_PUBLIC_CHK_STATUS_RETURN(AssignVeboxResourceForRender(caps, inputSurfaces[0], resHint, surfSetting));
1167 }
1168 return MOS_STATUS_SUCCESS;
1169 }
1170
AssignVeboxResourceForRender(VP_EXECUTE_CAPS & caps,VP_SURFACE * inputSurface,RESOURCE_ASSIGNMENT_HINT resHint,VP_SURFACE_SETTING & surfSetting)1171 MOS_STATUS VpResourceManager::AssignVeboxResourceForRender(VP_EXECUTE_CAPS &caps, VP_SURFACE *inputSurface, RESOURCE_ASSIGNMENT_HINT resHint, VP_SURFACE_SETTING &surfSetting)
1172 {
1173 VP_FUNC_CALL();
1174
1175 if (!caps.bRender)
1176 {
1177 return MOS_STATUS_INVALID_PARAMETER;
1178 }
1179
1180 return MOS_STATUS_SUCCESS;
1181 }
1182
AssignExecuteResource(std::vector<FeatureType> & featurePool,VP_EXECUTE_CAPS & caps,SwFilterPipe & executedFilters)1183 MOS_STATUS VpResourceManager::AssignExecuteResource(std::vector<FeatureType> &featurePool, VP_EXECUTE_CAPS& caps, SwFilterPipe &executedFilters)
1184 {
1185 VP_FUNC_CALL();
1186
1187 std::vector<VP_SURFACE *> inputSurfaces, pastSurfaces, futureSurfaces;
1188 for (uint32_t i = 0; i < executedFilters.GetSurfaceCount(true); ++i)
1189 {
1190 VP_SURFACE *inputSurface = GetCopyInstOfExtSurface(executedFilters.GetSurface(true, i));
1191 VP_PUBLIC_CHK_NULL_RETURN(inputSurface);
1192 inputSurfaces.push_back(inputSurface);
1193
1194 VP_SURFACE *pastSurface = GetCopyInstOfExtSurface(executedFilters.GetPastSurface(i));
1195 pastSurfaces.push_back(pastSurface ? pastSurface : nullptr);
1196
1197 VP_SURFACE *futureSurface = GetCopyInstOfExtSurface(executedFilters.GetFutureSurface(i));
1198 futureSurfaces.push_back(futureSurface ? futureSurface : nullptr);
1199 }
1200 VP_SURFACE *outputSurface = GetCopyInstOfExtSurface(executedFilters.GetSurface(false, 0));
1201
1202 RESOURCE_ASSIGNMENT_HINT resHint = {};
1203
1204 if (caps.bVebox && (caps.bDI || caps.bDiProcess2ndField))
1205 {
1206 m_isPastFrameVeboxDiUsed = true;
1207 }
1208 else
1209 {
1210 m_isPastFrameVeboxDiUsed = false;
1211 }
1212
1213 VP_PUBLIC_CHK_STATUS_RETURN(GetResourceHint(featurePool, executedFilters, resHint));
1214
1215 if (nullptr == outputSurface && IsOutputSurfaceNeeded(caps))
1216 {
1217 VP_PUBLIC_CHK_STATUS_RETURN(AssignIntermediaSurface(caps, executedFilters));
1218 outputSurface = GetCopyInstOfExtSurface(executedFilters.GetSurface(false, 0));
1219 VP_PUBLIC_CHK_NULL_RETURN(outputSurface);
1220 }
1221
1222 VP_PUBLIC_CHK_STATUS_RETURN(AssignExecuteResource(caps, inputSurfaces, outputSurface,
1223 pastSurfaces, futureSurfaces, resHint, executedFilters.GetSurfacesSetting(), executedFilters));
1224 ++m_currentPipeIndex;
1225 return MOS_STATUS_SUCCESS;
1226 }
1227
GetUpdatedExecuteResource(std::vector<FeatureType> & featurePool,VP_EXECUTE_CAPS & caps,SwFilterPipe & swfilterPipe,VP_SURFACE_SETTING & surfSetting)1228 MOS_STATUS VpResourceManager::GetUpdatedExecuteResource(std::vector<FeatureType> &featurePool, VP_EXECUTE_CAPS &caps, SwFilterPipe &swfilterPipe, VP_SURFACE_SETTING &surfSetting)
1229 {
1230 VP_FUNC_CALL();
1231
1232 std::vector<VP_SURFACE *> inputSurfaces, pastSurfaces, futureSurfaces;
1233 for (uint32_t i = 0; i < swfilterPipe.GetSurfaceCount(true); ++i)
1234 {
1235 VP_SURFACE *inputSurface = GetCopyInstOfExtSurface(swfilterPipe.GetSurface(true, i));
1236 VP_PUBLIC_CHK_NULL_RETURN(inputSurface);
1237 inputSurfaces.push_back(inputSurface);
1238
1239 VP_SURFACE *pastSurface = GetCopyInstOfExtSurface(swfilterPipe.GetPastSurface(i));
1240 pastSurfaces.push_back(pastSurface ? pastSurface : nullptr);
1241
1242 VP_SURFACE *futureSurface = GetCopyInstOfExtSurface(swfilterPipe.GetFutureSurface(i));
1243 futureSurfaces.push_back(futureSurface ? futureSurface : nullptr);
1244 }
1245 VP_SURFACE *outputSurface = GetCopyInstOfExtSurface(swfilterPipe.GetSurface(false, 0));
1246
1247 RESOURCE_ASSIGNMENT_HINT resHint = {};
1248
1249 VP_PUBLIC_CHK_STATUS_RETURN(GetResourceHint(featurePool, swfilterPipe, resHint));
1250
1251 VP_PUBLIC_CHK_STATUS_RETURN(AssignExecuteResource(caps, inputSurfaces, outputSurface,
1252 pastSurfaces, futureSurfaces, resHint, surfSetting, swfilterPipe));
1253 ++m_currentPipeIndex;
1254
1255 return MOS_STATUS_SUCCESS;
1256 }
1257
AssignExecuteResource(VP_EXECUTE_CAPS & caps,std::vector<VP_SURFACE * > & inputSurfaces,VP_SURFACE * outputSurface,std::vector<VP_SURFACE * > & pastSurfaces,std::vector<VP_SURFACE * > & futureSurfaces,RESOURCE_ASSIGNMENT_HINT resHint,VP_SURFACE_SETTING & surfSetting,SwFilterPipe & executedFilters)1258 MOS_STATUS VpResourceManager::AssignExecuteResource(VP_EXECUTE_CAPS& caps, std::vector<VP_SURFACE *> &inputSurfaces, VP_SURFACE *outputSurface,
1259 std::vector<VP_SURFACE *> &pastSurfaces, std::vector<VP_SURFACE *> &futureSurfaces, RESOURCE_ASSIGNMENT_HINT resHint, VP_SURFACE_SETTING &surfSetting, SwFilterPipe& executedFilters)
1260 {
1261 VP_FUNC_CALL();
1262
1263 surfSetting.Clean();
1264
1265 if (caps.bVebox || caps.bDnKernelUpdate)
1266 {
1267 // Create Vebox Resources
1268 VP_PUBLIC_CHK_STATUS_RETURN(AssignVeboxResource(caps, inputSurfaces[0], outputSurface, pastSurfaces[0], futureSurfaces[0], resHint, surfSetting, executedFilters));
1269 }
1270
1271 if (caps.bRender)
1272 {
1273 VP_PUBLIC_CHK_STATUS_RETURN(AssignRenderResource(caps, inputSurfaces, outputSurface, pastSurfaces, futureSurfaces, resHint, surfSetting, executedFilters));
1274 }
1275
1276 return MOS_STATUS_SUCCESS;
1277 }
1278
GetDemosaicOutputColorSpace(VPHAL_CSPACE colorSpace)1279 VPHAL_CSPACE GetDemosaicOutputColorSpace(VPHAL_CSPACE colorSpace)
1280 {
1281 return IS_COLOR_SPACE_BT2020(colorSpace) ? CSpace_BT2020_RGB : CSpace_sRGB;
1282 }
1283
GetDemosaicOutputFormat(VPHAL_CSPACE colorSpace)1284 MOS_FORMAT GetDemosaicOutputFormat(VPHAL_CSPACE colorSpace)
1285 {
1286 return IS_COLOR_SPACE_BT2020(colorSpace) ? Format_R10G10B10A2 : Format_A8B8G8R8;
1287 }
1288
GetVeboxOutputParams(VP_EXECUTE_CAPS & executeCaps,MOS_FORMAT inputFormat,MOS_TILE_TYPE inputTileType,MOS_FORMAT outputFormat,MOS_FORMAT & veboxOutputFormat,MOS_TILE_TYPE & veboxOutputTileType,VPHAL_CSPACE colorSpaceOutput)1289 MOS_STATUS GetVeboxOutputParams(VP_EXECUTE_CAPS &executeCaps, MOS_FORMAT inputFormat, MOS_TILE_TYPE inputTileType, MOS_FORMAT outputFormat,
1290 MOS_FORMAT &veboxOutputFormat, MOS_TILE_TYPE &veboxOutputTileType, VPHAL_CSPACE colorSpaceOutput)
1291 {
1292 VP_FUNC_CALL();
1293
1294 // Vebox Chroma Co-Sited downsampleing is part of VEO. It only affects format of vebox output surface, but not
1295 // affect sfc input format, that's why different logic between GetSfcInputFormat and GetVeboxOutputParams.
1296 // Check DI first and downsampling to NV12 if possible to save bandwidth no matter IECP enabled or not.
1297 if (executeCaps.b3DlutOutput)
1298 {
1299 if (IS_RGB64_FLOAT_FORMAT(outputFormat)) // SFC output FP16, YUV->ABGR16
1300 {
1301 veboxOutputFormat = Format_A16B16G16R16;
1302 }
1303 else
1304 {
1305 veboxOutputFormat = IS_COLOR_SPACE_BT2020(colorSpaceOutput) ? Format_R10G10B10A2 : Format_A8B8G8R8;
1306 }
1307 veboxOutputTileType = inputTileType;
1308 }
1309 else if (executeCaps.bDI || executeCaps.bDiProcess2ndField)
1310 {
1311 // NV12 will be used if target output is not YUV2 to save bandwidth.
1312 if (outputFormat == Format_YUY2)
1313 {
1314 veboxOutputFormat = Format_YUY2;
1315 }
1316 else
1317 {
1318 veboxOutputFormat = Format_NV12;
1319 }
1320 veboxOutputTileType = MOS_TILE_Y;
1321 }
1322 else if (executeCaps.bIECP && executeCaps.bCGC && executeCaps.bBt2020ToRGB)
1323 {
1324 veboxOutputFormat = Format_A8B8G8R8;
1325 veboxOutputTileType = inputTileType;
1326 }
1327 else if (executeCaps.bIECP)
1328 {
1329 // Upsampling to yuv444 for IECP input/output.
1330 // To align with legacy path, need to check whether inputFormat can also be used for IECP case,
1331 // in which case IECP down sampling will be applied.
1332 veboxOutputFormat = Format_AYUV;
1333 veboxOutputTileType = inputTileType;
1334 }
1335 else if (executeCaps.bDemosaicInUse)
1336 {
1337 veboxOutputFormat = GetDemosaicOutputFormat(colorSpaceOutput);
1338 veboxOutputTileType = inputTileType;
1339 }
1340 else
1341 {
1342 veboxOutputFormat = inputFormat;
1343 veboxOutputTileType = inputTileType;
1344 }
1345
1346 return MOS_STATUS_SUCCESS;
1347 }
1348
1349
GetSfcInputFormat(VP_EXECUTE_CAPS & executeCaps,MOS_FORMAT inputFormat,VPHAL_CSPACE colorSpaceOutput,MOS_FORMAT outputFormat)1350 MOS_FORMAT GetSfcInputFormat(VP_EXECUTE_CAPS &executeCaps, MOS_FORMAT inputFormat, VPHAL_CSPACE colorSpaceOutput, MOS_FORMAT outputFormat)
1351 {
1352 VP_FUNC_CALL();
1353
1354 // Vebox Chroma Co-Sited downsampling is part of VEO. It only affects format of vebox output surface, but not
1355 // affect sfc input format, that's why different logic between GetSfcInputFormat and GetVeboxOutputParams.
1356 // Check HDR case first, since 3DLUT output is fixed RGB32.
1357 // Then Check IECP, since IECP is done after DI, and the vebox downsampling not affect the vebox input.
1358 if (executeCaps.b3DlutOutput)
1359 {
1360 if (IS_RGB64_FLOAT_FORMAT(outputFormat)) // SFC output FP16, YUV->ABGR16
1361 {
1362 return Format_A16B16G16R16;
1363 }
1364 else
1365 {
1366 return IS_COLOR_SPACE_BT2020(colorSpaceOutput) ? Format_R10G10B10A2 : Format_A8B8G8R8;
1367 }
1368 }
1369 else if (executeCaps.bIECP && executeCaps.bCGC && executeCaps.bBt2020ToRGB)
1370 {
1371 // Upsampling to RGB444, and using ABGR as Vebox output
1372 return Format_A8B8G8R8;
1373 }
1374 else if (executeCaps.bIECP)
1375 {
1376 // Upsampling to yuv444 for IECP input/output.
1377 // To align with legacy path, need to check whether inputFormat can also be used for IECP case,
1378 // in which case IECP down sampling will be applied.
1379 return Format_AYUV;
1380 }
1381 else if (executeCaps.bDI)
1382 {
1383 // If the input is 4:2:0, then chroma data is doubled vertically to 4:2:2
1384 // For executeCaps.bDiProcess2ndField, no DI enabled in vebox, so no need
1385 // set to YUY2 here.
1386 return Format_YUY2;
1387 }
1388 else if (executeCaps.bDemosaicInUse)
1389 {
1390 return GetDemosaicOutputFormat(colorSpaceOutput);
1391 }
1392
1393 return inputFormat;
1394 }
1395
ReAllocateVeboxOutputSurface(VP_EXECUTE_CAPS & caps,VP_SURFACE * inputSurface,VP_SURFACE * outputSurface,bool & allocated)1396 MOS_STATUS VpResourceManager::ReAllocateVeboxOutputSurface(VP_EXECUTE_CAPS& caps, VP_SURFACE *inputSurface, VP_SURFACE *outputSurface, bool &allocated)
1397 {
1398 VP_FUNC_CALL();
1399
1400 MOS_RESOURCE_MMC_MODE surfCompressionMode = MOS_MMC_DISABLED;
1401 bool bSurfCompressible = false;
1402 uint32_t i = 0;
1403 auto *skuTable = m_osInterface.pfnGetSkuTable(&m_osInterface);
1404 Mos_MemPool memTypeSurfVideoMem = MOS_MEMPOOL_VIDEOMEMORY;
1405
1406 VP_PUBLIC_CHK_NULL_RETURN(inputSurface);
1407 VP_PUBLIC_CHK_NULL_RETURN(inputSurface->osSurface);
1408 VP_PUBLIC_CHK_NULL_RETURN(outputSurface);
1409 VP_PUBLIC_CHK_NULL_RETURN(outputSurface->osSurface);
1410
1411 if (skuTable && MEDIA_IS_SKU(skuTable, FtrLimitedLMemBar))
1412 {
1413 memTypeSurfVideoMem = MOS_MEMPOOL_DEVICEMEMORY;
1414 }
1415
1416 MOS_FORMAT veboxOutputFormat = inputSurface->osSurface->Format;
1417 MOS_TILE_TYPE veboxOutputTileType = inputSurface->osSurface->TileType;
1418
1419 VP_PUBLIC_CHK_STATUS_RETURN(GetVeboxOutputParams(caps, inputSurface->osSurface->Format, inputSurface->osSurface->TileType,
1420 outputSurface->osSurface->Format, veboxOutputFormat, veboxOutputTileType, outputSurface->ColorSpace));
1421
1422 allocated = false;
1423
1424 bool enableVeboxOutputSurf = false;
1425 if (m_vpUserFeatureControl)
1426 {
1427 enableVeboxOutputSurf = m_vpUserFeatureControl->IsVeboxOutputSurfEnabled();
1428 }
1429
1430 bSurfCompressible = inputSurface->osSurface->bCompressible;
1431 surfCompressionMode = inputSurface->osSurface->CompressionMode;
1432
1433 if (m_currentFrameIds.pastFrameAvailable && m_currentFrameIds.futureFrameAvailable)
1434 {
1435 // Not switch back to 2 after being set to 4.
1436 m_veboxOutputCount = 4;
1437 }
1438
1439 bool isVppInterResourceLocakable = enableVeboxOutputSurf ? VPP_INTER_RESOURCE_LOCKABLE : VPP_INTER_RESOURCE_NOTLOCKABLE;
1440
1441 for (i = 0; i < m_veboxOutputCount; i++)
1442 {
1443 VP_PUBLIC_CHK_STATUS_RETURN(m_allocator.ReAllocateSurface(
1444 m_veboxOutput[i],
1445 "VeboxSurfaceOutput",
1446 veboxOutputFormat,
1447 MOS_GFXRES_2D,
1448 veboxOutputTileType,
1449 inputSurface->osSurface->dwWidth,
1450 inputSurface->osSurface->dwHeight,
1451 bSurfCompressible,
1452 surfCompressionMode,
1453 allocated,
1454 false,
1455 IsDeferredResourceDestroyNeeded(),
1456 MOS_HW_RESOURCE_USAGE_VP_OUTPUT_PICTURE_FF,
1457 MOS_TILE_UNSET_GMM,
1458 memTypeSurfVideoMem,
1459 isVppInterResourceLocakable));
1460
1461 m_veboxOutput[i]->ColorSpace = inputSurface->ColorSpace;
1462 m_veboxOutput[i]->rcDst = inputSurface->rcDst;
1463 m_veboxOutput[i]->rcSrc = inputSurface->rcSrc;
1464 m_veboxOutput[i]->rcMaxSrc = inputSurface->rcMaxSrc;
1465
1466 m_veboxOutput[i]->SampleType = SAMPLE_PROGRESSIVE;
1467 }
1468
1469 if (allocated)
1470 {
1471 // Report Compress Status
1472 if (m_veboxOutput[0]->osSurface)
1473 {
1474 m_reporting.GetFeatures().ffdiCompressible = m_veboxOutput[0]->osSurface->bIsCompressed;
1475 m_reporting.GetFeatures().ffdiCompressMode = (uint8_t)m_veboxOutput[0]->osSurface->CompressionMode;
1476 }
1477 }
1478
1479 return MOS_STATUS_SUCCESS;
1480 }
1481
ReAllocateVeboxDenoiseOutputSurface(VP_EXECUTE_CAPS & caps,VP_SURFACE * inputSurface,bool & allocated)1482 MOS_STATUS VpResourceManager::ReAllocateVeboxDenoiseOutputSurface(VP_EXECUTE_CAPS& caps, VP_SURFACE *inputSurface, bool &allocated)
1483 {
1484 VP_FUNC_CALL();
1485
1486 MOS_RESOURCE_MMC_MODE surfCompressionMode = MOS_MMC_DISABLED;
1487 bool bSurfCompressible = false;
1488 MOS_TILE_MODE_GMM tileModeByForce = MOS_TILE_UNSET_GMM;
1489 auto * skuTable = m_osInterface.pfnGetSkuTable(&m_osInterface);
1490 auto * waTable = m_osInterface.pfnGetWaTable(&m_osInterface);
1491 Mos_MemPool memTypeSurfVideoMem = MOS_MEMPOOL_VIDEOMEMORY;
1492 uint32_t dwHeight;
1493 MOS_TILE_TYPE TileType;
1494
1495 VP_PUBLIC_CHK_NULL_RETURN(inputSurface);
1496 VP_PUBLIC_CHK_NULL_RETURN(inputSurface->osSurface);
1497
1498 if (skuTable)
1499 {
1500 //DN output surface must be tile64 only when input format is bayer
1501 if (!MEDIA_IS_SKU(skuTable, FtrTileY) &&
1502 IS_BAYER_FORMAT(inputSurface->osSurface->Format))
1503 {
1504 tileModeByForce = MOS_TILE_64_GMM;
1505 }
1506
1507 if (MEDIA_IS_SKU(skuTable, FtrLimitedLMemBar))
1508 {
1509 memTypeSurfVideoMem = MOS_MEMPOOL_DEVICEMEMORY;
1510 }
1511 }
1512
1513 allocated = false;
1514
1515 bSurfCompressible = inputSurface->osSurface->bCompressible;
1516 surfCompressionMode = inputSurface->osSurface->CompressionMode;
1517
1518 if (caps.bCappipe)
1519 {
1520 bSurfCompressible = false;
1521 surfCompressionMode = MOS_MMC_DISABLED;
1522 // Add 4 to input height for DN and STMM if Bayer Pattern offset is 10 or 11
1523 if (IS_BAYER_GRBG_FORMAT(inputSurface->osSurface->Format) ||
1524 IS_BAYER_GBRG_FORMAT(inputSurface->osSurface->Format))
1525 {
1526 dwHeight = inputSurface->osSurface->dwHeight + 4;
1527 }
1528 else
1529 {
1530 dwHeight = inputSurface->osSurface->dwHeight;
1531 }
1532 // For Bayer pattern inputs only the Current Denoised Output/Previous Denoised Input are in Tile-Y
1533 TileType = IS_BAYER_FORMAT(inputSurface->osSurface->Format) ? MOS_TILE_Y : inputSurface->osSurface->TileType;
1534 }
1535 else
1536 {
1537 dwHeight = inputSurface->osSurface->dwHeight;
1538 TileType = inputSurface->osSurface->TileType;
1539 }
1540
1541 for (uint32_t i = 0; i < VP_NUM_DN_SURFACES; i++)
1542 {
1543 VP_PUBLIC_CHK_STATUS_RETURN(m_allocator.ReAllocateSurface(
1544 m_veboxDenoiseOutput[i],
1545 "VeboxFFDNSurface",
1546 inputSurface->osSurface->Format,
1547 MOS_GFXRES_2D,
1548 TileType,
1549 inputSurface->osSurface->dwWidth,
1550 dwHeight,
1551 bSurfCompressible,
1552 surfCompressionMode,
1553 allocated,
1554 false,
1555 IsDeferredResourceDestroyNeeded(),
1556 MOS_HW_RESOURCE_USAGE_VP_INPUT_REFERENCE_FF,
1557 tileModeByForce,
1558 memTypeSurfVideoMem,
1559 VPP_INTER_RESOURCE_NOTLOCKABLE));
1560
1561 // DN output surface state should be able to share with vebox input surface state
1562 if (m_veboxDenoiseOutput[i]->osSurface &&
1563 (m_veboxDenoiseOutput[i]->osSurface->YoffsetForUplane != inputSurface->osSurface->YoffsetForUplane || m_veboxDenoiseOutput[i]->osSurface->YoffsetForVplane != inputSurface->osSurface->YoffsetForVplane))
1564 {
1565 VP_PUBLIC_ASSERTMESSAGE("Vebox surface state of DN output surface doesn't align with input surface!");
1566 VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_UNKNOWN);
1567 }
1568
1569 // if allocated, pVeboxState->PastSurface is not valid for DN reference.
1570 if (allocated)
1571 {
1572 // If DI is enabled, try to use app's reference if provided
1573 if (caps.bRefValid && caps.bDI)
1574 {
1575 //CopySurfaceValue(pVeboxState->m_previousSurface, pVeboxState->m_currentSurface->pBwdRef);
1576 }
1577 else
1578 {
1579 caps.bRefValid = false;
1580 }
1581 // Report Compress Status
1582 if (m_veboxDenoiseOutput[i]->osSurface)
1583 {
1584 m_reporting.GetFeatures().ffdnCompressible = m_veboxDenoiseOutput[i]->osSurface->bIsCompressed;
1585 m_reporting.GetFeatures().ffdnCompressMode = (uint8_t)m_veboxDenoiseOutput[i]->osSurface->CompressionMode;
1586 }
1587 }
1588 else
1589 {
1590 caps.bRefValid = true;
1591 }
1592
1593 // DN's output format should be same to input
1594 m_veboxDenoiseOutput[i]->SampleType =
1595 inputSurface->SampleType;
1596
1597 // Set Colorspace of FFDN
1598 m_veboxDenoiseOutput[i]->ColorSpace = inputSurface->ColorSpace;
1599
1600 // Copy FrameID and parameters, as DN output will be used as next blt's current
1601 m_veboxDenoiseOutput[i]->FrameID = inputSurface->FrameID;
1602
1603 // Place Holder to update report for debug purpose
1604 }
1605 return MOS_STATUS_SUCCESS;
1606 }
1607
1608 // Allocate STMM (Spatial-Temporal Motion Measure) Surfaces
ReAllocateVeboxSTMMSurface(VP_EXECUTE_CAPS & caps,VP_SURFACE * inputSurface,bool & allocated)1609 MOS_STATUS VpResourceManager::ReAllocateVeboxSTMMSurface(VP_EXECUTE_CAPS& caps, VP_SURFACE *inputSurface, bool &allocated)
1610 {
1611 VP_FUNC_CALL();
1612
1613 MOS_RESOURCE_MMC_MODE surfCompressionMode = MOS_MMC_DISABLED;
1614 bool bSurfCompressible = false;
1615 uint32_t i = 0;
1616 MOS_TILE_MODE_GMM tileModeByForce = MOS_TILE_UNSET_GMM;
1617 auto * skuTable = m_osInterface.pfnGetSkuTable(&m_osInterface);
1618 Mos_MemPool memTypeHistStat = GetHistStatMemType(caps);
1619 uint32_t dwHeight;
1620
1621 //STMM surface can be not lockable, if secure mode is enabled
1622 bool isSTMMNotLockable = caps.bSecureVebox;
1623
1624 VP_PUBLIC_CHK_NULL_RETURN(inputSurface);
1625 VP_PUBLIC_CHK_NULL_RETURN(inputSurface->osSurface);
1626
1627 if (skuTable && !MEDIA_IS_SKU(skuTable, FtrTileY))
1628 {
1629 tileModeByForce = MOS_TILE_64_GMM;
1630 }
1631
1632 if (caps.bCappipe)
1633 {
1634 // Add 4 to input height for DN and STMM if Bayer Pattern offset is 10 or 11
1635 if (IS_BAYER_GRBG_FORMAT(inputSurface->osSurface->Format) ||
1636 IS_BAYER_GBRG_FORMAT(inputSurface->osSurface->Format))
1637 {
1638 dwHeight = inputSurface->osSurface->dwHeight + 4;
1639 }
1640 else
1641 {
1642 dwHeight = inputSurface->osSurface->dwHeight;
1643 }
1644 }
1645 else
1646 {
1647 dwHeight = inputSurface->osSurface->dwHeight;
1648 }
1649
1650 allocated = false;
1651 for (i = 0; i < VP_NUM_STMM_SURFACES; i++)
1652 {
1653 VP_PUBLIC_CHK_STATUS_RETURN(m_allocator.ReAllocateSurface(
1654 m_veboxSTMMSurface[i],
1655 "VeboxSTMMSurface",
1656 Format_STMM,
1657 MOS_GFXRES_2D,
1658 MOS_TILE_Y,
1659 inputSurface->osSurface->dwWidth,
1660 dwHeight,
1661 bSurfCompressible,
1662 surfCompressionMode,
1663 allocated,
1664 false,
1665 IsDeferredResourceDestroyNeeded(),
1666 MOS_HW_RESOURCE_USAGE_VP_INTERNAL_READ_WRITE_FF,
1667 tileModeByForce,
1668 memTypeHistStat,
1669 isSTMMNotLockable));
1670
1671 if (allocated)
1672 {
1673 VP_PUBLIC_CHK_NULL_RETURN(m_veboxSTMMSurface[i]);
1674 // Report Compress Status
1675 m_reporting.GetFeatures().stmmCompressible = bSurfCompressible;
1676 m_reporting.GetFeatures().stmmCompressMode = (uint8_t)surfCompressionMode;
1677 }
1678 }
1679 return MOS_STATUS_SUCCESS;
1680 }
1681
DestoryVeboxOutputSurface()1682 void VpResourceManager::DestoryVeboxOutputSurface()
1683 {
1684 VP_FUNC_CALL();
1685
1686 for (uint32_t i = 0; i < VP_MAX_NUM_VEBOX_SURFACES; i++)
1687 {
1688 m_allocator.DestroyVpSurface(m_veboxOutput[i], IsDeferredResourceDestroyNeeded());
1689 }
1690 }
1691
DestoryVeboxDenoiseOutputSurface()1692 void VpResourceManager::DestoryVeboxDenoiseOutputSurface()
1693 {
1694 VP_FUNC_CALL();
1695
1696 for (uint32_t i = 0; i < VP_NUM_DN_SURFACES; i++)
1697 {
1698 m_allocator.DestroyVpSurface(m_veboxDenoiseOutput[i], IsDeferredResourceDestroyNeeded());
1699 }
1700 }
1701
DestoryVeboxSTMMSurface()1702 void VpResourceManager::DestoryVeboxSTMMSurface()
1703 {
1704 VP_FUNC_CALL();
1705
1706 // Free DI history buffers (STMM = Spatial-temporal motion measure)
1707 for (uint32_t i = 0; i < VP_NUM_STMM_SURFACES; i++)
1708 {
1709 m_allocator.DestroyVpSurface(m_veboxSTMMSurface[i], IsDeferredResourceDestroyNeeded());
1710 }
1711 }
1712
FillLinearBufferWithEncZero(VP_SURFACE * surface,uint32_t width,uint32_t height)1713 MOS_STATUS VpResourceManager::FillLinearBufferWithEncZero(VP_SURFACE *surface, uint32_t width, uint32_t height)
1714 {
1715 VP_FUNC_CALL();
1716
1717 return MOS_STATUS_SUCCESS;
1718 }
1719
Get3DLutSize(bool is33LutSizeEnabled,uint32_t & lutWidth,uint32_t & lutHeight)1720 uint32_t VpResourceManager::Get3DLutSize(bool is33LutSizeEnabled, uint32_t &lutWidth, uint32_t &lutHeight)
1721 {
1722 VP_FUNC_CALL();
1723
1724 if (is33LutSizeEnabled)
1725 {
1726 lutWidth = LUT33_SEG_SIZE * 2;
1727 lutHeight = LUT33_SEG_SIZE * LUT33_MUL_SIZE;
1728 VP_RENDER_NORMALMESSAGE("3DLut table is used 33 lutsize.");
1729 return VP_VEBOX_HDR_3DLUT33;
1730 }
1731 else
1732 {
1733 lutWidth = LUT65_SEG_SIZE * 2;
1734 lutHeight = LUT65_SEG_SIZE * LUT65_MUL_SIZE;
1735 return VP_VEBOX_HDR_3DLUT65;
1736 }
1737 }
1738
Get1DLutSize()1739 uint32_t VpResourceManager::Get1DLutSize()
1740 {
1741 VP_FUNC_CALL();
1742
1743 return SHAPE_1K_LOOKUP_SIZE;
1744 }
1745
GetHistStatMemType(VP_EXECUTE_CAPS & caps)1746 Mos_MemPool VpResourceManager::GetHistStatMemType(VP_EXECUTE_CAPS &caps)
1747 {
1748 VP_FUNC_CALL();
1749
1750 return MOS_MEMPOOL_VIDEOMEMORY;
1751 }
1752
AllocateVeboxResource(VP_EXECUTE_CAPS & caps,VP_SURFACE * inputSurface,VP_SURFACE * outputSurface)1753 MOS_STATUS VpResourceManager::AllocateVeboxResource(VP_EXECUTE_CAPS& caps, VP_SURFACE *inputSurface, VP_SURFACE *outputSurface)
1754 {
1755 VP_FUNC_CALL();
1756 MOS_FORMAT format;
1757 MOS_TILE_TYPE TileType;
1758 uint32_t dwWidth;
1759 uint32_t dwHeight;
1760 uint32_t dwSize;
1761 uint32_t i;
1762 MOS_RESOURCE_MMC_MODE surfCompressionMode = MOS_MMC_DISABLED;
1763 bool bSurfCompressible = false;
1764 bool bAllocated = false;
1765 uint8_t InitValue = 0;
1766 Mos_MemPool memTypeHistStat = GetHistStatMemType(caps);
1767 bool isStatisticsBufNotLockable = false;
1768
1769 VP_PUBLIC_CHK_NULL_RETURN(inputSurface);
1770 VP_PUBLIC_CHK_NULL_RETURN(inputSurface->osSurface);
1771 VP_PUBLIC_CHK_NULL_RETURN(outputSurface);
1772 VP_PUBLIC_CHK_NULL_RETURN(outputSurface->osSurface);
1773
1774 // change the init value when null hw is enabled
1775 if (m_osInterface.bNullHwIsEnabled)
1776 {
1777 InitValue = 0x80;
1778 }
1779
1780 if (IS_VP_VEBOX_DN_ONLY(caps))
1781 {
1782 bSurfCompressible = inputSurface->osSurface->bCompressible;
1783 surfCompressionMode = inputSurface->osSurface->CompressionMode;
1784 }
1785 else
1786 {
1787 bSurfCompressible = true;
1788 surfCompressionMode = MOS_MMC_MC;
1789 }
1790
1791 // Decide DN output surface
1792 if (VeboxOutputNeeded(caps))
1793 {
1794 VP_PUBLIC_CHK_STATUS_RETURN(ReAllocateVeboxOutputSurface(caps, inputSurface, outputSurface, bAllocated));
1795 }
1796 else
1797 {
1798 DestoryVeboxOutputSurface();
1799 }
1800
1801 if (VeboxDenoiseOutputNeeded(caps))
1802 {
1803 VP_PUBLIC_CHK_STATUS_RETURN(ReAllocateVeboxDenoiseOutputSurface(caps, inputSurface, bAllocated));
1804 if (bAllocated)
1805 {
1806 m_currentDnOutput = 0;
1807 m_pastDnOutputValid = false;
1808 }
1809 }
1810 else
1811 {
1812 DestoryVeboxDenoiseOutputSurface();
1813 m_pastDnOutputValid = false;
1814 }
1815
1816 if (VeboxSTMMNeeded(caps, false))
1817 {
1818 VP_PUBLIC_CHK_STATUS_RETURN(ReAllocateVeboxSTMMSurface(caps, inputSurface, bAllocated));
1819 if (bAllocated)
1820 {
1821 m_currentStmmIndex = 0;
1822 }
1823 }
1824 else
1825 {
1826 DestoryVeboxSTMMSurface();
1827 }
1828
1829 #if VEBOX_AUTO_DENOISE_SUPPORTED
1830 if (caps.bDnKernelUpdate)
1831 {
1832 // Allocate Temp Surface for Vebox Update kernels----------------------------------------
1833 // the surface size is one Page
1834 dwSize = MHW_PAGE_SIZE;
1835 VP_PUBLIC_CHK_STATUS_RETURN(m_allocator.ReAllocateSurface(
1836 m_veboxDNTempSurface,
1837 "VeboxDNTempSurface",
1838 Format_Buffer,
1839 MOS_GFXRES_BUFFER,
1840 MOS_TILE_LINEAR,
1841 dwSize,
1842 1,
1843 false,
1844 MOS_MMC_DISABLED,
1845 bAllocated,
1846 true,
1847 IsDeferredResourceDestroyNeeded(),
1848 MOS_HW_RESOURCE_USAGE_VP_INTERNAL_READ_WRITE_FF));
1849
1850 // Allocate Spatial Attributes Configuration Surface for DN kernel Gen9+-----------
1851 dwSize = MHW_PAGE_SIZE;
1852 VP_PUBLIC_CHK_STATUS_RETURN(m_allocator.ReAllocateSurface(
1853 m_veboxDNSpatialConfigSurface,
1854 "VeboxSpatialAttributesConfigurationSurface",
1855 Format_RAW,
1856 MOS_GFXRES_BUFFER,
1857 MOS_TILE_LINEAR,
1858 dwSize,
1859 1,
1860 false,
1861 MOS_MMC_DISABLED,
1862 bAllocated,
1863 false,
1864 IsDeferredResourceDestroyNeeded(),
1865 MOS_HW_RESOURCE_USAGE_VP_INTERNAL_READ_WRITE_FF));
1866
1867 if (bAllocated)
1868 {
1869 // initialize Spatial Attributes Configuration Surface
1870 VP_PUBLIC_CHK_STATUS_RETURN(InitVeboxSpatialAttributesConfiguration());
1871 }
1872 }
1873 #endif
1874
1875 dwSize = GetHistogramSurfaceSize(caps, inputSurface->osSurface->dwWidth, inputSurface->osSurface->dwHeight);
1876
1877 VP_PUBLIC_CHK_STATUS_RETURN(m_allocator.ReAllocateSurface(
1878 m_veboxRgbHistogram,
1879 "VeboxLaceAceRgbHistogram",
1880 Format_Buffer,
1881 MOS_GFXRES_BUFFER,
1882 MOS_TILE_LINEAR,
1883 dwSize,
1884 1,
1885 false,
1886 MOS_MMC_DISABLED,
1887 bAllocated,
1888 false,
1889 IsDeferredResourceDestroyNeeded(),
1890 MOS_HW_RESOURCE_USAGE_VP_INTERNAL_WRITE_FF));
1891
1892 m_isHistogramReallocated = bAllocated;
1893
1894 if (bAllocated && m_osInterface.bNullHwIsEnabled)
1895 {
1896 // Initialize veboxRgbHistogram Surface
1897 VP_PUBLIC_CHK_STATUS_RETURN(m_allocator.OsFillResource(
1898 &(m_veboxRgbHistogram->osSurface->OsResource),
1899 dwSize,
1900 InitValue));
1901 }
1902
1903 // Allocate Statistics State Surface----------------------------------------
1904 // Width to be a aligned on 64 bytes and height is 1/4 the height
1905 // Per frame information written twice per frame for 2 slices
1906 // Surface to be a rectangle aligned with dwWidth to get proper dwSize
1907 // APG PAth need to make sure input surface width/height is what to processed width/Height
1908 uint32_t statistic_size = m_vpPlatformInterface.VeboxQueryStaticSurfaceSize();
1909 dwWidth = MOS_ALIGN_CEIL(inputSurface->osSurface->dwWidth, 64);
1910 dwHeight = MOS_ROUNDUP_DIVIDE(inputSurface->osSurface->dwHeight, 4) +
1911 MOS_ROUNDUP_DIVIDE(statistic_size * sizeof(uint32_t), dwWidth);
1912
1913 if (caps.b1stPassOfSfc2PassScaling)
1914 {
1915 VP_PUBLIC_CHK_STATUS_RETURN(ReAllocateVeboxStatisticsSurface(m_veboxStatisticsSurfacefor1stPassofSfc2Pass, caps, inputSurface, dwWidth, dwHeight));
1916 }
1917 else
1918 {
1919 VP_PUBLIC_CHK_STATUS_RETURN(ReAllocateVeboxStatisticsSurface(m_veboxStatisticsSurface, caps, inputSurface, dwWidth, dwHeight));
1920 }
1921
1922 VP_PUBLIC_CHK_STATUS_RETURN(Allocate3DLut(caps));
1923
1924 if (caps.b1K1DLutInUse)
1925 {
1926 dwSize = Get1DLutSize();
1927 VP_PUBLIC_CHK_STATUS_RETURN(m_allocator.ReAllocateSurface(
1928 m_vebox1DLookUpTables,
1929 "Dv1K1DLutTableSurface",
1930 Format_Buffer,
1931 MOS_GFXRES_BUFFER,
1932 MOS_TILE_LINEAR,
1933 dwSize,
1934 1,
1935 false,
1936 MOS_MMC_DISABLED,
1937 bAllocated,
1938 false,
1939 IsDeferredResourceDestroyNeeded()));
1940 if (!bAllocated && !caps.bDV)
1941 {
1942 caps.b1K1DLutInited = 1;
1943 }
1944 }
1945 // cappipe
1946 if (caps.enableSFCLinearOutputByTileConvert)
1947 {
1948 VP_PUBLIC_CHK_STATUS_RETURN(m_allocator.ReAllocateSurface(
1949 m_innerTileConvertInput,
1950 "TempTargetSurface",
1951 outputSurface->osSurface->Format,
1952 MOS_GFXRES_2D,
1953 MOS_TILE_Y,
1954 outputSurface->osSurface->dwWidth,
1955 outputSurface->osSurface->dwHeight,
1956 false,
1957 MOS_MMC_DISABLED,
1958 bAllocated,
1959 false,
1960 IsDeferredResourceDestroyNeeded()));
1961
1962 m_innerTileConvertInput->ColorSpace = outputSurface->ColorSpace;
1963 m_innerTileConvertInput->rcSrc = outputSurface->rcSrc;
1964 m_innerTileConvertInput->rcDst = outputSurface->rcDst;
1965 m_innerTileConvertInput->rcMaxSrc = outputSurface->rcMaxSrc;
1966 }
1967 return MOS_STATUS_SUCCESS;
1968 }
1969
Allocate3DLut(VP_EXECUTE_CAPS & caps)1970 MOS_STATUS VpResourceManager::Allocate3DLut(VP_EXECUTE_CAPS& caps)
1971 {
1972 VP_FUNC_CALL();
1973 uint32_t size = 0;
1974 bool isAllocated = false;
1975
1976 if (caps.bHDR3DLUT || caps.b3DLutCalc)
1977 {
1978 // HDR
1979 uint32_t lutWidth = 0;
1980 uint32_t lutHeight = 0;
1981 size = Get3DLutSize(caps.bHdr33lutsize, lutWidth, lutHeight);
1982 VP_PUBLIC_CHK_STATUS_RETURN(m_allocator.ReAllocateSurface(
1983 m_vebox3DLookUpTables,
1984 "Vebox3DLutTableSurface",
1985 Format_Buffer,
1986 MOS_GFXRES_BUFFER,
1987 MOS_TILE_LINEAR,
1988 size,
1989 1,
1990 false,
1991 MOS_MMC_DISABLED,
1992 isAllocated,
1993 false,
1994 IsDeferredResourceDestroyNeeded(),
1995 MOS_HW_RESOURCE_USAGE_VP_INTERNAL_READ_WRITE_RENDER));
1996
1997 }
1998
1999 return MOS_STATUS_SUCCESS;
2000 }
2001
AllocateResourceFor3DLutKernel(VP_EXECUTE_CAPS & caps)2002 MOS_STATUS VpResourceManager::AllocateResourceFor3DLutKernel(VP_EXECUTE_CAPS& caps)
2003 {
2004 VP_FUNC_CALL();
2005 uint32_t size = 0;
2006 bool isAllocated = false;
2007 uint32_t lutWidth = 0;
2008 uint32_t lutHeight = 0;
2009
2010 uint32_t sizeOf3DLut = Get3DLutSize(caps.bHdr33lutsize, lutWidth, lutHeight);
2011
2012 if (caps.bHdr33lutsize)
2013 {
2014 if (VP_VEBOX_HDR_3DLUT33 != sizeOf3DLut)
2015 {
2016 VP_PUBLIC_ASSERTMESSAGE("3DLutSize(%x) != VP_VEBOX_HDR_3DLUT33(%x)", sizeOf3DLut, VP_VEBOX_HDR_3DLUT33);
2017 VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
2018 }
2019 }
2020 else
2021 {
2022 if (VP_VEBOX_HDR_3DLUT65 != sizeOf3DLut)
2023 {
2024 VP_PUBLIC_ASSERTMESSAGE("3DLutSize(%x) != VP_VEBOX_HDR_3DLUT65(%x)", sizeOf3DLut, VP_VEBOX_HDR_3DLUT65);
2025 VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
2026 }
2027 }
2028
2029 VP_PUBLIC_CHK_STATUS_RETURN(Allocate3DLut(caps));
2030
2031 uint32_t size_coef = 8 * 8 * 4;
2032
2033 VP_PUBLIC_CHK_STATUS_RETURN(m_allocator.ReAllocateSurface(
2034 m_3DLutKernelCoefSurface,
2035 "3DLutKernelCoefSurface",
2036 Format_Buffer,
2037 MOS_GFXRES_BUFFER,
2038 MOS_TILE_LINEAR,
2039 size_coef,
2040 1,
2041 false,
2042 MOS_MMC_DISABLED,
2043 isAllocated,
2044 false,
2045 IsDeferredResourceDestroyNeeded(),
2046 MOS_HW_RESOURCE_USAGE_VP_INTERNAL_READ_WRITE_RENDER));
2047
2048 return MOS_STATUS_SUCCESS;
2049 }
2050
Assign3DLutKernelResource(VP_EXECUTE_CAPS & caps,RESOURCE_ASSIGNMENT_HINT resHint,VP_SURFACE_SETTING & surfSetting)2051 MOS_STATUS VpResourceManager::Assign3DLutKernelResource(VP_EXECUTE_CAPS &caps, RESOURCE_ASSIGNMENT_HINT resHint, VP_SURFACE_SETTING &surfSetting)
2052 {
2053 VP_FUNC_CALL();
2054
2055 VP_PUBLIC_CHK_STATUS_RETURN(AllocateResourceFor3DLutKernel(caps));
2056
2057 surfSetting.surfGroup.insert(std::make_pair(SurfaceType3DLut, m_vebox3DLookUpTables));
2058 surfSetting.surfGroup.insert(std::make_pair(SurfaceType3DLutCoef, m_3DLutKernelCoefSurface));
2059
2060 return MOS_STATUS_SUCCESS;
2061 }
2062
AllocateResourceForHVSKernel(VP_EXECUTE_CAPS & caps)2063 MOS_STATUS VpResourceManager::AllocateResourceForHVSKernel(VP_EXECUTE_CAPS &caps)
2064 {
2065 VP_FUNC_CALL();
2066 bool isAllocated = false;
2067
2068 uint32_t size = 40 * 4;
2069
2070 VP_PUBLIC_CHK_STATUS_RETURN(m_allocator.ReAllocateSurface(
2071 m_veboxDnHVSTables,
2072 "HVSKernelTableSurface",
2073 Format_Buffer,
2074 MOS_GFXRES_BUFFER,
2075 MOS_TILE_LINEAR,
2076 size,
2077 1,
2078 false,
2079 MOS_MMC_DISABLED,
2080 isAllocated,
2081 false,
2082 IsDeferredResourceDestroyNeeded(),
2083 MOS_HW_RESOURCE_USAGE_VP_INTERNAL_READ_WRITE_RENDER));
2084
2085 return MOS_STATUS_SUCCESS;
2086 }
2087
AssignHVSKernelResource(VP_EXECUTE_CAPS & caps,RESOURCE_ASSIGNMENT_HINT resHint,VP_SURFACE_SETTING & surfSetting)2088 MOS_STATUS VpResourceManager::AssignHVSKernelResource(VP_EXECUTE_CAPS &caps, RESOURCE_ASSIGNMENT_HINT resHint, VP_SURFACE_SETTING &surfSetting)
2089 {
2090 VP_FUNC_CALL();
2091
2092 VP_PUBLIC_CHK_STATUS_RETURN(AllocateResourceForHVSKernel(caps));
2093
2094 surfSetting.surfGroup.insert(std::make_pair(SurfaceTypeHVSTable, m_veboxDnHVSTables));
2095
2096 return MOS_STATUS_SUCCESS;
2097 }
2098
AssignSurface(VP_EXECUTE_CAPS caps,VEBOX_SURFACE_ID & surfaceId,SurfaceType surfaceType,VP_SURFACE * inputSurface,VP_SURFACE * outputSurface,VP_SURFACE * pastSurface,VP_SURFACE * futureSurface,VP_SURFACE_GROUP & surfGroup)2099 MOS_STATUS VpResourceManager::AssignSurface(VP_EXECUTE_CAPS caps, VEBOX_SURFACE_ID &surfaceId, SurfaceType surfaceType, VP_SURFACE *inputSurface, VP_SURFACE *outputSurface, VP_SURFACE *pastSurface, VP_SURFACE *futureSurface, VP_SURFACE_GROUP &surfGroup)
2100 {
2101 VP_FUNC_CALL();
2102
2103 switch (surfaceId)
2104 {
2105 case VEBOX_SURFACE_INPUT:
2106 if (nullptr == inputSurface)
2107 {
2108 VP_PUBLIC_ASSERTMESSAGE("inputSurface should not be nullptr when surfaceId being VEBOX_SURFACE_INPUT.");
2109 break;
2110 }
2111 surfGroup.insert(std::make_pair(surfaceType, inputSurface));
2112 break;
2113 case VEBOX_SURFACE_OUTPUT:
2114 if (nullptr == outputSurface)
2115 {
2116 VP_PUBLIC_ASSERTMESSAGE("outputSurface should not be nullptr when surfaceId being VEBOX_SURFACE_OUTPUT.");
2117 break;
2118 }
2119 surfGroup.insert(std::make_pair(surfaceType, outputSurface));
2120 break;
2121 case VEBOX_SURFACE_PAST_REF:
2122 if (caps.bDN && m_pastDnOutputValid)
2123 {
2124 surfGroup.insert(std::make_pair(surfaceType, m_veboxDenoiseOutput[(m_currentDnOutput + 1) & 1]));
2125 }
2126 else
2127 {
2128 auto curDnOutputSurface = m_veboxDenoiseOutput[m_currentDnOutput];
2129
2130 if (nullptr == pastSurface)
2131 {
2132 VP_PUBLIC_ASSERTMESSAGE("pastSurface should not be nullptr when surfaceId being VEBOX_SURFACE_PAST_REF.");
2133 break;
2134 }
2135
2136 if (!caps.bDN ||
2137 nullptr == curDnOutputSurface ||
2138 // When FtrTileY is false, DN output surface will be tile64 when input is bayer format,
2139 // while pastSurface passed by OS maybe tile4, which is different from DN output surface.
2140 // For such case, passSurface cannot be used, as vebox previous input surface and vebox
2141 // DN output surface must share same setting. The derive pitch in vebox output surface
2142 // state is for both of them. Check pitch to handle it.
2143 pastSurface->osSurface->dwPitch == curDnOutputSurface->osSurface->dwPitch)
2144 {
2145 surfGroup.insert(std::make_pair(surfaceType, pastSurface));
2146 }
2147 else
2148 {
2149 // DN case with m_pastDnOutputValid being false. pastSurface cannot be used here as pitch
2150 // of pastSurface is different from current DN output surface.
2151 VP_PUBLIC_NORMALMESSAGE("Do not use pastSurface. pastSurf (TileModeGmm: %d, pitch: %d) vs curDnOutputSurface (TileModeGmm: %d, pitch: %d)",
2152 pastSurface->osSurface->TileModeGMM,
2153 pastSurface->osSurface->dwPitch,
2154 curDnOutputSurface->osSurface->TileModeGMM,
2155 curDnOutputSurface->osSurface->dwPitch);
2156 }
2157 }
2158 break;
2159 case VEBOX_SURFACE_FUTURE_REF:
2160 if (nullptr == futureSurface)
2161 {
2162 VP_PUBLIC_ASSERTMESSAGE("futureSurface should not be nullptr when surfaceId being VEBOX_SURFACE_FUTURE_REF.");
2163 break;
2164 }
2165 surfGroup.insert(std::make_pair(surfaceType, futureSurface));
2166 break;
2167 case VEBOX_SURFACE_FRAME0:
2168 surfGroup.insert(std::make_pair(surfaceType, m_veboxOutput[(m_currentDnOutput + 0) % m_veboxOutputCount]));
2169 break;
2170 case VEBOX_SURFACE_FRAME1:
2171 surfGroup.insert(std::make_pair(surfaceType, m_veboxOutput[(m_currentDnOutput + 1) % m_veboxOutputCount]));
2172 break;
2173 case VEBOX_SURFACE_FRAME2:
2174 surfGroup.insert(std::make_pair(surfaceType, m_veboxOutput[(m_currentDnOutput + 2) % m_veboxOutputCount]));
2175 break;
2176 case VEBOX_SURFACE_FRAME3:
2177 surfGroup.insert(std::make_pair(surfaceType, m_veboxOutput[(m_currentDnOutput + 3) % m_veboxOutputCount]));
2178 break;
2179 default:
2180 break;
2181 }
2182 return MOS_STATUS_SUCCESS;
2183 }
2184
AssignVeboxResource(VP_EXECUTE_CAPS & caps,VP_SURFACE * inputSurface,VP_SURFACE * outputSurface,VP_SURFACE * pastSurface,VP_SURFACE * futureSurface,RESOURCE_ASSIGNMENT_HINT resHint,VP_SURFACE_SETTING & surfSetting,SwFilterPipe & executedFilters)2185 MOS_STATUS VpResourceManager::AssignVeboxResource(VP_EXECUTE_CAPS& caps, VP_SURFACE *inputSurface, VP_SURFACE *outputSurface,
2186 VP_SURFACE *pastSurface, VP_SURFACE *futureSurface, RESOURCE_ASSIGNMENT_HINT resHint, VP_SURFACE_SETTING &surfSetting, SwFilterPipe& executedFilters)
2187 {
2188 VP_FUNC_CALL();
2189 VP_PUBLIC_CHK_NULL_RETURN(inputSurface);
2190 VP_PUBLIC_CHK_NULL_RETURN(inputSurface->osSurface);
2191 VP_PUBLIC_CHK_NULL_RETURN(outputSurface);
2192 VP_PUBLIC_CHK_NULL_RETURN(outputSurface->osSurface);
2193
2194 MOS_FORMAT format;
2195 MOS_TILE_TYPE TileType;
2196 uint32_t dwWidth;
2197 uint32_t dwHeight;
2198 uint32_t dwSize;
2199 uint32_t i;
2200 auto& surfGroup = surfSetting.surfGroup;
2201
2202 // Render case reuse vebox resource, and don`t need re-allocate.
2203 if (!caps.bRender ||
2204 (caps.bRender && caps.bDnKernelUpdate))
2205 {
2206 VP_PUBLIC_CHK_STATUS_RETURN(AllocateVeboxResource(caps, inputSurface, outputSurface));
2207 }
2208
2209 if (caps.bDI || caps.bDiProcess2ndField)
2210 {
2211 bool b60fpsDi = resHint.b60fpsDi || caps.bDiProcess2ndField;
2212 VEBOX_SURFACES_CONFIG cfg(b60fpsDi, caps.bSFC, m_sameSamples, m_outOfBound, m_currentFrameIds.pastFrameAvailable,
2213 m_currentFrameIds.futureFrameAvailable, IsInterleaveFirstField(inputSurface->SampleType));
2214 auto it = m_veboxSurfaceConfigMap.find(cfg.value);
2215 if (m_veboxSurfaceConfigMap.end() == it)
2216 {
2217 VP_PUBLIC_ASSERTMESSAGE("SurfaceConfig is invalid, cfg.value = %d", cfg.value);
2218 VP_PUBLIC_ASSERTMESSAGE("b64Di = %d, sfcEnable = %d, sameSample = %d, outOfBound = %d, pastframeAvailable = %d, future frameAvaliable = %d, FirstDiFiels = %d",
2219 cfg.b64DI,
2220 cfg.sfcEnable,
2221 cfg.sameSample,
2222 cfg.outOfBound,
2223 cfg.pastFrameAvailable,
2224 cfg.futureFrameAvailable,
2225 cfg.firstDiField);
2226 VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
2227 }
2228 auto surfaces = it->second;
2229 VP_PUBLIC_CHK_STATUS_RETURN(AssignSurface(caps, surfaces.currentInputSurface, SurfaceTypeVeboxInput, inputSurface, outputSurface, pastSurface, futureSurface, surfSetting.surfGroup));
2230 VP_PUBLIC_CHK_STATUS_RETURN(AssignSurface(caps, surfaces.pastInputSurface, SurfaceTypeVeboxPreviousInput, inputSurface, outputSurface, pastSurface, futureSurface, surfSetting.surfGroup));
2231 VP_PUBLIC_CHK_STATUS_RETURN(AssignSurface(caps, surfaces.currentOutputSurface, SurfaceTypeVeboxCurrentOutput, inputSurface, outputSurface, pastSurface, futureSurface, surfSetting.surfGroup));
2232 VP_PUBLIC_CHK_STATUS_RETURN(AssignSurface(caps, surfaces.pastOutputSurface, SurfaceTypeVeboxPreviousOutput, inputSurface, outputSurface, pastSurface, futureSurface, surfSetting.surfGroup));
2233
2234 if (caps.bDN)
2235 {
2236 // Insert DN output surface
2237 surfGroup.insert(std::make_pair(SurfaceTypeDNOutput, m_veboxDenoiseOutput[m_currentDnOutput]));
2238 }
2239
2240 caps.bRefValid = surfGroup.find(SurfaceTypeVeboxPreviousInput) != surfGroup.end();
2241 }
2242 else
2243 {
2244 surfGroup.insert(std::make_pair(SurfaceTypeVeboxInput, inputSurface));
2245 surfGroup.insert(std::make_pair(SurfaceTypeVeboxCurrentOutput, GetVeboxOutputSurface(caps, outputSurface)));
2246
2247 if (caps.bDN)
2248 {
2249 // Insert DN output surface
2250 surfGroup.insert(std::make_pair(SurfaceTypeDNOutput, m_veboxDenoiseOutput[m_currentDnOutput]));
2251 // Insert DN Reference surface
2252 if (caps.bRefValid)
2253 {
2254 surfGroup.insert(std::make_pair(SurfaceTypeVeboxPreviousInput, m_veboxDenoiseOutput[(m_currentDnOutput + 1) & 1]));
2255 }
2256 }
2257 }
2258
2259 if (VeboxSTMMNeeded(caps, true))
2260 {
2261 // Insert STMM input surface
2262 surfGroup.insert(std::make_pair(SurfaceTypeSTMMIn, m_veboxSTMMSurface[m_currentStmmIndex]));
2263 // Insert STMM output surface
2264 surfGroup.insert(std::make_pair(SurfaceTypeSTMMOut, m_veboxSTMMSurface[(m_currentStmmIndex + 1) & 1]));
2265 }
2266
2267 #if VEBOX_AUTO_DENOISE_SUPPORTED
2268 if (caps.bDnKernelUpdate)
2269 {
2270 // Insert Vebox auto DN noise level surface
2271 surfGroup.insert(std::make_pair(SurfaceTypeAutoDNNoiseLevel, m_veboxDNTempSurface));
2272 // Insert Vebox auto DN spatial config surface/buffer
2273 surfGroup.insert(std::make_pair(SurfaceTypeAutoDNSpatialConfig, m_veboxDNSpatialConfigSurface));
2274 }
2275 #endif
2276
2277 // Insert Vebox histogram surface
2278 surfGroup.insert(std::make_pair(SurfaceTypeLaceAceRGBHistogram, m_veboxRgbHistogram));
2279
2280 // Insert Vebox statistics surface
2281 if (caps.b1stPassOfSfc2PassScaling)
2282 {
2283 surfGroup.insert(std::make_pair(SurfaceTypeStatistics, m_veboxStatisticsSurfacefor1stPassofSfc2Pass));
2284 }
2285 else
2286 {
2287 surfGroup.insert(std::make_pair(SurfaceTypeStatistics, m_veboxStatisticsSurface));
2288 }
2289 surfSetting.dwVeboxPerBlockStatisticsHeight = m_dwVeboxPerBlockStatisticsHeight;
2290 surfSetting.dwVeboxPerBlockStatisticsWidth = m_dwVeboxPerBlockStatisticsWidth;
2291
2292 if (VeboxHdr3DlutNeeded(caps))
2293 {
2294 // Insert Vebox 3Dlut surface
2295 surfGroup.insert(std::make_pair(SurfaceType3DLut, m_vebox3DLookUpTables));
2296 }
2297
2298 if (resHint.isHVSTableNeeded)
2299 {
2300 VP_PUBLIC_CHK_NULL_RETURN(m_veboxDnHVSTables);
2301 // Insert Vebox HVS DN surface
2302 surfGroup.insert(std::make_pair(SurfaceTypeHVSTable, m_veboxDnHVSTables));
2303 }
2304
2305 if (caps.b1K1DLutInUse)
2306 {
2307 // Insert DV 1Dlut surface
2308 surfGroup.insert(std::make_pair(SurfaceType1k1dLut, m_vebox1DLookUpTables));
2309 }
2310
2311 if (caps.enableSFCLinearOutputByTileConvert)
2312 {
2313 surfGroup.insert(std::make_pair(SurfaceTypeInnerTileConvertInput, m_innerTileConvertInput));
2314 }
2315
2316 // Update previous Dn output flag for next frame to use.
2317 if (surfGroup.find(SurfaceTypeDNOutput) != surfGroup.end() || m_sameSamples && m_pastDnOutputValid)
2318 {
2319 m_pastDnOutputValid = true;
2320 }
2321 else
2322 {
2323 m_pastDnOutputValid = false;
2324 }
2325
2326 return MOS_STATUS_SUCCESS;
2327 }
2328
IsOutputSurfaceNeeded(VP_EXECUTE_CAPS caps)2329 bool VpResourceManager::IsOutputSurfaceNeeded(VP_EXECUTE_CAPS caps)
2330 {
2331 VP_FUNC_CALL();
2332
2333 // check whether intermedia surface needed to create based on caps
2334 if (caps.bDnKernelUpdate || // State Heap as putput, but it was not tracked in resource manager yet
2335 caps.bVeboxSecureCopy) // State Heap as putput, but it was not tracked in resource manager yet
2336 {
2337 return false;
2338 }
2339 else
2340 {
2341 return true;
2342 }
2343 }
2344
GetVeboxOutputSurface(VP_EXECUTE_CAPS & caps,VP_SURFACE * outputSurface)2345 VP_SURFACE* VpResourceManager::GetVeboxOutputSurface(VP_EXECUTE_CAPS& caps, VP_SURFACE *outputSurface)
2346 {
2347 VP_FUNC_CALL();
2348
2349 bool enableVeboxOutputSurf = false;
2350 if (m_vpUserFeatureControl)
2351 {
2352 enableVeboxOutputSurf = m_vpUserFeatureControl->IsVeboxOutputSurfEnabled();
2353 }
2354
2355 if (caps.bRender)
2356 {
2357 // Place Holder when enable DI
2358 return nullptr;
2359 }
2360
2361 if (!caps.bSFC) // Vebox output directlly to output surface
2362 {
2363 // RenderTarget will be assigned in VpVeboxCmdPacket::GetSurface.
2364 return outputSurface;
2365 }
2366 else if (caps.bDI && caps.bVebox) // Vebox DI enable
2367 {
2368 // Place Holder when enable DI
2369 return nullptr;
2370 }
2371 else if (caps.bIECP) // SFC + IECP enabled, output to internal surface
2372 {
2373 return m_veboxOutput[m_currentDnOutput];
2374 }
2375 else if (enableVeboxOutputSurf || caps.bDN) // SFC + DN case
2376 {
2377 // DN + SFC scenario needs IECP implicitly, which need vebox output surface being assigned.
2378 // Use m_currentDnOutput to ensure m_veboxOutput surface paired with DN output surface.
2379 return m_veboxOutput[m_currentDnOutput];
2380 }
2381 else
2382 {
2383 // Write to SFC cases, Vebox output is not needed.
2384 VP_PUBLIC_NORMALMESSAGE("No need output for Vebox output");
2385 return nullptr;
2386 }
2387 }
2388
InitVeboxSpatialAttributesConfiguration()2389 MOS_STATUS VpResourceManager::InitVeboxSpatialAttributesConfiguration()
2390 {
2391 VP_FUNC_CALL();
2392
2393 VP_PUBLIC_CHK_NULL_RETURN(m_veboxDNSpatialConfigSurface);
2394 VP_PUBLIC_CHK_NULL_RETURN(m_veboxDNSpatialConfigSurface->osSurface);
2395
2396 uint8_t* data = (uint8_t*)& g_cInit_VEBOX_SPATIAL_ATTRIBUTES_CONFIGURATIONS;
2397 return m_allocator.Write1DSurface(m_veboxDNSpatialConfigSurface, data,
2398 (uint32_t)sizeof(VEBOX_SPATIAL_ATTRIBUTES_CONFIGURATION));
2399 }
2400
VeboxOutputNeeded(VP_EXECUTE_CAPS & caps)2401 bool VpResourceManager::VeboxOutputNeeded(VP_EXECUTE_CAPS& caps)
2402 {
2403 VP_FUNC_CALL();
2404 bool enableVeboxOutputSurf = false;
2405 if (m_vpUserFeatureControl)
2406 {
2407 enableVeboxOutputSurf = m_vpUserFeatureControl->IsVeboxOutputSurfEnabled();
2408 }
2409
2410 // If DN and/or Hotpixel are the only functions enabled then the only output is the Denoised Output
2411 // and no need vebox output.
2412 // For any other vebox features being enabled, vebox output surface is needed.
2413 if (enableVeboxOutputSurf ||
2414 caps.bDI ||
2415 caps.bQueryVariance ||
2416 caps.bDiProcess2ndField ||
2417 caps.bIECP ||
2418 caps.bCappipe ||
2419 (caps.bDN && caps.bSFC)) // DN + SFC needs IECP implicitly and outputs to DI surface
2420 {
2421 return true;
2422 }
2423 else
2424 {
2425 return false;
2426 }
2427 }
2428
VeboxDenoiseOutputNeeded(VP_EXECUTE_CAPS & caps)2429 bool VpResourceManager::VeboxDenoiseOutputNeeded(VP_EXECUTE_CAPS& caps)
2430 {
2431 VP_FUNC_CALL();
2432
2433 return caps.bDN;
2434 }
2435
VeboxHdr3DlutNeeded(VP_EXECUTE_CAPS & caps)2436 bool VpResourceManager::VeboxHdr3DlutNeeded(VP_EXECUTE_CAPS &caps)
2437 {
2438 VP_FUNC_CALL();
2439
2440 return caps.bHDR3DLUT;
2441 }
2442
Vebox1DlutNeeded(VP_EXECUTE_CAPS & caps)2443 bool VpResourceManager::Vebox1DlutNeeded(VP_EXECUTE_CAPS &caps)
2444 {
2445 VP_FUNC_CALL();
2446
2447 return caps.bDV;
2448 }
2449
2450 // In some case, STMM should not be destroyed even when not being used by current workload to maintain data,
2451 // e.g. DI second field case.
2452 // If queryAssignment == true, query whether STMM needed by current workload.
2453 // If queryAssignment == false, query whether STMM needed to be allocated.
VeboxSTMMNeeded(VP_EXECUTE_CAPS & caps,bool queryAssignment)2454 bool VpResourceManager::VeboxSTMMNeeded(VP_EXECUTE_CAPS& caps, bool queryAssignment)
2455 {
2456 VP_FUNC_CALL();
2457
2458 if (queryAssignment)
2459 {
2460 return caps.bDI || caps.bDN;
2461 }
2462 else
2463 {
2464 return caps.bDI || caps.bDiProcess2ndField || caps.bDN;
2465 }
2466 }
2467
ReAllocateVeboxStatisticsSurface(VP_SURFACE * & statisticsSurface,VP_EXECUTE_CAPS & caps,VP_SURFACE * inputSurface,uint32_t dwWidth,uint32_t dwHeight)2468 MOS_STATUS VpResourceManager::ReAllocateVeboxStatisticsSurface(VP_SURFACE *&statisticsSurface, VP_EXECUTE_CAPS &caps, VP_SURFACE *inputSurface, uint32_t dwWidth, uint32_t dwHeight)
2469 {
2470 VP_FUNC_CALL();
2471
2472 bool bAllocated = false;
2473 Mos_MemPool memTypeHistStat = GetHistStatMemType(caps);
2474 //Statistics surface can be not lockable, if secure mode is enabled
2475 bool isStatisticsBufNotLockable = caps.bSecureVebox;
2476 uint8_t InitValue = 0;
2477
2478 // change the init value when null hw is enabled
2479 if (m_osInterface.bNullHwIsEnabled)
2480 {
2481 InitValue = 0x80;
2482 }
2483
2484 VP_PUBLIC_CHK_STATUS_RETURN(m_allocator.ReAllocateSurface(
2485 statisticsSurface,
2486 "m_veboxStatisticsSurface",
2487 Format_Buffer,
2488 MOS_GFXRES_BUFFER,
2489 MOS_TILE_LINEAR,
2490 dwWidth,
2491 dwHeight,
2492 false,
2493 MOS_MMC_DISABLED,
2494 bAllocated,
2495 false,
2496 IsDeferredResourceDestroyNeeded(),
2497 MOS_HW_RESOURCE_USAGE_VP_INTERNAL_WRITE_FF,
2498 MOS_TILE_UNSET_GMM,
2499 memTypeHistStat,
2500 isStatisticsBufNotLockable));
2501
2502 if (bAllocated)
2503 {
2504 if (caps.bSecureVebox)
2505 {
2506 VP_PUBLIC_CHK_STATUS_RETURN(FillLinearBufferWithEncZero(statisticsSurface, dwWidth, dwHeight));
2507 }
2508 }
2509
2510 m_dwVeboxPerBlockStatisticsWidth = dwWidth;
2511 m_dwVeboxPerBlockStatisticsHeight = MOS_ROUNDUP_DIVIDE(inputSurface->osSurface->dwHeight, 4);
2512
2513 return MOS_STATUS_SUCCESS;
2514 }
2515
AssignHdrResource(VP_EXECUTE_CAPS & caps,std::vector<VP_SURFACE * > & inputSurfaces,VP_SURFACE * outputSurface,RESOURCE_ASSIGNMENT_HINT resHint,VP_SURFACE_SETTING & surfSetting,SwFilterPipe & executedFilters)2516 MOS_STATUS VpResourceManager::AssignHdrResource(VP_EXECUTE_CAPS &caps, std::vector<VP_SURFACE *> &inputSurfaces, VP_SURFACE *outputSurface, RESOURCE_ASSIGNMENT_HINT resHint, VP_SURFACE_SETTING &surfSetting, SwFilterPipe &executedFilters)
2517 {
2518 VP_FUNC_CALL();
2519
2520 if (m_hdrResourceManager == nullptr)
2521 {
2522 m_hdrResourceManager = MOS_New(VphdrResourceManager, m_allocator);
2523 }
2524
2525 VP_PUBLIC_CHK_STATUS_RETURN(m_hdrResourceManager->AssignRenderResource(caps, inputSurfaces, outputSurface, resHint, surfSetting, executedFilters, m_osInterface, m_reporting, IsDeferredResourceDestroyNeeded()));
2526
2527 return MOS_STATUS_SUCCESS;
2528 }
2529 };
2530