external/vulkancts/modules/vulkan/pipeline/vktPipelineImageUtil.cpp

   1 /*------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2015 The Khronos Group Inc.
   6  * Copyright (c) 2015 Imagination Technologies Ltd.
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  *//*!
  21  * \file
  22  * \brief Utilities for images.
  23  *//*--------------------------------------------------------------------*/
  24
  25 #include "vktPipelineImageUtil.hpp"
  26 #include "vkImageUtil.hpp"
  27 #include "vkMemUtil.hpp"
  28 #include "vkQueryUtil.hpp"
  29 #include "vkRefUtil.hpp"
  30 #include "tcuTextureUtil.hpp"
  31 #include "tcuAstcUtil.hpp"
  32 #include "deRandom.hpp"
  33
  34 namespace vkt
  35 {
  36 namespace pipeline
  37 {
  38
  39 using namespace vk;
  40
  41 /*! Gets the next multiple of a given divisor */
  42 static deUint32 getNextMultiple (deUint32 divisor, deUint32 value)
  43 {
  44         if (value % divisor == 0)
  45         {
  46                 return value;
  47         }
  48         return value + divisor - (value % divisor);
  49 }
  50
  51 /*! Gets the next value that is multiple of all given divisors */
  52 static deUint32 getNextMultiple (const std::vector<deUint32>& divisors, deUint32 value)
  53 {
  54         deUint32        nextMultiple            = value;
  55         bool            nextMultipleFound       = false;
  56
  57         while (true)
  58         {
  59                 nextMultipleFound = true;
  60
  61                 for (size_t divNdx = 0; divNdx < divisors.size(); divNdx++)
  62                         nextMultipleFound = nextMultipleFound && (nextMultiple % divisors[divNdx] == 0);
  63
  64                 if (nextMultipleFound)
  65                         break;
  66
  67                 DE_ASSERT(nextMultiple < ~((deUint32)0u));
  68                 nextMultiple = getNextMultiple(divisors[0], nextMultiple + 1);
  69         }
  70
  71         return nextMultiple;
  72 }
  73
  74 bool isSupportedSamplableFormat (const InstanceInterface& instanceInterface, VkPhysicalDevice device, VkFormat format)
  75 {
  76         if (isCompressedFormat(format))
  77         {
  78                 VkPhysicalDeviceFeatures                physicalFeatures;
  79                 const tcu::CompressedTexFormat  compressedFormat        = mapVkCompressedFormat(format);
  80
  81                 instanceInterface.getPhysicalDeviceFeatures(device, &physicalFeatures);
  82
  83                 if (tcu::isAstcFormat(compressedFormat))
  84                 {
  85                         if (!physicalFeatures.textureCompressionASTC_LDR)
  86                                 return false;
  87                 }
  88                 else if (tcu::isEtcFormat(compressedFormat))
  89                 {
  90                         if (!physicalFeatures.textureCompressionETC2)
  91                                 return false;
  92                 }
  93                 else
  94                 {
  95                         DE_FATAL("Unsupported compressed format");
  96                 }
  97         }
  98
  99         VkFormatProperties      formatProps;
 100         instanceInterface.getPhysicalDeviceFormatProperties(device, format, &formatProps);
 101
 102         return (formatProps.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) != 0u;
 103 }
 104
 105 // \todo [2016-01-21 pyry] Update this to just rely on vkDefs.hpp once
 106 //                                                 CTS has been updated to 1.0.2.
 107 enum
 108 {
 109         VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000,
 110 };
 111
 112 bool isLinearFilteringSupported (const InstanceInterface& vki, VkPhysicalDevice physicalDevice, VkFormat format, VkImageTiling tiling)
 113 {
 114         const VkFormatProperties        formatProperties        = getPhysicalDeviceFormatProperties(vki, physicalDevice, format);
 115         const VkFormatFeatureFlags      formatFeatures          = tiling == VK_IMAGE_TILING_LINEAR
 116                                                                                                         ? formatProperties.linearTilingFeatures
 117                                                                                                         : formatProperties.optimalTilingFeatures;
 118
 119         switch (format)
 120         {
 121                 case VK_FORMAT_R32_SFLOAT:
 122                 case VK_FORMAT_R32G32_SFLOAT:
 123                 case VK_FORMAT_R32G32B32_SFLOAT:
 124                 case VK_FORMAT_R32G32B32A32_SFLOAT:
 125                 case VK_FORMAT_R64_SFLOAT:
 126                 case VK_FORMAT_R64G64_SFLOAT:
 127                 case VK_FORMAT_R64G64B64_SFLOAT:
 128                 case VK_FORMAT_R64G64B64A64_SFLOAT:
 129                         return (formatFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT) != 0;
 130
 131                 default:
 132                         // \todo [2016-01-21 pyry] Check for all formats once drivers have been updated to 1.0.2
 133                         //                                                 and we have tests to verify format properties.
 134                         return true;
 135         }
 136 }
 137
 138 VkBorderColor getFormatBorderColor (BorderColor color, VkFormat format)
 139 {
 140         if (!isCompressedFormat(format) && (isIntFormat(format) || isUintFormat(format)))
 141         {
 142                 switch (color)
 143                 {
 144                         case BORDER_COLOR_OPAQUE_BLACK:                 return VK_BORDER_COLOR_INT_OPAQUE_BLACK;
 145                         case BORDER_COLOR_OPAQUE_WHITE:                 return VK_BORDER_COLOR_INT_OPAQUE_WHITE;
 146                         case BORDER_COLOR_TRANSPARENT_BLACK:    return VK_BORDER_COLOR_INT_TRANSPARENT_BLACK;
 147                         default:
 148                                 break;
 149                 }
 150         }
 151         else
 152         {
 153                 switch (color)
 154                 {
 155                         case BORDER_COLOR_OPAQUE_BLACK:                 return VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK;
 156                         case BORDER_COLOR_OPAQUE_WHITE:                 return VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
 157                         case BORDER_COLOR_TRANSPARENT_BLACK:    return VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
 158                         default:
 159                                 break;
 160                 }
 161         }
 162
 163         DE_ASSERT(false);
 164         return VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
 165 }
 166
 167 de::MovePtr<tcu::TextureLevel> readColorAttachment (const vk::DeviceInterface&  vk,
 168                                                                                                         vk::VkDevice                            device,
 169                                                                                                         vk::VkQueue                                     queue,
 170                                                                                                         deUint32                                        queueFamilyIndex,
 171                                                                                                         vk::Allocator&                          allocator,
 172                                                                                                         vk::VkImage                                     image,
 173                                                                                                         vk::VkFormat                            format,
 174                                                                                                         const tcu::UVec2&                       renderSize)
 175 {
 176         Move<VkBuffer>                                  buffer;
 177         de::MovePtr<Allocation>                 bufferAlloc;
 178         Move<VkCommandPool>                             cmdPool;
 179         Move<VkCommandBuffer>                   cmdBuffer;
 180         Move<VkFence>                                   fence;
 181         const tcu::TextureFormat                tcuFormat               = mapVkFormat(format);
 182         const VkDeviceSize                              pixelDataSize   = renderSize.x() * renderSize.y() * tcuFormat.getPixelSize();
 183         de::MovePtr<tcu::TextureLevel>  resultLevel             (new tcu::TextureLevel(tcuFormat, renderSize.x(), renderSize.y()));
 184
 185         // Create destination buffer
 186         {
 187                 const VkBufferCreateInfo bufferParams =
 188                 {
 189                         VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,           // VkStructureType              sType;
 190                         DE_NULL,                                                                        // const void*                  pNext;
 191                         0u,                                                                                     // VkBufferCreateFlags  flags;
 192                         pixelDataSize,                                                          // VkDeviceSize                 size;
 193                         VK_BUFFER_USAGE_TRANSFER_DST_BIT,                       // VkBufferUsageFlags   usage;
 194                         VK_SHARING_MODE_EXCLUSIVE,                                      // VkSharingMode                sharingMode;
 195                         0u,                                                                                     // deUint32                             queueFamilyIndexCount;
 196                         DE_NULL                                                                         // const deUint32*              pQueueFamilyIndices;
 197                 };
 198
 199                 buffer          = createBuffer(vk, device, &bufferParams);
 200                 bufferAlloc = allocator.allocate(getBufferMemoryRequirements(vk, device, *buffer), MemoryRequirement::HostVisible);
 201                 VK_CHECK(vk.bindBufferMemory(device, *buffer, bufferAlloc->getMemory(), bufferAlloc->getOffset()));
 202         }
 203
 204         // Create command pool and buffer
 205         {
 206                 const VkCommandPoolCreateInfo cmdPoolParams =
 207                 {
 208                         VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,             // VkStructureType              sType;
 209                         DE_NULL,                                                                                // const void*                  pNext;
 210                         VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,                   // VkCmdPoolCreateFlags flags;
 211                         queueFamilyIndex,                                                               // deUint32                             queueFamilyIndex;
 212                 };
 213
 214                 cmdPool = createCommandPool(vk, device, &cmdPoolParams);
 215
 216                 const VkCommandBufferAllocateInfo cmdBufferAllocateInfo =
 217                 {
 218                         VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType                      sType;
 219                         DE_NULL,                                                                                // const void*                          pNext;
 220                         *cmdPool,                                                                               // VkCommandPool                        commandPool;
 221                         VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                // VkCommandBufferLevel         level;
 222                         1u                                                                                              // deUint32                                     bufferCount;
 223                 };
 224
 225                 cmdBuffer = allocateCommandBuffer(vk, device, &cmdBufferAllocateInfo);
 226         }
 227
 228         // Create fence
 229         {
 230                 const VkFenceCreateInfo fenceParams =
 231                 {
 232                         VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,            // VkStructureType              sType;
 233                         DE_NULL,                                                                        // const void*                  pNext;
 234                         0u                                                                                      // VkFenceCreateFlags   flags;
 235                 };
 236
 237                 fence = createFence(vk, device, &fenceParams);
 238         }
 239
 240         // Barriers for copying image to buffer
 241
 242         const VkImageMemoryBarrier imageBarrier =
 243         {
 244                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
 245                 DE_NULL,                                                                        // const void*                          pNext;
 246                 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,           // VkAccessFlags                        srcAccessMask;
 247                 VK_ACCESS_TRANSFER_READ_BIT,                            // VkAccessFlags                        dstAccessMask;
 248                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,       // VkImageLayout                        oldLayout;
 249                 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,           // VkImageLayout                        newLayout;
 250                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
 251                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     dstQueueFamilyIndex;
 252                 image,                                                                          // VkImage                                      image;
 253                 {                                                                                       // VkImageSubresourceRange      subresourceRange;
 254                         VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
 255                         0u,                                                     // deUint32                             baseMipLevel;
 256                         1u,                                                     // deUint32                             mipLevels;
 257                         0u,                                                     // deUint32                             baseArraySlice;
 258                         1u                                                      // deUint32                             arraySize;
 259                 }
 260         };
 261
 262         const VkBufferMemoryBarrier bufferBarrier =
 263         {
 264                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,        // VkStructureType      sType;
 265                 DE_NULL,                                                                        // const void*          pNext;
 266                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags        srcAccessMask;
 267                 VK_ACCESS_HOST_READ_BIT,                                        // VkAccessFlags        dstAccessMask;
 268                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     srcQueueFamilyIndex;
 269                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     dstQueueFamilyIndex;
 270                 *buffer,                                                                        // VkBuffer                     buffer;
 271                 0u,                                                                                     // VkDeviceSize         offset;
 272                 pixelDataSize                                                           // VkDeviceSize         size;
 273         };
 274
 275         const VkCommandBufferBeginInfo cmdBufferBeginInfo =
 276         {
 277                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                    // VkStructureType                                      sType;
 278                 DE_NULL,                                                                                                // const void*                                          pNext;
 279                 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,                    // VkCommandBufferUsageFlags            flags;
 280                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
 281         };
 282
 283         // Copy image to buffer
 284
 285         const VkBufferImageCopy copyRegion =
 286         {
 287                 0u,                                                                                             // VkDeviceSize                         bufferOffset;
 288                 (deUint32)renderSize.x(),                                               // deUint32                                     bufferRowLength;
 289                 (deUint32)renderSize.y(),                                               // deUint32                                     bufferImageHeight;
 290                 { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u },              // VkImageSubresourceLayers     imageSubresource;
 291                 { 0, 0, 0 },                                                                    // VkOffset3D                           imageOffset;
 292                 { renderSize.x(), renderSize.y(), 1u }                  // VkExtent3D                           imageExtent;
 293         };
 294
 295         VK_CHECK(vk.beginCommandBuffer(*cmdBuffer, &cmdBufferBeginInfo));
 296         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, &imageBarrier);
 297         vk.cmdCopyImageToBuffer(*cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *buffer, 1, &copyRegion);
 298         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &bufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
 299         VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
 300
 301         const VkSubmitInfo submitInfo =
 302         {
 303                 VK_STRUCTURE_TYPE_SUBMIT_INFO,  // VkStructureType                      sType;
 304                 DE_NULL,                                                // const void*                          pNext;
 305                 0u,                                                             // deUint32                                     waitSemaphoreCount;
 306                 DE_NULL,                                                // const VkSemaphore*           pWaitSemaphores;
 307                 DE_NULL,
 308                 1u,                                                             // deUint32                                     commandBufferCount;
 309                 &cmdBuffer.get(),                               // const VkCommandBuffer*       pCommandBuffers;
 310                 0u,                                                             // deUint32                                     signalSemaphoreCount;
 311                 DE_NULL                                                 // const VkSemaphore*           pSignalSemaphores;
 312         };
 313
 314         VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
 315         VK_CHECK(vk.waitForFences(device, 1, &fence.get(), 0, ~(0ull) /* infinity */));
 316
 317         // Read buffer data
 318         invalidateMappedMemoryRange(vk, device, bufferAlloc->getMemory(), bufferAlloc->getOffset(), pixelDataSize);
 319         tcu::copy(*resultLevel, tcu::ConstPixelBufferAccess(resultLevel->getFormat(), resultLevel->getSize(), bufferAlloc->getHostPtr()));
 320
 321         return resultLevel;
 322 }
 323
 324 void uploadTestTexture (const DeviceInterface&                  vk,
 325                                                 VkDevice                                                device,
 326                                                 VkQueue                                                 queue,
 327                                                 deUint32                                                queueFamilyIndex,
 328                                                 Allocator&                                              allocator,
 329                                                 const TestTexture&                              srcTexture,
 330                                                 VkImage                                                 destImage)
 331 {
 332         deUint32                                                bufferSize;
 333         Move<VkBuffer>                                  buffer;
 334         de::MovePtr<Allocation>                 bufferAlloc;
 335         Move<VkCommandPool>                             cmdPool;
 336         Move<VkCommandBuffer>                   cmdBuffer;
 337         Move<VkFence>                                   fence;
 338         std::vector<deUint32>                   levelDataSizes;
 339
 340         // Calculate buffer size
 341         bufferSize =  (srcTexture.isCompressed())? srcTexture.getCompressedSize(): srcTexture.getSize();
 342
 343         // Create source buffer
 344         {
 345                 const VkBufferCreateInfo bufferParams =
 346                 {
 347                         VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,           // VkStructureType              sType;
 348                         DE_NULL,                                                                        // const void*                  pNext;
 349                         0u,                                                                                     // VkBufferCreateFlags  flags;
 350                         bufferSize,                                                                     // VkDeviceSize                 size;
 351                         VK_BUFFER_USAGE_TRANSFER_SRC_BIT,                       // VkBufferUsageFlags   usage;
 352                         VK_SHARING_MODE_EXCLUSIVE,                                      // VkSharingMode                sharingMode;
 353                         0u,                                                                                     // deUint32                             queueFamilyIndexCount;
 354                         DE_NULL,                                                                        // const deUint32*              pQueueFamilyIndices;
 355                 };
 356
 357                 buffer          = createBuffer(vk, device, &bufferParams);
 358                 bufferAlloc = allocator.allocate(getBufferMemoryRequirements(vk, device, *buffer), MemoryRequirement::HostVisible);
 359                 VK_CHECK(vk.bindBufferMemory(device, *buffer, bufferAlloc->getMemory(), bufferAlloc->getOffset()));
 360         }
 361
 362         // Create command pool and buffer
 363         {
 364                 const VkCommandPoolCreateInfo cmdPoolParams =
 365                 {
 366                         VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,             // VkStructureType                      sType;
 367                         DE_NULL,                                                                                // const void*                          pNext;
 368                         VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,                   // VkCommandPoolCreateFlags     flags;
 369                         queueFamilyIndex,                                                               // deUint32                                     queueFamilyIndex;
 370                 };
 371
 372                 cmdPool = createCommandPool(vk, device, &cmdPoolParams);
 373
 374                 const VkCommandBufferAllocateInfo cmdBufferAllocateInfo =
 375                 {
 376                         VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType                      sType;
 377                         DE_NULL,                                                                                // const void*                          pNext;
 378                         *cmdPool,                                                                               // VkCommandPool                        commandPool;
 379                         VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                // VkCommandBufferLevel         level;
 380                         1u,                                                                                             // deUint32                                     bufferCount;
 381                 };
 382
 383                 cmdBuffer = allocateCommandBuffer(vk, device, &cmdBufferAllocateInfo);
 384         }
 385
 386         // Create fence
 387         {
 388                 const VkFenceCreateInfo fenceParams =
 389                 {
 390                         VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,            // VkStructureType              sType;
 391                         DE_NULL,                                                                        // const void*                  pNext;
 392                         0u                                                                                      // VkFenceCreateFlags   flags;
 393                 };
 394
 395                 fence = createFence(vk, device, &fenceParams);
 396         }
 397
 398         // Barriers for copying buffer to image
 399         const VkBufferMemoryBarrier preBufferBarrier =
 400         {
 401                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,        // VkStructureType      sType;
 402                 DE_NULL,                                                                        // const void*          pNext;
 403                 VK_ACCESS_HOST_WRITE_BIT,                                       // VkAccessFlags        srcAccessMask;
 404                 VK_ACCESS_TRANSFER_READ_BIT,                            // VkAccessFlags        dstAccessMask;
 405                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     srcQueueFamilyIndex;
 406                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     dstQueueFamilyIndex;
 407                 *buffer,                                                                        // VkBuffer                     buffer;
 408                 0u,                                                                                     // VkDeviceSize         offset;
 409                 bufferSize                                                                      // VkDeviceSize         size;
 410         };
 411
 412         const VkImageMemoryBarrier preImageBarrier =
 413         {
 414                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                 // VkStructureType                      sType;
 415                 DE_NULL,                                                                                // const void*                          pNext;
 416                 0u,                                                                                             // VkAccessFlags                        srcAccessMask;
 417                 VK_ACCESS_TRANSFER_WRITE_BIT,                                   // VkAccessFlags                        dstAccessMask;
 418                 VK_IMAGE_LAYOUT_UNDEFINED,                                              // VkImageLayout                        oldLayout;
 419                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                   // VkImageLayout                        newLayout;
 420                 VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                                     srcQueueFamilyIndex;
 421                 VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                                     dstQueueFamilyIndex;
 422                 destImage,                                                                              // VkImage                                      image;
 423                 {                                                                                               // VkImageSubresourceRange      subresourceRange;
 424                         VK_IMAGE_ASPECT_COLOR_BIT,                              // VkImageAspect        aspect;
 425                         0u,                                                                             // deUint32                     baseMipLevel;
 426                         (deUint32)srcTexture.getNumLevels(),    // deUint32                     mipLevels;
 427                         0u,                                                                             // deUint32                     baseArraySlice;
 428                         (deUint32)srcTexture.getArraySize(),    // deUint32                     arraySize;
 429                 }
 430         };
 431
 432         const VkImageMemoryBarrier postImageBarrier =
 433         {
 434                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                 // VkStructureType                      sType;
 435                 DE_NULL,                                                                                // const void*                          pNext;
 436                 VK_ACCESS_TRANSFER_WRITE_BIT,                                   // VkAccessFlags                        srcAccessMask;
 437                 VK_ACCESS_SHADER_READ_BIT,                                              // VkAccessFlags                        dstAccessMask;
 438                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                   // VkImageLayout                        oldLayout;
 439                 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,               // VkImageLayout                        newLayout;
 440                 VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                                     srcQueueFamilyIndex;
 441                 VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                                     dstQueueFamilyIndex;
 442                 destImage,                                                                              // VkImage                                      image;
 443                 {                                                                                               // VkImageSubresourceRange      subresourceRange;
 444                         VK_IMAGE_ASPECT_COLOR_BIT,                              // VkImageAspect        aspect;
 445                         0u,                                                                             // deUint32                     baseMipLevel;
 446                         (deUint32)srcTexture.getNumLevels(),    // deUint32                     mipLevels;
 447                         0u,                                                                             // deUint32                     baseArraySlice;
 448                         (deUint32)srcTexture.getArraySize(),    // deUint32                     arraySize;
 449                 }
 450         };
 451
 452         const VkCommandBufferBeginInfo cmdBufferBeginInfo =
 453         {
 454                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,    // VkStructureType                                      sType;
 455                 DE_NULL,                                                                                // const void*                                          pNext;
 456                 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,    // VkCommandBufferUsageFlags            flags;
 457                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
 458         };
 459
 460         const std::vector<VkBufferImageCopy>    copyRegions             = srcTexture.getBufferCopyRegions();
 461
 462         // Write buffer data
 463         srcTexture.write(reinterpret_cast<deUint8*>(bufferAlloc->getHostPtr()));
 464         flushMappedMemoryRange(vk, device, bufferAlloc->getMemory(), bufferAlloc->getOffset(), bufferSize);
 465
 466         // Copy buffer to image
 467         VK_CHECK(vk.beginCommandBuffer(*cmdBuffer, &cmdBufferBeginInfo));
 468         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &preBufferBarrier, 1, &preImageBarrier);
 469         vk.cmdCopyBufferToImage(*cmdBuffer, *buffer, destImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, (deUint32)copyRegions.size(), copyRegions.data());
 470         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, 1, &postImageBarrier);
 471
 472         VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
 473
 474         const VkSubmitInfo submitInfo =
 475         {
 476                 VK_STRUCTURE_TYPE_SUBMIT_INFO,  // VkStructureType                      sType;
 477                 DE_NULL,                                                // const void*                          pNext;
 478                 0u,                                                             // deUint32                                     waitSemaphoreCount;
 479                 DE_NULL,                                                // const VkSemaphore*           pWaitSemaphores;
 480                 DE_NULL,
 481                 1u,                                                             // deUint32                                     commandBufferCount;
 482                 &cmdBuffer.get(),                               // const VkCommandBuffer*       pCommandBuffers;
 483                 0u,                                                             // deUint32                                     signalSemaphoreCount;
 484                 DE_NULL                                                 // const VkSemaphore*           pSignalSemaphores;
 485         };
 486
 487         VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
 488         VK_CHECK(vk.waitForFences(device, 1, &fence.get(), true, ~(0ull) /* infinity */));
 489 }
 490
 491
 492 // Utilities for test textures
 493
 494 template<typename TcuTextureType>
 495 void allocateLevels (TcuTextureType& texture)
 496 {
 497         for (int levelNdx = 0; levelNdx < texture.getNumLevels(); levelNdx++)
 498                 texture.allocLevel(levelNdx);
 499 }
 500
 501 template<typename TcuTextureType>
 502 std::vector<tcu::PixelBufferAccess> getLevelsVector (const TcuTextureType& texture)
 503 {
 504         std::vector<tcu::PixelBufferAccess> levels(texture.getNumLevels());
 505
 506         for (int levelNdx = 0; levelNdx < texture.getNumLevels(); levelNdx++)
 507                 levels[levelNdx] = *reinterpret_cast<const tcu::PixelBufferAccess*>(&texture.getLevel(levelNdx));
 508
 509         return levels;
 510 }
 511
 512
 513 // TestTexture
 514
 515 TestTexture::TestTexture (const tcu::TextureFormat& format, int width, int height, int depth)
 516 {
 517         DE_ASSERT(width >= 1);
 518         DE_ASSERT(height >= 1);
 519         DE_ASSERT(depth >= 1);
 520
 521         DE_UNREF(format);
 522         DE_UNREF(width);
 523         DE_UNREF(height);
 524         DE_UNREF(depth);
 525 }
 526
 527 TestTexture::TestTexture (const tcu::CompressedTexFormat& format, int width, int height, int depth)
 528 {
 529         DE_ASSERT(width >= 1);
 530         DE_ASSERT(height >= 1);
 531         DE_ASSERT(depth >= 1);
 532
 533         DE_UNREF(format);
 534         DE_UNREF(width);
 535         DE_UNREF(height);
 536         DE_UNREF(depth);
 537 }
 538
 539 TestTexture::~TestTexture (void)
 540 {
 541         for (size_t levelNdx = 0; levelNdx < m_compressedLevels.size(); levelNdx++)
 542                 delete m_compressedLevels[levelNdx];
 543 }
 544
 545 deUint32 TestTexture::getSize (void) const
 546 {
 547         std::vector<deUint32>   offsetMultiples;
 548         deUint32                                textureSize = 0;
 549
 550         offsetMultiples.push_back(4);
 551         offsetMultiples.push_back(getLevel(0, 0).getFormat().getPixelSize());
 552
 553         for (int levelNdx = 0; levelNdx < getNumLevels(); levelNdx++)
 554         {
 555                 for (int layerNdx = 0; layerNdx < getArraySize(); layerNdx++)
 556                 {
 557                         const tcu::ConstPixelBufferAccess level = getLevel(levelNdx, layerNdx);
 558                         textureSize = getNextMultiple(offsetMultiples, textureSize);
 559                         textureSize += level.getWidth() * level.getHeight() * level.getDepth() * level.getFormat().getPixelSize();
 560                 }
 561         }
 562
 563         return textureSize;
 564 }
 565
 566 deUint32 TestTexture::getCompressedSize (void) const
 567 {
 568         if (!isCompressed())
 569                 throw tcu::InternalError("Texture is not compressed");
 570
 571         std::vector<deUint32>   offsetMultiples;
 572         deUint32                                textureSize                     = 0;
 573
 574         offsetMultiples.push_back(4);
 575         offsetMultiples.push_back(tcu::getBlockSize(getCompressedLevel(0, 0).getFormat()));
 576
 577         for (int levelNdx = 0; levelNdx < getNumLevels(); levelNdx++)
 578         {
 579                 for (int layerNdx = 0; layerNdx < getArraySize(); layerNdx++)
 580                 {
 581                         textureSize = getNextMultiple(offsetMultiples, textureSize);
 582                         textureSize += getCompressedLevel(levelNdx, layerNdx).getDataSize();
 583                 }
 584         }
 585
 586         return textureSize;
 587 }
 588
 589 tcu::CompressedTexture& TestTexture::getCompressedLevel (int level, int layer)
 590 {
 591         DE_ASSERT(level >= 0 && level < getNumLevels());
 592         DE_ASSERT(layer >= 0 && layer < getArraySize());
 593
 594         return *m_compressedLevels[level * getArraySize() + layer];
 595 }
 596
 597 const tcu::CompressedTexture& TestTexture::getCompressedLevel (int level, int layer) const
 598 {
 599         DE_ASSERT(level >= 0 && level < getNumLevels());
 600         DE_ASSERT(layer >= 0 && layer < getArraySize());
 601
 602         return *m_compressedLevels[level * getArraySize() + layer];
 603 }
 604
 605 std::vector<VkBufferImageCopy> TestTexture::getBufferCopyRegions (void) const
 606 {
 607         std::vector<deUint32>                   offsetMultiples;
 608         std::vector<VkBufferImageCopy>  regions;
 609         deUint32                                                layerDataOffset = 0;
 610
 611         offsetMultiples.push_back(4);
 612
 613         if (isCompressed())
 614         {
 615                 offsetMultiples.push_back(tcu::getBlockSize(getCompressedLevel(0, 0).getFormat()));
 616
 617                 for (int levelNdx = 0; levelNdx < getNumLevels(); levelNdx++)
 618                 {
 619                         for (int layerNdx = 0; layerNdx < getArraySize(); layerNdx++)
 620                         {
 621                                 const tcu::CompressedTexture& level = getCompressedLevel(levelNdx, layerNdx);
 622                                 tcu::IVec3 blockPixelSize                       = getBlockPixelSize(level.getFormat());
 623                                 layerDataOffset                                         = getNextMultiple(offsetMultiples, layerDataOffset);
 624
 625                                 const VkBufferImageCopy layerRegion =
 626                                 {
 627                                         layerDataOffset,                                                                                                        // VkDeviceSize                         bufferOffset;
 628                                         (deUint32)getNextMultiple(blockPixelSize.x(), level.getWidth()),        // deUint32                                     bufferRowLength;
 629                                         (deUint32)getNextMultiple(blockPixelSize.y(), level.getHeight()),       // deUint32                                     bufferImageHeight;
 630                                         {                                                                                                                                       // VkImageSubresourceLayers     imageSubresource;
 631                                                 VK_IMAGE_ASPECT_COLOR_BIT,
 632                                                 (deUint32)levelNdx,
 633                                                 (deUint32)layerNdx,
 634                                                 1u
 635                                         },
 636                                         { 0u, 0u, 0u },                                                 // VkOffset3D                           imageOffset;
 637                                         {                                                                               // VkExtent3D                           imageExtent;
 638                                                 (deUint32)level.getWidth(),
 639                                                 (deUint32)level.getHeight(),
 640                                                 (deUint32)level.getDepth()
 641                                         }
 642                                 };
 643
 644                                 regions.push_back(layerRegion);
 645                                 layerDataOffset += level.getDataSize();
 646                         }
 647                 }
 648         }
 649         else
 650         {
 651                 offsetMultiples.push_back(getLevel(0, 0).getFormat().getPixelSize());
 652
 653                 for (int levelNdx = 0; levelNdx < getNumLevels(); levelNdx++)
 654                 {
 655                         for (int layerNdx = 0; layerNdx < getArraySize(); layerNdx++)
 656                         {
 657                                 const tcu::ConstPixelBufferAccess level = getLevel(levelNdx, layerNdx);
 658
 659                                 layerDataOffset = getNextMultiple(offsetMultiples, layerDataOffset);
 660
 661                                 const VkBufferImageCopy layerRegion =
 662                                 {
 663                                         layerDataOffset,                                                // VkDeviceSize                         bufferOffset;
 664                                         (deUint32)level.getWidth(),                             // deUint32                                     bufferRowLength;
 665                                         (deUint32)level.getHeight(),                    // deUint32                                     bufferImageHeight;
 666                                         {                                                                               // VkImageSubresourceLayers     imageSubresource;
 667                                                 VK_IMAGE_ASPECT_COLOR_BIT,
 668                                                 (deUint32)levelNdx,
 669                                                 (deUint32)layerNdx,
 670                                                 1u
 671                                         },
 672                                         { 0u, 0u, 0u },                                                 // VkOffset3D                   imageOffset;
 673                                         {                                                                               // VkExtent3D                   imageExtent;
 674                                                 (deUint32)level.getWidth(),
 675                                                 (deUint32)level.getHeight(),
 676                                                 (deUint32)level.getDepth()
 677                                         }
 678                                 };
 679
 680                                 regions.push_back(layerRegion);
 681                                 layerDataOffset += level.getWidth() * level.getHeight() * level.getDepth() * level.getFormat().getPixelSize();
 682                         }
 683                 }
 684         }
 685
 686         return regions;
 687 }
 688
 689 void TestTexture::write (deUint8* destPtr) const
 690 {
 691         std::vector<deUint32>   offsetMultiples;
 692         deUint32                                levelOffset             = 0;
 693
 694         offsetMultiples.push_back(4);
 695
 696         if (isCompressed())
 697         {
 698                 offsetMultiples.push_back(tcu::getBlockSize(getCompressedLevel(0, 0).getFormat()));
 699
 700                 for (int levelNdx = 0; levelNdx < getNumLevels(); levelNdx++)
 701                 {
 702                         for (int layerNdx = 0; layerNdx < getArraySize(); layerNdx++)
 703                         {
 704                                 levelOffset = getNextMultiple(offsetMultiples, levelOffset);
 705
 706                                 const tcu::CompressedTexture&           compressedTex   = getCompressedLevel(levelNdx, layerNdx);
 707
 708                                 deMemcpy(destPtr + levelOffset, compressedTex.getData(), compressedTex.getDataSize());
 709                                 levelOffset += compressedTex.getDataSize();
 710                         }
 711                 }
 712         }
 713         else
 714         {
 715                 offsetMultiples.push_back(getLevel(0, 0).getFormat().getPixelSize());
 716
 717                 for (int levelNdx = 0; levelNdx < getNumLevels(); levelNdx++)
 718                 {
 719                         for (int layerNdx = 0; layerNdx < getArraySize(); layerNdx++)
 720                         {
 721                                 levelOffset = getNextMultiple(offsetMultiples, levelOffset);
 722
 723                                 const tcu::ConstPixelBufferAccess       srcAccess               = getLevel(levelNdx, layerNdx);
 724                                 const tcu::PixelBufferAccess            destAccess              (srcAccess.getFormat(), srcAccess.getSize(), srcAccess.getPitch(), destPtr + levelOffset);
 725
 726                                 tcu::copy(destAccess, srcAccess);
 727                                 levelOffset += srcAccess.getWidth() * srcAccess.getHeight() * srcAccess.getDepth() * srcAccess.getFormat().getPixelSize();
 728                         }
 729                 }
 730         }
 731 }
 732
 733 void TestTexture::populateLevels (const std::vector<tcu::PixelBufferAccess>& levels)
 734 {
 735         for (size_t levelNdx = 0; levelNdx < levels.size(); levelNdx++)
 736                 TestTexture::fillWithGradient(levels[levelNdx]);
 737 }
 738
 739 void TestTexture::populateCompressedLevels (tcu::CompressedTexFormat format, const std::vector<tcu::PixelBufferAccess>& decompressedLevels)
 740 {
 741         // Generate random compressed data and update decompressed data
 742
 743         de::Random random(123);
 744
 745         for (size_t levelNdx = 0; levelNdx < decompressedLevels.size(); levelNdx++)
 746         {
 747                 const tcu::PixelBufferAccess    level                           = decompressedLevels[levelNdx];
 748                 tcu::CompressedTexture*                 compressedLevel         = new tcu::CompressedTexture(format, level.getWidth(), level.getHeight(), level.getDepth());
 749                 deUint8* const                                  compressedData          = (deUint8*)compressedLevel->getData();
 750
 751                 if (tcu::isAstcFormat(format))
 752                 {
 753                         // \todo [2016-01-20 pyry] Comparison doesn't currently handle invalid blocks correctly so we use only valid blocks
 754                         tcu::astc::generateRandomValidBlocks(compressedData, compressedLevel->getDataSize()/tcu::astc::BLOCK_SIZE_BYTES,
 755                                                                                                  format, tcu::TexDecompressionParams::ASTCMODE_LDR, random.getUint32());
 756                 }
 757                 else
 758                 {
 759                         // Generate random compressed data
 760                         for (int byteNdx = 0; byteNdx < compressedLevel->getDataSize(); byteNdx++)
 761                                 compressedData[byteNdx] = 0xFF & random.getUint32();
 762                 }
 763
 764                 m_compressedLevels.push_back(compressedLevel);
 765
 766                 // Store decompressed data
 767                 compressedLevel->decompress(level, tcu::TexDecompressionParams(tcu::TexDecompressionParams::ASTCMODE_LDR));
 768         }
 769 }
 770
 771 void TestTexture::fillWithGradient (const tcu::PixelBufferAccess& levelAccess)
 772 {
 773         const tcu::TextureFormatInfo formatInfo = tcu::getTextureFormatInfo(levelAccess.getFormat());
 774         tcu::fillWithComponentGradients(levelAccess, formatInfo.valueMin, formatInfo.valueMax);
 775 }
 776
 777 // TestTexture1D
 778
 779 TestTexture1D::TestTexture1D (const tcu::TextureFormat& format, int width)
 780         : TestTexture   (format, width, 1, 1)
 781         , m_texture             (format, width)
 782 {
 783         allocateLevels(m_texture);
 784         TestTexture::populateLevels(getLevelsVector(m_texture));
 785 }
 786
 787 TestTexture1D::TestTexture1D (const tcu::CompressedTexFormat& format, int width)
 788         : TestTexture   (format, width, 1, 1)
 789         , m_texture             (tcu::getUncompressedFormat(format), width)
 790 {
 791         allocateLevels(m_texture);
 792         TestTexture::populateCompressedLevels(format, getLevelsVector(m_texture));
 793 }
 794
 795 TestTexture1D::~TestTexture1D (void)
 796 {
 797 }
 798
 799 int TestTexture1D::getNumLevels (void) const
 800 {
 801         return m_texture.getNumLevels();
 802 }
 803
 804 tcu::PixelBufferAccess TestTexture1D::getLevel (int level, int layer)
 805 {
 806         DE_ASSERT(layer == 0);
 807         DE_UNREF(layer);
 808         return m_texture.getLevel(level);
 809 }
 810
 811 const tcu::ConstPixelBufferAccess TestTexture1D::getLevel (int level, int layer) const
 812 {
 813         DE_ASSERT(layer == 0);
 814         DE_UNREF(layer);
 815         return m_texture.getLevel(level);
 816 }
 817
 818 const tcu::Texture1D& TestTexture1D::getTexture (void) const
 819 {
 820         return m_texture;
 821 }
 822
 823
 824 // TestTexture1DArray
 825
 826 TestTexture1DArray::TestTexture1DArray (const tcu::TextureFormat& format, int width, int arraySize)
 827         : TestTexture   (format, width, 1, arraySize)
 828         , m_texture             (format, width, arraySize)
 829 {
 830         allocateLevels(m_texture);
 831         TestTexture::populateLevels(getLevelsVector(m_texture));
 832 }
 833
 834 TestTexture1DArray::TestTexture1DArray (const tcu::CompressedTexFormat& format, int width, int arraySize)
 835         : TestTexture   (format, width, 1, arraySize)
 836         , m_texture             (tcu::getUncompressedFormat(format), width, arraySize)
 837 {
 838         allocateLevels(m_texture);
 839
 840         std::vector<tcu::PixelBufferAccess> layers;
 841         for (int levelNdx = 0; levelNdx < m_texture.getNumLevels(); levelNdx++)
 842                 for (int layerNdx = 0; layerNdx < m_texture.getNumLayers(); layerNdx++)
 843                         layers.push_back(getLevel(levelNdx, layerNdx));
 844
 845         TestTexture::populateCompressedLevels(format, layers);
 846 }
 847
 848 TestTexture1DArray::~TestTexture1DArray (void)
 849 {
 850 }
 851
 852 int TestTexture1DArray::getNumLevels (void) const
 853 {
 854         return m_texture.getNumLevels();
 855 }
 856
 857 tcu::PixelBufferAccess TestTexture1DArray::getLevel (int level, int layer)
 858 {
 859         const tcu::PixelBufferAccess    levelLayers     = m_texture.getLevel(level);
 860         const deUint32                                  layerSize       = levelLayers.getWidth() * levelLayers.getFormat().getPixelSize();
 861         const deUint32                                  layerOffset     = layerSize * layer;
 862
 863         return tcu::PixelBufferAccess(levelLayers.getFormat(), levelLayers.getWidth(), 1, 1, (deUint8*)levelLayers.getDataPtr() + layerOffset);
 864 }
 865
 866 const tcu::ConstPixelBufferAccess TestTexture1DArray::getLevel (int level, int layer) const
 867 {
 868         const tcu::ConstPixelBufferAccess       levelLayers     = m_texture.getLevel(level);
 869         const deUint32                                          layerSize       = levelLayers.getWidth() * levelLayers.getFormat().getPixelSize();
 870         const deUint32                                          layerOffset     = layerSize * layer;
 871
 872         return tcu::ConstPixelBufferAccess(levelLayers.getFormat(), levelLayers.getWidth(), 1, 1, (deUint8*)levelLayers.getDataPtr() + layerOffset);
 873 }
 874
 875 const tcu::Texture1DArray& TestTexture1DArray::getTexture (void) const
 876 {
 877         return m_texture;
 878 }
 879
 880 int TestTexture1DArray::getArraySize (void) const
 881 {
 882         return m_texture.getNumLayers();
 883 }
 884
 885
 886 // TestTexture2D
 887
 888 TestTexture2D::TestTexture2D (const tcu::TextureFormat& format, int width, int height)
 889         : TestTexture   (format, width, height, 1)
 890         , m_texture             (format, width, height)
 891 {
 892         allocateLevels(m_texture);
 893         TestTexture::populateLevels(getLevelsVector(m_texture));
 894 }
 895
 896 TestTexture2D::TestTexture2D (const tcu::CompressedTexFormat& format, int width, int height)
 897         : TestTexture   (format, width, height, 1)
 898         , m_texture             (tcu::getUncompressedFormat(format), width, height)
 899 {
 900         allocateLevels(m_texture);
 901         TestTexture::populateCompressedLevels(format, getLevelsVector(m_texture));
 902 }
 903
 904 TestTexture2D::~TestTexture2D (void)
 905 {
 906 }
 907
 908 int TestTexture2D::getNumLevels (void) const
 909 {
 910         return m_texture.getNumLevels();
 911 }
 912
 913 tcu::PixelBufferAccess TestTexture2D::getLevel (int level, int layer)
 914 {
 915         DE_ASSERT(layer == 0);
 916         DE_UNREF(layer);
 917         return m_texture.getLevel(level);
 918 }
 919
 920 const tcu::ConstPixelBufferAccess TestTexture2D::getLevel (int level, int layer) const
 921 {
 922         DE_ASSERT(layer == 0);
 923         DE_UNREF(layer);
 924         return m_texture.getLevel(level);
 925 }
 926
 927 const tcu::Texture2D& TestTexture2D::getTexture (void) const
 928 {
 929         return m_texture;
 930 }
 931
 932
 933 // TestTexture2DArray
 934
 935 TestTexture2DArray::TestTexture2DArray (const tcu::TextureFormat& format, int width, int height, int arraySize)
 936         : TestTexture   (format, width, height, arraySize)
 937         , m_texture             (format, width, height, arraySize)
 938 {
 939         allocateLevels(m_texture);
 940         TestTexture::populateLevels(getLevelsVector(m_texture));
 941 }
 942
 943 TestTexture2DArray::TestTexture2DArray (const tcu::CompressedTexFormat& format, int width, int height, int arraySize)
 944         : TestTexture   (format, width, height, arraySize)
 945         , m_texture             (tcu::getUncompressedFormat(format), width, height, arraySize)
 946 {
 947         allocateLevels(m_texture);
 948
 949         std::vector<tcu::PixelBufferAccess> layers;
 950         for (int levelNdx = 0; levelNdx < m_texture.getNumLevels(); levelNdx++)
 951                 for (int layerNdx = 0; layerNdx < m_texture.getNumLayers(); layerNdx++)
 952                         layers.push_back(getLevel(levelNdx, layerNdx));
 953
 954         TestTexture::populateCompressedLevels(format, layers);
 955 }
 956
 957 TestTexture2DArray::~TestTexture2DArray (void)
 958 {
 959 }
 960
 961 int TestTexture2DArray::getNumLevels (void) const
 962 {
 963         return m_texture.getNumLevels();
 964 }
 965
 966 tcu::PixelBufferAccess TestTexture2DArray::getLevel (int level, int layer)
 967 {
 968         const tcu::PixelBufferAccess    levelLayers     = m_texture.getLevel(level);
 969         const deUint32                                  layerSize       = levelLayers.getWidth() * levelLayers.getHeight() * levelLayers.getFormat().getPixelSize();
 970         const deUint32                                  layerOffset     = layerSize * layer;
 971
 972         return tcu::PixelBufferAccess(levelLayers.getFormat(), levelLayers.getWidth(), levelLayers.getHeight(), 1, (deUint8*)levelLayers.getDataPtr() + layerOffset);
 973 }
 974
 975 const tcu::ConstPixelBufferAccess TestTexture2DArray::getLevel (int level, int layer) const
 976 {
 977         const tcu::ConstPixelBufferAccess       levelLayers     = m_texture.getLevel(level);
 978         const deUint32                                          layerSize       = levelLayers.getWidth() * levelLayers.getHeight() * levelLayers.getFormat().getPixelSize();
 979         const deUint32                                          layerOffset     = layerSize * layer;
 980
 981         return tcu::ConstPixelBufferAccess(levelLayers.getFormat(), levelLayers.getWidth(), levelLayers.getHeight(), 1, (deUint8*)levelLayers.getDataPtr() + layerOffset);
 982 }
 983
 984 const tcu::Texture2DArray& TestTexture2DArray::getTexture (void) const
 985 {
 986         return m_texture;
 987 }
 988
 989 int TestTexture2DArray::getArraySize (void) const
 990 {
 991         return m_texture.getNumLayers();
 992 }
 993
 994
 995 // TestTexture3D
 996
 997 TestTexture3D::TestTexture3D (const tcu::TextureFormat& format, int width, int height, int depth)
 998         : TestTexture   (format, width, height, depth)
 999         , m_texture             (format, width, height, depth)
