Debian Codegraph @

media_softlet/linux/common/ddi/media_libva_interface_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_interface_next.cpp
24 //! \brief libva interface next implementaion.
25 //!
26
27 #if !defined(ANDROID) && defined(X11_FOUND)
28 #include <X11/Xutil.h>
29 #include "media_libva_putsurface_linux.h"
30 #endif
31
32 #include <drm_fourcc.h>
33
34 #include "media_libva_util_next.h"
35 #include "media_libva_interface_next.h"
36 #include "media_libva.h"
37 #include "mos_utilities.h"
38 #include "media_interfaces_mmd_next.h"
39 #include "media_libva_caps_next.h"
40 #include "media_ddi_prot.h"
41 #include "media_interfaces_hwinfo_device.h"
42 #include "mos_oca_interface_specific.h"
43 #include "media_interfaces_mcpy_next.h"
44 #include "ddi_decode_functions.h"
45 #include "ddi_encode_functions.h"
46 #include "ddi_vp_functions.h"
47 #include "media_libva_register.h"
48
49 MEDIA_MUTEX_T MediaLibvaInterfaceNext::m_GlobalMutex = MEDIA_MUTEX_INITIALIZER;
50
51 void MediaLibvaInterfaceNext::FreeForMediaContext(PDDI_MEDIA_CONTEXT mediaCtx)
52 {
53 DDI_FUNC_ENTER;
54
55 MosUtilities::MosUnlockMutex(&m_GlobalMutex);
56
57 if (mediaCtx)
58 {
59 mediaCtx->SkuTable.reset();
60 mediaCtx->WaTable.reset();
61 MOS_FreeMemory(mediaCtx->pSurfaceHeap);
62 MOS_FreeMemory(mediaCtx->pBufferHeap);
63 MOS_FreeMemory(mediaCtx->pImageHeap);
64 MOS_FreeMemory(mediaCtx->pDecoderCtxHeap);
65 MOS_FreeMemory(mediaCtx->pEncoderCtxHeap);
66 MOS_FreeMemory(mediaCtx->pVpCtxHeap);
67 MOS_FreeMemory(mediaCtx->pProtCtxHeap);
68 mediaCtx->m_userSettingPtr.reset();
69 MOS_Delete(mediaCtx);
70 }
71
72 return;
73 }
74
75 void MediaLibvaInterfaceNext::DestroyMediaContextMutex(PDDI_MEDIA_CONTEXT mediaCtx)
76 {
77 DDI_FUNC_ENTER;
78
79 // destroy the mutexs
80 MediaLibvaUtilNext::DestroyMutex(&mediaCtx->SurfaceMutex);
81 MediaLibvaUtilNext::DestroyMutex(&mediaCtx->BufferMutex);
82 MediaLibvaUtilNext::DestroyMutex(&mediaCtx->ImageMutex);
83 MediaLibvaUtilNext::DestroyMutex(&mediaCtx->DecoderMutex);
84 MediaLibvaUtilNext::DestroyMutex(&mediaCtx->EncoderMutex);
85 MediaLibvaUtilNext::DestroyMutex(&mediaCtx->VpMutex);
86
87 #if !defined(ANDROID) && defined(X11_FOUND)
88 MediaLibvaUtilNext::DestroyMutex(&mediaCtx->PutSurfaceRenderMutex);
89 MediaLibvaUtilNext::DestroyMutex(&mediaCtx->PutSurfaceSwapBufferMutex);
90 #endif
91
92 return;
93 }
94
95 PDDI_MEDIA_CONTEXT MediaLibvaInterfaceNext::CreateMediaDriverContext()
96 {
97 PDDI_MEDIA_CONTEXT mediaCtx;
98
99 mediaCtx = MOS_New(DDI_MEDIA_CONTEXT);
100
101 return mediaCtx;
102 }
103
104 VAStatus MediaLibvaInterfaceNext::HeapInitialize(PDDI_MEDIA_CONTEXT mediaCtx)
105 {
106 DDI_FUNC_ENTER;
107
108 DDI_CHK_NULL(mediaCtx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
109
110 // Heap initialization here
111 mediaCtx->pSurfaceHeap = (DDI_MEDIA_HEAP *)MOS_AllocAndZeroMemory(sizeof(DDI_MEDIA_HEAP));
112 DDI_CHK_NULL(mediaCtx->pSurfaceHeap, "nullptr pSurfaceHeap", VA_STATUS_ERROR_ALLOCATION_FAILED);
113 mediaCtx->pSurfaceHeap->uiHeapElementSize = sizeof(DDI_MEDIA_SURFACE_HEAP_ELEMENT);
114
115 mediaCtx->pBufferHeap = (DDI_MEDIA_HEAP *)MOS_AllocAndZeroMemory(sizeof(DDI_MEDIA_HEAP));
116 DDI_CHK_NULL(mediaCtx->pBufferHeap, "nullptr BufferHeap", VA_STATUS_ERROR_ALLOCATION_FAILED);
117 mediaCtx->pBufferHeap->uiHeapElementSize = sizeof(DDI_MEDIA_BUFFER_HEAP_ELEMENT);
118
119 mediaCtx->pImageHeap = (DDI_MEDIA_HEAP *)MOS_AllocAndZeroMemory(sizeof(DDI_MEDIA_HEAP));
120 DDI_CHK_NULL(mediaCtx->pImageHeap, "nullptr ImageHeap", VA_STATUS_ERROR_ALLOCATION_FAILED);
121 mediaCtx->pImageHeap->uiHeapElementSize = sizeof(DDI_MEDIA_IMAGE_HEAP_ELEMENT);
122
123 mediaCtx->pDecoderCtxHeap = (DDI_MEDIA_HEAP *)MOS_AllocAndZeroMemory(sizeof(DDI_MEDIA_HEAP));
124 DDI_CHK_NULL(mediaCtx->pDecoderCtxHeap, "nullptr DecoderCtxHeap", VA_STATUS_ERROR_ALLOCATION_FAILED);
125 mediaCtx->pDecoderCtxHeap->uiHeapElementSize = sizeof(DDI_MEDIA_VACONTEXT_HEAP_ELEMENT);
126
127 mediaCtx->pEncoderCtxHeap = (DDI_MEDIA_HEAP *)MOS_AllocAndZeroMemory(sizeof(DDI_MEDIA_HEAP));
128 DDI_CHK_NULL(mediaCtx->pEncoderCtxHeap, "nullptr EncoderCtxHeap", VA_STATUS_ERROR_ALLOCATION_FAILED);
129 mediaCtx->pEncoderCtxHeap->uiHeapElementSize = sizeof(DDI_MEDIA_VACONTEXT_HEAP_ELEMENT);
130
131 mediaCtx->pVpCtxHeap = (DDI_MEDIA_HEAP *)MOS_AllocAndZeroMemory(sizeof(DDI_MEDIA_HEAP));
132 DDI_CHK_NULL(mediaCtx->pVpCtxHeap, "nullptr VpCtxHeap", VA_STATUS_ERROR_ALLOCATION_FAILED);
133 mediaCtx->pVpCtxHeap->uiHeapElementSize = sizeof(DDI_MEDIA_VACONTEXT_HEAP_ELEMENT);
134
135 mediaCtx->pProtCtxHeap = (DDI_MEDIA_HEAP *)MOS_AllocAndZeroMemory(sizeof(DDI_MEDIA_HEAP));
136 DDI_CHK_NULL(mediaCtx->pProtCtxHeap, "nullptr pProtCtxHeap", VA_STATUS_ERROR_ALLOCATION_FAILED);
137 mediaCtx->pProtCtxHeap->uiHeapElementSize = sizeof(DDI_MEDIA_VACONTEXT_HEAP_ELEMENT);
138
139 // init the mutexs
140 MediaLibvaUtilNext::InitMutex(&mediaCtx->SurfaceMutex);
141 MediaLibvaUtilNext::InitMutex(&mediaCtx->BufferMutex);
142 MediaLibvaUtilNext::InitMutex(&mediaCtx->ImageMutex);
143 MediaLibvaUtilNext::InitMutex(&mediaCtx->DecoderMutex);
144 MediaLibvaUtilNext::InitMutex(&mediaCtx->EncoderMutex);
145 MediaLibvaUtilNext::InitMutex(&mediaCtx->VpMutex);
146 MediaLibvaUtilNext::InitMutex(&mediaCtx->ProtMutex);
147
148 return VA_STATUS_SUCCESS;
149 }
150
151 void MediaLibvaInterfaceNext::MediaMemoryDecompressInternal(
152 PMOS_CONTEXT mosCtx,
153 PMOS_RESOURCE osResource)
154 {
155 DDI_FUNC_ENTER;
156
157 DDI_CHK_NULL(mosCtx, "nullptr mosCtx",);
158 DDI_CHK_NULL(osResource, "nullptr osResource",);
159
160 MediaMemDecompBaseState *mediaMemDecompState = static_cast<MediaMemDecompBaseState*>(*mosCtx->ppMediaMemDecompState);
161
162 DDI_CHK_NULL(mediaMemDecompState, "nullptr mediaMemDecompState", );
163
164 mediaMemDecompState->MemoryDecompress(osResource);
165 }
166
167 void MediaLibvaInterfaceNext::MediaMemoryCopyInternal(
168 PMOS_CONTEXT mosCtx,
169 PMOS_RESOURCE inputOsResource,
170 PMOS_RESOURCE outputOsResource,
171 bool boutputcompressed)
172 {
173 DDI_FUNC_ENTER;
174
175 DDI_CHK_NULL(mosCtx, "nullptr mosCtx",);
176 DDI_CHK_NULL(inputOsResource, "nullptr input osResource",);
177 DDI_CHK_NULL(outputOsResource, "nullptr output osResource",);
178
179 MediaMemDecompBaseState *mediaMemDecompState = static_cast<MediaMemDecompBaseState*>(*mosCtx->ppMediaMemDecompState);
180
181 DDI_CHK_NULL(mediaMemDecompState, "nullptr mediaMemDecompState", );
182
183 mediaMemDecompState->MediaMemoryCopy(inputOsResource, outputOsResource, boutputcompressed);
184 }
185
186 void MediaLibvaInterfaceNext::MediaMemoryCopy2DInternal(
187 PMOS_CONTEXT mosCtx,
188 PMOS_RESOURCE inputOsResource,
189 PMOS_RESOURCE outputOsResource,
190 uint32_t copyWidth,
191 uint32_t copyHeight,
192 uint32_t copyInputOffset,
193 uint32_t copyOutputOffset,
194 uint32_t bpp,
195 bool boutputcompressed)
196 {
197 DDI_FUNC_ENTER;
198
199 DDI_CHK_NULL(mosCtx, "nullptr mosCtx",);
200 DDI_CHK_NULL(inputOsResource, "nullptr input osResource",);
201 DDI_CHK_NULL(outputOsResource, "nullptr output osResource",);
202
203 MediaMemDecompBaseState *mediaMemDecompState = static_cast<MediaMemDecompBaseState*>(*mosCtx->ppMediaMemDecompState);
204
205 DDI_CHK_NULL(mediaMemDecompState, "nullptr mediaMemDecompState", );
206
207 mediaMemDecompState->MediaMemoryCopy2D(
208 inputOsResource,
209 outputOsResource,
210 copyWidth,
211 copyHeight,
212 copyInputOffset,
213 copyOutputOffset,
214 bpp,
215 boutputcompressed);
216 }
217
218 VAStatus MediaLibvaInterfaceNext::MediaMemoryTileConvertInternal(
219 PMOS_CONTEXT mosCtx,
220 PMOS_RESOURCE inputOsResource,
221 PMOS_RESOURCE outputOsResource,
222 uint32_t copyWidth,
223 uint32_t copyHeight,
224 uint32_t copyInputOffset,
225 uint32_t copyOutputOffset,
226 bool isTileToLinear,
227 bool outputCompressed)
228 {
229 DDI_FUNC_ENTER;
230
231 DDI_CHK_NULL(mosCtx, "nullptr mosCtx", VA_STATUS_ERROR_INVALID_PARAMETER);
232 DDI_CHK_NULL(inputOsResource, "nullptr input osResource", VA_STATUS_ERROR_INVALID_PARAMETER);
233 DDI_CHK_NULL(outputOsResource, "nullptr output osResource", VA_STATUS_ERROR_INVALID_PARAMETER);
234
235 VAStatus vaStatus = VA_STATUS_SUCCESS;
236
237 MediaMemDecompBaseState *mediaMemDecompState = static_cast<MediaMemDecompBaseState*>(*mosCtx->ppMediaMemDecompState);
238
239 DDI_CHK_NULL(mediaMemDecompState, "nullptr mediaMemDecompState", VA_STATUS_ERROR_INVALID_PARAMETER);
240
241 MOS_STATUS mosStatus = mediaMemDecompState->MediaMemoryTileConvert(
242 inputOsResource,
243 outputOsResource,
244 copyWidth,
245 copyHeight,
246 copyInputOffset,
247 copyOutputOffset,
248 isTileToLinear,
249 outputCompressed);
250 if (mosStatus != MOS_STATUS_SUCCESS)
251 {
252 vaStatus = VA_STATUS_ERROR_UNKNOWN;
253 }
254
255 return vaStatus;
256 }
257
258 VAStatus MediaLibvaInterfaceNext::Initialize (
259 VADriverContextP ctx,
260 int32_t devicefd,
261 int32_t *major_version,
262 int32_t *minor_version
263 )
264 {
265 DDI_FUNC_ENTER;
266
267 #if !defined(ANDROID) && defined(X11_FOUND)
268 // ATRACE code in <cutils/trace.h> started from KitKat, version = 440
269 // ENABLE_TRACE is defined only for eng build so release build won't leak perf data
270 // thus trace code enabled only on KitKat (and newer) && eng build
271 #if ANDROID_VERSION > 439 && defined(ENABLE_ATRACE)
272 char switch_value[PROPERTY_VALUE_MAX];
273
274 property_get("debug.DdiCodec_.umd", switch_value, "0");
275 atrace_switch = atoi(switch_value);
276 #endif
277 #endif
278
279 if(major_version)
280 {
281 *major_version = VA_MAJOR_VERSION;
282 }
283
284 if(minor_version)
285 {
286 *minor_version = VA_MINOR_VERSION;
287 }
288
289 MosUtilities::MosLockMutex(&m_GlobalMutex);
290 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
291 if(mediaCtx)
292 {
293 FreeForMediaContext(mediaCtx);
294 }
295
296 mediaCtx = CreateMediaDriverContext();
297 if (nullptr == mediaCtx)
298 {
299 FreeForMediaContext(mediaCtx);
300 return VA_STATUS_ERROR_ALLOCATION_FAILED;
301 }
302 mediaCtx->uiRef++;
303 ctx->pDriverData = (void *)mediaCtx;
304 mediaCtx->fd = devicefd;
305
306 mediaCtx->pfnMemoryDecompress = MediaMemoryDecompressInternal;
307 mediaCtx->pfnMediaMemoryCopy = MediaMemoryCopyInternal;
308 mediaCtx->pfnMediaMemoryCopy2D = MediaMemoryCopy2DInternal;
309 mediaCtx->pfnMediaMemoryTileConvert = MediaMemoryTileConvertInternal;
310
311 mediaCtx->modularizedGpuCtxEnabled = true;
312
313 mediaCtx->m_userSettingPtr = std::make_shared<MediaUserSetting::MediaUserSetting>();
314
315 MOS_CONTEXT mosCtx = {};
316 mosCtx.fd = mediaCtx->fd;
317 mosCtx.m_userSettingPtr = mediaCtx->m_userSettingPtr;
318
319 MosInterface::InitOsUtilities(&mosCtx);
320 MosOcaInterfaceSpecific::InitInterface(&mosCtx);
321
322 mediaCtx->pGtSystemInfo = (MEDIA_SYSTEM_INFO *)MOS_AllocAndZeroMemory(sizeof(MEDIA_SYSTEM_INFO));
323 if (nullptr == mediaCtx->pGtSystemInfo)
324 {
325 FreeForMediaContext(mediaCtx);
326 return VA_STATUS_ERROR_ALLOCATION_FAILED;
327 }
328
329 if (MosInterface::CreateOsDeviceContext(&mosCtx, &mediaCtx->m_osDeviceContext) != MOS_STATUS_SUCCESS)
330 {
331 DDI_ASSERTMESSAGE("Unable to create MOS device context.");
332 FreeForMediaContext(mediaCtx);
333 return VA_STATUS_ERROR_OPERATION_FAILED;
334 }
335 mediaCtx->pDrmBufMgr = mosCtx.bufmgr;
336 mediaCtx->iDeviceId = mosCtx.iDeviceId;
337 mediaCtx->SkuTable = mosCtx.m_skuTable;
338 mediaCtx->WaTable = mosCtx.m_waTable;
339 *mediaCtx->pGtSystemInfo = mosCtx.m_gtSystemInfo;
340 mediaCtx->platform = mosCtx.m_platform;
341 mediaCtx->m_auxTableMgr = mosCtx.m_auxTableMgr;
342 mediaCtx->pGmmClientContext = mosCtx.pGmmClientContext;
343 mediaCtx->m_useSwSwizzling = mosCtx.bUseSwSwizzling;
344 mediaCtx->m_tileYFlag = mosCtx.bTileYFlag;
345 mediaCtx->bIsAtomSOC = mosCtx.bIsAtomSOC;
346 mediaCtx->perfData = mosCtx.pPerfData;
347
348 if (mosCtx.ppMediaMemDecompState == nullptr)
349 {
350 DDI_ASSERTMESSAGE("media decomp state is null.");
351 FreeForMediaContext(mediaCtx);
352 return VA_STATUS_ERROR_OPERATION_FAILED;
353 }
354 mediaCtx->pMediaMemDecompState = *mosCtx.ppMediaMemDecompState;
355
356 mediaCtx->pMediaCopyState = *mosCtx.ppMediaCopyState;
357
358 if (HeapInitialize(mediaCtx) != VA_STATUS_SUCCESS)
359 {
360 DestroyMediaContextMutex(mediaCtx);
361 FreeForMediaContext(mediaCtx);
362 return VA_STATUS_ERROR_ALLOCATION_FAILED;
363 }
364
365 mediaCtx->m_hwInfo = MediaInterfacesHwInfoDevice::CreateFactory(mediaCtx->platform);
366 if(!mediaCtx->m_hwInfo)
367 {
368 DDI_ASSERTMESSAGE("Query hwInfo failed. Not supported GFX device.");
369 DestroyMediaContextMutex(mediaCtx);
370 FreeForMediaContext(mediaCtx);
371 return VA_STATUS_ERROR_ALLOCATION_FAILED;
372 }
373
374 mediaCtx->m_capsNext = MediaLibvaCapsNext::CreateCaps(mediaCtx);
375 if (!mediaCtx->m_capsNext)
376 {
377 DDI_ASSERTMESSAGE("Caps create failed. Not supported GFX device.");
378 if(mediaCtx->m_hwInfo)
379 {
380 MOS_Delete(mediaCtx->m_hwInfo);
381 }
382 mediaCtx->m_hwInfo = nullptr;
383 DestroyMediaContextMutex(mediaCtx);
384 FreeForMediaContext(mediaCtx);
385 return VA_STATUS_ERROR_ALLOCATION_FAILED;
386 }
387
388 ctx->max_image_formats = mediaCtx->m_capsNext->GetImageFormatsMaxNum();
389
390 #if !defined(ANDROID) && defined(X11_FOUND)
391 MediaLibvaUtilNext::InitMutex(&mediaCtx->PutSurfaceRenderMutex);
392 MediaLibvaUtilNext::InitMutex(&mediaCtx->PutSurfaceSwapBufferMutex);
393
394 // try to open X11 lib, if fail, assume no X11 environment
395 if (VA_STATUS_SUCCESS != ConnectX11(mediaCtx))
396 {
397 // assume no X11 environment. In current implementation,
398 // PutSurface (Linux) needs X11 support, so just replace
399 // it with a dummy version. DdiCodec_PutSurfaceDummy() will
400 // return VA_STATUS_ERROR_UNIMPLEMENTED directly.
401 ctx->vtable->vaPutSurface = NULL;
402 }
403
404 if (OutputDriInit(ctx) == false)
405 {
406 DDI_ASSERTMESSAGE("Output driver init path failed.");
407 }
408 #endif
409
410 MediaLibvaUtilNext::SetMediaResetEnableFlag(mediaCtx);
411
412 if (InitCompList(mediaCtx) != VA_STATUS_SUCCESS)
413 {
414 DDI_ASSERTMESSAGE("Caps init failed. Not supported GFX device.");
415 MediaLibvaInterfaceNext::ReleaseCompList(mediaCtx);
416 if(mediaCtx->m_hwInfo)
417 {
418 MOS_Delete(mediaCtx->m_hwInfo);
419 }
420 mediaCtx->m_hwInfo = nullptr;
421 MOS_Delete(mediaCtx->m_capsNext);
422 mediaCtx->m_capsNext = nullptr;
423 DestroyMediaContextMutex(mediaCtx);
424 ReleaseCompList(mediaCtx);
425 FreeForMediaContext(mediaCtx);
426 return VA_STATUS_ERROR_ALLOCATION_FAILED;
427 }
428
429 MosUtilities::MosUnlockMutex(&m_GlobalMutex);
430
431 return VA_STATUS_ERROR_UNIMPLEMENTED;
432 }
433
434 VAStatus MediaLibvaInterfaceNext::InitCompList(PDDI_MEDIA_CONTEXT mediaCtx)
435 {
436 DDI_FUNC_ENTER;
437
438 VAStatus status = VA_STATUS_SUCCESS;
439 mediaCtx->m_compList[CompCommon] = MOS_New(DdiMediaFunctions);
440
441 if(nullptr == mediaCtx->m_compList[CompCommon])
442 {
443 status = VA_STATUS_ERROR_ALLOCATION_FAILED;
444 DDI_ASSERTMESSAGE("MediaLibvaContextNext::Init: Unable to create compList CompCommon.");
445 return status;
446 }
447
448 for(int i = CompCommon + 1; i < CompCount; i++)
449 {
450 if (FunctionsFactory::IsRegistered((CompType)i))
451 {
452 mediaCtx->m_compList[i] = FunctionsFactory::Create((CompType)i);
453 if (nullptr == mediaCtx->m_compList[i])
454 {
455 status = VA_STATUS_ERROR_ALLOCATION_FAILED;
456 DDI_ASSERTMESSAGE("MediaLibvaContextNext::Init: Unable to create compList %d.", i);
457 return status;
458 }
459 }
460 else
461 {
462 mediaCtx->m_compList[i] = mediaCtx->m_compList[CompCommon];
463 }
464 }
465
466 return status;
467 }
468
469 void MediaLibvaInterfaceNext::ReleaseCompList(PDDI_MEDIA_CONTEXT mediaCtx)
470 {
471 DDI_FUNC_ENTER;
472
473 MOS_Delete(mediaCtx->m_compList[CompCommon]);
474 mediaCtx->m_compList[CompCommon] = nullptr;
475
476 for(int i = CompCommon + 1; i < CompCount; i++)
477 {
478 if(nullptr != mediaCtx->m_compList[i])
479 {
480 if(FunctionsFactory::IsRegistered((CompType)i))
481 {
482 MOS_Delete(mediaCtx->m_compList[i]);
483 }
484 mediaCtx->m_compList[i] = nullptr;
485 }
486 }
487 }
488
489 void MediaLibvaInterfaceNext::FreeSurfaceHeapElements(PDDI_MEDIA_CONTEXT mediaCtx)
490 {
491 DDI_FUNC_ENTER;
492 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", );
493
494 PDDI_MEDIA_HEAP surfaceHeap = mediaCtx->pSurfaceHeap;
495 DDI_CHK_NULL(surfaceHeap, "nullptr surfaceHeap", );
496
497 PDDI_MEDIA_SURFACE_HEAP_ELEMENT mediaSurfaceHeapBase = (PDDI_MEDIA_SURFACE_HEAP_ELEMENT)surfaceHeap->pHeapBase;
498 DDI_CHK_NULL(mediaSurfaceHeapBase, "nullptr mediaSurfaceHeapBase", );
499
500 int32_t surfaceNums = mediaCtx->uiNumSurfaces;
501 for (int32_t elementId = 0; elementId < surfaceNums; elementId++)
502 {
503 PDDI_MEDIA_SURFACE_HEAP_ELEMENT mediaSurfaceHeapElmt = &mediaSurfaceHeapBase[elementId];
504 if (nullptr == mediaSurfaceHeapElmt->pSurface)
505 {
506 continue;
507 }
508 MediaLibvaUtilNext::FreeSurface(mediaSurfaceHeapElmt->pSurface);
509 MOS_FreeMemory(mediaSurfaceHeapElmt->pSurface);
510 MediaLibvaUtilNext::ReleasePMediaSurfaceFromHeap(surfaceHeap,mediaSurfaceHeapElmt->uiVaSurfaceID);
511 mediaCtx->uiNumSurfaces--;
512 }
513 }
514
515 void MediaLibvaInterfaceNext::FreeBufferHeapElements(VADriverContextP ctx)
516 {
517 DDI_FUNC_ENTER;
518
519 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
520 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", );
521
522 PDDI_MEDIA_HEAP bufferHeap = mediaCtx->pBufferHeap;
523 DDI_CHK_NULL(bufferHeap, "nullptr bufferHeap", );
524
525 PDDI_MEDIA_BUFFER_HEAP_ELEMENT mediaBufferHeapBase = (PDDI_MEDIA_BUFFER_HEAP_ELEMENT)bufferHeap->pHeapBase;
526 DDI_CHK_NULL(mediaBufferHeapBase, "nullptr mediaBufferHeapBase", );
527
528 int32_t bufNums = mediaCtx->uiNumBufs;
529 for (int32_t elementId = 0; bufNums > 0; ++elementId)
530 {
531 PDDI_MEDIA_BUFFER_HEAP_ELEMENT mediaBufferHeapElmt = &mediaBufferHeapBase[elementId];
532 if (nullptr == mediaBufferHeapElmt->pBuffer)
533 {
534 continue;
535 }
536 DestroyBuffer(ctx,mediaBufferHeapElmt->uiVaBufferID);
537 //Ensure the non-empty buffer to be destroyed.
538 --bufNums;
539 }
540 }
541
542 void MediaLibvaInterfaceNext::FreeImageHeapElements(VADriverContextP ctx)
543 {
544 DDI_FUNC_ENTER;
545
546 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
547 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", );
548
549 PDDI_MEDIA_HEAP imageHeap = mediaCtx->pImageHeap;
550 DDI_CHK_NULL(imageHeap, "nullptr imageHeap", );
551
552 PDDI_MEDIA_IMAGE_HEAP_ELEMENT mediaImageHeapBase = (PDDI_MEDIA_IMAGE_HEAP_ELEMENT)imageHeap->pHeapBase;
553 DDI_CHK_NULL(mediaImageHeapBase, "nullptr mediaImageHeapBase", );
554
555 int32_t imageNums = mediaCtx->uiNumImages;
556 for (int32_t elementId = 0; elementId < imageNums; ++elementId)
557 {
558 PDDI_MEDIA_IMAGE_HEAP_ELEMENT mediaImageHeapElmt = &mediaImageHeapBase[elementId];
559 if (nullptr == mediaImageHeapElmt->pImage)
560 {
561 continue;
562 }
563 DestroyImage(ctx, mediaImageHeapElmt->uiVaImageID);
564 }
565 }
566
567 void MediaLibvaInterfaceNext::FreeContextHeapElements(VADriverContextP ctx)
568 {
569 DDI_FUNC_ENTER;
570
571 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
572 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", );
573
574 //Free EncoderContext
575 PDDI_MEDIA_HEAP encoderContextHeap = mediaCtx->pEncoderCtxHeap;
576 int32_t encCtxNums = mediaCtx->uiNumEncoders;
577 if (nullptr != encoderContextHeap)
578 {
579 FreeContextHeap(ctx, encoderContextHeap, DDI_MEDIA_VACONTEXTID_OFFSET_ENCODER, encCtxNums);
580 }
581
582 //Free DecoderContext
583 PDDI_MEDIA_HEAP decoderContextHeap = mediaCtx->pDecoderCtxHeap;
584 int32_t decCtxNums = mediaCtx->uiNumDecoders;
585 if (nullptr != decoderContextHeap)
586 {
587 FreeContextHeap(ctx, decoderContextHeap, DDI_MEDIA_VACONTEXTID_OFFSET_DECODER, decCtxNums);
588 }
589
590 //Free VpContext
591 PDDI_MEDIA_HEAP vpContextHeap = mediaCtx->pVpCtxHeap;
592 int32_t vpctxNums = mediaCtx->uiNumVPs;
593 if (nullptr != vpContextHeap)
594 {
595 FreeContextHeap(ctx, vpContextHeap, DDI_MEDIA_VACONTEXTID_OFFSET_VP, vpctxNums);
596 }
597
598 //Free ProtContext
599 PDDI_MEDIA_HEAP protContextHeap = mediaCtx->pProtCtxHeap;
600 int32_t protCtxNums = mediaCtx->uiNumProts;
601 if (nullptr != protContextHeap)
602 {
603 DdiMedia_FreeProtectedSessionHeap(ctx, protContextHeap, DDI_MEDIA_VACONTEXTID_OFFSET_PROT, protCtxNums);
604 }
605
606 mediaCtx->pMediaMemDecompState = nullptr;
607 }
608
609 VAStatus MediaLibvaInterfaceNext::HeapDestroy(PDDI_MEDIA_CONTEXT mediaCtx)
610 {
611 DDI_FUNC_ENTER;
612
613 DDI_CHK_NULL(mediaCtx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
614 // destroy heaps
615 MOS_FreeMemory(mediaCtx->pSurfaceHeap->pHeapBase);
616 MOS_FreeMemory(mediaCtx->pSurfaceHeap);
617
618 MOS_FreeMemory(mediaCtx->pBufferHeap->pHeapBase);
619 MOS_FreeMemory(mediaCtx->pBufferHeap);
620
621 MOS_FreeMemory(mediaCtx->pImageHeap->pHeapBase);
622 MOS_FreeMemory(mediaCtx->pImageHeap);
623
624 MOS_FreeMemory(mediaCtx->pDecoderCtxHeap->pHeapBase);
625 MOS_FreeMemory(mediaCtx->pDecoderCtxHeap);
626
627 MOS_FreeMemory(mediaCtx->pEncoderCtxHeap->pHeapBase);
628 MOS_FreeMemory(mediaCtx->pEncoderCtxHeap);
629
630 MOS_FreeMemory(mediaCtx->pVpCtxHeap->pHeapBase);
631 MOS_FreeMemory(mediaCtx->pVpCtxHeap);
632
633 MOS_FreeMemory(mediaCtx->pProtCtxHeap->pHeapBase);
634 MOS_FreeMemory(mediaCtx->pProtCtxHeap);
635
636 // destroy the mutexs
637 MediaLibvaUtilNext::DestroyMutex(&mediaCtx->SurfaceMutex);
638 MediaLibvaUtilNext::DestroyMutex(&mediaCtx->BufferMutex);
639 MediaLibvaUtilNext::DestroyMutex(&mediaCtx->ImageMutex);
640 MediaLibvaUtilNext::DestroyMutex(&mediaCtx->DecoderMutex);
641 MediaLibvaUtilNext::DestroyMutex(&mediaCtx->EncoderMutex);
642 MediaLibvaUtilNext::DestroyMutex(&mediaCtx->VpMutex);
643 MediaLibvaUtilNext::DestroyMutex(&mediaCtx->ProtMutex);
644
645 //resource checking
646 if (mediaCtx->uiNumSurfaces != 0)
647 {
648 DDI_ASSERTMESSAGE("APP does not destroy all the surfaces.");
649 }
650 if (mediaCtx->uiNumBufs != 0)
651 {
652 DDI_ASSERTMESSAGE("APP does not destroy all the buffers.");
653 }
654 if (mediaCtx->uiNumImages != 0)
655 {
656 DDI_ASSERTMESSAGE("APP does not destroy all the images.");
657 }
658 if (mediaCtx->uiNumDecoders != 0)
659 {
660 DDI_ASSERTMESSAGE("APP does not destroy all the decoders.");
661 }
662 if (mediaCtx->uiNumEncoders != 0)
663 {
664 DDI_ASSERTMESSAGE("APP does not destroy all the encoders.");
665 }
666 if (mediaCtx->uiNumVPs != 0)
667 {
668 DDI_ASSERTMESSAGE("APP does not destroy all the VPs.");
669 }
670 if (mediaCtx->uiNumProts != 0)
671 {
672 DDI_ASSERTMESSAGE("APP does not destroy all the Prots.");
673 }
674 return VA_STATUS_SUCCESS;
675 }
676
677 void MediaLibvaInterfaceNext::FreeContextHeap(
678 VADriverContextP ctx,
679 PDDI_MEDIA_HEAP contextHeap,
680 int32_t vaContextOffset,
681 int32_t ctxNums)
682 {
683 DDI_FUNC_ENTER;
684
685 PDDI_MEDIA_VACONTEXT_HEAP_ELEMENT mediaContextHeapBase = (PDDI_MEDIA_VACONTEXT_HEAP_ELEMENT)contextHeap->pHeapBase;
686 DDI_CHK_NULL(mediaContextHeapBase, "nullptr mediaContextHeapBase", );
687
688 for (int32_t elementId = 0; elementId < ctxNums; ++elementId)
689 {
690 PDDI_MEDIA_VACONTEXT_HEAP_ELEMENT mediaContextHeapElmt = &mediaContextHeapBase[elementId];
691 if (nullptr == mediaContextHeapElmt->pVaContext)
692 {
693 continue;
694 }
695 VAContextID vaCtxID = (VAContextID)(mediaContextHeapElmt->uiVaContextID + vaContextOffset);
696 DestroyContext(ctx, vaCtxID);
697 }
698 }
699
700 VAStatus MediaLibvaInterfaceNext::Terminate(VADriverContextP ctx)
701 {
702 DDI_FUNC_ENTER;
703 MOS_CONTEXT mosCtx = {};
704
705 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
706
707 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
708 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
709
710 mosCtx.fd = mediaCtx->fd;
711 mosCtx.m_userSettingPtr = mediaCtx->m_userSettingPtr;
712
713 MosUtilities::MosLockMutex(&m_GlobalMutex);
714
715 #if !defined(ANDROID) && defined(X11_FOUND)
716 DestroyX11Connection(mediaCtx);
717 MediaLibvaUtilNext::DestroyMutex(&mediaCtx->PutSurfaceRenderMutex);
718 MediaLibvaUtilNext::DestroyMutex(&mediaCtx->PutSurfaceSwapBufferMutex);
719
720 if (mediaCtx->m_capsNext)
721 {
722 if (mediaCtx->dri_output != nullptr)
723 {
724 if (mediaCtx->dri_output->handle)
725 {
726 dso_close(mediaCtx->dri_output->handle);
727 }
728
729 free(mediaCtx->dri_output);
730 mediaCtx->dri_output = nullptr;
731 }
732 }
733 #endif
734
735 if (mediaCtx->m_capsNext)
736 {
737 MOS_Delete(mediaCtx->m_capsNext);
738 mediaCtx->m_capsNext = nullptr;
739 }
740 //destory resources
741 FreeSurfaceHeapElements(mediaCtx);
742 FreeBufferHeapElements(ctx);
743 FreeImageHeapElements(ctx);
744 FreeContextHeapElements(ctx);
745
746 HeapDestroy(mediaCtx);
747 DdiMediaProtected::FreeInstances();
748
749 MosInterface::DestroyOsDeviceContext(mediaCtx->m_osDeviceContext);
750 mediaCtx->m_osDeviceContext = MOS_INVALID_HANDLE;
751 MOS_FreeMemory(mediaCtx->pGtSystemInfo);
752 MosOcaInterfaceSpecific::UninitInterface();
753 MosInterface::CloseOsUtilities(&mosCtx);
754
755 ReleaseCompList(mediaCtx);
756 if(mediaCtx->m_hwInfo)
757 {
758 MOS_Delete(mediaCtx->m_hwInfo);
759 }
760 mediaCtx->m_hwInfo = nullptr;
761
762 if (mediaCtx->uiRef > 1)
763 {
764 mediaCtx->uiRef--;
765 MosUtilities::MosUnlockMutex(&m_GlobalMutex);
766
767 return VA_STATUS_SUCCESS;
768 }
769 mediaCtx->SkuTable.reset();
770 mediaCtx->WaTable.reset();
771
772 // release media driver context, ctx creation is behind the mos_utilities_init
773 // If free earilier than MOS_utilities_close, memnja count error.
774 MOS_Delete(mediaCtx);
775 mediaCtx = nullptr;
776 ctx->pDriverData = nullptr;
777
778 MosUtilities::MosUnlockMutex(&m_GlobalMutex);
779
780 return VA_STATUS_SUCCESS;
781 }
782
783 #if !defined(ANDROID) && defined(X11_FOUND)
784
785 #define X11_LIB_NAME "libX11.so.6"
786
787 void MediaLibvaInterfaceNext::DestroyX11Connection(
788 PDDI_MEDIA_CONTEXT mediaCtx
789 )
790 {
791 DDI_FUNC_ENTER;
792
793 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", );
794 DDI_CHK_NULL(mediaCtx->X11FuncTable, "nullptr X11FuncTable", );
795
796 MosUtilities::MosFreeLibrary(mediaCtx->X11FuncTable->pX11LibHandle);
797 MOS_FreeMemory(mediaCtx->X11FuncTable);
798 mediaCtx->X11FuncTable = nullptr;
799
800 return;
801 }
802
803 VAStatus MediaLibvaInterfaceNext::ConnectX11(
804 PDDI_MEDIA_CONTEXT mediaCtx
805 )
806 {
807 DDI_FUNC_ENTER;
808
809 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
810
811 mediaCtx->X11FuncTable = (PDDI_X11_FUNC_TABLE)MOS_AllocAndZeroMemory(sizeof(DDI_X11_FUNC_TABLE));
812 DDI_CHK_NULL(mediaCtx->X11FuncTable, "Allocation Failed for X11FuncTable", VA_STATUS_ERROR_ALLOCATION_FAILED);
813
814 HMODULE h_module = nullptr;
815 MOS_STATUS mos_status = MosUtilities::MosLoadLibrary(X11_LIB_NAME, &h_module);
816 if (MOS_STATUS_SUCCESS != mos_status || nullptr == h_module)
817 {
818 DestroyX11Connection(mediaCtx);
819 return VA_STATUS_ERROR_OPERATION_FAILED;
820 }
821
822 mediaCtx->X11FuncTable->pX11LibHandle = h_module;
823
824 mediaCtx->X11FuncTable->pfnXCreateGC =
825 MosUtilities::MosGetProcAddress(h_module, "XCreateGC");
826 mediaCtx->X11FuncTable->pfnXFreeGC =
827 MosUtilities::MosGetProcAddress(h_module, "XFreeGC");
828 mediaCtx->X11FuncTable->pfnXCreateImage =
829 MosUtilities::MosGetProcAddress(h_module, "XCreateImage");
830 mediaCtx->X11FuncTable->pfnXDestroyImage =
831 MosUtilities::MosGetProcAddress(h_module, "XDestroyImage");
832 mediaCtx->X11FuncTable->pfnXPutImage =
833 MosUtilities::MosGetProcAddress(h_module, "XPutImage");
834
835 if (nullptr == mediaCtx->X11FuncTable->pfnXCreateGC ||
836 nullptr == mediaCtx->X11FuncTable->pfnXFreeGC ||
837 nullptr == mediaCtx->X11FuncTable->pfnXCreateImage ||
838 nullptr == mediaCtx->X11FuncTable->pfnXDestroyImage ||
839 nullptr == mediaCtx->X11FuncTable->pfnXPutImage)
840 {
841 DestroyX11Connection(mediaCtx);
842 return VA_STATUS_ERROR_OPERATION_FAILED;
843 }
844
845 return VA_STATUS_SUCCESS;
846 }
847
848 bool MediaLibvaInterfaceNext::OutputDriInit(VADriverContextP ctx)
849 {
850 DDI_CHK_NULL(ctx, "nullptr ctx", false);
851
852 PDDI_MEDIA_CONTEXT mediaDrvCtx = nullptr;
853 mediaDrvCtx = GetMediaContext(ctx);
854 DDI_CHK_NULL(mediaDrvCtx, "nullptr ctx", false);
855
856 struct dso_handle *dso_handle = nullptr;
857 struct dri_vtable *dri_vtable = nullptr;
858
859 mediaDrvCtx->dri_output = nullptr;
860
861 static const struct dso_symbol symbols[] = {
862 { "va_dri_get_drawable",
863 offsetof(struct dri_vtable, get_drawable) },
864 { "va_dri_get_rendering_buffer",
865 offsetof(struct dri_vtable, get_rendering_buffer) },
866 { "va_dri_swap_buffer",
867 offsetof(struct dri_vtable, swap_buffer) },
868 { nullptr, }
869 };
870
871 mediaDrvCtx->dri_output = (va_dri_output*) calloc(1, sizeof(struct va_dri_output));
872 if (!mediaDrvCtx->dri_output)
873 {
874 return false;
875 }
876
877 mediaDrvCtx->dri_output->handle = DsoOpen(LIBVA_X11_NAME);
878 if (!mediaDrvCtx->dri_output->handle)
879 {
880 free(mediaDrvCtx->dri_output);
881 mediaDrvCtx->dri_output = nullptr;
882 return false;
883 }
884
885 dso_handle = mediaDrvCtx->dri_output->handle;
886 dri_vtable = &mediaDrvCtx->dri_output->vtable;
887 if (!DsoGetSymbols(dso_handle, dri_vtable, sizeof(*dri_vtable), symbols))
888 {
889 dso_close(mediaDrvCtx->dri_output->handle);
890 free(mediaDrvCtx->dri_output);
891 mediaDrvCtx->dri_output = nullptr;
892 return false;
893 }
894 return true;
895 }
896
897 struct dso_handle* MediaLibvaInterfaceNext::DsoOpen(const char *path)
898 {
899 struct dso_handle *h = nullptr;
900
901 h = (dso_handle *)calloc(1, sizeof(*h));
902 if (!h)
903 {
904 return nullptr;
905 }
906
907 if (path)
908 {
909 h->handle = dlopen(path, RTLD_LAZY|RTLD_LOCAL);
910 if (!h->handle)
911 {
912 dso_close(h);
913 return nullptr;
914 }
915 }
916 else
917 {
918 h->handle = RTLD_DEFAULT;
919 }
920 return h;
921 }
922
923 bool MediaLibvaInterfaceNext::DsoGetSymbols(
924 struct dso_handle *h,
925 void *vtable,
926 uint32_t vtable_length,
927 const struct dso_symbol *symbols
928 )
929 {
930 DDI_CHK_NULL(h, "nullptr h", false);
931
932 const struct dso_symbol *s = nullptr;
933 if (nullptr == symbols)
934 {
935 return VA_STATUS_ERROR_INVALID_PARAMETER;
936 }
937 for (s = symbols; s->name != nullptr; s++)
938 {
939 if (s->offset + sizeof(dso_generic_func) > vtable_length)
940 {
941 return false;
942 }
943 if (!GetSymbol(h, ((char *)vtable) + s->offset, s->name))
944 {
945 return false;
946 }
947 }
948 return true;
949 }
950
951 bool MediaLibvaInterfaceNext::GetSymbol(
952 struct dso_handle *h,
953 void *func_vptr,
954 const char *name)
955 {
956 DDI_CHK_NULL(h, "nullptr h", false);
957 DDI_CHK_NULL(func_vptr, "nullptr func_vptr", false);
958
959 dso_generic_func func;
960 dso_generic_func * const func_ptr = (dso_generic_func*) func_vptr;
961 const char *error = nullptr;
962
963 dlerror();
964 func = (dso_generic_func)dlsym(h->handle, name);
965 error = dlerror();
966 if (error)
967 {
968 fprintf(stderr, "error: failed to resolve %s(): %s\n", name, error);
969 return false;
970 }
971 *func_ptr = func;
972 return true;
973 }
974
975 #endif
976
977 VAStatus MediaLibvaInterfaceNext::LoadFunction(VADriverContextP ctx)
978 {
979 DDI_FUNC_ENTER;
980
981 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
982
983 struct VADriverVTable *pVTable = DDI_CODEC_GET_VTABLE(ctx);
984 DDI_CHK_NULL(pVTable, "nullptr pVTable", VA_STATUS_ERROR_INVALID_CONTEXT);
985
986 struct VADriverVTableVPP *pVTableVpp = DDI_CODEC_GET_VTABLE_VPP(ctx);
987 DDI_CHK_NULL(pVTableVpp, "nullptr pVTableVpp", VA_STATUS_ERROR_INVALID_CONTEXT);
988
989 #if VA_CHECK_VERSION(1,11,0)
990 struct VADriverVTableProt *pVTableProt = DDI_CODEC_GET_VTABLE_PROT(ctx);
991 DDI_CHK_NULL(pVTableProt, "nullptr pVTableProt", VA_STATUS_ERROR_INVALID_CONTEXT);
992 #endif
993
994 ctx->version_major = VA_MAJOR_VERSION;
995 ctx->version_minor = VA_MINOR_VERSION;
996 ctx->max_profiles = DDI_CODEC_GEN_MAX_PROFILES;
997 ctx->max_entrypoints = DDI_CODEC_GEN_MAX_ENTRYPOINTS;
998 ctx->max_attributes = (int32_t)VAConfigAttribTypeMax;
999 ctx->max_subpic_formats = DDI_CODEC_GEN_MAX_SUBPIC_FORMATS;
1000 ctx->max_display_attributes = DDI_MEDIA_GEN_MAX_DISPLAY_ATTRIBUTES ;
1001 ctx->str_vendor = DDI_CODEC_GEN_STR_VENDOR;
1002 ctx->vtable_tpi = nullptr;
1003
1004 pVTable->vaTerminate = Terminate;
1005
1006 pVTable->vaQueryConfigEntrypoints = QueryConfigEntrypoints;
1007 pVTable->vaQueryConfigProfiles = QueryConfigProfiles;
1008 pVTable->vaQueryConfigAttributes = QueryConfigAttributes;
1009 pVTable->vaCreateConfig = CreateConfig;
1010 pVTable->vaDestroyConfig = DestroyConfig;
1011 pVTable->vaGetConfigAttributes = GetConfigAttributes;
1012
1013 pVTable->vaCreateSurfaces = CreateSurfaces;
1014 pVTable->vaDestroySurfaces = DestroySurfaces;
1015 pVTable->vaCreateSurfaces2 = CreateSurfaces2;
1016
1017 pVTable->vaCreateContext = CreateContext;
1018 pVTable->vaDestroyContext = DestroyContext;
1019 pVTable->vaCreateBuffer = CreateBuffer;
1020 pVTable->vaBufferSetNumElements = BufferSetNumElements;
1021 pVTable->vaMapBuffer = MapBuffer;
1022 pVTable->vaUnmapBuffer = UnmapBuffer;
1023 pVTable->vaDestroyBuffer = DestroyBuffer;
1024 pVTable->vaBeginPicture = BeginPicture;
1025 pVTable->vaRenderPicture = RenderPicture;
1026 pVTable->vaEndPicture = EndPicture;
1027 pVTable->vaSyncSurface = SyncSurface;
1028 #if VA_CHECK_VERSION(1, 9, 0)
1029 pVTable->vaSyncSurface2 = SyncSurface2;
1030 pVTable->vaSyncBuffer = SyncBuffer;
1031 #endif
1032 pVTable->vaQuerySurfaceStatus = QuerySurfaceStatus;
1033 pVTable->vaQuerySurfaceError = QuerySurfaceError;
1034 pVTable->vaQuerySurfaceAttributes = QuerySurfaceAttributes;
1035 pVTable->vaPutSurface = PutSurface;
1036 pVTable->vaQueryImageFormats = QueryImageFormats;
1037
1038 pVTable->vaCreateImage = CreateImage;
1039 pVTable->vaDeriveImage = DeriveImage;
1040 pVTable->vaDestroyImage = DestroyImage;
1041 pVTable->vaSetImagePalette = SetImagePalette;
1042 pVTable->vaGetImage = GetImage;
1043 pVTable->vaPutImage = PutImage;
1044 pVTable->vaQuerySubpictureFormats = QuerySubpictureFormats;
1045 pVTable->vaCreateSubpicture = CreateSubpicture;
1046 pVTable->vaDestroySubpicture = DestroySubpicture;
1047 pVTable->vaSetSubpictureImage = SetSubpictureImage;
1048 pVTable->vaSetSubpictureChromakey = SetSubpictureChromakey;
1049 pVTable->vaSetSubpictureGlobalAlpha = SetSubpictureGlobalAlpha;
1050 pVTable->vaAssociateSubpicture = AssociateSubpicture;
1051 pVTable->vaDeassociateSubpicture = DeassociateSubpicture;
1052 pVTable->vaQueryDisplayAttributes = QueryDisplayAttributes;
1053 pVTable->vaGetDisplayAttributes = GetDisplayAttributes;
1054 pVTable->vaSetDisplayAttributes = SetDisplayAttributes;
1055 pVTable->vaQueryProcessingRate = QueryProcessingRate;
1056 #if VA_CHECK_VERSION(1,10,0)
1057 pVTable->vaCopy = Copy;
1058 #endif
1059
1060 // vaTrace
1061 pVTable->vaBufferInfo = BufferInfo;
1062 pVTable->vaLockSurface = LockSurface;
1063 pVTable->vaUnlockSurface = UnlockSurface;
1064
1065 pVTableVpp->vaQueryVideoProcFilters = QueryVideoProcFilters;
1066 pVTableVpp->vaQueryVideoProcFilterCaps = QueryVideoProcFilterCaps;
1067 pVTableVpp->vaQueryVideoProcPipelineCaps = QueryVideoProcPipelineCaps;
1068
1069 #if VA_CHECK_VERSION(1,11,0)
1070 pVTableProt->vaCreateProtectedSession = CreateProtectedSession;
1071 pVTableProt->vaDestroyProtectedSession = DestroyProtectedSession;
1072 pVTableProt->vaAttachProtectedSession = AttachProtectedSession;
1073 pVTableProt->vaDetachProtectedSession = DetachProtectedSession;
1074 pVTableProt->vaProtectedSessionExecute = ProtectedSessionExecute;
1075 #endif
1076
1077 pVTable->vaGetSurfaceAttributes = GetSurfaceAttributes;
1078 //Export PRIMEFD/FLINK to application for buffer sharing with OpenCL/GL
1079 pVTable->vaAcquireBufferHandle = AcquireBufferHandle;
1080 pVTable->vaReleaseBufferHandle = ReleaseBufferHandle;
1081 pVTable->vaExportSurfaceHandle = ExportSurfaceHandle;
1082
1083 return VA_STATUS_SUCCESS;
1084 }
1085
1086 VAStatus MediaLibvaInterfaceNext::CreateContext (
1087 VADriverContextP ctx,
1088 VAConfigID configId,
1089 int32_t pictureWidth,
1090 int32_t pictureHeight,
1091 int32_t flag,
1092 VASurfaceID *renderTarget,
1093 int32_t renderTargetsNum,
1094 VAContextID *context)
1095 {
1096 VAStatus vaStatus = VA_STATUS_SUCCESS;
1097
1098 DDI_FUNC_ENTER;
1099 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
1100 DDI_CHK_NULL(context, "nullptr context", VA_STATUS_ERROR_INVALID_PARAMETER);
1101
1102 PDDI_MEDIA_CONTEXT mediaDrvCtx = GetMediaContext(ctx);
1103 DDI_CHK_NULL(mediaDrvCtx, "nullptr mediaDrvCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
1104 DDI_CHK_NULL(mediaDrvCtx->m_capsNext, "nullptr m_capsNext", VA_STATUS_ERROR_INVALID_PARAMETER);
1105 DDI_CHK_NULL(mediaDrvCtx->m_capsNext->m_capsTable, "nullptr m_capsTable", VA_STATUS_ERROR_INVALID_PARAMETER);
1106
1107 if(!IS_VALID_CONFIG_ID(configId))
1108 {
1109 return VA_STATUS_ERROR_INVALID_CONFIG;
1110 }
1111 if(renderTargetsNum > 0)
1112 {
1113 DDI_CHK_NULL(renderTarget, "nullptr renderTarget", VA_STATUS_ERROR_INVALID_PARAMETER);
1114 DDI_CHK_NULL(mediaDrvCtx->pSurfaceHeap, "nullptr mediaDrvCtx->pSurfaceHeap", VA_STATUS_ERROR_INVALID_CONTEXT);
1115 for(int32_t i = 0; i < renderTargetsNum; i++)
1116 {
1117 uint32_t surfaceId = (uint32_t)renderTarget[i];
1118 DDI_CHK_LESS(surfaceId, mediaDrvCtx->pSurfaceHeap->uiAllocatedHeapElements, "Invalid Surface", VA_STATUS_ERROR_INVALID_SURFACE);
1119 }
1120 }
1121
1122 if(mediaDrvCtx->m_capsNext->m_capsTable->IsDecConfigId(configId) && REMOVE_CONFIG_ID_DEC_OFFSET(configId) < mediaDrvCtx->m_capsNext->m_capsTable->m_configList.size())
1123 {
1124 DDI_CHK_NULL(mediaDrvCtx->m_compList[CompDecode], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
1125 vaStatus = mediaDrvCtx->m_compList[CompDecode]->CreateContext(
1126 ctx, configId, pictureWidth, pictureHeight, flag, renderTarget, renderTargetsNum, context);
1127 }
1128 else if(mediaDrvCtx->m_capsNext->m_capsTable->IsEncConfigId(configId) && REMOVE_CONFIG_ID_ENC_OFFSET(configId) < mediaDrvCtx->m_capsNext->m_capsTable->m_configList.size())
1129 {
1130 DDI_CHK_NULL(mediaDrvCtx->m_compList[CompEncode], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
1131 vaStatus = mediaDrvCtx->m_compList[CompEncode]->CreateContext(
1132 ctx, configId, pictureWidth, pictureHeight, flag, renderTarget, renderTargetsNum, context);
1133 }
1134 else if(mediaDrvCtx->m_capsNext->m_capsTable->IsVpConfigId(configId) && mediaDrvCtx->m_capsNext->m_capsTable->m_configList.size())
1135 {
1136 DDI_CHK_NULL(mediaDrvCtx->m_compList[CompVp], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
1137 vaStatus = mediaDrvCtx->m_compList[CompVp]->CreateContext(
1138 ctx, configId, pictureWidth, pictureHeight, flag, renderTarget, renderTargetsNum, context);
1139 }
1140 else
1141 {
1142 DDI_ASSERTMESSAGE("DDI: Invalid configID");
1143 return VA_STATUS_ERROR_INVALID_CONFIG;
1144 }
1145 if(vaStatus != VA_STATUS_SUCCESS)
1146 {
1147 return vaStatus;
1148 }
1149 if(*context < DDI_MEDIA_VACONTEXTID_BASE)
1150 {
1151 DDI_ASSERTMESSAGE("DDI: Invalid contextID");
1152 return VA_STATUS_ERROR_INVALID_CONTEXT;
1153 }
1154
1155 return vaStatus;
1156 }
1157
1158 VAStatus MediaLibvaInterfaceNext::DestroyContext (
1159 VADriverContextP ctx,
1160 VAContextID context)
1161 {
1162 DDI_FUNC_ENTER;
1163
1164 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
1165 PDDI_MEDIA_CONTEXT mediaDrvCtx = GetMediaContext(ctx);
1166
1167 uint32_t ctxType = DDI_MEDIA_CONTEXT_TYPE_NONE;
1168 void *ctxPtr = MediaLibvaCommonNext::GetContextFromContextID(ctx, context, &ctxType);
1169 DDI_CHK_NULL(mediaDrvCtx, "nullptr mediaDrvCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
1170
1171 CompType componentIndex = MapComponentFromCtxType(ctxType);
1172 DDI_CHK_NULL(mediaDrvCtx->m_compList[componentIndex], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
1173
1174 if(componentIndex != CompCodec && componentIndex != CompEncode &&
1175 componentIndex != CompDecode && componentIndex != CompVp &&
1176 componentIndex != CompCp)
1177 {
1178 return VA_STATUS_ERROR_INVALID_CONTEXT;
1179 }
1180 return mediaDrvCtx->m_compList[componentIndex]->DestroyContext(ctx, context);
1181 }
1182
1183 VAStatus MediaLibvaInterfaceNext::CreateBuffer (
1184 VADriverContextP ctx,
1185 VAContextID context,
1186 VABufferType type,
1187 uint32_t size,
1188 uint32_t elementsNum,
1189 void *data,
1190 VABufferID *bufId)
1191 {
1192 DDI_FUNC_ENTER;
1193 int32_t event[] = {size, elementsNum, type};
1194 MOS_TraceEventExt(EVENT_VA_BUFFER, EVENT_TYPE_START, event, sizeof(event), nullptr, 0);
1195
1196 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
1197 DDI_CHK_NULL(bufId, "nullptr bufId", VA_STATUS_ERROR_INVALID_PARAMETER);
1198 DDI_CHK_LARGER(size, 0, "Invalid size", VA_STATUS_ERROR_INVALID_PARAMETER);
1199
1200 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
1201 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
1202
1203 uint32_t ctxType = DDI_MEDIA_CONTEXT_TYPE_NONE;
1204 void *ctxPtr = MediaLibvaCommonNext::GetContextFromContextID(ctx, context, &ctxType);
1205 DDI_CHK_NULL(ctxPtr, "nullptr ctxPtr", VA_STATUS_ERROR_INVALID_CONTEXT);
1206
1207 CompType componentIndex = MapComponentFromCtxType(ctxType);
1208 DDI_CHK_NULL(mediaCtx->m_compList[componentIndex], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
1209 *bufId = VA_INVALID_ID;
1210
1211 MosUtilities::MosLockMutex(&mediaCtx->BufferMutex);
1212 VAStatus vaStatus = mediaCtx->m_compList[componentIndex]->CreateBuffer(ctx, context, type, size, elementsNum, data, bufId);
1213 MosUtilities::MosUnlockMutex(&mediaCtx->BufferMutex);
1214
1215 MOS_TraceEventExt(EVENT_VA_BUFFER, EVENT_TYPE_END, bufId, sizeof(bufId), nullptr, 0);
1216 return vaStatus;
1217 }
1218
1219 VAStatus MediaLibvaInterfaceNext::DestroyBuffer (
1220 VADriverContextP ctx,
1221 VABufferID bufId)
1222 {
1223 PDDI_MEDIA_CONTEXT mediaCtx = nullptr;
1224 DDI_MEDIA_BUFFER *buf = nullptr;
1225 uint32_t ctxType = DDI_MEDIA_CONTEXT_TYPE_NONE;
1226
1227 DDI_FUNC_ENTER;
1228 MOS_TraceEventExt(EVENT_VA_FREE_BUFFER, EVENT_TYPE_START, &bufId, sizeof(bufId), nullptr, 0);
1229
1230 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
1231
1232 mediaCtx = GetMediaContext(ctx);
1233 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
1234 DDI_CHK_NULL(mediaCtx->pBufferHeap, "nullptr mediaCtx->pBufferHeap", VA_STATUS_ERROR_INVALID_CONTEXT);
1235 DDI_CHK_LESS((uint32_t)bufId, mediaCtx->pBufferHeap->uiAllocatedHeapElements, "Invalid bufId", VA_STATUS_ERROR_INVALID_BUFFER);
1236
1237 buf = MediaLibvaCommonNext::GetBufferFromVABufferID(mediaCtx, bufId);
1238 DDI_CHK_NULL(buf, "nullptr buf", VA_STATUS_ERROR_INVALID_BUFFER);
1239
1240 ctxType = MediaLibvaCommonNext::GetCtxTypeFromVABufferID(mediaCtx, bufId);
1241
1242 CompType componentIndex = MapComponentFromCtxType(ctxType);
1243 DDI_CHK_NULL(mediaCtx->m_compList[componentIndex], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
1244
1245 VAStatus vaStatus = mediaCtx->m_compList[componentIndex]->DestroyBuffer(mediaCtx, bufId);
1246
1247 MOS_TraceEventExt(EVENT_VA_FREE_BUFFER, EVENT_TYPE_END, nullptr, 0, nullptr, 0);
1248 return vaStatus;
1249 }
1250
1251 VAStatus MediaLibvaInterfaceNext::BeginPicture (
1252 VADriverContextP ctx,
1253 VAContextID context,
1254 VASurfaceID renderTarget)
1255 {
1256 DDI_FUNC_ENTER;
1257
1258 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
1259
1260 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
1261
1262 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
1263 DDI_CHK_NULL(mediaCtx->pSurfaceHeap, "nullptr mediaCtx->pSurfaceHeap", VA_STATUS_ERROR_INVALID_CONTEXT);
1264 DDI_CHK_LESS((uint32_t)renderTarget, mediaCtx->pSurfaceHeap->uiAllocatedHeapElements, "renderTarget", VA_STATUS_ERROR_INVALID_SURFACE);
1265
1266 uint32_t ctxType = DDI_MEDIA_CONTEXT_TYPE_NONE;
1267 void *ctxPtr = MediaLibvaCommonNext::GetContextFromContextID(ctx, context, &ctxType);
1268 uint32_t event[] = {(uint32_t)context, ctxType, (uint32_t)renderTarget};
1269 MOS_TraceEventExt(EVENT_VA_PICTURE, EVENT_TYPE_START, event, sizeof(event), nullptr, 0);
1270
1271 PDDI_MEDIA_SURFACE surface = MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, renderTarget);
1272 DDI_CHK_NULL(surface, "nullptr surface", VA_STATUS_ERROR_INVALID_SURFACE);
1273
1274 MosUtilities::MosLockMutex(&mediaCtx->SurfaceMutex);
1275 surface->curCtxType = ctxType;
1276 surface->curStatusReportQueryState = DDI_MEDIA_STATUS_REPORT_QUERY_STATE_PENDING;
1277 if(ctxType == DDI_MEDIA_CONTEXT_TYPE_VP)
1278 {
1279 surface->curStatusReport.vpp.status = VPREP_NOTAVAILABLE;
1280 }
1281 MosUtilities::MosUnlockMutex(&mediaCtx->SurfaceMutex);
1282
1283 CompType componentIndex = MapComponentFromCtxType(ctxType);
1284 DDI_CHK_NULL(mediaCtx->m_compList[componentIndex], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
1285
1286 return mediaCtx->m_compList[componentIndex]->BeginPicture(ctx, context, renderTarget);
1287 }
1288
1289 VAStatus MediaLibvaInterfaceNext::RenderPicture (
1290 VADriverContextP ctx,
1291 VAContextID context,
1292 VABufferID *buffers,
1293 int32_t buffersNum)
1294 {
1295 DDI_FUNC_ENTER;
1296
1297 DDI_CHK_NULL( ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
1298 DDI_CHK_NULL( buffers, "nullptr buffers", VA_STATUS_ERROR_INVALID_PARAMETER);
1299 DDI_CHK_LARGER(buffersNum, 0, "Invalid number buffers", VA_STATUS_ERROR_INVALID_PARAMETER);
1300 uint32_t event[] = {(uint32_t)context, (uint32_t)buffersNum};
1301 MOS_TraceEventExt(EVENT_VA_PICTURE, EVENT_TYPE_INFO, event, sizeof(event), buffers, buffersNum*sizeof(VAGenericID));
1302
1303 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
1304 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
1305 DDI_CHK_NULL(mediaCtx->pBufferHeap, "nullptr mediaCtx->pBufferHeap", VA_STATUS_ERROR_INVALID_CONTEXT);
1306
1307 for(int32_t i = 0; i < buffersNum; i++)
1308 {
1309 DDI_CHK_LESS((uint32_t)buffers[i], mediaCtx->pBufferHeap->uiAllocatedHeapElements, "Invalid Buffer", VA_STATUS_ERROR_INVALID_BUFFER);
1310 }
1311
1312 uint32_t ctxType = DDI_MEDIA_CONTEXT_TYPE_NONE;
1313 void *ctxPtr = MediaLibvaCommonNext::GetContextFromContextID(ctx, context, &ctxType);
1314 CompType componentIndex = MapComponentFromCtxType(ctxType);
1315 DDI_CHK_NULL(mediaCtx->m_compList[componentIndex], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
1316
1317 return mediaCtx->m_compList[componentIndex]->RenderPicture(ctx, context, buffers, buffersNum);
1318 }
1319
1320 VAStatus MediaLibvaInterfaceNext::EndPicture(
1321 VADriverContextP ctx,
1322 VAContextID context)
1323 {
1324 DDI_FUNC_ENTER;
1325
1326 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
1327
1328 uint32_t ctxType = DDI_MEDIA_CONTEXT_TYPE_NONE;
1329 void *ctxPtr = MediaLibvaCommonNext::GetContextFromContextID(ctx, context, &ctxType);
1330
1331 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
1332 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
1333 CompType componentIndex = MapComponentFromCtxType(ctxType);
1334 DDI_CHK_NULL(mediaCtx->m_compList[componentIndex], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
1335
1336 VAStatus vaStatus = mediaCtx->m_compList[componentIndex]->EndPicture(ctx, context);
1337
1338 MOS_TraceEventExt(EVENT_VA_PICTURE, EVENT_TYPE_END, &context, sizeof(context), &vaStatus, sizeof(vaStatus));
1339 PERF_UTILITY_STOP_ONCE("First Frame Time", PERF_MOS, PERF_LEVEL_DDI);
1340
1341 return vaStatus;
1342 }
1343
1344 VAStatus MediaLibvaInterfaceNext::SyncSurface(
1345 VADriverContextP ctx,
1346 VASurfaceID renderTarget)
1347 {
1348 DDI_FUNC_ENTER;
1349 MOS_TraceEventExt(EVENT_VA_SYNC, EVENT_TYPE_START, &renderTarget, sizeof(VAGenericID), nullptr, 0);
1350
1351 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
1352
1353 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
1354 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
1355 DDI_CHK_NULL(mediaCtx->pSurfaceHeap, "nullptr mediaCtx->pSurfaceHeap", VA_STATUS_ERROR_INVALID_CONTEXT);
1356 DDI_CHK_LESS((uint32_t)renderTarget, mediaCtx->pSurfaceHeap->uiAllocatedHeapElements, "Invalid renderTarget", VA_STATUS_ERROR_INVALID_SURFACE);
1357
1358 DDI_MEDIA_SURFACE *surface = MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, renderTarget);
1359 DDI_CHK_NULL(surface, "nullptr surface", VA_STATUS_ERROR_INVALID_CONTEXT);
1360 if (surface->pCurrentFrameSemaphore)
1361 {
1362 MediaLibvaUtilNext::WaitSemaphore(surface->pCurrentFrameSemaphore);
1363 MediaLibvaUtilNext::PostSemaphore(surface->pCurrentFrameSemaphore);
1364 }
1365
1366 MOS_TraceEventExt(EVENT_VA_SYNC, EVENT_TYPE_INFO, surface->bo? &surface->bo->handle:nullptr, sizeof(uint32_t), nullptr, 0);
1367 // check the bo here?
1368 // zero is a expected return value
1369 uint32_t timeout_NS = 100000000;
1370 while (0 != mos_bo_wait(surface->bo, timeout_NS))
1371 {
1372 // Just loop while gem_bo_wait times-out.
1373 }
1374
1375 MOS_TraceEventExt(EVENT_VA_SYNC, EVENT_TYPE_END, nullptr, 0, nullptr, 0);
1376
1377 CompType componentIndex = CompCommon;
1378 PDDI_DECODE_CONTEXT decCtx = (PDDI_DECODE_CONTEXT)surface->pDecCtx;
1379 if (decCtx && surface->curCtxType == DDI_MEDIA_CONTEXT_TYPE_DECODER)
1380 {
1381 componentIndex = CompDecode;
1382 }
1383 else if (surface->curCtxType == DDI_MEDIA_CONTEXT_TYPE_VP)
1384 {
1385 componentIndex = CompVp;
1386 }
1387
1388 DDI_CHK_NULL(mediaCtx->m_compList[componentIndex], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
1389 return mediaCtx->m_compList[componentIndex]->StatusCheck(mediaCtx, surface, renderTarget);
1390 }
1391
1392 VAStatus MediaLibvaInterfaceNext::QuerySurfaceError(
1393 VADriverContextP ctx,
1394 VASurfaceID renderTarget,
1395 VAStatus errorStatus,
1396 void **errorInfo)
1397 {
1398 return VA_STATUS_SUCCESS;
1399 }
1400
1401 VAStatus MediaLibvaInterfaceNext::PutSurface(
1402 VADriverContextP ctx,
1403 VASurfaceID surface,
1404 void *draw,
1405 int16_t srcx,
1406 int16_t srcy,
1407 uint16_t srcw,
1408 uint16_t srch,
1409 int16_t destx,
1410 int16_t desty,
1411 uint16_t destw,
1412 uint16_t desth,
1413 VARectangle *cliprects, /* client supplied clip list */
1414 uint32_t numberCliprects, /* number of clip rects in the clip list */
1415 uint32_t flags) /* de-interlacing flags */
1416 {
1417 DDI_FUNC_ENTER;
1418
1419 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_PARAMETER);
1420 if(numberCliprects > 0)
1421 {
1422 DDI_CHK_NULL(cliprects, "nullptr cliprects", VA_STATUS_ERROR_INVALID_PARAMETER);
1423 }
1424
1425 PDDI_MEDIA_CONTEXT mediaDrvCtx = GetMediaContext(ctx);
1426
1427 DDI_CHK_NULL(mediaDrvCtx, "nullptr mediaDrvCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
1428 DDI_CHK_NULL(mediaDrvCtx->m_compList[CompVp], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
1429
1430 return mediaDrvCtx->m_compList[CompVp]->PutSurface(ctx, surface, draw, srcx, srcy, srcw, srch, destx, desty, destw, desth, cliprects, numberCliprects, flags);
1431 }
1432
1433 VAImage* MediaLibvaInterfaceNext::GetVAImageFromVAImageID(PDDI_MEDIA_CONTEXT mediaCtx, VAImageID imageID)
1434 {
1435 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", nullptr);
1436
1437 uint32_t i = (uint32_t)imageID;
1438 DDI_CHK_LESS(i, mediaCtx->pImageHeap->uiAllocatedHeapElements, "invalid image id", nullptr);
1439 MosUtilities::MosLockMutex(&mediaCtx->ImageMutex);
1440
1441 PDDI_MEDIA_IMAGE_HEAP_ELEMENT imageElement = (PDDI_MEDIA_IMAGE_HEAP_ELEMENT)mediaCtx->pImageHeap->pHeapBase;
1442 imageElement += i;
1443 VAImage *vaImage = imageElement->pImage;
1444
1445 MosUtilities::MosUnlockMutex(&mediaCtx->ImageMutex);
1446
1447 return vaImage;
1448 }
1449
1450 bool MediaLibvaInterfaceNext::DestroyImageFromVAImageID(PDDI_MEDIA_CONTEXT mediaCtx, VAImageID imageID)
1451 {
1452 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", false);
1453
1454 MosUtilities::MosLockMutex(&mediaCtx->ImageMutex);
1455
1456 MediaLibvaUtilNext::ReleasePVAImageFromHeap(mediaCtx->pImageHeap, (uint32_t)imageID);
1457 mediaCtx->uiNumImages--;
1458
1459 MosUtilities::MosUnlockMutex(&mediaCtx->ImageMutex);
1460
1461 return true;
1462 }
1463
1464 VAStatus MediaLibvaInterfaceNext::DestroyImage(
1465 VADriverContextP ctx,
1466 VAImageID image)
1467 {
1468 DDI_FUNC_ENTER;
1469 MOS_TraceEventExt(EVENT_VA_FREE_IMAGE, EVENT_TYPE_START, &image, sizeof(image), nullptr, 0);
1470
1471 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
1472 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
1473
1474 DDI_CHK_NULL(mediaCtx, "nullptr Media", VA_STATUS_ERROR_INVALID_CONTEXT);
1475 DDI_CHK_NULL(mediaCtx->pImageHeap, "nullptr mediaCtx->pImageHeap", VA_STATUS_ERROR_INVALID_CONTEXT);
1476 DDI_CHK_LESS((uint32_t)image, mediaCtx->pImageHeap->uiAllocatedHeapElements, "Invalid image", VA_STATUS_ERROR_INVALID_IMAGE);
1477
1478 VAImage *vaImage = GetVAImageFromVAImageID(mediaCtx, image);
1479 if (vaImage == nullptr)
1480 {
1481 return VA_STATUS_ERROR_INVALID_PARAMETER;
1482 }
1483
1484 DDI_CHK_NULL(mediaCtx->m_compList[CompCommon], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
1485 mediaCtx->m_compList[CompCommon]->DestroyBuffer(mediaCtx, vaImage->buf);
1486 MOS_FreeMemory(vaImage);
1487
1488 DestroyImageFromVAImageID(mediaCtx, image);
1489
1490 MOS_TraceEventExt(EVENT_VA_FREE_IMAGE, EVENT_TYPE_END, nullptr, 0, nullptr, 0);
1491 return VA_STATUS_SUCCESS;
1492 }
1493
1494 void MediaLibvaInterfaceNext::CopyPlane(
1495 uint8_t *dst,
1496 uint32_t dstPitch,
1497 uint8_t *src,
1498 uint32_t srcPitch,
1499 uint32_t height)
1500 {
1501 uint32_t rowSize = std::min(dstPitch, srcPitch);
1502 for (int y = 0; y < height; y += 1)
1503 {
1504 MOS_SecureMemcpy(dst, rowSize, src, rowSize);
1505 dst += dstPitch;
1506 src += srcPitch;
1507 }
1508 }
1509
1510 VAStatus MediaLibvaInterfaceNext::CopySurfaceToImage(
1511 VADriverContextP ctx,
1512 DDI_MEDIA_SURFACE *surface,
1513 VAImage *image)
1514 {
1515 DDI_FUNC_ENTER;
1516
1517 DDI_CHK_NULL(ctx, "nullptr ctx.", VA_STATUS_ERROR_INVALID_CONTEXT);
1518 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
1519 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx.", VA_STATUS_ERROR_INVALID_CONTEXT);
1520 DDI_CHK_NULL(surface, "nullptr meida surface.", VA_STATUS_ERROR_INVALID_BUFFER);
1521 uint32_t flag = MOS_LOCKFLAG_READONLY;
1522 VAStatus vaStatus = VA_STATUS_SUCCESS;
1523
1524 //Lock Surface
1525 if ((Media_Format_CPU != surface->format))
1526 {
1527 vaStatus = MediaMemoryDecompress(mediaCtx, surface);
1528
1529 if (vaStatus != VA_STATUS_SUCCESS)
1530 {
1531 DDI_NORMALMESSAGE("surface Decompression fail, continue next steps.");
1532 }
1533 }
1534
1535 void *surfData = MediaLibvaUtilNext::LockSurface(surface, flag);
1536 if (surfData == nullptr)
1537 {
1538 DDI_ASSERTMESSAGE("nullptr surfData.");
1539 return vaStatus;
1540 }
1541
1542 void *imageData = nullptr;
1543 vaStatus = MapBuffer(ctx, image->buf, &imageData);
1544 if (vaStatus != VA_STATUS_SUCCESS)
1545 {
1546 DDI_ASSERTMESSAGE("Failed to map buffer.");
1547 MediaLibvaUtilNext::UnlockSurface(surface);
1548 return vaStatus;
1549 }
1550
1551 uint8_t *ySrc = (uint8_t*)surfData;
1552 uint8_t *yDst = (uint8_t*)imageData;
1553
1554 CopyPlane(yDst, image->pitches[0], ySrc, surface->iPitch, image->height);
1555 if (image->num_planes > 1)
1556 {
1557 uint8_t *uSrc = ySrc + surface->iPitch * surface->iHeight;
1558 uint8_t *uDst = yDst + image->offsets[1];
1559 uint32_t chromaPitch = 0;
1560 uint32_t chromaHeight = 0;
1561 uint32_t imageChromaPitch = 0;
1562 uint32_t imageChromaHeight = 0;
1563 GetChromaPitchHeight(MediaFormatToOsFormat(surface->format), surface->iPitch, surface->iHeight, &chromaPitch, &chromaHeight);
1564 GetChromaPitchHeight(image->format.fourcc, image->pitches[0], image->height, &imageChromaPitch, &imageChromaHeight);
1565 CopyPlane(uDst, image->pitches[1], uSrc, chromaPitch, imageChromaHeight);
1566
1567 if(image->num_planes > 2)
1568 {
1569 uint8_t *vSrc = uSrc + chromaPitch * chromaHeight;
1570 uint8_t *vDst = yDst + image->offsets[2];
1571 CopyPlane(vDst, image->pitches[2], vSrc, chromaPitch, imageChromaHeight);
1572 }
1573 }
1574
1575 vaStatus = UnmapBuffer(ctx, image->buf);
1576 if (vaStatus != VA_STATUS_SUCCESS)
1577 {
1578 DDI_ASSERTMESSAGE("Failed to unmap buffer.");
1579 MediaLibvaUtilNext::UnlockSurface(surface);
1580 return vaStatus;
1581 }
1582
1583 MediaLibvaUtilNext::UnlockSurface(surface);
1584
1585 return vaStatus;
1586 }
1587
1588 VAStatus MediaLibvaInterfaceNext::GetImage(
1589 VADriverContextP ctx,
1590 VASurfaceID surface,
1591 int32_t x, /* coordinates of the upper left source pixel */
1592 int32_t y,
1593 uint32_t width, /* width and height of the region */
1594 uint32_t height,
1595 VAImageID image
1596 )
1597 {
1598 DDI_FUNC_ENTER;
1599
1600 uint32_t event[] = {surface, x, y, width, height, image};
1601 MOS_TraceEventExt(EVENT_VA_GET, EVENT_TYPE_START, &event, sizeof(event), nullptr, 0);
1602
1603 DDI_CHK_NULL(ctx, "nullptr ctx.", VA_STATUS_ERROR_INVALID_CONTEXT);
1604
1605 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
1606 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx.", VA_STATUS_ERROR_INVALID_CONTEXT);
1607
1608 DDI_CHK_NULL(mediaCtx->pSurfaceHeap, "nullptr mediaCtx->pSurfaceHeap.", VA_STATUS_ERROR_INVALID_CONTEXT);
1609 DDI_CHK_NULL(mediaCtx->pImageHeap, "nullptr mediaCtx->pImageHeap.", VA_STATUS_ERROR_INVALID_CONTEXT);
1610 DDI_CHK_LESS((uint32_t)surface, mediaCtx->pSurfaceHeap->uiAllocatedHeapElements, "Invalid surface.", VA_STATUS_ERROR_INVALID_SURFACE);
1611 DDI_CHK_LESS((uint32_t)image, mediaCtx->pImageHeap->uiAllocatedHeapElements, "Invalid image.", VA_STATUS_ERROR_INVALID_IMAGE);
1612
1613 VAImage *vaimg = GetVAImageFromVAImageID(mediaCtx, image);
1614 DDI_CHK_NULL(vaimg, "nullptr vaimg.", VA_STATUS_ERROR_INVALID_IMAGE);
1615
1616 DDI_MEDIA_BUFFER *buf = MediaLibvaCommonNext::GetBufferFromVABufferID(mediaCtx, vaimg->buf);
1617 DDI_CHK_NULL(buf, "nullptr buf.", VA_STATUS_ERROR_INVALID_BUFFER);
1618
1619 DDI_MEDIA_SURFACE *inputSurface = MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, surface);
1620 DDI_CHK_NULL(inputSurface, "nullptr inputSurface.", VA_STATUS_ERROR_INVALID_SURFACE);
1621 DDI_CHK_NULL(inputSurface->bo, "nullptr inputSurface->bo.", VA_STATUS_ERROR_INVALID_SURFACE);
1622
1623 VAStatus vaStatus = VA_STATUS_SUCCESS;
1624 #ifndef _FULL_OPEN_SOURCE
1625 VASurfaceID targetSurface = VA_INVALID_SURFACE;
1626 VASurfaceID outputSurface = surface;
1627
1628 if (inputSurface->format != OsFormatToMediaFormat(vaimg->format.fourcc, vaimg->format.alpha_mask) ||
1629 (width != vaimg->width || height != vaimg->height) &&
1630 (vaimg->format.fourcc != VA_FOURCC_444P &&
1631 vaimg->format.fourcc != VA_FOURCC_422V &&
1632 vaimg->format.fourcc != VA_FOURCC_422H))
1633 {
1634 VAContextID context = VA_INVALID_ID;
1635 //Create VP Context.
1636 DDI_CHK_NULL(mediaCtx->m_compList[CompVp], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
1637 vaStatus = mediaCtx->m_compList[CompVp]->CreateContext(ctx, 0, 0, 0, 0, 0, 0, &context);
1638 DDI_CHK_RET(vaStatus, "Create VP Context failed.");
1639
1640 //Create target surface for VP pipeline.
1641 DDI_MEDIA_FORMAT mediaFmt = OsFormatToMediaFormat(vaimg->format.fourcc, vaimg->format.fourcc);
1642 if (mediaFmt == Media_Format_Count)
1643 {
1644 DDI_ASSERTMESSAGE("Unsupported surface type.");
1645 mediaCtx->m_compList[CompVp]->DestroyContext(ctx, context);
1646 return VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT;
1647 }
1648
1649 PDDI_MEDIA_SURFACE_DESCRIPTOR surfDesc = (PDDI_MEDIA_SURFACE_DESCRIPTOR)MOS_AllocAndZeroMemory(sizeof(DDI_MEDIA_SURFACE_DESCRIPTOR));
1650 if (!surfDesc)
1651 {
1652 DDI_ASSERTMESSAGE("nullptr surfDesc.");
1653 mediaCtx->m_compList[CompVp]->DestroyContext(ctx, context);
1654 return VA_STATUS_ERROR_ALLOCATION_FAILED;
1655 }
1656
1657 surfDesc->uiVaMemType = VA_SURFACE_ATTRIB_MEM_TYPE_VA;
1658 int memType = MOS_MEMPOOL_VIDEOMEMORY;
1659 if (MEDIA_IS_SKU(&mediaCtx->SkuTable, FtrLocalMemory))
1660 {
1661 memType = MOS_MEMPOOL_SYSTEMMEMORY;
1662 }
1663 targetSurface = (VASurfaceID)CreateRenderTarget(mediaCtx, mediaFmt, vaimg->width, vaimg->height, surfDesc, VA_SURFACE_ATTRIB_USAGE_HINT_GENERIC, memType);
1664 if (VA_INVALID_SURFACE == targetSurface)
1665 {
1666 DDI_ASSERTMESSAGE("Create temp surface failed.");
1667 mediaCtx->m_compList[CompVp]->DestroyContext(ctx, context);
1668 return VA_STATUS_ERROR_ALLOCATION_FAILED;
1669 }
1670
1671 VARectangle srcRect, dstRect;
1672 srcRect.x = x;
1673 srcRect.y = y;
1674 srcRect.width = width;
1675 srcRect.height = height;
1676 dstRect.x = 0;
1677 dstRect.y = 0;
1678 dstRect.width = vaimg->width;
1679 dstRect.height = vaimg->height;
1680
1681 //Execute VP pipeline.
1682 vaStatus = mediaCtx->m_compList[CompVp]->ProcessPipeline(ctx, context, surface, &srcRect, targetSurface, &dstRect);
1683 if (vaStatus != VA_STATUS_SUCCESS)
1684 {
1685 DDI_ASSERTMESSAGE("VP Pipeline failed.");
1686 DestroySurfaces(ctx, &targetSurface, 1);
1687 mediaCtx->m_compList[CompVp]->DestroyContext(ctx, context);
1688 return vaStatus;
1689 }
1690 vaStatus = SyncSurface(ctx, targetSurface);
1691 DDI_CHK_RET(vaStatus, "Sync surface failed.");
1692
1693 vaStatus = mediaCtx->m_compList[CompVp]->DestroyContext(ctx, context);
1694 DDI_CHK_RET(vaStatus, "destroy context failed.");
1695
1696 outputSurface = targetSurface;
1697 }
1698
1699 //Get Media Surface from output surface ID
1700 DDI_MEDIA_SURFACE *mediaSurface = MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, outputSurface);
1701 DDI_CHK_NULL(mediaSurface, "nullptr mediaSurface.", VA_STATUS_ERROR_INVALID_SURFACE);
1702 DDI_CHK_NULL(mediaSurface->bo, "nullptr mediaSurface->bo.", VA_STATUS_ERROR_INVALID_SURFACE);
1703
1704 vaStatus = CopySurfaceToImage(ctx, mediaSurface, vaimg);
1705 if (vaStatus != MOS_STATUS_SUCCESS)
1706 {
1707 DDI_ASSERTMESSAGE("Failed to copy surface to image buffer data!");
1708 if(targetSurface != VA_INVALID_SURFACE)
1709 {
1710 DestroySurfaces(ctx, &targetSurface, 1);
1711 }
1712 return vaStatus;
1713 }
1714
1715 //Destroy temp surface if created
1716 if(targetSurface != VA_INVALID_SURFACE)
1717 {
1718 DestroySurfaces(ctx, &targetSurface, 1);
1719 }
1720 #else
1721 vaStatus = CopySurfaceToImage(ctx, inputSurface, vaimg);
1722 DDI_CHK_RET(vaStatus, "Copy surface to image failed.");
1723 #endif
1724
1725 MOS_TraceEventExt(EVENT_VA_GET, EVENT_TYPE_END, nullptr, 0, nullptr, 0);
1726 return VA_STATUS_SUCCESS;
1727 }
1728
1729 VAStatus MediaLibvaInterfaceNext::PutImage(
1730 VADriverContextP ctx,
1731 VASurfaceID surface,
1732 VAImageID image,
1733 int32_t srcX,
1734 int32_t srcY,
1735 uint32_t srcWidth,
1736 uint32_t srcHeight,
1737 int32_t destX,
1738 int32_t destY,
1739 uint32_t destWidth,
1740 uint32_t destHeight
1741 )
1742 {
1743 DDI_FUNC_ENTER;
1744 uint32_t event[] = {surface, image, srcX, srcY, srcWidth, srcHeight, destX, destY, destWidth, destHeight};
1745 MOS_TraceEventExt(EVENT_VA_PUT, EVENT_TYPE_START, &event, sizeof(event), nullptr, 0);
1746
1747 DDI_CHK_NULL(ctx, "nullptr ctx.", VA_STATUS_ERROR_INVALID_CONTEXT);
1748
1749 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
1750 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx.", VA_STATUS_ERROR_INVALID_CONTEXT);
1751
1752 DDI_CHK_NULL(mediaCtx->pSurfaceHeap, "nullptr mediaCtx->pSurfaceHeap.", VA_STATUS_ERROR_INVALID_CONTEXT);
1753 DDI_CHK_NULL(mediaCtx->pImageHeap, "nullptr mediaCtx->pImageHeap.", VA_STATUS_ERROR_INVALID_CONTEXT);
1754 DDI_CHK_LESS((uint32_t)surface, mediaCtx->pSurfaceHeap->uiAllocatedHeapElements, "Invalid surface.", VA_STATUS_ERROR_INVALID_SURFACE);
1755 DDI_CHK_LESS((uint32_t)image, mediaCtx->pImageHeap->uiAllocatedHeapElements, "Invalid image.", VA_STATUS_ERROR_INVALID_IMAGE);
1756
1757 DDI_MEDIA_SURFACE *mediaSurface = MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, surface);
1758 DDI_CHK_NULL(mediaSurface, "nullptr mediaSurface.", VA_STATUS_ERROR_INVALID_SURFACE);
1759 DDI_CHK_NULL(mediaSurface->bo, "Invalid buffer.", VA_STATUS_ERROR_INVALID_BUFFER);
1760
1761 if (mediaSurface->pCurrentFrameSemaphore)
1762 {
1763 MediaLibvaUtilNext::WaitSemaphore(mediaSurface->pCurrentFrameSemaphore);
1764 MediaLibvaUtilNext::PostSemaphore(mediaSurface->pCurrentFrameSemaphore);
1765 }
1766
1767 VAImage *vaimg = GetVAImageFromVAImageID(mediaCtx, image);
1768 DDI_CHK_NULL(vaimg, "Invalid image.", VA_STATUS_ERROR_INVALID_IMAGE);
1769
1770 DDI_MEDIA_BUFFER *buf = MediaLibvaCommonNext::GetBufferFromVABufferID(mediaCtx, vaimg->buf);
1771 DDI_CHK_NULL(buf, "Invalid buffer.", VA_STATUS_ERROR_INVALID_BUFFER);
1772
1773 VAStatus vaStatus = VA_STATUS_SUCCESS;
1774 void *imageData = nullptr;
1775
1776 vaStatus = MapBuffer(ctx, vaimg->buf, &imageData);
1777 DDI_CHK_RET(vaStatus, "MapBuffer failed.");
1778 DDI_CHK_NULL(imageData, "nullptr imageData.", VA_STATUS_ERROR_INVALID_IMAGE);
1779
1780 // VP Pipeline will be called for CSC/Scaling if the surface format or data size is not consistent with image.
1781 if (mediaSurface->format != OsFormatToMediaFormat(vaimg->format.fourcc, vaimg->format.alpha_mask) ||
1782 destWidth != srcWidth || destHeight != srcHeight ||
1783 srcX != 0 || destX != 0 || srcY != 0 || destY != 0)
1784 {
1785 VAContextID context = VA_INVALID_ID;
1786
1787 //Create VP Context.
1788 DDI_CHK_NULL(mediaCtx->m_compList[CompVp], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
1789 vaStatus = mediaCtx->m_compList[CompVp]->CreateContext(ctx, 0, 0, 0, 0, 0, 0, &context);
1790 DDI_CHK_RET(vaStatus, "Create VP Context failed");
1791
1792 //Create temp surface for VP pipeline.
1793 DDI_MEDIA_FORMAT mediaFmt = OsFormatToMediaFormat(vaimg->format.fourcc, vaimg->format.fourcc);
1794 if (mediaFmt == Media_Format_Count)
1795 {
1796 DDI_ASSERTMESSAGE("Unsupported surface type.");
1797 return VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT;
1798 }
1799
1800 int memType = MOS_MEMPOOL_VIDEOMEMORY;
1801 if (MEDIA_IS_SKU(&mediaCtx->SkuTable, FtrLocalMemory))
1802 {
1803 memType = MOS_MEMPOOL_SYSTEMMEMORY;
1804 }
1805 VASurfaceID tempSurface = (VASurfaceID)CreateRenderTarget(mediaCtx, mediaFmt, vaimg->width, vaimg->height, nullptr, VA_SURFACE_ATTRIB_USAGE_HINT_VPP_READ, memType);
1806 if (tempSurface == VA_INVALID_ID)
1807 {
1808 return VA_STATUS_ERROR_ALLOCATION_FAILED;
1809 }
1810
1811 DDI_MEDIA_SURFACE *tempMediaSurface = MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, tempSurface);
1812 DDI_CHK_NULL(tempMediaSurface, "nullptr tempMediaSurface.", VA_STATUS_ERROR_INVALID_SURFACE);
1813
1814 //Lock Surface
1815 void *tempSurfData = MediaLibvaUtilNext::LockSurface(tempMediaSurface, (MOS_LOCKFLAG_READONLY | MOS_LOCKFLAG_WRITEONLY));
1816 if (nullptr == tempSurfData)
1817 {
1818 DestroySurfaces(ctx, &tempSurface, 1);
1819 return VA_STATUS_ERROR_SURFACE_BUSY;
1820 }
1821
1822 //Copy data from image to temp surferce
1823 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1824 if (tempMediaSurface->data_size >= vaimg->data_size)
1825 {
1826 eStatus = MOS_SecureMemcpy(tempSurfData, tempMediaSurface->data_size, imageData, vaimg->data_size);
1827 }
1828 else
1829 {
1830 eStatus = MOS_SecureMemcpy(tempSurfData, tempMediaSurface->data_size, imageData, tempMediaSurface->data_size);
1831 }
1832
1833 if (eStatus != MOS_STATUS_SUCCESS)
1834 {
1835 DDI_ASSERTMESSAGE("Failed to copy image to surface buffer.");
1836 MediaLibvaUtilNext::UnlockSurface(tempMediaSurface);
1837 DestroySurfaces(ctx, &tempSurface, 1);
1838 return VA_STATUS_ERROR_OPERATION_FAILED;
1839 }
1840
1841 vaStatus = UnmapBuffer(ctx, vaimg->buf);
1842 if (vaStatus != VA_STATUS_SUCCESS)
1843 {
1844 DDI_ASSERTMESSAGE("Failed to unmap buffer.");
1845 MediaLibvaUtilNext::UnlockSurface(tempMediaSurface);
1846 DestroySurfaces(ctx, &tempSurface, 1);
1847 return vaStatus;
1848 }
1849
1850 MediaLibvaUtilNext::UnlockSurface(tempMediaSurface);
1851
1852 VARectangle srcRect, dstRect;
1853 srcRect.x = srcX;
1854 srcRect.y = srcY;
1855 srcRect.width = srcWidth;
1856 srcRect.height = srcHeight;
1857 dstRect.x = destX;
1858 dstRect.y = destY;
1859 dstRect.width = destWidth;
1860 dstRect.height = destHeight;
1861
1862 //Execute VP pipeline.
1863 vaStatus = mediaCtx->m_compList[CompVp]->ProcessPipeline(ctx, context, tempSurface, &srcRect, surface, &dstRect);
1864 if (vaStatus != VA_STATUS_SUCCESS)
1865 {
1866 DDI_ASSERTMESSAGE("VP Pipeline failed.");
1867 DestroySurfaces(ctx, &tempSurface, 1);
1868 return vaStatus;
1869 }
1870
1871 vaStatus = SyncSurface(ctx, tempSurface);
1872 DDI_CHK_RET(vaStatus, "sync surface failed.");
1873
1874 vaStatus = DestroySurfaces(ctx, &tempSurface, 1);
1875 DDI_CHK_RET(vaStatus, "destroy surface failed.");
1876
1877 vaStatus = mediaCtx->m_compList[CompVp]->DestroyContext(ctx, context);
1878 }
1879 else
1880 {
1881 //Lock Surface
1882 if ((nullptr != buf->pSurface) && (Media_Format_CPU != mediaSurface->format))
1883 {
1884 vaStatus = MediaMemoryDecompress(mediaCtx, mediaSurface);
1885
1886 if (vaStatus != VA_STATUS_SUCCESS)
1887 {
1888 DDI_NORMALMESSAGE("surface Decompression fail, continue next steps.");
1889 }
1890 }
1891
1892 void *surfData = MediaLibvaUtilNext::LockSurface(mediaSurface, (MOS_LOCKFLAG_READONLY | MOS_LOCKFLAG_WRITEONLY));
1893 if (nullptr == surfData)
1894 {
1895 DDI_ASSERTMESSAGE("Failed to lock surface.");
1896 return VA_STATUS_ERROR_SURFACE_BUSY;
1897 }
1898
1899 if (srcWidth == destWidth && srcHeight == destHeight &&
1900 srcWidth == vaimg->width && srcHeight == vaimg->height &&
1901 srcWidth == mediaSurface->iWidth && srcHeight == mediaSurface->iHeight &&
1902 mediaSurface->data_size == vaimg->data_size &&
1903 (vaimg->num_planes == 1 ||
1904 (vaimg->num_planes > 1 && vaimg->offsets[1] == mediaSurface->iPitch * mediaSurface->iHeight)))
1905 {
1906 //Copy data from image to surface
1907 MOS_STATUS eStatus = MOS_SecureMemcpy(surfData, vaimg->data_size, imageData, vaimg->data_size);
1908 DDI_CHK_CONDITION((eStatus != MOS_STATUS_SUCCESS), "Failed to copy image to surface buffer.", VA_STATUS_ERROR_OPERATION_FAILED);
1909 }
1910 else
1911 {
1912 uint8_t *ySrc = (uint8_t *)imageData + vaimg->offsets[0];
1913 uint8_t *yDst = (uint8_t *)surfData;
1914 CopyPlane(yDst, mediaSurface->iPitch, ySrc, vaimg->pitches[0], srcHeight);
1915
1916 if (vaimg->num_planes > 1)
1917 {
1918 DDI_MEDIA_SURFACE uPlane = *mediaSurface;
1919
1920 uint32_t chromaHeight = 0;
1921 uint32_t chromaPitch = 0;
1922 GetChromaPitchHeight(MediaFormatToOsFormat(uPlane.format), uPlane.iPitch, uPlane.iHeight, &chromaPitch, &chromaHeight);
1923
1924 uint8_t *uSrc = (uint8_t *)imageData + vaimg->offsets[1];
1925 uint8_t *uDst = yDst + mediaSurface->iPitch * mediaSurface->iHeight;
1926 CopyPlane(uDst, chromaPitch, uSrc, vaimg->pitches[1], chromaHeight);
1927 if (vaimg->num_planes > 2)
1928 {
1929 uint8_t *vSrc = (uint8_t *)imageData + vaimg->offsets[2];
1930 uint8_t *vDst = uDst + chromaPitch * chromaHeight;
1931 CopyPlane(vDst, chromaPitch, vSrc, vaimg->pitches[2], chromaHeight);
1932 }
1933 }
1934 }
1935
1936 vaStatus = UnmapBuffer(ctx, vaimg->buf);
1937 if (vaStatus != VA_STATUS_SUCCESS)
1938 {
1939 DDI_ASSERTMESSAGE("Failed to unmap buffer.");
1940 MediaLibvaUtilNext::UnlockSurface(mediaSurface);
1941 return vaStatus;
1942 }
1943
1944 MediaLibvaUtilNext::UnlockSurface(mediaSurface);
1945 }
1946 MOS_TraceEventExt(EVENT_VA_PUT, EVENT_TYPE_END, nullptr, 0, nullptr, 0);
1947 return VA_STATUS_SUCCESS;
1948 }
1949
1950 VAStatus MediaLibvaInterfaceNext::LockSurface(
1951 VADriverContextP ctx,
1952 VASurfaceID surface,
1953 uint32_t *fourcc,
1954 uint32_t *lumaStride,
1955 uint32_t *chromaUStride,
1956 uint32_t *chromaVStride,
1957 uint32_t *lumaOffset,
1958 uint32_t *chromaUOffset,
1959 uint32_t *chromaVOffset,
1960 uint32_t *bufferName,
1961 void **buffer)
1962 {
1963 DDI_FUNC_ENTER;
1964 MOS_TraceEventExt(EVENT_VA_LOCK, EVENT_TYPE_START, &surface, sizeof(surface), nullptr, 0);
1965
1966 DDI_CHK_NULL(ctx, "nullptr context", VA_STATUS_ERROR_INVALID_CONTEXT);
1967 DDI_CHK_NULL(fourcc, "nullptr fourcc", VA_STATUS_ERROR_INVALID_PARAMETER);
1968 DDI_CHK_NULL(lumaStride, "nullptr lumaStride", VA_STATUS_ERROR_INVALID_PARAMETER);
1969 DDI_CHK_NULL(chromaUStride, "nullptr chromaUStride", VA_STATUS_ERROR_INVALID_PARAMETER);
1970 DDI_CHK_NULL(chromaVStride, "nullptr chromaVStride", VA_STATUS_ERROR_INVALID_PARAMETER);
1971 DDI_CHK_NULL(lumaOffset, "nullptr lumaOffset", VA_STATUS_ERROR_INVALID_PARAMETER);
1972 DDI_CHK_NULL(chromaUOffset, "nullptr chromaUOffset", VA_STATUS_ERROR_INVALID_PARAMETER);
1973 DDI_CHK_NULL(chromaVOffset, "nullptr chromaVOffset", VA_STATUS_ERROR_INVALID_PARAMETER);
1974 DDI_CHK_NULL(bufferName, "nullptr bufferName", VA_STATUS_ERROR_INVALID_PARAMETER);
1975 DDI_CHK_NULL(buffer, "nullptr buffer", VA_STATUS_ERROR_INVALID_PARAMETER);
1976
1977 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
1978 DDI_CHK_NULL(mediaCtx, "nullptr Media", VA_STATUS_ERROR_INVALID_CONTEXT);
1979 DDI_CHK_NULL(mediaCtx->pSurfaceHeap, "nullptr mediaCtx->pSurfaceHeap", VA_STATUS_ERROR_INVALID_CONTEXT);
1980 DDI_CHK_LESS((uint32_t)surface, mediaCtx->pSurfaceHeap->uiAllocatedHeapElements, "Invalid surface", VA_STATUS_ERROR_INVALID_SURFACE);
1981
1982 DDI_MEDIA_SURFACE *mediaSurface = MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, surface);
1983
1984 // Decompress surface is needed
1985 DDI_CHK_RET(MediaMemoryDecompress(mediaCtx, mediaSurface), "Decompress surface is failed");
1986
1987 if (nullptr == mediaSurface)
1988 {
1989 // Surface is absent.
1990 buffer = nullptr;
1991 return VA_STATUS_ERROR_INVALID_SURFACE;
1992 }
1993
1994 if (mediaSurface->uiLockedImageID != VA_INVALID_ID)
1995 {
1996 // Surface is locked already.
1997 buffer = nullptr;
1998 return VA_STATUS_ERROR_INVALID_PARAMETER;
1999 }
2000
2001 VAImage tmpImage;
2002 tmpImage.image_id = VA_INVALID_ID;
2003 VAStatus vaStatus = DeriveImage(ctx, surface, &tmpImage);
2004 if (vaStatus != VA_STATUS_SUCCESS)
2005 {
2006 buffer = nullptr;
2007 return vaStatus;
2008 }
2009
2010 mediaSurface->uiLockedImageID = tmpImage.image_id;
2011
2012 vaStatus = MapBuffer(ctx,tmpImage.buf, buffer);
2013 if (vaStatus != VA_STATUS_SUCCESS)
2014 {
2015 buffer = nullptr;
2016 return vaStatus;
2017 }
2018
2019 mediaSurface->uiLockedBufID = tmpImage.buf;
2020
2021 *fourcc = tmpImage.format.fourcc;
2022 *lumaOffset = tmpImage.offsets[0];
2023 *lumaStride = tmpImage.pitches[0];
2024 *chromaUOffset = tmpImage.offsets[1];
2025 *chromaUStride = tmpImage.pitches[1];
2026 *chromaVOffset = tmpImage.offsets[2];
2027 *chromaVStride = tmpImage.pitches[2];
2028 *bufferName = tmpImage.buf;
2029
2030 MOS_TraceEventExt(EVENT_VA_LOCK, EVENT_TYPE_END, nullptr, 0, nullptr, 0);
2031 return VA_STATUS_SUCCESS;
2032 }
2033
2034 //!
2035 //! \brief Unlock surface
2036 //!
2037 //! \param [in] ctx
2038 //! Pointer to VA driver context
2039 //! \param [in] surface
2040 //! VA surface ID
2041 //!
2042 //! \return VAStatus
2043 //! VA_STATUS_SUCCESS if success, else fail reason
2044 //!
2045 VAStatus MediaLibvaInterfaceNext::UnlockSurface(
2046 VADriverContextP ctx,
2047 VASurfaceID surface)
2048 {
2049 DDI_FUNC_ENTER;
2050 MOS_TraceEventExt(EVENT_VA_UNLOCK, EVENT_TYPE_START, &surface, sizeof(surface), nullptr, 0);
2051
2052 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
2053
2054 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
2055 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
2056 DDI_CHK_NULL(mediaCtx->pSurfaceHeap, "nullptr mediaCtx->pSurfaceHeap", VA_STATUS_ERROR_INVALID_CONTEXT);
2057 DDI_CHK_LESS((uint32_t)surface, mediaCtx->pSurfaceHeap->uiAllocatedHeapElements, "Invalid surface", VA_STATUS_ERROR_INVALID_SURFACE);
2058
2059 DDI_MEDIA_SURFACE *mediaSurface = MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, surface);
2060 DDI_CHK_NULL(mediaSurface, "nullptr mediaSurface", VA_STATUS_ERROR_INVALID_SURFACE);
2061
2062 if (mediaSurface->uiLockedImageID == VA_INVALID_ID)
2063 {
2064 return VA_STATUS_ERROR_INVALID_PARAMETER;
2065 }
2066
2067 VABufferID bufID = (VABufferID)(mediaSurface->uiLockedBufID);
2068 VAStatus vaStatus = UnmapBuffer(ctx, bufID);
2069 if (vaStatus != VA_STATUS_SUCCESS)
2070 {
2071 return vaStatus;
2072 }
2073 mediaSurface->uiLockedBufID = VA_INVALID_ID;
2074
2075 VAImageID imageID = (VAImageID)(mediaSurface->uiLockedImageID);
2076 vaStatus = DestroyImage(ctx,imageID);
2077 if (vaStatus != VA_STATUS_SUCCESS)
2078 {
2079 return vaStatus;
2080 }
2081 mediaSurface->uiLockedImageID = VA_INVALID_ID;
2082
2083 MOS_TraceEventExt(EVENT_VA_UNLOCK, EVENT_TYPE_END, nullptr, 0, nullptr, 0);
2084 return VA_STATUS_SUCCESS;
2085 }
2086
2087 VAStatus MediaLibvaInterfaceNext::QueryConfigEntrypoints(
2088 VADriverContextP ctx,
2089 VAProfile profile,
2090 VAEntrypoint *entrypointList,
2091 int32_t *entrypointsNum)
2092 {
2093 DDI_FUNC_ENTER;
2094
2095 PERF_UTILITY_START_ONCE("First Frame Time", PERF_MOS, PERF_LEVEL_DDI);
2096
2097 DDI_CHK_NULL(ctx, "nullptr Ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
2098 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
2099 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
2100 DDI_CHK_NULL(mediaCtx->m_capsNext, "nullptr m_caps", VA_STATUS_ERROR_INVALID_PARAMETER);
2101
2102 DDI_CHK_NULL(entrypointList, "nullptr entrypointList", VA_STATUS_ERROR_INVALID_PARAMETER);
2103 DDI_CHK_NULL(entrypointsNum, "nullptr entrypointsNum", VA_STATUS_ERROR_INVALID_PARAMETER);
2104
2105 return mediaCtx->m_capsNext->QueryConfigEntrypoints(profile, entrypointList, entrypointsNum);
2106 }
2107
2108 VAStatus MediaLibvaInterfaceNext::QueryConfigProfiles(
2109 VADriverContextP ctx,
2110 VAProfile *profileList,
2111 int32_t *profilesNum)
2112 {
2113 DDI_FUNC_ENTER;
2114
2115 DDI_CHK_NULL(ctx, "nullptr Ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
2116 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
2117 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
2118 DDI_CHK_NULL(mediaCtx->m_capsNext, "nullptr m_caps", VA_STATUS_ERROR_INVALID_CONTEXT);
2119
2120 DDI_CHK_NULL(profileList, "nullptr profileList", VA_STATUS_ERROR_INVALID_PARAMETER);
2121 DDI_CHK_NULL(profilesNum, "nullptr profilesNum", VA_STATUS_ERROR_INVALID_PARAMETER);
2122
2123 return mediaCtx->m_capsNext->QueryConfigProfiles(profileList, profilesNum);
2124 }
2125
2126 VAStatus MediaLibvaInterfaceNext::QueryConfigAttributes(
2127 VADriverContextP ctx,
2128 VAConfigID configId,
2129 VAProfile *profile,
2130 VAEntrypoint *entrypoint,
2131 VAConfigAttrib *attribList,
2132 int32_t *attribsNum)
2133 {
2134 DDI_FUNC_ENTER;
2135
2136 DDI_CHK_NULL(profile, "nullptr profile", VA_STATUS_ERROR_INVALID_PARAMETER);
2137 DDI_CHK_NULL(entrypoint, "nullptr entrypoint", VA_STATUS_ERROR_INVALID_PARAMETER);
2138 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
2139 DDI_CHK_NULL(attribList, "nullptr attribList", VA_STATUS_ERROR_INVALID_PARAMETER);
2140 DDI_CHK_NULL(attribsNum, "nullptr attribsNum", VA_STATUS_ERROR_INVALID_PARAMETER);
2141
2142 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
2143 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
2144 DDI_CHK_NULL(mediaCtx->m_capsNext, "nullptr m_caps", VA_STATUS_ERROR_INVALID_PARAMETER);
2145
2146 return mediaCtx->m_capsNext->QueryConfigAttributes(
2147 configId, profile, entrypoint, attribList, attribsNum);
2148 }
2149
2150 VAStatus MediaLibvaInterfaceNext::CreateConfig(
2151 VADriverContextP ctx,
2152 VAProfile profile,
2153 VAEntrypoint entrypoint,
2154 VAConfigAttrib *attribList,
2155 int32_t attribsNum,
2156 VAConfigID *configId
2157 )
2158 {
2159 DDI_FUNC_ENTER;
2160 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
2161 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
2162 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
2163
2164 CompType componentIndex = MapCompTypeFromEntrypoint(entrypoint);
2165 DDI_CHK_NULL(mediaCtx->m_compList[componentIndex], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
2166
2167 return mediaCtx->m_compList[componentIndex]->CreateConfig(
2168 ctx, profile, entrypoint, attribList, attribsNum, configId);
2169 }
2170
2171 VAStatus MediaLibvaInterfaceNext::DestroyConfig(
2172 VADriverContextP ctx,
2173 VAConfigID configId)
2174 {
2175 DDI_FUNC_ENTER;
2176
2177 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
2178
2179 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
2180 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
2181 DDI_CHK_NULL(mediaCtx->m_capsNext, "nullptr m_caps", VA_STATUS_ERROR_INVALID_PARAMETER);
2182
2183 return mediaCtx->m_capsNext->DestroyConfig(configId);
2184 }
2185
2186 VAStatus MediaLibvaInterfaceNext::GetConfigAttributes(
2187 VADriverContextP ctx,
2188 VAProfile profile,
2189 VAEntrypoint entrypoint,
2190 VAConfigAttrib *attribList,
2191 int32_t attribsNum)
2192 {
2193 DDI_FUNC_ENTER;
2194
2195 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
2196 DDI_CHK_NULL(attribList, "nullptr attribList", VA_STATUS_ERROR_INVALID_PARAMETER);
2197
2198 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
2199 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
2200 DDI_CHK_NULL(mediaCtx->m_capsNext, "nullptr m_caps", VA_STATUS_ERROR_INVALID_PARAMETER);
2201
2202 return mediaCtx->m_capsNext->GetConfigAttributes(profile, entrypoint, attribList, attribsNum);
2203 }
2204
2205 VAStatus MediaLibvaInterfaceNext::QuerySurfaceAttributes(
2206 VADriverContextP ctx,
2207 VAConfigID configId,
2208 VASurfaceAttrib *attribList,
2209 uint32_t *attribsNum)
2210 {
2211 DDI_FUNC_ENTER;
2212
2213 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
2214 DDI_CHK_NULL(attribsNum, "nullptr attribsNum", VA_STATUS_ERROR_INVALID_PARAMETER);
2215
2216 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
2217 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
2218 DDI_CHK_NULL(mediaCtx->m_capsNext, "nullptr m_caps", VA_STATUS_ERROR_INVALID_PARAMETER);
2219
2220 return mediaCtx->m_capsNext->QuerySurfaceAttributes(configId, attribList, attribsNum);
2221 }
2222
2223 VAStatus MediaLibvaInterfaceNext::QueryImageFormats(
2224 VADriverContextP ctx,
2225 VAImageFormat *formatList,
2226 int32_t *formatsNum)
2227 {
2228 DDI_FUNC_ENTER;
2229
2230 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
2231 DDI_CHK_NULL(formatList, "nullptr formatList", VA_STATUS_ERROR_INVALID_PARAMETER);
2232 DDI_CHK_NULL(formatsNum, "nullptr formatsNum", VA_STATUS_ERROR_INVALID_PARAMETER);
2233
2234 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
2235 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
2236 DDI_CHK_NULL(mediaCtx->m_capsNext, "nullptr caps", VA_STATUS_ERROR_INVALID_PARAMETER);
2237
2238 return mediaCtx->m_capsNext->QueryImageFormats(formatList, formatsNum);
2239 }
2240
2241 VAStatus MediaLibvaInterfaceNext::SetImagePalette(
2242 VADriverContextP ctx,
2243 VAImageID image,
2244 unsigned char *palette)
2245 {
2246 DDI_UNUSED(ctx);
2247 DDI_UNUSED(image);
2248 DDI_UNUSED(palette);
2249 DDI_FUNC_ENTER;
2250
2251 return VA_STATUS_ERROR_UNIMPLEMENTED;
2252 }
2253
2254 VAStatus MediaLibvaInterfaceNext::QuerySubpictureFormats(
2255 VADriverContextP ctx,
2256 VAImageFormat *formatList,
2257 uint32_t *flags,
2258 uint32_t *formatsNum)
2259 {
2260 DDI_UNUSED(ctx);
2261 DDI_UNUSED(formatList);
2262 DDI_UNUSED(flags);
2263 DDI_UNUSED(formatsNum);
2264
2265 DDI_FUNC_ENTER;
2266
2267 return VA_STATUS_SUCCESS;
2268 }
2269
2270 VAStatus MediaLibvaInterfaceNext::CreateSubpicture(
2271 VADriverContextP ctx,
2272 VAImageID image,
2273 VASubpictureID *subpicture)
2274 {
2275 DDI_UNUSED(ctx);
2276 DDI_UNUSED(image);
2277 DDI_UNUSED(subpicture);
2278
2279 DDI_FUNC_ENTER;
2280
2281 return VA_STATUS_ERROR_UNIMPLEMENTED;
2282 }
2283
2284 VAStatus MediaLibvaInterfaceNext::DestroySubpicture(
2285 VADriverContextP ctx,
2286 VASubpictureID subpicture)
2287 {
2288 DDI_UNUSED(ctx);
2289 DDI_UNUSED(subpicture);
2290
2291 DDI_FUNC_ENTER;
2292
2293 return VA_STATUS_ERROR_UNIMPLEMENTED;
2294 }
2295
2296 VAStatus MediaLibvaInterfaceNext::SetSubpictureImage(
2297 VADriverContextP ctx,
2298 VASubpictureID subpicture,
2299 VAImageID image)
2300 {
2301 DDI_UNUSED(ctx);
2302 DDI_UNUSED(subpicture);
2303 DDI_UNUSED(image);
2304
2305 DDI_FUNC_ENTER;
2306
2307 return VA_STATUS_ERROR_UNIMPLEMENTED;
2308 }
2309
2310 VAStatus MediaLibvaInterfaceNext::SetSubpictureChromakey(
2311 VADriverContextP ctx,
2312 VASubpictureID subpicture,
2313 uint32_t chromakeyMin,
2314 uint32_t chromakeyMax,
2315 uint32_t chromakeyMask)
2316 {
2317 DDI_UNUSED(ctx);
2318 DDI_UNUSED(subpicture);
2319 DDI_UNUSED(chromakeyMin);
2320 DDI_UNUSED(chromakeyMax);
2321 DDI_UNUSED(chromakeyMask);
2322
2323 DDI_FUNC_ENTER;
2324
2325 return VA_STATUS_ERROR_UNIMPLEMENTED;
2326 }
2327
2328 VAStatus MediaLibvaInterfaceNext::SetSubpictureGlobalAlpha(
2329 VADriverContextP ctx,
2330 VASubpictureID subpicture,
2331 float globalAlpha)
2332 {
2333 DDI_UNUSED(ctx);
2334 DDI_UNUSED(subpicture);
2335 DDI_UNUSED(globalAlpha);
2336
2337 DDI_FUNC_ENTER;
2338
2339 return VA_STATUS_ERROR_UNIMPLEMENTED;
2340 }
2341
2342 VAStatus MediaLibvaInterfaceNext::AssociateSubpicture(
2343 VADriverContextP ctx,
2344 VASubpictureID subpicture,
2345 VASurfaceID *targetSurfaces,
2346 int32_t surfacesNum,
2347 int16_t srcX,
2348 int16_t srcY,
2349 uint16_t srcWidth,
2350 uint16_t srcHeight,
2351 int16_t destX,
2352 int16_t destY,
2353 uint16_t destWidth,
2354 uint16_t destHeight,
2355 uint32_t flags)
2356 {
2357 DDI_UNUSED(ctx);
2358 DDI_UNUSED(subpicture);
2359 DDI_UNUSED(targetSurfaces);
2360 DDI_UNUSED(surfacesNum);
2361 DDI_UNUSED(srcX);
2362 DDI_UNUSED(srcY);
2363 DDI_UNUSED(srcWidth);
2364 DDI_UNUSED(srcHeight);
2365 DDI_UNUSED(destX);
2366 DDI_UNUSED(destY);
2367 DDI_UNUSED(destWidth);
2368 DDI_UNUSED(destHeight);
2369 DDI_UNUSED(flags);
2370
2371 DDI_FUNC_ENTER;
2372
2373 return VA_STATUS_ERROR_UNIMPLEMENTED;
2374 }
2375
2376 VAStatus MediaLibvaInterfaceNext::DeassociateSubpicture(
2377 VADriverContextP ctx,
2378 VASubpictureID subpicture,
2379 VASurfaceID *targetSurfaces,
2380 int32_t surfacesNum)
2381 {
2382 DDI_UNUSED(ctx);
2383 DDI_UNUSED(subpicture);
2384 DDI_UNUSED(targetSurfaces);
2385 DDI_UNUSED(surfacesNum);
2386
2387 DDI_FUNC_ENTER;
2388
2389 return VA_STATUS_ERROR_UNIMPLEMENTED;
2390 }
2391
2392 VAStatus MediaLibvaInterfaceNext::SetDisplayAttributes(
2393 VADriverContextP ctx,
2394 VADisplayAttribute *attrList,
2395 int32_t attributesNum)
2396 {
2397 DDI_UNUSED(ctx);
2398 DDI_UNUSED(attrList);
2399 DDI_UNUSED(attributesNum);
2400
2401 DDI_FUNC_ENTER;
2402
2403 return VA_STATUS_ERROR_UNIMPLEMENTED;
2404 }
2405
2406 VAStatus MediaLibvaInterfaceNext::QueryDisplayAttributes(
2407 VADriverContextP ctx,
2408 VADisplayAttribute *attribList,
2409 int32_t *attributesNum)
2410 {
2411 DDI_FUNC_ENTER;
2412
2413 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
2414
2415 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
2416 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
2417 DDI_CHK_NULL(mediaCtx->m_capsNext, "nullptr caps", VA_STATUS_ERROR_INVALID_PARAMETER);
2418
2419 return mediaCtx->m_capsNext->QueryDisplayAttributes(attribList, attributesNum);
2420 }
2421
2422 VAStatus MediaLibvaInterfaceNext::GetDisplayAttributes(
2423 VADriverContextP ctx,
2424 VADisplayAttribute *attribList,
2425 int32_t attributesNum)
2426 {
2427 DDI_FUNC_ENTER;
2428
2429 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
2430
2431 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
2432 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
2433 DDI_CHK_NULL(mediaCtx->m_capsNext, "nullptr caps", VA_STATUS_ERROR_INVALID_PARAMETER);
2434
2435 return mediaCtx->m_capsNext->GetDisplayAttributes(attribList, attributesNum);
2436 }
2437
2438 VAStatus MediaLibvaInterfaceNext::BufferSetNumElements(
2439 VADriverContextP ctx,
2440 VABufferID bufId,
2441 uint32_t elementsNum)
2442 {
2443 DDI_FUNC_ENTER;
2444
2445 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
2446
2447 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
2448 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
2449
2450 DDI_CHK_NULL(mediaCtx->pBufferHeap, "nullptr mediaCtx->pBufferHeap", VA_STATUS_ERROR_INVALID_CONTEXT);
2451 DDI_CHK_LESS((uint32_t)bufId, mediaCtx->pBufferHeap->uiAllocatedHeapElements, "Invalid bufId", VA_STATUS_ERROR_INVALID_BUFFER);
2452
2453 DDI_MEDIA_BUFFER* buf = MediaLibvaCommonNext::GetBufferFromVABufferID(mediaCtx, bufId);
2454 DDI_CHK_NULL(buf, "Invalid buffer.", VA_STATUS_ERROR_INVALID_BUFFER);
2455
2456 // only for VASliceParameterBufferType of buffer, the number of elements can be greater than 1
2457 if(buf->uiType != VASliceParameterBufferType &&
2458 elementsNum > 1)
2459 {
2460 return VA_STATUS_ERROR_INVALID_PARAMETER;
2461 }
2462
2463 if(buf->uiType == VASliceParameterBufferType &&
2464 buf->uiNumElements < elementsNum)
2465 {
2466 MOS_FreeMemory(buf->pData);
2467 buf->iSize = buf->iSize / buf->uiNumElements;
2468 buf->pData = (uint8_t*)MOS_AllocAndZeroMemory(buf->iSize * elementsNum);
2469 buf->iSize = buf->iSize * elementsNum;
2470 }
2471
2472 return VA_STATUS_SUCCESS;
2473 }
2474
2475 CompType MediaLibvaInterfaceNext::MapCompTypeFromEntrypoint(VAEntrypoint entrypoint)
2476 {
2477 DDI_FUNC_ENTER;
2478
2479 switch(entrypoint)
2480 {
2481 case VAEntrypointEncSlice:
2482 case VAEntrypointEncSliceLP:
2483 case VAEntrypointEncPicture:
2484 case VAEntrypointFEI:
2485 case VAEntrypointStats:
2486 return CompEncode;
2487 case VAEntrypointVLD:
2488 return CompDecode;
2489 case VAEntrypointVideoProc:
2490 return CompVp;
2491 case VAEntrypointProtectedContent:
2492 case VAEntrypointProtectedTEEComm:
2493 return CompCp;
2494 default:
2495 return CompCommon;
2496 }
2497 }
2498
2499 VAStatus MediaLibvaInterfaceNext::QueryVideoProcFilters(
2500 VADriverContextP ctx,
2501 VAContextID context,
2502 VAProcFilterType *filters,
2503 uint32_t *filtersNum)
2504 {
2505 DDI_FUNC_ENTER;
2506 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
2507 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
2508 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
2509 DDI_CHK_NULL(mediaCtx->m_compList[CompVp], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
2510
2511 return mediaCtx->m_compList[CompVp]->QueryVideoProcFilters(ctx, context, filters, filtersNum);
2512 }
2513
2514 VAStatus MediaLibvaInterfaceNext::QueryVideoProcFilterCaps(
2515 VADriverContextP ctx,
2516 VAContextID context,
2517 VAProcFilterType type,
2518 void *filterCaps,
2519 uint32_t *filterCapsNum)
2520 {
2521 DDI_FUNC_ENTER;
2522 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
2523 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
2524 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
2525 DDI_CHK_NULL(mediaCtx->m_compList[CompVp], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
2526
2527 return mediaCtx->m_compList[CompVp]->QueryVideoProcFilterCaps(ctx, context, type, filterCaps, filterCapsNum);
2528 }
2529
2530 VAStatus MediaLibvaInterfaceNext::QueryVideoProcPipelineCaps(
2531 VADriverContextP ctx,
2532 VAContextID context,
2533 VABufferID *filters,
2534 uint32_t filtersNum,
2535 VAProcPipelineCaps *pipelineCaps)
2536 {
2537 DDI_FUNC_ENTER;
2538 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
2539 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
2540 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
2541 DDI_CHK_NULL(mediaCtx->m_compList[CompVp], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
2542 DDI_CHK_NULL(mediaCtx->m_compList[CompDecode], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
2543
2544 if(context < DDI_MEDIA_VACONTEXTID_BASE)
2545 {
2546 DDI_ASSERTMESSAGE("Invalid ContextID.");
2547 return VA_STATUS_ERROR_INVALID_CONTEXT;
2548 }
2549
2550 if ((context & DDI_MEDIA_MASK_VACONTEXT_TYPE) == DDI_MEDIA_SOFTLET_VACONTEXTID_VP_OFFSET)
2551 {
2552 return mediaCtx->m_compList[CompVp]->QueryVideoProcPipelineCaps(ctx, context, filters, filtersNum, pipelineCaps);
2553 }
2554 else if ((context & DDI_MEDIA_MASK_VACONTEXT_TYPE) == DDI_MEDIA_SOFTLET_VACONTEXTID_DECODER_OFFSET)
2555 {
2556 //Decode+SFC, go SFC path, the restriction here is the capability of SFC
2557 return mediaCtx->m_compList[CompDecode]->QueryVideoProcPipelineCaps(ctx, context, filters, filtersNum, pipelineCaps);
2558 }
2559 else
2560 {
2561 DDI_ASSERTMESSAGE("Invalid ContextID.");
2562 return VA_STATUS_ERROR_INVALID_CONTEXT;
2563 }
2564 }
2565
2566 VAStatus MediaLibvaInterfaceNext::CreateImage (
2567 VADriverContextP ctx,
2568 VAImageFormat *format,
2569 int32_t width,
2570 int32_t height,
2571 VAImage *image)
2572 {
2573 DDI_FUNC_ENTER;
2574
2575 DDI_CHK_NULL(ctx, "Invalid context!", VA_STATUS_ERROR_INVALID_CONTEXT);
2576 DDI_CHK_NULL(format, "Invalid format!", VA_STATUS_ERROR_INVALID_PARAMETER);
2577 DDI_CHK_NULL(image, "Invalid image!", VA_STATUS_ERROR_INVALID_PARAMETER);
2578 DDI_CHK_LARGER(width, 0, "Invalid width!", VA_STATUS_ERROR_INVALID_PARAMETER);
2579 DDI_CHK_LARGER(height, 0, "Invalid height!", VA_STATUS_ERROR_INVALID_PARAMETER);
2580
2581 int32_t event[] = {width, height, format->fourcc};
2582 VAStatus vaStatus = VA_STATUS_SUCCESS;
2583
2584 MOS_TraceEventExt(EVENT_VA_IMAGE, EVENT_TYPE_START, event, sizeof(event), nullptr, 0);
2585
2586 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
2587 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx.", VA_STATUS_ERROR_INVALID_PARAMETER);
2588 DDI_CHK_NULL(mediaCtx->pGmmClientContext, "nullptr mediaCtx->pGmmClientContext.", VA_STATUS_ERROR_INVALID_PARAMETER);
2589
2590 VAImage *vaimg = (VAImage*)MOS_AllocAndZeroMemory(sizeof(VAImage));
2591 DDI_CHK_NULL(vaimg, "Insufficient to allocate an VAImage.", VA_STATUS_ERROR_ALLOCATION_FAILED);
2592
2593 GMM_RESCREATE_PARAMS gmmParams;
2594 GMM_RESOURCE_INFO *gmmResourceInfo;
2595 MOS_ZeroMemory(&gmmParams, sizeof(gmmParams));
2596
2597 gmmParams.BaseWidth = width;
2598 gmmParams.BaseHeight = height;
2599 gmmParams.ArraySize = 1;
2600 gmmParams.Type = RESOURCE_2D;
2601 gmmParams.Flags.Gpu.Video = true;
2602 gmmParams.Format = MediaLibvaUtilNext::ConvertFourccToGmmFmt(format->fourcc);
2603
2604 if (gmmParams.Format == GMM_FORMAT_INVALID)
2605 {
2606 MOS_FreeMemory(vaimg);
2607 return VA_STATUS_ERROR_UNIMPLEMENTED;
2608 }
2609
2610 gmmResourceInfo = mediaCtx->pGmmClientContext->CreateResInfoObject(&gmmParams);
2611 if(nullptr == gmmResourceInfo)
2612 {
2613 DDI_ASSERTMESSAGE("Gmm Create Resource Failed.");
2614 MOS_FreeMemory(vaimg);
2615 return VA_STATUS_ERROR_ALLOCATION_FAILED;
2616 }
2617
2618 vaStatus = GenerateVaImgFromOsFormat(*format, width, height, gmmResourceInfo, vaimg);
2619 if(vaStatus != VA_STATUS_SUCCESS)
2620 {
2621 DDI_ASSERTMESSAGE("Invaild Input format.");
2622 MOS_FreeMemory(vaimg);
2623 return VA_STATUS_ERROR_ALLOCATION_FAILED;
2624 }
2625
2626 mediaCtx->pGmmClientContext->DestroyResInfoObject(gmmResourceInfo);
2627
2628 DDI_MEDIA_BUFFER *buf = MOS_New(DDI_MEDIA_BUFFER);
2629 if (nullptr == buf)
2630 {
2631 MOS_FreeMemory(vaimg);
2632 return VA_STATUS_ERROR_ALLOCATION_FAILED;
2633 }
2634 buf->uiNumElements = 1;
2635 buf->iSize = vaimg->data_size;
2636 buf->uiType = VAImageBufferType;
2637 buf->format = Media_Format_CPU;//DdiCodec_OsFormatToMediaFormat(vaimg->format.fourcc); //Media_Format_Buffer;
2638 buf->uiOffset = 0;
2639 buf->pMediaCtx = mediaCtx;
2640
2641 //Put Image in untiled buffer for better CPU access?
2642 VAStatus status= MediaLibvaUtilNext::CreateBuffer(buf, mediaCtx->pDrmBufMgr);
2643 if((status != VA_STATUS_SUCCESS))
2644 {
2645 MOS_FreeMemory(vaimg);
2646 MOS_Delete(buf);
2647 return status;
2648 }
2649 buf->TileType = TILING_NONE;
2650
2651 MosUtilities::MosLockMutex(&mediaCtx->BufferMutex);
2652 PDDI_MEDIA_BUFFER_HEAP_ELEMENT bufferHeapElement = MediaLibvaUtilNext::AllocPMediaBufferFromHeap(mediaCtx->pBufferHeap);
2653
2654 if (nullptr == bufferHeapElement)
2655 {
2656 MosUtilities::MosUnlockMutex(&mediaCtx->BufferMutex);
2657 MOS_FreeMemory(vaimg);
2658 MediaLibvaUtilNext::FreeBuffer(buf);
2659 MOS_Delete(buf);
2660 return VA_STATUS_ERROR_MAX_NUM_EXCEEDED;
2661 }
2662
2663 bufferHeapElement->pBuffer = buf;
2664 bufferHeapElement->pCtx = nullptr;
2665 bufferHeapElement->uiCtxType = DDI_MEDIA_CONTEXT_TYPE_MEDIA;
2666
2667 vaimg->buf = bufferHeapElement->uiVaBufferID;
2668 mediaCtx->uiNumBufs++;
2669 MosUtilities::MosUnlockMutex(&mediaCtx->BufferMutex);
2670
2671 MosUtilities::MosLockMutex(&mediaCtx->ImageMutex);
2672 PDDI_MEDIA_IMAGE_HEAP_ELEMENT imageHeapElement = MediaLibvaUtilNext::AllocPVAImageFromHeap(mediaCtx->pImageHeap);
2673 if (nullptr == imageHeapElement)
2674 {
2675 MosUtilities::MosUnlockMutex(&mediaCtx->ImageMutex);
2676 MOS_FreeMemory(vaimg);
2677 return VA_STATUS_ERROR_MAX_NUM_EXCEEDED;
2678 }
2679 imageHeapElement->pImage = vaimg;
2680 mediaCtx->uiNumImages++;
2681 vaimg->image_id = imageHeapElement->uiVaImageID;
2682 MosUtilities::MosUnlockMutex(&mediaCtx->ImageMutex);
2683
2684 *image = *vaimg;
2685 MOS_TraceEventExt(EVENT_VA_IMAGE, EVENT_TYPE_END, &vaimg->image_id, sizeof(VAGenericID), nullptr, 0);
2686 return VA_STATUS_SUCCESS;
2687 }
2688
2689 VAStatus MediaLibvaInterfaceNext::DeriveImage (
2690 VADriverContextP ctx,
2691 VASurfaceID surface,
2692 VAImage *image
2693 )
2694 {
2695 DDI_FUNC_ENTER;
2696 MOS_TraceEventExt(EVENT_VA_DERIVE, EVENT_TYPE_START, nullptr, 0, nullptr, 0);
2697
2698 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
2699 DDI_CHK_NULL(image, "nullptr image", VA_STATUS_ERROR_INVALID_PARAMETER);
2700
2701 VAStatus status = VA_STATUS_SUCCESS;
2702 DDI_MEDIA_BUFFER *buf = nullptr;
2703 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
2704
2705 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
2706
2707 DDI_CHK_NULL(mediaCtx->pSurfaceHeap, "nullptr mediaCtx->pSurfaceHeap", VA_STATUS_ERROR_INVALID_CONTEXT);
2708 DDI_CHK_LESS((uint32_t)surface, mediaCtx->pSurfaceHeap->uiAllocatedHeapElements, "Invalid surface", VA_STATUS_ERROR_INVALID_SURFACE);
2709
2710 DDI_MEDIA_SURFACE *mediaSurface = MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, surface);
2711 DDI_CHK_NULL(mediaSurface, "nullptr mediaSurface", VA_STATUS_ERROR_INVALID_SURFACE);
2712
2713 VAImage *vaimg = (VAImage*)MOS_AllocAndZeroMemory(sizeof(VAImage));
2714 DDI_CHK_NULL(vaimg, "nullptr vaimg", VA_STATUS_ERROR_ALLOCATION_FAILED);
2715
2716 if (mediaSurface->pCurrentFrameSemaphore)
2717 {
2718 MediaLibvaUtilNext::WaitSemaphore(mediaSurface->pCurrentFrameSemaphore);
2719 MediaLibvaUtilNext::PostSemaphore(mediaSurface->pCurrentFrameSemaphore);
2720 }
2721 MosUtilities::MosLockMutex(&mediaCtx->ImageMutex);
2722 PDDI_MEDIA_IMAGE_HEAP_ELEMENT imageHeapElement = MediaLibvaUtilNext::AllocPVAImageFromHeap(mediaCtx->pImageHeap);
2723 if (nullptr == imageHeapElement)
2724 {
2725 MosUtilities::MosUnlockMutex(&mediaCtx->ImageMutex);
2726 MOS_FreeMemory(vaimg);
2727 return VA_STATUS_ERROR_MAX_NUM_EXCEEDED;
2728 }
2729 imageHeapElement->pImage = vaimg;
2730 mediaCtx->uiNumImages++;
2731 vaimg->image_id = imageHeapElement->uiVaImageID;
2732 MosUtilities::MosUnlockMutex(&mediaCtx->ImageMutex);
2733
2734 vaimg->format.fourcc = MediaFormatToOsFormat(mediaSurface->format);
2735 vaimg->width = mediaSurface->iWidth;
2736 vaimg->height = mediaSurface->iRealHeight;
2737 vaimg->format.byte_order = VA_LSB_FIRST;
2738
2739 status = GenerateVaImgFromMediaFormat(mediaSurface, mediaCtx, vaimg);
2740 if (status != VA_STATUS_SUCCESS)
2741 {
2742 MOS_FreeMemory(vaimg);
2743 return status;
2744 }
2745
2746 if ((mediaSurface->pSurfDesc != nullptr) && (mediaSurface->pSurfDesc->uiVaMemType == VA_SURFACE_ATTRIB_MEM_TYPE_USER_PTR))
2747 {
2748 vaimg->num_planes = mediaSurface->pSurfDesc->uiPlanes;
2749 for (uint32_t i = 0; i < vaimg->num_planes; i++)
2750 {
2751 vaimg->pitches[i] = mediaSurface->pSurfDesc->uiPitches[i];
2752 vaimg->offsets[i] = mediaSurface->pSurfDesc->uiOffsets[i];
2753 }
2754 }
2755 mediaCtx->m_capsNext->PopulateColorMaskInfo(&vaimg->format);
2756
2757 buf = MOS_New(DDI_MEDIA_BUFFER);
2758 if (buf == nullptr)
2759 {
2760 MOS_FreeMemory(vaimg);
2761 MOS_Delete(buf);
2762 return VA_STATUS_ERROR_ALLOCATION_FAILED;
2763 }
2764 buf->uiNumElements = 1;
2765 buf->iSize = vaimg->data_size;
2766 buf->uiType = VAImageBufferType;
2767 buf->format = mediaSurface->format;
2768 buf->uiOffset = 0;
2769
2770 buf->bo = mediaSurface->bo;
2771 buf->format = mediaSurface->format;
2772 buf->TileType = mediaSurface->TileType;
2773 buf->pSurface = mediaSurface;
2774 mos_bo_reference(mediaSurface->bo);
2775
2776 MosUtilities::MosLockMutex(&mediaCtx->BufferMutex);
2777 PDDI_MEDIA_BUFFER_HEAP_ELEMENT bufferHeapElement = MediaLibvaUtilNext::AllocPMediaBufferFromHeap(mediaCtx->pBufferHeap);
2778
2779 if (nullptr == bufferHeapElement)
2780 {
2781 MosUtilities::MosUnlockMutex(&mediaCtx->BufferMutex);
2782 MOS_FreeMemory(vaimg);
2783 MOS_Delete(buf);
2784 return VA_STATUS_ERROR_MAX_NUM_EXCEEDED;
2785 }
2786 bufferHeapElement->pBuffer = buf;
2787 bufferHeapElement->pCtx = nullptr;
2788 bufferHeapElement->uiCtxType = DDI_MEDIA_CONTEXT_TYPE_MEDIA;
2789
2790 vaimg->buf = bufferHeapElement->uiVaBufferID;
2791 mediaCtx->uiNumBufs++;
2792 MosUtilities::MosUnlockMutex(&mediaCtx->BufferMutex);
2793
2794 *image = *vaimg;
2795
2796 MOS_TraceEventExt(EVENT_VA_DERIVE, EVENT_TYPE_END, &surface, sizeof(surface), &vaimg->image_id, sizeof(VAGenericID));
2797 return VA_STATUS_SUCCESS;
2798 }
2799
2800 #if VA_CHECK_VERSION(1, 9, 0)
2801
2802 VAStatus MediaLibvaInterfaceNext::SyncSurface2 (
2803 VADriverContextP ctx,
2804 VASurfaceID surfaceId,
2805 uint64_t timeoutNs
2806 )
2807 {
2808 DDI_FUNC_ENTER;
2809 MOS_TraceEventExt(EVENT_VA_SYNC, EVENT_TYPE_START, &surfaceId, sizeof(VAGenericID), nullptr, 0);
2810
2811 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
2812
2813 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
2814 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
2815 DDI_CHK_NULL(mediaCtx->pSurfaceHeap, "nullptr mediaCtx->pSurfaceHeap", VA_STATUS_ERROR_INVALID_CONTEXT);
2816
2817 DDI_CHK_LESS((uint32_t)surfaceId, mediaCtx->pSurfaceHeap->uiAllocatedHeapElements, "Invalid renderTarget", VA_STATUS_ERROR_INVALID_SURFACE);
2818
2819 DDI_MEDIA_SURFACE *surface = MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, surfaceId);
2820 DDI_CHK_NULL(surface, "nullptr surface", VA_STATUS_ERROR_INVALID_CONTEXT);
2821 if (surface->pCurrentFrameSemaphore)
2822 {
2823 MediaLibvaUtilNext::WaitSemaphore(surface->pCurrentFrameSemaphore);
2824 MediaLibvaUtilNext::PostSemaphore(surface->pCurrentFrameSemaphore);
2825 }
2826 MOS_TraceEventExt(EVENT_VA_SYNC, EVENT_TYPE_INFO, surface->bo? &surface->bo->handle:nullptr, sizeof(uint32_t), nullptr, 0);
2827
2828 if (timeoutNs == VA_TIMEOUT_INFINITE)
2829 {
2830 // zero is an expected return value when not hit timeout
2831 auto ret = mos_bo_wait(surface->bo, DDI_BO_INFINITE_TIMEOUT);
2832 if (0 != ret)
2833 {
2834 DDI_NORMALMESSAGE("vaSyncSurface2: surface is still used by HW\n\r");
2835 return VA_STATUS_ERROR_TIMEDOUT;
2836 }
2837 }
2838 else
2839 {
2840 int64_t timeoutBoWait1 = 0;
2841 int64_t timeoutBoWait2 = 0;
2842 if (timeoutNs >= DDI_BO_MAX_TIMEOUT)
2843 {
2844 timeoutBoWait1 = DDI_BO_MAX_TIMEOUT - 1;
2845 timeoutBoWait2 = timeoutNs - DDI_BO_MAX_TIMEOUT + 1;
2846 }
2847 else
2848 {
2849 timeoutBoWait1 = (int64_t)timeoutNs;
2850 }
2851
2852 // zero is an expected return value when not hit timeout
2853 auto ret = mos_bo_wait(surface->bo, timeoutBoWait1);
2854 if (0 != ret)
2855 {
2856 if (timeoutBoWait2)
2857 {
2858 ret = mos_bo_wait(surface->bo, timeoutBoWait2);
2859 }
2860 if (0 != ret)
2861 {
2862 DDI_NORMALMESSAGE("vaSyncSurface2: surface is still used by HW\n\r");
2863 return VA_STATUS_ERROR_TIMEDOUT;
2864 }
2865 }
2866 }
2867 MOS_TraceEventExt(EVENT_VA_SYNC, EVENT_TYPE_END, nullptr, 0, nullptr, 0);
2868
2869 CompType componentIndex = CompCommon;
2870 PDDI_DECODE_CONTEXT decCtx = (PDDI_DECODE_CONTEXT)surface->pDecCtx;
2871 if (decCtx && surface->curCtxType == DDI_MEDIA_CONTEXT_TYPE_DECODER)
2872 {
2873 componentIndex = CompDecode;
2874 }
2875 else if (surface->curCtxType == DDI_MEDIA_CONTEXT_TYPE_VP)
2876 {
2877 componentIndex = CompVp;
2878 }
2879
2880 DDI_CHK_NULL(mediaCtx->m_compList[componentIndex], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
2881 return mediaCtx->m_compList[componentIndex]->StatusCheck(mediaCtx, surface, surfaceId);
2882 }
2883
2884 VAStatus MediaLibvaInterfaceNext::SyncBuffer (
2885 VADriverContextP ctx,
2886 VABufferID bufId,
2887 uint64_t timeoutNs)
2888 {
2889 PERF_UTILITY_AUTO(__FUNCTION__, "ENCODE", "DDI");
2890
2891 DDI_FUNC_ENTER;
2892 MOS_TraceEventExt(EVENT_VA_SYNC, EVENT_TYPE_START, &bufId, sizeof(bufId), nullptr, 0);
2893
2894 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
2895
2896 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
2897 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
2898 DDI_CHK_NULL(mediaCtx->pBufferHeap, "nullptr mediaCtx->pBufferHeap", VA_STATUS_ERROR_INVALID_CONTEXT);
2899
2900 DDI_CHK_LESS((uint32_t)bufId, mediaCtx->pBufferHeap->uiAllocatedHeapElements, "Invalid buffer", VA_STATUS_ERROR_INVALID_BUFFER);
2901
2902 DDI_MEDIA_BUFFER *buffer = MediaLibvaCommonNext::GetBufferFromVABufferID(mediaCtx, bufId);
2903 DDI_CHK_NULL(buffer, "nullptr buffer", VA_STATUS_ERROR_INVALID_CONTEXT);
2904
2905 MOS_TraceEventExt(EVENT_VA_SYNC, EVENT_TYPE_INFO, buffer->bo? &buffer->bo->handle:nullptr, sizeof(uint32_t), nullptr, 0);
2906 if (timeoutNs == VA_TIMEOUT_INFINITE)
2907 {
2908 // zero is a expected return value when not hit timeout
2909 auto ret = mos_bo_wait(buffer->bo, DDI_BO_INFINITE_TIMEOUT);
2910 if (0 != ret)
2911 {
2912 DDI_NORMALMESSAGE("vaSyncBuffer: buffer is still used by HW\n\r");
2913 return VA_STATUS_ERROR_TIMEDOUT;
2914 }
2915 }
2916 else
2917 {
2918 int64_t timeoutBoWait1 = 0;
2919 int64_t timeoutBoWait2 = 0;
2920 if (timeoutNs >= DDI_BO_MAX_TIMEOUT)
2921 {
2922 timeoutBoWait1 = DDI_BO_MAX_TIMEOUT - 1;
2923 timeoutBoWait2 = timeoutNs - DDI_BO_MAX_TIMEOUT + 1;
2924 }
2925 else
2926 {
2927 timeoutBoWait1 = (int64_t)timeoutNs;
2928 }
2929
2930 // zero is a expected return value when not hit timeout
2931 auto ret = mos_bo_wait(buffer->bo, timeoutBoWait1);
2932 if (0 != ret)
2933 {
2934 if (timeoutBoWait2)
2935 {
2936 ret = mos_bo_wait(buffer->bo, timeoutBoWait2);
2937 }
2938 if (0 != ret)
2939 {
2940 DDI_NORMALMESSAGE("vaSyncBuffer: buffer is still used by HW\n\r");
2941 return VA_STATUS_ERROR_TIMEDOUT;
2942 }
2943 }
2944 }
2945 MOS_TraceEventExt(EVENT_VA_SYNC, EVENT_TYPE_END, nullptr, 0, nullptr, 0);
2946 return VA_STATUS_SUCCESS;
2947 }
2948
2949 #endif
2950
2951 VAStatus MediaLibvaInterfaceNext::QuerySurfaceStatus (
2952 VADriverContextP ctx,
2953 VASurfaceID renderTarget,
2954 VASurfaceStatus *status
2955 )
2956 {
2957 DDI_FUNC_ENTER;
2958
2959 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
2960 DDI_CHK_NULL(status, "nullptr status", VA_STATUS_ERROR_INVALID_PARAMETER);
2961
2962 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
2963 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
2964 DDI_CHK_NULL(mediaCtx->pSurfaceHeap, "nullptr mediaCtx->pSurfaceHeap", VA_STATUS_ERROR_INVALID_CONTEXT);
2965
2966 DDI_CHK_LESS((uint32_t)renderTarget, mediaCtx->pSurfaceHeap->uiAllocatedHeapElements, "Invalid renderTarget", VA_STATUS_ERROR_INVALID_SURFACE);
2967 DDI_MEDIA_SURFACE *surface = MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, renderTarget);
2968 DDI_CHK_NULL(surface, "nullptr surface", VA_STATUS_ERROR_INVALID_SURFACE);
2969
2970 if (surface->pCurrentFrameSemaphore)
2971 {
2972 if(MediaLibvaUtilNext::TryWaitSemaphore(surface->pCurrentFrameSemaphore) == 0)
2973 {
2974 MediaLibvaUtilNext::PostSemaphore(surface->pCurrentFrameSemaphore);
2975 }
2976 else
2977 {
2978 // Return busy state if the surface is not submitted
2979 *status = VASurfaceRendering;
2980 return VA_STATUS_SUCCESS;
2981 }
2982 }
2983
2984 // Query the busy state of bo.
2985 // check the bo here?
2986 if(mos_bo_busy(surface->bo))
2987 {
2988 // busy
2989 *status = VASurfaceRendering;
2990 }
2991 else
2992 {
2993 // idle
2994 *status = VASurfaceReady;
2995 }
2996
2997 return VA_STATUS_SUCCESS;
2998 }
2999
3000 #if VA_CHECK_VERSION(1,11,0)
3001 VAStatus MediaLibvaInterfaceNext::CreateProtectedSession(
3002 VADriverContextP ctx,
3003 VAConfigID configId,
3004 VAProtectedSessionID *protectedSession)
3005 {
3006 DDI_FUNC_ENTER;
3007 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
3008 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
3009 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
3010 DDI_CHK_NULL(mediaCtx->m_compList[CompCp], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
3011
3012 return mediaCtx->m_compList[CompCp]->CreateProtectedSession(ctx, configId, protectedSession);
3013 }
3014
3015 VAStatus MediaLibvaInterfaceNext::DestroyProtectedSession(
3016 VADriverContextP ctx,
3017 VAProtectedSessionID protectedSession)
3018 {
3019 DDI_FUNC_ENTER;
3020 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
3021 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
3022 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
3023 DDI_CHK_NULL(mediaCtx->m_compList[CompCp], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
3024
3025 return mediaCtx->m_compList[CompCp]->DestroyProtectedSession(ctx, protectedSession);
3026 }
3027
3028 VAStatus MediaLibvaInterfaceNext::AttachProtectedSession(
3029 VADriverContextP ctx,
3030 VAContextID context,
3031 VAProtectedSessionID protectedSession)
3032 {
3033 DDI_FUNC_ENTER;
3034 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
3035 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
3036 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
3037 DDI_CHK_NULL(mediaCtx->m_compList[CompCp], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
3038
3039 return mediaCtx->m_compList[CompCp]->AttachProtectedSession(ctx, context, protectedSession);
3040 }
3041
3042 VAStatus MediaLibvaInterfaceNext::DetachProtectedSession(
3043 VADriverContextP ctx,
3044 VAContextID context)
3045 {
3046 DDI_FUNC_ENTER;
3047 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
3048 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
3049 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
3050 DDI_CHK_NULL(mediaCtx->m_compList[CompCp], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
3051
3052 return mediaCtx->m_compList[CompCp]->DetachProtectedSession(ctx, context);
3053 }
3054
3055 VAStatus MediaLibvaInterfaceNext::ProtectedSessionExecute(
3056 VADriverContextP ctx,
3057 VAProtectedSessionID protectedSession,
3058 VABufferID data)
3059 {
3060 DDI_FUNC_ENTER;
3061 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
3062 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
3063 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
3064 DDI_CHK_NULL(mediaCtx->m_compList[CompCp], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
3065
3066 return mediaCtx->m_compList[CompCp]->ProtectedSessionExecute(ctx, protectedSession, data);
3067 }
3068 #endif
3069
3070 CompType MediaLibvaInterfaceNext::MapComponentFromCtxType(uint32_t ctxType)
3071 {
3072 switch (ctxType)
3073 {
3074 case DDI_MEDIA_CONTEXT_TYPE_DECODER:
3075 return CompDecode;
3076 case DDI_MEDIA_CONTEXT_TYPE_ENCODER:
3077 return CompEncode;
3078 case DDI_MEDIA_CONTEXT_TYPE_VP:
3079 return CompVp;
3080 case DDI_MEDIA_CONTEXT_TYPE_PROTECTED:
3081 return CompCp;
3082 default:
3083 return CompCommon;
3084 }
3085 }
3086
3087 VAStatus MediaLibvaInterfaceNext::CreateSurfaces (
3088 VADriverContextP ctx,
3089 int32_t width,
3090 int32_t height,
3091 int32_t format,
3092 int32_t surfacesNum,
3093 VASurfaceID *surfaces
3094 )
3095 {
3096 DDI_FUNC_ENTER;
3097 int32_t event[] = {width, height, format};
3098 MOS_TraceEventExt(EVENT_VA_SURFACE, EVENT_TYPE_START, event, sizeof(event), nullptr, 0);
3099
3100 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
3101 DDI_CHK_LARGER(surfacesNum, 0, "Invalid surfacesNum", VA_STATUS_ERROR_INVALID_PARAMETER);
3102 DDI_CHK_NULL(surfaces, "nullptr surfaces", VA_STATUS_ERROR_INVALID_PARAMETER);
3103 DDI_CHK_LARGER(width, 0, "Invalid width", VA_STATUS_ERROR_INVALID_PARAMETER);
3104 DDI_CHK_LARGER(height, 0, "Invalid height", VA_STATUS_ERROR_INVALID_PARAMETER);
3105
3106 PDDI_MEDIA_CONTEXT mediaDrvCtx = GetMediaContext(ctx);
3107 DDI_CHK_NULL(mediaDrvCtx, "nullptr mediaDrvCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
3108
3109 return VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT;
3110 }
3111
3112 VAStatus MediaLibvaInterfaceNext::DestroySurfaces (
3113 VADriverContextP ctx,
3114 VASurfaceID *surfaces,
3115 int32_t surfacesNum
3116 )
3117 {
3118 DDI_FUNC_ENTER;
3119
3120 DDI_CHK_NULL (ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
3121 DDI_CHK_LARGER(surfacesNum, 0, "Invalid surfacesNum", VA_STATUS_ERROR_INVALID_PARAMETER);
3122 DDI_CHK_NULL (surfaces, "nullptr surfaces", VA_STATUS_ERROR_INVALID_PARAMETER);
3123 MOS_TraceEventExt(EVENT_VA_FREE_SURFACE, EVENT_TYPE_START, &surfacesNum, sizeof(int32_t), surfaces, surfacesNum*sizeof(VAGenericID));
3124
3125 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
3126 DDI_CHK_NULL (mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
3127 DDI_CHK_NULL (mediaCtx->pSurfaceHeap, "nullptr mediaCtx->pSurfaceHeap", VA_STATUS_ERROR_INVALID_CONTEXT);
3128
3129 PDDI_MEDIA_SURFACE surface = nullptr;
3130 for(int32_t i = 0; i < surfacesNum; i++)
3131 {
3132 DDI_CHK_LESS((uint32_t)surfaces[i], mediaCtx->pSurfaceHeap->uiAllocatedHeapElements, "Invalid surfaces", VA_STATUS_ERROR_INVALID_SURFACE);
3133 surface = MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, surfaces[i]);
3134 DDI_CHK_NULL(surface, "nullptr surface", VA_STATUS_ERROR_INVALID_SURFACE);
3135 if(surface->pCurrentFrameSemaphore)
3136 {
3137 MediaLibvaUtilNext::WaitSemaphore(surface->pCurrentFrameSemaphore);
3138 MediaLibvaUtilNext::PostSemaphore(surface->pCurrentFrameSemaphore);
3139 }
3140 if(surface->pReferenceFrameSemaphore)
3141 {
3142 MediaLibvaUtilNext::WaitSemaphore(surface->pReferenceFrameSemaphore);
3143 MediaLibvaUtilNext::PostSemaphore(surface->pReferenceFrameSemaphore);
3144 }
3145 }
3146
3147 for(int32_t i = 0; i < surfacesNum; i++)
3148 {
3149 DDI_CHK_LESS((uint32_t)surfaces[i], mediaCtx->pSurfaceHeap->uiAllocatedHeapElements, "Invalid surfaces", VA_STATUS_ERROR_INVALID_SURFACE);
3150 surface = MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, surfaces[i]);
3151 DDI_CHK_NULL(surface, "nullptr surface", VA_STATUS_ERROR_INVALID_SURFACE);
3152 if(surface->pCurrentFrameSemaphore)
3153 {
3154 MediaLibvaUtilNext::DestroySemaphore(surface->pCurrentFrameSemaphore);
3155 surface->pCurrentFrameSemaphore = nullptr;
3156 }
3157
3158 if(surface->pReferenceFrameSemaphore)
3159 {
3160 MediaLibvaUtilNext::DestroySemaphore(surface->pReferenceFrameSemaphore);
3161 surface->pReferenceFrameSemaphore = nullptr;
3162 }
3163
3164 MediaLibvaUtilNext::UnRegisterRTSurfaces(ctx, surface);
3165
3166 MosUtilities::MosLockMutex(&mediaCtx->SurfaceMutex);
3167 MediaLibvaUtilNext::FreeSurface(surface);
3168 MOS_FreeMemory(surface);
3169 MediaLibvaUtilNext::ReleasePMediaSurfaceFromHeap(mediaCtx->pSurfaceHeap, (uint32_t)surfaces[i]);
3170 mediaCtx->uiNumSurfaces--;
3171 MosUtilities::MosUnlockMutex(&mediaCtx->SurfaceMutex);
3172 }
3173
3174 MOS_TraceEventExt(EVENT_VA_FREE_SURFACE, EVENT_TYPE_END, nullptr, 0, nullptr, 0);
3175 return VA_STATUS_SUCCESS;
3176 }
3177
3178 VAStatus MediaLibvaInterfaceNext::CreateSurfaces2 (
3179 VADriverContextP ctx,
3180 uint32_t format,
3181 uint32_t width,
3182 uint32_t height,
3183 VASurfaceID *surfaces,
3184 uint32_t surfacesNum,
3185 VASurfaceAttrib *attribList,
3186 uint32_t attribsNum
3187 )
3188 {
3189 DDI_FUNC_ENTER;
3190
3191 VAStatus vaStatus = VA_STATUS_SUCCESS;
3192 uint32_t event[] = {width, height, format};
3193 MOS_TraceEventExt(EVENT_VA_SURFACE, EVENT_TYPE_START, event, sizeof(event), nullptr, 0);
3194
3195 DDI_CHK_NULL (ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
3196 DDI_CHK_LARGER(surfacesNum, 0, "Invalid surfacesNum", VA_STATUS_ERROR_INVALID_PARAMETER);
3197 DDI_CHK_NULL (surfaces, "nullptr surfaces", VA_STATUS_ERROR_INVALID_PARAMETER);
3198 DDI_CHK_LARGER(width, 0, "Invalid width", VA_STATUS_ERROR_INVALID_PARAMETER);
3199 DDI_CHK_LARGER(height, 0, "Invalid height", VA_STATUS_ERROR_INVALID_PARAMETER);
3200
3201 if(attribsNum > 0)
3202 {
3203 DDI_CHK_NULL(attribList, "nullptr attribList", VA_STATUS_ERROR_INVALID_PARAMETER);
3204 }
3205
3206 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
3207 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
3208
3209 int32_t expectedFourcc = VA_FOURCC_NV12;
3210
3211 vaStatus = RtFormatToOsFormat(format, expectedFourcc);
3212 if(vaStatus != VA_STATUS_SUCCESS)
3213 {
3214 DDI_ASSERTMESSAGE("Invalid VAConfigAttribRTFormat: 0x%x. Please uses the format defined in libva/va.h", format);
3215 return VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT;
3216 }
3217
3218 VASurfaceAttribExternalBuffers externalBufDescripor;
3219 VADRMPRIMESurfaceDescriptor drmPrimeSurfaceDescriptor;
3220 MosUtilities::MosZeroMemory(&externalBufDescripor, sizeof(VASurfaceAttribExternalBuffers));
3221 MosUtilities::MosZeroMemory(&drmPrimeSurfaceDescriptor, sizeof(VADRMPRIMESurfaceDescriptor));
3222 #if VA_CHECK_VERSION(1, 21, 0)
3223 VADRMPRIME3SurfaceDescriptor drmPrime3SurfaceDescriptor;
3224 MosUtilities::MosZeroMemory(&drmPrime3SurfaceDescriptor, sizeof(VADRMPRIME3SurfaceDescriptor));
3225 #endif
3226
3227 int32_t memTypeFlag = VA_SURFACE_ATTRIB_MEM_TYPE_VA;
3228 int32_t descFlag = 0;
3229 uint32_t surfaceUsageHint = VA_SURFACE_ATTRIB_USAGE_HINT_GENERIC;
3230 bool surfDescProvided = false;
3231 bool surfIsUserPtr = false;
3232
3233 for (uint32_t i = 0; i < attribsNum && attribList; i++)
3234 {
3235 if (attribList[i].flags & VA_SURFACE_ATTRIB_SETTABLE)
3236 {
3237 switch (attribList[i].type)
3238 {
3239 case VASurfaceAttribUsageHint:
3240 DDI_ASSERT(attribList[i].value.type == VAGenericValueTypeInteger);
3241 surfaceUsageHint = attribList[i].value.value.i;
3242 break;
3243 case VASurfaceAttribPixelFormat:
3244 DDI_ASSERT(attribList[i].value.type == VAGenericValueTypeInteger);
3245 expectedFourcc = attribList[i].value.value.i;
3246 break;
3247 case VASurfaceAttribMemoryType:
3248 DDI_ASSERT(attribList[i].value.type == VAGenericValueTypeInteger);
3249 if ((attribList[i].value.value.i == VA_SURFACE_ATTRIB_MEM_TYPE_VA) ||
3250 (attribList[i].value.value.i == VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM) ||
3251 (attribList[i].value.value.i == VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME) ||
3252 (attribList[i].value.value.i == VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2) ||
3253 #if VA_CHECK_VERSION(1, 21, 0)
3254 (attribList[i].value.value.i == VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_3) ||
3255 #endif
3256 (attribList[i].value.value.i == VA_SURFACE_ATTRIB_MEM_TYPE_USER_PTR))
3257 {
3258 memTypeFlag = attribList[i].value.value.i;
3259 surfIsUserPtr = (attribList[i].value.value.i == VA_SURFACE_ATTRIB_MEM_TYPE_USER_PTR);
3260 }
3261 else
3262 {
3263 DDI_ASSERTMESSAGE("Not supported external buffer type.");
3264 return VA_STATUS_ERROR_INVALID_PARAMETER;
3265 }
3266 break;
3267 case (VASurfaceAttribType)VASurfaceAttribExternalBufferDescriptor:
3268 DDI_ASSERT(attribList[i].value.type == VAGenericValueTypePointer);
3269 if( nullptr == attribList[i].value.value.p )
3270 {
3271 DDI_ASSERTMESSAGE("Invalid VASurfaceAttribExternalBuffers used.");
3272 //remove the check for libva-utils conformance test, need libva-utils change cases
3273 //after libva-utils fix the case, return VA_STATUS_ERROR_INVALID_PARAMETER;
3274 break;
3275 }
3276 surfDescProvided = true;
3277 if (memTypeFlag == VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2)
3278 {
3279 MosUtilities::MosSecureMemcpy(&drmPrimeSurfaceDescriptor, sizeof(VADRMPRIMESurfaceDescriptor), attribList[i].value.value.p, sizeof(VADRMPRIMESurfaceDescriptor));
3280 expectedFourcc = drmPrimeSurfaceDescriptor.fourcc;
3281 width = drmPrimeSurfaceDescriptor.width;
3282 height = drmPrimeSurfaceDescriptor.height;
3283 }
3284 #if VA_CHECK_VERSION(1, 21, 0)
3285 else if (memTypeFlag == VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_3)
3286 {
3287 MosUtilities::MosSecureMemcpy(&drmPrime3SurfaceDescriptor, sizeof(VADRMPRIME3SurfaceDescriptor), attribList[i].value.value.p, sizeof(VADRMPRIME3SurfaceDescriptor));
3288 expectedFourcc = drmPrime3SurfaceDescriptor.fourcc;
3289 width = drmPrime3SurfaceDescriptor.width;
3290 height = drmPrime3SurfaceDescriptor.height;
3291 drmPrimeSurfaceDescriptor = *((VADRMPRIMESurfaceDescriptor*)&drmPrime3SurfaceDescriptor);
3292 descFlag = drmPrime3SurfaceDescriptor.flags;
3293 }
3294 #endif
3295 else
3296 {
3297 MosUtilities::MosSecureMemcpy(&externalBufDescripor, sizeof(VASurfaceAttribExternalBuffers), attribList[i].value.value.p, sizeof(VASurfaceAttribExternalBuffers));
3298
3299 expectedFourcc = externalBufDescripor.pixel_format;
3300 width = externalBufDescripor.width;
3301 height = externalBufDescripor.height;
3302 descFlag = externalBufDescripor.flags;
3303 // the following code is for backward compatible problem caused by incorrect use of VA_SURFACE_ATTRIB_MEM_TYPE_XXX in application layer. and it will be removed in the future
3304 // new implemention should use VASurfaceAttribMemoryType attrib and set its value to VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM
3305 if ((externalBufDescripor.flags & VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM )||
3306 (externalBufDescripor.flags & VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME)||
3307 (externalBufDescripor.flags & VA_SURFACE_EXTBUF_DESC_PROTECTED)||
3308 (externalBufDescripor.flags & VA_SURFACE_EXTBUF_DESC_ENABLE_TILING))
3309 {
3310 if (externalBufDescripor.flags & VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM)
3311 {
3312 memTypeFlag = VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM;
3313 }
3314 else if (externalBufDescripor.flags & VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME)
3315 {
3316 memTypeFlag = VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME;
3317 }
3318
3319 descFlag = (externalBufDescripor.flags & ~(VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM | VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME));
3320 surfIsUserPtr = false;
3321 }
3322 }
3323
3324 break;
3325 default:
3326 DDI_ASSERTMESSAGE("Unsupported type.");
3327 break;
3328 }
3329 }
3330 }
3331
3332 DDI_MEDIA_FORMAT mediaFmt = OsFormatToMediaFormat(expectedFourcc, format);
3333 if (mediaFmt == Media_Format_Count)
3334 {
3335 DDI_ASSERTMESSAGE("DDI: unsupported surface type in CreateSurfaces2.");
3336 return VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT;
3337 }
3338
3339 for (uint32_t i = 0; i < surfacesNum; i++)
3340 {
3341 PDDI_MEDIA_SURFACE_DESCRIPTOR surfDesc = nullptr;
3342 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3343
3344 if (surfDescProvided == true)
3345 {
3346 surfDesc = (PDDI_MEDIA_SURFACE_DESCRIPTOR)MOS_AllocAndZeroMemory(sizeof(DDI_MEDIA_SURFACE_DESCRIPTOR));
3347 if (surfDesc == nullptr)
3348 {
3349 return VA_STATUS_ERROR_ALLOCATION_FAILED;
3350 }
3351 surfDesc->uiFlags = descFlag;
3352 surfDesc->uiVaMemType = memTypeFlag;
3353
3354 if (
3355 #if VA_CHECK_VERSION(1, 21, 0)
3356 memTypeFlag == VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_3 ||
3357 #endif
3358 memTypeFlag == VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2)
3359 {
3360 surfDesc->ulBuffer = drmPrimeSurfaceDescriptor.objects[0].fd;
3361 surfDesc->modifier = drmPrimeSurfaceDescriptor.objects[0].drm_format_modifier;
3362 surfDesc->uiSize = drmPrimeSurfaceDescriptor.objects[0].size;
3363 surfDesc->uiBuffserSize = drmPrimeSurfaceDescriptor.objects[0].size;
3364 if(drmPrimeSurfaceDescriptor.num_layers > 1)
3365 {
3366 surfDesc->uiPlanes = drmPrimeSurfaceDescriptor.num_layers;
3367 for (uint32_t k = 0; k < surfDesc->uiPlanes; k ++)
3368 {
3369 surfDesc->uiPitches[k] = drmPrimeSurfaceDescriptor.layers[k].pitch[0];
3370 surfDesc->uiOffsets[k] = drmPrimeSurfaceDescriptor.layers[k].offset[0];
3371 }
3372 }
3373 else
3374 {
3375 surfDesc->uiPlanes = drmPrimeSurfaceDescriptor.layers[0].num_planes;
3376 for(uint32_t k = 0; k < surfDesc->uiPlanes; k ++)
3377 {
3378 surfDesc->uiPitches[k] = drmPrimeSurfaceDescriptor.layers[0].pitch[k];
3379 surfDesc->uiOffsets[k] = drmPrimeSurfaceDescriptor.layers[0].offset[k];
3380 }
3381 }
3382 }
3383 else if (memTypeFlag != VA_SURFACE_ATTRIB_MEM_TYPE_VA)
3384 {
3385 surfDesc->uiPlanes = externalBufDescripor.num_planes;
3386 surfDesc->ulBuffer = externalBufDescripor.buffers[i];
3387 surfDesc->uiSize = externalBufDescripor.data_size;
3388 surfDesc->uiBuffserSize = externalBufDescripor.data_size;
3389
3390 eStatus = MosUtilities::MosSecureMemcpy(surfDesc->uiPitches, sizeof(surfDesc->uiPitches), externalBufDescripor.pitches, sizeof(externalBufDescripor.pitches));
3391 if (eStatus != MOS_STATUS_SUCCESS)
3392 {
3393 MOS_FreeMemory(surfDesc);
3394 DDI_VERBOSEMESSAGE("DDI:Failed to copy surface buffer data!");
3395 return VA_STATUS_ERROR_OPERATION_FAILED;
3396 }
3397 eStatus = MosUtilities::MosSecureMemcpy(surfDesc->uiOffsets, sizeof(surfDesc->uiOffsets), externalBufDescripor.offsets, sizeof(externalBufDescripor.offsets));
3398 if (eStatus != MOS_STATUS_SUCCESS)
3399 {
3400 MOS_FreeMemory(surfDesc);
3401 DDI_VERBOSEMESSAGE("DDI:Failed to copy surface buffer data!");
3402 return VA_STATUS_ERROR_OPERATION_FAILED;
3403 }
3404
3405 if( surfIsUserPtr )
3406 {
3407 surfDesc->uiTile = TILING_NONE;
3408 if (surfDesc->ulBuffer % 4096 != 0)
3409 {
3410 MOS_FreeMemory(surfDesc);
3411 DDI_VERBOSEMESSAGE("Buffer Address is invalid");
3412 return VA_STATUS_ERROR_INVALID_PARAMETER;
3413 }
3414 }
3415 }
3416 }
3417 VASurfaceID vaSurfaceID = (VASurfaceID)CreateRenderTarget(mediaCtx, mediaFmt, width, height, surfDesc, surfaceUsageHint, MOS_MEMPOOL_VIDEOMEMORY);
3418 if (VA_INVALID_ID != vaSurfaceID)
3419 {
3420 surfaces[i] = vaSurfaceID;
3421 }
3422 else
3423 {
3424 // here to release the successful allocated surfaces?
3425 if( nullptr != surfDesc )
3426 {
3427 MOS_FreeMemory(surfDesc);
3428 }
3429 return VA_STATUS_ERROR_ALLOCATION_FAILED;
3430 }
3431 }
3432
3433 MOS_TraceEventExt(EVENT_VA_SURFACE, EVENT_TYPE_END, &surfacesNum, sizeof(uint32_t), surfaces, surfacesNum*sizeof(VAGenericID));
3434 return VA_STATUS_SUCCESS;
3435 }
3436
3437 VAStatus MediaLibvaInterfaceNext::BufferInfo (
3438 VADriverContextP ctx,
3439 VABufferID bufId,
3440 VABufferType *type,
3441 uint32_t *size,
3442 uint32_t *elementsNum)
3443 {
3444 DDI_FUNC_ENTER;
3445
3446 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
3447 DDI_CHK_NULL(type, "nullptr type", VA_STATUS_ERROR_INVALID_PARAMETER);
3448 DDI_CHK_NULL(size, "nullptr size", VA_STATUS_ERROR_INVALID_PARAMETER);
3449 DDI_CHK_NULL(elementsNum, "nullptr num_elements", VA_STATUS_ERROR_INVALID_PARAMETER);
3450
3451 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
3452 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
3453 DDI_CHK_NULL(mediaCtx->pBufferHeap, "nullptr mediaCtx->pBufferHeap", VA_STATUS_ERROR_INVALID_CONTEXT);
3454 DDI_CHK_LESS((uint32_t)bufId, mediaCtx->pBufferHeap->uiAllocatedHeapElements, "Invalid buf_id", VA_STATUS_ERROR_INVALID_BUFFER);
3455
3456 DDI_MEDIA_BUFFER *buf = MediaLibvaCommonNext::GetBufferFromVABufferID(mediaCtx, bufId);
3457 DDI_CHK_NULL(buf, "nullptr buffer", VA_STATUS_ERROR_INVALID_BUFFER);
3458
3459 *type = (VABufferType)buf->uiType;
3460 *size = buf->iSize / buf->uiNumElements;
3461 *elementsNum = buf->uiNumElements;
3462
3463 return VA_STATUS_SUCCESS;
3464 }
3465
3466 VAStatus MediaLibvaInterfaceNext::GetSurfaceAttributes(
3467 VADriverContextP ctx,
3468 VAConfigID config,
3469 VASurfaceAttrib *attribList,
3470 uint32_t attribsNum)
3471 {
3472 DDI_UNUSED(ctx);
3473 DDI_UNUSED(config);
3474 DDI_UNUSED(attribList);
3475 DDI_UNUSED(attribsNum);
3476
3477 DDI_FUNC_ENTER;
3478
3479 VAStatus vaStatus = VA_STATUS_ERROR_UNIMPLEMENTED;
3480
3481 return vaStatus;
3482 }
3483
3484 VAStatus MediaLibvaInterfaceNext::AcquireBufferHandle(
3485 VADriverContextP ctx,
3486 VABufferID bufId,
3487 VABufferInfo *bufInfo)
3488 {
3489 DDI_FUNC_ENTER;
3490
3491 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
3492 DDI_CHK_NULL(bufInfo, "nullptr buf_info", VA_STATUS_ERROR_INVALID_PARAMETER);
3493
3494 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
3495 DDI_CHK_NULL(mediaCtx, "Invalid Media ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
3496
3497 DDI_MEDIA_BUFFER *buf = MediaLibvaCommonNext::GetBufferFromVABufferID(mediaCtx, bufId);
3498 DDI_CHK_NULL(buf, "Invalid Media Buffer", VA_STATUS_ERROR_INVALID_BUFFER);
3499 DDI_CHK_NULL(buf->bo, "Invalid Media Buffer", VA_STATUS_ERROR_INVALID_BUFFER);
3500
3501 // If user did not specify memtype he want's we use something we prefer, we prefer PRIME
3502 if (!bufInfo->mem_type)
3503 {
3504 bufInfo->mem_type = VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME;
3505 }
3506 // now chekcing memtype whether we support it
3507 if ((bufInfo->mem_type != VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME) &&
3508 (bufInfo->mem_type != VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM))
3509 {
3510 return VA_STATUS_ERROR_UNSUPPORTED_MEMORY_TYPE;
3511 }
3512
3513 MosUtilities::MosLockMutex(&mediaCtx->BufferMutex);
3514 // already acquired?
3515 if (buf->uiExportcount)
3516 { // yes, already acquired
3517 // can't provide access thru another memtype
3518 if (buf->uiMemtype != bufInfo->mem_type)
3519 {
3520 MosUtilities::MosUnlockMutex(&mediaCtx->BufferMutex);
3521 return VA_STATUS_ERROR_INVALID_PARAMETER;
3522 }
3523 }
3524 else
3525 { // no, not acquired - doing this now
3526 switch (bufInfo->mem_type)
3527 {
3528 case VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM:
3529 {
3530 uint32_t flink = 0;
3531 if (mos_bo_flink(buf->bo, &flink) != 0)
3532 {
3533 MosUtilities::MosUnlockMutex(&mediaCtx->BufferMutex);
3534 return VA_STATUS_ERROR_INVALID_BUFFER;
3535 }
3536 buf->handle = (intptr_t)flink;
3537 break;
3538 }
3539 case VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME:
3540 {
3541 int32_t prime_fd = 0;
3542 if (mos_bo_export_to_prime(buf->bo, &prime_fd) != 0)
3543 {
3544 MosUtilities::MosUnlockMutex(&mediaCtx->BufferMutex);
3545 return VA_STATUS_ERROR_INVALID_BUFFER;
3546 }
3547 buf->handle = (intptr_t)prime_fd;
3548 break;
3549 }
3550 }
3551 // saving memtepy which was provided to the user
3552 buf->uiMemtype = bufInfo->mem_type;
3553 }
3554
3555 ++buf->uiExportcount;
3556 mos_bo_reference(buf->bo);
3557
3558 bufInfo->type = buf->uiType;
3559 bufInfo->handle = buf->handle;
3560 bufInfo->mem_size = buf->uiNumElements * buf->iSize;
3561
3562 MosUtilities::MosUnlockMutex(&mediaCtx->BufferMutex);
3563 return VA_STATUS_SUCCESS;
3564 }
3565
3566 VAStatus MediaLibvaInterfaceNext::ReleaseBufferHandle(
3567 VADriverContextP ctx,
3568 VABufferID bufId)
3569 {
3570 DDI_FUNC_ENTER;
3571
3572 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
3573
3574 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
3575 DDI_CHK_NULL(mediaCtx, "Invalid Media ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
3576
3577 DDI_MEDIA_BUFFER *buf = MediaLibvaCommonNext::GetBufferFromVABufferID(mediaCtx, bufId);
3578 DDI_CHK_NULL(buf, "Invalid Media Buffer", VA_STATUS_ERROR_INVALID_BUFFER);
3579 DDI_CHK_NULL(buf->bo, "Invalid Media Buffer", VA_STATUS_ERROR_INVALID_BUFFER);
3580
3581 MosUtilities::MosLockMutex(&mediaCtx->BufferMutex);
3582 if (!buf->uiMemtype || !buf->uiExportcount)
3583 {
3584 MosUtilities::MosUnlockMutex(&mediaCtx->BufferMutex);
3585 return VA_STATUS_SUCCESS;
3586 }
3587 mos_bo_unreference(buf->bo);
3588 --buf->uiExportcount;
3589
3590 if (!buf->uiExportcount)
3591 {
3592 switch (buf->uiMemtype)
3593 {
3594 case VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME:
3595 {
3596 close((intptr_t)buf->handle);
3597 break;
3598 }
3599 }
3600 buf->uiMemtype = 0;
3601 }
3602 MosUtilities::MosUnlockMutex(&mediaCtx->BufferMutex);
3603
3604 if (!buf->uiExportcount && buf->bPostponedBufFree)
3605 {
3606 MOS_FreeMemory(buf);
3607 DestroyBufFromVABufferID(mediaCtx, bufId);
3608 }
3609
3610 return VA_STATUS_SUCCESS;
3611 }
3612
3613 VAStatus MediaLibvaInterfaceNext::InitSurfaceDescriptorWithoutAuxTableMgr(
3614 VADRMPRIMESurfaceDescriptor *desc,
3615 uint32_t *formats,
3616 int compositeObject,
3617 uint32_t planesNum,
3618 uint32_t offsetY,
3619 uint32_t offsetU,
3620 uint32_t offsetV,
3621 uint32_t pitch,
3622 uint32_t chromaPitch)
3623 {
3624 DDI_CHK_NULL(desc, "Invaild surface descriptor.", VA_STATUS_ERROR_INVALID_PARAMETER);
3625 DDI_CHK_NULL(formats, "Invaild formats.", VA_STATUS_ERROR_INVALID_PARAMETER);
3626
3627 if(compositeObject)
3628 {
3629 desc->num_layers = 1;
3630 desc->layers[0].drm_format = formats[0];
3631 desc->layers[0].num_planes = planesNum;
3632
3633 for (int i = 0; i < planesNum; i++)
3634 {
3635 desc->layers[0].object_index[i] = 0;
3636 switch(i)
3637 {
3638 case 0:
3639 desc->layers[0].offset[i] = offsetY;
3640 desc->layers[0].pitch[i] = pitch;
3641 break;
3642 case 1:
3643 if (desc->fourcc == VA_FOURCC_YV12)
3644 {
3645 desc->layers[0].offset[i] = offsetV;
3646 }
3647 else
3648 {
3649 desc->layers[0].offset[i] = offsetU;
3650 }
3651 desc->layers[0].pitch[i] = chromaPitch;
3652 break;
3653 case 2:
3654 if (desc->fourcc == VA_FOURCC_YV12)
3655 {
3656 desc->layers[0].offset[i] = offsetU;
3657 }
3658 else
3659 {
3660 desc->layers[0].offset[i] = offsetV;
3661 }
3662 desc->layers[0].pitch[i] = chromaPitch;
3663 break;
3664 default:
3665 DDI_ASSERTMESSAGE("vaExportSurfaceHandle: invalid plan numbers");
3666 }
3667 }
3668 }
3669 else
3670 {
3671 desc->num_layers = planesNum;
3672
3673 for (int i = 0; i < planesNum; i++)
3674 {
3675 desc->layers[i].drm_format = formats[i];
3676 desc->layers[i].num_planes = 1;
3677
3678 desc->layers[i].object_index[0] = 0;
3679
3680 switch(i)
3681 {
3682 case 0:
3683 desc->layers[i].offset[0] = offsetY;
3684 desc->layers[i].pitch[0] = pitch;
3685 break;
3686 case 1:
3687 if (desc->fourcc == VA_FOURCC_YV12)
3688 {
3689 desc->layers[i].offset[0] = offsetV;
3690 }
3691 else
3692 {
3693 desc->layers[i].offset[0] = offsetU;
3694 }
3695 desc->layers[i].pitch[0] = chromaPitch;
3696 break;
3697 case 2:
3698 if (desc->fourcc == VA_FOURCC_YV12)
3699 {
3700 desc->layers[i].offset[0] = offsetU;
3701 }
3702 else
3703 {
3704 desc->layers[i].offset[0] = offsetV;
3705 }
3706 desc->layers[i].pitch[0] = chromaPitch;
3707 break;
3708 default:
3709 DDI_ASSERTMESSAGE("vaExportSurfaceHandle: invalid plan numbers");
3710 }
3711 }
3712 }
3713
3714 return VA_STATUS_SUCCESS;
3715 }
3716
3717 VAStatus MediaLibvaInterfaceNext::InitSurfaceDescriptorWithAuxTableMgr(
3718 VADRMPRIMESurfaceDescriptor *desc,
3719 uint32_t *formats,
3720 int compositeObject,
3721 uint32_t planesNum,
3722 uint32_t offsetY,
3723 uint32_t offsetU,
3724 uint32_t offsetV,
3725 uint32_t auxOffsetY,
3726 uint32_t auxOffsetUV,
3727 int32_t pitch)
3728 {
3729 DDI_CHK_NULL(desc, "Invaild surface descriptor.", VA_STATUS_ERROR_INVALID_PARAMETER);
3730 DDI_CHK_NULL(formats, "Invaild formats.", VA_STATUS_ERROR_INVALID_PARAMETER);
3731
3732 if(compositeObject)
3733 {
3734 desc->num_layers = 1;
3735 desc->layers[0].drm_format = formats[0];
3736 desc->layers[0].num_planes = planesNum;
3737 // For semi-planar formats like NV12, CCS planes follow the Y and UV planes,
3738 // i.e. planes 0 and 1 are used for Y and UV surfaces, planes 2 and 3 for the respective CCS.
3739 for (int i = 0; i < planesNum/2; i++)
3740 {
3741 desc->layers[0].object_index[2*i] = 0;
3742 desc->layers[0].object_index[2*i+1] = 0;
3743 if (i == 0)
3744 {
3745 // Y plane
3746 desc->layers[0].offset[i] = offsetY;
3747 desc->layers[0].pitch[i] = pitch;
3748 // Y aux plane
3749 desc->layers[0].offset[i + planesNum/2] = auxOffsetY;
3750 desc->layers[0].pitch[i + planesNum/2] = pitch/8;
3751 }
3752 else
3753 {
3754 // UV plane
3755 desc->layers[0].offset[i] = offsetU;
3756 desc->layers[0].pitch[i] = pitch;
3757 // UV aux plane
3758 desc->layers[0].offset[i + planesNum/2] = auxOffsetUV;
3759 desc->layers[0].pitch[i + planesNum/2] = pitch/8;
3760 }
3761 }
3762 }
3763 else
3764 {
3765 desc->num_layers = planesNum / 2;
3766
3767 for (int i = 0; i < desc->num_layers; i++)
3768 {
3769 desc->layers[i].drm_format = formats[i];
3770 desc->layers[i].num_planes = 2;
3771 desc->layers[i].object_index[0] = 0;
3772
3773 if (i == 0)
3774 {
3775 desc->layers[i].offset[0] = offsetY;
3776 desc->layers[i].offset[1] = auxOffsetY;
3777 desc->layers[i].pitch[0] = pitch;
3778 desc->layers[i].pitch[1] = pitch/8;
3779 }
3780 else
3781 {
3782 desc->layers[i].offset[0] = offsetU;
3783 desc->layers[i].offset[1] = auxOffsetUV;
3784 desc->layers[i].pitch[0] = pitch;
3785 desc->layers[i].pitch[1] = pitch/8;
3786 }
3787 }
3788 }
3789
3790 return VA_STATUS_SUCCESS;
3791 }
3792
3793 VAStatus MediaLibvaInterfaceNext::ExportSurfaceHandle(
3794 VADriverContextP ctx,
3795 VASurfaceID surfaceId,
3796 uint32_t memType,
3797 uint32_t flags,
3798 void *descriptor)
3799 {
3800 DDI_FUNC_ENTER;
3801
3802 DDI_CHK_NULL(descriptor, "nullptr descriptor", VA_STATUS_ERROR_INVALID_PARAMETER);
3803 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
3804
3805 VAStatus status = VA_STATUS_SUCCESS;
3806 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
3807
3808 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
3809 DDI_CHK_NULL(mediaCtx->pSurfaceHeap, "nullptr mediaCtx->pSurfaceHeap", VA_STATUS_ERROR_INVALID_CONTEXT);
3810 DDI_CHK_LESS((uint32_t)(surfaceId), mediaCtx->pSurfaceHeap->uiAllocatedHeapElements, "Invalid surfaces", VA_STATUS_ERROR_INVALID_SURFACE);
3811
3812 DDI_MEDIA_SURFACE *mediaSurface = MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, surfaceId);
3813 DDI_CHK_NULL(mediaSurface, "nullptr mediaSurface", VA_STATUS_ERROR_INVALID_SURFACE);
3814 DDI_CHK_NULL(mediaSurface->bo, "nullptr mediaSurface->bo", VA_STATUS_ERROR_INVALID_SURFACE);
3815 DDI_CHK_NULL(mediaSurface->pGmmResourceInfo, "nullptr mediaSurface->pGmmResourceInfo", VA_STATUS_ERROR_INVALID_SURFACE);
3816
3817 if (
3818 #if VA_CHECK_VERSION(1, 21, 0)
3819 memType != VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_3 &&
3820 #endif
3821 memType != VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2)
3822 {
3823 DDI_ASSERTMESSAGE("vaExportSurfaceHandle: memory type %08x is not supported.\n", memType);
3824 return VA_STATUS_ERROR_UNSUPPORTED_MEMORY_TYPE;
3825 }
3826
3827 if (mos_bo_export_to_prime(mediaSurface->bo, (int32_t*)&mediaSurface->name))
3828 {
3829 DDI_ASSERTMESSAGE("Failed drm_intel_gem_export_to_prime operation!!!\n");
3830 return VA_STATUS_ERROR_OPERATION_FAILED;
3831 }
3832
3833 VADRMPRIMESurfaceDescriptor *desc = (VADRMPRIMESurfaceDescriptor *)descriptor;
3834 #if VA_CHECK_VERSION(1, 21, 0)
3835 if(memType == VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_3)
3836 {
3837 VADRMPRIME3SurfaceDescriptor *desc = (VADRMPRIME3SurfaceDescriptor *)descriptor;
3838 if(mediaSurface->pGmmResourceInfo->GetSetCpSurfTag(false, 0))
3839 {
3840 desc->flags |= VA_SURFACE_EXTBUF_DESC_PROTECTED;
3841 }
3842 }
3843 #endif
3844
3845 desc->fourcc = MediaFormatToOsFormat(mediaSurface->format);
3846 if(desc->fourcc == VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT)
3847 {
3848 return VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT;
3849 }
3850 desc->width = mediaSurface->iWidth;
3851 desc->height = mediaSurface->iRealHeight;
3852 desc->num_objects = 1;
3853 desc->objects[0].fd = mediaSurface->name;
3854 desc->objects[0].size = mediaSurface->pGmmResourceInfo->GetSizeSurface();
3855
3856 if(VA_STATUS_SUCCESS != MediaLibvaUtilNext::GetSurfaceModifier(mediaCtx, mediaSurface, desc->objects[0].drm_format_modifier))
3857 {
3858 DDI_ASSERTMESSAGE("could not find related modifier values");
3859 return VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT;
3860 }
3861
3862 // Query Aux Plane info form GMM
3863 bool hasAuxPlane = false;
3864 GMM_RESOURCE_FLAG GmmFlags = mediaSurface->pGmmResourceInfo->GetResFlags();
3865
3866 if (((GmmFlags.Gpu.MMC ||
3867 GmmFlags.Gpu.CCS) &&
3868 (GmmFlags.Info.MediaCompressed ||
3869 GmmFlags.Info.RenderCompressed) &&
3870 mediaCtx->m_auxTableMgr) )
3871 {
3872 hasAuxPlane = true;
3873 }
3874 else
3875 {
3876 hasAuxPlane = false;
3877 }
3878
3879 int compositeObject = flags & VA_EXPORT_SURFACE_COMPOSED_LAYERS;
3880
3881 uint32_t formats[4];
3882 uint32_t planesNum = GetPlaneNum(mediaSurface, hasAuxPlane);
3883
3884 if(compositeObject)
3885 {
3886 formats[0] = GetDrmFormatOfCompositeObject(desc->fourcc);
3887 if(!formats[0])
3888 {
3889 DDI_ASSERTMESSAGE("vaExportSurfaceHandle: fourcc %08x is not supported for export as a composite object.\n", desc->fourcc);
3890 return VA_STATUS_ERROR_INVALID_SURFACE;
3891 }
3892 }
3893 else
3894 {
3895 for (int i = 0; i < planesNum; i++)
3896 {
3897 formats[i] = GetDrmFormatOfSeparatePlane(desc->fourcc,i);
3898 if (!formats[i])
3899 {
3900 DDI_ASSERTMESSAGE("vaExportSurfaceHandle: fourcc %08x is not supported for export as separate planes.\n", desc->fourcc);
3901 return VA_STATUS_ERROR_INVALID_SURFACE;
3902 }
3903 }
3904 }
3905
3906 uint32_t pitch, height, chromaPitch, chromaHeight = 0;
3907 pitch = mediaSurface->iPitch;
3908 height = mediaSurface->iRealHeight;
3909 GetChromaPitchHeight(desc->fourcc, pitch, height, &chromaPitch, &chromaHeight);
3910
3911 // Get offset from GMM
3912 GMM_REQ_OFFSET_INFO reqInfo = {0};
3913 reqInfo.Plane = GMM_PLANE_Y;
3914 reqInfo.ReqRender = 1;
3915 mediaSurface->pGmmResourceInfo->GetOffset(reqInfo);
3916 uint32_t offsetY = reqInfo.Render.Offset;
3917 MOS_ZeroMemory(&reqInfo, sizeof(GMM_REQ_OFFSET_INFO));
3918 reqInfo.Plane = GMM_PLANE_U;
3919 reqInfo.ReqRender = 1;
3920 mediaSurface->pGmmResourceInfo->GetOffset(reqInfo);
3921 uint32_t offsetU = reqInfo.Render.Offset;
3922 MOS_ZeroMemory(&reqInfo, sizeof(GMM_REQ_OFFSET_INFO));
3923 reqInfo.Plane = GMM_PLANE_V;
3924 reqInfo.ReqRender = 1;
3925 mediaSurface->pGmmResourceInfo->GetOffset(reqInfo);
3926 uint32_t offsetV = reqInfo.Render.Offset;
3927 uint32_t auxOffsetY = (uint32_t)mediaSurface->pGmmResourceInfo->GetPlanarAuxOffset(0, GMM_AUX_Y_CCS);
3928 uint32_t auxOffsetUV = (uint32_t)mediaSurface->pGmmResourceInfo->GetPlanarAuxOffset(0, GMM_AUX_UV_CCS);
3929
3930 if(hasAuxPlane)
3931 {
3932 status = InitSurfaceDescriptorWithAuxTableMgr(desc, formats, compositeObject, planesNum,
3933 offsetY, offsetU, offsetV, auxOffsetY, auxOffsetUV, mediaSurface->iPitch);
3934 }
3935 else
3936 {
3937 status = InitSurfaceDescriptorWithoutAuxTableMgr(desc, formats, compositeObject, planesNum,
3938 offsetY, offsetU, offsetV, pitch, chromaPitch);
3939 }
3940
3941 return status;
3942 }
3943
3944 bool MediaLibvaInterfaceNext::DestroyBufFromVABufferID(
3945 PDDI_MEDIA_CONTEXT mediaCtx,
3946 VABufferID bufferID)
3947 {
3948 MosUtilities::MosLockMutex(&mediaCtx->BufferMutex);
3949 MediaLibvaUtilNext::ReleasePMediaBufferFromHeap(mediaCtx->pBufferHeap, bufferID);
3950 mediaCtx->uiNumBufs--;
3951 MosUtilities::MosUnlockMutex(&mediaCtx->BufferMutex);
3952 return true;
3953 }
3954
3955 VAStatus MediaLibvaInterfaceNext::GenerateVaImgFromMediaFormat(
3956 DDI_MEDIA_SURFACE *mediaSurface,
3957 PDDI_MEDIA_CONTEXT mediaCtx,
3958 VAImage *vaimg)
3959 {
3960 DDI_CHK_NULL(vaimg, "Invaild VAImage.", VA_STATUS_ERROR_INVALID_PARAMETER);
3961 DDI_CHK_NULL(mediaSurface, "Invaild media surface.", VA_STATUS_ERROR_INVALID_PARAMETER);
3962 DDI_CHK_NULL(mediaCtx, "Invaild media context.", VA_STATUS_ERROR_INVALID_CONTEXT);
3963
3964 GMM_RESOURCE_INFO *gmmResourceInfo = mediaSurface->pGmmResourceInfo;
3965 DDI_CHK_NULL(gmmResourceInfo, "Invaild gmm resource info.", VA_STATUS_ERROR_INVALID_PARAMETER);
3966
3967 GMM_REQ_OFFSET_INFO reqInfo = {0};
3968 reqInfo.Plane = GMM_PLANE_U;
3969 reqInfo.ReqRender = 1;
3970 gmmResourceInfo->GetOffset(reqInfo);
3971 uint32_t offsetU = reqInfo.Render.Offset;
3972 MOS_ZeroMemory(&reqInfo, sizeof(GMM_REQ_OFFSET_INFO));
3973 reqInfo.Plane = GMM_PLANE_V;
3974 reqInfo.ReqRender = 1;
3975 gmmResourceInfo->GetOffset(reqInfo);
3976 uint32_t offsetV = reqInfo.Render.Offset;
3977 vaimg->data_size = (uint32_t)gmmResourceInfo->GetSizeSurface();
3978
3979 switch( mediaSurface->format )
3980 {
3981 case Media_Format_YV12:
3982 case Media_Format_I420:
3983 case Media_Format_IYUV:
3984 vaimg->format.bits_per_pixel = 12;
3985 vaimg->num_planes = 3;
3986 vaimg->pitches[0] = mediaSurface->iPitch;
3987 vaimg->pitches[1] =
3988 vaimg->pitches[2] = mediaSurface->iPitch / 2;
3989 vaimg->offsets[0] = 0;
3990 vaimg->offsets[1] = mediaSurface->iHeight * mediaSurface->iPitch;
3991 vaimg->offsets[2] = vaimg->offsets[1] + vaimg->pitches[1] * MOS_ALIGN_CEIL(mediaSurface->iHeight, 2) / 2;
3992 break;
3993 case Media_Format_A8B8G8R8:
3994 case Media_Format_R8G8B8A8:
3995 case Media_Format_A8R8G8B8:
3996 vaimg->format.bits_per_pixel = 32;
3997 vaimg->format.alpha_mask = RGB_8BIT_ALPHAMASK;
3998 vaimg->num_planes = 1;
3999 vaimg->pitches[0] = mediaSurface->iPitch;
4000 vaimg->offsets[0] = 0;
4001 break;
4002 case Media_Format_X8R8G8B8:
4003 case Media_Format_X8B8G8R8:
4004 vaimg->format.bits_per_pixel = 32;
4005 vaimg->num_planes = 1;
4006 vaimg->pitches[0] = mediaSurface->iPitch;
4007 vaimg->offsets[0] = 0;
4008 break;
4009 case Media_Format_R10G10B10A2:
4010 case Media_Format_B10G10R10A2:
4011 vaimg->format.bits_per_pixel = 32;
4012 vaimg->format.alpha_mask = RGB_10BIT_ALPHAMASK;
4013 vaimg->num_planes = 1;
4014 vaimg->pitches[0] = mediaSurface->iPitch;
4015 vaimg->offsets[0] = 0;
4016 break;
4017 case Media_Format_R10G10B10X2:
4018 case Media_Format_B10G10R10X2:
4019 vaimg->format.bits_per_pixel = 32;
4020 vaimg->num_planes = 1;
4021 vaimg->pitches[0] = mediaSurface->iPitch;
4022 vaimg->offsets[0] = 0;
4023 break;
4024 case Media_Format_R5G6B5:
4025 vaimg->format.bits_per_pixel = 16;
4026 vaimg->data_size = mediaSurface->iPitch * mediaSurface->iHeight;
4027 vaimg->num_planes = 1;
4028 vaimg->pitches[0] = mediaSurface->iPitch;
4029 vaimg->offsets[0] = 0;
4030 break;
4031 case Media_Format_R8G8B8:
4032 vaimg->format.bits_per_pixel = 24;
4033 vaimg->num_planes = 1;
4034 vaimg->pitches[0] = mediaSurface->iPitch;
4035 vaimg->offsets[0] = 0;
4036 break;
4037 case Media_Format_YUY2:
4038 case Media_Format_UYVY:
4039 vaimg->format.bits_per_pixel = 16;
4040 vaimg->data_size = mediaSurface->iPitch * mediaSurface->iHeight;
4041 vaimg->num_planes = 1;
4042 vaimg->pitches[0] = mediaSurface->iPitch;
4043 vaimg->offsets[0] = 0;
4044 break;
4045 case Media_Format_400P:
4046 vaimg->format.bits_per_pixel = 8;
4047 vaimg->num_planes = 1;
4048 vaimg->pitches[0] = mediaSurface->iPitch;
4049 vaimg->offsets[0] = 0;
4050 break;
4051 case Media_Format_444P:
4052 case Media_Format_RGBP:
4053 case Media_Format_BGRP:
4054 vaimg->format.bits_per_pixel = 24;
4055 vaimg->num_planes = 3;
4056 vaimg->pitches[0] =
4057 vaimg->pitches[1] =
4058 vaimg->pitches[2] = mediaSurface->iPitch;
4059 vaimg->offsets[0] = 0;
4060 vaimg->offsets[1] = mediaSurface->iHeight * mediaSurface->iPitch;
4061 vaimg->offsets[2] = mediaSurface->iHeight * mediaSurface->iPitch * 2;
4062 break;
4063 case Media_Format_IMC3:
4064 vaimg->format.bits_per_pixel = 12;
4065 vaimg->num_planes = 3;
4066 vaimg->pitches[0] =
4067 vaimg->pitches[1] =
4068 vaimg->pitches[2] = mediaSurface->iPitch;
4069 vaimg->offsets[0] = 0;
4070 vaimg->offsets[1] = mediaSurface->iHeight * mediaSurface->iPitch;
4071 vaimg->offsets[2] = mediaSurface->iHeight * mediaSurface->iPitch * 3 / 2;
4072 break;
4073 case Media_Format_411P:
4074 vaimg->format.bits_per_pixel = 12;
4075 vaimg->num_planes = 3;
4076 vaimg->pitches[0] =
4077 vaimg->pitches[1] =
4078 vaimg->pitches[2] = mediaSurface->iPitch;
4079 vaimg->offsets[0] = 0;
4080 vaimg->offsets[1] = mediaSurface->iHeight * mediaSurface->iPitch;
4081 vaimg->offsets[2] = mediaSurface->iHeight * mediaSurface->iPitch * 2;
4082 break;
4083 case Media_Format_422V:
4084 vaimg->format.bits_per_pixel = 16;
4085 vaimg->num_planes = 3;
4086 vaimg->pitches[0] =
4087 vaimg->pitches[1] =
4088 vaimg->pitches[2] = mediaSurface->iPitch;
4089 vaimg->offsets[0] = 0;
4090 vaimg->offsets[1] = mediaSurface->iHeight * mediaSurface->iPitch;
4091 vaimg->offsets[2] = mediaSurface->iHeight * mediaSurface->iPitch * 3 / 2;
4092 break;
4093 case Media_Format_422H:
4094 vaimg->format.bits_per_pixel = 16;
4095 vaimg->num_planes = 3;
4096 vaimg->pitches[0] =
4097 vaimg->pitches[1] =
4098 vaimg->pitches[2] = mediaSurface->iPitch;
4099 vaimg->offsets[0] = 0;
4100 vaimg->offsets[1] = mediaSurface->iHeight * mediaSurface->iPitch;
4101 vaimg->offsets[2] = mediaSurface->iHeight * mediaSurface->iPitch * 2;
4102 break;
4103 case Media_Format_P010:
4104 case Media_Format_P012:
4105 case Media_Format_P016:
4106 vaimg->format.bits_per_pixel = 24;
4107 vaimg->num_planes = 2;
4108 vaimg->pitches[0] = mediaSurface->iPitch;
4109 vaimg->pitches[1] =
4110 vaimg->pitches[2] = mediaSurface->iPitch;
4111 vaimg->offsets[0] = 0;
4112 vaimg->offsets[1] = mediaSurface->iHeight * mediaSurface->iPitch;
4113 vaimg->offsets[2] = vaimg->offsets[1] + 2;
4114 break;
4115 case Media_Format_Y410:
4116 case Media_Format_AYUV:
4117 #if VA_CHECK_VERSION(1, 13, 0)
4118 case Media_Format_XYUV:
4119 #endif
4120 case Media_Format_Y210:
4121 #if VA_CHECK_VERSION(1, 9, 0)
4122 case Media_Format_Y212:
4123 #endif
4124 case Media_Format_Y216:
4125 vaimg->format.bits_per_pixel = 32;
4126 vaimg->data_size = mediaSurface->iPitch * mediaSurface->iHeight;
4127 vaimg->num_planes = 1;
4128 vaimg->pitches[0] = mediaSurface->iPitch;
4129 vaimg->offsets[0] = 0;
4130 break;
4131 #if VA_CHECK_VERSION(1, 9, 0)
4132 case Media_Format_Y412:
4133 #endif
4134 case Media_Format_Y416:
4135 vaimg->format.bits_per_pixel = 64; // packed format [alpha, Y, U, V], 16 bits per channel
4136 vaimg->num_planes = 1;
4137 vaimg->pitches[0] = mediaSurface->iPitch;
4138 vaimg->offsets[0] = 0;
4139 break;
4140 default:
4141 vaimg->format.bits_per_pixel = 12;
4142 vaimg->num_planes = 2;
4143 vaimg->pitches[0] = mediaSurface->iPitch;
4144 vaimg->pitches[1] =
4145 vaimg->pitches[2] = mediaSurface->iPitch;
4146 vaimg->offsets[0] = 0;
4147 if(MEDIA_IS_WA(&mediaCtx->WaTable, WaDisableGmmLibOffsetInDeriveImage))
4148 {
4149 vaimg->offsets[1] = mediaSurface->iHeight * mediaSurface->iPitch;
4150 vaimg->offsets[2] = vaimg->offsets[1] + 1;
4151 }
4152 else
4153 {
4154 vaimg->offsets[1] = offsetU;
4155 vaimg->offsets[2] = offsetV;
4156 }
4157 break;
4158 }
4159
4160 return VA_STATUS_SUCCESS;
4161 }
4162
4163 VAStatus MediaLibvaInterfaceNext::GenerateVaImgFromOsFormat(
4164 VAImageFormat format,
4165 int32_t width,
4166 int32_t height,
4167 GMM_RESOURCE_INFO *gmmResourceInfo,
4168 VAImage *vaimg)
4169 {
4170 DDI_CHK_NULL(vaimg, "Invaild VAImage.", VA_STATUS_ERROR_INVALID_PARAMETER);
4171 DDI_CHK_NULL(gmmResourceInfo, "Invaild gmmResourceInfo.", VA_STATUS_ERROR_INVALID_PARAMETER);
4172
4173 // Get offset from GMM
4174 GMM_REQ_OFFSET_INFO reqInfo = {0};
4175 reqInfo.Plane = GMM_PLANE_U;
4176 reqInfo.ReqRender = 1;
4177 gmmResourceInfo->GetOffset(reqInfo);
4178 uint32_t offsetU = reqInfo.Render.Offset;
4179
4180 MOS_ZeroMemory(&reqInfo, sizeof(GMM_REQ_OFFSET_INFO));
4181 reqInfo.Plane = GMM_PLANE_V;
4182 reqInfo.ReqRender = 1;
4183 gmmResourceInfo->GetOffset(reqInfo);
4184 uint32_t offsetV = reqInfo.Render.Offset;
4185
4186 uint32_t size = (uint32_t)gmmResourceInfo->GetSizeSurface();
4187 uint32_t pitch = (uint32_t)gmmResourceInfo->GetRenderPitch();
4188
4189 vaimg->format = format;
4190 vaimg->format.byte_order = VA_LSB_FIRST;
4191 vaimg->width = width;
4192 vaimg->height = height;
4193 vaimg->data_size = size;
4194
4195 switch(format.fourcc)
4196 {
4197 case VA_FOURCC_RGBA:
4198 case VA_FOURCC_BGRA:
4199 case VA_FOURCC_ARGB:
4200 case VA_FOURCC_ABGR:
4201 case VA_FOURCC_BGRX:
4202 case VA_FOURCC_RGBX:
4203 case VA_FOURCC_XRGB:
4204 case VA_FOURCC_XBGR:
4205 case VA_FOURCC_A2R10G10B10:
4206 case VA_FOURCC_A2B10G10R10:
4207 case VA_FOURCC_X2R10G10B10:
4208 case VA_FOURCC_X2B10G10R10:
4209 case VA_FOURCC_R8G8B8:
4210 case VA_FOURCC_RGB565:
4211 case VA_FOURCC_UYVY:
4212 case VA_FOURCC_YUY2:
4213 case VA_FOURCC_VYUY:
4214 case VA_FOURCC_YVYU:
4215 case VA_FOURCC_AYUV:
4216 #if VA_CHECK_VERSION(1, 13, 0)
4217 case VA_FOURCC_XYUV:
4218 #endif
4219 case VA_FOURCC_Y210:
4220 #if VA_CHECK_VERSION(1, 9, 0)
4221 case VA_FOURCC_Y212:
4222 #endif
4223 case VA_FOURCC_Y216:
4224 case VA_FOURCC_Y410:
4225 #if VA_CHECK_VERSION(1, 9, 0)
4226 case VA_FOURCC_Y412:
4227 #endif
4228 case VA_FOURCC_Y416:
4229 case VA_FOURCC_Y800:
4230 vaimg->num_planes = 1;
4231 vaimg->pitches[0] = pitch;
4232 vaimg->offsets[0] = 0;
4233 break;
4234 case VA_FOURCC_NV12:
4235 case VA_FOURCC_NV21:
4236 case VA_FOURCC_P010:
4237 case VA_FOURCC_P012:
4238 case VA_FOURCC_P016:
4239 vaimg->num_planes = 2;
4240 vaimg->pitches[0] = pitch;
4241 vaimg->pitches[1] = pitch;
4242 vaimg->offsets[0] = 0;
4243 vaimg->offsets[1] = offsetU;
4244 break;
4245 case VA_FOURCC_YV12:
4246 vaimg->num_planes = 3;
4247 vaimg->pitches[0] = pitch;
4248 vaimg->pitches[1] = pitch / 2;
4249 vaimg->pitches[2] = pitch / 2;
4250 vaimg->offsets[0] = 0;
4251 vaimg->offsets[1] = offsetV;
4252 vaimg->offsets[2] = offsetU;
4253 break;
4254 case VA_FOURCC_I420:
4255 vaimg->num_planes = 3;
4256 vaimg->pitches[0] = pitch;
4257 vaimg->pitches[1] = pitch / 2;
4258 vaimg->pitches[2] = pitch / 2;
4259 vaimg->offsets[0] = 0;
4260 vaimg->offsets[1] = offsetU;
4261 vaimg->offsets[2] = offsetV;
4262 break;
4263 case VA_FOURCC_IMC3:
4264 case VA_FOURCC_411P:
4265 case VA_FOURCC_422V:
4266 case VA_FOURCC_422H:
4267 case VA_FOURCC_444P:
4268 case VA_FOURCC_RGBP:
4269 case VA_FOURCC_BGRP:
4270 vaimg->num_planes = 3;
4271 vaimg->pitches[0] = pitch;
4272 vaimg->pitches[1] = pitch;
4273 vaimg->pitches[2] = pitch;
4274 vaimg->offsets[0] = 0;
4275 vaimg->offsets[1] = offsetU;
4276 vaimg->offsets[2] = offsetV;
4277 break;
4278 default:
4279 return VA_STATUS_ERROR_UNIMPLEMENTED;
4280 }
4281
4282 return VA_STATUS_SUCCESS;
4283 }
4284
4285 VAStatus MediaLibvaInterfaceNext::RtFormatToOsFormat(uint32_t format, int32_t &expectedFourcc)
4286 {
4287 DDI_FUNC_ENTER;
4288 expectedFourcc = VA_FOURCC_NV12;
4289 switch(format)
4290 {
4291 case VA_RT_FORMAT_YUV420:
4292 expectedFourcc = VA_FOURCC_NV12;
4293 break;
4294 case VA_RT_FORMAT_YUV420_12:
4295 expectedFourcc = VA_FOURCC_P012;
4296 break;
4297 case VA_RT_FORMAT_YUV422:
4298 expectedFourcc = VA_FOURCC_YUY2;
4299 break;
4300 case VA_RT_FORMAT_YUV422_10:
4301 expectedFourcc = VA_FOURCC_Y210;
4302 break;
4303 case VA_RT_FORMAT_YUV422_12:
4304 #if VA_CHECK_VERSION(1, 9, 0)
4305 expectedFourcc = VA_FOURCC_Y212;
4306 #else
4307 expectedFourcc = VA_FOURCC_Y216;
4308 #endif
4309 break;
4310 case VA_RT_FORMAT_YUV444:
4311 expectedFourcc = VA_FOURCC_444P;
4312 break;
4313 case VA_RT_FORMAT_YUV444_10:
4314 expectedFourcc = VA_FOURCC_Y410;
4315 break;
4316 case VA_RT_FORMAT_YUV444_12:
4317 #if VA_CHECK_VERSION(1, 9, 0)
4318 expectedFourcc = VA_FOURCC_Y412;
4319 #else
4320 expectedFourcc = VA_FOURCC_Y416;
4321 #endif
4322 break;
4323 case VA_RT_FORMAT_YUV411:
4324 expectedFourcc = VA_FOURCC_411P;
4325 break;
4326 case VA_RT_FORMAT_YUV400:
4327 expectedFourcc = VA_FOURCC('4','0','0','P');
4328 break;
4329 case VA_RT_FORMAT_YUV420_10BPP:
4330 expectedFourcc = VA_FOURCC_P010;
4331 break;
4332 case VA_RT_FORMAT_RGB16:
4333 expectedFourcc = VA_FOURCC_R5G6B5;
4334 break;
4335 case VA_RT_FORMAT_RGB32:
4336 expectedFourcc = VA_FOURCC_BGRA;
4337 break;
4338 case VA_RT_FORMAT_RGBP:
4339 expectedFourcc = VA_FOURCC_RGBP;
4340 break;
4341 #ifdef VA_RT_FORMAT_RGB32_10BPP
4342 case VA_RT_FORMAT_RGB32_10BPP:
4343 expectedFourcc = VA_FOURCC_BGRA;
4344 break;
4345 #endif
4346 #if 1 //added for having MDF sanity test pass, will be removed after MDF formal patch checked in
4347 case VA_FOURCC_NV12:
4348 expectedFourcc = VA_FOURCC_NV12;
4349 break;
4350 case VA_FOURCC_NV21:
4351 expectedFourcc = VA_FOURCC_NV21;
4352 break;
4353 case VA_FOURCC_ABGR:
4354 expectedFourcc = VA_FOURCC_ABGR;
4355 break;
4356 case VA_FOURCC_ARGB:
4357 expectedFourcc = VA_FOURCC_ARGB;
4358 break;
4359 case VA_FOURCC_XBGR:
4360 expectedFourcc = VA_FOURCC_XBGR;
4361 break;
4362 case VA_FOURCC_XRGB:
4363 expectedFourcc = VA_FOURCC_XRGB;
4364 break;
4365 case VA_FOURCC_R5G6B5:
4366 expectedFourcc = VA_FOURCC_R5G6B5;
4367 break;
4368 case VA_FOURCC_R8G8B8:
4369 expectedFourcc = VA_FOURCC_R8G8B8;
4370 break;
4371 case VA_FOURCC_YUY2:
4372 expectedFourcc = VA_FOURCC_YUY2;
4373 break;
4374 case VA_FOURCC_YV12:
4375 expectedFourcc = VA_FOURCC_YV12;
4376 break;
4377 case VA_FOURCC_422H:
4378 expectedFourcc = VA_FOURCC_422H;
4379 break;
4380 case VA_FOURCC_422V:
4381 expectedFourcc = VA_FOURCC_422V;
4382 break;
4383 case VA_FOURCC_P208:
4384 expectedFourcc = VA_FOURCC_P208;
4385 break;
4386 case VA_FOURCC_P010:
4387 expectedFourcc = VA_FOURCC_P010;
4388 break;
4389 case VA_FOURCC_P012:
4390 expectedFourcc = VA_FOURCC_P012;
4391 break;
4392 case VA_FOURCC_P016:
4393 expectedFourcc = VA_FOURCC_P016;
4394 break;
4395 case VA_FOURCC_Y210:
4396 expectedFourcc = VA_FOURCC_Y210;
4397 break;
4398 #if VA_CHECK_VERSION(1, 9, 0)
4399 case VA_FOURCC_Y212:
4400 expectedFourcc = VA_FOURCC_Y212;
4401 break;
4402 #endif
4403 case VA_FOURCC_Y216:
4404 expectedFourcc = VA_FOURCC_Y216;
4405 break;
4406 case VA_FOURCC_AYUV:
4407 expectedFourcc = VA_FOURCC_AYUV;
4408 break;
4409 #if VA_CHECK_VERSION(1, 13, 0)
4410 case VA_FOURCC_XYUV:
4411 expectedFourcc = VA_FOURCC_XYUV;
4412 break;
4413 #endif
4414 case VA_FOURCC_Y410:
4415 expectedFourcc = VA_FOURCC_Y410;
4416 break;
4417 #if VA_CHECK_VERSION(1, 9, 0)
4418 case VA_FOURCC_Y412:
4419 expectedFourcc = VA_FOURCC_Y412;
4420 break;
4421 #endif
4422 case VA_FOURCC_Y416:
4423 expectedFourcc = VA_FOURCC_Y416;
4424 break;
4425 case VA_FOURCC_I420:
4426 expectedFourcc = VA_FOURCC_I420;
4427 break;
4428 case VA_FOURCC_UYVY:
4429 expectedFourcc = VA_FOURCC_UYVY;
4430 break;
4431 #endif
4432 default:
4433 DDI_ASSERTMESSAGE("Invalid VAConfigAttribRTFormat: 0x%x. Please uses the format defined in libva/va.h", format);
4434 return VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT;
4435 }
4436
4437 return VA_STATUS_SUCCESS;
4438 }
4439
4440 DDI_MEDIA_FORMAT MediaLibvaInterfaceNext::OsFormatToMediaFormat(int32_t fourcc, int32_t rtformatType)
4441 {
4442 switch (fourcc)
4443 {
4444 case VA_FOURCC_A2R10G10B10:
4445 return Media_Format_B10G10R10A2;
4446 case VA_FOURCC_A2B10G10R10:
4447 return Media_Format_R10G10B10A2;
4448 case VA_FOURCC_X2R10G10B10:
4449 return Media_Format_B10G10R10X2;
4450 case VA_FOURCC_X2B10G10R10:
4451 return Media_Format_R10G10B10X2;
4452 case VA_FOURCC_BGRA:
4453 case VA_FOURCC_ARGB:
4454 #ifdef VA_RT_FORMAT_RGB32_10BPP
4455 if(VA_RT_FORMAT_RGB32_10BPP == rtformatType)
4456 {
4457 return Media_Format_B10G10R10A2;
4458 }
4459 #endif
4460 return Media_Format_A8R8G8B8;
4461 case VA_FOURCC_RGBA:
4462 #ifdef VA_RT_FORMAT_RGB32_10BPP
4463 if(VA_RT_FORMAT_RGB32_10BPP == rtformatType)
4464 {
4465 return Media_Format_R10G10B10A2;
4466 }
4467 #endif
4468 return Media_Format_R8G8B8A8;
4469 case VA_FOURCC_ABGR:
4470 #ifdef VA_RT_FORMAT_RGB32_10BPP
4471 if(VA_RT_FORMAT_RGB32_10BPP == rtformatType)
4472 {
4473 return Media_Format_R10G10B10A2;
4474 }
4475 #endif
4476 return Media_Format_A8B8G8R8;
4477 case VA_FOURCC_BGRX:
4478 case VA_FOURCC_XRGB:
4479 return Media_Format_X8R8G8B8;
4480 case VA_FOURCC_XBGR:
4481 case VA_FOURCC_RGBX:
4482 return Media_Format_X8B8G8R8;
4483 case VA_FOURCC_R5G6B5:
4484 return Media_Format_R5G6B5;
4485 case VA_FOURCC_R8G8B8:
4486 return Media_Format_R8G8B8;
4487 case VA_FOURCC_NV12:
4488 return Media_Format_NV12;
4489 case VA_FOURCC_NV21:
4490 return Media_Format_NV21;
4491 case VA_FOURCC_YUY2:
4492 return Media_Format_YUY2;
4493 case VA_FOURCC_UYVY:
4494 return Media_Format_UYVY;
4495 case VA_FOURCC_YV12:
4496 return Media_Format_YV12;
4497 case VA_FOURCC_IYUV:
4498 return Media_Format_IYUV;
4499 case VA_FOURCC_I420:
4500 return Media_Format_I420;
4501 case VA_FOURCC_422H:
4502 return Media_Format_422H;
4503 case VA_FOURCC_422V:
4504 return Media_Format_422V;
4505 case VA_FOURCC('4','0','0','P'):
4506 case VA_FOURCC_Y800:
4507 return Media_Format_400P;
4508 case VA_FOURCC_411P:
4509 return Media_Format_411P;
4510 case VA_FOURCC_IMC3:
4511 return Media_Format_IMC3;
4512 case VA_FOURCC_444P:
4513 return Media_Format_444P;
4514 case VA_FOURCC_BGRP:
4515 return Media_Format_BGRP;
4516 case VA_FOURCC_RGBP:
4517 return Media_Format_RGBP;
4518 case VA_FOURCC_P208:
4519 return Media_Format_Buffer;
4520 case VA_FOURCC_P010:
4521 return Media_Format_P010;
4522 case VA_FOURCC_P012:
4523 return Media_Format_P012;
4524 case VA_FOURCC_P016:
4525 return Media_Format_P016;
4526 case VA_FOURCC_Y210:
4527 return Media_Format_Y210;
4528 #if VA_CHECK_VERSION(1, 9, 0)
4529 case VA_FOURCC_Y212:
4530 return Media_Format_Y212;
4531 #endif
4532 case VA_FOURCC_Y216:
4533 return Media_Format_Y216;
4534 case VA_FOURCC_AYUV:
4535 return Media_Format_AYUV;
4536 #if VA_CHECK_VERSION(1, 13, 0)
4537 case VA_FOURCC_XYUV:
4538 return Media_Format_XYUV;
4539 #endif
4540 case VA_FOURCC_Y410:
4541 return Media_Format_Y410;
4542 #if VA_CHECK_VERSION(1, 9, 0)
4543 case VA_FOURCC_Y412:
4544 return Media_Format_Y412;
4545 #endif
4546 case VA_FOURCC_Y416:
4547 return Media_Format_Y416;
4548 case VA_FOURCC_Y8:
4549 return Media_Format_Y8;
4550 case VA_FOURCC_Y16:
4551 return Media_Format_Y16S;
4552 case VA_FOURCC_VYUY:
4553 return Media_Format_VYUY;
4554 case VA_FOURCC_YVYU:
4555 return Media_Format_YVYU;
4556 case VA_FOURCC_ARGB64:
4557 return Media_Format_A16R16G16B16;
4558 case VA_FOURCC_ABGR64:
4559 return Media_Format_A16B16G16R16;
4560
4561 default:
4562 return Media_Format_Count;
4563 }
4564 }
4565
4566 uint32_t MediaLibvaInterfaceNext::GetPlaneNum(PDDI_MEDIA_SURFACE mediaSurface, bool hasAuxPlane)
4567 {
4568 DDI_CHK_NULL(mediaSurface, "nullptr mediaSurface", VA_STATUS_ERROR_INVALID_PARAMETER);
4569
4570 uint32_t fourcc = MediaFormatToOsFormat(mediaSurface->format);
4571 uint32_t planeNum = 0;
4572 switch(fourcc)
4573 {
4574 case VA_FOURCC_NV12:
4575 case VA_FOURCC_NV21:
4576 case VA_FOURCC_P010:
4577 case VA_FOURCC_P012:
4578 case VA_FOURCC_P016:
4579 planeNum = hasAuxPlane ? 4 : 2;
4580 break;
4581 case VA_FOURCC_I420:
4582 case VA_FOURCC_YV12:
4583 case VA_FOURCC_411P:
4584 case VA_FOURCC_422H:
4585 case VA_FOURCC_422V:
4586 case VA_FOURCC_444P:
4587 case VA_FOURCC_IMC3:
4588 case VA_FOURCC_RGBP:
4589 case VA_FOURCC_BGRP:
4590 planeNum = 3;
4591 break;
4592 case VA_FOURCC_YUY2:
4593 case VA_FOURCC_UYVY:
4594 case VA_FOURCC_YVYU:
4595 case VA_FOURCC_VYUY:
4596 case VA_FOURCC_Y800:
4597 case VA_FOURCC_Y210:
4598 #if VA_CHECK_VERSION(1, 9, 0)
4599 case VA_FOURCC_Y212:
4600 #endif
4601 case VA_FOURCC_Y216:
4602 case VA_FOURCC_Y410:
4603 #if VA_CHECK_VERSION(1, 9, 0)
4604 case VA_FOURCC_Y412:
4605 #endif
4606 case VA_FOURCC_Y416:
4607 case VA_FOURCC_AYUV:
4608 #if VA_CHECK_VERSION(1, 13, 0)
4609 case VA_FOURCC_XYUV:
4610 #endif
4611 case VA_FOURCC_RGBA:
4612 case VA_FOURCC_RGBX:
4613 case VA_FOURCC_BGRA:
4614 case VA_FOURCC_BGRX:
4615 case VA_FOURCC_ARGB:
4616 case VA_FOURCC_ABGR:
4617 case VA_FOURCC_XRGB:
4618 case VA_FOURCC_XBGR:
4619 case VA_FOURCC_RGB565:
4620 case VA_FOURCC_R8G8B8:
4621 case VA_FOURCC_A2R10G10B10:
4622 case VA_FOURCC_A2B10G10R10:
4623 case VA_FOURCC_X2R10G10B10:
4624 case VA_FOURCC_X2B10G10R10:
4625 planeNum = hasAuxPlane ? 2 : 1;
4626 break;
4627 default:
4628 DDI_ASSERTMESSAGE("Unsupported format.\n");
4629 }
4630 return planeNum;
4631 }
4632
4633 uint32_t MediaLibvaInterfaceNext::GetDrmFormatOfSeparatePlane(uint32_t fourcc, int plane)
4634 {
4635 if (plane == 0)
4636 {
4637 switch (fourcc)
4638 {
4639 case VA_FOURCC_NV12:
4640 case VA_FOURCC_I420:
4641 case VA_FOURCC_IMC3:
4642 case VA_FOURCC_YV12:
4643 case VA_FOURCC_YV16:
4644 case VA_FOURCC_422H:
4645 case VA_FOURCC_422V:
4646 case VA_FOURCC_444P:
4647 case VA_FOURCC_Y800:
4648 case VA_FOURCC_RGBP:
4649 case VA_FOURCC_BGRP:
4650 return DRM_FORMAT_R8;
4651 case VA_FOURCC_P010:
4652 case VA_FOURCC_P012:
4653 case VA_FOURCC_P016:
4654 case VA_FOURCC_I010:
4655 return DRM_FORMAT_R16;
4656
4657 case VA_FOURCC_YUY2:
4658 return DRM_FORMAT_YUYV;
4659 case VA_FOURCC_YVYU:
4660 return DRM_FORMAT_YVYU;
4661 case VA_FOURCC_VYUY:
4662 return DRM_FORMAT_VYUY;
4663 case VA_FOURCC_UYVY:
4664 return DRM_FORMAT_UYVY;
4665 case VA_FOURCC_AYUV:
4666 return DRM_FORMAT_AYUV;
4667 #if VA_CHECK_VERSION(1, 13, 0)
4668 case VA_FOURCC_XYUV:
4669 return DRM_FORMAT_XYUV8888;
4670 #endif
4671 case VA_FOURCC_Y210:
4672 return DRM_FORMAT_Y210;
4673 case VA_FOURCC_Y216:
4674 return DRM_FORMAT_Y216;
4675 case VA_FOURCC_Y410:
4676 return DRM_FORMAT_Y410;
4677 case VA_FOURCC_Y416:
4678 return DRM_FORMAT_Y416;
4679 #if VA_CHECK_VERSION(1, 9, 0)
4680 case VA_FOURCC_Y212:
4681 return DRM_FORMAT_Y216;
4682 case VA_FOURCC_Y412:
4683 return DRM_FORMAT_Y416;
4684 #endif
4685
4686 case VA_FOURCC_ARGB:
4687 return DRM_FORMAT_ARGB8888;
4688 case VA_FOURCC_ABGR:
4689 return DRM_FORMAT_ABGR8888;
4690 case VA_FOURCC_RGBA:
4691 return DRM_FORMAT_RGBA8888;
4692 case VA_FOURCC_BGRA:
4693 return DRM_FORMAT_BGRA8888;
4694 case VA_FOURCC_XRGB:
4695 return DRM_FORMAT_XRGB8888;
4696 case VA_FOURCC_XBGR:
4697 return DRM_FORMAT_XBGR8888;
4698 case VA_FOURCC_RGBX:
4699 return DRM_FORMAT_RGBX8888;
4700 case VA_FOURCC_BGRX:
4701 return DRM_FORMAT_BGRX8888;
4702 case VA_FOURCC_A2R10G10B10:
4703 return DRM_FORMAT_ARGB2101010;
4704 case VA_FOURCC_A2B10G10R10:
4705 return DRM_FORMAT_ABGR2101010;
4706 case VA_FOURCC_X2R10G10B10:
4707 return DRM_FORMAT_XRGB2101010;
4708 case VA_FOURCC_X2B10G10R10:
4709 return DRM_FORMAT_XBGR2101010;
4710 }
4711 }
4712 else
4713 {
4714 switch (fourcc)
4715 {
4716 case VA_FOURCC_NV12:
4717 return DRM_FORMAT_GR88;
4718 case VA_FOURCC_I420:
4719 case VA_FOURCC_IMC3:
4720 case VA_FOURCC_YV12:
4721 case VA_FOURCC_YV16:
4722 case VA_FOURCC_422H:
4723 case VA_FOURCC_422V:
4724 case VA_FOURCC_444P:
4725 case VA_FOURCC_RGBP:
4726 case VA_FOURCC_BGRP:
4727 return DRM_FORMAT_R8;
4728 case VA_FOURCC_P010:
4729 case VA_FOURCC_P012:
4730 case VA_FOURCC_P016:
4731 return DRM_FORMAT_GR1616;
4732 case VA_FOURCC_I010:
4733 return DRM_FORMAT_R16;
4734 }
4735 }
4736 return 0;
4737 }
4738
4739 uint32_t MediaLibvaInterfaceNext::GetDrmFormatOfCompositeObject(uint32_t fourcc)
4740 {
4741 switch (fourcc)
4742 {
4743 case VA_FOURCC_NV12:
4744 return DRM_FORMAT_NV12;
4745 case VA_FOURCC_I420:
4746 return DRM_FORMAT_YUV420;
4747 case VA_FOURCC_IMC3:
4748 return DRM_FORMAT_YUV420;
4749 case VA_FOURCC_YV12:
4750 return DRM_FORMAT_YVU420;
4751 case VA_FOURCC_YV16:
4752 return DRM_FORMAT_YVU422;
4753 case VA_FOURCC_422H:
4754 return DRM_FORMAT_YUV422;
4755 case VA_FOURCC_422V:
4756 return DRM_FORMAT_YUV422;
4757 case VA_FOURCC_444P:
4758 return DRM_FORMAT_YUV444;
4759 case VA_FOURCC_YUY2:
4760 return DRM_FORMAT_YUYV;
4761 case VA_FOURCC_YVYU:
4762 return DRM_FORMAT_YVYU;
4763 case VA_FOURCC_VYUY:
4764 return DRM_FORMAT_VYUY;
4765 case VA_FOURCC_UYVY:
4766 return DRM_FORMAT_UYVY;
4767 case VA_FOURCC_AYUV:
4768 return DRM_FORMAT_AYUV;
4769 #if VA_CHECK_VERSION(1, 13, 0)
4770 case VA_FOURCC_XYUV:
4771 return DRM_FORMAT_XYUV8888;
4772 #endif
4773 case VA_FOURCC_Y210:
4774 return DRM_FORMAT_Y210;
4775 #if VA_CHECK_VERSION(1, 9, 0)
4776 case VA_FOURCC_Y212:
4777 return DRM_FORMAT_Y216;
4778 #endif
4779 case VA_FOURCC_Y216:
4780 return DRM_FORMAT_Y216;
4781 case VA_FOURCC_Y410:
4782 return DRM_FORMAT_Y410;
4783 #if VA_CHECK_VERSION(1, 9, 0)
4784 case VA_FOURCC_Y412:
4785 return DRM_FORMAT_Y416;
4786 #endif
4787 case VA_FOURCC_Y416:
4788 return DRM_FORMAT_Y416;
4789 case VA_FOURCC_Y800:
4790 return DRM_FORMAT_R8;
4791 case VA_FOURCC_P010:
4792 return DRM_FORMAT_P010;
4793 case VA_FOURCC_P012:
4794 return DRM_FORMAT_P016;
4795 case VA_FOURCC_P016:
4796 return DRM_FORMAT_P016;
4797 case VA_FOURCC_ARGB:
4798 return DRM_FORMAT_ARGB8888;
4799 case VA_FOURCC_ABGR:
4800 return DRM_FORMAT_ABGR8888;
4801 case VA_FOURCC_RGBA:
4802 return DRM_FORMAT_RGBA8888;
4803 case VA_FOURCC_BGRA:
4804 return DRM_FORMAT_BGRA8888;
4805 case VA_FOURCC_XRGB:
4806 return DRM_FORMAT_XRGB8888;
4807 case VA_FOURCC_XBGR:
4808 return DRM_FORMAT_XBGR8888;
4809 case VA_FOURCC_RGBX:
4810 return DRM_FORMAT_RGBX8888;
4811 case VA_FOURCC_BGRX:
4812 return DRM_FORMAT_BGRX8888;
4813 case VA_FOURCC_A2R10G10B10:
4814 return DRM_FORMAT_ARGB2101010;
4815 case VA_FOURCC_A2B10G10R10:
4816 return DRM_FORMAT_ABGR2101010;
4817 case VA_FOURCC_X2R10G10B10:
4818 return DRM_FORMAT_XRGB2101010;
4819 case VA_FOURCC_X2B10G10R10:
4820 return DRM_FORMAT_XBGR2101010;
4821 }
4822 return 0;
4823 }
4824
4825 int32_t MediaLibvaInterfaceNext::MediaFormatToOsFormat(DDI_MEDIA_FORMAT format)
4826 {
4827 switch (format)
4828 {
4829 case Media_Format_X8R8G8B8:
4830 return VA_FOURCC_XRGB;
4831 case Media_Format_X8B8G8R8:
4832 return VA_FOURCC_XBGR;
4833 case Media_Format_A8B8G8R8:
4834 return VA_FOURCC_ABGR;
4835 case Media_Format_R10G10B10A2:
4836 return VA_FOURCC_A2B10G10R10;
4837 case Media_Format_R8G8B8A8:
4838 return VA_FOURCC_RGBA;
4839 case Media_Format_A8R8G8B8:
4840 return VA_FOURCC_ARGB;
4841 case Media_Format_B10G10R10A2:
4842 return VA_FOURCC_A2R10G10B10;
4843 case Media_Format_R10G10B10X2:
4844 return VA_FOURCC_X2B10G10R10;
4845 case Media_Format_B10G10R10X2:
4846 return VA_FOURCC_X2R10G10B10;
4847 case Media_Format_R5G6B5:
4848 return VA_FOURCC_R5G6B5;
4849 case Media_Format_R8G8B8:
4850 return VA_FOURCC_R8G8B8;
4851 case Media_Format_NV12:
4852 return VA_FOURCC_NV12;
4853 case Media_Format_NV21:
4854 return VA_FOURCC_NV21;
4855 case Media_Format_YUY2:
4856 return VA_FOURCC_YUY2;
4857 case Media_Format_UYVY:
4858 return VA_FOURCC_UYVY;
4859 case Media_Format_YV12:
4860 return VA_FOURCC_YV12;
4861 case Media_Format_IYUV:
4862 return VA_FOURCC_IYUV;
4863 case Media_Format_I420:
4864 return VA_FOURCC_I420;
4865 case Media_Format_400P:
4866 return VA_FOURCC('4','0','0','P');
4867 case Media_Format_IMC3:
4868 return VA_FOURCC_IMC3;
4869 case Media_Format_422H:
4870 return VA_FOURCC_422H;
4871 case Media_Format_422V:
4872 return VA_FOURCC_422V;
4873 case Media_Format_411P:
4874 return VA_FOURCC_411P;
4875 case Media_Format_444P:
4876 return VA_FOURCC_444P;
4877 case Media_Format_RGBP:
4878 return VA_FOURCC_RGBP;
4879 case Media_Format_BGRP:
4880 return VA_FOURCC_BGRP;
4881 case Media_Format_Buffer:
4882 return VA_FOURCC_P208;
4883 case Media_Format_P010:
4884 return VA_FOURCC_P010;
4885 case Media_Format_P012:
4886 return VA_FOURCC_P012;
4887 case Media_Format_P016:
4888 return VA_FOURCC_P016;
4889 case Media_Format_Y210:
4890 return VA_FOURCC_Y210;
4891 #if VA_CHECK_VERSION(1, 9, 0)
4892 case Media_Format_Y212:
4893 return VA_FOURCC_Y212;
4894 #endif
4895 case Media_Format_Y216:
4896 return VA_FOURCC_Y216;
4897 case Media_Format_AYUV:
4898 return VA_FOURCC_AYUV;
4899 #if VA_CHECK_VERSION(1, 13, 0)
4900 case Media_Format_XYUV:
4901 return VA_FOURCC_XYUV;
4902 #endif
4903 case Media_Format_Y410:
4904 return VA_FOURCC_Y410;
4905 #if VA_CHECK_VERSION(1, 9, 0)
4906 case Media_Format_Y412:
4907 return VA_FOURCC_Y412;
4908 #endif
4909 case Media_Format_Y416:
4910 return VA_FOURCC_Y416;
4911 case Media_Format_Y8:
4912 return VA_FOURCC_Y8;
4913 case Media_Format_Y16S:
4914 return VA_FOURCC_Y16;
4915 case Media_Format_Y16U:
4916 return VA_FOURCC_Y16;
4917 case Media_Format_VYUY:
4918 return VA_FOURCC_VYUY;
4919 case Media_Format_YVYU:
4920 return VA_FOURCC_YVYU;
4921 case Media_Format_A16R16G16B16:
4922 return VA_FOURCC_ARGB64;
4923 case Media_Format_A16B16G16R16:
4924 return VA_FOURCC_ABGR64;
4925 default:
4926 return VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT;
4927 }
4928 }
4929
4930 VAStatus MediaLibvaInterfaceNext::GetChromaPitchHeight(
4931 uint32_t fourcc,
4932 uint32_t pitch,
4933 uint32_t height,
4934 uint32_t *chromaPitch,
4935 uint32_t *chromaHeight)
4936 {
4937 DDI_CHK_NULL(chromaPitch, "nullptr chromaPitch", VA_STATUS_ERROR_INVALID_PARAMETER);
4938 DDI_CHK_NULL(chromaHeight, "nullptr chromaHeight", VA_STATUS_ERROR_INVALID_PARAMETER);
4939
4940 switch(fourcc)
4941 {
4942 case VA_FOURCC_NV12:
4943 case VA_FOURCC_P010:
4944 case VA_FOURCC_P012:
4945 case VA_FOURCC_P016:
4946 *chromaHeight = MOS_ALIGN_CEIL(height, 2) / 2;
4947 *chromaPitch = pitch;
4948 break;
4949 case VA_FOURCC_I420:
4950 case VA_FOURCC_YV12:
4951 *chromaHeight = MOS_ALIGN_CEIL(height, 2) / 2;
4952 *chromaPitch = MOS_ALIGN_CEIL(pitch, 2) / 2;
4953 break;
4954 case VA_FOURCC_411P:
4955 case VA_FOURCC_422H:
4956 case VA_FOURCC_444P:
4957 case VA_FOURCC_RGBP:
4958 *chromaHeight = height;
4959 *chromaPitch = pitch;
4960 break;
4961 case VA_FOURCC_422V:
4962 case VA_FOURCC_IMC3:
4963 *chromaHeight = MOS_ALIGN_CEIL(height, 2) / 2;
4964 *chromaPitch = pitch;
4965 break;
4966 default:
4967 *chromaPitch = 0;
4968 *chromaHeight = 0;
4969 }
4970
4971 return VA_STATUS_SUCCESS;
4972 }
4973
4974 uint32_t MediaLibvaInterfaceNext::CreateRenderTarget(
4975 PDDI_MEDIA_CONTEXT mediaDrvCtx,
4976 DDI_MEDIA_FORMAT mediaFormat,
4977 uint32_t width,
4978 uint32_t height,
4979 DDI_MEDIA_SURFACE_DESCRIPTOR *surfDesc,
4980 uint32_t surfaceUsageHint,
4981 int memType
4982 )
4983 {
4984 DDI_FUNC_ENTER;
4985 MosUtilities::MosLockMutex(&mediaDrvCtx->SurfaceMutex);
4986
4987 PDDI_MEDIA_SURFACE_HEAP_ELEMENT surfaceElement = MediaLibvaUtilNext::AllocPMediaSurfaceFromHeap(mediaDrvCtx->pSurfaceHeap);
4988 if (nullptr == surfaceElement)
4989 {
4990 MosUtilities::MosUnlockMutex(&mediaDrvCtx->SurfaceMutex);
4991 return VA_INVALID_ID;
4992 }
4993
4994 surfaceElement->pSurface = (DDI_MEDIA_SURFACE *)MOS_AllocAndZeroMemory(sizeof(DDI_MEDIA_SURFACE));
4995 if (nullptr == surfaceElement->pSurface)
4996 {
4997 MediaLibvaUtilNext::ReleasePMediaSurfaceFromHeap(mediaDrvCtx->pSurfaceHeap, surfaceElement->uiVaSurfaceID);
4998 MosUtilities::MosUnlockMutex(&mediaDrvCtx->SurfaceMutex);
4999 return VA_INVALID_ID;
5000 }
5001
5002 surfaceElement->pSurface->pMediaCtx = mediaDrvCtx;
5003 surfaceElement->pSurface->iWidth = width;
5004 surfaceElement->pSurface->iHeight = height;
5005 surfaceElement->pSurface->pSurfDesc = surfDesc;
5006 surfaceElement->pSurface->format = mediaFormat;
5007 surfaceElement->pSurface->uiLockedBufID = VA_INVALID_ID;
5008 surfaceElement->pSurface->uiLockedImageID = VA_INVALID_ID;
5009 surfaceElement->pSurface->surfaceUsageHint= surfaceUsageHint;
5010 surfaceElement->pSurface->memType = memType;
5011
5012 if(MediaLibvaUtilNext::CreateSurface(surfaceElement->pSurface, mediaDrvCtx)!= VA_STATUS_SUCCESS)
5013 {
5014 MOS_FreeMemory(surfaceElement->pSurface);
5015 MediaLibvaUtilNext::ReleasePMediaSurfaceFromHeap(mediaDrvCtx->pSurfaceHeap, surfaceElement->uiVaSurfaceID);
5016 MosUtilities::MosUnlockMutex(&mediaDrvCtx->SurfaceMutex);
5017 return VA_INVALID_ID;
5018 }
5019
5020 mediaDrvCtx->uiNumSurfaces++;
5021 uint32_t surfaceID = surfaceElement->uiVaSurfaceID;
5022 MosUtilities::MosUnlockMutex(&mediaDrvCtx->SurfaceMutex);
5023 return surfaceID;
5024 }
5025
5026 VAStatus MediaLibvaInterfaceNext::CopyInternal(
5027 PMOS_CONTEXT mosCtx,
5028 PMOS_RESOURCE src,
5029 PMOS_RESOURCE dst,
5030 uint32_t copy_mode
5031 )
5032 {
5033 VAStatus vaStatus = VA_STATUS_SUCCESS;
5034 MOS_STATUS mosStatus = MOS_STATUS_UNINITIALIZED;
5035 DDI_CHK_NULL(mosCtx, "nullptr mosCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
5036 DDI_CHK_NULL(src, "nullptr input osResource", VA_STATUS_ERROR_INVALID_SURFACE);
5037 DDI_CHK_NULL(dst, "nullptr output osResource", VA_STATUS_ERROR_INVALID_SURFACE);
5038
5039 MediaCopyBaseState *mediaCopyState = static_cast<MediaCopyBaseState*>(*mosCtx->ppMediaCopyState);
5040
5041 if (!mediaCopyState)
5042 {
5043 mediaCopyState = static_cast<MediaCopyBaseState*>(McpyDeviceNext::CreateFactory(mosCtx));
5044 *mosCtx->ppMediaCopyState = mediaCopyState;
5045 }
5046
5047 DDI_CHK_NULL(mediaCopyState, "Invalid mediaCopy State", VA_STATUS_ERROR_INVALID_PARAMETER);
5048
5049 #if (_DEBUG || _RELEASE_INTERNAL)
5050 // enable reg key report to avoid conflict with media copy cases.
5051 mediaCopyState->SetRegkeyReport(true);
5052 #endif
5053
5054 mosStatus = mediaCopyState->SurfaceCopy(src, dst, (MCPY_METHOD)copy_mode);
5055 if (mosStatus != MOS_STATUS_SUCCESS)
5056 {
5057 vaStatus = VA_STATUS_ERROR_INVALID_PARAMETER;
5058 }
5059
5060 return vaStatus;
5061 }
5062
5063 #if VA_CHECK_VERSION(1,10,0)
5064 VAStatus MediaLibvaInterfaceNext::Copy(
5065 VADriverContextP ctx,
5066 VACopyObject *dst_obj,
5067 VACopyObject *src_obj,
5068 VACopyOption option
5069 )
5070 {
5071 VAStatus vaStatus = VA_STATUS_SUCCESS;
5072 MOS_CONTEXT mosCtx = {};
5073 MOS_RESOURCE src, dst;
5074 PDDI_MEDIA_SURFACE src_surface = nullptr;
5075 PDDI_MEDIA_SURFACE dst_surface = nullptr;
5076 PDDI_MEDIA_BUFFER src_buffer = nullptr;
5077 PDDI_MEDIA_BUFFER dst_buffer = nullptr;
5078
5079 DDI_FUNC_ENTER;
5080
5081 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
5082 PDDI_MEDIA_CONTEXT mediaCtx = GetMediaContext(ctx);
5083
5084 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
5085 DDI_CHK_NULL(mediaCtx->pBufferHeap, "nullptr mediaCtx->pBufferHeap", VA_STATUS_ERROR_INVALID_CONTEXT);
5086 DDI_CHK_NULL(mediaCtx->pSurfaceHeap, "nullptr mediaCtx->pSurfaceHeap", VA_STATUS_ERROR_INVALID_CONTEXT);
5087 DDI_CHK_NULL(dst_obj, "nullptr copy dst", VA_STATUS_ERROR_INVALID_SURFACE);
5088 DDI_CHK_NULL(src_obj, "nullptr copy src", VA_STATUS_ERROR_INVALID_SURFACE);
5089
5090 if (dst_obj->obj_type == VACopyObjectSurface)
5091 {
5092 DDI_CHK_LESS((uint32_t)dst_obj->object.surface_id, mediaCtx->pSurfaceHeap->uiAllocatedHeapElements, "copy_dst", VA_STATUS_ERROR_INVALID_SURFACE);
5093 dst_surface = MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, dst_obj->object.surface_id);
5094 DDI_CHK_NULL(dst_surface, "nullptr surface", VA_STATUS_ERROR_INVALID_SURFACE);
5095 DDI_CHK_NULL(dst_surface->pGmmResourceInfo, "nullptr dst_surface->pGmmResourceInfo", VA_STATUS_ERROR_INVALID_PARAMETER);
5096
5097 MOS_ZeroMemory(&dst, sizeof(dst));
5098 MediaLibvaCommonNext::MediaSurfaceToMosResource(dst_surface, &dst);
5099 }
5100 else if (dst_obj->obj_type == VACopyObjectBuffer)
5101 {
5102 DDI_CHK_LESS((uint32_t)dst_obj->object.buffer_id, mediaCtx->pBufferHeap->uiAllocatedHeapElements, "Invalid copy dst buf_id", VA_STATUS_ERROR_INVALID_BUFFER);
5103 dst_buffer = MediaLibvaCommonNext::GetBufferFromVABufferID(mediaCtx, dst_obj->object.buffer_id);
5104 DDI_CHK_NULL(dst_buffer, "nullptr buffer", VA_STATUS_ERROR_INVALID_BUFFER);
5105 DDI_CHK_NULL(dst_buffer->pGmmResourceInfo, "nullptr dst_buffer->pGmmResourceInfo", VA_STATUS_ERROR_INVALID_PARAMETER);
5106
5107 MOS_ZeroMemory(&dst, sizeof(dst));
5108 MediaLibvaCommonNext::MediaBufferToMosResource(dst_buffer, &dst);
5109 }
5110 else
5111 {
5112 DDI_ASSERTMESSAGE("DDI: unsupported src copy object in copy.");
5113 }
5114
5115 if (src_obj->obj_type == VACopyObjectSurface)
5116 {
5117 DDI_CHK_LESS((uint32_t)src_obj->object.surface_id, mediaCtx->pSurfaceHeap->uiAllocatedHeapElements, "copy_src", VA_STATUS_ERROR_INVALID_SURFACE);
5118 src_surface = MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, src_obj->object.surface_id);
5119 DDI_CHK_NULL(src_surface, "nullptr surface", VA_STATUS_ERROR_INVALID_SURFACE);
5120 DDI_CHK_NULL(src_surface->pGmmResourceInfo, "nullptr src_surface->pGmmResourceInfo", VA_STATUS_ERROR_INVALID_PARAMETER);
5121
5122 MOS_ZeroMemory(&src, sizeof(src));
5123 MediaLibvaCommonNext::MediaSurfaceToMosResource(src_surface, &src);
5124 }
5125 else if (src_obj->obj_type == VACopyObjectBuffer)
5126 {
5127 DDI_CHK_LESS((uint32_t)src_obj->object.buffer_id, mediaCtx->pBufferHeap->uiAllocatedHeapElements, "Invalid copy dst buf_id", VA_STATUS_ERROR_INVALID_BUFFER);
5128 src_buffer = MediaLibvaCommonNext::GetBufferFromVABufferID(mediaCtx, src_obj->object.buffer_id);
5129 DDI_CHK_NULL(src_buffer, "nullptr buffer", VA_STATUS_ERROR_INVALID_BUFFER);
5130 DDI_CHK_NULL(src_buffer->pGmmResourceInfo, "nullptr src_buffer->pGmmResourceInfo", VA_STATUS_ERROR_INVALID_PARAMETER);
5131
5132 MOS_ZeroMemory(&src, sizeof(src));
5133 MediaLibvaCommonNext::MediaBufferToMosResource(src_buffer, &src);
5134 }
5135 else
5136 {
5137 DDI_ASSERTMESSAGE("DDI: unsupported dst copy object in copy.");
5138 }
5139
5140 mosCtx.bufmgr = mediaCtx->pDrmBufMgr;
5141 mosCtx.fd = mediaCtx->fd;
5142 mosCtx.iDeviceId = mediaCtx->iDeviceId;
5143 mosCtx.m_skuTable = mediaCtx->SkuTable;
5144 mosCtx.m_waTable = mediaCtx->WaTable;
5145 mosCtx.m_gtSystemInfo = *mediaCtx->pGtSystemInfo;
5146 mosCtx.m_platform = mediaCtx->platform;
5147
5148 mosCtx.ppMediaCopyState = &mediaCtx->pMediaCopyState;
5149 mosCtx.m_gtSystemInfo = *mediaCtx->pGtSystemInfo;
5150 mosCtx.m_auxTableMgr = mediaCtx->m_auxTableMgr;
5151 mosCtx.pGmmClientContext = mediaCtx->pGmmClientContext;
5152
5153 mosCtx.m_osDeviceContext = mediaCtx->m_osDeviceContext;
5154 mosCtx.m_apoMosEnabled = true;
5155 mosCtx.pPerfData = mediaCtx->perfData;
5156 mosCtx.m_userSettingPtr = mediaCtx->m_userSettingPtr;
5157
5158 vaStatus = CopyInternal(&mosCtx, &src, &dst, option.bits.va_copy_mode);
5159
5160 if ((option.bits.va_copy_sync == VA_EXEC_SYNC) && dst_surface)
5161 {
5162 uint32_t timeout_NS = 100000000;
5163 while (0 != mos_bo_wait(dst_surface->bo, timeout_NS))
5164 {
5165 // Just loop while gem_bo_wait times-out.
5166 }
5167 }
5168
5169 return vaStatus;
5170 }
5171 #endif
5172
5173 VAStatus MediaLibvaInterfaceNext::MapBuffer(
5174 VADriverContextP ctx,
5175 VABufferID buf_id,
5176 void **pbuf)
5177 {
5178 DDI_FUNC_ENTER;
5179 return MapBufferInternal(ctx, buf_id, pbuf, MOS_LOCKFLAG_READONLY | MOS_LOCKFLAG_WRITEONLY);
5180 }
5181
5182 VAStatus MediaLibvaInterfaceNext::MapBufferInternal(
5183 VADriverContextP ctx,
5184 VABufferID bufId,
5185 void **buf,
5186 uint32_t flag)
5187 {
5188 VAStatus vaStatus = VA_STATUS_SUCCESS;
5189 DDI_MEDIA_BUFFER *mediaBuf = nullptr;
5190 PDDI_MEDIA_CONTEXT mediaCtx = nullptr;
5191 uint32_t ctxType = DDI_MEDIA_CONTEXT_TYPE_NONE;
5192
5193 DDI_FUNC_ENTER;
5194 MOS_TraceEventExt(EVENT_VA_MAP, EVENT_TYPE_START, &bufId, sizeof(bufId), &flag, sizeof(flag));
5195
5196 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
5197 DDI_CHK_NULL(buf, "nullptr buf", VA_STATUS_ERROR_INVALID_PARAMETER);
5198
5199 mediaCtx = GetMediaContext(ctx);
5200 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
5201
5202 DDI_CHK_NULL(mediaCtx->pBufferHeap, "nullptr mediaCtx->pBufferHeap", VA_STATUS_ERROR_INVALID_CONTEXT);
5203 DDI_CHK_LESS((uint32_t)bufId, mediaCtx->pBufferHeap->uiAllocatedHeapElements, "Invalid bufferId", VA_STATUS_ERROR_INVALID_CONTEXT);
5204
5205 mediaBuf = MediaLibvaCommonNext::GetBufferFromVABufferID(mediaCtx, bufId);
5206 DDI_CHK_NULL(buf, "nullptr buf", VA_STATUS_ERROR_INVALID_BUFFER);
5207
5208 ctxType = MediaLibvaCommonNext::GetCtxTypeFromVABufferID(mediaCtx, bufId);
5209 CompType componentIndex = MapComponentFromCtxType(ctxType);
5210 DDI_CHK_NULL(mediaCtx->m_compList[componentIndex], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
5211
5212 MOS_TraceEventExt(EVENT_VA_MAP, EVENT_TYPE_INFO, &ctxType, sizeof(ctxType), &mediaBuf->uiType, sizeof(uint32_t));
5213 vaStatus = mediaCtx->m_compList[componentIndex]->MapBufferInternal(mediaCtx, bufId, buf, flag);
5214
5215 MOS_TraceEventExt(EVENT_VA_MAP, EVENT_TYPE_END, nullptr, 0, nullptr, 0);
5216 return vaStatus;
5217 }
5218
5219 VAStatus MediaLibvaInterfaceNext::UnmapBuffer(
5220 VADriverContextP ctx,
5221 VABufferID bufId)
5222 {
5223 VAStatus vaStatus = VA_STATUS_SUCCESS;
5224 PDDI_MEDIA_CONTEXT mediaCtx = nullptr;
5225 DDI_MEDIA_BUFFER *buf = nullptr;
5226 uint32_t ctxType = DDI_MEDIA_CONTEXT_TYPE_NONE;
5227
5228 DDI_FUNC_ENTER;
5229 MOS_TraceEventExt(EVENT_VA_UNMAP, EVENT_TYPE_START, &bufId, sizeof(bufId), nullptr, 0);
5230
5231 DDI_CHK_NULL(ctx, "nullptr ctx", VA_STATUS_ERROR_INVALID_CONTEXT);
5232
5233 mediaCtx = GetMediaContext(ctx);
5234 DDI_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
5235 DDI_CHK_NULL(mediaCtx->pBufferHeap, "nullptr mediaCtx->pBufferHeap", VA_STATUS_ERROR_INVALID_CONTEXT);
5236 DDI_CHK_LESS((uint32_t)bufId, mediaCtx->pBufferHeap->uiAllocatedHeapElements, "Invalid bufId", VA_STATUS_ERROR_INVALID_BUFFER);
5237
5238 buf = MediaLibvaCommonNext::GetBufferFromVABufferID(mediaCtx, bufId);
5239 DDI_CHK_NULL(buf, "nullptr buf", VA_STATUS_ERROR_INVALID_BUFFER);
5240
5241 ctxType = MediaLibvaCommonNext::GetCtxTypeFromVABufferID(mediaCtx, bufId);
5242 CompType componentIndex = MapComponentFromCtxType(ctxType);
5243 DDI_CHK_NULL(mediaCtx->m_compList[componentIndex], "nullptr complist", VA_STATUS_ERROR_INVALID_CONTEXT);
5244
5245 vaStatus = mediaCtx->m_compList[componentIndex]->UnmapBuffer(mediaCtx, bufId);
5246
5247 MOS_TraceEventExt(EVENT_VA_MAP, EVENT_TYPE_END, nullptr, 0, nullptr, 0);
5248 return vaStatus;
5249 }
5250
5251 VAStatus MediaLibvaInterfaceNext::MediaMemoryDecompress(
5252 PDDI_MEDIA_CONTEXT mediaCtx,
5253 DDI_MEDIA_SURFACE *mediaSurface)
5254 {
5255 DDI_FUNC_ENTER;
5256 DDI_CHK_NULL(mediaCtx, "Null mediaCtx.", VA_STATUS_ERROR_INVALID_CONTEXT);
5257 DDI_CHK_NULL(mediaSurface, "nullptr mediaSurface", VA_STATUS_ERROR_INVALID_PARAMETER);
5258 DDI_CHK_NULL(mediaSurface->pGmmResourceInfo, "nullptr mediaSurface->pGmmResourceInfo", VA_STATUS_ERROR_INVALID_PARAMETER);
5259
5260 VAStatus vaStatus = VA_STATUS_SUCCESS;
5261 GMM_RESOURCE_FLAG GmmFlags;
5262
5263 MOS_ZeroMemory(&GmmFlags, sizeof(GmmFlags));
5264 GmmFlags = mediaSurface->pGmmResourceInfo->GetResFlags();
5265
5266 if (((GmmFlags.Gpu.MMC ||
5267 GmmFlags.Gpu.CCS) &&
5268 GmmFlags.Info.MediaCompressed) ||
5269 mediaSurface->pGmmResourceInfo->IsMediaMemoryCompressed(0))
5270 {
5271 MOS_CONTEXT mosCtx = {};
5272 MOS_RESOURCE surface;
5273
5274 MOS_ZeroMemory(&surface, sizeof(surface));
5275
5276 mosCtx.bufmgr = mediaCtx->pDrmBufMgr;
5277 mosCtx.fd = mediaCtx->fd;
5278 mosCtx.iDeviceId = mediaCtx->iDeviceId;
5279 mosCtx.m_skuTable = mediaCtx->SkuTable;
5280 mosCtx.m_waTable = mediaCtx->WaTable;
5281 mosCtx.m_gtSystemInfo = *mediaCtx->pGtSystemInfo;
5282 mosCtx.m_platform = mediaCtx->platform;
5283
5284 mosCtx.ppMediaMemDecompState = &mediaCtx->pMediaMemDecompState;
5285 mosCtx.pfnMemoryDecompress = mediaCtx->pfnMemoryDecompress;
5286 mosCtx.pfnMediaMemoryCopy = mediaCtx->pfnMediaMemoryCopy;
5287 mosCtx.pfnMediaMemoryCopy2D = mediaCtx->pfnMediaMemoryCopy2D;
5288 mosCtx.m_gtSystemInfo = *mediaCtx->pGtSystemInfo;
5289 mosCtx.m_auxTableMgr = mediaCtx->m_auxTableMgr;
5290 mosCtx.pGmmClientContext = mediaCtx->pGmmClientContext;
5291
5292 mosCtx.m_osDeviceContext = mediaCtx->m_osDeviceContext;
5293 mosCtx.m_apoMosEnabled = true;
5294
5295 mosCtx.m_userSettingPtr = mediaCtx->m_userSettingPtr;
5296
5297 MosUtilities::MosLockMutex(&mediaCtx->SurfaceMutex);
5298 MosUtilities::MosLockMutex(&mediaCtx->MemDecompMutex);
5299
5300 MediaLibvaCommonNext::MediaSurfaceToMosResource(mediaSurface, &surface);
5301 MediaLibvaInterfaceNext::MediaMemoryDecompressInternal(&mosCtx, &surface);
5302
5303 MosUtilities::MosUnlockMutex(&mediaCtx->MemDecompMutex);
5304 MosUtilities::MosUnlockMutex(&mediaCtx->SurfaceMutex);
5305 }
5306
5307 return vaStatus;
5308 }
5309
5310 VAStatus MediaLibvaInterfaceNext::QueryProcessingRate(
5311 VADriverContextP ctx,
5312 VAConfigID configId,
5313 VAProcessingRateParameter *procBuf,
5314 uint32_t *processingRate)
5315 {
5316 DDI_FUNC_ENTER;
5317 return VA_STATUS_ERROR_UNIMPLEMENTED;
5318 }