lib/ui/gfx/resources/gpu_image.cc

// Copyright 2017 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "garnet/lib/ui/gfx/resources/gpu_image.h"

#include "garnet/lib/ui/gfx/engine/session.h"
#include "garnet/lib/ui/gfx/resources/memory.h"
#include "lib/escher/impl/naive_image.h"
#include "lib/escher/util/image_utils.h"

namespace scenic_impl {
namespace gfx {

const ResourceTypeInfo GpuImage::kTypeInfo = {
    ResourceType::kGpuImage | ResourceType::kImage | ResourceType::kImageBase,
    "GpuImage"};

GpuImage::GpuImage(Session* session, ResourceId id, escher::GpuMemPtr gpu_mem,
                   escher::ImageInfo image_info, vk::Image vk_image)
    : Image(session, id, GpuImage::kTypeInfo) {
  image_ = escher::impl::NaiveImage::AdoptVkImage(
      session->resource_context().escher_resource_recycler, image_info,
      vk_image, std::move(gpu_mem));
  FXL_CHECK(image_);
}

GpuImagePtr GpuImage::New(Session* session, ResourceId id, MemoryPtr memory,
                          const fuchsia::images::ImageInfo& image_info,
                          uint64_t memory_offset,
                          ErrorReporter* error_reporter) {
  vk::Format pixel_format = vk::Format::eUndefined;
  size_t bytes_per_pixel;
  size_t pixel_alignment;
  switch (image_info.pixel_format) {
    case fuchsia::images::PixelFormat::BGRA_8:
      pixel_format = vk::Format::eB8G8R8A8Unorm;
      bytes_per_pixel = 4u;
      pixel_alignment = 4u;
      break;
    case fuchsia::images::PixelFormat::YUY2:
    case fuchsia::images::PixelFormat::NV12:
    case fuchsia::images::PixelFormat::YV12:
      error_reporter->ERROR()
          << "GpuImage::CreateFromMemory(): PixelFormat must be BGRA_8.";
      return nullptr;
  }

  if (image_info.width <= 0) {
    error_reporter->ERROR()
        << "GpuImage::CreateFromMemory(): width must be greater than 0.";
    return nullptr;
  }
  if (image_info.height <= 0) {
    error_reporter->ERROR()
        << "GpuImage::CreateFromMemory(): height must be greater than 0.";
    return nullptr;
  }

  auto& caps = session->resource_context().vk_device_queues_capabilities;
  if (image_info.width > caps.max_image_width) {
    error_reporter->ERROR()
        << "GpuImage::CreateFromMemory(): image width exceeds maximum ("
        << image_info.width << " vs. " << caps.max_image_width << ").";
    return nullptr;
  }
  if (image_info.height > caps.max_image_height) {
    error_reporter->ERROR()
        << "GpuImage::CreateFromMemory(): image height exceeds maximum ("
        << image_info.height << " vs. " << caps.max_image_height << ").";
    return nullptr;
  }

  escher::ImageInfo escher_image_info;
  escher_image_info.format = pixel_format;
  escher_image_info.width = image_info.width;
  escher_image_info.height = image_info.height;
  escher_image_info.sample_count = 1;
  escher_image_info.usage = vk::ImageUsageFlagBits::eTransferSrc |
                            vk::ImageUsageFlagBits::eTransferDst |
                            vk::ImageUsageFlagBits::eSampled;
  // TODO(SCN-1182): Add unit tests to verify this logic.
  switch (image_info.tiling) {
    case fuchsia::images::Tiling::LINEAR:
      escher_image_info.tiling = vk::ImageTiling::eLinear;
      break;
    case fuchsia::images::Tiling::GPU_OPTIMAL:
      escher_image_info.tiling = vk::ImageTiling::eOptimal;
      break;
  }
  // TODO(SCN-1012): Don't hardcode this -- use the data on the memory
  // object once we support a bitmask instead of an enum.
  escher_image_info.memory_flags = vk::MemoryPropertyFlagBits::eDeviceLocal;

  vk::Device vk_device = session->resource_context().vk_device;
  vk::Image vk_image =
      escher::image_utils::CreateVkImage(vk_device, escher_image_info);

  // Make sure that the image is within range of its associated memory.
  vk::MemoryRequirements memory_reqs;
  vk_device.getImageMemoryRequirements(vk_image, &memory_reqs);

  if (memory_offset >= memory->size()) {
    error_reporter->ERROR()
        << "GpuImage::CreateFromMemory(): the offset of the Image must be "
        << "within the range of the Memory";
    return nullptr;
  }

  if (memory_offset + memory_reqs.size > memory->size()) {
    error_reporter->ERROR()
        << "GpuImage::CreateFromMemory(): the Image must fit within the size "
        << "of the Memory";
    return nullptr;
  }

  // Make a pointer to a subregion of the memory, if necessary.
  escher::GpuMemPtr gpu_mem =
      (memory_offset > 0 || memory_reqs.size < memory->size())
          ? memory->GetGpuMem()->Suballocate(memory_reqs.size, memory_offset)
          : memory->GetGpuMem();

  return fxl::AdoptRef(new GpuImage(session, id, std::move(gpu_mem),
                                    escher_image_info, vk_image));
}

bool GpuImage::UpdatePixels(escher::BatchGpuUploader* uploader) {
  return false;
}

}  // namespace gfx
}  // namespace scenic_impl