Debian Codegraph @

media_softlet/agnostic/common/codec/hal/enc/shared/features/encode_basic_feature.cpp

raw
1 /*
2 * Copyright (c) 2018-2025, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file encode_basic_feature.cpp
24 //! \brief Defines the common interface for encode basic feature
25 //!
26
27 #include "encode_basic_feature.h"
28 #include "encode_utils.h"
29 #include "encode_allocator.h"
30 #include "mos_interface.h"
31 #include "codec_def_common_encode.h"
32 #include "codec_def_encode_vp9.h"
33 #include "codec_def_encode_hevc.h"
34
35 namespace encode
36 {
37 EncodeBasicFeature::EncodeBasicFeature(
38 EncodeAllocator *allocator,
39 CodechalHwInterfaceNext *hwInterface,
40 TrackedBuffer *trackedBuf,
41 RecycleResource *recycleBuf):
42 MediaFeature(hwInterface ? hwInterface->GetOsInterface() : nullptr),
43 m_trackedBuf(trackedBuf),
44 m_recycleBuf(recycleBuf),
45 m_allocator(allocator)
46 {
47 if(hwInterface)
48 {
49 m_osInterface = hwInterface->GetOsInterface();
50 }
51
52 }
53
54 MOS_STATUS EncodeBasicFeature::Init(void *setting)
55 {
56 ENCODE_FUNC_CALL();
57 ENCODE_CHK_NULL_RETURN(setting);
58
59 CodechalSetting *codecSettings = (CodechalSetting*)setting;
60 m_standard = codecSettings->standard;
61 m_mode = codecSettings->mode;
62 m_codecFunction = codecSettings->codecFunction;
63
64 m_is10Bit = codecSettings->lumaChromaDepth == CODECHAL_LUMA_CHROMA_DEPTH_10_BITS ? true : false;
65 m_chromaFormat = codecSettings->chromaFormat;
66 m_bitDepth = codecSettings->lumaChromaDepth == CODECHAL_LUMA_CHROMA_DEPTH_8_BITS ?
67 8 : (codecSettings->lumaChromaDepth == CODECHAL_LUMA_CHROMA_DEPTH_10_BITS ? 10 : 12);
68 m_standard = codecSettings->standard;
69
70 m_oriFrameWidth = codecSettings->width;
71 m_oriFrameHeight = codecSettings->height;
72 m_picWidthInMb = (uint16_t)CODECHAL_GET_WIDTH_IN_MACROBLOCKS(m_oriFrameWidth);
73 m_picHeightInMb = (uint16_t)CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_oriFrameHeight);
74 m_frameWidth = m_picWidthInMb * CODECHAL_MACROBLOCK_WIDTH;
75 m_frameHeight = m_picHeightInMb * CODECHAL_MACROBLOCK_HEIGHT;
76
77 m_currOriginalPic.PicFlags = PICTURE_INVALID;
78 m_currOriginalPic.FrameIdx = 0;
79 m_currOriginalPic.PicEntry = 0;
80
81 //RCPanic settings
82 MediaUserSetting::Value outValue;
83 ReadUserSetting(
84 m_userSettingPtr,
85 outValue,
86 "RC Panic Mode",
87 MediaUserSetting::Group::Sequence);
88 m_panicEnable = outValue.Get<bool>();
89
90 ReadUserSetting(
91 m_userSettingPtr,
92 outValue,
93 "HEVC Encode Enable HW Stitch",
94 MediaUserSetting::Group::Sequence);
95 m_enableTileStitchByHW = outValue.Get<bool>();
96
97
98 if (m_osInterface != nullptr)
99 {
100 //If Wa_16025947269 is set, disable chroma prefetch
101 MEDIA_WA_TABLE *waTable = m_osInterface->pfnGetWaTable(m_osInterface);
102 m_chromaPrefetchDisable = (waTable != nullptr) ? MEDIA_IS_WA(waTable, Wa_16025947269) : false;
103
104 //If user setting is set, set m_chromaPrefetchDisable as the user setting value.
105 #if (_DEBUG || _RELEASE_INTERNAL)
106 bool chromaPrefetchDisable = 0;
107 auto status = ReadUserSettingForDebug(
108 m_userSettingPtr,
109 chromaPrefetchDisable,
110 "ChromaPrefetchDisable",
111 MediaUserSetting::Group::Sequence);
112 if (status == MOS_STATUS_SUCCESS)
113 {
114 m_chromaPrefetchDisable = chromaPrefetchDisable;
115 }
116 #endif
117 }
118
119 return MOS_STATUS_SUCCESS;
120 }
121
122 MOS_STATUS EncodeBasicFeature::Update(void *params)
123 {
124 ENCODE_FUNC_CALL();
125 ENCODE_CHK_NULL_RETURN(params);
126 ENCODE_CHK_NULL_RETURN(m_allocator);
127
128 EncoderParams* encodeParams = (EncoderParams*)params;
129
130 m_newSeq = encodeParams->bNewSeq; // used by all except JPEG
131 m_mbDataBufferSize = encodeParams->dwMbDataBufferSize;// used by all except JPEG
132 m_newVuiData = encodeParams->bNewVuiData; // used by AVC and MPEG2
133 m_picQuant = encodeParams->bPicQuant ; // used by AVC and MPEG2
134 m_newQmatrixData = encodeParams->bNewQmatrixData; // used by AVC and MPEG2
135 m_numSlices = encodeParams->dwNumSlices; // used by all except VP9
136 m_slcData = (PCODEC_ENCODER_SLCDATA)(encodeParams->pSlcHeaderData);// used by AVC, MPEG2, and HEVC
137
138 ENCODE_CHK_NULL_RETURN(encodeParams->psRawSurface);
139 m_rawSurface = *(encodeParams->psRawSurface); // used by all
140 m_allocator->GetSurfaceInfo(&m_rawSurface);
141 ENCODE_CHK_STATUS_RETURN(m_allocator->UpdateResourceUsageType(&m_rawSurface.OsResource, MOS_HW_RESOURCE_USAGE_ENCODE_INPUT_RAW));
142
143 ENCODE_CHK_NULL_RETURN(encodeParams->presBitstreamBuffer);
144 m_resBitstreamBuffer = *(encodeParams->presBitstreamBuffer); // used by all
145
146 m_resMetadataBuffer = (encodeParams->presMetadataBuffer);
147 m_metaDataOffset = encodeParams->metaDataOffset;
148
149 m_laDataBufferEnabled = encodeParams->bLaDataBufferEnabled;
150 if (encodeParams->bLaDataBufferEnabled)
151 {
152 m_LaDataBuffer = (encodeParams->presLaDataBuffer);
153 }
154
155 // Get resource details of the bitstream resource
156 MOS_SURFACE bsSurface;
157 MOS_ZeroMemory(&bsSurface, sizeof(bsSurface));
158 bsSurface.OsResource = m_resBitstreamBuffer;
159 m_allocator->GetSurfaceInfo(&bsSurface);
160 ENCODE_CHK_STATUS_RETURN(m_allocator->UpdateResourceUsageType(&m_resBitstreamBuffer, MOS_HW_RESOURCE_USAGE_ENCODE_OUTPUT_BITSTREAM));
161
162 m_bitstreamSize = encodeParams->dwBitstreamSize = bsSurface.dwHeight * bsSurface.dwWidth;
163
164 if (Mos_ResourceIsNull(&m_rawSurface.OsResource))
165 {
166 ENCODE_ASSERTMESSAGE("Raw surface is nullptr!");
167 return MOS_STATUS_INVALID_PARAMETER;
168 }
169
170 #if (_DEBUG || _RELEASE_INTERNAL)
171 ReportUserSettingForDebug(
172 m_userSettingPtr,
173 "Encode Raw Surface Tile",
174 m_rawSurface.TileType,
175 MediaUserSetting::Group::Sequence);
176 #endif
177
178 m_rawSurfaceToEnc =
179 m_rawSurfaceToPak = &m_rawSurface;
180
181 if (encodeParams->psReconSurface != nullptr)
182 {
183 m_reconSurface = *(encodeParams->psReconSurface); // used by all except JPEG
184 ENCODE_CHK_STATUS_RETURN(m_allocator->GetSurfaceInfo(&m_reconSurface));
185 ENCODE_CHK_STATUS_RETURN(m_allocator->UpdateResourceUsageType(&m_reconSurface.OsResource, MOS_HW_RESOURCE_USAGE_ENCODE_OUTPUT_PICTURE));
186 }
187
188 if (encodeParams->pBSBuffer != nullptr)
189 {
190 m_bsBuffer = *(encodeParams->pBSBuffer); // used by all except VP9
191 }
192
193 m_mbDisableSkipMapEnabled = encodeParams->bMbDisableSkipMapEnabled;
194 m_mbQpDataEnabled = encodeParams->bMbQpDataEnabled;
195
196 if (encodeParams->bMbQpDataEnabled && encodeParams->psMbQpDataSurface != nullptr)
197 {
198 m_mbQpDataSurface = *(encodeParams->psMbQpDataSurface);
199 ENCODE_CHK_STATUS_RETURN(m_allocator->GetSurfaceInfo(&m_mbQpDataSurface));
200 }
201
202 if (encodeParams->psMbDisableSkipMapSurface != nullptr)
203 {
204 m_mbDisableSkipMapSurface = *(encodeParams->psMbDisableSkipMapSurface);
205 ENCODE_CHK_STATUS_RETURN(m_allocator->GetSurfaceInfo(&m_mbDisableSkipMapSurface));
206 }
207
208 m_slcData =
209 (PCODEC_ENCODER_SLCDATA)(encodeParams->pSlcHeaderData); // used by AVC, MPEG2, and HEVC
210
211 m_newSeqHeader = encodeParams->newSeqHeader;
212 m_newPpsHeader = encodeParams->newPpsHeader;
213
214 if (CodecHalUsesVideoEngine(m_codecFunction))
215 {
216 //UpdateBitstreamSize()
217 // Get resource details of the bitstream resource
218 MOS_SURFACE details;
219 MOS_ZeroMemory(&details, sizeof(details));
220 details.Format = Format_Invalid;
221 ENCODE_CHK_STATUS_RETURN(
222 m_osInterface->pfnGetResourceInfo(m_osInterface, &m_resBitstreamBuffer, &details));
223 m_bitstreamSize = details.dwHeight * details.dwWidth;
224 }
225
226 // check output Chroma format
227 ENCODE_CHK_STATUS_RETURN(UpdateFormat(params));
228
229 m_predicationNotEqualZero = encodeParams->m_predicationNotEqualZero;
230 m_predicationEnabled = encodeParams->m_predicationEnabled;
231 m_setMarkerEnabled = encodeParams->m_setMarkerEnabled;
232 m_predicationResOffset = encodeParams->m_predicationResOffset;
233 m_presPredication = encodeParams->m_presPredication;
234 m_tempPredicationBuffer = encodeParams->m_tempPredicationBuffer;
235
236 if (m_predicationBuffer == nullptr && m_predicationEnabled)
237 {
238 // initiate allocation parameters and lock flags
239 MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear;
240 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
241 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
242 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
243 allocParamsForBufferLinear.Format = Format_Buffer;
244 allocParamsForBufferLinear.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_CACHE;
245 allocParamsForBufferLinear.dwBytes = sizeof(uint32_t);
246 allocParamsForBufferLinear.pBufName = "PredicationBuffer";
247 m_predicationBuffer = m_allocator->AllocateResource(allocParamsForBufferLinear, false);
248 }
249
250 return MOS_STATUS_SUCCESS;
251 }
252
253 MOS_STATUS EncodeBasicFeature::UpdateFormat(void *params)
254 {
255 ENCODE_FUNC_CALL();
256 ENCODE_CHK_NULL_RETURN(params);
257 EncoderParams* encodeParams = (EncoderParams*)params;
258
259 PCODEC_VP9_ENCODE_SEQUENCE_PARAMS vp9SeqParams = nullptr;
260 PCODEC_HEVC_ENCODE_SEQUENCE_PARAMS hevcSeqParams = nullptr;
261
262 // check output Chroma format
263 switch (m_standard)
264 {
265 case CODECHAL_HEVC:
266 hevcSeqParams = static_cast<PCODEC_HEVC_ENCODE_SEQUENCE_PARAMS>(encodeParams->pSeqParams);
267 ENCODE_CHK_NULL_RETURN(hevcSeqParams);
268 m_outputChromaFormat = hevcSeqParams->chroma_format_idc;
269 break;
270
271 case CODECHAL_VP9:
272 // check output Chroma format
273 vp9SeqParams = static_cast<PCODEC_VP9_ENCODE_SEQUENCE_PARAMS>(encodeParams->pSeqParams);
274 if (VP9_ENCODED_CHROMA_FORMAT_YUV420 == vp9SeqParams->SeqFlags.fields.EncodedFormat)
275 {
276 m_outputChromaFormat = HCP_CHROMA_FORMAT_YUV420;
277 }
278 else if (VP9_ENCODED_CHROMA_FORMAT_YUV422 == vp9SeqParams->SeqFlags.fields.EncodedFormat)
279 {
280 m_outputChromaFormat = HCP_CHROMA_FORMAT_YUV422;
281 }
282 else if (VP9_ENCODED_CHROMA_FORMAT_YUV444 == vp9SeqParams->SeqFlags.fields.EncodedFormat)
283 {
284 m_outputChromaFormat = HCP_CHROMA_FORMAT_YUV444;
285 }
286 else
287 {
288 ENCODE_ASSERTMESSAGE("Invalid output chromat format in VP9 Seq param!");
289 return MOS_STATUS_INVALID_PARAMETER;
290 }
291 break;
292
293 default:
294 break;
295 }
296
297 if (m_outputChromaFormat == HCP_CHROMA_FORMAT_YUV422)
298 {
299 if (Format_YUY2 != m_reconSurface.Format && Format_Y216 != m_reconSurface.Format)
300 {
301 ENCODE_ASSERTMESSAGE("Recon surface format is not correct!");
302 return MOS_STATUS_INVALID_PARAMETER;
303 }
304 else if (m_reconSurface.dwHeight < m_oriFrameHeight * 2 ||
305 m_reconSurface.dwWidth < m_oriFrameWidth / 2)
306 {
307 ENCODE_ASSERTMESSAGE("Recon surface allocation size is not correct!");
308 return MOS_STATUS_INVALID_PARAMETER;
309 }
310 }
311 return MOS_STATUS_SUCCESS;
312 }
313
314 MOS_STATUS EncodeBasicFeature::UpdateTrackedBufferParameters()
315 {
316 ENCODE_CHK_NULL_RETURN(m_trackedBuf);
317
318 MOS_ALLOC_GFXRES_PARAMS allocParamsForLinear;
319 MOS_ZeroMemory(&allocParamsForLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
320 allocParamsForLinear.Type = MOS_GFXRES_BUFFER;
321 allocParamsForLinear.TileType = MOS_TILE_LINEAR;
322 allocParamsForLinear.Format = Format_Buffer;
323
324 MOS_ALLOC_GFXRES_PARAMS allocParamsForBuffer2D;
325 MOS_ZeroMemory(&allocParamsForBuffer2D, sizeof(MOS_ALLOC_GFXRES_PARAMS));
326 allocParamsForBuffer2D.Type = MOS_GFXRES_2D;
327 allocParamsForBuffer2D.TileType = MOS_TILE_Y;
328 allocParamsForBuffer2D.Format = Format_NV12;
329 allocParamsForBuffer2D.Flags.bNotLockable = allocParamsForLinear.Flags.bNotLockable
330 = ((m_standard == CODECHAL_AV1) && !m_lockableResource);
331
332 if (m_mbCodeSize > 0 && !m_isMbCodeRegistered)
333 {
334 allocParamsForLinear.pBufName = "mbCodeBuffer";
335 // Must reserve at least 8 cachelines after MI_BATCH_BUFFER_END_CMD since HW prefetch max 8 cachelines from BB everytime
336 // + 8 * CODECHAL_CACHELINE_SIZE is inherient from legacy code
337 allocParamsForLinear.dwBytes = m_mbCodeSize + 8 * CODECHAL_CACHELINE_SIZE;
338 allocParamsForLinear.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_NOCACHE;
339 ENCODE_CHK_STATUS_RETURN(m_trackedBuf->RegisterParam(encode::BufferType::mbCodedBuffer, allocParamsForLinear));
340 }
341
342 if (m_mvDataSize > 0)
343 {
344 allocParamsForLinear.pBufName = "mvDataBuffer";
345 allocParamsForLinear.dwBytes = m_mvDataSize;
346 ENCODE_CHK_STATUS_RETURN(m_trackedBuf->RegisterParam(encode::BufferType::mvDataBuffer, allocParamsForLinear));
347 }
348
349 if (m_downscaledWidth4x > 0 && m_downscaledHeight4x > 0)
350 {
351 allocParamsForBuffer2D.dwWidth = m_downscaledWidth4x;
352 allocParamsForBuffer2D.dwHeight = m_downscaledHeight4x;
353 allocParamsForBuffer2D.pBufName = "4xDSSurface";
354 allocParamsForBuffer2D.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_CACHE;
355 ENCODE_CHK_STATUS_RETURN(m_trackedBuf->RegisterParam(encode::BufferType::ds4xSurface, allocParamsForBuffer2D));
356
357 allocParamsForBuffer2D.dwWidth = m_downscaledWidth4x >> 1;
358 allocParamsForBuffer2D.dwHeight = MOS_ALIGN_CEIL(m_downscaledHeight4x >> 1, MOS_YTILE_H_ALIGNMENT) << 1;
359 allocParamsForBuffer2D.pBufName = "8xDSSurface";
360 allocParamsForBuffer2D.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_CACHE;
361 ENCODE_CHK_STATUS_RETURN(m_trackedBuf->RegisterParam(encode::BufferType::ds8xSurface, allocParamsForBuffer2D));
362 }
363
364 return MOS_STATUS_SUCCESS;
365 }
366
367 MOS_STATUS EncodeBasicFeature::Reset(CODEC_REF_LIST *refList)
368 {
369 ENCODE_CHK_NULL_RETURN(refList);
370 ENCODE_CHK_NULL_RETURN(m_trackedBuf);
371
372 m_trackedBuf->Release(refList);
373 return MOS_STATUS_SUCCESS;
374 }
375 } // namespace encode