external/vulkancts/modules/vulkan/image/vktImageTestsUtil.cpp

   1 /*------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2015 Mobica Ltd.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and/or associated documentation files (the
   9  * "Materials"), to deal in the Materials without restriction, including
  10  * without limitation the rights to use, copy, modify, merge, publish,
  11  * distribute, sublicense, and/or sell copies of the Materials, and to
  12  * permit persons to whom the Materials are furnished to do so, subject to
  13  * the following conditions:
  14  *
  15  * The above copyright notice(s) and this permission notice shall be included
  16  * in all copies or substantial portions of the Materials.
  17  *
  18  * The Materials are Confidential Information as defined by the
  19  * Khronos Membership Agreement until designated non-confidential by Khronos,
  20  * at which point this condition clause shall be removed.
  21  *
  22  * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  25  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  26  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  27  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  28  * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
  29  *
  30  *//*!
  31  * \file
  32  * \brief Image Tests Utility Classes
  33  *//*--------------------------------------------------------------------*/
  34
  35 #include "vktImageTestsUtil.hpp"
  36 #include "vkQueryUtil.hpp"
  37 #include "vkTypeUtil.hpp"
  38 #include "tcuTextureUtil.hpp"
  39
  40 using namespace vk;
  41
  42 namespace vkt
  43 {
  44 namespace image
  45 {
  46
  47 Buffer::Buffer (const DeviceInterface&          vk,
  48                                 const VkDevice                          device,
  49                                 Allocator&                                      allocator,
  50                                 const VkBufferCreateInfo&       bufferCreateInfo,
  51                                 const MemoryRequirement         memoryRequirement)
  52 {
  53         m_buffer = createBuffer(vk, device, &bufferCreateInfo);
  54         m_allocation = allocator.allocate(getBufferMemoryRequirements(vk, device, *m_buffer), memoryRequirement);
  55         VK_CHECK(vk.bindBufferMemory(device, *m_buffer, m_allocation->getMemory(), m_allocation->getOffset()));
  56 }
  57
  58 Image::Image (const DeviceInterface&    vk,
  59                           const VkDevice                        device,
  60                           Allocator&                            allocator,
  61                           const VkImageCreateInfo&      imageCreateInfo,
  62                           const MemoryRequirement       memoryRequirement)
  63 {
  64         m_image = createImage(vk, device, &imageCreateInfo);
  65         m_allocation = allocator.allocate(getImageMemoryRequirements(vk, device, *m_image), memoryRequirement);
  66         VK_CHECK(vk.bindImageMemory(device, *m_image, m_allocation->getMemory(), m_allocation->getOffset()));
  67 }
  68
  69 VkBufferCreateInfo makeBufferCreateInfo (const VkDeviceSize                     bufferSize,
  70                                                                                  const VkBufferUsageFlags       usage)
  71 {
  72         const VkBufferCreateInfo bufferCreateInfo =
  73         {
  74                 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,   // VkStructureType              sType;
  75                 DE_NULL,                                                                // const void*                  pNext;
  76                 0u,                                                                             // VkBufferCreateFlags  flags;
  77                 bufferSize,                                                             // VkDeviceSize                 size;
  78                 usage,                                                                  // VkBufferUsageFlags   usage;
  79                 VK_SHARING_MODE_EXCLUSIVE,                              // VkSharingMode                sharingMode;
  80                 0u,                                                                             // deUint32                             queueFamilyIndexCount;
  81                 DE_NULL,                                                                // const deUint32*              pQueueFamilyIndices;
  82         };
  83         return bufferCreateInfo;
  84 }
  85
  86 VkBufferImageCopy makeBufferImageCopy (const VkExtent3D extent,
  87                                                                            const deUint32       arraySize)
  88 {
  89         const VkBufferImageCopy copyParams =
  90         {
  91                 0ull,                                                                                                                                           //      VkDeviceSize                            bufferOffset;
  92                 0u,                                                                                                                                                     //      deUint32                                        bufferRowLength;
  93                 0u,                                                                                                                                                     //      deUint32                                        bufferImageHeight;
  94                 makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, arraySize),       //      VkImageSubresourceLayers        imageSubresource;
  95                 makeOffset3D(0, 0, 0),                                                                                                          //      VkOffset3D                                      imageOffset;
  96                 extent,                                                                                                                                         //      VkExtent3D                                      imageExtent;
  97         };
  98         return copyParams;
  99 }
 100
 101 Move<VkCommandPool> makeCommandPool (const DeviceInterface& vk, const VkDevice device, const deUint32 queueFamilyIndex)
 102 {
 103         const VkCommandPoolCreateInfo commandPoolParams =
 104         {
 105                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                     // VkStructureType                      sType;
 106                 DE_NULL,                                                                                        // const void*                          pNext;
 107                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,        // VkCommandPoolCreateFlags     flags;
 108                 queueFamilyIndex,                                                                       // deUint32                                     queueFamilyIndex;
 109         };
 110         return createCommandPool(vk, device, &commandPoolParams);
 111 }
 112
 113 Move<VkCommandBuffer> makeCommandBuffer (const DeviceInterface& vk, const VkDevice device, const VkCommandPool commandPool)
 114 {
 115         const VkCommandBufferAllocateInfo bufferAllocateParams =
 116         {
 117                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,         // VkStructureType                      sType;
 118                 DE_NULL,                                                                                        // const void*                          pNext;
 119                 commandPool,                                                                            // VkCommandPool                        commandPool;
 120                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                        // VkCommandBufferLevel         level;
 121                 1u,                                                                                                     // deUint32                                     bufferCount;
 122         };
 123         return allocateCommandBuffer(vk, device, &bufferAllocateParams);
 124 }
 125
 126 Move<VkPipelineLayout> makePipelineLayout (const DeviceInterface&               vk,
 127                                                                                    const VkDevice                               device,
 128                                                                                    const VkDescriptorSetLayout  descriptorSetLayout)
 129 {
 130         const VkPipelineLayoutCreateInfo pipelineLayoutParams =
 131         {
 132                 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,          // VkStructureType                                      sType;
 133                 DE_NULL,                                                                                        // const void*                                          pNext;
 134                 0u,                                                                                                     // VkPipelineLayoutCreateFlags          flags;
 135                 1u,                                                                                                     // deUint32                                                     setLayoutCount;
 136                 &descriptorSetLayout,                                                           // const VkDescriptorSetLayout*         pSetLayouts;
 137                 0u,                                                                                                     // deUint32                                                     pushConstantRangeCount;
 138                 DE_NULL,                                                                                        // const VkPushConstantRange*           pPushConstantRanges;
 139         };
 140         return createPipelineLayout(vk, device, &pipelineLayoutParams);
 141 }
 142
 143 Move<VkPipeline> makeComputePipeline (const DeviceInterface&    vk,
 144                                                                           const VkDevice                        device,
 145                                                                           const VkPipelineLayout        pipelineLayout,
 146                                                                           const VkShaderModule          shaderModule)
 147 {
 148         const VkPipelineShaderStageCreateInfo pipelineShaderStageParams =
 149         {
 150                 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,    // VkStructureType                                              sType;
 151                 DE_NULL,                                                                                                // const void*                                                  pNext;
 152                 0u,                                                                                                             // VkPipelineShaderStageCreateFlags             flags;
 153                 VK_SHADER_STAGE_COMPUTE_BIT,                                                    // VkShaderStageFlagBits                                stage;
 154                 shaderModule,                                                                                   // VkShaderModule                                               module;
 155                 "main",                                                                                                 // const char*                                                  pName;
 156                 DE_NULL,                                                                                                // const VkSpecializationInfo*                  pSpecializationInfo;
 157         };
 158         const VkComputePipelineCreateInfo pipelineCreateInfo =
 159         {
 160                 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,         // VkStructureType                                      sType;
 161                 DE_NULL,                                                                                        // const void*                                          pNext;
 162                 0u,                                                                                                     // VkPipelineCreateFlags                        flags;
 163                 pipelineShaderStageParams,                                                      // VkPipelineShaderStageCreateInfo      stage;
 164                 pipelineLayout,                                                                         // VkPipelineLayout                                     layout;
 165                 DE_NULL,                                                                                        // VkPipeline                                           basePipelineHandle;
 166                 0,                                                                                                      // deInt32                                                      basePipelineIndex;
 167         };
 168         return createComputePipeline(vk, device, DE_NULL , &pipelineCreateInfo);
 169 }
 170
 171 Move<VkBufferView> makeBufferView (const DeviceInterface&       vk,
 172                                                                    const VkDevice                       vkDevice,
 173                                                                    const VkBuffer                       buffer,
 174                                                                    const VkFormat                       format,
 175                                                                    const VkDeviceSize           offset,
 176                                                                    const VkDeviceSize           size)
 177 {
 178         const VkBufferViewCreateInfo bufferViewParams =
 179         {
 180                 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,      // VkStructureType                      sType;
 181                 DE_NULL,                                                                        // const void*                          pNext;
 182                 0u,                                                                                     // VkBufferViewCreateFlags      flags;
 183                 buffer,                                                                         // VkBuffer                                     buffer;
 184                 format,                                                                         // VkFormat                                     format;
 185                 offset,                                                                         // VkDeviceSize                         offset;
 186                 size,                                                                           // VkDeviceSize                         range;
 187         };
 188         return createBufferView(vk, vkDevice, &bufferViewParams);
 189 }
 190
 191 Move<VkImageView> makeImageView (const DeviceInterface&                 vk,
 192                                                                  const VkDevice                                 vkDevice,
 193                                                                  const VkImage                                  image,
 194                                                                  const VkImageViewType                  imageViewType,
 195                                                                  const VkFormat                                 format,
 196                                                                  const VkImageSubresourceRange  subresourceRange)
 197 {
 198         const VkImageViewCreateInfo imageViewParams =
 199         {
 200                 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,               // VkStructureType                      sType;
 201                 DE_NULL,                                                                                // const void*                          pNext;
 202                 0u,                                                                                             // VkImageViewCreateFlags       flags;
 203                 image,                                                                                  // VkImage                                      image;
 204                 imageViewType,                                                                  // VkImageViewType                      viewType;
 205                 format,                                                                                 // VkFormat                                     format;
 206                 makeComponentMappingRGBA(),                                             // VkComponentMapping           components;
 207                 subresourceRange,                                                               // VkImageSubresourceRange      subresourceRange;
 208         };
 209         return createImageView(vk, vkDevice, &imageViewParams);
 210 }
 211
 212 Move<VkDescriptorSet> makeDescriptorSet (const DeviceInterface&                 vk,
 213                                                                                  const VkDevice                                 device,
 214                                                                                  const VkDescriptorPool                 descriptorPool,
 215                                                                                  const VkDescriptorSetLayout    setLayout)
 216 {
 217         const VkDescriptorSetAllocateInfo allocateParams =
 218         {
 219                 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,         // VkStructureType                              sType;
 220                 DE_NULL,                                                                                        // const void*                                  pNext;
 221                 descriptorPool,                                                                         // VkDescriptorPool                             descriptorPool;
 222                 1u,                                                                                                     // deUint32                                             setLayoutCount;
 223                 &setLayout,                                                                                     // const VkDescriptorSetLayout* pSetLayouts;
 224         };
 225         return allocateDescriptorSet(vk, device, &allocateParams);
 226 }
 227
 228 VkBufferMemoryBarrier makeBufferMemoryBarrier (const VkAccessFlags      srcAccessMask,
 229                                                                                            const VkAccessFlags  dstAccessMask,
 230                                                                                            const VkBuffer               buffer,
 231                                                                                            const VkDeviceSize   offset,
 232                                                                                            const VkDeviceSize   bufferSizeBytes)
 233 {
 234         const VkBufferMemoryBarrier barrier =
 235         {
 236                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,        // VkStructureType      sType;
 237                 DE_NULL,                                                                        // const void*          pNext;
 238                 srcAccessMask,                                                          // VkAccessFlags        srcAccessMask;
 239                 dstAccessMask,                                                          // VkAccessFlags        dstAccessMask;
 240                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     srcQueueFamilyIndex;
 241                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     destQueueFamilyIndex;
 242                 buffer,                                                                         // VkBuffer                     buffer;
 243                 offset,                                                                         // VkDeviceSize         offset;
 244                 bufferSizeBytes,                                                        // VkDeviceSize         size;
 245         };
 246         return barrier;
 247 }
 248
 249 VkImageMemoryBarrier makeImageMemoryBarrier     (const VkAccessFlags                    srcAccessMask,
 250                                                                                          const VkAccessFlags                    dstAccessMask,
 251                                                                                          const VkImageLayout                    oldLayout,
 252                                                                                          const VkImageLayout                    newLayout,
 253                                                                                          const VkImage                                  image,
 254                                                                                          const VkImageSubresourceRange  subresourceRange)
 255 {
 256         const VkImageMemoryBarrier barrier =
 257         {
 258                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                 // VkStructureType                      sType;
 259                 DE_NULL,                                                                                // const void*                          pNext;
 260                 srcAccessMask,                                                                  // VkAccessFlags                        outputMask;
 261                 dstAccessMask,                                                                  // VkAccessFlags                        inputMask;
 262                 oldLayout,                                                                              // VkImageLayout                        oldLayout;
 263                 newLayout,                                                                              // VkImageLayout                        newLayout;
 264                 VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                                     srcQueueFamilyIndex;
 265                 VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                                     destQueueFamilyIndex;
 266                 image,                                                                                  // VkImage                                      image;
 267                 subresourceRange,                                                               // VkImageSubresourceRange      subresourceRange;
 268         };
 269         return barrier;
 270 }
 271
 272 void beginCommandBuffer (const DeviceInterface& vk, const VkCommandBuffer commandBuffer)
 273 {
 274         const VkCommandBufferBeginInfo commandBufBeginParams =
 275         {
 276                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,    // VkStructureType                                      sType;
 277                 DE_NULL,                                                                                // const void*                                          pNext;
 278                 0u,                                                                                             // VkCommandBufferUsageFlags            flags;
 279                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
 280         };
 281         VK_CHECK(vk.beginCommandBuffer(commandBuffer, &commandBufBeginParams));
 282 }
 283 void endCommandBuffer (const DeviceInterface& vk, const VkCommandBuffer commandBuffer)
 284 {
 285         VK_CHECK(vk.endCommandBuffer(commandBuffer));
 286 }
 287
 288 void submitCommandsAndWait (const DeviceInterface&      vk,
 289                                                         const VkDevice                  device,
 290                                                         const VkQueue                   queue,
 291                                                         const VkCommandBuffer   commandBuffer)
 292 {
 293         const VkFenceCreateInfo fenceParams =
 294         {
 295                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,    // VkStructureType              sType;
 296                 DE_NULL,                                                                // const void*                  pNext;
 297                 0u,                                                                             // VkFenceCreateFlags   flags;
 298         };
 299         const Unique<VkFence> fence(createFence(vk, device, &fenceParams));
 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                 (const VkPipelineStageFlags*)DE_NULL,
 308                 1u,                                                                     // deUint32                                     commandBufferCount;
 309                 &commandBuffer,                                         // const VkCommandBuffer*       pCommandBuffers;
 310                 0u,                                                                     // deUint32                                     signalSemaphoreCount;
 311                 DE_NULL,                                                        // const VkSemaphore*           pSignalSemaphores;
 312         };
 313
 314         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
 315         VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
 316 }
 317
 318 VkImageType     mapImageType (const ImageType imageType)
 319 {
 320         switch (imageType)
 321         {
 322                 case IMAGE_TYPE_1D:
 323                 case IMAGE_TYPE_1D_ARRAY:
 324                 case IMAGE_TYPE_BUFFER:
 325                         return VK_IMAGE_TYPE_1D;
 326
 327                 case IMAGE_TYPE_2D:
 328                 case IMAGE_TYPE_2D_ARRAY:
 329                 case IMAGE_TYPE_CUBE:
 330                 case IMAGE_TYPE_CUBE_ARRAY:
 331                         return VK_IMAGE_TYPE_2D;
 332
 333                 case IMAGE_TYPE_3D:
 334                         return VK_IMAGE_TYPE_3D;
 335
 336                 default:
 337                         DE_ASSERT(false);
 338                         return VK_IMAGE_TYPE_LAST;
 339         }
 340 }
 341
 342 VkImageViewType mapImageViewType (const ImageType imageType)
 343 {
 344         switch (imageType)
 345         {
 346                 case IMAGE_TYPE_1D:                     return VK_IMAGE_VIEW_TYPE_1D;
 347                 case IMAGE_TYPE_1D_ARRAY:       return VK_IMAGE_VIEW_TYPE_1D_ARRAY;
 348                 case IMAGE_TYPE_2D:                     return VK_IMAGE_VIEW_TYPE_2D;
 349                 case IMAGE_TYPE_2D_ARRAY:       return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
 350                 case IMAGE_TYPE_3D:                     return VK_IMAGE_VIEW_TYPE_3D;
 351                 case IMAGE_TYPE_CUBE:           return VK_IMAGE_VIEW_TYPE_CUBE;
 352                 case IMAGE_TYPE_CUBE_ARRAY:     return VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
 353
 354                 default:
 355                         DE_ASSERT(false);
 356                         return VK_IMAGE_VIEW_TYPE_LAST;
 357         }
 358 }
 359
 360 std::string getImageTypeName (const ImageType imageType)
 361 {
 362         switch (imageType)
 363         {
 364                 case IMAGE_TYPE_1D:                     return "1d";
 365                 case IMAGE_TYPE_1D_ARRAY:       return "1d_array";
 366                 case IMAGE_TYPE_2D:                     return "2d";
 367                 case IMAGE_TYPE_2D_ARRAY:       return "2d_array";
 368                 case IMAGE_TYPE_3D:                     return "3d";
 369                 case IMAGE_TYPE_CUBE:           return "cube";
 370                 case IMAGE_TYPE_CUBE_ARRAY:     return "cube_array";
 371                 case IMAGE_TYPE_BUFFER:         return "buffer";
 372
 373                 default:
 374                         DE_ASSERT(false);
 375                         return "";
 376         }
 377 }
 378
 379 std::string getShaderImageType (const tcu::TextureFormat& format, const ImageType imageType)
 380 {
 381         std::string formatPart = tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER ? "u" :
 382                                                          tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER   ? "i" : "";
 383
 384         std::string imageTypePart;
 385         switch (imageType)
 386         {
 387                 case IMAGE_TYPE_1D:                     imageTypePart = "1D";                   break;
 388                 case IMAGE_TYPE_1D_ARRAY:       imageTypePart = "1DArray";              break;
 389                 case IMAGE_TYPE_2D:                     imageTypePart = "2D";                   break;
 390                 case IMAGE_TYPE_2D_ARRAY:       imageTypePart = "2DArray";              break;
 391                 case IMAGE_TYPE_3D:                     imageTypePart = "3D";                   break;
 392                 case IMAGE_TYPE_CUBE:           imageTypePart = "Cube";                 break;
 393                 case IMAGE_TYPE_CUBE_ARRAY:     imageTypePart = "CubeArray";    break;
 394                 case IMAGE_TYPE_BUFFER:         imageTypePart = "Buffer";               break;
 395
 396                 default:
 397                         DE_ASSERT(false);
 398         }
 399
 400         return formatPart + "image" + imageTypePart;
 401 }
 402
 403 std::string getShaderImageFormatQualifier (const tcu::TextureFormat& format)
 404 {
 405         const char* orderPart;
 406         const char* typePart;
 407
 408         switch (format.order)
 409         {
 410                 case tcu::TextureFormat::R:             orderPart = "r";        break;
 411                 case tcu::TextureFormat::RG:    orderPart = "rg";       break;
 412                 case tcu::TextureFormat::RGB:   orderPart = "rgb";      break;
 413                 case tcu::TextureFormat::RGBA:  orderPart = "rgba";     break;
 414
 415                 default:
 416                         DE_ASSERT(false);
 417                         orderPart = DE_NULL;
 418         }
 419
 420         switch (format.type)
 421         {
 422                 case tcu::TextureFormat::FLOAT:                         typePart = "32f";               break;
 423                 case tcu::TextureFormat::HALF_FLOAT:            typePart = "16f";               break;
 424
 425                 case tcu::TextureFormat::UNSIGNED_INT32:        typePart = "32ui";              break;
 426                 case tcu::TextureFormat::UNSIGNED_INT16:        typePart = "16ui";              break;
 427                 case tcu::TextureFormat::UNSIGNED_INT8:         typePart = "8ui";               break;
 428
 429                 case tcu::TextureFormat::SIGNED_INT32:          typePart = "32i";               break;
 430                 case tcu::TextureFormat::SIGNED_INT16:          typePart = "16i";               break;
 431                 case tcu::TextureFormat::SIGNED_INT8:           typePart = "8i";                break;
 432
 433                 case tcu::TextureFormat::UNORM_INT16:           typePart = "16";                break;
 434                 case tcu::TextureFormat::UNORM_INT8:            typePart = "8";                 break;
 435
 436                 case tcu::TextureFormat::SNORM_INT16:           typePart = "16_snorm";  break;
 437                 case tcu::TextureFormat::SNORM_INT8:            typePart = "8_snorm";   break;
 438
 439                 default:
 440                         DE_ASSERT(false);
 441                         typePart = DE_NULL;
 442         }
 443
 444         return std::string() + orderPart + typePart;
 445 }
 446
 447 } // image
 448 } // vkt