gpu_surface_metal_skia.mm

Go to the documentation of this file.

// Copyright 2013 The Flutter 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 "flow/surface_frame.h"
#if !SLIMPELLER
 
#include "flutter/shell/gpu/gpu_surface_metal_skia.h"
 
#import <Metal/Metal.h>
#import <QuartzCore/QuartzCore.h>
 
#include <utility>
 
#include "flutter/common/graphics/persistent_cache.h"
#include "flutter/fml/make_copyable.h"
#include "flutter/fml/platform/darwin/cf_utils.h"
#include "flutter/fml/trace_event.h"
#include "flutter/shell/gpu/gpu_surface_metal_delegate.h"
#include "third_party/skia/include/core/SkColorSpace.h"
#include "third_party/skia/include/core/SkColorType.h"
#include "third_party/skia/include/core/SkRefCnt.h"
#include "third_party/skia/include/core/SkSurface.h"
#include "third_party/skia/include/core/SkSurfaceProps.h"
#include "third_party/skia/include/gpu/GpuTypes.h"
#include "third_party/skia/include/gpu/ganesh/GrBackendSurface.h"
#include "third_party/skia/include/gpu/ganesh/SkSurfaceGanesh.h"
#include "third_party/skia/include/gpu/ganesh/mtl/GrMtlBackendSurface.h"
#include "third_party/skia/include/gpu/ganesh/mtl/GrMtlTypes.h"
#include "third_party/skia/include/ports/SkCFObject.h"
 
static_assert(__has_feature(objc_arc), "ARC must be enabled.");
 
