@shopify/react-native-skia 1.5.4 → 1.5.6

package/android/CMakeLists.txt

@@ -54,7 +54,7 @@ if(SK_GRAPHITE)
 else()
     add_definitions(-DSK_GL -DSK_GANESH)
     set(BACKEND_SOURCES
-        "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/SkiaOpenGLSurfaceFactory.cpp"
+        "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/OpenGLWindowContext.cpp"
         "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/GrAHardwareBufferUtils.cpp"
     )
 endif()
@@ -74,6 +74,7 @@ add_library(
         "${PROJECT_SOURCE_DIR}/cpp/jni/JniSkiaManager.cpp"
 
         "${PROJECT_SOURCE_DIR}/cpp/jni/JniPlatformContext.cpp"
+        "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/gl/Error.cpp"
         "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/RNSkOpenGLCanvasProvider.cpp"
         "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/AHardwareBufferUtils.cpp"
         "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/RNSkAndroidVideo.cpp"

package/android/cpp/rnskia-android/OpenGLContext.h

@@ -1,12 +1,25 @@
 #pragma once
 
-#include "SkiaOpenGLSurfaceFactory.h"
-#include "WindowContext.h"
+#include "GrAHardwareBufferUtils.h"
+#include "OpenGLWindowContext.h"
+#include "gl/Display.h"
 
+#include "include/core/SkCanvas.h"
+#include "include/core/SkColorSpace.h"
 #include "include/core/SkSurface.h"
+#include "include/gpu/ganesh/GrDirectContext.h"
+#include "include/gpu/ganesh/SkImageGanesh.h"
+#include "include/gpu/ganesh/gl/GrGLBackendSurface.h"
+#include "include/gpu/ganesh/gl/GrGLDirectContext.h"
+#include "include/gpu/ganesh/gl/GrGLInterface.h"
+#include "src/gpu/ganesh/gl/GrGLDefines.h"
+
+namespace RNSkia {
 
 class OpenGLContext {
 public:
+  friend class OpenGLWindowContext;
+
   OpenGLContext(const OpenGLContext &) = delete;
   OpenGLContext &operator=(const OpenGLContext &) = delete;
 
@@ -16,25 +29,127 @@ public:
   }
 
   sk_sp<SkSurface> MakeOffscreen(int width, int height) {
-    return RNSkia::SkiaOpenGLSurfaceFactory::makeOffscreenSurface(
-        &_context, width, height);
+    auto colorType = kRGBA_8888_SkColorType;
+
+    SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
+
+    auto result = _glContext->makeCurrent(_glSurface.get());
+    if (!result) {
+      return nullptr;
+    }
+
+    // Create texture
+    auto texture = _directContext->createBackendTexture(
+        width, height, colorType, skgpu::Mipmapped::kNo, GrRenderable::kYes);
+
+    if (!texture.isValid()) {
+      RNSkLogger::logToConsole("couldn't create offscreen texture %dx%d", width,
+                               height);
+    }
+
+    struct ReleaseContext {
+      GrDirectContext *directContext;
+      GrBackendTexture texture;
+    };
+
+    auto releaseCtx = new ReleaseContext{.directContext = _directContext.get(),
+                                         .texture = texture};
+
+    // Create a SkSurface from the GrBackendTexture
+    return SkSurfaces::WrapBackendTexture(
+        _directContext.get(), texture, kTopLeft_GrSurfaceOrigin, 0, colorType,
+        nullptr, &props,
+        [](void *addr) {
+          auto releaseCtx = reinterpret_cast<ReleaseContext *>(addr);
+          releaseCtx->directContext->deleteBackendTexture(releaseCtx->texture);
+          delete releaseCtx;
+        },
+        releaseCtx);
   }
 
-  sk_sp<SkImage> MakeImageFromBuffer(void *buffer) {
-    return RNSkia::SkiaOpenGLSurfaceFactory::makeImageFromHardwareBuffer(
-        &_context, buffer);
+  sk_sp<SkImage> MakeImageFromBuffer(void *buffer,
+                                     bool requireKnownFormat = false) {
+#if __ANDROID_API__ >= 26
+    const AHardwareBuffer *hardwareBuffer =
+        static_cast<AHardwareBuffer *>(buffer);
+    DeleteImageProc deleteImageProc = nullptr;
+    UpdateImageProc updateImageProc = nullptr;
+    TexImageCtx deleteImageCtx = nullptr;
+
+    AHardwareBuffer_Desc description;
+    AHardwareBuffer_describe(hardwareBuffer, &description);
+    GrBackendFormat format;
+    switch (description.format) {
+    // TODO: find out if we can detect, which graphic buffers support
+    // GR_GL_TEXTURE_2D
+    case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
+      format = GrBackendFormats::MakeGL(GR_GL_RGBA8, GR_GL_TEXTURE_EXTERNAL);
+    case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
+      format = GrBackendFormats::MakeGL(GR_GL_RGBA16F, GR_GL_TEXTURE_EXTERNAL);
+    case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
+      format = GrBackendFormats::MakeGL(GR_GL_RGB565, GR_GL_TEXTURE_EXTERNAL);
+    case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
+      format = GrBackendFormats::MakeGL(GR_GL_RGB10_A2, GR_GL_TEXTURE_EXTERNAL);
+    case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
+      format = GrBackendFormats::MakeGL(GR_GL_RGB8, GR_GL_TEXTURE_EXTERNAL);
+#if __ANDROID_API__ >= 33
+    case AHARDWAREBUFFER_FORMAT_R8_UNORM:
+      format = GrBackendFormats::MakeGL(GR_GL_R8, GR_GL_TEXTURE_EXTERNAL);
+#endif
+    default:
+      if (requireKnownFormat) {
+        format = GrBackendFormat();
+      } else {
+        format = GrBackendFormats::MakeGL(GR_GL_RGBA8, GR_GL_TEXTURE_EXTERNAL);
+      }
+    }
+
+    auto backendTex = MakeGLBackendTexture(
+        _directContext.get(), const_cast<AHardwareBuffer *>(hardwareBuffer),
+        description.width, description.height, &deleteImageProc,
+        &updateImageProc, &deleteImageCtx, false, format, false);
+    if (!backendTex.isValid()) {
+      RNSkLogger::logToConsole(
+          "Failed to convert HardwareBuffer to OpenGL Texture!");
+      return nullptr;
+    }
+    sk_sp<SkImage> image = SkImages::BorrowTextureFrom(
+        _directContext.get(), backendTex, kTopLeft_GrSurfaceOrigin,
+        kRGBA_8888_SkColorType, kOpaque_SkAlphaType, nullptr, deleteImageProc,
+        deleteImageCtx);
+    return image;
+#else
+    throw std::runtime_error(
+        "HardwareBuffers are only supported on Android API 26 or higher! Set "
+        "your minSdk to 26 (or higher) and try again.");
+#endif
   }
 
-  std::unique_ptr<RNSkia::WindowContext> MakeWindow(ANativeWindow *window,
-                                                    int width, int height) {
-    return RNSkia::SkiaOpenGLSurfaceFactory::makeContext(&_context, window,
-                                                         width, height);
+  std::unique_ptr<WindowContext> MakeWindow(ANativeWindow *window, int width,
+                                            int height) {
+    return std::make_unique<OpenGLWindowContext>(this, window, width, height);
   }
 
 private:
-  RNSkia::SkiaOpenGLContext _context;
+  EGLConfig _glConfig;
+  std::unique_ptr<gl::Display> _glDisplay;
+  std::unique_ptr<gl::Context> _glContext;
+  std::unique_ptr<gl::Surface> _glSurface;
+  sk_sp<GrDirectContext> _directContext;
 
   OpenGLContext() {
-    RNSkia::SkiaOpenGLHelper::createSkiaDirectContextIfNecessary(&_context);
+    _glDisplay = std::make_unique<gl::Display>();
+    _glConfig = _glDisplay->chooseConfig();
+    _glContext = _glDisplay->makeContext(_glConfig, nullptr);
+    _glSurface = _glDisplay->makePixelBufferSurface(_glConfig, 1, 1);
+    _glContext->makeCurrent(_glSurface.get());
+    auto backendInterface = GrGLMakeNativeInterface();
+    _directContext = GrDirectContexts::MakeGL(backendInterface);
+
+    if (_directContext == nullptr) {
+      throw std::runtime_error("GrDirectContexts::MakeGL failed");
+    }
   }
 };
+
+} // namespace RNSkia

package/android/cpp/rnskia-android/OpenGLWindowContext.cpp

@@ -0,0 +1,90 @@
+#include "OpenGLWindowContext.h"
+#include "GrAHardwareBufferUtils.h"
+
+#include "OpenGLContext.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/gpu/ganesh/SkImageGanesh.h"
+#include "include/gpu/ganesh/gl/GrGLBackendSurface.h"
+#include "src/gpu/ganesh/gl/GrGLDefines.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+sk_sp<SkSurface> OpenGLWindowContext::getSurface() {
+  if (_skSurface == nullptr) {
+
+    struct ReleaseContext {
+      std::unique_ptr<gl::Surface> surface = nullptr;
+    };
+
+    if (!_window) {
+      throw std::runtime_error("No native window provided");
+    }
+    auto releaseCtx = new ReleaseContext();
+    releaseCtx->surface =
+        _context->_glDisplay->makeWindowSurface(_context->_glConfig, _window);
+    if (!releaseCtx->surface) {
+      throw std::runtime_error("Failed to create window surface");
+    }
+    _glSurface = releaseCtx->surface.get();
+
+    // Now make this one current
+    auto success = _context->_glContext->makeCurrent(releaseCtx->surface.get());
+    if (!success) {
+      throw std::runtime_error("Failed to make window surface current");
+    }
+
+    // Set up parameters for the render target so that it
+    // matches the underlying OpenGL context.
+    GrGLFramebufferInfo fboInfo;
+
+    // We pass 0 as the framebuffer id, since the
+    // underlying Skia GrGlGpu will read this when wrapping the context in the
+    // render target and the GrGlGpu object.
+    fboInfo.fFBOID = 0;
+    fboInfo.fFormat = 0x8058; // GL_RGBA8
+
+    GLint stencil;
+    glGetIntegerv(GL_STENCIL_BITS, &stencil);
+
+    GLint samples;
+    glGetIntegerv(GL_SAMPLES, &samples);
+
+    auto colorType = kN32_SkColorType;
+
+    auto maxSamples =
+        _context->_directContext->maxSurfaceSampleCountForColorType(colorType);
+
+    if (samples > maxSamples) {
+      samples = maxSamples;
+    }
+
+    auto renderTarget = GrBackendRenderTargets::MakeGL(_width, _height, samples,
+                                                       stencil, fboInfo);
+
+    SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
+
+    // Create surface object
+    _skSurface = SkSurfaces::WrapBackendRenderTarget(
+        _context->_directContext.get(), renderTarget,
+        kBottomLeft_GrSurfaceOrigin, colorType, nullptr, &props,
+        [](void *addr) {
+          auto releaseCtx = reinterpret_cast<ReleaseContext *>(addr);
+          delete releaseCtx;
+        },
+        reinterpret_cast<void *>(releaseCtx));
+  }
+  return _skSurface;
+}
+
+void OpenGLWindowContext::present() {
+  _context->_glContext->makeCurrent(_glSurface);
+  _context->_directContext->flushAndSubmit();
+  _glSurface->present();
+}
+
+} // namespace RNSkia

