impeller::AllocatedTextureSourceVK Class Reference

Inheritance diagram for impeller::AllocatedTextureSourceVK:

Public Member Functions
	AllocatedTextureSourceVK (const ContextVK &context, const TextureDescriptor &desc, VmaAllocator allocator, vk::Device device, bool supports_memoryless_textures)
	~AllocatedTextureSourceVK ()=default
bool	IsValid () const
vk::Image	GetImage () const override
	Get the image handle for this texture source. More...
vk::ImageView	GetImageView () const override
	Retrieve the image view used for sampling/blitting/compute with this texture source. More...
vk::ImageView	GetRenderTargetView (uint32_t mip_level, uint32_t array_layer) const override
	Retrieve the image view used to attach a specific subresource of this texture as a render target. More...
bool	IsSwapchainImage () const override
	Determines if swapchain image. That is, an image used as the root render target. More...
Public Member Functions inherited from impeller::TextureSourceVK
virtual	~TextureSourceVK ()
const TextureDescriptor &	GetTextureDescriptor () const
	Gets the texture descriptor for this image source. More...
fml::Status	SetLayout (const BarrierVK &barrier) const
	Encodes the layout transition barrier to barrier.cmd_buffer for the image. More...
vk::ImageLayout	SetLayoutWithoutEncoding (vk::ImageLayout layout) const
	Store the layout of the image. More...
vk::ImageLayout	GetLayout () const
	Get the last layout assigned to the TextureSourceVK. More...
virtual std::shared_ptr< YUVConversionVK >	GetYUVConversion () const
	When sampling from textures whose formats are not known to Vulkan, a custom conversion is necessary to setup custom samplers. This accessor provides this conversion if one is present. Most texture source have none. More...
void	SetCachedFrameData (const FramebufferAndRenderPass &data, SampleCount sample_count, uint32_t mip_level=0u, uint32_t slice=0u)
FramebufferAndRenderPass	GetCachedFrameData (SampleCount sample_count, uint32_t mip_level=0u, uint32_t slice=0u) const

Additional Inherited Members
Protected Member Functions inherited from impeller::TextureSourceVK
	TextureSourceVK (TextureDescriptor desc)
Protected Attributes inherited from impeller::TextureSourceVK
const TextureDescriptor	desc_

Detailed Description

Definition at line 289 of file allocator_vk.cc.

Constructor & Destructor Documentation

AllocatedTextureSourceVK()

impeller::AllocatedTextureSourceVK::AllocatedTextureSourceVK ( const ContextVK &  context, const TextureDescriptor &  desc, VmaAllocator  allocator, vk::Device  device, bool  supports_memoryless_textures  )

inline

