Merge vk-gl-cts/vulkan-cts-1.0.2 into vk-gl-cts/master

[platform/upstream/VK-GL-CTS.git] / external / vulkancts / modules / vulkan / api / vktApiCopiesAndBlittingTests.cpp

diff --git a/external/vulkancts/modules/vulkan/api/vktApiCopiesAndBlittingTests.cpp b/external/vulkancts/modules/vulkan/api/vktApiCopiesAndBlittingTests.cpp
index 7fc650a..6e38fdb 100644 (file)
--- a/external/vulkancts/modules/vulkan/api/vktApiCopiesAndBlittingTests.cpp
+++ b/external/vulkancts/modules/vulkan/api/vktApiCopiesAndBlittingTests.cpp
@@ -389,17 +389,21 @@ void CopiesAndBlittingTestInstance::generateBuffer (tcu::PixelBufferAccess buffe
                        case FILL_MODE_RED:
                                if (tcu::isCombinedDepthStencilType(buffer.getFormat().type))
                                {
-                                       buffer.setPixDepth(redColor[x % 4], x, y, z);
+                                       buffer.setPixDepth(redColor[0], x, y, z);
                                        if (tcu::hasStencilComponent(buffer.getFormat().order))
-                                               buffer.setPixStencil(255 * (int)redColor[y % 4], x, y, z);
+                                               buffer.setPixStencil((int)redColor[3], x, y, z);
                                }
                                else
                                        buffer.setPixel(redColor, x, y, z);
                                break;
 
                        case FILL_MODE_MULTISAMPLE:
-                               buffer.setPixel((x == y) ? tcu::Vec4(0.0, 0.5, 0.5, 1.0) : ((x > y) ? greenColor : blueColor), x, y, z);
+                       {
+                               float xScaled = static_cast<float>(x) / static_cast<float>(width);
+                               float yScaled = static_cast<float>(y) / static_cast<float>(height);
+                               buffer.setPixel((xScaled == yScaled) ? tcu::Vec4(0.0, 0.5, 0.5, 1.0) : ((xScaled > yScaled) ? greenColor : blueColor), x, y, z);
                                break;
+                       }
 
                        default:
                                break;
@@ -1044,6 +1048,31 @@ tcu::TestStatus CopyImageToImage::checkTestResult (tcu::ConstPixelBufferAccess r
                        if (!tcu::floatThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparison", m_expectedTextureLevel->getAccess(), result, fThreshold, tcu::COMPARE_LOG_RESULT))
                                return tcu::TestStatus::fail("CopiesAndBlitting test");
                }
+               else if (isSnormFormat(mapTextureFormat(result.getFormat())))
+               {
+                       // There may be an ambiguity between two possible binary representations of 1.0.
+                       // Get rid of that by expanding the data to floats and re-normalizing again.
+
+                       tcu::TextureLevel resultSnorm   (result.getFormat(), result.getWidth(), result.getHeight(), result.getDepth());
+                       {
+                               tcu::TextureLevel resultFloat   (tcu::TextureFormat(resultSnorm.getFormat().order, tcu::TextureFormat::FLOAT), resultSnorm.getWidth(), resultSnorm.getHeight(), resultSnorm.getDepth());
+
+                               tcu::copy(resultFloat.getAccess(), result);
+                               tcu::copy(resultSnorm, resultFloat.getAccess());
+                       }
+
+                       tcu::TextureLevel expectedSnorm (m_expectedTextureLevel->getFormat(), m_expectedTextureLevel->getWidth(), m_expectedTextureLevel->getHeight(), m_expectedTextureLevel->getDepth());
+
+                       {
+                               tcu::TextureLevel expectedFloat (tcu::TextureFormat(expectedSnorm.getFormat().order, tcu::TextureFormat::FLOAT), expectedSnorm.getWidth(), expectedSnorm.getHeight(), expectedSnorm.getDepth());
+
+                               tcu::copy(expectedFloat.getAccess(), m_expectedTextureLevel->getAccess());
+                               tcu::copy(expectedSnorm, expectedFloat.getAccess());
+                       }
+
+                       if (!tcu::intThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparison", expectedSnorm.getAccess(), resultSnorm.getAccess(), uThreshold, tcu::COMPARE_LOG_RESULT))
+                               return tcu::TestStatus::fail("CopiesAndBlitting test");
+               }
                else
                {
                        if (!tcu::intThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparison", m_expectedTextureLevel->getAccess(), result, uThreshold, tcu::COMPARE_LOG_RESULT))
@@ -1896,8 +1925,8 @@ tcu::TestStatus BlittingImages::iterate (void)
 
        VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
        vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &srcImageBarrier);
+       vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &dstImageBarrier);
        vk.cmdBlitImage(*m_cmdBuffer, m_source.get(), m_params.src.image.operationLayout, m_destination.get(), m_params.dst.image.operationLayout, (deUint32)m_params.regions.size(), &regions[0], m_params.filter);
-       vk.cmdPipelineBarrier(*m_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, 1, &dstImageBarrier);
        VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
        submitCommandsAndWait(vk, vkDevice, queue, *m_cmdBuffer);
 
@@ -3109,20 +3138,20 @@ tcu::TestStatus ResolveImageToImage::iterate (void)
        const tcu::TextureFormat                dstTcuFormat            = mapVkFormat(m_params.dst.image.format);
 
        // upload the destination image
-               m_destinationTextureLevel       = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dstTcuFormat,
-                                                                                                                                                               (int)m_params.dst.image.extent.width,
-                                                                                                                                                               (int)m_params.dst.image.extent.height,
-                                                                                                                                                               (int)m_params.dst.image.extent.depth));
-               generateBuffer(m_destinationTextureLevel->getAccess(), m_params.dst.image.extent.width, m_params.dst.image.extent.height, m_params.dst.image.extent.depth);
-               uploadImage(m_destinationTextureLevel->getAccess(), m_destination.get(), m_params.dst.image);
+       m_destinationTextureLevel       = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dstTcuFormat,
+                                                                                                                                                       (int)m_params.dst.image.extent.width,
+                                                                                                                                                       (int)m_params.dst.image.extent.height,
+                                                                                                                                                       (int)m_params.dst.image.extent.depth));
+       generateBuffer(m_destinationTextureLevel->getAccess(), m_params.dst.image.extent.width, m_params.dst.image.extent.height, m_params.dst.image.extent.depth);
+       uploadImage(m_destinationTextureLevel->getAccess(), m_destination.get(), m_params.dst.image);
 
