Debian Codegraph @

media_driver/agnostic/gen12/codec/hal/codechal_decode_scalability_g12.cpp

raw
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 //!
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 //!
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
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
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
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
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
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
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)
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
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
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
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
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
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
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 CODECHAL_DECODE_CHK_COND_RETURN(tileColumnCount == 0,"tileColumnCount minmum value should be 1");
1332 scalabilityState->lastValidTileIndex = tileColumnCount - 1;
1333 scalabilityState->dstXLandingCount = 0;
1334 }
1335
1336 ildbXOffset = (scalabilityState->Standard == CODECHAL_HEVC) ? 5 : 8; // 1 : HEVC; 0 : VP9
1337 oneBySf = (uint64_t)((double)((uint64_t)(srcRegion->m_width) * 524288 / (dstRegion->m_width)));
1338
1339 //------------------ start ildb offset correction -----------------------------//
1340 srcEndXTemp = srcEndX - ildbXOffset;
1341
1342 //---------------------- destination startX determination logic ---------------//
1343 if ((srcRegion->m_x + srcRegion->m_width - 1) <= srcEndXTemp)
1344 {
1345 xOffset = 0;
1346 tileEndX = (srcRegion->m_x + srcRegion->m_width);
1347 }
1348 else
1349 {
1350 xOffset = isInput444 ? 3 : (scalabilityState->Standard == CODECHAL_HEVC) ? 8 : 11;
1351 tileEndX = srcEndXTemp;
1352 }
1353
1354 while (true)
1355 {
1356 if (srcEndXTemp - srcRegion->m_x < (xOffset + 1))
1357 {
1358 dstEndX = 0;
1359 break;
1360 }
1361 if (scalabilityState->dstXLandingCount == 0)
1362 {
1363 scalabilityState->fistValidTileIndex = tileColumnIndex;
1364 }
1365
1366 // xLandingpoint = (float)(((max(0, (((float)dest_cntX * (float)one_by_sf) + Xphaseshift)) + ((float)1 << (one_by sf_fraction_precision - beta_precision - 1))) / 524288) + SourceRegionHorizontalOffset)
1367 //
1368 {
1369 const uint32_t one_by_sf_fraction_precision = 19;
1370 const uint32_t beta_precision = 5;
1371 double 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));
1372
1373 double tempDestCntx = (((double)scalabilityState->dstXLandingCount * (double)oneBySf) + xPhaseShift);
1374 if (tempDestCntx < 0)
1375 {
1376 tempDestCntx = 0;
1377 }
1378 xLandingPoint = (double)(((tempDestCntx + ((double)(1 << (one_by_sf_fraction_precision - beta_precision - 1)))) / 524288) + srcRegion->m_x);
1379 }
1380
1381 if (xLandingPoint >= (double)(tileEndX - xOffset))
1382 {
1383 if(scalabilityState->dstXLandingCount >= 1)
1384 {
1385 dstEndX = scalabilityState->dstXLandingCount - 1;
1386 break;
1387 }
1388 else
1389 {
1390 CODECHAL_DECODE_ASSERTMESSAGE("Invalid dstXLandingCount in this condition"); //scalabilityState->dstXLandingCount- 1 should not < 0 at this condition
1391 return MOS_STATUS_INVALID_PARAMETER;
1392 }
1393 }
1394 else
1395 {
1396 scalabilityState->dstXLandingCount++;
1397 }
1398 }
1399
1400 if (xOffset == 0)
1401 {
1402 scalabilityState->lastValidTileIndex = tileColumnIndex;
1403 }
1404
1405 // Last column end at destination region right border.
1406 if (tileColumnIndex == scalabilityState->lastValidTileIndex)
1407 {
1408 dstEndX = dstRegion->m_x + dstRegion->m_width - 1;
1409 }
1410
1411 if (tileColumnIndex <= scalabilityState->fistValidTileIndex)
1412 dstStartX = 0;
1413 else if (tileColumnIndex <= scalabilityState->lastValidTileIndex)
1414 {
1415 dstStartX = scalabilityState->lastDstEndX + 1;
1416 }
1417 else
1418 {
1419 dstStartX = 0;
1420 dstEndX = 0;
1421 }
1422 scalabilityState->lastDstEndX = dstEndX;
1423
1424 sfcScalabilityParams->engineMode = engMode;
1425 sfcScalabilityParams->tileType = tileType;
1426 sfcScalabilityParams->srcStartX = srcStartX;
1427 sfcScalabilityParams->srcEndX = srcEndX;
1428 sfcScalabilityParams->dstStartX = dstStartX;
1429 sfcScalabilityParams->dstEndX = dstEndX;
1430
1431 return eStatus;
1432 }
1433
1434 bool CodecHalDecodeScalabilityIsToSubmitCmdBuffer_G12(
1435 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityStateBase)
1436 {
1437 PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalabilityStateBase);
1438
1439 if (pScalabilityState == nullptr)
1440 {
1441 return false;
1442 }
1443 else
1444 {
1445 return (CodecHalDecodeScalabilityIsFinalBEPhaseG12(pScalabilityState) ||
1446 (pScalabilityState->HcpDecPhase == CODECHAL_HCP_DECODE_PHASE_FE && pScalabilityState->bFESeparateSubmission) ||
1447 CodecHalDecodeScalabilityIsLastRealTilePass(pScalabilityState));
1448 }
1449 }
1450
1451 MOS_STATUS CodecHalDecodeScalability_AllocateResources_VariableSizes_G12(
1452 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,
1453 PMHW_VDBOX_HCP_BUFFER_SIZE_PARAMS pHcpBufSizeParam,
1454 PMHW_VDBOX_HCP_BUFFER_REALLOC_PARAMS pAllocParam)
1455 {
1456 MOS_ALLOC_GFXRES_PARAMS AllocParamsForBufferLinear;
1457 PMOS_INTERFACE pOsInterface;
1458 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1459
1460 CODECHAL_DECODE_FUNCTION_ENTER;
1461
1462 CODECHAL_DECODE_CHK_NULL_RETURN(pScalabilityState);
1463 CODECHAL_DECODE_CHK_NULL_RETURN(pScalabilityState->pHwInterface);
1464 CODECHAL_DECODE_CHK_NULL_RETURN(pScalabilityState->pHwInterface->GetOsInterface());
1465 CODECHAL_DECODE_CHK_NULL_RETURN(pHcpBufSizeParam);
1466 CODECHAL_DECODE_CHK_NULL_RETURN(pAllocParam);
1467 pOsInterface = pScalabilityState->pHwInterface->GetOsInterface();
1468
1469 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_AllocateResources_VariableSizes(pScalabilityState, pHcpBufSizeParam, pAllocParam));
1470
1471 // for multi-pipe scalability mode
1472 if (pScalabilityState->ucNumVdbox > 2)
1473 {
1474 if (pScalabilityState->bFESeparateSubmission && pOsInterface->bParallelSubmission)
1475 {
1476 for (int i = 1; i < CODECHAL_HCP_STREAMOUT_BUFFER_MAX_NUM; i++)
1477 {
1478 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_AllocateCABACStreamOutBuffer(pScalabilityState,
1479 pHcpBufSizeParam,
1480 pAllocParam,
1481 &pScalabilityState->resCABACSyntaxStreamOutBuffer[i]));
1482 }
1483
1484 pScalabilityState->presCABACStreamOutBuffer =
1485 pScalabilityState->bToggleCABACStreamOutBuffer ? &pScalabilityState->resCABACSyntaxStreamOutBuffer[1] : &pScalabilityState->resCABACSyntaxStreamOutBuffer[0];
1486
1487 pScalabilityState->bToggleCABACStreamOutBuffer = !pScalabilityState->bToggleCABACStreamOutBuffer;
1488 }
1489 }
1490
1491 return eStatus;
1492 }
1493
1494 MOS_STATUS CodecHalDecodeScalability_AllocateResources_FixedSizes_G12(
1495 PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState)
1496 {
1497 PMOS_INTERFACE pOsInterface;
1498 MOS_ALLOC_GFXRES_PARAMS AllocParamsForBufferLinear;
1499 MOS_LOCK_PARAMS LockFlagsWriteOnly;
1500 uint8_t * pData = nullptr;
1501 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1502
1503 CODECHAL_DECODE_FUNCTION_ENTER;
1504
1505 CODECHAL_DECODE_CHK_NULL_RETURN(pScalabilityState);
1506 CODECHAL_DECODE_CHK_NULL_RETURN(pScalabilityState->pHwInterface);
1507 CODECHAL_DECODE_CHK_NULL_RETURN(pScalabilityState->pHwInterface->GetOsInterface());
1508
1509 pOsInterface = pScalabilityState->pHwInterface->GetOsInterface();
1510
1511 MOS_ZeroMemory(&LockFlagsWriteOnly, sizeof(MOS_LOCK_PARAMS));
1512 LockFlagsWriteOnly.WriteOnly = 1;
1513
1514 // initiate allocation paramters
1515 MOS_ZeroMemory(&AllocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
1516 AllocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
1517 AllocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
1518 AllocParamsForBufferLinear.Format = Format_Buffer;
1519
1520 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_AllocateResources_FixedSizes(pScalabilityState));
1521
1522 //Allocate additional BEs Semaphore memory for two pipes to avoid race condition
1523 if (!pOsInterface->phasedSubmission)
1524 {
1525 AllocParamsForBufferLinear.pBufName = "AdditionalBESemaphoreMemory";
1526 AllocParamsForBufferLinear.dwBytes = sizeof(uint32_t);
1527 for (uint32_t i = 0; i < 2; i++)
1528 {
1529 eStatus = (MOS_STATUS)pOsInterface->pfnAllocateResource(
1530 pOsInterface,
1531 &AllocParamsForBufferLinear,
1532 &pScalabilityState->resSemaMemBEsAdditional[i]);
1533
1534 if (eStatus != MOS_STATUS_SUCCESS)
1535 {
1536 CODECHAL_DECODE_ASSERTMESSAGE("Failed to allocate Additional BE Semaphore memory.");
1537 return eStatus;
1538 }
1539
1540 pData = (uint8_t *)pOsInterface->pfnLockResource(
1541 pOsInterface,
1542 &pScalabilityState->resSemaMemBEsAdditional[i],
1543 &LockFlagsWriteOnly);
1544
1545 CODECHAL_DECODE_CHK_NULL_RETURN(pData);
1546
1547 MOS_ZeroMemory(pData, sizeof(uint32_t));
1548
1549 CODECHAL_DECODE_CHK_STATUS_RETURN(pOsInterface->pfnUnlockResource(
1550 pOsInterface,
1551 &pScalabilityState->resSemaMemBEsAdditional[i]));
1552 }
1553 }
1554
1555 return eStatus;
1556 }
1557
1558 void CodecHalDecodeScalability_Destroy_G12(
1559 PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState)
1560 {
1561 PMOS_INTERFACE pOsInterface;
1562
1563 CODECHAL_DECODE_FUNCTION_ENTER;
1564
1565 CODECHAL_DECODE_CHK_NULL_NO_STATUS_RETURN(pScalabilityState);
1566 CODECHAL_DECODE_CHK_NULL_NO_STATUS_RETURN(pScalabilityState->pHwInterface);
1567 CODECHAL_DECODE_CHK_NULL_NO_STATUS_RETURN(pScalabilityState->pHwInterface->GetOsInterface());
1568 pOsInterface = pScalabilityState->pHwInterface->GetOsInterface();
1569
1570 CodecHalDecodeScalability_Destroy(pScalabilityState);
1571
1572 for (int i = 0; i < 2; i++)
1573 {
1574 pOsInterface->pfnFreeResource(
1575 pOsInterface,
1576 &pScalabilityState->resSemaMemBEsAdditional[i]);
1577 }
1578
1579 return;
1580 }
1581
1582 bool CodecHalDecodeScalability_DecideEnableScala_G12(
1583 PCODECHAL_DECODE_SCALABILITY_STATE pScalState,
1584 PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS pInitParams,
1585 bool bCanEnableRealTile)
1586 {
1587 bool bEnableScala = false;
1588
1589 CODECHAL_DECODE_FUNCTION_ENTER;
1590
1591 PMOS_INTERFACE pOsInterface = pScalState->pHwInterface->GetOsInterface();
1592
1593 if (pInitParams->usingHistogram)
1594 {
1595 bEnableScala = false;
1596 }
1597 else if (bCanEnableRealTile && (!pOsInterface->osCpInterface->IsCpEnabled() || pOsInterface->bCanEnableSecureRt))
1598 {
1599 bEnableScala = true;
1600 }
1601 else if(MEDIA_IS_SKU(pScalState->pHwInterface->GetSkuTable(), FtrVirtualTileScalabilityDisable))
1602 {
1603 bEnableScala = false;
1604 CODECHAL_DECODE_NORMALMESSAGE(" Disable VT Scalability according to platform SKU");
1605 }
1606 else
1607 {
1608 // NonRextFormat && >=5k - VT Scalability
1609 if (CodechalDecodeNonRextFormat(pInitParams->format) &&
1610 CodechalDecodeResolutionEqualLargerThan5k(pInitParams->u32PicWidthInPixel, pInitParams->u32PicHeightInPixel))
1611 {
1612 bEnableScala = true;
1613 }
1614
1615 // RextFormat && >=4k - VT Scalability
1616 if (!CodechalDecodeNonRextFormat(pInitParams->format) &&
1617 CodechalDecodeResolutionEqualLargerThan4k(pInitParams->u32PicWidthInPixel, pInitParams->u32PicHeightInPixel))
1618 {
1619 bEnableScala = true;
1620
1621 if (MEDIA_IS_SKU(pScalState->pHwInterface->GetSkuTable(), FtrDecodeHEVC422VTScalaDisable))
1622 {
1623 // HEVC 422 8b/10b && <8k - Disable VT Sclability
1624 if ((pScalState->Standard == CODECHAL_HEVC && (pInitParams->format == Format_YUY2 || pInitParams->format == Format_Y210)) &&
1625 (!CodechalDecodeResolutionEqualLargerThan8k(pInitParams->u32PicWidthInPixel, pInitParams->u32PicHeightInPixel)))
1626 {
1627 bEnableScala = false;
1628 CODECHAL_DECODE_NORMALMESSAGE("HEVC 422 && Resolution < 8k - Disable VT Scalability ");
1629 }
1630 }
1631 }
1632 }
1633
1634 return bEnableScala;
1635 }
1636
1637 MOS_STATUS CodecHalDecodeScalability_DecidePipeNum_G12(
1638 PCODECHAL_DECODE_SCALABILITY_STATE pScalState,
1639 PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS pInitParams)
1640 {
1641 PMOS_VIRTUALENGINE_INTERFACE pVEInterface;
1642 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1643
1644 CODECHAL_DECODE_FUNCTION_ENTER;
1645
1646 CODECHAL_DECODE_CHK_NULL_RETURN(pScalState);
1647 CODECHAL_DECODE_CHK_NULL_RETURN(pScalState->pVEInterface);
1648 CODECHAL_DECODE_CHK_NULL_RETURN(pInitParams);
1649 CODECHAL_DECODE_CHK_NULL_RETURN(pScalState->pHwInterface);
1650 CODECHAL_DECODE_CHK_NULL_RETURN(pScalState->pHwInterface->GetOsInterface());
1651
1652 pVEInterface = pScalState->pVEInterface;
1653 pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_Legacy_PIPE_NUM_1;
1654 PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalStateG12 = static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalState);
1655 PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS_G12 pInitParamsG12 = static_cast<PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS_G12>(pInitParams);
1656 uint8_t u8MaxTileColumn = HEVC_NUM_MAX_TILE_COLUMN;
1657 bool bCanEnableRealTile = true;
1658 bool bCanEnableScalability = !pScalState->pHwInterface->IsDisableScalability();
1659 PMOS_INTERFACE pOsInterface = pScalState->pHwInterface->GetOsInterface();
1660
1661 #if (_DEBUG || _RELEASE_INTERNAL)
1662 bCanEnableRealTile = !(static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalState))->bDisableRtMode;
1663 if (!pScalStateG12->bEnableRtMultiPhase)
1664 u8MaxTileColumn = 2;
1665 #endif
1666 if(!bCanEnableScalability
1667 && pOsInterface
1668 && (pOsInterface->bHcpDecScalabilityMode == MOS_SCALABILITY_ENABLE_MODE_USER_FORCE))
1669 {
1670 bCanEnableScalability = true;
1671 }
1672
1673 bCanEnableRealTile = bCanEnableRealTile && pInitParamsG12->bIsTileEnabled && (pInitParams->u8NumTileColumns > 1) &&
1674 (pInitParams->u8NumTileColumns <= u8MaxTileColumn) && (pInitParams->u8NumTileRows <= HEVC_NUM_MAX_TILE_ROW) &&
1675 pInitParamsG12->bHasSubsetParams;
1676
1677 if (pInitParams->usingSFC || !bCanEnableScalability)
1678 {
1679 return MOS_STATUS_SUCCESS;
1680 }
1681
1682 #if (_DEBUG || _RELEASE_INTERNAL)
1683 if (pScalState->bAlwaysFrameSplit)
1684 {
1685 if (pScalState->ucNumVdbox != 1)
1686 {
1687 if (pScalState->ucNumVdbox == 2)
1688 {
1689 pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_SCALABLE_PIPE_NUM_2;
1690 }
1691 else
1692 {
1693 uint8_t dbgOverUserPipeNum = pScalStateG12->dbgOverUserPipeNum;
1694 pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_SCALABLE_PIPE_NUM_2;
1695 if ((dbgOverUserPipeNum >= CODECHAL_DECODE_HCP_SCALABLE_PIPE_NUM_2) && (dbgOverUserPipeNum <= pScalState->ucNumVdbox))
1696 {
1697 pScalState->ucScalablePipeNum = dbgOverUserPipeNum;
1698 }
1699 }
1700 }
1701 }
1702 else
1703 #endif
1704 {
1705 if (pScalState->ucNumVdbox != 1)
1706 {
1707 if (pScalState->ucNumVdbox == 2)
1708 {
1709 if (pScalState->dwHcpDecModeSwtichTh1Width != 0)
1710 {
1711 if (pInitParams->u32PicWidthInPixel >= pScalState->dwHcpDecModeSwtichTh1Width)
1712 {
1713 pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_SCALABLE_PIPE_NUM_2;
1714 }
1715 }
1716 else if (CodecHalDecodeScalability_DecideEnableScala_G12(pScalState, pInitParams, bCanEnableRealTile))
1717 {
1718 pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_SCALABLE_PIPE_NUM_2;
1719 }
1720
1721 if (pScalState->bIsEvenSplit == false)
1722 {
1723 // disable scalability for clips with width less than split condition when MMC is on
1724 if (pInitParams->u32PicWidthInPixel <= CODEC_SCALABILITY_FIRST_TILE_WIDTH_4K)
1725 {
1726 pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_Legacy_PIPE_NUM_1;
1727 }
1728 }
1729 }
1730 else
1731 {
1732 pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_Legacy_PIPE_NUM_1;
1733 }
1734 }
1735 }
1736
1737 return eStatus;
1738 }
1739
1740
1741 MOS_STATUS CodechalDecodeScalability_ConstructParmsForGpuCtxCreation_g12(
1742 PCODECHAL_DECODE_SCALABILITY_STATE pScalState,
1743 PMOS_GPUCTX_CREATOPTIONS_ENHANCED gpuCtxCreatOpts,
1744 CodechalSetting * codecHalSetting)
1745 {
1746 PMOS_INTERFACE pOsInterface;
1747 CODECHAL_DECODE_SCALABILITY_INIT_PARAMS_G12 initParams;
1748 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1749
1750 CODECHAL_DECODE_FUNCTION_ENTER;
1751
1752 CODECHAL_DECODE_CHK_NULL_RETURN(pScalState);
1753 CODECHAL_DECODE_CHK_NULL_RETURN(pScalState->pHwInterface);
1754 CODECHAL_DECODE_CHK_NULL_RETURN(gpuCtxCreatOpts);
1755 CODECHAL_DECODE_CHK_NULL_RETURN(codecHalSetting);
1756 bool sfcInUse = codecHalSetting->sfcInUseHinted && codecHalSetting->downsamplingHinted
1757 && (MEDIA_IS_SKU(pScalState->pHwInterface->GetSkuTable(), FtrSFCPipe)
1758 && !MEDIA_IS_SKU(pScalState->pHwInterface->GetSkuTable(), FtrDisableVDBox2SFC));
1759 pOsInterface = pScalState->pHwInterface->GetOsInterface();
1760 MEDIA_FEATURE_TABLE *m_skuTable = pOsInterface->pfnGetSkuTable(pOsInterface);
1761 #if (_DEBUG || _RELEASE_INTERNAL)
1762 if (pOsInterface->bEnableDbgOvrdInVE)
1763 {
1764 PMOS_VIRTUALENGINE_INTERFACE pVEInterface = pScalState->pVEInterface;
1765 CODECHAL_DECODE_CHK_NULL_RETURN(pVEInterface);
1766 gpuCtxCreatOpts->DebugOverride = true;
1767 if (MEDIA_IS_SKU(m_skuTable, FtrSfcScalability))
1768 {
1769 gpuCtxCreatOpts->UsingSFC = false;// this param ignored when dbgoverride enabled
1770 }
1771 else
1772 {
1773 gpuCtxCreatOpts->UsingSFC = sfcInUse; // this param ignored when dbgoverride enabled
1774 }
1775 CODECHAL_DECODE_CHK_STATUS_RETURN(pScalState->pfnDebugOvrdDecidePipeNum(pScalState));
1776
1777 if (pOsInterface->apoMosEnabled)
1778 {
1779 CODECHAL_DECODE_CHK_NULL_RETURN(pVEInterface->veInterface);
1780 for (uint32_t i = 0; i < pVEInterface->veInterface->GetEngineCount(); i++)
1781 {
1782 gpuCtxCreatOpts->EngineInstance[i] = pVEInterface->veInterface->GetEngineLogicId(i);
1783 }
1784 }
1785 else
1786 {
1787 for (uint32_t i = 0; i < pVEInterface->ucEngineCount; i++)
1788 {
1789 gpuCtxCreatOpts->EngineInstance[i] = pVEInterface->EngineLogicId[i];
1790 }
1791 }
1792 }
1793 else
1794 #endif
1795 {
1796 if (MEDIA_IS_SKU(m_skuTable, FtrSfcScalability))
1797 {
1798 gpuCtxCreatOpts->UsingSFC = false;
1799 }
1800 else
1801 {
1802 gpuCtxCreatOpts->UsingSFC = sfcInUse;
1803 }
1804
1805 MOS_ZeroMemory(&initParams, sizeof(initParams));
1806 initParams.u32PicWidthInPixel = MOS_ALIGN_CEIL(codecHalSetting->width, 8);
1807 initParams.u32PicHeightInPixel = MOS_ALIGN_CEIL(codecHalSetting->height, 8);
1808 if (((codecHalSetting->standard == CODECHAL_VP9) || (codecHalSetting->standard == CODECHAL_HEVC))
1809 && (codecHalSetting->chromaFormat == HCP_CHROMA_FORMAT_YUV420))
1810 {
1811 initParams.format = Format_NV12;
1812 if (codecHalSetting->lumaChromaDepth == CODECHAL_LUMA_CHROMA_DEPTH_10_BITS)
1813 {
1814 initParams.format = Format_P010;
1815 }
1816 }
1817 initParams.usingSFC = sfcInUse;
1818 initParams.usingSecureDecode = codecHalSetting->secureMode;
1819 CODECHAL_DECODE_CHK_STATUS_RETURN(pScalState->pfnDecidePipeNum(
1820 pScalState,
1821 &initParams));
1822 }
1823
1824 CODECHAL_DECODE_CHK_STATUS_RETURN(pScalState->pfnMapPipeNumToLRCACount(
1825 pScalState,
1826 &gpuCtxCreatOpts->LRCACount));
1827
1828 return eStatus;
1829 }
1830
1831
1832 MOS_STATUS CodechalDecodeScalability_MapPipeNumToLRCACount_G12(
1833 PCODECHAL_DECODE_SCALABILITY_STATE pScalState,
1834 uint32_t *LRCACount)
1835 {
1836 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1837
1838 CODECHAL_DECODE_FUNCTION_ENTER;
1839
1840 CODECHAL_DECODE_CHK_NULL_RETURN(pScalState);
1841 CODECHAL_DECODE_CHK_NULL_RETURN(LRCACount);
1842
1843 *LRCACount = 1; // initialzed to 1.
1844
1845 switch (pScalState->ucScalablePipeNum)
1846 {
1847 case CODECHAL_DECODE_HCP_SCALABLE_PIPE_NUM_2:
1848 // on GT2 or debug override enabled, FE separate submission = false, FE run on the same engine of BEs;
1849 // on GT3, FE separate submission = true, scalability submission includes only BEs.
1850 *LRCACount = 2;
1851 break;
1852 case CODECHAL_DECODE_HCP_Legacy_PIPE_NUM_1:
1853 *LRCACount = 1;
1854 break;
1855 default:
1856 // in release driver bFESeparateSubmission is always false since this is on GT3 or GT4.
1857 // bFESeparateSubmission could be false if debug override enabled.
1858 if (pScalState->bFESeparateSubmission || (static_cast<PCODECHAL_DECODE_SCALABILITY_STATE_G12>(pScalState))->bIsRtMode)
1859 {
1860 *LRCACount = pScalState->ucScalablePipeNum;
1861 }
1862 else
1863 {
1864 *LRCACount = pScalState->ucScalablePipeNum + 1;
1865 }
1866 }
1867
1868 if (*LRCACount > pScalState->ucNumVdbox)
1869 {
1870 CODECHAL_DECODE_ASSERTMESSAGE("LRCA count can not exceed vdbox number.");
1871 return MOS_STATUS_INVALID_PARAMETER;
1872 }
1873
1874 return eStatus;
1875 }
1876
1877 #if (_DEBUG || _RELEASE_INTERNAL)
1878 MOS_STATUS CodechalDecodeScalability_DebugOvrdDecidePipeNum_G12(
1879 PCODECHAL_DECODE_SCALABILITY_STATE pScalState)
1880 {
1881 PMOS_VIRTUALENGINE_INTERFACE pVEInterface;
1882 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1883 PMOS_INTERFACE pOsInterface = nullptr;
1884 CODECHAL_DECODE_CHK_NULL_RETURN(pScalState);
1885 CODECHAL_DECODE_CHK_NULL_RETURN(pScalState->pVEInterface);
1886
1887 pVEInterface = pScalState->pVEInterface;
1888 pOsInterface = pVEInterface->pOsInterface;
1889 CODECHAL_DECODE_CHK_NULL_RETURN(pOsInterface);
1890
1891 if (pOsInterface->apoMosEnabled)
1892 {
1893 CODECHAL_DECODE_CHK_NULL_RETURN(pVEInterface->veInterface);
1894 auto veInterface = pVEInterface->veInterface;
1895 if (veInterface->GetEngineCount() > pScalState->ucNumVdbox)
1896 {
1897 CODECHAL_DECODE_ASSERTMESSAGE("invalid parameter settings in debug override.");
1898 return MOS_STATUS_INVALID_PARAMETER;
1899 }
1900 else if (veInterface->GetEngineCount() == 1)
1901 {
1902 pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_Legacy_PIPE_NUM_1;
1903 }
1904 else if (veInterface->GetEngineCount() == 2)
1905 {
1906 //engine count = 2, only support FE run on the same engine as one of BE for now.
1907 pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_SCALABLE_PIPE_NUM_2;
1908 }
1909 else
1910 {
1911 bool bEngineLogicIdValid = false;
1912 for (uint8_t i = 0; i < veInterface->GetEngineCount() - 1; i++)
1913 {
1914 if (veInterface->GetEngineLogicId(veInterface->GetEngineCount() - 1) !=
1915 veInterface->GetEngineLogicId(i))
1916 {
1917 bEngineLogicIdValid = true;
1918 }
1919 else
1920 {
1921 bEngineLogicIdValid = false;
1922 break;
1923 }
1924 }
1925 if (bEngineLogicIdValid)
1926 {
1927 pScalState->ucScalablePipeNum = pScalState->ucNumVdbox - 1;
1928 }
1929 }
1930
1931 return eStatus;
1932 }
1933
1934 // debug override for virtual tile
1935 if (pVEInterface->ucEngineCount > pScalState->ucNumVdbox)
1936 {
1937 CODECHAL_DECODE_ASSERTMESSAGE("invalid parameter settings in debug override.");
1938 return MOS_STATUS_INVALID_PARAMETER;
1939 }
1940 else if (pVEInterface->ucEngineCount == 1)
1941 {
1942 pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_Legacy_PIPE_NUM_1;
1943 }
1944 else if (pVEInterface->ucEngineCount == 2)
1945 {
1946 //engine count = 2, only support FE run on the same engine as one of BE for now.
1947 pScalState->ucScalablePipeNum = CODECHAL_DECODE_HCP_SCALABLE_PIPE_NUM_2;
1948 }
1949 else
1950 {
1951 bool bEngineLogicIdValid = false;
1952 for (uint8_t i = 0; i < pVEInterface->ucEngineCount - 1; i++)
1953 {
1954 if (pVEInterface->EngineLogicId[pVEInterface->ucEngineCount - 1] != pVEInterface->EngineLogicId[i])
1955 {
1956 bEngineLogicIdValid = true;
1957 }
1958 else
1959 {
1960 bEngineLogicIdValid = false;
1961 break;
1962 }
1963 }
1964 if (bEngineLogicIdValid)
1965 {
1966 pScalState->ucScalablePipeNum = pScalState->ucNumVdbox - 1;
1967 }
1968 }
1969
1970 return eStatus;
1971 }
1972 #endif
1973
1974 void CodecHalDecodeScalability_DecPhaseToSubmissionType_G12(
1975 PCODECHAL_DECODE_SCALABILITY_STATE_G12 pScalabilityState,
1976 PMOS_COMMAND_BUFFER pCmdBuffer)
1977 {
1978 switch (pScalabilityState->HcpDecPhase)
1979 {
1980 case CodechalDecode::CodechalHcpDecodePhaseLegacyS2L:
1981 //Note: no break here, S2L and FE commands put in one secondary command buffer.
1982 case CODECHAL_HCP_DECODE_PHASE_FE:
1983 pCmdBuffer->iSubmissionType = SUBMISSION_TYPE_MULTI_PIPE_ALONE;
1984 break;
1985 case CODECHAL_HCP_DECODE_PHASE_BE0:
1986 pCmdBuffer->iSubmissionType = SUBMISSION_TYPE_MULTI_PIPE_MASTER;
1987 break;
1988 case CODECHAL_HCP_DECODE_PHASE_REAL_TILE:
1989 if (pScalabilityState->u8RtCurPipe == 0)
1990 {
1991 pCmdBuffer->iSubmissionType = SUBMISSION_TYPE_MULTI_PIPE_MASTER;
1992 }
1993 else
1994 {
1995 pCmdBuffer->iSubmissionType = SUBMISSION_TYPE_MULTI_PIPE_SLAVE;
1996 pCmdBuffer->iSubmissionType |= ((pScalabilityState->u8RtCurPipe - 1) << SUBMISSION_TYPE_MULTI_PIPE_SLAVE_INDEX_SHIFT);
1997 }
1998
1999 if (!(pScalabilityState->pHwInterface->GetOsInterface()->bParallelSubmission)
2000 && (pScalabilityState->u8RtCurPhase == pScalabilityState->u8RtPhaseNum - 1))
2001 {
2002 if (pScalabilityState->u8RtCurPipe == pScalabilityState->u8RtPipeInLastPhase - 1)
2003 {
2004 pCmdBuffer->iSubmissionType |= SUBMISSION_TYPE_MULTI_PIPE_FLAGS_LAST_PIPE;
2005 }
2006 }
2007 else
2008 {
2009 if (pScalabilityState->u8RtCurPipe == pScalabilityState->ucScalablePipeNum-1)
2010 {
2011 pCmdBuffer->iSubmissionType |= SUBMISSION_TYPE_MULTI_PIPE_FLAGS_LAST_PIPE;
2012 }
2013 }
2014 break;
2015 default:
2016 if((pScalabilityState->HcpDecPhase > CODECHAL_HCP_DECODE_PHASE_BE0) &&
2017 ((pScalabilityState->HcpDecPhase - CODECHAL_HCP_DECODE_PHASE_FE) <= pScalabilityState->ucScalablePipeNum))
2018 {
2019 pCmdBuffer->iSubmissionType = SUBMISSION_TYPE_MULTI_PIPE_SLAVE;
2020 pCmdBuffer->iSubmissionType |= ((pScalabilityState->HcpDecPhase - CODECHAL_HCP_DECODE_PHASE_BE1) << SUBMISSION_TYPE_MULTI_PIPE_SLAVE_INDEX_SHIFT);
2021 if ((pScalabilityState->HcpDecPhase - CODECHAL_HCP_DECODE_PHASE_FE) == pScalabilityState->ucScalablePipeNum)
2022 {
2023 pCmdBuffer->iSubmissionType |= SUBMISSION_TYPE_MULTI_PIPE_FLAGS_LAST_PIPE;
2024 }
2025 }
2026 else
2027 {
2028 pCmdBuffer->iSubmissionType = SUBMISSION_TYPE_MULTI_PIPE_ALONE;
2029 }
2030 }
2031 }