Add offset to memory allocations

src/gpu/vk/GrVkGpu.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrVkGpu.h"
 
 #include "GrContextOptions.h"
@@ skipping 313 matching lines @@
     VkResult err;
 
     const GrVkInterface* interface = this->vkInterface();
 
     GR_VK_CALL(interface, GetImageSubresourceLayout(fDevice,
                                                     tex->image(),
                                                     &subres,
                                                     &layout));
 
     int texTop = kBottomLeft_GrSurfaceOrigin == desc.fOrigin ? tex->height() - top - height : top;
-    VkDeviceSize offset = texTop*layout.rowPitch + left*bpp;
+    VkDeviceSize offset = tex->offset() + texTop*layout.rowPitch + left*bpp;

[egdaniel, 2016/05/31 13:22:14]

is the offset actually needed here? If the image is bound to memory with some
offset, then do you reference the start of the image as 0 or the offset?

[jvanverth1, 2016/05/31 22:05:57]

There's no reference to the image in MapMemory, so it must be relative to the
start of the memory allocation.

     VkDeviceSize size = height*layout.rowPitch;
     void* mapPtr;
     err = GR_VK_CALL(interface, MapMemory(fDevice, tex->memory(), offset, size, 0, &mapPtr));
     if (err) {
         return false;
     }
 
     if (kBottomLeft_GrSurfaceOrigin == desc.fOrigin) {
         // copy into buffer by rows
         const char* srcRow = reinterpret_cast<const char*>(data);
@@ skipping 522 matching lines @@
 
     VkImageUsageFlags usageFlags = VK_IMAGE_USAGE_SAMPLED_BIT;
     usageFlags |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
     usageFlags |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 
     VkFlags memProps = (srcData && linearTiling) ? VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT :
                                                    VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
 
     VkImage image = VK_NULL_HANDLE;
     VkDeviceMemory alloc = VK_NULL_HANDLE;
+    VkDeviceSize offset = 0;
 
     VkImageTiling imageTiling = linearTiling ? VK_IMAGE_TILING_LINEAR : VK_IMAGE_TILING_OPTIMAL;
     VkImageLayout initialLayout = (VK_IMAGE_TILING_LINEAR == imageTiling)
                                 ? VK_IMAGE_LAYOUT_PREINITIALIZED
                                 : VK_IMAGE_LAYOUT_UNDEFINED;
 
     // Create Image
     VkSampleCountFlagBits vkSamples;
     if (!GrSampleCountToVkSampleCount(1, &vkSamples)) {
         return 0;
@@ skipping 12 matching lines @@
         imageTiling,                                 // VkImageTiling
         usageFlags,                                  // VkImageUsageFlags
         VK_SHARING_MODE_EXCLUSIVE,                   // VkSharingMode
         0,                                           // queueFamilyCount
         0,                                           // pQueueFamilyIndices
         initialLayout                                // initialLayout
     };
 
     GR_VK_CALL_ERRCHECK(this->vkInterface(), CreateImage(this->device(), &imageCreateInfo, nullptr, &image));
 
-    if (!GrVkMemory::AllocAndBindImageMemory(this, image, memProps, &alloc)) {
+    if (!GrVkMemory::AllocAndBindImageMemory(this, image, memProps, &alloc, &offset)) {
         VK_CALL(DestroyImage(this->device(), image, nullptr));
         return 0;
     }
 
     if (srcData) {
         if (linearTiling) {
             const VkImageSubresource subres = {
                 VK_IMAGE_ASPECT_COLOR_BIT,
                 0,  // mipLevel
                 0,  // arraySlice
             };
             VkSubresourceLayout layout;
             VkResult err;
 
             VK_CALL(GetImageSubresourceLayout(fDevice, image, &subres, &layout));
 
             void* mapPtr;
             err = VK_CALL(MapMemory(fDevice, alloc, 0, layout.rowPitch * h, 0, &mapPtr));
             if (err) {
-                VK_CALL(FreeMemory(this->device(), alloc, nullptr));
+                GrVkMemory::FreeImageMemory(this, alloc, offset);
                 VK_CALL(DestroyImage(this->device(), image, nullptr));
                 return 0;
             }
 
             size_t bpp = GrBytesPerPixel(config);
             size_t rowCopyBytes = bpp * w;
             // If there is no padding on dst (layout.rowPitch) we can do a single memcopy.
             // This assumes the srcData comes in with no padding.
             if (rowCopyBytes == layout.rowPitch) {
                 memcpy(mapPtr, srcData, rowCopyBytes * h);
             } else {
                 SkRectMemcpy(mapPtr, static_cast<size_t>(layout.rowPitch), srcData, rowCopyBytes,
                              rowCopyBytes, h);
             }
             VK_CALL(UnmapMemory(fDevice, alloc));
         } else {
             // TODO: Add support for copying to optimal tiling
             SkASSERT(false);
         }
     }
 
     GrVkImageInfo* info = new GrVkImageInfo;
     info->fImage = image;
     info->fAlloc = alloc;
+    info->fOffset = offset;
     info->fImageTiling = imageTiling;
     info->fImageLayout = initialLayout;
     info->fFormat = pixelFormat;
     info->fLevelCount = 1;
 
     return (GrBackendObject)info;
 }
 
 bool GrVkGpu::isTestingOnlyBackendTexture(GrBackendObject id) const {
     const GrVkImageInfo* backend = reinterpret_cast<const GrVkImageInfo*>(id);
@@ skipping 13 matching lines @@
 }
 
 void GrVkGpu::deleteTestingOnlyBackendTexture(GrBackendObject id, bool abandon) {
     const GrVkImageInfo* backend = reinterpret_cast<const GrVkImageInfo*>(id);
 
     if (backend) {
         if (!abandon) {
             // something in the command buffer may still be using this, so force submit
             this->submitCommandBuffer(kForce_SyncQueue);
 
-            VK_CALL(FreeMemory(this->device(), backend->fAlloc, nullptr));
+            GrVkMemory::FreeImageMemory(this, backend->fAlloc, backend->fOffset);
             VK_CALL(DestroyImage(this->device(), backend->fImage, nullptr));
         }
         delete backend;
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrVkGpu::addMemoryBarrier(VkPipelineStageFlags srcStageMask,
                                VkPipelineStageFlags dstStageMask,
@@ skipping 687 matching lines @@
     aglSwapBuffers(aglGetCurrentContext());
     int set_a_break_pt_here = 9;
     aglSwapBuffers(aglGetCurrentContext());
 #elif defined(SK_BUILD_FOR_WIN32)
     SwapBuf();
     int set_a_break_pt_here = 9;
     SwapBuf();
 #endif
 #endif
 }