[Impeller] Use a device buffer for SkBitmap allocation, use Linear texture on Metal backend.

impeller/renderer/backend/metal/context_mtl.mm

@@ -55,6 +55,7 @@ static bool DeviceSupportsComputeSubgroups(id<MTLDevice> device) {
       .SetSupportsBufferToTextureBlits(true)
       .SetSupportsTextureToTextureBlits(true)
       .SetSupportsDecalTileMode(true)
+      .SetSupportsSharedDeviceBufferTextureMemory(true)
       .SetSupportsFramebufferFetch(DeviceSupportsFramebufferFetch(device))
       .SetDefaultColorFormat(color_format)
       .SetDefaultStencilFormat(PixelFormat::kS8UInt)

impeller/renderer/backend/vulkan/capabilities_vk.cc

@@ -348,10 +348,16 @@ bool CapabilitiesVK::SupportsReadFromOnscreenTexture() const {
   return false;
 }
 
+// |Capabilities|
 bool CapabilitiesVK::SupportsDecalTileMode() const {
   return true;
 }
 
+// |Capabilities|
+bool CapabilitiesVK::SupportsSharedDeviceBufferTextureMemory() const {
+  return false;
+}
+
 // |Capabilities|
 PixelFormat CapabilitiesVK::GetDefaultColorFormat() const {
   return color_format_;

impeller/renderer/backend/vulkan/capabilities_vk.h

@@ -79,6 +79,9 @@ class CapabilitiesVK final : public Capabilities,
   // |Capabilities|
   bool SupportsDecalTileMode() const override;
 
+  // |Capabilities|
+  bool SupportsSharedDeviceBufferTextureMemory() const override;
+
   // |Capabilities|
   PixelFormat GetDefaultColorFormat() const override;
 

impeller/renderer/capabilities.cc

@@ -66,6 +66,11 @@ class StandardCapabilities final : public Capabilities {
     return supports_decal_tile_mode_;
   }
 
+  // |Capabilities|
+  bool SupportsSharedDeviceBufferTextureMemory() const override {
+    return supports_shared_device_buffer_texture_memory_;
+  }
+
   // |Capabilities|
   PixelFormat GetDefaultColorFormat() const override {
     return default_color_format_;
@@ -88,6 +93,7 @@ class StandardCapabilities final : public Capabilities {
                        bool supports_read_from_onscreen_texture,
                        bool supports_read_from_resolve,
                        bool supports_decal_tile_mode,
+                       bool supports_shared_device_buffer_texture_memory,
                        PixelFormat default_color_format,
                        PixelFormat default_stencil_format)
       : has_threading_restrictions_(has_threading_restrictions),
@@ -102,6 +108,8 @@ class StandardCapabilities final : public Capabilities {
             supports_read_from_onscreen_texture),
         supports_read_from_resolve_(supports_read_from_resolve),
         supports_decal_tile_mode_(supports_decal_tile_mode),
+        supports_shared_device_buffer_texture_memory_(
+            supports_shared_device_buffer_texture_memory),
         default_color_format_(default_color_format),
         default_stencil_format_(default_stencil_format) {}
 
@@ -118,6 +126,7 @@ class StandardCapabilities final : public Capabilities {
   bool supports_read_from_onscreen_texture_ = false;
   bool supports_read_from_resolve_ = false;
   bool supports_decal_tile_mode_ = false;
+  bool supports_shared_device_buffer_texture_memory_ = false;
   PixelFormat default_color_format_ = PixelFormat::kUnknown;
   PixelFormat default_stencil_format_ = PixelFormat::kUnknown;
 
@@ -202,6 +211,12 @@ CapabilitiesBuilder& CapabilitiesBuilder::SetSupportsDecalTileMode(bool value) {
   return *this;
 }
 
+CapabilitiesBuilder&
+CapabilitiesBuilder::SetSupportsSharedDeviceBufferTextureMemory(bool value) {
+  supports_shared_device_buffer_texture_memory_ = value;
+  return *this;
+}
+
 std::unique_ptr<Capabilities> CapabilitiesBuilder::Build() {
   return std::unique_ptr<StandardCapabilities>(new StandardCapabilities(  //
       has_threading_restrictions_,                                        //
@@ -215,6 +230,7 @@ std::unique_ptr<Capabilities> CapabilitiesBuilder::Build() {
       supports_read_from_onscreen_texture_,                               //
       supports_read_from_resolve_,                                        //
       supports_decal_tile_mode_,                                          //
+      supports_shared_device_buffer_texture_memory_,                      //
       *default_color_format_,                                             //
       *default_stencil_format_                                            //
       ));

impeller/renderer/capabilities.h

@@ -37,6 +37,8 @@ class Capabilities {
 
   virtual bool SupportsDecalTileMode() const = 0;
 
+  virtual bool SupportsSharedDeviceBufferTextureMemory() const = 0;
+
   virtual PixelFormat GetDefaultColorFormat() const = 0;
 
   virtual PixelFormat GetDefaultStencilFormat() const = 0;
@@ -79,6 +81,8 @@ class CapabilitiesBuilder {
 
   CapabilitiesBuilder& SetSupportsDecalTileMode(bool value);
 
+  CapabilitiesBuilder& SetSupportsSharedDeviceBufferTextureMemory(bool value);
+
   std::unique_ptr<Capabilities> Build();
 
  private:
@@ -93,6 +97,7 @@ class CapabilitiesBuilder {
   bool supports_read_from_onscreen_texture_ = false;
   bool supports_read_from_resolve_ = false;
   bool supports_decal_tile_mode_ = false;
+  bool supports_shared_device_buffer_texture_memory_ = false;
   std::optional<PixelFormat> default_color_format_ = std::nullopt;
   std::optional<PixelFormat> default_stencil_format_ = std::nullopt;
 

impeller/renderer/capabilities_unittests.cc

@@ -29,6 +29,7 @@ CAPABILITY_TEST(SupportsComputeSubgroups, false);
 CAPABILITY_TEST(SupportsReadFromOnscreenTexture, false);
 CAPABILITY_TEST(SupportsReadFromResolve, false);
 CAPABILITY_TEST(SupportsDecalTileMode, false);
+CAPABILITY_TEST(SupportsSharedDeviceBufferTextureMemory, false);
 
 }  // namespace testing
 }  // namespace impeller

impeller/typographer/backends/skia/text_render_context_skia.cc

@@ -10,11 +10,13 @@
 #include "flutter/fml/trace_event.h"
 #include "impeller/base/allocation.h"
 #include "impeller/core/allocator.h"
+#include "impeller/core/device_buffer.h"
 #include "impeller/typographer/backends/skia/typeface_skia.h"
-#include "third_party/skia/include/core/SkBitmap.h"
+
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkFont.h"
 #include "third_party/skia/include/core/SkFontMetrics.h"
+#include "third_party/skia/include/core/SkPixelRef.h"
 #include "third_party/skia/include/core/SkRSXform.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/src/core/SkIPoint16.h"   // nogncheck
@@ -139,7 +141,9 @@ ISize OptimumAtlasSizeForFontGlyphPairs(
     const FontGlyphPair::Set& pairs,
     std::vector<Rect>& glyph_positions,
     const std::shared_ptr<GlyphAtlasContext>& atlas_context) {
-  static constexpr auto kMinAtlasSize = 8u;
+  // This size needs to be above the minimum required aligment for linear
+  // textures. This is 256 for older intel macs and decreases on iOS devices.
+  static constexpr auto kMinAtlasSize = 256u;
   static constexpr auto kMaxAtlasSize = 4096u;
 
   TRACE_EVENT0("impeller", __FUNCTION__);
@@ -346,9 +350,12 @@ static bool UpdateAtlasBitmap(const GlyphAtlas& atlas,
   return true;
 }
 
-static std::shared_ptr<SkBitmap> CreateAtlasBitmap(const GlyphAtlas& atlas,
-                                                   const ISize& atlas_size) {
+static std::pair<std::shared_ptr<SkBitmap>, std::shared_ptr<DeviceBuffer>>
+CreateAtlasBitmap(const GlyphAtlas& atlas,
+                  std::shared_ptr<Allocator> allocator,
+                  const ISize& atlas_size) {
   TRACE_EVENT0("impeller", __FUNCTION__);
+  auto font_allocator = FontImpellerAllocator(std::move(allocator));
   auto bitmap = std::make_shared<SkBitmap>();
   SkImageInfo image_info;
 
@@ -363,17 +370,18 @@ static std::shared_ptr<SkBitmap> CreateAtlasBitmap(const GlyphAtlas& atlas,
       break;
   }
 
-  if (!bitmap->tryAllocPixels(image_info)) {
-    return nullptr;
+  bitmap->setInfo(image_info);
+  if (!bitmap->tryAllocPixels(&font_allocator)) {
+    return std::make_pair(nullptr, nullptr);
   }
 
   auto surface = SkSurface::MakeRasterDirect(bitmap->pixmap());
   if (!surface) {
-    return nullptr;
+    return std::make_pair(nullptr, nullptr);
   }
   auto canvas = surface->getCanvas();
   if (!canvas) {
-    return nullptr;
+    return std::make_pair(nullptr, nullptr);
   }
 
   bool has_color = atlas.GetType() == GlyphAtlas::Type::kColorBitmap;
@@ -384,13 +392,16 @@ static std::shared_ptr<SkBitmap> CreateAtlasBitmap(const GlyphAtlas& atlas,
     return true;
   });
 
-  return bitmap;
+  auto device_buffer = font_allocator.GetDeviceBuffer();
+  if (!device_buffer.has_value()) {
+    return std::make_pair(nullptr, nullptr);
+  }
+  return std::make_pair(bitmap, device_buffer.value());
 }
 
 static bool UpdateGlyphTextureAtlas(std::shared_ptr<SkBitmap> bitmap,
                                     const std::shared_ptr<Texture>& texture) {
   TRACE_EVENT0("impeller", __FUNCTION__);
-
   FML_DCHECK(bitmap != nullptr);
   auto texture_descriptor = texture->GetTextureDescriptor();
 
@@ -404,14 +415,12 @@ static bool UpdateGlyphTextureAtlas(std::shared_ptr<SkBitmap> bitmap,
 }
 
 static std::shared_ptr<Texture> UploadGlyphTextureAtlas(
-    const std::shared_ptr<Allocator>& allocator,
-    std::shared_ptr<SkBitmap> bitmap,
+    Allocator& allocator,
+    const std::shared_ptr<DeviceBuffer>& device_buffer,
+    const std::shared_ptr<SkBitmap>& bitmap,
     const ISize& atlas_size,
     PixelFormat format) {
   TRACE_EVENT0("impeller", __FUNCTION__);
-  if (!allocator) {
-    return nullptr;
-  }
 
   FML_DCHECK(bitmap != nullptr);
   const auto& pixmap = bitmap->pixmap();
@@ -421,32 +430,27 @@ static std::shared_ptr<Texture> UploadGlyphTextureAtlas(
   texture_descriptor.format = format;
   texture_descriptor.size = atlas_size;
 
+  // If the alignment isn't a multiple of the pixel format, we cannot use
+  // a linear texture and instead must blit to a new texture.
   if (pixmap.rowBytes() * pixmap.height() !=
       texture_descriptor.GetByteSizeOfBaseMipLevel()) {
     return nullptr;
   }
 
-  auto texture = allocator->CreateTexture(texture_descriptor);
+  FML_DCHECK(allocator.MinimumBytesPerRow(format) <= pixmap.rowBytes());
+  auto texture = device_buffer->AsTexture(allocator, texture_descriptor,
+                                          texture_descriptor.GetBytesPerRow());
   if (!texture || !texture->IsValid()) {
     return nullptr;
   }
   texture->SetLabel("GlyphAtlas");
-
-  auto mapping = std::make_shared<fml::NonOwnedMapping>(
-      reinterpret_cast<const uint8_t*>(bitmap->getAddr(0, 0)),  // data
-      texture_descriptor.GetByteSizeOfBaseMipLevel(),           // size
-      [bitmap](auto, auto) mutable { bitmap.reset(); }          // proc
-  );
-
-  if (!texture->SetContents(mapping)) {
-    return nullptr;
-  }
   return texture;
 }
 
 std::shared_ptr<GlyphAtlas> TextRenderContextSkia::CreateGlyphAtlas(
     GlyphAtlas::Type type,
     std::shared_ptr<GlyphAtlasContext> atlas_context,
+    const std::shared_ptr<const Capabilities>& capabilities,
     FrameIterator frame_iterator) const {
   TRACE_EVENT0("impeller", __FUNCTION__);
   if (!IsValid()) {
@@ -502,15 +506,18 @@ std::shared_ptr<GlyphAtlas> TextRenderContextSkia::CreateGlyphAtlas(
     // ---------------------------------------------------------------------------
     // Step 5: Draw new font-glyph pairs into the existing bitmap.
     // ---------------------------------------------------------------------------
-    auto bitmap = atlas_context->GetBitmap();
+    auto [bitmap, device_buffer] = atlas_context->GetBitmap();
     if (!UpdateAtlasBitmap(*last_atlas, bitmap, new_glyphs)) {
       return nullptr;
     }
 
     // ---------------------------------------------------------------------------
     // Step 6: Update the existing texture with the updated bitmap.
+    //         This is only necessary on backends that don't support creating
+    //         a texture that shares memory with the underlying device buffer.
     // ---------------------------------------------------------------------------
-    if (!UpdateGlyphTextureAtlas(bitmap, last_atlas->GetTexture())) {
+    if (!capabilities->SupportsSharedDeviceBufferTextureMemory() &&
+        !UpdateGlyphTextureAtlas(bitmap, last_atlas->GetTexture())) {
       return nullptr;
     }
     return last_atlas;
@@ -552,11 +559,12 @@ std::shared_ptr<GlyphAtlas> TextRenderContextSkia::CreateGlyphAtlas(
   // ---------------------------------------------------------------------------
   // Step 7: Draw font-glyph pairs in the correct spot in the atlas.
   // ---------------------------------------------------------------------------
-  auto bitmap = CreateAtlasBitmap(*glyph_atlas, atlas_size);
+  auto [bitmap, device_buffer] = CreateAtlasBitmap(
+      *glyph_atlas, GetContext()->GetResourceAllocator(), atlas_size);
   if (!bitmap) {
     return nullptr;
   }
-  atlas_context->UpdateBitmap(bitmap);
+  atlas_context->UpdateBitmap(bitmap, device_buffer);
 
   // ---------------------------------------------------------------------------
   // Step 8: Upload the atlas as a texture.
@@ -574,8 +582,9 @@ std::shared_ptr<GlyphAtlas> TextRenderContextSkia::CreateGlyphAtlas(
       format = PixelFormat::kR8G8B8A8UNormInt;
       break;
   }
-  auto texture = UploadGlyphTextureAtlas(GetContext()->GetResourceAllocator(),
-                                         bitmap, atlas_size, format);
+  auto texture =
+      UploadGlyphTextureAtlas(*GetContext()->GetResourceAllocator().get(),
+                              device_buffer, bitmap, atlas_size, format);
   if (!texture) {
     return nullptr;
   }
@@ -588,4 +597,43 @@ std::shared_ptr<GlyphAtlas> TextRenderContextSkia::CreateGlyphAtlas(
   return glyph_atlas;
 }
 
+FontImpellerAllocator::FontImpellerAllocator(
+    std::shared_ptr<impeller::Allocator> allocator)
+    : allocator_(std::move(allocator)) {}
+
+std::optional<std::shared_ptr<impeller::DeviceBuffer>>
+FontImpellerAllocator::GetDeviceBuffer() const {
+  return buffer_;
+}
+
+bool FontImpellerAllocator::allocPixelRef(SkBitmap* bitmap) {
+  const SkImageInfo& info = bitmap->info();
+  if (kUnknown_SkColorType == info.colorType() || info.width() < 0 ||
+      info.height() < 0 || !info.validRowBytes(bitmap->rowBytes())) {
+    return false;
+  }
+
+  DeviceBufferDescriptor descriptor;
+  descriptor.storage_mode = StorageMode::kHostVisible;
+  descriptor.size = ((bitmap->height() - 1) * bitmap->rowBytes()) +
+                    (bitmap->width() * bitmap->bytesPerPixel());
+
+  auto device_buffer = allocator_->CreateBuffer(descriptor);
+
+  struct ImpellerPixelRef final : public SkPixelRef {
+    ImpellerPixelRef(int w, int h, void* s, size_t r)
+        : SkPixelRef(w, h, s, r) {}
+
+    ~ImpellerPixelRef() override {}
+  };
+
+  auto pixel_ref = sk_sp<SkPixelRef>(
+      new ImpellerPixelRef(info.width(), info.height(),
+                           device_buffer->OnGetContents(), bitmap->rowBytes()));
+
+  bitmap->setPixelRef(std::move(pixel_ref), 0, 0);
+  buffer_ = std::move(device_buffer);
+  return true;
+}
+
 }  // namespace impeller