Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

initial support for rgbp format 

Change-Id: Ib266d6c64482a9b4a4384714a369ad159affd8d9
This commit is contained in:
kamdiedrich 2020-05-18 22:45:32 +02:00 committed by sys_ocldev
parent e854042302
commit 0443b97927
3 changed files with 171 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
opencl/source/sharings/va/va_surface.cpp
View File

@ -53,6 +53,9 @@ Image *VASurface::createSharedVaSurface(Context *context, VASharingFunctions *sh
if (plane == 1) {
imageOffset = vaDrmPrimeSurfaceDesc.layers[1].offset[0];
imagePitch = vaDrmPrimeSurfaceDesc.layers[1].pitch[0];
} else if (plane == 2) {
imageOffset = vaDrmPrimeSurfaceDesc.layers[2].offset[0];
imagePitch = vaDrmPrimeSurfaceDesc.layers[2].pitch[0];
}
imgInfo.linearStorage = DRM_FORMAT_MOD_LINEAR == vaDrmPrimeSurfaceDesc.objects[0].drm_format_modifier;
sharedHandle = vaDrmPrimeSurfaceDesc.objects[0].fd;
@ -65,11 +68,16 @@ Image *VASurface::createSharedVaSurface(Context *context, VASharingFunctions *sh
if (plane == 1) {
imageOffset = vaImage.offsets[1];
imagePitch = vaImage.pitches[0];
} else if (plane == 2) {
imageOffset = vaImage.offsets[2];
imagePitch = vaImage.pitches[0];
}
imgInfo.linearStorage = false;
sharingFunctions->extGetSurfaceHandle(surface, &sharedHandle);
}
bool isRGBPFormat = DebugManager.flags.EnableExtendedVaFormats.get() && imageFourcc == VA_FOURCC_RGBP;
imgDesc.image_type = CL_MEM_OBJECT_IMAGE2D;
imgInfo.imgDesc = Image::convertDescriptor(imgDesc);
@ -78,15 +86,19 @@ Image *VASurface::createSharedVaSurface(Context *context, VASharingFunctions *sh
channelOrder = CL_R;
} else if (plane == 1) {
imgInfo.plane = GMM_PLANE_U;
channelOrder = CL_RG;
channelOrder = isRGBPFormat ? CL_R : CL_RG;
} else if (plane == 2) {
UNRECOVERABLE_IF(!isRGBPFormat);
imgInfo.plane = GMM_PLANE_V;
channelOrder = CL_R;
} else {
UNRECOVERABLE_IF(true);
}
auto gmmSurfaceFormat = Image::getSurfaceFormatFromTable(flags, &gmmImgFormat, context->getDevice(0)->getHardwareInfo().capabilityTable.supportsOcl21Features); //vaImage.format.fourcc == VA_FOURCC_NV12
if (DebugManager.flags.EnableExtendedVaFormats.get() && imageFourcc == VA_FOURCC_P010) {
channelType = CL_UNORM_INT16;
if (DebugManager.flags.EnableExtendedVaFormats.get() && (imageFourcc == VA_FOURCC_P010 || imageFourcc == VA_FOURCC_RGBP)) {
channelType = isRGBPFormat ? CL_UNORM_INT8 : CL_UNORM_INT16;
gmmSurfaceFormat = getExtendedSurfaceFormatInfo(imageFourcc);
}
imgInfo.surfaceFormat = &gmmSurfaceFormat->surfaceFormat;
@ -105,14 +117,19 @@ Image *VASurface::createSharedVaSurface(Context *context, VASharingFunctions *sh
imgDesc.image_slice_pitch = 0u;
imgInfo.slicePitch = 0u;
imgInfo.surfaceFormat = &imgSurfaceFormat->surfaceFormat;
imgInfo.yOffset = 0;
imgInfo.xOffset = 0;
if (plane == 1) {
imgDesc.image_width /= 2;
imgDesc.image_height /= 2;
if (!isRGBPFormat) {
imgDesc.image_width /= 2;
imgDesc.image_height /= 2;
}
imgInfo.offset = imageOffset;
imgInfo.yOffset = 0;
imgInfo.xOffset = 0;
imgInfo.yOffsetForUVPlane = static_cast<uint32_t>(imageOffset / imagePitch);
}
if (isRGBPFormat && plane == 2) {
imgInfo.offset = imageOffset;
}
imgInfo.imgDesc = Image::convertDescriptor(imgDesc);
if (VA_INVALID_ID != imageId) {
sharingFunctions->destroyImage(imageId);
@ -163,6 +180,16 @@ const ClSurfaceFormatInfo *VASurface::getExtendedSurfaceFormatInfo(uint32_t form
2}};
return &formatInfo;
}
if (formatFourCC == VA_FOURCC_RGBP) {
static const ClSurfaceFormatInfo formatInfoRGBP = {{CL_NV12_INTEL, CL_UNORM_INT8},
{GMM_RESOURCE_FORMAT::GMM_FORMAT_RGBP,
static_cast<GFX3DSTATE_SURFACEFORMAT>(GFX3DSTATE_SURFACEFORMAT_R8_UNORM), // not used for plane images
0,
1,
1,
1}};
return &formatInfoRGBP;
}
return nullptr;
}

9
opencl/test/unit_test/mocks/mock_gmm_resource_info.cpp
View File

@ -101,6 +101,15 @@ void MockGmmResourceInfo::setSurfaceFormat() {
surfaceFormatInfo = &tempSurface;
}
if (mockResourceCreateParams.Format == GMM_RESOURCE_FORMAT::GMM_FORMAT_RGBP) {
tempSurface.GMMSurfaceFormat = GMM_RESOURCE_FORMAT::GMM_FORMAT_RGBP;
tempSurface.NumChannels = 1;
tempSurface.ImageElementSizeInBytes = 8;
tempSurface.PerChannelSizeInBytes = 8;
surfaceFormatInfo = &tempSurface;
}
iterate(SurfaceFormats::readOnly12());
iterate(SurfaceFormats::readOnly20());
iterate(SurfaceFormats::writeOnly());

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

@ -267,12 +267,18 @@ TEST_F(VaSharingTests, givenMockVaWhenVaSurfaceIsCreatedThenMemObjectHasVaHandle
delete vaSurface;
}
TEST_F(VaSharingTests, givenInvalidPlaneWhenVaSurfaceIsCreatedThenUnrecoverableIsCalled) {
TEST_F(VaSharingTests, givenInvalidPlaneWhenVaSurfaceIsCreatedAndNotRGBPThenUnrecoverableIsCalled) {
EXPECT_THROW(VASurface::createSharedVaSurface(&context, &vaSharing->sharingFunctions,
CL_MEM_READ_WRITE, 0, &vaSurfaceId, 2, &errCode),
std::exception);
}
TEST_F(VaSharingTests, givenInvalidPlaneWhenVaSurfaceIsCreatedThenUnrecoverableIsCalled) {
EXPECT_THROW(VASurface::createSharedVaSurface(&context, &vaSharing->sharingFunctions,
CL_MEM_READ_WRITE, 0, &vaSurfaceId, 3, &errCode),
std::exception);
}
TEST_F(VaSharingTests, givenInvalidPlaneInputWhenVaSurfaceIsCreatedThenInvalidValueErrorIsReturned) {
sharedClMem = clCreateFromVA_APIMediaSurfaceINTEL(&context, CL_MEM_READ_WRITE, &vaSurfaceId, 2, &errCode);
EXPECT_EQ(nullptr, sharedClMem);
@ -579,6 +585,127 @@ TEST_F(VaSharingTests, givenEnabledExtendedVaFormatsAndP010FormatWhenCreatingSha
EXPECT_EQ(CL_SUCCESS, errCode);
}
TEST_F(VaSharingTests, givenEnabledExtendedVaFormatsAndRGBPFormatWhenCreatingSharedVaSurfaceForPlane0ThenCorrectFormatIsUsedByImageAndGMM) {
DebugManagerStateRestore restore;
DebugManager.flags.EnableExtendedVaFormats.set(true);
vaSharing->sharingFunctions.mockVaSurfaceDesc.fourcc = VA_FOURCC_RGBP;
vaSharing->sharingFunctions.mockVaSurfaceDesc.objects[1] = {8, 98304, I915_FORMAT_MOD_Y_TILED};
vaSharing->sharingFunctions.mockVaSurfaceDesc.objects[2] = {8, 98304, I915_FORMAT_MOD_Y_TILED};
vaSharing->sharingFunctions.mockVaSurfaceDesc.num_layers = 3;
vaSharing->sharingFunctions.mockVaSurfaceDesc.layers[1] = {DRM_FORMAT_R8, 1, {}, {0, 0, 0, 0}, {256, 0, 0, 0}};
vaSharing->sharingFunctions.mockVaSurfaceDesc.layers[2] = {DRM_FORMAT_R8, 1, {}, {0, 0, 0, 0}, {256, 0, 0, 0}};
vaSharing->sharingFunctions.derivedImageFormatBpp = 8;
vaSharing->sharingFunctions.derivedImageFormatFourCC = VA_FOURCC_RGBP;
auto vaSurface = std::unique_ptr<Image>(VASurface::createSharedVaSurface(&context, &vaSharing->sharingFunctions,
CL_MEM_READ_WRITE, 0, &vaSurfaceId, 0, &errCode));
EXPECT_EQ(static_cast<cl_channel_type>(CL_UNORM_INT8), vaSurface->getImageFormat().image_channel_data_type);
EXPECT_EQ(static_cast<cl_channel_order>(CL_R), vaSurface->getImageFormat().image_channel_order);
EXPECT_EQ(GMM_RESOURCE_FORMAT::GMM_FORMAT_R8_UNORM, vaSurface->getSurfaceFormatInfo().surfaceFormat.GMMSurfaceFormat);
EXPECT_EQ(GMM_RESOURCE_FORMAT::GMM_FORMAT_RGBP, vaSurface->getGraphicsAllocation()->getDefaultGmm()->resourceParams.Format);
EXPECT_EQ(CL_SUCCESS, errCode);
}
TEST_F(VaSharingTests, givenEnabledExtendedVaFormatsAndRGBPFormatWhenCreatingSharedVaSurfaceForPlane1ThenCorrectFormatIsUsedByImageAndGMM) {
DebugManagerStateRestore restore;
DebugManager.flags.EnableExtendedVaFormats.set(true);
vaSharing->sharingFunctions.mockVaSurfaceDesc.fourcc = VA_FOURCC_RGBP;
vaSharing->sharingFunctions.mockVaSurfaceDesc.objects[1] = {8, 98304, I915_FORMAT_MOD_Y_TILED};
vaSharing->sharingFunctions.mockVaSurfaceDesc.objects[2] = {8, 98304, I915_FORMAT_MOD_Y_TILED};
vaSharing->sharingFunctions.mockVaSurfaceDesc.num_layers = 3;
vaSharing->sharingFunctions.mockVaSurfaceDesc.layers[1] = {DRM_FORMAT_R8, 1, {}, {0, 0, 0, 0}, {256, 0, 0, 0}};
vaSharing->sharingFunctions.mockVaSurfaceDesc.layers[2] = {DRM_FORMAT_R8, 1, {}, {0, 0, 0, 0}, {256, 0, 0, 0}};
vaSharing->sharingFunctions.derivedImageFormatBpp = 8;
vaSharing->sharingFunctions.derivedImageFormatFourCC = VA_FOURCC_RGBP;
auto vaSurface = std::unique_ptr<Image>(VASurface::createSharedVaSurface(&context, &vaSharing->sharingFunctions,
CL_MEM_READ_WRITE, 0, &vaSurfaceId, 1, &errCode));
EXPECT_EQ(static_cast<cl_channel_type>(CL_UNORM_INT8), vaSurface->getImageFormat().image_channel_data_type);
EXPECT_EQ(static_cast<cl_channel_order>(CL_R), vaSurface->getImageFormat().image_channel_order);
EXPECT_EQ(GMM_RESOURCE_FORMAT::GMM_FORMAT_R8_UNORM, vaSurface->getSurfaceFormatInfo().surfaceFormat.GMMSurfaceFormat);
EXPECT_EQ(GMM_RESOURCE_FORMAT::GMM_FORMAT_RGBP, vaSurface->getGraphicsAllocation()->getDefaultGmm()->resourceParams.Format);
EXPECT_EQ(CL_SUCCESS, errCode);
}
TEST_F(VaSharingTests, givenEnabledExtendedVaFormatsAndRGBPFormatWhenCreatingSharedVaSurfaceForPlane2ThenCorrectFormatIsUsedByImageAndGMM) {
DebugManagerStateRestore restore;
DebugManager.flags.EnableExtendedVaFormats.set(true);
vaSharing->sharingFunctions.mockVaSurfaceDesc.fourcc = VA_FOURCC_RGBP;
vaSharing->sharingFunctions.mockVaSurfaceDesc.objects[1] = {8, 98304, I915_FORMAT_MOD_Y_TILED};
vaSharing->sharingFunctions.mockVaSurfaceDesc.objects[2] = {8, 98304, I915_FORMAT_MOD_Y_TILED};
vaSharing->sharingFunctions.mockVaSurfaceDesc.num_layers = 3;
vaSharing->sharingFunctions.mockVaSurfaceDesc.layers[1] = {DRM_FORMAT_R8, 1, {}, {0, 0, 0, 0}, {256, 0, 0, 0}};
vaSharing->sharingFunctions.mockVaSurfaceDesc.layers[2] = {DRM_FORMAT_R8, 1, {}, {0, 0, 0, 0}, {256, 0, 0, 0}};
vaSharing->sharingFunctions.derivedImageFormatBpp = 8;
vaSharing->sharingFunctions.derivedImageFormatFourCC = VA_FOURCC_RGBP;
auto vaSurface = std::unique_ptr<Image>(VASurface::createSharedVaSurface(&context, &vaSharing->sharingFunctions,
CL_MEM_READ_WRITE, 0, &vaSurfaceId, 2, &errCode));
EXPECT_EQ(static_cast<cl_channel_type>(CL_UNORM_INT8), vaSurface->getImageFormat().image_channel_data_type);
EXPECT_EQ(static_cast<cl_channel_order>(CL_R), vaSurface->getImageFormat().image_channel_order);
EXPECT_EQ(GMM_RESOURCE_FORMAT::GMM_FORMAT_R8_UNORM, vaSurface->getSurfaceFormatInfo().surfaceFormat.GMMSurfaceFormat);
EXPECT_EQ(GMM_RESOURCE_FORMAT::GMM_FORMAT_RGBP, vaSurface->getGraphicsAllocation()->getDefaultGmm()->resourceParams.Format);
EXPECT_EQ(CL_SUCCESS, errCode);
}
TEST_F(VaSharingTests, givenMockVaWithExportSurfaceHandlerAndRGBPWhenVaSurfaceIsCreatedThenCallHandlerWithDrmPrime2ToGetSurfaceFormatsInDescriptor) {
DebugManagerStateRestore restore;
DebugManager.flags.EnableExtendedVaFormats.set(true);
vaSharing->sharingFunctions.haveExportSurfaceHandle = true;
vaSharing->sharingFunctions.mockVaSurfaceDesc.fourcc = VA_FOURCC_RGBP;
vaSharing->sharingFunctions.mockVaSurfaceDesc.objects[1] = {8, 98304, I915_FORMAT_MOD_Y_TILED};
vaSharing->sharingFunctions.mockVaSurfaceDesc.objects[2] = {8, 98304, I915_FORMAT_MOD_Y_TILED};
vaSharing->sharingFunctions.mockVaSurfaceDesc.num_layers = 3;
vaSharing->sharingFunctions.mockVaSurfaceDesc.layers[1] = {DRM_FORMAT_R8, 1, {}, {0, 0, 0, 0}, {256, 0, 0, 0}};
vaSharing->sharingFunctions.mockVaSurfaceDesc.layers[2] = {DRM_FORMAT_R8, 1, {}, {0, 0, 0, 0}, {256, 0, 0, 0}};
vaSharing->sharingFunctions.derivedImageFormatBpp = 8;
vaSharing->sharingFunctions.derivedImageFormatFourCC = VA_FOURCC_RGBP;
for (int plane = 0; plane < 3; plane++) {
auto vaSurface = std::unique_ptr<Image>(VASurface::createSharedVaSurface(
&context, &vaSharing->sharingFunctions, CL_MEM_READ_WRITE, 0, &vaSurfaceId, plane, &errCode));
ASSERT_NE(nullptr, vaSurface);
auto handler = vaSurface->peekSharingHandler();
ASSERT_NE(nullptr, handler);
auto vaHandler = static_cast<VASharing *>(handler);
EXPECT_EQ(vaHandler->peekFunctionsHandler(), &vaSharing->sharingFunctions);
auto sharingFunctions = vaSharing->sharingFunctions;
EXPECT_FALSE(sharingFunctions.deriveImageCalled);
EXPECT_FALSE(sharingFunctions.destroyImageCalled);
EXPECT_TRUE(sharingFunctions.exportSurfaceHandleCalled);
EXPECT_EQ(static_cast<uint32_t>(VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2), sharingFunctions.receivedSurfaceMemType);
EXPECT_EQ(static_cast<uint32_t>(VA_EXPORT_SURFACE_READ_WRITE | VA_EXPORT_SURFACE_SEPARATE_LAYERS), sharingFunctions.receivedSurfaceFlags);
EXPECT_EQ(256u, vaSurface->getImageDesc().image_width);
EXPECT_EQ(256u, vaSurface->getImageDesc().image_height);
if (plane != 0) {
SurfaceOffsets surfaceOffsets;
vaSurface->getSurfaceOffsets(surfaceOffsets);
auto vaSurfaceDesc = sharingFunctions.mockVaSurfaceDesc;
EXPECT_EQ(vaSurfaceDesc.layers[plane].offset[0], surfaceOffsets.offset);
EXPECT_EQ(0u, surfaceOffsets.xOffset);
EXPECT_EQ(0u, surfaceOffsets.yOffset);
EXPECT_EQ(vaSurfaceDesc.layers[plane].offset[0] / vaSurfaceDesc.layers[plane].pitch[0], surfaceOffsets.yOffsetForUVplane);
}
EXPECT_TRUE(vaSurface->isTiledAllocation());
EXPECT_EQ(8u, vaSurface->getGraphicsAllocation()->peekSharedHandle());
}
}
TEST_F(VaSharingTests, givenEnabledExtendedVaFormatsAndNV12FormatWhenCreatingSharedVaSurfaceForPlane0ThenCorrectFormatIsUsedByImageAndGMM) {
DebugManagerStateRestore restore;
DebugManager.flags.EnableExtendedVaFormats.set(true);