Commit a716b00fc88592b6655a5a543c66d88fb26a298e - intel-media-driver

New upstream version 21.3.1+dfsg1 Sebastian Ramacher 2 years ago

47 changed file(s) with 1247 addition(s) and 1160 deletion(s). Raw diff Collapse all Expand all

-1

CMakeLists.txt less more

19	19
20	20	cmake_minimum_required(VERSION 3.5)
21	21
22		set(MEDIA_VERSION "21.3.0${MEDIA_VERSION_EXTRA}" CACHE STRING "" FORCE)
	22	set(MEDIA_VERSION "21.3.1${MEDIA_VERSION_EXTRA}" CACHE STRING "" FORCE)
23	23
24	24	include(os_release_info.cmake)
25	25

-1

media_driver/agnostic/common/codec/hal/codechal_decoder.h less more

0	0	/*
1		* Copyright (c) 2011-2020, Intel Corporation
	1	* Copyright (c) 2011-2021, Intel Corporation
2	2	*
3	3	* Permission is hereby granted, free of charge, to any person obtaining a
4	4	* copy of this software and associated documentation files (the "Software"),

169	169	PMOS_RESOURCE m_currSfcOutputPicRes = nullptr;
170	170	//! \brief Applies when debug dumps are enabled, pointer to histogram output resource for the picture associated with this status report
171	171	PMOS_RESOURCE m_currHistogramOutBuf = nullptr;
	172	//! \brief Applies when debug dumps are enabled, pointer to AV1 film grain output resource for the picture associated with this status report
	173	PMOS_RESOURCE m_currFgOutputPicRes = nullptr;
172	174	//! \brief Applies when debug dumps are enabled, stream out buffer
173	175	PMOS_RESOURCE m_streamOutBuf = nullptr;
174	176	//! \brief Applies when debug dumps are enabled, index of the streamout buffer

-2

media_driver/agnostic/common/codec/hal/codechal_encode_csc_ds.cpp less more

1115	1115	m_threadTraverseSizeY = 2; // for NV12, thread space is 32x4
1116	1116
1117	1117	// check raw surface's color/tile format
1118		if (m_cscEnableColor && !m_encoder->CheckSupportedFormat(&details))
1119		{
	1118	if (!m_encoder->CheckSupportedFormat(&details))
	1119	{
	1120	CODECHAL_ENCODE_CHK_COND_RETURN(!m_cscEnableColor && !m_cscEnableSfc, "Input color format = %d is not supported!", details.Format);
1120	1121	CODECHAL_ENCODE_CHK_STATUS_RETURN(CheckRawColorFormat(details.Format, details.TileType));
1121	1122	}
1122	1123

-0

media_driver/agnostic/common/codec/hal/codechal_encode_csc_ds.h less more

365	365
366	366	void DisableCsc() { m_cscDsConvEnable = 0; }
367	367	void EnableCopy() { m_cscEnableCopy = 1; }
	368	void DisableCopy() { m_cscEnableCopy = 0; }
368	369	void EnableColor() { m_cscEnableColor = 1; }
369	370	void EnableMmc() { m_cscEnableMmc = 1; }
370	371	void EnableSfc() { m_cscEnableSfc = 1; }

-2

media_driver/agnostic/common/codec/hal/codechal_encoder_base.cpp less more

2581	2581
2582	2582	MOS_STATUS CodechalEncoderState::SendGenericKernelCmds(
2583	2583	PMOS_COMMAND_BUFFER cmdBuffer,
2584		SendKernelCmdsParams *params)
	2584	SendKernelCmdsParams *params,
	2585	bool bEnableRenderOCA)
2585	2586	{
2586	2587	MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2587	2588

2601	2602	// frame tracking tag is only added in the last command buffer header
2602	2603	requestFrameTracking = m_singleTaskPhaseSupported ? m_firstTaskInPhase : m_lastTaskInPhase;
2603	2604	}
	2605
2604	2606	// Send command buffer header at the beginning (OS dependent)
2605		CODECHAL_ENCODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(cmdBuffer, requestFrameTracking));
	2607	CODECHAL_ENCODE_CHK_STATUS_RETURN(
	2608	SendPrologWithFrameTracking(cmdBuffer, requestFrameTracking, bEnableRenderOCA ? m_renderEngineInterface->GetMmioRegisters() : nullptr));
2606	2609
2607	2610	m_firstTaskInPhase = false;
2608	2611	}

-1

media_driver/agnostic/common/codec/hal/codechal_encoder_base.h less more

2053	2053	//! cmdbuffer to send cmds
2054	2054	//! \param [in] params
2055	2055	//! Parameters for send cmds
	2056	//! \param [in] bEnableRenderOCA
	2057	//! Enable/Disable OCA support for Render Command Streamer
2056	2058	//! \return MOS_STATUS
2057	2059	//! MOS_STATUS_SUCCESS if success, else fail reason
2058	2060	//!
2059	2061	MOS_STATUS SendGenericKernelCmds(
2060	2062	PMOS_COMMAND_BUFFER cmdBuffer,
2061		SendKernelCmdsParams *params);
	2063	SendKernelCmdsParams *params,
	2064	bool bEnableRenderOCA = false);
2062	2065
2063	2066	//!
2064	2067	//! \brief Start Status Report

-1

media_driver/agnostic/common/codec/hal/codechal_hw.cpp less more

48	48	{
49	49	CODECHAL_HW_FUNCTION_ENTER;
50	50
51		MHW_HWCMDPARSER_INIT(osInterface);
	51	#if MHW_HWCMDPARSER_ENABLED
	52	mhw::HwcmdParser::InitInstance(osInterface);
	53	#endif
52	54
53	55	// Basic intialization
54	56	m_osInterface = osInterface;

-1

media_driver/agnostic/common/codec/hal/codechal_hw.h less more

538	538	m_sfcInterface = nullptr;
539	539	}
540	540
541		MHW_HWCMDPARSER_DESTROY();
	541	#if MHW_HWCMDPARSER_ENABLED
	542	mhw::HwcmdParser::DestroyInstance();
	543	#endif
542	544	}
543	545
544	546	//!

+20

-4

media_driver/agnostic/common/codec/hal/codechal_vdenc_avc.cpp less more

5816	5816	break;
5817	5817	}
5818	5818
5819		MHW_HWCMDPARSER_FRAMEINFOUPDATE(frameType);
	5819	auto instance = mhw::HwcmdParser::GetInstance();
	5820	if (instance)
	5821	{
	5822	instance->UpdateFrameInfo(frameType);
	5823	}
5820	5824	#endif
5821	5825
5822	5826	MHW_BATCH_BUFFER batchBuffer;

6113	6117
6114	6118	CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(nullptr, secondLevelBatchBufferUsed));
6115	6119
6116		MHW_HWCMDPARSER_PARSECMDBUF((uint32_t *)(secondLevelBatchBufferUsed->pData),
6117		secondLevelBatchBufferUsed->iCurrent / sizeof(uint32_t));
	6120	#if MHW_HWCMDPARSER_ENABLED
	6121	auto instance = mhw::HwcmdParser::GetInstance();
	6122	if (instance)
	6123	{
	6124	instance->ParseCmdBuf((uint32_t *)(secondLevelBatchBufferUsed->pData),
	6125	secondLevelBatchBufferUsed->iCurrent / sizeof(uint32_t));
	6126	}
	6127	#endif
6118	6128
6119	6129	CODECHAL_DEBUG_TOOL(
6120	6130	CODECHAL_ENCODE_CHK_STATUS_RETURN(PopulatePakParam(

6513	6523	// &cmdBuffer));
6514	6524	)
6515	6525
6516		MHW_HWCMDPARSER_PARSECMDBUF(cmdBuffer.pCmdBase, cmdBuffer.iOffset / sizeof(uint32_t));
	6526	#if MHW_HWCMDPARSER_ENABLED
	6527	auto instance = mhw::HwcmdParser::GetInstance();
	6528	if (instance)
	6529	{
	6530	instance->ParseCmdBuf(cmdBuffer.pCmdBase, cmdBuffer.iOffset / sizeof(uint32_t));
	6531	}
	6532	#endif
6517	6533	m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
6518	6534
6519	6535	bool renderingFlags = m_videoContextUsesNullHw;

-1

media_driver/agnostic/common/codec/shared/codec_def_decode_hevc.h less more

37	37	#define CODECHAL_HEVC_MAX_NUM_SLICES_LVL_5 200
38	38	#define CODECHAL_HEVC_NUM_DMEM_BUFFERS 32
39	39
40		#define CODEC_HEVC_NUM_SECOND_BB 8
	40	#define CODEC_HEVC_NUM_SECOND_BB 32
41	41
42	42	#define CODECHAL_HEVC_MIN_LCU 16
43	43	#define CODECHAL_HEVC_MAX_DIM_FOR_MIN_LCU 4222

+13

-10

media_driver/agnostic/common/hw/mhw_mi_generic.h less more

122	122	PMOS_COMMAND_BUFFER cmdBuffer,
123	123	bool isRender)
124	124	{
125		MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
126		PMOS_RESOURCE pResMarker = NULL;
127
128		MHW_FUNCTION_ENTER;
129
130		pResMarker = m_osInterface->pfnGetMarkerResource(m_osInterface);
	125	MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
	126	PMOS_RESOURCE resMarker = nullptr;
	127
	128	MHW_FUNCTION_ENTER;
	129
	130	resMarker = m_osInterface->pfnGetMarkerResource(m_osInterface);
	131	MHW_CHK_NULL_RETURN(resMarker);
131	132
132	133	if (isRender)
133	134	{
134	135	// Send pipe_control to get the timestamp
135	136	MHW_PIPE_CONTROL_PARAMS pipeControlParams;
136	137	MOS_ZeroMemory(&pipeControlParams, sizeof(pipeControlParams));
137		pipeControlParams.presDest = pResMarker;
	138	pipeControlParams.presDest = resMarker;
138	139	pipeControlParams.dwResourceOffset = sizeof(uint64_t);
139	140	pipeControlParams.dwPostSyncOp = MHW_FLUSH_WRITE_TIMESTAMP_REG;
140	141	pipeControlParams.dwFlushMode = MHW_FLUSH_WRITE_CACHE;

146	147	// Send flush_dw to get the timestamp
147	148	MHW_MI_FLUSH_DW_PARAMS flushDwParams;
148	149	MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
149		flushDwParams.pOsResource = pResMarker;
	150	flushDwParams.pOsResource = resMarker;
150	151	flushDwParams.dwResourceOffset = sizeof(uint64_t);
151	152	flushDwParams.postSyncOperation = MHW_FLUSH_WRITE_TIMESTAMP_REG;
152	153	flushDwParams.bQWordEnable = 1;
153	154
154	155	MHW_MI_CHK_STATUS(AddMiFlushDwCmd(cmdBuffer, &flushDwParams));
155	156	}
156
157		MOS_SafeFreeMemory(pResMarker);
	157	if (!m_osInterface->apoMosEnabled)
	158	{
	159	MOS_SafeFreeMemory(resMarker);
	160	}
158	161	return eStatus;
159	162	}
160	163

-3

media_driver/agnostic/common/hw/vdbox/mhw_vdbox_huc_interface.h less more

29	29
30	30	#include "mhw_vdbox.h"
31	31	#include "mhw_mi.h"
32		#include "mhw_cmdpar.h"
33	32
34	33	typedef struct _MHW_VDBOX_HUC_STREAM_OBJ_PARAMS
35	34	{

110	109
111	110	MHW_MEMORY_OBJECT_CONTROL_PARAMS m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_END_CODEC] = { }; //!< Cacheability settings
112	111
113		mhw::Pointer<void> m_hucItfNew = nullptr;
	112	std::shared_ptr<void> m_hucItfNew = nullptr;
114	113
115	114	//!
116	115	//! \brief Constructor

152	151	//!
153	152	//! \return pointer to new HUC interface
154	153	//!
155		virtual mhw::Pointer<void> GetNewHucInterface() { return nullptr; }
	154	virtual std::shared_ptr<void> GetNewHucInterface() { return nullptr; }
156	155
157	156	//!
158	157	//! \brief Get Huc Status Hevc S2l Failure Mask

-2

media_driver/agnostic/common/hw/vdbox/mhw_vdbox_vdenc_interface.h less more

192	192	bool m_rhoDomainStatsEnabled = false; //! indicate if rho domain stats is enabled
193	193	bool m_perfModeSupported = true; //! indicate perf mode is supported
194	194
195		mhw::Pointer<mhw::vdbox::vdenc::Itf> m_vdencItfNew = nullptr;
	195	std::shared_ptr<mhw::vdbox::vdenc::Itf> m_vdencItfNew = nullptr;
196	196
197	197	static const bool m_vdencFTQEnabled[NUM_VDENC_TARGET_USAGE_MODES];
198	198	static const bool m_vdencBlockBasedSkipEnabled[NUM_VDENC_TARGET_USAGE_MODES];

247	247	//!
248	248	//! \return pointer to new VDENC interface
249	249	//!
250		virtual mhw::Pointer<mhw::vdbox::vdenc::Itf> GetNewVdencInterface() { return nullptr; }
	250	virtual std::shared_ptr<mhw::vdbox::vdenc::Itf> GetNewVdencInterface() { return nullptr; }
251	251
252	252	//!
253	253	//! \brief Judge if row store caching supported

+22

-0

media_driver/agnostic/common/os/mos_interface.h less more

1880	1880	static int32_t IsGPUHung(
1881	1881	MOS_STREAM_HANDLE streamState);
1882	1882
	1883	//!
	1884	//! \brief Get SetMarker enabled flag
	1885	//! \details Get SetMarker enabled flag from streamState
	1886	//! \param [in] streamState
	1887	//! Handle of Os Stream State
	1888	//! \return bool
	1889	//! SetMarker enabled flag
	1890	//!
	1891	static bool IsSetMarkerEnabled(
	1892	MOS_STREAM_HANDLE streamState);
	1893
	1894	//!
	1895	//! \brief Get SetMarker resource address
	1896	//! \details Get SetMarker resource address from streamState
	1897	//! \param [in] streamState
	1898	//! Handle of Os Stream State
	1899	//! \return PMOS_RESOURCE
	1900	//! SetMarker resource address
	1901	//!
	1902	static PMOS_RESOURCE GetMarkerResource(
	1903	MOS_STREAM_HANDLE streamState);
	1904
1883	1905	private:
1884	1906	//!
1885	1907	//! \brief Init per stream parameters

-0

media_driver/agnostic/common/os/mos_os.h less more

1416	1416
1417	1417	int32_t bVeboxScalabilityMode; //!< Enable scalability vebox
1418	1418
	1419	bool bOptimizeCpuTiming; //!< Optimize Cpu Timing
	1420
1419	1421	//!< os interface extension
1420	1422	void *pOsExt;
1421	1423	} MOS_INTERFACE;

-0

media_driver/agnostic/common/vp/hal/vphal_common.c less more

482	482	goto finish;
483	483	}
484	484
	485	if (pOsInterface->bOptimizeCpuTiming &&
	486	(DefaultResType == MOS_GFXRES_BUFFER) &&
	487	(pSurface->dwWidth >= dwWidth))
	488	{
	489	goto finish;
	490	}
	491
485	492	MOS_ZeroMemory(&AllocParams, sizeof(MOS_ALLOC_GFXRES_PARAMS));
486	493
487	494	VpHal_AllocParamsInitType(&AllocParams, pSurface, DefaultResType, DefaultTileType);

-0

media_driver/agnostic/common/vp/hal/vphal_common.h less more

1234	1234	bool bDisableVeboxFor8K = false;
1235	1235	bool bUseVEHdrSfc = false; // use SFC for to perform CSC/Scaling/RGBSwap of HDR streaming; if false, use composite render.
1236	1236	bool bNonFirstFrame = false; // first frame or not: first frame false, otherwise true considering zeromemory parameters.
	1237	bool bOptimizeCpuTiming = false; //!< Optimize Cpu Timing
1237	1238
1238	1239	VPHAL_RENDER_PARAMS() :
1239	1240	uSrcCount(0),

-0

media_driver/agnostic/common/vp/hal/vphal_common_tools.h less more

181	181	//add config to switch 8K resolution on VEBOX or render
182	182	//default is use render for 8k
183	183	uint32_t dwUseVeboxFor8K;
	184
	185	// Optimize Cpu timing for VEBOX/SFC
	186	bool bOptimizeCpuTiming;
184	187	} VP_CONFIG, *PVP_CONFIG;
185	188
186	189	//!

+16

-1

media_driver/agnostic/gen11/codec/hal/codechal_encode_avc_g11.cpp less more

64	64	static const uint32_t mbTextureThreshold = 1024;
65	65	static const uint32_t adaptiveTxDecisionThreshold = 128;
66	66	static const uint32_t brcHistoryBufferOffsetSceneChanged = 0x2FC;
	67	static const uint32_t ocaMvDataBufferMaxSize = 0x70000; // MV buffer size for 1280x704 stream
67	68
68	69	static const uint32_t trellisQuantizationRounding[NUM_TARGET_USAGE_MODES] =
69	70	{

4314	4315	sendKernelCmdsParams.ucDmvPredFlag =
4315	4316	m_avcSliceParams->direct_spatial_mv_pred_flag;
4316	4317	sendKernelCmdsParams.pKernelState = kernelState;
4317		CODECHAL_ENCODE_CHK_STATUS_RETURN(SendGenericKernelCmds(&cmdBuffer, &sendKernelCmdsParams));
	4318	CODECHAL_ENCODE_CHK_STATUS_RETURN(SendGenericKernelCmds(&cmdBuffer, &sendKernelCmdsParams, true));
4318	4319	}
4319	4320
4320	4321	// Set up MB BRC Constant Data Buffer if there is QP change within a frame

4550	4551	m_hwInterface,
4551	4552	&walkerParams,
4552	4553	&walkerCodecParams));
	4554
	4555	HalOcaInterface::TraceMessage(cmdBuffer, *m_osInterface->pOsContext, __FUNCTION__, sizeof(__FUNCTION__));
	4556	HalOcaInterface::OnDispatch(cmdBuffer, m_osInterface->pOsContext, m_miInterface, *m_renderEngineInterface->GetMmioRegisters());
4553	4557
4554	4558	CODECHAL_ENCODE_CHK_STATUS_RETURN(m_renderEngineInterface->AddMediaObjectWalkerCmd(
4555	4559	&cmdBuffer,

7220	7224	&surfaceCodecParams,
7221	7225	kernelState));
7222	7226
	7227	// Limit OCA dump size for MV buffer to ocaMvDataBufferMaxSize to do not overflow OCA
	7228	if (m_mvDataSize > ocaMvDataBufferMaxSize)
	7229	{
	7230	std::stringstream ss;
	7231	ss << "MV Data buffer ( size == 0x" << std::hex << m_mvDataSize << " ) is too large to fit into the OCA buffer. "
	7232	"Put only 0x" << std::hex << ocaMvDataBufferMaxSize << " bytes - max allowed size";
	7233	std::string ocaLog = ss.str();
	7234	HalOcaInterface::TraceMessage(cmdBuffer, m_osInterface->pOsContext, ocaLog.c_str(), ocaLog.length());
	7235	}
	7236	HalOcaInterface::OnIndirectState(cmdBuffer, m_osInterface->pOsContext, mvDataBuffer, 0, false, MOS_MIN(m_mvDataSize, ocaMvDataBufferMaxSize));
	7237
7223	7238	// Current Picture Y
7224	7239	MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
7225	7240	surfaceCodecParams.bIs2DSurface = true;

-1

media_driver/agnostic/gen12/codec/hal/codechal_encode_avc_g12.cpp less more

1468	1468	sendKernelCmdsParams.ucDmvPredFlag =
1469	1469	m_avcSliceParams->direct_spatial_mv_pred_flag;
1470	1470	sendKernelCmdsParams.pKernelState = kernelState;
1471		CODECHAL_ENCODE_CHK_STATUS_RETURN(SendGenericKernelCmds(&cmdBuffer, &sendKernelCmdsParams));
	1471	CODECHAL_ENCODE_CHK_STATUS_RETURN(SendGenericKernelCmds(&cmdBuffer, &sendKernelCmdsParams, true));
1472	1472
1473	1473	// Set up MB BRC Constant Data Buffer if there is QP change within a frame
1474	1474	if (mbConstDataBufferInUse)

-1

media_driver/agnostic/gen12/codec/shared/codec_def_decode_av1.h less more

30	30
31	31	#define CODECHAL_MAX_DPB_NUM_AV1 127 // Maximum number of uncompressed decoded buffers that driver supports for non-LST mode
32	32	#define CODEC_NUM_REF_AV1_TEMP_BUFFERS 8
33		#define CODEC_NUM_AV1_SECOND_BB 16
	33	#define CODEC_NUM_AV1_SECOND_BB 64
34	34	#define CODEC_NUM_AV1_TEMP_BUFFERS (CODEC_NUM_REF_AV1_TEMP_BUFFERS + 1) //!< Temp buffers number
35	35	#define CODECHAL_MAX_DPB_NUM_LST_AV1 255 // Maximum number of uncompressed decoded buffers that driver supports with LST support
36	36

-0

media_driver/linux/common/ddi/media_libva.cpp less more

82	82	VAProcFilterTotalColorCorrection,
83	83	VAProcFilterHVSNoiseReduction,
84	84	VAProcFilterHighDynamicRangeToneMapping
	85	#if VA_CHECK_VERSION(1, 12, 0)
	86	, VAProcFilter3DLUT
	87	#endif
85	88	};
86	89
87	90	VAProcColorStandardType vp_input_color_std[DDI_VP_NUM_INPUT_COLOR_STD] = {

+12

-0

media_driver/linux/common/os/mos_interface.cpp less more

2852	2852	return result;
2853	2853	}
2854	2854
	2855	bool MosInterface::IsSetMarkerEnabled(
	2856	MOS_STREAM_HANDLE streamState)
	2857	{
	2858	return false;
	2859	}
	2860
	2861	PMOS_RESOURCE MosInterface::GetMarkerResource(
	2862	MOS_STREAM_HANDLE streamState)
	2863	{
	2864	return nullptr;
	2865	}
	2866
2855	2867	#if MOS_COMMAND_BUFFER_DUMP_SUPPORTED
2856	2868	MOS_STATUS MosInterface::DumpCommandBufferInit(
2857	2869	MOS_STREAM_HANDLE streamState)

-1

media_driver/media_interface/media_interfaces_m12_adlp/media_interfaces_g12_adlp.cpp less more

46	46	#ifdef _MMC_SUPPORTED
47	47	static bool adlsRegisteredMmd =
48	48	MediaInterfacesFactory<MmdDevice>::
49		RegisterHal<MmdDeviceG12Tgllp>((uint32_t)IGFX_TIGERLAKE_LP);
	49	RegisterHal<MmdDeviceG12Tgllp>((uint32_t)IGFX_ALDERLAKE_P);
50	50	#endif
51	51
52	52	#define PLATFORM_INTEL_ADLP 23

-0

media_driver/media_softlet/agnostic/gen12/codec/hal/dec/av1/features/decode_av1_filmgrain_feature_g12.cpp less more

961	961	DECODE_CHK_STATUS(AllocateVariableSizeSurfaces());
962	962	}
963	963
	964	#if (_DEBUG \|\| _RELEASE_INTERNAL)
	965	m_fgOutputSurfList[m_basicFeature->m_curRenderPic.FrameIdx] = m_basicFeature->m_fgOutputSurf;
	966	#endif
	967
964	968	return MOS_STATUS_SUCCESS;
965	969	}
966	970

-0

media_driver/media_softlet/agnostic/gen12/codec/hal/dec/av1/features/decode_av1_filmgrain_feature_g12.h less more

228	228	static const int32_t m_minChromaLegalRange = 16; //!< minimum chroma legal range
229	229	static const int32_t m_maxChromaLegalRange = 240; //!< maximum chroma legal range
230	230
	231	#if (_DEBUG \|\| _RELEASE_INTERNAL)
	232	MOS_SURFACE m_fgOutputSurfList[DecodeBasicFeature::m_maxFrameIndex] = {}; //! \brief fimm grain applied surfaces
	233	#endif
	234
231	235	enum
232	236	{
233	237	fieldTopSrcY = 0, //!< Binding table offset for Top field input Y

+57

-364

media_driver/media_softlet/agnostic/gen12/codec/hal/dec/av1/pipeline/decode_av1_pipeline_g12.cpp less more

130	130	inputParameters.currOriginalPic = basicFeature->m_curRenderPic;
131	131	inputParameters.currDecodedPicRes = basicFeature->m_destSurface.OsResource;
132	132	inputParameters.numUsedVdbox = m_numVdbox;
	133
	134	#if (_DEBUG \|\| _RELEASE_INTERNAL)
	135	auto filmGrainFeature = dynamic_cast<Av1DecodeFilmGrainG12*>(m_featureManager->GetFeature(
	136	Av1FeatureIDs::av1SwFilmGrain));
	137	if (filmGrainFeature != nullptr && filmGrainFeature->m_filmGrainEnabled)
	138	{
	139	auto frameIdx = basicFeature->m_curRenderPic.FrameIdx;
	140	inputParameters.fgOutputPicRes = &filmGrainFeature->m_fgOutputSurfList[frameIdx].OsResource;
	141	}
	142	#endif
133	143	m_allocator->UpdateResoreceUsageType(&inputParameters.currDecodedPicRes, resourceOutputPicture);
134	144	m_statusReport->Init(&inputParameters);
135	145	}

166	176	DECODE_CHK_STATUS(InitContext());
167	177	DECODE_CHK_STATUS(ActivateDecodePackets());
168	178	DECODE_CHK_STATUS(ExecuteActivePackets());
	179
	180	DECODE_CHK_STATUS(m_postSubPipeline->Execute());
	181
	182	CODECHAL_DEBUG_TOOL(
	183	PMHW_BATCH_BUFFER batchBuffer = m_av1DecodePkt->GetSecondLvlBB();
	184	batchBuffer->iLastCurrent = batchBuffer->iSize;
	185	batchBuffer->dwOffset = 0;
	186	DECODE_CHK_STATUS(m_debugInterface->Dump2ndLvlBatch(
	187	batchBuffer,
	188	CODECHAL_NUM_MEDIA_STATES,
	189	"AV1_DEC_Secondary"));)
	190
	191	#if (_DEBUG \|\| _RELEASE_INTERNAL)
	192	DECODE_CHK_STATUS(StatusCheck());
	193	#endif
	194	// Only update user features for the first frame.
	195	if (basicFeature->m_frameNum == 0)
	196	{
	197	DECODE_CHK_STATUS(UserFeatureReport());
	198	}
	199	basicFeature->m_frameNum++;
	200
	201	DECODE_CHK_STATUS(m_statusReport->Reset());
169	202	}
170
171		DECODE_CHK_STATUS(m_postSubPipeline->Execute());
172		}
173		else if (m_pipeMode == decodePipeModeEnd)
174		{
175		auto feature = dynamic_cast<DecodeBasicFeature*>(m_featureManager->GetFeature(FeatureIDs::basicFeature));
176		DECODE_CHK_NULL(feature);
177		CODECHAL_DEBUG_TOOL(
178		m_debugInterface->m_bufferDumpFrameNum = feature->m_frameNum;
179		DECODE_CHK_STATUS(m_debugInterface->DumpYUVSurface(
180		&feature->m_destSurface,
181		CodechalDbgAttr::attrDecodeOutputSurface,
182		"DstSurf"));)
183
184		auto filmGrainFeature = dynamic_cast<Av1DecodeFilmGrainG12*>(m_featureManager->GetFeature(
185		Av1FeatureIDs::av1SwFilmGrain));
186		if (filmGrainFeature != nullptr && filmGrainFeature->m_filmGrainEnabled)
187		{
188		auto av1Feature = dynamic_cast<Av1BasicFeature*>(feature);
189		CODECHAL_DEBUG_TOOL(
190		m_debugInterface->m_bufferDumpFrameNum = feature->m_frameNum;
191		DECODE_CHK_STATUS(m_debugInterface->DumpYUVSurface(
192		&av1Feature->m_fgOutputSurf,
193		CodechalDbgAttr::attrFilmGrain,
194		"FilmGrain"));)
195		}
196
197		CODECHAL_DEBUG_TOOL(
198		PMHW_BATCH_BUFFER batchBuffer = m_av1DecodePkt->GetSecondLvlBB();
199		DECODE_CHK_NULL(batchBuffer);
200		batchBuffer->iLastCurrent = batchBuffer->iSize;
201		batchBuffer->dwOffset = 0;
202		DECODE_CHK_STATUS(m_debugInterface->Dump2ndLvlBatch(
203		batchBuffer,
204		CODECHAL_NUM_MEDIA_STATES,
205		"AV1_DEC_Secondary"));)
206
207		// Only update user features for the first frame.
208		if (feature->m_frameNum == 0)
209		{
210		DECODE_CHK_STATUS(UserFeatureReport());
211		}
212		feature->m_frameNum++;
213
214		DECODE_CHK_STATUS(m_statusReport->Reset());
215	203	}
216	204
217	205	return MOS_STATUS_SUCCESS;

337	325	return MOS_STATUS_SUCCESS;
338	326	}
339	327
340		#if USE_CODECHAL_DEBUG_TOOL
341		MOS_STATUS Av1PipelineG12::DumpParams(Av1BasicFeature &basicFeature)
342		{
343		m_debugInterface->m_frameType = basicFeature.m_av1PicParams->m_picInfoFlags.m_fields.m_frameType ? P_TYPE : I_TYPE;
344		m_debugInterface->m_bufferDumpFrameNum = basicFeature.m_frameNum;
345
346		DECODE_CHK_STATUS(DumpPicParams(
347		basicFeature.m_av1PicParams));
348
349		DECODE_CHK_STATUS(DumpBitstreamControlParams(
350		basicFeature.m_av1TileParams));
351
352		return MOS_STATUS_SUCCESS;
353		}
354
355		MOS_STATUS Av1PipelineG12::DumpBitstreamControlParams(CodecAv1TileParams *tileParams)
356		{
357		CODECHAL_DEBUG_FUNCTION_ENTER;
358
359		if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrSlcParams))
360		{
361		return MOS_STATUS_SUCCESS;
362		}
363
364		CODECHAL_DEBUG_CHK_NULL(tileParams);
365
366		std::ostringstream oss;
367		oss.setf(std::ios::showbase \| std::ios::uppercase);
368
369		oss << "BSTileDataLocation: " << +tileParams->m_bsTileDataLocation << std::endl;
370		oss << "BSTileBytesInBuffer: " << +tileParams->m_bsTileBytesInBuffer << std::endl;
371		oss << "wBadBSBufferChopping: " << +tileParams->m_badBSBufferChopping << std::endl;
372		oss << "tile_row: " << +tileParams->m_tileRow << std::endl;
373		oss << "tile_column: " << +tileParams->m_tileColumn << std::endl;
374		oss << "tile_index: " << +tileParams->m_tileIndex << std::endl;
375		oss << "StartTileIdx: " << +tileParams->m_startTileIdx << std::endl;
376		oss << "EndTileIdx: " << +tileParams->m_endTileIdx << std::endl;
377		oss << "anchor_frame_idx: " << +tileParams->m_anchorFrameIdx.FrameIdx << std::endl;
378		oss << "BSTilePayloadSizeInBytes: " << +tileParams->m_bsTilePayloadSizeInBytes << std::endl;
379
380		const char *fileName = m_debugInterface->CreateFileName(
381		"DEC",
382		"BitstreamControlParams",
383		CodechalDbgExtType::txt);
384
385		std::ofstream ofs;
386		ofs.open(fileName, std::ios::out);
387		ofs << oss.str();
388		ofs.close();
389
390		return MOS_STATUS_SUCCESS;
391		}
392
393		MOS_STATUS Av1PipelineG12::DumpPicParams(CodecAv1PicParams *picParams)
394		{
395		CODECHAL_DEBUG_FUNCTION_ENTER;
396
397		if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrPicParams))
398		{
399		return MOS_STATUS_SUCCESS;
400		}
401		CODECHAL_DEBUG_CHK_NULL(picParams);
402
403		std::ostringstream oss;
404		oss.setf(std::ios::showbase \| std::ios::uppercase);
405
406		oss << "CurrPic FrameIdx: " << std::hex << +picParams->m_currPic.FrameIdx << std::endl;
407		oss << "CurrDisplayPic FrameIdx: " << std::hex << +picParams->m_currDisplayPic.FrameIdx << std::endl;
408		oss << "Profile: " << std::hex << +picParams->m_profile << std::endl;
409		oss << "AnchorFrameInsertion: " << std::hex << +picParams->m_anchorFrameInsertion << std::endl;
410		oss << "order_hint_bits_minus_1: " << std::hex << +picParams->m_orderHintBitsMinus1 << std::endl;
411		oss << "BitDepthIdx: " << std::hex << +picParams->m_bitDepthIdx << std::endl;
412
413		//Sequence Info Flags
414		oss << "dwSeqInfoFlags: " << std::hex << +picParams->m_seqInfoFlags.m_value << std::endl;
415		oss << "still_picture: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_stillPicture << std::endl;
416		oss << "use_128x128_superblock: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_use128x128Superblock << std::endl;
417		oss << "enable_filter_intra: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_enableFilterIntra << std::endl;
418		oss << "enable_intra_edge_filter: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_enableIntraEdgeFilter << std::endl;
419		oss << "enable_interintra_compound: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_enableInterintraCompound << std::endl;
420		oss << "enable_masked_compound: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_enableMaskedCompound << std::endl;
421		oss << "enable_dual_filter: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_enableDualFilter << std::endl;
422		oss << "enable_order_hint: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_enableOrderHint << std::endl;
423		oss << "enable_jnt_comp: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_enableJntComp << std::endl;
424		oss << "enable_cdef: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_enableCdef << std::endl;
425		oss << "mono_chrome: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_monoChrome << std::endl;
426		oss << "color_range: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_colorRange << std::endl;
427		oss << "subsampling_x: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_subsamplingX << std::endl;
428		oss << "subsampling_y: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_subsamplingY << std::endl;
429		oss << "chroma_sample_position: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_chromaSamplePosition << std::endl;
430		oss << "film_grain_params_present: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_filmGrainParamsPresent << std::endl;
431
432		//frame info
433		oss << "dwPicInfoFlags: " << std::hex << +picParams->m_picInfoFlags.m_value << std::endl;
434		oss << "frame_type: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_frameType << std::endl;
435		oss << "show_frame: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_showFrame << std::endl;
436		oss << "showable_frame: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_showableFrame << std::endl;
437		oss << "error_resilient_mode: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_errorResilientMode << std::endl;
438		oss << "disable_cdf_update: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_disableCdfUpdate << std::endl;
439		oss << "allow_screen_content_tools: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_allowScreenContentTools << std::endl;
440		oss << "force_integer_mv: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_forceIntegerMv << std::endl;
441		oss << "allow_intrabc: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_allowIntrabc << std::endl;
442		oss << "use_superres: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_useSuperres << std::endl;
443		oss << "allow_high_precision_mv: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_allowHighPrecisionMv << std::endl;
444		oss << "is_motion_mode_switchable: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_isMotionModeSwitchable << std::endl;
445		oss << "use_ref_frame_mvs: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_useRefFrameMvs << std::endl;
446		oss << "disable_frame_end_update_cdf: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_disableFrameEndUpdateCdf << std::endl;
447		oss << "uniform_tile_spacing_flag: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_uniformTileSpacingFlag << std::endl;
448		oss << "allow_warped_motion: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_allowWarpedMotion << std::endl;
449		oss << "large_scale_tile: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_largeScaleTile << std::endl;
450
451		oss << "frame_width_minus1: " << std::hex << +picParams->m_frameWidthMinus1 << std::endl;
452		oss << "frame_height_minus1: " << std::hex << +picParams->m_frameHeightMinus1 << std::endl;
453
454		for (auto i = 0; i < 8; ++i)
455		{
456		oss << "ref_frame_map[" << +i << "] FrameIdx:" << std::hex << +picParams->m_refFrameMap[i].FrameIdx << std::endl;
457		oss << "ref_frame_map[" << +i << "] PicFlags:" << std::hex << +picParams->m_refFrameMap[i].PicFlags << std::endl;
458		}
459
460		for (auto i = 0; i < 7; i++)
461		{
462		oss << "ref_frame_idx[" << +i << "]: " << std::hex << +picParams->m_refFrameIdx[i] << std::endl;
463		}
464
465		oss << "primary_ref_frame: " << std::hex << +picParams->m_primaryRefFrame << std::endl;
466		oss << "output_frame_width_in_tiles_minus_1: " << std::hex << +picParams->m_outputFrameWidthInTilesMinus1 << std::endl;
467		oss << "output_frame_height_in_tiles_minus_1: " << std::hex << +picParams->m_outputFrameHeightInTilesMinus1 << std::endl;
468
469		for (auto i = 0; i < 2; i++)
470		{
471		oss << "filter_level[" << +i << "]: " << std::hex << +picParams->m_filterLevel[i] << std::endl;
472		}
473		oss << "filter_level_u: " << std::hex << +picParams->m_filterLevelU << std::endl;
474		oss << "filter_level_v: " << std::hex << +picParams->m_filterLevelV << std::endl;
475
476		//Loop Filter Info Flags
477		oss << "cLoopFilterInfoFlags value: " << std::hex << +picParams->m_loopFilterInfoFlags.m_value << std::endl;
478		oss << "sharpness_level: " << std::hex << +picParams->m_loopFilterInfoFlags.m_fields.m_sharpnessLevel << std::endl;
479		oss << "mode_ref_delta_enabled: " << std::hex << +picParams->m_loopFilterInfoFlags.m_fields.m_modeRefDeltaEnabled << std::endl;
480		oss << "mode_ref_delta_update: " << std::hex << +picParams->m_loopFilterInfoFlags.m_fields.m_modeRefDeltaUpdate << std::endl;
481
482		oss << "order_hint: " << std::hex << +picParams->m_orderHint << std::endl;
483		oss << "superres_scale_denominator: " << std::hex << +picParams->m_superresScaleDenominator << std::endl;
484		oss << "interp_filter: " << std::hex << +picParams->m_interpFilter << std::endl;
485
486		for (auto i = 0; i < 8; i++)
487		{
488		oss << "ref_deltas[" << +i << "]: " << std::hex << +picParams->m_refDeltas[i] << std::endl;
489		}
490
491		for (auto i = 0; i < 2; i++)
492		{
493		oss << "mode_deltas[" << +i << "]: " << std::hex << +picParams->m_modeDeltas[i] << std::endl;
494		}
495
496		oss << "base_qindex: " << std::hex << +picParams->m_baseQindex << std::endl;
497		oss << "y_dc_delta_q: " << std::hex << +picParams->m_yDcDeltaQ << std::endl;
498		oss << "u_dc_delta_q: " << std::hex << +picParams->m_uDcDeltaQ << std::endl;
499		oss << "u_ac_delta_q: " << std::hex << +picParams->m_uAcDeltaQ << std::endl;
500		oss << "v_dc_delta_q: " << std::hex << +picParams->m_vDcDeltaQ << std::endl;
501		oss << "v_ac_delta_q: " << std::hex << +picParams->m_vAcDeltaQ << std::endl;
502
503		// quantization_matrix
504		oss << "wQMatrixFlags value: " << std::hex << +picParams->m_qMatrixFlags.m_value << std::endl;
505		oss << "using_qmatrix: " << std::hex << +picParams->m_qMatrixFlags.m_fields.m_usingQmatrix<< std::endl;
506		oss << "qm_y: " << std::hex << +picParams->m_qMatrixFlags.m_fields.m_qmY << std::endl;
507		oss << "qm_u: " << std::hex << +picParams->m_qMatrixFlags.m_fields.m_qmU << std::endl;
508		oss << "qm_v: " << std::hex << +picParams->m_qMatrixFlags.m_fields.m_qmV << std::endl;
509
510		// Mode control flags
511		oss << "dwModeControlFlags value: " << std::hex << +picParams->m_modeControlFlags.m_value << std::endl;
512		oss << "delta_q_present_flag: " << std::hex << +picParams->m_modeControlFlags.m_fields.m_deltaQPresentFlag << std::endl;
513		oss << "log2_delta_q_res: " << std::hex << +picParams->m_modeControlFlags.m_fields.m_log2DeltaQRes << std::endl;
514		oss << "delta_lf_present_flag: " << std::hex << +picParams->m_modeControlFlags.m_fields.m_deltaLfPresentFlag << std::endl;
515		oss << "log2_delta_lf_res: " << std::hex << +picParams->m_modeControlFlags.m_fields.m_log2DeltaLfRes << std::endl;
516		oss << "delta_lf_multi: " << std::hex << +picParams->m_modeControlFlags.m_fields.m_deltaLfMulti << std::endl;
517		oss << "tx_mode: " << std::hex << +picParams->m_modeControlFlags.m_fields.m_txMode << std::endl;
518		oss << "reference_mode: " << std::hex << +picParams->m_modeControlFlags.m_fields.m_referenceMode << std::endl;
519		oss << "reduced_tx_set_used: " << std::hex << +picParams->m_modeControlFlags.m_fields.m_reducedTxSetUsed << std::endl;
520		oss << "skip_mode_present: " << std::hex << +picParams->m_modeControlFlags.m_fields.m_skipModePresent << std::endl;
521
522		// Segmentation
523		oss << "enabled: " << std::hex << +picParams->m_av1SegData.m_enabled << std::endl;
524		oss << "update_map: " << std::hex << +picParams->m_av1SegData.m_updateMap << std::endl;
525		oss << "temporal_update: " << std::hex << +picParams->m_av1SegData.m_temporalUpdate << std::endl;
526		oss << "update_data: " << std::hex << +picParams->m_av1SegData.m_updateData << std::endl;
527
528		for (auto i = 0; i < 8; i++)
529		{
530		for (auto j = 0; j < 8; j++)
	328	#if USE_CODECHAL_DEBUG_TOOL
	329	MOS_STATUS Av1PipelineG12::DumpOutput(const DecodeStatusReportData& reportData)
	330	{
	331	DECODE_FUNC_CALL();
	332
	333	DECODE_CHK_STATUS(DecodePipeline::DumpOutput(reportData));
	334
	335	auto feature = dynamic_cast<Av1BasicFeature*>(m_featureManager->GetFeature(FeatureIDs::basicFeature));
	336	DECODE_CHK_NULL(feature);
	337	auto filmGrainFeature = dynamic_cast<Av1DecodeFilmGrainG12*>(m_featureManager->GetFeature(
	338	Av1FeatureIDs::av1SwFilmGrain));
	339	if (filmGrainFeature != nullptr && filmGrainFeature->m_filmGrainEnabled)
	340	{
	341	if (reportData.currFgOutputPicRes != nullptr)
531	342	{
532		oss << "feature_data[" << +i << "][" << +j << "]: " << std::hex << +picParams->m_av1SegData.m_featureData[i][j] << std::endl;
	343	MOS_SURFACE fgOutputSurface;
	344	MOS_ZeroMemory(&fgOutputSurface, sizeof(fgOutputSurface));
	345	fgOutputSurface.Format = Format_NV12;
	346	fgOutputSurface.OsResource = *reportData.currFgOutputPicRes;
	347	if (!Mos_ResourceIsNull(&fgOutputSurface.OsResource))
	348	{
	349	DECODE_CHK_STATUS(m_allocator->GetSurfaceInfo(&fgOutputSurface));
	350	DECODE_CHK_STATUS(m_debugInterface->DumpYUVSurface(
	351	&fgOutputSurface, CodechalDbgAttr::attrFilmGrain, "FilmGrain"));
	352	}
533	353	}
534	354	}
535		for (auto i = 0; i < 8; i++)
536		{
537		oss << "feature_mask[" << +i << "]: " << std::hex << +picParams->m_av1SegData.m_featureMask [i] << std::endl;
538		}
539
540		oss << "tile_cols: " << std::hex << +picParams->m_tileCols << std::endl;
541		for (auto i = 0; i < 63; i++)
542		{
543		oss << "width_in_sbs_minus_1[" << +i << "]: " << std::hex << +picParams->m_widthInSbsMinus1[i] << std::endl;
544		}
545		oss << "tile_rows: " << std::hex << +picParams->m_tileRows << std::endl;
546		for (auto i = 0; i < 63; i++)
547		{
548		oss << "height_in_sbs_minus_1[" << +i << "]: " << std::hex << +picParams->m_heightInSbsMinus1[i] << std::endl;
549		}
550
551
552		oss << "tile_count_minus_1: " << std::hex << +picParams->m_tileCountMinus1 << std::endl;
553		oss << "context_update_tile_id: " << std::hex << +picParams->m_contextUpdateTileId << std::endl;
554
555		oss << "cdef_damping_minus_3: " << std::hex << +picParams->m_cdefDampingMinus3 << std::endl;
556		oss << "cdef_bits: " << std::hex << +picParams->m_cdefBits << std::endl;
557		for (auto i = 0; i < 8; i++)
558		{
559		oss << "cdef_y_strengths[" << +i << "]: " << std::hex << +picParams->m_cdefYStrengths[i] << std::endl;
560		}
561		for (auto i = 0; i < 8; i++)
562		{
563		oss << "cdef_uv_strengths[" << +i << "]: " << std::hex << +picParams->m_cdefUvStrengths[i] << std::endl;
564		}
565
566		// Loop Restoration Flags
567		oss << "LoopRestorationFlags value: " << std::hex << +picParams->m_loopRestorationFlags.m_value << std::endl;
568		oss << "yframe_restoration_type: " << std::hex << +picParams->m_loopRestorationFlags.m_fields.m_yframeRestorationType << std::endl;
569		oss << "cbframe_restoration_type: " << std::hex << +picParams->m_loopRestorationFlags.m_fields.m_cbframeRestorationType << std::endl;
570		oss << "crframe_restoration_type: " << std::hex << +picParams->m_loopRestorationFlags.m_fields.m_crframeRestorationType << std::endl;
571		oss << "lr_unit_shift: " << std::hex << +picParams->m_loopRestorationFlags.m_fields.m_lrUnitShift << std::endl;
572		oss << "lr_uv_shift: " << std::hex << +picParams->m_loopRestorationFlags.m_fields.m_lrUvShift << std::endl;
573
574		for (auto i = 0; i < 7; i++)
575		{
576		oss << "wm[" << +i << "].wmtype: " << std::hex << +picParams->m_wm[i].m_wmtype << std::endl;
577		for (auto j = 0; j < 8; j++)
578		{
579		oss << "wm[" << +i << "].wmmat[" << +j << "]: " << std::hex << +picParams->m_wm[i].m_wmmat[j] << std::endl;
580		}
581		}
582
583		//Film Grain params
584		oss << "apply_grain: " << std::hex << +picParams->m_filmGrainParams.m_filmGrainInfoFlags.m_fields.m_applyGrain << std::endl;
585		oss << "chroma_scaling_from_luma: " << std::hex << +picParams->m_filmGrainParams.m_filmGrainInfoFlags.m_fields.m_chromaScalingFromLuma << std::endl;
586		oss << "grain_scaling_minus_8: " << std::hex << +picParams->m_filmGrainParams.m_filmGrainInfoFlags.m_fields.m_grainScalingMinus8 << std::endl;
587		oss << "ar_coeff_lag: " << std::hex << +picParams->m_filmGrainParams.m_filmGrainInfoFlags.m_fields.m_arCoeffLag << std::endl;
588		oss << "ar_coeff_shift_minus_6: " << std::hex << +picParams->m_filmGrainParams.m_filmGrainInfoFlags.m_fields.m_arCoeffShiftMinus6 << std::endl;
589		oss << "grain_scale_shift: " << std::hex << +picParams->m_filmGrainParams.m_filmGrainInfoFlags.m_fields.m_grainScaleShift << std::endl;
590		oss << "overlap_flag: " << std::hex << +picParams->m_filmGrainParams.m_filmGrainInfoFlags.m_fields.m_overlapFlag << std::endl;
591		oss << "clip_to_restricted_range: " << std::hex << +picParams->m_filmGrainParams.m_filmGrainInfoFlags.m_fields.m_clipToRestrictedRange << std::endl;
592
593		oss << "random_seed: " << std::hex << +picParams->m_filmGrainParams.m_randomSeed << std::endl;
594		oss << "num_y_points: " << std::hex << +picParams->m_filmGrainParams.m_numYPoints << std::endl;
595		for (auto i = 0; i < 14; i++)
596		{
597		oss << "point_y_value[" << +i << "]: " << std::hex << +picParams->m_filmGrainParams.m_pointYValue[i] << std::endl;
598		}
599		for (auto i = 0; i < 14; i++)
600		{
601		oss << "point_y_scaling[" << +i << "]: " << std::hex << +picParams->m_filmGrainParams.m_pointYScaling[i] << std::endl;
602		}
603
604		oss << "num_cb_points: " << std::hex << +picParams->m_filmGrainParams.m_numCbPoints << std::endl;
605		for (auto i = 0; i < 10; i++)
606		{
607		oss << "point_cb_value[" << +i << "]: " << std::hex << +picParams->m_filmGrainParams.m_pointCbValue[i] << std::endl;
608		}
609		for (auto i = 0; i < 10; i++)
610		{
611		oss << "point_cb_scaling[" << +i << "]: " << std::hex << +picParams->m_filmGrainParams.m_pointCbScaling[i] << std::endl;
612		}
613
614		oss << "num_cr_points: " << std::hex << +picParams->m_filmGrainParams.m_numCrPoints << std::endl;
615		for (auto i = 0; i < 10; i++)
616		{
617		oss << "point_cr_value[" << +i << "]: " << std::hex << +picParams->m_filmGrainParams.m_pointCrValue[i] << std::endl;
618		}
619		for (auto i = 0; i < 10; i++)
620		{
621		oss << "point_cr_scaling[" << +i << "]: " << std::hex << +picParams->m_filmGrainParams.m_pointCrScaling[i] << std::endl;
622		}
623
624		for (auto i = 0; i < 24; i++)
625		{
626		oss << "ar_coeffs_y[" << +i << "]: " << std::hex << +picParams->m_filmGrainParams.m_arCoeffsY[i] << std::endl;
627		}
628		for (auto i = 0; i < 25; i++)
629		{
630		oss << "ar_coeffs_cb[" << +i << "]: " << std::hex << +picParams->m_filmGrainParams.m_arCoeffsCb[i] << std::endl;
631		}
632		for (auto i = 0; i < 25; i++)
633		{
634		oss << "ar_coeffs_cr[" << +i << "]: " << std::hex << +picParams->m_filmGrainParams.m_arCoeffsCr[i] << std::endl;
635		}
636
637		oss << "cb_mult: " << std::hex << +picParams->m_filmGrainParams.m_cbMult << std::endl;
638		oss << "cb_luma_mult: " << std::hex << +picParams->m_filmGrainParams.m_cbLumaMult << std::endl;
639		oss << "cb_offset: " << std::hex << +picParams->m_filmGrainParams.m_cbOffset << std::endl;
640		oss << "cr_mult: " << std::hex << +picParams->m_filmGrainParams.m_crMult << std::endl;
641		oss << "cr_luma_mult: " << std::hex << +picParams->m_filmGrainParams.m_crLumaMult << std::endl;
642		oss << "cr_offset: " << std::hex << +picParams->m_filmGrainParams.m_crOffset << std::endl;
643		oss << "StatusReportFeedbackNumber: " << std::hex << +picParams->m_statusReportFeedbackNumber << std::endl;
644
645		//Driver internal
646		oss << "losslessMode: " << std::hex << +picParams->m_losslessMode << std::endl;
647		oss << "superResUpscaledWidthMinus1: " << std::hex << +picParams->m_superResUpscaledWidthMinus1 << std::endl;
648		oss << "superResUpscaledHeightMinus1: " << std::hex << +picParams->m_superResUpscaledHeightMinus1 << std::endl;
649		for (auto i = 0; i < 8; i++)
650		{
651		oss << "activeRefBitMaskMfmv[" << +i << "]: " << std::hex << +picParams->m_activeRefBitMaskMfmv[i] << std::endl;
652		}
653
654		const char* fileName = m_debugInterface->CreateFileName(
655		"DEC",
656		CodechalDbgBufferType::bufPicParams,
657		CodechalDbgExtType::txt);
658
659		std::ofstream ofs(fileName, std::ios::out);
660		ofs << oss.str();
661		ofs.close();
662	355
663	356	return MOS_STATUS_SUCCESS;
664	357	}

-27

media_driver/media_softlet/agnostic/gen12/codec/hal/dec/av1/pipeline/decode_av1_pipeline_g12.h less more

117	117	//!
118	118	virtual MOS_STATUS InitMmcState();
119	119
120
121		#if USE_CODECHAL_DEBUG_TOOL
122		//! \brief Dump the parameters
	120	#if USE_CODECHAL_DEBUG_TOOL
123	121	//!
124		//! \return MOS_STATUS
125		//! MOS_STATUS_SUCCESS if success, else fail reason
	122	//! \brief Dump render targets
	123	//! \param [in] reportData
	124	//! Decode report data
	125	//! \return MOS_STATUS
	126	//! MOS_STATUS_SUCCESS if success, else fail reason
126	127	//!
127		MOS_STATUS DumpParams(Av1BasicFeature &basicFeature);
128
129		//! \brief Dump the picture parameters
130		//!
131		//! \param [in] picParams
132		//! Pointer to CodecAv1PicParams
133		//!
134		//! \return MOS_STATUS
135		//! MOS_STATUS_SUCCESS if success, else fail reason
136		//!
137		MOS_STATUS DumpPicParams(CodecAv1PicParams *picParams);
138
139		//! \brief Dump Tile Group parameters into file
140		//!
141		//! \param [in] tileParams
142		//! Pointer to CodecAv1TileParams
143		//!
144		//! \return MOS_STATUS
145		//! MOS_STATUS_SUCCESS if success, else fail reason
146		//!
147		MOS_STATUS DumpBitstreamControlParams(CodecAv1TileParams *tileParams);
148		#endif
	128	virtual MOS_STATUS DumpOutput(const DecodeStatusReportData& reportData) override;
	129	#endif
149	130
150	131	//!
151	132	//! \brief Create AV1 Decode feature manager for Gen12

-1

media_driver/media_softlet/agnostic/gen12_base/codec/hal/dec/shared/packet/media_srcs.cmake less more

0		# Copyright (c) 2020, Intel Corporation
	0	# Copyright (c) 2021, Intel Corporation
1	1	#
2	2	# Permission is hereby granted, free of charge, to any person obtaining a
3	3	# copy of this software and associated documentation files (the "Software"),

-1

media_softlet/agnostic/common/codec/hal/dec/av1/features/decode_av1_basic_feature.cpp less more

187	187	}
188	188
189	189	if (m_av1PicParams->m_picInfoFlags.m_fields.m_forceIntegerMv &&
190		m_av1PicParams->m_picInfoFlags.m_fields.m_allowHighPrecisionMv)
	190	m_av1PicParams->m_picInfoFlags.m_fields.m_allowHighPrecisionMv &&
	191	!(m_av1PicParams->m_picInfoFlags.m_fields.m_frameType == intraOnlyFrame \|\|
	192	m_av1PicParams->m_picInfoFlags.m_fields.m_frameType == keyFrame))
191	193	{
192	194	DECODE_ASSERTMESSAGE("Conflict with AV1 Spec!");
193	195	return MOS_STATUS_INVALID_PARAMETER;

+328

-1

media_softlet/agnostic/common/codec/hal/dec/av1/pipeline/decode_av1_pipeline.cpp less more

164	164	return m_decodeMode;
165	165	}
166	166
167		}
	167	#if USE_CODECHAL_DEBUG_TOOL
	168	MOS_STATUS Av1Pipeline::DumpParams(Av1BasicFeature &basicFeature)
	169	{
	170	m_debugInterface->m_frameType = basicFeature.m_av1PicParams->m_picInfoFlags.m_fields.m_frameType ? P_TYPE : I_TYPE;
	171	m_debugInterface->m_bufferDumpFrameNum = basicFeature.m_frameNum;
	172
	173	DECODE_CHK_STATUS(DumpPicParams(
	174	basicFeature.m_av1PicParams));
	175
	176	DECODE_CHK_STATUS(DumpBitstreamControlParams(
	177	basicFeature.m_av1TileParams));
	178
	179	return MOS_STATUS_SUCCESS;
	180	}
	181
	182	MOS_STATUS Av1Pipeline::DumpBitstreamControlParams(CodecAv1TileParams *tileParams)
	183	{
	184	CODECHAL_DEBUG_FUNCTION_ENTER;
	185
	186	if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrSlcParams))
	187	{
	188	return MOS_STATUS_SUCCESS;
	189	}
	190
	191	CODECHAL_DEBUG_CHK_NULL(tileParams);
	192
	193	std::ostringstream oss;
	194	oss.setf(std::ios::showbase \| std::ios::uppercase);
	195
	196	oss << "BSTileDataLocation: " << +tileParams->m_bsTileDataLocation << std::endl;
	197	oss << "BSTileBytesInBuffer: " << +tileParams->m_bsTileBytesInBuffer << std::endl;
	198	oss << "wBadBSBufferChopping: " << +tileParams->m_badBSBufferChopping << std::endl;
	199	oss << "tile_row: " << +tileParams->m_tileRow << std::endl;
	200	oss << "tile_column: " << +tileParams->m_tileColumn << std::endl;
	201	oss << "tile_index: " << +tileParams->m_tileIndex << std::endl;
	202	oss << "StartTileIdx: " << +tileParams->m_startTileIdx << std::endl;
	203	oss << "EndTileIdx: " << +tileParams->m_endTileIdx << std::endl;
	204	oss << "anchor_frame_idx: " << +tileParams->m_anchorFrameIdx.FrameIdx << std::endl;
	205	oss << "BSTilePayloadSizeInBytes: " << +tileParams->m_bsTilePayloadSizeInBytes << std::endl;
	206
	207	const char *fileName = m_debugInterface->CreateFileName(
	208	"DEC",
	209	"BitstreamControlParams",
	210	CodechalDbgExtType::txt);
	211
	212	std::ofstream ofs;
	213	ofs.open(fileName, std::ios::out);
	214	ofs << oss.str();
	215	ofs.close();
	216
	217	return MOS_STATUS_SUCCESS;
	218	}
	219
	220	MOS_STATUS Av1Pipeline::DumpPicParams(CodecAv1PicParams *picParams)
	221	{
	222	CODECHAL_DEBUG_FUNCTION_ENTER;
	223
	224	if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrPicParams))
	225	{
	226	return MOS_STATUS_SUCCESS;
	227	}
	228	CODECHAL_DEBUG_CHK_NULL(picParams);
	229
	230	std::ostringstream oss;
	231	oss.setf(std::ios::showbase \| std::ios::uppercase);
	232
	233	oss << "CurrPic FrameIdx: " << std::hex << +picParams->m_currPic.FrameIdx << std::endl;
	234	oss << "CurrDisplayPic FrameIdx: " << std::hex << +picParams->m_currDisplayPic.FrameIdx << std::endl;
	235	oss << "Profile: " << std::hex << +picParams->m_profile << std::endl;
	236	oss << "AnchorFrameInsertion: " << std::hex << +picParams->m_anchorFrameInsertion << std::endl;
	237	oss << "order_hint_bits_minus_1: " << std::hex << +picParams->m_orderHintBitsMinus1 << std::endl;
	238	oss << "BitDepthIdx: " << std::hex << +picParams->m_bitDepthIdx << std::endl;
	239
	240	//Sequence Info Flags
	241	oss << "dwSeqInfoFlags: " << std::hex << +picParams->m_seqInfoFlags.m_value << std::endl;
	242	oss << "still_picture: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_stillPicture << std::endl;
	243	oss << "use_128x128_superblock: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_use128x128Superblock << std::endl;
	244	oss << "enable_filter_intra: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_enableFilterIntra << std::endl;
	245	oss << "enable_intra_edge_filter: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_enableIntraEdgeFilter << std::endl;
	246	oss << "enable_interintra_compound: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_enableInterintraCompound << std::endl;
	247	oss << "enable_masked_compound: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_enableMaskedCompound << std::endl;
	248	oss << "enable_dual_filter: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_enableDualFilter << std::endl;
	249	oss << "enable_order_hint: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_enableOrderHint << std::endl;
	250	oss << "enable_jnt_comp: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_enableJntComp << std::endl;
	251	oss << "enable_cdef: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_enableCdef << std::endl;
	252	oss << "mono_chrome: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_monoChrome << std::endl;
	253	oss << "color_range: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_colorRange << std::endl;
	254	oss << "subsampling_x: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_subsamplingX << std::endl;
	255	oss << "subsampling_y: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_subsamplingY << std::endl;
	256	oss << "chroma_sample_position: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_chromaSamplePosition << std::endl;
	257	oss << "film_grain_params_present: " << std::hex << +picParams->m_seqInfoFlags.m_fields.m_filmGrainParamsPresent << std::endl;
	258
	259	//frame info
	260	oss << "dwPicInfoFlags: " << std::hex << +picParams->m_picInfoFlags.m_value << std::endl;
	261	oss << "frame_type: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_frameType << std::endl;
	262	oss << "show_frame: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_showFrame << std::endl;
	263	oss << "showable_frame: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_showableFrame << std::endl;
	264	oss << "error_resilient_mode: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_errorResilientMode << std::endl;
	265	oss << "disable_cdf_update: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_disableCdfUpdate << std::endl;
	266	oss << "allow_screen_content_tools: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_allowScreenContentTools << std::endl;
	267	oss << "force_integer_mv: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_forceIntegerMv << std::endl;
	268	oss << "allow_intrabc: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_allowIntrabc << std::endl;
	269	oss << "use_superres: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_useSuperres << std::endl;
	270	oss << "allow_high_precision_mv: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_allowHighPrecisionMv << std::endl;
	271	oss << "is_motion_mode_switchable: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_isMotionModeSwitchable << std::endl;
	272	oss << "use_ref_frame_mvs: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_useRefFrameMvs << std::endl;
	273	oss << "disable_frame_end_update_cdf: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_disableFrameEndUpdateCdf << std::endl;
	274	oss << "uniform_tile_spacing_flag: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_uniformTileSpacingFlag << std::endl;
	275	oss << "allow_warped_motion: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_allowWarpedMotion << std::endl;
	276	oss << "large_scale_tile: " << std::hex << +picParams->m_picInfoFlags.m_fields.m_largeScaleTile << std::endl;
	277
	278	oss << "frame_width_minus1: " << std::hex << +picParams->m_frameWidthMinus1 << std::endl;
	279	oss << "frame_height_minus1: " << std::hex << +picParams->m_frameHeightMinus1 << std::endl;
	280
	281	for (auto i = 0; i < 8; ++i)
	282	{
	283	oss << "ref_frame_map[" << +i << "] FrameIdx:" << std::hex << +picParams->m_refFrameMap[i].FrameIdx << std::endl;
	284	oss << "ref_frame_map[" << +i << "] PicFlags:" << std::hex << +picParams->m_refFrameMap[i].PicFlags << std::endl;
	285	}
	286
	287	for (auto i = 0; i < 7; i++)
	288	{
	289	oss << "ref_frame_idx[" << +i << "]: " << std::hex << +picParams->m_refFrameIdx[i] << std::endl;
	290	}
	291
	292	oss << "primary_ref_frame: " << std::hex << +picParams->m_primaryRefFrame << std::endl;
	293	oss << "output_frame_width_in_tiles_minus_1: " << std::hex << +picParams->m_outputFrameWidthInTilesMinus1 << std::endl;
	294	oss << "output_frame_height_in_tiles_minus_1: " << std::hex << +picParams->m_outputFrameHeightInTilesMinus1 << std::endl;
	295
	296	for (auto i = 0; i < 2; i++)
	297	{
	298	oss << "filter_level[" << +i << "]: " << std::hex << +picParams->m_filterLevel[i] << std::endl;
	299	}
	300	oss << "filter_level_u: " << std::hex << +picParams->m_filterLevelU << std::endl;
	301	oss << "filter_level_v: " << std::hex << +picParams->m_filterLevelV << std::endl;
	302
	303	//Loop Filter Info Flags
	304	oss << "cLoopFilterInfoFlags value: " << std::hex << +picParams->m_loopFilterInfoFlags.m_value << std::endl;
	305	oss << "sharpness_level: " << std::hex << +picParams->m_loopFilterInfoFlags.m_fields.m_sharpnessLevel << std::endl;
	306	oss << "mode_ref_delta_enabled: " << std::hex << +picParams->m_loopFilterInfoFlags.m_fields.m_modeRefDeltaEnabled << std::endl;
	307	oss << "mode_ref_delta_update: " << std::hex << +picParams->m_loopFilterInfoFlags.m_fields.m_modeRefDeltaUpdate << std::endl;
	308
	309	oss << "order_hint: " << std::hex << +picParams->m_orderHint << std::endl;
	310	oss << "superres_scale_denominator: " << std::hex << +picParams->m_superresScaleDenominator << std::endl;
	311	oss << "interp_filter: " << std::hex << +picParams->m_interpFilter << std::endl;
	312
	313	for (auto i = 0; i < 8; i++)
	314	{
	315	oss << "ref_deltas[" << +i << "]: " << std::hex << +picParams->m_refDeltas[i] << std::endl;
	316	}
	317
	318	for (auto i = 0; i < 2; i++)
	319	{
	320	oss << "mode_deltas[" << +i << "]: " << std::hex << +picParams->m_modeDeltas[i] << std::endl;
	321	}
	322
	323	oss << "base_qindex: " << std::hex << +picParams->m_baseQindex << std::endl;
	324	oss << "y_dc_delta_q: " << std::hex << +picParams->m_yDcDeltaQ << std::endl;
	325	oss << "u_dc_delta_q: " << std::hex << +picParams->m_uDcDeltaQ << std::endl;
	326	oss << "u_ac_delta_q: " << std::hex << +picParams->m_uAcDeltaQ << std::endl;
	327	oss << "v_dc_delta_q: " << std::hex << +picParams->m_vDcDeltaQ << std::endl;
	328	oss << "v_ac_delta_q: " << std::hex << +picParams->m_vAcDeltaQ << std::endl;
	329
	330	// quantization_matrix
	331	oss << "wQMatrixFlags value: " << std::hex << +picParams->m_qMatrixFlags.m_value << std::endl;
	332	oss << "using_qmatrix: " << std::hex << +picParams->m_qMatrixFlags.m_fields.m_usingQmatrix<< std::endl;
	333	oss << "qm_y: " << std::hex << +picParams->m_qMatrixFlags.m_fields.m_qmY << std::endl;
	334	oss << "qm_u: " << std::hex << +picParams->m_qMatrixFlags.m_fields.m_qmU << std::endl;
	335	oss << "qm_v: " << std::hex << +picParams->m_qMatrixFlags.m_fields.m_qmV << std::endl;
	336
	337	// Mode control flags
	338	oss << "dwModeControlFlags value: " << std::hex << +picParams->m_modeControlFlags.m_value << std::endl;
	339	oss << "delta_q_present_flag: " << std::hex << +picParams->m_modeControlFlags.m_fields.m_deltaQPresentFlag << std::endl;
	340	oss << "log2_delta_q_res: " << std::hex << +picParams->m_modeControlFlags.m_fields.m_log2DeltaQRes << std::endl;
	341	oss << "delta_lf_present_flag: " << std::hex << +picParams->m_modeControlFlags.m_fields.m_deltaLfPresentFlag << std::endl;
	342	oss << "log2_delta_lf_res: " << std::hex << +picParams->m_modeControlFlags.m_fields.m_log2DeltaLfRes << std::endl;
	343	oss << "delta_lf_multi: " << std::hex << +picParams->m_modeControlFlags.m_fields.m_deltaLfMulti << std::endl;
	344	oss << "tx_mode: " << std::hex << +picParams->m_modeControlFlags.m_fields.m_txMode << std::endl;
	345	oss << "reference_mode: " << std::hex << +picParams->m_modeControlFlags.m_fields.m_referenceMode << std::endl;
	346	oss << "reduced_tx_set_used: " << std::hex << +picParams->m_modeControlFlags.m_fields.m_reducedTxSetUsed << std::endl;
	347	oss << "skip_mode_present: " << std::hex << +picParams->m_modeControlFlags.m_fields.m_skipModePresent << std::endl;
	348
	349	// Segmentation
	350	oss << "enabled: " << std::hex << +picParams->m_av1SegData.m_enabled << std::endl;
	351	oss << "update_map: " << std::hex << +picParams->m_av1SegData.m_updateMap << std::endl;
	352	oss << "temporal_update: " << std::hex << +picParams->m_av1SegData.m_temporalUpdate << std::endl;
	353	oss << "update_data: " << std::hex << +picParams->m_av1SegData.m_updateData << std::endl;
	354
	355	for (auto i = 0; i < 8; i++)
	356	{
	357	for (auto j = 0; j < 8; j++)
	358	{
	359	oss << "feature_data[" << +i << "][" << +j << "]: " << std::hex << +picParams->m_av1SegData.m_featureData[i][j] << std::endl;
	360	}
	361	}
	362	for (auto i = 0; i < 8; i++)
	363	{
	364	oss << "feature_mask[" << +i << "]: " << std::hex << +picParams->m_av1SegData.m_featureMask [i] << std::endl;
	365	}
	366
	367	oss << "tile_cols: " << std::hex << +picParams->m_tileCols << std::endl;
	368	for (auto i = 0; i < 63; i++)
	369	{
	370	oss << "width_in_sbs_minus_1[" << +i << "]: " << std::hex << +picParams->m_widthInSbsMinus1[i] << std::endl;
	371	}
	372	oss << "tile_rows: " << std::hex << +picParams->m_tileRows << std::endl;
	373	for (auto i = 0; i < 63; i++)
	374	{
	375	oss << "height_in_sbs_minus_1[" << +i << "]: " << std::hex << +picParams->m_heightInSbsMinus1[i] << std::endl;
	376	}
	377
	378
	379	oss << "tile_count_minus_1: " << std::hex << +picParams->m_tileCountMinus1 << std::endl;
	380	oss << "context_update_tile_id: " << std::hex << +picParams->m_contextUpdateTileId << std::endl;
	381
	382	oss << "cdef_damping_minus_3: " << std::hex << +picParams->m_cdefDampingMinus3 << std::endl;
	383	oss << "cdef_bits: " << std::hex << +picParams->m_cdefBits << std::endl;
	384	for (auto i = 0; i < 8; i++)
	385	{
	386	oss << "cdef_y_strengths[" << +i << "]: " << std::hex << +picParams->m_cdefYStrengths[i] << std::endl;
	387	}
	388	for (auto i = 0; i < 8; i++)
	389	{
	390	oss << "cdef_uv_strengths[" << +i << "]: " << std::hex << +picParams->m_cdefUvStrengths[i] << std::endl;
	391	}
	392
	393	// Loop Restoration Flags
	394	oss << "LoopRestorationFlags value: " << std::hex << +picParams->m_loopRestorationFlags.m_value << std::endl;
	395	oss << "yframe_restoration_type: " << std::hex << +picParams->m_loopRestorationFlags.m_fields.m_yframeRestorationType << std::endl;
	396	oss << "cbframe_restoration_type: " << std::hex << +picParams->m_loopRestorationFlags.m_fields.m_cbframeRestorationType << std::endl;
	397	oss << "crframe_restoration_type: " << std::hex << +picParams->m_loopRestorationFlags.m_fields.m_crframeRestorationType << std::endl;
	398	oss << "lr_unit_shift: " << std::hex << +picParams->m_loopRestorationFlags.m_fields.m_lrUnitShift << std::endl;
	399	oss << "lr_uv_shift: " << std::hex << +picParams->m_loopRestorationFlags.m_fields.m_lrUvShift << std::endl;
	400
	401	for (auto i = 0; i < 7; i++)
	402	{
	403	oss << "wm[" << +i << "].wmtype: " << std::hex << +picParams->m_wm[i].m_wmtype << std::endl;
	404	for (auto j = 0; j < 8; j++)
	405	{
	406	oss << "wm[" << +i << "].wmmat[" << +j << "]: " << std::hex << +picParams->m_wm[i].m_wmmat[j] << std::endl;
	407	}
	408	}
	409
	410	//Film Grain params
	411	oss << "apply_grain: " << std::hex << +picParams->m_filmGrainParams.m_filmGrainInfoFlags.m_fields.m_applyGrain << std::endl;
	412	oss << "chroma_scaling_from_luma: " << std::hex << +picParams->m_filmGrainParams.m_filmGrainInfoFlags.m_fields.m_chromaScalingFromLuma << std::endl;
	413	oss << "grain_scaling_minus_8: " << std::hex << +picParams->m_filmGrainParams.m_filmGrainInfoFlags.m_fields.m_grainScalingMinus8 << std::endl;
	414	oss << "ar_coeff_lag: " << std::hex << +picParams->m_filmGrainParams.m_filmGrainInfoFlags.m_fields.m_arCoeffLag << std::endl;
	415	oss << "ar_coeff_shift_minus_6: " << std::hex << +picParams->m_filmGrainParams.m_filmGrainInfoFlags.m_fields.m_arCoeffShiftMinus6 << std::endl;
	416	oss << "grain_scale_shift: " << std::hex << +picParams->m_filmGrainParams.m_filmGrainInfoFlags.m_fields.m_grainScaleShift << std::endl;
	417	oss << "overlap_flag: " << std::hex << +picParams->m_filmGrainParams.m_filmGrainInfoFlags.m_fields.m_overlapFlag << std::endl;
	418	oss << "clip_to_restricted_range: " << std::hex << +picParams->m_filmGrainParams.m_filmGrainInfoFlags.m_fields.m_clipToRestrictedRange << std::endl;
	419
	420	oss << "random_seed: " << std::hex << +picParams->m_filmGrainParams.m_randomSeed << std::endl;
	421	oss << "num_y_points: " << std::hex << +picParams->m_filmGrainParams.m_numYPoints << std::endl;
	422	for (auto i = 0; i < 14; i++)
	423	{
	424	oss << "point_y_value[" << +i << "]: " << std::hex << +picParams->m_filmGrainParams.m_pointYValue[i] << std::endl;
	425	}
	426	for (auto i = 0; i < 14; i++)
	427	{
	428	oss << "point_y_scaling[" << +i << "]: " << std::hex << +picParams->m_filmGrainParams.m_pointYScaling[i] << std::endl;
	429	}
	430
	431	oss << "num_cb_points: " << std::hex << +picParams->m_filmGrainParams.m_numCbPoints << std::endl;
	432	for (auto i = 0; i < 10; i++)
	433	{
	434	oss << "point_cb_value[" << +i << "]: " << std::hex << +picParams->m_filmGrainParams.m_pointCbValue[i] << std::endl;
	435	}
	436	for (auto i = 0; i < 10; i++)
	437	{
	438	oss << "point_cb_scaling[" << +i << "]: " << std::hex << +picParams->m_filmGrainParams.m_pointCbScaling[i] << std::endl;
	439	}
	440
	441	oss << "num_cr_points: " << std::hex << +picParams->m_filmGrainParams.m_numCrPoints << std::endl;
	442	for (auto i = 0; i < 10; i++)
	443	{
	444	oss << "point_cr_value[" << +i << "]: " << std::hex << +picParams->m_filmGrainParams.m_pointCrValue[i] << std::endl;
	445	}
	446	for (auto i = 0; i < 10; i++)
	447	{
	448	oss << "point_cr_scaling[" << +i << "]: " << std::hex << +picParams->m_filmGrainParams.m_pointCrScaling[i] << std::endl;
	449	}
	450
	451	for (auto i = 0; i < 24; i++)
	452	{
	453	oss << "ar_coeffs_y[" << +i << "]: " << std::hex << +picParams->m_filmGrainParams.m_arCoeffsY[i] << std::endl;
	454	}
	455	for (auto i = 0; i < 25; i++)
	456	{
	457	oss << "ar_coeffs_cb[" << +i << "]: " << std::hex << +picParams->m_filmGrainParams.m_arCoeffsCb[i] << std::endl;
	458	}
	459	for (auto i = 0; i < 25; i++)
	460	{
	461	oss << "ar_coeffs_cr[" << +i << "]: " << std::hex << +picParams->m_filmGrainParams.m_arCoeffsCr[i] << std::endl;
	462	}
	463
	464	oss << "cb_mult: " << std::hex << +picParams->m_filmGrainParams.m_cbMult << std::endl;
	465	oss << "cb_luma_mult: " << std::hex << +picParams->m_filmGrainParams.m_cbLumaMult << std::endl;
	466	oss << "cb_offset: " << std::hex << +picParams->m_filmGrainParams.m_cbOffset << std::endl;
	467	oss << "cr_mult: " << std::hex << +picParams->m_filmGrainParams.m_crMult << std::endl;
	468	oss << "cr_luma_mult: " << std::hex << +picParams->m_filmGrainParams.m_crLumaMult << std::endl;
	469	oss << "cr_offset: " << std::hex << +picParams->m_filmGrainParams.m_crOffset << std::endl;
	470	oss << "StatusReportFeedbackNumber: " << std::hex << +picParams->m_statusReportFeedbackNumber << std::endl;
	471
	472	//Driver internal
	473	oss << "losslessMode: " << std::hex << +picParams->m_losslessMode << std::endl;
	474	oss << "superResUpscaledWidthMinus1: " << std::hex << +picParams->m_superResUpscaledWidthMinus1 << std::endl;
	475	oss << "superResUpscaledHeightMinus1: " << std::hex << +picParams->m_superResUpscaledHeightMinus1 << std::endl;
	476	for (auto i = 0; i < 8; i++)
	477	{
	478	oss << "activeRefBitMaskMfmv[" << +i << "]: " << std::hex << +picParams->m_activeRefBitMaskMfmv[i] << std::endl;
	479	}
	480
	481	const char* fileName = m_debugInterface->CreateFileName(
	482	"DEC",
	483	CodechalDbgBufferType::bufPicParams,
	484	CodechalDbgExtType::txt);
	485
	486	std::ofstream ofs(fileName, std::ios::out);
	487	ofs << oss.str();
	488	ofs.close();
	489
	490	return MOS_STATUS_SUCCESS;
	491	}
	492	#endif
	493
	494	}

+29

-0

media_softlet/agnostic/common/codec/hal/dec/av1/pipeline/decode_av1_pipeline.h less more

110	110	//!
111	111	virtual MOS_STATUS CreateFeatureManager() override;
112	112
	113	#if USE_CODECHAL_DEBUG_TOOL
	114	//! \brief Dump the parameters
	115	//!
	116	//! \return MOS_STATUS
	117	//! MOS_STATUS_SUCCESS if success, else fail reason
	118	//!
	119	MOS_STATUS DumpParams(Av1BasicFeature &basicFeature);
	120
	121	//! \brief Dump the picture parameters
	122	//!
	123	//! \param [in] picParams
	124	//! Pointer to CodecAv1PicParams
	125	//!
	126	//! \return MOS_STATUS
	127	//! MOS_STATUS_SUCCESS if success, else fail reason
	128	//!
	129	MOS_STATUS DumpPicParams(CodecAv1PicParams *picParams);
	130
	131	//! \brief Dump Tile Group parameters into file
	132	//!
	133	//! \param [in] tileParams
	134	//! Pointer to CodecAv1TileParams
	135	//!
	136	//! \return MOS_STATUS
	137	//! MOS_STATUS_SUCCESS if success, else fail reason
	138	//!
	139	MOS_STATUS DumpBitstreamControlParams(CodecAv1TileParams *tileParams);
	140	#endif
	141
113	142	protected:
114	143	HucCopyPkt *m_cdfCopyPkt = nullptr; //!< Update default cdf buffer with huc stream out packet
115	144	Av1DecodeMode m_decodeMode = baseDecodeMode; //!< Decode mode

-1

media_softlet/agnostic/common/codec/hal/dec/shared/features/decode_downsampling_feature.cpp less more

0	0	/*
1		* Copyright (c) 2020, Intel Corporation
	1	* Copyright (c) 2020-2021, Intel Corporation
2	2	*
3	3	* Permission is hereby granted, free of charge, to any person obtaining a
4	4	* copy of this software and associated documentation files (the "Software"),

-1

media_softlet/agnostic/common/codec/hal/dec/shared/pipeline/decode_pipeline.cpp less more

504	504	uint32_t completedCount = m_statusReport->GetCompletedCount();
505	505	if (completedCount <= m_statusCheckCount)
506	506	{
507		DECODE_CHK_COND(completedCount < m_statusCheckCount, "Invalid statuc check count");
	507	DECODE_CHK_COND(completedCount < m_statusCheckCount, "Invalid status check count");
508	508	return MOS_STATUS_SUCCESS;
509	509	}
510	510

-0

media_softlet/agnostic/common/codec/hal/dec/shared/statusreport/decode_status_report.cpp less more

113	113	m_statusReportData[submitIndex].currSfcOutputPicRes = inputParameters->sfcOutputPicRes;
114	114	m_statusReportData[submitIndex].currHistogramOutBuf = inputParameters->histogramOutputBuf;
115	115	m_statusReportData[submitIndex].frameType = inputParameters->pictureCodingType;
	116	m_statusReportData[submitIndex].currFgOutputPicRes = inputParameters->fgOutputPicRes;
116	117	#endif
117	118	}
118	119

-0

media_softlet/agnostic/common/codec/hal/dec/shared/statusreport/decode_status_report.h less more

61	61	PMOS_RESOURCE currSfcOutputPicRes = nullptr;
62	62	//! \brief Applies when debug dumps are enabled, pointer to histogram output resource for the picture associated with this status report
63	63	PMOS_RESOURCE currHistogramOutBuf = nullptr;
	64	//! \brief Applies when debug dumps are enabled, pointer to AV1 film grain output resource for the picture associated with this status report
	65	PMOS_RESOURCE currFgOutputPicRes = nullptr;
64	66	//! \brief Applies when debug dumps are enabled, stream out buffer
65	67	PMOS_RESOURCE streamOutBuf = nullptr;
66	68	//! \brief Applies when debug dumps are enabled, index of the streamout buffer

-0

media_softlet/agnostic/common/codec/hal/dec/shared/statusreport/decode_status_report_defs.h less more

116	116	#if (_DEBUG \|\| _RELEASE_INTERNAL)
117	117	MOS_RESOURCE *sfcOutputPicRes;
118	118	MOS_RESOURCE *histogramOutputBuf;
	119	MOS_RESOURCE *fgOutputPicRes;
119	120	#endif
120	121	};
121	122

+13

-48

media_softlet/agnostic/common/hw/mhw_cmdpar.h less more

37	37	// only used by other \| _DECL: declaration
38	38	// macros \| _DEF : definition
39	39
40		#define __MHW_CMD_PAR_T2(CMD) CMD##_Params // MHW command parameter type
41		#define _MHW_CMD_PAR_T(CMD) __MHW_CMD_PAR_T2(CMD) // to support 2-level macro expanding
42		#define __MHW_CMD_PAR_T(CMD) CMD##_Params_ // MHW command parameter type alias, to avoid compile error
	40	#define __MHW_PAR_T(CMD) CMD##_PAR // MHW command parameter type
	41	#define _MHW_PAR_T(CMD) __MHW_PAR_T(CMD) // to support 2-level macro expanding
	42	#define __MHW_PAR_ALIAS_T(CMD) CMD##_PAR_ALIAS // MHW command parameter type alias, to avoid compile error
43	43
44		#define __MHW_CMD_PAR_SET_F(CMD) SetCmdParams_##CMD // function name to set MHW command parameters
	44	#define __MHW_SETPAR_F(CMD) SETPAR_##CMD // function name to set MHW command parameters
	45	#define MHW_SETPAR_F(CMD) __MHW_SETPAR_F(CMD) // to support 2-level macro expanding
45	46
46		#define __MHW_CMD_PAR_SET_COMMON_DECL(CMD) __MHW_CMD_PAR_SET_F(CMD)(mhw::Pointer<__MHW_CMD_PAR_T(CMD)> params) const
	47	#define __MHW_SETPAR_COMMON_DECL(CMD) MHW_SETPAR_F(CMD)(__MHW_PAR_ALIAS_T(CMD) &params) const
47	48
48	49	// CodecHal uses it to define set MHW params functions in header file
49		#define MHW_CMD_PAR_SET_DECL_HDR(CMD) MOS_STATUS __MHW_CMD_PAR_SET_COMMON_DECL(CMD) override
	50	#define MHW_SETPAR_DECL_HDR(CMD) MOS_STATUS __MHW_SETPAR_COMMON_DECL(CMD) override
50	51
51	52	// CodecHal uses it to define set MHW params functions in source file
52		#define MHW_CMD_PAR_SET_DECL_SRC(CMD, CLASS) MOS_STATUS CLASS::__MHW_CMD_PAR_SET_COMMON_DECL(CMD)
	53	#define MHW_SETPAR_DECL_SRC(CMD, CLASS) MOS_STATUS CLASS::__MHW_SETPAR_COMMON_DECL(CMD)
53	54
54		#define _MHW_CMD_PAR_SET_DEF(CMD) \
55		using __MHW_CMD_PAR_T(CMD) = _MHW_CMD_PAR_T(CMD); \
56		virtual MOS_STATUS __MHW_CMD_PAR_SET_COMMON_DECL(CMD) \
57		{ \
58		return MOS_STATUS_SUCCESS; \
	55	#define _MHW_SETPAR_DEF(CMD) \
	56	using __MHW_PAR_ALIAS_T(CMD) = _MHW_PAR_T(CMD); \
	57	virtual MOS_STATUS __MHW_SETPAR_COMMON_DECL(CMD) \
	58	{ \
	59	return MOS_STATUS_SUCCESS; \
59	60	}
60	61
61		namespace mhw
62		{
63		template <typename T>
64		using Pointer = std::shared_ptr<T>;
65
66		template <typename T, typename U>
67		Pointer<T> StaticPointerCast(const Pointer<U> &r)
68		{
69		return std::static_pointer_cast<T>(r);
70		}
71
72		template <typename T, typename U>
73		Pointer<T> DynamicPointerCast(const Pointer<U> &r)
74		{
75		return std::dynamic_pointer_cast<T>(r);
76		}
77
78		template <typename T, typename U>
79		Pointer<T> ConstPointerCast(const Pointer<U> &r)
80		{
81		return std::const_pointer_cast<T>(r);
82		}
83
84		template <typename T>
85		Pointer<T> MakePointer()
86		{
87		return std::make_shared<T>();
88		}
89
90		template <typename T, typename... Args>
91		Pointer<T> MakePointer(Args &&...args)
92		{
93		return std::make_shared<T>(std::forward<Args>(args)...);
94		}
95		} // namespace mhw
96
97	62	#endif // __MHW_CMDPAR_H__

-1

media_softlet/agnostic/common/hw/mhw_hwcmd_process_cmdfields.h less more

37	37	}
38	38	#endif // MHW_HWCMDPARSER_ENABLED
39	39	#undef DO_FIELDS
	40	#endif // DO_FIELDS
40	41	return MOS_STATUS_SUCCESS;
41		#endif // DO_FIELDS

+161

-126

media_softlet/agnostic/common/hw/mhw_impl.h less more

36	36	// only used by other \| _DECL: declaration
37	37	// macros \| _DEF : definition
38	38
39		#define _MHW_CMD_T(CMD) CMD##_CMD // MHW command type
40		#define __MHW_CMD_PAR_M(CMD) m_##CMD##_Params // member which is a pointer to MHW command parameters
41
42		#define __MHW_CMD_SET_F(CMD) SetCmd_##CMD // function name to set command data
	39	#define __MHW_CMD_T(CMD) CMD##_CMD // MHW command type
	40
	41	// MHW command parameters and data
	42	#define __MHW_CMDINFO_T(CMD) std::pair<_MHW_PAR_T(CMD), typename cmd_t::__MHW_CMD_T(CMD)>
	43
	44	#define __MHW_CMDINFO_M(CMD) m_##CMD##_Info
	45
	46	#define __MHW_GETPAR_DEF(CMD) \
	47	__MHW_GETPAR_DECL(CMD) override \
	48	{ \
	49	return this->__MHW_CMDINFO_M(CMD)->first; \
	50	}
	51
	52	#define __MHW_GETSIZE_DEF(CMD) \
	53	__MHW_GETSIZE_DECL(CMD) override \
	54	{ \
	55	return sizeof(typename cmd_t::__MHW_CMD_T(CMD)); \
	56	}
43	57
44	58	#if MHW_HWCMDPARSER_ENABLED
45		#define __MHW_CMD_SET_DECL(CMD) MOS_STATUS __MHW_CMD_SET_F(CMD)(void *cmdData, const std::string &cmdName = #CMD)
	59	#define MHW_HWCMDPARSER_INITCMDNAME(CMD) this->m_currentCmdName = #CMD
46	60	#else
47		#define __MHW_CMD_SET_DECL(CMD) MOS_STATUS __MHW_CMD_SET_F(CMD)(void *cmdData)
	61	#define MHW_HWCMDPARSER_INITCMDNAME(CMD)
48	62	#endif
49	63
50		#define _MHW_CMD_SET_DECL_OVERRIDE(CMD) __MHW_CMD_SET_DECL(CMD) override
51
52		#define __MHW_CMD_PAR_GET_DEF(CMD) \
53		__MHW_CMD_PAR_GET_DECL(CMD) override \
54		{ \
55		if (reset) \
56		{ \
57		*(this->__MHW_CMD_PAR_M(CMD)) = {}; \
58		} \
59		return this->__MHW_CMD_PAR_M(CMD); \
60		}
61
62		#define __MHW_CMD_BYTE_SIZE_GET_DEF(CMD) \
63		__MHW_CMD_BYTE_SIZE_GET_DECL(CMD) override \
64		{ \
65		return sizeof(typename cmd_t::_MHW_CMD_T(CMD)); \
66		}
67
68		#define __MHW_CMD_ADD_DEF(CMD) \
69		__MHW_CMD_ADD_DECL(CMD) override \
70		{ \
71		MHW_FUNCTION_ENTER; \
72		this->m_currentCmdBuf = cmdBuf; \
73		this->m_currentBatchBuf = batchBuf; \
74		typename cmd_t::_MHW_CMD_T(CMD) cmdData; \
75		MHW_CHK_STATUS_RETURN(this->__MHW_CMD_SET_F(CMD)(&cmdData)); \
76		MHW_HWCMDPARSER_PARSECMD(#CMD, \
77		reinterpret_cast<uint32_t*>(&cmdData), \
78		sizeof(cmdData) / sizeof(uint32_t)); \
79		MHW_CHK_STATUS_RETURN(Mhw_AddCommandCmdOrBB(cmdBuf, batchBuf, &cmdData, sizeof(cmdData))); \
80		if (extraData && extraDataSize > 0) \
81		{ \
82		MHW_CHK_STATUS_RETURN(Mhw_AddCommandCmdOrBB(cmdBuf, batchBuf, extraData, extraDataSize)); \
83		} \
84		return MOS_STATUS_SUCCESS; \
85		}
86
87		#define _MHW_CMD_ALL_DEF_FOR_IMPL(CMD) \
88		public: \
89		__MHW_CMD_PAR_GET_DEF(CMD); \
90		protected: \
91		virtual __MHW_CMD_SET_DECL(CMD) { return MOS_STATUS_SUCCESS; } \
92		mhw::Pointer<_MHW_CMD_PAR_T(CMD)> __MHW_CMD_PAR_M(CMD) = mhw::MakePointer<_MHW_CMD_PAR_T(CMD)>()
93
94		#define _MHW_CMD_ALL_DEF_FOR_IMPL_GENERIC(CMD) \
95		public: \
96		__MHW_CMD_BYTE_SIZE_GET_DEF(CMD); \
97		__MHW_CMD_ADD_DEF(CMD)
98
99		#define _MHW_CMDSET_GETCMDPARAMS_AND_CALLBASE(CMD) \
100		MHW_FUNCTION_ENTER; \
101		auto cmd = reinterpret_cast<typename cmd_t::_MHW_CMD_T(CMD) *>(cmdData); \
102		const auto &params = this->__MHW_CMD_PAR_M(CMD); \
103		base_t::__MHW_CMD_SET_F(CMD)(cmd)
	64	#define __MHW_ADDCMD_DEF(CMD) \
	65	__MHW_ADDCMD_DECL(CMD) override \
	66	{ \
	67	MHW_FUNCTION_ENTER; \
	68	MHW_HWCMDPARSER_INITCMDNAME(CMD); \
	69	return this->AddCmd(cmdBuf, \
	70	batchBuf, \
	71	this->__MHW_CMDINFO_M(CMD)->second, \
	72	[=]() -> MOS_STATUS { return this->__MHW_SETCMD_F(CMD)(); }); \
	73	}
	74
	75	#if __cplusplus < 201402L
	76	#define __MHW_CMDINFO_DEF(CMD) std::unique_ptr<__MHW_CMDINFO_T(CMD)> \
	77	__MHW_CMDINFO_M(CMD) = std::unique_ptr<__MHW_CMDINFO_T(CMD)>(new __MHW_CMDINFO_T(CMD)())
	78	#else
	79	#define __MHW_CMDINFO_DEF(CMD) std::unique_ptr<__MHW_CMDINFO_T(CMD)> \
	80	__MHW_CMDINFO_M(CMD) = std::make_unique<__MHW_CMDINFO_T(CMD)>()
	81	#endif
	82
	83	#define _MHW_CMD_ALL_DEF_FOR_IMPL(CMD) \
	84	public: \
	85	__MHW_GETPAR_DEF(CMD); \
	86	__MHW_GETSIZE_DEF(CMD); \
	87	__MHW_ADDCMD_DEF(CMD) \
	88	protected: \
	89	__MHW_CMDINFO_DEF(CMD)
	90
	91	#define _MHW_SETCMD_OVERRIDE_DECL(CMD) __MHW_SETCMD_DECL(CMD) override
	92
	93	#define _MHW_SETCMD_CALLBASE(CMD) \
	94	MHW_FUNCTION_ENTER; \
	95	const auto &params = this->__MHW_CMDINFO_M(CMD)->first; \
	96	auto & cmd = this->__MHW_CMDINFO_M(CMD)->second; \
	97	MHW_CHK_STATUS_RETURN(base_t::__MHW_SETCMD_F(CMD)())
104	98
105	99	// DWORD location of a command field
106	100	#define _MHW_CMD_DW_LOCATION(field) \
107		static_cast<uint32_t>((reinterpret_cast<uint32_t >(&(cmd->field)) - reinterpret_cast<uint32_t >(&(*cmd))))
108
109		#define _MHW_CMD_ASSIGN_FIELD(dw, field, value) cmd->dw.field = (value)
	101	static_cast<uint32_t>((reinterpret_cast<uint32_t >(&(cmd.field)) - reinterpret_cast<uint32_t >(&cmd)))
	102
	103	#define _MHW_CMD_ASSIGN_FIELD(dw, field, value) cmd.dw.field = (value)
110	104
111	105	namespace mhw
112	106	{
113		inline int32_t Clip3(int32_t x, int32_t y, int32_t z)
114		{
115		int32_t ret = 0;
116
117		if (z < x)
118		{
119		ret = x;
120		}
121		else if (z > y)
122		{
123		ret = y;
124		}
125		else
126		{
127		ret = z;
128		}
129
130		return ret;
131		}
132
133		inline bool MmcEnabled(MOS_MEMCOMP_STATE state)
134		{
135		return state == MOS_MEMCOMP_RC \|\| state == MOS_MEMCOMP_MC;
136		}
137
138		inline bool MmcRcEnabled(MOS_MEMCOMP_STATE state)
139		{
140		return state == MOS_MEMCOMP_RC;
141		}
142
143		inline uint32_t GetHwTileType(MOS_TILE_TYPE tileType, MOS_TILE_MODE_GMM tileModeGMM, bool gmmTileEnabled)
144		{
145		uint32_t tileMode = 0;
146
147		if (gmmTileEnabled)
148		{
149		return tileModeGMM;
150		}
151
152		switch (tileType)
153		{
154		case MOS_TILE_LINEAR:
155		tileMode = 0;
156		break;
157		case MOS_TILE_YS:
158		tileMode = 1;
159		break;
160		case MOS_TILE_X:
161		tileMode = 2;
162		break;
163		default:
164		tileMode = 3;
165		break;
166		}
167
168		return tileMode;
169		}
170
171	107	class Impl
172	108	{
173	109	protected:
	110	static int32_t Clip3(int32_t x, int32_t y, int32_t z)
	111	{
	112	int32_t ret = 0;
	113
	114	if (z < x)
	115	{
	116	ret = x;
	117	}
	118	else if (z > y)
	119	{
	120	ret = y;
	121	}
	122	else
	123	{
	124	ret = z;
	125	}
	126
	127	return ret;
	128	}
	129
	130	static bool MmcEnabled(MOS_MEMCOMP_STATE state)
	131	{
	132	return state == MOS_MEMCOMP_RC \|\| state == MOS_MEMCOMP_MC;
	133	}
	134
	135	static bool MmcRcEnabled(MOS_MEMCOMP_STATE state)
	136	{
	137	return state == MOS_MEMCOMP_RC;
	138	}
	139
	140	static uint32_t GetHwTileType(MOS_TILE_TYPE tileType, MOS_TILE_MODE_GMM tileModeGMM, bool gmmTileEnabled)
	141	{
	142	uint32_t tileMode = 0;
	143
	144	if (gmmTileEnabled)
	145	{
	146	return tileModeGMM;
	147	}
	148
	149	switch (tileType)
	150	{
	151	case MOS_TILE_LINEAR:
	152	tileMode = 0;
	153	break;
	154	case MOS_TILE_YS:
	155	tileMode = 1;
	156	break;
	157	case MOS_TILE_X:
	158	tileMode = 2;
	159	break;
	160	default:
	161	tileMode = 3;
	162	break;
	163	}
	164
	165	return tileMode;
	166	}
	167
174	168	Impl(PMOS_INTERFACE osItf)
175	169	{
176	170	MHW_FUNCTION_ENTER;

186	180	{
187	181	AddResourceToCmd = Mhw_AddResourceToCmd_PatchList;
188	182	}
189		}
190
191		virtual ~Impl() = default;
	183
	184	#if MHW_HWCMDPARSER_ENABLED
	185	mhw::HwcmdParser::InitInstance(osItf);
	186
	187	m_hwcmdParser = mhw::HwcmdParser::GetInstance();
	188	MHW_CHK_NULL_NO_STATUS_RETURN(m_hwcmdParser);
	189
	190	m_parseFieldsLayout = m_hwcmdParser->ParseFieldsLayoutEn();
	191	#endif
	192	}
	193
	194	virtual ~Impl()
	195	{
	196	MHW_FUNCTION_ENTER;
	197
	198	#if MHW_HWCMDPARSER_ENABLED
	199	mhw::HwcmdParser::DestroyInstance();
	200	#endif
	201	}
	202
	203	template <typename Cmd, typename CmdSetting>
	204	MOS_STATUS AddCmd(PMOS_COMMAND_BUFFER cmdBuf,
	205	PMHW_BATCH_BUFFER batchBuf,
	206	Cmd & cmd,
	207	const CmdSetting & setting)
	208	{
	209	this->m_currentCmdBuf = cmdBuf;
	210	this->m_currentBatchBuf = batchBuf;
	211
	212	// set MHW cmd
	213	cmd = {};
	214	MHW_CHK_STATUS_RETURN(setting());
	215
	216	// call MHW cmd parser
	217	#if MHW_HWCMDPARSER_ENABLED
	218	this->m_hwcmdParser->ParseCmd(this->m_currentCmdName,
	219	reinterpret_cast<uint32_t *>(&cmd),
	220	sizeof(cmd) / sizeof(uint32_t));
	221	#endif
	222
	223	// add cmd to cmd buffer
	224	return Mhw_AddCommandCmdOrBB(cmdBuf, batchBuf, &cmd, sizeof(cmd));
	225	}
192	226
193	227	protected:
194	228	MOS_STATUS(*AddResourceToCmd)

199	233	PMHW_BATCH_BUFFER m_currentBatchBuf = nullptr;
200	234
201	235	#if MHW_HWCMDPARSER_ENABLED
202		std::shared_ptr<HwcmdParser> m_hwcmdParser = mhw::HwcmdParser::GetInstance();
203		bool m_parseFieldsLayout = m_hwcmdParser->ParseFieldsLayoutEn();
	236	std::string m_currentCmdName;
	237	std::shared_ptr<HwcmdParser> m_hwcmdParser = nullptr;
	238	bool m_parseFieldsLayout = false;
204	239	#endif // MHW_HWCMDPARSER_ENABLED
205	240	};
206	241	} // namespace mhw

+20

-36

media_softlet/agnostic/common/hw/mhw_itf.h less more

29	29
30	30	#include "mhw_cmdpar.h"
31	31
32		#define MHW_HWCMDPARSER_ENABLED (_MHW_HWCMDPARSER_SUPPORTED && (_DEBUG \|\| _RELEASE_INTERNAL))
33		#if MHW_HWCMDPARSER_ENABLED
	32	#if _MHW_HWCMDPARSER_SUPPORTED
34	33	#include "mhw_hwcmd_parser.h"
35		#else
36		#define MHW_HWCMDPARSER_INIT(osInterface)
37		#define MHW_HWCMDPARSER_DESTROY()
38		#define MHW_HWCMDPARSER_FRAMEINFOUPDATE(frameType)
39		#define MHW_HWCMDPARSER_PARSECMD(cmdName, cmdData, dwLen)
40		#define MHW_HWCMDPARSER_PARSECMDBUF(cmdBuf, dwLen)
41		#define MHW_HWCMDPARSER_PARSECMDBUFGFX(cmdBufGfx)
42	34	#endif
43	35
44	36	// [Macro Prefixes] \| [Macro Suffixes]

48	40	// only used by other \| _DECL: declaration
49	41	// macros \| _DEF : definition
50	42
51		#define __MHW_CMD_PAR_GET_F(CMD) GetCmdPar_##CMD // function name to get the pointer to MHW command parameter
52		#define __MHW_CMD_BYTE_SIZE_GET_F(CMD) GetCmdByteSize_##CMD // function name to get MHW command size in byte
53		#define __MHW_CMD_ADD_F(CMD) AddCmd_##CMD // function name to add command
	43	#define __MHW_GETPAR_F(CMD) GETPAR_##CMD // function name to get the pointer to MHW command parameter
	44	#define MHW_GETPAR_F(CMD) __MHW_GETPAR_F(CMD) // to support 2-level macro expanding
	45	#define __MHW_GETSIZE_F(CMD) GETSIZE_##CMD // function name to get MHW command size in byte
	46	#define MHW_GETSIZE_F(CMD) __MHW_GETSIZE_F(CMD) // to support 2-level macro expanding
	47	#define __MHW_ADDCMD_F(CMD) ADDCMD_##CMD // function name to add command
	48	#define MHW_ADDCMD_F(CMD) __MHW_ADDCMD_F(CMD) // to support 2-level macro expanding
	49	#define __MHW_SETCMD_F(CMD) SETCMD_##CMD // function name to set command data
54	50
55		#define __MHW_CMD_PAR_GET_DECL(CMD) mhw::Pointer<_MHW_CMD_PAR_T(CMD)> __MHW_CMD_PAR_GET_F(CMD)(bool reset)
56		#define __MHW_CMD_BYTE_SIZE_GET_DECL(CMD) size_t __MHW_CMD_BYTE_SIZE_GET_F(CMD)() const
	51	#define __MHW_GETPAR_DECL(CMD) _MHW_PAR_T(CMD) & MHW_GETPAR_F(CMD)()
	52	#define __MHW_GETSIZE_DECL(CMD) size_t MHW_GETSIZE_F(CMD)() const
	53	#define __MHW_ADDCMD_DECL(CMD) MOS_STATUS MHW_ADDCMD_F(CMD)(PMOS_COMMAND_BUFFER cmdBuf, PMHW_BATCH_BUFFER batchBuf = nullptr)
	54	#define __MHW_SETCMD_DECL(CMD) MOS_STATUS __MHW_SETCMD_F(CMD)()
57	55
58		#define __MHW_CMD_ADD_DECL(CMD) MOS_STATUS __MHW_CMD_ADD_F(CMD)(PMOS_COMMAND_BUFFER cmdBuf, \
59		PMHW_BATCH_BUFFER batchBuf = nullptr, \
60		const uint8_t *extraData = nullptr, \
61		size_t extraDataSize = 0)
62
63		#define _MHW_CMD_ALL_DEF_FOR_ITF(CMD) \
64		public: \
65		virtual __MHW_CMD_PAR_GET_DECL(CMD) = 0; \
66		virtual __MHW_CMD_BYTE_SIZE_GET_DECL(CMD) = 0; \
67		virtual __MHW_CMD_ADD_DECL(CMD) = 0
68
69		#define _MHW_SETPARAMS_AND_ADDCMD(CMD, cmdPar_t, GetPar, AddCmd, ...) \
70		{ \
71		auto par = GetPar(CMD, true); \
72		auto p = dynamic_cast<const cmdPar_t *>(this); \
73		if (p) \
74		{ \
75		p->__MHW_CMD_PAR_SET_F(CMD)(par); \
76		} \
77		LOOP_FEATURE_INTERFACE_RETURN(cmdPar_t, __MHW_CMD_PAR_SET_F(CMD), par); \
78		AddCmd(CMD, __VA_ARGS__); \
79		}
	56	#define _MHW_CMD_ALL_DEF_FOR_ITF(CMD) \
	57	public: \
	58	virtual __MHW_GETPAR_DECL(CMD) = 0; \
	59	virtual __MHW_GETSIZE_DECL(CMD) = 0; \
	60	virtual __MHW_ADDCMD_DECL(CMD) = 0; \
	61	\
	62	protected: \
	63	virtual __MHW_SETCMD_DECL(CMD) { return MOS_STATUS_SUCCESS; }
80	64
81	65	#endif // __MHW_DEF_H__

+16

-37

media_softlet/agnostic/common/hw/vdbox/mhw_vdbox_vdenc_cmdpar.h less more

78	78	ayuvVariant = 0x14,
79	79	};
80	80
81		struct _MHW_CMD_PAR_T(VDENC_CONTROL_STATE)
	81	struct _MHW_PAR_T(VDENC_CONTROL_STATE)
82	82	{
83	83	bool vdencInitialization = true;
84	84	};
85	85
86		struct _MHW_CMD_PAR_T(VDENC_PIPE_MODE_SELECT)
	86	struct _MHW_PAR_T(VDENC_PIPE_MODE_SELECT)
87	87	{
88	88	uint8_t standardSelect = 0;
89	89	bool scalabilityMode = false;

115	115	__MHW_VDBOX_VDENC_WRAPPER_EXT(VDENC_PIPE_MODE_SELECT_CMDPAR_EXT);
116	116	};
117	117
118		struct _MHW_CMD_PAR_T(VDENC_SRC_SURFACE_STATE)
	118	struct _MHW_PAR_T(VDENC_SRC_SURFACE_STATE)
119	119	{
120	120	uint32_t width = 0;
121	121	uint32_t height = 0;

131	131	uint8_t vDirection = 0;
132	132	};
133	133
134		struct _MHW_CMD_PAR_T(VDENC_REF_SURFACE_STATE)
	134	struct _MHW_PAR_T(VDENC_REF_SURFACE_STATE)
135	135	{
136	136	uint32_t width = 0;
137	137	uint32_t height = 0;

145	145	uint8_t vDirection = 0;
146	146	};
147	147
148		struct _MHW_CMD_PAR_T(VDENC_DS_REF_SURFACE_STATE)
	148	struct _MHW_PAR_T(VDENC_DS_REF_SURFACE_STATE)
149	149	{
150	150	uint8_t vDirectionStage1 = 0;
151	151	uint8_t vDirectionStage2 = 0;

167	167	bool gmmTileEnStage2 = false;
168	168	};
169	169
170		struct _MHW_CMD_PAR_T(VDENC_PIPE_BUF_ADDR_STATE)
	170	struct _MHW_PAR_T(VDENC_PIPE_BUF_ADDR_STATE)
171	171	{
172	172	PMOS_SURFACE surfaceRaw = nullptr;
173	173	MOS_MEMCOMP_STATE mmcStateRaw = MOS_MEMCOMP_DISABLED;

189	189	PMOS_SURFACE surfaceDsStage2 = nullptr;
190	190	MOS_MEMCOMP_STATE mmcStateDsStage2 = MOS_MEMCOMP_DISABLED;
191	191	bool lowDelayB = false;
	192	bool isPFrame = false; //only HEVC should touch this flag
192	193	PMOS_RESOURCE colocatedMvReadBuffer = nullptr;
193	194	PMOS_RESOURCE colMvTempBuffer[MAX_REF_NUM_L0L1] = {};
194	195	PMOS_RESOURCE pakObjCmdStreamOutBuffer = nullptr;

201	202	__MHW_VDBOX_VDENC_WRAPPER_EXT(VDENC_PIPE_BUF_ADDR_STATE_CMDPAR_EXT);
202	203	};
203	204
204		struct _MHW_CMD_PAR_T(VDENC_WEIGHTSOFFSETS_STATE)
	205	struct _MHW_PAR_T(VDENC_WEIGHTSOFFSETS_STATE)
205	206	{
206	207	int8_t weightsLuma[MAX_REF_LIST_NUM][MAX_REF_NUM] = {};
207	208	int16_t offsetsLuma[MAX_REF_LIST_NUM][MAX_REF_NUM] = {};

211	212	uint32_t denomChroma = 0;
212	213	};
213	214
214		struct _MHW_CMD_PAR_T(VDENC_HEVC_VP9_TILE_SLICE_STATE)
	215	struct _MHW_PAR_T(VDENC_HEVC_VP9_TILE_SLICE_STATE)
215	216	{
216	217	bool tileEnable = false;
217	218	bool tileRowStoreSelect = false;

231	232	__MHW_VDBOX_VDENC_WRAPPER_EXT(VDENC_HEVC_VP9_TILE_SLICE_STATE_CMDPAR_EXT);
232	233	};
233	234
234		struct _MHW_CMD_PAR_T(VDENC_WALKER_STATE)
	235	struct _MHW_PAR_T(VDENC_WALKER_STATE)
235	236	{
236	237	bool firstSuperSlice = true;
237	238	uint32_t tileSliceStartLcuMbX = 0;

240	241	uint32_t nextTileSliceStartLcuMbY = 0;
241	242	};
242	243
243		struct _MHW_CMD_PAR_T(VD_PIPELINE_FLUSH)
	244	struct _MHW_PAR_T(VD_PIPELINE_FLUSH)
244	245	{
245	246	bool waitDoneHEVC = false;
246	247	bool waitDoneVDENC = false;

254	255	__MHW_VDBOX_VDENC_WRAPPER_EXT(VD_PIPELINE_FLUSH_CMDPAR_EXT);
255	256	};
256	257
257		struct _MHW_CMD_PAR_T(VDENC_CMD1)
	258	struct _MHW_PAR_T(VDENC_CMD1)
258	259	{
259	260	__MHW_VDBOX_VDENC_WRAPPER_EXT(VDENC_CMD1_CMDPAR_EXT);
260	261	};
261	262
262		struct _MHW_CMD_PAR_T(VDENC_CMD2)
	263	struct _MHW_PAR_T(VDENC_CMD2)
263	264	{
264	265	__MHW_VDBOX_VDENC_WRAPPER_EXT(VDENC_CMD2_CMDPAR_EXT);
265	266	};
266	267
267		struct _MHW_CMD_PAR_T(VDENC_CMD3)
	268	struct _MHW_PAR_T(VDENC_CMD3)
268	269	{
269	270	__MHW_VDBOX_VDENC_WRAPPER_EXT(VDENC_CMD3_CMDPAR_EXT);
270	271	};
271	272
272		struct _MHW_CMD_PAR_T(VDENC_CMD4)
	273	struct _MHW_PAR_T(VDENC_CMD4)
273	274	{
274	275	__MHW_VDBOX_VDENC_WRAPPER_EXT(VDENC_CMD4_CMDPAR_EXT);
275	276	};
276	277
277		struct _MHW_CMD_PAR_T(VDENC_CMD5)
	278	struct _MHW_PAR_T(VDENC_CMD5)
278	279	{
279	280	__MHW_VDBOX_VDENC_WRAPPER_EXT(VDENC_CMD5_CMDPAR_EXT);
280		};
281
282		class CmdPar
283		{
284		public:
285		virtual ~CmdPar() = default;
286
287		_MHW_CMD_PAR_SET_DEF(VDENC_CONTROL_STATE);
288		_MHW_CMD_PAR_SET_DEF(VDENC_PIPE_MODE_SELECT);
289		_MHW_CMD_PAR_SET_DEF(VDENC_SRC_SURFACE_STATE);
290		_MHW_CMD_PAR_SET_DEF(VDENC_REF_SURFACE_STATE);
291		_MHW_CMD_PAR_SET_DEF(VDENC_DS_REF_SURFACE_STATE);
292		_MHW_CMD_PAR_SET_DEF(VDENC_PIPE_BUF_ADDR_STATE);
293		_MHW_CMD_PAR_SET_DEF(VDENC_WEIGHTSOFFSETS_STATE);
294		_MHW_CMD_PAR_SET_DEF(VDENC_HEVC_VP9_TILE_SLICE_STATE);
295		_MHW_CMD_PAR_SET_DEF(VDENC_WALKER_STATE);
296		_MHW_CMD_PAR_SET_DEF(VD_PIPELINE_FLUSH);
297		_MHW_CMD_PAR_SET_DEF(VDENC_CMD1);
298		_MHW_CMD_PAR_SET_DEF(VDENC_CMD2);
299		_MHW_CMD_PAR_SET_DEF(VDENC_CMD3);
300		_MHW_CMD_PAR_SET_DEF(VDENC_CMD4);
301		_MHW_CMD_PAR_SET_DEF(VDENC_CMD5);
302	281	};
303	282	} // namespace vdenc
304	283	} // namespace vdbox

+409

-434

media_softlet/agnostic/common/hw/vdbox/mhw_vdbox_vdenc_impl.h less more

0	0	/*
1		* Copyright (c) 2020, Intel Corporation
	1	* Copyright (c) 2020-2021, Intel Corporation
2	2	*
3	3	* Permission is hereby granted, free of charge, to any person obtaining a
4	4	* copy of this software and associated documentation files (the "Software"),

133	133	}
134	134	}
135	135
	136	template <typename cmd_t>
136	137	class Impl : public Itf, public mhw::Impl
137	138	{
138	139	_MHW_CMD_ALL_DEF_FOR_IMPL(VDENC_CONTROL_STATE);

192	193	protected:
193	194	using base_t = Itf;
194	195
	196	vdbox::RowStoreCache m_vdencRowStoreCache = {};
	197	vdbox::RowStoreCache m_vdencIpdlRowstoreCache = {};
	198	MHW_MEMORY_OBJECT_CONTROL_PARAMS m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_END_CODEC] = {};
	199
195	200	Impl(PMOS_INTERFACE osItf) : mhw::Impl(osItf)
196	201	{
197	202	MHW_FUNCTION_ENTER;

257	262	return MOS_STATUS_SUCCESS;
258	263	}
259	264
260		protected:
261		vdbox::RowStoreCache m_vdencRowStoreCache = {};
262		vdbox::RowStoreCache m_vdencIpdlRowstoreCache = {};
263		MHW_MEMORY_OBJECT_CONTROL_PARAMS m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_END_CODEC] = {};
264		};
265
266		template <typename cmd_t>
267		class ImplGeneric : public Impl
268		{
269		_MHW_CMD_ALL_DEF_FOR_IMPL_GENERIC(VDENC_CONTROL_STATE);
270		_MHW_CMD_ALL_DEF_FOR_IMPL_GENERIC(VDENC_PIPE_MODE_SELECT);
271		_MHW_CMD_ALL_DEF_FOR_IMPL_GENERIC(VDENC_SRC_SURFACE_STATE);
272		_MHW_CMD_ALL_DEF_FOR_IMPL_GENERIC(VDENC_REF_SURFACE_STATE);
273		_MHW_CMD_ALL_DEF_FOR_IMPL_GENERIC(VDENC_DS_REF_SURFACE_STATE);
274		_MHW_CMD_ALL_DEF_FOR_IMPL_GENERIC(VDENC_PIPE_BUF_ADDR_STATE);
275		_MHW_CMD_ALL_DEF_FOR_IMPL_GENERIC(VDENC_WEIGHTSOFFSETS_STATE);
276		_MHW_CMD_ALL_DEF_FOR_IMPL_GENERIC(VDENC_HEVC_VP9_TILE_SLICE_STATE);
277		_MHW_CMD_ALL_DEF_FOR_IMPL_GENERIC(VDENC_WALKER_STATE);
278		_MHW_CMD_ALL_DEF_FOR_IMPL_GENERIC(VD_PIPELINE_FLUSH);
279		_MHW_CMD_ALL_DEF_FOR_IMPL_GENERIC(VDENC_CMD1);
280		_MHW_CMD_ALL_DEF_FOR_IMPL_GENERIC(VDENC_CMD2);
281		_MHW_CMD_ALL_DEF_FOR_IMPL_GENERIC(VDENC_CMD3);
282		_MHW_CMD_ALL_DEF_FOR_IMPL_GENERIC(VDENC_CMD4);
283		_MHW_CMD_ALL_DEF_FOR_IMPL_GENERIC(VDENC_CMD5);
284
285		protected:
286		using base_t = Impl;
287
288		ImplGeneric(PMOS_INTERFACE osItf) : base_t(osItf){};
289
290		_MHW_CMD_SET_DECL_OVERRIDE(VDENC_CONTROL_STATE)
291		{
292		_MHW_CMDSET_GETCMDPARAMS_AND_CALLBASE(VDENC_CONTROL_STATE);
	265	_MHW_SETCMD_OVERRIDE_DECL(VDENC_CONTROL_STATE)
	266	{
	267	_MHW_SETCMD_CALLBASE(VDENC_CONTROL_STATE);
293	268
294	269	#define DO_FIELDS() \
295		DO_FIELD(DW1, VdencInitialization, params->vdencInitialization)
296
297		#include "mhw_hwcmd_process_cmdfields.h"
298		}
299
300		_MHW_CMD_SET_DECL_OVERRIDE(VDENC_PIPE_MODE_SELECT)
301		{
302		_MHW_CMDSET_GETCMDPARAMS_AND_CALLBASE(VDENC_PIPE_MODE_SELECT);
303
304		#define DO_FIELDS() \
305		DO_FIELD(DW1, StandardSelect, params->standardSelect); \
306		DO_FIELD(DW1, ScalabilityMode, params->scalabilityMode); \
307		DO_FIELD(DW1, FrameStatisticsStreamOutEnable, params->frameStatisticsStreamOut); \
308		DO_FIELD(DW1, VdencPakObjCmdStreamOutEnable, params->pakObjCmdStreamOut); \
309		DO_FIELD(DW1, TlbPrefetchEnable, params->tlbPrefetch); \
310		DO_FIELD(DW1, PakThresholdCheckEnable, params->dynamicSlice); \
311		DO_FIELD(DW1, VdencStreamInEnable, params->streamIn); \
312		DO_FIELD(DW1, BitDepth, params->bitDepthMinus8); \
313		DO_FIELD(DW1, PakChromaSubSamplingType, params->chromaType); \
314		DO_FIELD(DW1, OutputRangeControlAfterColorSpaceConversion, params->outputRangeControlCsc); \
315		DO_FIELD(DW1, TileReplayEnable, params->tileBasedReplayMode); \
316		DO_FIELD(DW1, IsRandomAccess, params->randomAccess); \
317		DO_FIELD(DW1, RgbEncodingEnable, params->rgbEncodingMode); \
318		DO_FIELD(DW1, StreamingBufferConfig, params->streamingBufferConfig); \
319		\
320		DO_FIELD(DW2, HmeRegionPreFetchenable, params->hmeRegionPrefetch); \
321		DO_FIELD(DW2, Topprefetchenablemode, params->topPrefetchEnableMode); \
322		DO_FIELD(DW2, LeftpreFetchatwraparound, params->leftPrefetchAtWrapAround); \
323		DO_FIELD(DW2, Verticalshift32Minus1, params->verticalShift32Minus1); \
324		DO_FIELD(DW2, Hzshift32Minus1, params->hzShift32Minus1); \
325		DO_FIELD(DW2, NumVerticalReqMinus1, params->numVerticalReqMinus1); \
326		DO_FIELD(DW2, Numhzreqminus1, params->numHzReqMinus1); \
327		DO_FIELD(DW2, PreFetchOffsetForReferenceIn16PixelIncrement, params->prefetchOffset); \
328		\
329		DO_FIELD(DW5, CaptureMode, params->captureMode); \
330		DO_FIELD(DW5, ParallelCaptureAndEncodeSessionId, params->wirelessSessionId); \
331		DO_FIELD(DW5, TailPointerReadFrequency, params->tailPointerReadFrequency); \
332		DO_FIELD(DW5, QuantizationPrecisionOptimization, params->quantizationPrecision); \
333		DO_FIELD(DW5, LatencyToleratePreFetchEnable, params->latencyTolerate); \
334
335		#include "mhw_hwcmd_process_cmdfields.h"
336		}
337
338		_MHW_CMD_SET_DECL_OVERRIDE(VDENC_SRC_SURFACE_STATE)
339		{
340		_MHW_CMDSET_GETCMDPARAMS_AND_CALLBASE(VDENC_SRC_SURFACE_STATE);
341
342		#define DO_FIELDS() \
343		DO_FIELD(Dwords25.DW0, Width, params->width - 1); \
344		DO_FIELD(Dwords25.DW0, Height, params->height - 1); \
345		DO_FIELD(Dwords25.DW0, ColorSpaceSelection, params->colorSpaceSelection); \
346		DO_FIELD(Dwords25.DW0, CrVCbUPixelOffsetVDirection, params->vDirection); \
347		DO_FIELD(Dwords25.DW0, SurfaceFormatByteSwizzle, params->displayFormatSwizzle); \
348		\
349		DO_FIELD(Dwords25.DW1, TileMode, GetHwTileType(params->tileType, params->tileModeGmm, params->gmmTileEn)); \
350		DO_FIELD(Dwords25.DW1, SurfaceFormat, static_cast<uint32_t>(MosFormatToVdencSurfaceRawFormat(params->format))); \
351		DO_FIELD(Dwords25.DW1, SurfacePitch, params->pitch - 1); \
352		\
353		DO_FIELD(Dwords25.DW2, YOffsetForUCb, params->uOffset); \
354		DO_FIELD(Dwords25.DW3, YOffsetForVCr, params->vOffset)
355
356		#include "mhw_hwcmd_process_cmdfields.h"
357		}
358
359		_MHW_CMD_SET_DECL_OVERRIDE(VDENC_REF_SURFACE_STATE)
360		{
361		_MHW_CMDSET_GETCMDPARAMS_AND_CALLBASE(VDENC_REF_SURFACE_STATE);
362
363		#define DO_FIELDS() \
364		DO_FIELD(Dwords25.DW0, Width, params->width - 1); \
365		DO_FIELD(Dwords25.DW0, Height, params->height - 1); \
366		DO_FIELD(Dwords25.DW0, CrVCbUPixelOffsetVDirection, params->vDirection); \
367		\
368		DO_FIELD(Dwords25.DW1, TileMode, GetHwTileType(params->tileType, params->tileModeGmm, params->gmmTileEn)); \
369		DO_FIELD(Dwords25.DW1, SurfacePitch, params->pitch - 1); \
370		DO_FIELD(Dwords25.DW1, SurfaceFormat, static_cast<uint32_t>(MosFormatToVdencSurfaceReconFormat(params->format))); \
371		\
372		DO_FIELD(Dwords25.DW2, YOffsetForUCb, params->uOffset); \
373		DO_FIELD(Dwords25.DW3, YOffsetForVCr, params->vOffset)
374
375		#include "mhw_hwcmd_process_cmdfields.h"
376		}
377
378		_MHW_CMD_SET_DECL_OVERRIDE(VDENC_DS_REF_SURFACE_STATE)
379		{
380		_MHW_CMDSET_GETCMDPARAMS_AND_CALLBASE(VDENC_DS_REF_SURFACE_STATE);
381
382		const bool stage2 = params->widthStage2 && params->heightStage2 && params->pitchStage2;
383
384		#define DO_FIELDS() \
385		DO_FIELD(Dwords25.DW0, Width, params->widthStage1 - 1); \
386		DO_FIELD(Dwords25.DW0, Height, params->heightStage1 - 1); \
387		DO_FIELD(Dwords25.DW0, CrVCbUPixelOffsetVDirection, params->vDirectionStage1); \
388		\
389		DO_FIELD(Dwords25.DW1, TileMode, GetHwTileType(params->tileTypeStage1, params->tileModeGmmStage1, params->gmmTileEnStage1)); \
390		DO_FIELD(Dwords25.DW1, SurfaceFormat, cmd_t::VDENC_Surface_State_Fields_CMD::SURFACE_FORMAT_PLANAR_420_8); \
391		DO_FIELD(Dwords25.DW1, SurfacePitch, params->pitchStage1 - 1); \
392		\
393		DO_FIELD(Dwords25.DW2, YOffsetForUCb, params->uOffsetStage1); \
394		\
395		DO_FIELD(Dwords25.DW3, YOffsetForVCr, params->vOffsetStage1); \
396		\
397		DO_FIELD(Dwords69.DW0, Width, stage2 ? params->widthStage2 - 1 : 0); \
398		DO_FIELD(Dwords69.DW0, Height, stage2 ? params->heightStage2 - 1 : 0); \
399		DO_FIELD(Dwords69.DW0, CrVCbUPixelOffsetVDirection, stage2 ? params->vDirectionStage2 : 0); \
400		\
401		DO_FIELD(Dwords69.DW1, TileMode, stage2 ? GetHwTileType(params->tileTypeStage2, params->tileModeGmmStage2, params->gmmTileEnStage2) : 0); \
402		DO_FIELD(Dwords69.DW1, SurfaceFormat, stage2 ? cmd_t::VDENC_Surface_State_Fields_CMD::SURFACE_FORMAT_PLANAR_420_8 : 0); \
403		DO_FIELD(Dwords69.DW1, SurfacePitch, stage2 ? params->pitchStage2 - 1 : 0); \
404		\
405		DO_FIELD(Dwords69.DW2, YOffsetForUCb, stage2 ? params->uOffsetStage2 : 0); \
406		\
407		DO_FIELD(Dwords69.DW3, YOffsetForVCr, stage2 ? params->vOffsetStage2 : 0)
408
409		#include "mhw_hwcmd_process_cmdfields.h"
410		}
411
412		_MHW_CMD_SET_DECL_OVERRIDE(VDENC_PIPE_BUF_ADDR_STATE)
413		{
414		_MHW_CMDSET_GETCMDPARAMS_AND_CALLBASE(VDENC_PIPE_BUF_ADDR_STATE);
	270	DO_FIELD(DW1, VdencInitialization, params.vdencInitialization)
	271
	272	#include "mhw_hwcmd_process_cmdfields.h"
	273	}
	274
	275	_MHW_SETCMD_OVERRIDE_DECL(VDENC_PIPE_MODE_SELECT)
	276	{
	277	_MHW_SETCMD_CALLBASE(VDENC_PIPE_MODE_SELECT);
	278
	279	#define DO_FIELDS() \
	280	DO_FIELD(DW1, StandardSelect, params.standardSelect); \
	281	DO_FIELD(DW1, ScalabilityMode, params.scalabilityMode); \
	282	DO_FIELD(DW1, FrameStatisticsStreamOutEnable, params.frameStatisticsStreamOut); \
	283	DO_FIELD(DW1, VdencPakObjCmdStreamOutEnable, params.pakObjCmdStreamOut); \
	284	DO_FIELD(DW1, TlbPrefetchEnable, params.tlbPrefetch); \
	285	DO_FIELD(DW1, PakThresholdCheckEnable, params.dynamicSlice); \
	286	DO_FIELD(DW1, VdencStreamInEnable, params.streamIn); \
	287	DO_FIELD(DW1, BitDepth, params.bitDepthMinus8); \
	288	DO_FIELD(DW1, PakChromaSubSamplingType, params.chromaType); \
	289	DO_FIELD(DW1, OutputRangeControlAfterColorSpaceConversion, params.outputRangeControlCsc); \
	290	DO_FIELD(DW1, TileReplayEnable, params.tileBasedReplayMode); \
	291	DO_FIELD(DW1, IsRandomAccess, params.randomAccess); \
	292	DO_FIELD(DW1, RgbEncodingEnable, params.rgbEncodingMode); \
	293	DO_FIELD(DW1, StreamingBufferConfig, params.streamingBufferConfig); \
	294	\
	295	DO_FIELD(DW2, HmeRegionPreFetchenable, params.hmeRegionPrefetch); \
	296	DO_FIELD(DW2, Topprefetchenablemode, params.topPrefetchEnableMode); \
	297	DO_FIELD(DW2, LeftpreFetchatwraparound, params.leftPrefetchAtWrapAround); \
	298	DO_FIELD(DW2, Verticalshift32Minus1, params.verticalShift32Minus1); \
	299	DO_FIELD(DW2, Hzshift32Minus1, params.hzShift32Minus1); \
	300	DO_FIELD(DW2, NumVerticalReqMinus1, params.numVerticalReqMinus1); \
	301	DO_FIELD(DW2, Numhzreqminus1, params.numHzReqMinus1); \
	302	DO_FIELD(DW2, PreFetchOffsetForReferenceIn16PixelIncrement, params.prefetchOffset); \
	303	\
	304	DO_FIELD(DW5, CaptureMode, params.captureMode); \
	305	DO_FIELD(DW5, ParallelCaptureAndEncodeSessionId, params.wirelessSessionId); \
	306	DO_FIELD(DW5, TailPointerReadFrequency, params.tailPointerReadFrequency); \
	307	DO_FIELD(DW5, QuantizationPrecisionOptimization, params.quantizationPrecision); \
	308	DO_FIELD(DW5, LatencyToleratePreFetchEnable, params.latencyTolerate);
	309
	310	#include "mhw_hwcmd_process_cmdfields.h"
	311	}
	312
	313	_MHW_SETCMD_OVERRIDE_DECL(VDENC_SRC_SURFACE_STATE)
	314	{
	315	_MHW_SETCMD_CALLBASE(VDENC_SRC_SURFACE_STATE);
	316
	317	#define DO_FIELDS() \
	318	DO_FIELD(Dwords25.DW0, Width, params.width - 1); \
	319	DO_FIELD(Dwords25.DW0, Height, params.height - 1); \
	320	DO_FIELD(Dwords25.DW0, ColorSpaceSelection, params.colorSpaceSelection); \
	321	DO_FIELD(Dwords25.DW0, CrVCbUPixelOffsetVDirection, params.vDirection); \
	322	DO_FIELD(Dwords25.DW0, SurfaceFormatByteSwizzle, params.displayFormatSwizzle); \
	323	\
	324	DO_FIELD(Dwords25.DW1, TileMode, GetHwTileType(params.tileType, params.tileModeGmm, params.gmmTileEn)); \
	325	DO_FIELD(Dwords25.DW1, SurfaceFormat, static_cast<uint32_t>(MosFormatToVdencSurfaceRawFormat(params.format))); \
	326	DO_FIELD(Dwords25.DW1, SurfacePitch, params.pitch - 1); \
	327	\
	328	DO_FIELD(Dwords25.DW2, YOffsetForUCb, params.uOffset); \
	329	DO_FIELD(Dwords25.DW3, YOffsetForVCr, params.vOffset)
	330
	331	#include "mhw_hwcmd_process_cmdfields.h"
	332	}
	333
	334	_MHW_SETCMD_OVERRIDE_DECL(VDENC_REF_SURFACE_STATE)
	335	{
	336	_MHW_SETCMD_CALLBASE(VDENC_REF_SURFACE_STATE);
	337
	338	#define DO_FIELDS() \
	339	DO_FIELD(Dwords25.DW0, Width, params.width - 1); \
	340	DO_FIELD(Dwords25.DW0, Height, params.height - 1); \
	341	DO_FIELD(Dwords25.DW0, CrVCbUPixelOffsetVDirection, params.vDirection); \
	342	\
	343	DO_FIELD(Dwords25.DW1, TileMode, GetHwTileType(params.tileType, params.tileModeGmm, params.gmmTileEn)); \
	344	DO_FIELD(Dwords25.DW1, SurfacePitch, params.pitch - 1); \
	345	DO_FIELD(Dwords25.DW1, SurfaceFormat, static_cast<uint32_t>(MosFormatToVdencSurfaceReconFormat(params.format))); \
	346	\
	347	DO_FIELD(Dwords25.DW2, YOffsetForUCb, params.uOffset); \
	348	DO_FIELD(Dwords25.DW3, YOffsetForVCr, params.vOffset)
	349
	350	#include "mhw_hwcmd_process_cmdfields.h"
	351	}
	352
	353	_MHW_SETCMD_OVERRIDE_DECL(VDENC_DS_REF_SURFACE_STATE)
	354	{
	355	_MHW_SETCMD_CALLBASE(VDENC_DS_REF_SURFACE_STATE);
	356
	357	const bool stage2 = params.widthStage2 && params.heightStage2 && params.pitchStage2;
	358
	359	#define DO_FIELDS() \
	360	DO_FIELD(Dwords25.DW0, Width, params.widthStage1 - 1); \
	361	DO_FIELD(Dwords25.DW0, Height, params.heightStage1 - 1); \
	362	DO_FIELD(Dwords25.DW0, CrVCbUPixelOffsetVDirection, params.vDirectionStage1); \
	363	\
	364	DO_FIELD(Dwords25.DW1, TileMode, GetHwTileType(params.tileTypeStage1, params.tileModeGmmStage1, params.gmmTileEnStage1)); \
	365	DO_FIELD(Dwords25.DW1, SurfaceFormat, cmd_t::VDENC_Surface_State_Fields_CMD::SURFACE_FORMAT_PLANAR_420_8); \
	366	DO_FIELD(Dwords25.DW1, SurfacePitch, params.pitchStage1 - 1); \
	367	\
	368	DO_FIELD(Dwords25.DW2, YOffsetForUCb, params.uOffsetStage1); \
	369	\
	370	DO_FIELD(Dwords25.DW3, YOffsetForVCr, params.vOffsetStage1); \
	371	\
	372	DO_FIELD(Dwords69.DW0, Width, stage2 ? params.widthStage2 - 1 : 0); \
	373	DO_FIELD(Dwords69.DW0, Height, stage2 ? params.heightStage2 - 1 : 0); \
	374	DO_FIELD(Dwords69.DW0, CrVCbUPixelOffsetVDirection, stage2 ? params.vDirectionStage2 : 0); \
	375	\
	376	DO_FIELD(Dwords69.DW1, TileMode, stage2 ? GetHwTileType(params.tileTypeStage2, params.tileModeGmmStage2, params.gmmTileEnStage2) : 0); \
	377	DO_FIELD(Dwords69.DW1, SurfaceFormat, stage2 ? cmd_t::VDENC_Surface_State_Fields_CMD::SURFACE_FORMAT_PLANAR_420_8 : 0); \
	378	DO_FIELD(Dwords69.DW1, SurfacePitch, stage2 ? params.pitchStage2 - 1 : 0); \
	379	\
	380	DO_FIELD(Dwords69.DW2, YOffsetForUCb, stage2 ? params.uOffsetStage2 : 0); \
	381	\
	382	DO_FIELD(Dwords69.DW3, YOffsetForVCr, stage2 ? params.vOffsetStage2 : 0)
	383
	384	#include "mhw_hwcmd_process_cmdfields.h"
	385	}
	386
	387	_MHW_SETCMD_OVERRIDE_DECL(VDENC_PIPE_BUF_ADDR_STATE)
	388	{
	389	_MHW_SETCMD_CALLBASE(VDENC_PIPE_BUF_ADDR_STATE);
415	390
416	391	MHW_RESOURCE_PARAMS resourceParams;
417	392
418		if (params->surfaceRaw)
419		{
420		cmd->OriginalUncompressedPicture.PictureFields.DW0.MemoryCompressionEnable = MmcEnabled(params->mmcStateRaw);
421		cmd->OriginalUncompressedPicture.PictureFields.DW0.CompressionType = MmcRcEnabled(params->mmcStateRaw);
422		cmd->OriginalUncompressedPicture.PictureFields.DW0.MemoryObjectControlState =
	393	if (params.surfaceRaw)
	394	{
	395	cmd.OriginalUncompressedPicture.PictureFields.DW0.MemoryCompressionEnable = MmcEnabled(params.mmcStateRaw);
	396	cmd.OriginalUncompressedPicture.PictureFields.DW0.CompressionType = MmcRcEnabled(params.mmcStateRaw);
	397	cmd.OriginalUncompressedPicture.PictureFields.DW0.MemoryObjectControlState =
423	398	this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_ENCODE].Value;
424		cmd->OriginalUncompressedPicture.PictureFields.DW0.CompressionFormat = params->compressionFormatRaw;
	399	cmd.OriginalUncompressedPicture.PictureFields.DW0.CompressionFormat = params.compressionFormatRaw;
425	400
426	401	resourceParams = {};
427		resourceParams.presResource = &params->surfaceRaw->OsResource;
428		resourceParams.dwOffset = params->surfaceRaw->dwOffset;
429		resourceParams.pdwCmd = (uint32_t *)&(cmd->OriginalUncompressedPicture.LowerAddress);
	402	resourceParams.presResource = &params.surfaceRaw->OsResource;
	403	resourceParams.dwOffset = params.surfaceRaw->dwOffset;
	404	resourceParams.pdwCmd = (uint32_t *)&(cmd.OriginalUncompressedPicture.LowerAddress);
430	405	resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(OriginalUncompressedPicture.LowerAddress);
431	406	resourceParams.bIsWritable = false;
432	407	resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;

439	414
440	415	if (this->m_vdencRowStoreCache.enabled)
441	416	{
442		cmd->RowStoreScratchBuffer.BufferPictureFields.DW0.CacheSelect = cmd_t::VDENC_Surface_Control_Bits_CMD::CACHE_SELECT_UNNAMED1;
443		cmd->RowStoreScratchBuffer.LowerAddress.DW0.Value = this->m_vdencRowStoreCache.dwAddress << 6;
444		}
445		else if (!Mos_ResourceIsNull(params->intraRowStoreScratchBuffer))
446		{
447		cmd->RowStoreScratchBuffer.BufferPictureFields.DW0.MemoryObjectControlState =
	417	cmd.RowStoreScratchBuffer.BufferPictureFields.DW0.CacheSelect = cmd_t::VDENC_Surface_Control_Bits_CMD::CACHE_SELECT_UNNAMED1;
	418	cmd.RowStoreScratchBuffer.LowerAddress.DW0.Value = this->m_vdencRowStoreCache.dwAddress << 6;
	419	}
	420	else if (!Mos_ResourceIsNull(params.intraRowStoreScratchBuffer))
	421	{
	422	cmd.RowStoreScratchBuffer.BufferPictureFields.DW0.MemoryObjectControlState =
448	423	this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_VDENC_ROW_STORE_BUFFER_CODEC].Value;
449	424
450		resourceParams.presResource = params->intraRowStoreScratchBuffer;
	425	resourceParams.presResource = params.intraRowStoreScratchBuffer;
451	426	resourceParams.dwOffset = 0;
452		resourceParams.pdwCmd = (uint32_t *)&(cmd->RowStoreScratchBuffer.LowerAddress);
	427	resourceParams.pdwCmd = (uint32_t *)&(cmd.RowStoreScratchBuffer.LowerAddress);
453	428	resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(RowStoreScratchBuffer.LowerAddress);
454	429	resourceParams.bIsWritable = true;
455	430	resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;

460	435	&resourceParams));
461	436	}
462	437
463		if (!Mos_ResourceIsNull(params->streamOutBuffer))
464		{
465		cmd->VdencStatisticsStreamout.PictureFields.DW0.MemoryObjectControlState =
	438	if (!Mos_ResourceIsNull(params.streamOutBuffer))
	439	{
	440	cmd.VdencStatisticsStreamout.PictureFields.DW0.MemoryObjectControlState =
466	441	this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC].Value;
467	442
468		resourceParams.presResource = params->streamOutBuffer;
469		resourceParams.dwOffset = params->streamOutOffset;
470		resourceParams.pdwCmd = (uint32_t *)&(cmd->VdencStatisticsStreamout.LowerAddress);
	443	resourceParams.presResource = params.streamOutBuffer;
	444	resourceParams.dwOffset = params.streamOutOffset;
	445	resourceParams.pdwCmd = (uint32_t *)&(cmd.VdencStatisticsStreamout.LowerAddress);
471	446	resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(VdencStatisticsStreamout.LowerAddress);
472	447	resourceParams.bIsWritable = true;
473	448	resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;

478	453	&resourceParams));
479	454	}
480	455
481		if (!Mos_ResourceIsNull(params->streamInBuffer))
482		{
483		cmd->StreaminDataPicture.PictureFields.DW0.MemoryObjectControlState =
	456	if (!Mos_ResourceIsNull(params.streamInBuffer))
	457	{
	458	cmd.StreaminDataPicture.PictureFields.DW0.MemoryObjectControlState =
484	459	this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_VDENC_STREAMIN_CODEC].Value;
485	460
486		resourceParams.presResource = params->streamInBuffer;
	461	resourceParams.presResource = params.streamInBuffer;
487	462	resourceParams.dwOffset = 0;
488		resourceParams.pdwCmd = (uint32_t *)&(cmd->StreaminDataPicture.LowerAddress);
	463	resourceParams.pdwCmd = (uint32_t *)&(cmd.StreaminDataPicture.LowerAddress);
489	464	resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(StreaminDataPicture.LowerAddress);
490	465	resourceParams.bIsWritable = false;
491	466	resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;

497	472	}
498	473
499	474	typename cmd_t::VDENC_Reference_Picture_CMD *fwdRefs[] =
500		{&cmd->FwdRef0, &cmd->FwdRef1, &cmd->FwdRef2, &cmd->BwdRef0};
	475	{&cmd.FwdRef0, &cmd.FwdRef1, &cmd.FwdRef2, &cmd.BwdRef0};
501	476	uint32_t fwdRefsDwLoaction[] =
502	477	{_MHW_CMD_DW_LOCATION(FwdRef0), _MHW_CMD_DW_LOCATION(FwdRef1), _MHW_CMD_DW_LOCATION(FwdRef2)};
503	478
504	479	typename cmd_t::VDENC_Down_Scaled_Reference_Picture_CMD *fwdRefsDsStage1[] =
505		{&cmd->DsFwdRef0, &cmd->DsFwdRef1};
	480	{&cmd.DsFwdRef0, &cmd.DsFwdRef1};
506	481	uint32_t fwdRefsDsStage1DwLoaction[] =
507	482	{_MHW_CMD_DW_LOCATION(DsFwdRef0), _MHW_CMD_DW_LOCATION(DsFwdRef1)};
508	483
509	484	typename cmd_t::VDENC_Down_Scaled_Reference_Picture_CMD *fwdRefsDsStage2[] =
510		{&cmd->DsFwdRef04X, &cmd->DsFwdRef14X, &cmd->Additional4xDsFwdRef};
	485	{&cmd.DsFwdRef04X, &cmd.DsFwdRef14X, &cmd.Additional4xDsFwdRef};
511	486	uint32_t fwdRefsDsStage2DwLoaction[] =
512	487	{_MHW_CMD_DW_LOCATION(DsFwdRef04X), _MHW_CMD_DW_LOCATION(DsFwdRef14X), _MHW_CMD_DW_LOCATION(Additional4xDsFwdRef)};
513	488
514	489	uint8_t refIdx;
515		for (refIdx = 0; refIdx < params->numActiveRefL0; refIdx++)
516		{
517		if (!Mos_ResourceIsNull(params->refs[refIdx]) && refIdx < sizeof(fwdRefs) / sizeof(fwdRefs[0]))
	490	for (refIdx = 0; refIdx < params.numActiveRefL0; refIdx++)
	491	{
	492	if (!Mos_ResourceIsNull(params.refs[refIdx]) && refIdx < sizeof(fwdRefs) / sizeof(fwdRefs[0]))
518	493	{
519	494	MOS_SURFACE details = {};
520	495	details.Format = Format_Invalid;
521		MHW_CHK_STATUS_RETURN(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params->refs[refIdx], &details));
522
523		resourceParams.presResource = params->refs[refIdx];
	496	MHW_CHK_STATUS_RETURN(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params.refs[refIdx], &details));
	497
	498	resourceParams.presResource = params.refs[refIdx];
524	499	resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
525	500	resourceParams.dwLocationInCmd = fwdRefsDwLoaction[refIdx];
526	501	resourceParams.bIsWritable = false;
527	502	resourceParams.pdwCmd = (uint32_t *)&fwdRefs[refIdx]->LowerAddress;
528	503	resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
529	504
530		auto mmcMode = (params->mmcStatePostDeblock != MOS_MEMCOMP_DISABLED) ? params->mmcStatePostDeblock : params->mmcStatePreDeblock;
	505	auto mmcMode = (params.mmcStatePostDeblock != MOS_MEMCOMP_DISABLED) ? params.mmcStatePostDeblock : params.mmcStatePreDeblock;
531	506
532	507	fwdRefs[refIdx]->PictureFields.DW0.MemoryCompressionEnable = MmcEnabled(mmcMode);
533	508	fwdRefs[refIdx]->PictureFields.DW0.CompressionType = MmcRcEnabled(mmcMode);
534	509	fwdRefs[refIdx]->PictureFields.DW0.MemoryObjectControlState =
535	510	this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
536		fwdRefs[refIdx]->PictureFields.DW0.CompressionFormat = params->compressionFormatRecon;
	511	fwdRefs[refIdx]->PictureFields.DW0.CompressionFormat = params.compressionFormatRecon;
537	512
538	513	MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
539	514	this->m_osItf,

541	516	&resourceParams));
542	517	}
543	518
544		if (!Mos_ResourceIsNull(params->refsDsStage1[refIdx]) && refIdx < sizeof(fwdRefsDsStage1) / sizeof(fwdRefsDsStage1[0]))
	519	if (!Mos_ResourceIsNull(params.refsDsStage1[refIdx]) && refIdx < sizeof(fwdRefsDsStage1) / sizeof(fwdRefsDsStage1[0]))
545	520	{
546	521	MOS_SURFACE details = {};
547	522	details.Format = Format_Invalid;
548		MHW_CHK_STATUS_RETURN(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params->refsDsStage1[refIdx], &details));
549
550		resourceParams.presResource = params->refsDsStage1[refIdx];
	523	MHW_CHK_STATUS_RETURN(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params.refsDsStage1[refIdx], &details));
	524
	525	resourceParams.presResource = params.refsDsStage1[refIdx];
551	526	resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
552	527	resourceParams.dwLocationInCmd = fwdRefsDsStage1DwLoaction[refIdx];
553	528	resourceParams.bIsWritable = false;
554	529	resourceParams.pdwCmd = (uint32_t *)&(fwdRefsDsStage1[refIdx]->LowerAddress);
555	530	resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
556	531
557		auto mmcMode = params->mmcStateDsStage1;
	532	auto mmcMode = params.mmcStateDsStage1;
558	533
559	534	fwdRefsDsStage1[refIdx]->PictureFields.DW0.MemoryCompressionEnable = MmcEnabled(mmcMode);
560	535	fwdRefsDsStage1[refIdx]->PictureFields.DW0.CompressionType = MmcRcEnabled(mmcMode);

567	542	&resourceParams));
568	543	}
569	544
570		if (!Mos_ResourceIsNull(params->refsDsStage2[refIdx]) && refIdx < sizeof(fwdRefsDsStage2) / sizeof(fwdRefsDsStage2[0]))
	545	if (!Mos_ResourceIsNull(params.refsDsStage2[refIdx]) && refIdx < sizeof(fwdRefsDsStage2) / sizeof(fwdRefsDsStage2[0]))
571	546	{
572	547	MOS_SURFACE details = {};
573	548	details.Format = Format_Invalid;
574		MHW_CHK_STATUS_RETURN(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params->refsDsStage2[refIdx], &details));
575
576		resourceParams.presResource = params->refsDsStage2[refIdx];
	549	MHW_CHK_STATUS_RETURN(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params.refsDsStage2[refIdx], &details));
	550
	551	resourceParams.presResource = params.refsDsStage2[refIdx];
577	552	resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
578	553	resourceParams.dwLocationInCmd = fwdRefsDsStage2DwLoaction[refIdx];
579	554	resourceParams.bIsWritable = false;
580	555	resourceParams.pdwCmd = (uint32_t *)&(fwdRefsDsStage2[refIdx]->LowerAddress);
581	556	resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
582	557
583		auto mmcMode = params->mmcStateDsStage2;
	558	auto mmcMode = params.mmcStateDsStage2;
584	559
585	560	fwdRefsDsStage2[refIdx]->PictureFields.DW0.MemoryCompressionEnable = MmcEnabled(mmcMode);
586	561	fwdRefsDsStage2[refIdx]->PictureFields.DW0.CompressionType = MmcRcEnabled(mmcMode);

592	567	this->m_currentCmdBuf,
593	568	&resourceParams));
594	569
595		if (params->numActiveRefL0 == 2 && params->numActiveRefL1 == 1 && refIdx == 1)
	570	if (params.numActiveRefL0 == 2 && params.numActiveRefL1 == 1 && refIdx == 1)
596	571	{
597	572	resourceParams.dwLocationInCmd = fwdRefsDsStage2DwLoaction[refIdx + 1];
598	573	resourceParams.pdwCmd = (uint32_t *)&(fwdRefsDsStage2[refIdx + 1]->LowerAddress);

611	586	}
612	587	}
613	588
614		if (!params->lowDelayB && params->numActiveRefL1)
615		{
616		if (!Mos_ResourceIsNull(params->refs[refIdx]))
	589	if ((!params.lowDelayB && params.numActiveRefL1) \|\| params.isPFrame) //HW request HEVC PFrame to set address in BwdRef0 to be same as FwdRef0
	590	{
	591	if (!Mos_ResourceIsNull(params.refs[refIdx]))
617	592	{
618	593	MOS_SURFACE details = {};
619	594	details.Format = Format_Invalid;
620		MHW_CHK_STATUS_RETURN(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params->refs[refIdx], &details));
621
622		resourceParams.presResource = params->refs[refIdx];
	595	MHW_CHK_STATUS_RETURN(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params.refs[refIdx], &details));
	596
	597	resourceParams.presResource = params.refs[refIdx];
623	598	resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
624	599	resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(BwdRef0);
625	600	resourceParams.bIsWritable = false;
626		resourceParams.pdwCmd = (uint32_t *)&(cmd->BwdRef0.LowerAddress);
	601	resourceParams.pdwCmd = (uint32_t *)&(cmd.BwdRef0.LowerAddress);
627	602	resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
628	603
629		auto mmcMode = (params->mmcStatePostDeblock != MOS_MEMCOMP_DISABLED) ? params->mmcStatePostDeblock : params->mmcStatePreDeblock;
630
631		cmd->BwdRef0.PictureFields.DW0.MemoryCompressionEnable = MmcEnabled(mmcMode);
632		cmd->BwdRef0.PictureFields.DW0.CompressionType = MmcRcEnabled(mmcMode);
633		cmd->BwdRef0.PictureFields.DW0.MemoryObjectControlState =
	604	auto mmcMode = (params.mmcStatePostDeblock != MOS_MEMCOMP_DISABLED) ? params.mmcStatePostDeblock : params.mmcStatePreDeblock;
	605
	606	cmd.BwdRef0.PictureFields.DW0.MemoryCompressionEnable = MmcEnabled(mmcMode);
	607	cmd.BwdRef0.PictureFields.DW0.CompressionType = MmcRcEnabled(mmcMode);
	608	cmd.BwdRef0.PictureFields.DW0.MemoryObjectControlState =
634	609	this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
635		cmd->BwdRef0.PictureFields.DW0.CompressionFormat = params->compressionFormatRecon;
	610	cmd.BwdRef0.PictureFields.DW0.CompressionFormat = params.compressionFormatRecon;
636	611
637	612	MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
638	613	this->m_osItf,

640	615	&resourceParams));
641	616	}
642	617
643		if (!Mos_ResourceIsNull(params->refsDsStage1[refIdx]))
	618	if (!Mos_ResourceIsNull(params.refsDsStage1[refIdx]))
644	619	{
645	620	MOS_SURFACE details = {};
646	621	details.Format = Format_Invalid;
647		MHW_CHK_STATUS_RETURN(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params->refsDsStage1[refIdx], &details));
648
649		resourceParams.presResource = params->refsDsStage1[refIdx];
	622	MHW_CHK_STATUS_RETURN(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params.refsDsStage1[refIdx], &details));
	623
	624	resourceParams.presResource = params.refsDsStage1[refIdx];
650	625	resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
651	626	resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DsBwdRef0);
652	627	resourceParams.bIsWritable = false;
653		resourceParams.pdwCmd = (uint32_t *)&(cmd->DsBwdRef0.LowerAddress);
	628	resourceParams.pdwCmd = (uint32_t *)&(cmd.DsBwdRef0.LowerAddress);
654	629	resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
655	630
656		auto mmcMode = params->mmcStateDsStage1;
657
658		cmd->DsBwdRef0.PictureFields.DW0.MemoryCompressionEnable = MmcEnabled(mmcMode);
659		cmd->DsBwdRef0.PictureFields.DW0.CompressionType = MmcRcEnabled(mmcMode);
660		cmd->DsBwdRef0.PictureFields.DW0.MemoryObjectControlState =
	631	auto mmcMode = params.mmcStateDsStage1;
	632
	633	cmd.DsBwdRef0.PictureFields.DW0.MemoryCompressionEnable = MmcEnabled(mmcMode);
	634	cmd.DsBwdRef0.PictureFields.DW0.CompressionType = MmcRcEnabled(mmcMode);
	635	cmd.DsBwdRef0.PictureFields.DW0.MemoryObjectControlState =
661	636	this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
662	637
663	638	MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(

666	641	&resourceParams));
667	642	}
668	643
669		if (!Mos_ResourceIsNull(params->refsDsStage2[refIdx]))
	644	if (!Mos_ResourceIsNull(params.refsDsStage2[refIdx]))
670	645	{
671	646	MOS_SURFACE details = {};
672	647	details.Format = Format_Invalid;
673		MHW_CHK_STATUS_RETURN(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params->refsDsStage2[refIdx], &details));
674
675		resourceParams.presResource = params->refsDsStage2[refIdx];
	648	MHW_CHK_STATUS_RETURN(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params.refsDsStage2[refIdx], &details));
	649
	650	resourceParams.presResource = params.refsDsStage2[refIdx];
676	651	resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
677	652	resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DsBwdRef04X);
678	653	resourceParams.bIsWritable = false;
679		resourceParams.pdwCmd = (uint32_t *)&(cmd->DsBwdRef04X.LowerAddress);
	654	resourceParams.pdwCmd = (uint32_t *)&(cmd.DsBwdRef04X.LowerAddress);
680	655	resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
681	656
682		auto mmcMode = params->mmcStateDsStage2;
683
684		cmd->DsBwdRef04X.PictureFields.DW0.MemoryCompressionEnable = MmcEnabled(mmcMode);
685		cmd->DsBwdRef04X.PictureFields.DW0.CompressionType = MmcRcEnabled(mmcMode);
686		cmd->DsBwdRef04X.PictureFields.DW0.MemoryObjectControlState =
	657	auto mmcMode = params.mmcStateDsStage2;
	658
	659	cmd.DsBwdRef04X.PictureFields.DW0.MemoryCompressionEnable = MmcEnabled(mmcMode);
	660	cmd.DsBwdRef04X.PictureFields.DW0.CompressionType = MmcRcEnabled(mmcMode);
	661	cmd.DsBwdRef04X.PictureFields.DW0.MemoryObjectControlState =
687	662	this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
688	663
689	664	MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(

693	668	}
694	669	}
695	670
696		if (!Mos_ResourceIsNull(params->colocatedMvReadBuffer))
697		{
698		resourceParams.presResource = params->colocatedMvReadBuffer;
	671	if (!Mos_ResourceIsNull(params.colocatedMvReadBuffer))
	672	{
	673	resourceParams.presResource = params.colocatedMvReadBuffer;
699	674	resourceParams.dwOffset = 0;
700		resourceParams.pdwCmd = (uint32_t *)&(cmd->ColocatedMv.LowerAddress);
	675	resourceParams.pdwCmd = (uint32_t *)&(cmd.ColocatedMv.LowerAddress);
701	676	resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(ColocatedMv.LowerAddress);
702	677	resourceParams.bIsWritable = false;
703	678	resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
704	679
705		cmd->ColocatedMv.PictureFields.DW0.MemoryCompressionEnable = 0;
706		cmd->ColocatedMv.PictureFields.DW0.CompressionType = 0;
707		cmd->ColocatedMv.PictureFields.DW0.MemoryObjectControlState =
	680	cmd.ColocatedMv.PictureFields.DW0.MemoryCompressionEnable = 0;
	681	cmd.ColocatedMv.PictureFields.DW0.CompressionType = 0;
	682	cmd.ColocatedMv.PictureFields.DW0.MemoryObjectControlState =
708	683	this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
709	684
710	685	MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(

713	688	&resourceParams));
714	689	}
715	690
716		if (!Mos_ResourceIsNull(params->colMvTempBuffer[0]))
717		{
718		resourceParams.presResource = params->colMvTempBuffer[0];
	691	if (!Mos_ResourceIsNull(params.colMvTempBuffer[0]))
	692	{
	693	resourceParams.presResource = params.colMvTempBuffer[0];
719	694	resourceParams.dwOffset = 0;
720		resourceParams.pdwCmd = (uint32_t *)&(cmd->ColocatedMv.LowerAddress);
	695	resourceParams.pdwCmd = (uint32_t *)&(cmd.ColocatedMv.LowerAddress);
721	696	resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(ColocatedMv.LowerAddress);
722	697	resourceParams.bIsWritable = true;
723	698	resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
724	699
725		cmd->ColocatedMv.PictureFields.DW0.MemoryCompressionEnable = 0;
726		cmd->ColocatedMv.PictureFields.DW0.CompressionType = 0;
727		cmd->ColocatedMv.PictureFields.DW0.MemoryObjectControlState =
	700	cmd.ColocatedMv.PictureFields.DW0.MemoryCompressionEnable = 0;
	701	cmd.ColocatedMv.PictureFields.DW0.CompressionType = 0;
	702	cmd.ColocatedMv.PictureFields.DW0.MemoryObjectControlState =
728	703	this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
729	704
730	705	MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(

733	708	&resourceParams));
734	709	}
735	710
736		if (params->surfaceDsStage1)
737		{
738		resourceParams.presResource = &params->surfaceDsStage1->OsResource;
739		resourceParams.dwOffset = params->surfaceDsStage1->dwOffset;
740		resourceParams.pdwCmd = (uint32_t *)&(cmd->ScaledReferenceSurfaceStage1.LowerAddress);
	711	if (params.surfaceDsStage1)
	712	{
	713	resourceParams.presResource = &params.surfaceDsStage1->OsResource;
	714	resourceParams.dwOffset = params.surfaceDsStage1->dwOffset;
	715	resourceParams.pdwCmd = (uint32_t *)&(cmd.ScaledReferenceSurfaceStage1.LowerAddress);
741	716	resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(ScaledReferenceSurfaceStage1.LowerAddress);
742	717	resourceParams.bIsWritable = true;
743	718	resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
744	719
745		auto mmcMode = params->mmcStateDsStage1;
746
747		cmd->ScaledReferenceSurfaceStage1.PictureFields.DW0.MemoryCompressionEnable = MmcEnabled(mmcMode);
748		cmd->ScaledReferenceSurfaceStage1.PictureFields.DW0.CompressionType = MmcRcEnabled(mmcMode);
749		cmd->ScaledReferenceSurfaceStage1.PictureFields.DW0.MemoryObjectControlState =
	720	auto mmcMode = params.mmcStateDsStage1;
	721
	722	cmd.ScaledReferenceSurfaceStage1.PictureFields.DW0.MemoryCompressionEnable = MmcEnabled(mmcMode);
	723	cmd.ScaledReferenceSurfaceStage1.PictureFields.DW0.CompressionType = MmcRcEnabled(mmcMode);
	724	cmd.ScaledReferenceSurfaceStage1.PictureFields.DW0.MemoryObjectControlState =
750	725	this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
751	726
752	727	MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(

755	730	&resourceParams));
756	731	}
757	732
758		if (params->surfaceDsStage2)
759		{
760		resourceParams.presResource = &params->surfaceDsStage2->OsResource;
761		resourceParams.dwOffset = params->surfaceDsStage2->dwOffset;
762		resourceParams.pdwCmd = (uint32_t *)&(cmd->ScaledReferenceSurfaceStage2.LowerAddress);
	733	if (params.surfaceDsStage2)
	734	{
	735	resourceParams.presResource = &params.surfaceDsStage2->OsResource;
	736	resourceParams.dwOffset = params.surfaceDsStage2->dwOffset;
	737	resourceParams.pdwCmd = (uint32_t *)&(cmd.ScaledReferenceSurfaceStage2.LowerAddress);
763	738	resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(ScaledReferenceSurfaceStage2.LowerAddress);
764	739	resourceParams.bIsWritable = true;
765	740	resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
766	741
767		auto mmcMode = params->mmcStateDsStage2;
768
769		cmd->ScaledReferenceSurfaceStage2.PictureFields.DW0.MemoryCompressionEnable = MmcEnabled(mmcMode);
770		cmd->ScaledReferenceSurfaceStage2.PictureFields.DW0.CompressionType = MmcRcEnabled(mmcMode);
771		cmd->ScaledReferenceSurfaceStage2.PictureFields.DW0.MemoryObjectControlState =
	742	auto mmcMode = params.mmcStateDsStage2;
	743
	744	cmd.ScaledReferenceSurfaceStage2.PictureFields.DW0.MemoryCompressionEnable = MmcEnabled(mmcMode);
	745	cmd.ScaledReferenceSurfaceStage2.PictureFields.DW0.CompressionType = MmcRcEnabled(mmcMode);
	746	cmd.ScaledReferenceSurfaceStage2.PictureFields.DW0.MemoryObjectControlState =
772	747	this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
773	748
774	749	MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(

777	752	&resourceParams));
778	753	}
779	754
780		if (!Mos_ResourceIsNull(params->pakObjCmdStreamOutBuffer))
781		{
782		resourceParams.presResource = params->pakObjCmdStreamOutBuffer;
	755	if (!Mos_ResourceIsNull(params.pakObjCmdStreamOutBuffer))
	756	{
	757	resourceParams.presResource = params.pakObjCmdStreamOutBuffer;
783	758	resourceParams.dwOffset = 0;
784		resourceParams.pdwCmd = (uint32_t *)&(cmd->VdencLcuPakObjCmdBuffer.LowerAddress);
	759	resourceParams.pdwCmd = (uint32_t *)&(cmd.VdencLcuPakObjCmdBuffer.LowerAddress);
785	760	resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(VdencLcuPakObjCmdBuffer.LowerAddress);
786	761	resourceParams.bIsWritable = true;
787	762	resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
788	763
789		cmd->VdencLcuPakObjCmdBuffer.PictureFields.DW0.MemoryCompressionEnable = 0;
790		cmd->VdencLcuPakObjCmdBuffer.PictureFields.DW0.CompressionType = 0;
791		cmd->VdencLcuPakObjCmdBuffer.PictureFields.DW0.MemoryObjectControlState =
	764	cmd.VdencLcuPakObjCmdBuffer.PictureFields.DW0.MemoryCompressionEnable = 0;
	765	cmd.VdencLcuPakObjCmdBuffer.PictureFields.DW0.CompressionType = 0;
	766	cmd.VdencLcuPakObjCmdBuffer.PictureFields.DW0.MemoryObjectControlState =
792	767	this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
793	768
794	769	MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(

797	772	&resourceParams));
798	773	}
799	774
800		if (!Mos_ResourceIsNull(params->segmentMapStreamInBuffer))
801		{
802		resourceParams.presResource = params->segmentMapStreamInBuffer;
	775	if (!Mos_ResourceIsNull(params.segmentMapStreamInBuffer))
	776	{
	777	resourceParams.presResource = params.segmentMapStreamInBuffer;
803	778	resourceParams.dwOffset = 0;
804		resourceParams.pdwCmd = (uint32_t *)&(cmd->Vp9SegmentationMapStreaminBuffer.LowerAddress);
	779	resourceParams.pdwCmd = (uint32_t *)&(cmd.Vp9SegmentationMapStreaminBuffer.LowerAddress);
805	780	resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(Vp9SegmentationMapStreaminBuffer.LowerAddress);
806	781	resourceParams.bIsWritable = true;
807	782	resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;

812	787	&resourceParams));
813	788	}
814	789
815		if (!Mos_ResourceIsNull(params->segmentMapStreamOutBuffer))
816		{
817		resourceParams.presResource = params->segmentMapStreamOutBuffer;
	790	if (!Mos_ResourceIsNull(params.segmentMapStreamOutBuffer))
	791	{
	792	resourceParams.presResource = params.segmentMapStreamOutBuffer;
818	793	resourceParams.dwOffset = 0;
819		resourceParams.pdwCmd = (uint32_t *)&(cmd->Vp9SegmentationMapStreamoutBuffer.LowerAddress);
	794	resourceParams.pdwCmd = (uint32_t *)&(cmd.Vp9SegmentationMapStreamoutBuffer.LowerAddress);
820	795	resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(Vp9SegmentationMapStreamoutBuffer.LowerAddress);
821	796	resourceParams.bIsWritable = true;
822	797	resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;

827	802	&resourceParams));
828	803	}
829	804
830		cmd->DW61.WeightsHistogramStreamoutOffset = 3 * MHW_CACHELINE_SIZE;
831
832		if (!Mos_ResourceIsNull(params->tileRowStoreBuffer))
833		{
834		resourceParams.presResource = params->tileRowStoreBuffer;
	805	cmd.DW61.WeightsHistogramStreamoutOffset = 3 * MHW_CACHELINE_SIZE;
	806
	807	if (!Mos_ResourceIsNull(params.tileRowStoreBuffer))
	808	{
	809	resourceParams.presResource = params.tileRowStoreBuffer;
835	810	resourceParams.dwOffset = 0;
836		resourceParams.pdwCmd = (uint32_t *)&(cmd->VdencTileRowStoreBuffer.LowerAddress);
	811	resourceParams.pdwCmd = (uint32_t *)&(cmd.VdencTileRowStoreBuffer.LowerAddress);
837	812	resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(VdencTileRowStoreBuffer.LowerAddress);
838	813	resourceParams.bIsWritable = true;
839	814	resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
840	815
841		cmd->VdencTileRowStoreBuffer.BufferPictureFields.DW0.MemoryObjectControlState =
	816	cmd.VdencTileRowStoreBuffer.BufferPictureFields.DW0.MemoryObjectControlState =
842	817	this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_VDENC_ROW_STORE_BUFFER_CODEC].Value;
843	818
844	819	MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(

849	824
850	825	if (this->m_vdencIpdlRowstoreCache.enabled)
851	826	{
852		cmd->IntraPredictionRowstoreBaseAddress.BufferPictureFields.DW0.CacheSelect = cmd_t::VDENC_Surface_Control_Bits_CMD::CACHE_SELECT_UNNAMED1;
853		cmd->IntraPredictionRowstoreBaseAddress.LowerAddress.DW0.Value = m_vdencIpdlRowstoreCache.dwAddress << 6;
854		}
855		else if (!Mos_ResourceIsNull(params->mfdIntraRowStoreScratchBuffer))
856		{
857		resourceParams.presResource = params->mfdIntraRowStoreScratchBuffer;
	827	cmd.IntraPredictionRowstoreBaseAddress.BufferPictureFields.DW0.CacheSelect = cmd_t::VDENC_Surface_Control_Bits_CMD::CACHE_SELECT_UNNAMED1;
	828	cmd.IntraPredictionRowstoreBaseAddress.LowerAddress.DW0.Value = m_vdencIpdlRowstoreCache.dwAddress << 6;
	829	}
	830	else if (!Mos_ResourceIsNull(params.mfdIntraRowStoreScratchBuffer))
	831	{
	832	resourceParams.presResource = params.mfdIntraRowStoreScratchBuffer;
858	833	resourceParams.dwOffset = 0;
859		resourceParams.pdwCmd = (uint32_t *)&(cmd->IntraPredictionRowstoreBaseAddress);
	834	resourceParams.pdwCmd = (uint32_t *)&(cmd.IntraPredictionRowstoreBaseAddress);
860	835	resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(IntraPredictionRowstoreBaseAddress);
861	836	resourceParams.bIsWritable = true;
862	837	resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
863	838
864		cmd->IntraPredictionRowstoreBaseAddress.BufferPictureFields.DW0.MemoryObjectControlState =
	839	cmd.IntraPredictionRowstoreBaseAddress.BufferPictureFields.DW0.MemoryObjectControlState =
865	840	m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_INTRA_ROWSTORE_SCRATCH_BUFFER_CODEC].Value;
866		cmd->IntraPredictionRowstoreBaseAddress.BufferPictureFields.DW0.MemoryCompressionEnable = 0;
867
868		MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
869		this->m_osItf,
870		this->m_currentCmdBuf,
871		&resourceParams));
872		}
873
874		if (!Mos_ResourceIsNull(params->cumulativeCuCountStreamOutBuffer))
875		{
876		resourceParams.presResource = params->cumulativeCuCountStreamOutBuffer;
	841	cmd.IntraPredictionRowstoreBaseAddress.BufferPictureFields.DW0.MemoryCompressionEnable = 0;
	842
	843	MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
	844	this->m_osItf,
	845	this->m_currentCmdBuf,
	846	&resourceParams));
	847	}
	848
	849	if (!Mos_ResourceIsNull(params.cumulativeCuCountStreamOutBuffer))
	850	{
	851	resourceParams.presResource = params.cumulativeCuCountStreamOutBuffer;
877	852	resourceParams.dwOffset = 0;
878		resourceParams.pdwCmd = (uint32_t *)&(cmd->VdencCumulativeCuCountStreamoutSurface.LowerAddress);
	853	resourceParams.pdwCmd = (uint32_t *)&(cmd.VdencCumulativeCuCountStreamoutSurface.LowerAddress);
879	854	resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(VdencCumulativeCuCountStreamoutSurface.LowerAddress);
880	855	resourceParams.bIsWritable = true;
881	856	resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;

886	861	&resourceParams));
887	862	}
888	863
889		if (!Mos_ResourceIsNull(params->colocatedMvWriteBuffer))
890		{
891		resourceParams.presResource = params->colocatedMvWriteBuffer;
	864	if (!Mos_ResourceIsNull(params.colocatedMvWriteBuffer))
	865	{
	866	resourceParams.presResource = params.colocatedMvWriteBuffer;
892	867	resourceParams.dwOffset = 0;
893		resourceParams.pdwCmd = (uint32_t *)&(cmd->ColocatedMvAvcWriteBuffer.LowerAddress);
	868	resourceParams.pdwCmd = (uint32_t *)&(cmd.ColocatedMvAvcWriteBuffer.LowerAddress);
894	869	resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(ColocatedMvAvcWriteBuffer.LowerAddress);
895	870	resourceParams.bIsWritable = true;
896	871	resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
897	872
898		cmd->ColocatedMvAvcWriteBuffer.PictureFields.DW0.MemoryCompressionEnable = 0;
899		cmd->ColocatedMvAvcWriteBuffer.PictureFields.DW0.CompressionType = 0;
900		cmd->ColocatedMvAvcWriteBuffer.PictureFields.DW0.MemoryObjectControlState =
	873	cmd.ColocatedMvAvcWriteBuffer.PictureFields.DW0.MemoryCompressionEnable = 0;
	874	cmd.ColocatedMvAvcWriteBuffer.PictureFields.DW0.CompressionType = 0;
	875	cmd.ColocatedMvAvcWriteBuffer.PictureFields.DW0.MemoryObjectControlState =
901	876	this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
902	877
903	878	MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(

909	884	return MOS_STATUS_SUCCESS;
910	885	}
911	886
912		_MHW_CMD_SET_DECL_OVERRIDE(VDENC_WEIGHTSOFFSETS_STATE)
913		{
914		_MHW_CMDSET_GETCMDPARAMS_AND_CALLBASE(VDENC_WEIGHTSOFFSETS_STATE);
915
916		#define DO_FIELDS() \
917		DO_FIELD(DW1, WeightsForwardReference0, Clip3(-128, 127, params->weightsLuma[0][0] + params->denomLuma)); \
918		DO_FIELD(DW1, OffsetForwardReference0, params->offsetsLuma[0][0]); \
919		DO_FIELD(DW1, WeightsForwardReference1, Clip3(-128, 127, params->weightsLuma[0][1] + params->denomLuma)); \
920		DO_FIELD(DW1, OffsetForwardReference1, params->offsetsLuma[0][1]); \
921		\
922		DO_FIELD(DW2, WeightsForwardReference2, Clip3(-128, 127, params->weightsLuma[0][2] + params->denomLuma)); \
923		DO_FIELD(DW2, OffsetForwardReference2, params->offsetsLuma[0][2]); \
924		DO_FIELD(DW2, WeightsBackwardReference0, Clip3(-128, 127, params->weightsLuma[1][0] + params->denomLuma)); \
925		DO_FIELD(DW2, OffsetBackwardReference0, params->offsetsLuma[1][0]); \
926		\
927		DO_FIELD(DW3, CbWeightsForwardReference0, Clip3(-128, 127, params->weightsChroma[0][0][0] + params->denomChroma)); \
928		DO_FIELD(DW3, CbOffsetForwardReference0, params->offsetsChroma[0][0][0]); \
929		DO_FIELD(DW3, CbWeightsForwardReference1, Clip3(-128, 127, params->weightsChroma[0][1][0] + params->denomChroma)); \
930		DO_FIELD(DW3, CbOffsetForwardReference1, params->offsetsChroma[0][1][0]); \
931		\
932		DO_FIELD(DW4, CbWeightsForwardReference2, Clip3(-128, 127, params->weightsChroma[0][2][0] + params->denomChroma)); \
933		DO_FIELD(DW4, CbOffsetForwardReference2, params->offsetsChroma[0][2][0]); \
934		DO_FIELD(DW4, CbWeightsBackwardReference0, Clip3(-128, 127, params->weightsChroma[1][0][0] + params->denomChroma)); \
935		DO_FIELD(DW4, CbOffsetBackwardReference0, params->offsetsChroma[1][0][0]); \
936		\
937		DO_FIELD(DW5, CrWeightsForwardReference0, Clip3(-128, 127, params->weightsChroma[0][0][1] + params->denomChroma)); \
938		DO_FIELD(DW5, CrOffsetForwardReference0, params->offsetsChroma[0][0][1]); \
939		DO_FIELD(DW5, CrWeightsForwardReference1, Clip3(-128, 127, params->weightsChroma[0][1][1] + params->denomChroma)); \
940		DO_FIELD(DW5, CrOffsetForwardReference1, params->offsetsChroma[0][1][1]); \
941		\
942		DO_FIELD(DW6, CrWeightsForwardReference2, Clip3(-128, 127, params->weightsChroma[0][2][1] + params->denomChroma)); \
943		DO_FIELD(DW6, CrOffsetForwardReference2, params->offsetsChroma[0][2][1]); \
944		DO_FIELD(DW6, CrWeightsBackwardReference0, Clip3(-128, 127, params->weightsChroma[1][0][1] + params->denomChroma)); \
945		DO_FIELD(DW6, CrOffsetBackwardReference0, params->offsetsChroma[1][0][1])
946
947		#include "mhw_hwcmd_process_cmdfields.h"
948		}
949
950		_MHW_CMD_SET_DECL_OVERRIDE(VDENC_HEVC_VP9_TILE_SLICE_STATE)
951		{
952		_MHW_CMDSET_GETCMDPARAMS_AND_CALLBASE(VDENC_HEVC_VP9_TILE_SLICE_STATE);
953
954		#define DO_FIELDS() \
955		DO_FIELD(DW3, NumParEngine, params->numPipe); \
956		DO_FIELD(DW3, TileNumber, params->tileId); \
957		DO_FIELD(DW3, TileRowStoreSelect, params->tileRowStoreSelect); \
958		DO_FIELD(DW3, Log2WeightDenomLuma, params->log2WeightDenomLuma); \
959		DO_FIELD(DW3, HevcVp9Log2WeightDenomLuma, params->hevcVp9Log2WeightDenomLuma); \
960		DO_FIELD(DW3, Log2WeightDenomChroma, params->log2WeightDenomChroma); \
961		\
962		DO_FIELD(DW4, TileStartCtbX, params->tileStartLCUX * params->ctbSize); \
963		DO_FIELD(DW4, TileStartCtbY, params->tileStartLCUY * params->ctbSize); \
964		\
965		DO_FIELD(DW5, TileWidth, (params->tileWidth >= 256 ? MOS_ALIGN_CEIL(params->tileWidth, 8) : params->tileWidth) - 1); \
966		DO_FIELD(DW5, TileHeight, (params->tileHeight >= 128 ? MOS_ALIGN_CEIL(params->tileHeight, 8) : params->tileHeight) - 1); \
967		\
968		DO_FIELD(DW6, StreaminOffsetEnable, params->tileEnable); \
969		DO_FIELD(DW6, TileStreaminOffset, params->tileStreamInOffset); \
970		\
971		DO_FIELD(DW7, RowStoreOffsetEnable, cmd->DW4.TileStartCtbY == 0 ? params->tileEnable : 0); \
972		DO_FIELD(DW7, TileRowstoreOffset, cmd->DW4.TileStartCtbY == 0 ? cmd->DW4.TileStartCtbX / 32 : 0); \
973		\
974		DO_FIELD(DW8, TileStreamoutOffsetEnable, params->tileEnable); \
975		DO_FIELD(DW8, TileStreamoutOffset, params->tileId * 19); \
976		\
977		DO_FIELD(DW9, LcuStreamOutOffsetEnable, params->tileEnable); \
978		DO_FIELD(DW9, TileLcuStreamOutOffset, params->tileLCUStreamOutOffset); \
979		\
980		DO_FIELD(DW17, CumulativeCuTileOffsetEnable, params->tileEnable); \
981		DO_FIELD(DW17, CumulativeCuTileOffset, params->cumulativeCUTileOffset); \
	887	_MHW_SETCMD_OVERRIDE_DECL(VDENC_WEIGHTSOFFSETS_STATE)
	888	{
	889	_MHW_SETCMD_CALLBASE(VDENC_WEIGHTSOFFSETS_STATE);
	890
	891	#define DO_FIELDS() \
	892	DO_FIELD(DW1, WeightsForwardReference0, Clip3(-128, 127, params.weightsLuma[0][0] + params.denomLuma)); \
	893	DO_FIELD(DW1, OffsetForwardReference0, params.offsetsLuma[0][0]); \
	894	DO_FIELD(DW1, WeightsForwardReference1, Clip3(-128, 127, params.weightsLuma[0][1] + params.denomLuma)); \
	895	DO_FIELD(DW1, OffsetForwardReference1, params.offsetsLuma[0][1]); \
	896	\
	897	DO_FIELD(DW2, WeightsForwardReference2, Clip3(-128, 127, params.weightsLuma[0][2] + params.denomLuma)); \
	898	DO_FIELD(DW2, OffsetForwardReference2, params.offsetsLuma[0][2]); \
	899	DO_FIELD(DW2, WeightsBackwardReference0, Clip3(-128, 127, params.weightsLuma[1][0] + params.denomLuma)); \
	900	DO_FIELD(DW2, OffsetBackwardReference0, params.offsetsLuma[1][0]); \
	901	\
	902	DO_FIELD(DW3, CbWeightsForwardReference0, Clip3(-128, 127, params.weightsChroma[0][0][0] + params.denomChroma)); \
	903	DO_FIELD(DW3, CbOffsetForwardReference0, params.offsetsChroma[0][0][0]); \
	904	DO_FIELD(DW3, CbWeightsForwardReference1, Clip3(-128, 127, params.weightsChroma[0][1][0] + params.denomChroma)); \
	905	DO_FIELD(DW3, CbOffsetForwardReference1, params.offsetsChroma[0][1][0]); \
	906	\
	907	DO_FIELD(DW4, CbWeightsForwardReference2, Clip3(-128, 127, params.weightsChroma[0][2][0] + params.denomChroma)); \
	908	DO_FIELD(DW4, CbOffsetForwardReference2, params.offsetsChroma[0][2][0]); \
	909	DO_FIELD(DW4, CbWeightsBackwardReference0, Clip3(-128, 127, params.weightsChroma[1][0][0] + params.denomChroma)); \
	910	DO_FIELD(DW4, CbOffsetBackwardReference0, params.offsetsChroma[1][0][0]); \
	911	\
	912	DO_FIELD(DW5, CrWeightsForwardReference0, Clip3(-128, 127, params.weightsChroma[0][0][1] + params.denomChroma)); \
	913	DO_FIELD(DW5, CrOffsetForwardReference0, params.offsetsChroma[0][0][1]); \
	914	DO_FIELD(DW5, CrWeightsForwardReference1, Clip3(-128, 127, params.weightsChroma[0][1][1] + params.denomChroma)); \
	915	DO_FIELD(DW5, CrOffsetForwardReference1, params.offsetsChroma[0][1][1]); \
	916	\
	917	DO_FIELD(DW6, CrWeightsForwardReference2, Clip3(-128, 127, params.weightsChroma[0][2][1] + params.denomChroma)); \
	918	DO_FIELD(DW6, CrOffsetForwardReference2, params.offsetsChroma[0][2][1]); \
	919	DO_FIELD(DW6, CrWeightsBackwardReference0, Clip3(-128, 127, params.weightsChroma[1][0][1] + params.denomChroma)); \
	920	DO_FIELD(DW6, CrOffsetBackwardReference0, params.offsetsChroma[1][0][1])
	921
	922	#include "mhw_hwcmd_process_cmdfields.h"
	923	}
	924
	925	_MHW_SETCMD_OVERRIDE_DECL(VDENC_HEVC_VP9_TILE_SLICE_STATE)
	926	{
	927	_MHW_SETCMD_CALLBASE(VDENC_HEVC_VP9_TILE_SLICE_STATE);
	928
	929	#define DO_FIELDS() \
	930	DO_FIELD(DW3, NumParEngine, params.numPipe); \
	931	DO_FIELD(DW3, TileNumber, params.tileId); \
	932	DO_FIELD(DW3, TileRowStoreSelect, params.tileRowStoreSelect); \
	933	DO_FIELD(DW3, Log2WeightDenomLuma, params.log2WeightDenomLuma); \
	934	DO_FIELD(DW3, HevcVp9Log2WeightDenomLuma, params.hevcVp9Log2WeightDenomLuma); \
	935	DO_FIELD(DW3, Log2WeightDenomChroma, params.log2WeightDenomChroma); \
	936	\
	937	DO_FIELD(DW4, TileStartCtbX, params.tileStartLCUX *params.ctbSize); \
	938	DO_FIELD(DW4, TileStartCtbY, params.tileStartLCUY *params.ctbSize); \
	939	\
	940	DO_FIELD(DW5, TileWidth, (params.tileWidth >= 256 ? MOS_ALIGN_CEIL(params.tileWidth, 8) : params.tileWidth) - 1); \
	941	DO_FIELD(DW5, TileHeight, (params.tileHeight >= 128 ? MOS_ALIGN_CEIL(params.tileHeight, 8) : params.tileHeight) - 1); \
	942	\
	943	DO_FIELD(DW6, StreaminOffsetEnable, params.tileEnable); \
	944	DO_FIELD(DW6, TileStreaminOffset, params.tileStreamInOffset); \
	945	\
	946	DO_FIELD(DW7, RowStoreOffsetEnable, cmd.DW4.TileStartCtbY == 0 ? params.tileEnable : 0); \
	947	DO_FIELD(DW7, TileRowstoreOffset, cmd.DW4.TileStartCtbY == 0 ? cmd.DW4.TileStartCtbX / 32 : 0); \
	948	\
	949	DO_FIELD(DW8, TileStreamoutOffsetEnable, params.tileEnable); \
	950	DO_FIELD(DW8, TileStreamoutOffset, params.tileId * 19); \
	951	\
	952	DO_FIELD(DW9, LcuStreamOutOffsetEnable, params.tileEnable); \
	953	DO_FIELD(DW9, TileLcuStreamOutOffset, params.tileLCUStreamOutOffset); \
	954	\
	955	DO_FIELD(DW17, CumulativeCuTileOffsetEnable, params.tileEnable); \
	956	DO_FIELD(DW17, CumulativeCuTileOffset, params.cumulativeCUTileOffset); \
982	957	__MHW_VDBOX_VDENC_WRAPPER_EXT(VDENC_HEVC_VP9_TILE_SLICE_STATE_IMPL_EXT)
983	958
984	959	#include "mhw_hwcmd_process_cmdfields.h"
985	960	}
986	961
987		_MHW_CMD_SET_DECL_OVERRIDE(VDENC_WALKER_STATE)
988		{
989		_MHW_CMDSET_GETCMDPARAMS_AND_CALLBASE(VDENC_WALKER_STATE);
990
991		#define DO_FIELDS() \
992		DO_FIELD(DW1, FirstSuperSlice, params->firstSuperSlice); \
993		DO_FIELD(DW1, MbLcuStartXPosition, params->tileSliceStartLcuMbX); \
994		DO_FIELD(DW1, MbLcuStartYPosition, params->tileSliceStartLcuMbY); \
995		\
996		DO_FIELD(DW2, NextsliceMbLcuStartXPosition, params->nextTileSliceStartLcuMbX); \
997		DO_FIELD(DW2, NextsliceMbStartYPosition, params->nextTileSliceStartLcuMbY)
998
999		#include "mhw_hwcmd_process_cmdfields.h"
1000		}
1001
1002		_MHW_CMD_SET_DECL_OVERRIDE(VD_PIPELINE_FLUSH)
1003		{
1004		_MHW_CMDSET_GETCMDPARAMS_AND_CALLBASE(VD_PIPELINE_FLUSH);
1005
1006		#define DO_FIELDS() \
1007		DO_FIELD(DW1, HevcPipelineDone, params->waitDoneHEVC); \
1008		DO_FIELD(DW1, VdencPipelineDone, params->waitDoneVDENC); \
1009		DO_FIELD(DW1, MflPipelineDone, params->waitDoneMFL); \
1010		DO_FIELD(DW1, MfxPipelineDone, params->waitDoneMFX); \
1011		DO_FIELD(DW1, VdCommandMessageParserDone, params->waitDoneVDCmdMsgParser); \
1012		DO_FIELD(DW1, HevcPipelineCommandFlush, params->flushHEVC); \
1013		DO_FIELD(DW1, VdencPipelineCommandFlush, params->flushVDENC); \
1014		DO_FIELD(DW1, MflPipelineCommandFlush, params->flushMFL); \
1015		DO_FIELD(DW1, MfxPipelineCommandFlush, params->flushMFX); \
	962	_MHW_SETCMD_OVERRIDE_DECL(VDENC_WALKER_STATE)
	963	{
	964	_MHW_SETCMD_CALLBASE(VDENC_WALKER_STATE);
	965
	966	#define DO_FIELDS() \
	967	DO_FIELD(DW1, FirstSuperSlice, params.firstSuperSlice); \
	968	DO_FIELD(DW1, MbLcuStartXPosition, params.tileSliceStartLcuMbX); \
	969	DO_FIELD(DW1, MbLcuStartYPosition, params.tileSliceStartLcuMbY); \
	970	\
	971	DO_FIELD(DW2, NextsliceMbLcuStartXPosition, params.nextTileSliceStartLcuMbX); \
	972	DO_FIELD(DW2, NextsliceMbStartYPosition, params.nextTileSliceStartLcuMbY)
	973
	974	#include "mhw_hwcmd_process_cmdfields.h"
	975	}
	976
	977	_MHW_SETCMD_OVERRIDE_DECL(VD_PIPELINE_FLUSH)
	978	{
	979	_MHW_SETCMD_CALLBASE(VD_PIPELINE_FLUSH);
	980
	981	#define DO_FIELDS() \
	982	DO_FIELD(DW1, HevcPipelineDone, params.waitDoneHEVC); \
	983	DO_FIELD(DW1, VdencPipelineDone, params.waitDoneVDENC); \
	984	DO_FIELD(DW1, MflPipelineDone, params.waitDoneMFL); \
	985	DO_FIELD(DW1, MfxPipelineDone, params.waitDoneMFX); \
	986	DO_FIELD(DW1, VdCommandMessageParserDone, params.waitDoneVDCmdMsgParser); \
	987	DO_FIELD(DW1, HevcPipelineCommandFlush, params.flushHEVC); \
	988	DO_FIELD(DW1, VdencPipelineCommandFlush, params.flushVDENC); \
	989	DO_FIELD(DW1, MflPipelineCommandFlush, params.flushMFL); \
	990	DO_FIELD(DW1, MfxPipelineCommandFlush, params.flushMFX); \
1016	991	__MHW_VDBOX_VDENC_WRAPPER_EXT(VD_PIPELINE_FLUSH_IMPL_EXT)
1017	992
1018	993	#include "mhw_hwcmd_process_cmdfields.h"
1019	994	}
1020	995
1021		_MHW_CMD_SET_DECL_OVERRIDE(VDENC_CMD1)
1022		{
1023		_MHW_CMDSET_GETCMDPARAMS_AND_CALLBASE(VDENC_CMD1);
	996	_MHW_SETCMD_OVERRIDE_DECL(VDENC_CMD1)
	997	{
	998	_MHW_SETCMD_CALLBASE(VDENC_CMD1);
1024	999
1025	1000	#define DO_FIELDS() __MHW_VDBOX_VDENC_WRAPPER_EXT(VDENC_CMD1_IMPL_EXT)
1026	1001
1027	1002	#include "mhw_hwcmd_process_cmdfields.h"
1028	1003	}
1029	1004
1030		_MHW_CMD_SET_DECL_OVERRIDE(VDENC_CMD2)
1031		{
1032		_MHW_CMDSET_GETCMDPARAMS_AND_CALLBASE(VDENC_CMD2);
	1005	_MHW_SETCMD_OVERRIDE_DECL(VDENC_CMD2)
	1006	{
	1007	_MHW_SETCMD_CALLBASE(VDENC_CMD2);
1033	1008
1034	1009	#define DO_FIELDS() __MHW_VDBOX_VDENC_WRAPPER_EXT(VDENC_CMD2_IMPL_EXT)
1035	1010
1036	1011	#include "mhw_hwcmd_process_cmdfields.h"
1037	1012	}
1038	1013
1039		_MHW_CMD_SET_DECL_OVERRIDE(VDENC_CMD3)
1040		{
1041		_MHW_CMDSET_GETCMDPARAMS_AND_CALLBASE(VDENC_CMD3);
	1014	_MHW_SETCMD_OVERRIDE_DECL(VDENC_CMD3)
	1015	{
	1016	_MHW_SETCMD_CALLBASE(VDENC_CMD3);
1042	1017
1043	1018	#define DO_FIELDS() __MHW_VDBOX_VDENC_WRAPPER_EXT(VDENC_CMD3_IMPL_EXT)
1044	1019
1045	1020	#include "mhw_hwcmd_process_cmdfields.h"
1046	1021	}
1047	1022
1048		_MHW_CMD_SET_DECL_OVERRIDE(VDENC_CMD4)
1049		{
1050		_MHW_CMDSET_GETCMDPARAMS_AND_CALLBASE(VDENC_CMD4);
	1023	_MHW_SETCMD_OVERRIDE_DECL(VDENC_CMD4)
	1024	{
	1025	_MHW_SETCMD_CALLBASE(VDENC_CMD4);
1051	1026
1052	1027	#define DO_FIELDS() __MHW_VDBOX_VDENC_WRAPPER_EXT(VDENC_CMD4_IMPL_EXT)
1053	1028
1054	1029	#include "mhw_hwcmd_process_cmdfields.h"
1055	1030	}
1056	1031
1057		_MHW_CMD_SET_DECL_OVERRIDE(VDENC_CMD5)
1058		{
1059		_MHW_CMDSET_GETCMDPARAMS_AND_CALLBASE(VDENC_CMD5);
	1032	_MHW_SETCMD_OVERRIDE_DECL(VDENC_CMD5)
	1033	{
	1034	_MHW_SETCMD_CALLBASE(VDENC_CMD5);
1060	1035
1061	1036	#define DO_FIELDS() __MHW_VDBOX_VDENC_WRAPPER_EXT(VDENC_CMD5_IMPL_EXT)
1062	1037

+23

-10

media_softlet/agnostic/common/hw/vdbox/mhw_vdbox_vdenc_itf.h less more

0	0	/*
1		* Copyright (c) 2020, Intel Corporation
	1	* Copyright (c) 2020-2021, Intel Corporation
2	2	*
3	3	* Permission is hereby granted, free of charge, to any person obtaining a
4	4	* copy of this software and associated documentation files (the "Software"),

39	39	class Itf
40	40	{
41	41	public:
	42	class ParSetting
	43	{
	44	public:
	45	virtual ~ParSetting() = default;
	46
	47	_MHW_SETPAR_DEF(VDENC_CONTROL_STATE);
	48	_MHW_SETPAR_DEF(VDENC_PIPE_MODE_SELECT);
	49	_MHW_SETPAR_DEF(VDENC_SRC_SURFACE_STATE);
	50	_MHW_SETPAR_DEF(VDENC_REF_SURFACE_STATE);
	51	_MHW_SETPAR_DEF(VDENC_DS_REF_SURFACE_STATE);
	52	_MHW_SETPAR_DEF(VDENC_PIPE_BUF_ADDR_STATE);
	53	_MHW_SETPAR_DEF(VDENC_WEIGHTSOFFSETS_STATE);
	54	_MHW_SETPAR_DEF(VDENC_HEVC_VP9_TILE_SLICE_STATE);
	55	_MHW_SETPAR_DEF(VDENC_WALKER_STATE);
	56	_MHW_SETPAR_DEF(VD_PIPELINE_FLUSH);
	57	_MHW_SETPAR_DEF(VDENC_CMD1);
	58	_MHW_SETPAR_DEF(VDENC_CMD2);
	59	_MHW_SETPAR_DEF(VDENC_CMD3);
	60	_MHW_SETPAR_DEF(VDENC_CMD4);
	61	_MHW_SETPAR_DEF(VDENC_CMD5);
	62	};
	63
42	64	virtual ~Itf() = default;
43	65
44	66	virtual MOS_STATUS EnableVdencRowstoreCacheIfSupported(uint32_t address) = 0;

81	103	} // namespace vdbox
82	104	} // namespace mhw
83	105
84		#define MHW_VDBOX_VDENC_GET_CMD_PAR(CMD, reset) m_vdencItf->__MHW_CMD_PAR_GET_F(CMD)(reset)
85
86		#define MHW_VDBOX_VDENC_GET_CMD_SIZE(CMD) m_vdencItf->__MHW_CMD_BYTE_SIZE_GET_F(CMD)()
87
88		#define MHW_VDBOX_VDENC_ADD_CMD(CMD, ...) MHW_CHK_STATUS_RETURN(m_vdencItf->__MHW_CMD_ADD_F(CMD)(__VA_ARGS__))
89
90		#define MHW_VDBOX_VDENC_SETPARAMS_AND_ADDCMD(CMD, ...) \
91		_MHW_SETPARAMS_AND_ADDCMD(CMD, mhw::vdbox::vdenc::CmdPar, MHW_VDBOX_VDENC_GET_CMD_PAR, MHW_VDBOX_VDENC_ADD_CMD, __VA_ARGS__)
92
93	106	#endif // __MHW_VDBOX_VDENC_ITF_H__

-38

media_softlet/agnostic/common/shared/features/media_feature_manager.h less more

90	90	} \
91	91	}
92	92
93		//!
94		//! \def LOOP_FEATURE_INTERFACE_RETURN(_interfaceClass, _interface, ...)
95		//! Run _featureInterface for all features
96		//!
97		#define LOOP_FEATURE_INTERFACE_RETURN(_interfaceClass, _interface, ...) \
98		{ \
99		if (m_featureManager) \
100		{ \
101		for (auto feature : *m_featureManager) \
102		{ \
103		auto itf = dynamic_cast<_interfaceClass *>(feature); \
104		if (itf) \
105		{ \
106		MHW_CHK_STATUS_RETURN(itf->_interface(__VA_ARGS__)); \
107		} \
108		} \
109		} \
110		}
111
112		//!
113		//! \def LOOP_FEATURE_INTERFACE_NO_RETURN(_interfaceClass, _interface, ...)
114		//! Run _featureInterface for all features
115		//!
116		#define LOOP_FEATURE_INTERFACE_NO_RETURN(_interfaceClass, _interface, ...) \
117		{ \
118		if (m_featureManager) \
119		{ \
120		for (auto feature : *m_featureManager) \
121		{ \
122		auto itf = dynamic_cast<_interfaceClass *>(feature); \
123		if (itf) \
124		{ \
125		itf->_interface(__VA_ARGS__); \
126		} \
127		} \
128		} \
129		}
130
131	93	class MediaFeature;
132	94
133	95	enum class LIST_TYPE

+24

-0

media_softlet/agnostic/common/shared/packet/media_packet.h less more

32	32	#include "mhw_mi.h"
33	33	#include "media_status_report.h"
34	34
	35	#define SETPAR_AND_ADDCMD(CMD, itf, ...) \
	36	{ \
	37	auto &par = itf->MHW_GETPAR_F(CMD)(); \
	38	par = {}; \
	39	using setting_t = typename std::remove_reference<decltype(*itf)>::type::ParSetting; \
	40	auto p = dynamic_cast<const setting_t *>(this); \
	41	if (p) \
	42	{ \
	43	MHW_CHK_STATUS_RETURN(p->MHW_SETPAR_F(CMD)(par)); \
	44	} \
	45	if (m_featureManager) \
	46	{ \
	47	for (auto feature : *m_featureManager) \
	48	{ \
	49	p = dynamic_cast<const setting_t *>(feature); \
	50	if (p) \
	51	{ \
	52	MHW_CHK_STATUS_RETURN(p->MHW_SETPAR_F(CMD)(par)); \
	53	} \
	54	} \
	55	} \
	56	MHW_CHK_STATUS_RETURN(itf->MHW_ADDCMD_F(CMD)(__VA_ARGS__)); \
	57	}
	58
35	59	namespace CMRT_UMD
36	60	{
37	61	class CmTask;

+10

-1

media_softlet/agnostic/common/vp/hal/utils/vp_dumper.cpp less more

1037	1037	// which is designed to avoid splitting two cache lines
1038	1038	if (pSurface->Format == Format_R8G8B8)
1039	1039	{
1040		int dummyBytesPerLine = (int)(ceil)((planes[j].dwWidth) / 63.0);
	1040	int dummyBytesPerLine = planes[j].dwWidth / 63;
	1041	int resPixel = planes[j].dwWidth - 63 * dummyBytesPerLine;
1041	1042	for (int p = 0; p < dummyBytesPerLine; p++)
1042	1043	{
1043	1044	MOS_SecureMemcpy(

1045	1046	63,
1046	1047	&pTmpSrc[p * 64],
1047	1048	63);
	1049	}
	1050	if (resPixel > 0)
	1051	{
	1052	MOS_SecureMemcpy(
	1053	&pTmpDst[dummyBytesPerLine * 63],
	1054	resPixel,
	1055	&pTmpSrc[dummyBytesPerLine * 64],
	1056	resPixel);
1048	1057	}
1049	1058	}
1050	1059	else