Debian Codegraph @

media_softlet/agnostic/common/codec/hal/enc/shared/packet/encode_preenc_packet.cpp

raw
1 /*
2 * Copyright (c) 2020-2022, 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_preenc_packet.cpp
24 //! \brief Defines the interface for preenc packet
25 //!
26
27 #include "encode_preenc_packet.h"
28 #include "encode_status_report_defs.h"
29 #include "media_perf_profiler.h"
30 #include "encode_utils.h"
31 #include "encode_status_report_defs.h"
32 #include "mos_solo_generic.h"
33 #include "encode_status_report_defs.h"
34 #include "codec_hw_next.h"
35
36 using namespace mhw::vdbox;
37
38 namespace encode
39 {
40 MOS_STATUS EncodePreEncPacket::Init()
41 {
42 ENCODE_FUNC_CALL();
43 ENCODE_CHK_NULL_RETURN(m_statusReport);
44
45 ENCODE_CHK_STATUS_RETURN(CmdPacket::Init());
46 m_basicFeature = dynamic_cast<PreEncBasicFeature *>(m_featureManager->GetFeature(FeatureIDs::preEncFeature));
47 ENCODE_CHK_NULL_RETURN(m_basicFeature);
48 ENCODE_CHK_STATUS_RETURN(m_basicFeature->GetEncodeMode(m_encodeMode));
49
50 m_mmcState = m_pipeline->GetMmcState();
51 ENCODE_CHK_NULL_RETURN(m_mmcState);
52 m_basicFeature->m_mmcState = m_mmcState;
53
54 m_allocator = m_pipeline->GetEncodeAllocator();
55 ENCODE_CHK_STATUS_RETURN(AllocateResources());
56
57 if (m_encodeMode == MediaEncodeMode::MANUAL_RES_PRE_ENC || m_encodeMode == MediaEncodeMode::AUTO_RES_PRE_ENC)
58 {
59 ENCODE_CHK_STATUS_RETURN(m_statusReport->RegistObserver(this));
60 }
61
62 CalculatePictureStateCommandSize();
63
64 uint32_t vdencPictureStatesSize = 0, vdencPicturePatchListSize = 0;
65 GetVdencStateCommandsDataSize(vdencPictureStatesSize, vdencPicturePatchListSize);
66 m_defaultPictureStatesSize += vdencPictureStatesSize;
67 m_defaultPicturePatchListSize += vdencPicturePatchListSize;
68
69 GetHxxPrimitiveCommandSize();
70
71 m_usePatchList = m_osInterface->bUsesPatchList;
72
73 return MOS_STATUS_SUCCESS;
74 }
75
76 MOS_STATUS EncodePreEncPacket::Prepare()
77 {
78 ENCODE_FUNC_CALL();
79
80 m_pictureStatesSize = m_defaultPictureStatesSize;
81 m_picturePatchListSize = m_defaultPicturePatchListSize;
82 m_sliceStatesSize = m_defaultSliceStatesSize;
83 m_slicePatchListSize = m_defaultSlicePatchListSize;
84
85 MediaPipeline *pipeline = dynamic_cast<MediaPipeline *>(m_pipeline);
86 ENCODE_CHK_NULL_RETURN(pipeline);
87
88 m_hevcIqMatrixParams = &(m_basicFeature->m_hevcIqMatrixParams);
89 m_nalUnitParams = m_basicFeature->m_nalUnitParams;
90
91 return MOS_STATUS_SUCCESS;
92 }
93
94 MOS_STATUS EncodePreEncPacket::Destroy()
95 {
96 if (m_encodeMode == MediaEncodeMode::MANUAL_RES_PRE_ENC || m_encodeMode == MediaEncodeMode::AUTO_RES_PRE_ENC)
97 {
98 m_statusReport->UnregistObserver(this);
99 }
100 return MOS_STATUS_SUCCESS;
101 }
102
103 MOS_STATUS EncodePreEncPacket::AllocateResources()
104 {
105 ENCODE_FUNC_CALL();
106 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
107 ENCODE_CHK_NULL_RETURN(m_allocator);
108 MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear;
109 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
110 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
111 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
112 allocParamsForBufferLinear.Format = Format_Buffer;
113
114 allocParamsForBufferLinear.dwBytes = MOS_ROUNDUP_DIVIDE(m_basicFeature->m_frameWidth, m_basicFeature->m_maxLCUSize) * CODECHAL_CACHELINE_SIZE * 2 * 2;
115 allocParamsForBufferLinear.pBufName = "vdencIntraRowStoreScratch";
116 allocParamsForBufferLinear.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ;
117 m_vdencIntraRowStoreScratch = m_allocator->AllocateResource(allocParamsForBufferLinear, false);
118
119 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
120 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
121 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
122 allocParamsForBufferLinear.Format = Format_Buffer;
123
124 // VDENC tile row store buffer
125 allocParamsForBufferLinear.dwBytes = MOS_ROUNDUP_DIVIDE(m_basicFeature->m_frameWidth, 32) * CODECHAL_CACHELINE_SIZE * 2;
126 allocParamsForBufferLinear.pBufName = "VDENC Tile Row Store Buffer";
127 allocParamsForBufferLinear.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ;
128 m_vdencTileRowStoreBuffer = m_allocator->AllocateResource(allocParamsForBufferLinear, false);
129
130 hcp::HcpBufferSizePar hcpBufSizePar;
131 MOS_ZeroMemory(&hcpBufSizePar, sizeof(hcpBufSizePar));
132
133 hcpBufSizePar.ucMaxBitDepth = m_basicFeature->m_bitDepth;
134 hcpBufSizePar.ucChromaFormat = m_basicFeature->m_chromaFormat;
135 // We should move the buffer allocation to picture level if the size is dependent on LCU size
136 hcpBufSizePar.dwCtbLog2SizeY = 6; //assume Max LCU size
137 hcpBufSizePar.dwPicWidth = MOS_ALIGN_CEIL(m_basicFeature->m_frameWidth, m_basicFeature->m_maxLCUSize);
138 hcpBufSizePar.dwPicHeight = MOS_ALIGN_CEIL(m_basicFeature->m_frameHeight, m_basicFeature->m_maxLCUSize);
139
140 auto AllocateHcpBuffer = [&](PMOS_RESOURCE &res, const hcp::HCP_INTERNAL_BUFFER_TYPE bufferType, const char *bufferName) {
141 uint32_t bufSize = 0;
142 hcpBufSizePar.bufferType = bufferType;
143 eStatus = m_hcpItf->GetHcpBufSize(hcpBufSizePar, bufSize);
144 if (eStatus != MOS_STATUS_SUCCESS)
145 {
146 ENCODE_ASSERTMESSAGE("Failed to get hcp buffer size.");
147 return eStatus;
148 }
149 allocParamsForBufferLinear.dwBytes = bufSize;
150 allocParamsForBufferLinear.pBufName = bufferName;
151 allocParamsForBufferLinear.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ;
152 res = m_allocator->AllocateResource(allocParamsForBufferLinear, false);
153 return MOS_STATUS_SUCCESS;
154 };
155
156 // Metadata Line buffer
157 ENCODE_CHK_STATUS_RETURN(AllocateHcpBuffer(m_resMetadataLineBuffer, hcp::HCP_INTERNAL_BUFFER_TYPE::META_LINE, "MetadataLineBuffer"));
158 // Metadata Tile Line buffer
159 ENCODE_CHK_STATUS_RETURN(AllocateHcpBuffer(m_resMetadataTileLineBuffer, hcp::HCP_INTERNAL_BUFFER_TYPE::META_TILE_LINE, "MetadataTileLineBuffer"));
160 // Metadata Tile Column buffer
161 ENCODE_CHK_STATUS_RETURN(AllocateHcpBuffer(m_resMetadataTileColumnBuffer, hcp::HCP_INTERNAL_BUFFER_TYPE::META_TILE_COL, "MetadataTileColumnBuffer"));
162
163 return eStatus;
164 }
165
166 void EncodePreEncPacket::SetPerfTag(uint16_t type, uint16_t mode, uint16_t picCodingType)
167 {
168 ENCODE_FUNC_CALL();
169
170 PerfTagSetting perfTag = {};
171 perfTag.Value = 0;
172 perfTag.Mode = mode & CODECHAL_ENCODE_MODE_BIT_MASK;
173 perfTag.CallType = type;
174 perfTag.PictureCodingType = picCodingType > 3 ? 0 : picCodingType;
175 m_osInterface->pfnSetPerfTag(m_osInterface, perfTag.Value);
176 m_osInterface->pfnIncPerfBufferID(m_osInterface);
177 }
178
179 MOS_STATUS EncodePreEncPacket::SendPrologCmds(
180 MOS_COMMAND_BUFFER &cmdBuffer)
181 {
182 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
183
184 ENCODE_FUNC_CALL();
185
186 ENCODE_CHK_NULL_RETURN(m_mmcState);
187 ENCODE_CHK_STATUS_RETURN(m_mmcState->SendPrologCmd(&cmdBuffer, false));
188
189 MHW_GENERIC_PROLOG_PARAMS genericPrologParams;
190 MOS_ZeroMemory(&genericPrologParams, sizeof(genericPrologParams));
191 genericPrologParams.pOsInterface = m_osInterface;
192 genericPrologParams.pvMiInterface = nullptr;
193 genericPrologParams.bMmcEnabled = m_mmcState ? m_mmcState->IsMmcEnabled() : false;
194 ENCODE_CHK_STATUS_RETURN(Mhw_SendGenericPrologCmdNext(&cmdBuffer, &genericPrologParams, m_miItf));
195
196 return eStatus;
197 }
198
199 MOS_STATUS EncodePreEncPacket::AddForceWakeup(MOS_COMMAND_BUFFER &cmdBuffer)
200 {
201 ENCODE_FUNC_CALL();
202 // NativeFence sync BB may cause preemption and ring idle, so force wakeup after it
203 ENCODE_CHK_STATUS_RETURN(AddNativeFenceSyncBBStartCmd(cmdBuffer));
204
205 auto &forceWakeupParams = m_miItf->MHW_GETPAR_F(MI_FORCE_WAKEUP)();
206 forceWakeupParams = {};
207 forceWakeupParams.bMFXPowerWellControl = true;
208 forceWakeupParams.bMFXPowerWellControlMask = true;
209 forceWakeupParams.bHEVCPowerWellControl = true;
210 forceWakeupParams.bHEVCPowerWellControlMask = true;
211
212 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_FORCE_WAKEUP)(&cmdBuffer));
213
214 return MOS_STATUS_SUCCESS;
215 }
216
217 MHW_SETPAR_DECL_SRC(HCP_PIPE_MODE_SELECT, EncodePreEncPacket)
218 {
219 ENCODE_FUNC_CALL();
220
221 params.codecStandardSelect = CODECHAL_HEVC - CODECHAL_HCP_BASE;
222 params.bStreamOutEnabled = false;
223 params.bVdencEnabled = true;
224 params.codecSelect = 1;
225
226 params.multiEngineMode = MHW_VDBOX_HCP_MULTI_ENGINE_MODE_FE_LEGACY;
227 params.pipeWorkMode = MHW_VDBOX_HCP_PIPE_WORK_MODE_LEGACY;
228
229 params.bTileBasedReplayMode = 0;
230
231 return MOS_STATUS_SUCCESS;
232 }
233
234 MOS_STATUS EncodePreEncPacket::AddHcpSurfaceStateCmds(PMOS_COMMAND_BUFFER cmdBuffer) const
235 {
236 ENCODE_FUNC_CALL();
237 ENCODE_CHK_NULL_RETURN(cmdBuffer);
238
239 m_curHcpSurfStateId = CODECHAL_HCP_SRC_SURFACE_ID;
240 SETPAR_AND_ADDCMD(HCP_SURFACE_STATE, m_hcpItf, cmdBuffer);
241
242 m_curHcpSurfStateId = CODECHAL_HCP_DECODED_SURFACE_ID;
243 SETPAR_AND_ADDCMD(HCP_SURFACE_STATE, m_hcpItf, cmdBuffer);
244
245 m_curHcpSurfStateId = CODECHAL_HCP_REF_SURFACE_ID;
246 SETPAR_AND_ADDCMD(HCP_SURFACE_STATE, m_hcpItf, cmdBuffer);
247
248 return MOS_STATUS_SUCCESS;
249 }
250
251 MHW_SETPAR_DECL_SRC(HCP_PIPE_BUF_ADDR_STATE, EncodePreEncPacket)
252 {
253 ENCODE_FUNC_CALL();
254
255 params.Mode = m_basicFeature->m_mode;
256 params.psPreDeblockSurface = &m_basicFeature->m_reconSurface;
257 params.psPostDeblockSurface = &m_basicFeature->m_reconSurface;
258 params.psRawSurface = m_basicFeature->m_preEncRawSurface;
259
260 params.presMetadataLineBuffer = m_resMetadataLineBuffer;
261 params.presMetadataTileLineBuffer = m_resMetadataTileLineBuffer;
262 params.presMetadataTileColumnBuffer = m_resMetadataTileColumnBuffer;
263
264 params.bRawIs10Bit = m_basicFeature->m_is10Bit;
265
266 return MOS_STATUS_SUCCESS;
267 }
268
269 MHW_SETPAR_DECL_SRC(HCP_IND_OBJ_BASE_ADDR_STATE, EncodePreEncPacket)
270 {
271 ENCODE_FUNC_CALL();
272
273 params.presMvObjectBuffer = m_basicFeature->m_resMbCodeBuffer;
274 params.dwMvObjectOffset = 0;
275 params.dwMvObjectSize = m_basicFeature->m_mbCodeSize;
276 params.presPakBaseObjectBuffer = &m_basicFeature->m_resBitstreamBuffer;
277 params.dwPakBaseObjectSize = m_basicFeature->m_bitstreamSize;
278
279 return MOS_STATUS_SUCCESS;
280 }
281
282 MOS_STATUS EncodePreEncPacket::StartStatusReport(
283 uint32_t srType,
284 MOS_COMMAND_BUFFER *cmdBuffer)
285 {
286 ENCODE_FUNC_CALL();
287 ENCODE_CHK_NULL_RETURN(cmdBuffer);
288
289 if (m_encodeMode == MediaEncodeMode::MANUAL_RES_PRE_ENC || m_encodeMode == MediaEncodeMode::AUTO_RES_PRE_ENC)
290 {
291 ENCODE_CHK_STATUS_RETURN(MediaPacket::StartStatusReportNext(srType, cmdBuffer));
292 }
293
294 MediaPerfProfiler *perfProfiler = MediaPerfProfiler::Instance();
295 ENCODE_CHK_NULL_RETURN(perfProfiler);
296 ENCODE_CHK_STATUS_RETURN(perfProfiler->AddPerfCollectStartCmd(
297 (void *)m_pipeline, m_osInterface, m_miItf, cmdBuffer));
298
299 return MOS_STATUS_SUCCESS;
300 }
301
302 MOS_STATUS EncodePreEncPacket::EndStatusReport(
303 uint32_t srType,
304 MOS_COMMAND_BUFFER *cmdBuffer)
305 {
306 ENCODE_FUNC_CALL();
307 ENCODE_CHK_NULL_RETURN(cmdBuffer);
308
309 if (m_encodeMode == MediaEncodeMode::MANUAL_RES_PRE_ENC || m_encodeMode == MediaEncodeMode::AUTO_RES_PRE_ENC)
310 {
311 ENCODE_CHK_STATUS_RETURN(MediaPacket::EndStatusReportNext(srType, cmdBuffer));
312 }
313
314 MediaPerfProfiler *perfProfiler = MediaPerfProfiler::Instance();
315 ENCODE_CHK_NULL_RETURN(perfProfiler);
316 ENCODE_CHK_STATUS_RETURN(perfProfiler->AddPerfCollectEndCmd(
317 (void *)m_pipeline, m_osInterface, m_miItf, cmdBuffer));
318
319 return MOS_STATUS_SUCCESS;
320 }
321
322 MOS_STATUS EncodePreEncPacket::ReadHcpStatus(
323 MHW_VDBOX_NODE_IND vdboxIndex,
324 MediaStatusReport * statusReport,
325 MOS_COMMAND_BUFFER &cmdBuffer)
326 {
327 ENCODE_FUNC_CALL();
328
329 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
330
331 CODEC_HW_FUNCTION_ENTER;
332
333 ENCODE_CHK_NULL_RETURN(statusReport);
334 ENCODE_CHK_NULL_RETURN(m_hwInterface);
335
336 MOS_RESOURCE *osResource = nullptr;
337 uint32_t offset = 0;
338
339 EncodeStatusReadParams params;
340 MOS_ZeroMemory(&params, sizeof(params));
341
342 ENCODE_CHK_STATUS_RETURN(statusReport->GetAddress(encode::statusReportMfxBitstreamByteCountPerFrame, osResource, offset));
343 params.resBitstreamByteCountPerFrame = osResource;
344 params.bitstreamByteCountPerFrameOffset = offset;
345
346 ENCODE_CHK_STATUS_RETURN(statusReport->GetAddress(encode::statusReportMfxBitstreamSyntaxElementOnlyBitCount, osResource, offset));
347 params.resBitstreamSyntaxElementOnlyBitCount = osResource;
348 params.bitstreamSyntaxElementOnlyBitCountOffset = offset;
349
350 ENCODE_CHK_STATUS_RETURN(statusReport->GetAddress(encode::statusReportQPStatusCount, osResource, offset));
351 params.resQpStatusCount = osResource;
352 params.qpStatusCountOffset = offset;
353
354 ENCODE_CHK_STATUS_RETURN(statusReport->GetAddress(encode::statusReportImageStatusMask, osResource, offset));
355 params.resImageStatusMask = osResource;
356 params.imageStatusMaskOffset = offset;
357
358 ENCODE_CHK_STATUS_RETURN(statusReport->GetAddress(encode::statusReportImageStatusCtrl, osResource, offset));
359 params.resImageStatusCtrl = osResource;
360 params.imageStatusCtrlOffset = offset;
361
362 ENCODE_CHK_STATUS_RETURN(statusReport->GetAddress(encode::statusReportNumSlices, osResource, offset));
363 params.resNumSlices = osResource;
364 params.numSlicesOffset = offset;
365
366 ENCODE_CHK_STATUS_RETURN(m_hwInterface->ReadHcpStatus(vdboxIndex, params, &cmdBuffer));
367
368 ENCODE_CHK_STATUS_RETURN(m_hwInterface->ReadImageStatusForHcp(vdboxIndex, params, &cmdBuffer));
369 return eStatus;
370 }
371
372 MOS_STATUS EncodePreEncPacket::Completed(void *mfxStatus, void *rcsStatus, void *statusReport)
373 {
374 ENCODE_FUNC_CALL();
375
376 ENCODE_CHK_NULL_RETURN(statusReport);
377 ENCODE_CHK_NULL_RETURN(m_basicFeature);
378
379 EncodeStatusReportData *statusReportData = (EncodeStatusReportData *)statusReport;
380 #if USE_CODECHAL_DEBUG_TOOL
381 auto preencFeature = dynamic_cast<PreEncBasicFeature *>(m_featureManager->GetFeature(FeatureIDs::preEncFeature));
382 ENCODE_CHK_NULL_RETURN(preencFeature);
383 preencFeature->EncodePreencBasicFuntion1();
384 #endif
385
386 m_basicFeature->Reset((CODEC_REF_LIST *)statusReportData->currRefList);
387 return MOS_STATUS_SUCCESS;
388 }
389
390 MOS_STATUS EncodePreEncPacket::GetVdencStateCommandsDataSize(uint32_t &vdencPictureStatesSize, uint32_t &vdencPicturePatchListSize)
391 {
392 vdencPictureStatesSize =
393 m_vdencItf->MHW_GETSIZE_F(VDENC_PIPE_MODE_SELECT)() +
394 m_vdencItf->MHW_GETSIZE_F(VDENC_SRC_SURFACE_STATE)() +
395 m_vdencItf->MHW_GETSIZE_F(VDENC_REF_SURFACE_STATE)() +
396 m_vdencItf->MHW_GETSIZE_F(VDENC_DS_REF_SURFACE_STATE)() +
397 m_vdencItf->MHW_GETSIZE_F(VDENC_PIPE_BUF_ADDR_STATE)() +
398 m_vdencItf->MHW_GETSIZE_F(VDENC_WEIGHTSOFFSETS_STATE)() +
399 m_vdencItf->MHW_GETSIZE_F(VDENC_WALKER_STATE)() +
400 m_vdencItf->MHW_GETSIZE_F(VD_PIPELINE_FLUSH)() +
401 m_miItf->MHW_GETSIZE_F(MI_LOAD_REGISTER_IMM)()*8 +
402 m_miItf->MHW_GETSIZE_F(MI_FLUSH_DW)() +
403 m_miItf->MHW_GETSIZE_F(MI_BATCH_BUFFER_START)() +
404 m_hcpItf->MHW_GETSIZE_F(HEVC_VP9_RDOQ_STATE)() +
405 m_miItf->MHW_GETSIZE_F(MI_BATCH_BUFFER_END)();
406
407 vdencPicturePatchListSize = PATCH_LIST_COMMAND(mhw::vdbox::vdenc::Itf::VDENC_PIPE_BUF_ADDR_STATE_CMD);
408
409 return MOS_STATUS_SUCCESS;
410 }
411
412 MOS_STATUS EncodePreEncPacket::GetHxxPrimitiveCommandSize()
413 {
414 uint32_t hcpCommandsSize = 0;
415 uint32_t hcpPatchListSize = 0;
416 hcpCommandsSize =
417 m_hcpItf->MHW_GETSIZE_F(HCP_REF_IDX_STATE)() * 2 +
418 m_hcpItf->MHW_GETSIZE_F(HCP_WEIGHTOFFSET_STATE)() * 2 +
419 m_hcpItf->MHW_GETSIZE_F(HCP_SLICE_STATE)() +
420 m_hcpItf->MHW_GETSIZE_F(HCP_PAK_INSERT_OBJECT)() +
421 m_miItf->MHW_GETSIZE_F(MI_BATCH_BUFFER_START)() * 2 +
422 m_hcpItf->MHW_GETSIZE_F(HCP_TILE_CODING)(); // one slice cannot be with more than one tile
423
424 hcpPatchListSize =
425 mhw::vdbox::hcp::Itf::HCP_REF_IDX_STATE_CMD_NUMBER_OF_ADDRESSES * 2 +
426 mhw::vdbox::hcp::Itf::HCP_WEIGHTOFFSET_STATE_CMD_NUMBER_OF_ADDRESSES * 2 +
427 mhw::vdbox::hcp::Itf::HCP_SLICE_STATE_CMD_NUMBER_OF_ADDRESSES +
428 mhw::vdbox::hcp::Itf::HCP_PAK_INSERT_OBJECT_CMD_NUMBER_OF_ADDRESSES +
429 mhw::vdbox::hcp::Itf::MI_BATCH_BUFFER_START_CMD_NUMBER_OF_ADDRESSES * 2 + // One is for the PAK command and another one is for the BB when BRC and single task mode are on
430 mhw::vdbox::hcp::Itf::HCP_TILE_CODING_COMMAND_NUMBER_OF_ADDRESSES; // HCP_TILE_CODING_STATE command
431
432 uint32_t cpCmdsize = 0;
433 uint32_t cpPatchListSize = 0;
434 if (m_hwInterface->GetCpInterface())
435 {
436 m_hwInterface->GetCpInterface()->GetCpSliceLevelCmdSize(cpCmdsize, cpPatchListSize);
437 }
438
439 m_defaultSliceStatesSize = hcpCommandsSize + (uint32_t)cpCmdsize;
440 m_defaultSlicePatchListSize = hcpPatchListSize + (uint32_t)cpPatchListSize;
441 return MOS_STATUS_SUCCESS;
442 }
443
444 MOS_STATUS EncodePreEncPacket::CalculateCommandSize(uint32_t &commandBufferSize, uint32_t &requestedPatchListSize)
445 {
446 m_pictureStatesSize = m_defaultPictureStatesSize;
447 m_picturePatchListSize = m_defaultPicturePatchListSize;
448 m_sliceStatesSize = m_defaultSliceStatesSize;
449 m_slicePatchListSize = m_defaultSlicePatchListSize;
450
451 commandBufferSize = CalculateCommandBufferSize();
452 requestedPatchListSize = CalculatePatchListSize();
453 return MOS_STATUS_SUCCESS;
454 }
455
456 uint32_t EncodePreEncPacket::CalculateCommandBufferSize()
457 {
458 ENCODE_FUNC_CALL();
459 uint32_t commandBufferSize = 0;
460
461 commandBufferSize = m_pictureStatesSize + m_sliceStatesSize;
462
463 if (m_pipeline->IsSingleTaskPhaseSupported())
464 {
465 commandBufferSize *= m_pipeline->GetPassNum();
466 }
467
468 // 4K align since allocation is in chunks of 4K bytes.
469 commandBufferSize = MOS_ALIGN_CEIL(commandBufferSize, CODECHAL_PAGE_SIZE);
470
471 return commandBufferSize;
472 }
473
474 uint32_t EncodePreEncPacket::CalculatePatchListSize()
475 {
476 ENCODE_FUNC_CALL();
477 uint32_t requestedPatchListSize = 0;
478 if (m_usePatchList)
479 {
480 requestedPatchListSize = m_picturePatchListSize + m_slicePatchListSize;
481
482 if (m_pipeline->IsSingleTaskPhaseSupported())
483 {
484 requestedPatchListSize *= m_pipeline->GetPassNum();
485 }
486
487 // Multi pipes are sharing one patchlist
488 requestedPatchListSize *= m_pipeline->GetPipeNum();
489 }
490 return requestedPatchListSize;
491 }
492
493 MHW_SETPAR_DECL_SRC(VDENC_PIPE_MODE_SELECT, EncodePreEncPacket)
494 {
495 //params.tlbPrefetch = true;
496
497 // can be enabled by reg key (disabled by default)
498 params.pakObjCmdStreamOut = false;
499
500 if (!MEDIA_IS_WA(m_osInterface->pfnGetWaTable(m_osInterface), WaEnableOnlyASteppingFeatures))
501 {
502 params.VdencPipeModeSelectPar0 = 1;
503 }
504
505 params.rgbEncodingMode = false;
506
507 return MOS_STATUS_SUCCESS;
508 }
509
510 MHW_SETPAR_DECL_SRC(VDENC_PIPE_BUF_ADDR_STATE, EncodePreEncPacket)
511 {
512 params.intraRowStoreScratchBuffer = m_vdencIntraRowStoreScratch;
513 params.tileRowStoreBuffer = m_vdencTileRowStoreBuffer;
514
515 return MOS_STATUS_SUCCESS;
516 }
517
518 MHW_SETPAR_DECL_SRC(VD_PIPELINE_FLUSH, EncodePreEncPacket)
519 {
520 switch (m_flushCmd)
521 {
522 case waitHevc:
523 params.waitDoneHEVC = true;
524 params.flushHEVC = true;
525 params.waitDoneVDCmdMsgParser = true;
526 break;
527 case waitVdenc:
528 params.waitDoneMFX = true;
529 params.waitDoneVDENC = true;
530 params.flushVDENC = true;
531 params.waitDoneVDCmdMsgParser = true;
532 break;
533 case waitHevcVdenc:
534 params.waitDoneMFX = true;
535 params.waitDoneVDENC = true;
536 params.flushVDENC = true;
537 params.flushHEVC = true;
538 params.waitDoneVDCmdMsgParser = true;
539 break;
540 }
541
542 return MOS_STATUS_SUCCESS;
543 }
544
545 #if USE_CODECHAL_DEBUG_TOOL
546 MOS_STATUS EncodePreEncPacket::DumpResources(
547 EncodeStatusMfx * encodeStatusMfx,
548 EncodeStatusReportData *statusReportData)
549 {
550 ENCODE_FUNC_CALL();
551 ENCODE_CHK_NULL_RETURN(encodeStatusMfx);
552 ENCODE_CHK_NULL_RETURN(statusReportData);
553 ENCODE_CHK_NULL_RETURN(m_pipeline);
554 ENCODE_CHK_NULL_RETURN(m_statusReport);
555 ENCODE_CHK_NULL_RETURN(m_basicFeature);
556 ENCODE_CHK_NULL_RETURN(m_basicFeature->m_trackedBuf);
557
558 CodechalDebugInterface *debugInterface = m_pipeline->GetStatusReportDebugInterface();
559 ENCODE_CHK_NULL_RETURN(debugInterface);
560
561 CODEC_REF_LIST currRefList = *((CODEC_REF_LIST *)statusReportData->currRefList);
562 currRefList.RefPic = statusReportData->currOriginalPic;
563
564 debugInterface->m_currPic = statusReportData->currOriginalPic;
565 debugInterface->m_bufferDumpFrameNum = m_statusReport->GetReportedCount();
566 debugInterface->m_frameType = encodeStatusMfx->pictureCodingType;
567
568 ENCODE_CHK_STATUS_RETURN(debugInterface->DumpBuffer(
569 &currRefList.resBitstreamBuffer,
570 CodechalDbgAttr::attrBitstream,
571 "_PAK",
572 statusReportData->bitstreamSize,
573 0,
574 CODECHAL_NUM_MEDIA_STATES));
575
576 ENCODE_CHK_STATUS_RETURN(debugInterface->DumpData(
577 statusReportData,
578 sizeof(EncodeStatusReportData),
579 CodechalDbgAttr::attrStatusReport,
580 "EncodeStatusReport_Buffer"));
581
582 MOS_SURFACE *ds4xSurface = m_basicFeature->m_trackedBuf->GetSurface(
583 BufferType::ds4xSurface, currRefList.ucScalingIdx);
584
585 if (ds4xSurface != nullptr)
586 {
587 ENCODE_CHK_STATUS_RETURN(debugInterface->DumpYUVSurface(
588 ds4xSurface,
589 CodechalDbgAttr::attrReconstructedSurface,
590 "4xScaledSurf"))
591 }
592
593 MOS_SURFACE *ds8xSurface = m_basicFeature->m_trackedBuf->GetSurface(
594 BufferType::ds8xSurface, currRefList.ucScalingIdx);
595
596 if (ds8xSurface != nullptr)
597 {
598 ENCODE_CHK_STATUS_RETURN(debugInterface->DumpYUVSurface(
599 ds8xSurface,
600 CodechalDbgAttr::attrReconstructedSurface,
601 "8xScaledSurf"))
602 }
603
604 ENCODE_CHK_STATUS_RETURN(debugInterface->DumpYUVSurface(
605 &currRefList.sRefReconBuffer,
606 CodechalDbgAttr::attrReconstructedSurface,
607 "ReconSurf"))
608
609 ENCODE_CHK_STATUS_RETURN(debugInterface->DumpYUVSurface(
610 &currRefList.sRefRawBuffer,
611 CodechalDbgAttr::attrEncodeRawInputSurface,
612 "SrcSurf"))
613
614 return MOS_STATUS_SUCCESS;
615 }
616
617 #endif
618
619 MOS_STATUS EncodePreEncPacket::SubmitPictureLevel(
620 MOS_COMMAND_BUFFER *commandBuffer,
621 uint8_t packetPhase)
622 {
623 ENCODE_FUNC_CALL();
624
625 MOS_COMMAND_BUFFER &cmdBuffer = *commandBuffer;
626 ENCODE_CHK_STATUS_RETURN(Mos_Solo_PreProcessEncode(m_osInterface, &m_basicFeature->m_resBitstreamBuffer, &m_basicFeature->m_reconSurface));
627
628 MOS_SYNC_PARAMS syncParams;
629 syncParams = g_cInitSyncParams;
630 syncParams.GpuContext = m_osInterface->pfnGetGpuContext(m_osInterface);
631 syncParams.presSyncResource = &m_basicFeature->m_preEncRawSurface->OsResource;
632 syncParams.bReadOnly = true;
633 ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams));
634 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
635
636 ENCODE_CHK_STATUS_RETURN(PatchPictureLevelCommands(packetPhase, cmdBuffer));
637
638 return MOS_STATUS_SUCCESS;
639 }
640
641 MOS_STATUS EncodePreEncPacket::Submit(
642 MOS_COMMAND_BUFFER *commandBuffer,
643 uint8_t packetPhase)
644 {
645 ENCODE_FUNC_CALL();
646
647 ENCODE_CHK_STATUS_RETURN(PrepareRawSurface());
648
649 ENCODE_CHK_STATUS_RETURN(SubmitPictureLevel(commandBuffer, packetPhase));
650
651 MOS_COMMAND_BUFFER &cmdBuffer = *commandBuffer;
652
653 ENCODE_CHK_STATUS_RETURN(PatchSliceLevelCommands(cmdBuffer, packetPhase));
654
655 ENCODE_CHK_STATUS_RETURN(Mos_Solo_PostProcessEncode(m_osInterface, &m_basicFeature->m_resBitstreamBuffer, &m_basicFeature->m_reconSurface));
656
657 m_enablePreEncStatusReport = true;
658
659 return MOS_STATUS_SUCCESS;
660 }
661
662 MOS_STATUS EncodePreEncPacket::PrepareRawSurface()
663 {
664 ENCODE_FUNC_CALL();
665
666 if (m_basicFeature->m_rawDsSurface != nullptr)
667 {
668 ENCODE_CHK_STATUS_RETURN(RawSurfaceDownScaling(&m_basicFeature->m_rawSurface, m_basicFeature->m_rawDsSurface));
669 m_basicFeature->m_preEncRawSurface = m_basicFeature->m_rawDsSurface;
670 }
671 else
672 {
673 m_basicFeature->m_preEncRawSurface = &m_basicFeature->m_rawSurface;
674 }
675
676 return MOS_STATUS_SUCCESS;
677 }
678
679 MOS_STATUS EncodePreEncPacket::RawSurfaceDownScaling(const PMOS_SURFACE inSurf, PMOS_SURFACE outSurf)
680 {
681 ENCODE_FUNC_CALL();
682
683 if (outSurf == nullptr)
684 {
685 return MOS_STATUS_SUCCESS;
686 }
687
688 VEBOX_SFC_PARAMS params = {};
689
690 params.input.surface = inSurf;
691 params.input.colorSpace = CSpace_Any;
692 params.input.chromaSiting = 0;
693 params.input.rcSrc = {0, 0, (long)inSurf->dwWidth, (long)inSurf->dwHeight};
694 params.input.rotation = ROTATION_IDENTITY;
695
696 params.output.surface = outSurf;
697 params.output.colorSpace = CSpace_Any;
698 params.output.chromaSiting = 0;
699 params.output.rcDst = {0, 0, (long)outSurf->dwWidth, (long)outSurf->dwHeight};
700
701 ENCODE_CHK_STATUS_RETURN(m_sfcItf->Render(params));
702
703 m_pipeline->ContextSwitchBack();
704
705 return MOS_STATUS_SUCCESS;
706 }
707
708 MOS_STATUS EncodePreEncPacket::PatchPictureLevelCommands(const uint8_t &packetPhase, MOS_COMMAND_BUFFER &cmdBuffer)
709 {
710 ENCODE_FUNC_CALL();
711
712 ENCODE_CHK_STATUS_RETURN(m_miItf->SetWatchdogTimerThreshold((uint32_t)m_basicFeature->m_rawSurfaceToEnc->dwWidth, (uint32_t)m_basicFeature->m_rawSurfaceToEnc->dwHeight, true));
713
714 SetPerfTag(CODECHAL_ENCODE_PERFTAG_CALL_PAK_ENGINE, (uint16_t)m_basicFeature->m_mode, m_basicFeature->GetPictureCodingType());
715
716 bool firstTaskInPhase = packetPhase & firstPacket;
717 if (!m_pipeline->IsSingleTaskPhaseSupported() || firstTaskInPhase)
718 {
719 ENCODE_CHK_STATUS_RETURN(AddForceWakeup(cmdBuffer));
720
721 // Send command buffer header at the beginning (OS dependent)
722 ENCODE_CHK_STATUS_RETURN(SendPrologCmds(cmdBuffer));
723 }
724
725 ENCODE_CHK_STATUS_RETURN(StartStatusReport(statusReportMfx, &cmdBuffer));
726
727 ENCODE_CHK_STATUS_RETURN(AddPictureHcpCommands(cmdBuffer));
728
729 ENCODE_CHK_STATUS_RETURN(AddPictureVdencCommands(cmdBuffer));
730
731 ENCODE_CHK_STATUS_RETURN(AddPicStateWithNoTile(cmdBuffer));
732
733 return MOS_STATUS_SUCCESS;
734 }
735
736 MOS_STATUS EncodePreEncPacket::PatchSliceLevelCommands(MOS_COMMAND_BUFFER &cmdBuffer, uint8_t packetPhase)
737 {
738 ENCODE_FUNC_CALL();
739
740 ENCODE_CHK_STATUS_RETURN(SendHwSliceEncodeCommand(cmdBuffer));
741
742 m_flushCmd = waitVdenc;
743 SETPAR_AND_ADDCMD(VD_PIPELINE_FLUSH, m_vdencItf, &cmdBuffer);
744
745 ENCODE_CHK_STATUS_RETURN(EnsureAllCommandsExecuted(cmdBuffer));
746
747 m_flushCmd = waitHevc;
748 SETPAR_AND_ADDCMD(VD_PIPELINE_FLUSH, m_vdencItf, &cmdBuffer);
749
750 ENCODE_CHK_STATUS_RETURN(EnsureAllCommandsExecuted(cmdBuffer));
751
752 if (m_encodeMode == MediaEncodeMode::MANUAL_RES_PRE_ENC || m_encodeMode == MediaEncodeMode::AUTO_RES_PRE_ENC)
753 {
754 ENCODE_CHK_STATUS_RETURN(ReadHcpStatus(MHW_VDBOX_NODE_1, m_statusReport, cmdBuffer));
755 }
756
757 ENCODE_CHK_STATUS_RETURN(EndStatusReport(statusReportMfx, &cmdBuffer));
758
759 if (m_encodeMode == MediaEncodeMode::MANUAL_RES_PRE_ENC || m_encodeMode == MediaEncodeMode::AUTO_RES_PRE_ENC)
760 {
761 ENCODE_CHK_STATUS_RETURN(MediaPacket::UpdateStatusReportNext(statusReportGlobalCount, &cmdBuffer));
762 }
763
764 return MOS_STATUS_SUCCESS;
765 }
766
767 MOS_STATUS EncodePreEncPacket::AddPicStateWithNoTile(
768 MOS_COMMAND_BUFFER &cmdBuffer)
769 {
770 ENCODE_FUNC_CALL();
771
772 SETPAR_AND_ADDCMD(VDENC_CMD1, m_vdencItf, &cmdBuffer);
773
774 SETPAR_AND_ADDCMD(HCP_PIC_STATE, m_hcpItf, &cmdBuffer);
775
776 SETPAR_AND_ADDCMD(VDENC_CMD2, m_vdencItf, &cmdBuffer);
777
778 // Send HEVC_VP9_RDOQ_STATE command
779 SETPAR_AND_ADDCMD(HEVC_VP9_RDOQ_STATE, m_hcpItf, &cmdBuffer);
780
781 return MOS_STATUS_SUCCESS;
782 }
783
784 MOS_STATUS EncodePreEncPacket::EnsureAllCommandsExecuted(MOS_COMMAND_BUFFER &cmdBuffer)
785 {
786 ENCODE_FUNC_CALL();
787
788 // Send MI_FLUSH command
789 auto &flushDwParams = m_miItf->MHW_GETPAR_F(MI_FLUSH_DW)();
790 flushDwParams = {};
791 flushDwParams.bVideoPipelineCacheInvalidate = true;
792 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_FLUSH_DW)(&cmdBuffer));
793
794 return MOS_STATUS_SUCCESS;
795 }
796
797 MOS_STATUS EncodePreEncPacket::AddPictureVdencCommands(MOS_COMMAND_BUFFER &cmdBuffer)
798 {
799 ENCODE_FUNC_CALL();
800
801 SETPAR_AND_ADDCMD(VDENC_PIPE_MODE_SELECT, m_vdencItf, &cmdBuffer);
802 SETPAR_AND_ADDCMD(VDENC_SRC_SURFACE_STATE, m_vdencItf, &cmdBuffer);
803 SETPAR_AND_ADDCMD(VDENC_REF_SURFACE_STATE, m_vdencItf, &cmdBuffer);
804 SETPAR_AND_ADDCMD(VDENC_DS_REF_SURFACE_STATE, m_vdencItf, &cmdBuffer);
805 SETPAR_AND_ADDCMD(VDENC_PIPE_BUF_ADDR_STATE, m_vdencItf, &cmdBuffer);
806
807 return MOS_STATUS_SUCCESS;
808 }
809
810 MOS_STATUS EncodePreEncPacket::AddPictureHcpCommands(
811 MOS_COMMAND_BUFFER &cmdBuffer)
812 {
813 ENCODE_FUNC_CALL();
814
815 ENCODE_CHK_STATUS_RETURN(AddHcpPipeModeSelect(cmdBuffer));
816
817 ENCODE_CHK_STATUS_RETURN(AddHcpSurfaceStateCmds(&cmdBuffer));
818
819 SETPAR_AND_ADDCMD(HCP_PIPE_BUF_ADDR_STATE, m_hcpItf, &cmdBuffer);
820
821 SETPAR_AND_ADDCMD(HCP_IND_OBJ_BASE_ADDR_STATE, m_hcpItf, &cmdBuffer);
822
823 ENCODE_CHK_STATUS_RETURN(AddHcpFqmStateCmds(&cmdBuffer));
824 ENCODE_CHK_STATUS_RETURN(AddHcpQMStateCmds(&cmdBuffer));
825
826 return MOS_STATUS_SUCCESS;
827 }
828
829 MOS_STATUS EncodePreEncPacket::AddHcpPipeModeSelect(
830 MOS_COMMAND_BUFFER &cmdBuffer)
831 {
832 ENCODE_FUNC_CALL();
833
834 SETPAR_AND_ADDCMD(VDENC_CONTROL_STATE, m_vdencItf, &cmdBuffer);
835
836 auto &vdControlStateParams = m_miItf->MHW_GETPAR_F(VD_CONTROL_STATE)();
837 vdControlStateParams = {};
838 vdControlStateParams.initialization = true;
839 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(VD_CONTROL_STATE)(&cmdBuffer));
840
841 // for Gen11+, we need to add MFX wait for both KIN and VRT before and after HCP Pipemode select...
842 auto &mfxWaitParams = m_miItf->MHW_GETPAR_F(MFX_WAIT)();
843 mfxWaitParams = {};
844 mfxWaitParams.iStallVdboxPipeline = true;
845 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MFX_WAIT)(&cmdBuffer));
846
847 SETPAR_AND_ADDCMD(HCP_PIPE_MODE_SELECT, m_hcpItf, &cmdBuffer);
848
849 mfxWaitParams = {};
850 mfxWaitParams.iStallVdboxPipeline = true;
851 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MFX_WAIT)(&cmdBuffer));
852
853 return MOS_STATUS_SUCCESS;
854 }
855
856 MOS_STATUS EncodePreEncPacket::CalculatePictureStateCommandSize()
857 {
858 ENCODE_FUNC_CALL();
859
860 uint32_t hcpCommandsSize = 0;
861 uint32_t hcpPatchListSize = 0;
862 uint32_t cpCmdsize = 0;
863 uint32_t cpPatchListSize = 0;
864 uint32_t hucCommandsSize = 0;
865 uint32_t hucPatchListSize = 0;
866
867 MHW_VDBOX_STATE_CMDSIZE_PARAMS stateCmdSizeParams;
868
869 // Determine semaphore wait command size based on hardware capability
870 uint32_t semaphoreWaitSize = 0;
871 #ifdef _MEDIA_RESERVED
872 bool isSemaphore64Supported = MEDIA_IS_SKU(m_osInterface->pfnGetSkuTable(m_osInterface), FtrHwSemaphore64);
873 semaphoreWaitSize = isSemaphore64Supported ? m_miItf->MHW_GETSIZE_F(MI_SEMAPHORE_WAIT_64)() : m_miItf->MHW_GETSIZE_F(MI_SEMAPHORE_WAIT)();
874 #else
875 semaphoreWaitSize = m_miItf->MHW_GETSIZE_F(MI_SEMAPHORE_WAIT)();
876 #endif
877
878 hcpCommandsSize =
879 m_vdencItf->MHW_GETSIZE_F(VD_PIPELINE_FLUSH)() +
880 m_miItf->MHW_GETSIZE_F(MI_FLUSH_DW)() +
881 m_hcpItf->MHW_GETSIZE_F(HCP_PIPE_MODE_SELECT)() +
882 m_hcpItf->MHW_GETSIZE_F(HCP_SURFACE_STATE)() +
883 m_hcpItf->MHW_GETSIZE_F(HCP_PIPE_BUF_ADDR_STATE)() +
884 m_hcpItf->MHW_GETSIZE_F(HCP_IND_OBJ_BASE_ADDR_STATE)() +
885 m_miItf->MHW_GETSIZE_F(MI_LOAD_REGISTER_REG)() * 8;
886
887 hcpPatchListSize =
888 PATCH_LIST_COMMAND(mhw::vdbox::hcp::Itf::VD_PIPELINE_FLUSH_CMD) +
889 PATCH_LIST_COMMAND(mhw::vdbox::hcp::Itf::MI_FLUSH_DW_CMD) +
890 PATCH_LIST_COMMAND(mhw::vdbox::hcp::Itf::HCP_PIPE_MODE_SELECT_CMD) +
891 PATCH_LIST_COMMAND(mhw::vdbox::hcp::Itf::HCP_SURFACE_STATE_CMD) +
892 PATCH_LIST_COMMAND(mhw::vdbox::hcp::Itf::HCP_PIPE_BUF_ADDR_STATE_CMD) +
893 PATCH_LIST_COMMAND(mhw::vdbox::hcp::Itf::HCP_IND_OBJ_BASE_ADDR_STATE_CMD);
894
895 // HCP_QM_STATE_CMD may be issued up to 20 times: 3x Colour Component plus 2x intra/inter plus 4x SizeID minus 4 for the 32x32 chroma components.
896 // HCP_FQP_STATE_CMD may be issued up to 8 times: 4 scaling list per intra and inter.
897 hcpCommandsSize +=
898 2 * m_miItf->MHW_GETSIZE_F(VD_CONTROL_STATE)() +
899 m_hcpItf->MHW_GETSIZE_F(HCP_SURFACE_STATE)() + // encoder needs two surface state commands. One is for raw and another one is for recon surfaces.
900 20 * m_hcpItf->MHW_GETSIZE_F(HCP_QM_STATE)() +
901 8 * m_hcpItf->MHW_GETSIZE_F(HCP_FQM_STATE)() +
902 m_hcpItf->MHW_GETSIZE_F(HCP_PIC_STATE)() +
903 m_hcpItf->MHW_GETSIZE_F(HEVC_VP9_RDOQ_STATE)() + // RDOQ
904 2 * m_miItf->MHW_GETSIZE_F(MI_STORE_DATA_IMM)() + // Slice level commands
905 2 * m_miItf->MHW_GETSIZE_F(MI_FLUSH_DW)() + // need for Status report, Mfc Status and
906 10 * m_miItf->MHW_GETSIZE_F(MI_STORE_REGISTER_MEM)() + // 8 for BRCStatistics and 2 for RC6 WAs
907 m_miItf->MHW_GETSIZE_F(MI_LOAD_REGISTER_MEM)() + // 1 for RC6 WA
908 2 * m_hcpItf->MHW_GETSIZE_F(HCP_PAK_INSERT_OBJECT)() + // Two PAK insert object commands are for headers before the slice header and the header for the end of stream
909 4 * m_miItf->MHW_GETSIZE_F(MI_STORE_DATA_IMM)() + // two (BRC+reference frame) for clean-up HW semaphore memory and another two for signal it
910 17 * semaphoreWaitSize + // Use HW wait command for each reference and one wait for current semaphore object
911 semaphoreWaitSize + // Use HW wait command for each BRC pass
912 semaphoreWaitSize // Use HW wait command for each VDBOX
913 + 2 * m_miItf->MHW_GETSIZE_F(MI_STORE_DATA_IMM)() // One is for reset and another one for set per VDBOX
914 + 8 * m_miItf->MHW_GETSIZE_F(MI_COPY_MEM_MEM)() // Need to copy SSE statistics/ Slice Size overflow into memory
915 ;
916
917 hcpPatchListSize +=
918 20 * PATCH_LIST_COMMAND(mhw::vdbox::hcp::Itf::HCP_QM_STATE_CMD) +
919 8 * PATCH_LIST_COMMAND(mhw::vdbox::hcp::Itf::HCP_FQM_STATE_CMD) +
920 PATCH_LIST_COMMAND(mhw::vdbox::hcp::Itf::HCP_PIC_STATE_CMD) +
921 PATCH_LIST_COMMAND(mhw::vdbox::hcp::Itf::MI_BATCH_BUFFER_START_CMD) + // When BRC is on, HCP_PIC_STATE_CMD command is in the BB
922 2 * PATCH_LIST_COMMAND(mhw::vdbox::hcp::Itf::MI_STORE_DATA_IMM_CMD) + // Slice level commands
923 2 * PATCH_LIST_COMMAND(mhw::vdbox::hcp::Itf::MI_FLUSH_DW_CMD) + // need for Status report, Mfc Status and
924 11 * PATCH_LIST_COMMAND(mhw::vdbox::hcp::Itf::MI_STORE_REGISTER_MEM_CMD) + // 8 for BRCStatistics and 3 for RC6 WAs
925 22 * PATCH_LIST_COMMAND(mhw::vdbox::hcp::Itf::MI_STORE_DATA_IMM_CMD) // Use HW wait commands plus its memory clean-up and signal (4+ 16 + 1 + 1)
926 + 8 * PATCH_LIST_COMMAND(mhw::vdbox::hcp::Itf::MI_BATCH_BUFFER_START_CMD) // At maximal, there are 8 batch buffers for 8 VDBOXes for VE. Each box has one BB.
927 + PATCH_LIST_COMMAND(mhw::vdbox::hcp::Itf::MI_FLUSH_DW_CMD) // Need one flush before copy command
928 + PATCH_LIST_COMMAND(mhw::vdbox::hcp::Itf::MFX_WAIT_CMD) // Need one wait after copy command
929 + 3 * PATCH_LIST_COMMAND(mhw::vdbox::hcp::Itf::MI_STORE_DATA_IMM_CMD) // one wait commands and two for reset and set semaphore memory
930 + 8 * PATCH_LIST_COMMAND(mhw::vdbox::hcp::Itf::MI_COPY_MEM_MEM_CMD) // Need to copy SSE statistics/ Slice Size overflow into memory
931 ;
932
933 auto cpInterface = m_hwInterface->GetCpInterface();
934 cpInterface->GetCpStateLevelCmdSize(cpCmdsize, cpPatchListSize);
935
936 ENCODE_CHK_STATUS_RETURN(m_hwInterface->GetHucStateCommandSize(
937 m_basicFeature->m_mode, (uint32_t *)&hucCommandsSize, (uint32_t *)&hucPatchListSize, &stateCmdSizeParams));
938
939 m_defaultPictureStatesSize = hcpCommandsSize + hucCommandsSize + (uint32_t)cpCmdsize;
940 m_defaultPicturePatchListSize = hcpPatchListSize + hucPatchListSize + (uint32_t)cpPatchListSize;
941
942 return MOS_STATUS_SUCCESS;
943 }
944
945 MOS_STATUS EncodePreEncPacket::SendHwSliceEncodeCommand(
946 MOS_COMMAND_BUFFER &cmdBuffer)
947 {
948 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
949
950 ENCODE_FUNC_CALL();
951
952 // VDENC does not use batch buffer for slice state
953 // add HCP_REF_IDX command
954 ENCODE_CHK_STATUS_RETURN(AddHcpRefIdxStateCmds(&cmdBuffer));
955
956 // add HEVC Slice state commands
957 SETPAR_AND_ADDCMD(HCP_SLICE_STATE, m_hcpItf, &cmdBuffer);
958
959 // add HCP_PAK_INSERT_OBJECTS command
960 ENCODE_CHK_STATUS_RETURN(AddHcpPakInsertObjectCmds(&cmdBuffer));
961
962 // Send VDENC_WEIGHT_OFFSETS_STATE command
963 SETPAR_AND_ADDCMD(VDENC_WEIGHTSOFFSETS_STATE, m_vdencItf, &cmdBuffer);
964
965 SETPAR_AND_ADDCMD(VDENC_HEVC_VP9_TILE_SLICE_STATE, m_vdencItf, &cmdBuffer);
966
967 // Send VDENC_WALKER_STATE command
968 SETPAR_AND_ADDCMD(VDENC_WALKER_STATE, m_vdencItf, &cmdBuffer);
969
970 return eStatus;
971 }
972
973 MHW_SETPAR_DECL_SRC(VDENC_HEVC_VP9_TILE_SLICE_STATE, EncodePreEncPacket)
974 {
975
976 params.numPipe = VDENC_PIPE_SINGLE_PIPE;
977
978 return MOS_STATUS_SUCCESS;
979 }
980
981 MHW_SETPAR_DECL_SRC(HCP_SURFACE_STATE, EncodePreEncPacket)
982 {
983 params.surfaceStateId = m_curHcpSurfStateId;
984
985 return MOS_STATUS_SUCCESS;
986 }
987
988 MHW_SETPAR_DECL_SRC(HCP_SLICE_STATE, EncodePreEncPacket)
989 {
990 ENCODE_FUNC_CALL();
991
992 params.intrareffetchdisable = false;
993
994 return MOS_STATUS_SUCCESS;
995 }
996
997 MOS_STATUS EncodePreEncPacket::AddHcpFqmStateCmds(PMOS_COMMAND_BUFFER cmdBuffer) const
998 {
999 ENCODE_FUNC_CALL();
1000 ENCODE_CHK_NULL_RETURN(cmdBuffer);
1001
1002 MHW_MI_CHK_NULL(m_hevcIqMatrixParams);
1003
1004 auto &params = m_hcpItf->MHW_GETPAR_F(HCP_FQM_STATE)();
1005 params = {};
1006
1007 auto iqMatrix = (PMHW_VDBOX_HEVC_QM_PARAMS)m_hevcIqMatrixParams;
1008 uint16_t *fqMatrix = (uint16_t *)params.quantizermatrix;
1009
1010 /* 4x4 */
1011 for (uint8_t i = 0; i < 32; i++)
1012 {
1013 params.quantizermatrix[i] = 0;
1014 }
1015 for (uint8_t intraInter = 0; intraInter <= 1; intraInter++)
1016 {
1017 params.intraInter = intraInter;
1018 params.sizeid = 0;
1019 params.colorComponent = 0;
1020
1021 for (uint8_t i = 0; i < 16; i++)
1022 {
1023 fqMatrix[i] =
1024 GetReciprocalScalingValue(iqMatrix->List4x4[3 * intraInter][i]);
1025 }
1026
1027 m_hcpItf->MHW_ADDCMD_F(HCP_FQM_STATE)(cmdBuffer);
1028 }
1029
1030 /* 8x8, 16x16 and 32x32 */
1031 for (uint8_t i = 0; i < 32; i++)
1032 {
1033 params.quantizermatrix[i] = 0;
1034 }
1035 for (uint8_t intraInter = 0; intraInter <= 1; intraInter++)
1036 {
1037 params.intraInter = intraInter;
1038 params.sizeid = 1;
1039 params.colorComponent = 0;
1040
1041 for (uint8_t i = 0; i < 64; i++)
1042 {
1043 fqMatrix[i] =
1044 GetReciprocalScalingValue(iqMatrix->List8x8[3 * intraInter][i]);
1045 }
1046
1047 m_hcpItf->MHW_ADDCMD_F(HCP_FQM_STATE)(cmdBuffer);
1048 }
1049
1050 /* 16x16 DC */
1051 for (uint8_t i = 0; i < 32; i++)
1052 {
1053 params.quantizermatrix[i] = 0;
1054 }
1055 for (uint8_t intraInter = 0; intraInter <= 1; intraInter++)
1056 {
1057 params.intraInter = intraInter;
1058 params.sizeid = 2;
1059 params.colorComponent = 0;
1060 params.fqmDcValue1Dc = GetReciprocalScalingValue(iqMatrix->ListDC16x16[3 * intraInter]);
1061
1062 for (uint8_t i = 0; i < 64; i++)
1063 {
1064 fqMatrix[i] =
1065 GetReciprocalScalingValue(iqMatrix->List16x16[3 * intraInter][i]);
1066 }
1067
1068 m_hcpItf->MHW_ADDCMD_F(HCP_FQM_STATE)(cmdBuffer);
1069 }
1070
1071 /* 32x32 DC */
1072 for (uint8_t i = 0; i < 32; i++)
1073 {
1074 params.quantizermatrix[i] = 0;
1075 }
1076 for (uint8_t intraInter = 0; intraInter <= 1; intraInter++)
1077 {
1078 params.intraInter = intraInter;
1079 params.sizeid = 3;
1080 params.colorComponent = 0;
1081 params.fqmDcValue1Dc = GetReciprocalScalingValue(iqMatrix->ListDC32x32[intraInter]);
1082
1083 for (uint8_t i = 0; i < 64; i++)
1084 {
1085 fqMatrix[i] =
1086 GetReciprocalScalingValue(iqMatrix->List32x32[intraInter][i]);
1087 }
1088
1089 m_hcpItf->MHW_ADDCMD_F(HCP_FQM_STATE)(cmdBuffer);
1090 }
1091
1092 return MOS_STATUS_SUCCESS;
1093 }
1094
1095 MOS_STATUS EncodePreEncPacket::AddHcpQMStateCmds(PMOS_COMMAND_BUFFER cmdBuffer) const
1096 {
1097 ENCODE_FUNC_CALL();
1098 ENCODE_CHK_NULL_RETURN(cmdBuffer);
1099
1100 MHW_MI_CHK_NULL(m_hevcIqMatrixParams);
1101
1102 auto &params = m_hcpItf->MHW_GETPAR_F(HCP_QM_STATE)();
1103 params = {};
1104
1105 auto iqMatrix = (PMHW_VDBOX_HEVC_QM_PARAMS)m_hevcIqMatrixParams;
1106 uint8_t *qMatrix = (uint8_t *)params.quantizermatrix;
1107
1108 for (uint8_t sizeId = 0; sizeId < 4; sizeId++) // 4x4, 8x8, 16x16, 32x32
1109 {
1110 for (uint8_t predType = 0; predType < 2; predType++) // Intra, Inter
1111 {
1112 for (uint8_t color = 0; color < 3; color++) // Y, Cb, Cr
1113 {
1114 if ((sizeId == 3) && (color != 0))
1115 break;
1116
1117 params.sizeid = sizeId;
1118 params.predictionType = predType;
1119 params.colorComponent = color;
1120 switch (sizeId)
1121 {
1122 case 0:
1123 case 1:
1124 default:
1125 params.dcCoefficient = 0;
1126 break;
1127 case 2:
1128 params.dcCoefficient = iqMatrix->ListDC16x16[3 * predType + color];
1129 break;
1130 case 3:
1131 params.dcCoefficient = iqMatrix->ListDC32x32[predType];
1132 break;
1133 }
1134
1135 if (sizeId == 0)
1136 {
1137 for (uint8_t i = 0; i < 4; i++)
1138 {
1139 for (uint8_t ii = 0; ii < 4; ii++)
1140 {
1141 qMatrix[4 * i + ii] = iqMatrix->List4x4[3 * predType + color][4 * i + ii];
1142 }
1143 }
1144 }
1145 else if (sizeId == 1)
1146 {
1147 for (uint8_t i = 0; i < 8; i++)
1148 {
1149 for (uint8_t ii = 0; ii < 8; ii++)
1150 {
1151 qMatrix[8 * i + ii] = iqMatrix->List8x8[3 * predType + color][8 * i + ii];
1152 }
1153 }
1154 }
1155 else if (sizeId == 2)
1156 {
1157 for (uint8_t i = 0; i < 8; i++)
1158 {
1159 for (uint8_t ii = 0; ii < 8; ii++)
1160 {
1161 qMatrix[8 * i + ii] = iqMatrix->List16x16[3 * predType + color][8 * i + ii];
1162 }
1163 }
1164 }
1165 else // 32x32
1166 {
1167 for (uint8_t i = 0; i < 8; i++)
1168 {
1169 for (uint8_t ii = 0; ii < 8; ii++)
1170 {
1171 qMatrix[8 * i + ii] = iqMatrix->List32x32[predType][8 * i + ii];
1172 }
1173 }
1174 }
1175
1176 m_hcpItf->MHW_ADDCMD_F(HCP_QM_STATE)(cmdBuffer);
1177 }
1178 }
1179 }
1180
1181 return MOS_STATUS_SUCCESS;
1182 }
1183
1184 MOS_STATUS EncodePreEncPacket::AddHcpPakInsertObjectCmds(PMOS_COMMAND_BUFFER cmdBuffer) const
1185 {
1186 ENCODE_FUNC_CALL();
1187
1188 ENCODE_CHK_NULL_RETURN(m_osInterface);
1189 ENCODE_CHK_NULL_RETURN(cmdBuffer);
1190
1191 auto &params = m_hcpItf->MHW_GETPAR_F(HCP_PAK_INSERT_OBJECT)();
1192 params = {};
1193
1194 PCODECHAL_NAL_UNIT_PARAMS *ppNalUnitParams = (CODECHAL_NAL_UNIT_PARAMS **)m_nalUnitParams;
1195
1196 PBSBuffer pBsBuffer = &(m_basicFeature->m_bsBuffer);
1197 uint32_t bitSize = 0;
1198 uint32_t offSet = 0;
1199
1200 //insert AU, SPS, PSP headers before first slice header
1201 uint32_t maxBytesInPakInsertObjCmd = ((2 << 11) - 1) * 4; // 12 bits for Length field in PAK_INSERT_OBJ cmd
1202
1203 for (uint32_t i = 0; i < m_basicFeature->m_NumNalUnits; i++)
1204 {
1205 uint32_t nalunitPosiSize = ppNalUnitParams[i]->uiSize;
1206 uint32_t nalunitPosiOffset = ppNalUnitParams[i]->uiOffset;
1207
1208 while (nalunitPosiSize > 0)
1209 {
1210 bitSize = MOS_MIN(maxBytesInPakInsertObjCmd * 8, nalunitPosiSize * 8);
1211 offSet = nalunitPosiOffset;
1212
1213 params = {};
1214
1215 params.dwPadding = (MOS_ALIGN_CEIL((bitSize + 7) >> 3, sizeof(uint32_t))) / sizeof(uint32_t);
1216 params.bEmulationByteBitsInsert = ppNalUnitParams[i]->bInsertEmulationBytes;
1217 params.uiSkipEmulationCheckCount = ppNalUnitParams[i]->uiSkipEmulationCheckCount;
1218 params.dataBitsInLastDw = bitSize % 32;
1219 if (params.dataBitsInLastDw == 0)
1220 {
1221 params.dataBitsInLastDw = 32;
1222 }
1223
1224 if (nalunitPosiSize > maxBytesInPakInsertObjCmd)
1225 {
1226 nalunitPosiSize -= maxBytesInPakInsertObjCmd;
1227 nalunitPosiOffset += maxBytesInPakInsertObjCmd;
1228 }
1229 else
1230 {
1231 nalunitPosiSize = 0;
1232 }
1233 m_hcpItf->MHW_ADDCMD_F(HCP_PAK_INSERT_OBJECT)(cmdBuffer);
1234 uint32_t byteSize = (bitSize + 7) >> 3;
1235 if (byteSize)
1236 {
1237 MHW_MI_CHK_NULL(pBsBuffer);
1238 MHW_MI_CHK_NULL(pBsBuffer->pBase);
1239 uint8_t *data = (uint8_t *)(pBsBuffer->pBase + offSet);
1240 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, data, byteSize));
1241 }
1242 }
1243 }
1244
1245 params = {};
1246 // Insert slice header
1247 params.bLastHeader = true;
1248 params.bEmulationByteBitsInsert = true;
1249
1250 // App does the slice header packing, set the skip count passed by the app
1251 PCODEC_ENCODER_SLCDATA slcData = m_basicFeature->m_slcData;
1252
1253 params.uiSkipEmulationCheckCount = slcData->SkipEmulationByteCount;
1254 bitSize = slcData->BitSize;
1255 offSet = slcData->SliceOffset;
1256
1257 // Hevc header needs slcData->BitSize > 0 to caculate params.dwPadding and params.dataBitsInLastDw for cmd HCP_PAK_INSERT_OBJECT.
1258 // For Av1, slcData params are zeros. Av1 use Hevc preEnc packet, need to set bitSize>0.
1259 // The bitstream header size will have no effect on the mv.
1260 if (bitSize == 0)
1261 {
1262 bitSize = sizeof(uint8_t) * 8;
1263 }
1264
1265 params.dwPadding = (MOS_ALIGN_CEIL((bitSize + 7) >> 3, sizeof(uint32_t))) / sizeof(uint32_t);
1266 params.dataBitsInLastDw = bitSize % 32;
1267 if (params.dataBitsInLastDw == 0)
1268 {
1269 params.dataBitsInLastDw = 32;
1270 }
1271 m_hcpItf->MHW_ADDCMD_F(HCP_PAK_INSERT_OBJECT)(cmdBuffer);
1272 uint32_t byteSize = (bitSize + 7) >> 3;
1273 if (byteSize)
1274 {
1275 MHW_MI_CHK_NULL(pBsBuffer);
1276 MHW_MI_CHK_NULL(pBsBuffer->pBase);
1277 uint8_t *data = (uint8_t *)(pBsBuffer->pBase + offSet);
1278 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, data, byteSize));
1279 }
1280
1281 return MOS_STATUS_SUCCESS;
1282 }
1283
1284 MOS_STATUS EncodePreEncPacket::AddHcpRefIdxStateCmds(PMOS_COMMAND_BUFFER cmdBuffer) const
1285 {
1286 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1287 ENCODE_FUNC_CALL();
1288 ENCODE_CHK_NULL_RETURN(cmdBuffer);
1289
1290 auto &params = m_hcpItf->MHW_GETPAR_F(HCP_REF_IDX_STATE)();
1291 params = {};
1292
1293 CODEC_PICTURE currPic = {};
1294 CODEC_PICTURE refPicList[2][CODEC_MAX_NUM_REF_FRAME_HEVC] = {};
1295 void ** hevcRefList = nullptr;
1296 int32_t pocCurrPic = 0;
1297 int8_t * pRefIdxMapping = nullptr;
1298 int32_t pocList[CODEC_MAX_NUM_REF_FRAME_HEVC] = {};
1299
1300 if (m_basicFeature->m_preEncConfig.SliceType != encodeHevcISlice)
1301 {
1302 currPic = m_basicFeature->m_preEncConfig.CurrReconstructedPic;
1303 params.ucList = LIST_0;
1304 params.numRefIdxLRefpiclistnumActiveMinus1 = 0;
1305 eStatus = MOS_SecureMemcpy(&refPicList, sizeof(refPicList), &m_basicFeature->m_preEncConfig.RefPicList, sizeof(m_basicFeature->m_preEncConfig.RefPicList));
1306 if (eStatus != MOS_STATUS_SUCCESS)
1307 {
1308 ENCODE_ASSERTMESSAGE("Failed to copy memory.");
1309 return eStatus;
1310 }
1311
1312 hevcRefList = (void **)m_basicFeature->GetRefList();
1313 pocCurrPic = m_basicFeature->m_preEncConfig.CurrPicOrderCnt;
1314 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
1315 {
1316 pocList[i] = m_basicFeature->m_preEncConfig.RefFramePOCList[i];
1317 }
1318
1319 pRefIdxMapping = m_basicFeature->GetRefIdxMapping();
1320
1321 MHW_ASSERT(currPic.FrameIdx != 0x7F);
1322
1323 for (uint8_t i = 0; i <= params.numRefIdxLRefpiclistnumActiveMinus1; i++)
1324 {
1325 uint8_t refFrameIDx = refPicList[params.ucList][i].FrameIdx;
1326 if (refFrameIDx < CODEC_MAX_NUM_REF_FRAME_HEVC)
1327 {
1328 MHW_ASSERT(*(pRefIdxMapping + refFrameIDx) >= 0);
1329
1330 params.listEntryLxReferencePictureFrameIdRefaddr07[i] = *(pRefIdxMapping + refFrameIDx);
1331 int32_t pocDiff = pocCurrPic - pocList[refFrameIDx];
1332 params.referencePictureTbValue[i] = (uint8_t)CodecHal_Clip3(-128, 127, pocDiff);
1333 CODEC_REF_LIST **refList = (CODEC_REF_LIST **)hevcRefList;
1334 params.longtermreference[i] = CodecHal_PictureIsLongTermRef(refList[currPic.FrameIdx]->RefList[refFrameIDx]);
1335 params.bottomFieldFlag[i] = 1;
1336 }
1337 else
1338 {
1339 params.listEntryLxReferencePictureFrameIdRefaddr07[i] = 0;
1340 params.referencePictureTbValue[i] = 0;
1341 params.longtermreference[i] = false;
1342 params.bottomFieldFlag[i] = 0;
1343 }
1344 }
1345
1346 for (uint8_t i = (uint8_t)(params.numRefIdxLRefpiclistnumActiveMinus1 + 1); i < 16; i++)
1347 {
1348 params.listEntryLxReferencePictureFrameIdRefaddr07[i] = 0;
1349 params.referencePictureTbValue[i] = 0;
1350 params.longtermreference[i] = false;
1351 params.bottomFieldFlag[i] = 0;
1352 }
1353
1354 m_hcpItf->MHW_ADDCMD_F(HCP_REF_IDX_STATE)(cmdBuffer);
1355
1356 params = {};
1357
1358 if (m_basicFeature->m_preEncConfig.SliceType == encodeHevcBSlice)
1359 {
1360 AddHcpBSliceRefIdxStateCmds(cmdBuffer);
1361 }
1362 }
1363
1364 return MOS_STATUS_SUCCESS;
1365 }
1366
1367 MOS_STATUS EncodePreEncPacket::AddHcpBSliceRefIdxStateCmds(PMOS_COMMAND_BUFFER cmdBuffer) const
1368 {
1369 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1370 ENCODE_FUNC_CALL();
1371 ENCODE_CHK_NULL_RETURN(cmdBuffer);
1372
1373 auto &params = m_hcpItf->MHW_GETPAR_F(HCP_REF_IDX_STATE)();
1374 params = {};
1375
1376 CODEC_PICTURE currPic = {};
1377 CODEC_PICTURE refPicList[2][CODEC_MAX_NUM_REF_FRAME_HEVC] = {};
1378 void ** hevcRefList = nullptr;
1379 int32_t pocCurrPic = 0;
1380 int8_t * pRefIdxMapping = nullptr;
1381 int32_t pocList[CODEC_MAX_NUM_REF_FRAME_HEVC] = {};
1382
1383 currPic = m_basicFeature->m_preEncConfig.CurrReconstructedPic;
1384 eStatus = MOS_SecureMemcpy(&refPicList, sizeof(refPicList), &m_basicFeature->m_preEncConfig.RefPicList, sizeof(m_basicFeature->m_preEncConfig.RefPicList));
1385 if (eStatus != MOS_STATUS_SUCCESS)
1386 {
1387 ENCODE_ASSERTMESSAGE("Failed to copy memory.");
1388 return eStatus;
1389 }
1390 hevcRefList = (void **)m_basicFeature->GetRefList();
1391 pocCurrPic = m_basicFeature->m_preEncConfig.CurrPicOrderCnt;
1392 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
1393 {
1394 pocList[i] = m_basicFeature->m_preEncConfig.RefFramePOCList[i];
1395 }
1396
1397 pRefIdxMapping = m_basicFeature->GetRefIdxMapping();
1398
1399 MHW_ASSERT(currPic.FrameIdx != 0x7F);
1400
1401 params.ucList = LIST_1;
1402 params.numRefIdxLRefpiclistnumActiveMinus1 = 0;
1403 for (uint8_t i = 0; i <= params.numRefIdxLRefpiclistnumActiveMinus1; i++)
1404 {
1405 uint8_t refFrameIDx = m_basicFeature->m_preEncConfig.isPToB ? refPicList[0][i].FrameIdx : refPicList[1][i].FrameIdx;
1406 if (refFrameIDx < CODEC_MAX_NUM_REF_FRAME_HEVC)
1407 {
1408 MHW_ASSERT(*(pRefIdxMapping + refFrameIDx) >= 0);
1409
1410 params.listEntryLxReferencePictureFrameIdRefaddr07[i] = *(pRefIdxMapping + refFrameIDx);
1411 int32_t pocDiff = pocCurrPic - pocList[refFrameIDx];
1412 params.referencePictureTbValue[i] = (uint8_t)CodecHal_Clip3(-128, 127, pocDiff);
1413 CODEC_REF_LIST **refList = (CODEC_REF_LIST **)hevcRefList;
1414 params.longtermreference[i] = CodecHal_PictureIsLongTermRef(refList[currPic.FrameIdx]->RefList[refFrameIDx]);
1415 params.bottomFieldFlag[i] = 1;
1416 }
1417 else
1418 {
1419 params.listEntryLxReferencePictureFrameIdRefaddr07[i] = 0;
1420 params.referencePictureTbValue[i] = 0;
1421 params.longtermreference[i] = false;
1422 params.bottomFieldFlag[i] = 0;
1423 }
1424 }
1425
1426 for (uint8_t i = (uint8_t)(params.numRefIdxLRefpiclistnumActiveMinus1 + 1); i < 16; i++)
1427 {
1428 params.listEntryLxReferencePictureFrameIdRefaddr07[i] = 0;
1429 params.referencePictureTbValue[i] = 0;
1430 params.longtermreference[i] = false;
1431 params.bottomFieldFlag[i] = 0;
1432 }
1433 m_hcpItf->MHW_ADDCMD_F(HCP_REF_IDX_STATE)(cmdBuffer);
1434 return eStatus;
1435 }
1436 } // namespace encode