-               m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(srcTcuFormat,
-                                                                                                                                               (int)m_params.src.image.extent.width,
-                                                                                                                                               (int)m_params.src.image.extent.height,
-                                                                                                                                               (int)m_params.dst.image.extent.depth));
+       m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(srcTcuFormat,
+                                                                                                                                       (int)m_params.src.image.extent.width,
+                                                                                                                                       (int)m_params.src.image.extent.height,
+                                                                                                                                       (int)m_params.dst.image.extent.depth));
 
-               generateBuffer(m_sourceTextureLevel->getAccess(), m_params.src.image.extent.width, m_params.src.image.extent.height, m_params.dst.image.extent.depth, FILL_MODE_MULTISAMPLE);
-               generateExpectedResult();
+       generateBuffer(m_sourceTextureLevel->getAccess(), m_params.src.image.extent.width, m_params.src.image.extent.height, m_params.dst.image.extent.depth, FILL_MODE_MULTISAMPLE);
+       generateExpectedResult();
 
        switch (m_options)
        {
@@ -3160,7 +3189,7 @@ tcu::TestStatus ResolveImageToImage::iterate (void)
                                0u,                                                                     // deUint32                             baseMipLevel;
                                1u,                                                                     // deUint32                             mipLevels;
                                0u,                                                                     // deUint32                             baseArraySlice;
-                               getArraySize(m_params.dst.image)        // deUint32                             arraySize;
+                               getArraySize(m_params.src.image)        // deUint32                             arraySize;
                        }
                },
                // destination image
@@ -3295,7 +3324,7 @@ void ResolveImageToImage::copyMSImageToMSImage (void)
 
        const VkImageMemoryBarrier              imageBarriers[]         =
        {
-               //// source image
+               // source image
                {
                        VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
                        DE_NULL,                                                                        // const void*                          pNext;
@@ -4206,6 +4235,7 @@ void addImageToImage3dImagesTests (tcu::TestCaseGroup* group, AllocationKind all
                params3DTo2D.dst.image.operationLayout  = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
                params3DTo2D.allocationKind                             = allocationKind;
 
+               for (deUint32 slicesLayersNdx = 0; slicesLayersNdx < slicesLayers; ++slicesLayersNdx)
                {
                        const VkImageSubresourceLayers  sourceLayer     =
                        {
@@ -4619,6 +4649,7 @@ void addBufferToBufferTests (tcu::TestCaseGroup* group, AllocationKind allocatio
                group->addChild(new BufferToBufferTestCase(testCtx, "whole", "Whole buffer", params));
        }
 
+       // Filter is VK_FILTER_NEAREST.
        {
                TestParams                      params;
                params.src.buffer.size  = defaultFourthSize;
@@ -4992,7 +5023,6 @@ void addBlittingImageSimpleMirrorSubregionsTests (tcu::TestCaseGroup* group, All
                                {defaultSize, 0, 1}
                        }                                       // VkOffset3D                           dstOffset[2];
                };
-
                CopyRegion      region;
                region.imageBlit = imageBlit;
                params.regions.push_back(region);