Debian Codegraph @

media_softlet/linux/common/ddi/media_libva_util_next.cpp

raw
1 /*
2 * Copyright (c) 2021-2022, 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 media_libva_util_next.cpp
24 //! \brief libva util next implementaion.
25 //!
26 #include <sys/time.h>
27 #include "inttypes.h"
28 #include "media_libva_util_next.h"
29 #include "media_interfaces_mcpy_next.h"
30 #include "mos_utilities.h"
31 #include "mos_os.h"
32 #include "mos_defs.h"
33 #include "hwinfo_linux.h"
34 #include "ddi_decode_base_specific.h"
35 #include "media_ddi_encode_base.h"
36 //#include "ddi_libva_decoder_specific.h"
37 #include "media_libva_decoder.h"
38 #include "media_libva_encoder.h"
39 #include "memory_policy_manager.h"
40 #include "drm_fourcc.h"
41
42 // will remove when mtl open source
43 #define INTEL_PRELIM_ID_FLAG (1ULL << 55)
44
45 #define intel_prelim_fourcc_mod_code(val) \
46 (fourcc_mod_code(INTEL, (val)) | INTEL_PRELIM_ID_FLAG)
47
48 /* this definition is to avoid duplicate drm_fourcc.h this file is updated seldom */
49 #ifndef I915_FORMAT_MOD_4_TILED_MTL_MC_CCS
50 #define I915_FORMAT_MOD_4_TILED_MTL_MC_CCS fourcc_mod_code(INTEL, 14)
51 #endif
52 #ifndef I915_FORMAT_MOD_4_TILED_MTL_RC_CCS_CC
53 #define I915_FORMAT_MOD_4_TILED_MTL_RC_CCS_CC fourcc_mod_code(INTEL, 15)
54 #endif
55 #ifndef I915_FORMAT_MOD_4_TILED_LNL_CCS
56 #define I915_FORMAT_MOD_4_TILED_LNL_CCS fourcc_mod_code(INTEL, 16)
57 #endif
58 #ifndef I915_FORMAT_MOD_4_TILED_BMG_CCS
59 #define I915_FORMAT_MOD_4_TILED_BMG_CCS fourcc_mod_code(INTEL, 17)
60 #endif
61
62 // default protected surface tag
63 #define PROTECTED_SURFACE_TAG 0x3000f
64
65 int32_t MediaLibvaUtilNext::m_frameCountFps = -1;
66 struct timeval MediaLibvaUtilNext::m_tv1 = {};
67 pthread_mutex_t MediaLibvaUtilNext::m_fpsMutex = PTHREAD_MUTEX_INITIALIZER;
68 int32_t MediaLibvaUtilNext::m_vaFpsSampleSize = 100;
69 bool MediaLibvaUtilNext::m_isMediaFpsPrintFpsEnabled = false;
70
71 VAStatus MediaLibvaUtilNext::SetDefaultTileFormat(
72 DDI_MEDIA_FORMAT format,
73 uint32_t surfaceUsageHint,
74 MEDIA_FEATURE_TABLE *skuTable,
75 MEDIA_SURFACE_ALLOCATE_PARAM &params
76 )
77 {
78 VAStatus status = VA_STATUS_SUCCESS;
79 uint32_t tileFormat = TILING_Y;
80 DDI_FUNC_ENTER;
81 DDI_CHK_NULL(skuTable, "skuTable is nullptr", VA_STATUS_ERROR_INVALID_PARAMETER);
82
83 switch (format)
84 {
85 case Media_Format_X8R8G8B8:
86 case Media_Format_X8B8G8R8:
87 case Media_Format_A8B8G8R8:
88 case Media_Format_R8G8B8A8:
89 case Media_Format_R5G6B5:
90 case Media_Format_R8G8B8:
91 case Media_Format_R10G10B10A2:
92 case Media_Format_B10G10R10A2:
93 case Media_Format_R10G10B10X2:
94 case Media_Format_B10G10R10X2:
95 case Media_Format_A16R16G16B16:
96 case Media_Format_A16B16G16R16:
97 case Media_Format_YV12:
98 case Media_Format_I420:
99 case Media_Format_IYUV:
100 if (VA_SURFACE_ATTRIB_USAGE_HINT_ENCODER != surfaceUsageHint &&
101 !(surfaceUsageHint & VA_SURFACE_ATTRIB_USAGE_HINT_VPP_WRITE))
102 {
103 tileFormat = TILING_NONE;
104 }
105 break;
106 case Media_Format_RGBP:
107 case Media_Format_BGRP:
108 if (VA_SURFACE_ATTRIB_USAGE_HINT_ENCODER != surfaceUsageHint &&
109 !(surfaceUsageHint & VA_SURFACE_ATTRIB_USAGE_HINT_VPP_WRITE))
110 {
111 if(!(surfaceUsageHint & VA_SURFACE_ATTRIB_USAGE_HINT_DECODER))
112 {
113 tileFormat = TILING_NONE;
114 break;
115 }
116 //Planar type surface align 32 to improve performance.
117 params.alignedHeight = MOS_ALIGN_CEIL(params.height, 32);
118 }
119 params.alignedWidth = MOS_ALIGN_CEIL(params.width, 8);
120 if (surfaceUsageHint & VA_SURFACE_ATTRIB_USAGE_HINT_VPP_WRITE)
121 {
122 if (format == Media_Format_RGBP)
123 {
124 //Planar type surface align 32 to improve performance.
125 params.alignedHeight = MOS_ALIGN_CEIL(params.height, 32);
126 }
127 }
128 tileFormat = TILING_Y;
129 break;
130 case Media_Format_A8R8G8B8:
131 if (VA_SURFACE_ATTRIB_USAGE_HINT_ENCODER != surfaceUsageHint &&
132 !(surfaceUsageHint & VA_SURFACE_ATTRIB_USAGE_HINT_DECODER) &&
133 !(surfaceUsageHint & VA_SURFACE_ATTRIB_USAGE_HINT_VPP_WRITE) &&
134 !(MEDIA_IS_SKU(skuTable, FtrRenderCompressionOnly) &&
135 MEDIA_IS_SKU(skuTable, FtrE2ECompression)))
136 {
137 tileFormat = TILING_NONE;
138 }
139 break;
140 case Media_Format_NV12:
141 case Media_Format_NV21:
142 case Media_Format_444P:
143 case Media_Format_422H:
144 case Media_Format_411P:
145 case Media_Format_422V:
146 case Media_Format_IMC3:
147 case Media_Format_400P:
148 case Media_Format_P010:
149 case Media_Format_P012:
150 case Media_Format_P016:
151 case Media_Format_YUY2:
152 case Media_Format_Y210:
153 #if VA_CHECK_VERSION(1, 9, 0)
154 case Media_Format_Y212:
155 #endif
156 case Media_Format_Y216:
157 case Media_Format_AYUV:
158 #if VA_CHECK_VERSION(1, 13, 0)
159 case Media_Format_XYUV:
160 #endif
161 case Media_Format_Y410:
162 #if VA_CHECK_VERSION(1, 9, 0)
163 case Media_Format_Y412:
164 #endif
165 case Media_Format_Y416:
166 case Media_Format_Y8:
167 case Media_Format_Y16S:
168 case Media_Format_Y16U:
169 case Media_Format_VYUY:
170 case Media_Format_YVYU:
171 case Media_Format_UYVY:
172 if (VA_SURFACE_ATTRIB_USAGE_HINT_ENCODER != surfaceUsageHint &&
173 !(surfaceUsageHint & VA_SURFACE_ATTRIB_USAGE_HINT_VPP_WRITE))
174 {
175 //Planar type surface align 32 to improve performance.
176 params.alignedHeight = MOS_ALIGN_CEIL(params.height, 32);
177 }
178 params.alignedWidth = MOS_ALIGN_CEIL(params.width, 8);
179 if (surfaceUsageHint & VA_SURFACE_ATTRIB_USAGE_HINT_VPP_WRITE)
180 {
181 if ((format == Media_Format_NV12) || (format == Media_Format_P010))
182 {
183 //Planar type surface align 32 to improve performance.
184 params.alignedHeight = MOS_ALIGN_CEIL(params.height, 32);
185 }
186 }
187 tileFormat = TILING_Y;
188 break;
189 case Media_Format_Buffer:
190 tileFormat = TILING_NONE;
191 break;
192 default:
193 tileFormat = TILING_NONE;
194 DDI_ASSERTMESSAGE("Unsupported format");
195 status = VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT;
196 }
197
198 if (VA_SURFACE_ATTRIB_USAGE_HINT_ENCODER & surfaceUsageHint)
199 {
200 params.alignedWidth = MOS_ALIGN_CEIL(params.alignedWidth, 16);
201 params.alignedHeight = MOS_ALIGN_CEIL(params.alignedHeight, 16);
202 }
203 params.tileFormat = tileFormat;
204 return status;
205 }
206
207 void MediaLibvaUtilNext::InitSurfaceAllocateParams(
208 MEDIA_SURFACE_ALLOCATE_PARAM &params,
209 int32_t width,
210 int32_t height,
211 DDI_MEDIA_FORMAT format,
212 int memType,
213 uint32_t surfaceUsageHint)
214 {
215 DDI_FUNC_ENTER;
216 params.pitch = 0;
217 params.tileFormat = TILING_NONE;
218 params.alignedWidth = params.width = width;
219 params.alignedHeight = params.height = height;
220 params.format = format;
221 params.cpTag = 0;
222 params.memType = memType;
223
224 params.bMemCompEnable = true;
225
226 params.bMemCompRC = false;
227 return;
228 }
229
230 VAStatus MediaLibvaUtilNext::SetSurfaceParameterFromModifier(
231 MEDIA_SURFACE_ALLOCATE_PARAM &params,
232 uint64_t modifier)
233 {
234 DDI_FUNC_ENTER;
235 switch (modifier)
236 {
237 case I915_FORMAT_MOD_4_TILED:
238 params.tileFormat = TILING_Y;
239 params.bMemCompEnable = false;
240 break;
241 case I915_FORMAT_MOD_4_TILED_LNL_CCS:
242 case I915_FORMAT_MOD_4_TILED_BMG_CCS:
243 params.tileFormat = TILING_Y;
244 params.bMemCompEnable = true;
245 break;
246 case I915_FORMAT_MOD_4_TILED_MTL_RC_CCS_CC:
247 params.tileFormat = TILING_Y;
248 params.bMemCompEnable = true;
249 params.bMemCompRC = true;
250 break;
251 case I915_FORMAT_MOD_4_TILED_MTL_MC_CCS:
252 params.tileFormat = TILING_Y;
253 params.bMemCompEnable = true;
254 params.bMemCompRC = false;
255 break;
256 case DRM_FORMAT_MOD_LINEAR:
257 params.tileFormat = TILING_NONE;
258 params.bMemCompEnable = false;
259 break;
260 case I915_FORMAT_MOD_X_TILED:
261 params.tileFormat = TILING_X;
262 params.bMemCompEnable = false;
263 break;
264 case I915_FORMAT_MOD_Y_TILED:
265 case I915_FORMAT_MOD_Yf_TILED:
266 params.tileFormat = TILING_Y;
267 params.bMemCompEnable = false;
268 break;
269 case I915_FORMAT_MOD_Y_TILED_GEN12_RC_CCS:
270 params.tileFormat = TILING_Y;
271 params.bMemCompEnable = true;
272 params.bMemCompRC = true;
273 break;
274 case I915_FORMAT_MOD_Y_TILED_GEN12_MC_CCS:
275 params.tileFormat = TILING_Y;
276 params.bMemCompEnable = true;
277 params.bMemCompRC = false;
278 break;
279 default:
280 DDI_ASSERTMESSAGE("Unsupported modifier.");
281 return VA_STATUS_ERROR_INVALID_PARAMETER;
282 }
283 return VA_STATUS_SUCCESS;
284 }
285
286 VAStatus MediaLibvaUtilNext::GenerateGmmParamsForNoneCompressionExternalSurface(
287 GMM_RESCREATE_CUSTOM_PARAMS &gmmCustomParams,
288 MEDIA_SURFACE_ALLOCATE_PARAM &params,
289 PDDI_MEDIA_SURFACE mediaSurface)
290 {
291 DDI_FUNC_ENTER;
292 DDI_CHK_NULL(mediaSurface, "mediaSurface is nullptr", VA_STATUS_ERROR_INVALID_BUFFER);
293 DDI_CHK_NULL(mediaSurface->pSurfDesc, "mediaSurface desc is nullptr", VA_STATUS_ERROR_INVALID_BUFFER);
294
295 int32_t baseHeight = 0;
296 DDI_CHK_CONDITION(mediaSurface->pSurfDesc->uiPlanes == 0,
297 "Invalid plane number.",
298 VA_STATUS_ERROR_INVALID_PARAMETER);
299
300 if (mediaSurface->pSurfDesc->uiPlanes == 1)
301 {
302 DDI_CHK_CONDITION(mediaSurface->pSurfDesc->uiSize == 0,
303 "Invalid Size.",
304 VA_STATUS_ERROR_INVALID_PARAMETER);
305 baseHeight = mediaSurface->pSurfDesc->uiSize / params.pitch;
306 }
307 else
308 {
309 DDI_CHK_CONDITION(mediaSurface->pSurfDesc->uiOffsets[1] == 0,
310 "Invalid offset.",
311 VA_STATUS_ERROR_INVALID_PARAMETER);
312 baseHeight = mediaSurface->pSurfDesc->uiOffsets[1] / params.pitch;
313 }
314
315 // Create GmmResourceInfo
316 gmmCustomParams.Type = RESOURCE_2D;
317 gmmCustomParams.Format = ConvertMediaFmtToGmmFmt(params.format);
318 if ((params.format == Media_Format_YV12) || \
319 (params.format == Media_Format_I420) || \
320 (params.format == Media_Format_IYUV) || \
321 (params.format == Media_Format_NV12) || \
322 (params.format == Media_Format_P010) || \
323 (params.format == Media_Format_P012) || \
324 (params.format == Media_Format_P016) || \
325 (params.format == Media_Format_NV21)) {
326 // Align width to 2 for specific planar formats to handle
327 // odd dimensions for external non-compressible surfaces
328 gmmCustomParams.BaseWidth64 = MOS_ALIGN_CEIL(params.width, 2);
329 } else {
330 gmmCustomParams.BaseWidth64 = params.width;
331 }
332 gmmCustomParams.BaseHeight = baseHeight;
333 gmmCustomParams.Pitch = params.pitch;
334 gmmCustomParams.Size = mediaSurface->pSurfDesc->uiSize;
335 gmmCustomParams.BaseAlignment = 4096;
336 gmmCustomParams.NoOfPlanes = mediaSurface->pSurfDesc->uiPlanes;
337 gmmCustomParams.CpTag = params.cpTag;
338 switch (params.tileFormat)
339 {
340 case TILING_Y:
341 gmmCustomParams.Flags.Info.TiledY = true;
342 break;
343 case TILING_X:
344 gmmCustomParams.Flags.Info.TiledX = true;
345 break;
346 case TILING_NONE:
347 default:
348 gmmCustomParams.Flags.Info.Linear = true;
349 }
350
351
352 // Init NotCompressed flag as true to default Create as uncompressed surface on Xe2 Compression.
353 gmmCustomParams.Flags.Info.NotCompressed = 1;
354
355 switch (mediaSurface->pSurfDesc->uiPlanes)
356 {
357 case 1:
358 gmmCustomParams.PlaneOffset.X[GMM_PLANE_Y] = 0;
359 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_Y] = mediaSurface->pSurfDesc->uiOffsets[0] / params.pitch;
360 break;
361 case 2:
362 gmmCustomParams.PlaneOffset.X[GMM_PLANE_Y] = 0;
363 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_Y] = mediaSurface->pSurfDesc->uiOffsets[0] / params.pitch;
364 gmmCustomParams.PlaneOffset.X[GMM_PLANE_U] = 0;
365 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_U] = mediaSurface->pSurfDesc->uiOffsets[1] / params.pitch;
366 gmmCustomParams.PlaneOffset.X[GMM_PLANE_V] = 0;
367 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_V] = mediaSurface->pSurfDesc->uiOffsets[1] / params.pitch;
368 break;
369 case 3:
370 if (mediaSurface->format == Media_Format_YV12)
371 {
372 gmmCustomParams.PlaneOffset.X[GMM_PLANE_Y] = 0;
373 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_Y] = mediaSurface->pSurfDesc->uiOffsets[0] / params.pitch;
374 gmmCustomParams.PlaneOffset.X[GMM_PLANE_U] = 0;
375 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_U] = mediaSurface->pSurfDesc->uiOffsets[2] / params.pitch;
376 gmmCustomParams.PlaneOffset.X[GMM_PLANE_V] = 0;
377 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_V] = mediaSurface->pSurfDesc->uiOffsets[1] / params.pitch;
378 }
379 else
380 {
381 gmmCustomParams.PlaneOffset.X[GMM_PLANE_Y] = 0;
382 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_Y] = mediaSurface->pSurfDesc->uiOffsets[0] / params.pitch;
383 gmmCustomParams.PlaneOffset.X[GMM_PLANE_U] = 0;
384 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_U] = mediaSurface->pSurfDesc->uiOffsets[1] / params.pitch;
385 gmmCustomParams.PlaneOffset.X[GMM_PLANE_V] = 0;
386 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_V] = mediaSurface->pSurfDesc->uiOffsets[2] / params.pitch;
387 }
388 break;
389 default:
390 DDI_ASSERTMESSAGE("Invalid plane number.");
391 return VA_STATUS_ERROR_ALLOCATION_FAILED;
392 }
393
394 return VA_STATUS_SUCCESS;
395 }
396
397 VAStatus MediaLibvaUtilNext::GenerateGmmParamsForCompressionExternalSurface(
398 GMM_RESCREATE_CUSTOM_PARAMS_2 &gmmCustomParams,
399 MEDIA_SURFACE_ALLOCATE_PARAM &params,
400 PDDI_MEDIA_SURFACE mediaSurface,
401 PDDI_MEDIA_CONTEXT mediaDrvCtx)
402 {
403 DDI_FUNC_ENTER;
404 DDI_CHK_NULL(mediaSurface, "mediaSurface is nullptr", VA_STATUS_ERROR_INVALID_BUFFER);
405 DDI_CHK_NULL(mediaSurface->pSurfDesc, "mediaSurface desc is nullptr", VA_STATUS_ERROR_INVALID_BUFFER);
406 DDI_CHK_NULL(mediaDrvCtx, "media context is nullptr", VA_STATUS_ERROR_INVALID_CONTEXT);
407 // Create GmmResourceInfo
408 gmmCustomParams.Type = RESOURCE_2D;
409 gmmCustomParams.Format = ConvertMediaFmtToGmmFmt(params.format);
410 if ((params.format == Media_Format_YV12) || \
411 (params.format == Media_Format_I420) || \
412 (params.format == Media_Format_IYUV) || \
413 (params.format == Media_Format_NV12) || \
414 (params.format == Media_Format_NV21)) {
415 // Align width to 2 for specific planar formats to handle
416 // odd dimensions for external non-compressible surfaces
417 gmmCustomParams.BaseWidth64 = MOS_ALIGN_CEIL(params.alignedWidth, 2);
418 } else {
419 gmmCustomParams.BaseWidth64 = params.alignedWidth;
420 }
421 gmmCustomParams.BaseHeight = params.alignedHeight;
422 gmmCustomParams.Pitch = params.pitch;
423 gmmCustomParams.Size = mediaSurface->pSurfDesc->uiSize;
424 gmmCustomParams.BaseAlignment = 4096;
425 gmmCustomParams.NoOfPlanes = mediaSurface->pSurfDesc->uiPlanes;
426 gmmCustomParams.CpTag = params.cpTag;
427
428 if (MEDIA_IS_SKU(&mediaDrvCtx->SkuTable, FtrXe2Compression))
429 {
430 // Init NotCompressed flag as false to default Create as compressed surface w/ Xe2 Compression.
431 gmmCustomParams.Flags.Info.NotCompressed = 0;
432 }
433
434 switch (params.tileFormat)
435 {
436 case TILING_Y:
437 gmmCustomParams.Flags.Info.TiledY = true;
438 gmmCustomParams.Flags.Gpu.MMC = false;
439 if (MEDIA_IS_SKU(&mediaDrvCtx->SkuTable, FtrE2ECompression) &&
440 (!MEDIA_IS_WA(&mediaDrvCtx->WaTable, WaDisableVPMmc) &&
441 !MEDIA_IS_WA(&mediaDrvCtx->WaTable, WaDisableCodecMmc)) &&
442 params.bMemCompEnable)
443 {
444 gmmCustomParams.Flags.Gpu.MMC = true;
445 gmmCustomParams.Flags.Info.MediaCompressed = 1;
446 gmmCustomParams.Flags.Info.RenderCompressed = 0;
447 gmmCustomParams.Flags.Gpu.CCS = 1;
448 gmmCustomParams.Flags.Gpu.RenderTarget = 1;
449 gmmCustomParams.Flags.Gpu.UnifiedAuxSurface = 1;
450
451 if (params.bMemCompRC)
452 {
453 gmmCustomParams.Flags.Info.MediaCompressed = 0;
454 gmmCustomParams.Flags.Info.RenderCompressed = 1;
455 }
456
457 if(MEDIA_IS_SKU(&mediaDrvCtx->SkuTable, FtrRenderCompressionOnly))
458 {
459 gmmCustomParams.Flags.Info.MediaCompressed = 0;
460
461 if (params.format == Media_Format_X8R8G8B8 ||
462 params.format == Media_Format_X8B8G8R8 ||
463 params.format == Media_Format_A8B8G8R8 ||
464 params.format == Media_Format_A8R8G8B8 ||
465 params.format == Media_Format_R8G8B8A8)
466 {
467 gmmCustomParams.Flags.Info.MediaCompressed = 0;
468 gmmCustomParams.Flags.Info.RenderCompressed = 1;
469 }
470 }
471
472 if(MEDIA_IS_SKU(&mediaDrvCtx->SkuTable, FtrFlatPhysCCS))
473 {
474 gmmCustomParams.Flags.Gpu.UnifiedAuxSurface = 0;
475 }
476 }
477 break;
478 case TILING_X:
479 gmmCustomParams.Flags.Info.TiledX = true;
480 break;
481 case TILING_NONE:
482 default:
483 gmmCustomParams.Flags.Info.Linear = true;
484 }
485
486 if(MEDIA_IS_SKU(&mediaDrvCtx->SkuTable, FtrFlatPhysCCS))
487 {
488 switch (mediaSurface->pSurfDesc->uiPlanes)
489 {
490 case 1:
491 gmmCustomParams.PlaneOffset.X[GMM_PLANE_Y] = 0;
492 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_Y] = mediaSurface->pSurfDesc->uiOffsets[0] / params.pitch;
493 break;
494 case 2:
495 gmmCustomParams.PlaneOffset.X[GMM_PLANE_Y] = 0;
496 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_Y] = mediaSurface->pSurfDesc->uiOffsets[0] / params.pitch;
497 gmmCustomParams.PlaneOffset.X[GMM_PLANE_U] = 0;
498 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_U] = mediaSurface->pSurfDesc->uiOffsets[1] / params.pitch;
499 gmmCustomParams.PlaneOffset.X[GMM_PLANE_V] = 0;
500 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_V] = mediaSurface->pSurfDesc->uiOffsets[1] / params.pitch;
501 break;
502 case 3:
503 if (mediaSurface->format == Media_Format_YV12)
504 {
505 gmmCustomParams.PlaneOffset.X[GMM_PLANE_Y] = 0;
506 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_Y] = mediaSurface->pSurfDesc->uiOffsets[0] / params.pitch;
507 gmmCustomParams.PlaneOffset.X[GMM_PLANE_U] = 0;
508 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_U] = mediaSurface->pSurfDesc->uiOffsets[2] / params.pitch;
509 gmmCustomParams.PlaneOffset.X[GMM_PLANE_V] = 0;
510 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_V] = mediaSurface->pSurfDesc->uiOffsets[1] / params.pitch;
511 }
512 else
513 {
514 gmmCustomParams.PlaneOffset.X[GMM_PLANE_Y] = 0;
515 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_Y] = mediaSurface->pSurfDesc->uiOffsets[0] / params.pitch;
516 gmmCustomParams.PlaneOffset.X[GMM_PLANE_U] = 0;
517 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_U] = mediaSurface->pSurfDesc->uiOffsets[1] / params.pitch;
518 gmmCustomParams.PlaneOffset.X[GMM_PLANE_V] = 0;
519 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_V] = mediaSurface->pSurfDesc->uiOffsets[2] / params.pitch;
520 }
521 break;
522 default:
523 DDI_ASSERTMESSAGE("Invalid plane number.");
524 return VA_STATUS_ERROR_ALLOCATION_FAILED;
525 }
526 }
527 else
528 {
529 // build Aux SW map for platfroms w/o physical map
530 gmmCustomParams.AuxSurf.BaseAlignment = {0};
531 gmmCustomParams.NoOfPlanes = mediaSurface->pSurfDesc->uiPlanes/2;
532 gmmCustomParams.Size = (gmmCustomParams.NoOfPlanes == 1) ? mediaSurface->pSurfDesc->uiOffsets[1]:mediaSurface->pSurfDesc->uiOffsets[2];
533 switch(gmmCustomParams.NoOfPlanes)
534 {
535 case 1:
536 gmmCustomParams.PlaneOffset.X[GMM_PLANE_Y] = 0;
537 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_Y] = mediaSurface->pSurfDesc->uiOffsets[0] / params.pitch;
538 gmmCustomParams.AuxSurf.Size = mediaSurface->pSurfDesc->uiSize - gmmCustomParams.Size;
539 gmmCustomParams.AuxSurf.Pitch = mediaSurface->pSurfDesc->uiPitches[1];
540 gmmCustomParams.AuxSurf.PlaneOffset.X[GMM_PLANE_Y] = 0;
541 gmmCustomParams.AuxSurf.PlaneOffset.Y[GMM_PLANE_Y] = 0;
542 break;
543 case 2:
544 gmmCustomParams.PlaneOffset.X[GMM_PLANE_Y] = 0;
545 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_Y] = mediaSurface->pSurfDesc->uiOffsets[0] / params.pitch;
546 gmmCustomParams.PlaneOffset.X[GMM_PLANE_U] = 0;
547 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_U] = mediaSurface->pSurfDesc->uiOffsets[1] / params.pitch;
548 gmmCustomParams.PlaneOffset.X[GMM_PLANE_V] = 0;
549 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_V] = mediaSurface->pSurfDesc->uiOffsets[1] / params.pitch;
550 gmmCustomParams.AuxSurf.Size = (mediaSurface->pSurfDesc->uiOffsets[3] - mediaSurface->pSurfDesc->uiOffsets[2]) * 2;
551 gmmCustomParams.AuxSurf.Pitch = mediaSurface->pSurfDesc->uiPitches[2];
552 gmmCustomParams.AuxSurf.PlaneOffset.X[GMM_PLANE_Y] = 0;
553 gmmCustomParams.AuxSurf.PlaneOffset.Y[GMM_PLANE_Y] = 0;
554 gmmCustomParams.AuxSurf.PlaneOffset.X[GMM_PLANE_U] = (mediaSurface->pSurfDesc->uiOffsets[3]
555 - mediaSurface->pSurfDesc->uiOffsets[2]);
556 gmmCustomParams.AuxSurf.PlaneOffset.Y[GMM_PLANE_U] = 0;
557 gmmCustomParams.AuxSurf.PlaneOffset.X[GMM_PLANE_V] = (mediaSurface->pSurfDesc->uiOffsets[3]
558 - mediaSurface->pSurfDesc->uiOffsets[2]);
559 gmmCustomParams.AuxSurf.PlaneOffset.Y[GMM_PLANE_V] = 0;
560 break;
561 case 3:
562 if (mediaSurface->format == Media_Format_YV12)
563 {
564 gmmCustomParams.PlaneOffset.X[GMM_PLANE_Y] = 0;
565 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_Y] = mediaSurface->pSurfDesc->uiOffsets[0] / params.pitch;
566 gmmCustomParams.PlaneOffset.X[GMM_PLANE_U] = 0;
567 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_U] = mediaSurface->pSurfDesc->uiOffsets[2] / params.pitch;
568 gmmCustomParams.PlaneOffset.X[GMM_PLANE_V] = 0;
569 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_V] = mediaSurface->pSurfDesc->uiOffsets[1] / params.pitch;
570 }
571 else
572 {
573 gmmCustomParams.PlaneOffset.X[GMM_PLANE_Y] = 0;
574 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_Y] = mediaSurface->pSurfDesc->uiOffsets[0] / params.pitch;
575 gmmCustomParams.PlaneOffset.X[GMM_PLANE_U] = 0;
576 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_U] = mediaSurface->pSurfDesc->uiOffsets[1] / params.pitch;
577 gmmCustomParams.PlaneOffset.X[GMM_PLANE_V] = 0;
578 gmmCustomParams.PlaneOffset.Y[GMM_PLANE_V] = mediaSurface->pSurfDesc->uiOffsets[2] / params.pitch;
579 }
580 break;
581 default:
582 DDI_ASSERTMESSAGE("Invalid plane number.");
583 return VA_STATUS_ERROR_ALLOCATION_FAILED;
584 }
585 }
586
587 return VA_STATUS_SUCCESS;
588 }
589
590 VAStatus MediaLibvaUtilNext::CreateExternalSurface(
591 MEDIA_SURFACE_ALLOCATE_PARAM &params,
592 PDDI_MEDIA_SURFACE mediaSurface,
593 PDDI_MEDIA_CONTEXT mediaDrvCtx)
594 {
595 DDI_FUNC_ENTER;
596 DDI_CHK_NULL(mediaSurface, "mediaSurface is nullptr", VA_STATUS_ERROR_INVALID_BUFFER);
597 DDI_CHK_NULL(mediaSurface->pSurfDesc, "mediaSurface desc is nullptr", VA_STATUS_ERROR_INVALID_BUFFER);
598 DDI_CHK_NULL(mediaDrvCtx, "media context is nullptr", VA_STATUS_ERROR_INVALID_CONTEXT);
599 DDI_CHK_NULL(mediaDrvCtx->pDrmBufMgr, "drm buffer mgr is nullptr", VA_STATUS_ERROR_INVALID_BUFFER);
600 DDI_CHK_NULL(mediaDrvCtx->pGmmClientContext, "gmm context is nullptr", VA_STATUS_ERROR_INVALID_CONTEXT);
601
602 GMM_RESOURCE_INFO *gmmResourceInfo = nullptr;
603 MOS_LINUX_BO *bo = nullptr;
604 uint32_t swizzle_mode;
605 unsigned int patIndex = PAT_INDEX_INVALID;
606 VAStatus status = VA_STATUS_SUCCESS;
607
608 // Default set as compression not supported, surface compression import only support from Memory Type VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2 or VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_3
609 params.bMemCompEnable = false;
610 params.bMemCompRC = false;
611 params.pitch = mediaSurface->pSurfDesc->uiPitches[0];
612 DDI_CHK_CONDITION(params.pitch == 0, "Invalid pich.", VA_STATUS_ERROR_INVALID_PARAMETER);
613
614 // Set cp flag to indicate the secure surface
615 if (mediaSurface->pSurfDesc->uiFlags & VA_SURFACE_EXTBUF_DESC_PROTECTED)
616 {
617 params.cpTag = PROTECTED_SURFACE_TAG;
618 }
619
620 switch(mediaSurface->pSurfDesc->uiVaMemType)
621 {
622 case VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM:
623 case VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME:
624 params.tileFormat = mediaSurface->pSurfDesc->uiFlags & VA_SURFACE_EXTBUF_DESC_ENABLE_TILING ? TILING_Y : TILING_NONE;
625 break;
626 case VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2:
627 params.pitch = mediaSurface->pSurfDesc->uiPitches[0];
628 status = SetSurfaceParameterFromModifier(params, mediaSurface->pSurfDesc->modifier);
629 if(status != VA_STATUS_SUCCESS)
630 {
631 DDI_ASSERTMESSAGE("Set surface from modifier failed.");
632 return status;
633 }
634 break;
635 #if VA_CHECK_VERSION(1, 21, 0)
636 case VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_3:
637 params.pitch = mediaSurface->pSurfDesc->uiPitches[0];
638 status = SetSurfaceParameterFromModifier(params, mediaSurface->pSurfDesc->modifier);
639 if(status != VA_STATUS_SUCCESS)
640 {
641 DDI_ASSERTMESSAGE("Set surface from modifier failed.");
642 return status;
643 }
644 break;
645 #endif
646 case VA_SURFACE_ATTRIB_MEM_TYPE_USER_PTR:
647 params.tileFormat = TILE_NONE;
648 break;
649 }
650
651
652 GMM_RESCREATE_CUSTOM_PARAMS_2 gmmCustomParams;
653 MOS_ZeroMemory(&gmmCustomParams, sizeof(gmmCustomParams));
654 gmmCustomParams.Usage = GMM_RESOURCE_USAGE_STAGING;
655 if ((VA_SURFACE_EXTBUF_DESC_UNCACHED & mediaSurface->pSurfDesc->uiFlags) || (VA_SURFACE_EXTBUF_DESC_WC & mediaSurface->pSurfDesc->uiFlags))
656 {
657 gmmCustomParams.Usage = GMM_RESOURCE_USAGE_UNKNOWN;
658 }
659 if (VA_SURFACE_ATTRIB_MEM_TYPE_USER_PTR == mediaSurface->pSurfDesc->uiVaMemType)
660 {
661 gmmCustomParams.Usage = GMM_RESOURCE_USAGE_STAGING; //temp WA for some application wrongly use flags for user ptr
662 gmmCustomParams.Type = RESOURCE_1D;
663 }
664
665 if (params.bMemCompEnable)
666 {
667 status = GenerateGmmParamsForCompressionExternalSurface(gmmCustomParams, params, mediaSurface, mediaDrvCtx);
668 if(status != VA_STATUS_SUCCESS)
669 {
670 DDI_ASSERTMESSAGE("Generate gmmParams for compression external surface failed.");
671 return status;
672 }
673
674 gmmResourceInfo = mediaDrvCtx->pGmmClientContext->CreateCustomResInfoObject_2(&gmmCustomParams);
675 }
676 else
677 {
678 status = GenerateGmmParamsForNoneCompressionExternalSurface(gmmCustomParams, params, mediaSurface);
679 if(status != VA_STATUS_SUCCESS)
680 {
681 DDI_ASSERTMESSAGE("Generate gmmParams for none compression external surface failed.");
682 return status;
683 }
684
685 gmmResourceInfo = mediaDrvCtx->pGmmClientContext->CreateCustomResInfoObject(&gmmCustomParams);
686 }
687
688 DDI_CHK_NULL(gmmResourceInfo, "Gmm create resource failed", VA_STATUS_ERROR_ALLOCATION_FAILED);
689
690 patIndex = MosInterface::GetPATIndexFromGmm(mediaDrvCtx->pGmmClientContext, gmmResourceInfo);
691
692 // DRM buffer allocated by Application, No need to re-allocate new DRM buffer
693 switch (mediaSurface->pSurfDesc->uiVaMemType)
694 {
695 case VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM:
696 bo = mos_bo_create_from_name(mediaDrvCtx->pDrmBufMgr, "MEDIA", mediaSurface->pSurfDesc->ulBuffer);
697 break;
698 case VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME:
699 case VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2:
700 #if VA_CHECK_VERSION(1, 21, 0)
701 case VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_3:
702 #endif
703 {
704 struct mos_drm_bo_alloc_prime alloc_prime;
705 alloc_prime.name = "prime";
706 alloc_prime.prime_fd = mediaSurface->pSurfDesc->ulBuffer;
707 alloc_prime.size = mediaSurface->pSurfDesc->uiSize;
708 alloc_prime.pat_index = patIndex;
709
710 bo = mos_bo_create_from_prime(mediaDrvCtx->pDrmBufMgr, &alloc_prime);
711 }
712 break;
713 case VA_SURFACE_ATTRIB_MEM_TYPE_USER_PTR:
714 {
715 struct mos_drm_bo_alloc_userptr alloc_uptr;
716 alloc_uptr.name = "SysSurface";
717 alloc_uptr.addr = (void *)mediaSurface->pSurfDesc->ulBuffer;
718 alloc_uptr.tiling_mode = mediaSurface->pSurfDesc->uiTile;
719 alloc_uptr.stride = params.pitch;
720 alloc_uptr.size = mediaSurface->pSurfDesc->uiBuffserSize;
721 alloc_uptr.pat_index = patIndex;
722
723 bo = mos_bo_alloc_userptr(mediaDrvCtx->pDrmBufMgr, &alloc_uptr);
724 }
725 break;
726 }
727
728 if (nullptr == bo)
729 {
730 DDI_ASSERTMESSAGE("Failed to create drm buffer object according to input buffer descriptor.");
731 mediaDrvCtx->pGmmClientContext->DestroyResInfoObject(gmmResourceInfo);
732 return VA_STATUS_ERROR_ALLOCATION_FAILED;
733 }
734
735 mediaSurface->pGmmResourceInfo = gmmResourceInfo;
736 mediaSurface->bMapped = false;
737 mediaSurface->format = params.format;
738 mediaSurface->iWidth = params.width;
739 mediaSurface->iHeight = gmmResourceInfo->GetBaseHeight();
740 mediaSurface->iRealHeight = params.height;
741 mediaSurface->iPitch = params.pitch;
742 mediaSurface->iRefCount = 0;
743 mediaSurface->bo = bo;
744 mediaSurface->TileType = params.tileFormat;
745 mediaSurface->isTiled = (params.tileFormat != TILING_NONE) ? 1 : 0;
746 mediaSurface->pData = (uint8_t*) bo->virt;
747 DDI_VERBOSEMESSAGE("Allocate external surface %7d bytes (%d x %d resource).", mediaSurface->pSurfDesc->uiSize, params.width, params.height);
748 uint32_t event[] = {bo->handle, params.format, params.width, params.height, params.pitch, bo->size, params.tileFormat, params.cpTag};
749 MOS_TraceEventExt(EVENT_VA_SURFACE, EVENT_TYPE_INFO, event, sizeof(event), &gmmResourceInfo->GetResFlags(), sizeof(GMM_RESOURCE_FLAG));
750
751 return VA_STATUS_SUCCESS;
752 }
753
754 VAStatus MediaLibvaUtilNext::GenerateGmmParamsForInternalSurface(
755 GMM_RESCREATE_PARAMS &gmmParams,
756 MEDIA_SURFACE_ALLOCATE_PARAM &params,
757 PDDI_MEDIA_CONTEXT mediaDrvCtx)
758 {
759 DDI_FUNC_ENTER;
760 DDI_CHK_NULL(mediaDrvCtx, "media context is nullptr", VA_STATUS_ERROR_INVALID_CONTEXT);
761
762 MosUtilities::MosZeroMemory(&gmmParams, sizeof(gmmParams));
763 gmmParams.BaseWidth = params.alignedWidth;
764 gmmParams.BaseHeight = params.alignedHeight;
765 gmmParams.ArraySize = 1;
766 gmmParams.Type = RESOURCE_2D;
767 gmmParams.Format = ConvertMediaFmtToGmmFmt(params.format);
768
769 DDI_CHK_CONDITION(gmmParams.Format == GMM_FORMAT_INVALID, "Unsupported format", VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT);
770
771 if (MEDIA_IS_SKU(&mediaDrvCtx->SkuTable, FtrXe2Compression))
772 {
773 // Init NotCompressed flag as true to default Create as uncompressed surface on Xe2 Compression.
774 gmmParams.Flags.Info.NotCompressed = 1;
775 }
776
777 switch (params.tileFormat)
778 {
779 case TILING_Y:
780 // Disable MMC for application required surfaces, because some cases' output streams have corruption.
781 gmmParams.Flags.Gpu.MMC = false;
782 if (MEDIA_IS_SKU(&mediaDrvCtx->SkuTable, FtrE2ECompression) &&
783 (!MEDIA_IS_WA(&mediaDrvCtx->WaTable, WaDisableVPMmc) &&
784 !MEDIA_IS_WA(&mediaDrvCtx->WaTable, WaDisableCodecMmc)) &&
785 MEDIA_IS_SKU(&mediaDrvCtx->SkuTable, FtrCompressibleSurfaceDefault) &&
786 params.bMemCompEnable)
787 {
788 gmmParams.Flags.Gpu.MMC = true;
789 gmmParams.Flags.Info.MediaCompressed = 1;
790 gmmParams.Flags.Info.RenderCompressed = 0;
791 gmmParams.Flags.Gpu.CCS = 1;
792 gmmParams.Flags.Gpu.RenderTarget = 1;
793 gmmParams.Flags.Gpu.UnifiedAuxSurface = 1;
794
795 if (params.bMemCompRC)
796 {
797 gmmParams.Flags.Info.MediaCompressed = 0;
798 gmmParams.Flags.Info.RenderCompressed = 1;
799 }
800
801 if(MEDIA_IS_SKU(&mediaDrvCtx->SkuTable, FtrXe2Compression))
802 {
803 gmmParams.Flags.Info.NotCompressed = 0;
804 }
805
806 if (MEDIA_IS_SKU(&mediaDrvCtx->SkuTable, FtrRenderCompressionOnly))
807 {
808 gmmParams.Flags.Info.MediaCompressed = 0;
809
810 if (params.format == Media_Format_X8R8G8B8 ||
811 params.format == Media_Format_X8B8G8R8 ||
812 params.format == Media_Format_A8B8G8R8 ||
813 params.format == Media_Format_A8R8G8B8 ||
814 params.format == Media_Format_R8G8B8A8)
815 {
816 gmmParams.Flags.Info.MediaCompressed = 0;
817 gmmParams.Flags.Info.RenderCompressed = 1;
818 }
819 else
820 {
821 gmmParams.Flags.Gpu.MMC = false;
822 gmmParams.Flags.Info.MediaCompressed = 0;
823 gmmParams.Flags.Info.RenderCompressed = 0;
824 gmmParams.Flags.Gpu.CCS = 0;
825 gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
826 }
827 }
828 }
829 // For ARGB surface, always allocate it as tile4.
830 // This is a WA for ExportSurfaceHandle because modifer for tile64 isn't defined.
831 if ((params.format == Media_Format_A8R8G8B8 ||
832 params.format == Media_Format_B10G10R10A2 ||
833 params.format == Media_Format_A8B8G8R8 ||
834 params.format == Media_Format_X8R8G8B8) && !MEDIA_IS_SKU(&mediaDrvCtx->SkuTable, FtrTileY))
835 {
836 gmmParams.Flags.Info.Tile4 = true;
837 }
838 break;
839 case TILING_X:
840 gmmParams.Flags.Info.TiledX = true;
841 break;
842 default:
843 gmmParams.Flags.Info.Linear = true;
844 }
845 gmmParams.Flags.Gpu.Video = true;
846 gmmParams.Flags.Info.LocalOnly = MEDIA_IS_SKU(&mediaDrvCtx->SkuTable, FtrLocalMemory);
847
848 return VA_STATUS_SUCCESS;
849 }
850
851 VAStatus MediaLibvaUtilNext::CreateInternalSurface(
852 MEDIA_SURFACE_ALLOCATE_PARAM &params,
853 PDDI_MEDIA_SURFACE mediaSurface,
854 PDDI_MEDIA_CONTEXT mediaDrvCtx)
855 {
856 DDI_FUNC_ENTER;
857 DDI_CHK_NULL(mediaSurface, "mediaSurface is nullptr", VA_STATUS_ERROR_INVALID_BUFFER);
858 DDI_CHK_NULL(mediaDrvCtx, "media context is nullptr", VA_STATUS_ERROR_INVALID_CONTEXT);
859 DDI_CHK_NULL(mediaDrvCtx->pGmmClientContext, "gmm context is nullptr", VA_STATUS_ERROR_INVALID_CONTEXT);
860
861 VAStatus status = VA_STATUS_SUCCESS;
862 MOS_LINUX_BO *bo = nullptr;
863 GMM_RESCREATE_PARAMS gmmParams = {};
864 GMM_RESOURCE_INFO *gmmResourceInfo = nullptr;
865 if (mediaSurface->pSurfDesc)
866 {
867 if (mediaSurface->pSurfDesc->uiFlags & VA_SURFACE_EXTBUF_DESC_ENABLE_TILING )
868 {
869 params.tileFormat = TILING_Y;
870 }
871 else if (mediaSurface->pSurfDesc->uiVaMemType == VA_SURFACE_ATTRIB_MEM_TYPE_VA)
872 {
873 params.tileFormat = TILING_NONE;
874 params.alignedHeight = params.height;
875 }
876 }
877
878 status = GenerateGmmParamsForInternalSurface(gmmParams, params, mediaDrvCtx);
879 if(status != VA_STATUS_SUCCESS)
880 {
881 DDI_ASSERTMESSAGE("Generate gmmParams for internal surface failed.");
882 return status;
883 }
884
885 mediaSurface->pGmmResourceInfo = gmmResourceInfo = mediaDrvCtx->pGmmClientContext->CreateResInfoObject(&gmmParams);
886 DDI_CHK_NULL(gmmResourceInfo, "Gmm create resource failed", VA_STATUS_ERROR_ALLOCATION_FAILED);
887
888 uint32_t gmmPitch = (uint32_t)gmmResourceInfo->GetRenderPitch();
889 uint32_t gmmSize = (uint32_t)gmmResourceInfo->GetSizeSurface();
890 uint32_t gmmHeight = gmmResourceInfo->GetBaseHeight();
891
892 if (0 == gmmPitch || 0 == gmmSize || 0 == gmmHeight)
893 {
894 DDI_ASSERTMESSAGE("Gmm Create Resource Failed.");
895 return VA_STATUS_ERROR_ALLOCATION_FAILED;
896 }
897
898 switch (gmmResourceInfo->GetTileType())
899 {
900 case GMM_TILED_Y:
901 params.tileFormat = TILING_Y;
902 break;
903 case GMM_TILED_X:
904 params.tileFormat = TILING_X;
905 break;
906 case GMM_NOT_TILED:
907 params.tileFormat = TILING_NONE;
908 break;
909 default:
910 params.tileFormat = TILING_Y;
911 break;
912 }
913
914 MemoryPolicyParameter memPolicyPar;
915 MosUtilities::MosZeroMemory(&memPolicyPar, sizeof(MemoryPolicyParameter));
916
917 memPolicyPar.skuTable = &mediaDrvCtx->SkuTable;
918 memPolicyPar.waTable = &mediaDrvCtx->WaTable;
919 memPolicyPar.resInfo = mediaSurface->pGmmResourceInfo;
920 memPolicyPar.resName = "Media Surface";
921 memPolicyPar.preferredMemType = (MEDIA_IS_WA(&mediaDrvCtx->WaTable, WaForceAllocateLML4)) ? MOS_MEMPOOL_DEVICEMEMORY : params.memType;
922
923 params.memType = MemoryPolicyManager::UpdateMemoryPolicy(&memPolicyPar);
924
925 unsigned int patIndex = MosInterface::GetPATIndexFromGmm(mediaDrvCtx->pGmmClientContext, gmmResourceInfo);
926 bool isCpuCacheable = gmmResourceInfo->GetResFlags().Info.Cacheable;
927
928 //This is wa for tile4 + compressed + scanout surface(!isCpuCacheable)
929 bool is64kPageAlignmentNeed =
930 MEDIA_IS_WA(&mediaDrvCtx->WaTable, WaTile4CompressScanoutSurf64KNeed)
931 && gmmResourceInfo->GetResFlags().Info.Tile4
932 && (gmmResourceInfo->GetResFlags().Info.MediaCompressed || gmmResourceInfo->GetResFlags().Info.RenderCompressed)
933 && !isCpuCacheable;
934
935 if ( params.tileFormat == TILING_NONE )
936 {
937 struct mos_drm_bo_alloc alloc;
938 alloc.name = "Media";
939 alloc.size = gmmSize;
940 alloc.alignment = is64kPageAlignmentNeed ? PAGE_SIZE_64K : PAGE_SIZE_4K;
941 alloc.ext.tiling_mode = TILING_NONE;
942 alloc.ext.mem_type = params.memType;
943 alloc.ext.pat_index = patIndex;
944 alloc.ext.cpu_cacheable = isCpuCacheable;
945 alloc.ext.scanout_surf = !isCpuCacheable;
946 bo = mos_bo_alloc(mediaDrvCtx->pDrmBufMgr, &alloc);
947 params.pitch = gmmPitch;
948 }
949 else
950 {
951 struct mos_drm_bo_alloc_tiled alloc_tiled;
952 alloc_tiled.name = "MEDIA";
953 alloc_tiled.x = gmmPitch;
954 alloc_tiled.y = (gmmSize + gmmPitch -1)/gmmPitch;
955 alloc_tiled.cpp = 1;
956 alloc_tiled.alignment = is64kPageAlignmentNeed ? PAGE_SIZE_64K : PAGE_SIZE_4K;
957 alloc_tiled.ext.tiling_mode = params.tileFormat;
958 alloc_tiled.ext.mem_type = params.memType;;
959 alloc_tiled.ext.pat_index = patIndex;
960 alloc_tiled.ext.cpu_cacheable = isCpuCacheable;
961 alloc_tiled.ext.scanout_surf = !isCpuCacheable;
962
963 bo = mos_bo_alloc_tiled(mediaDrvCtx->pDrmBufMgr, &alloc_tiled);
964 params.pitch = alloc_tiled.pitch;
965 }
966
967 mediaSurface->bMapped = false;
968 DDI_CHK_NULL(bo, "Failed to create drm buffer object according to input buffer descriptor." ,VA_STATUS_ERROR_ALLOCATION_FAILED);
969
970 mediaSurface->format = params.format;
971 mediaSurface->iWidth = params.width;
972 mediaSurface->iHeight = gmmHeight;
973 mediaSurface->iRealHeight = params.height;
974 mediaSurface->iPitch = params.pitch;
975 mediaSurface->iRefCount = 0;
976 mediaSurface->bo = bo;
977 mediaSurface->TileType = params.tileFormat;
978 mediaSurface->isTiled = (params.tileFormat != TILING_NONE) ? 1 : 0;
979 mediaSurface->pData = (uint8_t*) bo->virt;
980 DDI_VERBOSEMESSAGE("Alloc %7d bytes (%d x %d resource, gmmTiledType %d)).",gmmSize, params.width, params.height, gmmResourceInfo->GetTileType());
981 uint32_t event[] = {bo->handle, params.format, params.width, params.height, params.pitch, bo->size, params.tileFormat, params.cpTag};
982 MOS_TraceEventExt(EVENT_VA_SURFACE, EVENT_TYPE_INFO, event, sizeof(event), &gmmResourceInfo->GetResFlags(), sizeof(GMM_RESOURCE_FLAG));
983
984 return VA_STATUS_SUCCESS;
985 }
986
987 VAStatus MediaLibvaUtilNext::AllocateSurface(
988 DDI_MEDIA_FORMAT format,
989 int32_t width,
990 int32_t height,
991 PDDI_MEDIA_SURFACE mediaSurface,
992 PDDI_MEDIA_CONTEXT mediaDrvCtx)
993 {
994 VAStatus status = VA_STATUS_SUCCESS;
995 MEDIA_SURFACE_ALLOCATE_PARAM params = {};
996 DDI_FUNC_ENTER;
997 DDI_CHK_NULL(mediaSurface, "mediaSurface is nullptr", VA_STATUS_ERROR_INVALID_BUFFER);
998 DDI_CHK_NULL(mediaDrvCtx, "mediaDrvCtx is nullptr", VA_STATUS_ERROR_INVALID_BUFFER);
999 DDI_CHK_NULL(mediaDrvCtx->pGmmClientContext, "mediaDrvCtx->pGmmClientContext is nullptr", VA_STATUS_ERROR_INVALID_BUFFER);
1000
1001 InitSurfaceAllocateParams(params, width, height, format,
1002 mediaSurface->memType, mediaSurface->surfaceUsageHint);
1003
1004 status = SetDefaultTileFormat(format, mediaSurface->surfaceUsageHint, &mediaDrvCtx->SkuTable, params);
1005 if (status != VA_STATUS_SUCCESS)
1006 {
1007 DDI_ASSERTMESSAGE("Get tile format failed.");
1008 return status;
1009 }
1010
1011 if (IsExternalSurface(mediaSurface))
1012 {
1013 return CreateExternalSurface(params, mediaSurface, mediaDrvCtx);
1014 }
1015 else
1016 {
1017 return CreateInternalSurface(params, mediaSurface, mediaDrvCtx);
1018 }
1019 }
1020
1021 bool MediaLibvaUtilNext::IsExternalSurface(PDDI_MEDIA_SURFACE surface)
1022 {
1023 DDI_FUNC_ENTER;
1024 if (nullptr == surface)
1025 {
1026 return false;
1027 }
1028 else if (surface->pSurfDesc == nullptr)
1029 {
1030 return false;
1031 }
1032 else
1033 {
1034 if (surface->pSurfDesc->uiVaMemType == VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM ||
1035 surface->pSurfDesc->uiVaMemType == VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME ||
1036 surface->pSurfDesc->uiVaMemType == VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2 ||
1037 #if VA_CHECK_VERSION(1, 21, 0)
1038 surface->pSurfDesc->uiVaMemType == VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_3 ||
1039 #endif
1040 surface->pSurfDesc->uiVaMemType == VA_SURFACE_ATTRIB_MEM_TYPE_USER_PTR)
1041 {
1042 return true;
1043 }
1044 else
1045 {
1046 return false;
1047 }
1048 }
1049 }
1050
1051 PDDI_MEDIA_SURFACE_HEAP_ELEMENT MediaLibvaUtilNext::AllocPMediaSurfaceFromHeap(PDDI_MEDIA_HEAP surfaceHeap)
1052 {
1053 PDDI_MEDIA_SURFACE_HEAP_ELEMENT mediaSurfaceHeapElmt = nullptr;
1054 DDI_FUNC_ENTER;
1055 DDI_CHK_NULL(surfaceHeap, "nullptr surfaceHeap", nullptr);
1056
1057 if (nullptr == surfaceHeap->pFirstFreeHeapElement)
1058 {
1059 void *newHeapBase = MOS_ReallocMemory(surfaceHeap->pHeapBase, (surfaceHeap->uiAllocatedHeapElements + DDI_MEDIA_HEAP_INCREMENTAL_SIZE) * sizeof(DDI_MEDIA_SURFACE_HEAP_ELEMENT));
1060
1061 if (nullptr == newHeapBase)
1062 {
1063 DDI_ASSERTMESSAGE("DDI: realloc failed.");
1064 return nullptr;
1065 }
1066 surfaceHeap->pHeapBase = newHeapBase;
1067 PDDI_MEDIA_SURFACE_HEAP_ELEMENT surfaceHeapBase = (PDDI_MEDIA_SURFACE_HEAP_ELEMENT)surfaceHeap->pHeapBase;
1068 surfaceHeap->pFirstFreeHeapElement = (void*)(&surfaceHeapBase[surfaceHeap->uiAllocatedHeapElements]);
1069 for (int32_t i = 0; i < (DDI_MEDIA_HEAP_INCREMENTAL_SIZE); i++)
1070 {
1071 mediaSurfaceHeapElmt = &surfaceHeapBase[surfaceHeap->uiAllocatedHeapElements + i];
1072 mediaSurfaceHeapElmt->pNextFree = (i == (DDI_MEDIA_HEAP_INCREMENTAL_SIZE - 1))? nullptr : &surfaceHeapBase[surfaceHeap->uiAllocatedHeapElements + i + 1];
1073 mediaSurfaceHeapElmt->uiVaSurfaceID = surfaceHeap->uiAllocatedHeapElements + i;
1074 }
1075 surfaceHeap->uiAllocatedHeapElements += DDI_MEDIA_HEAP_INCREMENTAL_SIZE;
1076 }
1077
1078 mediaSurfaceHeapElmt = (PDDI_MEDIA_SURFACE_HEAP_ELEMENT)surfaceHeap->pFirstFreeHeapElement;
1079 surfaceHeap->pFirstFreeHeapElement = mediaSurfaceHeapElmt->pNextFree;
1080
1081 return mediaSurfaceHeapElmt;
1082 }
1083
1084 void MediaLibvaUtilNext::ReleasePMediaSurfaceFromHeap(PDDI_MEDIA_HEAP surfaceHeap, uint32_t vaSurfaceID)
1085 {
1086 DDI_FUNC_ENTER;
1087 DDI_CHK_NULL(surfaceHeap, "nullptr surfaceHeap", );
1088
1089 DDI_CHK_LESS(vaSurfaceID, surfaceHeap->uiAllocatedHeapElements, "invalid surface id", );
1090 PDDI_MEDIA_SURFACE_HEAP_ELEMENT mediaSurfaceHeapBase = (PDDI_MEDIA_SURFACE_HEAP_ELEMENT)surfaceHeap->pHeapBase;
1091 DDI_CHK_NULL(mediaSurfaceHeapBase, "nullptr mediaSurfaceHeapBase", );
1092
1093 PDDI_MEDIA_SURFACE_HEAP_ELEMENT mediaSurfaceHeapElmt = &mediaSurfaceHeapBase[vaSurfaceID];
1094 DDI_CHK_NULL(mediaSurfaceHeapElmt->pSurface, "surface is already released", );
1095 void *firstFree = surfaceHeap->pFirstFreeHeapElement;
1096 surfaceHeap->pFirstFreeHeapElement = (void*)mediaSurfaceHeapElmt;
1097 mediaSurfaceHeapElmt->pNextFree = (PDDI_MEDIA_SURFACE_HEAP_ELEMENT)firstFree;
1098 mediaSurfaceHeapElmt->pSurface = nullptr;
1099 }
1100
1101 VAStatus MediaLibvaUtilNext::CreateSurface(DDI_MEDIA_SURFACE *surface, PDDI_MEDIA_CONTEXT mediaDrvCtx)
1102 {
1103 VAStatus hr = VA_STATUS_SUCCESS;
1104 DDI_FUNC_ENTER;
1105 DDI_CHK_NULL(surface, "nullptr surface", VA_STATUS_ERROR_INVALID_BUFFER);
1106
1107 // better to differentiate 1D and 2D type
1108 hr = AllocateSurface(surface->format,
1109 surface->iWidth,
1110 surface->iHeight,
1111 surface,
1112 mediaDrvCtx);
1113 if (VA_STATUS_SUCCESS == hr && nullptr != surface->bo)
1114 {
1115 surface->base = surface->name;
1116 }
1117
1118 return hr;
1119 }
1120
1121 GMM_RESOURCE_FORMAT MediaLibvaUtilNext::ConvertMediaFmtToGmmFmt(DDI_MEDIA_FORMAT format)
1122 {
1123 DDI_FUNC_ENTER;
1124 switch (format)
1125 {
1126 case Media_Format_X8R8G8B8 : return GMM_FORMAT_B8G8R8X8_UNORM_TYPE;
1127 case Media_Format_A8R8G8B8 : return GMM_FORMAT_B8G8R8A8_UNORM_TYPE;
1128 case Media_Format_X8B8G8R8 : return GMM_FORMAT_R8G8B8X8_UNORM_TYPE;
1129 case Media_Format_A8B8G8R8 : return GMM_FORMAT_R8G8B8A8_UNORM_TYPE;
1130 case Media_Format_R8G8B8A8 : return GMM_FORMAT_R8G8B8A8_UNORM_TYPE;
1131 case Media_Format_R5G6B5 : return GMM_FORMAT_B5G6R5_UNORM_TYPE;
1132 case Media_Format_R8G8B8 : return GMM_FORMAT_R8G8B8_UNORM;
1133 case Media_Format_RGBP : return GMM_FORMAT_RGBP;
1134 case Media_Format_BGRP : return GMM_FORMAT_BGRP;
1135 case Media_Format_NV12 : return GMM_FORMAT_NV12_TYPE;
1136 case Media_Format_NV21 : return GMM_FORMAT_NV21_TYPE;
1137 case Media_Format_YUY2 : return GMM_FORMAT_YUY2;
1138 case Media_Format_YVYU : return GMM_FORMAT_YVYU;
1139 case Media_Format_UYVY : return GMM_FORMAT_UYVY;
1140 case Media_Format_VYUY : return GMM_FORMAT_VYUY;
1141 case Media_Format_YV12 : return GMM_FORMAT_YV12_TYPE;
1142 case Media_Format_IYUV : return GMM_FORMAT_IYUV_TYPE;
1143 case Media_Format_I420 : return GMM_FORMAT_I420_TYPE;
1144 case Media_Format_444P : return GMM_FORMAT_MFX_JPEG_YUV444_TYPE;
1145 case Media_Format_422H : return GMM_FORMAT_MFX_JPEG_YUV422H_TYPE;
1146 case Media_Format_411P : return GMM_FORMAT_MFX_JPEG_YUV411_TYPE;
1147 case Media_Format_422V : return GMM_FORMAT_MFX_JPEG_YUV422V_TYPE;
1148 case Media_Format_IMC3 : return GMM_FORMAT_IMC3_TYPE;
1149 case Media_Format_400P : return GMM_FORMAT_GENERIC_8BIT;
1150 case Media_Format_Buffer : return GMM_FORMAT_RENDER_8BIT;
1151 case Media_Format_P010 : return GMM_FORMAT_P010_TYPE;
1152 case Media_Format_R10G10B10A2: return GMM_FORMAT_R10G10B10A2_UNORM_TYPE;
1153 case Media_Format_B10G10R10A2: return GMM_FORMAT_B10G10R10A2_UNORM_TYPE;
1154 case Media_Format_R10G10B10X2: return GMM_FORMAT_R10G10B10A2_UNORM_TYPE;
1155 case Media_Format_B10G10R10X2: return GMM_FORMAT_B10G10R10A2_UNORM_TYPE;
1156 case Media_Format_P012 : return GMM_FORMAT_P016_TYPE;
1157 case Media_Format_P016 : return GMM_FORMAT_P016_TYPE;
1158 case Media_Format_Y210 : return GMM_FORMAT_Y210_TYPE;
1159 #if VA_CHECK_VERSION(1, 9, 0)
1160 case Media_Format_Y212 : return GMM_FORMAT_Y212_TYPE;
1161 #endif
1162 case Media_Format_Y216 : return GMM_FORMAT_Y216_TYPE;
1163 case Media_Format_AYUV : return GMM_FORMAT_AYUV_TYPE;
1164 #if VA_CHECK_VERSION(1, 13, 0)
1165 case Media_Format_XYUV : return GMM_FORMAT_AYUV_TYPE;
1166 #endif
1167 case Media_Format_Y410 : return GMM_FORMAT_Y410_TYPE;
1168 #if VA_CHECK_VERSION(1, 9, 0)
1169 case Media_Format_Y412 : return GMM_FORMAT_Y412_TYPE;
1170 #endif
1171 case Media_Format_Y416 : return GMM_FORMAT_Y416_TYPE;
1172 case Media_Format_Y8 : return GMM_FORMAT_MEDIA_Y8_UNORM;
1173 case Media_Format_Y16S : return GMM_FORMAT_MEDIA_Y16_SNORM;
1174 case Media_Format_Y16U : return GMM_FORMAT_MEDIA_Y16_UNORM;
1175 case Media_Format_A16R16G16B16: return GMM_FORMAT_B16G16R16A16_UNORM;
1176 case Media_Format_A16B16G16R16: return GMM_FORMAT_R16G16B16A16_UNORM;
1177 default : return GMM_FORMAT_INVALID;
1178 }
1179 }
1180
1181 void MediaLibvaUtilNext::WaitSemaphore(PMEDIA_SEM_T sem)
1182 {
1183 DDI_FUNC_ENTER;
1184 int32_t ret = sem_wait(sem);
1185 if (ret != 0)
1186 {
1187 DDI_NORMALMESSAGE("wait semaphore error!\n");
1188 }
1189 }
1190
1191 int32_t MediaLibvaUtilNext::TryWaitSemaphore(PMEDIA_SEM_T sem)
1192 {
1193 return sem_trywait(sem);
1194 }
1195
1196 void MediaLibvaUtilNext::PostSemaphore(PMEDIA_SEM_T sem)
1197 {
1198 int32_t ret = sem_post(sem);
1199 if (ret != 0)
1200 {
1201 DDI_NORMALMESSAGE("post semaphore error!\n");
1202 }
1203 }
1204
1205 void MediaLibvaUtilNext::DestroySemaphore(PMEDIA_SEM_T sem)
1206 {
1207 int32_t ret = sem_destroy(sem);
1208 if(ret != 0)
1209 {
1210 DDI_NORMALMESSAGE("can't destroy the semaphore!\n");
1211 }
1212 }
1213
1214 VAStatus MediaLibvaUtilNext::UnRegisterRTSurfaces(
1215 VADriverContextP ctx,
1216 PDDI_MEDIA_SURFACE surface)
1217 {
1218 DDI_FUNC_ENTER;
1219 DDI_CHK_NULL(ctx, "nullptr context!", VA_STATUS_ERROR_INVALID_CONTEXT);
1220 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
1221 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx!", VA_STATUS_ERROR_INVALID_CONTEXT);
1222 DDI_CHK_NULL(surface, "nullptr surface!", VA_STATUS_ERROR_INVALID_PARAMETER);
1223
1224 //Look through all decode contexts to unregister the surface in each decode context's RTtable.
1225 if (mediaCtx->pDecoderCtxHeap != nullptr)
1226 {
1227 PDDI_MEDIA_VACONTEXT_HEAP_ELEMENT decVACtxHeapBase = nullptr;
1228
1229 MosUtilities::MosLockMutex(&mediaCtx->DecoderMutex);
1230 decVACtxHeapBase = (PDDI_MEDIA_VACONTEXT_HEAP_ELEMENT)mediaCtx->pDecoderCtxHeap->pHeapBase;
1231 for (uint32_t j = 0; j < mediaCtx->pDecoderCtxHeap->uiAllocatedHeapElements; j++)
1232 {
1233 if (decVACtxHeapBase[j].pVaContext != nullptr)
1234 {
1235 decode::PDDI_DECODE_CONTEXT decCtx = (decode::PDDI_DECODE_CONTEXT)decVACtxHeapBase[j].pVaContext;
1236 if (decCtx && decCtx->m_ddiDecodeNext)
1237 {
1238 //not check the return value since the surface may not be registered in the context. pay attention to LOGW.
1239 decCtx->m_ddiDecodeNext->UnRegisterRTSurfaces(&decCtx->RTtbl, surface);
1240 }
1241 }
1242 }
1243 MosUtilities::MosUnlockMutex(&mediaCtx->DecoderMutex);
1244 }
1245 if (mediaCtx->pEncoderCtxHeap != nullptr)
1246 {
1247 PDDI_MEDIA_VACONTEXT_HEAP_ELEMENT pEncVACtxHeapBase = nullptr;
1248
1249 MosUtilities::MosLockMutex(&mediaCtx->EncoderMutex);
1250 pEncVACtxHeapBase = (PDDI_MEDIA_VACONTEXT_HEAP_ELEMENT)mediaCtx->pEncoderCtxHeap->pHeapBase;
1251 for (uint32_t j = 0; j < mediaCtx->pEncoderCtxHeap->uiAllocatedHeapElements; j++)
1252 {
1253 if (pEncVACtxHeapBase[j].pVaContext != nullptr)
1254 {
1255 PDDI_ENCODE_CONTEXT pEncCtx = (PDDI_ENCODE_CONTEXT)pEncVACtxHeapBase[j].pVaContext;
1256 if (pEncCtx && pEncCtx->m_encode)
1257 {
1258 //not check the return value since the surface may not be registered in the context. pay attention to LOGW.
1259 pEncCtx->m_encode->UnRegisterRTSurfaces(&pEncCtx->RTtbl, surface);
1260 }
1261 }
1262 }
1263 MosUtilities::MosUnlockMutex(&mediaCtx->EncoderMutex);
1264 }
1265
1266 return VA_STATUS_SUCCESS;
1267 }
1268
1269 void MediaLibvaUtilNext::FreeSurface(DDI_MEDIA_SURFACE *surface)
1270 {
1271 DDI_FUNC_ENTER;
1272 DDI_CHK_NULL(surface, "nullptr surface", );
1273 DDI_CHK_NULL(surface->bo, "nullptr surface->bo", );
1274 DDI_CHK_NULL(surface->pMediaCtx, "nullptr surface->pMediaCtx", );
1275 DDI_CHK_NULL(surface->pMediaCtx->pGmmClientContext, "nullptr surface->pMediaCtx->pGmmClientContext", );
1276
1277 // Unmap Aux mapping if the surface was mapped
1278 if (surface->pMediaCtx->m_auxTableMgr)
1279 {
1280 surface->pMediaCtx->m_auxTableMgr->UnmapResource(surface->pGmmResourceInfo, surface->bo);
1281 }
1282
1283 if(surface->bMapped)
1284 {
1285 UnlockSurface(surface);
1286 DDI_VERBOSEMESSAGE("DDI: try to free a locked surface.");
1287 }
1288 mos_bo_unreference(surface->bo);
1289 // For External Buffer, only needs to destory SurfaceDescriptor
1290 if (surface->pSurfDesc)
1291 {
1292 MOS_FreeMemory(surface->pSurfDesc);
1293 surface->pSurfDesc = nullptr;
1294 }
1295
1296 if (nullptr != surface->pGmmResourceInfo)
1297 {
1298 surface->pMediaCtx->pGmmClientContext->DestroyResInfoObject(surface->pGmmResourceInfo);
1299 surface->pGmmResourceInfo = nullptr;
1300 }
1301 }
1302
1303 void MediaLibvaUtilNext::FreeBuffer(DDI_MEDIA_BUFFER *buf)
1304 {
1305 DDI_FUNC_ENTER;
1306 DDI_CHK_NULL(buf, "nullptr", );
1307 // calling sequence checking
1308 if (buf->bMapped)
1309 {
1310 UnlockBuffer(buf);
1311 DDI_VERBOSEMESSAGE("DDI: try to free a locked buffer.");
1312 }
1313 if (buf->format == Media_Format_CPU)
1314 {
1315 MOS_FreeMemory(buf->pData);
1316 buf->pData = nullptr;
1317 }
1318 else
1319 {
1320 mos_bo_unreference(buf->bo);
1321 buf->bo = nullptr;
1322 }
1323
1324 if (nullptr != buf->pMediaCtx && nullptr != buf->pMediaCtx->pGmmClientContext && nullptr != buf->pGmmResourceInfo)
1325 {
1326 buf->pMediaCtx->pGmmClientContext->DestroyResInfoObject(buf->pGmmResourceInfo);
1327 buf->pGmmResourceInfo = nullptr;
1328 }
1329 }
1330
1331 void* MediaLibvaUtilNext::LockSurface(DDI_MEDIA_SURFACE *surface, uint32_t flag)
1332 {
1333 DDI_FUNC_ENTER;
1334 DDI_CHK_NULL(surface, "nullptr surface", nullptr);
1335 DDI_CHK_NULL(surface->pMediaCtx, "nullptr surface->pMediaCtx", nullptr);
1336
1337 if (MEDIA_IS_SKU(&surface->pMediaCtx->SkuTable, FtrLocalMemory))
1338 {
1339 if ((MosUtilities::MosAtomicIncrement(&surface->iRefCount) == 1) && (false == surface->bMapped))
1340 {
1341 return LockSurfaceInternal(surface, flag);
1342 }
1343 else
1344 {
1345 DDI_VERBOSEMESSAGE("line %d, invalide operation for lockSurface. the surface reference count = %d", __LINE__, surface->iRefCount);
1346 }
1347 }
1348 else
1349 {
1350 if ((surface->iRefCount == 0) && (false == surface->bMapped))
1351 {
1352 LockSurfaceInternal(surface, flag);
1353 }
1354 else
1355 {
1356 // do nothing here
1357 }
1358 surface->iRefCount++;
1359 }
1360
1361 return surface->pData;
1362 }
1363
1364 void* MediaLibvaUtilNext::LockSurfaceInternal(DDI_MEDIA_SURFACE *surface, uint32_t flag)
1365 {
1366 int err = 0;
1367 VAStatus vaStatus = VA_STATUS_SUCCESS;
1368 DDI_FUNC_ENTER;
1369
1370 DDI_CHK_NULL(surface, "nullptr surface", nullptr);
1371 DDI_CHK_NULL(surface->bo, "nullptr surface->bo", nullptr);
1372 DDI_CHK_NULL(surface->pMediaCtx, "nullptr surface->pMediaCtx", nullptr);
1373
1374 // non-tield surface
1375 if (surface->TileType == TILING_NONE)
1376 {
1377 mos_bo_map(surface->bo, flag & MOS_LOCKFLAG_WRITEONLY);
1378 surface->pData = (uint8_t*)surface->bo->virt;
1379 surface->data_size = surface->bo->size;
1380 surface->bMapped = true;
1381
1382 return surface->pData;
1383 }
1384
1385 auto DoHwSwizzle = [&]()->bool
1386 {
1387 if (MEDIA_IS_SKU(&surface->pMediaCtx->SkuTable, FtrUseSwSwizzling))
1388 {
1389 return false;
1390 }
1391 // RGBP not supported by ve.
1392 if (surface->format == Media_Format_RGBP)
1393 {
1394 return false;
1395 }
1396 if (!surface->pShadowBuffer)
1397 {
1398 vaStatus = CreateShadowResource(surface);
1399 if (vaStatus != VA_STATUS_SUCCESS)
1400 {
1401 return false;
1402 }
1403 }
1404
1405 vaStatus = SwizzleSurfaceByHW(surface);
1406 if (vaStatus == VA_STATUS_SUCCESS)
1407 {
1408 err = mos_bo_map(surface->pShadowBuffer->bo, flag & MOS_LOCKFLAG_WRITEONLY);
1409 if (err == 0)
1410 {
1411 surface->pData = (uint8_t *)surface->pShadowBuffer->bo->virt;
1412 return true;
1413 }
1414 }
1415
1416 // HW swizzle failed
1417 FreeBuffer(surface->pShadowBuffer);
1418 MOS_Delete(surface->pShadowBuffer);
1419 surface->pShadowBuffer = nullptr;
1420 return false;
1421 };
1422
1423 auto DoSwSwizzle = [&]()->bool
1424 {
1425 mos_bo_map(surface->bo, flag & MOS_LOCKFLAG_WRITEONLY);
1426
1427 surface->pSystemShadow = MOS_NewArray(uint8_t, surface->bo->size);
1428 if (!surface->pSystemShadow)
1429 {
1430 return false;
1431 }
1432
1433 vaStatus = SwizzleSurface(surface->pMediaCtx,
1434 surface->pGmmResourceInfo,
1435 surface->bo->virt,
1436 (MOS_TILE_TYPE)surface->TileType,
1437 (uint8_t *)surface->pSystemShadow,
1438 false);
1439 if(vaStatus == VA_STATUS_SUCCESS)
1440 {
1441 surface->pData = surface->pSystemShadow;
1442 return true;
1443 }
1444
1445 // SW swizzle failed
1446 MOS_DeleteArray(surface->pSystemShadow);
1447 surface->pSystemShadow = nullptr;
1448 return false;
1449 };
1450
1451 if (!DoHwSwizzle())
1452 {
1453 if (!DoSwSwizzle())
1454 {
1455 DDI_ASSERTMESSAGE("Swizzle failed!");
1456 return nullptr;
1457 }
1458 }
1459
1460 surface->uiMapFlag = flag;
1461 surface->data_size = surface->bo->size;
1462 surface->bMapped = true;
1463
1464 return surface->pData;
1465 }
1466
1467 void MediaLibvaUtilNext::UnlockSurface(DDI_MEDIA_SURFACE *surface)
1468 {
1469 DDI_FUNC_ENTER;
1470 DDI_CHK_NULL(surface, "nullptr surface", );
1471 DDI_CHK_NULL(surface->bo, "nullptr surface->bo", );
1472 if (0 == surface->iRefCount)
1473 {
1474 return;
1475 }
1476
1477 if((true == surface->bMapped) && (1 == surface->iRefCount))
1478 {
1479 if (surface->pMediaCtx->bIsAtomSOC)
1480 {
1481 mos_bo_unmap_gtt(surface->bo);
1482 }
1483 else
1484 {
1485 if (surface->TileType == TILING_NONE)
1486 {
1487 mos_bo_unmap(surface->bo);
1488 }
1489 else if (surface->pShadowBuffer != nullptr)
1490 {
1491 SwizzleSurfaceByHW(surface, true);
1492
1493 mos_bo_unmap(surface->pShadowBuffer->bo);
1494 FreeBuffer(surface->pShadowBuffer);
1495 MOS_Delete(surface->pShadowBuffer);
1496 surface->pShadowBuffer = nullptr;
1497
1498 mos_bo_unmap(surface->bo);
1499 }
1500 else if (surface->pSystemShadow)
1501 {
1502 SwizzleSurface(surface->pMediaCtx,
1503 surface->pGmmResourceInfo,
1504 surface->bo->virt,
1505 (MOS_TILE_TYPE)surface->TileType,
1506 (uint8_t *)surface->pSystemShadow,
1507 true);
1508
1509 MOS_DeleteArray(surface->pSystemShadow);
1510 surface->pSystemShadow = nullptr;
1511
1512 mos_bo_unmap(surface->bo);
1513 }
1514 else if(surface->uiMapFlag & MOS_LOCKFLAG_NO_SWIZZLE)
1515 {
1516 mos_bo_unmap(surface->bo);
1517 }
1518 else
1519 {
1520 mos_bo_unmap_gtt(surface->bo);
1521 }
1522 }
1523 surface->pData = nullptr;
1524 surface->bo->virt = nullptr;
1525 surface->bMapped = false;
1526 }
1527 else
1528 {
1529 // do nothing here
1530 }
1531
1532 surface->iRefCount--;
1533
1534 return;
1535 }
1536
1537 VAStatus MediaLibvaUtilNext::CreateShadowResource(DDI_MEDIA_SURFACE *surface)
1538 {
1539 VAStatus vaStatus = VA_STATUS_SUCCESS;
1540 DDI_FUNC_ENTER;
1541 DDI_CHK_NULL(surface, "nullptr surface", VA_STATUS_ERROR_INVALID_SURFACE);
1542 DDI_CHK_NULL(surface->pGmmResourceInfo, "nullptr surface->pGmmResourceInfo", VA_STATUS_ERROR_INVALID_SURFACE);
1543
1544 if (surface->iWidth < 64 || surface->iRealHeight < 64 || (surface->iPitch % 64 != 0) || surface->format == Media_Format_P016)
1545 {
1546 return VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT;
1547 }
1548
1549 surface->pShadowBuffer = MOS_New(DDI_MEDIA_BUFFER);
1550 DDI_CHK_NULL(surface->pShadowBuffer, "Failed to allocate shadow buffer", VA_STATUS_ERROR_INVALID_BUFFER);
1551 surface->pShadowBuffer->pMediaCtx = surface->pMediaCtx;
1552 surface->pShadowBuffer->bUseSysGfxMem = true;
1553 surface->pShadowBuffer->iSize = surface->pGmmResourceInfo->GetSizeSurface();
1554
1555 vaStatus = AllocateBuffer(Media_Format_Buffer, surface->pShadowBuffer->iSize, surface->pShadowBuffer, surface->pMediaCtx->pDrmBufMgr, true);
1556
1557 if (vaStatus != VA_STATUS_SUCCESS)
1558 {
1559 MOS_Delete(surface->pShadowBuffer);
1560 surface->pShadowBuffer = nullptr;
1561 }
1562
1563 return vaStatus;
1564 }
1565
1566 void* MediaLibvaUtilNext::LockBuffer(DDI_MEDIA_BUFFER *buf, uint32_t flag)
1567 {
1568 DDI_FUNC_ENTER;
1569 DDI_CHK_NULL(buf, "nullptr buf", nullptr);
1570 if((Media_Format_CPU != buf->format) && (false == buf->bMapped))
1571 {
1572 if (nullptr != buf->pSurface)
1573 {
1574 LockSurface(buf->pSurface, flag);
1575 buf->pData = buf->pSurface->pData;
1576 }
1577 else
1578 {
1579 if (buf->pMediaCtx->bIsAtomSOC)
1580 {
1581 mos_bo_map_gtt(buf->bo);
1582 }
1583 else
1584 {
1585 if (buf->TileType == TILING_NONE)
1586 {
1587 mos_bo_map(buf->bo, ((MOS_LOCKFLAG_READONLY | MOS_LOCKFLAG_WRITEONLY) & flag));
1588 }
1589 else
1590 {
1591 mos_bo_map_gtt(buf->bo);
1592 }
1593 }
1594
1595 buf->pData = (uint8_t*)(buf->bo->virt);
1596 }
1597
1598 buf->bMapped = true;
1599 buf->iRefCount++;
1600 }
1601 else if ((Media_Format_CPU == buf->format) && (false == buf->bMapped))
1602 {
1603 buf->bMapped = true;
1604 buf->iRefCount++;
1605 }
1606 else
1607 {
1608 buf->iRefCount++;
1609 }
1610
1611 return buf->pData;
1612 }
1613
1614 void MediaLibvaUtilNext::UnlockBuffer(DDI_MEDIA_BUFFER *buf)
1615 {
1616 DDI_FUNC_ENTER;
1617 DDI_CHK_NULL(buf, "nullptr buf", );
1618 if (0 == buf->iRefCount)
1619 {
1620 return;
1621 }
1622 if((true == buf->bMapped) && (Media_Format_CPU != buf->format) && (1 == buf->iRefCount))
1623 {
1624 if (nullptr != buf->pSurface)
1625 {
1626 UnlockSurface(buf->pSurface);
1627 }
1628 else
1629 {
1630 if (buf->pMediaCtx->bIsAtomSOC)
1631 {
1632 mos_bo_unmap_gtt(buf->bo);
1633 }
1634 else
1635 {
1636 if (buf->TileType == TILING_NONE)
1637 {
1638 mos_bo_unmap(buf->bo);
1639 }
1640 else
1641 {
1642 mos_bo_unmap_gtt(buf->bo);
1643 }
1644 }
1645 buf->bo->virt = nullptr;
1646 }
1647
1648 buf->pData = nullptr;
1649
1650 buf->bMapped = false;
1651 }
1652 else if ((true == buf->bMapped) && (Media_Format_CPU == buf->format) && (1 == buf->iRefCount))
1653 {
1654 buf->bMapped = false;
1655 }
1656 else
1657 {
1658 // do nothing here
1659 }
1660 buf->iRefCount--;
1661 return;
1662 }
1663
1664 VAStatus MediaLibvaUtilNext::SwizzleSurface(
1665 PDDI_MEDIA_CONTEXT mediaCtx,
1666 PGMM_RESOURCE_INFO pGmmResInfo,
1667 void *pLockedAddr,
1668 uint32_t TileType,
1669 uint8_t *pResourceBase,
1670 bool bUpload)
1671 {
1672 uint32_t uiSize = 0, uiPitch = 0;
1673 GMM_RES_COPY_BLT gmmResCopyBlt = {0};
1674 uint32_t uiPicHeight = 0;
1675 uint32_t ulSwizzledSize = 0;
1676 VAStatus vaStatus = VA_STATUS_SUCCESS;
1677 DDI_FUNC_ENTER;
1678
1679 DDI_CHK_NULL(pGmmResInfo, "pGmmResInfo is NULL", VA_STATUS_ERROR_OPERATION_FAILED);
1680 DDI_CHK_NULL(pLockedAddr, "pLockedAddr is NULL", VA_STATUS_ERROR_OPERATION_FAILED);
1681 DDI_CHK_NULL(pResourceBase, "pResourceBase is NULL", VA_STATUS_ERROR_ALLOCATION_FAILED);
1682
1683 uiPicHeight = pGmmResInfo->GetBaseHeight();
1684 uiSize = pGmmResInfo->GetSizeSurface();
1685 uiPitch = pGmmResInfo->GetRenderPitch();
1686 gmmResCopyBlt.Gpu.pData = pLockedAddr;
1687 gmmResCopyBlt.Sys.pData = pResourceBase;
1688 gmmResCopyBlt.Sys.RowPitch = uiPitch;
1689 gmmResCopyBlt.Sys.BufferSize = uiSize;
1690 gmmResCopyBlt.Sys.SlicePitch = uiSize;
1691 gmmResCopyBlt.Blt.Slices = 1;
1692 gmmResCopyBlt.Blt.Upload = bUpload;
1693
1694 if(mediaCtx->pGmmClientContext->IsPlanar(pGmmResInfo->GetResourceFormat()) == true)
1695 {
1696 gmmResCopyBlt.Blt.Width = pGmmResInfo->GetBaseWidth();
1697 gmmResCopyBlt.Blt.Height = uiSize/uiPitch;
1698 }
1699
1700 pGmmResInfo->CpuBlt(&gmmResCopyBlt);
1701
1702 return vaStatus;
1703 }
1704
1705 void MediaLibvaUtilNext::ReleasePMediaBufferFromHeap(
1706 PDDI_MEDIA_HEAP bufferHeap,
1707 uint32_t vaBufferID)
1708 {
1709 DDI_FUNC_ENTER;
1710 DDI_CHK_NULL(bufferHeap, "nullptr bufferHeap", );
1711
1712 DDI_CHK_LESS(vaBufferID, bufferHeap->uiAllocatedHeapElements, "invalid buffer id", );
1713 PDDI_MEDIA_BUFFER_HEAP_ELEMENT mediaBufferHeapBase = (PDDI_MEDIA_BUFFER_HEAP_ELEMENT)bufferHeap->pHeapBase;
1714 PDDI_MEDIA_BUFFER_HEAP_ELEMENT mediaBufferHeapElmt = &mediaBufferHeapBase[vaBufferID];
1715 DDI_CHK_NULL(mediaBufferHeapElmt->pBuffer, "buffer is already released", );
1716 void *firstFree = bufferHeap->pFirstFreeHeapElement;
1717 bufferHeap->pFirstFreeHeapElement = (void*)mediaBufferHeapElmt;
1718 mediaBufferHeapElmt->pNextFree = (PDDI_MEDIA_BUFFER_HEAP_ELEMENT)firstFree;
1719 mediaBufferHeapElmt->pBuffer = nullptr;
1720 return;
1721 }
1722
1723 VAStatus MediaLibvaUtilNext::SwizzleSurfaceByHW(DDI_MEDIA_SURFACE *surface, bool isDeSwizzle)
1724 {
1725 DDI_FUNC_ENTER;
1726 DDI_CHK_NULL(surface, "nullptr surface", VA_STATUS_ERROR_INVALID_SURFACE);
1727 DDI_CHK_NULL(surface->pMediaCtx, "nullptr media context", VA_STATUS_ERROR_INVALID_CONTEXT);
1728
1729 MOS_CONTEXT mosCtx = {};
1730 PERF_DATA perfData = {};
1731 PDDI_MEDIA_CONTEXT mediaDrvCtx = surface->pMediaCtx;
1732
1733 // Get the buf manager for codechal create
1734 mosCtx.bufmgr = mediaDrvCtx->pDrmBufMgr;
1735 mosCtx.fd = mediaDrvCtx->fd;
1736 mosCtx.iDeviceId = mediaDrvCtx->iDeviceId;
1737 mosCtx.m_skuTable = mediaDrvCtx->SkuTable;
1738 mosCtx.m_waTable = mediaDrvCtx->WaTable;
1739 mosCtx.m_gtSystemInfo = *mediaDrvCtx->pGtSystemInfo;
1740 mosCtx.m_platform = mediaDrvCtx->platform;
1741
1742 mosCtx.ppMediaMemDecompState = &mediaDrvCtx->pMediaMemDecompState;
1743 mosCtx.pfnMemoryDecompress = mediaDrvCtx->pfnMemoryDecompress;
1744 mosCtx.pfnMediaMemoryCopy = mediaDrvCtx->pfnMediaMemoryCopy;
1745 mosCtx.pfnMediaMemoryCopy2D = mediaDrvCtx->pfnMediaMemoryCopy2D;
1746 mosCtx.pPerfData = &perfData;
1747 mosCtx.m_gtSystemInfo = *mediaDrvCtx->pGtSystemInfo;
1748 mosCtx.m_auxTableMgr = mediaDrvCtx->m_auxTableMgr;
1749 mosCtx.pGmmClientContext = mediaDrvCtx->pGmmClientContext;
1750
1751 mosCtx.m_osDeviceContext = mediaDrvCtx->m_osDeviceContext;
1752 mosCtx.m_userSettingPtr = mediaDrvCtx->m_userSettingPtr;
1753
1754 MOS_RESOURCE source = {};
1755 MOS_RESOURCE target = {};
1756
1757 if (isDeSwizzle)
1758 {
1759 MediaLibvaCommonNext::MediaBufferToMosResource(surface->pShadowBuffer, &source);
1760 MediaLibvaCommonNext::MediaSurfaceToMosResource(surface, &target);
1761 }
1762 else
1763 {
1764 MediaLibvaCommonNext::MediaSurfaceToMosResource(surface, &source);
1765 MediaLibvaCommonNext::MediaBufferToMosResource(surface->pShadowBuffer, &target);
1766 }
1767
1768 DDI_NORMALMESSAGE("If mmd device isn't registered, use media blt copy.");
1769 MediaCopyBaseState *mediaCopyState = static_cast<MediaCopyBaseState*>(mediaDrvCtx->pMediaCopyState);
1770 if (!mediaCopyState)
1771 {
1772 mediaCopyState = static_cast<MediaCopyBaseState*>(McpyDeviceNext::CreateFactory(&mosCtx));
1773 if (!mediaCopyState)
1774 {
1775 return VA_STATUS_ERROR_UNKNOWN;
1776 }
1777 mediaDrvCtx->pMediaCopyState = mediaCopyState;
1778 }
1779
1780 #if (_DEBUG || _RELEASE_INTERNAL)
1781 // disable reg key report to avoid conflict with media copy cases.
1782 mediaCopyState->SetRegkeyReport(false);
1783 #endif
1784
1785 auto format = surface->pGmmResourceInfo->GetResourceFormat();
1786 auto width = surface->pGmmResourceInfo->GetBaseWidth();
1787 auto height = surface->pGmmResourceInfo->GetBaseHeight();
1788 auto pitch = surface->pGmmResourceInfo->GetRenderPitch();
1789
1790 auto uOffsetX = surface->pGmmResourceInfo->GetPlanarXOffset(GMM_PLANE_U);
1791 auto uOffsetY = surface->pGmmResourceInfo->GetPlanarYOffset(GMM_PLANE_U);
1792 auto vOffsetX = surface->pGmmResourceInfo->GetPlanarXOffset(GMM_PLANE_V);
1793 auto vOffsetY = surface->pGmmResourceInfo->GetPlanarYOffset(GMM_PLANE_V);
1794
1795 DDI_NORMALMESSAGE("Override param: format %d, width %d, height %d, pitch %d", format, width, height, pitch);
1796
1797 DDI_CHK_NULL(source.pGmmResInfo, "nullptr surface", VA_STATUS_ERROR_INVALID_SURFACE);
1798 DDI_CHK_NULL(target.pGmmResInfo, "nullptr surface", VA_STATUS_ERROR_INVALID_SURFACE);
1799
1800 if (isDeSwizzle)
1801 {
1802 source.pGmmResInfo->OverrideSurfaceFormat(format);
1803 source.pGmmResInfo->OverrideSurfaceType(RESOURCE_2D);
1804 source.pGmmResInfo->OverrideBaseWidth(width);
1805 source.pGmmResInfo->OverrideBaseHeight(height);
1806 source.pGmmResInfo->OverridePitch(pitch);
1807
1808 source.pGmmResInfo->OverridePlanarXOffset(GMM_PLANE_U, uOffsetX);
1809 source.pGmmResInfo->OverridePlanarYOffset(GMM_PLANE_U, uOffsetY);
1810 source.pGmmResInfo->OverridePlanarXOffset(GMM_PLANE_V, vOffsetX);
1811 source.pGmmResInfo->OverridePlanarYOffset(GMM_PLANE_V, vOffsetY);
1812
1813 source.Format = target.Format;
1814 }
1815 else
1816 {
1817 target.pGmmResInfo->OverrideSurfaceFormat(format);
1818 target.pGmmResInfo->OverrideSurfaceType(RESOURCE_2D);
1819 target.pGmmResInfo->OverrideBaseWidth(width);
1820 target.pGmmResInfo->OverrideBaseHeight(height);
1821 target.pGmmResInfo->OverridePitch(pitch);
1822
1823 target.pGmmResInfo->OverridePlanarXOffset(GMM_PLANE_U, uOffsetX);
1824 target.pGmmResInfo->OverridePlanarYOffset(GMM_PLANE_U, uOffsetY);
1825 target.pGmmResInfo->OverridePlanarXOffset(GMM_PLANE_V, vOffsetX);
1826 target.pGmmResInfo->OverridePlanarYOffset(GMM_PLANE_V, vOffsetY);
1827
1828 target.Format = source.Format;
1829 }
1830
1831 MOS_STATUS mosSts = mediaCopyState->SurfaceCopy(&source, &target, MCPY_METHOD_BALANCE);
1832
1833 if (mosSts == MOS_STATUS_SUCCESS)
1834 {
1835 return VA_STATUS_SUCCESS;
1836 }
1837 else
1838 {
1839 return VA_STATUS_ERROR_UNKNOWN;
1840 }
1841 }
1842
1843 VAStatus MediaLibvaUtilNext::CreateBuffer(
1844 DDI_MEDIA_BUFFER *buffer,
1845 MOS_BUFMGR *bufmgr)
1846 {
1847 VAStatus status = VA_STATUS_SUCCESS;
1848 DDI_FUNC_ENTER;
1849 DDI_CHK_NULL(buffer, "nullptr buffer", VA_STATUS_ERROR_INVALID_BUFFER);
1850 DDI_CHK_LESS(buffer->format, Media_Format_Count, "Invalid buffer->format", VA_STATUS_ERROR_INVALID_PARAMETER);
1851
1852 if (buffer->format == Media_Format_CPU)
1853 {
1854 buffer->pData= (uint8_t*)MOS_AllocAndZeroMemory(buffer->iSize);
1855 if (nullptr == buffer->pData)
1856 {
1857 status = VA_STATUS_ERROR_ALLOCATION_FAILED;
1858 }
1859 }
1860 else
1861 {
1862 if (Media_Format_2DBuffer == buffer->format)
1863 {
1864 status = Allocate2DBuffer(buffer->uiHeight, buffer->uiWidth, buffer, bufmgr);
1865 }
1866 else
1867 {
1868 status = AllocateBuffer(buffer->format, buffer->iSize, buffer, bufmgr);
1869 }
1870 }
1871
1872 buffer->uiLockedBufID = VA_INVALID_ID;
1873 buffer->uiLockedImageID = VA_INVALID_ID;
1874 buffer->iRefCount = 0;
1875
1876 return status;
1877 }
1878
1879 VAStatus MediaLibvaUtilNext::Allocate2DBuffer(
1880 uint32_t height,
1881 uint32_t width,
1882 PDDI_MEDIA_BUFFER mediaBuffer,
1883 MOS_BUFMGR *bufmgr)
1884 {
1885 DDI_CHK_NULL(mediaBuffer, "mediaBuffer is nullptr", VA_STATUS_ERROR_INVALID_BUFFER);
1886 DDI_CHK_NULL(mediaBuffer->pMediaCtx, "mediaBuffer->pMediaCtx is nullptr", VA_STATUS_ERROR_INVALID_BUFFER);
1887 DDI_CHK_NULL(mediaBuffer->pMediaCtx->pGmmClientContext, "mediaBuffer->pMediaCtx->pGmmClientContext is nullptr", VA_STATUS_ERROR_INVALID_BUFFER);
1888
1889 int32_t size = 0;
1890 uint32_t tileformat = TILING_NONE;
1891 VAStatus hRes = VA_STATUS_SUCCESS;
1892 int32_t mem_type = MOS_MEMPOOL_VIDEOMEMORY;
1893
1894 // Create GmmResourceInfo
1895 GMM_RESCREATE_PARAMS gmmParams;
1896 MOS_ZeroMemory(&gmmParams, sizeof(gmmParams));
1897 gmmParams.BaseWidth = width;
1898 gmmParams.BaseHeight = height;
1899 gmmParams.ArraySize = 1;
1900 gmmParams.Type = RESOURCE_2D;
1901 gmmParams.Format = GMM_FORMAT_GENERIC_8BIT;
1902
1903 DDI_CHK_CONDITION(gmmParams.Format == GMM_FORMAT_INVALID,
1904 "Unsupported format",
1905 VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT);
1906
1907 gmmParams.Flags.Info.Linear = true;
1908 gmmParams.Flags.Gpu.Video = true;
1909 gmmParams.Flags.Info.LocalOnly = MEDIA_IS_SKU(&mediaBuffer->pMediaCtx->SkuTable, FtrLocalMemory);
1910 GMM_RESOURCE_INFO *gmmResourceInfo;
1911 mediaBuffer->pGmmResourceInfo = gmmResourceInfo = mediaBuffer->pMediaCtx->pGmmClientContext->CreateResInfoObject(&gmmParams);
1912
1913 if(nullptr == gmmResourceInfo)
1914 {
1915 DDI_VERBOSEMESSAGE("Gmm Create Resource Failed.");
1916 hRes = VA_STATUS_ERROR_ALLOCATION_FAILED;
1917 return hRes;
1918 }
1919 uint32_t gmmPitch;
1920 uint32_t gmmSize;
1921 uint32_t gmmHeight;
1922 gmmPitch = (uint32_t)gmmResourceInfo->GetRenderPitch();
1923 gmmSize = (uint32_t)gmmResourceInfo->GetSizeSurface();
1924 gmmHeight = gmmResourceInfo->GetBaseHeight();
1925
1926 MemoryPolicyParameter memPolicyPar = { 0 };
1927 memPolicyPar.skuTable = &mediaBuffer->pMediaCtx->SkuTable;
1928 memPolicyPar.waTable = &mediaBuffer->pMediaCtx->WaTable;
1929 memPolicyPar.resInfo = mediaBuffer->pGmmResourceInfo;
1930 memPolicyPar.resName = "Media 2D Buffer";
1931 memPolicyPar.uiType = mediaBuffer->uiType;
1932 memPolicyPar.preferredMemType = mediaBuffer->bUseSysGfxMem ? MOS_MEMPOOL_SYSTEMMEMORY : 0;
1933
1934 mem_type = MemoryPolicyManager::UpdateMemoryPolicy(&memPolicyPar);
1935
1936 unsigned int patIndex = MosInterface::GetPATIndexFromGmm(mediaBuffer->pMediaCtx->pGmmClientContext, gmmResourceInfo);
1937 bool isCpuCacheable = gmmResourceInfo->GetResFlags().Info.Cacheable;
1938
1939 MOS_LINUX_BO *bo;
1940 struct mos_drm_bo_alloc alloc;
1941 alloc.name = "Media 2D Buffer";
1942 alloc.size = gmmSize;
1943 alloc.alignment = 4096;
1944 alloc.ext.tiling_mode = TILING_NONE;
1945 alloc.ext.mem_type = mem_type;
1946 alloc.ext.pat_index = patIndex;
1947 alloc.ext.cpu_cacheable = isCpuCacheable;
1948
1949 bo = mos_bo_alloc(bufmgr, &alloc);
1950
1951 mediaBuffer->bMapped = false;
1952 if (bo)
1953 {
1954 mediaBuffer->format = Media_Format_2DBuffer;
1955 mediaBuffer->uiWidth = width;
1956 mediaBuffer->uiHeight = gmmHeight;
1957 mediaBuffer->uiPitch = gmmPitch;
1958 mediaBuffer->iSize = gmmSize;
1959 mediaBuffer->iRefCount = 0;
1960 mediaBuffer->bo = bo;
1961 mediaBuffer->TileType = tileformat;
1962 mediaBuffer->pData = (uint8_t*) bo->virt;
1963 DDI_VERBOSEMESSAGE("Alloc %7d bytes (%d x %d resource)\n", size, width, height);
1964 uint32_t event[] = {bo->handle, mediaBuffer->format, width, height, gmmPitch, bo->size, tileformat, 0};
1965 MOS_TraceEventExt(EVENT_VA_BUFFER, EVENT_TYPE_INFO, event, sizeof(event), &gmmResourceInfo->GetResFlags(), sizeof(GMM_RESOURCE_FLAG));
1966 }
1967 else
1968 {
1969 DDI_VERBOSEMESSAGE("Fail to Alloc %7d bytes (%d x %d resource)\n", size, width, height);
1970 hRes = VA_STATUS_ERROR_ALLOCATION_FAILED;
1971 }
1972
1973 return hRes;
1974 }
1975
1976 VAStatus MediaLibvaUtilNext::AllocateBuffer(
1977 DDI_MEDIA_FORMAT format,
1978 int32_t size,
1979 PDDI_MEDIA_BUFFER mediaBuffer,
1980 MOS_BUFMGR *bufmgr,
1981 bool isShadowBuffer)
1982 {
1983 DDI_FUNC_ENTER;
1984 DDI_CHK_NULL(mediaBuffer, "mediaBuffer is nullptr", VA_STATUS_ERROR_INVALID_BUFFER);
1985 DDI_CHK_NULL(mediaBuffer->pMediaCtx, "mediaBuffer->pMediaCtx is nullptr", VA_STATUS_ERROR_INVALID_BUFFER);
1986 DDI_CHK_NULL(mediaBuffer->pMediaCtx->pGmmClientContext, "mediaBuffer->pMediaCtx->pGmmClientContext is nullptr", VA_STATUS_ERROR_INVALID_BUFFER);
1987 if(format >= Media_Format_Count)
1988 {
1989 return VA_STATUS_ERROR_INVALID_PARAMETER;
1990 }
1991
1992 VAStatus hRes = VA_STATUS_SUCCESS;
1993 int32_t mem_type = MOS_MEMPOOL_VIDEOMEMORY;
1994
1995 // create fake GmmResourceInfo
1996 GMM_RESCREATE_PARAMS gmmParams;
1997 MOS_ZeroMemory(&gmmParams, sizeof(gmmParams));
1998 gmmParams.BaseWidth = 1;
1999 gmmParams.BaseHeight = 1;
2000 gmmParams.ArraySize = 0;
2001 gmmParams.Type = RESOURCE_1D;
2002 gmmParams.Format = GMM_FORMAT_GENERIC_8BIT;
2003 gmmParams.Flags.Gpu.Video = true;
2004 gmmParams.Flags.Info.Linear = true;
2005 gmmParams.Flags.Info.LocalOnly = MEDIA_IS_SKU(&mediaBuffer->pMediaCtx->SkuTable, FtrLocalMemory);
2006
2007 if (isShadowBuffer)
2008 {
2009 gmmParams.Flags.Info.Cacheable = true;
2010 gmmParams.Usage = GMM_RESOURCE_USAGE_STAGING;
2011 }
2012
2013 mediaBuffer->pGmmResourceInfo = mediaBuffer->pMediaCtx->pGmmClientContext->CreateResInfoObject(&gmmParams);
2014 DDI_CHK_NULL(mediaBuffer->pGmmResourceInfo, "pGmmResourceInfo is nullptr", VA_STATUS_ERROR_INVALID_BUFFER);
2015 mediaBuffer->pGmmResourceInfo->OverrideSize(mediaBuffer->iSize);
2016 mediaBuffer->pGmmResourceInfo->OverrideBaseWidth(mediaBuffer->iSize);
2017 mediaBuffer->pGmmResourceInfo->OverridePitch(mediaBuffer->iSize);
2018
2019 MemoryPolicyParameter memPolicyPar = { 0 };
2020 memPolicyPar.skuTable = &mediaBuffer->pMediaCtx->SkuTable;
2021 memPolicyPar.waTable = &mediaBuffer->pMediaCtx->WaTable;
2022 memPolicyPar.resInfo = mediaBuffer->pGmmResourceInfo;
2023 memPolicyPar.resName = "Media Buffer";
2024 memPolicyPar.uiType = mediaBuffer->uiType;
2025 memPolicyPar.preferredMemType = mediaBuffer->bUseSysGfxMem ? MOS_MEMPOOL_SYSTEMMEMORY : 0;
2026
2027 mem_type = MemoryPolicyManager::UpdateMemoryPolicy(&memPolicyPar);
2028
2029 unsigned int patIndex = MosInterface::GetPATIndexFromGmm(mediaBuffer->pMediaCtx->pGmmClientContext, mediaBuffer->pGmmResourceInfo);
2030 bool isCpuCacheable = mediaBuffer->pGmmResourceInfo->GetResFlags().Info.Cacheable;
2031
2032 struct mos_drm_bo_alloc alloc;
2033 alloc.name = "Media Buffer";
2034 alloc.size = size;
2035 alloc.alignment = 4096;
2036 alloc.ext.tiling_mode = TILING_NONE;
2037 alloc.ext.mem_type = mem_type;
2038 alloc.ext.pat_index = patIndex;
2039 alloc.ext.cpu_cacheable = isCpuCacheable;
2040
2041 MOS_LINUX_BO *bo = mos_bo_alloc(bufmgr, &alloc);
2042 mediaBuffer->bMapped = false;
2043 if (bo)
2044 {
2045 mediaBuffer->format = format;
2046 mediaBuffer->iSize = size;
2047 mediaBuffer->iRefCount = 0;
2048 mediaBuffer->bo = bo;
2049 mediaBuffer->pData = (uint8_t*) bo->virt;
2050
2051 DDI_VERBOSEMESSAGE("Alloc %8d bytes resource.",size);
2052 uint32_t event[] = {bo->handle, format, size, 1, size, bo->size, 0, 0};
2053 MOS_TraceEventExt(EVENT_VA_BUFFER, EVENT_TYPE_INFO, event, sizeof(event), &mediaBuffer->pGmmResourceInfo->GetResFlags(), sizeof(GMM_RESOURCE_FLAG));
2054 }
2055 else
2056 {
2057 DDI_ASSERTMESSAGE("Fail to Alloc %8d bytes resource.",size);
2058 hRes = VA_STATUS_ERROR_ALLOCATION_FAILED;
2059 }
2060
2061 return hRes;
2062 }
2063
2064 PDDI_MEDIA_BUFFER_HEAP_ELEMENT MediaLibvaUtilNext::AllocPMediaBufferFromHeap(PDDI_MEDIA_HEAP bufferHeap)
2065 {
2066 DDI_FUNC_ENTER;
2067 DDI_CHK_NULL(bufferHeap, "nullptr bufferHeap", nullptr);
2068
2069 PDDI_MEDIA_BUFFER_HEAP_ELEMENT mediaBufferHeapElmt = nullptr;
2070 if (nullptr == bufferHeap->pFirstFreeHeapElement)
2071 {
2072 void *newHeapBase = MOS_ReallocMemory(bufferHeap->pHeapBase, (bufferHeap->uiAllocatedHeapElements + DDI_MEDIA_HEAP_INCREMENTAL_SIZE) * sizeof(DDI_MEDIA_BUFFER_HEAP_ELEMENT));
2073 if (nullptr == newHeapBase)
2074 {
2075 DDI_ASSERTMESSAGE("DDI: realloc failed.");
2076 return nullptr;
2077 }
2078 bufferHeap->pHeapBase = newHeapBase;
2079 PDDI_MEDIA_BUFFER_HEAP_ELEMENT mediaBufferHeapBase = (PDDI_MEDIA_BUFFER_HEAP_ELEMENT)bufferHeap->pHeapBase;
2080 bufferHeap->pFirstFreeHeapElement = (void*)(&mediaBufferHeapBase[bufferHeap->uiAllocatedHeapElements]);
2081 for (int32_t i = 0; i < (DDI_MEDIA_HEAP_INCREMENTAL_SIZE); i++)
2082 {
2083 mediaBufferHeapElmt = &mediaBufferHeapBase[bufferHeap->uiAllocatedHeapElements + i];
2084 mediaBufferHeapElmt->pNextFree = (i == (DDI_MEDIA_HEAP_INCREMENTAL_SIZE - 1))? nullptr : &mediaBufferHeapBase[bufferHeap->uiAllocatedHeapElements + i + 1];
2085 mediaBufferHeapElmt->uiVaBufferID = bufferHeap->uiAllocatedHeapElements + i;
2086 }
2087 bufferHeap->uiAllocatedHeapElements += DDI_MEDIA_HEAP_INCREMENTAL_SIZE;
2088 }
2089
2090 mediaBufferHeapElmt = (PDDI_MEDIA_BUFFER_HEAP_ELEMENT)bufferHeap->pFirstFreeHeapElement;
2091 bufferHeap->pFirstFreeHeapElement = mediaBufferHeapElmt->pNextFree;
2092 return mediaBufferHeapElmt;
2093 }
2094
2095 PDDI_MEDIA_IMAGE_HEAP_ELEMENT MediaLibvaUtilNext::AllocPVAImageFromHeap(PDDI_MEDIA_HEAP imageHeap)
2096 {
2097 PDDI_MEDIA_IMAGE_HEAP_ELEMENT vaimageHeapElmt = nullptr;
2098 DDI_FUNC_ENTER;
2099 DDI_CHK_NULL(imageHeap, "nullptr imageHeap", nullptr);
2100
2101 if (nullptr == imageHeap->pFirstFreeHeapElement)
2102 {
2103 void *newHeapBase = MOS_ReallocMemory(imageHeap->pHeapBase, (imageHeap->uiAllocatedHeapElements + DDI_MEDIA_HEAP_INCREMENTAL_SIZE) * sizeof(DDI_MEDIA_IMAGE_HEAP_ELEMENT));
2104
2105 if (nullptr == newHeapBase)
2106 {
2107 DDI_ASSERTMESSAGE("DDI: realloc failed.");
2108 return nullptr;
2109 }
2110 imageHeap->pHeapBase = newHeapBase;
2111 PDDI_MEDIA_IMAGE_HEAP_ELEMENT vaimageHeapBase = (PDDI_MEDIA_IMAGE_HEAP_ELEMENT)imageHeap->pHeapBase;
2112 imageHeap->pFirstFreeHeapElement = (void*)(&vaimageHeapBase[imageHeap->uiAllocatedHeapElements]);
2113 for (int32_t i = 0; i < (DDI_MEDIA_HEAP_INCREMENTAL_SIZE); i++)
2114 {
2115 vaimageHeapElmt = &vaimageHeapBase[imageHeap->uiAllocatedHeapElements + i];
2116 vaimageHeapElmt->pNextFree = (i == (DDI_MEDIA_HEAP_INCREMENTAL_SIZE - 1))? nullptr : &vaimageHeapBase[imageHeap->uiAllocatedHeapElements + i + 1];
2117 vaimageHeapElmt->uiVaImageID = imageHeap->uiAllocatedHeapElements + i;
2118 }
2119 imageHeap->uiAllocatedHeapElements += DDI_MEDIA_HEAP_INCREMENTAL_SIZE;
2120
2121 }
2122
2123 vaimageHeapElmt = (PDDI_MEDIA_IMAGE_HEAP_ELEMENT)imageHeap->pFirstFreeHeapElement;
2124 imageHeap->pFirstFreeHeapElement = vaimageHeapElmt->pNextFree;
2125 return vaimageHeapElmt;
2126 }
2127
2128 GMM_RESOURCE_FORMAT MediaLibvaUtilNext::ConvertFourccToGmmFmt(uint32_t fourcc)
2129 {
2130 DDI_FUNC_ENTER;
2131 switch (fourcc)
2132 {
2133 case VA_FOURCC_BGRA : return GMM_FORMAT_B8G8R8A8_UNORM_TYPE;
2134 case VA_FOURCC_ARGB : return GMM_FORMAT_B8G8R8A8_UNORM_TYPE;
2135 case VA_FOURCC_RGBA : return GMM_FORMAT_R8G8B8A8_UNORM_TYPE;
2136 case VA_FOURCC_ABGR : return GMM_FORMAT_R8G8B8A8_UNORM_TYPE;
2137 case VA_FOURCC_BGRX : return GMM_FORMAT_B8G8R8X8_UNORM_TYPE;
2138 case VA_FOURCC_XRGB : return GMM_FORMAT_B8G8R8X8_UNORM_TYPE;
2139 case VA_FOURCC_RGBX : return GMM_FORMAT_R8G8B8X8_UNORM_TYPE;
2140 case VA_FOURCC_XBGR : return GMM_FORMAT_R8G8B8X8_UNORM_TYPE;
2141 case VA_FOURCC_R8G8B8 : return GMM_FORMAT_R8G8B8_UNORM;
2142 case VA_FOURCC_RGBP : return GMM_FORMAT_RGBP;
2143 case VA_FOURCC_BGRP : return GMM_FORMAT_BGRP;
2144 case VA_FOURCC_RGB565 : return GMM_FORMAT_B5G6R5_UNORM_TYPE;
2145 case VA_FOURCC_AYUV : return GMM_FORMAT_AYUV_TYPE;
2146 #if VA_CHECK_VERSION(1, 13, 0)
2147 case VA_FOURCC_XYUV : return GMM_FORMAT_AYUV_TYPE;
2148 #endif
2149 case VA_FOURCC_NV12 : return GMM_FORMAT_NV12_TYPE;
2150 case VA_FOURCC_NV21 : return GMM_FORMAT_NV21_TYPE;
2151 case VA_FOURCC_YUY2 : return GMM_FORMAT_YUY2;
2152 case VA_FOURCC_UYVY : return GMM_FORMAT_UYVY;
2153 case VA_FOURCC_YV12 : return GMM_FORMAT_YV12_TYPE;
2154 case VA_FOURCC_I420 : return GMM_FORMAT_I420_TYPE;
2155 case VA_FOURCC_IYUV : return GMM_FORMAT_IYUV_TYPE;
2156 case VA_FOURCC_411P : return GMM_FORMAT_MFX_JPEG_YUV411_TYPE;
2157 case VA_FOURCC_422H : return GMM_FORMAT_MFX_JPEG_YUV422H_TYPE;
2158 case VA_FOURCC_422V : return GMM_FORMAT_MFX_JPEG_YUV422V_TYPE;
2159 case VA_FOURCC_444P : return GMM_FORMAT_MFX_JPEG_YUV444_TYPE;
2160 case VA_FOURCC_IMC3 : return GMM_FORMAT_IMC3_TYPE;
2161 case VA_FOURCC_P208 : return GMM_FORMAT_P208_TYPE;
2162 case VA_FOURCC_P010 : return GMM_FORMAT_P010_TYPE;
2163 case VA_FOURCC_P012 : return GMM_FORMAT_P016_TYPE;
2164 case VA_FOURCC_P016 : return GMM_FORMAT_P016_TYPE;
2165 case VA_FOURCC_Y210 : return GMM_FORMAT_Y210_TYPE;
2166 case VA_FOURCC_Y410 : return GMM_FORMAT_Y410_TYPE;
2167 #if VA_CHECK_VERSION(1, 9, 0)
2168 case VA_FOURCC_Y212 : return GMM_FORMAT_Y212_TYPE;
2169 #endif
2170 case VA_FOURCC_Y216 : return GMM_FORMAT_Y216_TYPE;
2171 #if VA_CHECK_VERSION(1, 9, 0)
2172 case VA_FOURCC_Y412 : return GMM_FORMAT_Y412_TYPE;
2173 #endif
2174 case VA_FOURCC_Y416 : return GMM_FORMAT_Y416_TYPE;
2175 case VA_FOURCC_Y800 : return GMM_FORMAT_GENERIC_8BIT;
2176 case VA_FOURCC_A2R10G10B10 : return GMM_FORMAT_R10G10B10A2_UNORM_TYPE;
2177 case VA_FOURCC_A2B10G10R10 : return GMM_FORMAT_B10G10R10A2_UNORM_TYPE;
2178 case VA_FOURCC_X2R10G10B10 : return GMM_FORMAT_R10G10B10A2_UNORM_TYPE;
2179 case VA_FOURCC_X2B10G10R10 : return GMM_FORMAT_B10G10R10A2_UNORM_TYPE;
2180 default : return GMM_FORMAT_INVALID;
2181 }
2182 }
2183
2184 void MediaLibvaUtilNext::InitMutex(PMEDIA_MUTEX_T mutex)
2185 {
2186 pthread_mutex_init(mutex, nullptr);
2187 }
2188
2189 void MediaLibvaUtilNext::DestroyMutex(PMEDIA_MUTEX_T mutex)
2190 {
2191 int32_t ret = pthread_mutex_destroy(mutex);
2192 if(ret != 0)
2193 {
2194 DDI_NORMALMESSAGE("can't destroy the mutex!\n");
2195 }
2196 }
2197
2198 VAStatus MediaLibvaUtilNext::SetMediaResetEnableFlag(PDDI_MEDIA_CONTEXT mediaCtx)
2199 {
2200 bool enableReset = false;
2201 mediaCtx->bMediaResetEnable = false;
2202
2203 DDI_CHK_NULL(mediaCtx,"nullptr mediaCtx!", VA_STATUS_ERROR_INVALID_CONTEXT);
2204
2205 if(!MEDIA_IS_SKU(&mediaCtx->SkuTable, FtrSWMediaReset))
2206 {
2207 mediaCtx->bMediaResetEnable = false;
2208 return VA_STATUS_SUCCESS;
2209 }
2210
2211 mediaCtx->bMediaResetEnable = true;
2212
2213 #if (_DEBUG || _RELEASE_INTERNAL)
2214 ReadUserSettingForDebug(
2215 mediaCtx->m_userSettingPtr,
2216 enableReset,
2217 __MEDIA_USER_FEATURE_VALUE_MEDIA_RESET_ENABLE,
2218 MediaUserSetting::Group::Device);
2219 mediaCtx->bMediaResetEnable = enableReset;
2220 #endif
2221 if(!mediaCtx->bMediaResetEnable)
2222 {
2223 return VA_STATUS_SUCCESS;
2224 }
2225
2226 char* mediaResetEnv = getenv("INTEL_MEDIA_RESET_WATCHDOG");
2227 if(mediaResetEnv)
2228 {
2229 mediaCtx->bMediaResetEnable = strcmp(mediaResetEnv, "1") ? false : true;
2230 return VA_STATUS_SUCCESS;
2231 }
2232
2233 return VA_STATUS_SUCCESS;
2234 }
2235
2236 VAStatus MediaLibvaUtilNext::GetSurfaceModifier(
2237 DDI_MEDIA_CONTEXT *mediaCtx,
2238 DDI_MEDIA_SURFACE *mediaSurface,
2239 uint64_t &modifier)
2240 {
2241 DDI_CHK_NULL(mediaCtx, "nullptr media context", VA_STATUS_ERROR_INVALID_CONTEXT);
2242 DDI_CHK_NULL(mediaSurface, "nullptr mediaSurface", VA_STATUS_ERROR_INVALID_SURFACE);
2243 DDI_CHK_NULL(mediaSurface->bo, "nullptr mediaSurface->bo", VA_STATUS_ERROR_INVALID_SURFACE);
2244 DDI_CHK_NULL(mediaSurface->pGmmResourceInfo, "nullptr mediaSurface->pGmmResourceInfo", VA_STATUS_ERROR_INVALID_SURFACE);
2245 GMM_TILE_TYPE gmmTileType = mediaSurface->pGmmResourceInfo->GetTileType();
2246 GMM_RESOURCE_FLAG gmmFlags = {0};
2247 gmmFlags = mediaSurface->pGmmResourceInfo->GetResFlags();
2248
2249 if(MEDIA_IS_SKU(&mediaCtx->SkuTable, FtrXe2Compression))
2250 {
2251 // Update Xe2Compression Modifier
2252 uint64_t compressedModifier = I915_FORMAT_MOD_4_TILED_LNL_CCS;
2253
2254 if (MEDIA_IS_SKU(&mediaCtx->SkuTable, FtrLocalMemory))
2255 {
2256 // DGfx only support compression on Local memory
2257 compressedModifier = I915_FORMAT_MOD_4_TILED_BMG_CCS;
2258 }
2259 switch(gmmTileType)
2260 {
2261 case GMM_TILED_4:
2262 modifier = gmmFlags.Info.NotCompressed ? I915_FORMAT_MOD_4_TILED : compressedModifier;
2263 break;
2264 case GMM_TILED_Y:
2265 modifier = I915_FORMAT_MOD_Y_TILED;
2266 break;
2267 case GMM_TILED_X:
2268 modifier = I915_FORMAT_MOD_X_TILED;
2269 break;
2270 case GMM_NOT_TILED:
2271 modifier = DRM_FORMAT_MOD_LINEAR;
2272 break;
2273 default:
2274 //handle other possible tile format
2275 if(TILING_Y == mediaSurface->TileType)
2276 {
2277 modifier = gmmFlags.Info.NotCompressed ? I915_FORMAT_MOD_4_TILED : compressedModifier;
2278 }
2279 else
2280 {
2281 modifier = DRM_FORMAT_MOD_LINEAR;
2282 }
2283 break;
2284 }
2285
2286 return VA_STATUS_SUCCESS;
2287 }
2288
2289 bool bMmcEnabled = false;
2290 if ((gmmFlags.Gpu.MMC ||
2291 gmmFlags.Gpu.CCS) &&
2292 (gmmFlags.Info.MediaCompressed ||
2293 gmmFlags.Info.RenderCompressed))
2294 {
2295 bMmcEnabled = true;
2296 }
2297 else
2298 {
2299 bMmcEnabled = false;
2300 }
2301
2302 switch(gmmTileType)
2303 {
2304 case GMM_TILED_4:
2305 if(mediaCtx->m_auxTableMgr && bMmcEnabled)
2306 {
2307 modifier = gmmFlags.Info.MediaCompressed ? I915_FORMAT_MOD_4_TILED_MTL_MC_CCS :
2308 (gmmFlags.Info.RenderCompressed ? I915_FORMAT_MOD_4_TILED_MTL_RC_CCS_CC : I915_FORMAT_MOD_4_TILED);
2309 }
2310 else
2311 {
2312 modifier = I915_FORMAT_MOD_4_TILED;
2313 }
2314 break;
2315 case GMM_TILED_Y:
2316 if (mediaCtx->m_auxTableMgr && bMmcEnabled)
2317 {
2318 modifier = gmmFlags.Info.MediaCompressed ? I915_FORMAT_MOD_Y_TILED_GEN12_MC_CCS :
2319 (gmmFlags.Info.RenderCompressed ? I915_FORMAT_MOD_Y_TILED_GEN12_RC_CCS : I915_FORMAT_MOD_Y_TILED);
2320 }
2321 else
2322 {
2323 modifier = I915_FORMAT_MOD_Y_TILED;
2324 }
2325 break;
2326 case GMM_TILED_X:
2327 modifier = I915_FORMAT_MOD_X_TILED;
2328 break;
2329 case GMM_NOT_TILED:
2330 modifier = DRM_FORMAT_MOD_LINEAR;
2331 break;
2332 default:
2333 //handle other possible tile format
2334 if(TILING_Y == mediaSurface->TileType)
2335 {
2336 modifier = gmmFlags.Info.MediaCompressed ? I915_FORMAT_MOD_Y_TILED_GEN12_MC_CCS :
2337 (gmmFlags.Info.RenderCompressed ? I915_FORMAT_MOD_Y_TILED_GEN12_RC_CCS : I915_FORMAT_MOD_Y_TILED);
2338 }
2339 else
2340 {
2341 modifier = DRM_FORMAT_MOD_LINEAR;
2342 }
2343 break;
2344
2345 }
2346 return VA_STATUS_SUCCESS;
2347 }
2348
2349 PDDI_MEDIA_VACONTEXT_HEAP_ELEMENT MediaLibvaUtilNext::DdiAllocPVAContextFromHeap(
2350 PDDI_MEDIA_HEAP vaContextHeap)
2351 {
2352 PDDI_MEDIA_VACONTEXT_HEAP_ELEMENT vacontextHeapElmt = nullptr;
2353 DDI_FUNCTION_ENTER();
2354 DDI_CHK_NULL(vaContextHeap, "nullptr vaContextHeap", nullptr);
2355
2356 if (nullptr == vaContextHeap->pFirstFreeHeapElement)
2357 {
2358 void *newHeapBase = MOS_ReallocMemory(vaContextHeap->pHeapBase, (vaContextHeap->uiAllocatedHeapElements + DDI_MEDIA_HEAP_INCREMENTAL_SIZE) * sizeof(DDI_MEDIA_VACONTEXT_HEAP_ELEMENT));
2359 DDI_CHK_NULL(newHeapBase, "DDI: realloc failed.", nullptr);
2360
2361 vaContextHeap->pHeapBase = newHeapBase;
2362 PDDI_MEDIA_VACONTEXT_HEAP_ELEMENT vacontextHeapBase = (PDDI_MEDIA_VACONTEXT_HEAP_ELEMENT)vaContextHeap->pHeapBase;
2363 DDI_CHK_NULL(vacontextHeapBase, "nullptr vacontextHeapBase.", nullptr);
2364 vaContextHeap->pFirstFreeHeapElement = (void*)(&(vacontextHeapBase[vaContextHeap->uiAllocatedHeapElements]));
2365 for (int32_t i = 0; i < (DDI_MEDIA_HEAP_INCREMENTAL_SIZE); i++)
2366 {
2367 vacontextHeapElmt = &vacontextHeapBase[vaContextHeap->uiAllocatedHeapElements + i];
2368 vacontextHeapElmt->pNextFree = (i == (DDI_MEDIA_HEAP_INCREMENTAL_SIZE - 1))? nullptr : &vacontextHeapBase[vaContextHeap->uiAllocatedHeapElements + i + 1];
2369 vacontextHeapElmt->uiVaContextID = vaContextHeap->uiAllocatedHeapElements + i;
2370 vacontextHeapElmt->pVaContext = nullptr;
2371 }
2372 vaContextHeap->uiAllocatedHeapElements += DDI_MEDIA_HEAP_INCREMENTAL_SIZE;
2373 }
2374
2375 vacontextHeapElmt = (PDDI_MEDIA_VACONTEXT_HEAP_ELEMENT)vaContextHeap->pFirstFreeHeapElement;
2376 vaContextHeap->pFirstFreeHeapElement = vacontextHeapElmt->pNextFree;
2377 return vacontextHeapElmt;
2378 }
2379
2380 void MediaLibvaUtilNext::DdiReleasePVAContextFromHeap(
2381 PDDI_MEDIA_HEAP vaContextHeap,
2382 uint32_t vaContextID)
2383 {
2384 DDI_FUNCTION_ENTER();
2385 DDI_CHK_NULL(vaContextHeap, "nullptr vaContextHeap", );
2386 DDI_CHK_LESS(vaContextID, vaContextHeap->uiAllocatedHeapElements, "invalid context id", );
2387
2388 PDDI_MEDIA_VACONTEXT_HEAP_ELEMENT vaContextHeapBase = (PDDI_MEDIA_VACONTEXT_HEAP_ELEMENT)vaContextHeap->pHeapBase;
2389 PDDI_MEDIA_VACONTEXT_HEAP_ELEMENT vaContextHeapElmt = &vaContextHeapBase[vaContextID];
2390 DDI_CHK_NULL(vaContextHeapElmt->pVaContext, "context is already released", );
2391 void *firstFree = vaContextHeap->pFirstFreeHeapElement;
2392
2393 vaContextHeap->pFirstFreeHeapElement = (void*)vaContextHeapElmt;
2394 vaContextHeapElmt->pNextFree = (PDDI_MEDIA_VACONTEXT_HEAP_ELEMENT)firstFree;
2395 vaContextHeapElmt->pVaContext = nullptr;
2396
2397 return;
2398 }
2399
2400 MOS_FORMAT MediaLibvaUtilNext::GetFormatFromMediaFormat(DDI_MEDIA_FORMAT mediaFormat)
2401 {
2402 MOS_FORMAT format = Format_Invalid;
2403 DDI_FUNC_ENTER;
2404 static const std::map<const DDI_MEDIA_FORMAT, const MOS_FORMAT> ddiFormatToMediaFormatMap =
2405 {
2406 {Media_Format_NV12, Format_NV12},
2407 {Media_Format_NV21, Format_NV21},
2408 {Media_Format_X8R8G8B8, Format_X8R8G8B8},
2409 {Media_Format_X8B8G8R8, Format_X8B8G8R8},
2410 {Media_Format_A8R8G8B8, Format_A8R8G8B8},
2411 {Media_Format_A8B8G8R8, Format_A8B8G8R8},
2412 {Media_Format_R8G8B8A8, Format_A8B8G8R8},
2413 {Media_Format_R5G6B5, Format_R5G6B5},
2414 {Media_Format_R8G8B8, Format_R8G8B8},
2415 {Media_Format_YUY2, Format_YUY2},
2416 {Media_Format_UYVY, Format_UYVY},
2417 {Media_Format_YV12, Format_YV12},
2418 {Media_Format_I420, Format_I420},
2419 {Media_Format_IYUV, Format_IYUV},
2420 {Media_Format_422H, Format_422H},
2421 {Media_Format_422V, Format_422V},
2422 {Media_Format_400P, Format_400P},
2423 {Media_Format_411P, Format_411P},
2424 {Media_Format_444P, Format_444P},
2425 {Media_Format_IMC3, Format_IMC3},
2426 {Media_Format_P010, Format_P010},
2427 {Media_Format_P012, Format_P016},
2428 {Media_Format_P016, Format_P016},
2429 {Media_Format_R10G10B10A2, Format_R10G10B10A2},
2430 {Media_Format_R10G10B10X2, Format_R10G10B10A2},
2431 {Media_Format_B10G10R10A2, Format_B10G10R10A2},
2432 {Media_Format_B10G10R10X2, Format_B10G10R10A2},
2433 {Media_Format_RGBP, Format_RGBP},
2434 {Media_Format_BGRP, Format_BGRP},
2435 {Media_Format_Y210, Format_Y210},
2436 #if VA_CHECK_VERSION(1, 9, 0)
2437 {Media_Format_Y212, Format_Y216},
2438 {Media_Format_Y412, Format_Y416},
2439 #endif
2440 {Media_Format_Y216, Format_Y216},
2441 {Media_Format_Y410, Format_Y410},
2442 {Media_Format_Y416, Format_Y416},
2443 {Media_Format_AYUV, Format_AYUV},
2444 #if VA_CHECK_VERSION(1, 13, 0)
2445 {Media_Format_XYUV, Format_AYUV},
2446 #endif
2447 {Media_Format_Y8, Format_Y8},
2448 {Media_Format_Y16S, Format_Y16S},
2449 {Media_Format_Y16U, Format_Y16U},
2450 {Media_Format_VYUY, Format_VYUY},
2451 {Media_Format_YVYU, Format_YVYU},
2452 {Media_Format_A16R16G16B16, Format_A16R16G16B16},
2453 {Media_Format_A16B16G16R16, Format_A16B16G16R16}
2454 };
2455 auto it = ddiFormatToMediaFormatMap.find(mediaFormat);
2456 if(it != ddiFormatToMediaFormatMap.end())
2457 {
2458 return it->second;
2459 }
2460 else
2461 {
2462 DDI_ASSERTMESSAGE("ERROR media format to vphal format.");
2463 return Format_Invalid;
2464 }
2465 }
2466
2467 MOS_TILE_TYPE MediaLibvaUtilNext::GetTileTypeFromMediaTileType(uint32_t mediaTileType)
2468 {
2469 MOS_TILE_TYPE tileType = MOS_TILE_INVALID;
2470 DDI_FUNC_ENTER;
2471
2472 switch(mediaTileType)
2473 {
2474 case TILING_Y:
2475 tileType = MOS_TILE_Y;
2476 break;
2477 case TILING_X:
2478 tileType = MOS_TILE_X;
2479 break;
2480 case TILING_NONE:
2481 tileType = MOS_TILE_LINEAR;
2482 break;
2483 default:
2484 tileType = MOS_TILE_LINEAR;
2485 }
2486
2487 return tileType;
2488 }
2489
2490 VPHAL_CSPACE MediaLibvaUtilNext::GetColorSpaceFromMediaFormat(DDI_MEDIA_FORMAT format)
2491 {
2492 DDI_FUNC_ENTER;
2493 MOS_FORMAT mosFormat = GetFormatFromMediaFormat(format);
2494
2495 if (IS_RGB_FORMAT(mosFormat))
2496 {
2497 return CSpace_sRGB;
2498 }
2499 else
2500 {
2501 return CSpace_BT601;
2502 }
2503 }
2504
2505 void MediaLibvaUtilNext::UnRefBufObjInMediaBuffer(PDDI_MEDIA_BUFFER buf)
2506 {
2507 DDI_FUNC_ENTER;
2508 mos_bo_unreference(buf->bo);
2509 return;
2510 }
2511
2512 void MediaLibvaUtilNext::ReleasePVAImageFromHeap(PDDI_MEDIA_HEAP imageHeap, uint32_t vaImageID)
2513 {
2514 PDDI_MEDIA_IMAGE_HEAP_ELEMENT vaImageHeapBase = nullptr;
2515 PDDI_MEDIA_IMAGE_HEAP_ELEMENT vaImageHeapElmt = nullptr;
2516 void *firstFree = nullptr;
2517 DDI_FUNC_ENTER;
2518 DDI_CHK_NULL(imageHeap, "nullptr imageHeap", );
2519
2520 DDI_CHK_LESS(vaImageID, imageHeap->uiAllocatedHeapElements, "invalid image id", );
2521 vaImageHeapBase = (PDDI_MEDIA_IMAGE_HEAP_ELEMENT)imageHeap->pHeapBase;
2522 vaImageHeapElmt = &vaImageHeapBase[vaImageID];
2523 DDI_CHK_NULL(vaImageHeapElmt->pImage, "image is already released", );
2524 firstFree = imageHeap->pFirstFreeHeapElement;
2525 imageHeap->pFirstFreeHeapElement = (void*)vaImageHeapElmt;
2526 vaImageHeapElmt->pNextFree = (PDDI_MEDIA_IMAGE_HEAP_ELEMENT)firstFree;
2527 vaImageHeapElmt->pImage = nullptr;
2528 }
2529
2530 #ifdef RELEASE
2531 void MediaLibvaUtilNext::MediaPrintFps()
2532 {
2533 return;
2534 }
2535 #else
2536 void MediaLibvaUtilNext::MediaPrintFps()
2537 {
2538 struct timeval tv2 ={};
2539 DDI_FUNC_ENTER;
2540 if (m_isMediaFpsPrintFpsEnabled == false)
2541 {
2542 return;
2543 }
2544 if (0 == m_vaFpsSampleSize)
2545 {
2546 return;
2547 }
2548 gettimeofday(&tv2, 0);
2549
2550 pthread_mutex_lock(&m_fpsMutex);
2551 if (-1 == m_frameCountFps)
2552 {
2553 gettimeofday(&m_tv1, 0);
2554 }
2555
2556 if (++m_frameCountFps >= m_vaFpsSampleSize)
2557 {
2558 char fpsFileName[LENGTH_OF_FPS_FILE_NAME] = {};
2559 FILE *fp = nullptr;
2560 char temp[LENGTH_OF_FPS_FILE_NAME] = {};
2561
2562 int64_t diff = (tv2.tv_sec - m_tv1.tv_sec)*1000000 + tv2.tv_usec - m_tv1.tv_usec;
2563 float fps = m_frameCountFps / (diff / 1000000.0);
2564 DDI_NORMALMESSAGE("FPS:%6.4f, Interval:%11lu.", fps,((uint64_t)tv2.tv_sec)*1000 + (tv2.tv_usec/1000));
2565 sprintf_s(temp, sizeof(temp), "FPS:%6.4f, Interval:%" PRIu64"\n", fps,((uint64_t)tv2.tv_sec)*1000 + (tv2.tv_usec/1000));
2566
2567 MOS_ZeroMemory(fpsFileName,LENGTH_OF_FPS_FILE_NAME);
2568 sprintf_s(fpsFileName, sizeof(fpsFileName), FPS_FILE_NAME);
2569 if ((fp = fopen(fpsFileName, "wb")) == nullptr)
2570 {
2571 pthread_mutex_unlock(&m_fpsMutex);
2572 DDI_ASSERTMESSAGE("Unable to open fps file.");
2573 return;
2574 }
2575
2576 fwrite(temp, 1, strlen(temp), fp);
2577 fclose(fp);
2578 m_frameCountFps = -1;
2579 }
2580 pthread_mutex_unlock(&m_fpsMutex);
2581 return;
2582 }
2583 #endif