@shopify/react-native-skia 1.12.0 → 1.12.2

package/android/cpp/jni/JniPlatformContext.cpp

@@ -162,6 +162,7 @@ void JniPlatformContext::performStreamOperation(
         jni::Environment::current()->GetByteArrayElements(array.get(), nullptr);
     if (!elements) {
       printf("Element Fail\n");
+      free(buffer);
       return;
     }
 

package/apple/MetalContext.h

@@ -0,0 +1,129 @@
+#pragma once
+
+#include "MetalWindowContext.h"
+#include "SkiaCVPixelBufferUtils.h"
+
+#include "include/core/SkSurface.h"
+
+#import <include/gpu/ganesh/GrBackendSurface.h>
+#import <include/gpu/ganesh/GrDirectContext.h>
+#import <include/gpu/ganesh/SkImageGanesh.h>
+#import <include/gpu/ganesh/SkSurfaceGanesh.h>
+#import <include/gpu/ganesh/mtl/GrMtlBackendContext.h>
+#import <include/gpu/ganesh/mtl/GrMtlBackendSurface.h>
+#import <include/gpu/ganesh/mtl/GrMtlDirectContext.h>
+#import <include/gpu/ganesh/mtl/SkSurfaceMetal.h>
+
+class MetalSharedContext {
+public:
+  static MetalSharedContext &getInstance() {
+    static MetalSharedContext instance;
+    return instance;
+  }
+
+  id<MTLDevice> getDevice() { return _device; }
+
+private:
+  MetalSharedContext() {
+    _device = MTLCreateSystemDefaultDevice();
+    if (!_device) {
+      throw std::runtime_error("Failed to create Metal device");
+    }
+  }
+
+  MetalSharedContext(const MetalSharedContext &) = delete;
+  MetalSharedContext &operator=(const MetalSharedContext &) = delete;
+
+  id<MTLDevice> _device;
+};
+
+struct OffscreenRenderContext {
+  id<MTLTexture> texture;
+
+  OffscreenRenderContext(id<MTLDevice> device,
+                         sk_sp<GrDirectContext> skiaContext,
+                         id<MTLCommandQueue> commandQueue, int width,
+                         int height) {
+    // Create a Metal texture descriptor
+    MTLTextureDescriptor *textureDescriptor = [MTLTextureDescriptor
+        texture2DDescriptorWithPixelFormat:MTLPixelFormatBGRA8Unorm
+                                     width:width
+                                    height:height
+                                 mipmapped:NO];
+    textureDescriptor.usage =
+        MTLTextureUsageRenderTarget | MTLTextureUsageShaderRead;
+    texture = [device newTextureWithDescriptor:textureDescriptor];
+  }
+};
+
+class MetalContext {
+
+public:
+  MetalContext(const MetalContext &) = delete;
+  MetalContext &operator=(const MetalContext &) = delete;
+
+  static MetalContext &getInstance() {
+    static thread_local MetalContext instance;
+    return instance;
+  }
+
+  sk_sp<SkSurface> MakeOffscreen(int width, int height) {
+    auto device = MetalSharedContext::getInstance().getDevice();
+    auto ctx = new OffscreenRenderContext(device, _directContext, _commandQueue,
+                                          width, height);
+
+    // Create a GrBackendTexture from the Metal texture
+    GrMtlTextureInfo info;
+    info.fTexture.retain((__bridge void *)ctx->texture);
+    GrBackendTexture backendTexture =
+        GrBackendTextures::MakeMtl(width, height, skgpu::Mipmapped::kNo, info);
+
+    // Create a SkSurface from the GrBackendTexture
+    auto surface = SkSurfaces::WrapBackendTexture(
+        _directContext.get(), backendTexture, kTopLeft_GrSurfaceOrigin, 0,
+        kBGRA_8888_SkColorType, nullptr, nullptr,
+        [](void *addr) { delete (OffscreenRenderContext *)addr; }, ctx);
+
+    return surface;
+  }
+
+  sk_sp<SkImage> MakeImageFromBuffer(void *buffer) {
+
+    CVPixelBufferRef sampleBuffer = (CVPixelBufferRef)buffer;
+    SkiaCVPixelBufferUtils::CVPixelBufferBaseFormat format =
+        SkiaCVPixelBufferUtils::getCVPixelBufferBaseFormat(sampleBuffer);
+    switch (format) {
+    case SkiaCVPixelBufferUtils::CVPixelBufferBaseFormat::rgb: {
+      // CVPixelBuffer is in any RGB format, single-plane
+      return SkiaCVPixelBufferUtils::RGB::makeSkImageFromCVPixelBuffer(
+          _directContext.get(), sampleBuffer);
+    }
+    case SkiaCVPixelBufferUtils::CVPixelBufferBaseFormat::yuv: {
+      // CVPixelBuffer is in any YUV format, multi-plane
+      return SkiaCVPixelBufferUtils::YUV::makeSkImageFromCVPixelBuffer(
+          _directContext.get(), sampleBuffer);
+    }
+    default:
+      [[unlikely]] {
+        throw std::runtime_error("Failed to convert NativeBuffer to SkImage - "
+                                 "NativeBuffer has unsupported PixelFormat! " +
+                                 std::to_string(static_cast<int>(format)));
+      }
+    }
+  }
+
+  std::unique_ptr<RNSkia::WindowContext> MakeWindow(CALayer *window, int width,
+                                                    int height) {
+    auto device = MetalSharedContext::getInstance().getDevice();
+    return std::make_unique<MetalWindowContext>(
+        _directContext.get(), device, _commandQueue, window, width, height);
+  }
+
+  GrDirectContext *getDirectContext() { return _directContext.get(); }
+
+private:
+  id<MTLCommandQueue> _commandQueue = nullptr;
+  sk_sp<GrDirectContext> _directContext = nullptr;
+
+  MetalContext();
+};

package/apple/MetalContext.mm

@@ -0,0 +1,34 @@
+#include "MetalContext.h"
+
+#include "RNSkLog.h"
+
+#import <MetalKit/MetalKit.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#import <include/gpu/ganesh/GrBackendSurface.h>
+#import <include/gpu/ganesh/SkImageGanesh.h>
+#import <include/gpu/ganesh/mtl/GrMtlBackendContext.h>
+#import <include/gpu/ganesh/mtl/GrMtlBackendSurface.h>
+#import <include/gpu/ganesh/mtl/GrMtlDirectContext.h>
+#import <include/gpu/ganesh/mtl/GrMtlTypes.h>
+#import <include/gpu/ganesh/mtl/SkSurfaceMetal.h>
+
+#pragma clang diagnostic pop
+
+MetalContext::MetalContext() {
+  auto device = MetalSharedContext::getInstance().getDevice();
+  _commandQueue =
+      id<MTLCommandQueue>(CFRetain((GrMTLHandle)[device newCommandQueue]));
+  GrMtlBackendContext backendContext = {};
+  backendContext.fDevice.reset((__bridge void *)device);
+  backendContext.fQueue.reset((__bridge void *)_commandQueue);
+  GrContextOptions grContextOptions; // set different options here.
+
+  // Create the Skia Direct Context
+  _directContext = GrDirectContexts::MakeMetal(backendContext);
+  if (_directContext == nullptr) {
+    RNSkia::RNSkLogger::logToConsole("Couldn't create a Skia Metal Context");
+  }
+}

package/apple/MetalWindowContext.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#import <MetalKit/MetalKit.h>
+
+#include "WindowContext.h"
+
+class SkiaMetalContext;
+
+class MetalWindowContext : public RNSkia::WindowContext {
+public:
+  MetalWindowContext(GrDirectContext *directContext, id<MTLDevice> device,
+                     id<MTLCommandQueue> commandQueue, CALayer *layer,
+                     int width, int height);
+  ~MetalWindowContext() = default;
+
+  sk_sp<SkSurface> getSurface() override;
+
+  void present() override;
+
+  int getWidth() override {
+    return _layer.frame.size.width * _layer.contentsScale;
+  };
+
+  int getHeight() override {
+    return _layer.frame.size.height * _layer.contentsScale;
+  };
+
+  void resize(int width, int height) override { _skSurface = nullptr; }
+
+private:
+  GrDirectContext *_directContext;
+  id<MTLCommandQueue> _commandQueue;
+  sk_sp<SkSurface> _skSurface = nullptr;
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunguarded-availability-new"
+  CAMetalLayer *_layer;
+#pragma clang diagnostic pop
+  id<CAMetalDrawable> _currentDrawable = nil;
+};

package/apple/MetalWindowContext.mm

@@ -0,0 +1,64 @@
+#include "MetalWindowContext.h"
+
+#include "MetalContext.h"
+#include "RNSkLog.h"
+
+MetalWindowContext::MetalWindowContext(GrDirectContext *directContext,
+                                       id<MTLDevice> device,
+                                       id<MTLCommandQueue> commandQueue,
+                                       CALayer *layer, int width, int height)
+    : _directContext(directContext), _commandQueue(commandQueue) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunguarded-availability-new"
+  _layer = (CAMetalLayer *)layer;
+#pragma clang diagnostic pop
+  _layer.framebufferOnly = NO;
+  _layer.device = device;
+  _layer.opaque = false;
+#if !TARGET_OS_OSX
+  _layer.contentsScale = [UIScreen mainScreen].scale;
+#else
+  _layer.contentsScale = [NSScreen mainScreen].backingScaleFactor;
+#endif // !TARGET_OS_OSX
+  _layer.pixelFormat = MTLPixelFormatBGRA8Unorm;
+  _layer.contentsGravity = kCAGravityBottomLeft;
+  _layer.drawableSize = CGSizeMake(width, height);
+}
+
+sk_sp<SkSurface> MetalWindowContext::getSurface() {
+  if (_skSurface) {
+    return _skSurface;
+  }
+
+  // Get the next drawable from the CAMetalLayer
+  _currentDrawable = [_layer nextDrawable];
+  if (!_currentDrawable) {
+    RNSkia::RNSkLogger::logToConsole(
+        "Could not retrieve drawable from CAMetalLayer");
+    return nullptr;
+  }
+
+  // Get the texture from the drawable
+  GrMtlTextureInfo fbInfo;
+  fbInfo.fTexture.retain((__bridge void *)_currentDrawable.texture);
+
+  GrBackendRenderTarget backendRT = GrBackendRenderTargets::MakeMtl(
+      _layer.drawableSize.width, _layer.drawableSize.height, fbInfo);
+
+  _skSurface = SkSurfaces::WrapBackendRenderTarget(
+      _directContext, backendRT, kTopLeft_GrSurfaceOrigin,
+      kBGRA_8888_SkColorType, nullptr, nullptr);
+
+  return _skSurface;
+}
+
+void MetalWindowContext::present() {
+  if (auto dContext = GrAsDirectContext(_skSurface->recordingContext())) {
+    dContext->flushAndSubmit();
+  }
+
+  id<MTLCommandBuffer> commandBuffer([_commandQueue commandBuffer]);
+  [commandBuffer presentDrawable:_currentDrawable];
+  [commandBuffer commit];
+  _skSurface = nullptr;
+}

