1 /*
2 * Copyright (c) 2016-2019, 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.h
24 //! \brief Defines the decode interface extension for scalability.
25 //! \details Defines all types, macros, and functions required by CodecHal for virtual engine decode supporting both single pipe and scalable mode. Definitions are not externally facing.
26 //!
27
28 #ifndef __CODECHAL_DECODER_SCALABILITY_H__
29 #define __CODECHAL_DECODER_SCALABILITY_H__
30
31 #include "codechal.h"
32 #include "codechal_hw.h"
33 #include "codechal_decoder.h"
34 #include "mos_os_virtualengine_scalability.h"
35
36 #define CODEC_VTILE_MAX_NUM 8
37
38 // first tile column width
39
40 #define CODEC_SCALABILITY_FIRST_TILE_WIDTH_4K 2048
41 #define CODEC_SCALABILITY_FIRST_TILE_WIDTH_8K 4096
42
43 #define CODECHAL_HCP_DECODE_SCALABLE_THRESHOLD1_WIDTH 3840
44 #define CODECHAL_HCP_DECODE_SCALABLE_THRESHOLD2_WIDTH 3996
45 #define CODECHAL_HCP_DECODE_SCALABLE_THRESHOLD3_WIDTH 5120
46 #define CODECHAL_HCP_DECODE_SCALABLE_THRESHOLD4_WIDTH 7680
47 #define CODECHAL_HCP_DECODE_SCALABLE_THRESHOLD1_HEIGHT 1440
48 #define CODECHAL_HCP_DECODE_SCALABLE_THRESHOLD2_HEIGHT 1716
49 #define CODECHAL_HCP_DECODE_SCALABLE_THRESHOLD3_HEIGHT 2160
50 #define CODECHAL_HCP_DECODE_SCALABLE_THRESHOLD4_HEIGHT 4320
51
CodechalDecodeResolutionEqualLargerThan4k(uint32_t width,uint32_t height)52 inline static bool CodechalDecodeResolutionEqualLargerThan4k(uint32_t width, uint32_t height)
53 {
54 return (((width * height) >= (CODECHAL_HCP_DECODE_SCALABLE_THRESHOLD1_WIDTH * CODECHAL_HCP_DECODE_SCALABLE_THRESHOLD3_HEIGHT))
55 || ((width >= CODECHAL_HCP_DECODE_SCALABLE_THRESHOLD1_WIDTH) && (height >= CODECHAL_HCP_DECODE_SCALABLE_THRESHOLD2_HEIGHT)));
56 }
57
CodechalDecodeResolutionEqualLargerThan5k(uint32_t width,uint32_t height)58 inline static bool CodechalDecodeResolutionEqualLargerThan5k(uint32_t width, uint32_t height)
59 {
60 return (((width * height) >= (CODECHAL_HCP_DECODE_SCALABLE_THRESHOLD3_WIDTH * CODECHAL_HCP_DECODE_SCALABLE_THRESHOLD3_HEIGHT))
61 || ((width >= CODECHAL_HCP_DECODE_SCALABLE_THRESHOLD3_WIDTH) && (height >= CODECHAL_HCP_DECODE_SCALABLE_THRESHOLD1_HEIGHT)));
62 }
63
CodechalDecodeResolutionEqualLargerThan8k(uint32_t width,uint32_t height)64 inline static bool CodechalDecodeResolutionEqualLargerThan8k(uint32_t width, uint32_t height)
65 {
66 return (((width * height) >= (CODECHAL_HCP_DECODE_SCALABLE_THRESHOLD4_WIDTH * CODECHAL_HCP_DECODE_SCALABLE_THRESHOLD4_HEIGHT))
67 || ((width >= CODECHAL_HCP_DECODE_SCALABLE_THRESHOLD4_WIDTH) && (height >= CODECHAL_HCP_DECODE_SCALABLE_THRESHOLD4_HEIGHT)));
68 }
69
CodechalDecodeNonRextFormat(MOS_FORMAT format)70 inline static bool CodechalDecodeNonRextFormat(MOS_FORMAT format)
71 {
72 return ((format == Format_NV12) || (format == Format_P010));
73 }
74
75 //!
76 //! \enum CODECHAL_HCP_DECODE_SCALABLE_PHASE
77 //! \brief extended HCP decode phase for scalability mode
78 //!
79 typedef enum
80 {
81 CODECHAL_HCP_DECODE_PHASE_FE = CodechalDecode::CodechalHcpDecodePhaseMax, //!< HCP decode virtual tile frontend phase
82 CODECHAL_HCP_DECODE_PHASE_BE0, //!< HCP decode virutal tile backend pipe0 phase
83 CODECHAL_HCP_DECODE_PHASE_BE1, //!< HCP decode virutal tile backend pipe1 phase
84 CODECHAL_HCP_DECODE_PHASE_RESERVED, //!< HCP decode reserved phase
85 CODECHAL_HCP_DECODE_SCALABLE_PHASE_MAX //!< HCP decode maximal phase in scalability mode
86 }CODECHAL_HCP_DECODE_SCALABLE_PHASE;
87
88 static const int CODECHAL_HCP_STREAMOUT_BUFFER_MAX_NUM = 2;
89
90 static const int CODECHAL_HCP_DECODE_SCALABLE_MAX_PHASE_NUM = (CODECHAL_HCP_DECODE_PHASE_BE1 + 1 - CODECHAL_HCP_DECODE_PHASE_FE + 1);
91
92 typedef struct _CODECHAL_DECODE_SCALABILITY_FE_STATUS
93 {
94 uint64_t dwCarryFlagOfReportedSizeMinusAllocSize; //!< Carry flag of reported stream out size minus allocated size
95 } CODECHAL_DECODE_SCALABILITY_FE_STATUS, *PCODECHAL_DECODE_SCALABILITY_FE_STATUS;
96
97 typedef struct _CODECHAL_DECODE_SCALABILITY_FE_CABAC_STREAMOUT_BUFF_SIZE
98 {
99 uint64_t dwCabacStreamoutBuffSize; //!< Cabac Streamout buff size
100 } CODECHAL_DECODE_SCALABILITY_FE_CABAC_STREAMOUT_BUFF_SIZE, *PCODECHAL_DECODE_SCALABILITY_FE_CABAC_STREAMOUT_BUFF_SIZE;
101
102 typedef struct _CODECHAL_DECODE_SCALABILITY_SETHINT_PARMS
103 {
104 bool bSameEngineAsLastSubmission;
105 bool bNeedSyncWithPrevious;
106 bool bSFCInUse;
107 }CODECHAL_DECODE_SCALABILITY_SETHINT_PARMS, *PCODECHAL_DECODE_SCALABILITY_SETHINT_PARMS;
108
109 typedef struct _CODECHAL_DECODE_SCALABILITY_INIT_PARAMS
110 {
111 uint32_t u32PicWidthInPixel; //!< Picture width in pixel align to minimal coding block
112 uint32_t u32PicHeightInPixel; //!< Picture height in pixel align to minimal coding block
113 MOS_FORMAT format; //!< Surface format
114 bool usingSFC;
115 uint8_t u8NumTileColumns; //!< Number of tile columns for this picture
116 uint8_t u8NumTileRows; //!< Number of tile rows for this picture
117 MOS_GPU_CONTEXT gpuCtxInUse; //!< gpu context in use
118 bool usingSecureDecode;
119 bool usingHistogram;
120 }CODECHAL_DECODE_SCALABILITY_INIT_PARAMS, *PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS;
121
122 typedef struct _CODECHAL_DECODE_SCALABILITY_STATE CODECHAL_DECODE_SCALABILITY_STATE, *PCODECHAL_DECODE_SCALABILITY_STATE;
123
124 struct _CODECHAL_DECODE_SCALABILITY_STATE
125 {
126 CodechalHwInterface *pHwInterface;
127 uint32_t Standard;
128 MOS_GPU_CONTEXT VideoContextForFE;
129 MOS_GPU_CONTEXT VideoContext;
130 MOS_GPU_CONTEXT VideoContextForSP;
131 MOS_GPU_CONTEXT VideoContextForMP;
132 MOS_GPU_CONTEXT VideoContextFor3P;
133 uint32_t HcpDecPhase;
134 bool bScalableDecodeMode;
135
136 bool bFESeparateSubmission;
137 bool bFESeparateSubmissionVT;
138 bool bShortFormatInUse;
139 bool bUseSecdryCmdBuffer;
140 bool bIsEvenSplit;
141 uint8_t ucScalablePipeNum;
142 uint8_t ucNumVdbox;
143 uint32_t uiFirstTileColWidth;
144 uint32_t dwHcpDecModeSwtichTh1Width;
145 uint32_t dwHcpDecModeSwtichTh2Width;
146 MOS_RESOURCE resSliceStateStreamOutBuffer;
147 MOS_RESOURCE resMvUpRightColStoreBuffer;
148 MOS_RESOURCE resIntraPredUpRightColStoreBuffer;
149 MOS_RESOURCE resIntraPredLeftReconColStoreBuffer;
150 MOS_RESOURCE resCABACSyntaxStreamOutBuffer[CODECHAL_HCP_STREAMOUT_BUFFER_MAX_NUM];
151 bool bToggleCABACStreamOutBuffer;
152 PMOS_RESOURCE presCABACStreamOutBuffer;
153 MOS_RESOURCE resSemaMemBEs;
154 MOS_RESOURCE resSemaMemFEBE;
155 MOS_RESOURCE resSemaMemCompletion;
156 MOS_RESOURCE resFEStatusBuffer;
157 MOS_RESOURCE resFeBeSyncObject;
158 MOS_RESOURCE resDelayMinus;
159 uint32_t numDelay;
160 uint32_t dwCABACSyntaxStreamOutBufferSize;
161 bool bIsEnableEndCurrentBatchBuffLevel;
162 #if (_DEBUG || _RELEASE_INTERNAL)
163 bool bAlwaysFrameSplit;
164 uint32_t dbgOvrdWidthInMinCb;
165 #endif
166
167 //For SFC Scalability
168 uint32_t fistValidTileIndex;
169 uint32_t lastValidTileIndex;
170 uint32_t dstXLandingCount;
171 uint32_t lastDstEndX;
172 uint32_t sliceStateCLs;
173
174 //Virtual Engine related
175 PMOS_VIRTUALENGINE_INTERFACE pVEInterface;
176 PMOS_VIRTUALENGINE_HINT_PARAMS pScalHintParms;
177 PMOS_VIRTUALENGINE_HINT_PARAMS pSingleHintParms;
178
179 MOS_STATUS(*pfnIsHcpBufferReallocNeeded) (
180 CodechalHwInterface *pHwInterface,
181 MHW_VDBOX_HCP_INTERNAL_BUFFER_TYPE BufferType,
182 PMHW_VDBOX_HCP_BUFFER_REALLOC_PARAMS pReallocParam);
183
184 MOS_STATUS (*pfnGetHcpBufferSize) (
185 CodechalHwInterface *pHwInterface,
186 MHW_VDBOX_HCP_INTERNAL_BUFFER_TYPE dwBufferType,
187 PMHW_VDBOX_HCP_BUFFER_SIZE_PARAMS pHcpBufSizeParam);
188
189 MOS_STATUS (*pfnDecidePipeNum) (
190 PCODECHAL_DECODE_SCALABILITY_STATE pScalState,
191 PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS pInitParams);
192
193 MOS_STATUS(*pfnMapPipeNumToLRCACount)(
194 PCODECHAL_DECODE_SCALABILITY_STATE pScalState,
195 uint32_t *LRCACount);
196
197 #if (_DEBUG || _RELEASE_INTERNAL)
198 MOS_STATUS (*pfnDebugOvrdDecidePipeNum)(
199 PCODECHAL_DECODE_SCALABILITY_STATE pScalState);
200 #endif
201 };
202
203 #define CodecHalDecodeScalabilityIsBEPhase(pScalabilityState) \
204 (pScalabilityState && pScalabilityState->bScalableDecodeMode && \
205 ((pScalabilityState->HcpDecPhase == CODECHAL_HCP_DECODE_PHASE_BE0) || \
206 (pScalabilityState->HcpDecPhase == CODECHAL_HCP_DECODE_PHASE_BE1) || \
207 (pScalabilityState->HcpDecPhase == CODECHAL_HCP_DECODE_PHASE_RESERVED)))
208
209 #define CodecHalDecodeScalabilityIsFEPhase(pScalabilityState) \
210 (pScalabilityState && pScalabilityState->bScalableDecodeMode && pScalabilityState->HcpDecPhase == CODECHAL_HCP_DECODE_PHASE_FE)
211
212 #define CodecHalDecodeScalabilityIsFinalBEPhase(pScalabilityState) \
213 (pScalabilityState && pScalabilityState->bScalableDecodeMode && \
214 ((pScalabilityState->HcpDecPhase == CODECHAL_HCP_DECODE_PHASE_BE0 && pScalabilityState->ucScalablePipeNum == 1) || \
215 (pScalabilityState->HcpDecPhase == CODECHAL_HCP_DECODE_PHASE_BE1 && pScalabilityState->ucScalablePipeNum == 2) || \
216 (pScalabilityState->HcpDecPhase == CODECHAL_HCP_DECODE_PHASE_RESERVED && \
217 pScalabilityState->ucScalablePipeNum == CODECHAL_HCP_DECODE_PHASE_RESERVED - CODECHAL_HCP_DECODE_PHASE_FE)))
218
219 #define CodecHalDecodeScalablity_DecPhaseToHwWorkMode(EngineMode, PipeWorkMode)\
220 do \
221 { \
222 if (m_hcpDecPhase == CODECHAL_HCP_DECODE_PHASE_FE) \
223 { \
224 EngineMode = MHW_VDBOX_HCP_MULTI_ENGINE_MODE_FE_LEGACY; \
225 PipeWorkMode = MHW_VDBOX_HCP_PIPE_WORK_MODE_CABAC_FE; \
226 } \
227 else if (m_hcpDecPhase == CODECHAL_HCP_DECODE_PHASE_BE0) \
228 { \
229 EngineMode = MHW_VDBOX_HCP_MULTI_ENGINE_MODE_LEFT; \
230 PipeWorkMode = MHW_VDBOX_HCP_PIPE_WORK_MODE_CODEC_BE; \
231 } \
232 else if (m_hcpDecPhase == CODECHAL_HCP_DECODE_PHASE_BE1) \
233 { \
234 CODECHAL_DECODE_ASSERT(m_scalabilityState->ucScalablePipeNum >= 2); \
235 EngineMode = (m_scalabilityState->ucScalablePipeNum == 2) ? \
236 MHW_VDBOX_HCP_MULTI_ENGINE_MODE_RIGHT : MHW_VDBOX_HCP_MULTI_ENGINE_MODE_MIDDLE; \
237 PipeWorkMode = MHW_VDBOX_HCP_PIPE_WORK_MODE_CODEC_BE; \
238 } \
239 else if (m_hcpDecPhase == CODECHAL_HCP_DECODE_PHASE_RESERVED) \
240 { \
241 CODECHAL_DECODE_ASSERT(m_scalabilityState->ucScalablePipeNum >= CODECHAL_HCP_DECODE_PHASE_RESERVED - CODECHAL_HCP_DECODE_PHASE_FE); \
242 EngineMode = MHW_VDBOX_HCP_MULTI_ENGINE_MODE_RIGHT; \
243 PipeWorkMode = MHW_VDBOX_HCP_PIPE_WORK_MODE_CODEC_BE; \
244 } \
245 }while (0)
246
247 #define CodecHalDecodeScalabilityIsScalableMode(pScalabilityState) \
248 (pScalabilityState ? pScalabilityState->bScalableDecodeMode : false)
249
250 #define CodecHalDecodeScalabilityIsFESeparateSubmission(pScalabilityState) \
251 (pScalabilityState ? (pScalabilityState->bScalableDecodeMode && pScalabilityState->bFESeparateSubmission) : false)
252
253 #define CodecHalDecodeScalability1stDecPhase(pScalabilityState)\
254 (pScalabilityState->HcpDecPhase == CodechalDecode::CodechalHcpDecodePhaseLegacyS2L || \
255 (pScalabilityState->HcpDecPhase == CODECHAL_HCP_DECODE_PHASE_FE && !pScalabilityState->bShortFormatInUse))
256
257 #define CodecHalDecodeScalabilityIsLastCompletePhase(pScalabilityState)\
258 (pScalabilityState->HcpDecPhase == CODECHAL_HCP_DECODE_PHASE_BE0)
259
260 #define CodecHalDecodeScalability1stPhaseofSubmission(pScalabilityState)\
261 (CodecHalDecodeScalability1stDecPhase(pScalabilityState) || \
262 (pScalabilityState->HcpDecPhase == CODECHAL_HCP_DECODE_PHASE_BE0 && pScalabilityState->bFESeparateSubmission))
263
264 //HCP Decode pipe number
265 typedef enum _CODECHAL_DECODE_HCP_SCALABILITY_PIPE_NUM
266 {
267 CODECHAL_DECODE_HCP_Legacy_PIPE_NUM_1 = 1,
268 CODECHAL_DECODE_HCP_SCALABLE_PIPE_NUM_2 = 2,
269 CODECHAL_DECODE_HCP_SCALABLE_PIPE_NUM_RESERVED,
270 CODECHAL_DECODE_HCP_SCALABLE_MAX_PIPE_NUM
271 }CODECHAL_DECODE_HCP_SCALABILITY_PIPE_NUM;
272
273 #define CODECHAL_SCALABILITY_DECODE_SECONDARY_CMDBUFSET_NUM 16
274 #define CODECHAL_SCALABILITY_SLICE_STATE_CACHELINES_PER_SLICE 8
275
276 //!
277 //! \brief Decide pipe num of scalability decode
278 //! \param [in] pScalState
279 //! pointer to Scalability decode state
280 //! \param [in] pInitParams
281 //! pointer to initialize parameter
282 //! \return MOS_STATUS
283 //! MOS_STATUS_SUCCESS if success, else fail reason
284 //!
285 MOS_STATUS CodecHalDecodeScalability_DecidePipeNum(
286 PCODECHAL_DECODE_SCALABILITY_STATE pScalState,
287 PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS pInitParams);
288
289 //!
290 //! \brief Map the scalability pipe num to the LRCA count
291 //! \param [in] pScalState
292 //! pointer to Scalability decode state
293 //! \param [in] LRCACount
294 //! pointer to LRCA count
295 //! \return MOS_STATUS
296 //! MOS_STATUS_SUCCESS if success, else fail reason
297 //!
298 MOS_STATUS CodechalDecodeScalability_MapPipeNumToLRCACount(
299 PCODECHAL_DECODE_SCALABILITY_STATE pScalState,
300 uint32_t *LRCACount);
301
302 #if (_DEBUG || _RELEASE_INTERNAL)
303 //!
304 //! \brief Debug override for scalability pipe num
305 //! \param [in] pScalState
306 //! pointer to Scalability decode state
307 //! \return MOS_STATUS
308 //! MOS_STATUS_SUCCESS if success, else fail reason
309 //!
310 MOS_STATUS CodechalDecodeScalability_DebugOvrdDecidePipeNum(
311 PCODECHAL_DECODE_SCALABILITY_STATE pScalState);
312 #endif
313
314 //!
315 //! \brief Judge if Hevc buffer reallocate is needed
316 //! \param [in] hwInterface
317 //! HW interface for codechal
318 //! \param [in] bufferType
319 //! Type of the buffer
320 //! \param [in] reallocParam
321 //! Parameter of the reallocation
322 //! \return MOS_STATUS
323 //! MOS_STATUS_SUCCESS if success, else fail reason
324 //!
325 MOS_STATUS IsHevcBufferReallocNeeded(
326 CodechalHwInterface *hwInterface,
327 MHW_VDBOX_HCP_INTERNAL_BUFFER_TYPE bufferType,
328 PMHW_VDBOX_HCP_BUFFER_REALLOC_PARAMS reallocParam);
329
330 //!
331 //! \brief Get Hevc buffer size
332 //! \param [in] hwInterface
333 //! HW interface for codechal
334 //! \param [in] bufferType
335 //! Type of the buffer
336 //! \param [in] hcpBufSizeParam
337 //! Parameter of the buffer size
338 //! \return MOS_STATUS
339 //! MOS_STATUS_SUCCESS if success, else fail reason
340 //!
341 MOS_STATUS GetHevcBufferSize(
342 CodechalHwInterface *hwInterface,
343 MHW_VDBOX_HCP_INTERNAL_BUFFER_TYPE bufferType,
344 PMHW_VDBOX_HCP_BUFFER_SIZE_PARAMS hcpBufSizeParam);
345
346 //!
347 //! \brief Judge if Vp9 buffer reallocate is needed
348 //! \param [in] hwInterface
349 //! HW interface for codechal
350 //! \param [in] bufferType
351 //! Type of the buffer
352 //! \param [in] reallocParam
353 //! Parameter of the reallocation
354 //! \return MOS_STATUS
355 //! MOS_STATUS_SUCCESS if success, else fail reason
356 //!
357 MOS_STATUS IsVp9BufferReallocNeeded(
358 CodechalHwInterface *hwInterface,
359 MHW_VDBOX_HCP_INTERNAL_BUFFER_TYPE bufferType,
360 PMHW_VDBOX_HCP_BUFFER_REALLOC_PARAMS reallocParam);
361
362 //!
363 //! \brief Get Vp9 buffer size
364 //! \param [in] hwInterface
365 //! HW interface for codechal
366 //! \param [in] bufferType
367 //! Type of the buffer
368 //! \param [in] hcpBufSizeParam
369 //! Parameter of the buffer size
370 //! \return MOS_STATUS
371 //! MOS_STATUS_SUCCESS if success, else fail reason
372 //!
373 MOS_STATUS GetVp9BufferSize(
374 CodechalHwInterface *hwInterface,
375 MHW_VDBOX_HCP_INTERNAL_BUFFER_TYPE bufferType,
376 PMHW_VDBOX_HCP_BUFFER_SIZE_PARAMS hcpBufSizeParam);
377
378 //!
379 //! \brief Allocate fixed size resources for scalability decode
380 //! \param [in] pScalabilityState
381 //! pointer to Scalability decode state
382 //! \return MOS_STATUS
383 //! MOS_STATUS_SUCCESS if success, else fail reason
384 //!
385 MOS_STATUS CodecHalDecodeScalability_AllocateResources_FixedSizes(
386 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState);
387
388 //!
389 //! \brief Allocate variable size resources for scalability decode
390 //! \param [in] pScalabilityState
391 //! pointer to Scalability decode state
392 //! \param [in] pHcpBufSizeParam
393 //! pointer to HCP Buf size parameter
394 //! \param [in] pAllocParam
395 //! pointer to Re-alloc parameter
396 //! \return MOS_STATUS
397 //! MOS_STATUS_SUCCESS if success, else fail reason
398 //!
399 MOS_STATUS CodecHalDecodeScalability_AllocateResources_VariableSizes(
400 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,
401 PMHW_VDBOX_HCP_BUFFER_SIZE_PARAMS pHcpBufSizeParam,
402 PMHW_VDBOX_HCP_BUFFER_REALLOC_PARAMS pAllocParam);
403
404 //!
405 //! \brief Allocate CABAC streamout buffer for scalability decode
406 //! \param [in] pScalabilityState
407 //! pointer to Scalability decode state
408 //! \param [in] pHcpBufSizeParam
409 //! pointer to HCP Buf size parameter
410 //! \param [in] pAllocParam
411 //! pointer to Re-alloc parameter
412 //! \param [in] presCABACStreamOutBuffer
413 //! pointer to cabac streamout buffer
414 //! \return MOS_STATUS
415 //! MOS_STATUS_SUCCESS if success, else fail reason
416 MOS_STATUS CodecHalDecodeScalability_AllocateCABACStreamOutBuffer(
417 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,
418 PMHW_VDBOX_HCP_BUFFER_SIZE_PARAMS pHcpBufSizeParam,
419 PMHW_VDBOX_HCP_BUFFER_REALLOC_PARAMS pAllocParam,
420 PMOS_RESOURCE presCABACStreamOutBuffer);
421
422 //!
423 //! \brief Destroy resources for scalability decoder
424 //! \param [in] pScalabilityState
425 //! Scalability decode state
426 //! \return MOS_STATUS
427 //! MOS_STATUS_SUCCESS if success, else fail reason
428 //!
429 void CodecHalDecodeScalability_Destroy (
430 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState);
431
432 //!
433 //! \brief get command buffer to use
434 //! \details decide and get command buffer to add cmds. it is for decoder which can support both scalability and single pipe
435 //! \param [in] pScalabilityState
436 //! Scalability decode state
437 //! \param [in] pScdryCmdBuf
438 //! pointer to secondary cmd buffer
439 //! \param [in] ppCmdBufToUse
440 //! pointer to cmd buffer to use
441 //! \return MOS_STATUS
442 //! MOS_STATUS_SUCCESS if success, else fail reason
443 //!
444 MOS_STATUS CodecHalDecodeScalability_GetCmdBufferToUse(
445 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,
446 PMOS_COMMAND_BUFFER pScdryCmdBuf,
447 PMOS_COMMAND_BUFFER *ppCmdBufToUse);
448
449 //!
450 //! \brief return secondary cmd buffer
451 //! \param [in] pScalabilityState
452 //! Scalability decode state
453 //! \param [in] pScdryCmdBuf
454 //! pointer to secondary cmd buffer
455 //! \return MOS_STATUS
456 //! MOS_STATUS_SUCCESS if success, else fail reason
457 //!
458 MOS_STATUS CodecHalDecodeScalability_ReturnSdryCmdBuffer(
459 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,
460 PMOS_COMMAND_BUFFER pSdryCmdBuf);
461
462 #if (_DEBUG || _RELEASE_INTERNAL)
463 //!
464 //! \brief dump command buffer in scalability mode
465 //! \param [in] pDecoder
466 //! Decoder device
467 //! \param [in] pScalabilityState
468 //! Scalability decode state
469 //! \return MOS_STATUS
470 //! MOS_STATUS_SUCCESS if success, else fail reason
471 //!
472 MOS_STATUS CodecHalDecodeScalability_DbgDumpCmdBuffer(
473 CodechalDecode *pDecoder,
474 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,
475 CodechalDebugInterface *debugInterface,
476 PMOS_COMMAND_BUFFER pPrimCmdBuf);
477 #endif
478
479 //!
480 //! \brief Set FE CABAC Streamout buffer overflow status for Scalability Decode
481 //! \param [in] pScalabilityState
482 //! Scalability decode state
483 //! \param [in] pCmdBufferInUse
484 //! Address of command buffer in use
485 //! \return MOS_STATUS
486 //! MOS_STATUS_SUCCESS if success, else fail reason
487 //!
488 MOS_STATUS CodecHalDecodeScalablity_SetFECabacStreamoutOverflowStatus(
489 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,
490 PMOS_COMMAND_BUFFER pCmdBufferInUse);
491
492 //!
493 //! \brief Get FE Reported CABAC Streamout buffer size from register for Scalability Decode
494 //! \param [in] pScalabilityState
495 //! Scalability decode state
496 //! \param [in] pCmdBufferInUse
497 //! Address of command buffer in use
498 //! \return MOS_STATUS
499 //! MOS_STATUS_SUCCESS if success, else fail reason
500 //!
501 MOS_STATUS CodecHalDecodeScalablity_GetFEReportedCabacStreamoutBufferSize(
502 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,
503 PMOS_COMMAND_BUFFER pCmdBufferInUse);
504
505 //!
506 //! \brief Determine decode phase
507 //! \details determine decode phase for decoder supporting scalability mode but not necessarily always running in scalable mode
508 //! \param [in] pScalabilityState
509 //! Scalability decode state
510 //! \param [in] pHcpDecPhase
511 //! Address of hcp decode phase
512 //! \return MOS_STATUS
513 //! MOS_STATUS_SUCCESS if success, else fail reason
514 //!
515 MOS_STATUS CodecHalDecodeScalability_DetermineDecodePhase(
516 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,
517 uint32_t *pHcpDecPhase);
518
519 //!
520 //! \brief Determine if sending watch dog timer start cmd
521 //! \details determine decode phase for decoder supporting scalability mode but not necessarily always running in scalable mode
522 //! \param [in] pScalabilityState
523 //! Scalability decode state
524 //! \param [in] pbSend
525 //! pointer to a flag indicating if to send
526 //! \return MOS_STATUS
527 //! MOS_STATUS_SUCCESS if success, else fail reason
528 //!
529 MOS_STATUS CodecHalDecodeScalability_DetermineSendWatchdogTimerStart(
530 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,
531 bool *pbSend);
532
533 //!
534 //! \brief switch gpu context in scalability decode mode
535 //! \param [in] pScalabilityState
536 //! Scalability decode state
537 //! \return MOS_STATUS
538 //! MOS_STATUS_SUCCESS if success, else fail reason
539 //!
540 MOS_STATUS CodecHalDecodeScalability_SwitchGpuContext(
541 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState);
542
543 //!
544 //! \brief Initiliaze BEBE sync resources in scalability decode mode
545 //! \param [in] pScalabilityState
546 //! Scalability decode state
547 //! \param [in] pCmdBufferInUse
548 //! address of command buffer
549 //! \return MOS_STATUS
550 //! MOS_STATUS_SUCCESS if success, else fail reason
551 //!
552 MOS_STATUS CodecHalDecodeScalability_InitSemaMemResources(
553 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,
554 PMOS_COMMAND_BUFFER pCmdBuffer);
555
556 //!
557 //! \brief Initiliaze Decode Parameters for virtual engine decode
558 //! \details Initiliaze decode parameters for virtual engine decode. this is for decoder supporting scalability but not necessarily always running in scalable mode
559 //! \param [in] pScalabilityState
560 //! Scalability decode state
561 //! \param [in] pInitParams
562 //! pointer to parameters to initialize decode scalability
563 //! \param [in] pucDecPassNum
564 //! pointer to decode pass number
565 //! \return MOS_STATUS
566 //! MOS_STATUS_SUCCESS if success, else fail reason
567 //!
568 MOS_STATUS CodecHalDecodeScalability_InitScalableParams(
569 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,
570 PCODECHAL_DECODE_SCALABILITY_INIT_PARAMS pInitParams,
571 uint16_t *pucDecPassNum);
572
573 //!
574 //! \brief Set virtual engine hint parameters for scalable decode
575 //! \param [in] pScalabilityState
576 //! Scalability decode state
577 //! \param [in] pSetHintParms
578 //! pointer to set hint parameter
579 //! \return MOS_STATUS
580 //! MOS_STATUS_SUCCESS if success, else fail reason
581 //!
582 MOS_STATUS CodecHalDecodeScalability_SetHintParams(
583 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,
584 PCODECHAL_DECODE_SCALABILITY_SETHINT_PARMS pSetHintParms);
585
586 //!
587 //! \brief Populate virtual engine hint parameters
588 //! \details Populate virtual engine hint parameters. Support both scalable and single pipe decode mode.
589 //! \param [in] pScalabilityState
590 //! Scalability decode state
591 //! \param [in] pPrimCmdBuf
592 //! pointer to primary cmd buffer
593 //! \return MOS_STATUS
594 //! MOS_STATUS_SUCCESS if success, else fail reason
595 //!
596 MOS_STATUS CodecHalDecodeScalability_PopulateHintParams(
597 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,
598 PMOS_COMMAND_BUFFER pPrimCmdBuf);
599
600 //!
601 //! \brief Signal HW or SW semaphore for sync between FE and BE
602 //! \details signal hw or sw semaphore at end of FE cmd buffer for sync between FE and BE
603 //! \param [in] pScalabilityState
604 //! Scalability decode state
605 //! \param [in] pCmdBufferInUse
606 //! address of command buffer
607 //! \return MOS_STATUS
608 //! MOS_STATUS_SUCCESS if success, else fail reason
609 //!
610 MOS_STATUS CodecHalDecodeScalability_SignalFE2BESemaphore(
611 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,
612 PMOS_COMMAND_BUFFER pCmdBufferInUse);
613
614 //!
615 //! \brief Sync between FE and BE
616 //! \details This function does 3 major things
617 //! 1) send hw or sw semaphore wait at start of BE0 cmd.
618 //! 2) use HW semaphore wait and MI ATOMIC cmd to make all BEs start running at the same time
619 //! 3) add COND BB END cmd to check if CABAC stream out buffer overflow.
620 //! \param [in] pScalabilityState
621 //! Scalability decode state
622 //! \param [in] pCmdBufferInUse
623 //! address of command buffer
624 //! \return MOS_STATUS
625 //! MOS_STATUS_SUCCESS if success, else fail reason
626 //!
627 MOS_STATUS CodecHalDecodeScalability_FEBESync(
628 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,
629 PMOS_COMMAND_BUFFER pCmdBufferInUse);
630
631 //!
632 //! \brief To judge if command buffer should be submitted.
633 //! \param [in] pScalabilityState
634 //! Scalability decode state
635 //! \return bool
636 //! True means to submit command buffer, False means not to submit.
637 //!
638 bool CodecHalDecodeScalabilityIsToSubmitCmdBuffer(
639 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState);
640
641 //!
642 //! \brief Calculate parameters for adding HCP_TILE_CODING cmd
643 //! \details Calculate parameters for adding HCP_TILE_CODING cmd in scalability decode
644 //! \param [in] pScalabilityState
645 //! Scalability decode state
646 //! \param [in] pvStandardPicParams
647 //! HEVC or VP9 picture parameters
648 //! \param [in] pHcpTileCodingParam
649 //! pointer of HCP_TILE_CODING parameters
650 //! \return MOS_STATUS
651 //! MOS_STATUS_SUCCESS if success, else fail reason
652 //!
653 template <class TILE_CODING_PARAMS>
CodecHalDecodeScalability_CalculateHcpTileCodingParams(PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,void * pvStandardPicParams,TILE_CODING_PARAMS * pHcpTileCodingParam)654 MOS_STATUS CodecHalDecodeScalability_CalculateHcpTileCodingParams(
655 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,
656 void *pvStandardPicParams,
657 TILE_CODING_PARAMS *pHcpTileCodingParam)
658 {
659 PCODEC_HEVC_PIC_PARAMS pHevcPicParams = nullptr;
660 PCODEC_VP9_PIC_PARAMS pVp9PicParams = nullptr;
661 uint32_t i, uiMaxCbSize, uiMinCbSize, uiWidthInPixel, uiHeightInPixel;
662 uint32_t uiPicWidthInMinCb, uiPicHeightInMinCb, uiPicWidthInCtb;
663 uint8_t ucPipeIdx;
664 uint16_t usVTileColPos = 0;
665 uint16_t usVTileWidthInLCU[CODEC_VTILE_MAX_NUM];
666 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
667
668 CODECHAL_DECODE_FUNCTION_ENTER;
669
670 CODECHAL_DECODE_CHK_NULL(pScalabilityState);
671 CODECHAL_DECODE_CHK_NULL(pScalabilityState->pHwInterface);
672 CODECHAL_DECODE_CHK_NULL(pvStandardPicParams);
673 CODECHAL_DECODE_CHK_NULL(pHcpTileCodingParam);
674
675 //BEs: HCP TILE CODING
676 CODECHAL_DECODE_ASSERT(pScalabilityState->HcpDecPhase >= CODECHAL_HCP_DECODE_PHASE_BE0);
677 ucPipeIdx = pScalabilityState->HcpDecPhase - CODECHAL_HCP_DECODE_PHASE_BE0;
678
679 //calc virtual tile parameters
680 if (pScalabilityState->Standard == CODECHAL_HEVC)
681 {
682 pHevcPicParams = (PCODEC_HEVC_PIC_PARAMS)pvStandardPicParams;
683 uiMinCbSize = 1 << (pHevcPicParams->log2_min_luma_coding_block_size_minus3 + 3);
684 uiMaxCbSize = (1 << (pHevcPicParams->log2_diff_max_min_luma_coding_block_size)) * uiMinCbSize;
685 uiWidthInPixel = uiMinCbSize * (pHevcPicParams->PicWidthInMinCbsY);
686 uiHeightInPixel = uiMinCbSize * (pHevcPicParams->PicHeightInMinCbsY);
687 uiPicWidthInCtb = MOS_ROUNDUP_DIVIDE(uiWidthInPixel, uiMaxCbSize);
688 uiPicWidthInMinCb = pHevcPicParams->PicWidthInMinCbsY;
689 uiPicHeightInMinCb = pHevcPicParams->PicHeightInMinCbsY;
690 }
691 else if (pScalabilityState->Standard == CODECHAL_VP9)
692 {
693 pVp9PicParams = (PCODEC_VP9_PIC_PARAMS)pvStandardPicParams;
694 uiMinCbSize = CODEC_VP9_MIN_BLOCK_WIDTH;
695 uiMaxCbSize = CODEC_VP9_SUPER_BLOCK_WIDTH;
696 uiWidthInPixel = pVp9PicParams->FrameWidthMinus1 + 1;
697 uiHeightInPixel = pVp9PicParams->FrameHeightMinus1 + 1;
698 uiPicWidthInCtb = MOS_ROUNDUP_DIVIDE(pVp9PicParams->FrameWidthMinus1 + 1, CODEC_VP9_SUPER_BLOCK_WIDTH);
699 uiPicWidthInMinCb = MOS_ROUNDUP_DIVIDE(pVp9PicParams->FrameWidthMinus1 + 1, CODEC_VP9_MIN_BLOCK_WIDTH);
700 uiPicHeightInMinCb = MOS_ROUNDUP_DIVIDE(pVp9PicParams->FrameHeightMinus1 + 1, CODEC_VP9_MIN_BLOCK_WIDTH);
701 }
702 else
703 {
704 eStatus = MOS_STATUS_INVALID_PARAMETER;
705 CODECHAL_DECODE_ASSERTMESSAGE("invalid codec type, only HEVC/VP9 are supported in scalability mode.");
706 goto finish;
707 }
708
709 //calc virtual tile width and position
710 for (i = 0; i <= ucPipeIdx; i++)
711 {
712 usVTileWidthInLCU[i] = ((i + 1) * uiPicWidthInCtb / pScalabilityState->ucScalablePipeNum) -
713 (i * uiPicWidthInCtb / pScalabilityState->ucScalablePipeNum);
714
715 usVTileColPos += (i == 0 ? 0 : usVTileWidthInLCU[i - 1]);
716 }
717
718 if (usVTileWidthInLCU[ucPipeIdx] < 2)
719 {
720 eStatus = MOS_STATUS_INVALID_PARAMETER;
721 MHW_ASSERTMESSAGE("HW limitation: Virtual tile for decode should be at least 2 LCU.");
722 goto finish;
723 }
724
725 MOS_ZeroMemory(pHcpTileCodingParam, sizeof(TILE_CODING_PARAMS));
726
727 if (pScalabilityState->bIsEvenSplit)
728 {
729 //if the last tile, the tilewidth need to align to min CU not LCU.
730 if ( ucPipeIdx == (pScalabilityState->ucScalablePipeNum - 1))
731 {
732 uint16_t usVTileColPosInMinCb = usVTileColPos * uiMaxCbSize / uiMinCbSize;
733 pHcpTileCodingParam->TileWidthInMinCbMinus1 = uiPicWidthInMinCb - usVTileColPosInMinCb - 1;
734 }
735 else
736 {
737 pHcpTileCodingParam->TileWidthInMinCbMinus1 = usVTileWidthInLCU[ucPipeIdx] * uiMaxCbSize / uiMinCbSize - 1;
738 }
739 #if (_DEBUG || _RELEASE_INTERNAL)
740 if (pScalabilityState->dbgOvrdWidthInMinCb && pScalabilityState->ucScalablePipeNum == 2)
741 {
742 if (ucPipeIdx == 1)
743 {
744 pHcpTileCodingParam->TileWidthInMinCbMinus1 = uiPicWidthInMinCb - pScalabilityState->dbgOvrdWidthInMinCb - 1;
745 usVTileColPos = pScalabilityState->dbgOvrdWidthInMinCb * uiMinCbSize / uiMaxCbSize;
746 }
747 else
748 {
749 pHcpTileCodingParam->TileWidthInMinCbMinus1 = pScalabilityState->dbgOvrdWidthInMinCb - 1;
750 usVTileColPos = 0;
751 }
752 }
753 #endif
754 }
755 else
756 {
757 if (ucPipeIdx == 0)
758 {
759 usVTileColPos = 0;
760 if ((uiWidthInPixel * uiHeightInPixel) >= (CODECHAL_HCP_DECODE_SCALABLE_THRESHOLD4_WIDTH * CODECHAL_HCP_DECODE_SCALABLE_THRESHOLD4_HEIGHT))
761 {
762 // need to align first Tile Column to 4096
763 pScalabilityState->uiFirstTileColWidth = CODEC_SCALABILITY_FIRST_TILE_WIDTH_8K;
764 }
765 else
766 {
767 // need to align first Tile Column to 2048
768 pScalabilityState->uiFirstTileColWidth = CODEC_SCALABILITY_FIRST_TILE_WIDTH_4K;
769 }
770
771 if (uiWidthInPixel <= pScalabilityState->uiFirstTileColWidth)
772 {
773 eStatus = MOS_STATUS_INVALID_PARAMETER;
774 MHW_ASSERTMESSAGE("HW limitation: pic width %d should be greater than min tile width %d.", uiWidthInPixel, pScalabilityState->uiFirstTileColWidth);
775 goto finish;
776 }
777
778 pHcpTileCodingParam->TileWidthInMinCbMinus1 = MOS_ROUNDUP_DIVIDE(pScalabilityState->uiFirstTileColWidth, uiMinCbSize) - 1;
779 }
780 else if (ucPipeIdx == 1)
781 {
782 usVTileColPos = GFX_CEIL_DIV(pScalabilityState->uiFirstTileColWidth, uiMaxCbSize);
783 pHcpTileCodingParam->TileWidthInMinCbMinus1 = uiPicWidthInMinCb - MOS_ROUNDUP_DIVIDE(pScalabilityState->uiFirstTileColWidth, uiMinCbSize) - 1;
784 }
785 else
786 {
787 eStatus = MOS_STATUS_INVALID_PARAMETER;
788 CODECHAL_DECODE_ASSERTMESSAGE("Invalid pipe number %d for scalability + MMC.", ucPipeIdx);
789 goto finish;
790 }
791 }
792
793 pHcpTileCodingParam->TileHeightInMinCbMinus1 = uiPicHeightInMinCb - 1;
794 pHcpTileCodingParam->TileStartLCUX = usVTileColPos;
795 pHcpTileCodingParam->ucNumDecodePipes = pScalabilityState->ucScalablePipeNum;
796 pHcpTileCodingParam->ucPipeIdx = ucPipeIdx;
797
798 finish:
799 return eStatus;
800 }
801
802 //!
803 //! \brief Sync for all BEs completion
804 //! \details Add hw semaphore and/or MI ATOMIC cmd for all other BEs execution completion
805 //! \param [in] pScalabilityState
806 //! Scalability decode state
807 //! \param [in] pCmdBufferInUse
808 //! address of command buffer
809 //! \return MOS_STATUS
810 //! MOS_STATUS_SUCCESS if success, else fail reason
811 //!
812 MOS_STATUS CodecHalDecodeScalability_BEsCompletionSync(
813 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,
814 PMOS_COMMAND_BUFFER pCmdBufferInUse);
815
816 //!
817 //! \brief Read CS ENGINEID register to know which engine is in use for current workload
818 //! \param [in] pDecodeStatusBuf
819 //! Decode status buffer
820 //! \param [in] pCmdBufferInUse
821 //! address of command buffer
822 //! \return MOS_STATUS
823 //! MOS_STATUS_SUCCESS if success, else fail reason
824 //!
825 MOS_STATUS CodecHalDecodeScalability_ReadCSEngineIDReg(
826 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,
827 CodechalDecodeStatusBuffer *pDecodeStatusBuf,
828 PMOS_COMMAND_BUFFER pCmdBufferInUse);
829
830 //!
831 //! \brief State initialization for virtual engine decode supporting scalable and single pipe mode
832 //! \param [in] pDecoder
833 //! Decoder device
834 //! \param [in] pScalabilityState
835 //! Scalability decode state
836 //! \param [in] bShortFormat
837 //! short format decode flag
838 //! \return MOS_STATUS
839 //! MOS_STATUS_SUCCESS if success, else fail reason
840 //!
841 MOS_STATUS CodecHalDecodeScalability_InitializeState (
842 CodechalDecode *pDecoder,
843 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,
844 CodechalHwInterface *hwInterface,
845 bool bShortFormat);
846
847 //! \brief construct gpu context creation options when scalability supported
848 //! \param [in] scalabilityState
849 //! Scalability decode state
850 //! \param [in] gpuCtxCreatOptions
851 //! pointer to gpu context creation options
852 //! \param [in] codechalSetting
853 //! Pointer to codechal setting
854 //! \return MOS_STATUS
855 //! MOS_STATUS_SUCCESS if success, else fail reason
856 //!
857 MOS_STATUS CodechalDecodeScalability_ConstructParmsForGpuCtxCreation(
858 PCODECHAL_DECODE_SCALABILITY_STATE pScalState,
859 PMOS_GPUCTX_CREATOPTIONS_ENHANCED gpuCtxCreatOpts,
860 CodechalSetting * codecHalSetting);
861
862 //! \brief Check if need to recreate gpu context and if yes, do it.
863 //! \param [in] scalabilityState
864 //! Scalability decode state
865 //! \param [in] gpuCtxCreatOptions
866 //! pointer to gpu context creation options
867 //! \return MOS_STATUS
868 //! MOS_STATUS_SUCCESS if success, else fail reason
869 //!
870 MOS_STATUS CodechalDecodeScalability_ChkGpuCtxReCreation(
871 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,
872 PMOS_GPUCTX_CREATOPTIONS_ENHANCED CurgpuCtxCreatOpts);
873
874 //!
875 //! \brief Convert Decode Phase to Batch Buffer Submission Type
876 //! \param [in] scalabilityState
877 //! Scalability decode state
878 //! \param [in] pCmdBuffer
879 //! Pointer to command buffer
880 //! \return void
881 //! void
882 //!
883 void CodecHalDecodeScalability_DecPhaseToSubmissionType(
884 PCODECHAL_DECODE_SCALABILITY_STATE pScalabilityState,
885 PMOS_COMMAND_BUFFER pCmdBuffer);
886
887 #endif //__CODECHAL_DECODER_SCALABILITY_H__
888