1 /*
2 * Copyright (c) 2017-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 codechal_decode_scalability_g12.cpp
24 //! \brief Impelements the public interface for Gen12 Scalability Decode
25 //!
26 #include "codechal_decoder.h"
27 #include "codechal_decode_scalability_g12.h"
28 #include "mos_os_virtualengine_next.h"
29 #include "mos_os_cp_interface_specific.h"
30
31 //==<Functions>=======================================================
32 //!
33 //! \brief calculate secondary cmd buffer index
34 //! \details calculate secondary cmd buffer index to get or return secondary cmd buffer
35 //! \param [in] pScalabilityState
36 //! pointer to scalability decode state
37 //! \param [in] pdwBufIdxPlus1
38 //! pointer to buf index, will contain the returned buf index value.
39 //! \return MOS_STATUS
40 //! MOS_STATUS_SUCCESS if success, else fail reason
41 //!
CodecHalDecodeScalability_CalculateScdryCmdBufIndex_G12(PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase,uint32_t * pdwBufIdxPlus1)42 static MOS_STATUS CodecHalDecodeScalability_CalculateScdryCmdBufIndex_G12(
43 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase,
44 uint32_t *pdwBufIdxPlus1)
45 {
46 uint32_t HcpDecPhaseForBufIdx;
47 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
48
49 CODECHAL_DECODE_FUNCTION_ENTER;
50
51 PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalabilityStateBase);
52
53 CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase);
54 CODECHAL_DECODE_CHK_NULL(pdwBufIdxPlus1);
55 CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase->pHwInterface);
56 CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase->pHwInterface->GetOsInterface());
57
58 if (pScalabilityState->HcpDecPhase == CODECHAL_HCP_DECODE_PHASE_REAL_TILE)
59 {
60 *pdwBufIdxPlus1 = pScalabilityState->u8RtCurPipe + 1;
61 if(pScalabilityStateBase->pHwInterface->GetOsInterface()->phasedSubmission
62 && !pScalabilityStateBase->pHwInterface->GetOsInterface()->bParallelSubmission)
63 {
64 /* 3 tiles 2 pipe for example:
65 cur phase cur pip
66 0 0, 1 2 cmd buffer needed
67 1 0 1 cmd buffer needed
68 all of 3 tiles cmd ready, submit 3 cmd togather
69 */
70 *pdwBufIdxPlus1 += (pScalabilityState->u8RtCurPhase * pScalabilityState->u8RtPhaseNum);
71 }
72 }
73 else
74 {
75 HcpDecPhaseForBufIdx = pScalabilityState->HcpDecPhase;
76 if (pScalabilityState->HcpDecPhase == CodechalDecode::CodechalHcpDecodePhaseLegacyS2L)
77 {
78 //S2L commands put in the FE secondary command buffer.
79 CODECHAL_DECODE_ASSERT(pScalabilityState->bShortFormatInUse);
80 HcpDecPhaseForBufIdx = CODECHAL_HCP_DECODE_PHASE_FE;
81 }
82
83 //buffer index order is same as the buffer order in resScalableBatchBufs[] of MOS_VIRTUALENGINE_HINT_PARAMS
84 *pdwBufIdxPlus1 = HcpDecPhaseForBufIdx - (pScalabilityState->bFESeparateSubmission ?
85 CODECHAL_HCP_DECODE_PHASE_BE0 : CODECHAL_HCP_DECODE_PHASE_FE) + 1;
86 }
87
88 finish:
89 return eStatus;
90 }
91
92 //!
93 //! \brief check if valid decode phase
94 //! \param [in] pScalabilityState
95 //! pointer to scalability decode state
96 //! \param [in] HcpDecPhase
97 //! Hcp Decode Phase
98 //! \return MOS_STATUS
99 //! MOS_STATUS_SUCCESS if valid decode phase, else fail reason
100 //!
CodecHalDecodeScalability_CheckDecPhaseValidity_G12(PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase,uint32_t HcpDecPhase)101 static MOS_STATUS CodecHalDecodeScalability_CheckDecPhaseValidity_G12(
102 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase,
103 uint32_t HcpDecPhase)
104 {
105 bool bInValidPhase = false;
106 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
107
108 CODECHAL_DECODE_FUNCTION_ENTER;
109
110 PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalabilityStateBase);
111
112 CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase);
113
114 switch (HcpDecPhase)
115 {
116 case CodechalDecode::CodechalHcpDecodePhaseInitialized:
117 break;
118 case CodechalDecode::CodechalHcpDecodePhaseLegacyS2L:
119 if (!pScalabilityState->bShortFormatInUse)
120 {
121 bInValidPhase = true;
122 }
123 break;
124 case CodechalDecode::CodechalHcpDecodePhaseLegacyLong:
125 if (pScalabilityState->bScalableDecodeMode)
126 {
127 bInValidPhase = true;
128 }
129 break;
130 case CODECHAL_HCP_DECODE_PHASE_FE:
131 case CODECHAL_HCP_DECODE_PHASE_BE0:
132 if (!pScalabilityState->bScalableDecodeMode)
133 {
134 bInValidPhase = true;
135 }
136 else if (pScalabilityState->ucScalablePipeNum < 2)
137 {
138 //at least 2 pipe
139 bInValidPhase = true;
140 }
141 break;
142 case CODECHAL_HCP_DECODE_PHASE_REAL_TILE:
143 if (pScalabilityState->ucScalablePipeNum <= pScalabilityState->u8RtCurPipe)
144 {
145 bInValidPhase = true;
146 }
147 break;
148 default:
149 if(HcpDecPhase > CODECHAL_HCP_DECODE_PHASE_BE0 &&
150 HcpDecPhase != CODECHAL_HCP_DECODE_PHASE_REAL_TILE)
151 {
152 if (!pScalabilityState->bScalableDecodeMode)
153 {
154 bInValidPhase = true;
155 }
156 else if (pScalabilityState->ucScalablePipeNum < (HcpDecPhase - CODECHAL_HCP_DECODE_PHASE_BE0 + 1))
157 {
158 bInValidPhase = true;
159 }
160 }
161 else
162 {
163 bInValidPhase = true;
164 }
165 break;
166 }
167
168 if (bInValidPhase)
169 {
170 eStatus = MOS_STATUS_INVALID_PARAMETER;
171 CODECHAL_DECODE_ASSERTMESSAGE("invalid decode phase : %d !", HcpDecPhase);
172 }
173
174 finish:
175 return eStatus;
176 }
177
CodecHalDecodeScalability_GetVESecondaryCmdBuffer_G12(PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,PMOS_COMMAND_BUFFER pSdryCmdBuf)178 MOS_STATUS CodecHalDecodeScalability_GetVESecondaryCmdBuffer_G12(
179 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,
180 PMOS_COMMAND_BUFFER pSdryCmdBuf)
181 {
182 PMOS_INTERFACE pOsInterface;
183 uint32_t HcpDecPhase;
184 uint32_t dwBufIdxPlus1 = 0;
185 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
186
187 CODECHAL_DECODE_FUNCTION_ENTER;
188
189 CODECHAL_DECODE_CHK_NULL(pScalabilityState);
190 CODECHAL_DECODE_CHK_NULL(pSdryCmdBuf);
191 CODECHAL_DECODE_CHK_NULL(pScalabilityState->pHwInterface);
192 CODECHAL_DECODE_CHK_NULL(pScalabilityState->pHwInterface->GetOsInterface());
193
194 pOsInterface = pScalabilityState->pHwInterface->GetOsInterface();
195 HcpDecPhase = pScalabilityState->HcpDecPhase;
196
197 //calculate bufidx for getting secondary cmd buffer.
198 CODECHAL_DECODE_CHK_STATUS(CodecHalDecodeScalability_CalculateScdryCmdBufIndex_G12(pScalabilityState, &dwBufIdxPlus1));
199 //Check if valid decode phase
200 CODECHAL_DECODE_CHK_STATUS(CodecHalDecodeScalability_CheckDecPhaseValidity_G12(pScalabilityState, HcpDecPhase));
201
202 //Get batch buffer according to current decode phase
203 switch (HcpDecPhase)
204 {
205 case CodechalDecode::CodechalHcpDecodePhaseLegacyS2L:
206 //Note: no break here, S2L and FE commands put in one secondary command buffer.
207 case CODECHAL_HCP_DECODE_PHASE_FE:
208 if (!pScalabilityState->bFESeparateSubmission)
209 {
210 CODECHAL_DECODE_CHK_STATUS(pOsInterface->pfnGetCommandBuffer(pOsInterface, pSdryCmdBuf, dwBufIdxPlus1));
211 CODECHAL_DECODE_CHK_NULL(pSdryCmdBuf);
212 }
213 else
214 {
215 //if FE separate submission, S2L and FE cmd buffer are in primary cmd buffer, shall not call this function to get secondary cmd buffer
216 eStatus = MOS_STATUS_INVALID_PARAMETER;
217 CODECHAL_DECODE_ASSERTMESSAGE("S2L or FE does not need secondary cmd buffer in FE separate submission!");
218 }
219 break;
220 default:
221 if(((HcpDecPhase >= CODECHAL_HCP_DECODE_PHASE_BE0) && ((HcpDecPhase-CODECHAL_HCP_DECODE_PHASE_FE) <= pScalabilityState->ucScalablePipeNum)) ||
222 (HcpDecPhase == CODECHAL_HCP_DECODE_PHASE_REAL_TILE))
223 {
224 CODECHAL_DECODE_CHK_STATUS(pOsInterface->pfnGetCommandBuffer(pOsInterface, pSdryCmdBuf, dwBufIdxPlus1));
225 CODECHAL_DECODE_CHK_NULL(pSdryCmdBuf);
226 }
227 else
228 {
229 eStatus = MOS_STATUS_INVALID_PARAMETER;
230 }
231 break;
232 }
233
234 finish:
235 return eStatus;
236 }
237
CodecHalDecodeScalability_GetCmdBufferToUse_G12(PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase,PMOS_COMMAND_BUFFER pScdryCmdBuf,PMOS_COMMAND_BUFFER * ppCmdBufToUse)238 MOS_STATUS CodecHalDecodeScalability_GetCmdBufferToUse_G12(
239 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase,
240 PMOS_COMMAND_BUFFER pScdryCmdBuf,
241 PMOS_COMMAND_BUFFER *ppCmdBufToUse)
242 {
243 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
244
245 CODECHAL_DECODE_FUNCTION_ENTER;
246
247 PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalabilityStateBase);
248
249 CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase);
250 CODECHAL_DECODE_CHK_NULL(ppCmdBufToUse);
251 CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase->pHwInterface);
252 CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase->pHwInterface->GetOsInterface());
253
254 if (!CodecHalDecodeScalabilityIsFESeparateSubmission(pScalabilityState) ||
255 CodecHalDecodeScalabilityIsBEPhaseG12(pScalabilityState) ||
256 pScalabilityStateBase->pHwInterface->GetOsInterface()->bParallelSubmission)
257 {
258 pScalabilityState->bUseSecdryCmdBuffer = true;
259 CODECHAL_DECODE_CHK_STATUS(CodecHalDecodeScalability_GetVESecondaryCmdBuffer_G12(pScalabilityState, pScdryCmdBuf));
260 *ppCmdBufToUse = pScdryCmdBuf;
261 }
262 else
263 {
264 pScalabilityState->bUseSecdryCmdBuffer = false;
265 }
266
267 finish:
268 return eStatus;
269 }
270
CodecHalDecodeScalability_ReturnSdryCmdBuffer_G12(PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,PMOS_COMMAND_BUFFER pSdryCmdBuf)271 MOS_STATUS CodecHalDecodeScalability_ReturnSdryCmdBuffer_G12(
272 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,
273 PMOS_COMMAND_BUFFER pSdryCmdBuf)
274 {
275 PMOS_INTERFACE pOsInterface;
276 uint32_t HcpDecPhase;
277 uint32_t dwBufIdxPlus1;
278 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
279
280 CODECHAL_DECODE_FUNCTION_ENTER;
281
282 CODECHAL_DECODE_CHK_NULL(pScalabilityState);
283 CODECHAL_DECODE_CHK_NULL(pSdryCmdBuf);
284 CODECHAL_DECODE_CHK_NULL(pScalabilityState->pHwInterface);
285 CODECHAL_DECODE_CHK_NULL(pScalabilityState->pHwInterface->GetOsInterface());
286
287 pOsInterface = pScalabilityState->pHwInterface->GetOsInterface();
288
289 if (!pScalabilityState->bUseSecdryCmdBuffer)
290 {
291 goto finish;
292 }
293
294 HcpDecPhase = pScalabilityState->HcpDecPhase;
295
296 //calculate bufidx for getting secondary cmd buffer.
297 CODECHAL_DECODE_CHK_STATUS(CodecHalDecodeScalability_CalculateScdryCmdBufIndex_G12(pScalabilityState, &dwBufIdxPlus1));
298 //Check if valid decode phase
299 CODECHAL_DECODE_CHK_STATUS(CodecHalDecodeScalability_CheckDecPhaseValidity_G12(pScalabilityState, HcpDecPhase));
300
301 //Get batch buffer according to current decode phase
302 switch (HcpDecPhase)
303 {
304 case CodechalDecode::CodechalHcpDecodePhaseLegacyS2L:
305 //Note: no break here, S2L and FE commands put in one secondary command buffer.
306 case CODECHAL_HCP_DECODE_PHASE_FE:
307 if (!pScalabilityState->bFESeparateSubmission)
308 {
309 pOsInterface->pfnReturnCommandBuffer(pOsInterface, pSdryCmdBuf, dwBufIdxPlus1);
310 }
311 else
312 {
313 //if FE separate submission, S2L and FE cmd buffer are in primary cmd buffer, shall not call this function to get secondary cmd buffer
314 eStatus = MOS_STATUS_INVALID_PARAMETER;
315 CODECHAL_DECODE_ASSERTMESSAGE("S2L or FE does not need secondary cmd buffer in FE separate submission!");
316 }
317 break;
318 default:
319 if(((HcpDecPhase >= CODECHAL_HCP_DECODE_PHASE_BE0) && ((HcpDecPhase-CODECHAL_HCP_DECODE_PHASE_FE) <= pScalabilityState->ucScalablePipeNum)) ||
320 (HcpDecPhase == CODECHAL_HCP_DECODE_PHASE_REAL_TILE))
321 {
322 pOsInterface->pfnReturnCommandBuffer(pOsInterface, pSdryCmdBuf, dwBufIdxPlus1);
323 }
324 else
325 {
326 eStatus = MOS_STATUS_INVALID_PARAMETER;
327 }
328 break;
329 }
330
331 finish:
332 return eStatus;
333 }
334
CodecHalDecodeScalability_DetermineDecodePhase_G12(PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase,uint32_t * pHcpDecPhase)335 MOS_STATUS CodecHalDecodeScalability_DetermineDecodePhase_G12(
336 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase,
337 uint32_t *pHcpDecPhase)
338 {
339 uint32_t CurPhase;
340 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
341
342 CODECHAL_DECODE_FUNCTION_ENTER;
343
344 PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalabilityStateBase);
345
346 CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase);
347 CODECHAL_DECODE_CHK_NULL(pHcpDecPhase);
348
349 CurPhase = *pHcpDecPhase;
350 //Check if valid decode phase
351 CODECHAL_DECODE_CHK_STATUS(CodecHalDecodeScalability_CheckDecPhaseValidity_G12(pScalabilityState, CurPhase));
352
353 if (pScalabilityState->bIsRtMode)
354 {
355 switch (CurPhase)
356 {
357 case CodechalDecode::CodechalHcpDecodePhaseInitialized:
358 if (pScalabilityState->bShortFormatInUse)
359 {
360 *pHcpDecPhase = CodechalDecode::CodechalHcpDecodePhaseLegacyS2L;
361 }
362 else
363 {
364 *pHcpDecPhase = CODECHAL_HCP_DECODE_PHASE_REAL_TILE;
365 }
366 break;
367 case CodechalDecode::CodechalHcpDecodePhaseLegacyS2L:
368 case CODECHAL_HCP_DECODE_PHASE_REAL_TILE:
369 *pHcpDecPhase = CODECHAL_HCP_DECODE_PHASE_REAL_TILE;
370 break;
371 default:
372 eStatus = MOS_STATUS_INVALID_PARAMETER;
373 break;
374 }
375 }
376 else if (CodecHalDecodeScalabilityIsScalableMode(pScalabilityState))
377 {
378 switch (CurPhase)
379 {
380 case CodechalDecode::CodechalHcpDecodePhaseInitialized:
381 if (pScalabilityState->bShortFormatInUse)
382 {
383 *pHcpDecPhase = CodechalDecode::CodechalHcpDecodePhaseLegacyS2L;
384 }
385 else
386 {
387 *pHcpDecPhase = CODECHAL_HCP_DECODE_PHASE_FE;
388 }
389 break;
390 case CodechalDecode::CodechalHcpDecodePhaseLegacyS2L:
391 *pHcpDecPhase = CODECHAL_HCP_DECODE_PHASE_FE;
392 break;
393 case CODECHAL_HCP_DECODE_PHASE_FE:
394 *pHcpDecPhase = CODECHAL_HCP_DECODE_PHASE_BE0;
395 break;
396 default:
397 if(CurPhase >= CODECHAL_HCP_DECODE_PHASE_BE0 && ((CurPhase-CODECHAL_HCP_DECODE_PHASE_FE) <= pScalabilityState->ucScalablePipeNum))
398 {
399 *pHcpDecPhase = CurPhase + 1;
400 }
401 else
402 {
403 eStatus = MOS_STATUS_INVALID_PARAMETER;
404 }
405 break;
406 }
407 }
408 else
409 {
410 switch (CurPhase)
411 {
412 case CodechalDecode::CodechalHcpDecodePhaseInitialized:
413 if (pScalabilityState->bShortFormatInUse)
414 {
415 *pHcpDecPhase = CodechalDecode::CodechalHcpDecodePhaseLegacyS2L;
416 }
417 else
418 {
419 *pHcpDecPhase = CodechalDecode::CodechalHcpDecodePhaseLegacyLong;
420 }
421 break;
422 case CodechalDecode::CodechalHcpDecodePhaseLegacyS2L:
423 case CodechalDecode::CodechalHcpDecodePhaseLegacyLong:
424 *pHcpDecPhase = CodechalDecode::CodechalHcpDecodePhaseLegacyLong;
425 break;
426 default:
427 //never comes here because other decode phase already checked invalid in function CodecHalDecodeScalability_CheckDecPhaseValidity,
428 eStatus = MOS_STATUS_INVALID_PARAMETER;
429 break;
430 }
431 }
432
433 pScalabilityState->HcpDecPhase = *pHcpDecPhase;
434
435 finish:
436 return eStatus;
437 }
438
CodecHalDecodeScalability_InitScalableParams_G12(PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase,PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS pInitParamsBase,uint16_t * pucDecPassNum)439 MOS_STATUS CodecHalDecodeScalability_InitScalableParams_G12(
440 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase,
441 PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS pInitParamsBase,
442 uint16_t *pucDecPassNum)
443 {
444 PMOS_INTERFACE pOsInterface;
445 PMOS_VIRTUALENGINE_INTERFACE pVEInterface;
446 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
447
448 CODECHAL_DECODE_FUNCTION_ENTER;
449
450 PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalabilityStateBase);
451 PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS_G12 pInitParams = static_cast<PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS_G12>(pInitParamsBase);
452
453 CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase);
454 CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase->pHwInterface);
455 CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase->pHwInterface->GetOsInterface());
456
457 pOsInterface = pScalabilityStateBase->pHwInterface->GetOsInterface();
458 pVEInterface = pScalabilityStateBase->pVEInterface;
459
460 if (!pOsInterface->bSupportVirtualEngine)
461 {
462 eStatus = MOS_STATUS_INVALID_PARAMETER;
463 CODECHAL_DECODE_ASSERTMESSAGE("Scalability decode must run with virtual engine interface.\n");
464 goto finish;
465 }
466
467 pScalabilityState->bScalableDecodeMode = false; // initialized to false
468 pScalabilityState->bIsRtMode = false;
469
470 #if (_DEBUG || _RELEASE_INTERNAL)
471 if (pOsInterface->bEnableDbgOvrdInVE)
472 {
473 if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(pOsInterface))
474 {
475 if (pOsInterface->apoMosEnabled)
476 {
477 CODECHAL_DECODE_CHK_NULL(pVEInterface->veInterface);
478 pScalabilityState->ucScalablePipeNum = pVEInterface->veInterface->GetEngineCount() - 1;
479 }
480 else
481 {
482 pScalabilityState->ucScalablePipeNum = pVEInterface->ucEngineCount - 1;
483 }
484 pScalabilityState->bScalableDecodeMode = true;
485 }
486 else
487 {
488 // do nothing since pipe number already decided at the gpu context creation.
489 }
490 }
491 else
492 #endif
493 {
494 // Decide pipe number
495 CODECHAL_DECODE_CHK_STATUS(pScalabilityState->pfnDecidePipeNum(pScalabilityState, pInitParams));
496 }
497
498 // Decide scalable mode or single pipe mode
499 if (pScalabilityState->ucScalablePipeNum > 1)
500 {
501 pScalabilityState->bScalableDecodeMode = true;
502 }
503
504 CODECHAL_DECODE_CHK_NULL(pucDecPassNum);
505 // Decide Decode pass number - pucDecPassNum
506 if (pScalabilityState->bScalableDecodeMode)
507 {
508 bool bCanEnableRealTile = true;
509 uint8_t u8MaxTileColumn = HEVC_NUM_MAX_TILE_COLUMN;
510
511 #if (_DEBUG || _RELEASE_INTERNAL)
512 bCanEnableRealTile = !pScalabilityState->bDisableRtMode;
513 if (!pScalabilityState->bEnableRtMultiPhase)
514 u8MaxTileColumn = pScalabilityState->ucScalablePipeNum;
515 #endif
516 bCanEnableRealTile = bCanEnableRealTile && pInitParams->bIsTileEnabled && (pInitParams->u8NumTileColumns > 1) &&
517 (pInitParams->u8NumTileColumns <= u8MaxTileColumn) && (pInitParams->u8NumTileRows <= HEVC_NUM_MAX_TILE_ROW) &&
518 pInitParams->bHasSubsetParams;
519
520 if (bCanEnableRealTile)
521 {
522 pScalabilityState->bIsRtMode = true;
523 //WA: No FE for real tile decoding and need to disable FE separate submission
524 pScalabilityState->bFESeparateSubmission = false;
525 pScalabilityState->u8RtPhaseNum =
526 (pInitParams->u8NumTileColumns + pScalabilityState->ucScalablePipeNum - 1) / pScalabilityState->ucScalablePipeNum;
527 pScalabilityState->u8RtPipeInLastPhase = pInitParams->u8NumTileColumns - pScalabilityState->ucScalablePipeNum * (pScalabilityState->u8RtPhaseNum - 1);
528 pScalabilityState->u8RtCurPipe = 0;
529 pScalabilityState->u8RtCurPhase = 0;
530
531 *pucDecPassNum = pInitParams->u8NumTileColumns;
532 }
533 else if (pInitParams->bIsSccDecoding) // No virtual tile support for SCC, fallback to legacy mode
534 {
535 pScalabilityState->bScalableDecodeMode = false;
536 *pucDecPassNum = 1;
537 }
538 else
539 {
540 *pucDecPassNum = pScalabilityState->ucScalablePipeNum + 1; // FE + all BEs
541 pScalabilityState->bFESeparateSubmission = pScalabilityState->bFESeparateSubmissionVT;
542 }
543 }
544 else
545 {
546 *pucDecPassNum = 1;
547 }
548
549 // Add one pass for S2L conversion in short format.
550 if (pScalabilityState->bShortFormatInUse)
551 {
552 *pucDecPassNum = *pucDecPassNum + 1;
553 }
554
555 pScalabilityState->VideoContext = pInitParams->gpuCtxInUse;
556
557 finish:
558 return eStatus;
559 }
560
CodecHalDecodeScalability_SetHintParams_G12(PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase,PCODECHAL_DECODE_SCALABILITY_SETHINT_PARMS pSetHintParms)561 MOS_STATUS CodecHalDecodeScalability_SetHintParams_G12(
562 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase,
563 PCODECHAL_DECODE_SCALABILITY_SETHINT_PARMS pSetHintParms)
564 {
565 PMOS_VIRTUALENGINE_INTERFACE pVEInterface;
566 MOS_VIRTUALENGINE_SET_PARAMS VEParams;
567 PMOS_INTERFACE pOsInterface;
568 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
569
570 CODECHAL_DECODE_FUNCTION_ENTER;
571
572 PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalabilityStateBase);
573
574 CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase);
575 CODECHAL_DECODE_CHK_NULL(pSetHintParms);
576 CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase->pHwInterface);
577 CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase->pHwInterface->GetOsInterface());
578
579 pOsInterface = pScalabilityStateBase->pHwInterface->GetOsInterface();
580 pVEInterface = pScalabilityStateBase->pVEInterface;
581
582 MOS_ZeroMemory(&VEParams, sizeof(VEParams));
583 if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(pOsInterface))
584 {
585 //not used by VE2.0
586 VEParams.bNeedSyncWithPrevious = pSetHintParms->bNeedSyncWithPrevious;
587 VEParams.bSameEngineAsLastSubmission = pSetHintParms->bSameEngineAsLastSubmission;
588 VEParams.bSFCInUse = pSetHintParms->bSFCInUse;
589 }
590
591 VEParams.ucScalablePipeNum = pScalabilityState->ucScalablePipeNum;
592
593 if (pScalabilityState->bScalableDecodeMode)
594 {
595 if (pScalabilityState->bFESeparateSubmission)
596 {
597 //set Hint parameter for FE submission
598 VEParams.bScalableMode = false;
599 if (pVEInterface->pfnVESetHintParams)
600 {
601 CODECHAL_DECODE_CHK_STATUS(pVEInterface->pfnVESetHintParams(pVEInterface, &VEParams));
602 }
603 }
604
605 VEParams.bScalableMode = true;
606 VEParams.bHaveFrontEndCmds = pScalabilityState->bIsRtMode ? false : (pScalabilityState->bFESeparateSubmission ? false : true);
607 if (pVEInterface->pfnVESetHintParams)
608 {
609 CODECHAL_DECODE_CHK_STATUS(pVEInterface->pfnVESetHintParams(pVEInterface, &VEParams));
610 }
611 }
612 else
613 {
614 VEParams.bScalableMode = false;
615 if (pVEInterface->pfnVESetHintParams)
616 {
617 CODECHAL_DECODE_CHK_STATUS(pVEInterface->pfnVESetHintParams(pVEInterface, &VEParams));
618 }
619 }
620
621 finish:
622 return eStatus;
623 }
624
625 #if (_DEBUG || _RELEASE_INTERNAL)
CodecHalDecodeScalability_DbgDumpCmdBuffer_G12(CodechalDecode * pDecoder,PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,CodechalDebugInterface * debugInterface,PMOS_COMMAND_BUFFER pPrimCmdBuf)626 MOS_STATUS CodecHalDecodeScalability_DbgDumpCmdBuffer_G12(
627 CodechalDecode *pDecoder,
628 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,
629 CodechalDebugInterface *debugInterface,
630 PMOS_COMMAND_BUFFER pPrimCmdBuf)
631 {
632 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
633 MOS_COMMAND_BUFFER ScdryCmdBuffer;
634 PMOS_COMMAND_BUFFER pCmdBufferInUse;
635 std::string cmdName = "DEC";
636
637 CODECHAL_DECODE_FUNCTION_ENTER;
638
639 CODECHAL_DECODE_CHK_NULL(pDecoder);
640 CODECHAL_DECODE_CHK_NULL(pScalabilityState);
641 CODECHAL_DECODE_CHK_NULL(pPrimCmdBuf);
642
643 if (!pScalabilityState->bScalableDecodeMode)
644 {
645 eStatus = MOS_STATUS_INVALID_PARAMETER;
646 CODECHAL_DECODE_ASSERTMESSAGE("Invalid decode parameters!");
647 goto finish;
648 }
649
650 if (CodecHalDecodeScalabilityIsFESeparateSubmission(pScalabilityState)
651 && CodecHalDecodeScalabilityIsFEPhase(pScalabilityState))
652 {
653 pCmdBufferInUse = pPrimCmdBuf;
654 }
655 else
656 {
657 //calculate bufidx for getting secondary cmd buffer.
658 uint32_t dwBufIdxPlus1 = 0;
659 CODECHAL_DECODE_CHK_STATUS(CodecHalDecodeScalability_CalculateScdryCmdBufIndex_G12(pScalabilityState, &dwBufIdxPlus1));
660 cmdName = cmdName + "_secondary_" + std::to_string(dwBufIdxPlus1);
661 CODECHAL_DECODE_CHK_STATUS(CodecHalDecodeScalability_GetVESecondaryCmdBuffer_G12(pScalabilityState, &ScdryCmdBuffer));
662 pCmdBufferInUse = &ScdryCmdBuffer;
663 }
664
665 CODECHAL_DECODE_CHK_STATUS_RETURN(debugInterface->DumpCmdBuffer(
666 pCmdBufferInUse,
667 CODECHAL_NUM_MEDIA_STATES,
668 cmdName.c_str()));
669
670 finish:
671 return eStatus;
672 }
673 #endif
674
CodecHalDecodeScalability_FEBESync_G12(PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase,PMOS_COMMAND_BUFFER pCmdBufferInUse,bool phasedSubmission)675 MOS_STATUS CodecHalDecodeScalability_FEBESync_G12(
676 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase,
677 PMOS_COMMAND_BUFFER pCmdBufferInUse,
678 bool phasedSubmission)
679 {
680 PMOS_INTERFACE pOsInterface;
681 MhwMiInterface *pMiInterface;
682 uint32_t HcpDecPhase;
683 uint32_t curPipeInUse = 0;
684 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
685
686 CODECHAL_DECODE_FUNCTION_ENTER;
687
688 PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalabilityStateBase);
689
690 CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase);
691 CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase->pHwInterface);
692 CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase->pHwInterface->GetOsInterface());
693 CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase->pHwInterface->GetMiInterface());
694 CODECHAL_DECODE_CHK_NULL(pCmdBufferInUse);
695
696 pOsInterface = pScalabilityStateBase->pHwInterface->GetOsInterface();
697 pMiInterface = pScalabilityState->pHwInterface->GetMiInterface();
698 HcpDecPhase = pScalabilityStateBase->HcpDecPhase;
699
700 //FE& BE0 Sync. to refine (ucNumVdbox > )for GT3
701 if (HcpDecPhase == CODECHAL_HCP_DECODE_PHASE_BE0
702 && pScalabilityState->pHwInterface->GetMfxInterface()->GetNumVdbox() > 2
703 && !pOsInterface->bParallelSubmission)
704 {
705 if (pScalabilityState->bFESeparateSubmission)
706 {
707 MOS_SYNC_PARAMS SyncParams;
708
709 SyncParams = g_cInitSyncParams;
710 SyncParams.GpuContext = pScalabilityState->VideoContext;
711 SyncParams.presSyncResource = &pScalabilityState->resFeBeSyncObject;
712
713 CODECHAL_DECODE_CHK_STATUS(pOsInterface->pfnEngineWait(pOsInterface, &SyncParams));
714 }
715 else
716 {
717 CODECHAL_DECODE_CHK_STATUS(pScalabilityState->pHwInterface->SendHwSemaphoreWaitCmd(&pScalabilityState->resSemaMemFEBE, 1, MHW_MI_SAD_EQUAL_SDD, pCmdBufferInUse));
718 //reset semaphore. mi atomic decrease 1
719 CODECHAL_DECODE_CHK_STATUS(pScalabilityState->pHwInterface->SendMiAtomicDwordCmd(&pScalabilityState->resSemaMemFEBE, 1, MHW_MI_ATOMIC_DEC, pCmdBufferInUse));
720 }
721 }
722
723 if (CodecHalDecodeScalabilityIsBEPhaseG12(pScalabilityState) ||
724 (CodecHalDecodeScalabilityIsFirstRealTilePhase(pScalabilityState)))
725 {
726 // Stop Watchdog before BEs wait
727 pMiInterface->AddWatchdogTimerStopCmd(pCmdBufferInUse);
728
729 //HW Semaphore for BEs Starting at the same time
730 CODECHAL_DECODE_CHK_STATUS(pScalabilityState->pHwInterface->SendMiAtomicDwordCmd(&pScalabilityState->resSemaMemBEs, 1, MHW_MI_ATOMIC_INC, pCmdBufferInUse));
731 uint8_t u8PipeNum = pScalabilityState->ucScalablePipeNum;
732
733 if (phasedSubmission && pScalabilityState->bIsRtMode)
734 {
735 if (pScalabilityState->u8RtCurPhase == pScalabilityState->u8RtPhaseNum - 1)
736 {
737 u8PipeNum = pScalabilityState->u8RtPipeInLastPhase;
738 }
739 }
740
741 CODECHAL_DECODE_CHK_STATUS(pScalabilityState->pHwInterface->SendHwSemaphoreWaitCmd(
742 &pScalabilityState->resSemaMemBEs,
743 u8PipeNum,
744 MHW_MI_SAD_EQUAL_SDD,
745 pCmdBufferInUse));
746
747 //add additional BEs Sync for two pipes
748 if (u8PipeNum == 2 && !phasedSubmission)
749 {
750 if (pScalabilityState->bIsRtMode)
751 {
752 curPipeInUse = pScalabilityState->u8RtCurPipe;
753 }
754 else
755 {
756 curPipeInUse = HcpDecPhase == CODECHAL_HCP_DECODE_PHASE_BE0 ? 0 : 1;
757 }
758 //pipe 0: resSemaMemBEsAdditional[0] + 1, pipe 1: resSemaMemBEsAdditional[1] + 1
759 CODECHAL_DECODE_CHK_STATUS(pScalabilityState->pHwInterface->SendMiAtomicDwordCmd(&pScalabilityState->resSemaMemBEsAdditional[curPipeInUse],
760 1,
761 MHW_MI_ATOMIC_INC,
762 pCmdBufferInUse));
763 }
764
765 // Program some placeholder cmds to resolve the hazard between BEs sync
766 MHW_MI_STORE_DATA_PARAMS dataParams;
767 dataParams.pOsResource = &pScalabilityState->resDelayMinus;
768 dataParams.dwResourceOffset = 0;
769 dataParams.dwValue = 0xDE1A;
770 for (uint32_t i = 0; i < pScalabilityState->numDelay; i++)
771 {
772 CODECHAL_DECODE_CHK_STATUS_RETURN(pScalabilityState->pHwInterface->GetMiInterface()->AddMiStoreDataImmCmd(
773 pCmdBufferInUse,
774 &dataParams));
775 }
776 //additional Semaphore Wait: pipe 0 wait resSemaMemBEsAdditional[1] == 1, pipe 1 wait resSemaMemBEsAdditional[0] == 1
777 if (u8PipeNum == 2 && !phasedSubmission)
778 {
779 CODECHAL_DECODE_CHK_STATUS(pScalabilityState->pHwInterface->SendHwSemaphoreWaitCmd(
780 &pScalabilityState->resSemaMemBEsAdditional[CODECHAL_SCALABILITY_MAX_PIPE_INDEX_OF_TWO_PIPE - curPipeInUse],
781 1,
782 MHW_MI_SAD_EQUAL_SDD,
783 pCmdBufferInUse));
784 }
785 //reset HW semaphore
786 CODECHAL_DECODE_CHK_STATUS(pScalabilityState->pHwInterface->SendMiAtomicDwordCmd(&pScalabilityState->resSemaMemBEs, 1, MHW_MI_ATOMIC_DEC, pCmdBufferInUse));
787 //pipe 0 reset resSemaMemBEsAdditional[1], pipe 1 reset resSemaMemBEsAdditional[0]
788 if (u8PipeNum == 2 && !phasedSubmission)
789 {
790 CODECHAL_DECODE_CHK_STATUS(pScalabilityState->pHwInterface->SendMiAtomicDwordCmd(
791 &pScalabilityState->resSemaMemBEsAdditional[CODECHAL_SCALABILITY_MAX_PIPE_INDEX_OF_TWO_PIPE - curPipeInUse],
792 1,
793 MHW_MI_ATOMIC_DEC,
794 pCmdBufferInUse));
795 }
796
797 if (!pScalabilityState->bIsRtMode)
798 {
799 if (pScalabilityState->bIsEnableEndCurrentBatchBuffLevel)
800 {
801 // Enhanced Condidtional BB END for streamout buffer writing over allocated size
802 CODECHAL_DECODE_CHK_STATUS(static_cast<CodechalHwInterfaceG12*>(pScalabilityState->pHwInterface)->SendCondBbEndCmd(
803 &pScalabilityState->resFEStatusBuffer,
804 CODECHAL_OFFSETOF(CODECHAL_DECODE_SCALABILITY_FE_CABAC_STREAMOUT_BUFF_SIZE, dwCabacStreamoutBuffSize),
805 pScalabilityState->dwCABACSyntaxStreamOutBufferSize,
806 true,
807 pScalabilityState->bIsEnableEndCurrentBatchBuffLevel,
808 mhw_mi_g12_X::MI_CONDITIONAL_BATCH_BUFFER_END_CMD::COMPARE_OPERATION_MADLESSTHANIDD,
809 pCmdBufferInUse));
810 CODECHAL_DECODE_NORMALMESSAGE("pScalabilityState->bIsEnableEndCurrentBatchBuffLevel: %s\n", "true");
811 }
812 else
813 {
814 // Condidtional BB END for streamout buffer writing over allocated size
815 CODECHAL_DECODE_CHK_STATUS(pScalabilityState->pHwInterface->SendCondBbEndCmd(
816 &pScalabilityState->resFEStatusBuffer,
817 CODECHAL_OFFSETOF(CODECHAL_DECODE_SCALABILITY_FE_STATUS, dwCarryFlagOfReportedSizeMinusAllocSize),
818 0,
819 true,
820 pCmdBufferInUse));
821 }
822 }
823 }
824
825 finish:
826 return eStatus;
827 }
828
CodecHalDecodeScalability_ReadCSEngineIDReg_G12(PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase,CodechalDecodeStatusBuffer * pDecodeStatusBuf,PMOS_COMMAND_BUFFER pCmdBufferInUse)829 MOS_STATUS CodecHalDecodeScalability_ReadCSEngineIDReg_G12(
830 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase,
831 CodechalDecodeStatusBuffer *pDecodeStatusBuf,
832 PMOS_COMMAND_BUFFER pCmdBufferInUse)
833 {
834 MHW_MI_STORE_REGISTER_MEM_PARAMS StoreRegParams;
835 MhwMiInterface *pMiInterface;
836 MhwVdboxMfxInterface *vdboxMfxInterface;
837 MmioRegistersHcp *pMmioRegisters;
838 uint8_t ucPhaseIndex;
839 uint8_t hcpDecMaxPhaseNum;
840 uint32_t dwOffset, dwCurrIndex, dwPreIndex;
841 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
842
843 CODECHAL_DECODE_FUNCTION_ENTER;
844
845 PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalabilityStateBase);
846
847 CODECHAL_DECODE_CHK_NULL(pDecodeStatusBuf);
848 CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase);
849 CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase->pHwInterface);
850 CODECHAL_DECODE_CHK_NULL(pScalabilityStateBase->pHwInterface->GetMiInterface());
851
852 pMiInterface = pScalabilityStateBase->pHwInterface->GetMiInterface();
853 pMmioRegisters = pScalabilityStateBase->pHwInterface->GetHcpInterface()->GetMmioRegisters(MHW_VDBOX_NODE_1); //relative mmio addressing.
854
855 vdboxMfxInterface = pScalabilityStateBase->pHwInterface->GetMfxInterface();
856 CODECHAL_DECODE_CHK_NULL(vdboxMfxInterface);
857 hcpDecMaxPhaseNum = vdboxMfxInterface->GetNumVdbox();
858
859 if (pScalabilityState->HcpDecPhase == CODECHAL_HCP_DECODE_PHASE_REAL_TILE)
860 {
861 ucPhaseIndex = pScalabilityState->u8RtCurPipe;
862 dwCurrIndex = pDecodeStatusBuf->m_currIndex;
863 }
864 else
865 {
866 ucPhaseIndex = (pScalabilityState->HcpDecPhase < CODECHAL_HCP_DECODE_PHASE_FE) ?
867 0 : (pScalabilityState->HcpDecPhase - CODECHAL_HCP_DECODE_PHASE_FE);
868
869 if (ucPhaseIndex > hcpDecMaxPhaseNum)
870 {
871 eStatus = MOS_STATUS_INVALID_PARAMETER;
872 CODECHAL_DECODE_ASSERTMESSAGE("Invalid HCP decode phase!");
873 goto finish;
874 }
875
876 if (CodecHalDecodeScalabilityIsScalableMode(pScalabilityState) &&
877 pScalabilityState->HcpDecPhase > CODECHAL_HCP_DECODE_PHASE_BE0)
878 {
879 if (pDecodeStatusBuf->m_currIndex == 0)
880 {
881 dwPreIndex = CODECHAL_DECODE_STATUS_NUM - 1;
882 }
883 else
884 {
885 dwPreIndex = pDecodeStatusBuf->m_currIndex - 1;
886 }
887 }
888
889 dwCurrIndex = (CodecHalDecodeScalabilityIsScalableMode(pScalabilityState) &&
890 pScalabilityState->HcpDecPhase > CODECHAL_HCP_DECODE_PHASE_BE0) ?
891 dwPreIndex : pDecodeStatusBuf->m_currIndex;
892 }
893
894 dwOffset = (dwCurrIndex * sizeof(CodechalDecodeStatus)) +
895 pDecodeStatusBuf->m_csEngineIdOffset + sizeof(uint32_t)* ucPhaseIndex +
896 sizeof(uint32_t) * 2;
897
898 MOS_ZeroMemory(&StoreRegParams, sizeof(StoreRegParams));
899 StoreRegParams.presStoreBuffer = &pDecodeStatusBuf->m_statusBuffer;
900 StoreRegParams.dwOffset = dwOffset;
901 StoreRegParams.dwRegister = pMmioRegisters->csEngineIdOffset;
902 CODECHAL_DECODE_CHK_STATUS(pMiInterface->AddMiStoreRegisterMemCmd(pCmdBufferInUse, &StoreRegParams));
903
904 finish:
905 return eStatus;
906 }
907
CodecHalDecodeScalability_InitializeState_G12(CodechalDecode * pDecoder,PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase,CodechalHwInterface * hwInterface,bool bShortFormat,CodechalSetting * settings)908 MOS_STATUS CodecHalDecodeScalability_InitializeState_G12(
909 CodechalDecode *pDecoder,
910 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase,
911 CodechalHwInterface *hwInterface,
912 bool bShortFormat,
913 CodechalSetting *settings)
914 {
915 PMOS_VIRTUALENGINE_INTERFACE pVEInterface;
916 MOS_VIRTUALENGINE_INIT_PARAMS VEInitParms;
917 MOS_USER_FEATURE_VALUE_DATA UserFeatureData;
918 PMOS_INTERFACE osInterface;
919 MhwVdboxMfxInterface *vdboxMfxInterface;
920 uint8_t vdboxNum;
921 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
922
923 CODECHAL_DECODE_FUNCTION_ENTER;
924
925 PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalabilityStateBase);
926
927 CODECHAL_DECODE_CHK_NULL(pDecoder);
928 CODECHAL_DECODE_CHK_NULL(pScalabilityState);
929 CODECHAL_DECODE_CHK_NULL(hwInterface);
930 osInterface = hwInterface->GetOsInterface();
931 CODECHAL_DECODE_CHK_NULL(osInterface);
932
933 vdboxMfxInterface = hwInterface->GetMfxInterface();
934 CODECHAL_DECODE_CHK_NULL(vdboxMfxInterface);
935 vdboxNum = vdboxMfxInterface->GetNumVdbox();
936
937 if (vdboxNum < 2
938 || !osInterface->bHcpDecScalabilityMode)
939 {
940 eStatus = MOS_STATUS_INVALID_PARAMETER;
941 CODECHAL_DECODE_ASSERTMESSAGE("not support scalability on this platform.");
942 goto finish;
943 }
944
945 pScalabilityState->VideoContextForSP = MOS_GPU_CONTEXT_VIDEO;
946 pScalabilityState->VideoContextForMP = MOS_VE_MULTINODESCALING_SUPPORTED(osInterface) ? MOS_GPU_CONTEXT_VIDEO5 : MOS_GPU_CONTEXT_VDBOX2_VIDEO;
947 pScalabilityState->VideoContextFor3P = MOS_VE_MULTINODESCALING_SUPPORTED(osInterface) ? MOS_GPU_CONTEXT_VIDEO7 : MOS_GPU_CONTEXT_VDBOX2_VIDEO2;
948
949 pScalabilityState->numDelay = 15;
950
951 #if (_DEBUG || _RELEASE_INTERNAL)
952 // Reg key of the threshold for mode switch single pipe <-> 2 pipe. Using pic width value to control mode switch for now
953 MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
954 MOS_UserFeature_ReadValue_ID(
955 nullptr,
956 __MEDIA_USER_FEATURE_VALUE_HCP_DECODE_MODE_SWITCH_THRESHOLD1_ID,
957 &UserFeatureData,
958 osInterface->pOsContext);
959 pScalabilityState->dwHcpDecModeSwtichTh1Width = UserFeatureData.u32Data;
960
961 MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
962 MOS_UserFeature_ReadValue_ID(
963 nullptr,
964 __MEDIA_USER_FEATURE_VALUE_HCP_DECODE_MODE_SWITCH_THRESHOLD2_ID,
965 &UserFeatureData,
966 osInterface->pOsContext);
967 pScalabilityState->dwHcpDecModeSwtichTh2Width = UserFeatureData.u32Data;
968
969 // Reg key to control hevc real tile decoding
970 MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
971 MOS_UserFeature_ReadValue_ID(
972 nullptr,
973 __MEDIA_USER_FEATURE_VALUE_DISABLE_HEVC_REALTILE_DECODE_ID,
974 &UserFeatureData,
975 osInterface->pOsContext);
976 pScalabilityState->bDisableRtMode = (UserFeatureData.u32Data != 0);
977
978 // Reg key to control hevc real tile multi-phase decoding
979 MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
980 MOS_UserFeature_ReadValue_ID(
981 nullptr,
982 __MEDIA_USER_FEATURE_VALUE_ENABLE_HEVC_REALTILE_MULTI_PHASE_DECODE_ID,
983 &UserFeatureData,
984 osInterface->pOsContext);
985 pScalabilityState->bEnableRtMultiPhase = (UserFeatureData.u32Data != 0);
986
987 MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
988 MOS_UserFeature_ReadValue_ID(
989 nullptr,
990 __MEDIA_USER_FEATURE_VALUE_SCALABILITY_OVERRIDE_SPLIT_WIDTH_IN_MINCB,
991 &UserFeatureData,
992 osInterface->pOsContext);
993 pScalabilityState->dbgOvrdWidthInMinCb = UserFeatureData.u32Data;
994
995 MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
996 MOS_UserFeature_ReadValue_ID(
997 nullptr,
998 __MEDIA_USER_FEATURE_VALUE_HCP_DECODE_USER_PIPE_NUM_ID,
999 &UserFeatureData,
1000 osInterface->pOsContext);
1001 pScalabilityState->dbgOverUserPipeNum = (uint8_t)UserFeatureData.u32Data;
1002 #endif
1003
1004 // enable FE separate submission by default in multi-pipe mode
1005 if((vdboxNum > 2) && osInterface->phasedSubmission)
1006 {
1007 pScalabilityState->bFESeparateSubmission = true;
1008 }
1009 else if ((vdboxNum > 2)
1010 #if (_DEBUG || _RELEASE_INTERNAL)
1011 && (((pScalabilityState->dbgOverUserPipeNum >= 3)
1012 && (pScalabilityState->dbgOverUserPipeNum <= vdboxNum)))
1013 #endif
1014 )
1015 {
1016 pScalabilityState->bFESeparateSubmission = true;
1017 }
1018 else
1019 {
1020 pScalabilityState->bFESeparateSubmission = false;
1021 }
1022
1023 if(osInterface->bParallelSubmission)
1024 {
1025 pScalabilityState->bFESeparateSubmission = false;
1026 }
1027
1028 #if (_DEBUG || _RELEASE_INTERNAL)
1029 if (osInterface->bEnableDbgOvrdInVE)
1030 {
1031 //if DbgOverride is enabled, FE separate submission is not supported
1032 pScalabilityState->bFESeparateSubmission = false;
1033 }
1034 #endif
1035
1036 pScalabilityState->bFESeparateSubmissionVT = pScalabilityState->bFESeparateSubmission;
1037
1038 if (pScalabilityState->bFESeparateSubmission)
1039 {
1040 MOS_GPU_CONTEXT GpuContext = MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(osInterface) ? MOS_GPU_CONTEXT_VIDEO : MOS_GPU_CONTEXT_VIDEO4;
1041 GpuContext = MOS_VE_MULTINODESCALING_SUPPORTED(osInterface) ? MOS_GPU_CONTEXT_VIDEO4 : GpuContext;
1042
1043 MOS_GPUCTX_CREATOPTIONS_ENHANCED createOpts;
1044 createOpts.UsingSFC = settings->sfcInUseHinted && settings->downsamplingHinted
1045 && (MEDIA_IS_SKU(hwInterface->GetSkuTable(), FtrSFCPipe)
1046 && !MEDIA_IS_SKU(hwInterface->GetSkuTable(), FtrDisableVDBox2SFC));
1047 CODECHAL_DECODE_CHK_STATUS(osInterface->pfnCreateGpuContext(
1048 osInterface,
1049 GpuContext,
1050 MOS_GPU_NODE_VIDEO,
1051 &createOpts));
1052
1053 pScalabilityState->VideoContextForFE = GpuContext;
1054 }
1055
1056 pScalabilityState->Standard = pDecoder->GetStandard();
1057 pScalabilityState->VideoContext = pDecoder->GetVideoContext();
1058 pScalabilityState->bShortFormatInUse = bShortFormat;
1059 pScalabilityState->ucNumVdbox = vdboxNum;
1060 pScalabilityState->pHwInterface = hwInterface;
1061
1062 //virtual engine init with scalability
1063 MOS_ZeroMemory(&VEInitParms, sizeof(VEInitParms));
1064 VEInitParms.bScalabilitySupported = true;
1065 VEInitParms.bFESeparateSubmit = pScalabilityState->bFESeparateSubmission;
1066 VEInitParms.ucMaxNumPipesInUse = CodecHalDecodeMaxNumPipesInUseG12(vdboxNum);
1067 VEInitParms.ucNumOfSdryCmdBufSets = CODECHAL_SCALABILITY_DECODE_SECONDARY_CMDBUFSET_NUM;
1068 VEInitParms.ucMaxNumOfSdryCmdBufInOneFrame = pScalabilityState->bFESeparateSubmission ? VEInitParms.ucMaxNumPipesInUse : (VEInitParms.ucMaxNumPipesInUse + 1);
1069 CODECHAL_DECODE_CHK_STATUS(osInterface->pfnVirtualEngineInterfaceInitialize(osInterface, &VEInitParms));
1070 pScalabilityState->pVEInterface = pVEInterface = osInterface->pVEInterf;
1071
1072 if (pVEInterface->pfnVEGetHintParams)
1073 {
1074 CODECHAL_DECODE_CHK_STATUS(pVEInterface->pfnVEGetHintParams(pVEInterface, true, &pScalabilityState->pScalHintParms));
1075 }
1076 if (pVEInterface->pfnVEGetHintParams)
1077 {
1078 CODECHAL_DECODE_CHK_STATUS(pVEInterface->pfnVEGetHintParams(pVEInterface, false, &pScalabilityState->pSingleHintParms));
1079 }
1080
1081 #if (_DEBUG || _RELEASE_INTERNAL)
1082 MOS_ZeroMemory(&UserFeatureData, sizeof(UserFeatureData));
1083 MOS_UserFeature_ReadValue_ID(
1084 nullptr,
1085 __MEDIA_USER_FEATURE_VALUE_HCP_DECODE_ALWAYS_FRAME_SPLIT_ID,
1086 &UserFeatureData,
1087 osInterface->pOsContext);
1088 pScalabilityState->bAlwaysFrameSplit = UserFeatureData.u32Data ? true : false;
1089 #endif
1090
1091 pScalabilityState->bIsEvenSplit = true;
1092
1093 pScalabilityState->bIsEnableEndCurrentBatchBuffLevel = MEDIA_IS_SKU(hwInterface->GetSkuTable(), FtrConditionalBatchBuffEnd);
1094
1095 if (pDecoder->GetStandard() == CODECHAL_HEVC)
1096 {
1097 pScalabilityState->pfnGetHcpBufferSize = GetHevcBufferSize;
1098 pScalabilityState->pfnIsHcpBufferReallocNeeded = IsHevcBufferReallocNeeded;
1099 }
1100 else if (pDecoder->GetStandard() == CODECHAL_VP9)
1101 {
1102 pScalabilityState->pfnGetHcpBufferSize = GetVp9BufferSize;
1103 pScalabilityState->pfnIsHcpBufferReallocNeeded = IsVp9BufferReallocNeeded;
1104 }
1105 else
1106 {
1107 eStatus = MOS_STATUS_INVALID_PARAMETER;
1108 CODECHAL_DECODE_ASSERTMESSAGE("unsupported decode format for scalability mode.");
1109 goto finish;
1110 }
1111
1112 pScalabilityState->bToggleCABACStreamOutBuffer = false;
1113 pScalabilityState->pfnDecidePipeNum = CodecHalDecodeScalability_DecidePipeNum_G12;
1114 pScalabilityState->pfnMapPipeNumToLRCACount = CodechalDecodeScalability_MapPipeNumToLRCACount_G12;
1115 #if (_DEBUG || _RELEASE_INTERNAL)
1116 pScalabilityState->pfnDebugOvrdDecidePipeNum = CodechalDecodeScalability_DebugOvrdDecidePipeNum_G12;
1117 #endif
1118
1119 pScalabilityState->sliceStateCLs = CODECHAL_SCALABILITY_SLICE_STATE_CACHELINES_PER_SLICE_TGL;
1120 CODECHAL_DECODE_CHK_STATUS(CodecHalDecodeScalability_AllocateResources_FixedSizes_G12(pScalabilityState));
1121
1122 finish:
1123 return eStatus;
1124 }
1125
CodecHalDecodeScalability_AdvanceRealTilePass(PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase)1126 MOS_STATUS CodecHalDecodeScalability_AdvanceRealTilePass(
1127 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase)
1128 {
1129 auto eStatus = MOS_STATUS_SUCCESS;
1130
1131 PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalabilityStateBase);
1132
1133 CODECHAL_DECODE_CHK_NULL_RETURN(pScalabilityStateBase);
1134 CODECHAL_DECODE_ASSERT(pScalabilityState->bIsRtMode);
1135 CODECHAL_DECODE_ASSERT(pScalabilityState->u8RtCurPhase < pScalabilityState->u8RtPhaseNum);
1136
1137 pScalabilityState->u8RtCurPipe++;
1138 if (pScalabilityState->u8RtCurPipe >= pScalabilityState->ucScalablePipeNum)
1139 {
1140 pScalabilityState->u8RtCurPipe = 0;
1141 pScalabilityState->u8RtCurPhase++;
1142 }
1143
1144 return eStatus;
1145 }
1146
CodecHalDecodeScalability_GetCurrentRealTileColumnId(PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase,uint8_t & col)1147 MOS_STATUS CodecHalDecodeScalability_GetCurrentRealTileColumnId(
1148 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase,
1149 uint8_t &col)
1150 {
1151 auto eStatus = MOS_STATUS_SUCCESS;
1152
1153 PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalabilityStateBase);
1154
1155 CODECHAL_DECODE_CHK_NULL_RETURN(pScalabilityStateBase);
1156
1157 col = pScalabilityState->u8RtCurPipe + pScalabilityState->u8RtCurPhase * pScalabilityState->ucScalablePipeNum;
1158 return eStatus;
1159 }
1160
CodecHalDecodeScalability_SetSfcState(PCODECHAL_DECODE_SCALABILITY_STATE scalabilityStateBase,void * picParams,CodecRectangle * srcRegion,CodecRectangle * dstRegion,PCODECHAL_DECODE_SFC_SCALABILITY_PARAMS sfcScalabilityParams)1161 MOS_STATUS CodecHalDecodeScalability_SetSfcState(
1162 PCODECHAL_DECODE_SCALABILITY_STATE scalabilityStateBase,
1163 void *picParams,
1164 CodecRectangle *srcRegion,
1165 CodecRectangle *dstRegion,
1166 PCODECHAL_DECODE_SFC_SCALABILITY_PARAMS sfcScalabilityParams)
1167 {
1168 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1169 uint32_t minCbSize, maxCbSize, widthInPixel, widthInMaxCb;
1170 uint32_t srcStartX = 0, srcEndX = 0;
1171 uint32_t engMode, tileType;
1172 uint32_t tileColumnIndex = 0;
1173 uint32_t tileColumnCount = 0;
1174 bool isInput444;
1175 uint32_t ildbXOffset;
1176 uint64_t oneBySf;
1177 double xLandingPoint;
1178 uint32_t srcEndXTemp;
1179 uint32_t xOffset;
1180 uint32_t tileEndX;
1181 uint32_t dstStartX, dstEndX;
1182
1183 PCODECHAL_DECODE_SCALABILITY_STATE_G12 scalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(scalabilityStateBase);
1184
1185 CODECHAL_DECODE_CHK_NULL_RETURN(scalabilityStateBase);
1186 CODECHAL_DECODE_CHK_NULL_RETURN(sfcScalabilityParams);
1187 CODECHAL_DECODE_CHK_NULL_RETURN(srcRegion);
1188 CODECHAL_DECODE_CHK_NULL_RETURN(dstRegion);
1189 CODECHAL_DECODE_CHK_NULL_RETURN(picParams);
1190
1191 if (!CodecHalDecodeScalabilityIsScalableMode(scalabilityState))
1192 {
1193 return MOS_STATUS_SUCCESS;
1194 }
1195
1196 if (scalabilityState->Standard == CODECHAL_HEVC)
1197 {
1198 PCODEC_HEVC_PIC_PARAMS hevcPicParams = (PCODEC_HEVC_PIC_PARAMS)picParams;
1199
1200 minCbSize = 1 << (hevcPicParams->log2_min_luma_coding_block_size_minus3 + 3);
1201 maxCbSize = (minCbSize << hevcPicParams->log2_diff_max_min_luma_coding_block_size);
1202 widthInPixel = hevcPicParams->PicWidthInMinCbsY * minCbSize;
1203 widthInMaxCb = MOS_ROUNDUP_DIVIDE(widthInPixel, maxCbSize);
1204 isInput444 = (hevcPicParams->chroma_format_idc == HCP_CHROMA_FORMAT_YUV444);
1205 }
1206 else if (scalabilityState->Standard == CODECHAL_VP9)
1207 {
1208 PCODEC_VP9_PIC_PARAMS vp9PicParams = (PCODEC_VP9_PIC_PARAMS)picParams;
1209
1210 minCbSize = CODEC_VP9_MIN_BLOCK_WIDTH;
1211 maxCbSize = CODEC_VP9_SUPER_BLOCK_WIDTH;
1212 widthInPixel = vp9PicParams->FrameWidthMinus1 + 1;
1213 widthInMaxCb = MOS_ROUNDUP_DIVIDE(widthInPixel, maxCbSize);
1214 isInput444 = (vp9PicParams->subsampling_x == 0 && vp9PicParams->subsampling_y == 0);
1215 }
1216 else
1217 {
1218 eStatus = MOS_STATUS_INVALID_PARAMETER;
1219 CODECHAL_DECODE_ASSERTMESSAGE("invalid codec type, only HEVC/VP9 are supported in scalability mode.");
1220 return eStatus;
1221 }
1222
1223 if (scalabilityState->bIsRtMode)
1224 {
1225 PCODEC_HEVC_PIC_PARAMS hevcPicParams = (PCODEC_HEVC_PIC_PARAMS)picParams;
1226 uint8_t col = scalabilityState->u8RtCurPipe + scalabilityState->u8RtCurPhase * scalabilityState->ucScalablePipeNum;
1227
1228 if (scalabilityState->u8RtCurPipe == 0)
1229 {
1230 engMode = 1;
1231 }
1232 else if (scalabilityState->u8RtCurPipe == scalabilityState->ucScalablePipeNum - 1)
1233 {
1234 engMode = 2;
1235 }
1236 else
1237 {
1238 engMode = 3;
1239 }
1240
1241 if (hevcPicParams->uniform_spacing_flag == 1)
1242 {
1243 srcStartX = (col * widthInMaxCb) / (hevcPicParams->num_tile_columns_minus1 + 1) * maxCbSize;
1244 srcEndX = ((col + 1) * widthInMaxCb) / (hevcPicParams->num_tile_columns_minus1 + 1) * maxCbSize - 1;
1245 }
1246 else
1247 {
1248 for (uint8_t i = 0; i < col; i++)
1249 {
1250 srcStartX += (hevcPicParams->column_width_minus1[i] + 1) * maxCbSize;
1251 }
1252 if (col == hevcPicParams->num_tile_columns_minus1)
1253 {
1254 srcEndX = srcRegion->m_x + srcRegion->m_width - 1;
1255 }
1256 else
1257 {
1258 srcEndX = srcStartX + (hevcPicParams->column_width_minus1[col] + 1) * maxCbSize - 1;
1259 }
1260 }
1261
1262 tileType = 0;
1263 tileColumnIndex = col;
1264 tileColumnCount = hevcPicParams->num_tile_columns_minus1 + 1;
1265 }
1266 else if (CodecHalDecodeScalabilityIsBEPhaseG12(scalabilityState))
1267 {
1268 uint8_t pipeIndex = scalabilityState->HcpDecPhase - CODECHAL_HCP_DECODE_PHASE_BE0;
1269
1270 if (pipeIndex == 0)
1271 {
1272 engMode = 1;
1273 }
1274 else if (pipeIndex == scalabilityState->ucScalablePipeNum - 1)
1275 {
1276 engMode = 2;
1277 }
1278 else
1279 {
1280 engMode = 3;
1281 }
1282
1283 srcStartX = pipeIndex * widthInMaxCb / scalabilityState->ucScalablePipeNum;
1284 srcStartX *= maxCbSize;
1285 if (pipeIndex == scalabilityState->ucScalablePipeNum - 1)
1286 {
1287 srcEndX = srcRegion->m_x + srcRegion->m_width - 1;
1288 }
1289 else
1290 {
1291 srcEndX = (pipeIndex + 1) * widthInMaxCb / scalabilityState->ucScalablePipeNum;
1292 srcEndX = srcEndX * maxCbSize - 1;
1293 }
1294 #if (_DEBUG || _RELEASE_INTERNAL)
1295 if (scalabilityState->dbgOvrdWidthInMinCb && scalabilityState->ucScalablePipeNum == 2)
1296 {
1297 if (pipeIndex == 1)
1298 {
1299 srcStartX = scalabilityState->dbgOvrdWidthInMinCb * minCbSize;
1300 srcEndX = srcRegion->m_x + srcRegion->m_width - 1;
1301 }
1302 else
1303 {
1304 srcStartX = 0;
1305 srcEndX = scalabilityState->dbgOvrdWidthInMinCb * minCbSize - 1;
1306 }
1307 }
1308 #endif
1309
1310 tileType = 1;
1311 tileColumnIndex = pipeIndex;
1312 tileColumnCount = scalabilityState->ucScalablePipeNum;
1313 }
1314 else
1315 {
1316 engMode = 0;
1317 tileType = 0;
1318 srcStartX = 0;
1319 srcEndX = srcRegion->m_x + srcRegion->m_width - 1;
1320 }
1321
1322 // Clamp srcStartX, srcEndX into source region
1323 if (srcStartX < srcRegion->m_x)
1324 srcStartX = srcRegion->m_x;
1325 if (srcEndX > srcRegion->m_x + srcRegion->m_width - 1)
1326 srcEndX = srcRegion->m_x + srcRegion->m_width - 1;
1327
1328 if (tileColumnIndex == 0)
1329 {
1330 scalabilityState->fistValidTileIndex = 0;
1331 scalabilityState->lastValidTileIndex = tileColumnCount - 1;
1332 scalabilityState->dstXLandingCount = 0;
1333 }
1334
1335 ildbXOffset = (scalabilityState->Standard == CODECHAL_HEVC) ? 5 : 8; // 1 : HEVC; 0 : VP9
1336 oneBySf = (uint64_t)((double)((uint64_t)(srcRegion->m_width) * 524288 / (dstRegion->m_width)));
1337
1338 //------------------ start ildb offset correction -----------------------------//
1339 srcEndXTemp = srcEndX - ildbXOffset;
1340
1341 //---------------------- destination startX determination logic ---------------//
1342 if ((srcRegion->m_x + srcRegion->m_width - 1) <= srcEndXTemp)
1343 {
1344 xOffset = 0;
1345 tileEndX = (srcRegion->m_x + srcRegion->m_width);
1346 }
1347 else
1348 {
1349 xOffset = isInput444 ? 3 : (scalabilityState->Standard == CODECHAL_HEVC) ? 8 : 11;
1350 tileEndX = srcEndXTemp;
1351 }
1352
1353 while (true)
1354 {
1355 if (srcEndXTemp - srcRegion->m_x < (xOffset + 1))
1356 {
1357 dstEndX = 0;
1358 break;
1359 }
1360 if (scalabilityState->dstXLandingCount == 0)
1361 {
1362 scalabilityState->fistValidTileIndex = tileColumnIndex;
1363 }
1364
1365 // xLandingpoint = (float)(((max(0, (((float)dest_cntX * (float)one_by_sf) + Xphaseshift)) + ((float)1 << (one_by sf_fraction_precision - beta_precision - 1))) / 524288) + SourceRegionHorizontalOffset)
1366 //
1367 {
1368 const uint32_t one_by_sf_fraction_precision = 19;
1369 const uint32_t beta_precision = 5;
1370 uint32_t xPhaseShift = MOS_CLAMP_MIN_MAX(MOS_F_ROUND((((double)srcRegion->m_width / dstRegion->m_width - 1.0) / 2.0) * 524288.0F), -(1 << (4 + 19)), ((1 << (4 + 19)) - 1));
1371
1372 double tempDestCntx = (((double)scalabilityState->dstXLandingCount * (double)oneBySf) + xPhaseShift);
1373 if (tempDestCntx < 0)
1374 {
1375 tempDestCntx = 0;
1376 }
1377 xLandingPoint = (double)(((tempDestCntx + ((double)(1 << (one_by_sf_fraction_precision - beta_precision - 1)))) / 524288) + srcRegion->m_x);
1378 }
1379
1380 if (xLandingPoint >= (double)(tileEndX - xOffset))
1381 {
1382 dstEndX = scalabilityState->dstXLandingCount - 1;
1383 break;
1384 }
1385 else
1386 {
1387 scalabilityState->dstXLandingCount++;
1388 }
1389 }
1390
1391 if (xOffset == 0)
1392 {
1393 scalabilityState->lastValidTileIndex = tileColumnIndex;
1394 }
1395
1396 // Last column end at destination region right border.
1397 if (tileColumnIndex == scalabilityState->lastValidTileIndex)
1398 {
1399 dstEndX = dstRegion->m_x + dstRegion->m_width - 1;
1400 }
1401
1402 if (tileColumnIndex <= scalabilityState->fistValidTileIndex)
1403 dstStartX = 0;
1404 else if (tileColumnIndex <= scalabilityState->lastValidTileIndex)
1405 {
1406 dstStartX = scalabilityState->lastDstEndX + 1;
1407 }
1408 else
1409 {
1410 dstStartX = 0;
1411 dstEndX = 0;
1412 }
1413 scalabilityState->lastDstEndX = dstEndX;
1414
1415 sfcScalabilityParams->engineMode = engMode;
1416 sfcScalabilityParams->tileType = tileType;
1417 sfcScalabilityParams->srcStartX = srcStartX;
1418 sfcScalabilityParams->srcEndX = srcEndX;
1419 sfcScalabilityParams->dstStartX = dstStartX;
1420 sfcScalabilityParams->dstEndX = dstEndX;
1421
1422 return eStatus;
1423 }
1424
CodecHalDecodeScalabilityIsToSubmitCmdBuffer_G12(PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase)1425 bool CodecHalDecodeScalabilityIsToSubmitCmdBuffer_G12(
1426 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase)
1427 {
1428 PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalabilityStateBase);
1429
1430 if (pScalabilityState == nullptr)
1431 {
1432 return false;
1433 }
1434 else
1435 {
1436 return (CodecHalDecodeScalabilityIsFinalBEPhaseG12(pScalabilityState) ||
1437 (pScalabilityState->HcpDecPhase == CODECHAL_HCP_DECODE_PHASE_FE && pScalabilityState->bFESeparateSubmission) ||
1438 CodecHalDecodeScalabilityIsLastRealTilePass(pScalabilityState));
1439 }
1440 }
1441
CodecHalDecodeScalability_AllocateResources_VariableSizes_G12(PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,PMHW_VDBOX_HCP_BUFFER_SIZE_PARAMS pHcpBufSizeParam,PMHW_VDBOX_HCP_BUFFER_REALLOC_PARAMS pAllocParam)1442 MOS_STATUS CodecHalDecodeScalability_AllocateResources_VariableSizes_G12(
1443 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,
1444 PMHW_VDBOX_HCP_BUFFER_SIZE_PARAMS pHcpBufSizeParam,
1445 PMHW_VDBOX_HCP_BUFFER_REALLOC_PARAMS pAllocParam)
1446 {
1447 MOS_ALLOC_GFXRES_PARAMS AllocParamsForBufferLinear;
1448 PMOS_INTERFACE pOsInterface;
1449 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1450
1451 CODECHAL_DECODE_FUNCTION_ENTER;
1452
1453 CODECHAL_DECODE_CHK_NULL_RETURN(pScalabilityState);
1454 CODECHAL_DECODE_CHK_NULL_RETURN(pScalabilityState->pHwInterface);
1455 CODECHAL_DECODE_CHK_NULL_RETURN(pScalabilityState->pHwInterface->GetOsInterface());
1456 CODECHAL_DECODE_CHK_NULL_RETURN(pHcpBufSizeParam);
1457 CODECHAL_DECODE_CHK_NULL_RETURN(pAllocParam);
1458 pOsInterface = pScalabilityState->pHwInterface->GetOsInterface();
1459
1460 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_AllocateResources_VariableSizes(pScalabilityState, pHcpBufSizeParam, pAllocParam));
1461
1462 // for multi-pipe scalability mode
1463 if (pScalabilityState->ucNumVdbox > 2)
1464 {
1465 if (pScalabilityState->bFESeparateSubmission && pOsInterface->bParallelSubmission)
1466 {
1467 for (int i = 1; i < CODECHAL_HCP_STREAMOUT_BUFFER_MAX_NUM; i++)
1468 {
1469 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_AllocateCABACStreamOutBuffer(pScalabilityState,
1470 pHcpBufSizeParam,
1471 pAllocParam,
1472 &pScalabilityState->resCABACSyntaxStreamOutBuffer[i]));
1473 }
1474
1475 pScalabilityState->presCABACStreamOutBuffer =
1476 pScalabilityState->bToggleCABACStreamOutBuffer ? &pScalabilityState->resCABACSyntaxStreamOutBuffer[1] : &pScalabilityState->resCABACSyntaxStreamOutBuffer[0];
1477
1478 pScalabilityState->bToggleCABACStreamOutBuffer = !pScalabilityState->bToggleCABACStreamOutBuffer;
1479 }
1480 }
1481
1482 return eStatus;
1483 }
1484
CodecHalDecodeScalability_AllocateResources_FixedSizes_G12(PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState)1485 MOS_STATUS CodecHalDecodeScalability_AllocateResources_FixedSizes_G12(
1486 PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState)
1487 {
1488 PMOS_INTERFACE pOsInterface;
1489 MOS_ALLOC_GFXRES_PARAMS AllocParamsForBufferLinear;
1490 MOS_LOCK_PARAMS LockFlagsWriteOnly;
1491 uint8_t * pData = nullptr;
1492 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1493
1494 CODECHAL_DECODE_FUNCTION_ENTER;
1495
1496 CODECHAL_DECODE_CHK_NULL_RETURN(pScalabilityState);
1497 CODECHAL_DECODE_CHK_NULL_RETURN(pScalabilityState->pHwInterface);
1498 CODECHAL_DECODE_CHK_NULL_RETURN(pScalabilityState->pHwInterface->GetOsInterface());
1499
1500 pOsInterface = pScalabilityState->pHwInterface->GetOsInterface();
1501
1502 MOS_ZeroMemory(&LockFlagsWriteOnly, sizeof(MOS_LOCK_PARAMS));
1503 LockFlagsWriteOnly.WriteOnly = 1;
1504
1505 // initiate allocation paramters
1506 MOS_ZeroMemory(&AllocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
1507 AllocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
1508 AllocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
1509 AllocParamsForBufferLinear.Format = Format_Buffer;
1510
1511 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_AllocateResources_FixedSizes(pScalabilityState));
1512
1513 //Allocate additional BEs Semaphore memory for two pipes to avoid race condition
1514 if (!pOsInterface->phasedSubmission)
1515 {
1516 AllocParamsForBufferLinear.pBufName = "AdditionalBESemaphoreMemory";
1517 AllocParamsForBufferLinear.dwBytes = sizeof(uint32_t);
1518 for (uint32_t i = 0; i < 2; i++)
1519 {
1520 eStatus = (MOS_STATUS)pOsInterface->pfnAllocateResource(
1521 pOsInterface,
1522 &AllocParamsForBufferLinear,
1523 &pScalabilityState->resSemaMemBEsAdditional[i]);
1524
1525 if (eStatus != MOS_STATUS_SUCCESS)
1526 {
1527 CODECHAL_DECODE_ASSERTMESSAGE("Failed to allocate Additional BE Semaphore memory.");
1528 return eStatus;
1529 }
1530
1531 pData = (uint8_t *)pOsInterface->pfnLockResource(
1532 pOsInterface,
1533 &pScalabilityState->resSemaMemBEsAdditional[i],
1534 &LockFlagsWriteOnly);
1535
1536 CODECHAL_DECODE_CHK_NULL_RETURN(pData);
1537
1538 MOS_ZeroMemory(pData, sizeof(uint32_t));
1539
1540 CODECHAL_DECODE_CHK_STATUS_RETURN(pOsInterface->pfnUnlockResource(
1541 pOsInterface,
1542 &pScalabilityState->resSemaMemBEsAdditional[i]));
1543 }
1544 }
1545
1546 return eStatus;
1547 }
1548
CodecHalDecodeScalability_Destroy_G12(PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState)1549 void CodecHalDecodeScalability_Destroy_G12(
1550 PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState)
1551 {
1552 PMOS_INTERFACE pOsInterface;
1553
1554 CODECHAL_DECODE_FUNCTION_ENTER;
1555
1556 CODECHAL_DECODE_CHK_NULL_NO_STATUS_RETURN(pScalabilityState);
1557 CODECHAL_DECODE_CHK_NULL_NO_STATUS_RETURN(pScalabilityState->pHwInterface);
1558 CODECHAL_DECODE_CHK_NULL_NO_STATUS_RETURN(pScalabilityState->pHwInterface->GetOsInterface());
1559 pOsInterface = pScalabilityState->pHwInterface->GetOsInterface();
1560
1561 CodecHalDecodeScalability_Destroy(pScalabilityState);
1562
1563 for (int i = 0; i < 2; i++)
1564 {
1565 pOsInterface->pfnFreeResource(
1566 pOsInterface,
1567 &pScalabilityState->resSemaMemBEsAdditional[i]);
1568 }
1569
1570 return;
1571 }
1572
CodecHalDecodeScalability_DecideEnableScala_G12(PCODECHAL_DECODE_SCALABILITY_STATE pScalState,PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS pInitParams,bool bCanEnableRealTile)1573 bool CodecHalDecodeScalability_DecideEnableScala_G12(
1574 PCODECHAL_DECODE_SCALABILITY_STATE pScalState,
1575 PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS pInitParams,
1576 bool bCanEnableRealTile)
1577 {
1578 bool bEnableScala = false;
1579
1580 CODECHAL_DECODE_FUNCTION_ENTER;
1581
1582 PMOS_INTERFACE pOsInterface = pScalState->pHwInterface->GetOsInterface();
1583
1584 if (pInitParams->usingHistogram)
1585 {
1586 bEnableScala = false;
1587 }
1588 else if (bCanEnableRealTile && (!pOsInterface->osCpInterface->IsCpEnabled() || pOsInterface->bCanEnableSecureRt))
1589 {
1590 bEnableScala = true;
1591 }
1592 else if(MEDIA_IS_SKU(pScalState->pHwInterface->GetSkuTable(), FtrVirtualTileScalabilityDisable))
1593 {
1594 bEnableScala = false;
1595 CODECHAL_DECODE_NORMALMESSAGE(" Disable VT Scalability according to platform SKU");
1596 }
1597 else
1598 {
1599 // NonRextFormat && >=5k - VT Scalability
1600 if (CodechalDecodeNonRextFormat(pInitParams->format) &&
1601 CodechalDecodeResolutionEqualLargerThan5k(pInitParams->u32PicWidthInPixel, pInitParams->u32PicHeightInPixel))
1602 {
1603 bEnableScala = true;
1604 }
1605
1606 // RextFormat && >=4k - VT Scalability
1607 if (!CodechalDecodeNonRextFormat(pInitParams->format) &&
1608 CodechalDecodeResolutionEqualLargerThan4k(pInitParams->u32PicWidthInPixel, pInitParams->u32PicHeightInPixel))
1609 {
1610 bEnableScala = true;
1611
1612 if (MEDIA_IS_SKU(pScalState->pHwInterface->GetSkuTable(), FtrDecodeHEVC422VTScalaDisable))
1613 {
1614 // HEVC 422 8b/10b && <8k - Disable VT Sclability
1615 if ((pScalState->Standard == CODECHAL_HEVC && (pInitParams->format == Format_YUY2 || pInitParams->format == Format_Y210)) &&
1616 (!CodechalDecodeResolutionEqualLargerThan8k(pInitParams->u32PicWidthInPixel, pInitParams->u32PicHeightInPixel)))
1617 {
1618 bEnableScala = false;
1619 CODECHAL_DECODE_NORMALMESSAGE("HEVC 422 && Resolution < 8k - Disable VT Scalability ");
1620 }
1621 }
1622 }
1623 }
1624
1625 return bEnableScala;
1626 }
1627
CodecHalDecodeScalability_DecidePipeNum_G12(PCODECHAL_DECODE_SCALABILITY_STATE pScalState,PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS pInitParams)1628 MOS_STATUS CodecHalDecodeScalability_DecidePipeNum_G12(
1629 PCODECHAL_DECODE_SCALABILITY_STATE pScalState,
1630 PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS pInitParams)
1631 {
1632 PMOS_VIRTUALENGINE_INTERFACE pVEInterface;
1633 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1634
1635 CODECHAL_DECODE_FUNCTION_ENTER;
1636
1637 CODECHAL_DECODE_CHK_NULL_RETURN(pScalState);
1638 CODECHAL_DECODE_CHK_NULL_RETURN(pScalState->pVEInterface);
1639 CODECHAL_DECODE_CHK_NULL_RETURN(pInitParams);
1640 CODECHAL_DECODE_CHK_NULL_RETURN(pScalState->pHwInterface);
1641 CODECHAL_DECODE_CHK_NULL_RETURN(pScalState->pHwInterface->GetOsInterface());
1642
1643 pVEInterface = pScalState->pVEInterface;
1644 pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_Legacy_PIPE_NUM_1;
1645 PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalStateG12 = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalState);
1646 PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS_G12 pInitParamsG12 = static_cast<PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS_G12>(pInitParams);
1647 uint8_t u8MaxTileColumn = HEVC_NUM_MAX_TILE_COLUMN;
1648 bool bCanEnableRealTile = true;
1649 bool bCanEnableScalability = !pScalState->pHwInterface->IsDisableScalability();
1650 PMOS_INTERFACE pOsInterface = pScalState->pHwInterface->GetOsInterface();
1651
1652 #if (_DEBUG || _RELEASE_INTERNAL)
1653 bCanEnableRealTile = !(static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalState))->bDisableRtMode;
1654 if (!pScalStateG12->bEnableRtMultiPhase)
1655 u8MaxTileColumn = 2;
1656 #endif
1657 if(!bCanEnableScalability
1658 && pOsInterface
1659 && (pOsInterface->bHcpDecScalabilityMode == MOS_SCALABILITY_ENABLE_MODE_USER_FORCE))
1660 {
1661 bCanEnableScalability = true;
1662 }
1663
1664 bCanEnableRealTile = bCanEnableRealTile && pInitParamsG12->bIsTileEnabled && (pInitParams->u8NumTileColumns > 1) &&
1665 (pInitParams->u8NumTileColumns <= u8MaxTileColumn) && (pInitParams->u8NumTileRows <= HEVC_NUM_MAX_TILE_ROW) &&
1666 pInitParamsG12->bHasSubsetParams;
1667
1668 if (pInitParams->usingSFC || !bCanEnableScalability)
1669 {
1670 return MOS_STATUS_SUCCESS;
1671 }
1672
1673 #if (_DEBUG || _RELEASE_INTERNAL)
1674 if (pScalState->bAlwaysFrameSplit)
1675 {
1676 if (pScalState->ucNumVdbox != 1)
1677 {
1678 if (pScalState->ucNumVdbox == 2)
1679 {
1680 pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_SCALABLE_PIPE_NUM_2;
1681 }
1682 else
1683 {
1684 uint8_t dbgOverUserPipeNum = pScalStateG12->dbgOverUserPipeNum;
1685 pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_SCALABLE_PIPE_NUM_2;
1686 if ((dbgOverUserPipeNum >= CODECHAL_DECODE_HCP_SCALABLE_PIPE_NUM_2) && (dbgOverUserPipeNum <= pScalState->ucNumVdbox))
1687 {
1688 pScalState->ucScalablePipeNum = dbgOverUserPipeNum;
1689 }
1690 }
1691 }
1692 }
1693 else
1694 #endif
1695 {
1696 if (pScalState->ucNumVdbox != 1)
1697 {
1698 if (pScalState->ucNumVdbox == 2)
1699 {
1700 if (pScalState->dwHcpDecModeSwtichTh1Width != 0)
1701 {
1702 if (pInitParams->u32PicWidthInPixel >= pScalState->dwHcpDecModeSwtichTh1Width)
1703 {
1704 pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_SCALABLE_PIPE_NUM_2;
1705 }
1706 }
1707 else if (CodecHalDecodeScalability_DecideEnableScala_G12(pScalState, pInitParams, bCanEnableRealTile))
1708 {
1709 pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_SCALABLE_PIPE_NUM_2;
1710 }
1711
1712 if (pScalState->bIsEvenSplit == false)
1713 {
1714 // disable scalability for clips with width less than split condition when MMC is on
1715 if (pInitParams->u32PicWidthInPixel <= CODEC_SCALABILITY_FIRST_TILE_WIDTH_4K)
1716 {
1717 pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_Legacy_PIPE_NUM_1;
1718 }
1719 }
1720 }
1721 else
1722 {
1723 pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_Legacy_PIPE_NUM_1;
1724 }
1725 }
1726 }
1727
1728 return eStatus;
1729 }
1730
1731
CodechalDecodeScalability_ConstructParmsForGpuCtxCreation_g12(PCODECHAL_DECODE_SCALABILITY_STATE pScalState,PMOS_GPUCTX_CREATOPTIONS_ENHANCED gpuCtxCreatOpts,CodechalSetting * codecHalSetting)1732 MOS_STATUS CodechalDecodeScalability_ConstructParmsForGpuCtxCreation_g12(
1733 PCODECHAL_DECODE_SCALABILITY_STATE pScalState,
1734 PMOS_GPUCTX_CREATOPTIONS_ENHANCED gpuCtxCreatOpts,
1735 CodechalSetting * codecHalSetting)
1736 {
1737 PMOS_INTERFACE pOsInterface;
1738 CODECHAL_DECODE_SCALABILITY_INIT_PARAMS_G12 initParams;
1739 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1740
1741 CODECHAL_DECODE_FUNCTION_ENTER;
1742
1743 CODECHAL_DECODE_CHK_NULL_RETURN(pScalState);
1744 CODECHAL_DECODE_CHK_NULL_RETURN(pScalState->pHwInterface);
1745 CODECHAL_DECODE_CHK_NULL_RETURN(gpuCtxCreatOpts);
1746 CODECHAL_DECODE_CHK_NULL_RETURN(codecHalSetting);
1747 bool sfcInUse = codecHalSetting->sfcInUseHinted && codecHalSetting->downsamplingHinted
1748 && (MEDIA_IS_SKU(pScalState->pHwInterface->GetSkuTable(), FtrSFCPipe)
1749 && !MEDIA_IS_SKU(pScalState->pHwInterface->GetSkuTable(), FtrDisableVDBox2SFC));
1750 pOsInterface = pScalState->pHwInterface->GetOsInterface();
1751 MEDIA_FEATURE_TABLE *m_skuTable = pOsInterface->pfnGetSkuTable(pOsInterface);
1752 #if (_DEBUG || _RELEASE_INTERNAL)
1753 if (pOsInterface->bEnableDbgOvrdInVE)
1754 {
1755 PMOS_VIRTUALENGINE_INTERFACE pVEInterface = pScalState->pVEInterface;
1756 CODECHAL_DECODE_CHK_NULL_RETURN(pVEInterface);
1757 gpuCtxCreatOpts->DebugOverride = true;
1758 if (MEDIA_IS_SKU(m_skuTable, FtrSfcScalability))
1759 {
1760 gpuCtxCreatOpts->UsingSFC = false;// this param ignored when dbgoverride enabled
1761 }
1762 else
1763 {
1764 gpuCtxCreatOpts->UsingSFC = sfcInUse; // this param ignored when dbgoverride enabled
1765 }
1766 CODECHAL_DECODE_CHK_STATUS_RETURN(pScalState->pfnDebugOvrdDecidePipeNum(pScalState));
1767
1768 if (pOsInterface->apoMosEnabled)
1769 {
1770 CODECHAL_DECODE_CHK_NULL_RETURN(pVEInterface->veInterface);
1771 for (uint32_t i = 0; i < pVEInterface->veInterface->GetEngineCount(); i++)
1772 {
1773 gpuCtxCreatOpts->EngineInstance[i] = pVEInterface->veInterface->GetEngineLogicId(i);
1774 }
1775 }
1776 else
1777 {
1778 for (uint32_t i = 0; i < pVEInterface->ucEngineCount; i++)
1779 {
1780 gpuCtxCreatOpts->EngineInstance[i] = pVEInterface->EngineLogicId[i];
1781 }
1782 }
1783 }
1784 else
1785 #endif
1786 {
1787 if (MEDIA_IS_SKU(m_skuTable, FtrSfcScalability))
1788 {
1789 gpuCtxCreatOpts->UsingSFC = false;
1790 }
1791 else
1792 {
1793 gpuCtxCreatOpts->UsingSFC = sfcInUse;
1794 }
1795
1796 MOS_ZeroMemory(&initParams, sizeof(initParams));
1797 initParams.u32PicWidthInPixel = MOS_ALIGN_CEIL(codecHalSetting->width, 8);
1798 initParams.u32PicHeightInPixel = MOS_ALIGN_CEIL(codecHalSetting->height, 8);
1799 if (((codecHalSetting->standard == CODECHAL_VP9) || (codecHalSetting->standard == CODECHAL_HEVC))
1800 && (codecHalSetting->chromaFormat == HCP_CHROMA_FORMAT_YUV420))
1801 {
1802 initParams.format = Format_NV12;
1803 if (codecHalSetting->lumaChromaDepth == CODECHAL_LUMA_CHROMA_DEPTH_10_BITS)
1804 {
1805 initParams.format = Format_P010;
1806 }
1807 }
1808 initParams.usingSFC = sfcInUse;
1809 initParams.usingSecureDecode = codecHalSetting->secureMode;
1810 CODECHAL_DECODE_CHK_STATUS_RETURN(pScalState->pfnDecidePipeNum(
1811 pScalState,
1812 &initParams));
1813 }
1814
1815 CODECHAL_DECODE_CHK_STATUS_RETURN(pScalState->pfnMapPipeNumToLRCACount(
1816 pScalState,
1817 &gpuCtxCreatOpts->LRCACount));
1818
1819 return eStatus;
1820 }
1821
1822
CodechalDecodeScalability_MapPipeNumToLRCACount_G12(PCODECHAL_DECODE_SCALABILITY_STATE pScalState,uint32_t * LRCACount)1823 MOS_STATUS CodechalDecodeScalability_MapPipeNumToLRCACount_G12(
1824 PCODECHAL_DECODE_SCALABILITY_STATE pScalState,
1825 uint32_t *LRCACount)
1826 {
1827 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1828
1829 CODECHAL_DECODE_FUNCTION_ENTER;
1830
1831 CODECHAL_DECODE_CHK_NULL_RETURN(pScalState);
1832 CODECHAL_DECODE_CHK_NULL_RETURN(LRCACount);
1833
1834 *LRCACount = 1; // initialzed to 1.
1835
1836 switch (pScalState->ucScalablePipeNum)
1837 {
1838 case CODECHAL_DECODE_HCP_SCALABLE_PIPE_NUM_2:
1839 // on GT2 or debug override enabled, FE separate submission = false, FE run on the same engine of BEs;
1840 // on GT3, FE separate submission = true, scalability submission includes only BEs.
1841 *LRCACount = 2;
1842 break;
1843 case CODECHAL_DECODE_HCP_Legacy_PIPE_NUM_1:
1844 *LRCACount = 1;
1845 break;
1846 default:
1847 // in release driver bFESeparateSubmission is always false since this is on GT3 or GT4.
1848 // bFESeparateSubmission could be false if debug override enabled.
1849 if (pScalState->bFESeparateSubmission || (static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalState))->bIsRtMode)
1850 {
1851 *LRCACount = pScalState->ucScalablePipeNum;
1852 }
1853 else
1854 {
1855 *LRCACount = pScalState->ucScalablePipeNum + 1;
1856 }
1857 }
1858
1859 if (*LRCACount > pScalState->ucNumVdbox)
1860 {
1861 CODECHAL_DECODE_ASSERTMESSAGE("LRCA count can not exceed vdbox number.");
1862 return MOS_STATUS_INVALID_PARAMETER;
1863 }
1864
1865 return eStatus;
1866 }
1867
1868 #if (_DEBUG || _RELEASE_INTERNAL)
CodechalDecodeScalability_DebugOvrdDecidePipeNum_G12(PCODECHAL_DECODE_SCALABILITY_STATE pScalState)1869 MOS_STATUS CodechalDecodeScalability_DebugOvrdDecidePipeNum_G12(
1870 PCODECHAL_DECODE_SCALABILITY_STATE pScalState)
1871 {
1872 PMOS_VIRTUALENGINE_INTERFACE pVEInterface;
1873 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1874 PMOS_INTERFACE pOsInterface = nullptr;
1875 CODECHAL_DECODE_CHK_NULL_RETURN(pScalState);
1876 CODECHAL_DECODE_CHK_NULL_RETURN(pScalState->pVEInterface);
1877
1878 pVEInterface = pScalState->pVEInterface;
1879 pOsInterface = pVEInterface->pOsInterface;
1880 CODECHAL_DECODE_CHK_NULL_RETURN(pOsInterface);
1881
1882 if (pOsInterface->apoMosEnabled)
1883 {
1884 CODECHAL_DECODE_CHK_NULL_RETURN(pVEInterface->veInterface);
1885 auto veInterface = pVEInterface->veInterface;
1886 if (veInterface->GetEngineCount() > pScalState->ucNumVdbox)
1887 {
1888 CODECHAL_DECODE_ASSERTMESSAGE("invalid parameter settings in debug override.");
1889 return MOS_STATUS_INVALID_PARAMETER;
1890 }
1891 else if (veInterface->GetEngineCount() == 1)
1892 {
1893 pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_Legacy_PIPE_NUM_1;
1894 }
1895 else if (veInterface->GetEngineCount() == 2)
1896 {
1897 //engine count = 2, only support FE run on the same engine as one of BE for now.
1898 pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_SCALABLE_PIPE_NUM_2;
1899 }
1900 else
1901 {
1902 bool bEngineLogicIdValid = false;
1903 for (uint8_t i = 0; i < veInterface->GetEngineCount() - 1; i++)
1904 {
1905 if (veInterface->GetEngineLogicId(veInterface->GetEngineCount() - 1) !=
1906 veInterface->GetEngineLogicId(i))
1907 {
1908 bEngineLogicIdValid = true;
1909 }
1910 else
1911 {
1912 bEngineLogicIdValid = false;
1913 break;
1914 }
1915 }
1916 if (bEngineLogicIdValid)
1917 {
1918 pScalState->ucScalablePipeNum = pScalState->ucNumVdbox - 1;
1919 }
1920 }
1921
1922 return eStatus;
1923 }
1924
1925 // debug override for virtual tile
1926 if (pVEInterface->ucEngineCount > pScalState->ucNumVdbox)
1927 {
1928 CODECHAL_DECODE_ASSERTMESSAGE("invalid parameter settings in debug override.");
1929 return MOS_STATUS_INVALID_PARAMETER;
1930 }
1931 else if (pVEInterface->ucEngineCount == 1)
1932 {
1933 pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_Legacy_PIPE_NUM_1;
1934 }
1935 else if (pVEInterface->ucEngineCount == 2)
1936 {
1937 //engine count = 2, only support FE run on the same engine as one of BE for now.
1938 pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_SCALABLE_PIPE_NUM_2;
1939 }
1940 else
1941 {
1942 bool bEngineLogicIdValid = false;
1943 for (uint8_t i = 0; i < pVEInterface->ucEngineCount - 1; i++)
1944 {
1945 if (pVEInterface->EngineLogicId[pVEInterface->ucEngineCount - 1] != pVEInterface->EngineLogicId[i])
1946 {
1947 bEngineLogicIdValid = true;
1948 }
1949 else
1950 {
1951 bEngineLogicIdValid = false;
1952 break;
1953 }
1954 }
1955 if (bEngineLogicIdValid)
1956 {
1957 pScalState->ucScalablePipeNum = pScalState->ucNumVdbox - 1;
1958 }
1959 }
1960
1961 return eStatus;
1962 }
1963 #endif
1964
CodecHalDecodeScalability_DecPhaseToSubmissionType_G12(PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState,PMOS_COMMAND_BUFFER pCmdBuffer)1965 void CodecHalDecodeScalability_DecPhaseToSubmissionType_G12(
1966 PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState,
1967 PMOS_COMMAND_BUFFER pCmdBuffer)
1968 {
1969 switch (pScalabilityState->HcpDecPhase)
1970 {
1971 case CodechalDecode::CodechalHcpDecodePhaseLegacyS2L:
1972 //Note: no break here, S2L and FE commands put in one secondary command buffer.
1973 case CODECHAL_HCP_DECODE_PHASE_FE:
1974 pCmdBuffer->iSubmissionType = SUBMISSION_TYPE_MULTI_PIPE_ALONE;
1975 break;
1976 case CODECHAL_HCP_DECODE_PHASE_BE0:
1977 pCmdBuffer->iSubmissionType = SUBMISSION_TYPE_MULTI_PIPE_MASTER;
1978 break;
1979 case CODECHAL_HCP_DECODE_PHASE_REAL_TILE:
1980 if (pScalabilityState->u8RtCurPipe == 0)
1981 {
1982 pCmdBuffer->iSubmissionType = SUBMISSION_TYPE_MULTI_PIPE_MASTER;
1983 }
1984 else
1985 {
1986 pCmdBuffer->iSubmissionType = SUBMISSION_TYPE_MULTI_PIPE_SLAVE;
1987 pCmdBuffer->iSubmissionType |= ((pScalabilityState->u8RtCurPipe - 1) << SUBMISSION_TYPE_MULTI_PIPE_SLAVE_INDEX_SHIFT);
1988 }
1989
1990 if (!(pScalabilityState->pHwInterface->GetOsInterface()->bParallelSubmission)
1991 && (pScalabilityState->u8RtCurPhase == pScalabilityState->u8RtPhaseNum - 1))
1992 {
1993 if (pScalabilityState->u8RtCurPipe == pScalabilityState->u8RtPipeInLastPhase - 1)
1994 {
1995 pCmdBuffer->iSubmissionType |= SUBMISSION_TYPE_MULTI_PIPE_FLAGS_LAST_PIPE;
1996 }
1997 }
1998 else
1999 {
2000 if (pScalabilityState->u8RtCurPipe == pScalabilityState->ucScalablePipeNum-1)
2001 {
2002 pCmdBuffer->iSubmissionType |= SUBMISSION_TYPE_MULTI_PIPE_FLAGS_LAST_PIPE;
2003 }
2004 }
2005 break;
2006 default:
2007 if((pScalabilityState->HcpDecPhase > CODECHAL_HCP_DECODE_PHASE_BE0) &&
2008 ((pScalabilityState->HcpDecPhase - CODECHAL_HCP_DECODE_PHASE_FE) <= pScalabilityState->ucScalablePipeNum))
2009 {
2010 pCmdBuffer->iSubmissionType = SUBMISSION_TYPE_MULTI_PIPE_SLAVE;
2011 pCmdBuffer->iSubmissionType |= ((pScalabilityState->HcpDecPhase - CODECHAL_HCP_DECODE_PHASE_BE1) << SUBMISSION_TYPE_MULTI_PIPE_SLAVE_INDEX_SHIFT);
2012 if ((pScalabilityState->HcpDecPhase - CODECHAL_HCP_DECODE_PHASE_FE) == pScalabilityState->ucScalablePipeNum)
2013 {
2014 pCmdBuffer->iSubmissionType |= SUBMISSION_TYPE_MULTI_PIPE_FLAGS_LAST_PIPE;
2015 }
2016 }
2017 else
2018 {
2019 pCmdBuffer->iSubmissionType = SUBMISSION_TYPE_MULTI_PIPE_ALONE;
2020 }
2021 }
2022 }
2023