Definition at line 291 of file allocator_vk.cc.

      : TextureSourceVK(desc), resource_(context.GetResourceManager()) {
    FML_DCHECK(desc.format != PixelFormat::kUnknown);
    vk::StructureChain<vk::ImageCreateInfo, vk::ImageCompressionControlEXT>
        image_info_chain;
    auto& image_info = image_info_chain.get();
    image_info.flags = ToVKImageCreateFlags(desc.type);
    image_info.imageType = vk::ImageType::e2D;
    image_info.format = ToVKImageFormat(desc.format);
    image_info.extent = VkExtent3D{
        static_cast<uint32_t>(desc.size.width),   // width
        static_cast<uint32_t>(desc.size.height),  // height
        1u                                        // depth
    };
    image_info.samples = ToVKSampleCount(desc.sample_count);
    image_info.mipLevels = desc.mip_count;
    image_info.arrayLayers = ToArrayLayerCount(desc.type);
    image_info.tiling = vk::ImageTiling::eOptimal;
    image_info.initialLayout = vk::ImageLayout::eUndefined;
    image_info.usage = AllocatorVK::ToVKImageUsageFlags(
        desc.format, desc.usage, desc.storage_mode,
        supports_memoryless_textures);
    image_info.sharingMode = vk::SharingMode::eExclusive;
 
    vk::ImageCompressionFixedRateFlagsEXT frc_rates[1] = {
        vk::ImageCompressionFixedRateFlagBitsEXT::eNone};
 
    const auto frc_rate =
        CapabilitiesVK::Cast(*context.GetCapabilities())
            .GetSupportedFRCRate(desc.compression_type,
                                 FRCFormatDescriptor{image_info});
    if (frc_rate.has_value()) {
      // This array must not be in a temporary scope.
      frc_rates[0] = frc_rate.value();
 
      auto& compression_info =
          image_info_chain.get<vk::ImageCompressionControlEXT>();
      compression_info.pFixedRateFlags = frc_rates;
      compression_info.compressionControlPlaneCount = 1u;
      compression_info.flags =
          vk::ImageCompressionFlagBitsEXT::eFixedRateExplicit;
    } else {
      image_info_chain.unlink<vk::ImageCompressionControlEXT>();
    }
 
    VmaAllocationCreateInfo alloc_nfo = {};
 
    alloc_nfo.usage = ToVMAMemoryUsage();
    alloc_nfo.preferredFlags =
        static_cast<VkMemoryPropertyFlags>(ToVKTextureMemoryPropertyFlags(
            desc.storage_mode, supports_memoryless_textures));
    alloc_nfo.flags = ToVmaAllocationCreateFlags(desc.storage_mode);
 
    VkImage vk_image = VK_NULL_HANDLE;
    VmaAllocation allocation = {};
    VmaAllocationInfo allocation_info = {};
 
    // Performs the VMA image allocation using the current create-info chain.
    // The native create-info is re-derived from the chain on each call, so an
    // unlink of the compression-control struct between calls is reflected.
    const auto try_create_image = [&]() -> vk::Result {
      vk::ImageCreateInfo::NativeType create_info_native =
          static_cast<vk::ImageCreateInfo::NativeType>(
              image_info_chain.get<vk::ImageCreateInfo>());
      return vk::Result{::vmaCreateImage(allocator,            //
                                         &create_info_native,  //
                                         &alloc_nfo,           //
                                         &vk_image,            //
                                         &allocation,          //
                                         &allocation_info      //
                                         )};
    };
 
    // Fixed-rate compression was requested iff a rate was selected above.
    const bool requested_compression = frc_rate.has_value();
    vk::Result alloc_result = try_create_image();
 
    // Some drivers (e.g. PowerVR) can return VK_ERROR_COMPRESSION_EXHAUSTED_EXT
    // when fixed-rate compression resources are depleted. Per the Vulkan spec
    // this error is only returned for fixed-rate compression requests, so
    // retrying without compression is a valid recovery. Without it the
    // allocation fails, the texture is invalid, and the resulting null render
    // target crashes the raster thread.
    if (alloc_result == vk::Result::eErrorCompressionExhaustedEXT &&
        requested_compression) {
      static std::once_flag warn_once;
      std::call_once(warn_once, [] {
        FML_LOG(WARNING)
            << "Fixed-rate image compression exhausted; falling back to "
               "uncompressed image allocation. (This message is logged once.)";
      });
      // The compression-control struct is only present here because compression
      // was requested above, so unlinking it once is safe (no double-unlink).
      image_info_chain.unlink<vk::ImageCompressionControlEXT>();
      alloc_result = try_create_image();
    }
 
    if (alloc_result != vk::Result::eSuccess) {
      VALIDATION_LOG << "Unable to allocate Vulkan Image: "
                     << vk::to_string(alloc_result)
                     << " Type: " << TextureTypeToString(desc.type)
                     << " Mode: " << StorageModeToString(desc.storage_mode)
                     << " Usage: " << TextureUsageMaskToString(desc.usage)
                     << " [VK]Flags: " << vk::to_string(image_info.flags)
                     << " [VK]Format: " << vk::to_string(image_info.format)
                     << " [VK]Usage: " << vk::to_string(image_info.usage)
                     << " [VK]Mem. Flags: "
                     << vk::to_string(
                            vk::MemoryPropertyFlags(alloc_nfo.preferredFlags));
      return;
    }
 
    auto image = vk::Image{vk_image};
 
    vk::ImageViewCreateInfo view_info = {};
    view_info.image = image;
    view_info.viewType = ToVKImageViewType(desc.type);
    view_info.format = image_info.format;
    view_info.subresourceRange.aspectMask = ToVKImageAspectFlags(desc.format);
    view_info.subresourceRange.levelCount = image_info.mipLevels;
    view_info.subresourceRange.layerCount = ToArrayLayerCount(desc.type);
 
    // Vulkan does not have an image format that is equivalent to
    // `MTLPixelFormatA8Unorm`, so we use `R8Unorm` instead. Given that the
    // shaders expect that alpha channel to be set in the cases, we swizzle.
    // See: https://github.com/flutter/flutter/issues/115461 for more details.
    if (desc.format == PixelFormat::kA8UNormInt) {
      view_info.components.a = vk::ComponentSwizzle::eR;
      view_info.components.r = vk::ComponentSwizzle::eA;
    }
 
    auto [result, image_view] = device.createImageViewUnique(view_info);
    if (result != vk::Result::eSuccess) {
      VALIDATION_LOG << "Unable to create an image view for allocation: "
                     << vk::to_string(result);
      return;
    }
    // Create one 2D attachment view per (mip level, array layer) so a
    // specific subresource can be rendered into. Render targets are usually a
    // single 2D mip (one view); cube and mipmapped render targets get the
    // full set. Non-render-target textures only need the base view.
    view_info.viewType = vk::ImageViewType::e2D;
    view_info.subresourceRange.levelCount = 1u;
    view_info.subresourceRange.layerCount = 1u;
    const bool is_render_target = !!(desc.usage & TextureUsage::kRenderTarget);
    const uint32_t rt_mip_count = is_render_target ? image_info.mipLevels : 1u;
    const uint32_t rt_layer_count =
        is_render_target ? ToArrayLayerCount(desc.type) : 1u;
    std::vector<vk::UniqueImageView> rt_image_views;
    rt_image_views.reserve(rt_mip_count * rt_layer_count);
    for (uint32_t mip = 0; mip < rt_mip_count; mip++) {
      for (uint32_t layer = 0; layer < rt_layer_count; layer++) {
        view_info.subresourceRange.baseMipLevel = mip;
        view_info.subresourceRange.baseArrayLayer = layer;
        auto [rt_result, rt_image_view] =
            device.createImageViewUnique(view_info);
        if (rt_result != vk::Result::eSuccess) {
          VALIDATION_LOG << "Unable to create a render target image view: "
                         << vk::to_string(rt_result);
          return;
        }
        rt_image_views.push_back(std::move(rt_image_view));
      }
    }
 
    resource_.Swap(ImageResource(
        ImageVMA{allocator, allocation, image}, std::move(image_view),
        std::move(rt_image_views), context.GetResourceAllocator(),
        context.GetDeviceHolder()));
    is_valid_ = true;
  }