package/android/cpp/rnskia-android/OpenGLWindowContext.h

@@ -0,0 +1,73 @@
+#pragma once
+
+#include "RNSkLog.h"
+
+#include <fbjni/fbjni.h>
+#include <jni.h>
+
+#include <android/native_window_jni.h>
+#include <android/surface_texture.h>
+#include <android/surface_texture_jni.h>
+#include <condition_variable>
+#include <memory>
+#include <thread>
+#include <unordered_map>
+
+#include "WindowContext.h"
+#include "gl/Display.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkCanvas.h"
+#include "include/core/SkColorSpace.h"
+#include "include/core/SkSurface.h"
+#include "include/gpu/ganesh/GrBackendSurface.h"
+#include "include/gpu/ganesh/GrDirectContext.h"
+#include "include/gpu/ganesh/SkSurfaceGanesh.h"
+#include "include/gpu/ganesh/gl/GrGLInterface.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+class OpenGLContext;
+
+class OpenGLWindowContext : public WindowContext {
+public:
+  OpenGLWindowContext(OpenGLContext *context, ANativeWindow *window, int width,
+                      int height)
+      : _context(context), _window(window), _width(width), _height(height) {
+    ANativeWindow_acquire(_window);
+  }
+
+  ~OpenGLWindowContext() {
+    _skSurface = nullptr;
+    _glSurface = nullptr;
+    ANativeWindow_release(_window);
+  }
+
+  sk_sp<SkSurface> getSurface() override;
+
+  void present() override;
+
+  void resize(int width, int height) override {
+    _skSurface = nullptr;
+    _width = width;
+    _height = height;
+  }
+
+  int getWidth() override { return _width; };
+
+  int getHeight() override { return _height; };
+
+private:
+  OpenGLContext *_context;
+  ANativeWindow *_window;
+  sk_sp<SkSurface> _skSurface = nullptr;
+  gl::Surface *_glSurface = nullptr;
+  int _width = 0;
+  int _height = 0;
+};
+
+} // namespace RNSkia

