1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
5 * Copyright (c) 2017 The Khronos Group Inc.
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
20 * \file vktImageCompressionTranscodingSupport.cpp
21 * \brief Compression transcoding support
22 *//*--------------------------------------------------------------------*/
24 #include "vktImageCompressionTranscodingSupport.hpp"
26 #include "deUniquePtr.hpp"
27 #include "deStringUtil.hpp"
28 #include "deSharedPtr.hpp"
29 #include "deRandom.hpp"
31 #include "vktTestCaseUtil.hpp"
32 #include "vkPrograms.hpp"
33 #include "vkImageUtil.hpp"
34 #include "vktImageTestsUtil.hpp"
35 #include "vkBuilderUtil.hpp"
37 #include "vkRefUtil.hpp"
38 #include "vkTypeUtil.hpp"
39 #include "vkQueryUtil.hpp"
41 #include "tcuTextureUtil.hpp"
42 #include "tcuTexture.hpp"
43 #include "tcuCompressedTexture.hpp"
44 #include "tcuVectorType.hpp"
45 #include "tcuResource.hpp"
46 #include "tcuImageIO.hpp"
47 #include "tcuImageCompare.hpp"
48 #include "tcuTestLog.hpp"
49 #include "tcuRGBA.hpp"
50 #include "tcuSurface.hpp"
64 using tcu::TestContext;
65 using tcu::TestStatus;
67 using tcu::CompressedTexFormat;
68 using tcu::CompressedTexture;
75 typedef SharedPtr<MovePtr<Image> > ImageSp;
76 typedef SharedPtr<Move<VkImageView> > ImageViewSp;
88 OPERATION_TEXEL_FETCH,
90 OPERATION_IMAGE_STORE,
91 OPERATION_ATTACHMENT_READ,
92 OPERATION_ATTACHMENT_WRITE,
93 OPERATION_TEXTURE_READ,
94 OPERATION_TEXTURE_WRITE,
104 VkFormat formatCompressed;
105 VkFormat formatUncompressed;
106 deUint32 imagesCount;
107 VkImageUsageFlags compressedImageUsage;
108 VkImageUsageFlags uncompressedImageUsage;
110 VkFormat formatForVerify;
114 inline SharedPtr<Move<T> > makeVkSharedPtr (Move<T> move)
116 return SharedPtr<Move<T> >(new vk::Move<T>(move));
120 inline SharedPtr<MovePtr<T> > makeVkSharedPtr (MovePtr<T> movePtr)
122 return SharedPtr<MovePtr<T> >(new MovePtr<T>(movePtr));
125 class BasicTranscodingTestInstance : public TestInstance
128 BasicTranscodingTestInstance (Context& contex,
129 const TestParameters& parameters);
130 virtual TestStatus iterate (void) = 0;
132 void generateData (deUint8* toFill,
134 const VkFormat format = VK_FORMAT_UNDEFINED);
135 const TestParameters m_parameters;
138 BasicTranscodingTestInstance::BasicTranscodingTestInstance (Context& context, const TestParameters& parameters)
139 : TestInstance (context)
140 , m_parameters (parameters)
144 void BasicTranscodingTestInstance::generateData (deUint8* toFill, size_t size, const VkFormat format)
146 const deUint8 pattern[] =
149 0x11, 0x11, 0x11, 0x11, 0x22, 0x22, 0x22, 0x22,
150 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
151 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
152 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
153 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
154 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
155 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
156 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00,
157 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00,
158 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00,
159 0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Positive infinity
160 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Negative infinity
161 0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, // Start of a signalling NaN (NANS)
162 0x7F, 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // End of a signalling NaN (NANS)
163 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, // Start of a signalling NaN (NANS)
164 0xFF, 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // End of a signalling NaN (NANS)
165 0x7F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Start of a quiet NaN (NANQ)
166 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // End of of a quiet NaN (NANQ)
167 0xFF, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Start of a quiet NaN (NANQ)
168 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // End of a quiet NaN (NANQ)
170 0x7F, 0x80, 0x00, 0x00, // Positive infinity
171 0xFF, 0x80, 0x00, 0x00, // Negative infinity
172 0x7F, 0x80, 0x00, 0x01, // Start of a signalling NaN (NANS)
173 0x7F, 0xBF, 0xFF, 0xFF, // End of a signalling NaN (NANS)
174 0xFF, 0x80, 0x00, 0x01, // Start of a signalling NaN (NANS)
175 0xFF, 0xBF, 0xFF, 0xFF, // End of a signalling NaN (NANS)
176 0x7F, 0xC0, 0x00, 0x00, // Start of a quiet NaN (NANQ)
177 0x7F, 0xFF, 0xFF, 0xFF, // End of of a quiet NaN (NANQ)
178 0xFF, 0xC0, 0x00, 0x00, // Start of a quiet NaN (NANQ)
179 0xFF, 0xFF, 0xFF, 0xFF, // End of a quiet NaN (NANQ)
180 0xAA, 0xAA, 0xAA, 0xAA,
181 0x55, 0x55, 0x55, 0x55,
184 deUint8* start = toFill;
185 size_t sizeToRnd = size;
188 if (size >= 2 * sizeof(pattern))
191 for (size_t i = 0; i < sizeof(pattern); i++)
192 start[sizeof(pattern) - i - 1] = pattern[i];
194 start += sizeof(pattern);
195 sizeToRnd -= sizeof(pattern);
198 deMemcpy(start, pattern, sizeof(pattern));
200 start += sizeof(pattern);
201 sizeToRnd -= sizeof(pattern);
206 DE_ASSERT(sizeToRnd % sizeof(deUint32) == 0);
208 deUint32* start32 = reinterpret_cast<deUint32*>(start);
209 size_t sizeToRnd32 = sizeToRnd / sizeof(deUint32);
210 Random rnd (static_cast<deUint32>(format));
212 for (size_t i = 0; i < sizeToRnd32; i++)
213 start32[i] = rnd.getUint32();
217 // Remove certain values that may not be preserved based on the uncompressed view format
218 if (isSnormFormat(m_parameters.formatUncompressed))
220 for (size_t i = 0; i < size; i += 2)
222 // SNORM fix: due to write operation in SNORM format
223 // replaces 0x00 0x80 to 0x01 0x80
224 if (toFill[i] == 0x00 && toFill[i+1] == 0x80)
228 else if (isFloatFormat(m_parameters.formatUncompressed))
230 tcu::TextureFormat textureFormat = mapVkFormat(m_parameters.formatUncompressed);
232 if (textureFormat.type == tcu::TextureFormat::HALF_FLOAT)
234 for (size_t i = 0; i < size; i += 2)
236 // HALF_FLOAT fix: remove INF and NaN
237 if ((toFill[i+1] & 0x7C) == 0x7C)
241 else if (textureFormat.type == tcu::TextureFormat::FLOAT)
243 for (size_t i = 0; i < size; i += 4)
245 // HALF_FLOAT fix: remove INF and NaN
246 if ((toFill[i+1] & 0x7C) == 0x7C)
250 for (size_t i = 0; i < size; i += 4)
252 // FLOAT fix: remove INF, NaN, and denorm
254 if (((toFill[i+3] & 0x7F) == 0x7F && (toFill[i+2] & 0x80) == 0x80) || ((toFill[i+3] & 0x7F) == 0x00 && (toFill[i+2] & 0x80) == 0x00))
257 if (((toFill[i+0] & 0x7F) == 0x7F && (toFill[i+1] & 0x80) == 0x80) || ((toFill[i+0] & 0x7F) == 0x00 && (toFill[i+1] & 0x80) == 0x00))
265 class BasicComputeTestInstance : public BasicTranscodingTestInstance
268 BasicComputeTestInstance (Context& contex,
269 const TestParameters& parameters);
270 TestStatus iterate (void);
272 void copyDataToImage (const VkCommandBuffer& cmdBuffer,
273 const VkImage& compressed,
274 const VkImageCreateInfo& imageInfo);
275 virtual void executeShader (const VkCommandBuffer& cmdBuffer,
276 const VkDescriptorSetLayout& descriptorSetLayout,
277 const VkDescriptorPool& descriptorPool,
278 const vector<ImageSp>& images,
279 const vector<ImageViewSp>& imageViews);
280 bool copyResultAndCompare (const VkCommandBuffer& cmdBuffer,
281 const VkImage& uncompressed);
282 void descriptorSetUpdate (VkDescriptorSet descriptorSet,
283 const VkDescriptorImageInfo* descriptorImageInfos);
284 void createImageInfos (VkImageCreateInfo* imageInfos);
285 bool decompressImage (const VkCommandBuffer& cmdBuffer,
286 const VkImage& uncompressed,
287 const VkImage& compressed,
288 const VkExtent3D& extentunCompressed);
289 vector<deUint8> m_data;
292 BasicComputeTestInstance::BasicComputeTestInstance (Context& context, const TestParameters& parameters)
293 :BasicTranscodingTestInstance (context, parameters)
294 ,m_data (static_cast<size_t>(getCompressedImageSizeInBytes(parameters.formatCompressed, parameters.size)))
296 generateData (&m_data[0], m_data.size(), m_parameters.formatCompressed);
299 TestStatus BasicComputeTestInstance::iterate (void)
301 const DeviceInterface& vk = m_context.getDeviceInterface();
302 const VkDevice device = m_context.getDevice();
303 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
304 Allocator& allocator = m_context.getDefaultAllocator();
306 Move<VkDescriptorSetLayout> descriptorSetLayout;
307 Move<VkDescriptorPool> descriptorPool;
309 vector<ImageSp> images;
310 vector<VkImageCreateInfo> imagesInfo (m_parameters.imagesCount);
311 createImageInfos(&imagesInfo[0]);
312 vector<ImageViewSp> imageViews (m_parameters.imagesCount);
313 images.resize(m_parameters.imagesCount);
314 const deUint32 compressedNdx = 0u;
315 const deUint32 uncompressedNdx = m_parameters.imagesCount - 1u;
318 DescriptorSetLayoutBuilder descriptorSetLayoutBuilder;
319 DescriptorPoolBuilder descriptorPoolBuilder;
321 for (deUint32 imageNdx = 0; imageNdx < m_parameters.imagesCount; ++imageNdx)
323 images[imageNdx] = makeVkSharedPtr(MovePtr<Image>(new Image(vk, device, allocator, imagesInfo[imageNdx], MemoryRequirement::Any)));
324 if (compressedNdx == imageNdx)
326 const VkImageViewUsageCreateInfoKHR imageViewUsageCreateInfoKHR =
328 VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR, //VkStructureType sType;
329 DE_NULL, //const void* pNext;
330 m_parameters.compressedImageUsage, //VkImageUsageFlags usage;
332 imageViews[imageNdx] = makeVkSharedPtr(makeImageView(vk, device, **images[imageNdx]->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatUncompressed,
333 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, imagesInfo[imageNdx].extent.depth, 0u, imagesInfo[imageNdx].arrayLayers), &imageViewUsageCreateInfoKHR));
337 imageViews[imageNdx] = makeVkSharedPtr(makeImageView(vk, device, **images[imageNdx]->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatUncompressed,
338 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, imagesInfo[imageNdx].extent.depth, 0u, imagesInfo[imageNdx].arrayLayers)));
340 switch(m_parameters.operation)
342 case OPERATION_IMAGE_LOAD:
343 case OPERATION_IMAGE_STORE:
344 descriptorSetLayoutBuilder.addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT);
345 descriptorPoolBuilder.addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, imagesInfo[imageNdx].arrayLayers);
347 case OPERATION_TEXEL_FETCH:
348 case OPERATION_TEXTURE:
349 descriptorSetLayoutBuilder.addSingleBinding((compressedNdx == imageNdx) ? VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER : VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT);
350 descriptorPoolBuilder.addType((compressedNdx == imageNdx) ? VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER : VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, imagesInfo[imageNdx].arrayLayers);
357 descriptorSetLayout = descriptorSetLayoutBuilder.build(vk, device);
358 descriptorPool = descriptorPoolBuilder.build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, imagesInfo[0].arrayLayers);
361 const Unique<VkCommandPool> cmdPool (createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex));
362 const Unique<VkCommandBuffer> cmdBuffer (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
364 switch(m_parameters.operation)
366 case OPERATION_IMAGE_LOAD:
367 case OPERATION_TEXEL_FETCH:
368 case OPERATION_TEXTURE:
369 copyDataToImage(*cmdBuffer, **images[compressedNdx]->get(), imagesInfo[compressedNdx]);
371 case OPERATION_IMAGE_STORE:
372 copyDataToImage(*cmdBuffer, **images[1]->get(), imagesInfo[1]);
378 executeShader(*cmdBuffer, *descriptorSetLayout, *descriptorPool, images, imageViews);
380 if (copyResultAndCompare(*cmdBuffer, **images[uncompressedNdx]->get()) &&
381 decompressImage(*cmdBuffer, **images[uncompressedNdx]->get(), **images[compressedNdx]->get(), imagesInfo[uncompressedNdx].extent))
383 return TestStatus::pass("Pass");
385 return TestStatus::fail("Fail");
388 void BasicComputeTestInstance::copyDataToImage (const VkCommandBuffer& cmdBuffer, const VkImage& compressed, const VkImageCreateInfo& imageInfo)
390 const DeviceInterface& vk = m_context.getDeviceInterface();
391 const VkDevice device = m_context.getDevice();
392 const VkQueue queue = m_context.getUniversalQueue();
393 Allocator& allocator = m_context.getDefaultAllocator();
395 Buffer imageBuffer (vk, device, allocator,
396 makeBufferCreateInfo(m_data.size(), VK_BUFFER_USAGE_TRANSFER_SRC_BIT),
397 MemoryRequirement::HostVisible);
399 const Allocation& alloc = imageBuffer.getAllocation();
400 deMemcpy(alloc.getHostPtr(), &m_data[0], m_data.size());
401 flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), m_data.size());
404 beginCommandBuffer(vk, cmdBuffer);
406 const VkImageSubresourceRange subresourceRange =
408 VK_IMAGE_ASPECT_COLOR_BIT, //VkImageAspectFlags aspectMask
409 0u, //deUint32 baseMipLevel
410 1u, //deUint32 levelCount
411 0u, //deUint32 baseArrayLayer
412 1 //deUint32 layerCount
415 const VkImageMemoryBarrier preCopyImageBarrier = makeImageMemoryBarrier(
416 0u, VK_ACCESS_TRANSFER_WRITE_BIT,
417 VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
418 compressed, subresourceRange);
420 const VkBufferMemoryBarrier FlushHostCopyBarrier = makeBufferMemoryBarrier(
421 VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
422 imageBuffer.get(), 0ull, m_data.size());
424 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
425 (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &FlushHostCopyBarrier, 1u, &preCopyImageBarrier);
427 const VkBufferImageCopy copyRegion =
429 0ull, // VkDeviceSize bufferOffset;
430 0u, // deUint32 bufferRowLength;
431 0u, // deUint32 bufferImageHeight;
432 makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u), // VkImageSubresourceLayers imageSubresource;
433 makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
434 imageInfo.extent, // VkExtent3D imageExtent;
437 vk.cmdCopyBufferToImage(cmdBuffer, imageBuffer.get(), compressed, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, ©Region);
439 endCommandBuffer(vk, cmdBuffer);
440 submitCommandsAndWait(vk, device, queue, cmdBuffer);
443 void BasicComputeTestInstance::executeShader (const VkCommandBuffer& cmdBuffer,
444 const VkDescriptorSetLayout& descriptorSetLayout,
445 const VkDescriptorPool& descriptorPool,
446 const vector<ImageSp>& images,
447 const vector<ImageViewSp>& imageViews)
449 const DeviceInterface& vk = m_context.getDeviceInterface();
450 const VkDevice device = m_context.getDevice();
451 const VkQueue queue = m_context.getUniversalQueue();
452 const Unique<VkShaderModule> shaderModule (createShaderModule(vk, device, m_context.getBinaryCollection().get("comp"), 0));
453 Move<VkDescriptorSet> descriptorSet = makeDescriptorSet(vk, device, descriptorPool, descriptorSetLayout);
454 const Unique<VkPipelineLayout> pipelineLayout (makePipelineLayout(vk, device, descriptorSetLayout));
455 const Unique<VkPipeline> pipeline (makeComputePipeline(vk, device, *pipelineLayout, *shaderModule));
456 const UVec3 extentUncompressed = getCompressedImageResolutionInBlocks(m_parameters.formatCompressed, m_parameters.size);
457 Move<VkSampler> sampler;
459 const vk::VkSamplerCreateInfo createInfo =
461 vk::VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, //VkStructureType sType;
462 DE_NULL, //const void* pNext;
463 0u, //VkSamplerCreateFlags flags;
464 VK_FILTER_NEAREST, //VkFilter magFilter;
465 VK_FILTER_NEAREST, //VkFilter minFilter;
466 VK_SAMPLER_MIPMAP_MODE_NEAREST, //VkSamplerMipmapMode mipmapMode;
467 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, //VkSamplerAddressMode addressModeU;
468 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, //VkSamplerAddressMode addressModeV;
469 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, //VkSamplerAddressMode addressModeW;
470 0.0f, //float mipLodBias;
471 VK_FALSE, //VkBool32 anisotropyEnable;
472 1.0f, //float maxAnisotropy;
473 VK_TRUE, //VkBool32 compareEnable;
474 VK_COMPARE_OP_EQUAL, //VkCompareOp compareOp;
475 0.0f, //float minLod;
476 0.0f, //float maxLod;
477 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, //VkBorderColor borderColor;
478 VK_TRUE, //VkBool32 unnormalizedCoordinates;
480 sampler = vk::createSampler(vk, device, &createInfo);
483 vector<VkDescriptorImageInfo> descriptorImageInfos (m_parameters.imagesCount);
484 for (deUint32 bindingNdx = 0; bindingNdx < m_parameters.imagesCount; ++bindingNdx)
485 descriptorImageInfos[bindingNdx] = makeDescriptorImageInfo(*sampler, **imageViews[bindingNdx], VK_IMAGE_LAYOUT_GENERAL);
487 beginCommandBuffer(vk, cmdBuffer);
489 const VkImageSubresourceRange subresourceRange =
491 VK_IMAGE_ASPECT_COLOR_BIT, //VkImageAspectFlags aspectMask
492 0u, //deUint32 baseMipLevel
493 1u, //deUint32 levelCount
494 0u, //deUint32 baseArrayLayer
495 1u //deUint32 layerCount
498 vk.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
500 const VkImageMemoryBarrier preShaderImageBarriers[] =
502 makeImageMemoryBarrier(
503 VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
504 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL,
505 **images[0]->get(), subresourceRange),
507 makeImageMemoryBarrier(
508 VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_WRITE_BIT,
509 VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL,
510 **images[1]->get(), subresourceRange)
513 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
514 (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, (const VkBufferMemoryBarrier*)DE_NULL,
515 DE_LENGTH_OF_ARRAY(preShaderImageBarriers), preShaderImageBarriers);
517 descriptorSetUpdate (*descriptorSet, &descriptorImageInfos[0]);
519 vk.cmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
520 vk.cmdDispatch(cmdBuffer, extentUncompressed.x(), extentUncompressed.y(), extentUncompressed.z());
522 endCommandBuffer(vk, cmdBuffer);
523 submitCommandsAndWait(vk, device, queue, cmdBuffer);
526 bool BasicComputeTestInstance::copyResultAndCompare (const VkCommandBuffer& cmdBuffer, const VkImage& uncompressed)
528 const DeviceInterface& vk = m_context.getDeviceInterface();
529 const VkQueue queue = m_context.getUniversalQueue();
530 const VkDevice device = m_context.getDevice();
531 Allocator& allocator = m_context.getDefaultAllocator();
532 const UVec3 extentUncompressed = getCompressedImageResolutionInBlocks(m_parameters.formatCompressed, m_parameters.size);
534 vk::VkDeviceSize imageResultSize = getImageSizeBytes (tcu::IVec3(extentUncompressed.x(), extentUncompressed.y(), extentUncompressed.z()), m_parameters.formatUncompressed);
535 Buffer imageBufferResult (vk, device, allocator,
536 makeBufferCreateInfo(imageResultSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT),
537 MemoryRequirement::HostVisible);
539 beginCommandBuffer(vk, cmdBuffer);
541 const VkImageSubresourceRange subresourceRange =
543 VK_IMAGE_ASPECT_COLOR_BIT, //VkImageAspectFlags aspectMask
544 0u, //deUint32 baseMipLevel
545 1u, //deUint32 levelCount
546 0u, //deUint32 baseArrayLayer
547 1u //deUint32 layerCount
550 const VkBufferImageCopy copyRegion =
552 0ull, // VkDeviceSize bufferOffset;
553 0u, // deUint32 bufferRowLength;
554 0u, // deUint32 bufferImageHeight;
555 makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u), // VkImageSubresourceLayers imageSubresource;
556 makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
557 makeExtent3D(extentUncompressed), // VkExtent3D imageExtent;
560 const VkImageMemoryBarrier prepareForTransferBarrier = makeImageMemoryBarrier(
561 VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
562 VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
563 uncompressed, subresourceRange);
565 const VkBufferMemoryBarrier copyBarrier = makeBufferMemoryBarrier(
566 VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT,
567 imageBufferResult.get(), 0ull, imageResultSize);
569 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &prepareForTransferBarrier);
570 vk.cmdCopyImageToBuffer(cmdBuffer, uncompressed, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, imageBufferResult.get(), 1u, ©Region);
571 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, ©Barrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
573 endCommandBuffer(vk, cmdBuffer);
574 submitCommandsAndWait(vk, device, queue, cmdBuffer);
576 const Allocation& allocResult = imageBufferResult.getAllocation();
577 invalidateMappedMemoryRange(vk, device, allocResult.getMemory(), allocResult.getOffset(), imageResultSize);
579 if (deMemCmp(allocResult.getHostPtr(), &m_data[0], (size_t)imageResultSize) == 0)
584 void BasicComputeTestInstance::descriptorSetUpdate (VkDescriptorSet descriptorSet, const VkDescriptorImageInfo* descriptorImageInfos)
586 const DeviceInterface& vk = m_context.getDeviceInterface();
587 const VkDevice device = m_context.getDevice();
588 DescriptorSetUpdateBuilder descriptorSetUpdateBuilder;
590 switch(m_parameters.operation)
592 case OPERATION_IMAGE_LOAD:
593 case OPERATION_IMAGE_STORE:
595 for (deUint32 bindingNdx = 0; bindingNdx < m_parameters.imagesCount; ++bindingNdx)
596 descriptorSetUpdateBuilder.writeSingle(descriptorSet, DescriptorSetUpdateBuilder::Location::binding(bindingNdx), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorImageInfos[bindingNdx]);
601 case OPERATION_TEXEL_FETCH:
602 case OPERATION_TEXTURE:
604 for (deUint32 bindingNdx = 0; bindingNdx < m_parameters.imagesCount; ++bindingNdx)
606 descriptorSetUpdateBuilder.writeSingle(descriptorSet, DescriptorSetUpdateBuilder::Location::binding(bindingNdx),
607 bindingNdx == 0 ? VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER : VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorImageInfos[bindingNdx]);
615 descriptorSetUpdateBuilder.update(vk, device);
618 void BasicComputeTestInstance::createImageInfos (VkImageCreateInfo* imageInfos)
620 const VkExtent3D extentUncompressed = makeExtent3D(getCompressedImageResolutionInBlocks(m_parameters.formatCompressed, m_parameters.size));
621 const VkExtent3D extentCompressed = makeExtent3D(getLayerSize(m_parameters.imageType, m_parameters.size));
622 const deUint32 arrayLayers = getNumLayers(m_parameters.imageType, m_parameters.size);
623 const VkImageType imageType = mapImageType(m_parameters.imageType);
625 const VkImageCreateInfo compressedInfo =
627 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
628 DE_NULL, // const void* pNext;
629 VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT |
630 VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR |
631 VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR, // VkImageCreateFlags flags;
632 imageType, // VkImageType imageType;
633 m_parameters.formatCompressed, // VkFormat format;
634 extentCompressed, // VkExtent3D extent;
635 1u, // deUint32 mipLevels;
636 arrayLayers, // deUint32 arrayLayers;
637 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
638 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
639 VK_IMAGE_USAGE_SAMPLED_BIT |
640 VK_IMAGE_USAGE_STORAGE_BIT |
641 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
642 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
643 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
644 0u, // deUint32 queueFamilyIndexCount;
645 DE_NULL, // const deUint32* pQueueFamilyIndices;
646 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
648 imageInfos[0] = compressedInfo;
650 for (size_t ndx = 1; ndx < m_parameters.imagesCount; ++ndx)
652 const VkImageCreateInfo uncompressedInfo =
654 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
655 DE_NULL, // const void* pNext;
656 0u, // VkImageCreateFlags flags;
657 imageType, // VkImageType imageType;
658 m_parameters.formatUncompressed, // VkFormat format;
659 extentUncompressed, // VkExtent3D extent;
660 1u, // deUint32 mipLevels;
661 arrayLayers, // deUint32 arrayLayers;
662 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
663 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
664 m_parameters.uncompressedImageUsage |
665 VK_IMAGE_USAGE_SAMPLED_BIT, // VkImageUsageFlags usage;
666 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
667 0u, // deUint32 queueFamilyIndexCount;
668 DE_NULL, // const deUint32* pQueueFamilyIndices;
669 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
671 imageInfos[ndx] = uncompressedInfo;
675 bool BasicComputeTestInstance::decompressImage (const VkCommandBuffer& cmdBuffer, const VkImage& uncompressed, const VkImage& compressed, const VkExtent3D& extentunCompressed)
677 const DeviceInterface& vk = m_context.getDeviceInterface();
678 const VkDevice device = m_context.getDevice();
679 const VkQueue queue = m_context.getUniversalQueue();
680 Allocator& allocator = m_context.getDefaultAllocator();
681 const Unique<VkShaderModule> shaderModule (createShaderModule(vk, device, m_context.getBinaryCollection().get("decompress"), 0));
682 const VkImageCreateInfo decompressedImageInfo =
684 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
685 DE_NULL, // const void* pNext;
686 0u, // VkImageCreateFlags flags;
687 VK_IMAGE_TYPE_2D, // VkImageType imageType;
688 VK_FORMAT_R8G8B8A8_UNORM, // VkFormat format;
689 makeExtent3D(m_parameters.size), // VkExtent3D extent;
690 1u, // deUint32 mipLevels;
691 1u, // deUint32 arrayLayers;
692 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
693 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
694 VK_IMAGE_USAGE_SAMPLED_BIT |
695 VK_IMAGE_USAGE_STORAGE_BIT |
696 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
697 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
698 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
699 0u, // deUint32 queueFamilyIndexCount;
700 DE_NULL, // const deUint32* pQueueFamilyIndices;
701 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
703 const VkImageCreateInfo compressedImageInfo =
705 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
706 DE_NULL, // const void* pNext;
707 0u, // VkImageCreateFlags flags;
708 VK_IMAGE_TYPE_2D, // VkImageType imageType;
709 m_parameters.formatCompressed, // VkFormat format;
710 makeExtent3D(m_parameters.size), // VkExtent3D extent;
711 1u, // deUint32 mipLevels;
712 1u, // deUint32 arrayLayers;
713 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
714 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
715 VK_IMAGE_USAGE_SAMPLED_BIT |
716 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
717 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
718 0u, // deUint32 queueFamilyIndexCount;
719 DE_NULL, // const deUint32* pQueueFamilyIndices;
720 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
722 const VkImageUsageFlags compressedViewUsageFlags = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
723 const VkImageViewUsageCreateInfoKHR compressedViewUsageCI =
725 VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR, //VkStructureType sType;
726 DE_NULL, //const void* pNext;
727 compressedViewUsageFlags, //VkImageUsageFlags usage;
729 Image resultImage (vk, device, allocator, decompressedImageInfo, MemoryRequirement::Any);
730 Image referenceImage (vk, device, allocator, decompressedImageInfo, MemoryRequirement::Any);
731 Image uncompressedImage (vk, device, allocator, compressedImageInfo, MemoryRequirement::Any);
732 Move<VkImageView> resultView = makeImageView(vk, device, resultImage.get(), mapImageViewType(m_parameters.imageType), decompressedImageInfo.format,
733 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, decompressedImageInfo.extent.depth, 0u, decompressedImageInfo.arrayLayers));
734 Move<VkImageView> referenceView = makeImageView(vk, device, referenceImage.get(), mapImageViewType(m_parameters.imageType), decompressedImageInfo.format,
735 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, decompressedImageInfo.extent.depth, 0u, decompressedImageInfo.arrayLayers));
736 Move<VkImageView> uncompressedView = makeImageView(vk, device, uncompressedImage.get(), mapImageViewType(m_parameters.imageType), m_parameters.formatCompressed,
737 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, compressedImageInfo.extent.depth, 0u, compressedImageInfo.arrayLayers));
738 Move<VkImageView> compressedView = makeImageView(vk, device, compressed, mapImageViewType(m_parameters.imageType), m_parameters.formatCompressed,
739 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, compressedImageInfo.extent.depth, 0u, compressedImageInfo.arrayLayers), &compressedViewUsageCI);
740 Move<VkDescriptorSetLayout> descriptorSetLayout = DescriptorSetLayoutBuilder()
741 .addSingleBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_COMPUTE_BIT)
742 .addSingleBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_COMPUTE_BIT)
743 .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT)
744 .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT)
746 Move<VkDescriptorPool> descriptorPool = DescriptorPoolBuilder()
747 .addType(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, decompressedImageInfo.arrayLayers)
748 .addType(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, decompressedImageInfo.arrayLayers)
749 .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, decompressedImageInfo.arrayLayers)
750 .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, decompressedImageInfo.arrayLayers)
751 .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, decompressedImageInfo.arrayLayers);
753 Move<VkDescriptorSet> descriptorSet = makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout);
754 const Unique<VkPipelineLayout> pipelineLayout (makePipelineLayout(vk, device, *descriptorSetLayout));
755 const Unique<VkPipeline> pipeline (makeComputePipeline(vk, device, *pipelineLayout, *shaderModule));
756 const VkDeviceSize bufferSize = getImageSizeBytes(tcu::IVec3((int)m_parameters.size.x(), (int)m_parameters.size.y(), (int)m_parameters.size.z()), VK_FORMAT_R8G8B8A8_UNORM);
757 Buffer resultBuffer (vk, device, allocator,
758 makeBufferCreateInfo(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT), MemoryRequirement::HostVisible);
759 Buffer referenceBuffer (vk, device, allocator,
760 makeBufferCreateInfo(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT), MemoryRequirement::HostVisible);
761 Buffer transferBuffer (vk, device, allocator,
762 makeBufferCreateInfo(m_data.size(), VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT), MemoryRequirement::HostVisible);
763 Move<VkSampler> sampler;
765 const vk::VkSamplerCreateInfo createInfo =
767 vk::VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, //VkStructureType sType;
768 DE_NULL, //const void* pNext;
769 0u, //VkSamplerCreateFlags flags;
770 VK_FILTER_NEAREST, //VkFilter magFilter;
771 VK_FILTER_NEAREST, //VkFilter minFilter;
772 VK_SAMPLER_MIPMAP_MODE_NEAREST, //VkSamplerMipmapMode mipmapMode;
773 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, //VkSamplerAddressMode addressModeU;
774 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, //VkSamplerAddressMode addressModeV;
775 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, //VkSamplerAddressMode addressModeW;
776 0.0f, //float mipLodBias;
777 VK_FALSE, //VkBool32 anisotropyEnable;
778 1.0f, //float maxAnisotropy;
779 VK_TRUE, //VkBool32 compareEnable;
780 VK_COMPARE_OP_EQUAL, //VkCompareOp compareOp;
781 0.0f, //float minLod;
782 0.0f, //float maxLod;
783 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, //VkBorderColor borderColor;
784 VK_TRUE, //VkBool32 unnormalizedCoordinates;
786 sampler = vk::createSampler(vk, device, &createInfo);
789 VkDescriptorImageInfo descriptorImageInfos[] =
791 makeDescriptorImageInfo(*sampler, *uncompressedView, VK_IMAGE_LAYOUT_GENERAL),
792 makeDescriptorImageInfo(*sampler, *compressedView, VK_IMAGE_LAYOUT_GENERAL),
793 makeDescriptorImageInfo(DE_NULL, *resultView, VK_IMAGE_LAYOUT_GENERAL),
794 makeDescriptorImageInfo(DE_NULL, *referenceView, VK_IMAGE_LAYOUT_GENERAL)
796 DescriptorSetUpdateBuilder()
797 .writeSingle(descriptorSet.get(), DescriptorSetUpdateBuilder::Location::binding(0), VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &descriptorImageInfos[0])
798 .writeSingle(descriptorSet.get(), DescriptorSetUpdateBuilder::Location::binding(1), VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &descriptorImageInfos[1])
799 .writeSingle(descriptorSet.get(), DescriptorSetUpdateBuilder::Location::binding(2), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorImageInfos[2])
800 .writeSingle(descriptorSet.get(), DescriptorSetUpdateBuilder::Location::binding(3), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorImageInfos[3])
804 beginCommandBuffer(vk, cmdBuffer);
806 const VkImageSubresourceRange subresourceRange =
808 VK_IMAGE_ASPECT_COLOR_BIT, //VkImageAspectFlags aspectMask
809 0u, //deUint32 baseMipLevel
810 1u, //deUint32 levelCount
811 0u, //deUint32 baseArrayLayer
812 1 //deUint32 layerCount
815 const VkBufferImageCopy copyRegion =
817 0ull, // VkDeviceSize bufferOffset;
818 0u, // deUint32 bufferRowLength;
819 0u, // deUint32 bufferImageHeight;
820 makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u), // VkImageSubresourceLayers imageSubresource;
821 makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
822 decompressedImageInfo.extent, // VkExtent3D imageExtent;
825 const VkBufferImageCopy compressedCopyRegion =
827 0ull, // VkDeviceSize bufferOffset;
828 0u, // deUint32 bufferRowLength;
829 0u, // deUint32 bufferImageHeight;
830 makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u), // VkImageSubresourceLayers imageSubresource;
831 makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
832 extentunCompressed, // VkExtent3D imageExtent;
836 const VkBufferMemoryBarrier preCopyBufferBarriers = makeBufferMemoryBarrier(0u, VK_ACCESS_TRANSFER_WRITE_BIT,
837 transferBuffer.get(), 0ull, m_data.size());
839 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
840 (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &preCopyBufferBarriers, 0u, (const VkImageMemoryBarrier*)DE_NULL);
843 vk.cmdCopyImageToBuffer(cmdBuffer, uncompressed, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, transferBuffer.get(), 1u, &compressedCopyRegion);
846 const VkBufferMemoryBarrier postCopyBufferBarriers = makeBufferMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
847 transferBuffer.get(), 0ull, m_data.size());
849 const VkImageMemoryBarrier preCopyImageBarriers = makeImageMemoryBarrier(0u, VK_ACCESS_TRANSFER_WRITE_BIT,
850 VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, uncompressedImage.get(), subresourceRange);
852 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
853 (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &postCopyBufferBarriers, 1u, &preCopyImageBarriers);
856 vk.cmdCopyBufferToImage(cmdBuffer, transferBuffer.get(), uncompressedImage.get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, ©Region);
858 vk.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
859 vk.cmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
862 const VkImageMemoryBarrier preShaderImageBarriers[] =
864 makeImageMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
865 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL,
866 uncompressedImage.get(), subresourceRange),
868 makeImageMemoryBarrier(0u, VK_ACCESS_SHADER_WRITE_BIT,
869 VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL,
870 resultImage.get(), subresourceRange),
872 makeImageMemoryBarrier(0u, VK_ACCESS_SHADER_WRITE_BIT,
873 VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL,
874 referenceImage.get(), subresourceRange)
877 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
878 (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, (const VkBufferMemoryBarrier*)DE_NULL,
879 DE_LENGTH_OF_ARRAY(preShaderImageBarriers), preShaderImageBarriers);
882 vk.cmdDispatch(cmdBuffer, m_parameters.size.x(), m_parameters.size.y(), m_parameters.size.z());
885 const VkImageMemoryBarrier postShaderImageBarriers[] =
887 makeImageMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
888 VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
889 resultImage.get(), subresourceRange),
891 makeImageMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
892 VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
893 referenceImage.get(), subresourceRange)
896 const VkBufferMemoryBarrier preCopyBufferBarrier[] =
898 makeBufferMemoryBarrier( 0, VK_BUFFER_USAGE_TRANSFER_DST_BIT,
899 resultBuffer.get(), 0ull, bufferSize),
901 makeBufferMemoryBarrier( 0, VK_BUFFER_USAGE_TRANSFER_DST_BIT,
902 referenceBuffer.get(), 0ull, bufferSize),
905 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
906 (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, DE_LENGTH_OF_ARRAY(preCopyBufferBarrier), preCopyBufferBarrier,
907 DE_LENGTH_OF_ARRAY(postShaderImageBarriers), postShaderImageBarriers);
909 vk.cmdCopyImageToBuffer(cmdBuffer, resultImage.get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, resultBuffer.get(), 1u, ©Region);
910 vk.cmdCopyImageToBuffer(cmdBuffer, referenceImage.get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, referenceBuffer.get(), 1u, ©Region);
912 endCommandBuffer(vk, cmdBuffer);
913 submitCommandsAndWait(vk, device, queue, cmdBuffer);
915 const Allocation& resultAlloc = resultBuffer.getAllocation();
916 const Allocation& referenceAlloc = referenceBuffer.getAllocation();
917 invalidateMappedMemoryRange(vk, device, resultAlloc.getMemory(), resultAlloc.getOffset(), bufferSize);
918 invalidateMappedMemoryRange(vk, device, referenceAlloc.getMemory(), referenceAlloc.getOffset(), bufferSize);
920 tcu::ConstPixelBufferAccess resultPixels (mapVkFormat(decompressedImageInfo.format), decompressedImageInfo.extent.width, decompressedImageInfo.extent.height, decompressedImageInfo.extent.depth, resultAlloc.getHostPtr());
921 tcu::ConstPixelBufferAccess referencePixels (mapVkFormat(decompressedImageInfo.format), decompressedImageInfo.extent.width, decompressedImageInfo.extent.height, decompressedImageInfo.extent.depth, referenceAlloc.getHostPtr());
923 return tcu::fuzzyCompare(m_context.getTestContext().getLog(), "ImageComparison", "Image Comparison", resultPixels, referencePixels, 0.001f, tcu::COMPARE_LOG_EVERYTHING);
927 class ImageStoreComputeTestInstance : public BasicComputeTestInstance
930 ImageStoreComputeTestInstance (Context& contex, const TestParameters& parameters);
932 virtual void executeShader (const VkCommandBuffer& cmdBuffer,
933 const VkDescriptorSetLayout& descriptorSetLayout,
934 const VkDescriptorPool& descriptorPool,
935 const vector<ImageSp>& images,
936 const vector<ImageViewSp>& imageViews);
940 ImageStoreComputeTestInstance::ImageStoreComputeTestInstance (Context& contex, const TestParameters& parameters)
941 :BasicComputeTestInstance (contex, parameters)
945 void ImageStoreComputeTestInstance::executeShader (const VkCommandBuffer& cmdBuffer,
946 const VkDescriptorSetLayout& descriptorSetLayout,
947 const VkDescriptorPool& descriptorPool,
948 const vector<ImageSp>& images,
949 const vector<ImageViewSp>& imageViews)
951 const DeviceInterface& vk = m_context.getDeviceInterface();
952 const VkDevice device = m_context.getDevice();
953 const VkQueue queue = m_context.getUniversalQueue();
954 const Unique<VkShaderModule> shaderModule (createShaderModule(vk, device, m_context.getBinaryCollection().get("comp"), 0));
955 Move<VkDescriptorSet> descriptorSet = makeDescriptorSet(vk, device, descriptorPool, descriptorSetLayout);
956 const Unique<VkPipelineLayout> pipelineLayout (makePipelineLayout(vk, device, descriptorSetLayout));
957 const Unique<VkPipeline> pipeline (makeComputePipeline(vk, device, *pipelineLayout, *shaderModule));
958 const UVec3 extentUncompressed = getCompressedImageResolutionInBlocks(m_parameters.formatCompressed, m_parameters.size);
960 vector<VkDescriptorImageInfo> descriptorImageInfos (m_parameters.imagesCount);
961 for (deUint32 bindingNdx = 0; bindingNdx < m_parameters.imagesCount; ++bindingNdx)
962 descriptorImageInfos[bindingNdx] = makeDescriptorImageInfo(DE_NULL, **imageViews[bindingNdx], VK_IMAGE_LAYOUT_GENERAL);
964 beginCommandBuffer(vk, cmdBuffer);
966 const VkImageSubresourceRange subresourceRange =
968 VK_IMAGE_ASPECT_COLOR_BIT, //VkImageAspectFlags aspectMask
969 0u, //deUint32 baseMipLevel
970 1u, //deUint32 levelCount
971 0u, //deUint32 baseArrayLayer
972 1u //deUint32 layerCount
975 const VkImageMemoryBarrier preShaderImageBarriers[] =
977 makeImageMemoryBarrier(
978 VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT,
979 VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL,
980 **images[0]->get(), subresourceRange),
982 makeImageMemoryBarrier(
983 VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
984 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL,
985 **images[1]->get(), subresourceRange),
987 makeImageMemoryBarrier(
988 VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_WRITE_BIT,
989 VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL,
990 **images[2]->get(), subresourceRange)
993 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
994 (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, (const VkBufferMemoryBarrier*)DE_NULL,
995 DE_LENGTH_OF_ARRAY(preShaderImageBarriers), preShaderImageBarriers);
997 vk.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
998 descriptorSetUpdate (*descriptorSet, &descriptorImageInfos[0]);
1000 vk.cmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
1002 vk.cmdDispatch(cmdBuffer, extentUncompressed.x(), extentUncompressed.y(), extentUncompressed.z());
1004 endCommandBuffer(vk, cmdBuffer);
1005 submitCommandsAndWait(vk, device, queue, cmdBuffer);
1008 class GraphicsAttachmentsTestInstance : public BasicTranscodingTestInstance
1011 GraphicsAttachmentsTestInstance (Context& context, const TestParameters& parameters);
1012 virtual TestStatus iterate (void);
1015 virtual bool isWriteToCompressedOperation ();
1016 VkImageCreateInfo makeCreateImageInfo (VkFormat format, ImageType type, const UVec3& size, VkImageUsageFlags usageFlags, const VkImageCreateFlags* createFlags);
1017 VkImageViewUsageCreateInfoKHR makeImageViewUsageCreateInfo (VkImageUsageFlags imageUsageFlags);
1018 VkDeviceSize getCompressedImageData (const VkFormat format, const UVec3& size, std::vector<deUint8>& data);
1019 VkDeviceSize getUncompressedImageData (const VkFormat format, const UVec3& size, std::vector<deUint8>& data);
1020 virtual void transcode (std::vector<deUint8>& srcData, std::vector<deUint8>& dstData, de::MovePtr<Image>& outputImage);
1021 bool compareAndLog (const void* reference, const void* result, size_t size);
1022 bool verifyDecompression (const std::vector<deUint8>& refCompressedData, const de::MovePtr<Image>& resCompressedImage);
1024 deUint32 m_arrayLayers;
1028 GraphicsAttachmentsTestInstance::GraphicsAttachmentsTestInstance (Context& context, const TestParameters& parameters)
1029 : BasicTranscodingTestInstance(context, parameters)
1030 , m_arrayLayers(getNumLayers(m_parameters.imageType, m_parameters.size))
1031 , m_layerSize(getLayerSize(m_parameters.imageType, m_parameters.size))
1035 TestStatus GraphicsAttachmentsTestInstance::iterate (void)
1037 std::vector<deUint8> srcData;
1038 std::vector<deUint8> dstData;
1039 de::MovePtr<Image> outputImage;
1041 transcode(srcData, dstData, outputImage);
1043 DE_ASSERT(srcData.size() > 0 && srcData.size() == dstData.size());
1045 if (!compareAndLog(&srcData[0], &dstData[0], srcData.size()))
1046 return TestStatus::fail("Output differs from input");
1048 // Verify by sampling
1049 if (isWriteToCompressedOperation())
1050 if (!verifyDecompression(srcData, outputImage))
1051 return TestStatus::fail("Decompressed images difference detected");
1053 return TestStatus::pass("Pass");
1056 void GraphicsAttachmentsTestInstance::transcode (std::vector<deUint8>& srcData, std::vector<deUint8>& dstData, de::MovePtr<Image>& outputImage)
1058 const DeviceInterface& vk = m_context.getDeviceInterface();
1059 const VkDevice device = m_context.getDevice();
1060 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
1061 const VkQueue queue = m_context.getUniversalQueue();
1062 Allocator& allocator = m_context.getDefaultAllocator();
1064 const deUint32 levelCount = m_layerSize[2];
1065 const VkImageSubresourceRange subresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, levelCount, 0u, m_arrayLayers);
1066 const VkImageCreateFlags* imgCreateFlagsOverride = DE_NULL;
1067 const VkImageViewUsageCreateInfoKHR imageViewUsageKHR = makeImageViewUsageCreateInfo(m_parameters.compressedImageUsage);
1068 const VkImageViewUsageCreateInfoKHR* imageViewUsageKHRNull = (VkImageViewUsageCreateInfoKHR*)DE_NULL;
1070 const UVec3 compressedImageRes = m_parameters.size;
1071 const UVec3 uncompressedImageRes = getCompressedImageResolutionInBlocks(m_parameters.formatCompressed, m_parameters.size);
1073 const VkFormat srcFormat = (m_parameters.operation == OPERATION_ATTACHMENT_READ) ? m_parameters.formatCompressed :
1074 (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? m_parameters.formatUncompressed :
1075 VK_FORMAT_UNDEFINED;
1076 const UVec3 srcImageResolution = (m_parameters.operation == OPERATION_ATTACHMENT_READ) ? compressedImageRes :
1077 (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? uncompressedImageRes :
1079 const VkDeviceSize srcImageSizeInBytes = (m_parameters.operation == OPERATION_ATTACHMENT_READ) ? getCompressedImageData(srcFormat, srcImageResolution, srcData) :
1080 (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? getUncompressedImageData(srcFormat, srcImageResolution, srcData) :
1082 const VkImageUsageFlags srcImageUsageFlags = (m_parameters.operation == OPERATION_ATTACHMENT_READ) ? m_parameters.compressedImageUsage :
1083 (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? m_parameters.uncompressedImageUsage :
1085 const VkImageViewUsageCreateInfoKHR* srcImageViewUsageKHR = (m_parameters.operation == OPERATION_ATTACHMENT_READ) ? &imageViewUsageKHR :
1086 (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? imageViewUsageKHRNull :
1087 imageViewUsageKHRNull;
1089 const VkFormat dstFormat = (m_parameters.operation == OPERATION_ATTACHMENT_READ) ? m_parameters.formatUncompressed :
1090 (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? m_parameters.formatCompressed :
1091 VK_FORMAT_UNDEFINED;
1092 const UVec3 dstImageResolution = (m_parameters.operation == OPERATION_ATTACHMENT_READ) ? uncompressedImageRes :
1093 (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? compressedImageRes :
1095 const VkDeviceSize dstImageSizeInBytes = (m_parameters.operation == OPERATION_ATTACHMENT_READ) ? getUncompressedImageSizeInBytes(dstFormat, dstImageResolution) :
1096 (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? getCompressedImageSizeInBytes(dstFormat, dstImageResolution) :
1098 const VkImageUsageFlags dstImageUsageFlags = (m_parameters.operation == OPERATION_ATTACHMENT_READ) ? m_parameters.uncompressedImageUsage :
1099 (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? m_parameters.compressedImageUsage :
1101 const VkImageViewUsageCreateInfoKHR* dstImageViewUsageKHR = (m_parameters.operation == OPERATION_ATTACHMENT_READ) ? imageViewUsageKHRNull :
1102 (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? &imageViewUsageKHR :
1103 imageViewUsageKHRNull;
1105 const std::vector<tcu::Vec4> vertexArray = createFullscreenQuad();
1106 const deUint32 vertexCount = static_cast<deUint32>(vertexArray.size());
1107 const size_t vertexBufferSizeInBytes = vertexCount * sizeof(vertexArray[0]);
1108 const MovePtr<Buffer> vertexBuffer = MovePtr<Buffer>(new Buffer(vk, device, allocator, makeBufferCreateInfo(vertexBufferSizeInBytes, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), MemoryRequirement::HostVisible));
1109 const Allocation& vertexBufferAlloc = vertexBuffer->getAllocation();
1110 const VkDeviceSize vertexBufferOffset[] = { 0 };
1112 const VkBufferCreateInfo srcImageBufferInfo (makeBufferCreateInfo(srcImageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_SRC_BIT));
1113 const MovePtr<Buffer> srcImageBuffer = MovePtr<Buffer>(new Buffer(vk, device, allocator, srcImageBufferInfo, MemoryRequirement::HostVisible));
1115 const VkImageCreateInfo srcImageCreateInfo = makeCreateImageInfo(srcFormat, m_parameters.imageType, srcImageResolution, srcImageUsageFlags, imgCreateFlagsOverride);
1116 const MovePtr<Image> srcImage (new Image(vk, device, allocator, srcImageCreateInfo, MemoryRequirement::Any));
1117 Move<VkImageView> srcImageView (makeImageView(vk, device, srcImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatUncompressed, subresourceRange, srcImageViewUsageKHR));
1119 const VkImageCreateInfo dstImageCreateInfo = makeCreateImageInfo(dstFormat, m_parameters.imageType, dstImageResolution, dstImageUsageFlags, imgCreateFlagsOverride);
1120 de::MovePtr<Image> dstImage (new Image(vk, device, allocator, dstImageCreateInfo, MemoryRequirement::Any));
1121 Move<VkImageView> dstImageView (makeImageView(vk, device, dstImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatUncompressed, subresourceRange, dstImageViewUsageKHR));
1123 const VkBufferCreateInfo dstImageBufferInfo (makeBufferCreateInfo(dstImageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT));
1124 MovePtr<Buffer> dstImageBuffer = MovePtr<Buffer>(new Buffer(vk, device, allocator, dstImageBufferInfo, MemoryRequirement::HostVisible));
1126 const Unique<VkShaderModule> vertShaderModule (createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0));
1127 const Unique<VkShaderModule> fragShaderModule (createShaderModule(vk, device, m_context.getBinaryCollection().get("frag"), 0));
1129 const Unique<VkRenderPass> renderPass (makeRenderPass(vk, device, m_parameters.formatUncompressed, m_parameters.formatUncompressed));
1131 const Move<VkDescriptorSetLayout> descriptorSetLayout (DescriptorSetLayoutBuilder()
1132 .addSingleBinding(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, VK_SHADER_STAGE_FRAGMENT_BIT)
1133 .build(vk, device));
1134 const Move<VkDescriptorPool> descriptorPool (DescriptorPoolBuilder()
1135 .addType(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, m_arrayLayers)
1136 .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, m_arrayLayers));
1137 const Move<VkDescriptorSet> descriptorSet (makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout));
1138 const VkDescriptorImageInfo descriptorSrcImageInfo (makeDescriptorImageInfo(DE_NULL, *srcImageView, VK_IMAGE_LAYOUT_GENERAL));
1140 const VkExtent2D renderSize (makeExtent2D(uncompressedImageRes[0], uncompressedImageRes[1]));
1141 const Unique<VkPipelineLayout> pipelineLayout (makePipelineLayout(vk, device, *descriptorSetLayout));
1142 const Unique<VkPipeline> pipeline (makeGraphicsPipeline(vk, device, *pipelineLayout, *renderPass, *vertShaderModule, *fragShaderModule, renderSize, 1u));
1143 const Unique<VkCommandPool> cmdPool (createCommandPool(vk, device, VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT, queueFamilyIndex));
1144 const Unique<VkCommandBuffer> cmdBuffer (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
1146 const VkBufferImageCopy srcCopyRegion = makeBufferImageCopy(srcImageResolution[0], srcImageResolution[1]);
1147 const VkBufferMemoryBarrier srcCopyBufferBarrierPre = makeBufferMemoryBarrier(VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, srcImageBuffer->get(), 0ull, srcImageSizeInBytes);
1148 const VkImageMemoryBarrier srcCopyImageBarrierPre = makeImageMemoryBarrier(0u, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, srcImage->get(), subresourceRange);
1149 const VkImageMemoryBarrier srcCopyImageBarrierPost = makeImageMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, srcImage->get(), subresourceRange);
1150 const VkBufferImageCopy dstCopyRegion = makeBufferImageCopy(dstImageResolution[0], dstImageResolution[1]);
1152 const VkImageView attachmentBindInfos[] = { *srcImageView, *dstImageView };
1153 const Move<VkFramebuffer> framebuffer (makeFramebuffer(vk, device, *renderPass, DE_LENGTH_OF_ARRAY(attachmentBindInfos), attachmentBindInfos, renderSize, m_arrayLayers));
1155 DE_ASSERT(srcImageSizeInBytes == dstImageSizeInBytes);
1157 // Upload vertex data
1158 deMemcpy(vertexBufferAlloc.getHostPtr(), &vertexArray[0], vertexBufferSizeInBytes);
1159 flushMappedMemoryRange(vk, device, vertexBufferAlloc.getMemory(), vertexBufferAlloc.getOffset(), vertexBufferSizeInBytes);
1161 // Upload source image data
1162 const Allocation& alloc = srcImageBuffer->getAllocation();
1163 deMemcpy(alloc.getHostPtr(), &srcData[0], (size_t)srcImageSizeInBytes);
1164 flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), srcImageSizeInBytes);
1166 beginCommandBuffer(vk, *cmdBuffer);
1167 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
1169 //Copy buffer to image
1170 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &srcCopyBufferBarrierPre, 1u, &srcCopyImageBarrierPre);
1171 vk.cmdCopyBufferToImage(*cmdBuffer, srcImageBuffer->get(), srcImage->get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, &srcCopyRegion);
1172 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1u, &srcCopyImageBarrierPost);
1174 beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, renderSize);
1176 for (deUint32 layerNdx = 0; layerNdx < m_arrayLayers; ++layerNdx)
1178 DescriptorSetUpdateBuilder()
1179 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, &descriptorSrcImageInfo)
1180 .update(vk, device);
1182 vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
1183 vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &vertexBuffer->get(), vertexBufferOffset);
1184 vk.cmdDraw(*cmdBuffer, vertexCount, 1, 0, 0);
1187 vk.cmdEndRenderPass(*cmdBuffer);
1189 const VkImageMemoryBarrier prepareForTransferBarrier = makeImageMemoryBarrier(
1190 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
1191 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL,
1192 dstImage->get(), subresourceRange);
1194 const VkBufferMemoryBarrier copyBarrier = makeBufferMemoryBarrier(
1195 VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT,
1196 dstImageBuffer->get(), 0ull, dstImageSizeInBytes);
1198 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &prepareForTransferBarrier);
1199 vk.cmdCopyImageToBuffer(*cmdBuffer, dstImage->get(), VK_IMAGE_LAYOUT_GENERAL, dstImageBuffer->get(), 1u, &dstCopyRegion);
1200 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, ©Barrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
1202 endCommandBuffer(vk, *cmdBuffer);
1204 submitCommandsAndWait(vk, device, queue, *cmdBuffer);
1206 const Allocation& dstImageBufferAlloc = dstImageBuffer->getAllocation();
1207 invalidateMappedMemoryRange(vk, device, dstImageBufferAlloc.getMemory(), dstImageBufferAlloc.getOffset(), dstImageSizeInBytes);
1208 dstData.resize((size_t)dstImageSizeInBytes);
1209 deMemcpy(&dstData[0], dstImageBufferAlloc.getHostPtr(), (size_t)dstImageSizeInBytes);
1211 outputImage = dstImage;
1214 bool GraphicsAttachmentsTestInstance::isWriteToCompressedOperation ()
1216 return (m_parameters.operation == OPERATION_ATTACHMENT_WRITE);
1219 VkImageCreateInfo GraphicsAttachmentsTestInstance::makeCreateImageInfo (VkFormat format, ImageType type, const UVec3& size, VkImageUsageFlags usageFlags, const VkImageCreateFlags* createFlags)
1221 const VkImageType imageType = mapImageType(type);
1222 const VkImageCreateFlags imageCreateFlagsBase = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
1223 const VkImageCreateFlags imageCreateFlagsAddOn = isCompressedFormat(format) ? VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR | VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR : 0;
1224 const VkImageCreateFlags imageCreateFlags = (createFlags != DE_NULL) ? *createFlags : (imageCreateFlagsBase | imageCreateFlagsAddOn);
1226 const VkImageCreateInfo createImageInfo =
1228 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1229 DE_NULL, // const void* pNext;
1230 imageCreateFlags, // VkImageCreateFlags flags;
1231 imageType, // VkImageType imageType;
1232 format, // VkFormat format;
1233 makeExtent3D(getLayerSize(type, size)), // VkExtent3D extent;
1234 1u, // deUint32 mipLevels;
1235 1u, // deUint32 arrayLayers;
1236 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
1237 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1238 usageFlags, // VkImageUsageFlags usage;
1239 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1240 0u, // deUint32 queueFamilyIndexCount;
1241 DE_NULL, // const deUint32* pQueueFamilyIndices;
1242 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
1245 return createImageInfo;
1248 VkImageViewUsageCreateInfoKHR GraphicsAttachmentsTestInstance::makeImageViewUsageCreateInfo (VkImageUsageFlags imageUsageFlags)
1250 VkImageViewUsageCreateInfoKHR imageViewUsageCreateInfoKHR =
1252 VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR, //VkStructureType sType;
1253 DE_NULL, //const void* pNext;
1254 imageUsageFlags, //VkImageUsageFlags usage;
1257 return imageViewUsageCreateInfoKHR;
1260 VkDeviceSize GraphicsAttachmentsTestInstance::getCompressedImageData (const VkFormat format, const UVec3& size, std::vector<deUint8>& data)
1262 VkDeviceSize sizeBytes = getCompressedImageSizeInBytes(format, size);
1264 data.resize((size_t)sizeBytes);
1265 generateData(&data[0], data.size(), format);
1270 VkDeviceSize GraphicsAttachmentsTestInstance::getUncompressedImageData (const VkFormat format, const UVec3& size, std::vector<deUint8>& data)
1272 tcu::IVec3 sizeAsIVec3 = tcu::IVec3(static_cast<int>(size[0]), static_cast<int>(size[1]), static_cast<int>(size[2]));
1273 VkDeviceSize sizeBytes = getImageSizeBytes(sizeAsIVec3, format);
1275 data.resize((size_t)sizeBytes);
1276 generateData(&data[0], data.size(), format);
1281 bool GraphicsAttachmentsTestInstance::compareAndLog (const void* reference, const void* result, size_t size)
1283 tcu::TestLog& log = m_context.getTestContext().getLog();
1285 const deUint64* ref64 = reinterpret_cast<const deUint64*>(reference);
1286 const deUint64* res64 = reinterpret_cast<const deUint64*>(result);
1287 const size_t sizew = size / sizeof(deUint64);
1290 DE_ASSERT(size % sizeof(deUint64) == 0);
1292 for (deUint32 ndx = 0u; ndx < static_cast<deUint32>(sizew); ndx++)
1294 if (ref64[ndx] != res64[ndx])
1296 std::stringstream str;
1298 str << "Difference begins near byte " << ndx * sizeof(deUint64) << "."
1299 << " reference value: 0x" << std::hex << std::setw(2ull * sizeof(deUint64)) << std::setfill('0') << ref64[ndx]
1300 << " result value: 0x" << std::hex << std::setw(2ull * sizeof(deUint64)) << std::setfill('0') << res64[ndx];
1302 log.writeMessage(str.str().c_str());
1313 bool GraphicsAttachmentsTestInstance::verifyDecompression (const std::vector<deUint8>& refCompressedData, const de::MovePtr<Image>& resCompressedImage)
1315 const DeviceInterface& vk = m_context.getDeviceInterface();
1316 const VkDevice device = m_context.getDevice();
1317 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
1318 const VkQueue queue = m_context.getUniversalQueue();
1319 Allocator& allocator = m_context.getDefaultAllocator();
1321 const deUint32 levelCount = m_layerSize[2];
1322 const VkImageSubresourceRange subresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, levelCount, 0u, m_arrayLayers);
1324 const VkDeviceSize dstBufferSize = getUncompressedImageSizeInBytes(m_parameters.formatForVerify, m_parameters.size);
1325 const VkImageUsageFlags refSrcImageUsageFlags = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
1327 const std::vector<tcu::Vec4> vertexArray = createFullscreenQuad();
1328 const deUint32 vertexCount = static_cast<deUint32>(vertexArray.size());
1329 const size_t vertexBufferSizeInBytes = vertexCount * sizeof(vertexArray[0]);
1330 const MovePtr<Buffer> vertexBuffer (new Buffer(vk, device, allocator, makeBufferCreateInfo(vertexBufferSizeInBytes, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), MemoryRequirement::HostVisible));
1331 const Allocation& vertexBufferAlloc = vertexBuffer->getAllocation();
1332 const VkDeviceSize vertexBufferOffset[] = { 0 };
1334 const VkBufferCreateInfo refSrcImageBufferInfo (makeBufferCreateInfo(refCompressedData.size(), VK_BUFFER_USAGE_TRANSFER_SRC_BIT));
1335 const MovePtr<Buffer> refSrcImageBuffer = MovePtr<Buffer>(new Buffer(vk, device, allocator, refSrcImageBufferInfo, MemoryRequirement::HostVisible));
1337 const VkImageCreateFlags refSrcImageCreateFlags = 0;
1338 const VkImageCreateInfo refSrcImageCreateInfo = makeCreateImageInfo(m_parameters.formatCompressed, m_parameters.imageType, m_parameters.size, refSrcImageUsageFlags, &refSrcImageCreateFlags);
1339 const MovePtr<Image> refSrcImage (new Image(vk, device, allocator, refSrcImageCreateInfo, MemoryRequirement::Any));
1340 Move<VkImageView> refSrcImageView (makeImageView(vk, device, refSrcImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatCompressed, subresourceRange));
1342 const VkImageUsageFlags resSrcImageUsageFlags = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
1343 const VkImageViewUsageCreateInfoKHR resSrcImageViewUsageKHR = makeImageViewUsageCreateInfo(resSrcImageUsageFlags);
1344 Move<VkImageView> resSrcImageView (makeImageView(vk, device, resCompressedImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatCompressed, subresourceRange, &resSrcImageViewUsageKHR));
1346 const VkImageCreateFlags refDstImageCreateFlags = 0;
1347 const VkImageUsageFlags refDstImageUsageFlags = VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
1348 const VkImageCreateInfo refDstImageCreateInfo = makeCreateImageInfo(m_parameters.formatForVerify, m_parameters.imageType, m_parameters.size, refDstImageUsageFlags, &refDstImageCreateFlags);
1349 const MovePtr<Image> refDstImage (new Image(vk, device, allocator, refDstImageCreateInfo, MemoryRequirement::Any));
1350 const Move<VkImageView> refDstImageView (makeImageView(vk, device, refDstImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatForVerify, subresourceRange));
1351 const VkImageMemoryBarrier refDstCopyImageBarrier = makeImageMemoryBarrier(0u, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, refDstImage->get(), subresourceRange);
1352 const VkBufferCreateInfo refDstBufferInfo (makeBufferCreateInfo(dstBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT));
1353 const MovePtr<Buffer> refDstBuffer = MovePtr<Buffer>(new Buffer(vk, device, allocator, refDstBufferInfo, MemoryRequirement::HostVisible));
1355 const VkImageCreateFlags resDstImageCreateFlags = 0;
1356 const VkImageUsageFlags resDstImageUsageFlags = VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
1357 const VkImageCreateInfo resDstImageCreateInfo = makeCreateImageInfo(m_parameters.formatForVerify, m_parameters.imageType, m_parameters.size, resDstImageUsageFlags, &resDstImageCreateFlags);
1358 const MovePtr<Image> resDstImage (new Image(vk, device, allocator, resDstImageCreateInfo, MemoryRequirement::Any));
1359 const Move<VkImageView> resDstImageView (makeImageView(vk, device, resDstImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatForVerify, subresourceRange));
1360 const VkImageMemoryBarrier resDstCopyImageBarrier = makeImageMemoryBarrier(0u, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, resDstImage->get(), subresourceRange);
1361 const VkBufferCreateInfo resDstBufferInfo (makeBufferCreateInfo(dstBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT));
1362 const MovePtr<Buffer> resDstBuffer = MovePtr<Buffer>(new Buffer(vk, device, allocator, resDstBufferInfo, MemoryRequirement::HostVisible));
1364 const Unique<VkShaderModule> vertShaderModule (createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0));
1365 const Unique<VkShaderModule> fragShaderModule (createShaderModule(vk, device, m_context.getBinaryCollection().get("frag_verify"), 0));
1367 const Unique<VkRenderPass> renderPass (makeRenderPass(vk, device));
1369 const Move<VkDescriptorSetLayout> descriptorSetLayout (DescriptorSetLayoutBuilder()
1370 .addSingleBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT)
1371 .addSingleBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT)
1372 .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_FRAGMENT_BIT)
1373 .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_FRAGMENT_BIT)
1374 .build(vk, device));
1375 const Move<VkDescriptorPool> descriptorPool (DescriptorPoolBuilder()
1376 .addType(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, m_arrayLayers)
1377 .addType(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, m_arrayLayers)
1378 .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, m_arrayLayers)
1379 .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, m_arrayLayers)
1380 .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, m_arrayLayers));
1381 const Move<VkDescriptorSet> descriptorSet (makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout));
1382 const VkSamplerCreateInfo refSrcSamplerInfo (makeSamplerCreateInfo());
1383 const Move<VkSampler> refSrcSampler = vk::createSampler(vk, device, &refSrcSamplerInfo);
1384 const VkSamplerCreateInfo resSrcSamplerInfo (makeSamplerCreateInfo());
1385 const Move<VkSampler> resSrcSampler = vk::createSampler(vk, device, &resSrcSamplerInfo);
1386 const VkDescriptorImageInfo descriptorRefSrcImage (makeDescriptorImageInfo(*refSrcSampler, *refSrcImageView, VK_IMAGE_LAYOUT_GENERAL));
1387 const VkDescriptorImageInfo descriptorResSrcImage (makeDescriptorImageInfo(*resSrcSampler, *resSrcImageView, VK_IMAGE_LAYOUT_GENERAL));
1388 const VkDescriptorImageInfo descriptorRefDstImage (makeDescriptorImageInfo(DE_NULL, *refDstImageView, VK_IMAGE_LAYOUT_GENERAL));
1389 const VkDescriptorImageInfo descriptorResDstImage (makeDescriptorImageInfo(DE_NULL, *resDstImageView, VK_IMAGE_LAYOUT_GENERAL));
1391 const VkExtent2D renderSize (makeExtent2D(m_parameters.size.x(), m_parameters.size.y()));
1392 const Unique<VkPipelineLayout> pipelineLayout (makePipelineLayout(vk, device, *descriptorSetLayout));
1393 const Unique<VkPipeline> pipeline (makeGraphicsPipeline(vk, device, *pipelineLayout, *renderPass, *vertShaderModule, *fragShaderModule, renderSize, 0u));
1394 const Unique<VkCommandPool> cmdPool (createCommandPool(vk, device, VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT, queueFamilyIndex));
1395 const Unique<VkCommandBuffer> cmdBuffer (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
1397 const VkBufferImageCopy copyRegion = makeBufferImageCopy(m_parameters.size.x(), m_parameters.size.y());
1398 const VkBufferMemoryBarrier refSrcCopyBufferBarrier = makeBufferMemoryBarrier(VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, refSrcImageBuffer->get(), 0ull, refCompressedData.size());
1399 const VkImageMemoryBarrier refSrcCopyImageBarrier = makeImageMemoryBarrier(0u, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, refSrcImage->get(), subresourceRange);
1400 const VkImageMemoryBarrier refSrcCopyImageBarrierPost = makeImageMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL, refSrcImage->get(), subresourceRange);
1402 const Move<VkFramebuffer> framebuffer (makeFramebuffer(vk, device, *renderPass, 0, DE_NULL, renderSize, m_arrayLayers));
1404 // Upload vertex data
1405 deMemcpy(vertexBufferAlloc.getHostPtr(), &vertexArray[0], vertexBufferSizeInBytes);
1406 flushMappedMemoryRange(vk, device, vertexBufferAlloc.getMemory(), vertexBufferAlloc.getOffset(), vertexBufferSizeInBytes);
1408 // Upload source image data
1410 const Allocation& refSrcImageBufferAlloc = refSrcImageBuffer->getAllocation();
1411 deMemcpy(refSrcImageBufferAlloc.getHostPtr(), &refCompressedData[0], refCompressedData.size());
1412 flushMappedMemoryRange(vk, device, refSrcImageBufferAlloc.getMemory(), refSrcImageBufferAlloc.getOffset(), refCompressedData.size());
1415 beginCommandBuffer(vk, *cmdBuffer);
1416 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
1418 //Copy buffer to image
1419 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &refSrcCopyBufferBarrier, 1u, &refSrcCopyImageBarrier);
1420 vk.cmdCopyBufferToImage(*cmdBuffer, refSrcImageBuffer->get(), refSrcImage->get(), VK_IMAGE_LAYOUT_GENERAL, 1u, ©Region);
1421 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, DE_NULL, 1u, &refSrcCopyImageBarrierPost);
1423 // Make reference and result images readable
1424 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &refDstCopyImageBarrier);
1425 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &resDstCopyImageBarrier);
1427 beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, renderSize);
1428 for (deUint32 layerNdx = 0; layerNdx < m_arrayLayers; ++layerNdx)
1430 DescriptorSetUpdateBuilder()
1431 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &descriptorRefSrcImage)
1432 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(1u), VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &descriptorResSrcImage)
1433 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(2u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorRefDstImage)
1434 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(3u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorResDstImage)
1435 .update(vk, device);
1437 vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
1438 vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &vertexBuffer->get(), vertexBufferOffset);
1439 vk.cmdDraw(*cmdBuffer, vertexCount, 1, 0, 0);
1441 vk.cmdEndRenderPass(*cmdBuffer);
1443 // Decompress reference image
1445 const VkImageMemoryBarrier refDstImageBarrier = makeImageMemoryBarrier(
1446 VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
1447 VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL,
1448 refDstImage->get(), subresourceRange);
1450 const VkBufferMemoryBarrier refDstBufferBarrier = makeBufferMemoryBarrier(
1451 VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT,
1452 refDstBuffer->get(), 0ull, dstBufferSize);
1454 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &refDstImageBarrier);
1455 vk.cmdCopyImageToBuffer(*cmdBuffer, refDstImage->get(), VK_IMAGE_LAYOUT_GENERAL, refDstBuffer->get(), 1u, ©Region);
1456 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &refDstBufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
1459 // Decompress result image
1461 const VkImageMemoryBarrier resDstImageBarrier = makeImageMemoryBarrier(
1462 VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
1463 VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL,
1464 resDstImage->get(), subresourceRange);
1466 const VkBufferMemoryBarrier resDstBufferBarrier = makeBufferMemoryBarrier(
1467 VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT,
1468 resDstBuffer->get(), 0ull, dstBufferSize);
1470 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &resDstImageBarrier);
1471 vk.cmdCopyImageToBuffer(*cmdBuffer, resDstImage->get(), VK_IMAGE_LAYOUT_GENERAL, resDstBuffer->get(), 1u, ©Region);
1472 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &resDstBufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
1475 endCommandBuffer(vk, *cmdBuffer);
1477 submitCommandsAndWait(vk, device, queue, *cmdBuffer);
1479 // Compare decompressed pixel data in reference and result images
1481 const Allocation& refDstBufferAlloc = refDstBuffer->getAllocation();
1482 invalidateMappedMemoryRange(vk, device, refDstBufferAlloc.getMemory(), refDstBufferAlloc.getOffset(), dstBufferSize);
1484 const Allocation& resDstBufferAlloc = resDstBuffer->getAllocation();
1485 invalidateMappedMemoryRange(vk, device, resDstBufferAlloc.getMemory(), resDstBufferAlloc.getOffset(), dstBufferSize);
1487 return compareAndLog(refDstBufferAlloc.getHostPtr(), resDstBufferAlloc.getHostPtr(), (size_t)dstBufferSize);
1492 class GraphicsTextureTestInstance : public GraphicsAttachmentsTestInstance
1495 GraphicsTextureTestInstance (Context& context, const TestParameters& parameters);
1498 virtual bool isWriteToCompressedOperation ();
1499 void transcode (std::vector<deUint8>& srcData, std::vector<deUint8>& dstData, de::MovePtr<Image>& outputImage);
1502 GraphicsTextureTestInstance::GraphicsTextureTestInstance (Context& context, const TestParameters& parameters)
1503 : GraphicsAttachmentsTestInstance(context, parameters)
1507 bool GraphicsTextureTestInstance::isWriteToCompressedOperation ()
1509 return (m_parameters.operation == OPERATION_TEXTURE_WRITE);
1512 void GraphicsTextureTestInstance::transcode (std::vector<deUint8>& srcData, std::vector<deUint8>& dstData, de::MovePtr<Image>& outputImage)
1514 const DeviceInterface& vk = m_context.getDeviceInterface();
1515 const VkDevice device = m_context.getDevice();
1516 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
1517 const VkQueue queue = m_context.getUniversalQueue();
1518 Allocator& allocator = m_context.getDefaultAllocator();
1520 const deUint32 levelCount = m_layerSize[2];
1521 const VkImageSubresourceRange subresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, levelCount, 0u, m_arrayLayers);
1522 const UVec3 compressedImageRes = m_parameters.size;
1523 const UVec3 uncompressedImageRes = getCompressedImageResolutionInBlocks(m_parameters.formatCompressed, m_parameters.size);
1524 const VkImageCreateFlags* imgCreateFlagsOverride = DE_NULL;
1525 const VkImageViewUsageCreateInfoKHR imageViewUsageKHR = makeImageViewUsageCreateInfo(m_parameters.compressedImageUsage);
1526 const VkImageViewUsageCreateInfoKHR* imageViewUsageKHRNull = (VkImageViewUsageCreateInfoKHR*)DE_NULL;
1528 const VkFormat srcFormat = (m_parameters.operation == OPERATION_TEXTURE_READ) ? m_parameters.formatCompressed :
1529 (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? m_parameters.formatUncompressed :
1530 VK_FORMAT_UNDEFINED;
1531 const UVec3 srcImageResolution = (m_parameters.operation == OPERATION_TEXTURE_READ) ? compressedImageRes :
1532 (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? uncompressedImageRes :
1534 const VkDeviceSize srcImageSizeInBytes = (m_parameters.operation == OPERATION_TEXTURE_READ) ? getCompressedImageData(srcFormat, srcImageResolution, srcData) :
1535 (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? getUncompressedImageData(srcFormat, srcImageResolution, srcData) :
1537 const VkImageUsageFlags srcImageUsageFlags = (m_parameters.operation == OPERATION_TEXTURE_READ) ? m_parameters.compressedImageUsage :
1538 (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? m_parameters.uncompressedImageUsage :
1540 const VkImageViewUsageCreateInfoKHR* srcImageViewUsageKHR = (m_parameters.operation == OPERATION_TEXTURE_READ) ? &imageViewUsageKHR :
1541 (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? imageViewUsageKHRNull :
1542 imageViewUsageKHRNull;
1544 const VkFormat dstFormat = (m_parameters.operation == OPERATION_TEXTURE_READ) ? m_parameters.formatUncompressed :
1545 (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? m_parameters.formatCompressed :
1546 VK_FORMAT_UNDEFINED;
1547 const UVec3 dstImageResolution = (m_parameters.operation == OPERATION_TEXTURE_READ) ? uncompressedImageRes :
1548 (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? compressedImageRes :
1550 const VkDeviceSize dstImageSizeInBytes = (m_parameters.operation == OPERATION_TEXTURE_READ) ? getUncompressedImageSizeInBytes(dstFormat, dstImageResolution) :
1551 (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? getCompressedImageSizeInBytes(dstFormat, dstImageResolution) :
1553 const VkImageUsageFlags dstImageUsageFlags = (m_parameters.operation == OPERATION_TEXTURE_READ) ? m_parameters.uncompressedImageUsage :
1554 (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? m_parameters.compressedImageUsage :
1556 const VkImageViewUsageCreateInfoKHR* dstImageViewUsageKHR = (m_parameters.operation == OPERATION_TEXTURE_READ) ? imageViewUsageKHRNull :
1557 (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? &imageViewUsageKHR :
1558 imageViewUsageKHRNull;
1560 const std::vector<tcu::Vec4> vertexArray = createFullscreenQuad();
1561 const deUint32 vertexCount = static_cast<deUint32>(vertexArray.size());
1562 const size_t vertexBufferSizeInBytes = vertexCount * sizeof(vertexArray[0]);
1563 const MovePtr<Buffer> vertexBuffer = MovePtr<Buffer>(new Buffer(vk, device, allocator, makeBufferCreateInfo(vertexBufferSizeInBytes, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), MemoryRequirement::HostVisible));
1564 const Allocation& vertexBufferAlloc = vertexBuffer->getAllocation();
1565 const VkDeviceSize vertexBufferOffset[] = { 0 };
1567 const VkBufferCreateInfo srcImageBufferInfo (makeBufferCreateInfo(srcImageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_SRC_BIT));
1568 const MovePtr<Buffer> srcImageBuffer = MovePtr<Buffer>(new Buffer(vk, device, allocator, srcImageBufferInfo, MemoryRequirement::HostVisible));
1570 const VkImageCreateInfo srcImageCreateInfo = makeCreateImageInfo(srcFormat, m_parameters.imageType, srcImageResolution, srcImageUsageFlags, imgCreateFlagsOverride);
1571 const MovePtr<Image> srcImage (new Image(vk, device, allocator, srcImageCreateInfo, MemoryRequirement::Any));
1572 Move<VkImageView> srcImageView (makeImageView(vk, device, srcImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatUncompressed, subresourceRange, srcImageViewUsageKHR));
1574 const VkImageCreateInfo dstImageCreateInfo = makeCreateImageInfo(dstFormat, m_parameters.imageType, dstImageResolution, dstImageUsageFlags, imgCreateFlagsOverride);
1575 de::MovePtr<Image> dstImage (new Image(vk, device, allocator, dstImageCreateInfo, MemoryRequirement::Any));
1576 Move<VkImageView> dstImageView (makeImageView(vk, device, dstImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatUncompressed, subresourceRange, dstImageViewUsageKHR));
1577 const VkImageMemoryBarrier dstCopyImageBarrier = makeImageMemoryBarrier(0u, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, dstImage->get(), subresourceRange);
1579 const VkBufferCreateInfo dstImageBufferInfo (makeBufferCreateInfo(dstImageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT));
1580 MovePtr<Buffer> dstImageBuffer = MovePtr<Buffer>(new Buffer(vk, device, allocator, dstImageBufferInfo, MemoryRequirement::HostVisible));
1582 const Unique<VkShaderModule> vertShaderModule (createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0));
1583 const Unique<VkShaderModule> fragShaderModule (createShaderModule(vk, device, m_context.getBinaryCollection().get("frag"), 0));
1585 const Unique<VkRenderPass> renderPass (makeRenderPass(vk, device));
1587 const Move<VkDescriptorSetLayout> descriptorSetLayout (DescriptorSetLayoutBuilder()
1588 .addSingleBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT)
1589 .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_FRAGMENT_BIT)
1590 .build(vk, device));
1591 const Move<VkDescriptorPool> descriptorPool (DescriptorPoolBuilder()
1592 .addType(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, m_arrayLayers)
1593 .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, m_arrayLayers)
1594 .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, m_arrayLayers));
1595 const Move<VkDescriptorSet> descriptorSet (makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout));
1596 const VkSamplerCreateInfo srcSamplerInfo (makeSamplerCreateInfo());
1597 const Move<VkSampler> srcSampler = vk::createSampler(vk, device, &srcSamplerInfo);
1598 const VkDescriptorImageInfo descriptorSrcImage (makeDescriptorImageInfo(*srcSampler, *srcImageView, VK_IMAGE_LAYOUT_GENERAL));
1599 const VkDescriptorImageInfo descriptorDstImage (makeDescriptorImageInfo(DE_NULL, *dstImageView, VK_IMAGE_LAYOUT_GENERAL));
1601 const VkExtent2D renderSize (makeExtent2D(uncompressedImageRes[0], uncompressedImageRes[1]));
1602 const Unique<VkPipelineLayout> pipelineLayout (makePipelineLayout(vk, device, *descriptorSetLayout));
1603 const Unique<VkPipeline> pipeline (makeGraphicsPipeline(vk, device, *pipelineLayout, *renderPass, *vertShaderModule, *fragShaderModule, renderSize, 0u));
1604 const Unique<VkCommandPool> cmdPool (createCommandPool(vk, device, VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT, queueFamilyIndex));
1605 const Unique<VkCommandBuffer> cmdBuffer (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
1607 const VkBufferImageCopy srcCopyRegion = makeBufferImageCopy(srcImageResolution[0], srcImageResolution[1]);
1608 const VkBufferMemoryBarrier srcCopyBufferBarrier = makeBufferMemoryBarrier(VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, srcImageBuffer->get(), 0ull, srcImageSizeInBytes);
1609 const VkImageMemoryBarrier srcCopyImageBarrier = makeImageMemoryBarrier(0u, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, srcImage->get(), subresourceRange);
1610 const VkImageMemoryBarrier srcCopyImageBarrierPost = makeImageMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL, srcImage->get(), subresourceRange);
1612 const VkBufferImageCopy dstCopyRegion = makeBufferImageCopy(dstImageResolution[0], dstImageResolution[1]);
1614 const VkExtent2D framebufferSize (makeExtent2D(dstImageResolution[0], dstImageResolution[1]));
1615 const Move<VkFramebuffer> framebuffer (makeFramebuffer(vk, device, *renderPass, 0, DE_NULL, framebufferSize, m_arrayLayers));
1617 DE_ASSERT(srcImageSizeInBytes == dstImageSizeInBytes);
1619 // Upload vertex data
1620 deMemcpy(vertexBufferAlloc.getHostPtr(), &vertexArray[0], vertexBufferSizeInBytes);
1621 flushMappedMemoryRange(vk, device, vertexBufferAlloc.getMemory(), vertexBufferAlloc.getOffset(), vertexBufferSizeInBytes);
1623 // Upload source image data
1624 const Allocation& alloc = srcImageBuffer->getAllocation();
1625 deMemcpy(alloc.getHostPtr(), &srcData[0], (size_t)srcImageSizeInBytes);
1626 flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), srcImageSizeInBytes);
1628 beginCommandBuffer(vk, *cmdBuffer);
1629 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
1631 //Copy buffer to image
1632 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &srcCopyBufferBarrier, 1u, &srcCopyImageBarrier);
1633 vk.cmdCopyBufferToImage(*cmdBuffer, srcImageBuffer->get(), srcImage->get(), VK_IMAGE_LAYOUT_GENERAL, 1u, &srcCopyRegion);
1634 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1u, &srcCopyImageBarrierPost);
1636 // Make source image readable
1637 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &dstCopyImageBarrier);
1639 beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, renderSize);
1641 for (deUint32 layerNdx = 0; layerNdx < m_arrayLayers; ++layerNdx)
1643 DescriptorSetUpdateBuilder()
1644 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &descriptorSrcImage)
1645 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(1u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorDstImage)
1646 .update(vk, device);
1648 vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
1649 vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &vertexBuffer->get(), vertexBufferOffset);
1650 vk.cmdDraw(*cmdBuffer, vertexCount, 1, 0, 0);
1653 vk.cmdEndRenderPass(*cmdBuffer);
1655 const VkImageMemoryBarrier prepareForTransferBarrier = makeImageMemoryBarrier(
1656 VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
1657 VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL,
1658 dstImage->get(), subresourceRange);
1660 const VkBufferMemoryBarrier copyBarrier = makeBufferMemoryBarrier(
1661 VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT,
1662 dstImageBuffer->get(), 0ull, dstImageSizeInBytes);
1664 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &prepareForTransferBarrier);
1665 vk.cmdCopyImageToBuffer(*cmdBuffer, dstImage->get(), VK_IMAGE_LAYOUT_GENERAL, dstImageBuffer->get(), 1u, &dstCopyRegion);
1666 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, ©Barrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
1668 endCommandBuffer(vk, *cmdBuffer);
1670 submitCommandsAndWait(vk, device, queue, *cmdBuffer);
1672 const Allocation& dstImageBufferAlloc = dstImageBuffer->getAllocation();
1673 invalidateMappedMemoryRange(vk, device, dstImageBufferAlloc.getMemory(), dstImageBufferAlloc.getOffset(), dstImageSizeInBytes);
1674 dstData.resize((size_t)dstImageSizeInBytes);
1675 deMemcpy(&dstData[0], dstImageBufferAlloc.getHostPtr(), (size_t)dstImageSizeInBytes);
1677 outputImage = dstImage;
1681 class TexelViewCompatibleCase : public TestCase
1684 TexelViewCompatibleCase (TestContext& testCtx,
1685 const std::string& name,
1686 const std::string& desc,
1687 const TestParameters& parameters);
1688 void initPrograms (SourceCollections& programCollection) const;
1689 TestInstance* createInstance (Context& context) const;
1691 const TestParameters m_parameters;
1694 TexelViewCompatibleCase::TexelViewCompatibleCase (TestContext& testCtx, const std::string& name, const std::string& desc, const TestParameters& parameters)
1695 : TestCase (testCtx, name, desc)
1696 , m_parameters (parameters)
1700 void TexelViewCompatibleCase::initPrograms (vk::SourceCollections& programCollection) const
1702 switch (m_parameters.shader)
1704 case SHADER_TYPE_COMPUTE:
1706 const std::string imageTypeStr = getShaderImageType(mapVkFormat(m_parameters.formatUncompressed), m_parameters.imageType);
1707 const std::string formatQualifierStr = getShaderImageFormatQualifier(mapVkFormat(m_parameters.formatUncompressed));
1708 std::ostringstream src;
1709 std::ostringstream src_decompress;
1711 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
1712 << "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n\n";
1713 src_decompress << src.str();
1715 switch(m_parameters.operation)
1717 case OPERATION_IMAGE_LOAD:
1719 src << "layout (binding = 0, "<<formatQualifierStr<<") readonly uniform "<<imageTypeStr<<" u_image0;\n"
1720 << "layout (binding = 1, "<<formatQualifierStr<<") writeonly uniform "<<imageTypeStr<<" u_image1;\n\n"
1721 << "void main (void)\n"
1723 << " ivec2 pos = ivec2(gl_GlobalInvocationID.xy);\n"
1724 << " imageStore(u_image1, pos, imageLoad(u_image0, pos));\n"
1730 case OPERATION_TEXEL_FETCH:
1732 src << "layout (binding = 0) uniform "<<getGlslSamplerType(mapVkFormat(m_parameters.formatUncompressed), mapImageViewType(m_parameters.imageType))<<" u_image0;\n"
1733 << "layout (binding = 1, "<<formatQualifierStr<<") writeonly uniform "<<imageTypeStr<<" u_image1;\n\n"
1734 << "void main (void)\n"
1736 << " ivec3 pos = ivec3(gl_GlobalInvocationID.xyz);\n"
1737 << " imageStore(u_image1, pos.xy, texelFetch(u_image0, pos.xy, pos.z));\n"
1743 case OPERATION_TEXTURE:
1745 src << "layout (binding = 0) uniform "<<getGlslSamplerType(mapVkFormat(m_parameters.formatUncompressed), mapImageViewType(m_parameters.imageType))<<" u_image0;\n"
1746 << "layout (binding = 1, "<<formatQualifierStr<<") writeonly uniform "<<imageTypeStr<<" u_image1;\n\n"
1747 << "void main (void)\n"
1749 << " ivec2 pos = ivec2(gl_GlobalInvocationID.xy);\n"
1750 << " imageStore(u_image1, pos, texture(u_image0, pos));\n"
1756 case OPERATION_IMAGE_STORE:
1758 src << "layout (binding = 0, "<<formatQualifierStr<<") uniform "<<imageTypeStr<<" u_image0;\n"
1759 << "layout (binding = 1, "<<formatQualifierStr<<") readonly uniform "<<imageTypeStr<<" u_image1;\n"
1760 << "layout (binding = 2, "<<formatQualifierStr<<") writeonly uniform "<<imageTypeStr<<" u_image2;\n\n"
1761 << "void main (void)\n"
1763 << " ivec2 pos = ivec2(gl_GlobalInvocationID.xy);\n"
1764 << " imageStore(u_image0, pos, imageLoad(u_image1, pos));\n"
1765 << " imageStore(u_image2, pos, imageLoad(u_image0, pos));\n"
1775 src_decompress << "layout (binding = 0) uniform "<<getGlslSamplerType(mapVkFormat(m_parameters.formatUncompressed), mapImageViewType(m_parameters.imageType))<<" compressed_result;\n"
1776 << "layout (binding = 1) uniform "<<getGlslSamplerType(mapVkFormat(m_parameters.formatUncompressed), mapImageViewType(m_parameters.imageType))<<" compressed_reference;\n"
1777 << "layout (binding = 2, "<<formatQualifierStr<<") writeonly uniform "<<imageTypeStr<<" decompressed_result;\n"
1778 << "layout (binding = 3, "<<formatQualifierStr<<") writeonly uniform "<<imageTypeStr<<" decompressed_reference;\n\n"
1779 << "void main (void)\n"
1781 << " ivec2 pos = ivec2(gl_GlobalInvocationID.xy);\n"
1782 << " imageStore(decompressed_result, pos, texture(compressed_result, pos));\n"
1783 << " imageStore(decompressed_reference, pos, texture(compressed_reference, pos));\n"
1785 programCollection.glslSources.add("comp") << glu::ComputeSource(src.str());
1786 programCollection.glslSources.add("decompress") << glu::ComputeSource(src_decompress.str());
1791 case SHADER_TYPE_FRAGMENT:
1793 DE_ASSERT(m_parameters.size[0] > 0);
1794 DE_ASSERT(m_parameters.size[1] > 0);
1798 std::ostringstream src;
1799 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n\n"
1800 << "layout(location = 0) in vec4 v_in_position;\n"
1802 << "void main (void)\n"
1804 << " gl_Position = v_in_position;\n"
1807 programCollection.glslSources.add("vert") << glu::VertexSource(src.str());
1812 switch(m_parameters.operation)
1814 case OPERATION_ATTACHMENT_READ:
1815 case OPERATION_ATTACHMENT_WRITE:
1817 std::ostringstream src;
1819 const std::string dstTypeStr = getGlslFormatType(m_parameters.formatUncompressed);
1820 const std::string srcTypeStr = getGlslInputFormatType(m_parameters.formatUncompressed);
1822 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n\n"
1823 << "precision highp int;\n"
1824 << "precision highp float;\n"
1826 << "layout (location = 0) out highp " << dstTypeStr << " o_color;\n"
1827 << "layout (input_attachment_index = 0, set = 0, binding = 0) uniform highp " << srcTypeStr << " inputImage1;\n"
1829 << "void main (void)\n"
1831 << " o_color = " << dstTypeStr << "(subpassLoad(inputImage1));\n"
1834 programCollection.glslSources.add("frag") << glu::FragmentSource(src.str());
1839 case OPERATION_TEXTURE_READ:
1840 case OPERATION_TEXTURE_WRITE:
1842 std::ostringstream src;
1844 const std::string srcSamplerTypeStr = getGlslSamplerType(mapVkFormat(m_parameters.formatUncompressed), mapImageViewType(m_parameters.imageType));
1845 const std::string dstImageTypeStr = getShaderImageType(mapVkFormat(m_parameters.formatUncompressed), m_parameters.imageType);
1846 const std::string dstFormatQualifierStr = getShaderImageFormatQualifier(mapVkFormat(m_parameters.formatUncompressed));
1847 const UVec3 uncompressedImageRes = getCompressedImageResolutionInBlocks(m_parameters.formatCompressed, m_parameters.size);
1849 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n\n"
1850 << "layout (binding = 0) uniform " << srcSamplerTypeStr << " u_imageIn;\n"
1851 << "layout (binding = 1, " << dstFormatQualifierStr << ") writeonly uniform " << dstImageTypeStr << " u_imageOut;\n"
1853 << "void main (void)\n"
1855 << " const ivec2 out_pos = ivec2(gl_FragCoord.xy);\n"
1856 << " const ivec2 pixels_resolution = ivec2(" << uncompressedImageRes[0] - 1 << ", " << uncompressedImageRes[1] - 1 << ");\n"
1857 << " const vec2 in_pos = vec2(out_pos) / vec2(pixels_resolution);\n"
1858 << " imageStore(u_imageOut, out_pos, texture(u_imageIn, in_pos));\n"
1861 programCollection.glslSources.add("frag") << glu::FragmentSource(src.str());
1871 // Verification fragment shader
1873 switch(m_parameters.operation)
1875 case OPERATION_ATTACHMENT_WRITE:
1876 case OPERATION_TEXTURE_WRITE:
1878 std::ostringstream src;
1880 const std::string samplerType = getGlslSamplerType(mapVkFormat(m_parameters.formatForVerify), mapImageViewType(m_parameters.imageType));
1881 const std::string imageTypeStr = getShaderImageType(mapVkFormat(m_parameters.formatForVerify), m_parameters.imageType);
1882 const std::string formatQualifierStr = getShaderImageFormatQualifier(mapVkFormat(m_parameters.formatForVerify));
1884 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n\n"
1885 << "layout (binding = 0) uniform " << samplerType << " u_imageIn0;\n"
1886 << "layout (binding = 1) uniform " << samplerType << " u_imageIn1;\n"
1887 << "layout (binding = 2, " << formatQualifierStr << ") writeonly uniform " << imageTypeStr << " u_imageOut0;\n"
1888 << "layout (binding = 3, " << formatQualifierStr << ") writeonly uniform " << imageTypeStr << " u_imageOut1;\n"
1890 << "void main (void)\n"
1892 << " const ivec2 out_pos = ivec2(gl_FragCoord.xy);\n"
1893 << " const ivec2 pixels_resolution = ivec2(" << m_parameters.size[0] - 1 << ", " << m_parameters.size[1] - 1 << ");\n"
1894 << " const vec2 in_pos = vec2(out_pos) / vec2(pixels_resolution);\n"
1895 << " imageStore(u_imageOut0, out_pos, texture(u_imageIn0, in_pos));\n"
1896 << " imageStore(u_imageOut1, out_pos, texture(u_imageIn1, in_pos));\n"
1899 programCollection.glslSources.add("frag_verify") << glu::FragmentSource(src.str());
1904 case OPERATION_ATTACHMENT_READ:
1905 case OPERATION_TEXTURE_READ:
1906 // Read operations do not have sampling verification
1922 TestInstance* TexelViewCompatibleCase::createInstance (Context& context) const
1924 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
1925 const InstanceInterface& vk = context.getInstanceInterface();
1927 DE_ASSERT(getNumLayers(m_parameters.imageType, m_parameters.size) == 1u);
1928 DE_ASSERT(getLayerSize(m_parameters.imageType, m_parameters.size).z() == 1u);
1929 DE_ASSERT(getLayerSize(m_parameters.imageType, m_parameters.size).x() > 0u);
1930 DE_ASSERT(getLayerSize(m_parameters.imageType, m_parameters.size).y() > 0u);
1932 if (std::find(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_maintenance2") == context.getDeviceExtensions().end())
1933 TCU_THROW(NotSupportedError, "Extension VK_KHR_maintenance2 not supported");
1936 VkImageFormatProperties imageFormatProperties;
1938 if (VK_ERROR_FORMAT_NOT_SUPPORTED == vk.getPhysicalDeviceImageFormatProperties(physicalDevice, m_parameters.formatUncompressed,
1939 mapImageType(m_parameters.imageType), VK_IMAGE_TILING_OPTIMAL,
1940 m_parameters.uncompressedImageUsage, 0u, &imageFormatProperties))
1941 TCU_THROW(NotSupportedError, "Operation not supported with this image format");
1943 if (VK_ERROR_FORMAT_NOT_SUPPORTED == vk.getPhysicalDeviceImageFormatProperties(physicalDevice, m_parameters.formatCompressed,
1944 mapImageType(m_parameters.imageType), VK_IMAGE_TILING_OPTIMAL,
1945 VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
1946 VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR | VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT | VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR,
1947 &imageFormatProperties))
1948 TCU_THROW(NotSupportedError, "Operation not supported with this image format");
1952 const VkPhysicalDeviceFeatures physicalDeviceFeatures = getPhysicalDeviceFeatures (vk, physicalDevice);
1954 if (deInRange32(m_parameters.formatCompressed, VK_FORMAT_BC1_RGB_UNORM_BLOCK, VK_FORMAT_BC7_SRGB_BLOCK) &&
1955 !physicalDeviceFeatures.textureCompressionBC)
1956 TCU_THROW(NotSupportedError, "textureCompressionBC not supported");
1958 if (deInRange32(m_parameters.formatCompressed, VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, VK_FORMAT_EAC_R11G11_SNORM_BLOCK) &&
1959 !physicalDeviceFeatures.textureCompressionETC2)
1960 TCU_THROW(NotSupportedError, "textureCompressionETC2 not supported");
1962 if (deInRange32(m_parameters.formatCompressed, VK_FORMAT_ASTC_4x4_UNORM_BLOCK, VK_FORMAT_ASTC_12x12_SRGB_BLOCK) &&
1963 !physicalDeviceFeatures.textureCompressionASTC_LDR)
1964 TCU_THROW(NotSupportedError, "textureCompressionASTC_LDR not supported");
1967 switch (m_parameters.shader)
1969 case SHADER_TYPE_COMPUTE:
1971 switch (m_parameters.operation)
1973 case OPERATION_IMAGE_LOAD:
1974 case OPERATION_TEXEL_FETCH:
1975 case OPERATION_TEXTURE:
1976 return new BasicComputeTestInstance(context, m_parameters);
1977 case OPERATION_IMAGE_STORE:
1978 return new ImageStoreComputeTestInstance(context, m_parameters);
1980 TCU_THROW(InternalError, "Impossible");
1984 case SHADER_TYPE_FRAGMENT:
1986 switch (m_parameters.operation)
1988 case OPERATION_ATTACHMENT_READ:
1989 case OPERATION_ATTACHMENT_WRITE:
1990 return new GraphicsAttachmentsTestInstance(context, m_parameters);
1992 case OPERATION_TEXTURE_READ:
1993 case OPERATION_TEXTURE_WRITE:
1994 return new GraphicsTextureTestInstance(context, m_parameters);
1997 TCU_THROW(InternalError, "Impossible");
2002 TCU_THROW(InternalError, "Impossible");
2009 tcu::TestCaseGroup* createImageCompressionTranscodingTests (tcu::TestContext& testCtx)
2011 MovePtr<tcu::TestCaseGroup> texelViewCompatibleTests (new tcu::TestCaseGroup(testCtx, "texel_view_compatible", "Texel view compatible cases"));
2015 const VkFormat* formats;
2019 const std::string pipelineName[SHADER_TYPE_LAST] =
2025 const std::string operationName[OPERATION_LAST] =
2037 const VkImageUsageFlags baseImageUsageFlagSet = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
2038 const VkImageUsageFlags compressedImageUsageFlags[OPERATION_LAST] =
2040 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_STORAGE_BIT), // "image_load"
2041 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT), // "texel_fetch"
2042 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT), // "texture"
2043 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT), // "image_store"
2044 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT), // "attachment_read"
2045 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT), // "attachment_write"
2046 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT), // "texture_read"
2047 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT), // "texture_write"
2050 const VkImageUsageFlags uncompressedImageUsageFlags[OPERATION_LAST] =
2052 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_STORAGE_BIT), //"image_load"
2053 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT), //"texel_fetch"
2054 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT), //"texture"
2055 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT), //"image_store"
2056 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT), //"attachment_read"
2057 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT), //"attachment_write"
2058 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT), //"texture_read"
2059 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT), //"texture_write"
2062 const VkFormat compressedFormats64bit[] =
2064 VK_FORMAT_BC1_RGB_UNORM_BLOCK,
2065 VK_FORMAT_BC1_RGB_SRGB_BLOCK,
2066 VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
2067 VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
2068 VK_FORMAT_BC4_UNORM_BLOCK,
2069 VK_FORMAT_BC4_SNORM_BLOCK,
2070 VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
2071 VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
2072 VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
2073 VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
2074 VK_FORMAT_EAC_R11_UNORM_BLOCK,
2075 VK_FORMAT_EAC_R11_SNORM_BLOCK,
2078 const VkFormat compressedFormats128bit[] =
2080 VK_FORMAT_BC2_UNORM_BLOCK,
2081 VK_FORMAT_BC2_SRGB_BLOCK,
2082 VK_FORMAT_BC3_UNORM_BLOCK,
2083 VK_FORMAT_BC3_SRGB_BLOCK,
2084 VK_FORMAT_BC5_UNORM_BLOCK,
2085 VK_FORMAT_BC5_SNORM_BLOCK,
2086 VK_FORMAT_BC6H_UFLOAT_BLOCK,
2087 VK_FORMAT_BC6H_SFLOAT_BLOCK,
2088 VK_FORMAT_BC7_UNORM_BLOCK,
2089 VK_FORMAT_BC7_SRGB_BLOCK,
2090 VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
2091 VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
2092 VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
2093 VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
2094 VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
2095 VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
2096 VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
2097 VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
2098 VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
2099 VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
2100 VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
2101 VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
2102 VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
2103 VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
2104 VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
2105 VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
2106 VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
2107 VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
2108 VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
2109 VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
2110 VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
2111 VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
2112 VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
2113 VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
2114 VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
2115 VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
2116 VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
2117 VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
2118 VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
2119 VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
2120 VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
2121 VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
2124 const VkFormat uncompressedFormats64bit[] =
2126 VK_FORMAT_R16G16B16A16_UNORM,
2127 VK_FORMAT_R16G16B16A16_SNORM,
2128 VK_FORMAT_R16G16B16A16_USCALED,
2129 VK_FORMAT_R16G16B16A16_SSCALED,
2130 VK_FORMAT_R16G16B16A16_UINT,
2131 VK_FORMAT_R16G16B16A16_SINT,
2132 VK_FORMAT_R16G16B16A16_SFLOAT,
2133 VK_FORMAT_R32G32_UINT,
2134 VK_FORMAT_R32G32_SINT,
2135 VK_FORMAT_R32G32_SFLOAT,
2136 //VK_FORMAT_R64_UINT, remove from the test it couln'd not be use
2137 //VK_FORMAT_R64_SINT, remove from the test it couln'd not be use
2138 //VK_FORMAT_R64_SFLOAT, remove from the test it couln'd not be use
2141 const VkFormat uncompressedFormats128bit[] =
2143 VK_FORMAT_R32G32B32A32_UINT,
2144 VK_FORMAT_R32G32B32A32_SINT,
2145 VK_FORMAT_R32G32B32A32_SFLOAT,
2146 //VK_FORMAT_R64G64_UINT, remove from the test it couln'd not be use
2147 //VK_FORMAT_R64G64_SINT, remove from the test it couln'd not be use
2148 //VK_FORMAT_R64G64_SFLOAT, remove from the test it couln'd not be use
2151 const FormatsArray formatsCompressed[] =
2154 compressedFormats64bit,
2155 DE_LENGTH_OF_ARRAY(compressedFormats64bit)
2158 compressedFormats128bit,
2159 DE_LENGTH_OF_ARRAY(compressedFormats128bit)
2163 const FormatsArray formatsUncompressed[] =
2166 uncompressedFormats64bit,
2167 DE_LENGTH_OF_ARRAY(uncompressedFormats64bit)
2170 uncompressedFormats128bit,
2171 DE_LENGTH_OF_ARRAY(uncompressedFormats128bit)
2175 const bool mipmapTest = false; // TODO
2176 const deUint32 unniceMipmapTextureSize[] = { 1, 1, 1, 2, 6, 8, 21, 51, 92, 209, 295, 512, 1134 };
2178 DE_ASSERT(DE_LENGTH_OF_ARRAY(formatsCompressed) == DE_LENGTH_OF_ARRAY(formatsUncompressed));
2180 for (int shaderType = SHADER_TYPE_COMPUTE; shaderType < SHADER_TYPE_LAST; ++shaderType)
2182 MovePtr<tcu::TestCaseGroup> pipelineTypeGroup (new tcu::TestCaseGroup(testCtx, pipelineName[shaderType].c_str(), ""));
2184 for (int operationNdx = OPERATION_IMAGE_LOAD; operationNdx < OPERATION_LAST; ++operationNdx)
2186 if (shaderType != SHADER_TYPE_FRAGMENT && deInRange32(operationNdx, OPERATION_ATTACHMENT_READ, OPERATION_TEXTURE_WRITE))
2189 if (shaderType != SHADER_TYPE_COMPUTE && deInRange32(operationNdx, OPERATION_IMAGE_LOAD, OPERATION_IMAGE_STORE))
2192 MovePtr<tcu::TestCaseGroup> imageOperationGroup (new tcu::TestCaseGroup(testCtx, operationName[operationNdx].c_str(), ""));
2194 // Iterate through bitness groups (64 bit, 128 bit, etc)
2195 for (deUint32 formatBitnessGroup = 0; formatBitnessGroup < DE_LENGTH_OF_ARRAY(formatsCompressed); ++formatBitnessGroup)
2197 for (deUint32 formatCompressedNdx = 0; formatCompressedNdx < formatsCompressed[formatBitnessGroup].count; ++formatCompressedNdx)
2199 const VkFormat formatCompressed = formatsCompressed[formatBitnessGroup].formats[formatCompressedNdx];
2200 const std::string compressedFormatGroupName = getFormatShortString(formatCompressed);
2201 MovePtr<tcu::TestCaseGroup> compressedFormatGroup (new tcu::TestCaseGroup(testCtx, compressedFormatGroupName.c_str(), ""));
2203 for (deUint32 formatUncompressedNdx = 0; formatUncompressedNdx < formatsUncompressed[formatBitnessGroup].count; ++formatUncompressedNdx)
2205 const VkFormat formatUncompressed = formatsUncompressed[formatBitnessGroup].formats[formatUncompressedNdx];
2206 const std::string uncompressedFormatGroupName = getFormatShortString(formatUncompressed);
2207 const deUint32 testTextureWidth = mipmapTest
2208 ? unniceMipmapTextureSize[getBlockWidth(formatCompressed)]
2210 const deUint32 testTextureHeight = mipmapTest
2211 ? unniceMipmapTextureSize[getBlockWidth(formatCompressed)]
2213 const TestParameters parameters =
2215 static_cast<Operation>(operationNdx),
2216 static_cast<ShaderType>(shaderType),
2217 UVec3(testTextureWidth, testTextureHeight, 1u),
2221 (operationNdx == OPERATION_IMAGE_STORE) ? 3u : 2u,
2222 compressedImageUsageFlags[operationNdx],
2223 uncompressedImageUsageFlags[operationNdx],
2225 VK_FORMAT_R8G8B8A8_UNORM
2228 compressedFormatGroup->addChild(new TexelViewCompatibleCase(testCtx, uncompressedFormatGroupName, "", parameters));
2231 imageOperationGroup->addChild(compressedFormatGroup.release());
2235 pipelineTypeGroup->addChild(imageOperationGroup.release());
2238 texelViewCompatibleTests->addChild(pipelineTypeGroup.release());
2241 return texelViewCompatibleTests.release();