Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add packed formats to import va surface

Browse Source 
This patch adds YUY2 and Y210 packed formats into cl/va sharing

Signed-off-by: Kamil Diedrich <kamil.diedrich@intel.com>
This commit is contained in:
Kamil Diedrich
2022-08-23 09:45:24 +00:00
committed by Compute-Runtime-Automation
parent 40c73d5101
commit 2de3cdc90c
6 changed files with 533 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
opencl/test/unit_test/sharings/va/mock_va_sharing.h
View File

@ -20,6 +20,7 @@ class VASharingFunctionsMock : public VASharingFunctions {
using VASharingFunctions::mutex;
using VASharingFunctions::supported2PlaneFormats;
using VASharingFunctions::supported3PlaneFormats;
using VASharingFunctions::supportedPackedFormats;
VAImage mockVaImage = {};
int32_t derivedImageFormatFourCC = VA_FOURCC_NV12;
@ -28,6 +29,7 @@ class VASharingFunctionsMock : public VASharingFunctions {
uint16_t derivedImageWidth = 256;
VAStatus queryImageFormatsReturnStatus = VA_STATUS_SUCCESS;
VAStatus syncSurfaceReturnStatus = VA_STATUS_SUCCESS;
VAStatus deriveImageReturnStatus = VA_STATUS_SUCCESS;
bool isValidDisplayCalled = false;
bool deriveImageCalled = false;
@ -61,6 +63,9 @@ class VASharingFunctionsMock : public VASharingFunctions {
VASharingFunctionsMock() : VASharingFunctionsMock(nullptr){};
VAStatus deriveImage(VASurfaceID vaSurface, VAImage *vaImage) override {
if (deriveImageReturnStatus != VA_STATUS_SUCCESS) {
return deriveImageReturnStatus;
}
deriveImageCalled = true;
uint32_t pitch;
vaImage->height = derivedImageHeight;

327
opencl/test/unit_test/sharings/va/va_sharing_tests.cpp
View File

@ -280,6 +280,274 @@ TEST_F(VaSharingTests, givenMockVaWhenVaSurfaceIsCreatedThenMemObjectHasVaHandle
delete vaSurface;
}
TEST_F(VaSharingTests, givenSupportedFourccFormatWhenIsSupportedPlanarFormatThenSuccessIsReturned) {
EXPECT_TRUE(VASurface::isSupportedPlanarFormat(VA_FOURCC_P010));
EXPECT_TRUE(VASurface::isSupportedPlanarFormat(VA_FOURCC_P016));
EXPECT_TRUE(VASurface::isSupportedPlanarFormat(VA_FOURCC_NV12));
DebugManagerStateRestore restore;
DebugManager.flags.EnableExtendedVaFormats.set(true);
EXPECT_TRUE(VASurface::isSupportedPlanarFormat(VA_FOURCC_RGBP));
}
TEST_F(VaSharingTests, givenSupportedPackedFormatWhenIsSupportedPlanarFormatThenFailIsReturned) {
EXPECT_FALSE(VASurface::isSupportedPlanarFormat(VA_FOURCC_YUY2));
}
TEST_F(VaSharingTests, givenSupportedFourccFormatWhenIsSupportedPackedFormatThenSuccessIsReturned) {
EXPECT_TRUE(VASurface::isSupportedPackedFormat(VA_FOURCC_YUY2));
}
TEST_F(VaSharingTests, givenSupportedPlanarFormatWhenIsSupportedPackedFormatThenFailIsReturned) {
EXPECT_FALSE(VASurface::isSupportedPackedFormat(VA_FOURCC_NV12));
}
TEST_F(VaSharingTests, givenValidSurfaceWhenGetSurfaceDescriptionThenCLSuccessIsReturnedAndDataAreSet) {
DebugManagerStateRestore restore;
DebugManager.flags.EnableExtendedVaFormats.set(true);
vaSharing->sharingFunctions.haveExportSurfaceHandle = true;
vaSharing->sharingFunctions.mockVaSurfaceDesc.fourcc = VA_FOURCC_YUY2;
vaSharing->sharingFunctions.mockVaSurfaceDesc.objects[0] = {8, 98304, I915_FORMAT_MOD_Y_TILED};
vaSharing->sharingFunctions.mockVaSurfaceDesc.num_layers = 1;
vaSharing->sharingFunctions.mockVaSurfaceDesc.layers[0] = {DRM_FORMAT_YUYV, 1, {}, {0, 0, 0, 0}, {256, 0, 0, 0}};
vaSharing->sharingFunctions.mockVaSurfaceDesc.width = 24;
vaSharing->sharingFunctions.mockVaSurfaceDesc.height = 24;
vaSharing->sharingFunctions.derivedImageFormatBpp = 16;
vaSharing->sharingFunctions.derivedImageFormatFourCC = VA_FOURCC_YUY2;
SharedSurfaceInfo surfaceInfo{};
EXPECT_EQ(VA_STATUS_SUCCESS, VASurface::getSurfaceDescription(surfaceInfo, &vaSharing->sharingFunctions, &vaSurfaceId));
EXPECT_EQ(vaSharing->sharingFunctions.mockVaSurfaceDesc.height, surfaceInfo.imgInfo.imgDesc.imageWidth);
EXPECT_EQ(vaSharing->sharingFunctions.mockVaSurfaceDesc.width, surfaceInfo.imgInfo.imgDesc.imageHeight);
EXPECT_EQ(static_cast<uint32_t>(vaSharing->sharingFunctions.mockVaSurfaceDesc.objects[0].fd), surfaceInfo.sharedHandle);
EXPECT_EQ(vaSharing->sharingFunctions.mockVaSurfaceDesc.fourcc, surfaceInfo.imageFourcc);
EXPECT_FALSE(surfaceInfo.imgInfo.linearStorage);
}
TEST_F(VaSharingTests, givenValidSurfaceWithInvalidPlaneNumberWhenGetSurfaceDescriptionThenFailIsReturned) {
DebugManagerStateRestore restore;
DebugManager.flags.EnableExtendedVaFormats.set(true);
vaSharing->sharingFunctions.haveExportSurfaceHandle = true;
vaSharing->sharingFunctions.mockVaSurfaceDesc.fourcc = VA_FOURCC_YUY2;
vaSharing->sharingFunctions.mockVaSurfaceDesc.objects[0] = {8, 98304, I915_FORMAT_MOD_Y_TILED};
vaSharing->sharingFunctions.mockVaSurfaceDesc.num_layers = 1;
vaSharing->sharingFunctions.mockVaSurfaceDesc.layers[0] = {DRM_FORMAT_YUYV, 1, {}, {0, 0, 0, 0}, {256, 0, 0, 0}};
vaSharing->sharingFunctions.mockVaSurfaceDesc.width = 24;
vaSharing->sharingFunctions.mockVaSurfaceDesc.height = 24;
vaSharing->sharingFunctions.derivedImageFormatBpp = 16;
vaSharing->sharingFunctions.derivedImageFormatFourCC = VA_FOURCC_YUY2;
SharedSurfaceInfo surfaceInfo{};
surfaceInfo.plane = 1;
EXPECT_EQ(VA_STATUS_ERROR_INVALID_PARAMETER, VASurface::getSurfaceDescription(surfaceInfo, &vaSharing->sharingFunctions, &vaSurfaceId));
}
TEST_F(VaSharingTests, givenValidPlanarSurfaceWithPlaneSetWhenGetSurfaceDescriptionThenCLSuccessIsReturnedAndDataAreSet) {
DebugManagerStateRestore restore;
DebugManager.flags.EnableExtendedVaFormats.set(true);
vaSharing->sharingFunctions.haveExportSurfaceHandle = true;
vaSharing->sharingFunctions.mockVaSurfaceDesc.fourcc = VA_FOURCC_NV12;
vaSharing->sharingFunctions.mockVaSurfaceDesc.objects[0] = {8, 98304, I915_FORMAT_MOD_Y_TILED};
vaSharing->sharingFunctions.mockVaSurfaceDesc.num_layers = 1;
vaSharing->sharingFunctions.mockVaSurfaceDesc.layers[0] = {DRM_FORMAT_YUYV, 1, {}, {0, 0, 0, 0}, {256, 0, 0, 0}};
vaSharing->sharingFunctions.mockVaSurfaceDesc.layers[1] = {DRM_FORMAT_R8, 1, {}, {128, 0, 0, 0}, {256, 0, 0, 0}};
vaSharing->sharingFunctions.mockVaSurfaceDesc.layers[2] = {DRM_FORMAT_R8, 1, {}, {512, 0, 0, 0}, {1024, 0, 0, 0}};
vaSharing->sharingFunctions.mockVaSurfaceDesc.width = 24;
vaSharing->sharingFunctions.mockVaSurfaceDesc.height = 24;
SharedSurfaceInfo surfaceInfo{};
surfaceInfo.plane = 1;
EXPECT_EQ(VA_STATUS_SUCCESS, VASurface::getSurfaceDescription(surfaceInfo, &vaSharing->sharingFunctions, &vaSurfaceId));
EXPECT_EQ(vaSharing->sharingFunctions.mockVaSurfaceDesc.height, surfaceInfo.imgInfo.imgDesc.imageWidth);
EXPECT_EQ(vaSharing->sharingFunctions.mockVaSurfaceDesc.width, surfaceInfo.imgInfo.imgDesc.imageHeight);
EXPECT_EQ(static_cast<uint32_t>(vaSharing->sharingFunctions.mockVaSurfaceDesc.objects[0].fd), surfaceInfo.sharedHandle);
EXPECT_EQ(vaSharing->sharingFunctions.mockVaSurfaceDesc.fourcc, surfaceInfo.imageFourcc);
EXPECT_FALSE(surfaceInfo.imgInfo.linearStorage);
EXPECT_EQ(surfaceInfo.imageOffset, vaSharing->sharingFunctions.mockVaSurfaceDesc.layers[1].offset[0]);
EXPECT_EQ(surfaceInfo.imagePitch, vaSharing->sharingFunctions.mockVaSurfaceDesc.layers[1].pitch[0]);
surfaceInfo.plane = 2;
EXPECT_EQ(VA_STATUS_SUCCESS, VASurface::getSurfaceDescription(surfaceInfo, &vaSharing->sharingFunctions, &vaSurfaceId));
EXPECT_EQ(vaSharing->sharingFunctions.mockVaSurfaceDesc.height, surfaceInfo.imgInfo.imgDesc.imageWidth);
EXPECT_EQ(vaSharing->sharingFunctions.mockVaSurfaceDesc.width, surfaceInfo.imgInfo.imgDesc.imageHeight);
EXPECT_EQ(static_cast<uint32_t>(vaSharing->sharingFunctions.mockVaSurfaceDesc.objects[0].fd), surfaceInfo.sharedHandle);
EXPECT_EQ(vaSharing->sharingFunctions.mockVaSurfaceDesc.fourcc, surfaceInfo.imageFourcc);
EXPECT_FALSE(surfaceInfo.imgInfo.linearStorage);
EXPECT_EQ(surfaceInfo.imageOffset, vaSharing->sharingFunctions.mockVaSurfaceDesc.layers[2].offset[0]);
EXPECT_EQ(surfaceInfo.imagePitch, vaSharing->sharingFunctions.mockVaSurfaceDesc.layers[2].pitch[0]);
}
TEST_F(VaSharingTests, givenValidSurfaceWhenGetSurfaceDescriptionWithDeriveImageThenCLSuccessIsReturnedAndDataAreSet) {
vaSharing->sharingFunctions.derivedImageFormatBpp = 16;
vaSharing->sharingFunctions.derivedImageFormatFourCC = VA_FOURCC_YUY2;
vaSharing->sharingFunctions.derivedImageHeight = 24;
vaSharing->sharingFunctions.derivedImageWidth = 24;
SharedSurfaceInfo surfaceInfo{};
EXPECT_EQ(VA_STATUS_SUCCESS, VASurface::getSurfaceDescription(surfaceInfo, &vaSharing->sharingFunctions, &vaSurfaceId));
EXPECT_EQ(vaSharing->sharingFunctions.derivedImageHeight, surfaceInfo.imgInfo.imgDesc.imageWidth);
EXPECT_EQ(vaSharing->sharingFunctions.derivedImageWidth, surfaceInfo.imgInfo.imgDesc.imageHeight);
EXPECT_EQ(static_cast<uint32_t>(vaSharing->sharingFunctions.derivedImageFormatFourCC), surfaceInfo.imageFourcc);
}
TEST_F(VaSharingTests, givenValidSurfaceWithInvalidPlaneNumberWhenGetSurfaceDescriptionWithDeriveImageThenFailIsReturned) {
vaSharing->sharingFunctions.derivedImageFormatBpp = 16;
vaSharing->sharingFunctions.derivedImageFormatFourCC = VA_FOURCC_YUY2;
vaSharing->sharingFunctions.derivedImageHeight = 24;
vaSharing->sharingFunctions.derivedImageWidth = 24;
SharedSurfaceInfo surfaceInfo{};
surfaceInfo.plane = 1;
EXPECT_EQ(VA_STATUS_ERROR_INVALID_PARAMETER, VASurface::getSurfaceDescription(surfaceInfo, &vaSharing->sharingFunctions, &vaSurfaceId));
}
TEST_F(VaSharingTests, givenInvalidSurfaceWhenGetSurfaceDescriptionWithDeriveImageThenFailIsReturned) {
vaSharing->sharingFunctions.deriveImageReturnStatus = VA_STATUS_ERROR_OPERATION_FAILED;
SharedSurfaceInfo surfaceInfo{};
EXPECT_EQ(VA_STATUS_ERROR_OPERATION_FAILED, VASurface::getSurfaceDescription(surfaceInfo, &vaSharing->sharingFunctions, &vaSurfaceId));
}
TEST_F(VaSharingTests, givenValidPlanarSurfaceWithPlaneSetWhenGetSurfaceDescriptionWithDeriveImageThenCLSuccessIsReturnedAndDataAreSet) {
vaSharing->sharingFunctions.derivedImageFormatBpp = 16;
vaSharing->sharingFunctions.derivedImageFormatFourCC = VA_FOURCC_NV12;
vaSharing->sharingFunctions.derivedImageHeight = 24;
vaSharing->sharingFunctions.derivedImageWidth = 24;
size_t pitch = alignUp(vaSharing->sharingFunctions.derivedImageWidth, 128);
size_t offset = alignUp(vaSharing->sharingFunctions.derivedImageHeight, 32) * pitch;
SharedSurfaceInfo surfaceInfo{};
surfaceInfo.plane = 1;
EXPECT_EQ(VA_STATUS_SUCCESS, VASurface::getSurfaceDescription(surfaceInfo, &vaSharing->sharingFunctions, &vaSurfaceId));
EXPECT_EQ(vaSharing->sharingFunctions.derivedImageHeight, surfaceInfo.imgInfo.imgDesc.imageWidth);
EXPECT_EQ(vaSharing->sharingFunctions.derivedImageWidth, surfaceInfo.imgInfo.imgDesc.imageHeight);
EXPECT_EQ(static_cast<uint32_t>(vaSharing->sharingFunctions.derivedImageFormatFourCC), surfaceInfo.imageFourcc);
EXPECT_EQ(surfaceInfo.imageOffset, offset);
EXPECT_EQ(surfaceInfo.imagePitch, pitch);
surfaceInfo.plane = 2;
EXPECT_EQ(VA_STATUS_SUCCESS, VASurface::getSurfaceDescription(surfaceInfo, &vaSharing->sharingFunctions, &vaSurfaceId));
EXPECT_EQ(vaSharing->sharingFunctions.derivedImageHeight, surfaceInfo.imgInfo.imgDesc.imageWidth);
EXPECT_EQ(vaSharing->sharingFunctions.derivedImageWidth, surfaceInfo.imgInfo.imgDesc.imageHeight);
EXPECT_EQ(static_cast<uint32_t>(vaSharing->sharingFunctions.derivedImageFormatFourCC), surfaceInfo.imageFourcc);
EXPECT_EQ(surfaceInfo.imageOffset, offset + 1);
EXPECT_EQ(surfaceInfo.imagePitch, pitch);
}
TEST_F(VaSharingTests, givenValidPlanarSurfaceWithPlaneSetWhenApplyPlanarOptionsThenProperDataAreSet) {
SharedSurfaceInfo surfaceInfo{};
// NV12 part
surfaceInfo.plane = 0;
surfaceInfo.gmmImgFormat = {CL_NV12_INTEL, CL_UNORM_INT8};
surfaceInfo.channelOrder = CL_RG;
surfaceInfo.channelType = CL_UNORM_INT8;
VASurface::applyPlanarOptions(surfaceInfo, 0, 0, true);
EXPECT_EQ(surfaceInfo.imgInfo.plane, GMM_PLANE_Y);
EXPECT_EQ(surfaceInfo.channelOrder, static_cast<cl_channel_order>(CL_R));
EXPECT_EQ(surfaceInfo.imgInfo.surfaceFormat->GMMSurfaceFormat, GMM_FORMAT_NV12);
VASurface::applyPlanarOptions(surfaceInfo, 1, 0, true);
EXPECT_EQ(surfaceInfo.imgInfo.plane, GMM_PLANE_U);
EXPECT_EQ(surfaceInfo.channelOrder, static_cast<cl_channel_order>(CL_RG));
// RGBP part
DebugManagerStateRestore restore;
DebugManager.flags.EnableExtendedVaFormats.set(true);
surfaceInfo.imageFourcc = VA_FOURCC_RGBP;
VASurface::applyPlanarOptions(surfaceInfo, 1, 0, true);
EXPECT_EQ(surfaceInfo.imgInfo.plane, GMM_PLANE_U);
EXPECT_EQ(surfaceInfo.channelOrder, static_cast<cl_channel_order>(CL_R));
EXPECT_EQ(surfaceInfo.channelType, static_cast<cl_channel_type>(CL_UNORM_INT8));
surfaceInfo.imageFourcc = VA_FOURCC_RGBP;
VASurface::applyPlanarOptions(surfaceInfo, 2, 0, true);
EXPECT_EQ(surfaceInfo.imgInfo.plane, GMM_PLANE_V);
EXPECT_EQ(surfaceInfo.channelOrder, static_cast<cl_channel_order>(CL_R));
EXPECT_EQ(surfaceInfo.channelType, static_cast<cl_channel_type>(CL_UNORM_INT8));
// P010 part
surfaceInfo.imageFourcc = VA_FOURCC_P010;
VASurface::applyPlanarOptions(surfaceInfo, 1, 0, true);
EXPECT_EQ(surfaceInfo.channelType, static_cast<cl_channel_type>(CL_UNORM_INT16));
EXPECT_EQ(surfaceInfo.imgInfo.surfaceFormat->GMMSurfaceFormat, GMM_FORMAT_P010);
// P016 part
surfaceInfo.imageFourcc = VA_FOURCC_P016;
VASurface::applyPlanarOptions(surfaceInfo, 1, 0, true);
EXPECT_EQ(surfaceInfo.channelType, static_cast<cl_channel_type>(CL_UNORM_INT16));
EXPECT_EQ(surfaceInfo.imgInfo.surfaceFormat->GMMSurfaceFormat, GMM_FORMAT_P016);
}
TEST_F(VaSharingTests, givenValidPlanarSurfaceWithInvalidPlaneSetWhenApplyPlanarOptionsThenUnrecoverableIsCalled) {
SharedSurfaceInfo surfaceInfo{};
surfaceInfo.imageFourcc = VA_FOURCC_P016;
EXPECT_THROW(VASurface::applyPlanarOptions(surfaceInfo, 2, 0, true), std::exception);
EXPECT_THROW(VASurface::applyPlanarOptions(surfaceInfo, 3, 0, true), std::exception);
}
TEST_F(VaSharingTests, givenValidSurfaceWithPlaneSetWhenApplyPlaneSettingsThenProperDataAreSet) {
SharedSurfaceInfo surfaceInfo{};
surfaceInfo.imgInfo.imgDesc.imageWidth = 128;
surfaceInfo.imgInfo.imgDesc.imageHeight = 128;
surfaceInfo.imageOffset = 24;
surfaceInfo.imagePitch = 24;
VASurface::applyPlaneSettings(surfaceInfo, 1u);
EXPECT_EQ(surfaceInfo.imgInfo.imgDesc.imageHeight, 64u);
EXPECT_EQ(surfaceInfo.imgInfo.imgDesc.imageWidth, 64u);
EXPECT_EQ(surfaceInfo.imgInfo.offset, surfaceInfo.imageOffset);
EXPECT_EQ(surfaceInfo.imgInfo.yOffsetForUVPlane, static_cast<uint32_t>(surfaceInfo.imageOffset / surfaceInfo.imagePitch));
DebugManagerStateRestore restore;
DebugManager.flags.EnableExtendedVaFormats.set(true);
surfaceInfo.imageFourcc = VA_FOURCC_RGBP;
VASurface::applyPlaneSettings(surfaceInfo, 1u);
EXPECT_EQ(surfaceInfo.imgInfo.imgDesc.imageHeight, 64u);
EXPECT_EQ(surfaceInfo.imgInfo.imgDesc.imageWidth, 64u);
surfaceInfo.imageOffset = 128;
VASurface::applyPlaneSettings(surfaceInfo, 2u);
EXPECT_EQ(surfaceInfo.imgInfo.offset, surfaceInfo.imageOffset);
}
TEST_F(VaSharingTests, givenValidPackedFormatWhenApplyPackedOptionsThenSurfaceFormatIsSet) {
SharedSurfaceInfo surfaceInfo{};
surfaceInfo.imageFourcc = VA_FOURCC_YUY2;
VASurface::applyPackedOptions(surfaceInfo);
EXPECT_EQ(surfaceInfo.imgInfo.surfaceFormat->GMMSurfaceFormat, GMM_FORMAT_YCRCB_NORMAL);
}
TEST_F(VaSharingTests, givenInvalidPlaneWhenVaSurfaceIsCreatedAndNotRGBPThenUnrecoverableIsCalled) {
EXPECT_THROW(VASurface::createSharedVaSurface(&context, &vaSharing->sharingFunctions,
CL_MEM_READ_WRITE, 0, &vaSurfaceId, 2, &errCode),
@ -542,8 +810,8 @@ TEST_F(VaSharingTests, whenSyncSurfaceFailedThenReturnOutOfResource) {
TEST_F(VaSharingTests, givenYuvPlaneWhenCreateIsCalledThenChangeWidthAndHeight) {
cl_uint planeTypes[] = {
0, //Y
1 //U
0, // Y
1 // U
};
context.setInteropUserSyncEnabled(true);
@ -645,6 +913,49 @@ TEST_F(VaSharingTests, givenP016FormatWhenCreatingSharedVaSurfaceForPlane1ThenCo
EXPECT_EQ(CL_SUCCESS, errCode);
}
TEST_F(VaSharingTests, givenInvalidSurfaceWhenCreatingSharedVaSurfaceThenNullptrReturnedAndErrIsSet) {
vaSharing->sharingFunctions.deriveImageReturnStatus = VA_STATUS_ERROR_OPERATION_FAILED;
auto vaSurface = std::unique_ptr<Image>(VASurface::createSharedVaSurface(&context, &vaSharing->sharingFunctions,
CL_MEM_READ_WRITE, 0, &vaSurfaceId, 1, &errCode));
EXPECT_EQ(vaSurface, nullptr);
EXPECT_EQ(errCode, VA_STATUS_ERROR_OPERATION_FAILED);
}
TEST_F(VaSharingTests, givenYUY2FormatWhenCreatingSharedVaSurfaceThenCorrectFormatIsUsedByImageAndGMM) {
vaSharing->sharingFunctions.haveExportSurfaceHandle = true;
vaSharing->sharingFunctions.mockVaSurfaceDesc.fourcc = VA_FOURCC_YUY2;
vaSharing->sharingFunctions.mockVaSurfaceDesc.objects[0] = {8, 98304, I915_FORMAT_MOD_Y_TILED};
vaSharing->sharingFunctions.mockVaSurfaceDesc.num_layers = 1;
vaSharing->sharingFunctions.mockVaSurfaceDesc.layers[0] = {DRM_FORMAT_YUYV, 1, {}, {0, 0, 0, 0}, {256, 0, 0, 0}};
vaSharing->sharingFunctions.mockVaSurfaceDesc.width = 24;
vaSharing->sharingFunctions.mockVaSurfaceDesc.height = 24;
vaSharing->sharingFunctions.derivedImageFormatBpp = 16;
vaSharing->sharingFunctions.derivedImageFormatFourCC = VA_FOURCC_YUY2;
auto vaSurface = std::unique_ptr<Image>(VASurface::createSharedVaSurface(&context, &vaSharing->sharingFunctions,
CL_MEM_READ_WRITE, 0, &vaSurfaceId, 0, &errCode));
auto graphicsAllocation = vaSurface->getGraphicsAllocation(rootDeviceIndex);
EXPECT_EQ(static_cast<cl_channel_type>(CL_UNORM_INT8), vaSurface->getImageFormat().image_channel_data_type);
EXPECT_EQ(static_cast<cl_channel_order>(CL_YUYV_INTEL), vaSurface->getImageFormat().image_channel_order);
EXPECT_EQ(GMM_RESOURCE_FORMAT::GMM_FORMAT_YCRCB_NORMAL, vaSurface->getSurfaceFormatInfo().surfaceFormat.GMMSurfaceFormat);
EXPECT_EQ(GMM_RESOURCE_FORMAT::GMM_FORMAT_YCRCB_NORMAL, graphicsAllocation->getDefaultGmm()->resourceParams.Format);
EXPECT_EQ(CL_SUCCESS, errCode);
}
TEST_F(VaSharingTests, givenNotSupportedFormatWhenCreatingSharedVaSurfaceThenErrorIsReturned) {
vaSharing->sharingFunctions.haveExportSurfaceHandle = true;
vaSharing->sharingFunctions.mockVaSurfaceDesc.fourcc = VA_FOURCC_NV21;
auto vaSurface = std::unique_ptr<Image>(VASurface::createSharedVaSurface(&context, &vaSharing->sharingFunctions,
CL_MEM_READ_WRITE, 0, &vaSurfaceId, 0, &errCode));
EXPECT_EQ(vaSurface, nullptr);
EXPECT_EQ(errCode, VA_STATUS_ERROR_INVALID_PARAMETER);
}
TEST_F(VaSharingTests, givenEnabledExtendedVaFormatsAndRGBPFormatWhenCreatingSharedVaSurfaceForPlane0ThenCorrectFormatIsUsedByImageAndGMM) {
DebugManagerStateRestore restore;
DebugManager.flags.EnableExtendedVaFormats.set(true);
@ -952,6 +1263,7 @@ TEST(VaSharingFunctions, givenErrorReturnedFromVaLibWhenQuerySupportedVaImageFor
TEST(VaSharingFunctions, givenNoSupportedFormatsWhenQuerySupportedVaImageFormatsThenSupportedFormatsAreNotSet) {
VASharingFunctionsMock sharingFunctions;
EXPECT_EQ(0u, sharingFunctions.supportedPackedFormats.size());
EXPECT_EQ(0u, sharingFunctions.supported2PlaneFormats.size());
EXPECT_EQ(0u, sharingFunctions.supported3PlaneFormats.size());
cl_mem_flags flags = CL_MEM_READ_WRITE;
@ -1133,26 +1445,28 @@ TEST_F(VaSharingTests, givenPlaneArgumentLessThan2WithProperFormatsAndEmptySuppo
EXPECT_EQ(0u, vaApiFormats[0].fourcc);
}
TEST_F(VaSharingTests, givenPlaneArgumentLessThan2WithProperFormatsAndSupportedFormatsVectorsThenAll2And3PlaneFormatsAreReturned) {
TEST_F(VaSharingTests, givenPlaneArgumentLessThan2WithProperFormatsAndSupportedFormatsVectorsThenAllPackedAnd2And3PlaneFormatsAreReturned) {
VASharingFunctionsMock sharingFunctions;
EXPECT_EQ(sharingFunctions.supported2PlaneFormats.size(), 0u);
EXPECT_EQ(sharingFunctions.supported3PlaneFormats.size(), 0u);
EXPECT_EQ(sharingFunctions.supportedPackedFormats.size(), 0u);
cl_mem_flags flags = CL_MEM_READ_WRITE;
cl_mem_object_type imageType = CL_MEM_OBJECT_IMAGE2D;
cl_uint numImageFormats = 4;
VAImageFormat vaApiFormats[4] = {};
cl_uint numImageFormats = 5;
VAImageFormat vaApiFormats[5] = {};
sharingFunctions.supported2PlaneFormats.push_back(VAImageFormat{VA_FOURCC_NV12, VA_LSB_FIRST, 0, 0, 0, 0, 0, 0});
sharingFunctions.supported2PlaneFormats.push_back(VAImageFormat{VA_FOURCC_P010, VA_LSB_FIRST, 0, 0, 0, 0, 0, 0});
sharingFunctions.supported2PlaneFormats.push_back(VAImageFormat{VA_FOURCC_P016, VA_LSB_FIRST, 0, 0, 0, 0, 0, 0});
sharingFunctions.supported3PlaneFormats.push_back(VAImageFormat{VA_FOURCC_RGBP, VA_LSB_FIRST, 0, 0, 0, 0, 0, 0});
sharingFunctions.supportedPackedFormats.push_back(VAImageFormat{VA_FOURCC_YUY2, VA_LSB_FIRST, 0, 0, 0, 0, 0, 0});
sharingFunctions.getSupportedFormats(
flags,
imageType,
0,
4,
5,
vaApiFormats,
&numImageFormats);
@ -1160,6 +1474,7 @@ TEST_F(VaSharingTests, givenPlaneArgumentLessThan2WithProperFormatsAndSupportedF
EXPECT_EQ(static_cast<uint32_t>(VA_FOURCC_P010), vaApiFormats[1].fourcc);
EXPECT_EQ(static_cast<uint32_t>(VA_FOURCC_P016), vaApiFormats[2].fourcc);
EXPECT_EQ(static_cast<uint32_t>(VA_FOURCC_RGBP), vaApiFormats[3].fourcc);
EXPECT_EQ(static_cast<uint32_t>(VA_FOURCC_YUY2), vaApiFormats[4].fourcc);
}
TEST_F(VaSharingTests, givenPlaneArgumentLessThan2WithProperFormatsAndOnly3PlaneSupportedFormatsVectorThen3PlaneFormatIsReturned) {