[VP] Add DI support in APO path
[VP] Add DI support in APO path
1 Add DI related code in SwFilter/Policy/HwFilter/Packet.
2 By default disabled.
Change-Id: I9a8f07cdb7a8538b4a9d7f2ffde460caf5aa97c3
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/bufferMgr/vp_resource_manager.cpp b/media_driver/media_driver_next/agnostic/common/vp/hal/bufferMgr/vp_resource_manager.cpp
index 6173373..f87773b 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/bufferMgr/vp_resource_manager.cpp
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/bufferMgr/vp_resource_manager.cpp
@@ -1,5 +1,5 @@
/*
-* Copyright (c) 2018, Intel Corporation
+* Copyright (c) 2018-2020, Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
@@ -35,6 +35,13 @@
#define VP_SAME_SAMPLE_THRESHOLD 0
+inline bool IsInterleaveFirstField(VPHAL_SAMPLE_TYPE sampleType)
+{
+ return ((sampleType == SAMPLE_INTERLEAVED_ODD_FIRST_BOTTOM_FIELD) ||
+ (sampleType == SAMPLE_INTERLEAVED_EVEN_FIRST_TOP_FIELD) ||
+ (sampleType == SAMPLE_SINGLE_TOP_FIELD));
+}
+
extern const VEBOX_SPATIAL_ATTRIBUTES_CONFIGURATION g_cInit_VEBOX_SPATIAL_ATTRIBUTES_CONFIGURATIONS =
{
// DWORD 0
@@ -141,6 +148,7 @@
VpResourceManager::VpResourceManager(MOS_INTERFACE &osInterface, VpAllocator &allocator, VphalFeatureReport &reporting)
: m_osInterface(osInterface), m_allocator(allocator), m_reporting(reporting)
{
+ InitSurfaceConfigMap();
}
VpResourceManager::~VpResourceManager()
@@ -201,8 +209,6 @@
int32_t pastFrameId = pastSurface ? pastSurface->FrameID : 0;
int32_t futureFrameId = futureSurface ? futureSurface->FrameID : 0;
- m_pastFrameIds = m_currentFrameIds;
-
m_currentFrameIds.valid = true;
m_currentFrameIds.diEnabled = nullptr != diFilter;
m_currentFrameIds.currentFrameId = currentFrameId;
@@ -211,7 +217,6 @@
m_currentFrameIds.pastFrameAvailable = pastSurface ? true : false;
m_currentFrameIds.futureFrameAvailable = futureSurface ? true : false;
-
// Only set sameSamples flag DI enabled frames.
if (m_pastFrameIds.valid && m_currentFrameIds.pastFrameAvailable &&
m_pastFrameIds.diEnabled && m_currentFrameIds.diEnabled)
@@ -226,11 +231,18 @@
-VP_SAME_SAMPLE_THRESHOLD,
VP_SAME_SAMPLE_THRESHOLD);
- m_outOfBound =
- OUT_OF_BOUNDS(
- m_currentFrameIds.pastFrameId - m_pastFrameIds.currentFrameId,
- -VP_SAME_SAMPLE_THRESHOLD,
- VP_SAME_SAMPLE_THRESHOLD);
+ if (m_sameSamples)
+ {
+ m_outOfBound = false;
+ }
+ else
+ {
+ m_outOfBound =
+ OUT_OF_BOUNDS(
+ m_currentFrameIds.pastFrameId - m_pastFrameIds.currentFrameId,
+ -VP_SAME_SAMPLE_THRESHOLD,
+ VP_SAME_SAMPLE_THRESHOLD);
+ }
}
// bSameSamples flag also needs to be set for no reference case
else if (m_pastFrameIds.valid && !m_currentFrameIds.pastFrameAvailable &&
@@ -256,12 +268,39 @@
}
// Swap buffers for next iteration
- m_currentDnOutput = (m_currentDnOutput + 1) & 1;
- m_currentStmmIndex = (m_currentStmmIndex + 1) & 1;
+ if (!m_sameSamples)
+ {
+ m_currentDnOutput = (m_currentDnOutput + 1) & 1;
+ m_currentStmmIndex = (m_currentStmmIndex + 1) & 1;
+ }
+
+ m_pastFrameIds = m_currentFrameIds;
return MOS_STATUS_SUCCESS;
}
+void VpResourceManager::InitSurfaceConfigMap()
+{
+ ///* _b64DI
+ // | _sfcEnable
+ // | | _sameSample
+ // | | | _outOfBound
+ // | | | | _pastRefAvailable
+ // | | | | | _futureRefAvailable
+ // | | | | | | _firstDiField
+ // | | | | | | | _currentInputSurface
+ // | | | | | | | | _pastInputSurface
+ // | | | | | | | | | _currentOutputSurface
+ // | | | | | | | | | | _pastOutputSurface*/
+ // | | | | | | | | | | | */
+ AddSurfaceConfig(true, true, false, false, true, false, true, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_PAST_REF, VEBOX_SURFACE_FRAME1, VEBOX_SURFACE_FRAME0);
+ AddSurfaceConfig(true, true, true, false, true, false, false, VEBOX_SURFACE_FRAME1, VEBOX_SURFACE_NULL, VEBOX_SURFACE_NULL, VEBOX_SURFACE_NULL);
+ AddSurfaceConfig(true, true, false, false, false, false, true, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_NULL, VEBOX_SURFACE_FRAME1, VEBOX_SURFACE_NULL);
+ AddSurfaceConfig(true, true, false, false, false, false, false, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_NULL, VEBOX_SURFACE_FRAME1, VEBOX_SURFACE_NULL);
+ AddSurfaceConfig(true, true, true, false, false, false, true, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_NULL, VEBOX_SURFACE_FRAME1, VEBOX_SURFACE_NULL);
+ AddSurfaceConfig(true, true, true, false, false, false, false, VEBOX_SURFACE_INPUT, VEBOX_SURFACE_NULL, VEBOX_SURFACE_FRAME1, VEBOX_SURFACE_NULL);
+}
+
uint32_t VpResourceManager::GetHistogramSurfaceSize(VP_EXECUTE_CAPS& caps, uint32_t inputWidth, uint32_t inputHeight)
{
// Allocate Rgb Histogram surface----------------------------------------------
@@ -275,32 +314,76 @@
return dwSize;
}
-MOS_STATUS VpResourceManager::AssignExecuteResource(VP_EXECUTE_CAPS& caps, VP_SURFACE *inputSurface, VP_SURFACE *outputSurface, VP_SURFACE_GROUP &surfGroup)
+MOS_STATUS VpResourceManager::AssignExecuteResource(VP_EXECUTE_CAPS& caps, VP_SURFACE *inputSurface, VP_SURFACE *outputSurface,
+ VP_SURFACE *pastSurface, VP_SURFACE *futureSurface, RESOURCE_ASSIGNMENT_HINT resHint, VP_SURFACE_GROUP &surfGroup)
{
surfGroup.clear();
if (caps.bVebox)
{
// Create Vebox Resources
- VP_PUBLIC_CHK_STATUS_RETURN(AssignVeboxResource(caps, inputSurface, outputSurface, surfGroup));
+ VP_PUBLIC_CHK_STATUS_RETURN(AssignVeboxResource(caps, inputSurface, outputSurface, pastSurface, futureSurface, resHint, surfGroup));
}
return MOS_STATUS_SUCCESS;
}
-MOS_FORMAT GetVeboxOutputFormat(VP_EXECUTE_CAPS &executeCaps, MOS_FORMAT inputFormat, MOS_FORMAT outputFormat)
+MOS_STATUS GetVeboxOutputParams(VP_EXECUTE_CAPS &executeCaps, MOS_FORMAT inputFormat, MOS_TILE_TYPE inputTileType, MOS_FORMAT outputFormat,
+ MOS_FORMAT &veboxOutputFormat, MOS_TILE_TYPE &veboxOutputTileType)
{
+ // Vebox Chroma Co-Sited downsampleing is part of VEO. It only affects format of vebox output surface, but not
+ // affect sfc input format, that's why different logic between GetSfcInputFormat and GetVeboxOutputParams.
+ // Check DI first and downsampling to NV12 if possible to save bandwidth no matter IECP enabled or not.
+ if (executeCaps.bDI || executeCaps.bDiProcess2ndField)
+ {
+ // NV12 will be used if target output is not YUV2 to save bandwidth.
+ if (outputFormat == Format_YUY2)
+ {
+ veboxOutputFormat = Format_YUY2;
+ }
+ else
+ {
+ veboxOutputFormat = Format_NV12;
+ }
+ veboxOutputTileType = MOS_TILE_Y;
+ }
+ else if (executeCaps.bIECP)
+ {
+ // Upsampling to yuv444 for IECP input/output.
+ // To align with legacy path, need to check whether inputFormat can also be used for IECP case,
+ // in which case IECP down sampling will be applied.
+ veboxOutputFormat = Format_AYUV;
+ veboxOutputTileType = inputTileType;
+ }
+ else
+ {
+ veboxOutputFormat = inputFormat;
+ veboxOutputTileType = inputTileType;
+ }
+
+ return MOS_STATUS_SUCCESS;
+}
+
+MOS_FORMAT GetSfcInputFormat(VP_EXECUTE_CAPS &executeCaps, MOS_FORMAT inputFormat, VPHAL_CSPACE colorSpaceOutput)
+{
+ // Vebox Chroma Co-Sited downsampling is part of VEO. It only affects format of vebox output surface, but not
+ // affect sfc input format, that's why different logic between GetSfcInputFormat and GetVeboxOutputParams.
+ // Check IECP first here, since IECP is done after DI, and the vebox downsampling not affect the vebox input.
if (executeCaps.bIECP)
{
+ if (executeCaps.bHDR3DLUT)
+ {
+ return IS_COLOR_SPACE_BT2020(colorSpaceOutput) ? Format_R10G10B10A2 : Format_A8B8G8R8;
+ }
// Upsampling to yuv444 for IECP input/output.
// To align with legacy path, need to check whether inputFormat can also be used for IECP case,
// in which case IECP down sampling will be applied.
return Format_AYUV;
}
- else if (executeCaps.bDI && VpHal_GetSurfaceColorPack(inputFormat) == VPHAL_COLORPACK_420)
+ else if (executeCaps.bDI)
{
// If the input is 4:2:0, then chroma data is doubled vertically to 4:2:2
- // In legacy path, NV12 will be used if target output is not YUV2 to save bandwidth.
- // Need to check whether it can applied here.
+ // For executeCaps.bDiProcess2ndField, no DI enabled in vebox, so no need
+ // set to YUY2 here.
return Format_YUY2;
}
@@ -318,7 +401,11 @@
VP_PUBLIC_CHK_NULL_RETURN(outputSurface);
VP_PUBLIC_CHK_NULL_RETURN(outputSurface->osSurface);
- MOS_FORMAT format = GetVeboxOutputFormat(caps, inputSurface->osSurface->Format, outputSurface->osSurface->Format);
+ MOS_FORMAT veboxOutputFormat = inputSurface->osSurface->Format;
+ MOS_TILE_TYPE veboxOutputTileType = inputSurface->osSurface->TileType;
+
+ VP_PUBLIC_CHK_STATUS_RETURN(GetVeboxOutputParams(caps, inputSurface->osSurface->Format, inputSurface->osSurface->TileType,
+ outputSurface->osSurface->Format, veboxOutputFormat, veboxOutputTileType));
allocated = false;
if (IS_VP_VEBOX_DN_ONLY(caps))
@@ -343,9 +430,9 @@
VP_PUBLIC_CHK_STATUS_RETURN(m_allocator.ReAllocateSurface(
m_veboxOutput[i],
"VeboxSurfaceOutput",
- format,
+ veboxOutputFormat,
MOS_GFXRES_2D,
- inputSurface->osSurface->TileType,
+ veboxOutputTileType,
inputSurface->osSurface->dwWidth,
inputSurface->osSurface->dwHeight,
bSurfCompressible,
@@ -359,19 +446,14 @@
m_veboxOutput[i]->rcSrc = inputSurface->rcSrc;
m_veboxOutput[i]->rcMaxSrc = inputSurface->rcMaxSrc;
- // When IECP is enabled and Bob or interlaced scaling is selected for interlaced input,
- // output surface's SampleType should be same to input's. Bob is being
- // done in Composition part
- if ((caps.bIECP &&
- (caps.bDI && caps.bBobDI)) ||
- (caps.bIScaling))
- {
- m_veboxOutput[i]->SampleType = inputSurface->SampleType;
- }
- else
- {
- m_veboxOutput[i]->SampleType = SAMPLE_PROGRESSIVE;
- }
+ m_veboxOutput[i]->SampleType = SAMPLE_PROGRESSIVE;
+ }
+
+ if (allocated)
+ {
+ // Report Compress Status
+ m_reporting.FFDICompressible = bSurfCompressible;
+ m_reporting.FFDICompressMode = (uint8_t)(surfCompressionMode);
}
return MOS_STATUS_SUCCESS;
@@ -449,6 +531,75 @@
return MOS_STATUS_SUCCESS;
}
+//!
+//! \brief Vebox initialize STMM History
+//! \details Initialize STMM History surface
+//! Description:
+//! This function is used by VEBox for initializing
+//! the STMM surface. The STMM / Denoise history is a custom surface used
+//! for both input and output. Each cache line contains data for 4 4x4s.
+//! The STMM for each 4x4 is 8 bytes, while the denoise history is 1 byte
+//! and the chroma denoise history is 1 byte for each U and V.
+//! Byte Data\n
+//! 0 STMM for 2 luma values at luma Y=0, X=0 to 1\n
+//! 1 STMM for 2 luma values at luma Y=0, X=2 to 3\n
+//! 2 Luma Denoise History for 4x4 at 0,0\n
+//! 3 Not Used\n
+//! 4-5 STMM for luma from X=4 to 7\n
+//! 6 Luma Denoise History for 4x4 at 0,4\n
+//! 7 Not Used\n
+//! 8-15 Repeat for 4x4s at 0,8 and 0,12\n
+//! 16 STMM for 2 luma values at luma Y=1,X=0 to 1\n
+//! 17 STMM for 2 luma values at luma Y=1, X=2 to 3\n
+//! 18 U Chroma Denoise History\n
+//! 19 Not Used\n
+//! 20-31 Repeat for 3 4x4s at 1,4, 1,8 and 1,12\n
+//! 32 STMM for 2 luma values at luma Y=2,X=0 to 1\n
+//! 33 STMM for 2 luma values at luma Y=2, X=2 to 3\n
+//! 34 V Chroma Denoise History\n
+//! 35 Not Used\n
+//! 36-47 Repeat for 3 4x4s at 2,4, 2,8 and 2,12\n
+//! 48 STMM for 2 luma values at luma Y=3,X=0 to 1\n
+//! 49 STMM for 2 luma values at luma Y=3, X=2 to 3\n
+//! 50-51 Not Used\n
+//! 36-47 Repeat for 3 4x4s at 3,4, 3,8 and 3,12\n
+//! \param [in] iSurfaceIndex
+//! Index of STMM surface array
+//! \return MOS_STATUS
+//! Return MOS_STATUS_SUCCESS if successful, otherwise failed
+//!
+MOS_STATUS VpResourceManager::VeboxInitSTMMHistory(MOS_SURFACE *stmmSurface)
+{
+ uint32_t dwSize = 0;
+ int32_t x = 0, y = 0;
+ uint8_t* pByte = nullptr;
+
+ VP_PUBLIC_CHK_NULL_RETURN(stmmSurface);
+
+ // Lock the surface for writing
+ pByte = (uint8_t*)m_allocator.LockResouceForWrite(&stmmSurface->OsResource);
+ VP_PUBLIC_CHK_NULL_RETURN(pByte);
+
+ dwSize = stmmSurface->dwWidth >> 2;
+
+ // Fill STMM surface with DN history init values.
+ for (y = 0; y < (int32_t)stmmSurface->dwHeight; y++)
+ {
+ for (x = 0; x < (int32_t)dwSize; x++)
+ {
+ MOS_FillMemory(pByte, 2, DNDI_HISTORY_INITVALUE);
+ // skip denosie history init.
+ pByte += 4;
+ }
+
+ pByte += stmmSurface->dwPitch - stmmSurface->dwWidth;
+ }
+
+ // Unlock the surface
+ VP_PUBLIC_CHK_STATUS_RETURN(m_allocator.UnLock(&stmmSurface->OsResource));
+ return MOS_STATUS_SUCCESS;
+}
+
// Allocate STMM (Spatial-Temporal Motion Measure) Surfaces
MOS_STATUS VpResourceManager::ReAllocateVeboxSTMMSurface(VP_EXECUTE_CAPS& caps, VP_SURFACE *inputSurface, bool &allocated)
{
@@ -478,6 +629,8 @@
if (allocated)
{
+ VP_PUBLIC_CHK_NULL_RETURN(m_veboxSTMMSurface[i]);
+ VP_PUBLIC_CHK_STATUS_RETURN(VeboxInitSTMMHistory(m_veboxSTMMSurface[i]->osSurface));
// Report Compress Status
m_reporting.STMMCompressible = bSurfCompressible;
m_reporting.STMMCompressMode = (uint8_t)surfCompressionMode;
@@ -568,7 +721,7 @@
DestoryVeboxDenoiseOutputSurface();
}
- if (VeboxSTMMNeeded(caps))
+ if (VeboxSTMMNeeded(caps, false))
{
VP_PUBLIC_CHK_STATUS_RETURN(ReAllocateVeboxSTMMSurface(caps, inputSurface, bAllocated));
if (bAllocated)
@@ -683,7 +836,42 @@
return MOS_STATUS_SUCCESS;
}
-MOS_STATUS VpResourceManager::AssignVeboxResource(VP_EXECUTE_CAPS& caps, VP_SURFACE *inputSurface, VP_SURFACE *outputSurface, VP_SURFACE_GROUP &surfGroup)
+MOS_STATUS VpResourceManager::AssignSurface(VEBOX_SURFACE_ID &surfaceId, SurfaceType surfaceType, VP_SURFACE *inputSurface, VP_SURFACE *outputSurface, VP_SURFACE *pastSurface, VP_SURFACE *futureSurface, VP_SURFACE_GROUP &surfGroup)
+{
+ switch (surfaceId)
+ {
+ case VEBOX_SURFACE_INPUT:
+ surfGroup.insert(std::make_pair(surfaceType, inputSurface));
+ break;
+ case VEBOX_SURFACE_OUTPUT:
+ surfGroup.insert(std::make_pair(surfaceType, outputSurface));
+ break;
+ case VEBOX_SURFACE_PAST_REF:
+ surfGroup.insert(std::make_pair(surfaceType, pastSurface));
+ break;
+ case VEBOX_SURFACE_FUTURE_REF:
+ surfGroup.insert(std::make_pair(surfaceType, futureSurface));
+ break;
+ case VEBOX_SURFACE_FRAME0:
+ surfGroup.insert(std::make_pair(surfaceType, m_veboxOutput[(m_currentDnOutput + 0) % m_veboxOutputCount]));
+ break;
+ case VEBOX_SURFACE_FRAME1:
+ surfGroup.insert(std::make_pair(surfaceType, m_veboxOutput[(m_currentDnOutput + 1) % m_veboxOutputCount]));
+ break;
+ case VEBOX_SURFACE_FRAME2:
+ surfGroup.insert(std::make_pair(surfaceType, m_veboxOutput[(m_currentDnOutput + 2) % m_veboxOutputCount]));
+ break;
+ case VEBOX_SURFACE_FRAME3:
+ surfGroup.insert(std::make_pair(surfaceType, m_veboxOutput[(m_currentDnOutput + 3) % m_veboxOutputCount]));
+ break;
+ default:
+ break;
+ }
+ return MOS_STATUS_SUCCESS;
+}
+
+MOS_STATUS VpResourceManager::AssignVeboxResource(VP_EXECUTE_CAPS& caps, VP_SURFACE *inputSurface, VP_SURFACE *outputSurface,
+ VP_SURFACE *pastSurface, VP_SURFACE *futureSurface, RESOURCE_ASSIGNMENT_HINT resHint, VP_SURFACE_GROUP &surfGroup)
{
VP_FUNC_CALL();
VP_PUBLIC_CHK_NULL_RETURN(inputSurface);
@@ -700,24 +888,54 @@
VP_PUBLIC_CHK_STATUS_RETURN(AllocateVeboxResource(caps, inputSurface, outputSurface));
- surfGroup.insert(std::make_pair(SurfaceTypeVeboxInput, inputSurface));
- surfGroup.insert(std::make_pair(SurfaceTypeVeboxCurrentOutput, GetVeboxOutputSurface(caps, outputSurface)));
-
- if (caps.bDN)
+ if (caps.bDI || caps.bDiProcess2ndField)
{
- // Insert DN output surface
- surfGroup.insert(std::make_pair(SurfaceTypeDNOutput, m_veboxDenoiseOutput[m_currentDnOutput]));
- // Insert DN Reference surface
- if (caps.bRefValid)
+ bool b60fpsDi = resHint.b60fpsDi || caps.bDiProcess2ndField;
+ VEBOX_SURFACES_CONFIG cfg(b60fpsDi, caps.bSFC, m_sameSamples, m_outOfBound, m_currentFrameIds.pastFrameAvailable,
+ m_currentFrameIds.futureFrameAvailable, IsInterleaveFirstField(inputSurface->SampleType));
+ auto it = m_veboxSurfaceConfigMap.find(cfg.value);
+ if (m_veboxSurfaceConfigMap.end() == it)
{
- surfGroup.insert(std::make_pair(SurfaceTypeVeboxPreviousInput, m_veboxDenoiseOutput[(m_currentDnOutput + 1) & 1]));
+ VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
+ }
+ auto surfaces = it->second;
+ VP_PUBLIC_CHK_STATUS_RETURN(AssignSurface(surfaces.currentInputSurface, SurfaceTypeVeboxInput, inputSurface, outputSurface, pastSurface, futureSurface, surfGroup));
+ VP_PUBLIC_CHK_STATUS_RETURN(AssignSurface(surfaces.pastInputSurface, SurfaceTypeVeboxPreviousInput, inputSurface, outputSurface, pastSurface, futureSurface, surfGroup));
+ VP_PUBLIC_CHK_STATUS_RETURN(AssignSurface(surfaces.currentOutputSurface, SurfaceTypeVeboxCurrentOutput, inputSurface, outputSurface, pastSurface, futureSurface, surfGroup));
+ VP_PUBLIC_CHK_STATUS_RETURN(AssignSurface(surfaces.pastOutputSurface, SurfaceTypeVeboxPreviousOutput, inputSurface, outputSurface, pastSurface, futureSurface, surfGroup));
+
+ if (caps.bDN)
+ {
+ // Insert DN output surface
+ surfGroup.insert(std::make_pair(SurfaceTypeDNOutput, m_veboxDenoiseOutput[m_currentDnOutput]));
+ }
+
+ caps.bRefValid = surfGroup.find(SurfaceTypeVeboxPreviousInput) != surfGroup.end();
+ }
+ else
+ {
+ surfGroup.insert(std::make_pair(SurfaceTypeVeboxInput, inputSurface));
+ surfGroup.insert(std::make_pair(SurfaceTypeVeboxCurrentOutput, GetVeboxOutputSurface(caps, outputSurface)));
+
+ if (caps.bDN)
+ {
+ // Insert DN output surface
+ surfGroup.insert(std::make_pair(SurfaceTypeDNOutput, m_veboxDenoiseOutput[m_currentDnOutput]));
+ // Insert DN Reference surface
+ if (caps.bRefValid)
+ {
+ surfGroup.insert(std::make_pair(SurfaceTypeVeboxPreviousInput, m_veboxDenoiseOutput[(m_currentDnOutput + 1) & 1]));
+ }
}
}
- // Insert STMM input surface
- surfGroup.insert(std::make_pair(SurfaceTypeSTMMIn, m_veboxSTMMSurface[m_currentStmmIndex]));
- // Insert STMM output surface
- surfGroup.insert(std::make_pair(SurfaceTypeSTMMOut, m_veboxSTMMSurface[(m_currentStmmIndex + 1) & 1]));
+ if (VeboxSTMMNeeded(caps, true))
+ {
+ // Insert STMM input surface
+ surfGroup.insert(std::make_pair(SurfaceTypeSTMMIn, m_veboxSTMMSurface[m_currentStmmIndex]));
+ // Insert STMM output surface
+ surfGroup.insert(std::make_pair(SurfaceTypeSTMMOut, m_veboxSTMMSurface[(m_currentStmmIndex + 1) & 1]));
+ }
#if VEBOX_AUTO_DENOISE_SUPPORTED
// Insert Vebox auto DN noise level surface
@@ -788,9 +1006,10 @@
// If DN and/or Hotpixel are the only functions enabled then the only output is the Denoised Output
// and no need vebox output.
// For any other vebox features being enabled, vebox output surface is needed.
- if (caps.bDI ||
- caps.bQueryVariance ||
- caps.bIECP ||
+ if (caps.bDI ||
+ caps.bQueryVariance ||
+ caps.bDiProcess2ndField ||
+ caps.bIECP ||
(caps.bDN && caps.bSFC)) // DN + SFC needs IECP implicitly and outputs to DI surface
{
return true;
@@ -806,9 +1025,20 @@
return caps.bDN;
}
-bool VpResourceManager::VeboxSTMMNeeded(VP_EXECUTE_CAPS& caps)
+// In some case, STMM should not be destroyed even when not being used by current workload to maintain data,
+// e.g. DI second field case.
+// If queryAssignment == true, query whether STMM needed by current workload.
+// If queryAssignment == false, query whether STMM needed to be allocated.
+bool VpResourceManager::VeboxSTMMNeeded(VP_EXECUTE_CAPS& caps, bool queryAssignment)
{
- return caps.bDI || caps.bDN;
+ if (queryAssignment)
+ {
+ return caps.bDI || caps.bDN;
+ }
+ else
+ {
+ return caps.bDI || caps.bDiProcess2ndField || caps.bDN;
+ }
}
};
\ No newline at end of file
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/bufferMgr/vp_resource_manager.h b/media_driver/media_driver_next/agnostic/common/vp/hal/bufferMgr/vp_resource_manager.h
index 21d05b3..6608392 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/bufferMgr/vp_resource_manager.h
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/bufferMgr/vp_resource_manager.h
@@ -259,6 +259,60 @@
uint32_t dwPad[7];
};
+enum VEBOX_SURFACE_ID
+{
+ VEBOX_SURFACE_NULL = 0,
+ VEBOX_SURFACE_INPUT,
+ VEBOX_SURFACE_OUTPUT,
+ VEBOX_SURFACE_PAST_REF,
+ VEBOX_SURFACE_FUTURE_REF,
+ VEBOX_SURFACE_FRAME0,
+ VEBOX_SURFACE_FRAME1,
+ VEBOX_SURFACE_FRAME2,
+ VEBOX_SURFACE_FRAME3,
+};
+
+struct VEBOX_SURFACES
+{
+ VEBOX_SURFACE_ID currentInputSurface;
+ VEBOX_SURFACE_ID pastInputSurface;
+ VEBOX_SURFACE_ID currentOutputSurface;
+ VEBOX_SURFACE_ID pastOutputSurface;
+
+ VEBOX_SURFACES(VEBOX_SURFACE_ID _currentInputSurface, VEBOX_SURFACE_ID _pastInputSurface, VEBOX_SURFACE_ID _currentOutputSurface, VEBOX_SURFACE_ID _pastOutputSurface)
+ : currentInputSurface(_currentInputSurface), pastInputSurface(_pastInputSurface), currentOutputSurface(_currentOutputSurface), pastOutputSurface(_pastOutputSurface)
+ {}
+};
+
+inline uint32_t BoolToInt(bool b)
+{
+ return ((b) ? 1 : 0);
+}
+
+union VEBOX_SURFACES_CONFIG
+{
+ struct
+ {
+ uint32_t b64DI : 1;
+ uint32_t sfcEnable : 1;
+ uint32_t sameSample : 1;
+ uint32_t outOfBound : 1;
+ uint32_t pastFrameAvailable : 1;
+ uint32_t futureFrameAvailable : 1;
+ uint32_t firstDiField : 1;
+ uint32_t reserved : 25;
+ };
+ uint32_t value;
+ VEBOX_SURFACES_CONFIG() : value(0)
+ {}
+ VEBOX_SURFACES_CONFIG(bool _b64DI, bool _sfcEnable, bool _sameSample, bool _outOfBound, bool _pastFrameAvailable, bool _futureFrameAvailable, bool _firstDiField) :
+ b64DI(BoolToInt(_b64DI)), sfcEnable(BoolToInt(_sfcEnable)), sameSample(BoolToInt(_sameSample)), outOfBound(BoolToInt(_outOfBound)),
+ pastFrameAvailable(BoolToInt(_pastFrameAvailable)), futureFrameAvailable(BoolToInt(_futureFrameAvailable)), firstDiField(BoolToInt(_firstDiField)), reserved(0)
+ {}
+};
+
+typedef std::map<uint32_t, VEBOX_SURFACES> VEBOX_SURFACE_CONFIG_MAP;
+
struct VP_FRAME_IDS
{
bool valid;
@@ -276,8 +330,10 @@
VpResourceManager(MOS_INTERFACE &osInterface, VpAllocator &allocator, VphalFeatureReport &reporting);
virtual ~VpResourceManager();
MOS_STATUS StartProcessNewFrame(SwFilterPipe &pipe);
- MOS_STATUS AssignExecuteResource(VP_EXECUTE_CAPS& caps, VP_SURFACE *inputSurface, VP_SURFACE *outputSurface, VP_SURFACE_GROUP &surfGroup);
- virtual MOS_STATUS AssignVeboxResource(VP_EXECUTE_CAPS& caps, VP_SURFACE *inputSurface, VP_SURFACE *outputSurface, VP_SURFACE_GROUP &surfGroup);
+ MOS_STATUS AssignExecuteResource(VP_EXECUTE_CAPS& caps, VP_SURFACE *inputSurface, VP_SURFACE *outputSurface, VP_SURFACE *pastSurface, VP_SURFACE *futureSurface,
+ RESOURCE_ASSIGNMENT_HINT resHint, VP_SURFACE_GROUP &surfGroup);
+ virtual MOS_STATUS AssignVeboxResource(VP_EXECUTE_CAPS& caps, VP_SURFACE *inputSurface, VP_SURFACE *outputSurface, VP_SURFACE *pastSurface, VP_SURFACE *futureSurface,
+ RESOURCE_ASSIGNMENT_HINT resHint, VP_SURFACE_GROUP &surfGroup);
bool IsSameSamples()
{
return m_sameSamples;
@@ -292,9 +348,14 @@
VP_SURFACE* GetVeboxOutputSurface(VP_EXECUTE_CAPS& caps, VP_SURFACE *outputSurface);
MOS_STATUS InitVeboxSpatialAttributesConfiguration();
MOS_STATUS AllocateVeboxResource(VP_EXECUTE_CAPS& caps, VP_SURFACE *inputSurface, VP_SURFACE *outputSurface);
+ MOS_STATUS AssignSurface(VEBOX_SURFACE_ID &surfaceId, SurfaceType surfaceType, VP_SURFACE *inputSurface, VP_SURFACE *outputSurface, VP_SURFACE *pastRefSurface, VP_SURFACE *futureRefSurface, VP_SURFACE_GROUP &surfGroup);
bool VeboxOutputNeeded(VP_EXECUTE_CAPS& caps);
bool VeboxDenoiseOutputNeeded(VP_EXECUTE_CAPS& caps);
- bool VeboxSTMMNeeded(VP_EXECUTE_CAPS& caps);
+ // In some case, STMM should not be destroyed but not be used by current workload to maintain data,
+ // e.g. DI second field case.
+ // If queryAssignment == true, query whether STMM needed by current workload.
+ // If queryAssignment == false, query whether STMM needed to be allocated.
+ bool VeboxSTMMNeeded(VP_EXECUTE_CAPS& caps, bool queryAssignment);
virtual uint32_t GetHistogramSurfaceSize(VP_EXECUTE_CAPS& caps, uint32_t inputWidth, uint32_t inputHeight);
virtual uint32_t Get3DLutSize();
MOS_STATUS ReAllocateVeboxOutputSurface(VP_EXECUTE_CAPS& caps, VP_SURFACE *inputSurface, VP_SURFACE *outputSurface, bool &allocated);
@@ -304,6 +365,52 @@
void DestoryVeboxDenoiseOutputSurface();
void DestoryVeboxSTMMSurface();
+ //!
+ //! \brief Vebox initialize STMM History
+ //! \details Initialize STMM History surface
+ //! Description:
+ //! This function is used by VEBox for initializing
+ //! the STMM surface. The STMM / Denoise history is a custom surface used
+ //! for both input and output. Each cache line contains data for 4 4x4s.
+ //! The STMM for each 4x4 is 8 bytes, while the denoise history is 1 byte
+ //! and the chroma denoise history is 1 byte for each U and V.
+ //! Byte Data\n
+ //! 0 STMM for 2 luma values at luma Y=0, X=0 to 1\n
+ //! 1 STMM for 2 luma values at luma Y=0, X=2 to 3\n
+ //! 2 Luma Denoise History for 4x4 at 0,0\n
+ //! 3 Not Used\n
+ //! 4-5 STMM for luma from X=4 to 7\n
+ //! 6 Luma Denoise History for 4x4 at 0,4\n
+ //! 7 Not Used\n
+ //! 8-15 Repeat for 4x4s at 0,8 and 0,12\n
+ //! 16 STMM for 2 luma values at luma Y=1,X=0 to 1\n
+ //! 17 STMM for 2 luma values at luma Y=1, X=2 to 3\n
+ //! 18 U Chroma Denoise History\n
+ //! 19 Not Used\n
+ //! 20-31 Repeat for 3 4x4s at 1,4, 1,8 and 1,12\n
+ //! 32 STMM for 2 luma values at luma Y=2,X=0 to 1\n
+ //! 33 STMM for 2 luma values at luma Y=2, X=2 to 3\n
+ //! 34 V Chroma Denoise History\n
+ //! 35 Not Used\n
+ //! 36-47 Repeat for 3 4x4s at 2,4, 2,8 and 2,12\n
+ //! 48 STMM for 2 luma values at luma Y=3,X=0 to 1\n
+ //! 49 STMM for 2 luma values at luma Y=3, X=2 to 3\n
+ //! 50-51 Not Used\n
+ //! 36-47 Repeat for 3 4x4s at 3,4, 3,8 and 3,12\n
+ //! \param [in] stmmSurface
+ //! STMM surface
+ //! \return MOS_STATUS
+ //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
+ //!
+ MOS_STATUS VeboxInitSTMMHistory(MOS_SURFACE *stmmSurface);
+
+ void InitSurfaceConfigMap();
+ void AddSurfaceConfig(bool _b64DI, bool _sfcEnable, bool _sameSample, bool _outOfBound, bool _pastRefAvailable, bool _futureRefAvailable, bool _firstDiField,
+ VEBOX_SURFACE_ID _currentInputSurface, VEBOX_SURFACE_ID _pastInputSurface, VEBOX_SURFACE_ID _currentOutputSurface, VEBOX_SURFACE_ID _pastOutputSurface)
+ {
+ m_veboxSurfaceConfigMap.insert(std::make_pair(VEBOX_SURFACES_CONFIG(_b64DI, _sfcEnable, _sameSample, _outOfBound, _pastRefAvailable, _futureRefAvailable, _firstDiField).value, VEBOX_SURFACES(_currentInputSurface, _pastInputSurface, _currentOutputSurface, _pastOutputSurface)));
+ }
+
protected:
MOS_INTERFACE &m_osInterface;
VpAllocator &m_allocator;
@@ -321,13 +428,13 @@
uint32_t m_currentDnOutput = 0;
uint32_t m_currentStmmIndex = 0;
uint32_t m_veboxOutputCount = 2; //!< PE on: 4 used. PE off: 2 used
-
VP_FRAME_IDS m_currentFrameIds = {};
- VP_FRAME_IDS m_pastFrameIds = {};
+ VP_FRAME_IDS m_pastFrameIds = {};
bool m_firstFrame = true;
bool m_sameSamples = false;
bool m_outOfBound = false;
RECT m_maxSrcRect = {};
+ VEBOX_SURFACE_CONFIG_MAP m_veboxSurfaceConfigMap;
};
}
#endif // _VP_RESOURCE_MANAGER_H__
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/hw_filter.h b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/hw_filter.h
index ab9c3ef..1db5d96 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/hw_filter.h
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/hw_filter.h
@@ -46,6 +46,7 @@
#include "vp_ste_filter.h"
#include "vp_procamp_filter.h"
#include "vp_hdr_filter.h"
+#include "vp_di_filter.h"
namespace vp
{
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/policy.cpp b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/policy.cpp
index c10f05f..d855d70 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/policy.cpp
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/policy.cpp
@@ -122,6 +122,10 @@
VP_PUBLIC_CHK_NULL_RETURN(p);
m_VeboxSfcFeatureHandlers.insert(std::make_pair(FeatureTypeDnOnVebox, p));
+ p = MOS_New(PolicyVeboxDiHandler);
+ VP_PUBLIC_CHK_NULL_RETURN(p);
+ m_VeboxSfcFeatureHandlers.insert(std::make_pair(FeatureTypeDiOnVebox, p));
+
p = MOS_New(PolicyVeboxCscHandler);
VP_PUBLIC_CHK_NULL_RETURN(p);
m_VeboxSfcFeatureHandlers.insert(std::make_pair(FeatureTypeCscOnVebox, p));
@@ -152,6 +156,7 @@
m_featurePool.push_back(FeatureTypeTcc);
m_featurePool.push_back(FeatureTypeProcamp);
m_featurePool.push_back(FeatureTypeHdr);
+ m_featurePool.push_back(FeatureTypeDi);
return MOS_STATUS_SUCCESS;
}
@@ -267,7 +272,15 @@
switch (featureType)
{
case FeatureTypeCsc:
- VP_PUBLIC_CHK_STATUS_RETURN(GetCSCExecutionCaps(feature));
+ diFilter = swFilterPipe.GetSwFilter(FeatureTypeDi);
+ if (diFilter)
+ {
+ VP_PUBLIC_CHK_STATUS_RETURN(GetCSCExecutionCapsDi(feature));
+ }
+ else
+ {
+ VP_PUBLIC_CHK_STATUS_RETURN(GetCSCExecutionCaps(feature));
+ }
break;
case FeatureTypeScaling:
VP_PUBLIC_CHK_STATUS_RETURN(GetScalingExecutionCaps(feature));
@@ -290,6 +303,9 @@
case FeatureTypeHdr:
VP_PUBLIC_CHK_STATUS_RETURN(GetHdrExecutionCaps(feature));
break;
+ case FeatureTypeDi:
+ VP_PUBLIC_CHK_STATUS_RETURN(GetDeinterlaceExecutionCaps(feature));
+ break;
default:
VP_PUBLIC_CHK_STATUS_RETURN(GetExecutionCaps(feature));
VP_PUBLIC_NORMALMESSAGE("Feature didn't have supported in driver, default to use Render");
@@ -365,6 +381,28 @@
return MOS_STATUS_SUCCESS;
}
+MOS_STATUS Policy::GetCSCExecutionCapsDi(SwFilter* feature)
+{
+ VP_PUBLIC_CHK_NULL_RETURN(feature);
+
+ SwFilterCsc* csc = dynamic_cast<SwFilterCsc*>(feature);
+ VP_PUBLIC_CHK_NULL_RETURN(csc);
+
+ VP_PUBLIC_CHK_STATUS_RETURN(GetCSCExecutionCaps(feature));
+
+ VP_EngineEntry *cscEngine = &csc->GetFilterEngineCaps();
+ VP_PUBLIC_CHK_NULL_RETURN(cscEngine);
+ if (cscEngine->bEnabled &&
+ (cscEngine->SfcNeeded && cscEngine->VeboxNeeded ||
+ 0 == cscEngine->SfcNeeded && 0 == cscEngine->VeboxNeeded && 0 == cscEngine->RenderNeeded))
+ {
+ cscEngine->SfcNeeded = 1;
+ cscEngine->VeboxNeeded = 0;
+ cscEngine->RenderNeeded = 0;
+ }
+ return MOS_STATUS_SUCCESS;
+}
+
MOS_STATUS Policy::GetCSCExecutionCaps(SwFilter* feature)
{
VP_FUNC_CALL();
@@ -690,6 +728,45 @@
return MOS_STATUS_SUCCESS;
}
+MOS_STATUS Policy::GetDeinterlaceExecutionCaps(SwFilter* feature)
+{
+ VP_FUNC_CALL();
+ VP_PUBLIC_CHK_NULL_RETURN(feature);
+
+ SwFilterDeinterlace* swFilterDi = dynamic_cast<SwFilterDeinterlace*>(feature);
+ VP_PUBLIC_CHK_NULL_RETURN(swFilterDi);
+
+ FeatureParamDeinterlace &diParams = swFilterDi->GetSwFilterParams();
+
+ VP_EngineEntry &diEngine = swFilterDi->GetFilterEngineCaps();
+ MOS_FORMAT inputformat = diParams.formatInput;
+
+ // MOS_FORMAT is [-14,103], cannot use -14~-1 as index for m_veboxHwEntry
+ if (inputformat < 0)
+ {
+ inputformat = Format_Any;
+ }
+
+ if (diEngine.value != 0)
+ {
+ VP_PUBLIC_NORMALMESSAGE("Scaling Feature Already been processed, Skip further process");
+ return MOS_STATUS_SUCCESS;
+ }
+
+ if (m_vpInterface.GetResourceManager()->IsRefValid() &&
+ m_vpInterface.GetResourceManager()->IsSameSamples())
+ {
+ diEngine.bypassVeboxFeatures = 1;
+ }
+ else if (m_veboxHwEntry[inputformat].deinterlaceSupported)
+ {
+ diEngine.bEnabled = 1;
+ diEngine.VeboxNeeded = 1;
+ }
+
+ return MOS_STATUS_SUCCESS;
+}
+
MOS_STATUS Policy::GetSteExecutionCaps(SwFilter* feature)
{
VP_FUNC_CALL();
@@ -981,6 +1058,20 @@
feature->GetFilterEngineCaps().RenderNeeded = 0;
}
}
+
+ if (engineCaps.bypassVeboxFeatures)
+ {
+ if (caps.bVebox && feature->GetFilterEngineCaps().VeboxNeeded)
+ {
+ // Disable vebox features.
+ feature->GetFilterEngineCaps().bEnabled = false;
+ }
+
+ if (FeatureTypeDi == filterID)
+ {
+ caps.bDiProcess2ndField = 1;
+ }
+ }
}
}
}
@@ -1089,6 +1180,10 @@
{
// surface should be added before swFilters, since empty feature pipe will be allocated accordingly when surface being added.
VP_PUBLIC_CHK_STATUS_RETURN(params.executedFilters->AddSurface(surfInput, true, index));
+ VP_SURFACE *pastRefSurface = featurePipe.RemovePastSurface(index);
+ VP_SURFACE *futureRefSurface = featurePipe.RemoveFutureSurface(index);
+ params.executedFilters->SetPastSurface(index, pastRefSurface);
+ params.executedFilters->SetFutureSurface(index, futureRefSurface);
}
else
{
@@ -1118,12 +1213,6 @@
UpdateExeCaps(feature, caps, engineCaps->SfcNeeded ? EngineTypeVeboxSfc : EngineTypeVebox);
featurePipe.RemoveSwFilter(feature);
params.executedFilters->AddSwFilterUnordered(feature, true, 0);
-
- //Create and Add CSC filter for VEBOX IECP chromasiting config
- if (caps.bIECP && filterID == FeatureTypeCsc)
- {
- AddNewFilterOnVebox(featurePipe, caps, params, FeatureTypeCsc);
- }
}
// Vebox only cases
else if (caps.bVebox && engineCaps->bEnabled &&
@@ -1139,7 +1228,7 @@
UpdateExeCaps(feature, caps, EngineTypeRender);
if (caps.bIECP && filterID == FeatureTypeCsc)
{
- AddNewFilterOnVebox(featurePipe, caps, params, FeatureTypeCsc);
+ AddNewFilterOnVebox(featurePipe, caps, *params.executedFilters, FeatureTypeCsc);
}
}
else
@@ -1158,6 +1247,8 @@
}
}
}
+
+ VP_PUBLIC_CHK_STATUS_RETURN(AddFiltersBasedOnCaps(featurePipe, caps, *params.executedFilters));
}
else
{
@@ -1169,6 +1260,23 @@
return MOS_STATUS_SUCCESS;
}
+MOS_STATUS Policy::GetResourceHint(SwFilterPipe& featurePipe, RESOURCE_ASSIGNMENT_HINT &hint)
+{
+ uint32_t index = 0;
+ SwFilterSubPipe* inputPipe = featurePipe.GetSwFilterPrimaryPipe(index);
+ // only process Primary surface
+ VP_PUBLIC_CHK_NULL_RETURN(inputPipe);
+ for (auto filterID : m_featurePool)
+ {
+ SwFilter* feature = (SwFilter*)inputPipe->GetSwFilter(FeatureType(filterID));
+ if (feature)
+ {
+ VP_PUBLIC_CHK_STATUS_RETURN(feature->SetResourceAssignmentHint(hint));
+ }
+ }
+ return MOS_STATUS_SUCCESS;
+}
+
MOS_STATUS Policy::SetupFilterResource(SwFilterPipe& featurePipe, VP_EXECUTE_CAPS& caps, HW_FILTER_PARAMS& params)
{
VP_FUNC_CALL();
@@ -1242,6 +1350,10 @@
caps.bSTE = 1;
feature->SetFeatureType(FeatureType(FEATURE_TYPE_EXECUTE(Ste, Vebox)));
break;
+ case FeatureTypeDi:
+ caps.bDI = 1;
+ feature->SetFeatureType(FeatureType(FEATURE_TYPE_EXECUTE(Di, Vebox)));
+ break;
case FeatureTypeAce:
caps.bACE = 1;
feature->SetFeatureType(FeatureType(FEATURE_TYPE_EXECUTE(Ace, Vebox)));
@@ -1296,7 +1408,12 @@
VP_SURFACE *inputSurface = params.executedFilters->GetSurface(true, 0);
VP_SURFACE *outputSurface = params.executedFilters->GetSurface(false, 0);
- VP_PUBLIC_CHK_STATUS_RETURN(m_vpInterface.GetResourceManager()->AssignExecuteResource(caps, inputSurface, outputSurface, params.executedFilters->GetSurfacesGroup()));
+ VP_SURFACE *pastSurface = params.executedFilters->GetPastSurface(0);
+ VP_SURFACE *futureSurface = params.executedFilters->GetFutureSurface(0);
+ RESOURCE_ASSIGNMENT_HINT resHint = {};
+ VP_PUBLIC_CHK_STATUS_RETURN(GetResourceHint(*params.executedFilters, resHint));
+ VP_PUBLIC_CHK_STATUS_RETURN(m_vpInterface.GetResourceManager()->AssignExecuteResource(caps, inputSurface, outputSurface,
+ pastSurface, futureSurface, resHint, params.executedFilters->GetSurfacesGroup()));
return MOS_STATUS_SUCCESS;
}
@@ -1381,14 +1498,29 @@
return MOS_STATUS_SUCCESS;
}
+MOS_STATUS Policy::AddFiltersBasedOnCaps(
+ SwFilterPipe& featurePipe,
+ VP_EXECUTE_CAPS& caps,
+ SwFilterPipe& executedFilters)
+{
+ //Create and Add CSC filter for VEBOX IECP chromasiting config
+ if (caps.bSFC && !caps.bBeCSC && (caps.bIECP || caps.bDI))
+ {
+ VP_PUBLIC_CHK_STATUS_RETURN(AddNewFilterOnVebox(featurePipe, caps, executedFilters, FeatureTypeCsc));
+ }
+ return MOS_STATUS_SUCCESS;
+}
+
MOS_STATUS Policy::AddNewFilterOnVebox(
SwFilterPipe& featurePipe,
VP_EXECUTE_CAPS& caps,
- HW_FILTER_PARAMS& params,
+ SwFilterPipe& executedFilters,
FeatureType featureType)
{
PVP_SURFACE pSurfInput = featurePipe.GetSurface(true, 0);
+ PVP_SURFACE pSurfOutput = featurePipe.GetSurface(false, 0);
VP_PUBLIC_CHK_NULL_RETURN(pSurfInput);
+ VP_PUBLIC_CHK_NULL_RETURN(pSurfOutput);
auto handler = m_vpInterface.GetSwFilterHandler(featureType);
@@ -1398,49 +1530,19 @@
return MOS_STATUS_INVALID_HANDLE;
}
- SwFilter* pSwfilter = handler->CreateSwFilter();
- VP_PUBLIC_CHK_NULL_RETURN(pSwfilter);
+ SwFilter* swfilter = handler->CreateSwFilter();
+ VP_PUBLIC_CHK_NULL_RETURN(swfilter);
- MOS_STATUS status = pSwfilter->Configure(pSurfInput, caps);
+ MOS_STATUS status = swfilter->Configure(pSurfInput, pSurfOutput, caps);
if (MOS_FAILED(status))
{
- handler->Destory(pSwfilter);
+ handler->Destory(swfilter);
VP_PUBLIC_CHK_STATUS_RETURN(status);
}
- FeatureType featureOnVebox = FeatureTypeInvalid;
- switch (featureType)
- {
- case FeatureTypeDn:
- featureOnVebox = FEATURE_TYPE_EXECUTE(Dn, Vebox);
- break;
- case FeatureTypeSte:
- featureOnVebox = FEATURE_TYPE_EXECUTE(Ste, Vebox);
- break;
- case FeatureTypeAce:
- featureOnVebox = FEATURE_TYPE_EXECUTE(Ace, Vebox);
- break;
- case FeatureTypeTcc:
- featureOnVebox = FEATURE_TYPE_EXECUTE(Tcc, Vebox);
- break;
- case FeatureTypeProcamp:
- featureOnVebox = FEATURE_TYPE_EXECUTE(Procamp, Vebox);
- break;
- case FeatureTypeCsc:
- featureOnVebox = FEATURE_TYPE_EXECUTE(Csc, Vebox);
- break;
- case FeatureTypeHdr:
- featureOnVebox = FEATURE_TYPE_EXECUTE(Hdr, Vebox);
- break;
- default:
- featureOnVebox = FeatureTypeInvalid;
- break;
- }
+ VP_PUBLIC_CHK_STATUS_RETURN(UpdateExeCaps(swfilter, caps, EngineTypeVebox));
- status = pSwfilter->SetFeatureType(featureOnVebox);
- VP_PUBLIC_CHK_STATUS_RETURN(status);
-
- status = params.executedFilters->AddSwFilterUnordered(pSwfilter, true, 0);
+ status = executedFilters.AddSwFilterUnordered(swfilter, true, 0);
VP_PUBLIC_CHK_STATUS_RETURN(status);
return status;
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/policy.h b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/policy.h
index c8a5301..90296c6 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/policy.h
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/policy.h
@@ -79,6 +79,7 @@
MOS_STATUS ReleaseHwFilterParam(HW_FILTER_PARAMS ¶ms);
MOS_STATUS GetExecuteCaps(SwFilterPipe& subSwFilterPipe, HW_FILTER_PARAMS& params);
MOS_STATUS GetCSCExecutionCapsHdr(SwFilter *hdr, SwFilter *csc);
+ MOS_STATUS GetCSCExecutionCapsDi(SwFilter* feature);
MOS_STATUS GetCSCExecutionCaps(SwFilter* feature);
MOS_STATUS GetScalingExecutionCaps(SwFilter* feature);
MOS_STATUS GetRotationExecutionCaps(SwFilter* feature);
@@ -88,17 +89,23 @@
MOS_STATUS GetProcampExecutionCaps(SwFilter* feature);
MOS_STATUS GetHdrExecutionCaps(SwFilter *feature);
MOS_STATUS GetExecutionCaps(SwFilter* feature);
+ MOS_STATUS GetDeinterlaceExecutionCaps(SwFilter* feature);
MOS_STATUS BuildFilters(SwFilterPipe& subSwFilterPipe, HW_FILTER_PARAMS& params);
MOS_STATUS UpdateFilterCaps(SwFilterPipe& subSwFilterPipe, VP_EngineEntry& engineCaps, VP_EXECUTE_CAPS &caps);
MOS_STATUS BuildExecuteFilter(SwFilterPipe& subSwFilterPipe, VP_EXECUTE_CAPS& caps, HW_FILTER_PARAMS& params);
MOS_STATUS BuildExecuteHwFilter(SwFilterPipe& subSwFilterPipe, VP_EXECUTE_CAPS& caps, HW_FILTER_PARAMS& params);
MOS_STATUS SetupExecuteFilter(SwFilterPipe& featurePipe, VP_EXECUTE_CAPS& caps, HW_FILTER_PARAMS& params);
+ MOS_STATUS GetResourceHint(SwFilterPipe& featurePipe, RESOURCE_ASSIGNMENT_HINT &hint);
MOS_STATUS SetupFilterResource(SwFilterPipe& featurePipe, VP_EXECUTE_CAPS& caps, HW_FILTER_PARAMS& params);
+ virtual MOS_STATUS AddFiltersBasedOnCaps(
+ SwFilterPipe& featurePipe,
+ VP_EXECUTE_CAPS& caps,
+ SwFilterPipe& executedFilters);
MOS_STATUS AddNewFilterOnVebox(
SwFilterPipe& featurePipe,
VP_EXECUTE_CAPS& caps,
- HW_FILTER_PARAMS& params,
+ SwFilterPipe& executedFilters,
FeatureType featureType);
MOS_STATUS AssignExecuteResource(VP_EXECUTE_CAPS& caps, HW_FILTER_PARAMS& params);
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter.cpp b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter.cpp
index bd9f424..8b4cbb6 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter.cpp
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter.cpp
@@ -129,30 +129,51 @@
return MOS_STATUS_SUCCESS;
}
-MOS_STATUS SwFilterCsc::Configure(PVP_SURFACE pSurfInput, VP_EXECUTE_CAPS caps)
+namespace vp
{
- VP_PUBLIC_CHK_NULL_RETURN(pSurfInput);
- VP_PUBLIC_CHK_NULL_RETURN(pSurfInput->osSurface);
+MOS_STATUS GetVeboxOutputParams(VP_EXECUTE_CAPS &executeCaps, MOS_FORMAT inputFormat, MOS_TILE_TYPE inputTileType, MOS_FORMAT outputFormat,
+ MOS_FORMAT &veboxOutputFormat, MOS_TILE_TYPE &veboxOutputTileType);
+}
+
+MOS_STATUS SwFilterCsc::Configure(PVP_SURFACE surfInput, PVP_SURFACE surfOutput, VP_EXECUTE_CAPS caps)
+{
+ VP_PUBLIC_CHK_NULL_RETURN(surfInput);
+ VP_PUBLIC_CHK_NULL_RETURN(surfInput->osSurface);
+ VP_PUBLIC_CHK_NULL_RETURN(surfOutput);
+ VP_PUBLIC_CHK_NULL_RETURN(surfOutput->osSurface);
if (caps.bSFC)
{
- m_Params.colorSpaceInput = pSurfInput->ColorSpace;
- m_Params.colorSpaceOutput = pSurfInput->ColorSpace;
+ MOS_FORMAT veboxOutputFormat = surfInput->osSurface->Format;
+ MOS_TILE_TYPE veboxOutputTileType = surfInput->osSurface->TileType;
- m_Params.formatInput = pSurfInput->osSurface->Format;
- m_Params.formatOutput = Format_AYUV; // To get colorPack as 4:4:4
- m_Params.chromaSitingInput = pSurfInput->ChromaSiting;
- m_Params.chromaSitingOutput = pSurfInput->ChromaSiting;
+ GetVeboxOutputParams(caps, surfInput->osSurface->Format, surfInput->osSurface->TileType,
+ surfOutput->osSurface->Format, veboxOutputFormat, veboxOutputTileType);
+ m_Params.colorSpaceInput = surfInput->ColorSpace;
+ m_Params.colorSpaceOutput = surfInput->ColorSpace;
+
+ m_Params.formatInput = surfInput->osSurface->Format;
+ m_Params.formatOutput = veboxOutputFormat;
+ m_Params.chromaSitingInput = surfInput->ChromaSiting;
+ m_Params.chromaSitingOutput = surfOutput->ChromaSiting;
m_Params.pAlphaParams = nullptr;
m_Params.pIEFParams = nullptr;
+
+ m_noNeedUpdate = true;
+
+ return MOS_STATUS_SUCCESS;
}
- return MOS_STATUS_SUCCESS;
+ return MOS_STATUS_UNIMPLEMENTED;
}
MOS_STATUS SwFilterCsc::Configure(VEBOX_SFC_PARAMS ¶ms)
{
+ if (m_noNeedUpdate)
+ {
+ return MOS_STATUS_SUCCESS;
+ }
m_Params.colorSpaceInput = params.input.colorSpace;
m_Params.colorSpaceOutput = params.output.colorSpace;
m_Params.pIEFParams = nullptr;
@@ -192,6 +213,12 @@
MOS_STATUS SwFilterCsc::Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf)
{
+ if (FeatureTypeCscOnVebox == m_type)
+ {
+ // BeCSC may be added for IECP/DI. No need update.
+ return MOS_STATUS_SUCCESS;
+ }
+
VP_PUBLIC_CHK_NULL_RETURN(inputSurf);
VP_PUBLIC_CHK_NULL_RETURN(outputSurf);
VP_PUBLIC_CHK_NULL_RETURN(inputSurf->osSurface);
@@ -207,6 +234,13 @@
return MOS_STATUS_SUCCESS;
}
+MOS_STATUS SwFilterCsc::SetFeatureType(FeatureType type)
+{
+ VP_PUBLIC_CHK_STATUS_RETURN(SwFilter::SetFeatureType(type));
+ m_Params.type = m_type;
+ return MOS_STATUS_SUCCESS;
+}
+
/****************************************************************************************************/
/* SwFilterScaling */
/****************************************************************************************************/
@@ -468,6 +502,7 @@
{
PVPHAL_SURFACE surfInput = isInputSurf ? params.pSrc[surfIndex] : params.pSrc[0];
+ m_Params.sampleTypeInput = surfInput->SampleType;
m_Params.denoiseParams = *surfInput->pDenoiseParams;
m_Params.formatInput = surfInput->Format;
m_Params.formatOutput = surfInput->Format;// Denoise didn't change the original format;
@@ -517,7 +552,82 @@
}
/****************************************************************************************************/
-/* SwFilterSte */
+/* SwFilterDeinterlace */
+/****************************************************************************************************/
+
+SwFilterDeinterlace::SwFilterDeinterlace(VpInterface& vpInterface) : SwFilter(vpInterface, FeatureTypeDi)
+{
+ m_Params.type = m_type;
+}
+
+SwFilterDeinterlace::~SwFilterDeinterlace()
+{
+ Clean();
+}
+
+MOS_STATUS SwFilterDeinterlace::Clean()
+{
+ VP_PUBLIC_CHK_STATUS_RETURN(SwFilter::Clean());
+ return MOS_STATUS_SUCCESS;
+}
+
+MOS_STATUS SwFilterDeinterlace::Configure(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex)
+{
+ PVPHAL_SURFACE surfInput = isInputSurf ? params.pSrc[surfIndex] : params.pSrc[0];
+ VP_PUBLIC_CHK_NULL_RETURN(surfInput);
+ VP_PUBLIC_CHK_NULL_RETURN(surfInput->pDeinterlaceParams);
+
+ m_Params.formatInput = surfInput->Format;
+ m_Params.formatOutput = surfInput->Format;
+ m_Params.sampleTypeInput = surfInput->SampleType;
+ m_Params.DIMode = surfInput->pDeinterlaceParams->DIMode; //!< DeInterlacing mode
+ m_Params.bEnableFMD = surfInput->pDeinterlaceParams->bEnableFMD; //!< FMD
+ m_Params.b60fpsDi = !surfInput->pDeinterlaceParams->bSingleField; //!< Used in frame Recon - if 30fps (one call per sample pair)
+ m_Params.bSCDEnable = surfInput->pDeinterlaceParams->bSCDEnable; //!< Scene change detection
+ m_Params.bHDContent = MEDIA_IS_HDCONTENT(surfInput->dwWidth, surfInput->dwHeight);
+
+ return MOS_STATUS_SUCCESS;
+}
+
+FeatureParamDeinterlace& SwFilterDeinterlace::GetSwFilterParams()
+{
+ return m_Params;
+}
+
+SwFilter *SwFilterDeinterlace::Clone()
+{
+ SwFilter* p = CreateSwFilter(m_type);
+
+ SwFilterDeinterlace *swFilter = dynamic_cast<SwFilterDeinterlace *>(p);
+ if (nullptr == swFilter)
+ {
+ DestroySwFilter(p);
+ return nullptr;
+ }
+
+ swFilter->m_Params = m_Params;
+ return p;
+}
+
+bool vp::SwFilterDeinterlace::operator==(SwFilter& swFilter)
+{
+ SwFilterDeinterlace* p = dynamic_cast<SwFilterDeinterlace*>(&swFilter);
+ return nullptr != p && 0 == memcmp(&this->m_Params, &p->m_Params, sizeof(FeatureParamDeinterlace));
+}
+
+MOS_STATUS vp::SwFilterDeinterlace::Update(VP_SURFACE* inputSurf, VP_SURFACE* outputSurf)
+{
+ VP_PUBLIC_CHK_NULL_RETURN(inputSurf);
+ VP_PUBLIC_CHK_NULL_RETURN(inputSurf->osSurface);
+ VP_PUBLIC_CHK_NULL_RETURN(outputSurf);
+ VP_PUBLIC_CHK_NULL_RETURN(outputSurf->osSurface);
+ m_Params.formatInput = inputSurf->osSurface->Format;
+ m_Params.formatOutput = outputSurf->osSurface->Format;
+ return MOS_STATUS_SUCCESS;
+}
+
+/****************************************************************************************************/
+/* SwFilterSte */
/****************************************************************************************************/
SwFilterSte::SwFilterSte(VpInterface& vpInterface) : SwFilter(vpInterface, FeatureTypeSte)
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter.h b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter.h
index e19aa5c..251c186 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter.h
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter.h
@@ -54,6 +54,7 @@
FeatureTypeDn = 0x400,
FeatureTypeDnOnVebox,
FeatureTypeDi = 0x500,
+ FeatureTypeDiOnVebox,
FeatureTypeSte = 0x600,
FeatureTypeSteOnVebox,
FeatureTypeAce = 0x700,
@@ -143,6 +144,7 @@
virtual MOS_STATUS Clean()
{
MOS_ZeroMemory(&m_EngineCaps, sizeof(m_EngineCaps));
+ m_noNeedUpdate = false;
return MOS_STATUS_SUCCESS;
}
virtual FeatureType GetFeatureType()
@@ -150,7 +152,7 @@
return m_type;
}
virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS ¶ms, bool bInputSurf, int surfIndex) = 0;
- virtual MOS_STATUS Configure(PVP_SURFACE surfInput, VP_EXECUTE_CAPS caps)
+ virtual MOS_STATUS Configure(PVP_SURFACE surfInput, PVP_SURFACE surfOutput, VP_EXECUTE_CAPS caps)
{
return MOS_STATUS_UNIMPLEMENTED;
}
@@ -167,7 +169,7 @@
virtual SwFilter *Clone() = 0;
virtual bool operator == (class SwFilter&) = 0;
virtual MOS_STATUS Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf) = 0;
- MOS_STATUS SetFeatureType(FeatureType type);
+ virtual MOS_STATUS SetFeatureType(FeatureType type);
SwFilter* CreateSwFilter(FeatureType type);
void DestroySwFilter(SwFilter* p);
@@ -191,12 +193,20 @@
return m_EngineCaps;
}
+ // The child class need to implement SetResourceAssignmentHint only when any feature
+ // parameters will affect the resource assignment.
+ virtual MOS_STATUS SetResourceAssignmentHint(RESOURCE_ASSIGNMENT_HINT &hint)
+ {
+ return MOS_STATUS_SUCCESS;
+ }
+
protected:
VpInterface &m_vpInterface;
FeatureType m_type = FeatureTypeInvalid;
// SwFilterSet current swFilter belongs to.
SwFilterSet *m_location = nullptr;
VP_EngineEntry m_EngineCaps = {};
+ bool m_noNeedUpdate = false;
};
struct FeatureParamCsc : public FeatureParam
@@ -217,12 +227,13 @@
virtual ~SwFilterCsc();
virtual MOS_STATUS Clean();
virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS ¶ms, bool isInputSurf, int surfIndex);
- virtual MOS_STATUS Configure(PVP_SURFACE surfInput, VP_EXECUTE_CAPS caps);
+ virtual MOS_STATUS Configure(PVP_SURFACE surfInput, PVP_SURFACE surfOutput, VP_EXECUTE_CAPS caps);
virtual MOS_STATUS Configure(VEBOX_SFC_PARAMS ¶ms);
virtual FeatureParamCsc &GetSwFilterParams();
virtual SwFilter *Clone();
virtual bool operator == (SwFilter& swFilter);
virtual MOS_STATUS Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf);
+ virtual MOS_STATUS SetFeatureType(FeatureType type);
private:
FeatureParamCsc m_Params = {};
@@ -318,6 +329,38 @@
FeatureParamDenoise m_Params = {};
};
+struct FeatureParamDeinterlace : public FeatureParam
+{
+ VPHAL_SAMPLE_TYPE sampleTypeInput;
+ bool bHDContent;
+ VPHAL_DI_MODE DIMode; //!< DeInterlacing mode
+ bool bEnableFMD; //!< FMD
+ bool b60fpsDi; //!< Used in frame Recon - if 30fps (one call per sample pair)
+ bool bSCDEnable; //!< Scene change detection
+};
+
+class SwFilterDeinterlace : public SwFilter
+{
+public:
+ SwFilterDeinterlace(VpInterface& vpInterface);
+ virtual ~SwFilterDeinterlace();
+ virtual MOS_STATUS Clean();
+ virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex);
+ virtual FeatureParamDeinterlace& GetSwFilterParams();
+ virtual SwFilter* Clone();
+ virtual bool operator == (SwFilter& swFilter);
+ virtual MOS_STATUS Update(VP_SURFACE* inputSurf, VP_SURFACE* outputSurf);
+ virtual MOS_STATUS SetResourceAssignmentHint(RESOURCE_ASSIGNMENT_HINT &hint)
+ {
+ hint.bDi = 1;
+ hint.b60fpsDi = m_Params.b60fpsDi;
+ return MOS_STATUS_SUCCESS;
+ }
+
+private:
+ FeatureParamDeinterlace m_Params = {};
+};
+
struct FeatureParamSte : public FeatureParam
{
bool bEnableSTE;
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter_handle.cpp b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter_handle.cpp
index ff244fd..c3536ac 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter_handle.cpp
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter_handle.cpp
@@ -306,6 +306,54 @@
}
/****************************************************************************************************/
+/* SwFilterDiHandler */
+/****************************************************************************************************/
+
+SwFilterDiHandler::SwFilterDiHandler(VpInterface& vpInterface) :
+ SwFilterFeatureHandler(vpInterface, FeatureTypeDi),
+ m_swFilterFactory(vpInterface)
+{}
+SwFilterDiHandler::~SwFilterDiHandler()
+{}
+
+bool SwFilterDiHandler::IsFeatureEnabled(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex, SwFilterPipeType pipeType)
+{
+ if (!SwFilterFeatureHandler::IsFeatureEnabled(params, isInputSurf, surfIndex, pipeType))
+ {
+ return false;
+ }
+
+ PVPHAL_SURFACE vphalSurf = isInputSurf ? params.pSrc[surfIndex] : params.pTarget[surfIndex];
+ if (vphalSurf && vphalSurf->pDeinterlaceParams && vphalSurf->SampleType != SAMPLE_PROGRESSIVE)
+ {
+ return true;
+ }
+
+ return false;
+}
+
+SwFilter* SwFilterDiHandler::CreateSwFilter()
+{
+ SwFilter* swFilter = nullptr;
+ swFilter = m_swFilterFactory.Create();
+
+ if (swFilter)
+ {
+ swFilter->SetFeatureType(FeatureTypeDi);
+ }
+
+ return swFilter;
+}
+
+void SwFilterDiHandler::Destory(SwFilter*& swFilter)
+{
+ SwFilterDeinterlace* filter = nullptr;
+ filter = dynamic_cast<SwFilterDeinterlace*>(swFilter);
+ m_swFilterFactory.Destory(filter);
+ return;
+}
+
+/****************************************************************************************************/
/* SwFilterSteHandler */
/****************************************************************************************************/
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter_handle.h b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter_handle.h
index e2d1b15..edbd91b 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter_handle.h
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter_handle.h
@@ -109,6 +109,19 @@
SwFilterFactory<SwFilterDenoise> m_swFilterFactory;
};
+class SwFilterDiHandler : public SwFilterFeatureHandler
+{
+public:
+ SwFilterDiHandler(VpInterface& vpInterface);
+ virtual ~SwFilterDiHandler();
+ virtual bool IsFeatureEnabled(VP_PIPELINE_PARAMS& params, bool isInputPipe, int surfIndex, SwFilterPipeType pipeType);
+ virtual SwFilter* CreateSwFilter();
+protected:
+ virtual void Destory(SwFilter*& swFilter);
+protected:
+ SwFilterFactory<SwFilterDeinterlace> m_swFilterFactory;
+};
+
class SwFilterSteHandler : public SwFilterFeatureHandler
{
public:
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter_pipe.cpp b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter_pipe.cpp
index bb03378..55abccd 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter_pipe.cpp
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter_pipe.cpp
@@ -175,9 +175,20 @@
return MOS_STATUS_NULL_POINTER;
}
m_InputSurfaces.push_back(surf);
- // Keep m_pastSurface same size as m_InputSurfaces.
- m_pastSurface.push_back(nullptr);
- m_futureSurface.push_back(nullptr);
+
+ // Keep m_pastSurface/m_futureSurface same size as m_InputSurfaces.
+ VP_SURFACE *pastSurface = nullptr;
+ if (params.pSrc[i]->pBwdRef)
+ {
+ pastSurface = m_vpInterface.GetAllocator().AllocateVpSurface(*params.pSrc[i]->pBwdRef);
+ }
+ VP_SURFACE *futureSurface = nullptr;
+ if (params.pSrc[i]->pFwdRef)
+ {
+ futureSurface = m_vpInterface.GetAllocator().AllocateVpSurface(*params.pSrc[i]->pFwdRef);
+ }
+ m_pastSurface.push_back(pastSurface);
+ m_futureSurface.push_back(futureSurface);
// Initialize m_InputPipes.
SwFilterSubPipe *pipe = MOS_New(SwFilterSubPipe);
@@ -666,6 +677,48 @@
return index < m_futureSurface.size() ? m_futureSurface[index] : nullptr;
}
+MOS_STATUS SwFilterPipe::SetPastSurface(uint32_t index, VP_SURFACE *surf)
+{
+ if (index >= m_pastSurface.size())
+ {
+ return MOS_STATUS_INVALID_PARAMETER;
+ }
+ m_pastSurface[index] = surf;
+ return MOS_STATUS_SUCCESS;
+}
+
+MOS_STATUS SwFilterPipe::SetFutureSurface(uint32_t index, VP_SURFACE *surf)
+{
+ if (index >= m_futureSurface.size())
+ {
+ return MOS_STATUS_INVALID_PARAMETER;
+ }
+ m_futureSurface[index] = surf;
+ return MOS_STATUS_SUCCESS;
+}
+
+VP_SURFACE *SwFilterPipe::RemovePastSurface(uint32_t index)
+{
+ if (index >= m_pastSurface.size())
+ {
+ return nullptr;
+ }
+ VP_SURFACE *surf = m_pastSurface[index];
+ m_pastSurface[index] = nullptr;
+ return surf;
+}
+
+VP_SURFACE *SwFilterPipe::RemoveFutureSurface(uint32_t index)
+{
+ if (index >= m_futureSurface.size())
+ {
+ return nullptr;
+ }
+ VP_SURFACE *surf = m_futureSurface[index];
+ m_futureSurface[index] = nullptr;
+ return surf;
+}
+
VP_SURFACE *SwFilterPipe::RemoveSurface(bool isInputSurface, uint32_t index)
{
auto &surfaces = isInputSurface ? m_InputSurfaces : m_OutputSurfaces;
@@ -678,8 +731,14 @@
if (isInputSurface)
{
// Keep m_pastSurface and m_futureSurface same status as m_InputSurfaces.
- m_pastSurface[index] = nullptr;
- m_futureSurface[index] = nullptr;
+ if (m_pastSurface[index])
+ {
+ m_vpInterface.GetAllocator().DestroyVpSurface(m_pastSurface[index]);
+ }
+ if (m_futureSurface[index])
+ {
+ m_vpInterface.GetAllocator().DestroyVpSurface(m_futureSurface[index]);
+ }
}
return surf;
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter_pipe.h b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter_pipe.h
index e84cb8a..9cc434a 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter_pipe.h
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/sw_filter_pipe.h
@@ -135,7 +135,11 @@
VP_SURFACE *GetSurface(bool isInputSurface, uint32_t index);
VP_SURFACE *GetPastSurface(uint32_t index);
VP_SURFACE *GetFutureSurface(uint32_t index);
+ MOS_STATUS SetPastSurface(uint32_t index, VP_SURFACE *surf);
+ MOS_STATUS SetFutureSurface(uint32_t index, VP_SURFACE *surf);
VP_SURFACE *RemoveSurface(bool isInputSurface, uint32_t index);
+ VP_SURFACE *RemovePastSurface(uint32_t index);
+ VP_SURFACE *RemoveFutureSurface(uint32_t index);
MOS_STATUS AddSurface(VP_SURFACE *&surf, bool isInputSurface, uint32_t index);
MOS_STATUS Update();
uint32_t GetSurfaceCount(bool isInputSurface);
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/vp_feature_manager.cpp b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/vp_feature_manager.cpp
index f7a6288..461c48e 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/vp_feature_manager.cpp
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/vp_feature_manager.cpp
@@ -154,6 +154,10 @@
VP_PUBLIC_CHK_NULL_RETURN(p);
m_featureHandler.insert(std::make_pair(FeatureTypeHdr, p));
+ p = MOS_New(SwFilterDiHandler, m_vpInterface);
+ VP_PUBLIC_CHK_NULL_RETURN(p);
+ m_featureHandler.insert(std::make_pair(FeatureTypeDi, p));
+
m_isFeatureRegistered = true;
return MOS_STATUS_SUCCESS;
}
@@ -866,3 +870,23 @@
return eStatus;
}
+
+bool VPFeatureManager::IsDiFormatSupported(MOS_FORMAT format)
+{
+ if (format != Format_AYUV &&
+ format != Format_Y416 &&
+ format != Format_Y410 &&
+ format != Format_A8B8G8R8 &&
+ format != Format_A8R8G8B8 &&
+ format != Format_B10G10R10A2 &&
+ format != Format_R10G10B10A2 &&
+ format != Format_A16B16G16R16 &&
+ format != Format_A16R16G16B16)
+ {
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+}
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/vp_feature_manager.h b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/vp_feature_manager.h
index bc9ae73..869a62c 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/vp_feature_manager.h
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/feature_manager/vp_feature_manager.h
@@ -151,6 +151,8 @@
return false;
}
+ virtual bool IsDiFormatSupported(MOS_FORMAT format);
+
protected:
PVP_MHWINTERFACE m_hwInterface = nullptr;
PMOS_INTERFACE m_pOsInterface = nullptr;
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/features/media_srcs.cmake b/media_driver/media_driver_next/agnostic/common/vp/hal/features/media_srcs.cmake
index 12ba760..a5c314d 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/features/media_srcs.cmake
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/features/media_srcs.cmake
@@ -28,6 +28,7 @@
${CMAKE_CURRENT_LIST_DIR}/vp_tcc_filter.cpp
${CMAKE_CURRENT_LIST_DIR}/vp_procamp_filter.cpp
${CMAKE_CURRENT_LIST_DIR}/vp_hdr_filter.cpp
+ ${CMAKE_CURRENT_LIST_DIR}/vp_di_filter.cpp
)
set(TMP_HEADERS_
@@ -40,6 +41,7 @@
${CMAKE_CURRENT_LIST_DIR}/vp_tcc_filter.h
${CMAKE_CURRENT_LIST_DIR}/vp_procamp_filter.h
${CMAKE_CURRENT_LIST_DIR}/vp_hdr_filter.h
+ ${CMAKE_CURRENT_LIST_DIR}/vp_di_filter.h
)
set(SOURCES_NEW
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/features/vp_csc_filter.cpp b/media_driver/media_driver_next/agnostic/common/vp/hal/features/vp_csc_filter.cpp
index bf4d397..d0eea82 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/features/vp_csc_filter.cpp
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/features/vp_csc_filter.cpp
@@ -80,6 +80,8 @@
#define VP_VEBOX_CHROMA_DOWNSAMPLING_422_TYPE2_VERT_OFFSET 0
#define VP_VEBOX_CHROMA_DOWNSAMPLING_422_TYPE3_VERT_OFFSET 0
+MOS_FORMAT GetSfcInputFormat(VP_EXECUTE_CAPS &executeCaps, MOS_FORMAT inputFormat, VPHAL_CSPACE colorSpaceOutput);
+
VpCscFilter::VpCscFilter(PVP_MHWINTERFACE vpMhwInterface) :
VpFilter(vpMhwInterface)
{
@@ -134,18 +136,19 @@
{
VP_FUNC_CALL();
- if (m_executeCaps.bSfcCsc)
+ if (FeatureTypeCscOnSfc == m_cscParams.type)
{
VP_RENDER_CHK_STATUS_RETURN(CalculateSfcEngineParams());
}
- else if (m_executeCaps.bBeCSC)
+ else if (FeatureTypeCscOnVebox == m_cscParams.type)
{
VP_RENDER_CHK_STATUS_RETURN(CalculateVeboxEngineParams());
}
- else if (m_executeCaps.bRender)
+ else if (FeatureTypeCscOnRender == m_cscParams.type)
{
// place hold for Render solution
VP_PUBLIC_ASSERTMESSAGE("No function support CSC in Render path now");
+ return MOS_STATUS_UNIMPLEMENTED;
}
else
{
@@ -165,26 +168,6 @@
return inputColorSpace;
}
-MOS_FORMAT GetSfcInputFormat(VP_EXECUTE_CAPS &executeCaps, MOS_FORMAT inputFormat, VPHAL_CSPACE colorSpaceOutput)
-{
- if (executeCaps.bIECP)
- {
- if (executeCaps.bHDR3DLUT)
- {
- return IS_COLOR_SPACE_BT2020(colorSpaceOutput) ? Format_R10G10B10A2 : Format_A8B8G8R8;
- }
- // Upsampling to yuv444 for IECP input/output.
- return Format_AYUV;
- }
- else if (executeCaps.bDI && VpHal_GetSurfaceColorPack(inputFormat) == VPHAL_COLORPACK_420)
- {
- // If the input is 4:2:0, then chroma data is doubled vertically to 4:2:2
- return Format_YUY2;
- }
-
- return inputFormat;
-}
-
MOS_STATUS VpCscFilter::CalculateSfcEngineParams()
{
VP_FUNC_CALL();
@@ -279,6 +262,8 @@
m_veboxCSCParams->bCSCEnabled = (m_cscParams.colorSpaceInput != m_cscParams.colorSpaceOutput);
m_veboxCSCParams->alphaParams = m_cscParams.pAlphaParams;
+ VP_RENDER_CHK_STATUS_RETURN(UpdateChromaSiting());
+
VP_RENDER_CHK_STATUS_RETURN(SetVeboxCUSChromaParams(m_executeCaps));
VP_RENDER_CHK_STATUS_RETURN(SetVeboxCDSChromaParams(m_executeCaps));
@@ -293,7 +278,9 @@
VP_RENDER_CHK_NULL_RETURN(m_sfcCSCParams);
// Update chroma sitting according to updated input format.
- VP_RENDER_CHK_STATUS_RETURN(UpdateSfcChromaSiting());
+ VP_RENDER_CHK_STATUS_RETURN(UpdateChromaSiting());
+
+ m_sfcCSCParams->sfcSrcChromaSiting = m_cscParams.chromaSitingInput;
// Setup General params
// Set chroma subsampling type according to the Vebox output, but
@@ -473,10 +460,12 @@
bool bNeedDownSampling = false;
+ VPHAL_COLORPACK dstColorPack = VpHal_GetSurfaceColorPack(m_cscParams.formatOutput);
+
// Only VEBOX output, we use VEO to do downsampling.
// Else, we use SFC/FC path to do downscaling.
// if VEBOX intermediate buffer format is non_YUY2 on DI case, enable downsampling as center-left
- if (vpExecuteCaps.bDI && (m_cscParams.formatOutput != Format_YUY2))
+ if (vpExecuteCaps.bDI && (m_cscParams.formatOutput != Format_YUY2 || vpExecuteCaps.bIECP))
{
bNeedDownSampling = true;
}
@@ -485,10 +474,6 @@
bNeedDownSampling = vpExecuteCaps.bVebox && !vpExecuteCaps.bSFC;
}
-
- VPHAL_COLORPACK dstColorPack;
- dstColorPack = VpHal_GetSurfaceColorPack(m_cscParams.formatOutput);
-
// Init as CDS disabled
m_veboxCSCParams->bypassCDS = true;
@@ -576,12 +561,10 @@
return MOS_STATUS_SUCCESS;
}
-MOS_STATUS VpCscFilter::UpdateSfcChromaSiting()
+MOS_STATUS VpCscFilter::UpdateChromaSiting()
{
VP_FUNC_CALL();
- VP_RENDER_CHK_NULL_RETURN(m_sfcCSCParams);
-
if (MHW_CHROMA_SITING_NONE == m_cscParams.chromaSitingInput)
{
m_cscParams.chromaSitingInput = (CHROMA_SITING_HORZ_LEFT | CHROMA_SITING_VERT_CENTER);
@@ -598,8 +581,6 @@
break;
}
- m_sfcCSCParams->sfcSrcChromaSiting = m_cscParams.chromaSitingInput;
-
if (MHW_CHROMA_SITING_NONE == m_cscParams.chromaSitingOutput)
{
m_cscParams.chromaSitingOutput = (CHROMA_SITING_HORZ_LEFT | CHROMA_SITING_VERT_CENTER);
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/features/vp_csc_filter.h b/media_driver/media_driver_next/agnostic/common/vp/hal/features/vp_csc_filter.h
index bc22275..93913cc 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/features/vp_csc_filter.h
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/features/vp_csc_filter.h
@@ -106,7 +106,7 @@
//! \details Setup Chroma sitting parameters
//! \return MOS_STATUS
//!
- MOS_STATUS UpdateSfcChromaSiting();
+ MOS_STATUS UpdateChromaSiting();
//!
//! \brief Check whether Chroma Up Sampling Needed
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/features/vp_di_filter.cpp b/media_driver/media_driver_next/agnostic/common/vp/hal/features/vp_di_filter.cpp
new file mode 100644
index 0000000..93499ee
--- /dev/null
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/features/vp_di_filter.cpp
@@ -0,0 +1,269 @@
+/*
+* Copyright (c) 2020, Intel Corporation
+*
+* Permission is hereby granted, free of charge, to any person obtaining a
+* copy of this software and associated documentation files (the "Software"),
+* to deal in the Software without restriction, including without limitation
+* the rights to use, copy, modify, merge, publish, distribute, sublicense,
+* and/or sell copies of the Software, and to permit persons to whom the
+* Software is furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included
+* in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+* OTHER DEALINGS IN THE SOFTWARE.
+*/
+//!
+//! \file vp_di_filter.cpp
+//! \brief Defines the common interface for Adaptive Contrast Enhancement
+//! this file is for the base interface which is shared by all Ace in driver.
+//!
+#include "vp_di_filter.h"
+#include "vp_vebox_cmd_packet.h"
+#include "hw_filter.h"
+#include "sw_filter_pipe.h"
+
+using namespace vp;
+
+VpDiFilter::VpDiFilter(PVP_MHWINTERFACE vpMhwInterface) :
+ VpFilter(vpMhwInterface)
+{
+
+}
+
+MOS_STATUS VpDiFilter::Init()
+{
+ VP_FUNC_CALL();
+
+ return MOS_STATUS_SUCCESS;
+}
+
+MOS_STATUS VpDiFilter::Prepare()
+{
+ VP_FUNC_CALL();
+
+ return MOS_STATUS_SUCCESS;
+}
+
+MOS_STATUS VpDiFilter::Destroy()
+{
+ VP_FUNC_CALL();
+
+ if (m_pVeboxDiParams)
+ {
+ MOS_FreeMemAndSetNull(m_pVeboxDiParams);
+ }
+
+ return MOS_STATUS_SUCCESS;
+}
+
+MOS_STATUS VpDiFilter::SetExecuteEngineCaps(
+ FeatureParamDeinterlace &diParams,
+ VP_EXECUTE_CAPS vpExecuteCaps)
+{
+ VP_FUNC_CALL();
+
+ m_diParams = diParams;
+ m_executeCaps = vpExecuteCaps;
+
+ return MOS_STATUS_SUCCESS;
+}
+
+MOS_STATUS VpDiFilter::CalculateEngineParams()
+{
+ VP_FUNC_CALL();
+ if (m_executeCaps.bVebox)
+ {
+ // create a filter Param buffer
+ if (!m_pVeboxDiParams)
+ {
+ m_pVeboxDiParams = (PVEBOX_DI_PARAMS)MOS_AllocAndZeroMemory(sizeof(VEBOX_DI_PARAMS));
+
+ if (m_pVeboxDiParams == nullptr)
+ {
+ VP_PUBLIC_ASSERTMESSAGE("Vebox DI Pamas buffer allocate failed, return nullpointer");
+ return MOS_STATUS_NO_SPACE;
+ }
+ }
+ else
+ {
+ MOS_ZeroMemory(m_pVeboxDiParams, sizeof(VEBOX_DI_PARAMS));
+ }
+
+ m_pVeboxDiParams->bDiEnabled = true;
+ m_pVeboxDiParams->sampleTypeInput = m_diParams.sampleTypeInput;
+ m_pVeboxDiParams->b60fpsDi = m_diParams.b60fpsDi;
+ m_pVeboxDiParams->diMode = m_diParams.DIMode;
+ m_pVeboxDiParams->enableFMD = m_diParams.bEnableFMD;
+ m_pVeboxDiParams->bSCDEnabled = m_diParams.bSCDEnable;
+ m_pVeboxDiParams->bHDContent = m_diParams.bHDContent;
+ }
+ else
+ {
+ VP_PUBLIC_ASSERTMESSAGE("Wrong engine caps! Vebox should be used for DI");
+ return MOS_STATUS_INVALID_PARAMETER;
+ }
+
+ return MOS_STATUS_SUCCESS;
+}
+
+
+/****************************************************************************************************/
+/* HwFilter DI Parameter */
+/****************************************************************************************************/
+HwFilterParameter *HwFilterDiParameter::Create(HW_FILTER_DI_PARAM ¶m, FeatureType featureType)
+{
+ HwFilterDiParameter *p = MOS_New(HwFilterDiParameter, featureType);
+ if (p)
+ {
+ if (MOS_FAILED(p->Initialize(param)))
+ {
+ MOS_Delete(p);
+ return nullptr;
+ }
+ }
+ return p;
+}
+
+HwFilterDiParameter::HwFilterDiParameter(FeatureType featureType) : HwFilterParameter(featureType)
+{
+}
+
+HwFilterDiParameter::~HwFilterDiParameter()
+{
+}
+
+MOS_STATUS HwFilterDiParameter::ConfigParams(HwFilter &hwFilter)
+{
+ return hwFilter.ConfigParam(m_Params);
+}
+
+MOS_STATUS HwFilterDiParameter::Initialize(HW_FILTER_DI_PARAM ¶m)
+{
+ m_Params = param;
+ return MOS_STATUS_SUCCESS;
+}
+
+/****************************************************************************************************/
+/* Packet Vebox DI Parameter */
+/****************************************************************************************************/
+VpPacketParameter *VpVeboxDiParameter::Create(HW_FILTER_DI_PARAM ¶m)
+{
+ if (nullptr == param.pPacketParamFactory)
+ {
+ return nullptr;
+ }
+ VpVeboxDiParameter *p = dynamic_cast<VpVeboxDiParameter *>(param.pPacketParamFactory->GetPacketParameter(param.pHwInterface));
+ if (p)
+ {
+ if (MOS_FAILED(p->Initialize(param)))
+ {
+ VpPacketParameter *pParam = p;
+ param.pPacketParamFactory->ReturnPacketParameter(pParam);
+ return nullptr;
+ }
+ }
+ return p;
+}
+
+VpVeboxDiParameter::VpVeboxDiParameter(PVP_MHWINTERFACE pHwInterface, PacketParamFactoryBase *packetParamFactory) :
+ VpPacketParameter(packetParamFactory), m_diFilter(pHwInterface)
+{
+}
+VpVeboxDiParameter::~VpVeboxDiParameter() {}
+
+bool VpVeboxDiParameter::SetPacketParam(VpCmdPacket *pPacket)
+{
+ VpVeboxCmdPacket *pVeboxPacket = dynamic_cast<VpVeboxCmdPacket *>(pPacket);
+ if (nullptr == pVeboxPacket)
+ {
+ return false;
+ }
+
+ VEBOX_DI_PARAMS *pParams = m_diFilter.GetVeboxParams();
+ if (nullptr == pParams)
+ {
+ return false;
+ }
+ return MOS_SUCCEEDED(pVeboxPacket->SetDiParams(pParams));
+}
+
+MOS_STATUS VpVeboxDiParameter::Initialize(HW_FILTER_DI_PARAM ¶ms)
+{
+ VP_PUBLIC_CHK_STATUS_RETURN(m_diFilter.Init());
+ VP_PUBLIC_CHK_STATUS_RETURN(m_diFilter.SetExecuteEngineCaps(params.diParams, params.vpExecuteCaps));
+ VP_PUBLIC_CHK_STATUS_RETURN(m_diFilter.CalculateEngineParams());
+ return MOS_STATUS_SUCCESS;
+}
+
+/****************************************************************************************************/
+/* Policy Vebox DI Handler */
+/****************************************************************************************************/
+PolicyVeboxDiHandler::PolicyVeboxDiHandler()
+{
+ m_Type = FeatureTypeDiOnVebox;
+}
+PolicyVeboxDiHandler::~PolicyVeboxDiHandler()
+{
+}
+
+bool PolicyVeboxDiHandler::IsFeatureEnabled(VP_EXECUTE_CAPS vpExecuteCaps)
+{
+ return vpExecuteCaps.bDI;
+}
+
+HwFilterParameter* PolicyVeboxDiHandler::CreateHwFilterParam(VP_EXECUTE_CAPS vpExecuteCaps, SwFilterPipe& swFilterPipe, PVP_MHWINTERFACE pHwInterface)
+{
+ if (IsFeatureEnabled(vpExecuteCaps))
+ {
+ if (SwFilterPipeType1To1 != swFilterPipe.GetSwFilterPipeType())
+ {
+ VP_PUBLIC_ASSERTMESSAGE("Invalid parameter! Sfc only support 1To1 swFilterPipe!");
+ return nullptr;
+ }
+
+ SwFilterDeinterlace *swFilter = dynamic_cast<SwFilterDeinterlace *>(swFilterPipe.GetSwFilter(true, 0, FeatureTypeDiOnVebox));
+
+ if (nullptr == swFilter)
+ {
+ VP_PUBLIC_ASSERTMESSAGE("Invalid parameter! Feature enabled in vpExecuteCaps but no swFilter exists!");
+ return nullptr;
+ }
+
+ FeatureParamDeinterlace ¶m = swFilter->GetSwFilterParams();
+
+ HW_FILTER_DI_PARAM diParam = {};
+ diParam.type = m_Type;
+ diParam.pHwInterface = pHwInterface;
+ diParam.vpExecuteCaps = vpExecuteCaps;
+ diParam.pPacketParamFactory = &m_PacketParamFactory;
+ diParam.diParams = param;
+ diParam.pfnCreatePacketParam = PolicyVeboxDiHandler::CreatePacketParam;
+
+ HwFilterParameter *pHwFilterParam = GetHwFeatureParameterFromPool();
+
+ if (pHwFilterParam)
+ {
+ if (MOS_FAILED(((HwFilterDiParameter*)pHwFilterParam)->Initialize(diParam)))
+ {
+ ReleaseHwFeatureParameter(pHwFilterParam);
+ }
+ }
+ else
+ {
+ pHwFilterParam = HwFilterDiParameter::Create(diParam, m_Type);
+ }
+
+ return pHwFilterParam;
+ }
+ else
+ {
+ return nullptr;
+ }
+}
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/features/vp_di_filter.h b/media_driver/media_driver_next/agnostic/common/vp/hal/features/vp_di_filter.h
new file mode 100644
index 0000000..0085f37
--- /dev/null
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/features/vp_di_filter.h
@@ -0,0 +1,124 @@
+/*
+* Copyright (c) 2020, Intel Corporation
+*
+* Permission is hereby granted, free of charge, to any person obtaining a
+* copy of this software and associated documentation files (the "Software"),
+* to deal in the Software without restriction, including without limitation
+* the rights to use, copy, modify, merge, publish, distribute, sublicense,
+* and/or sell copies of the Software, and to permit persons to whom the
+* Software is furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included
+* in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+* OTHER DEALINGS IN THE SOFTWARE.
+*/
+//!
+//! \file vp_di_filter.h
+//! \brief Defines the common interface for ace
+//! this file is for the base interface which is shared by all ace in driver.
+//!
+#ifndef __VP_DI_FILTER_H__
+#define __VP_DI_FILTER_H__
+#include "vp_filter.h"
+#include "sw_filter.h"
+
+namespace vp {
+class VpDiFilter : public VpFilter
+{
+public:
+
+ VpDiFilter(
+ PVP_MHWINTERFACE vpMhwInterface);
+
+ ~VpDiFilter()
+ {
+ Destroy();
+ };
+
+ virtual MOS_STATUS Init() override;
+
+ virtual MOS_STATUS Prepare() override;
+
+ virtual MOS_STATUS Destroy() override;
+
+ virtual MOS_STATUS SetExecuteEngineCaps(
+ FeatureParamDeinterlace &diParams,
+ VP_EXECUTE_CAPS vpExecuteCaps);
+
+ MOS_STATUS CalculateEngineParams();
+ PVEBOX_DI_PARAMS GetVeboxParams()
+ {
+ return m_pVeboxDiParams;
+ }
+
+protected:
+ FeatureParamDeinterlace m_diParams = {};
+ PVEBOX_DI_PARAMS m_pVeboxDiParams = nullptr;
+};
+
+struct HW_FILTER_DI_PARAM : public HW_FILTER_PARAM
+{
+ FeatureParamDeinterlace diParams;
+};
+
+class HwFilterDiParameter : public HwFilterParameter
+{
+public:
+ static HwFilterParameter *Create(HW_FILTER_DI_PARAM ¶m, FeatureType featureType);
+ HwFilterDiParameter(FeatureType featureType);
+ virtual ~HwFilterDiParameter();
+ virtual MOS_STATUS ConfigParams(HwFilter &hwFilter);
+
+ MOS_STATUS Initialize(HW_FILTER_DI_PARAM¶m);
+
+private:
+ HW_FILTER_DI_PARAM m_Params = {};
+};
+
+class VpVeboxDiParameter : public VpPacketParameter
+{
+public:
+ static VpPacketParameter *Create(HW_FILTER_DI_PARAM ¶m);
+ VpVeboxDiParameter(PVP_MHWINTERFACE pHwInterface, PacketParamFactoryBase *packetParamFactory);
+ virtual ~VpVeboxDiParameter();
+
+ virtual bool SetPacketParam(VpCmdPacket *pPacket);
+
+private:
+ MOS_STATUS Initialize(HW_FILTER_DI_PARAM¶ms);
+
+ VpDiFilter m_diFilter;
+};
+
+class PolicyVeboxDiHandler : public PolicyFeatureHandler
+{
+public:
+ PolicyVeboxDiHandler();
+ virtual ~PolicyVeboxDiHandler();
+ virtual bool IsFeatureEnabled(VP_EXECUTE_CAPS vpExecuteCaps);
+ virtual HwFilterParameter *CreateHwFilterParam(VP_EXECUTE_CAPS vpExecuteCaps, SwFilterPipe &swFilterPipe, PVP_MHWINTERFACE pHwInterface);
+
+ static VpPacketParameter* CreatePacketParam(HW_FILTER_PARAM& param)
+ {
+ if (param.type != FeatureTypeDiOnVebox)
+ {
+ VP_PUBLIC_ASSERTMESSAGE("Invalid parameter for Vebox ACE!");
+ return nullptr;
+ }
+
+ HW_FILTER_DI_PARAM* aceParam = (HW_FILTER_DI_PARAM*)(¶m);
+ return VpVeboxDiParameter::Create(*aceParam);
+ }
+
+private:
+ PacketParamFactory<VpVeboxDiParameter> m_PacketParamFactory;
+};
+}
+#endif
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/features/vp_filter.h b/media_driver/media_driver_next/agnostic/common/vp/hal/features/vp_filter.h
index ca7ea4b..a7c8fc0 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/features/vp_filter.h
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/features/vp_filter.h
@@ -177,12 +177,24 @@
uint32_t dwSTEFactor;
};
+struct _VEBOX_DI_PARAMS
+{
+ bool bDiEnabled; // DI Enabled
+ VPHAL_SAMPLE_TYPE sampleTypeInput;
+ bool b60fpsDi;
+ VPHAL_DI_MODE diMode; //!< DeInterlacing mode
+ bool enableFMD; //!< FMD
+ bool bSCDEnabled; //!< Scene change detection
+ bool bHDContent;
+};
+
struct _VEBOX_ACE_PARAMS
{
bool bEnableACE; // ACE Enabled
bool bAceLevelChanged;
uint32_t dwAceLevel;
uint32_t dwAceStrength;
+ bool bAceHistogramEnabled;
};
struct _VEBOX_TCC_PARAMS
@@ -261,6 +273,8 @@
using PVEBOX_DN_PARAMS = VEBOX_DN_PARAMS *;
using VEBOX_STE_PARAMS = _VEBOX_STE_PARAMS;
using PVEBOX_STE_PARAMS = VEBOX_STE_PARAMS *;
+using VEBOX_DI_PARAMS = _VEBOX_DI_PARAMS;
+using PVEBOX_DI_PARAMS = VEBOX_DI_PARAMS *;
using VEBOX_ACE_PARAMS = _VEBOX_ACE_PARAMS;
using PVEBOX_ACE_PARAMS = VEBOX_ACE_PARAMS *;
using VEBOX_TCC_PARAMS = _VEBOX_TCC_PARAMS;
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_vebox_cmd_packet.cpp b/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_vebox_cmd_packet.cpp
index d514f95..937d075 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_vebox_cmd_packet.cpp
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_vebox_cmd_packet.cpp
@@ -48,12 +48,10 @@
0x000000ab, 0x00000080, 0x00000066, 0x00000055, 0x000000c2, 0x000000b9, 0x000000b0, 0x000000a9, 0x000000a2, 0x0000009c };
void VpVeboxCmdPacket::SetupSurfaceStates(
- bool bDiVarianceEnable,
PVPHAL_VEBOX_SURFACE_STATE_CMD_PARAMS pVeboxSurfaceStateCmdParams)
{
VP_PUBLIC_CHK_NULL_NO_STATUS_RETURN(pVeboxSurfaceStateCmdParams);
MOS_ZeroMemory(pVeboxSurfaceStateCmdParams, sizeof(VPHAL_VEBOX_SURFACE_STATE_CMD_PARAMS));
- MOS_UNUSED(bDiVarianceEnable);
pVeboxSurfaceStateCmdParams->pSurfInput = m_veboxPacketSurface.pCurrInput;
pVeboxSurfaceStateCmdParams->pSurfOutput = m_veboxPacketSurface.pCurrOutput;
pVeboxSurfaceStateCmdParams->pSurfSTMM = m_veboxPacketSurface.pSTMMInput;
@@ -62,7 +60,6 @@
}
MOS_STATUS VpVeboxCmdPacket::SetupVeboxState(
- bool bDiVarianceEnable,
PMHW_VEBOX_STATE_CMD_PARAMS pVeboxStateCmdParams)
{
PMHW_VEBOX_MODE pVeboxMode = nullptr;
@@ -83,12 +80,12 @@
// For next step, need to enable it only when necessary.
pVeboxMode->GlobalIECPEnable = true;
- pVeboxMode->DIEnable = bDiVarianceEnable;
+ pVeboxMode->DIEnable = m_PacketCaps.bDI;
pVeboxMode->SFCParallelWriteEnable = m_IsSfcUsed &&
- (m_PacketCaps.bDN || bDiVarianceEnable);
+ (m_PacketCaps.bDN || m_PacketCaps.bDI);
pVeboxMode->DNEnable = m_PacketCaps.bDN;
- pVeboxMode->DNDIFirstFrame = (!m_PacketCaps.bRefValid && (pVeboxMode->DNEnable || pVeboxMode->DIEnable));
+ pVeboxMode->DNDIFirstFrame = m_DNDIFirstFrame;
pVeboxMode->DIOutputFrames = m_DIOutputFrames;
pVeboxMode->DisableEncoderStatistics = true;
pVeboxMode->DisableTemporalDenoiseFilter = false;
@@ -286,6 +283,27 @@
// Vebox output case.
surf = m_renderTarget;
}
+ else if (SurfaceTypeVeboxInput == type && surf)
+ {
+ // The vp surface object for external surface will be destroyed by hw filter before packet submit.
+ // Store the vp surface object inside packet.
+ if (MOS_FAILED(m_allocator->CopyVpSurface(*m_currentSurface ,*surf)))
+ {
+ return nullptr;
+ }
+ m_currentSurface->rcMaxSrc = m_currentSurface->rcSrc;
+ surf = m_currentSurface;
+ }
+ else if (SurfaceTypeVeboxPreviousInput == type && surf)
+ {
+ // The vp surface object for external surface will be destroyed by hw filter before packet submit.
+ // Store the vp surface object inside packet.
+ if (MOS_FAILED(m_allocator->CopyVpSurface(*m_previousSurface ,*surf)))
+ {
+ return nullptr;
+ }
+ surf = m_previousSurface;
+ }
return surf;
}
@@ -692,6 +710,114 @@
return MOS_STATUS_SUCCESS;
}
+MOS_STATUS VpVeboxCmdPacket::SetDiParams(PVEBOX_DI_PARAMS diParams)
+{
+ MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
+ VpVeboxRenderData *renderData = GetLastExecRenderData();
+ VP_SAMPLER_STATE_DN_PARAM lumaParams = {};
+ VPHAL_DNUV_PARAMS chromaParams = {};
+
+ VP_PUBLIC_CHK_NULL_RETURN(diParams);
+ VP_PUBLIC_CHK_NULL_RETURN(renderData);
+
+ renderData->DI.value = 0;
+ renderData->DI.bDeinterlace = diParams->bDiEnabled;
+ renderData->DI.bQueryVariance = false;
+
+ // for 30i->30fps + SFC
+ if (m_PacketCaps.bSFC && !diParams->b60fpsDi)
+ {
+ // Set BLT1's Current DI Output as BLT2's input, it is always under Mode0
+ // BLT1 output 1st field of current frame for the following cases:
+ if (m_DNDIFirstFrame ||
+ (diParams->sampleTypeInput == SAMPLE_INTERLEAVED_ODD_FIRST_BOTTOM_FIELD) ||
+ (diParams->sampleTypeInput == SAMPLE_INTERLEAVED_EVEN_FIRST_TOP_FIELD) ||
+ (diParams->sampleTypeInput == SAMPLE_SINGLE_TOP_FIELD) ||
+ (diParams->sampleTypeInput == SAMPLE_PROGRESSIVE))
+ {
+ m_DIOutputFrames = MEDIA_VEBOX_DI_OUTPUT_CURRENT;
+ }
+ else
+ {
+ // First sample output - 2nd field of the previous frame
+ m_DIOutputFrames = MEDIA_VEBOX_DI_OUTPUT_PREVIOUS;
+ }
+ }
+ // for 30i->60fps or other 30i->30fps cases
+ else
+ {
+ m_DIOutputFrames = m_DNDIFirstFrame ?
+ MEDIA_VEBOX_DI_OUTPUT_CURRENT :
+ MEDIA_VEBOX_DI_OUTPUT_BOTH;
+ }
+
+ VP_PUBLIC_CHK_STATUS_RETURN(SetDiParams(diParams->bDiEnabled, diParams->bSCDEnabled, diParams->bHDContent, diParams->sampleTypeInput, renderData->GetDNDIParams()));
+
+ return eStatus;
+}
+
+MOS_STATUS VpVeboxCmdPacket::SetDiParams(bool bDiEnabled, bool bSCDEnabled, bool bHDContent, VPHAL_SAMPLE_TYPE sampleTypeInput, MHW_VEBOX_DNDI_PARAMS ¶m)
+{
+ if (!bDiEnabled)
+ {
+ return MOS_STATUS_SUCCESS;
+ }
+
+ param.bDNDITopFirst = (sampleTypeInput == SAMPLE_INTERLEAVED_EVEN_FIRST_TOP_FIELD) ||
+ (sampleTypeInput == SAMPLE_INTERLEAVED_ODD_FIRST_TOP_FIELD);
+ param.dwLumaTDMWeight = VPHAL_VEBOX_DI_LUMA_TDM_WEIGHT_NATUAL;
+ param.dwChromaTDMWeight = VPHAL_VEBOX_DI_CHROMA_TDM_WEIGHT_NATUAL;
+ param.dwSHCMDelta = VPHAL_VEBOX_DI_SHCM_DELTA_NATUAL;
+ param.dwSHCMThreshold = VPHAL_VEBOX_DI_SHCM_THRESHOLD_NATUAL;
+ param.dwSVCMDelta = VPHAL_VEBOX_DI_SVCM_DELTA_NATUAL;
+ param.dwSVCMThreshold = VPHAL_VEBOX_DI_SVCM_THRESHOLD_NATUAL;
+ param.bFasterConvergence = false;
+ param.bTDMLumaSmallerWindow = false;
+ param.bTDMChromaSmallerWindow = false;
+ param.dwLumaTDMCoringThreshold = VPHAL_VEBOX_DI_LUMA_TDM_CORING_THRESHOLD_NATUAL;
+ param.dwChromaTDMCoringThreshold = VPHAL_VEBOX_DI_CHROMA_TDM_CORING_THRESHOLD_NATUAL;
+ param.bBypassDeflickerFilter = true;
+ param.bUseSyntheticContentMedian = false;
+ param.bLocalCheck = true;
+ param.bSyntheticContentCheck = false;
+ param.dwDirectionCheckThreshold = VPHAL_VEBOX_DI_DIRECTION_CHECK_THRESHOLD_NATUAL;
+ param.dwTearingLowThreshold = VPHAL_VEBOX_DI_TEARING_LOW_THRESHOLD_NATUAL;
+ param.dwTearingHighThreshold = VPHAL_VEBOX_DI_TEARING_HIGH_THRESHOLD_NATUAL;
+ param.dwDiffCheckSlackThreshold = VPHAL_VEBOX_DI_DIFF_CHECK_SLACK_THRESHOLD_NATUAL;
+ param.dwSADWT0 = VPHAL_VEBOX_DI_SAD_WT0_NATUAL;
+ param.dwSADWT1 = VPHAL_VEBOX_DI_SAD_WT1_NATUAL;
+ param.dwSADWT2 = VPHAL_VEBOX_DI_SAD_WT2_NATUAL;
+ param.dwSADWT3 = VPHAL_VEBOX_DI_SAD_WT3_NATUAL;
+ param.dwSADWT4 = VPHAL_VEBOX_DI_SAD_WT4_NATUAL;
+ param.dwSADWT6 = VPHAL_VEBOX_DI_SAD_WT6_NATUAL;
+ param.bSCDEnable = bSCDEnabled;
+
+ if (bHDContent)
+ {
+ param.dwLPFWtLUT0 = VPHAL_VEBOX_DI_LPFWTLUT0_HD_NATUAL;
+ param.dwLPFWtLUT1 = VPHAL_VEBOX_DI_LPFWTLUT1_HD_NATUAL;
+ param.dwLPFWtLUT2 = VPHAL_VEBOX_DI_LPFWTLUT2_HD_NATUAL;
+ param.dwLPFWtLUT3 = VPHAL_VEBOX_DI_LPFWTLUT3_HD_NATUAL;
+ param.dwLPFWtLUT4 = VPHAL_VEBOX_DI_LPFWTLUT4_HD_NATUAL;
+ param.dwLPFWtLUT5 = VPHAL_VEBOX_DI_LPFWTLUT5_HD_NATUAL;
+ param.dwLPFWtLUT6 = VPHAL_VEBOX_DI_LPFWTLUT6_HD_NATUAL;
+ param.dwLPFWtLUT7 = VPHAL_VEBOX_DI_LPFWTLUT7_HD_NATUAL;
+ }
+ else
+ {
+ param.dwLPFWtLUT0 = VPHAL_VEBOX_DI_LPFWTLUT0_SD_NATUAL;
+ param.dwLPFWtLUT1 = VPHAL_VEBOX_DI_LPFWTLUT1_SD_NATUAL;
+ param.dwLPFWtLUT2 = VPHAL_VEBOX_DI_LPFWTLUT2_SD_NATUAL;
+ param.dwLPFWtLUT3 = VPHAL_VEBOX_DI_LPFWTLUT3_SD_NATUAL;
+ param.dwLPFWtLUT4 = VPHAL_VEBOX_DI_LPFWTLUT4_SD_NATUAL;
+ param.dwLPFWtLUT5 = VPHAL_VEBOX_DI_LPFWTLUT5_SD_NATUAL;
+ param.dwLPFWtLUT6 = VPHAL_VEBOX_DI_LPFWTLUT6_SD_NATUAL;
+ param.dwLPFWtLUT7 = VPHAL_VEBOX_DI_LPFWTLUT7_SD_NATUAL;
+ }
+
+ return MOS_STATUS_SUCCESS;
+}
+
MOS_STATUS VpVeboxCmdPacket::SetupDiIecpState(
bool bDiScdEnable,
PMHW_VEBOX_DI_IECP_CMD_PARAMS pVeboxDiIecpCmdParams)
@@ -1099,7 +1225,6 @@
bDiVarianceEnable = m_PacketCaps.bDI;
SetupSurfaceStates(
- bDiVarianceEnable,
&VeboxSurfaceStateCmdParams);
// Add compressible info of input/output surface to log
@@ -1111,7 +1236,6 @@
}
SetupVeboxState(
- bDiVarianceEnable,
&VeboxStateCmdParams);
VP_RENDER_CHK_STATUS_RETURN(SetupDiIecpState(
@@ -1409,31 +1533,18 @@
VP_RENDER_CHK_STATUS_RETURN(InitSurfMemCacheControl(packetCaps));
- if (packetCaps.bSFC)
- {
- m_IsSfcUsed = true;
- }
- else
- {
- m_IsSfcUsed = false;
- }
+ m_IsSfcUsed = packetCaps.bSFC;
//update VEBOX resource GMM resource usage type
m_allocator->UpdateResourceUsageType(&inputSurface->osSurface->OsResource, MOS_HW_RESOURCE_USAGE_VP_INPUT_PICTURE_FF);
m_allocator->UpdateResourceUsageType(&outputSurface->osSurface->OsResource, MOS_HW_RESOURCE_USAGE_VP_OUTPUT_PICTURE_FF);
// Set current src = current primary input
- VP_PUBLIC_CHK_STATUS_RETURN(m_allocator->CopyVpSurface(*m_currentSurface ,*inputSurface));
VP_PUBLIC_CHK_STATUS_RETURN(m_allocator->CopyVpSurface(*m_renderTarget ,*outputSurface));
- if (previousSurface)
- {
- VP_PUBLIC_CHK_STATUS_RETURN(m_allocator->CopyVpSurface(*m_previousSurface ,*previousSurface));
- }
- m_currentSurface->rcMaxSrc = m_currentSurface->rcSrc;
// Init packet surface params.
m_surfacesGroup = internalSurfaces;
- m_veboxPacketSurface.pCurrInput = m_currentSurface;
+ m_veboxPacketSurface.pCurrInput = GetSurface(SurfaceTypeVeboxInput);
m_veboxPacketSurface.pStatisticsOutput = GetSurface(SurfaceTypeStatistics);
m_veboxPacketSurface.pCurrOutput = GetSurface(SurfaceTypeVeboxCurrentOutput);
m_veboxPacketSurface.pPrevInput = GetSurface(SurfaceTypeVeboxPreviousInput);
@@ -1448,6 +1559,9 @@
VP_RENDER_CHK_NULL_RETURN(m_veboxPacketSurface.pStatisticsOutput);
VP_RENDER_CHK_NULL_RETURN(m_veboxPacketSurface.pLaceOrAceOrRgbHistogram);
+ m_DNDIFirstFrame = (!m_PacketCaps.bRefValid && (m_PacketCaps.bDN || m_PacketCaps.bDI));
+ m_DIOutputFrames = MEDIA_VEBOX_DI_OUTPUT_CURRENT;
+
return MOS_STATUS_SUCCESS;
}
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_vebox_cmd_packet.h b/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_vebox_cmd_packet.h
index 2e86d68..bb7c792 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_vebox_cmd_packet.h
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_vebox_cmd_packet.h
@@ -379,7 +379,6 @@
//! \return void
//!
virtual void SetupSurfaceStates(
- bool bDiVarianceEnable,
PVPHAL_VEBOX_SURFACE_STATE_CMD_PARAMS pVeboxSurfaceStateCmdParams);
//!
@@ -512,6 +511,16 @@
virtual MOS_STATUS SetProcampParams(PVEBOX_PROCAMP_PARAMS procampParams);
//!
+ //! \brief Setup DI Params for Vebox
+ //! \details Setup surface DN Params for Vebox
+ //! \param [in] diParams
+ //! DI Params
+ //! \return MOS_STATUS
+ //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
+ //!
+ virtual MOS_STATUS SetDiParams(PVEBOX_DI_PARAMS diParams);
+
+ //!
//! \brief Get DN luma parameters
//! \details Get DN luma parameters
//! \param [in] bDnEnabled
@@ -683,15 +692,12 @@
//!
//! \brief Setup Vebox_State Command parameter
- //! \param [in] bDiVarianceEnable
- //! Is DI/Variances report enabled
//! \param [in,out] pVeboxStateCmdParams
//! Pointer to VEBOX_STATE command parameters
//! \return MOS_STATUS
//! Return MOS_STATUS_SUCCESS if successful, otherwise failed
//!
virtual MOS_STATUS SetupVeboxState(
- bool bDiVarianceEnable,
PMHW_VEBOX_STATE_CMD_PARAMS pVeboxStateCmdParams);
//!
@@ -955,6 +961,13 @@
PVPHAL_SURFACE pSrcSurface,
PVPHAL_SURFACE pOutSurface);
+ virtual MOS_STATUS SetDiParams(
+ bool bDiEnabled,
+ bool bSCDEnabled,
+ bool bHDContent,
+ VPHAL_SAMPLE_TYPE sampleTypeInput,
+ MHW_VEBOX_DNDI_PARAMS ¶m);
+
//!
//! \brief Get surface by type
//! \details Get surface by type
@@ -1012,6 +1025,7 @@
uint32_t m_dwGlobalNoiseLevelV = 0; //!< Global Noise Level for V
uint32_t m_dwGlobalNoiseLevel = 0; //!< Global Noise Level
PVP_VEBOX_CACHE_CNTL m_surfMemCacheCtl = nullptr; //!< Surface memory cache control
+ uint32_t m_DNDIFirstFrame = 0;
uint32_t m_DIOutputFrames = MEDIA_VEBOX_DI_OUTPUT_CURRENT; //!< default value is 2 for non-DI case.
// Statistics
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_vebox_common.h b/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_vebox_common.h
index a609aa5..04765cf 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_vebox_common.h
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/packet/vp_vebox_common.h
@@ -373,7 +373,7 @@
struct
{
uint32_t bAceEnabled : 1; // ACE enabled;
- uint32_t bQueryAceHistogram : 1; // Chroma Dn Enabled
+ uint32_t bAceHistogramEnabled : 1; // ACE histogram enabled, should be set to 1 when bAceEnabled == 1;
};
uint32_t value = 0;
} ACE;
diff --git a/media_driver/media_driver_next/agnostic/common/vp/hal/pipeline/vp_pipeline_common.h b/media_driver/media_driver_next/agnostic/common/vp/hal/pipeline/vp_pipeline_common.h
index 2ce8e71..567e92b 100644
--- a/media_driver/media_driver_next/agnostic/common/vp/hal/pipeline/vp_pipeline_common.h
+++ b/media_driver/media_driver_next/agnostic/common/vp/hal/pipeline/vp_pipeline_common.h
@@ -107,7 +107,8 @@
uint32_t bRender : 1; // Render Only needed;
// Vebox Features
uint32_t bDN : 1; // Vebox DN needed;
- uint32_t bDI : 1; // Vebox DNDI enabled
+ uint32_t bDI : 1; // Vebox DI enabled
+ uint32_t bDiProcess2ndField : 1; // Vebox DI enabled
uint32_t bIECP : 1; // Vebox IECP needed;
uint32_t bSTE : 1; // Vebox STE needed;
uint32_t bACE : 1; // Vebox ACE needed;
@@ -130,10 +131,8 @@
uint32_t bSfcIef : 1; // Sfc Details Needed;
// Render Features
- uint32_t bComposite : 1;
- uint32_t bBobDI : 1;
- uint32_t bIScaling : 1;
- uint32_t reserved : 6; // Reserved
+ uint32_t bComposite : 1;
+ uint32_t reserved : 7; // Reserved
};
};
};
@@ -154,7 +153,8 @@
uint32_t DisableVeboxSFCMode : 1;
uint32_t FurtherProcessNeeded : 1;
uint32_t CompositionNeeded : 1;
- uint32_t reserve : 19;
+ uint32_t bypassVeboxFeatures : 1;
+ uint32_t reserve : 18;
};
uint32_t value;
};
@@ -173,6 +173,19 @@
VP_COMP_BYPASS_ENABLED = 0x1
} VP_COMP_BYPASS_MODE, * PVP_COMP_BYPASS_MODE;
+// RESOURCE_ASSIGNMENT_HINT are feature parameters which will affect resource assignment.
+// For caps existing in VP_EXECUTE_CAPS, they should not be added to RESOURCE_ASSIGNMENT_HINT.
+union RESOURCE_ASSIGNMENT_HINT
+{
+ struct
+ {
+ // Hint for DI
+ uint32_t bDi : 1;
+ uint32_t b60fpsDi : 1;
+ };
+ uint32_t value;
+};
+
using VP_MHWINTERFACE = _VP_MHWINTERFACE;
using PVP_MHWINTERFACE = VP_MHWINTERFACE * ;
using VP_EXECUTE_CAPS = _VP_EXECUTE_CAPS;
diff --git a/media_driver/media_driver_next/agnostic/gen12/vp/hal/vp_vebox_cmd_packet_g12.cpp b/media_driver/media_driver_next/agnostic/gen12/vp/hal/vp_vebox_cmd_packet_g12.cpp
index 01440be..4f5822d 100644
--- a/media_driver/media_driver_next/agnostic/gen12/vp/hal/vp_vebox_cmd_packet_g12.cpp
+++ b/media_driver/media_driver_next/agnostic/gen12/vp/hal/vp_vebox_cmd_packet_g12.cpp
@@ -1,5 +1,5 @@
/*
-* Copyright (c) 2019, Intel Corporation
+* Copyright (c) 2019-2020, Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
@@ -371,84 +371,6 @@
return MOS_STATUS_SUCCESS;
}
-MOS_STATUS VpVeboxCmdPacketG12::SetDIParams(
- PVPHAL_SURFACE pSrcSurface)
-{
- // Place Hold: Add it back when enabling DI.
- //PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
- //VP_RENDER_CHK_NULL_RETURN(pRenderData);
-
- //if (!m_PacketCaps.bDI)
- //{
- // VP_RENDER_NORMALMESSAGE("DI for Output is enabled in Vebox, pls recheck the features enabling in Vebox");
- // return MOS_STATUS_INVALID_PARAMETER;
- //}
-
- //// Set DI params
- //if (pRenderData->bDeinterlace)
- //{
- // pRenderData->VeboxDNDIParams.dwLumaTDMWeight = VPHAL_VEBOX_DI_LUMA_TDM_WEIGHT_NATUAL;
- // pRenderData->VeboxDNDIParams.dwChromaTDMWeight = VPHAL_VEBOX_DI_CHROMA_TDM_WEIGHT_NATUAL;
- // pRenderData->VeboxDNDIParams.dwSHCMDelta = VPHAL_VEBOX_DI_SHCM_DELTA_NATUAL;
- // pRenderData->VeboxDNDIParams.dwSHCMThreshold = VPHAL_VEBOX_DI_SHCM_THRESHOLD_NATUAL;
- // pRenderData->VeboxDNDIParams.dwSVCMDelta = VPHAL_VEBOX_DI_SVCM_DELTA_NATUAL;
- // pRenderData->VeboxDNDIParams.dwSVCMThreshold = VPHAL_VEBOX_DI_SVCM_THRESHOLD_NATUAL;
- // pRenderData->VeboxDNDIParams.bFasterConvergence = false;
- // pRenderData->VeboxDNDIParams.bTDMLumaSmallerWindow = false;
- // pRenderData->VeboxDNDIParams.bTDMChromaSmallerWindow = false;
- // pRenderData->VeboxDNDIParams.dwLumaTDMCoringThreshold = VPHAL_VEBOX_DI_LUMA_TDM_CORING_THRESHOLD_NATUAL;
- // pRenderData->VeboxDNDIParams.dwChromaTDMCoringThreshold = VPHAL_VEBOX_DI_CHROMA_TDM_CORING_THRESHOLD_NATUAL;
- // pRenderData->VeboxDNDIParams.bBypassDeflickerFilter = true;
- // pRenderData->VeboxDNDIParams.bUseSyntheticContentMedian = false;
- // pRenderData->VeboxDNDIParams.bLocalCheck = true;
- // pRenderData->VeboxDNDIParams.bSyntheticContentCheck = false;
- // pRenderData->VeboxDNDIParams.dwDirectionCheckThreshold = VPHAL_VEBOX_DI_DIRECTION_CHECK_THRESHOLD_NATUAL;
- // pRenderData->VeboxDNDIParams.dwTearingLowThreshold = VPHAL_VEBOX_DI_TEARING_LOW_THRESHOLD_NATUAL;
- // pRenderData->VeboxDNDIParams.dwTearingHighThreshold = VPHAL_VEBOX_DI_TEARING_HIGH_THRESHOLD_NATUAL;
- // pRenderData->VeboxDNDIParams.dwDiffCheckSlackThreshold = VPHAL_VEBOX_DI_DIFF_CHECK_SLACK_THRESHOLD_NATUAL;
- // pRenderData->VeboxDNDIParams.dwSADWT0 = VPHAL_VEBOX_DI_SAD_WT0_NATUAL;
- // pRenderData->VeboxDNDIParams.dwSADWT1 = VPHAL_VEBOX_DI_SAD_WT1_NATUAL;
- // pRenderData->VeboxDNDIParams.dwSADWT2 = VPHAL_VEBOX_DI_SAD_WT2_NATUAL;
- // pRenderData->VeboxDNDIParams.dwSADWT3 = VPHAL_VEBOX_DI_SAD_WT3_NATUAL;
- // pRenderData->VeboxDNDIParams.dwSADWT4 = VPHAL_VEBOX_DI_SAD_WT4_NATUAL;
- // pRenderData->VeboxDNDIParams.dwSADWT6 = VPHAL_VEBOX_DI_SAD_WT6_NATUAL;
- // if (pSrcSurface && pSrcSurface->pDeinterlaceParams)
- // {
- // pRenderData->VeboxDNDIParams.bSCDEnable = pSrcSurface->pDeinterlaceParams->bSCDEnable;
- // }
- // else
- // {
- // pRenderData->VeboxDNDIParams.bSCDEnable = false;
- // }
-
- // VP_RENDER_CHK_NULL_RETURN(pSrcSurface);
- // if (MEDIA_IS_HDCONTENT(pSrcSurface->dwWidth, pSrcSurface->dwHeight))
- // {
- // pRenderData->VeboxDNDIParams.dwLPFWtLUT0 = VPHAL_VEBOX_DI_LPFWTLUT0_HD_NATUAL;
- // pRenderData->VeboxDNDIParams.dwLPFWtLUT1 = VPHAL_VEBOX_DI_LPFWTLUT1_HD_NATUAL;
- // pRenderData->VeboxDNDIParams.dwLPFWtLUT2 = VPHAL_VEBOX_DI_LPFWTLUT2_HD_NATUAL;
- // pRenderData->VeboxDNDIParams.dwLPFWtLUT3 = VPHAL_VEBOX_DI_LPFWTLUT3_HD_NATUAL;
- // pRenderData->VeboxDNDIParams.dwLPFWtLUT4 = VPHAL_VEBOX_DI_LPFWTLUT4_HD_NATUAL;
- // pRenderData->VeboxDNDIParams.dwLPFWtLUT5 = VPHAL_VEBOX_DI_LPFWTLUT5_HD_NATUAL;
- // pRenderData->VeboxDNDIParams.dwLPFWtLUT6 = VPHAL_VEBOX_DI_LPFWTLUT6_HD_NATUAL;
- // pRenderData->VeboxDNDIParams.dwLPFWtLUT7 = VPHAL_VEBOX_DI_LPFWTLUT7_HD_NATUAL;
- // }
- // else
- // {
- // pRenderData->VeboxDNDIParams.dwLPFWtLUT0 = VPHAL_VEBOX_DI_LPFWTLUT0_SD_NATUAL;
- // pRenderData->VeboxDNDIParams.dwLPFWtLUT1 = VPHAL_VEBOX_DI_LPFWTLUT1_SD_NATUAL;
- // pRenderData->VeboxDNDIParams.dwLPFWtLUT2 = VPHAL_VEBOX_DI_LPFWTLUT2_SD_NATUAL;
- // pRenderData->VeboxDNDIParams.dwLPFWtLUT3 = VPHAL_VEBOX_DI_LPFWTLUT3_SD_NATUAL;
- // pRenderData->VeboxDNDIParams.dwLPFWtLUT4 = VPHAL_VEBOX_DI_LPFWTLUT4_SD_NATUAL;
- // pRenderData->VeboxDNDIParams.dwLPFWtLUT5 = VPHAL_VEBOX_DI_LPFWTLUT5_SD_NATUAL;
- // pRenderData->VeboxDNDIParams.dwLPFWtLUT6 = VPHAL_VEBOX_DI_LPFWTLUT6_SD_NATUAL;
- // pRenderData->VeboxDNDIParams.dwLPFWtLUT7 = VPHAL_VEBOX_DI_LPFWTLUT7_SD_NATUAL;
- // }
- //}
-
- return MOS_STATUS_SUCCESS;
-}
-
//!
//! \brief Setup Vebox_DI_IECP Command params
//! \details Setup Vebox_DI_IECP Command params
diff --git a/media_driver/media_driver_next/agnostic/gen12/vp/hal/vp_vebox_cmd_packet_g12.h b/media_driver/media_driver_next/agnostic/gen12/vp/hal/vp_vebox_cmd_packet_g12.h
index ba6780b..272cc9b 100644
--- a/media_driver/media_driver_next/agnostic/gen12/vp/hal/vp_vebox_cmd_packet_g12.h
+++ b/media_driver/media_driver_next/agnostic/gen12/vp/hal/vp_vebox_cmd_packet_g12.h
@@ -1,5 +1,5 @@
/*
-* Copyright (c) 2019, Intel Corporation
+* Copyright (c) 2019-2020, Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
@@ -91,9 +91,6 @@
bool bAutoDetect,
float fDnFactor) override;
- virtual MOS_STATUS SetDIParams(
- PVPHAL_SURFACE pSrcSurface);
-
//!
//! \brief Setup Vebox_DI_IECP Command params
//! \details Setup Vebox_DI_IECP Command params