namespace flutter {
 
namespace {
sk_sp<SkSurface> CreateSurfaceFromMetalTexture(GrDirectContext* context,
                                               id<MTLTexture> texture,
                                               GrSurfaceOrigin origin,
                                               SkColorType color_type,
                                               sk_sp<SkColorSpace> color_space,
                                               const SkSurfaceProps* props,
                                               SkSurfaces::TextureReleaseProc release_proc,
                                               SkSurface::ReleaseContext release_context) {
  GrMtlTextureInfo info;
  info.fTexture.retain((__bridge GrMTLHandle)texture);
  GrBackendTexture backend_texture =
      GrBackendTextures::MakeMtl(texture.width, texture.height, skgpu::Mipmapped::kNo, info);
  return SkSurfaces::WrapBackendTexture(context, backend_texture, origin, 1, color_type,
                                        std::move(color_space), props, release_proc,
                                        release_context);
}
}  // namespace
 
GPUSurfaceMetalSkia::GPUSurfaceMetalSkia(GPUSurfaceMetalDelegate* delegate,
                                         sk_sp<GrDirectContext> context,
                                         bool render_to_surface)
    : delegate_(delegate),
      render_target_type_(delegate->GetRenderTargetType()),
      context_(std::move(context)),
      render_to_surface_(render_to_surface) {
  // If this preference is explicitly set, we allow for disabling partial repaint.
  NSNumber* disablePartialRepaint =
      [[NSBundle mainBundle] objectForInfoDictionaryKey:@"FLTDisablePartialRepaint"];
  if (disablePartialRepaint != nil) {
    disable_partial_repaint_ = disablePartialRepaint.boolValue;
  }
}
 
GPUSurfaceMetalSkia::~GPUSurfaceMetalSkia() = default;
 
// |Surface|
bool GPUSurfaceMetalSkia::IsValid() {
  return context_ != nullptr;
}
 
void GPUSurfaceMetalSkia::PrecompileKnownSkSLsIfNecessary() {
  auto* current_context = GetContext();
  if (current_context == precompiled_sksl_context_) {
    // Known SkSLs have already been prepared in this context.
    return;
  }
  precompiled_sksl_context_ = current_context;
  flutter::PersistentCache::GetCacheForProcess()->PrecompileKnownSkSLs(precompiled_sksl_context_);
}
 
// |Surface|
std::unique_ptr<SurfaceFrame> GPUSurfaceMetalSkia::AcquireFrame(const DlISize& frame_size) {
  if (!IsValid()) {
    FML_LOG(ERROR) << "Metal surface was invalid.";
    return nullptr;
  }
 
  if (frame_size.IsEmpty()) {
    FML_LOG(ERROR) << "Metal surface was asked for an empty frame.";
    return nullptr;
  }
 
  if (!render_to_surface_) {
    return std::make_unique<SurfaceFrame>(
        nullptr,                                                                   //
        SurfaceFrame::FramebufferInfo(),                                           //
        [](const SurfaceFrame& surface_frame, DlCanvas* canvas) { return true; },  //
        [](const SurfaceFrame& surface_frame) { return true; },                    //
        frame_size                                                                 //
    );
  }
 
  PrecompileKnownSkSLsIfNecessary();
 
  switch (render_target_type_) {
    case MTLRenderTargetType::kCAMetalLayer:
      return AcquireFrameFromCAMetalLayer(frame_size);
    case MTLRenderTargetType::kMTLTexture:
      return AcquireFrameFromMTLTexture(frame_size);
    default:
      FML_CHECK(false) << "Unknown MTLRenderTargetType type.";
  }
 
  return nullptr;
}
 
std::unique_ptr<SurfaceFrame> GPUSurfaceMetalSkia::AcquireFrameFromCAMetalLayer(
    const DlISize& frame_info) {
  CAMetalLayer* layer = (__bridge CAMetalLayer*)delegate_->GetCAMetalLayer(frame_info);
  if (!layer) {
    FML_LOG(ERROR) << "Invalid CAMetalLayer given by the embedder.";
    return nullptr;
  }
 
  // Get the drawable eagerly, we will need texture object to identify target framebuffer
  id<CAMetalDrawable> drawable = [layer nextDrawable];
  if (!drawable) {
    FML_LOG(ERROR) << "Could not obtain drawable from the metal layer.";
    return nullptr;
  }
 
  auto surface = CreateSurfaceFromMetalTexture(context_.get(), drawable.texture,
                                               kTopLeft_GrSurfaceOrigin,  // origin
                                               kBGRA_8888_SkColorType,    // color type
                                               nullptr,                   // colorspace
                                               nullptr,                   // surface properties
                                               nullptr,                   // release proc
                                               nullptr                    // release context
  );
 
  if (!surface) {
    FML_LOG(ERROR) << "Could not create the SkSurface from the CAMetalLayer.";
    return nullptr;
  }
 
  // drawable is a local and needs to be strongly-captured.
  SurfaceFrame::EncodeCallback encode_callback =
      [this, drawable, layer](const SurfaceFrame& surface_frame, DlCanvas* canvas) -> bool {
    layer.presentsWithTransaction = surface_frame.submit_info().present_with_transaction;
    if (canvas == nullptr) {
      FML_DLOG(ERROR) << "Canvas not available.";
      return false;
    }
 
    {
      TRACE_EVENT0("flutter", "SkCanvas::Flush");
      canvas->Flush();
    }
 
    if (!disable_partial_repaint_) {
      void* texture = (__bridge void*)drawable.texture;
      for (auto& entry : damage_) {
        if (entry.first != texture) {
          // Accumulate damage for other framebuffers
          if (surface_frame.submit_info().frame_damage) {
            entry.second = entry.second.Union(*surface_frame.submit_info().frame_damage);
          }
        }
      }
      // Reset accumulated damage for current framebuffer
      damage_[texture] = DlIRect();
    }
 
    return true;
  };
 
  // drawable is a local and needs to be strongly-captured.
  SurfaceFrame::SubmitCallback submit_callback =
      [this, drawable](const SurfaceFrame& surface_frame) -> bool {
    TRACE_EVENT0("flutter", "GPUSurfaceMetal::Submit");
    return delegate_->PresentDrawable((__bridge GrMTLHandle)drawable);
  };
 
  SurfaceFrame::FramebufferInfo framebuffer_info;
  framebuffer_info.supports_readback = true;
 
  if (!disable_partial_repaint_) {
    // Provide accumulated damage to rasterizer (area in current framebuffer that lags behind
    // front buffer)
    void* texture = (__bridge void*)drawable.texture;
    auto i = damage_.find(texture);
    if (i != damage_.end()) {
      framebuffer_info.existing_damage = i->second;
    }
    framebuffer_info.supports_partial_repaint = true;
  }
 
  return std::make_unique<SurfaceFrame>(std::move(surface), framebuffer_info, encode_callback,
                                        submit_callback, frame_info);
}
 
std::unique_ptr<SurfaceFrame> GPUSurfaceMetalSkia::AcquireFrameFromMTLTexture(
    const DlISize& frame_info) {
  GPUMTLTextureInfo texture = delegate_->GetMTLTexture(frame_info);
  id<MTLTexture> mtl_texture = (__bridge id<MTLTexture>)texture.texture;
 
  if (!mtl_texture) {
    FML_LOG(ERROR) << "Invalid MTLTexture given by the embedder.";
    return nullptr;
  }
 
  sk_sp<SkSurface> surface = CreateSurfaceFromMetalTexture(
      context_.get(), mtl_texture, kTopLeft_GrSurfaceOrigin, kBGRA_8888_SkColorType, nullptr,
      nullptr, static_cast<SkSurfaces::TextureReleaseProc>(texture.destruction_callback),
      texture.destruction_context);
 
  if (!surface) {
    FML_LOG(ERROR) << "Could not create the SkSurface from the metal texture.";
    return nullptr;
  }
 
  auto encode_callback = [](const SurfaceFrame& surface_frame, DlCanvas* canvas) -> bool {
    if (canvas == nullptr) {
      FML_DLOG(ERROR) << "Canvas not available.";
      return false;
    }
 
    {
      TRACE_EVENT0("flutter", "SkCanvas::Flush");
      canvas->Flush();
    }
 
    return true;
  };
  auto submit_callback = [texture = texture,
                          delegate = delegate_](const SurfaceFrame& surface_frame) {
    TRACE_EVENT0("flutter", "GPUSurfaceMetal::PresentTexture");
    return delegate->PresentTexture(texture);
  };
 
  SurfaceFrame::FramebufferInfo framebuffer_info;
  framebuffer_info.supports_readback = true;
 
  return std::make_unique<SurfaceFrame>(std::move(surface), framebuffer_info, encode_callback,
                                        submit_callback, frame_info);
}
 
// |Surface|
DlMatrix GPUSurfaceMetalSkia::GetRootTransformation() const {
  // This backend does not currently support root surface transformations. Just
  // return identity.
  return {};
}
 
// |Surface|
GrDirectContext* GPUSurfaceMetalSkia::GetContext() {
  return context_.get();
}
 
// |Surface|
std::unique_ptr<GLContextResult> GPUSurfaceMetalSkia::MakeRenderContextCurrent() {
  // A context may either be necessary to render to the surface or to snapshot an offscreen
  // surface. Either way, SkSL precompilation must be attempted.
  PrecompileKnownSkSLsIfNecessary();
 
  // This backend has no such concept.
  return std::make_unique<GLContextDefaultResult>(true);
}
 
bool GPUSurfaceMetalSkia::AllowsDrawingWhenGpuDisabled() const {
  return delegate_->AllowsDrawingWhenGpuDisabled();
}
 
}  // namespace flutter
 
#endif  //  !SLIMPELLER