package/apple/RNSkApplePlatformContext.h

@@ -0,0 +1,79 @@
+#pragma once
+
+#import <React/RCTBridge+Private.h>
+#import <React/RCTBridge.h>
+
+#include <functional>
+#include <memory>
+#include <string>
+
+#include "RNSkPlatformContext.h"
+#include "ViewScreenshotService.h"
+
+namespace facebook {
+namespace react {
+class CallInvoker;
+}
+} // namespace facebook
+
+namespace RNSkia {
+
+class RNSkApplePlatformContext : public RNSkPlatformContext {
+public:
+  RNSkApplePlatformContext(
+      RCTBridge *bridge,
+      std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker)
+#if !TARGET_OS_OSX
+      : RNSkPlatformContext(jsCallInvoker, [[UIScreen mainScreen] scale]) {
+#else
+      : RNSkPlatformContext(jsCallInvoker, [[NSScreen mainScreen] backingScaleFactor]) {
+#endif // !TARGET_OS_OSX
+
+    // Create screenshot manager
+    _screenshotService =
+        [[ViewScreenshotService alloc] initWithUiManager:bridge.uiManager];
+  }
+
+  ~RNSkApplePlatformContext() = default;
+
+  void runOnMainThread(std::function<void()>) override;
+
+  sk_sp<SkImage> takeScreenshotFromViewTag(size_t tag) override;
+
+  sk_sp<SkImage> makeImageFromNativeBuffer(void *buffer) override;
+
+  sk_sp<SkImage> makeImageFromNativeTexture(const TextureInfo &textureInfo,
+                                            int width, int height,
+                                            bool mipMapped) override;
+
+  uint64_t makeNativeBuffer(sk_sp<SkImage> image) override;
+
+  const TextureInfo getTexture(sk_sp<SkSurface> image) override;
+
+  const TextureInfo getTexture(sk_sp<SkImage> image) override;
+
+  void releaseNativeBuffer(uint64_t pointer) override;
+
+  std::shared_ptr<RNSkVideo> createVideo(const std::string &url) override;
+
+  std::shared_ptr<WindowContext>
+  makeContextFromNativeSurface(void *surface, int width, int height) override;
+
+  virtual void performStreamOperation(
+      const std::string &sourceUri,
+      const std::function<void(std::unique_ptr<SkStreamAsset>)> &op) override;
+
+  void raiseError(const std::exception &err) override;
+  sk_sp<SkSurface> makeOffscreenSurface(int width, int height) override;
+#if !defined(SK_GRAPHITE)
+  GrDirectContext *getDirectContext() override;
+#endif
+  sk_sp<SkFontMgr> createFontMgr() override;
+
+private:
+  ViewScreenshotService *_screenshotService;
+
+  SkColorType mtlPixelFormatToSkColorType(MTLPixelFormat pixelFormat);
+};
+
+} // namespace RNSkia

package/apple/RNSkApplePlatformContext.mm

@@ -0,0 +1,303 @@
+#import "RNSkApplePlatformContext.h"
+
+#import <CoreMedia/CMSampleBuffer.h>
+#include <Metal/Metal.h>
+#import <React/RCTUtils.h>
+#include <thread>
+#include <utility>
+
+#if defined(SK_GRAPHITE)
+#include "DawnContext.h"
+#else
+#include "MetalContext.h"
+#endif
+#include "RNSkAppleVideo.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#import "include/core/SkColorSpace.h"
+#include "include/core/SkFontMgr.h"
+#include "include/core/SkSurface.h"
+
+#include "include/ports/SkFontMgr_mac_ct.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+void RNSkApplePlatformContext::performStreamOperation(
+    const std::string &sourceUri,
+    const std::function<void(std::unique_ptr<SkStreamAsset>)> &op) {
+
+  auto loader = [=]() {
+    NSURL *url = [[NSURL alloc]
+        initWithString:[NSString stringWithUTF8String:sourceUri.c_str()]];
+
+    NSData *data = nullptr;
+    auto scheme = url.scheme;
+    auto extension = url.pathExtension;
+
+    if (scheme == nullptr &&
+        (extension == nullptr || [extension isEqualToString:@""])) {
+      // If the extension and scheme is nil, we assume that we're trying to
+      // load from the embedded iOS app bundle and will try to load image
+      // and get data from the image directly. imageNamed will return the
+      // best version of the requested image:
+      auto image = [UIImage imageNamed:[url absoluteString]];
+      // We don't know the image format (png, jpg, etc) but
+      // UIImagePNGRepresentation will support all of them
+      data = UIImagePNGRepresentation(image);
+    } else {
+      // Load from metro / node
+      data = [NSData dataWithContentsOfURL:url];
+    }
+
+    auto bytes = [data bytes];
+    auto skData = SkData::MakeWithCopy(bytes, [data length]);
+    auto stream = SkMemoryStream::Make(skData);
+
+    op(std::move(stream));
+  };
+
+  // Fire and forget the thread - will be resolved on completion
+  std::thread(loader).detach();
+}
+
+void RNSkApplePlatformContext::releaseNativeBuffer(uint64_t pointer) {
+  CVPixelBufferRef pixelBuffer = reinterpret_cast<CVPixelBufferRef>(pointer);
+  if (pixelBuffer) {
+    CFRelease(pixelBuffer);
+  }
+}
+
+uint64_t RNSkApplePlatformContext::makeNativeBuffer(sk_sp<SkImage> image) {
+  // 0. If Image is not in BGRA, convert to BGRA as only BGRA is supported.
+  if (image->colorType() != kBGRA_8888_SkColorType) {
+#if defined(SK_GRAPHITE)
+    SkImage::RequiredProperties requiredProps;
+    image = image->makeColorTypeAndColorSpace(
+        DawnContext::getInstance().getRecorder(), kBGRA_8888_SkColorType,
+        SkColorSpace::MakeSRGB(), requiredProps);
+#else
+    // on iOS, 32_BGRA is the only supported RGB format for CVPixelBuffers.
+    image = image->makeColorTypeAndColorSpace(
+        MetalContext::getInstance().getDirectContext(), kBGRA_8888_SkColorType,
+        SkColorSpace::MakeSRGB());
+#endif
+    if (image == nullptr) {
+      throw std::runtime_error(
+          "Failed to convert image to BGRA_8888 colortype! Only BGRA_8888 "
+          "NativeBuffers are supported.");
+    }
+  }
+
+  // 1. Get image info
+  auto bytesPerPixel = image->imageInfo().bytesPerPixel();
+  int bytesPerRow = image->width() * bytesPerPixel;
+  auto buf = SkData::MakeUninitialized(image->width() * image->height() *
+                                       bytesPerPixel);
+  SkImageInfo info = SkImageInfo::Make(image->width(), image->height(),
+                                       image->colorType(), image->alphaType());
+  // 2. Copy pixels into our buffer
+  image->readPixels(nullptr, info, const_cast<void *>(buf->data()), bytesPerRow,
+                    0, 0);
+
+  // 3. Create an IOSurface (GPU + CPU memory)
+  CFMutableDictionaryRef dict = CFDictionaryCreateMutable(
+      kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks,
+      &kCFTypeDictionaryValueCallBacks);
+  int width = image->width();
+  int height = image->height();
+  int pitch = width * bytesPerPixel;
+  int size = width * height * bytesPerPixel;
+  OSType pixelFormat = kCVPixelFormatType_32BGRA;
+  CFDictionarySetValue(
+      dict, kIOSurfaceBytesPerRow,
+      CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &pitch));
+  CFDictionarySetValue(
+      dict, kIOSurfaceBytesPerElement,
+      CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &bytesPerPixel));
+  CFDictionarySetValue(
+      dict, kIOSurfaceWidth,
+      CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &width));
+  CFDictionarySetValue(
+      dict, kIOSurfaceHeight,
+      CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &height));
+  CFDictionarySetValue(
+      dict, kIOSurfacePixelFormat,
+      CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &pixelFormat));
+  CFDictionarySetValue(
+      dict, kIOSurfaceAllocSize,
+      CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &size));
+  IOSurfaceRef surface = IOSurfaceCreate(dict);
+  if (surface == nil) {
+    throw std::runtime_error("Failed to create " + std::to_string(width) + "x" +
+                             std::to_string(height) + " IOSurface!");
+  }
+
+  // 4. Copy over the memory from the pixels into the IOSurface
+  IOSurfaceLock(surface, 0, nil);
+  void *base = IOSurfaceGetBaseAddress(surface);
+  memcpy(base, buf->data(), buf->size());
+  IOSurfaceUnlock(surface, 0, nil);
+
+  // 5. Create a CVPixelBuffer from the IOSurface
+  CVPixelBufferRef pixelBuffer = nullptr;
+  CVReturn result =
+      CVPixelBufferCreateWithIOSurface(nil, surface, nil, &pixelBuffer);
+  if (result != kCVReturnSuccess) {
+    throw std::runtime_error(
+        "Failed to create CVPixelBuffer from SkImage! Return value: " +
+        std::to_string(result));
+  }
+
+  // 8. Return CVPixelBuffer casted to uint64_t
+  return reinterpret_cast<uint64_t>(pixelBuffer);
+}
+
+const TextureInfo RNSkApplePlatformContext::getTexture(sk_sp<SkImage> image) {
+  GrBackendTexture texture;
+  TextureInfo result;
+  if (!SkImages::GetBackendTextureFromImage(image, &texture, true)) {
+    throw std::runtime_error("Couldn't get backend texture");
+  }
+  if (!texture.isValid()) {
+    throw std::runtime_error("Invalid backend texture");
+  }
+  GrMtlTextureInfo textureInfo;
+  if (!GrBackendTextures::GetMtlTextureInfo(texture, &textureInfo)) {
+    throw std::runtime_error("Couldn't get Metal texture info");
+  }
+  result.mtlTexture = textureInfo.fTexture.get();
+  return result;
+}
+
+const TextureInfo RNSkApplePlatformContext::getTexture(sk_sp<SkSurface> surface) {
+  GrBackendTexture texture = SkSurfaces::GetBackendTexture(
+      surface.get(), SkSurfaces::BackendHandleAccess::kFlushRead);
+  TextureInfo result;
+  if (!texture.isValid()) {
+    throw std::runtime_error("Invalid backend texture");
+  }
+  GrMtlTextureInfo textureInfo;
+  if (!GrBackendTextures::GetMtlTextureInfo(texture, &textureInfo)) {
+    throw std::runtime_error("Couldn't get Metal texture info");
+  }
+  result.mtlTexture = textureInfo.fTexture.get();
+  return result;
+}
+
+std::shared_ptr<RNSkVideo>
+RNSkApplePlatformContext::createVideo(const std::string &url) {
+  return std::make_shared<RNSkAppleVideo>(url, this);
+}
+
+std::shared_ptr<WindowContext>
+RNSkApplePlatformContext::makeContextFromNativeSurface(void *surface, int width,
+                                                     int height) {
+#if defined(SK_GRAPHITE)
+  return DawnContext::getInstance().MakeWindow(surface, width, height);
+#else
+  return MetalContext::getInstance().MakeWindow((__bridge CALayer *)surface,
+                                                width, height);
+#endif
+}
+
+void RNSkApplePlatformContext::raiseError(const std::exception &err) {
+  RCTFatal(RCTErrorWithMessage([NSString stringWithUTF8String:err.what()]));
+}
+
+sk_sp<SkSurface> RNSkApplePlatformContext::makeOffscreenSurface(int width,
+                                                              int height) {
+#if defined(SK_GRAPHITE)
+  return DawnContext::getInstance().MakeOffscreen(width, height);
+#else
+  return MetalContext::getInstance().MakeOffscreen(width, height);
+#endif
+}
+
+sk_sp<SkImage> RNSkApplePlatformContext::makeImageFromNativeBuffer(void *buffer) {
+#if defined(SK_GRAPHITE)
+  return DawnContext::getInstance().MakeImageFromBuffer(buffer);
+#else
+  return MetalContext::getInstance().MakeImageFromBuffer(buffer);
+#endif
+}
+
+sk_sp<SkImage> RNSkApplePlatformContext::makeImageFromNativeTexture(
+    const TextureInfo &texInfo, int width, int height, bool mipMapped) {
+  id<MTLTexture> mtlTexture = (__bridge id<MTLTexture>)(texInfo.mtlTexture);
+
+  SkColorType colorType = mtlPixelFormatToSkColorType(mtlTexture.pixelFormat);
+  if (colorType == SkColorType::kUnknown_SkColorType) {
+    throw std::runtime_error("Unsupported pixelFormat");
+  }
+
+  GrMtlTextureInfo textureInfo;
+  textureInfo.fTexture.retain((__bridge const void *)mtlTexture);
+
+  GrBackendTexture texture = GrBackendTextures::MakeMtl(
+      width, height, mipMapped ? skgpu::Mipmapped::kYes : skgpu::Mipmapped::kNo,
+      textureInfo);
+
+  return SkImages::BorrowTextureFrom(getDirectContext(), texture,
+                                     kTopLeft_GrSurfaceOrigin, colorType,
+                                     kPremul_SkAlphaType, nullptr);
+}
+
+SkColorType RNSkApplePlatformContext::mtlPixelFormatToSkColorType(
+    MTLPixelFormat pixelFormat) {
+  switch (pixelFormat) {
+  case MTLPixelFormatRGBA8Unorm:
+    return kRGBA_8888_SkColorType;
+  case MTLPixelFormatBGRA8Unorm:
+    return kBGRA_8888_SkColorType;
+  case MTLPixelFormatRGB10A2Unorm:
+    return kRGBA_1010102_SkColorType;
+  case MTLPixelFormatR8Unorm:
+    return kGray_8_SkColorType;
+  case MTLPixelFormatRGBA16Float:
+    return kRGBA_F16_SkColorType;
+  case MTLPixelFormatRG8Unorm:
+    return kR8G8_unorm_SkColorType;
+  case MTLPixelFormatR16Float:
+    return kA16_float_SkColorType;
+  case MTLPixelFormatRG16Float:
+    return kR16G16_float_SkColorType;
+  case MTLPixelFormatR16Unorm:
+    return kA16_unorm_SkColorType;
+  case MTLPixelFormatRG16Unorm:
+    return kR16G16_unorm_SkColorType;
+  case MTLPixelFormatRGBA16Unorm:
+    return kR16G16B16A16_unorm_SkColorType;
+  case MTLPixelFormatRGBA8Unorm_sRGB:
+    return kSRGBA_8888_SkColorType;
+  default:
+    return kUnknown_SkColorType;
+  }
+}
+
+#if !defined(SK_GRAPHITE)
+GrDirectContext *RNSkApplePlatformContext::getDirectContext() {
+  return MetalContext::getInstance().getDirectContext();
+}
+#endif
+
+sk_sp<SkFontMgr> RNSkApplePlatformContext::createFontMgr() {
+  return SkFontMgr_New_CoreText(nullptr);
+}
+
+void RNSkApplePlatformContext::runOnMainThread(std::function<void()> func) {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    func();
+  });
+}
+
+sk_sp<SkImage>
+RNSkApplePlatformContext::takeScreenshotFromViewTag(size_t viewTag) {
+  return [_screenshotService
+      screenshotOfViewWithTag:[NSNumber numberWithLong:viewTag]];
+}
+
+} // namespace RNSkia