intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-11 08:07:19 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add RGBP planar formats

Browse Source 
Signed-off-by: Kamil Diedrich <kamil.diedrich@intel.com>
This commit is contained in:
Kamil Diedrich
2021-11-10 00:49:20 +00:00
committed by Compute-Runtime-Automation
parent bc11f7b4f7
commit 35f709b221
4 changed files with 250 additions and 7 deletions
Download Patch File Download Diff File Expand all files Collapse all files

233
level_zero/core/test/black_box_tests/zello_image_view.cpp
View File

@@ -39,7 +39,7 @@ const char *readNV12Module = R"===(
}
)===";
void testAppendImageViewCopy(ze_context_handle_t &context, ze_device_handle_t &device, bool &validRet) {
void testAppendImageViewNV12Copy(ze_context_handle_t &context, ze_device_handle_t &device, bool &validRet) {
std::string buildLog;
auto spirV = compileToSpirV(readNV12Module, "", buildLog);
if (buildLog.size() > 0) {
@@ -286,6 +286,234 @@ void testAppendImageViewCopy(ze_context_handle_t &context, ze_device_handle_t &d
SUCCESS_OR_TERMINATE(zeCommandQueueDestroy(cmdQueue));
}
void testAppendImageViewRGBPCopy(ze_context_handle_t &context, ze_device_handle_t &device, bool &validRet) {
const size_t width = 32;
const size_t height = 32;
const size_t depth = 1;
const size_t size = 3 * width * height * depth; /* 3 channels per pixel */
ze_command_queue_handle_t cmdQueue = nullptr;
ze_command_list_handle_t cmdList = nullptr;
ze_command_queue_desc_t cmdQueueDesc = {};
cmdQueueDesc.pNext = nullptr;
cmdQueueDesc.flags = 0;
cmdQueueDesc.mode = ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS;
cmdQueueDesc.priority = ZE_COMMAND_QUEUE_PRIORITY_NORMAL;
cmdQueueDesc.ordinal = 0;
cmdQueueDesc.index = 0;
SUCCESS_OR_TERMINATE(zeCommandQueueCreate(context, device, &cmdQueueDesc, &cmdQueue));
ze_command_list_desc_t cmdListDesc = {};
cmdListDesc.stype = ZE_STRUCTURE_TYPE_COMMAND_LIST_DESC;
cmdListDesc.pNext = nullptr;
cmdListDesc.flags = 0;
SUCCESS_OR_TERMINATE(zeCommandListCreate(context, device, &cmdListDesc, &cmdList));
// create RGBP image
ze_image_desc_t srcImgDesc = {ZE_STRUCTURE_TYPE_IMAGE_DESC,
nullptr,
(ZE_IMAGE_FLAG_BIAS_UNCACHED),
ZE_IMAGE_TYPE_2D,
{ZE_IMAGE_FORMAT_LAYOUT_RGBP, ZE_IMAGE_FORMAT_TYPE_UINT,
ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_G,
ZE_IMAGE_FORMAT_SWIZZLE_B, ZE_IMAGE_FORMAT_SWIZZLE_A},
width,
height,
depth,
0,
0};
ze_image_handle_t srcImg;
SUCCESS_OR_TERMINATE(
zeImageCreate(context, device, const_cast<const ze_image_desc_t *>(&srcImgDesc), &srcImg));
// create image_veiw for Y plane
ze_image_view_planar_exp_desc_t planeYdesc = {};
planeYdesc.stype = ZE_STRUCTURE_TYPE_IMAGE_VIEW_PLANAR_EXP_DESC;
planeYdesc.planeIndex = 0u; // Y plane
ze_image_desc_t imageViewDescPlaneY = {ZE_STRUCTURE_TYPE_IMAGE_DESC,
&planeYdesc,
(ZE_IMAGE_FLAG_KERNEL_WRITE | ZE_IMAGE_FLAG_BIAS_UNCACHED),
ZE_IMAGE_TYPE_2D,
{ZE_IMAGE_FORMAT_LAYOUT_8, ZE_IMAGE_FORMAT_TYPE_UINT,
ZE_IMAGE_FORMAT_SWIZZLE_A, ZE_IMAGE_FORMAT_SWIZZLE_B,
ZE_IMAGE_FORMAT_SWIZZLE_G, ZE_IMAGE_FORMAT_SWIZZLE_R},
width,
height,
depth,
0,
0};
ze_image_handle_t planeYImageView;
SUCCESS_OR_TERMINATE(
zeImageViewCreateExp(context, device, &imageViewDescPlaneY, srcImg, &planeYImageView));
// create image_view for U plane
ze_image_view_planar_exp_desc_t planeUdesc = {};
planeUdesc.stype = ZE_STRUCTURE_TYPE_IMAGE_VIEW_PLANAR_EXP_DESC;
planeUdesc.planeIndex = 1u; // U plane
ze_image_desc_t imageViewDescPlaneU = {ZE_STRUCTURE_TYPE_IMAGE_DESC,
&planeUdesc,
(ZE_IMAGE_FLAG_KERNEL_WRITE | ZE_IMAGE_FLAG_BIAS_UNCACHED),
ZE_IMAGE_TYPE_2D,
{ZE_IMAGE_FORMAT_LAYOUT_8, ZE_IMAGE_FORMAT_TYPE_UINT,
ZE_IMAGE_FORMAT_SWIZZLE_A, ZE_IMAGE_FORMAT_SWIZZLE_B,
ZE_IMAGE_FORMAT_SWIZZLE_G, ZE_IMAGE_FORMAT_SWIZZLE_R},
width,
height,
depth,
0,
0};
ze_image_handle_t planeUImageView;
SUCCESS_OR_TERMINATE(
zeImageViewCreateExp(context, device, &imageViewDescPlaneU, srcImg, &planeUImageView));
// create image_view for V plane
ze_image_view_planar_exp_desc_t planeVdesc = {};
planeVdesc.stype = ZE_STRUCTURE_TYPE_IMAGE_VIEW_PLANAR_EXP_DESC;
planeVdesc.planeIndex = 2u; // V plane
ze_image_desc_t imageViewDescPlaneV = {ZE_STRUCTURE_TYPE_IMAGE_DESC,
&planeVdesc,
(ZE_IMAGE_FLAG_KERNEL_WRITE | ZE_IMAGE_FLAG_BIAS_UNCACHED),
ZE_IMAGE_TYPE_2D,
{ZE_IMAGE_FORMAT_LAYOUT_8, ZE_IMAGE_FORMAT_TYPE_UINT,
ZE_IMAGE_FORMAT_SWIZZLE_A, ZE_IMAGE_FORMAT_SWIZZLE_B,
ZE_IMAGE_FORMAT_SWIZZLE_G, ZE_IMAGE_FORMAT_SWIZZLE_R},
width,
height,
depth,
0,
0};
ze_image_handle_t planeVImageView;
SUCCESS_OR_TERMINATE(
zeImageViewCreateExp(context, device, &imageViewDescPlaneV, srcImg, &planeVImageView));
// prepare input data
std::vector<uint8_t> srcVecY;
srcVecY.resize(width * height);
for (size_t i = 0; i < width * height; ++i) {
srcVecY[i] = static_cast<uint8_t>(i);
}
std::vector<uint8_t> srcVecU;
srcVecU.resize(width * height);
for (size_t i = 0; i < width * height; ++i) {
if (i % 2 == 0) {
srcVecU[i] = static_cast<uint8_t>(0x33);
} else {
srcVecU[i] = static_cast<uint8_t>(0x55);
}
}
std::vector<uint8_t> srcVecV;
srcVecV.resize(width * height);
for (size_t i = 0; i < width * height; ++i) {
if (i % 2 == 0) {
srcVecV[i] = static_cast<uint8_t>(0x44);
} else {
srcVecV[i] = static_cast<uint8_t>(0x66);
}
}
// prepare destination buffer
uint8_t *dstMem;
ze_host_mem_alloc_desc_t hostDesc = {};
hostDesc.stype = ZE_STRUCTURE_TYPE_HOST_MEM_ALLOC_DESC;
hostDesc.pNext = nullptr;
hostDesc.flags = 0;
SUCCESS_OR_TERMINATE(zeMemAllocHost(context, &hostDesc, size, 1, (void **)(&dstMem)));
for (size_t i = 0; i < size; ++i) {
dstMem[i] = 0xff;
}
ze_image_region_t srcYRegion = {0, 0, 0, width, height, depth};
ze_image_region_t srcURegion = {0, 0, 0, width, height, depth};
ze_image_region_t srcVRegion = {0, 0, 0, width, height, depth};
SUCCESS_OR_TERMINATE(zeCommandListAppendImageCopyFromMemory(cmdList, planeYImageView, srcVecY.data(),
&srcYRegion, nullptr, 0, nullptr));
SUCCESS_OR_TERMINATE(zeCommandListAppendImageCopyFromMemory(cmdList, planeUImageView, srcVecU.data(),
&srcURegion, nullptr, 0, nullptr));
SUCCESS_OR_TERMINATE(zeCommandListAppendImageCopyFromMemory(cmdList, planeVImageView, srcVecV.data(),
&srcVRegion, nullptr, 0, nullptr));
SUCCESS_OR_TERMINATE(zeCommandListAppendBarrier(cmdList, nullptr, 0, nullptr));
// destination buffer for Y plane
std::vector<uint8_t> dstVecY;
dstVecY.resize(width * height);
// destination buffer for U plane
std::vector<uint8_t> dstVecU;
dstVecU.resize(width * height);
// destination buffer for V plane
std::vector<uint8_t> dstVecV;
dstVecV.resize(width * height);
// read Y plane data
SUCCESS_OR_TERMINATE(zeCommandListAppendImageCopyToMemory(cmdList, dstVecY.data(), planeYImageView,
&srcYRegion, nullptr, 0, nullptr));
// read U plane data
SUCCESS_OR_TERMINATE(zeCommandListAppendImageCopyToMemory(cmdList, dstVecU.data(), planeUImageView,
&srcURegion, nullptr, 0, nullptr));
// read V plane data
SUCCESS_OR_TERMINATE(zeCommandListAppendImageCopyToMemory(cmdList, dstVecV.data(), planeVImageView,
&srcVRegion, nullptr, 0, nullptr));
SUCCESS_OR_TERMINATE(zeCommandListAppendBarrier(cmdList, nullptr, 0, nullptr));
SUCCESS_OR_TERMINATE(zeCommandListClose(cmdList));
SUCCESS_OR_TERMINATE(zeCommandQueueExecuteCommandLists(cmdQueue, 1, &cmdList, nullptr));
SUCCESS_OR_TERMINATE(zeCommandQueueSynchronize(cmdQueue, std::numeric_limits<uint32_t>::max()));
// validate Y plane data
auto result = memcmp(srcVecY.data(), dstVecY.data(), width * height);
if (result != 0) {
std::cout << "Failed to validate data read for plane Y from Y-plane view" << std::endl;
validRet = false;
}
// validate U plane data
result = memcmp(srcVecU.data(), dstVecU.data(), width * height);
if (result != 0 && validRet) {
std::cout << "Failed to validate data read for plane U from U-plane view" << std::endl;
validRet = false;
}
// validate V plane data
result = memcmp(srcVecV.data(), dstVecV.data(), width * height);
if (result != 0 && validRet) {
std::cout << "Failed to validate data read for plane V from V-plane view" << std::endl;
validRet = false;
}
// cleanup
SUCCESS_OR_TERMINATE(zeImageDestroy(srcImg));
SUCCESS_OR_TERMINATE(zeImageDestroy(planeYImageView));
SUCCESS_OR_TERMINATE(zeImageDestroy(planeUImageView));
SUCCESS_OR_TERMINATE(zeImageDestroy(planeVImageView));
SUCCESS_OR_TERMINATE(zeCommandListDestroy(cmdList));
SUCCESS_OR_TERMINATE(zeCommandQueueDestroy(cmdQueue));
}
int main(int argc, char *argv[]) {
ze_context_handle_t context = nullptr;
auto devices = zelloInitContextAndGetDevices(context);
@@ -298,7 +526,8 @@ int main(int argc, char *argv[]) {
<< " * name : " << deviceProperties.name << "\n"
<< " * vendorId : " << std::hex << deviceProperties.vendorId << "\n";
testAppendImageViewCopy(context, device, outputValidationSuccessful);
testAppendImageViewNV12Copy(context, device, outputValidationSuccessful);
testAppendImageViewRGBPCopy(context, device, outputValidationSuccessful);
SUCCESS_OR_TERMINATE(zeContextDestroy(context));
std::cout << "\nZello Image View Results validation " << (outputValidationSuccessful ? "PASSED" : "FAILED") << "\n";

4
level_zero/core/test/unit_tests/sources/image/test_image.cpp
View File

@@ -623,7 +623,9 @@ std::pair<ze_image_format_layout_t, ze_image_format_type_t> validFormats[] = {
{ZE_IMAGE_FORMAT_LAYOUT_Y410, ZE_IMAGE_FORMAT_TYPE_UNORM},
{ZE_IMAGE_FORMAT_LAYOUT_P012, ZE_IMAGE_FORMAT_TYPE_UNORM},
{ZE_IMAGE_FORMAT_LAYOUT_Y216, ZE_IMAGE_FORMAT_TYPE_UNORM},
{ZE_IMAGE_FORMAT_LAYOUT_P016, ZE_IMAGE_FORMAT_TYPE_UNORM}};
{ZE_IMAGE_FORMAT_LAYOUT_P016, ZE_IMAGE_FORMAT_TYPE_UNORM},
{ZE_IMAGE_FORMAT_LAYOUT_RGBP, ZE_IMAGE_FORMAT_TYPE_UNORM},
{ZE_IMAGE_FORMAT_LAYOUT_BRGP, ZE_IMAGE_FORMAT_TYPE_UNORM}};
INSTANTIATE_TEST_CASE_P(
validImageFormats,