package/android/cpp/rnskia-android/RNSkAndroidPlatformContext.h

@@ -68,8 +68,8 @@ public:
 #if defined(SK_GRAPHITE)
     return DawnContext::getInstance().MakeWindow(surface, width, height);
 #else
-    return OpenGLContext::getInstance().MakeWindow(
-        reinterpret_cast<ANativeWindow *>(surface), width, height);
+    auto aWindow = reinterpret_cast<ANativeWindow *>(surface);
+    return OpenGLContext::getInstance().MakeWindow(aWindow, width, height);
 #endif
   }
 

package/android/cpp/rnskia-android/RNSkOpenGLCanvasProvider.cpp

@@ -71,7 +71,6 @@ bool RNSkOpenGLCanvasProvider::renderToCanvas(
       return false;
     }
   }
-
   return false;
 }
 

package/android/cpp/rnskia-android/gl/Context.h

@@ -0,0 +1,77 @@
+#pragma once
+
+#include "gl/Error.h"
+#include "gl/Surface.h"
+
+namespace gl {
+
+class Surface;
+class Display;
+
+class Context {
+public:
+  ~Context() {
+    if (_context != EGL_NO_CONTEXT) {
+      if (eglDestroyContext(_display, _context) != EGL_TRUE) {
+        LOG_EGL_ERROR;
+      }
+    }
+  }
+
+  bool isValid() const { return _context != EGL_NO_CONTEXT; }
+
+  const EGLContext &getHandle() const { return _context; }
+
+  bool makeCurrent(const Surface *surface) {
+    if (_context == EGL_NO_CONTEXT) {
+      return false;
+    }
+    const auto result =
+        eglMakeCurrentIfNecessary(_display, surface->getHandle(),
+                                  surface->getHandle(), _context) == EGL_TRUE;
+    if (!result) {
+      LOG_EGL_ERROR;
+    }
+    return result;
+  }
+
+  bool clearCurrent() {
+    const auto result =
+        eglMakeCurrentIfNecessary(_display, EGL_NO_SURFACE, EGL_NO_SURFACE,
+                                  EGL_NO_CONTEXT) == EGL_TRUE;
+    if (!result) {
+      LOG_EGL_ERROR;
+    }
+    return result;
+  }
+
+  bool isCurrent() const { return eglGetCurrentContext() == _context; }
+
+private:
+  friend class Display;
+
+  EGLDisplay _display = EGL_NO_DISPLAY;
+  EGLContext _context = EGL_NO_CONTEXT;
+
+  static EGLBoolean eglMakeCurrentIfNecessary(EGLDisplay display,
+                                              EGLSurface draw, EGLSurface read,
+                                              EGLContext context) {
+    if (display != eglGetCurrentDisplay() ||
+        draw != eglGetCurrentSurface(EGL_DRAW) ||
+        read != eglGetCurrentSurface(EGL_READ) ||
+        context != eglGetCurrentContext()) {
+      return eglMakeCurrent(display, draw, read, context);
+    }
+
+    return EGL_TRUE;
+  }
+
+  Context(EGLDisplay display, EGLContext context)
+      : _display(display), _context(context) {}
+
+  Context(const Context &) = delete;
+
+  Context &operator=(const Context &) = delete;
+};
+
+} // namespace gl

package/android/cpp/rnskia-android/gl/Display.h

