Debian Codegraph @

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

raw
1 /*
2 * Copyright (c) 2020, 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_packet_utilities.cpp
24 //! \brief Defines encode packrt utilities.
25 //!
26
27 #include "encode_packet_utilities.h"
28 #include "codec_def_common_encode.h"
29
30 namespace encode {
31 MOS_STATUS PacketUtilities::Init()
32 {
33 #if USE_CODECHAL_DEBUG_TOOL
34 MediaUserSetting::Value outValue;
35 ReadUserSettingForDebug(
36 m_userSettingPtr,
37 outValue,
38 "Fake Header Size Enable",
39 MediaUserSetting::Group::Sequence);
40 m_enableFakeHrdSize = outValue.Get<uint32_t>();
41
42 ReadUserSettingForDebug(
43 m_userSettingPtr,
44 outValue,
45 "Fake IFrame Header Size",
46 MediaUserSetting::Group::Sequence);
47 m_fakeIFrameHrdSize = outValue.Get<uint32_t>();
48
49 ReadUserSettingForDebug(
50 m_userSettingPtr,
51 outValue,
52 "Fake PBFrame Header Size",
53 MediaUserSetting::Group::Sequence);
54 m_fakePBFrameHrdSize = outValue.Get<uint32_t>();
55 #endif
56
57 return MOS_STATUS_SUCCESS;
58 }
59
60 PacketUtilities::PacketUtilities(CodechalHwInterfaceNext *hwInterface, MediaFeatureManager *featureManager)
61 {
62 m_hwInterface = hwInterface;
63 m_featureManager = featureManager;
64
65 ENCODE_CHK_NULL_NO_STATUS_RETURN(hwInterface);
66 m_miItf = hwInterface->GetMiInterfaceNext();
67 auto osInterface = hwInterface->GetOsInterface();
68 ENCODE_CHK_NULL_NO_STATUS_RETURN(osInterface);
69 m_userSettingPtr = osInterface->pfnGetUserSettingInstance(osInterface);
70 if (!m_userSettingPtr)
71 {
72 ENCODE_NORMALMESSAGE("Initialize m_userSettingPtr instance failed!");
73 }
74 }
75
76 PacketUtilities::~PacketUtilities()
77 {
78 }
79
80 MOS_STATUS PacketUtilities::AddMemCopyCmd(PMOS_COMMAND_BUFFER cmdBuf, PMOS_RESOURCE pDst, PMOS_RESOURCE pSrc, uint32_t size)
81 {
82 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
83
84 ENCODE_FUNC_CALL();
85
86 ENCODE_CHK_NULL_RETURN(cmdBuf);
87 ENCODE_CHK_NULL_RETURN(pDst);
88 ENCODE_CHK_NULL_RETURN(pSrc);
89 ENCODE_CHK_NULL_RETURN(m_miItf);
90
91 auto &copyMemMemParams = m_miItf->MHW_GETPAR_F(MI_COPY_MEM_MEM)();
92 copyMemMemParams = {};
93 copyMemMemParams.presSrc = pSrc;
94 copyMemMemParams.presDst = pDst;
95 for (uint32_t i = 0; i < size; i = i + 4)
96 {
97 copyMemMemParams.dwSrcOffset = i;
98 copyMemMemParams.dwDstOffset = i;
99 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_COPY_MEM_MEM)(cmdBuf));
100 }
101 // Make Flush DW call to make sure all previous work is done
102 auto &flushDwParams = m_miItf->MHW_GETPAR_F(MI_FLUSH_DW)();
103 flushDwParams = {};
104 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_FLUSH_DW)(cmdBuf));
105 return eStatus;
106 }
107
108 MOS_STATUS PacketUtilities::AddStoreDataImmCmd(PMOS_COMMAND_BUFFER cmdBuf, PMOS_RESOURCE pSrc, uint32_t offset, uint32_t flag)
109 {
110 ENCODE_FUNC_CALL();
111 auto &storeDataParam = m_miItf->MHW_GETPAR_F(MI_STORE_DATA_IMM)();
112 storeDataParam = {};
113 storeDataParam.pOsResource = pSrc;
114 storeDataParam.dwResourceOffset = offset;
115 storeDataParam.dwValue = flag;
116 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_DATA_IMM)(cmdBuf));
117
118 auto &flushDwParams = m_miItf->MHW_GETPAR_F(MI_FLUSH_DW)();
119 flushDwParams = {};
120 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_FLUSH_DW)(cmdBuf));
121 return MOS_STATUS_SUCCESS;
122 }
123
124 MOS_STATUS PacketUtilities::SendMarkerCommand(PMOS_COMMAND_BUFFER cmdBuffer, PMOS_RESOURCE presSetMarker)
125 {
126 ENCODE_FUNC_CALL();
127
128 ENCODE_CHK_NULL_RETURN(cmdBuffer);
129
130 EncodeBasicFeature *basicFeature = dynamic_cast<EncodeBasicFeature *>(m_featureManager->GetFeature(FeatureIDs::basicFeature));
131 ENCODE_CHK_NULL_RETURN(basicFeature);
132
133 if (presSetMarker == nullptr)
134 {
135 return MOS_STATUS_SUCCESS;
136 }
137
138 // Send flush_dw to get the timestamp
139 auto &params = m_miItf->MHW_GETPAR_F(MI_FLUSH_DW)();
140 params = {};
141 params.pOsResource = presSetMarker;
142 params.dwResourceOffset = 0; //sizeof(uint64_t);
143 params.postSyncOperation = MHW_FLUSH_WRITE_TIMESTAMP_REG;
144 params.bQWordEnable = 1;
145 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_FLUSH_DW)(cmdBuffer));
146
147 return MOS_STATUS_SUCCESS;
148 }
149
150 MOS_STATUS PacketUtilities::SendPredicationCommand(PMOS_COMMAND_BUFFER cmdBuffer)
151 {
152 ENCODE_FUNC_CALL();
153
154 ENCODE_CHK_NULL_RETURN(cmdBuffer);
155
156 EncodeBasicFeature *basicFeature = dynamic_cast<EncodeBasicFeature *>(m_featureManager->GetFeature(FeatureIDs::basicFeature));
157 ENCODE_CHK_NULL_RETURN(basicFeature);
158
159 // Predication can be set based on the value of 64-bits within a buffer
160 auto PreparePredicationBuf = [&](bool predicationNotEqualZero) {
161 auto mmioRegistersMfx = m_hwInterface->SelectVdAndGetMmioReg(m_vdboxIndex, cmdBuffer);
162 auto &flushDwParams = m_miItf->MHW_GETPAR_F(MI_FLUSH_DW)();
163 flushDwParams = {};
164 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_FLUSH_DW)(cmdBuffer));
165
166 // load presPredication to general purpose register0
167 auto &miLoadRegMemParams = m_miItf->MHW_GETPAR_F(MI_LOAD_REGISTER_MEM)();
168 miLoadRegMemParams = {};
169 miLoadRegMemParams.presStoreBuffer = basicFeature->m_presPredication;
170 miLoadRegMemParams.dwOffset = (uint32_t)basicFeature->m_predicationResOffset;
171 miLoadRegMemParams.dwRegister = mmioRegistersMfx->generalPurposeRegister0LoOffset;
172 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_MEM)(cmdBuffer));
173
174 auto &miLoadRegImmParams = m_miItf->MHW_GETPAR_F(MI_LOAD_REGISTER_IMM)();
175 miLoadRegImmParams = {};
176 miLoadRegImmParams.dwData = 0;
177 miLoadRegImmParams.dwRegister = mmioRegistersMfx->generalPurposeRegister0HiOffset;
178 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_IMM)(cmdBuffer));
179
180 miLoadRegMemParams = {};
181 miLoadRegMemParams.presStoreBuffer = basicFeature->m_presPredication;
182 miLoadRegMemParams.dwOffset = (uint32_t)basicFeature->m_predicationResOffset + sizeof(uint32_t);
183 miLoadRegMemParams.dwRegister = mmioRegistersMfx->generalPurposeRegister4LoOffset;
184 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_MEM)(cmdBuffer));
185
186 miLoadRegImmParams = {};
187 miLoadRegImmParams.dwData = 0;
188 miLoadRegImmParams.dwRegister = mmioRegistersMfx->generalPurposeRegister4HiOffset;
189 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_IMM)(cmdBuffer));
190
191 mhw::mi::MHW_MI_ALU_PARAMS miAluParams[4] = {};
192 miAluParams[0].AluOpcode = MHW_MI_ALU_LOAD;
193 miAluParams[0].Operand1 = MHW_MI_ALU_SRCA;
194 miAluParams[0].Operand2 = MHW_MI_ALU_GPREG0;
195 // load srcB, reg4
196 miAluParams[1].AluOpcode = MHW_MI_ALU_LOAD;
197 miAluParams[1].Operand1 = MHW_MI_ALU_SRCB;
198 miAluParams[1].Operand2 = MHW_MI_ALU_GPREG4;
199 // add srcA, srcB
200 miAluParams[2].AluOpcode = predicationNotEqualZero ? MHW_MI_ALU_ADD : MHW_MI_ALU_OR;
201 miAluParams[2].Operand1 = MHW_MI_ALU_SRCB;
202 miAluParams[2].Operand2 = MHW_MI_ALU_GPREG4;
203 // store reg0, ZF
204 miAluParams[3].AluOpcode = MHW_MI_ALU_STORE;
205 miAluParams[3].Operand1 = MHW_MI_ALU_GPREG0;
206 miAluParams[3].Operand2 = predicationNotEqualZero ? MHW_MI_ALU_ZF : MHW_MI_ALU_ACCU;
207
208 auto &miMathParams = m_miItf->MHW_GETPAR_F(MI_MATH)();
209 miMathParams = {};
210 miMathParams.pAluPayload = miAluParams;
211 miMathParams.dwNumAluParams = 4;
212 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_MATH)(cmdBuffer));
213
214 // if MHW_MI_ALU_ZF, the zero flag will be 0xFFFFFFFF, else zero flag will be 0x0.
215 // if MHW_MI_ALU_ACCU, the OR result directly copied
216 auto &miStoreRegMemParams = m_miItf->MHW_GETPAR_F(MI_STORE_REGISTER_MEM)();
217 miStoreRegMemParams = {};
218 miStoreRegMemParams.presStoreBuffer = basicFeature->m_predicationBuffer;
219 miStoreRegMemParams.dwOffset = 0;
220 miStoreRegMemParams.dwRegister = mmioRegistersMfx->generalPurposeRegister0LoOffset;
221 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_REGISTER_MEM)(cmdBuffer));
222
223 ENCODE_CHK_NULL_RETURN(basicFeature->m_tempPredicationBuffer);
224 *basicFeature->m_tempPredicationBuffer = basicFeature->m_predicationBuffer;
225
226 return MOS_STATUS_SUCCESS;
227 };
228
229 ENCODE_CHK_STATUS_RETURN(PreparePredicationBuf(basicFeature->m_predicationNotEqualZero));
230
231 auto &miConditionalBatchBufferEndParams = m_miItf->MHW_GETPAR_F(MI_CONDITIONAL_BATCH_BUFFER_END)();
232 miConditionalBatchBufferEndParams = {};
233 miConditionalBatchBufferEndParams.dwOffset = 0;
234 miConditionalBatchBufferEndParams.dwValue = 0;
235 miConditionalBatchBufferEndParams.bDisableCompareMask = true;
236 miConditionalBatchBufferEndParams.presSemaphoreBuffer = basicFeature->m_predicationBuffer;
237 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_CONDITIONAL_BATCH_BUFFER_END)(cmdBuffer));
238
239 return MOS_STATUS_SUCCESS;
240 }
241
242 #if USE_CODECHAL_DEBUG_TOOL
243 MOS_STATUS PacketUtilities::ModifyEncodedFrameSizeWithFakeHeaderSize(
244 PMOS_COMMAND_BUFFER cmdBuffer,
245 uint32_t fakeHeaderSizeInByte,
246 PMOS_RESOURCE resBrcUpdateCurbe,
247 uint32_t targetSizePos,
248 PMOS_RESOURCE resPakStat,
249 uint32_t slcHrdSizePos)
250 {
251 ENCODE_FUNC_CALL();
252
253 ENCODE_CHK_NULL_RETURN(m_featureManager);
254 EncodeBasicFeature* basicFeature = dynamic_cast<EncodeBasicFeature*>(m_featureManager->GetFeature(FeatureIDs::basicFeature));
255 ENCODE_CHK_NULL_RETURN(basicFeature);
256
257 //calculate slice headers size
258 PCODEC_ENCODER_SLCDATA slcData = basicFeature->m_slcData;
259 ENCODE_CHK_NULL_RETURN(slcData);
260 uint32_t totalSliceHeaderSize = 0;
261 for (uint32_t slcCount = 0; slcCount < basicFeature->m_numSlices; slcCount++)
262 {
263 totalSliceHeaderSize += (slcData->BitSize + 7) >> 3;
264 slcData++;
265 }
266
267 uint32_t firstHdrSz = 0;
268 for (uint32_t i = 0; i < basicFeature->m_NumNalUnits; i++)
269 {
270 firstHdrSz += basicFeature->m_nalUnitParams[i]->uiSize;
271 }
272
273 totalSliceHeaderSize += firstHdrSz;
274
275 ENCODE_CHK_STATUS_RETURN(AddBufferWithIMMValue(
276 cmdBuffer,
277 resBrcUpdateCurbe,
278 targetSizePos,
279 fakeHeaderSizeInByte - totalSliceHeaderSize,
280 true));
281
282 ENCODE_CHK_STATUS_RETURN(AddBufferWithIMMValue(
283 cmdBuffer,
284 resPakStat,
285 slcHrdSizePos,
286 fakeHeaderSizeInByte * 8,
287 true));
288
289 return MOS_STATUS_SUCCESS;
290 }
291
292 MOS_STATUS PacketUtilities::ModifyEncodedFrameSizeWithFakeHeaderSizeAVC(
293 PMOS_COMMAND_BUFFER cmdBuffer,
294 uint32_t fakeHeaderSizeInByte,
295 PMOS_RESOURCE *resBrcUpdateCurbe,
296 uint32_t targetSizePos,
297 PMOS_RESOURCE resPakStat,
298 uint32_t slcHrdSizePos)
299 {
300 ENCODE_FUNC_CALL();
301
302 ENCODE_CHK_NULL_RETURN(m_featureManager);
303 EncodeBasicFeature *basicFeature = dynamic_cast<EncodeBasicFeature *>(m_featureManager->GetFeature(FeatureIDs::basicFeature));
304 ENCODE_CHK_NULL_RETURN(basicFeature);
305
306 //calculate all frame headers size, including 1st slice header
307 uint32_t totalHeaderSize = uint32_t(basicFeature->m_bsBuffer.pCurrent - basicFeature->m_bsBuffer.pBase);
308
309 // change encoded frame size for next frame and next pass
310 for (int i = 0; i < 2; i++)
311 {
312 if (resBrcUpdateCurbe[i] == nullptr)
313 continue;
314 ENCODE_CHK_STATUS_RETURN(AddBufferWithIMMValue(
315 cmdBuffer,
316 resBrcUpdateCurbe[i],
317 sizeof(uint32_t) * 5,
318 fakeHeaderSizeInByte - totalHeaderSize,
319 true));
320 }
321
322 // change headers size (U16)
323 ENCODE_CHK_STATUS_RETURN(SetBufferWithIMMValueU16(
324 cmdBuffer,
325 resPakStat,
326 0,
327 fakeHeaderSizeInByte * 8,
328 0)); // second or first word in dword
329
330 return MOS_STATUS_SUCCESS;
331 }
332
333 MOS_STATUS PacketUtilities::AddBufferWithIMMValue(
334 PMOS_COMMAND_BUFFER cmdBuffer,
335 PMOS_RESOURCE presStoreBuffer,
336 uint32_t offset,
337 uint32_t value,
338 bool bAdd)
339 {
340 MHW_MI_STORE_REGISTER_MEM_PARAMS StoreRegParams;
341 MHW_MI_STORE_DATA_PARAMS StoreDataParams;
342 MHW_MI_LOAD_REGISTER_REG_PARAMS LoadRegRegParams;
343 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
344
345 ENCODE_FUNC_CALL();
346
347 ENCODE_CHK_NULL_RETURN(m_hwInterface);
348
349 if (m_vdboxIndex > m_hwInterface->GetMaxVdboxIndex())
350 {
351 ENCODE_ASSERTMESSAGE("ERROR - vdbox index exceed the maximum");
352 eStatus = MOS_STATUS_INVALID_PARAMETER;
353 return eStatus;
354 }
355
356 auto pMmioRegisters = m_hwInterface->GetVdencInterfaceNext()->GetMmioRegisters(m_vdboxIndex);
357
358 auto &parFlush = m_miItf->MHW_GETPAR_F(MI_FLUSH_DW)();
359 parFlush = {};
360 m_miItf->MHW_ADDCMD_F(MI_FLUSH_DW)(cmdBuffer);
361
362 MOS_ZeroMemory(&LoadRegRegParams, sizeof(LoadRegRegParams));
363
364 auto &registerMemParams = m_miItf->MHW_GETPAR_F(MI_LOAD_REGISTER_MEM)();
365 registerMemParams = {};
366 registerMemParams.presStoreBuffer = presStoreBuffer;
367 registerMemParams.dwOffset = offset;
368 registerMemParams.dwRegister = pMmioRegisters->generalPurposeRegister0LoOffset;
369 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_MEM)(cmdBuffer));
370
371 auto &loadRegImmParams = m_miItf->MHW_GETPAR_F(MI_LOAD_REGISTER_IMM)();
372 loadRegImmParams = {};
373 loadRegImmParams.dwRegister = pMmioRegisters->generalPurposeRegister0HiOffset;
374 loadRegImmParams.dwData = 0;
375 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_IMM)(cmdBuffer));
376
377 loadRegImmParams = {};
378 loadRegImmParams.dwData = value;
379 loadRegImmParams.dwRegister = pMmioRegisters->generalPurposeRegister4LoOffset;
380 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_IMM)(cmdBuffer));
381
382 loadRegImmParams = {};
383 loadRegImmParams.dwData = 0;
384 loadRegImmParams.dwRegister = pMmioRegisters->generalPurposeRegister4HiOffset;
385 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_IMM)(cmdBuffer));
386
387 mhw::mi::MHW_MI_ALU_PARAMS aluParams[4] = {0};
388 int aluCount = 0;
389
390 // load srcA, reg0
391 aluParams[aluCount].AluOpcode = MHW_MI_ALU_LOAD;
392 aluParams[aluCount].Operand1 = MHW_MI_ALU_SRCA;
393 aluParams[aluCount].Operand2 = MHW_MI_ALU_GPREG0;
394 ++aluCount;
395 // load srcB, reg4
396 aluParams[aluCount].AluOpcode = MHW_MI_ALU_LOAD;
397 aluParams[aluCount].Operand1 = MHW_MI_ALU_SRCB;
398 aluParams[aluCount].Operand2 = MHW_MI_ALU_GPREG4;
399 ++aluCount;
400 if (bAdd)
401 {
402 // add srcA, srcB
403 aluParams[aluCount].AluOpcode = MHW_MI_ALU_ADD;
404 }
405 else
406 {
407 // sub srcA, srcB
408 aluParams[aluCount].AluOpcode = MHW_MI_ALU_SUB;
409 }
410 ++aluCount;
411 // store reg0, ACCU
412 aluParams[aluCount].AluOpcode = MHW_MI_ALU_STORE;
413 aluParams[aluCount].Operand1 = MHW_MI_ALU_GPREG0;
414 aluParams[aluCount].Operand2 = MHW_MI_ALU_ACCU;
415 ++aluCount;
416
417 auto &miMathParams = m_miItf->MHW_GETPAR_F(MI_MATH)();
418 miMathParams = {};
419 miMathParams.dwNumAluParams = aluCount;
420 miMathParams.pAluPayload = aluParams;
421 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_MATH)(cmdBuffer));
422
423 // update the value
424 auto &miStoreRegMemParams = m_miItf->MHW_GETPAR_F(MI_STORE_REGISTER_MEM)();
425 miStoreRegMemParams = {};
426 miStoreRegMemParams.presStoreBuffer = presStoreBuffer;
427 miStoreRegMemParams.dwOffset = offset;
428 miStoreRegMemParams.dwRegister = pMmioRegisters->generalPurposeRegister0LoOffset;
429 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_REGISTER_MEM)(cmdBuffer));
430 return eStatus;
431 }
432
433 MOS_STATUS PacketUtilities::SetBufferWithIMMValueU16(
434 PMOS_COMMAND_BUFFER cmdBuffer,
435 PMOS_RESOURCE presStoreBuffer,
436 uint32_t offset,
437 uint32_t value,
438 bool bSecond)
439 {
440 MHW_MI_STORE_REGISTER_MEM_PARAMS StoreRegParams;
441 MHW_MI_LOAD_REGISTER_IMM_PARAMS LoadRegisterImmParams;
442 MHW_MI_MATH_PARAMS MiMathParams;
443 MHW_MI_ALU_PARAMS MiAluParams[4]; // is used twice
444 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
445
446 ENCODE_FUNC_CALL();
447
448 ENCODE_CHK_NULL_RETURN(m_hwInterface);
449
450 if (m_vdboxIndex > m_hwInterface->GetMaxVdboxIndex())
451 {
452 ENCODE_ASSERTMESSAGE("ERROR - vdbox index exceed the maximum");
453 eStatus = MOS_STATUS_INVALID_PARAMETER;
454 return eStatus;
455 }
456
457 auto pMmioRegisters = m_hwInterface->GetVdencInterfaceNext()->GetMmioRegisters(m_vdboxIndex);
458
459 auto &parFlush = m_miItf->MHW_GETPAR_F(MI_FLUSH_DW)();
460 parFlush = {};
461 m_miItf->MHW_ADDCMD_F(MI_FLUSH_DW)(cmdBuffer);
462
463 auto &registerMemParams = m_miItf->MHW_GETPAR_F(MI_LOAD_REGISTER_MEM)();
464 registerMemParams = {};
465 registerMemParams.presStoreBuffer = presStoreBuffer;
466 registerMemParams.dwOffset = offset;
467 registerMemParams.dwRegister = pMmioRegisters->generalPurposeRegister0LoOffset;
468 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_MEM)(cmdBuffer));
469
470 auto &loadRegImmParams = m_miItf->MHW_GETPAR_F(MI_LOAD_REGISTER_IMM)();
471 loadRegImmParams = {};
472 loadRegImmParams.dwRegister = pMmioRegisters->generalPurposeRegister0HiOffset;
473 loadRegImmParams.dwData = 0;
474 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_IMM)(cmdBuffer));
475
476 uint32_t mask = bSecond ? 0xffff : 0xffff0000;
477 value = bSecond ? value << 16 : value;
478
479 loadRegImmParams = {};
480 loadRegImmParams.dwData = mask;
481 loadRegImmParams.dwRegister = pMmioRegisters->generalPurposeRegister4LoOffset;
482 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_IMM)(cmdBuffer));
483
484 loadRegImmParams = {};
485 loadRegImmParams.dwData = 0;
486 loadRegImmParams.dwRegister = pMmioRegisters->generalPurposeRegister4HiOffset;
487 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_IMM)(cmdBuffer));
488
489 mhw::mi::MHW_MI_ALU_PARAMS aluParams[4] = {0};
490 int aluCount = 0;
491
492 // load srcA, reg0
493 aluParams[aluCount].AluOpcode = MHW_MI_ALU_LOAD;
494 aluParams[aluCount].Operand1 = MHW_MI_ALU_SRCA;
495 aluParams[aluCount].Operand2 = MHW_MI_ALU_GPREG0;
496 aluCount++;
497 // load srcB, reg4
498 aluParams[aluCount].AluOpcode = MHW_MI_ALU_LOAD;
499 aluParams[aluCount].Operand1 = MHW_MI_ALU_SRCB;
500 aluParams[aluCount].Operand2 = MHW_MI_ALU_GPREG4;
501 aluCount++;
502 // and srcA, srcB
503 aluParams[aluCount].AluOpcode = MHW_MI_ALU_AND;
504 aluCount++;
505 // store reg0, ACCU
506 aluParams[aluCount].AluOpcode = MHW_MI_ALU_STORE;
507 aluParams[aluCount].Operand1 = MHW_MI_ALU_GPREG0;
508 aluParams[aluCount].Operand2 = MHW_MI_ALU_ACCU;
509 aluCount++;
510
511 auto &miMathParams = m_miItf->MHW_GETPAR_F(MI_MATH)();
512 miMathParams = {};
513 miMathParams.dwNumAluParams = aluCount;
514 miMathParams.pAluPayload = aluParams;
515 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_MATH)(cmdBuffer));
516
517 loadRegImmParams = {};
518 loadRegImmParams.dwData = value;
519 loadRegImmParams.dwRegister = pMmioRegisters->generalPurposeRegister4LoOffset;
520 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_IMM)(cmdBuffer));
521
522 loadRegImmParams = {};
523 loadRegImmParams.dwData = 0;
524 loadRegImmParams.dwRegister = pMmioRegisters->generalPurposeRegister4HiOffset;
525 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_LOAD_REGISTER_IMM)(cmdBuffer));
526
527 aluCount = 0;
528 // load srcA, reg0
529 aluParams[aluCount].AluOpcode = MHW_MI_ALU_LOAD;
530 aluParams[aluCount].Operand1 = MHW_MI_ALU_SRCA;
531 aluParams[aluCount].Operand2 = MHW_MI_ALU_GPREG0;
532 aluCount++;
533 // load srcB, reg4
534 aluParams[aluCount].AluOpcode = MHW_MI_ALU_LOAD;
535 aluParams[aluCount].Operand1 = MHW_MI_ALU_SRCB;
536 aluParams[aluCount].Operand2 = MHW_MI_ALU_GPREG4;
537 aluCount++;
538
539 // or srcA, srcB
540 aluParams[aluCount].AluOpcode = MHW_MI_ALU_OR;
541 aluCount++;
542
543 // store reg0, ACCU
544 aluParams[aluCount].AluOpcode = MHW_MI_ALU_STORE;
545 aluParams[aluCount].Operand1 = MHW_MI_ALU_GPREG0;
546 aluParams[aluCount].Operand2 = MHW_MI_ALU_ACCU;
547 aluCount++;
548
549 miMathParams = {};
550 miMathParams = {};
551 miMathParams.dwNumAluParams = aluCount;
552 miMathParams.pAluPayload = aluParams;
553 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_MATH)(cmdBuffer));
554
555 // update the value
556 auto &miStoreRegMemParams = m_miItf->MHW_GETPAR_F(MI_STORE_REGISTER_MEM)();
557 miStoreRegMemParams = {};
558 miStoreRegMemParams.presStoreBuffer = presStoreBuffer;
559 miStoreRegMemParams.dwOffset = offset;
560 miStoreRegMemParams.dwRegister = pMmioRegisters->generalPurposeRegister0LoOffset;
561 ENCODE_CHK_STATUS_RETURN(m_miItf->MHW_ADDCMD_F(MI_STORE_REGISTER_MEM)(cmdBuffer));
562
563 return eStatus;
564 }
565
566 bool PacketUtilities::GetFakeHeaderSettings(uint32_t &fakeHeaderSizeInByte, bool isIframe)
567 {
568 ENCODE_FUNC_CALL();
569
570 fakeHeaderSizeInByte = isIframe ? m_fakeIFrameHrdSize : m_fakePBFrameHrdSize;
571
572 return m_enableFakeHrdSize;
573 }
574 #endif
575 }