| // 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/scenic/resources/host_image.h" |
| |
| #include "garnet/lib/ui/scenic/engine/session.h" |
| #include "garnet/lib/ui/scenic/resources/gpu_memory.h" |
| #include "garnet/lib/ui/scenic/resources/host_memory.h" |
| #include "lib/escher/util/image_utils.h" |
| #include "lib/escher/util/image_formats.h" |
| |
| namespace scene_manager { |
| |
| const ResourceTypeInfo HostImage::kTypeInfo = { |
| ResourceType::kHostImage | ResourceType::kImage | ResourceType::kImageBase, |
| "HostImage"}; |
| |
| HostImage::HostImage(Session* session, |
| scenic::ResourceId id, |
| HostMemoryPtr memory, |
| escher::ImagePtr gpu_image, |
| uint64_t host_memory_offset, |
| scenic::ImageInfo host_image_format) |
| : Image(session, id, HostImage::kTypeInfo), |
| memory_(std::move(memory)), |
| memory_offset_(host_memory_offset), |
| host_image_format_(host_image_format) { |
| image_ = std::move(gpu_image); |
| image_conversion_function_ = |
| escher::image_formats::GetConversionFunction(host_image_format); |
| } |
| |
| ImagePtr HostImage::New(Session* session, |
| scenic::ResourceId id, |
| HostMemoryPtr host_memory, |
| const scenic::ImageInfoPtr& host_image_info, |
| uint64_t memory_offset, |
| mz::ErrorReporter* error_reporter) { |
| // No matter what the incoming format, the gpu format will be BGRA: |
| vk::Format gpu_image_pixel_format = vk::Format::eB8G8R8A8Unorm; |
| size_t bytes_per_pixel = |
| escher::image_formats::BytesPerPixel(host_image_info->pixel_format); |
| size_t pixel_alignment = |
| escher::image_formats::PixelAlignment(host_image_info->pixel_format); |
| |
| if (host_image_info->width <= 0) { |
| error_reporter->ERROR() |
| << "Image::CreateFromMemory(): width must be greater than 0."; |
| return nullptr; |
| } |
| if (host_image_info->height <= 0) { |
| error_reporter->ERROR() |
| << "Image::CreateFromMemory(): height must be greater than 0."; |
| return nullptr; |
| } |
| |
| auto& caps = session->engine()->escher()->device()->caps(); |
| if (host_image_info->width > caps.max_image_width) { |
| error_reporter->ERROR() |
| << "Image::CreateFromMemory(): image width exceeds maximum (" |
| << host_image_info->width << " vs. " << caps.max_image_width << ")."; |
| return nullptr; |
| } |
| if (host_image_info->height > caps.max_image_height) { |
| error_reporter->ERROR() |
| << "Image::CreateFromMemory(): image height exceeds maximum (" |
| << host_image_info->height << " vs. " << caps.max_image_height << ")."; |
| return nullptr; |
| } |
| |
| if (host_image_info->stride < host_image_info->width * bytes_per_pixel) { |
| error_reporter->ERROR() |
| << "Image::CreateFromMemory(): stride too small for width."; |
| return nullptr; |
| } |
| if (host_image_info->stride % pixel_alignment != 0) { |
| error_reporter->ERROR() |
| << "Image::CreateFromMemory(): stride must preserve pixel alignment."; |
| return nullptr; |
| } |
| if (host_image_info->tiling != scenic::ImageInfo::Tiling::LINEAR) { |
| error_reporter->ERROR() |
| << "Image::CreateFromMemory(): tiling must be LINEAR for images " |
| << "created using host memory."; |
| return nullptr; |
| } |
| |
| size_t image_size = host_image_info->height * host_image_info->stride; |
| if (memory_offset >= host_memory->size()) { |
| error_reporter->ERROR() |
| << "Image::CreateFromMemory(): the offset of the Image must be " |
| << "within the range of the Memory"; |
| return nullptr; |
| } |
| |
| if (memory_offset + image_size > host_memory->size()) { |
| error_reporter->ERROR() |
| << "Image::CreateFromMemory(): the Image must fit within the size " |
| << "of the Memory"; |
| return nullptr; |
| } |
| |
| // TODO(MZ-141): Support non-minimal strides. |
| if (host_image_info->stride != host_image_info->width * bytes_per_pixel) { |
| error_reporter->ERROR() |
| << "Image::CreateFromMemory(): the stride must be minimal (MZ-141)"; |
| return nullptr; |
| } |
| |
| auto escher_image = escher::image_utils::NewGpuImageFromPixels( |
| session->engine()->escher_image_factory(), gpu_image_pixel_format, |
| host_image_info->width, host_image_info->height); |
| |
| return fxl::AdoptRef(new HostImage(session, id, std::move(host_memory), |
| std::move(escher_image), memory_offset, |
| *host_image_info)); |
| } |
| |
| bool HostImage::UpdatePixels() { |
| if (session()->engine()->escher_gpu_uploader()) { |
| escher::image_utils::WritePixelsToImage( |
| session()->engine()->escher_gpu_uploader(), |
| static_cast<uint8_t*>(memory_->memory_base()) + memory_offset_, image_, |
| image_conversion_function_); |
| return true; |
| } |
| return false; |
| } |
| |
| ImagePtr HostImage::NewForTesting(Session* session, |
| scenic::ResourceId id, |
| escher::ResourceManager* image_owner, |
| HostMemoryPtr host_memory) { |
| escher::ImagePtr escher_image = escher::Image::New( |
| image_owner, escher::ImageInfo(), vk::Image(), nullptr); |
| FXL_CHECK(escher_image); |
| scenic::ImageInfo host_image_format; |
| host_image_format.pixel_format = scenic::ImageInfo::PixelFormat::BGRA_8; |
| return fxl::AdoptRef(new HostImage(session, id, host_memory, escher_image, 0, |
| host_image_format)); |
| } |
| |
| } // namespace scene_manager |