@@ -0,0 +1,117 @@
+#pragma once
+
+#include <memory>
+
+#include "EGL/egl.h"
+#include "GLES2/gl2.h"
+
+#include "gl/Context.h"
+#include "gl/Error.h"
+
+namespace gl {
+
+class Context;
+class Surface;
+
+class Display {
+public:
+  Display() {
+    EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+
+    if (eglInitialize(display, nullptr, nullptr) != EGL_TRUE) {
+      LOG_EGL_ERROR;
+      return;
+    }
+    _display = display;
+  }
+
+  ~Display() {
+    if (_display != EGL_NO_DISPLAY) {
+      if (eglTerminate(_display) != EGL_TRUE) {
+        LOG_EGL_ERROR;
+      }
+    }
+  }
+
+  bool isValid() const { return _display != EGL_NO_DISPLAY; }
+
+  EGLConfig chooseConfig() {
+
+    EGLint att[] = {EGL_RENDERABLE_TYPE,
+                    EGL_OPENGL_ES2_BIT,
+                    EGL_ALPHA_SIZE,
+                    8,
+                    EGL_BLUE_SIZE,
+                    8,
+                    EGL_GREEN_SIZE,
+                    8,
+                    EGL_RED_SIZE,
+                    8,
+                    EGL_DEPTH_SIZE,
+                    0,
+                    EGL_STENCIL_SIZE,
+                    0,
+                    EGL_SAMPLE_BUFFERS,
+                    0,
+                    EGL_NONE};
+
+    EGLint numConfigs;
+    EGLConfig glConfig = 0;
+    if (eglChooseConfig(_display, att, &glConfig, 1, &numConfigs) != EGL_TRUE ||
+        numConfigs == 0) {
+      LOG_EGL_ERROR;
+      return 0;
+    }
+
+    return glConfig;
+  }
+
+  std::unique_ptr<Context> makeContext(const EGLConfig &config,
+                                       const Context *share_context) {
+    EGLint contextAttribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
+    auto context = eglCreateContext(
+        _display, config,
+        share_context != nullptr ? share_context->getHandle() : nullptr,
+        contextAttribs);
+
+    if (context == EGL_NO_CONTEXT) {
+      LOG_EGL_ERROR;
+      return nullptr;
+    }
+    return std::unique_ptr<Context>(new Context(_display, context));
+  }
+
+  std::unique_ptr<Surface> makeWindowSurface(const EGLConfig &config,
+                                             ANativeWindow *window) {
+    const EGLint attribs[] = {EGL_NONE};
+    auto surface = eglCreateWindowSurface(_display, config, window, attribs);
+    if (surface == EGL_NO_SURFACE) {
+      LOG_EGL_ERROR;
+      return nullptr;
+    }
+    return std::make_unique<Surface>(_display, surface);
+  }
+
+  std::unique_ptr<Surface> makePixelBufferSurface(const EGLConfig &config,
+                                                  size_t width, size_t height) {
+    const EGLint attribs[] = {EGL_WIDTH, static_cast<EGLint>(width), EGL_HEIGHT,
+                              static_cast<EGLint>(height), EGL_NONE};
+    auto surface = eglCreatePbufferSurface(_display, config, attribs);
+    if (surface == EGL_NO_SURFACE) {
+      LOG_EGL_ERROR;
+      return nullptr;
+    }
+    return std::make_unique<Surface>(_display, surface);
+  }
+
+  const EGLDisplay &getHandle() const { return _display; }
+
+private:
+  EGLDisplay _display = EGL_NO_DISPLAY;
+
+  Display(const Display &) = delete;
+
+  Display &operator=(const Display &) = delete;
+};
+
+} // namespace gl

package/android/cpp/rnskia-android/gl/Error.cpp

@@ -0,0 +1,9 @@
+#include "gl/Error.h"
+
+#include "RNSkLog.h"
+
+void LogEGLError(const char *file, int line) {
+  const auto error = eglGetError();
+  RNSkia::RNSkLogger::logToConsole("EGL Error: %s (%d) in %s:%d",
+                                   EGLErrorToString(error), error, file, line);
+}

package/android/cpp/rnskia-android/gl/Error.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "EGL/egl.h"
+#include "GLES2/gl2.h"
+
+#define LOG_EGL_ERROR LogEGLError(__FILE__, __LINE__);
+
+static const char *EGLErrorToString(EGLint error) {
+  switch (error) {
+  case EGL_SUCCESS:
+    return "Success";
+  case EGL_NOT_INITIALIZED:
+    return "Not Initialized";
+  case EGL_BAD_ACCESS:
+    return "Bad Access";
+  case EGL_BAD_ALLOC:
+    return "Bad Alloc";
+  case EGL_BAD_ATTRIBUTE:
+    return "Bad Attribute";
+  case EGL_BAD_CONTEXT:
+    return "Bad Context";
+  case EGL_BAD_CONFIG:
+    return "Bad Config";
+  case EGL_BAD_CURRENT_SURFACE:
+    return "Bad Current Surface";
+  case EGL_BAD_DISPLAY:
+    return "Bad Display";
+  case EGL_BAD_SURFACE:
+    return "Bad Surface";
+  case EGL_BAD_MATCH:
+    return "Bad Match";
+  case EGL_BAD_PARAMETER:
+    return "Bad Parameter";
+  case EGL_BAD_NATIVE_PIXMAP:
+    return "Bad Native Pixmap";
+  case EGL_BAD_NATIVE_WINDOW:
+    return "Bad Native Window";
+  case EGL_CONTEXT_LOST:
+    return "Context Lost";
+  }
+  return "Unknown";
+}
+
+void LogEGLError(const char *file, int line);

package/android/cpp/rnskia-android/gl/Surface.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "gl/Error.h"
+
+namespace gl {
+
+class Surface {
+public:
+  Surface(EGLDisplay display, EGLSurface surface)
+      : _display(display), _surface(surface) {}
+
+  ~Surface() {
+    if (_surface != EGL_NO_SURFACE) {
+      if (eglDestroySurface(_display, _surface) != EGL_TRUE) {
+        LOG_EGL_ERROR;
+      }
+    }
+  }
+
+  bool isValid() { return _surface != EGL_NO_SURFACE; }
+
+  const EGLSurface &getHandle() const { return _surface; }
+
+  bool present() {
+    const auto result = eglSwapBuffers(_display, _surface) == EGL_TRUE;
+    if (!result) {
+      LOG_EGL_ERROR;
+    }
+    return result;
+  }
+
+private:
+  friend class Display;
+
+  EGLDisplay _display = EGL_NO_DISPLAY;
+  EGLSurface _surface = EGL_NO_SURFACE;
+
+  Surface(const Surface &) = delete;
+
+  Surface &operator=(const Surface &) = delete;
+};
+
+} // Namespace gl

package/cpp/api/JsiSkiaContext.h

@@ -69,6 +69,9 @@ public:
       void *surface = reinterpret_cast<void *>(nativeBufferPointer);
       auto width = static_cast<int>(arguments[1].asNumber());
       auto height = static_cast<int>(arguments[2].asNumber());
