1 /*
2 * Copyright (c) 2012-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_vp9_g11.cpp
24 //! \brief    Implements the decode interface extension for Gen11 VP9.
25 //! \details  Implements all functions required by CodecHal for Gen11 VP9 decoding.
26 //!
27 
28 #include "codechal_decoder.h"
29 #include "codechal_secure_decode_interface.h"
30 #include "codechal_decode_vp9_g11.h"
31 #include "codechal_mmc_decode_vp9.h"
32 #include "mhw_vdbox_hcp_g11_X.h"
33 #include "mhw_vdbox_mfx_g11_X.h"
34 #include "mhw_vdbox_g11_X.h"
35 #include "codechal_hw_g11_X.h"
36 #include "hal_oca_interface.h"
37 
~CodechalDecodeVp9G11()38 CodechalDecodeVp9G11 ::  ~CodechalDecodeVp9G11()
39 {
40     CODECHAL_DECODE_FUNCTION_ENTER;
41 
42     if (m_sinlgePipeVeState)
43     {
44         MOS_FreeMemAndSetNull(m_sinlgePipeVeState);
45      }
46      if (m_scalabilityState)
47      {
48          CodecHalDecodeScalability_Destroy(m_scalabilityState);
49          MOS_FreeMemAndSetNull(m_scalabilityState);
50      }
51      //Note: virtual engine interface destroy is done in MOS layer
52 }
53 
CodechalDecodeVp9G11(CodechalHwInterface * hwInterface,CodechalDebugInterface * debugInterface,PCODECHAL_STANDARD_INFO standardInfo)54 CodechalDecodeVp9G11::CodechalDecodeVp9G11(
55     CodechalHwInterface *   hwInterface,
56     CodechalDebugInterface *debugInterface,
57     PCODECHAL_STANDARD_INFO standardInfo) : CodechalDecodeVp9(hwInterface, debugInterface, standardInfo),
58                                             m_frameSizeMaxAlloced(0),
59                                             m_sinlgePipeVeState(nullptr),
60                                             m_scalabilityState(nullptr)
61 {
62     CODECHAL_DECODE_FUNCTION_ENTER;
63 
64     CODECHAL_DECODE_CHK_NULL_NO_STATUS_RETURN(m_osInterface);
65 
66     m_osInterface->pfnVirtualEngineSupported(m_osInterface, true, true);
67 }
68 
SetGpuCtxCreatOption(CodechalSetting * codecHalSetting)69 MOS_STATUS CodechalDecodeVp9G11::SetGpuCtxCreatOption(
70     CodechalSetting *          codecHalSetting)
71 {
72     MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
73 
74     CODECHAL_DECODE_FUNCTION_ENTER;
75 
76     if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
77     {
78         CodechalDecode::SetGpuCtxCreatOption(codecHalSetting);
79     }
80     else
81     {
82         m_gpuCtxCreatOpt = MOS_New(MOS_GPUCTX_CREATOPTIONS_ENHANCED);
83         CODECHAL_DECODE_CHK_NULL_RETURN(m_gpuCtxCreatOpt);
84 
85         if (static_cast<MhwVdboxMfxInterfaceG11*>(m_mfxInterface)->IsScalabilitySupported())
86         {
87             CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeScalability_ConstructParmsForGpuCtxCreation(
88                 m_scalabilityState,
89                 (PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt,
90                 codecHalSetting));
91 
92             if (((PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt)->LRCACount == 2)
93             {
94                 m_videoContext = MOS_VE_MULTINODESCALING_SUPPORTED(m_osInterface) ? MOS_GPU_CONTEXT_VIDEO5 : MOS_GPU_CONTEXT_VDBOX2_VIDEO;
95 
96                 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateGpuContext(
97                     m_osInterface,
98                     m_videoContext,
99                     MOS_GPU_NODE_VIDEO,
100                     m_gpuCtxCreatOpt));
101 
102                 MOS_GPUCTX_CREATOPTIONS createOption;
103                 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateGpuContext(
104                     m_osInterface,
105                     MOS_GPU_CONTEXT_VIDEO,
106                     m_videoGpuNode,
107                     &createOption));
108             }
109             else if (((PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt)->LRCACount == 3)
110             {
111                 m_videoContext = MOS_VE_MULTINODESCALING_SUPPORTED(m_osInterface) ? MOS_GPU_CONTEXT_VIDEO7 : MOS_GPU_CONTEXT_VDBOX2_VIDEO2;
112 
113                 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateGpuContext(
114                     m_osInterface,
115                     m_videoContext,
116                     MOS_GPU_NODE_VIDEO,
117                     m_gpuCtxCreatOpt));
118 
119                 MOS_GPUCTX_CREATOPTIONS createOption;
120                 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateGpuContext(
121                     m_osInterface,
122                     MOS_GPU_CONTEXT_VIDEO,
123                     m_videoGpuNode,
124                     &createOption));
125             }
126             else
127             {
128                 m_videoContext = MOS_GPU_CONTEXT_VIDEO;
129             }
130         }
131         else
132         {
133             CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_ConstructParmsForGpuCtxCreation(
134                 m_sinlgePipeVeState,
135                 (PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt,
136                 false));
137 
138             m_videoContext = MOS_GPU_CONTEXT_VIDEO;
139         }
140     }
141 
142     return eStatus;
143 }
144 
AllocateResourcesVariableSizes()145 MOS_STATUS CodechalDecodeVp9G11 :: AllocateResourcesVariableSizes()
146 {
147     MOS_STATUS              eStatus = MOS_STATUS_SUCCESS;
148 
149     CODECHAL_DECODE_FUNCTION_ENTER;
150 
151     CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeVp9 :: AllocateResourcesVariableSizes());
152 
153     if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
154     {
155         uint32_t widthInSb  = MOS_ROUNDUP_DIVIDE(m_width, CODEC_VP9_SUPER_BLOCK_WIDTH);
156         uint32_t heightInSb = MOS_ROUNDUP_DIVIDE(m_height, CODEC_VP9_SUPER_BLOCK_HEIGHT);
157         uint32_t frameSizeMax = MOS_MAX((m_copyDataBufferInUse ? m_copyDataBufferSize : m_dataSize), m_frameSizeMaxAlloced);
158         uint8_t  maxBitDepth  = 8 + m_vp9DepthIndicator * 2;
159         uint8_t  chromaFormat = m_chromaFormatinProfile;
160 
161         MHW_VDBOX_HCP_BUFFER_SIZE_PARAMS    hcpBufSizeParam;
162         MOS_ZeroMemory(&hcpBufSizeParam, sizeof(hcpBufSizeParam));
163         hcpBufSizeParam.ucMaxBitDepth  = maxBitDepth;
164         hcpBufSizeParam.ucChromaFormat = chromaFormat;
165         hcpBufSizeParam.dwPicWidth     = widthInSb;
166         hcpBufSizeParam.dwPicHeight    = heightInSb;
167         hcpBufSizeParam.dwMaxFrameSize = frameSizeMax;
168 
169         MHW_VDBOX_HCP_BUFFER_REALLOC_PARAMS reallocParam;
170         MOS_ZeroMemory(&reallocParam, sizeof(reallocParam));
171         reallocParam.ucMaxBitDepth       = maxBitDepth;
172         reallocParam.ucChromaFormat      = chromaFormat;
173         reallocParam.dwPicWidth          = widthInSb;
174         reallocParam.dwPicWidthAlloced   = m_allocatedWidthInSb;
175         reallocParam.dwPicHeight         = heightInSb;
176         reallocParam.dwPicHeightAlloced  = m_allocatedHeightInSb;
177         reallocParam.dwFrameSize         = frameSizeMax;
178         reallocParam.dwFrameSizeAlloced  = m_frameSizeMaxAlloced;
179         CODECHAL_DECODE_CHK_STATUS_RETURN(
180             CodecHalDecodeScalability_AllocateResources_VariableSizes(
181                 m_scalabilityState,
182                 &hcpBufSizeParam,
183                 &reallocParam));
184 
185         m_frameSizeMaxAlloced = frameSizeMax;
186     }
187 
188     return eStatus;
189 }
190 
InitializeDecodeMode()191 MOS_STATUS CodechalDecodeVp9G11 :: InitializeDecodeMode ()
192 {
193     MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
194 
195     CODECHAL_DECODE_FUNCTION_ENTER;
196 
197     if ( MOS_VE_SUPPORTED(m_osInterface) && static_cast<MhwVdboxMfxInterfaceG11*>(m_mfxInterface)->IsScalabilitySupported())
198     {
199         CODECHAL_DECODE_SCALABILITY_INIT_PARAMS  initParams;
200 
201         MOS_ZeroMemory(&initParams, sizeof(initParams));
202         initParams.u32PicWidthInPixel  = m_usFrameWidthAlignedMinBlk;
203         initParams.u32PicHeightInPixel = m_usFrameHeightAlignedMinBlk;
204         initParams.format = m_decodeParams.m_destSurface->Format;
205         initParams.usingSFC            = false;
206         initParams.gpuCtxInUse         = GetVideoContext();
207 
208         CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_InitScalableParams(
209             m_scalabilityState,
210             &initParams,
211             &m_decodePassNum));
212 
213         if (MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
214         {
215             CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeScalability_ChkGpuCtxReCreation(
216                     m_scalabilityState,
217                     (PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt));
218             SetVideoContext(m_scalabilityState->VideoContext);
219         }
220     }
221 
222     return eStatus;
223 }
224 
DetermineDecodePhase()225 MOS_STATUS CodechalDecodeVp9G11::DetermineDecodePhase()
226 {
227     MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
228 
229     CODECHAL_DECODE_FUNCTION_ENTER;
230 
231     if (static_cast<MhwVdboxMfxInterfaceG11*>(m_mfxInterface)->IsScalabilitySupported() && MOS_VE_SUPPORTED(m_osInterface))
232     {
233         CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_DetermineDecodePhase(
234             m_scalabilityState,
235             &m_hcpDecPhase));
236     }
237     else
238     {
239         CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeVp9 :: DetermineDecodePhase());
240     }
241 
242     return eStatus;
243 }
244 
EndStatusReport(CodechalDecodeStatusReport & decodeStatusReport,PMOS_COMMAND_BUFFER cmdBuffer)245 MOS_STATUS CodechalDecodeVp9G11::EndStatusReport(
246     CodechalDecodeStatusReport &decodeStatusReport,
247     PMOS_COMMAND_BUFFER cmdBuffer)
248 {
249     MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
250 
251     CODECHAL_DECODE_FUNCTION_ENTER;
252 
253     CODECHAL_DECODE_CHK_COND_RETURN((m_vdboxIndex > m_mfxInterface->GetMaxVdboxIndex()),
254         "ERROR - vdbox index exceed the maximum");
255 
256     auto mmioRegistersMfx = m_mfxInterface->GetMmioRegisters(m_vdboxIndex);
257     uint32_t currIndex = m_decodeStatusBuf.m_currIndex;
258 
259     MHW_MI_STORE_REGISTER_MEM_PARAMS regParams;
260     MOS_ZeroMemory(&regParams, sizeof(regParams));
261 
262     //Frame CRC
263     if (m_reportFrameCrc)
264     {
265         uint32_t frameCrcOffset =
266             currIndex * sizeof(CodechalDecodeStatus) +
267             m_decodeStatusBuf.m_decFrameCrcOffset +
268             sizeof(uint32_t) * 2;
269 
270         regParams.presStoreBuffer = &m_decodeStatusBuf.m_statusBuffer;
271         regParams.dwOffset = frameCrcOffset;
272         regParams.dwRegister = mmioRegistersMfx->mfxFrameCrcRegOffset;
273 
274         CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(
275             cmdBuffer,
276             &regParams));
277     }
278 
279     // First copy all the SW data in to the eStatus buffer
280     m_decodeStatusBuf.m_decodeStatus[currIndex].m_swStoredData = m_decodeStatusBuf.m_swStoreData;
281     m_decodeStatusBuf.m_decodeStatus[currIndex].m_decodeStatusReport = decodeStatusReport;
282 
283     uint32_t storeDataOffset =
284         currIndex * sizeof(CodechalDecodeStatus) +
285         m_decodeStatusBuf.m_storeDataOffset +
286         sizeof(uint32_t) * 2;
287 
288     MHW_MI_STORE_DATA_PARAMS dataParams;
289     dataParams.pOsResource = &m_decodeStatusBuf.m_statusBuffer;
290     dataParams.dwResourceOffset = storeDataOffset;
291     dataParams.dwValue = CODECHAL_STATUS_QUERY_END_FLAG;
292 
293     CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(
294         cmdBuffer,
295         &dataParams));
296 
297     m_decodeStatusBuf.m_currIndex = (m_decodeStatusBuf.m_currIndex + 1) % CODECHAL_DECODE_STATUS_NUM;
298 
299     CodechalDecodeStatus *decodeStatus = &m_decodeStatusBuf.m_decodeStatus[m_decodeStatusBuf.m_currIndex];
300     MOS_ZeroMemory(decodeStatus, sizeof(CodechalDecodeStatus));
301 
302     CODECHAL_DECODE_CHK_STATUS_RETURN(m_perfProfiler->AddPerfCollectEndCmd((void *)this, m_osInterface, m_miInterface, cmdBuffer));
303 
304     if (!m_osInterface->bEnableKmdMediaFrameTracking && m_osInterface->bInlineCodecStatusUpdate)
305     {
306         MHW_MI_FLUSH_DW_PARAMS flushDwParams;
307         // Send MI_FLUSH with protection bit off, which will FORCE exit protected mode for MFX
308         MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
309         flushDwParams.bVideoPipelineCacheInvalidate = true;
310         flushDwParams.pOsResource = &m_decodeStatusBuf.m_statusBuffer;
311         flushDwParams.dwDataDW1 = m_decodeStatusBuf.m_swStoreData;
312         MHW_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
313             cmdBuffer,
314             &flushDwParams));
315     }
316 
317     return eStatus;
318 }
319 
EndStatusReportForFE(PMOS_COMMAND_BUFFER cmdBuffer)320 MOS_STATUS CodechalDecodeVp9G11::EndStatusReportForFE(
321     PMOS_COMMAND_BUFFER cmdBuffer)
322 {
323     MOS_STATUS                      eStatus = MOS_STATUS_SUCCESS;
324 
325     CODECHAL_DECODE_FUNCTION_ENTER;
326 
327     CODECHAL_DECODE_CHK_COND_RETURN((m_vdboxIndex > m_mfxInterface->GetMaxVdboxIndex()),
328         "ERROR - vdbox index exceed the maximum");
329     auto mmioRegistersMfx = m_mfxInterface->GetMmioRegisters(m_vdboxIndex);
330     auto mmioRegistersHcp = m_hcpInterface ? m_hcpInterface->GetMmioRegisters(m_vdboxIndex) : nullptr;
331 
332     uint32_t currIndex = m_decodeStatusBuf.m_currIndex;
333     //Error Status report
334     uint32_t errStatusOffset =
335         currIndex * sizeof(CodechalDecodeStatus) +
336         m_decodeStatusBuf.m_decErrorStatusOffset +
337         sizeof(uint32_t) * 2;
338 
339     MHW_MI_STORE_REGISTER_MEM_PARAMS regParams;
340     MOS_ZeroMemory(&regParams, sizeof(regParams));
341 
342     regParams.presStoreBuffer = &m_decodeStatusBuf.m_statusBuffer;
343     regParams.dwOffset = errStatusOffset;
344     regParams.dwRegister = mmioRegistersHcp ?
345         mmioRegistersHcp->hcpCabacStatusRegOffset : mmioRegistersMfx->mfxErrorFlagsRegOffset;
346     CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(
347         cmdBuffer,
348         &regParams));
349 
350     //MB Count
351     uint32_t mbCountOffset =
352         currIndex * sizeof(CodechalDecodeStatus) +
353         m_decodeStatusBuf.m_decMBCountOffset +
354         sizeof(uint32_t) * 2;
355 
356     regParams.presStoreBuffer = &m_decodeStatusBuf.m_statusBuffer;
357     regParams.dwOffset = mbCountOffset;
358     regParams.dwRegister = mmioRegistersHcp ?
359         mmioRegistersHcp->hcpDecStatusRegOffset : mmioRegistersMfx->mfxMBCountRegOffset;
360     CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(
361         cmdBuffer,
362         &regParams));
363 
364     return eStatus;
365 }
366 
SetAndPopulateVEHintParams(PMOS_COMMAND_BUFFER primCmdBuf)367 MOS_STATUS CodechalDecodeVp9G11::SetAndPopulateVEHintParams(
368     PMOS_COMMAND_BUFFER       primCmdBuf)
369 {
370     MOS_STATUS                      eStatus = MOS_STATUS_SUCCESS;
371 
372     CODECHAL_DECODE_FUNCTION_ENTER;
373 
374     if (static_cast<MhwVdboxMfxInterfaceG11*>(m_mfxInterface)->IsScalabilitySupported() && MOS_VE_SUPPORTED(m_osInterface))
375     {
376         CODECHAL_DECODE_SCALABILITY_SETHINT_PARMS scalSetParms;
377         MOS_ZeroMemory(&scalSetParms, sizeof(CODECHAL_DECODE_SCALABILITY_SETHINT_PARMS));
378         if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
379         {
380             scalSetParms.bNeedSyncWithPrevious       = true;
381             scalSetParms.bSameEngineAsLastSubmission = false;
382             scalSetParms.bSFCInUse                   = false;
383         }
384         CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_SetHintParams(m_scalabilityState, &scalSetParms));
385         CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_PopulateHintParams(m_scalabilityState, primCmdBuf));
386     }
387     else
388     {
389         if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
390         {
391             MOS_VIRTUALENGINE_SET_PARAMS  vesetParams;
392             MOS_ZeroMemory(&vesetParams, sizeof(vesetParams));
393             vesetParams.bNeedSyncWithPrevious       = true;
394             vesetParams.bSameEngineAsLastSubmission = false;
395             vesetParams.bSFCInUse                   = false;
396             CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_SetHintParams(m_sinlgePipeVeState, &vesetParams));
397         }
398         CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_PopulateHintParams(m_sinlgePipeVeState, primCmdBuf, true));
399     }
400 
401     return eStatus;
402 }
403 
DetermineSendProlgwithFrmTracking(bool * sendPrologWithFrameTracking)404 MOS_STATUS CodechalDecodeVp9G11::DetermineSendProlgwithFrmTracking(
405     bool                        *sendPrologWithFrameTracking)
406 {
407     MOS_STATUS       eStatus = MOS_STATUS_SUCCESS;
408 
409     CODECHAL_DECODE_FUNCTION_ENTER;
410 
411     CODECHAL_DECODE_CHK_NULL_RETURN(sendPrologWithFrameTracking);
412 
413     if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
414     {
415         if (CodecHalDecodeScalability1stPhaseofSubmission(m_scalabilityState))
416         {
417             *sendPrologWithFrameTracking = true;
418         }
419     }
420     else
421     {
422         *sendPrologWithFrameTracking = true;
423     }
424 
425     return eStatus;
426 }
427 
RequestedSpaceSize(uint32_t requestedSize)428 uint32_t CodechalDecodeVp9G11::RequestedSpaceSize(uint32_t requestedSize)
429 {
430     if (static_cast<MhwVdboxMfxInterfaceG11*>(m_mfxInterface)->IsScalabilitySupported())
431     {
432         //primary cmd buffer only including cmd buffer header .
433         return COMMAND_BUFFER_RESERVED_SPACE * 2;
434     }
435     else
436     {
437         return requestedSize;
438     }
439 }
440 
VerifyExtraSpace(uint32_t requestedSize,uint32_t additionalSizeNeeded)441 MOS_STATUS CodechalDecodeVp9G11::VerifyExtraSpace(
442     uint32_t requestedSize,
443     uint32_t additionalSizeNeeded)
444 {
445     MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
446 
447     CODECHAL_DECODE_FUNCTION_ENTER;
448 
449     if (static_cast<MhwVdboxMfxInterfaceG11*>(m_mfxInterface)->IsScalabilitySupported())
450     {
451         eStatus = MOS_STATUS_NO_SPACE;
452 
453         // Try a maximum of 3 attempts to request the required sizes from OS
454         // OS could reset the sizes if necessary, therefore, requires to re-verify
455         for (auto i = 0; (i < 3) && (eStatus != MOS_STATUS_SUCCESS); i++)
456         {
457             // Verify secondary cmd buffer
458             eStatus = (MOS_STATUS)m_osInterface->pfnVerifyCommandBufferSize(
459                 m_osInterface,
460                 requestedSize,
461                 MOS_VE_HAVE_SECONDARY_CMDBUFFER);
462 
463             // Resize command buffer if not enough
464             if (eStatus != MOS_STATUS_SUCCESS)
465             {
466                 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResizeCommandBufferAndPatchList(
467                     m_osInterface,
468                     requestedSize + additionalSizeNeeded,
469                     0,
470                     MOS_VE_HAVE_SECONDARY_CMDBUFFER));
471                 // Set status to NO_SPACE to enter the commaned buffer size verification on next loop.
472                 eStatus = MOS_STATUS_NO_SPACE;
473             }
474         }
475     }
476 
477     return eStatus;
478 }
479 
DecodeStateLevel()480 MOS_STATUS CodechalDecodeVp9G11 :: DecodeStateLevel()
481 {
482     MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
483 
484     PERF_UTILITY_AUTO(__FUNCTION__, PERF_DECODE, PERF_LEVEL_HAL);
485     CODECHAL_DECODE_FUNCTION_ENTER;
486 
487     CODECHAL_DECODE_CHK_NULL_RETURN(m_hwInterface->GetCpInterface());
488 
489     if (m_secureDecoder && m_hcpDecPhase == CodechalHcpDecodePhaseInitialized)
490     {
491         CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->Execute(this));
492     }
493 
494     //HCP Decode Phase State Machine
495     DetermineDecodePhase();
496 
497     if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
498     {
499         //Switch GPU context when necessary
500         CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_SwitchGpuContext(m_scalabilityState));
501     }
502 
503     MOS_COMMAND_BUFFER primCmdBuffer;
504     CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &primCmdBuffer, 0));
505 
506     bool sendPrologWithFrameTracking;
507     CODECHAL_DECODE_CHK_STATUS_RETURN(DetermineSendProlgwithFrmTracking(&sendPrologWithFrameTracking));
508     if (sendPrologWithFrameTracking)
509     {
510         //Frame tracking functionality is called at the start of primary command buffer.
511         CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(
512             &primCmdBuffer, true));
513     }
514 
515     PMOS_COMMAND_BUFFER cmdBufferInUse = &primCmdBuffer;
516     MOS_COMMAND_BUFFER  scdryCmdBuffer;
517     auto                mmioRegisters = m_hwInterface->GetMfxInterface()->GetMmioRegisters(m_vdboxIndex);
518 
519     if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) && MOS_VE_SUPPORTED(m_osInterface))
520     {
521         CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_GetCmdBufferToUse(
522             m_scalabilityState,
523             &scdryCmdBuffer,
524             &cmdBufferInUse));
525 
526         if (cmdBufferInUse == &scdryCmdBuffer)
527         {
528             //send prolog at the start of a secondary cmd buffer
529             CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(cmdBufferInUse, false));
530         }
531 
532         HalOcaInterface::On1stLevelBBStart(scdryCmdBuffer, *m_osInterface->pOsContext, m_osInterface->CurrentGpuContextHandle, *m_miInterface, *mmioRegisters);
533     }
534     else
535     {
536         HalOcaInterface::On1stLevelBBStart(primCmdBuffer, *m_osInterface->pOsContext, m_osInterface->CurrentGpuContextHandle, *m_miInterface, *mmioRegisters);
537     }
538 
539     auto pipeModeSelectParams =
540         static_cast<PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G11>(m_picMhwParams.PipeModeSelectParams);
541     *pipeModeSelectParams = {};
542     auto pipeBufAddrParams =
543         static_cast<PMHW_VDBOX_PIPE_BUF_ADDR_PARAMS_G11>(m_picMhwParams.PipeBufAddrParams);
544     *pipeBufAddrParams = {};
545 
546     CODECHAL_DECODE_CHK_STATUS_RETURN(InitPicStateMhwParams());
547 
548     bool drmStartStatusFlag = true;
549     if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
550     {
551         // Put all DRM/Start Status related cmd into FE VDBOX
552         drmStartStatusFlag = CodecHalDecodeScalabilityIsFEPhase(m_scalabilityState);
553 
554         CodecHalDecodeScalablity_DecPhaseToHwWorkMode(
555             pipeModeSelectParams->MultiEngineMode,
556             pipeModeSelectParams->PipeWorkMode);
557 
558         pipeBufAddrParams->presCABACSyntaxStreamOutBuffer =
559             m_scalabilityState->presCABACStreamOutBuffer;
560         pipeBufAddrParams->presIntraPredUpRightColStoreBuffer =
561             &m_scalabilityState->resIntraPredUpRightColStoreBuffer;
562         pipeBufAddrParams->presIntraPredLeftReconColStoreBuffer =
563             &m_scalabilityState->resIntraPredLeftReconColStoreBuffer;
564     }
565 
566     if (drmStartStatusFlag)
567     {
568         CODECHAL_DECODE_CHK_STATUS_RETURN(UpdatePicStateBuffers(cmdBufferInUse));
569 
570         if (m_statusQueryReportingEnabled)
571         {
572             CODECHAL_DECODE_CHK_STATUS_RETURN(StartStatusReport(
573                 cmdBufferInUse));
574         }
575     }
576 
577     if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
578     {
579         CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_FEBESync(
580             m_scalabilityState,
581             cmdBufferInUse));
582         if (m_perfFEBETimingEnabled && CodecHalDecodeScalabilityIsLastCompletePhase(m_scalabilityState))
583         {
584             CODECHAL_DECODE_CHK_STATUS_RETURN(m_perfProfiler->AddPerfCollectStartCmd((void *)this, m_osInterface, m_miInterface, &scdryCmdBuffer));
585         }
586     }
587 
588     if (CodecHalDecodeScalabilityIsBEPhase(m_scalabilityState))
589     {
590         CODECHAL_DECODE_CHK_STATUS_RETURN(
591             m_miInterface->AddWatchdogTimerStartCmd(cmdBufferInUse));
592     }
593 
594     CODECHAL_DECODE_CHK_STATUS_RETURN(AddPicStateMhwCmds(
595         cmdBufferInUse));
596 
597     if (CodecHalDecodeScalabilityIsBEPhase(m_scalabilityState))
598     {
599         MHW_VDBOX_HCP_TILE_CODING_PARAMS_G11  hcpTileCodingParam;
600         CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_CalculateHcpTileCodingParams<MHW_VDBOX_HCP_TILE_CODING_PARAMS_G11>(
601             m_scalabilityState,
602             m_vp9PicParams,
603             &hcpTileCodingParam));
604         CODECHAL_DECODE_CHK_STATUS_RETURN(static_cast<MhwVdboxHcpInterfaceG11*>(m_hcpInterface)->AddHcpTileCodingCmd(
605             cmdBufferInUse,
606             &hcpTileCodingParam));
607     }
608 
609     m_osInterface->pfnReturnCommandBuffer(m_osInterface, &primCmdBuffer, 0);
610     if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) && MOS_VE_SUPPORTED(m_osInterface))
611     {
612         CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_ReturnSdryCmdBuffer(m_scalabilityState, &scdryCmdBuffer));
613     }
614 
615     return eStatus;
616 }
617 
DecodePrimitiveLevel()618 MOS_STATUS CodechalDecodeVp9G11 :: DecodePrimitiveLevel()
619 {
620     MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
621 
622     PERF_UTILITY_AUTO(__FUNCTION__, PERF_DECODE, PERF_LEVEL_HAL);
623 
624     CODECHAL_DECODE_FUNCTION_ENTER;
625 
626     // Bitstream is incomplete, don't do any decoding work.
627     if (m_incompletePicture)
628     {
629         eStatus = MOS_STATUS_SUCCESS;
630         return eStatus;
631     }
632 
633     CODECHAL_DECODE_CHK_COND_RETURN(
634         (m_vdboxIndex > m_mfxInterface->GetMaxVdboxIndex()),
635         "ERROR - vdbox index exceed the maximum");
636 
637     CODECHAL_DECODE_CHK_NULL_RETURN(m_osInterface);
638 
639     m_osInterface->pfnSetPerfTag(
640         m_osInterface,
641         (uint16_t)(((m_mode << 4) & 0xF0) | (m_perfType & 0xF)));
642     m_osInterface->pfnResetPerfBufferID(m_osInterface);
643 
644     MOS_COMMAND_BUFFER primCmdBuffer;
645     CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &primCmdBuffer, 0));
646 
647     PMOS_COMMAND_BUFFER cmdBufferInUse = &primCmdBuffer;
648     MOS_COMMAND_BUFFER  scdryCmdBuffer;
649     if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) && MOS_VE_SUPPORTED(m_osInterface))
650     {
651         CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_GetCmdBufferToUse(
652             m_scalabilityState,
653             &scdryCmdBuffer,
654             &cmdBufferInUse));
655         CodecHalDecodeScalability_DecPhaseToSubmissionType(m_scalabilityState,cmdBufferInUse);
656     }
657 
658     // store CS ENGINE ID register
659     if (static_cast<MhwVdboxMfxInterfaceG11*>(m_mfxInterface)->IsScalabilitySupported() && MOS_VE_SUPPORTED(m_osInterface))
660     {
661         CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_ReadCSEngineIDReg(
662             m_scalabilityState,
663             &m_decodeStatusBuf,
664             cmdBufferInUse));
665     }
666 
667     //no slice level command for Huc based DRM and scalability decode BE phases
668     if (m_cencBuf == nullptr && !CodecHalDecodeScalabilityIsBEPhase(m_scalabilityState))
669     {
670         MHW_VDBOX_HCP_BSD_PARAMS bsdParams;
671         MOS_ZeroMemory(&bsdParams, sizeof(bsdParams));
672         bsdParams.dwBsdDataLength =
673             m_vp9PicParams->BSBytesInBuffer - m_vp9PicParams->UncompressedHeaderLengthInBytes;
674         bsdParams.dwBsdDataStartOffset = m_vp9PicParams->UncompressedHeaderLengthInBytes;
675 
676         CODECHAL_DECODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpBsdObjectCmd(
677             cmdBufferInUse,
678             &bsdParams));
679     }
680 
681     // Send VD Pipe Flush command for SKL+
682     MHW_VDBOX_VD_PIPE_FLUSH_PARAMS vdpipeFlushParams;
683     MOS_ZeroMemory(&vdpipeFlushParams, sizeof(vdpipeFlushParams));
684     vdpipeFlushParams.Flags.bWaitDoneHEVC = 1;
685     vdpipeFlushParams.Flags.bFlushHEVC = 1;
686     vdpipeFlushParams.Flags.bWaitDoneVDCmdMsgParser = 1;
687     CODECHAL_DECODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(
688         cmdBufferInUse,
689         &vdpipeFlushParams));
690 
691     MHW_MI_FLUSH_DW_PARAMS flushDwParams;
692     MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
693     CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
694         cmdBufferInUse,
695         &flushDwParams));
696 
697     if (CodecHalDecodeScalabilityIsFEPhase(m_scalabilityState))
698     {
699         CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalablity_SetFECabacStreamoutOverflowStatus(
700             m_scalabilityState,
701             cmdBufferInUse));
702 
703         CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_SignalFE2BESemaphore(
704             m_scalabilityState,
705             cmdBufferInUse));
706 
707         //hcp decode status read at end of FE to support scalability
708         if (m_statusQueryReportingEnabled)
709         {
710             EndStatusReportForFE(cmdBufferInUse);
711             if (m_perfFEBETimingEnabled)
712             {
713                 CODECHAL_DECODE_CHK_STATUS_RETURN(m_perfProfiler->AddPerfCollectEndCmd((void *)this, m_osInterface, m_miInterface, &scdryCmdBuffer));
714             }
715         }
716     }
717 
718     //Sync for decode completion in scalable mode
719     if (CodecHalDecodeScalabilityIsBEPhase(m_scalabilityState))
720     {
721         CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_BEsCompletionSync(
722             m_scalabilityState,
723             cmdBufferInUse));
724     }
725 
726     //if scalable decode,  BE0 finish means whole frame complete.
727     // Check if destination surface needs to be synchronized
728     bool syncDestSurface = true;
729     if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
730     {
731         syncDestSurface = CodecHalDecodeScalabilityIsLastCompletePhase(m_scalabilityState);
732     }
733 
734     MOS_SYNC_PARAMS syncParams;
735     if (syncDestSurface)
736     {
737         syncParams                          = g_cInitSyncParams;
738         syncParams.GpuContext               = m_videoContext;
739         syncParams.presSyncResource         = &m_destSurface.OsResource;
740         syncParams.bReadOnly                = false;
741         syncParams.bDisableDecodeSyncLock   = m_disableDecodeSyncLock;
742         syncParams.bDisableLockForTranscode = m_disableLockForTranscode;
743 
744         CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(
745             m_osInterface,
746             &syncParams));
747         CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(
748             m_osInterface,
749             &syncParams));
750 
751         // Update the resource tag (s/w tag) for On-Demand Sync
752         m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
753 
754         // Update the tag in GPU Sync eStatus buffer (H/W Tag) to match the current S/W tag
755         if (m_osInterface->bTagResourceSync)
756         {
757             CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(
758                 cmdBufferInUse,
759                 &syncParams));
760         }
761 
762         if (m_statusQueryReportingEnabled)
763         {
764             CodechalDecodeStatusReport decodeStatusReport;
765 
766             decodeStatusReport.m_statusReportNumber = m_statusReportFeedbackNumber;
767             decodeStatusReport.m_currDecodedPic     = m_vp9PicParams->CurrPic;
768             decodeStatusReport.m_currDeblockedPic   = m_vp9PicParams->CurrPic;
769             decodeStatusReport.m_codecStatus        = CODECHAL_STATUS_UNAVAILABLE;
770             decodeStatusReport.m_numMbsAffected     = m_usFrameWidthAlignedMinBlk * m_usFrameHeightAlignedMinBlk;
771             decodeStatusReport.m_currDecodedPicRes  = m_vp9RefList[m_vp9PicParams->CurrPic.FrameIdx]->resRefPic;
772 
773             // VP9 plug-in/out was NOT fully enabled; this is just to make sure driver would not crash in CodecHal_DecodeEndFrame(),
774             // which requires the value of DecodeStatusReport.presCurrDecodedPic
775             CODECHAL_DEBUG_TOOL(
776                 decodeStatusReport.m_frameType = m_perfType;
777             )
778 
779             if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
780             {
781                 CODECHAL_DECODE_CHK_STATUS_RETURN(EndStatusReport(
782                     decodeStatusReport,
783                     cmdBufferInUse));
784             }
785             else
786             {
787                 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecode::EndStatusReport(
788                     decodeStatusReport,
789                     cmdBufferInUse));
790             }
791         }
792     }
793 
794     MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
795     CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
796         cmdBufferInUse,
797         &flushDwParams));
798 
799     CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
800         cmdBufferInUse,
801         nullptr));
802 
803     m_osInterface->pfnReturnCommandBuffer(m_osInterface, &primCmdBuffer, 0);
804     if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState) && MOS_VE_SUPPORTED(m_osInterface))
805     {
806         CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_ReturnSdryCmdBuffer(m_scalabilityState, &scdryCmdBuffer));
807     }
808 
809     CODECHAL_DEBUG_TOOL(
810 
811         if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState)) {
812             CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_DbgDumpCmdBuffer(
813                 this,
814                 m_scalabilityState,
815                 m_debugInterface,
816                 &primCmdBuffer));
817         } else {
818             CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
819                 &primCmdBuffer,
820                 CODECHAL_NUM_MEDIA_STATES,
821                 "_DEC"));
822 
823             //CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHal_DbgReplaceAllCommands(
824             //    m_debugInterface,
825             //    &primCmdBuffer));
826         }
827 
828         m_mmc->UpdateUserFeatureKey(&m_destSurface);)
829 
830     bool syncCompleteFrame = m_copyDataBufferInUse;
831     if (MOS_VE_SUPPORTED(m_osInterface) && CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
832     {
833         syncCompleteFrame = syncCompleteFrame && CodecHalDecodeScalabilityIsFEPhase(m_scalabilityState);
834     }
835 
836     MOS_SYNC_PARAMS copyDataSyncParams;
837     if (syncCompleteFrame)
838     {
839         //Sync up complete frame
840         copyDataSyncParams = g_cInitSyncParams;
841         copyDataSyncParams.GpuContext = m_videoContextForWa;
842         copyDataSyncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
843 
844         CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(
845             m_osInterface,
846             &copyDataSyncParams));
847 
848         copyDataSyncParams = g_cInitSyncParams;
849         copyDataSyncParams.GpuContext = m_videoContext;
850         copyDataSyncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
851 
852         CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(
853             m_osInterface,
854             &copyDataSyncParams));
855     }
856 
857 
858     bool submitCommand = true;
859     if (MOS_VE_SUPPORTED(m_osInterface) && CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
860     {
861         submitCommand = CodecHalDecodeScalabilityIsToSubmitCmdBuffer(m_scalabilityState);
862 
863         HalOcaInterface::On1stLevelBBEnd(scdryCmdBuffer, *m_osInterface);
864     }
865     else
866     {
867         HalOcaInterface::On1stLevelBBEnd(primCmdBuffer, *m_osInterface);
868     }
869 
870     if (submitCommand)
871     {
872         uint32_t renderingFlags = m_videoContextUsesNullHw;
873 
874         //command buffer to submit is the primary cmd buffer.
875         if ( MOS_VE_SUPPORTED(m_osInterface))
876         {
877             CODECHAL_DECODE_CHK_STATUS_RETURN(SetAndPopulateVEHintParams(&primCmdBuffer));
878         }
879 
880         if (m_osInterface->phasedSubmission
881             && MOS_VE_SUPPORTED(m_osInterface)
882             && CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
883         {
884             CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(
885                 m_osInterface,
886                 cmdBufferInUse,
887                 renderingFlags));
888         }
889         else
890         {
891             CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(
892                 m_osInterface,
893                 &primCmdBuffer,
894                 renderingFlags));
895         }
896     }
897 
898     // Reset status report
899     if (m_statusQueryReportingEnabled)
900     {
901         bool resetStatusReport = true;
902 
903         //if scalable decode,  reset status report at final BE phase.
904         if (CodecHalDecodeScalabilityIsScalableMode(m_scalabilityState))
905         {
906             resetStatusReport = CodecHalDecodeScalabilityIsFinalBEPhase(m_scalabilityState);
907         }
908 
909         if (resetStatusReport)
910         {
911             CODECHAL_DECODE_CHK_STATUS_RETURN(ResetStatusReport(
912                 m_videoContextUsesNullHw));
913         }
914     }
915 
916 #ifdef CODECHAL_HUC_KERNEL_DEBUG
917     CODECHAL_DEBUG_TOOL(
918     CODECHAL_DECODE_CHK_STATUS(m_debugInterface->DumpHucRegion(
919         &resHucSharedBuffer,
920         0,
921         CODEC_VP9_PROB_MAX_NUM_ELEM,
922         15,
923         "",
924         false,
925         1,
926         CodechalHucRegionDumpType::hucRegionDumpDefault));
927     )
928 #endif
929     CODECHAL_DEBUG_TOOL(
930         CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
931             &m_resVp9SegmentIdBuffer,
932             CodechalDbgAttr::attrSegId,
933             "SegId",
934             (m_allocatedWidthInSb * m_allocatedHeightInSb * CODECHAL_CACHELINE_SIZE)));
935         CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
936             &(m_resVp9ProbBuffer[m_frameCtxIdx]),
937             CodechalDbgAttr::attrCoefProb,
938             "PakHwCoeffProbs",
939             CODEC_VP9_PROB_MAX_NUM_ELEM));)
940 
941     // Needs to be re-set for Linux buffer re-use scenarios
942     //pVp9State->pVp9RefList[pVp9PicParams->ucCurrPicIndex]->resRefPic =
943     //    pVp9State->sDestSurface.OsResource;
944 
945     // Send the signal to indicate decode completion, in case On-Demand Sync is not present
946     CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(
947         m_osInterface,
948         &syncParams));
949 
950     return eStatus;
951 }
952 
AllocateStandard(CodechalSetting * settings)953 MOS_STATUS CodechalDecodeVp9G11 :: AllocateStandard (
954     CodechalSetting *          settings)
955 {
956     MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
957 
958     CODECHAL_DECODE_FUNCTION_ENTER;
959 
960     CODECHAL_DECODE_CHK_NULL_RETURN(settings);
961 
962     CODECHAL_DECODE_CHK_STATUS_RETURN(InitMmcState());
963 
964     m_width                      = settings->width;
965     m_height                     = settings->height;
966     if (settings->lumaChromaDepth & CODECHAL_LUMA_CHROMA_DEPTH_8_BITS)
967         m_vp9DepthIndicator = 0;
968     if (settings->lumaChromaDepth & CODECHAL_LUMA_CHROMA_DEPTH_10_BITS)
969         m_vp9DepthIndicator = 1;
970     if (settings->lumaChromaDepth & CODECHAL_LUMA_CHROMA_DEPTH_12_BITS)
971         m_vp9DepthIndicator = 2;
972     m_chromaFormatinProfile = settings->chromaFormat;
973 
974     MHW_VDBOX_STATE_CMDSIZE_PARAMS_G11      stateCmdSizeParams;
975     stateCmdSizeParams.bHucDummyStream = false;
976     stateCmdSizeParams.bScalableMode   = static_cast<MhwVdboxMfxInterfaceG11*>(m_mfxInterface)->IsScalabilitySupported();
977     //FE has more commands than BE.
978 
979     // Picture Level Commands
980     m_hwInterface->GetHxxStateCommandSize(
981         m_mode,
982         &m_commandBufferSizeNeeded,
983         &m_commandPatchListSizeNeeded,
984         &stateCmdSizeParams);
985 
986     // Primitive Level Commands
987     m_hwInterface->GetHxxPrimitiveCommandSize(
988         m_mode,
989         &m_standardDecodeSizeNeeded,
990         &m_standardDecodePatchListSizeNeeded,
991         false);
992 
993    if ( MOS_VE_SUPPORTED(m_osInterface))
994     {
995         if (static_cast<MhwVdboxMfxInterfaceG11*>(m_mfxInterface)->IsScalabilitySupported())
996         {
997             m_scalabilityState = (PCODECHAL_DECODE_SCALABILITY_STATE)MOS_AllocAndZeroMemory(sizeof(CODECHAL_DECODE_SCALABILITY_STATE));
998             CODECHAL_DECODE_CHK_NULL_RETURN(m_scalabilityState);
999             //scalability initialize
1000             CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeScalability_InitializeState(
1001                 this,
1002                 m_scalabilityState,
1003                 m_hwInterface,
1004                 false));
1005         }
1006         else
1007         {
1008             //single pipe VE initialize
1009             m_sinlgePipeVeState = (PCODECHAL_DECODE_SINGLEPIPE_VIRTUALENGINE_STATE)MOS_AllocAndZeroMemory(sizeof(CODECHAL_DECODE_SINGLEPIPE_VIRTUALENGINE_STATE));
1010             CODECHAL_DECODE_CHK_NULL_RETURN(m_sinlgePipeVeState);
1011             CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_InitInterface(m_osInterface, m_sinlgePipeVeState));
1012         }
1013     }
1014 
1015     CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeVp9::AllocateResourcesFixedSizes());
1016 
1017     // Prepare Pic Params
1018     m_picMhwParams.PipeModeSelectParams = MOS_New(MHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G11);
1019     m_picMhwParams.PipeBufAddrParams = MOS_New(MHW_VDBOX_PIPE_BUF_ADDR_PARAMS_G11);
1020     m_picMhwParams.IndObjBaseAddrParams = MOS_New(MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS);
1021     m_picMhwParams.Vp9PicState = MOS_New(MHW_VDBOX_VP9_PIC_STATE);
1022     m_picMhwParams.Vp9SegmentState = MOS_New(MHW_VDBOX_VP9_SEGMENT_STATE);
1023 
1024     MOS_ZeroMemory(m_picMhwParams.IndObjBaseAddrParams, sizeof(MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS));
1025     MOS_ZeroMemory(m_picMhwParams.Vp9PicState, sizeof(MHW_VDBOX_VP9_PIC_STATE));
1026     MOS_ZeroMemory(m_picMhwParams.Vp9SegmentState, sizeof(MHW_VDBOX_VP9_SEGMENT_STATE));
1027 
1028     for (uint16_t i = 0; i < 4; i++)
1029     {
1030         m_picMhwParams.SurfaceParams[i] = MOS_New(MHW_VDBOX_SURFACE_PARAMS);
1031         MOS_ZeroMemory(m_picMhwParams.SurfaceParams[i], sizeof(MHW_VDBOX_SURFACE_PARAMS));
1032     }
1033 
1034     return eStatus;
1035 }
1036