References impeller::TextureDescriptor::compression_type, context, impeller::TextureDescriptor::format, impeller::TSize< T >::height, impeller::TextureDescriptor::mip_count, impeller::TextureDescriptor::sample_count, impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, impeller::StorageModeToString(), impeller::TextureTypeToString(), impeller::TextureUsageMaskToString(), impeller::ToArrayLayerCount(), impeller::ToVKImageAspectFlags(), impeller::ToVKImageCreateFlags(), impeller::ToVKImageFormat(), impeller::ToVKImageViewType(), impeller::ToVKSampleCount(), impeller::ToVKTextureMemoryPropertyFlags(), impeller::ToVmaAllocationCreateFlags(), impeller::ToVMAMemoryUsage(), impeller::TextureDescriptor::type, impeller::TextureDescriptor::usage, VALIDATION_LOG, and impeller::TSize< T >::width.

~AllocatedTextureSourceVK()

impeller::AllocatedTextureSourceVK::~AllocatedTextureSourceVK ( )

default

Member Function Documentation

GetImage()

vk::Image impeller::AllocatedTextureSourceVK::GetImage ( ) const

inlineoverridevirtual

Get the image handle for this texture source.

Returns

The image.

Implements impeller::TextureSourceVK.

Definition at line 471 of file allocator_vk.cc.

{ return resource_->image.get().image; }

GetImageView()

vk::ImageView impeller::AllocatedTextureSourceVK::GetImageView ( ) const

inlineoverridevirtual

Retrieve the image view used for sampling/blitting/compute with this texture source.

Returns

The image view.

Implements impeller::TextureSourceVK.

Definition at line 473 of file allocator_vk.cc.

                                            {
    return resource_->image_view.get();
  }

GetRenderTargetView()

vk::ImageView impeller::AllocatedTextureSourceVK::GetRenderTargetView ( uint32_t  mip_level, uint32_t  array_layer  ) const

inlineoverridevirtual

Retrieve the image view used to attach a specific subresource of this texture as a render target.

The returned view covers a single mip level and a single array layer (or cube map face), since attachment views cannot span multiple levels or layers.

Parameters

[in]	mip_level	The mip level to attach.
[in]	array_layer	The array layer or cube map face to attach.

Returns

The render target view.

Implements impeller::TextureSourceVK.

Definition at line 477 of file allocator_vk.cc.

                                                                         {
    const auto& views = resource_->rt_image_views;
    if (views.empty()) {
      return VK_NULL_HANDLE;
    }
    const uint32_t layer_count = ToArrayLayerCount(GetTextureDescriptor().type);
    const size_t index =
        static_cast<size_t>(mip_level) * layer_count + array_layer;
    return index < views.size() ? views[index].get() : views[0].get();
  }

References impeller::ToArrayLayerCount().

IsSwapchainImage()

bool impeller::AllocatedTextureSourceVK::IsSwapchainImage ( ) const

inlineoverridevirtual

Determines if swapchain image. That is, an image used as the root render target.

Returns

Whether or not this is a swapchain image.

Implements impeller::TextureSourceVK.

Definition at line 489 of file allocator_vk.cc.

{ return false; }

IsValid()

bool impeller::AllocatedTextureSourceVK::IsValid ( ) const

inline

Definition at line 469 of file allocator_vk.cc.

{ return is_valid_; }

---

The documentation for this class was generated from the following file:

• impeller/renderer/backend/vulkan/allocator_vk.cc