Debian Codegraph @

media_softlet/agnostic/common/os/mos_os.cpp

raw
1 /*
2 * Copyright (c) 2009-2023, 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 mos_os.c
24 //! \brief
25 //!
26 //!
27 //! \file mos_os.c
28 //! \brief Unified OS Formats
29 //! \details Unified OS Formats
30 //!
31
32 #include "mos_os.h"
33 #include "mos_util_debug.h"
34 #include "mos_interface.h"
35 #include "media_user_setting.h"
36
37 #if MOS_MEDIASOLO_SUPPORTED
38 void * _MOS_INTERFACE::pvSoloContext = nullptr;
39 uint32_t _MOS_INTERFACE::soloRefCnt = 0;
40 #endif // MOS_MEDIASOLO_SUPPORTED
41
42 extern MhwCpInterface* Create_MhwCpInterface(PMOS_INTERFACE osInterface);
43 extern void Delete_MhwCpInterface(MhwCpInterface* mhwInterface);
44
45 #if !EMUL
46 extern CodechalSecureDecodeInterface* Create_SecureDecodeInterface(CodechalSetting* codechalSettings, CodechalHwInterface* hwInterfaceInput);
47 extern void Delete_SecureDecodeInterface(CodechalSecureDecodeInterface* codechalSecureDecodeInterface);
48 #endif
49
50 static constexpr GMM_RESOURCE_USAGE_TYPE GmmResourceUsage[MOS_HW_RESOURCE_DEF_MAX] =
51 {
52 //
53 // CODEC USAGES
54 //
55 GMM_RESOURCE_USAGE_BEGIN_CODEC,
56 GMM_RESOURCE_USAGE_PRE_DEBLOCKING_CODEC,
57 GMM_RESOURCE_USAGE_PRE_DEBLOCKING_CODEC_PARTIALENCSURFACE,
58 GMM_RESOURCE_USAGE_POST_DEBLOCKING_CODEC,
59 GMM_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_ENCODE,
60 GMM_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_DECODE,
61 GMM_RESOURCE_USAGE_STREAMOUT_DATA_CODEC,
62 GMM_RESOURCE_USAGE_INTRA_ROWSTORE_SCRATCH_BUFFER_CODEC,
63 GMM_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC,
64 GMM_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC,
65 GMM_RESOURCE_USAGE_MACROBLOCK_STATUS_BUFFER_CODEC,
66 GMM_RESOURCE_USAGE_MFX_INDIRECT_BITSTREAM_OBJECT_DECODE,
67 GMM_RESOURCE_USAGE_MFX_INDIRECT_MV_OBJECT_CODEC,
68 GMM_RESOURCE_USAGE_MFD_INDIRECT_IT_COEF_OBJECT_DECODE,
69 GMM_RESOURCE_USAGE_MFC_INDIRECT_PAKBASE_OBJECT_CODEC,
70 GMM_RESOURCE_USAGE_BSDMPC_ROWSTORE_SCRATCH_BUFFER_CODEC,
71 GMM_RESOURCE_USAGE_MPR_ROWSTORE_SCRATCH_BUFFER_CODEC,
72 GMM_RESOURCE_USAGE_BITPLANE_READ_CODEC,
73 GMM_RESOURCE_USAGE_DIRECTMV_BUFFER_CODEC,
74 GMM_RESOURCE_USAGE_SURFACE_CURR_ENCODE,
75 GMM_RESOURCE_USAGE_SURFACE_REF_ENCODE,
76 GMM_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE,
77 GMM_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE,
78 GMM_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE_FF,
79 GMM_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE_DST,
80 GMM_RESOURCE_USAGE_SURFACE_ME_DISTORTION_ENCODE,
81 GMM_RESOURCE_USAGE_SURFACE_BRC_ME_DISTORTION_ENCODE,
82 GMM_RESOURCE_USAGE_PAK_OBJECT_ENCODE,
83 GMM_RESOURCE_USAGE_SURFACE_FLATNESS_CHECK_ENCODE,
84 GMM_RESOURCE_USAGE_SURFACE_MBENC_CURBE_ENCODE,
85 GMM_RESOURCE_USAGE_SURFACE_MAD_ENCODE,
86 GMM_RESOURCE_USAGE_VP8_BLOCK_MODE_COST_ENCODE,
87 GMM_RESOURCE_USAGE_VP8_MB_MODE_COST_ENCODE,
88 GMM_RESOURCE_USAGE_VP8_MBENC_OUTPUT_ENCODE,
89 GMM_RESOURCE_USAGE_VP8_HISTOGRAM_ENCODE,
90 GMM_RESOURCE_USAGE_VP8_L3_LLC_ENCODE,
91 GMM_RESOURCE_USAGE_MFX_STANDALONE_DEBLOCKING_CODEC,
92 GMM_RESOURCE_USAGE_HCP_MD_CODEC,
93 GMM_RESOURCE_USAGE_HCP_SAO_CODEC,
94 GMM_RESOURCE_USAGE_HCP_MV_CODEC,
95 GMM_RESOURCE_USAGE_HCP_STATUS_ERROR_CODEC,
96 GMM_RESOURCE_USAGE_HCP_LCU_ILDB_STREAMOUT_CODEC,
97 GMM_RESOURCE_USAGE_VP9_PROBABILITY_BUFFER_CODEC,
98 GMM_RESOURCE_USAGE_VP9_SEGMENT_ID_BUFFER_CODEC,
99 GMM_RESOURCE_USAGE_VP9_HVD_ROWSTORE_BUFFER_CODEC,
100 GMM_RESOURCE_USAGE_MBDISABLE_SKIPMAP_CODEC,
101 GMM_RESOURCE_USAGE_VDENC_ROW_STORE_BUFFER_CODEC,
102 GMM_RESOURCE_USAGE_VDENC_STREAMIN_CODEC,
103 GMM_RESOURCE_USAGE_SURFACE_MB_QP_CODEC,
104 GMM_RESOURCE_USAGE_MACROBLOCK_ILDB_STREAM_OUT_BUFFER_CODEC,
105 GMM_RESOURCE_USAGE_SSE_SRC_PIXEL_ROW_STORE_BUFFER_CODEC,
106 GMM_RESOURCE_USAGE_SLICE_STATE_STREAM_OUT_BUFFER_CODEC,
107 GMM_RESOURCE_USAGE_CABAC_SYNTAX_STREAM_OUT_BUFFER_CODEC,
108 GMM_RESOURCE_USAGE_PRED_COL_STORE_BUFFER_CODEC,
109 GMM_RESOURCE_USAGE_SURFACE_PAK_IMAGESTATE_ENCODE,
110 GMM_RESOURCE_USAGE_SURFACE_MBENC_BRC_ENCODE,
111 GMM_RESOURCE_USAGE_SURFACE_MB_BRC_CONST_ENCODE,
112 GMM_RESOURCE_USAGE_SURFACE_BRC_MB_QP_ENCODE,
113 GMM_RESOURCE_USAGE_SURFACE_BRC_ROI_ENCODE,
114 GMM_RESOURCE_USAGE_SURFACE_SLICE_MAP_ENCODE,
115 GMM_RESOURCE_USAGE_SURFACE_WP_DOWNSAMPLED_ENCODE,
116 GMM_RESOURCE_USAGE_SURFACE_VDENC_IMAGESTATE_ENCODE,
117 GMM_RESOURCE_USAGE_SURFACE_UNCACHED,
118 GMM_RESOURCE_USAGE_SURFACE_ELLC_ONLY,
119 GMM_RESOURCE_USAGE_SURFACE_ELLC_LLC_ONLY,
120 GMM_RESOURCE_USAGE_SURFACE_ELLC_LLC_L3,
121 GMM_RESOURCE_USAGE_SURFACE_BRC_HISTORY_ENCODE,
122 GMM_RESOURCE_USAGE_SURFACE_SOFTWARE_SCOREBOARD_ENCODE,
123 GMM_RESOURCE_USAGE_SURFACE_ME_MV_DATA_ENCODE,
124 GMM_RESOURCE_USAGE_SURFACE_MV_DISTORTION_ENCODE,
125 GMM_RESOURCE_USAGE_SURFACE_4XME_DISTORTION_ENCODE,
126 GMM_RESOURCE_USAGE_SURFACE_INTRA_DISTORTION_ENCODE,
127 GMM_RESOURCE_USAGE_MB_STATS_ENCODE,
128 GMM_RESOURCE_USAGE_SURFACE_PAK_STATS_ENCODE,
129 GMM_RESOURCE_USAGE_SURFACE_PIC_STATE_READ_ENCODE,
130 GMM_RESOURCE_USAGE_SURFACE_PIC_STATE_WRITE_ENCODE,
131 GMM_RESOURCE_USAGE_SURFACE_COMBINED_ENC_ENCODE,
132 GMM_RESOURCE_USAGE_SURFACE_BRC_CONSTANT_DATA_ENCODE,
133 GMM_RESOURCE_USAGE_SURFACE_INTERMEDIATE_CU_RECORD_SURFACE_ENCODE,
134 GMM_RESOURCE_USAGE_SURFACE_SCRATCH_ENCODE,
135 GMM_RESOURCE_USAGE_SURFACE_LCU_LEVEL_DATA_ENCODE,
136 GMM_RESOURCE_USAGE_SURFACE_ENC_HISTORY_INPUT_ENCODE,
137 GMM_RESOURCE_USAGE_SURFACE_ENC_HISTORY_OUTPUT_ENCODE,
138 GMM_RESOURCE_USAGE_SURFACE_DEBUG_ENCODE,
139 GMM_RESOURCE_USAGE_SURFACE_ENC_CONSTANT_TABLE_ENCODE,
140 GMM_RESOURCE_USAGE_SURFACE_ENC_CU_RECORD_ENCODE,
141 GMM_RESOURCE_USAGE_SURFACE_ENC_MV_TEMPORAL_BUFFER_ENCODE,
142 GMM_RESOURCE_USAGE_SURFACE_ENC_CU_PACKET_FOR_PAK_ENCODE,
143 GMM_RESOURCE_USAGE_SURFACE_ENC_BCOMBINED1_ENCODE,
144 GMM_RESOURCE_USAGE_SURFACE_ENC_BCOMBINED2_ENCODE,
145 GMM_RESOURCE_USAGE_FRAME_STATS_STREAMOUT_DATA_CODEC,
146 GMM_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_TILE_LINE_BUFFER_CODEC,
147 GMM_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_TILE_COLUMN_BUFFER_CODEC,
148 GMM_RESOURCE_USAGE_HCP_MD_TILE_LINE_CODEC,
149 GMM_RESOURCE_USAGE_HCP_MD_TILE_COLUMN_CODEC,
150 GMM_RESOURCE_USAGE_HCP_SAO_TILE_LINE_CODEC,
151 GMM_RESOURCE_USAGE_HCP_SAO_TILE_COLUMN_CODEC,
152 GMM_RESOURCE_USAGE_VP9_PROBABILITY_COUNTER_BUFFER_CODEC,
153 GMM_RESOURCE_USAGE_HUC_VIRTUAL_ADDR_REGION_BUFFER_CODEC,
154 GMM_RESOURCE_USAGE_SIZE_STREAMOUT_CODEC,
155 GMM_RESOURCE_USAGE_COMPRESSED_HEADER_BUFFER_CODEC,
156 GMM_RESOURCE_USAGE_PROBABILITY_DELTA_BUFFER_CODEC,
157 GMM_RESOURCE_USAGE_TILE_RECORD_BUFFER_CODEC,
158 GMM_RESOURCE_USAGE_TILE_SIZE_STAS_BUFFER_CODEC,
159 GMM_RESOURCE_USAGE_END_CODEC,
160
161 //
162 // CM USAGES
163 //
164 CM_RESOURCE_USAGE_SurfaceState,
165 CM_RESOURCE_USAGE_StateHeap,
166 CM_RESOURCE_USAGE_NO_L3_SurfaceState,
167 CM_RESOURCE_USAGE_NO_LLC_ELLC_SurfaceState,
168 CM_RESOURCE_USAGE_NO_LLC_SurfaceState,
169 CM_RESOURCE_USAGE_NO_ELLC_SurfaceState,
170 CM_RESOURCE_USAGE_NO_LLC_L3_SurfaceState,
171 CM_RESOURCE_USAGE_NO_ELLC_L3_SurfaceState,
172 CM_RESOURCE_USAGE_NO_CACHE_SurfaceState,
173 CM_RESOURCE_USAGE_L1_Enabled_SurfaceState,
174
175 //
176 // MP USAGES
177 //
178 MP_RESOURCE_USAGE_BEGIN,
179 MP_RESOURCE_USAGE_DEFAULT,
180 MP_RESOURCE_USAGE_DEFAULT_FF,
181 MP_RESOURCE_USAGE_DEFAULT_RCS,
182 MP_RESOURCE_USAGE_SurfaceState,
183 MP_RESOURCE_USAGE_SurfaceState_FF,
184 MP_RESOURCE_USAGE_SurfaceState_RCS,
185 MP_RESOURCE_USAGE_AGE3_SurfaceState,
186 MP_RESOURCE_USAGE_EDRAM_SurfaceState,
187 MP_RESOURCE_USAGE_EDRAM_AGE3_SurfaceState,
188 MP_RESOURCE_USAGE_No_L3_SurfaceState,
189 MP_RESOURCE_USAGE_No_LLC_L3_SurfaceState,
190 MP_RESOURCE_USAGE_No_LLC_L3_AGE_SurfaceState,
191 MP_RESOURCE_USAGE_No_LLC_eLLC_L3_AGE_SurfaceState,
192 MP_RESOURCE_USAGE_PartialEnc_No_LLC_L3_AGE_SurfaceState,
193 MP_RESOURCE_USAGE_END,
194
195 // MHW - SFC
196 MHW_RESOURCE_USAGE_Sfc_CurrentOutputSurface, //!< SFC output surface
197 MHW_RESOURCE_USAGE_Sfc_CurrentOutputSurface_PartialEncSurface, //!< SFC output surface for partial secure surfaces
198 MHW_RESOURCE_USAGE_Sfc_AvsLineBufferSurface, //!< SFC AVS Line buffer Surface
199 MHW_RESOURCE_USAGE_Sfc_IefLineBufferSurface, //!< SFC IEF Line buffer Surface
200
201 // Camera caputure.
202 GMM_RESOURCE_USAGE_CAMERA_CAPTURE,
203 // Media GMM Resource USAGES
204 GMM_RESOURCE_USAGE_CCS_MEDIA_WRITABLE,
205
206 // Media BLT copy USAGES
207 GMM_RESOURCE_USAGE_BLT_SOURCE,
208 GMM_RESOURCE_USAGE_BLT_DESTINATION,
209
210 // PAT Media Usages
211 GMM_RESOURCE_USAGE_MEDIA_BATCH_BUFFERS,
212 // DECODE
213 GMM_RESOURCE_USAGE_DECODE_INPUT_BITSTREAM,
214 GMM_RESOURCE_USAGE_DECODE_INPUT_REFERENCE,
215 GMM_RESOURCE_USAGE_DECODE_INTERNAL_READ,
216 GMM_RESOURCE_USAGE_DECODE_INTERNAL_WRITE,
217 GMM_RESOURCE_USAGE_DECODE_INTERNAL_READ_WRITE_CACHE,
218 GMM_RESOURCE_USAGE_DECODE_INTERNAL_READ_WRITE_NOCACHE,
219 GMM_RESOURCE_USAGE_DECODE_OUTPUT_PICTURE,
220 GMM_RESOURCE_USAGE_DECODE_OUTPUT_STATISTICS_WRITE,
221 GMM_RESOURCE_USAGE_DECODE_OUTPUT_STATISTICS_READ_WRITE,
222 // ENCODE
223 GMM_RESOURCE_USAGE_ENCODE_INPUT_RAW,
224 GMM_RESOURCE_USAGE_ENCODE_INPUT_RECON,
225 GMM_RESOURCE_USAGE_ENCODE_INTERNAL_READ,
226 GMM_RESOURCE_USAGE_ENCODE_INTERNAL_WRITE,
227 GMM_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_CACHE,
228 GMM_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_NOCACHE,
229 GMM_RESOURCE_USAGE_ENCODE_EXTERNAL_READ,
230 GMM_RESOURCE_USAGE_ENCODE_OUTPUT_PICTURE,
231 GMM_RESOURCE_USAGE_ENCODE_OUTPUT_BITSTREAM,
232 GMM_RESOURCE_USAGE_ENCODE_OUTPUT_STATISTICS_WRITE,
233 GMM_RESOURCE_USAGE_ENCODE_OUTPUT_STATISTICS_READ_WRITE,
234 // VP
235 GMM_RESOURCE_USAGE_VP_INPUT_PICTURE_FF,
236 GMM_RESOURCE_USAGE_VP_INPUT_REFERENCE_FF,
237 GMM_RESOURCE_USAGE_VP_INTERNAL_READ_FF,
238 GMM_RESOURCE_USAGE_VP_INTERNAL_WRITE_FF,
239 GMM_RESOURCE_USAGE_VP_INTERNAL_READ_WRITE_FF,
240 GMM_RESOURCE_USAGE_VP_OUTPUT_PICTURE_FF,
241 GMM_RESOURCE_USAGE_VP_INPUT_PICTURE_RENDER,
242 GMM_RESOURCE_USAGE_VP_INPUT_REFERENCE_RENDER,
243 GMM_RESOURCE_USAGE_VP_INTERNAL_READ_RENDER,
244 GMM_RESOURCE_USAGE_VP_INTERNAL_WRITE_RENDER,
245 GMM_RESOURCE_USAGE_VP_INTERNAL_READ_WRITE_RENDER,
246 GMM_RESOURCE_USAGE_VP_OUTPUT_PICTURE_RENDER,
247 // CP
248 GMM_RESOURCE_USAGE_CP_EXTERNAL_READ,
249 GMM_RESOURCE_USAGE_CP_INTERNAL_WRITE,
250 };
251
252 //! \brief Unified OS add command to command buffer
253 //! \details Offset returned is dword aligned but size requested can be byte aligned
254 //! \param PMOS_COMMAND_BUFFER pCmdBuffer
255 //! [in/out] Pointer to Command Buffer
256 //! \param void *pCmd
257 //! [in] Command Pointer
258 //! \param uint32_t dwCmdSize
259 //! [in] Size of command in bytes
260 //! \return MOS_STATUS
261 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
262 //!
263 MOS_STATUS Mos_AddCommand(
264 PMOS_COMMAND_BUFFER pCmdBuffer,
265 const void *pCmd,
266 uint32_t dwCmdSize)
267 {
268 return MosInterface::AddCommand(pCmdBuffer, pCmd, dwCmdSize);
269 }
270
271 //!
272 //! \brief Unified OS fill Resource
273 //! \details Locks the surface and fills the resource with data
274 //! \param PMOS_INTERFACE pOsInterface
275 //! [in] Pointer to OS Interface
276 //! \param PMOS_RESOURCE pOsResource
277 //! [in] Pointer to OS Resource
278 //! \param uint32_t dwSize
279 //! [in] Size of the Buffer
280 //! \param uint8_t iValue
281 //! [in] Value to be filled
282 //! \return MOS_STATUS
283 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
284 //!
285 MOS_STATUS Mos_OsFillResource(
286 PMOS_INTERFACE pOsInterface,
287 PMOS_RESOURCE pOsResource,
288 uint32_t dwSize,
289 uint8_t iValue)
290 {
291 MOS_OS_CHK_NULL_RETURN(pOsInterface);
292 MOS_OS_CHK_NULL_RETURN(pOsResource);
293 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
294
295 uint8_t * pByte = nullptr;
296 MOS_LOCK_PARAMS lockFlags = {};
297 uint32_t size = 0;
298 #ifndef VPSOLO_EMUL
299 if (pOsResource->pGmmResInfo)
300 {
301 size = (uint32_t)pOsResource->pGmmResInfo->GetSizeSurface();
302 }
303 if (dwSize > size)
304 {
305 MOS_OS_ASSERTMESSAGE("dwSize (%x)> size (%x)", dwSize, size);
306 }
307 #endif
308 // Lock the surface for writing
309 lockFlags.WriteOnly = 1;
310 pByte = (uint8_t*)pOsInterface->pfnLockResource(
311 pOsInterface,
312 pOsResource,
313 &lockFlags);
314
315 MOS_OS_CHK_NULL_RETURN(pByte);
316
317 MOS_FillMemory(pByte, dwSize, iValue);
318
319 // Unlock the surface
320 MOS_OS_CHK_STATUS_RETURN(pOsInterface->pfnUnlockResource(pOsInterface, pOsResource));
321
322 return eStatus;
323 }
324
325 //! \brief Unified OS Get bits per pixel
326 //! \details Gets Bits Per Pixel
327 //! \param PMOS_INTERFACE pOsInterface
328 //! [in] Pointer to OS Interface
329 //! \param PMOS_RESOURCE pOsResource
330 //! [in] Pointer to OS Resource
331 //! \param uint32_t *piBpp
332 //! [out] Bits per pixel
333 //! \return MOS_STATUS
334 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
335 //!
336 MOS_STATUS Mos_OsGetBitsPerPixel(
337 PMOS_INTERFACE pOsInterface,
338 MOS_FORMAT Format,
339 uint32_t *piBpp)
340 {
341 MOS_STATUS eStatus;
342 MOS_UNUSED(pOsInterface);
343
344 eStatus = MOS_STATUS_SUCCESS;
345
346 switch(Format)
347 {
348 case Format_A8R8G8B8:
349 case Format_X8R8G8B8:
350 case Format_A8B8G8R8:
351 case Format_X8B8G8R8:
352 case Format_AYUV:
353 case Format_R32U:
354 case Format_R32S:
355 case Format_R32F:
356 case Format_R10G10B10A2:
357 case Format_B10G10R10A2:
358 *piBpp = 32;
359 break;
360
361 case Format_P010:
362 case Format_P016:
363 case Format_R8G8B8:
364 *piBpp = 24;
365 break;
366
367 case Format_R5G6B5:
368 case Format_A8P8:
369 case Format_A8L8:
370 case Format_R16U:
371 case Format_V8U8:
372 case Format_R16F:
373 *piBpp = 16;
374 break;
375
376 case Format_YUY2:
377 case Format_YUYV:
378 case Format_YVYU:
379 case Format_UYVY:
380 case Format_VYUY:
381 *piBpp = 16;
382 break;
383
384 case Format_AI44:
385 case Format_IA44:
386 case Format_A8:
387 case Format_P8:
388 case Format_L8:
389 case Format_A4L4:
390 *piBpp = 8;
391 break;
392
393 case Format_IMC1:
394 case Format_IMC3:
395 case Format_IMC2:
396 case Format_IMC4:
397 case Format_NV12:
398 case Format_YV12:
399 case Format_I420:
400 case Format_IYUV:
401 *piBpp = 12;
402 break;
403
404 case Format_400P:
405 *piBpp = 8;
406 break;
407
408 case Format_411P:
409 *piBpp = 12;
410 break;
411
412 case Format_422H:
413 case Format_422V:
414 *piBpp = 16;
415 break;
416
417 case Format_444P:
418 case Format_RGBP:
419 case Format_BGRP:
420 *piBpp = 24;
421 break;
422
423 case Format_YVU9:
424 *piBpp = 9;
425 break;
426
427 case Format_Buffer:
428 case Format_RAW:
429 case Format_R8U:
430 case Format_R8UN:
431 *piBpp = 8;
432 break;
433
434 default:
435 MOS_OS_ASSERTMESSAGE("Format '%d' not supported.", Format);
436 *piBpp = 0;
437 eStatus = MOS_STATUS_UNKNOWN;
438 break;
439 }
440
441 return eStatus;
442 }
443
444 #if MOS_COMMAND_BUFFER_DUMP_SUPPORTED
445 //!
446 //! \brief Get Platform Name
447 //! \details This function retrieve the platform name
448 //! \param PMOS_RESOURCE pOsResource
449 //! [in] Pointer to OS Resource
450 //! \param buffer
451 //! [out] Buffer to contain platform name
452 //! \return MOS_STATUS
453 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
454 //!
455 MOS_STATUS Mos_GetPlatformName(
456 PMOS_INTERFACE pOsInterface,
457 char *buffer)
458 {
459 MOS_SecureStrcpy(buffer, MOS_COMMAND_BUFFER_PLATFORM_LEN, "N/A");
460
461 return MOS_STATUS_SUCCESS;
462 }
463
464 void Mos_AddIndirectState(
465 PMOS_INTERFACE pOsInterface,
466 uint32_t stateSize,
467 uint32_t *pIndirectState,
468 uint32_t *gfxAddressBottom,
469 uint32_t *gfxAddressTop,
470 const char *stateName)
471 {
472 MOS_OS_CHK_NULL_NO_STATUS_RETURN(pOsInterface);
473 MOS_OS_CHK_NULL_NO_STATUS_RETURN(pOsInterface->osStreamState);
474 if (pOsInterface->apoMosEnabled)
475 {
476 if (MOS_STATUS_SUCCESS != MosInterface::AddIndirectState(pOsInterface->osStreamState, stateSize, pIndirectState, gfxAddressBottom, gfxAddressTop, stateName, 0, 0))
477 {
478 MOS_OS_ASSERTMESSAGE("Fail to Add Indirect State to Dump List");
479 }
480 }
481 return;
482 }
483
484 void Mos_AddIndirectStateByAddressValue(
485 PMOS_INTERFACE pOsInterface,
486 uint32_t stateSize,
487 uint32_t *pIndirectState,
488 uint32_t gfxAddressBottom,
489 uint32_t gfxAddressTop,
490 const char *stateName)
491 {
492 MOS_OS_CHK_NULL_NO_STATUS_RETURN(pOsInterface);
493 MOS_OS_CHK_NULL_NO_STATUS_RETURN(pOsInterface->osStreamState);
494 if (pOsInterface->apoMosEnabled)
495 {
496 if (MOS_STATUS_SUCCESS != MosInterface::AddIndirectState(pOsInterface->osStreamState, stateSize, pIndirectState, 0, 0, stateName, gfxAddressBottom, gfxAddressTop))
497 {
498 MOS_OS_ASSERTMESSAGE("Fail to Add Indirect State to Dump List");
499 }
500 }
501 return;
502 }
503
504 //!
505 //! \brief Dump command buffers
506 //! \details This function dumps the command buffer just before rendering it to the GPU.
507 //! The output is saved to %TEMP%\Command_buffer_dumps.
508 //! A GPU engine prefix is printed for each command buffer, to let the user know which command streamer is being used.
509 //! \param PMOS_RESOURCE pOsResource
510 //! [in] Pointer to OS Resource
511 //! \param PMOS_COMMAND_BUFFER pCmdBuffer
512 //! [in] Pointer to command buffer structure
513 //! \return MOS_STATUS
514 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
515 //!
516 MOS_STATUS Mos_DumpCommandBuffer(
517 PMOS_INTERFACE pOsInterface,
518 PMOS_COMMAND_BUFFER pCmdBuffer)
519 {
520 static uint32_t dwCommandBufferNumber = 0;
521 MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
522 char *pOutputBuffer = nullptr;
523 // Each hex value should have 9 chars.
524 uint32_t SIZE_OF_ONE_WORD = 9;
525 uint32_t dwBytesWritten = 0;
526 uint32_t dwNumberOfDwords = 0;
527 uint32_t dwSizeToAllocate = 0;
528 char sFileName[MOS_MAX_HLT_FILENAME_LEN];
529 // Maximum length of engine name is 6
530 char sEngName[6];
531 char *psFileNameAfterPrefix = nullptr;
532 size_t nSizeFileNamePrefix = 0;
533
534 MOS_OS_CHK_NULL_RETURN(pOsInterface);
535 MOS_OS_CHK_NULL_RETURN(pCmdBuffer);
536
537 if (pOsInterface->apoMosEnabled)
538 {
539 return MosInterface::DumpCommandBuffer(pOsInterface->osStreamState, pCmdBuffer);
540 }
541
542 // Set the name of the engine that is going to be used.
543 MOS_GPU_CONTEXT sGpuContext = pOsInterface->pfnGetGpuContext(pOsInterface);
544 switch (sGpuContext)
545 {
546 case MOS_GPU_CONTEXT_VIDEO:
547 case MOS_GPU_CONTEXT_VIDEO2:
548 case MOS_GPU_CONTEXT_VIDEO3:
549 case MOS_GPU_CONTEXT_VIDEO4:
550 case MOS_GPU_CONTEXT_VDBOX2_VIDEO:
551 case MOS_GPU_CONTEXT_VDBOX2_VIDEO2:
552 case MOS_GPU_CONTEXT_VDBOX2_VIDEO3:
553 case MOS_GPU_CONTEXT_VIDEO5:
554 case MOS_GPU_CONTEXT_VIDEO6:
555 case MOS_GPU_CONTEXT_VIDEO7:
556 MOS_SecureStrcpy(sEngName, sizeof(sEngName), MOS_COMMAND_BUFFER_VIDEO_ENGINE);
557 break;
558 case MOS_GPU_CONTEXT_TEE:
559 MOS_SecureStrcpy(sEngName, sizeof(sEngName), MOS_COMMAND_BUFFER_TEE_ENGINE);
560 break;
561 case MOS_GPU_CONTEXT_RENDER:
562 case MOS_GPU_CONTEXT_RENDER2:
563 case MOS_GPU_CONTEXT_RENDER3:
564 case MOS_GPU_CONTEXT_RENDER4:
565 case MOS_GPU_CONTEXT_RENDER_RA:
566 case MOS_GPU_CONTEXT_COMPUTE:
567 case MOS_GPU_CONTEXT_COMPUTE_RA:
568 case MOS_GPU_CONTEXT_CM_COMPUTE:
569 MOS_SecureStrcpy(sEngName, sizeof(sEngName), MOS_COMMAND_BUFFER_RENDER_ENGINE);
570 break;
571 case MOS_GPU_CONTEXT_VEBOX:
572 MOS_SecureStrcpy(sEngName, sizeof(sEngName), MOS_COMMAND_BUFFER_VEBOX_ENGINE);
573 break;
574 default:
575 MOS_OS_ASSERTMESSAGE("Unsupported GPU context.");
576 return MOS_STATUS_UNKNOWN;
577 }
578
579 dwNumberOfDwords = pCmdBuffer->iOffset / sizeof(uint32_t);
580
581 dwSizeToAllocate =
582 dwNumberOfDwords * (SIZE_OF_ONE_WORD + 1) // Add 1 byte for the space following each Dword.
583 + 3 * SIZE_OF_ONE_WORD; // For engine and platform names.
584
585 // Alloc output buffer.
586 pOutputBuffer = (char *)MOS_AllocAndZeroMemory(dwSizeToAllocate);
587 MOS_OS_CHK_NULL_RETURN(pOutputBuffer);
588
589 dwBytesWritten = MOS_SecureStringPrint(
590 pOutputBuffer,
591 SIZE_OF_ONE_WORD * 3,
592 SIZE_OF_ONE_WORD * 3,
593 "Eng=%s Plat=%s ",
594 sEngName, pOsInterface->sPlatformName);
595
596 if (pOsInterface->bDumpCommandBufferToFile)
597 {
598 // Set the file name.
599 memcpy(sFileName, pOsInterface->sDirName, MOS_MAX_HLT_FILENAME_LEN);
600 nSizeFileNamePrefix = strnlen(sFileName, sizeof(sFileName));
601 MOS_SecureStringPrint(
602 sFileName + nSizeFileNamePrefix,
603 sizeof(sFileName) - nSizeFileNamePrefix,
604 sizeof(sFileName) - nSizeFileNamePrefix,
605 "%c%s%c%s_%d.txt",
606 MOS_DIR_SEPERATOR, MOS_COMMAND_BUFFER_OUT_DIR,
607 MOS_DIR_SEPERATOR, MOS_COMMAND_BUFFER_OUT_FILE, dwCommandBufferNumber);
608
609 // Write the output buffer to file.
610 MOS_OS_CHK_STATUS_RETURN(MosUtilities::MosWriteFileFromPtr((const char *)sFileName, pOutputBuffer, dwBytesWritten));
611 }
612
613 if (pOsInterface->bDumpCommandBufferAsMessages)
614 {
615 MOS_OS_NORMALMESSAGE(pOutputBuffer);
616 }
617
618 MOS_ZeroMemory(pOutputBuffer, dwBytesWritten);
619 dwBytesWritten = 0;
620
621 // Fill in the output buffer with the command buffer dwords.
622 for (uint32_t dwIndex = 0; dwIndex < dwNumberOfDwords; dwIndex++)
623 {
624 dwBytesWritten += MOS_SecureStringPrint(
625 pOutputBuffer + dwBytesWritten,
626 SIZE_OF_ONE_WORD + 1,
627 SIZE_OF_ONE_WORD + 1,
628 "%.8x ",
629 pCmdBuffer->pCmdBase[dwIndex]);
630
631 if (dwBytesWritten % (SIZE_OF_ONE_WORD + 1) == 0)
632 {
633 if (pOsInterface->bDumpCommandBufferToFile)
634 {
635 MOS_OS_CHK_STATUS_RETURN(MosUtilities::MosAppendFileFromPtr((const char *)sFileName, pOutputBuffer, dwBytesWritten));
636 }
637 if (pOsInterface->bDumpCommandBufferAsMessages)
638 {
639 MOS_OS_NORMALMESSAGE(pOutputBuffer);
640 }
641
642 MOS_ZeroMemory(pOutputBuffer, dwBytesWritten);
643 dwBytesWritten = 0;
644 }
645 }
646
647 if (pOsInterface->bDumpCommandBufferToFile)
648 {
649 MOS_OS_CHK_STATUS_RETURN(MosUtilities::MosAppendFileFromPtr((const char *)sFileName, pOutputBuffer, dwBytesWritten));
650 }
651
652 if (pOsInterface->bDumpCommandBufferAsMessages)
653 {
654 MOS_OS_NORMALMESSAGE(pOutputBuffer);
655 }
656
657 dwCommandBufferNumber++;
658
659 eStatus = MOS_STATUS_SUCCESS;
660
661 // Free the memory.
662 if (pOutputBuffer)
663 {
664 MOS_FreeMemAndSetNull(pOutputBuffer);
665 }
666
667 return eStatus;
668 }
669
670 //! \brief Unified dump command buffer initialization
671 //! \details check if dump command buffer was enabled and create the output directory
672 //! \param PMOS_INTERFACE pOsInterface
673 //! [in/out] Pointer to OS Interface
674 //! \return MOS_STATUS
675 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
676 //!
677 MOS_STATUS Mos_DumpCommandBufferInit(
678 PMOS_INTERFACE pOsInterface)
679 {
680 char sFileName[MOS_MAX_HLT_FILENAME_LEN] = {};
681 MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
682 size_t nSizeFileNamePrefix = 0;
683 MediaUserSettingSharedPtr userSettingPtr = nullptr;
684 uint32_t value = 0;
685 MOS_OS_CHK_NULL_RETURN(pOsInterface);
686
687 userSettingPtr = pOsInterface->pfnGetUserSettingInstance(pOsInterface);
688
689 // Setup member function and variable.
690 pOsInterface->pfnDumpCommandBuffer = Mos_DumpCommandBuffer;
691 pOsInterface->pfnAddIndirectState = Mos_AddIndirectState;
692 pOsInterface->pfnAddIndirectStateByAddressValue = Mos_AddIndirectStateByAddressValue;
693
694 // Check if command buffer dump was enabled in user feature.
695 ReadUserSetting(
696 userSettingPtr,
697 value,
698 __MEDIA_USER_FEATURE_VALUE_DUMP_COMMAND_BUFFER_ENABLE,
699 MediaUserSetting::Group::Device);
700
701 pOsInterface->bDumpCommandBuffer = (value != 0);
702 pOsInterface->bDumpCommandBufferToFile = ((value & 1) != 0);
703 pOsInterface->bDumpCommandBufferAsMessages = ((value & 2) != 0);
704
705 if (pOsInterface->bDumpCommandBufferToFile)
706 {
707 // Create output directory.
708 eStatus = MosUtilDebug::MosLogFileNamePrefix(pOsInterface->sDirName, userSettingPtr);
709 if (eStatus != MOS_STATUS_SUCCESS)
710 {
711 MOS_OS_NORMALMESSAGE("Failed to create log file prefix. Status = %d", eStatus);
712 return eStatus;
713 }
714
715 memcpy(sFileName, pOsInterface->sDirName, MOS_MAX_HLT_FILENAME_LEN);
716 nSizeFileNamePrefix = strnlen(sFileName, sizeof(sFileName));
717 MOS_SecureStringPrint(
718 sFileName + nSizeFileNamePrefix,
719 sizeof(sFileName) - nSizeFileNamePrefix,
720 sizeof(sFileName) - nSizeFileNamePrefix,
721 "%c%s",
722 MOS_DIR_SEPERATOR, MOS_COMMAND_BUFFER_OUT_DIR);
723
724 eStatus = MosUtilities::MosCreateDirectory(sFileName);
725 if (eStatus != MOS_STATUS_SUCCESS)
726 {
727 MOS_OS_NORMALMESSAGE("Failed to create output directory. Status = %d", eStatus);
728 return eStatus;
729 }
730 }
731
732 Mos_GetPlatformName(pOsInterface, pOsInterface->sPlatformName);
733
734 return MOS_STATUS_SUCCESS;
735 }
736 #endif // MOS_COMMAND_BUFFER_DUMP_SUPPORTED
737
738 #if MOS_COMMAND_RESINFO_DUMP_SUPPORTED
739
740 std::shared_ptr<GpuCmdResInfoDump> GpuCmdResInfoDump::m_instance = nullptr;
741
742 const GpuCmdResInfoDump *GpuCmdResInfoDump::GetInstance(PMOS_CONTEXT mosCtx)
743 {
744 if (m_instance == nullptr)
745 {
746 m_instance = std::make_shared<GpuCmdResInfoDump>(mosCtx);
747 }
748 return m_instance.get();
749 }
750
751 GpuCmdResInfoDump::GpuCmdResInfoDump(PMOS_CONTEXT mosCtx)
752 {
753 MediaUserSettingSharedPtr userSettingPtr = nullptr;
754 MediaUserSetting::Value value;
755
756 userSettingPtr = MosInterface::MosGetUserSettingInstance(mosCtx);
757
758 ReadUserSetting(
759 userSettingPtr,
760 m_dumpEnabled,
761 __MEDIA_USER_FEATURE_VALUE_DUMP_COMMAND_INFO_ENABLE,
762 MediaUserSetting::Group::Device);
763
764 if (!m_dumpEnabled)
765 {
766 return;
767 }
768
769 ReadUserSetting(
770 userSettingPtr,
771 value,
772 __MEDIA_USER_FEATURE_VALUE_DUMP_COMMAND_INFO_PATH,
773 MediaUserSetting::Group::Device);
774
775 auto path = value.ConstString();
776 if(path.size() > 0)
777 {
778 m_path = path;
779 if (path.back() != '/' && path.back() != '\\')
780 {
781 m_path += '/';
782 }
783 }
784 m_path = m_path + "gpuCmdResInfo_" + std::to_string(MosUtilities::MosGetPid()) + ".txt";
785 }
786
787 void GpuCmdResInfoDump::Dump(PMOS_INTERFACE pOsInterface) const
788 {
789 if (!m_dumpEnabled)
790 {
791 return;
792 }
793
794 using std::endl;
795
796 std::ofstream outputFile;
797 outputFile.open(m_path, std::ios_base::app);
798 MOS_OS_ASSERT(outputFile.is_open());
799
800 auto &cmdResInfoPtrs = GetCmdResPtrs(pOsInterface);
801
802 outputFile << "--PerfTag: " << std::to_string(pOsInterface->pfnGetPerfTag(pOsInterface)) << " --Cmd Num: "
803 << cmdResInfoPtrs.size() << " --Dump Count: " << ++m_cnt << endl;
804
805 outputFile << "********************************CMD Paket Begin********************************" << endl;
806 for (auto e : cmdResInfoPtrs)
807 {
808 Dump(e, outputFile);
809 }
810 outputFile << "********************************CMD Paket End**********************************" << endl << endl;
811
812 outputFile.close();
813 }
814
815 const char *GpuCmdResInfoDump::GetResType(MOS_GFXRES_TYPE resType) const
816 {
817 switch (resType)
818 {
819 case MOS_GFXRES_INVALID:
820 return "MOS_GFXRES_INVALID";
821 case MOS_GFXRES_BUFFER:
822 return "MOS_GFXRES_BUFFER";
823 case MOS_GFXRES_2D:
824 return "MOS_GFXRES_2D";
825 case MOS_GFXRES_VOLUME:
826 return "MOS_GFXRES_VOLUME";
827 default:
828 return "";
829 }
830 }
831
832 const char *GpuCmdResInfoDump::GetTileType(MOS_TILE_TYPE tileType) const
833 {
834 switch (tileType)
835 {
836 case MOS_TILE_X:
837 return "MOS_TILE_X";
838 case MOS_TILE_Y:
839 return "MOS_TILE_Y";
840 case MOS_TILE_YF:
841 return "MOS_TILE_YF";
842 case MOS_TILE_YS:
843 return "MOS_TILE_YS";
844 case MOS_TILE_LINEAR:
845 return "MOS_TILE_LINEAR";
846 case MOS_TILE_INVALID:
847 return "MOS_TILE_INVALID";
848 default:
849 return "";
850 }
851 }
852 #endif // MOS_COMMAND_RESINFO_DUMP_SUPPORTED
853
854 //! \brief Unified OS Initializes OS Interface
855 //! \details OS Interface initilization
856 //! \param PMOS_INTERFACE pOsInterface
857 //! [in/out] Pointer to OS Interface
858 //! \param MOS_CONTEXT_HANDLE osDriverContext
859 //! [in] Pointer to Driver context
860 //! \param MOS_COMPONENT component
861 //! [in] OS component
862 //! \return MOS_STATUS
863 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
864 //!
865 MOS_STATUS Mos_InitOsInterface(
866 PMOS_INTERFACE pOsInterface,
867 MOS_CONTEXT_HANDLE osDriverContext,
868 MOS_COMPONENT component)
869 {
870 MOS_OS_CHK_NULL_RETURN(pOsInterface);
871 #if !EMUL
872 MOS_OS_CHK_NULL_RETURN(osDriverContext);
873 #endif
874 MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
875 MediaUserSettingSharedPtr userSettingPtr = nullptr;
876 PMOS_CONTEXT pOsDriverContext = (PMOS_CONTEXT)osDriverContext;
877 // Setup Member functions
878 pOsInterface->pfnFillResource = Mos_OsFillResource;
879 pOsInterface->pfnGetBitsPerPixel = Mos_OsGetBitsPerPixel;
880 pOsInterface->pfnAddCommand = Mos_AddCommand;
881 pOsInterface->pfnVirtualEngineSupported = Mos_CheckVirtualEngineSupported;
882 pOsInterface->pfnGetResourceCachePolicyMemoryObject = Mos_GetResourceCachePolicyMemoryObject;
883
884 pOsInterface->pfnIsAsyncDevice = Mos_IsAsyncDevice;
885 pOsInterface->pfnMosFmtToOsFmt = Mos_MosFmtToOsFmt;
886 pOsInterface->pfnOsFmtToMosFmt = Mos_OsFmtToMosFmt;
887 pOsInterface->pfnMosFmtToGmmFmt = Mos_MosFmtToGmmFmt;
888 pOsInterface->pfnGmmFmtToMosFmt = Mos_GmmFmtToMosFmt;
889 pOsInterface->pfnWaitForCmdCompletion = Mos_WaitForCmdCompletion;
890 pOsInterface->pfnGetResourceArrayIndex = Mos_GetResourceArrayIndex;
891 pOsInterface->pfnSetupAttributeVeBuffer = Mos_SetupAttributeVeBuffer;
892 pOsInterface->pfnGetAttributeVeBuffer = Mos_GetAttributeVeBuffer;
893 pOsInterface->pfnSetupCurrentCmdListAndPool = Mos_SetupCurrentCmdListAndPool;
894 pOsInterface->pfnGmmToMosResourceUsageType = Mos_GmmToMosResourceUsageType;
895 pOsInterface->pfnGetAdapterInfo = Mos_GetAdapterInfo;
896 pOsInterface->pfnIsCompressibelSurfaceSupported = Mos_IsCompressibelSurfaceSupported;
897 pOsInterface->pfnDestroyVirtualEngineState = Mos_DestroyVirtualEngineState;
898 pOsInterface->pfnGetResourceHandle = Mos_GetResourceHandle;
899 pOsInterface->pfnGetRtLogResourceInfo = Mos_GetRtLogResourceInfo;
900 pOsInterface->pfnResetResource = Mos_ResetMosResource;
901 pOsInterface->pfnVerifyMosSurface = Mos_VerifyMosSurface;
902
903 pOsInterface->pfnCreateMhwCpInterface = Create_MhwCpInterface;
904 pOsInterface->pfnDeleteMhwCpInterface = Delete_MhwCpInterface;
905 pOsInterface->pfnInsertCacheSetting = Mos_InsertCacheSetting;
906 pOsInterface->pfnGetCacheSetting = Mos_GetCacheSetting;
907 pOsInterface->pfnSetHybridCmdMgrToGpuContext = MOS_SetHybridCmdMgrToGpuContext;
908 pOsInterface->pfnSetHybridMgrSubmitMode = MOS_SetHybridCmdMgrSubmitMode;
909 pOsInterface->pfnStartHybridCmdMgr = MOS_StartHybridCmdMgr;
910 pOsInterface->pfnStopHybridCmdMgr = MOS_StopHybridCmdMgr;
911 pOsInterface->pfnSubmitPackage = MOS_SubmitPackage;
912 #if !EMUL
913 pOsInterface->pfnCreateSecureDecodeInterface = Create_SecureDecodeInterface;
914 pOsInterface->pfnDeleteSecureDecodeInterface = Delete_SecureDecodeInterface;
915 #endif
916 #if (_DEBUG || _RELEASE_INTERNAL)
917 pOsInterface->pfnGetVeEngineCount = Mos_GetVeEngineCount;
918 pOsInterface->pfnGetEngineLogicIdByIdx = Mos_GetEngineLogicId;
919 pOsInterface->pfnSetGpuVirtualAddress = MOS_SetGpuVirtualAddress;
920 #endif
921
922 pOsInterface->Component = component;
923 pOsInterface->modulizedMosEnabled = true;
924 pOsInterface->osContextPtr = nullptr;
925 pOsInterface->veDefaultEnable = true;
926
927 pOsInterface->streamIndex = 0;
928 pOsInterface->bSimIsActive = 0;
929
930 eStatus = Mos_Specific_InitInterface(pOsInterface, pOsDriverContext);
931 if (eStatus != MOS_STATUS_SUCCESS)
932 {
933 MOS_OS_ASSERTMESSAGE("Mos_Specific_InitInterface FAILED, errno = 0x%x", eStatus);
934 return eStatus;
935 }
936
937 userSettingPtr = pOsInterface->pfnGetUserSettingInstance(pOsInterface);
938
939 #if MOS_COMMAND_BUFFER_DUMP_SUPPORTED
940 Mos_DumpCommandBufferInit(pOsInterface);
941 #endif // MOS_COMMAND_BUFFER_DUMP_SUPPORTED
942
943 #if (_DEBUG || _RELEASE_INTERNAL)
944 // Report if pre-si environment is in use
945 ReportUserSettingForDebug(
946 userSettingPtr,
947 __MEDIA_USER_FEATURE_VALUE_SIM_IN_USE,
948 pOsInterface->bSimIsActive,
949 MediaUserSetting::Group::Device);
950 #endif
951
952 if (pOsInterface->apoMosEnabled)
953 {
954 pOsInterface->osStreamState->osCpInterface = pOsInterface->osCpInterface;
955 }
956
957 return eStatus;
958 }
959
960 #if !EMUL
961 MEMORY_OBJECT_CONTROL_STATE Mos_CachePolicyGetMemoryObject(
962 MOS_HW_RESOURCE_DEF MosUsage,
963 GMM_CLIENT_CONTEXT *pGmmClientContext)
964 {
965 MOS_OS_ASSERT(pGmmClientContext);
966
967 GMM_RESOURCE_USAGE_TYPE usage = GmmResourceUsage[MosUsage];
968 if (pGmmClientContext->GetCachePolicyElement(usage).Initialized)
969 {
970 return pGmmClientContext->CachePolicyGetMemoryObject(nullptr, usage);
971 }
972 else
973 {
974 return pGmmClientContext->GetCachePolicyUsage()[GMM_RESOURCE_USAGE_UNKNOWN].MemoryObjectOverride;
975 }
976 }
977 #endif
978
979 #ifndef SKIP_VE_DEFINE
980 MOS_STATUS Mos_CheckVirtualEngineSupported(
981 PMOS_INTERFACE osInterface,
982 bool isNotEncode,
983 bool veDefaultEnable)
984 {
985 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
986 MediaUserSettingSharedPtr userSettingPtr = nullptr;
987 uint32_t value = 0;
988
989 MOS_OS_CHK_NULL_RETURN(osInterface);
990
991 userSettingPtr = osInterface->pfnGetUserSettingInstance(osInterface);
992 if (isNotEncode)
993 {
994 //UMD Decode Virtual Engine Override
995 // 0: disable. can set to 1 only when KMD VE is enabled.
996 // Default value is 1 if not set this key
997 osInterface->bSupportVirtualEngine = true;
998 #if (_DEBUG || _RELEASE_INTERNAL)
999 ReadUserSettingForDebug(
1000 userSettingPtr,
1001 value,
1002 __MEDIA_USER_FEATURE_VALUE_ENABLE_DECODE_VIRTUAL_ENGINE,
1003 MediaUserSetting::Group::Device);
1004 osInterface->bSupportVirtualEngine = value ? true : false;
1005 #endif
1006
1007 auto skuTable = osInterface->pfnGetSkuTable(osInterface);
1008 MOS_OS_CHK_NULL_RETURN(skuTable);
1009 if (osInterface->bSupportVirtualEngine && MEDIA_IS_SKU(skuTable, FtrContextBasedScheduling))
1010 {
1011 osInterface->ctxBasedScheduling = true;
1012 }
1013 else
1014 {
1015 osInterface->ctxBasedScheduling = false;
1016 }
1017
1018 if (osInterface->pfnCheckVirtualEngineSupported)
1019 {
1020 osInterface->pfnCheckVirtualEngineSupported(osInterface);
1021 }
1022
1023 osInterface->multiNodeScaling = osInterface->ctxBasedScheduling && MEDIA_IS_SKU(skuTable, FtrVcs2) ? true : false;
1024
1025 #if (_DEBUG || _RELEASE_INTERNAL)
1026 value = osInterface->ctxBasedScheduling ? true : false;
1027 ReportUserSettingForDebug(
1028 userSettingPtr,
1029 __MEDIA_USER_FEATURE_VALUE_ENABLE_DECODE_VE_CTXSCHEDULING,
1030 value,
1031 MediaUserSetting::Group::Device);
1032 #endif
1033 }
1034 else
1035 {
1036 //UMD Encode Virtual Engine Override
1037 osInterface->bSupportVirtualEngine = true;
1038 #if (_DEBUG || _RELEASE_INTERNAL)
1039 ReadUserSettingForDebug(
1040 userSettingPtr,
1041 value,
1042 __MEDIA_USER_FEATURE_VALUE_ENABLE_ENCODE_VIRTUAL_ENGINE,
1043 MediaUserSetting::Group::Device);
1044 osInterface->bSupportVirtualEngine = value ? true : false;
1045 #endif
1046
1047 auto skuTable = osInterface->pfnGetSkuTable(osInterface);
1048 MOS_OS_CHK_NULL_RETURN(skuTable);
1049 if (osInterface->bSupportVirtualEngine && MEDIA_IS_SKU(skuTable, FtrContextBasedScheduling))
1050 {
1051 osInterface->ctxBasedScheduling = true;
1052 }
1053 else
1054 {
1055 osInterface->ctxBasedScheduling = false;
1056 }
1057 osInterface->multiNodeScaling = osInterface->ctxBasedScheduling && MEDIA_IS_SKU(skuTable, FtrVcs2) ? true : false;
1058 }
1059
1060 if (osInterface->apoMosEnabled)
1061 {
1062 // Update ctx based scheduling flag also in APO MOS stream state
1063 MOS_OS_CHK_NULL_RETURN(osInterface->osStreamState);
1064 osInterface->osStreamState->ctxBasedScheduling = osInterface->ctxBasedScheduling;
1065 osInterface->osStreamState->multiNodeScaling = osInterface->multiNodeScaling;
1066 }
1067 MOS_OS_VERBOSEMESSAGE("Virtual Engine Context based SCheduling enabled:%d.\n", osInterface->ctxBasedScheduling);
1068 MOS_OS_VERBOSEMESSAGE("Virtual Engine Multi-node Scaling enabled:%d.\n", osInterface->multiNodeScaling);
1069
1070 return eStatus;
1071 }
1072 #endif // !SKIP_VE_DEFINE
1073
1074 MEMORY_OBJECT_CONTROL_STATE Mos_GetResourceCachePolicyMemoryObject(
1075 PMOS_INTERFACE osInterface,
1076 PMOS_RESOURCE resource)
1077 {
1078 MEMORY_OBJECT_CONTROL_STATE memObjCtrlState = {};
1079
1080 if(resource == nullptr)
1081 {
1082 MOS_OS_ASSERTMESSAGE("resource == nullptr");
1083 return memObjCtrlState;
1084 }
1085
1086 memObjCtrlState = resource->memObjCtrlState;
1087 if(osInterface == nullptr)
1088 {
1089 MOS_OS_ASSERTMESSAGE("osInterface == nullptr");
1090 return memObjCtrlState;
1091 }
1092
1093 auto gmmClientContext = osInterface->pfnGetGmmClientContext(osInterface);
1094
1095 if(resource->bConvertedFromDDIResource &&
1096 resource->mocsMosResUsageType >= MOS_HW_RESOURCE_USAGE_MEDIA_BATCH_BUFFERS)
1097 {
1098 memObjCtrlState = MosInterface::GetCachePolicyMemoryObject(gmmClientContext, resource->mocsMosResUsageType);
1099 }
1100
1101 if (resource->mocsMosResUsageType >= (sizeof(GmmResourceUsage) / sizeof(GmmResourceUsage[0])))
1102 {
1103 MOS_OS_ASSERTMESSAGE("mocsMosResUsageType out of bound");
1104 resource->mocsMosResUsageType = MOS_CODEC_RESOURCE_USAGE_BEGIN_CODEC;
1105 }
1106 GMM_RESOURCE_USAGE_TYPE usage = GmmResourceUsage[resource->mocsMosResUsageType];
1107 if ((memObjCtrlState.DwordValue == 0)
1108 #if !EMUL
1109 && !gmmClientContext->GetCachePolicyElement(usage).Initialized
1110 #endif
1111 )
1112 {
1113 memObjCtrlState = MosInterface::GetDefaultCachePolicyMemoryObject(gmmClientContext);
1114 }
1115 return memObjCtrlState;
1116 }
1117
1118 bool Mos_IsAsyncDevice(
1119 MOS_STREAM_HANDLE streamState)
1120 {
1121 return MosInterface::IsAsyncDevice(streamState);
1122 }
1123
1124 uint32_t Mos_MosFmtToOsFmt(
1125 MOS_FORMAT format)
1126 {
1127 return MosInterface::MosFmtToOsFmt(format);
1128 }
1129
1130 MOS_FORMAT Mos_OsFmtToMosFmt(
1131 uint32_t format)
1132 {
1133 return MosInterface::OsFmtToMosFmt(format);
1134 }
1135
1136 GMM_RESOURCE_FORMAT Mos_MosFmtToGmmFmt(
1137 MOS_FORMAT format)
1138 {
1139 return MosInterface::MosFmtToGmmFmt(format);
1140 }
1141
1142 MOS_FORMAT Mos_GmmFmtToMosFmt(
1143 GMM_RESOURCE_FORMAT format)
1144 {
1145 return MosInterface::GmmFmtToMosFmt(format);
1146 }
1147
1148 MOS_STATUS Mos_WaitForCmdCompletion(
1149 MOS_STREAM_HANDLE streamState,
1150 GPU_CONTEXT_HANDLE gpuCtx)
1151 {
1152 return MosInterface::WaitForCmdCompletion(streamState, gpuCtx);
1153 }
1154
1155 uint32_t Mos_GetResourceArrayIndex(
1156 PMOS_RESOURCE resource)
1157 {
1158 return MosInterface::GetResourceArrayIndex(resource);
1159 }
1160
1161 MOS_STATUS Mos_SetupAttributeVeBuffer(
1162 MOS_STREAM_HANDLE streamState,
1163 COMMAND_BUFFER_HANDLE cmdBuffer)
1164 {
1165 return MosInterface::SetupAttributeVeBuffer(streamState, cmdBuffer);
1166 }
1167
1168 MOS_CMD_BUF_ATTRI_VE *Mos_GetAttributeVeBuffer(
1169 COMMAND_BUFFER_HANDLE cmdBuffer)
1170 {
1171 return MosInterface::GetAttributeVeBuffer(cmdBuffer);
1172 }
1173
1174 MOS_STATUS Mos_SetupCurrentCmdListAndPool(
1175 PMOS_INTERFACE osInterface,
1176 MOS_STREAM_HANDLE streamState)
1177 {
1178 return MosInterface::SetupCurrentCmdListAndPoolFromOsInterface(osInterface, streamState);
1179 }
1180
1181 MOS_HW_RESOURCE_DEF Mos_GmmToMosResourceUsageType(
1182 GMM_RESOURCE_USAGE_TYPE gmmResUsage)
1183 {
1184 return MosInterface::GmmToMosResourceUsageType(gmmResUsage);
1185 }
1186
1187 ADAPTER_INFO *Mos_GetAdapterInfo(
1188 MOS_STREAM_HANDLE streamState)
1189 {
1190 return MosInterface::GetAdapterInfo(streamState);
1191 }
1192
1193 bool Mos_IsCompressibelSurfaceSupported(
1194 MEDIA_FEATURE_TABLE *skuTable)
1195 {
1196 return MosInterface::IsCompressibelSurfaceSupported(skuTable);
1197 }
1198
1199 MOS_STATUS Mos_DestroyVirtualEngineState(
1200 MOS_STREAM_HANDLE streamState)
1201 {
1202 return MosInterface::DestroyVirtualEngineState(streamState);
1203 }
1204
1205 uint64_t Mos_GetResourceHandle(
1206 MOS_STREAM_HANDLE streamState,
1207 PMOS_RESOURCE osResource)
1208 {
1209 return MosInterface::GetResourceHandle(streamState, osResource);
1210 }
1211
1212 MOS_STATUS Mos_VerifyMosSurface(
1213 PMOS_SURFACE mosSurface,
1214 bool& bIsValid)
1215 {
1216 return MosInterface::VerifyMosSurface(mosSurface, bIsValid);
1217 }
1218
1219 void Mos_GetRtLogResourceInfo(
1220 PMOS_INTERFACE osInterface,
1221 PMOS_RESOURCE &osResource,
1222 uint32_t &size)
1223 {
1224 return MosInterface::GetRtLogResourceInfo(osInterface, osResource, size);
1225 }
1226
1227 void Mos_ResetMosResource(
1228 PMOS_RESOURCE resource)
1229 {
1230 return MosInterface::MosResetResource(resource);
1231 }
1232
1233 bool Mos_InsertCacheSetting(CACHE_COMPONENTS id, std::map<uint64_t, MOS_CACHE_ELEMENT> *cacheTablesPtr)
1234 {
1235 return RegisterCacheSettings(id, cacheTablesPtr);
1236 }
1237
1238 bool Mos_GetCacheSetting(MOS_COMPONENT id, uint32_t feature, bool bOut, ENGINE_TYPE engineType, MOS_CACHE_ELEMENT &element, bool isHeapSurf)
1239 {
1240 return LoadCacheSettings(id, feature, bOut, engineType, element, isHeapSurf);
1241 }
1242
1243 MOS_STATUS MOS_SetHybridCmdMgrToGpuContext(
1244 PMOS_INTERFACE pOsInterface,
1245 uint64_t gpuCtxOnHybridCmd)
1246 {
1247 return MosInterface::SetHybridCmdMgrToGpuContext(pOsInterface, gpuCtxOnHybridCmd);
1248 }
1249
1250 MOS_STATUS MOS_SetHybridCmdMgrSubmitMode(
1251 PMOS_INTERFACE pOsInterface,
1252 uint64_t hybridMgrSubmitMode)
1253 {
1254 return MosInterface::SetHybridCmdMgrSubmitMode(pOsInterface, hybridMgrSubmitMode);
1255 }
1256
1257 MOS_STATUS MOS_StartHybridCmdMgr(
1258 PMOS_INTERFACE pOsInterface)
1259 {
1260 return MosInterface::StartHybridCmdMgr(pOsInterface);
1261 }
1262
1263 MOS_STATUS MOS_StopHybridCmdMgr(
1264 PMOS_INTERFACE pOsInterface)
1265 {
1266 return MosInterface::StopHybridCmdMgr(pOsInterface);
1267 }
1268
1269 MOS_STATUS MOS_SubmitPackage(
1270 PMOS_INTERFACE pOsInterface,
1271 CmdPackage &cmdPackage)
1272 {
1273 return MosInterface::SubmitPackage(pOsInterface, cmdPackage);
1274 }
1275
1276 #if (_DEBUG || _RELEASE_INTERNAL)
1277 uint8_t Mos_GetVeEngineCount(
1278 MOS_STREAM_HANDLE streamState)
1279 {
1280 return MosInterface::GetVeEngineCount(streamState);
1281 }
1282
1283 uint8_t Mos_GetEngineLogicId(
1284 MOS_STREAM_HANDLE streamState,
1285 uint32_t instanceIdx)
1286 {
1287 return MosInterface::GetEngineLogicId(streamState, instanceIdx);
1288 }
1289
1290 MOS_STATUS MOS_SetGpuVirtualAddress(
1291 PMOS_RESOURCE pResource,
1292 uint64_t address)
1293 {
1294 return MosInterface::SetGpuVirtualAddress(pResource, address);
1295 }
1296
1297 #endif
1298
1299 void *MosStreamState::pvSoloContext = nullptr;
1300