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