1000 {
1001         allocateLevels(m_texture);
1002         TestTexture::populateLevels(getLevelsVector(m_texture));
1003 }
1004
1005 TestTexture3D::TestTexture3D (const tcu::CompressedTexFormat& format, int width, int height, int depth)
1006         : TestTexture   (format, width, height, depth)
1007         , m_texture             (tcu::getUncompressedFormat(format), width, height, depth)
1008 {
1009         allocateLevels(m_texture);
1010         TestTexture::populateCompressedLevels(format, getLevelsVector(m_texture));
1011 }
1012
1013 TestTexture3D::~TestTexture3D (void)
1014 {
1015 }
1016
1017 int TestTexture3D::getNumLevels (void) const
1018 {
1019         return m_texture.getNumLevels();
1020 }
1021
1022 tcu::PixelBufferAccess TestTexture3D::getLevel (int level, int layer)
1023 {
1024         DE_ASSERT(layer == 0);
1025         DE_UNREF(layer);
1026         return m_texture.getLevel(level);
1027 }
1028
1029 const tcu::ConstPixelBufferAccess TestTexture3D::getLevel (int level, int layer) const
1030 {
1031         DE_ASSERT(layer == 0);
1032         DE_UNREF(layer);
1033         return m_texture.getLevel(level);
1034 }
1035
1036 const tcu::Texture3D& TestTexture3D::getTexture (void) const
1037 {
1038         return m_texture;
1039 }
1040
1041
1042 // TestTextureCube
1043
1044 const static tcu::CubeFace tcuFaceMapping[tcu::CUBEFACE_LAST] =
1045 {
1046         tcu::CUBEFACE_POSITIVE_X,
1047         tcu::CUBEFACE_NEGATIVE_X,
1048         tcu::CUBEFACE_POSITIVE_Y,
1049         tcu::CUBEFACE_NEGATIVE_Y,
1050         tcu::CUBEFACE_POSITIVE_Z,
1051         tcu::CUBEFACE_NEGATIVE_Z
1052 };
1053
1054 TestTextureCube::TestTextureCube (const tcu::TextureFormat& format, int size)
1055         : TestTexture   (format, size, size, 1)
1056         , m_texture             (format, size)
1057 {
1058         for (int levelNdx = 0; levelNdx < getNumLevels(); levelNdx++)
1059         {
1060                 for (int faceNdx = 0; faceNdx < tcu::CUBEFACE_LAST; faceNdx++)
1061                 {
1062                         m_texture.allocLevel(tcuFaceMapping[faceNdx], levelNdx);
1063                         TestTexture::fillWithGradient(m_texture.getLevelFace(levelNdx, tcuFaceMapping[faceNdx]));
1064                 }
1065         }
1066 }
1067
1068 TestTextureCube::TestTextureCube (const tcu::CompressedTexFormat& format, int size)
1069         : TestTexture   (format, size, size, 1)
1070         , m_texture             (tcu::getUncompressedFormat(format), size)
1071 {
1072         std::vector<tcu::PixelBufferAccess> levels(m_texture.getNumLevels() * tcu::CUBEFACE_LAST);
1073
1074         for (int levelNdx = 0; levelNdx < getNumLevels(); levelNdx++)
1075         {
1076                 for (int faceNdx = 0; faceNdx < tcu::CUBEFACE_LAST; faceNdx++)
1077                 {
1078                         m_texture.allocLevel(tcuFaceMapping[faceNdx], levelNdx);
1079                         levels[levelNdx * tcu::CUBEFACE_LAST + faceNdx] = m_texture.getLevelFace(levelNdx, tcuFaceMapping[faceNdx]);
1080                 }
1081         }
1082
1083         TestTexture::populateCompressedLevels(format, levels);
1084 }
1085
1086 TestTextureCube::~TestTextureCube (void)
1087 {
1088 }
1089
1090 int TestTextureCube::getNumLevels (void) const
1091 {
1092         return m_texture.getNumLevels();
1093 }
1094
1095 tcu::PixelBufferAccess TestTextureCube::getLevel (int level, int face)
1096 {
1097         return m_texture.getLevelFace(level, (tcu::CubeFace)face);
1098 }
1099
1100 const tcu::ConstPixelBufferAccess TestTextureCube::getLevel (int level, int face) const
1101 {
1102         return m_texture.getLevelFace(level, (tcu::CubeFace)face);
1103 }
1104
1105 int TestTextureCube::getArraySize (void) const
1106 {
1107         return (int)tcu::CUBEFACE_LAST;
1108 }
1109
1110 const tcu::TextureCube& TestTextureCube::getTexture (void) const
1111 {
1112         return m_texture;
1113 }
1114
1115 // TestTextureCubeArray
1116
1117 TestTextureCubeArray::TestTextureCubeArray (const tcu::TextureFormat& format, int size, int arraySize)
1118         : TestTexture   (format, size, size, arraySize)
1119         , m_texture             (format, size, arraySize)
1120 {
1121         allocateLevels(m_texture);
1122         TestTexture::populateLevels(getLevelsVector(m_texture));
1123 }
1124
1125 TestTextureCubeArray::TestTextureCubeArray (const tcu::CompressedTexFormat& format, int size, int arraySize)
1126         : TestTexture   (format, size, size, arraySize)
1127         , m_texture             (tcu::getUncompressedFormat(format), size, arraySize)
1128 {
1129         DE_ASSERT(arraySize % 6 == 0);
1130
1131         allocateLevels(m_texture);
1132
1133         std::vector<tcu::PixelBufferAccess> layers;
1134         for (int levelNdx = 0; levelNdx < m_texture.getNumLevels(); levelNdx++)
1135                 for (int layerNdx = 0; layerNdx < m_texture.getDepth(); layerNdx++)
1136                         layers.push_back(getLevel(levelNdx, layerNdx));
1137
1138         TestTexture::populateCompressedLevels(format, layers);
1139 }
1140
1141 TestTextureCubeArray::~TestTextureCubeArray (void)
1142 {
1143 }
1144
1145 int TestTextureCubeArray::getNumLevels (void) const
1146 {
1147         return m_texture.getNumLevels();
1148 }
1149
1150 tcu::PixelBufferAccess TestTextureCubeArray::getLevel (int level, int layer)
1151 {
1152         const tcu::PixelBufferAccess    levelLayers     = m_texture.getLevel(level);
1153         const deUint32                                  layerSize       = levelLayers.getWidth() * levelLayers.getHeight() * levelLayers.getFormat().getPixelSize();
1154         const deUint32                                  layerOffset     = layerSize * layer;
1155
1156         return tcu::PixelBufferAccess(levelLayers.getFormat(), levelLayers.getWidth(), levelLayers.getHeight(), 1, (deUint8*)levelLayers.getDataPtr() + layerOffset);
1157 }
1158
1159 const tcu::ConstPixelBufferAccess TestTextureCubeArray::getLevel (int level, int layer) const
1160 {
1161         const tcu::ConstPixelBufferAccess       levelLayers     = m_texture.getLevel(level);
1162         const deUint32                                          layerSize       = levelLayers.getWidth() * levelLayers.getHeight() * levelLayers.getFormat().getPixelSize();
1163         const deUint32                                          layerOffset     = layerSize * layer;
1164
1165         return tcu::ConstPixelBufferAccess(levelLayers.getFormat(), levelLayers.getWidth(), levelLayers.getHeight(), 1, (deUint8*)levelLayers.getDataPtr() + layerOffset);
1166 }
1167
1168 int TestTextureCubeArray::getArraySize (void) const
1169 {
1170         return m_texture.getDepth();
1171 }
1172
1173 const tcu::TextureCubeArray& TestTextureCubeArray::getTexture (void) const
1174 {
1175         return m_texture;
1176 }
1177
1178 } // pipeline
1179 } // vkt