+      if (surface == nullptr) {
+        throw std::runtime_error("Surface is null");
+      }
       auto result =
           context->makeContextFromNativeSurface(surface, width, height);
       // Return the newly constructed object

package/ios/RNSkia-iOS/RNSkMetalCanvasProvider.mm

@@ -77,6 +77,9 @@ bool RNSkMetalCanvasProvider::renderToCanvas(
   // usage growing very fast in the simulator without this.
   @autoreleasepool {
     auto surface = _ctx->getSurface();
+    if (!surface) {
+      return false;
+    }
     auto canvas = surface->getCanvas();
     cb(canvas);
     _ctx->present();

package/ios/RNSkia-iOS/SkiaMetalSurfaceFactory.h

@@ -109,9 +109,13 @@ public:
 
   void resize(int width, int height) override { _skSurface = nullptr; }
 
-  int getWidth() override { return _layer.frame.size.width * _layer.contentsScale; };
+  int getWidth() override {
+    return _layer.frame.size.width * _layer.contentsScale;
+  };
 
-  int getHeight() override { return _layer.frame.size.height * _layer.contentsScale; };
+  int getHeight() override {
+    return _layer.frame.size.height * _layer.contentsScale;
+  };
 
 private:
   SkiaMetalContext *_context;

package/package.json

@@ -7,7 +7,7 @@
     "setup-skia-web": "./scripts/setup-canvaskit.js"
   },
   "title": "React Native Skia",
-  "version": "1.5.4",
+  "version": "1.5.6",
   "description": "High-performance React Native Graphics using Skia",
   "main": "lib/module/index.js",
   "react-native": "src/index.ts",

package/android/cpp/rnskia-android/SkiaOpenGLHelper.h

@@ -1,310 +0,0 @@
-#pragma once
-
-#include "EGL/egl.h"
-#include "GLES2/gl2.h"
-#include <fbjni/fbjni.h>
-#include <jni.h>
-
-#include <atomic>
-
-#include "RNSkLog.h"
-
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdocumentation"
-
-#include "include/core/SkCanvas.h"
-#include "include/core/SkColorSpace.h"
-#include "include/core/SkSurface.h"
-#include "include/gpu/ganesh/GrDirectContext.h"
-#include "include/gpu/ganesh/gl/GrGLDirectContext.h"
-#include "include/gpu/ganesh/gl/GrGLInterface.h"
-
-#pragma clang diagnostic pop
-
-namespace RNSkia {
-
-/**
- * Singleton holding the default display and shared eglContext that will be the
- * first context we create so that we can share data between contexts.
- */
-class OpenGLResourceHolder {
-private:
-  OpenGLResourceHolder() {
-    // Initialize OpenGL
-    glDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
-    if (glDisplay == EGL_NO_DISPLAY) {
-      RNSkLogger::logToConsole("eglGetDisplay failed : %i", glGetError());
-      return;
-    }
-
-    EGLint major;
-    EGLint minor;
-    if (eglInitialize(glDisplay, &major, &minor) != EGL_TRUE) {
-      RNSkLogger::logToConsole("eglInitialize failed : %i", glGetError());
-      return;
-    }
-
-    // Create a default shared context
-    glConfig = getConfig(glDisplay);
-
-    // Create OpenGL context attributes
-    EGLint contextAttribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
-
-    // Initialize the offscreen context for this thread
-    glContext =
-        eglCreateContext(glDisplay, glConfig, glContext, contextAttribs);
-    if (glContext == EGL_NO_CONTEXT) {
-      RNSkLogger::logToConsole("eglCreateContext failed : %i", glGetError());
-    }
-  }
-
-  ~OpenGLResourceHolder() {
-    if (glContext != EGL_NO_CONTEXT) {
-      eglDestroyContext(glDisplay, glContext);
-      glContext = EGL_NO_CONTEXT;
-    }
-
-    if (glDisplay != EGL_NO_DISPLAY) {
-      eglTerminate(glDisplay);
-      glDisplay = EGL_NO_DISPLAY;
-    }
-  }
-  /* Explicitly disallow copying. */
-  OpenGLResourceHolder(const OpenGLResourceHolder &) = delete;
-  OpenGLResourceHolder &operator=(const OpenGLResourceHolder &) = delete;
-
-public:
-  static OpenGLResourceHolder &getInstance() {
-    static OpenGLResourceHolder Instance;
-    return Instance;
-  }
-
-  /**
-   * The first context created will be considered the parent / shared context
-   * and will be used as the parent / shareable context when creating subsequent
-   * contexts.
-   */
-  std::atomic<EGLContext> glContext = EGL_NO_CONTEXT;
-  /**
-   * Shared egl display
-   */
-  std::atomic<EGLDisplay> glDisplay = EGL_NO_DISPLAY;
-
-  /**
-   * Shared eglConfig
-   */
-  std::atomic<EGLConfig> glConfig = 0;
-
-private:
-  /**
-   * Finds the correct EGL Config for the given parameters
-   * @param glDisplay
-   * @return Config or zero if no matching context could be found.
-   */
-  static EGLConfig getConfig(EGLDisplay glDisplay) {
-
-    EGLint att[] = {EGL_RENDERABLE_TYPE,
-                    EGL_OPENGL_ES2_BIT,
-                    EGL_ALPHA_SIZE,
-                    8,
-                    EGL_BLUE_SIZE,
-                    8,
-                    EGL_GREEN_SIZE,
-                    8,
-                    EGL_RED_SIZE,
-                    8,
-                    EGL_DEPTH_SIZE,
-                    0,
-                    EGL_STENCIL_SIZE,
-                    0,
-                    EGL_SAMPLE_BUFFERS,
-                    0,
-                    EGL_NONE};
-
-    EGLint numConfigs;
-    EGLConfig glConfig = 0;
-    if (eglChooseConfig(glDisplay, att, &glConfig, 1, &numConfigs) !=
-            EGL_TRUE ||
-        numConfigs == 0) {
-      RNSkLogger::logToConsole(
-          "Failed to choose a config for %s surface. Error code: %d\n",
-          eglGetError());
-      return 0;
-    }
-
-    return glConfig;
-  }
-};
-
-struct SkiaOpenGLContext {
-  SkiaOpenGLContext() {
-    glContext = EGL_NO_CONTEXT;
-    gl1x1Surface = EGL_NO_SURFACE;
-    directContext = nullptr;
-  }
-  ~SkiaOpenGLContext() {
-    if (gl1x1Surface != EGL_NO_SURFACE) {
-      eglDestroySurface(OpenGLResourceHolder::getInstance().glDisplay,
-                        gl1x1Surface);
-      gl1x1Surface = EGL_NO_SURFACE;
-    }
-
-    if (directContext) {
-      directContext->releaseResourcesAndAbandonContext();
-      directContext = nullptr;
-    }
-
-    if (glContext != EGL_NO_CONTEXT) {
-      eglDestroyContext(OpenGLResourceHolder::getInstance().glDisplay,
-                        glContext);
-      glContext = EGL_NO_CONTEXT;
-    }
-  }
-  EGLContext glContext;
-  EGLSurface gl1x1Surface;
-  sk_sp<GrDirectContext> directContext;
-};
-
-class SkiaOpenGLHelper {
-public:
-  /**
-   * Calls eglMakeCurrent on the surface provided using the provided
-   * thread context.
-   * @param context Skia OpenGL context to use
-   * @param surface Surface to set as current
-   * @return true if eglMakeCurrent was successfull
-   */
-  static bool makeCurrent(SkiaOpenGLContext *context, EGLSurface glSurface) {
-    // We don't need to call make current if we already are current:
-    if (eglGetCurrentSurface(EGL_DRAW) != glSurface ||
-        eglGetCurrentSurface(EGL_READ) != glSurface ||
-        eglGetCurrentContext() != context->glContext) {
-
-      // Make current!
-      if (eglMakeCurrent(OpenGLResourceHolder::getInstance().glDisplay,
-                         glSurface, glSurface,
-                         context->glContext) != EGL_TRUE) {
-        RNSkLogger::logToConsole("eglMakeCurrent failed: %d\n", eglGetError());
-        return false;
-      }
-    }
-    return true;
-  }
-
-  /**
-   * Creates a new windowed surface
-   * @param window ANativeWindow to create surface in
-   * @return EGLSurface or EGL_NO_SURFACE if the call failed
-   */
-  static EGLSurface createWindowedSurface(ANativeWindow *window) {
-    const EGLint attribs[] = {EGL_NONE};
-    return eglCreateWindowSurface(OpenGLResourceHolder::getInstance().glDisplay,
-                                  OpenGLResourceHolder::getInstance().glConfig,
-                                  window, attribs);
-  }
-
-  /**
-   * Destroys an egl surface
-   * @param glSurface
-   * @return
-   */
-  static bool destroySurface(EGLSurface glSurface) {
-    if (eglMakeCurrent(OpenGLResourceHolder::getInstance().glDisplay,
-                       EGL_NO_SURFACE, EGL_NO_SURFACE,
-                       EGL_NO_CONTEXT) != EGL_TRUE) {
-      RNSkLogger::logToConsole(
-          "destroySurface: Could not clear selected surface");
-      return false;
-    }
-    return eglDestroySurface(OpenGLResourceHolder::getInstance().glDisplay,
-                             glSurface) == EGL_TRUE;
-  }
-
-  /**
-   * Calls the eglSwapBuffer in the current thread with the provided surface
-   * @param context Thread context
-   * @param glSurface surface to present
-   * @return true if eglSwapBuffers succeeded.
-   */
-  static bool swapBuffers(SkiaOpenGLContext *context, EGLSurface glSurface) {
-    if (eglSwapBuffers(OpenGLResourceHolder::getInstance().glDisplay,
-                       glSurface) != EGL_TRUE) {
-      RNSkLogger::logToConsole("eglSwapBuffers failed: %d\n", eglGetError());
-      return false;
-    }
-    return true;
-  }
-
-  /***
-   * Creates a new Skia direct context backed by the provided eglContext in the
-   * SkiaOpenGLContext.
-   * @param context Context to store results in
-   * @param sharedContext Shared Context
-   * @return true if the call to create a skia direct context suceeded.
-   */
-  static bool createSkiaDirectContextIfNecessary(SkiaOpenGLContext *context) {
-    if (context->directContext == nullptr) {
-
-      // Create OpenGL context
-      createOpenGLContext(context);
-
-      // Create attributes for a simple 1x1 pbuffer surface that we can
-      // use to activate and create Skia direct context for
-      const EGLint offScreenSurfaceAttribs[] = {EGL_WIDTH, 1, EGL_HEIGHT, 1,
-                                                EGL_NONE};
-
-      context->gl1x1Surface =
-          eglCreatePbufferSurface(OpenGLResourceHolder::getInstance().glDisplay,
-                                  OpenGLResourceHolder::getInstance().glConfig,
-                                  offScreenSurfaceAttribs);
-
-      if (context->gl1x1Surface == EGL_NO_SURFACE) {
-        RNSkLogger::logToConsole("Failed creating a 1x1 pbuffer surface");
-        return false;
-      }
-
-      // Activate
-      if (!makeCurrent(context, context->gl1x1Surface)) {
-        return false;
-      }
-
-      // Create the Skia context
-      auto backendInterface = GrGLMakeNativeInterface();
-      context->directContext = GrDirectContexts::MakeGL(backendInterface);
-
-      if (context->directContext == nullptr) {
-        RNSkLogger::logToConsole("GrDirectContexts::MakeGL failed");
-        return false;
-      }
-    }
-
-    // It all went well!
-    return true;
-  }
-
-private:
-  /**
-   * Creates a new GLContext.
-   * @param context Context to save results in
-   * @return True if the call to eglCreateContext returned a valid OpenGL
-   * Context or if the context already is setup.
-   */
-  static bool createOpenGLContext(SkiaOpenGLContext *context) {
-    // Create OpenGL context attributes
-    EGLint contextAttribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
-
-    // Initialize the offscreen context for this thread
-    context->glContext = eglCreateContext(
-        OpenGLResourceHolder::getInstance().glDisplay,
-        OpenGLResourceHolder::getInstance().glConfig,
-        OpenGLResourceHolder::getInstance().glContext, contextAttribs);
-
-    if (context->glContext == EGL_NO_CONTEXT) {
-      RNSkLogger::logToConsole("eglCreateContext failed: %d\n", eglGetError());
-      return EGL_NO_CONTEXT;
-    }
-
-    return true;
-  }
-};
-} // namespace RNSkia

package/android/cpp/rnskia-android/SkiaOpenGLSurfaceFactory.cpp

@@ -1,188 +0,0 @@
-#include "SkiaOpenGLSurfaceFactory.h"
-#include "GrAHardwareBufferUtils.h"
-#include "SkiaOpenGLHelper.h"
-
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdocumentation"
-
-#include "include/gpu/ganesh/SkImageGanesh.h"
-#include "include/gpu/ganesh/gl/GrGLBackendSurface.h"
-#include "src/gpu/ganesh/gl/GrGLDefines.h"
-
-#pragma clang diagnostic pop
-
-namespace RNSkia {
-
-sk_sp<SkImage> SkiaOpenGLSurfaceFactory::makeImageFromHardwareBuffer(
-    SkiaOpenGLContext *context, void *buffer, bool requireKnownFormat) {
-#if __ANDROID_API__ >= 26
-  const AHardwareBuffer *hardwareBuffer =
-      static_cast<AHardwareBuffer *>(buffer);
-  DeleteImageProc deleteImageProc = nullptr;
-  UpdateImageProc updateImageProc = nullptr;
-  TexImageCtx deleteImageCtx = nullptr;
-
-  AHardwareBuffer_Desc description;
-  AHardwareBuffer_describe(hardwareBuffer, &description);
-  GrBackendFormat format;
-  switch (description.format) {
-  // TODO: find out if we can detect, which graphic buffers support
-  // GR_GL_TEXTURE_2D
-  case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
-    format = GrBackendFormats::MakeGL(GR_GL_RGBA8, GR_GL_TEXTURE_EXTERNAL);
-  case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
-    format = GrBackendFormats::MakeGL(GR_GL_RGBA16F, GR_GL_TEXTURE_EXTERNAL);
-  case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
-    format = GrBackendFormats::MakeGL(GR_GL_RGB565, GR_GL_TEXTURE_EXTERNAL);
-  case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
-    format = GrBackendFormats::MakeGL(GR_GL_RGB10_A2, GR_GL_TEXTURE_EXTERNAL);
-  case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
-    format = GrBackendFormats::MakeGL(GR_GL_RGB8, GR_GL_TEXTURE_EXTERNAL);
-#if __ANDROID_API__ >= 33
-  case AHARDWAREBUFFER_FORMAT_R8_UNORM:
-    format = GrBackendFormats::MakeGL(GR_GL_R8, GR_GL_TEXTURE_EXTERNAL);
-#endif
-  default:
-    if (requireKnownFormat) {
-      format = GrBackendFormat();
-    } else {
-      format = GrBackendFormats::MakeGL(GR_GL_RGBA8, GR_GL_TEXTURE_EXTERNAL);
-    }
-  }
-
-  auto backendTex = MakeGLBackendTexture(
-      context->directContext.get(),
-      const_cast<AHardwareBuffer *>(hardwareBuffer), description.width,
-      description.height, &deleteImageProc, &updateImageProc, &deleteImageCtx,
-      false, format, false);
-  if (!backendTex.isValid()) {
-    RNSkLogger::logToConsole(
-        "Failed to convert HardwareBuffer to OpenGL Texture!");
-    return nullptr;
-  }
-  sk_sp<SkImage> image = SkImages::BorrowTextureFrom(
-      context->directContext.get(), backendTex, kTopLeft_GrSurfaceOrigin,
-      kRGBA_8888_SkColorType, kOpaque_SkAlphaType, nullptr, deleteImageProc,
-      deleteImageCtx);
-  return image;
-#else
-  throw std::runtime_error(
-      "HardwareBuffers are only supported on Android API 26 or higher! Set "
-      "your minSdk to 26 (or higher) and try again.");
-#endif
-}
-
-sk_sp<SkSurface>
-SkiaOpenGLSurfaceFactory::makeOffscreenSurface(SkiaOpenGLContext *context,
-                                               int width, int height) {
-
-  auto colorType = kN32_SkColorType;
-
-  SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
-
-  if (!SkiaOpenGLHelper::makeCurrent(context, context->gl1x1Surface)) {
-    RNSkLogger::logToConsole(
-        "Could not create EGL Surface from native window / surface. Could "
-        "not set new surface as current surface.");
-    return nullptr;
-  }
-
-  // Create texture
-  auto texture = context->directContext->createBackendTexture(
-      width, height, colorType, skgpu::Mipmapped::kNo, GrRenderable::kYes);
-
-  if (!texture.isValid()) {
-    RNSkLogger::logToConsole("couldn't create offscreen texture %dx%d", width,
-                             height);
-  }
-
-  struct ReleaseContext {
-    SkiaOpenGLContext *context;
-    GrBackendTexture texture;
-  };
-
-  auto releaseCtx = new ReleaseContext({context, texture});
-
-  // Create a SkSurface from the GrBackendTexture
-  return SkSurfaces::WrapBackendTexture(
-      context->directContext.get(), texture, kTopLeft_GrSurfaceOrigin, 0,
-      colorType, nullptr, &props,
-      [](void *addr) {
-        auto releaseCtx = reinterpret_cast<ReleaseContext *>(addr);
-
-        releaseCtx->context->directContext->deleteBackendTexture(
-            releaseCtx->texture);
-      },
-      releaseCtx);
-}
-
-sk_sp<SkSurface> AndroidSkiaContext::getSurface() {
-  if (_skSurface == nullptr) {
-
-    // Now we can create a surface
-    _glSurface = SkiaOpenGLHelper::createWindowedSurface(_window);
-    if (_glSurface == EGL_NO_SURFACE) {
-      RNSkLogger::logToConsole(
-          "Could not create EGL Surface from native window / surface.");
-      return nullptr;
-    }
-
-    // Now make this one current
-    if (!SkiaOpenGLHelper::makeCurrent(_context, _glSurface)) {
-      RNSkLogger::logToConsole(
-          "Could not create EGL Surface from native window / surface. Could "
-          "not set new surface as current surface.");
-      return nullptr;
-    }
-
-    // Set up parameters for the render target so that it
-    // matches the underlying OpenGL context.
-    GrGLFramebufferInfo fboInfo;
-
-    // We pass 0 as the framebuffer id, since the
-    // underlying Skia GrGlGpu will read this when wrapping the context in the
-    // render target and the GrGlGpu object.
-    fboInfo.fFBOID = 0;
-    fboInfo.fFormat = 0x8058; // GL_RGBA8
-
-    GLint stencil;
-    glGetIntegerv(GL_STENCIL_BITS, &stencil);
-
-    GLint samples;
-    glGetIntegerv(GL_SAMPLES, &samples);
-
-    auto colorType = kN32_SkColorType;
-
-    auto maxSamples =
-        _context->directContext->maxSurfaceSampleCountForColorType(colorType);
-
-    if (samples > maxSamples) {
-      samples = maxSamples;
-    }
-
-    auto renderTarget = GrBackendRenderTargets::MakeGL(_width, _height, samples,
-                                                       stencil, fboInfo);
-
-    SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
-
-    struct ReleaseContext {
-      EGLSurface glSurface;
-    };
-
-    auto releaseCtx = new ReleaseContext({_glSurface});
-
-    // Create surface object
-    _skSurface = SkSurfaces::WrapBackendRenderTarget(
-        _context->directContext.get(), renderTarget,
-        kBottomLeft_GrSurfaceOrigin, colorType, nullptr, &props,
-        [](void *addr) {
-          auto releaseCtx = reinterpret_cast<ReleaseContext *>(addr);
-          SkiaOpenGLHelper::destroySurface(releaseCtx->glSurface);
-          delete releaseCtx;
-        },
-        reinterpret_cast<void *>(releaseCtx));
-  }
-  return _skSurface;
-}
-
-} // namespace RNSkia

package/android/cpp/rnskia-android/SkiaOpenGLSurfaceFactory.h

@@ -1,100 +0,0 @@
-#pragma once
-
-#include "RNSkLog.h"
-
-#include <fbjni/fbjni.h>
-#include <jni.h>
-
-#include <android/native_window_jni.h>
-#include <android/surface_texture.h>
-#include <android/surface_texture_jni.h>
-#include <condition_variable>
-#include <memory>
-#include <thread>
-#include <unordered_map>
-
-#include "SkiaOpenGLHelper.h"
-#include "WindowContext.h"
-
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdocumentation"
-
-#include "include/core/SkCanvas.h"
-#include "include/core/SkColorSpace.h"
-#include "include/core/SkSurface.h"
-#include "include/gpu/ganesh/GrBackendSurface.h"
-#include "include/gpu/ganesh/GrDirectContext.h"
-#include "include/gpu/ganesh/SkSurfaceGanesh.h"
-#include "include/gpu/ganesh/gl/GrGLInterface.h"
-
-#pragma clang diagnostic pop
-
-namespace RNSkia {
-
-class AndroidSkiaContext : public WindowContext {
-public:
-  AndroidSkiaContext(SkiaOpenGLContext *context, ANativeWindow *window,
-                     int width, int height)
-      : _context(context), _window(window), _width(width), _height(height) {}
-
-  ~AndroidSkiaContext() { ANativeWindow_release(_window); }
-
-  sk_sp<SkSurface> getSurface() override;
-
-  void present() override {
-    if (!SkiaOpenGLHelper::makeCurrent(_context, _glSurface)) {
-      RNSkLogger::logToConsole(
-          "Could not create EGL Surface from native window / surface. Could "
-          "not set new surface as current surface.");
-      return;
-    }
-    // Flush and submit the direct context
-    _context->directContext->flushAndSubmit();
-
-    // Swap buffers
-    SkiaOpenGLHelper::swapBuffers(_context, _glSurface);
-  }
-
-  void resize(int width, int height) override {
-    _skSurface = nullptr;
-    _width = width;
-    _height = height;
-  }
-
-  int getWidth() override { return _width; };
-
-  int getHeight() override { return _height; };
-
-private:
-  ANativeWindow *_window;
-  sk_sp<SkSurface> _skSurface = nullptr;
-  EGLSurface _glSurface = EGL_NO_SURFACE;
-  SkiaOpenGLContext *_context;
-  int _width = 0;
-  int _height = 0;
-};
-
-class SkiaOpenGLSurfaceFactory {
-public:
-  /**
-   * Creates a new Skia surface that is backed by a texture.
-   * @param width Width of surface
-   * @param height Height of surface
-   * @return An SkSurface backed by a texture.
-   */
-  static sk_sp<SkSurface> makeOffscreenSurface(SkiaOpenGLContext *context,
-                                               int width, int height);
-
-  static sk_sp<SkImage>
-  makeImageFromHardwareBuffer(SkiaOpenGLContext *context, void *buffer,
-                              bool requireKnownFormat = false);
-
-  static std::unique_ptr<AndroidSkiaContext>
-  makeContext(SkiaOpenGLContext *context, ANativeWindow *surface, int width,
-              int height) {
-    return std::make_unique<AndroidSkiaContext>(context, surface, width,
-                                                height);
-  }
-};
-
-} // namespace RNSkia