@shopify/react-native-skia 0.1.200 → 0.1.202

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

@@ -0,0 +1,310 @@
+#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 "SkCanvas.h"
+#include "SkColorSpace.h"
+#include "SkSurface.h"
+#include "include/gpu/GrDirectContext.h"
+#include "include/gpu/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;
+    }
+    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 = GrDirectContext::MakeGL(backendInterface);
+
+      if (context->directContext == nullptr) {
+        RNSkLogger::logToConsole("GrDirectContext::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

@@ -0,0 +1,132 @@
+#include "SkiaOpenGLHelper.h"
+#include <SkiaOpenGLSurfaceFactory.h>
+
+namespace RNSkia {
+
+thread_local SkiaOpenGLContext ThreadContextHolder::ThreadSkiaOpenGLContext;
+
+sk_sp<SkSurface> SkiaOpenGLSurfaceFactory::makeOffscreenSurface(int width,
+                                                                int height) {
+  // Setup OpenGL and Skia:
+  if (!SkiaOpenGLHelper::createSkiaDirectContextIfNecessary(
+          &ThreadContextHolder::ThreadSkiaOpenGLContext)) {
+
+    RNSkLogger::logToConsole(
+        "Could not create Skia Surface from native window / surface. "
+        "Failed creating Skia Direct Context");
+    return nullptr;
+  }
+
+  auto colorType = kN32_SkColorType;
+
+  SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
+
+  // Create texture
+  auto texture =
+      ThreadContextHolder::ThreadSkiaOpenGLContext.directContext
+          ->createBackendTexture(width, height, colorType, GrMipMapped::kNo,
+                                 GrRenderable::kYes);
+
+  struct ReleaseContext {
+    SkiaOpenGLContext *context;
+    GrBackendTexture texture;
+  };
+
+  auto releaseCtx = new ReleaseContext(
+      {&ThreadContextHolder::ThreadSkiaOpenGLContext, texture});
+
+  // Create a SkSurface from the GrBackendTexture
+  return SkSurfaces::WrapBackendTexture(
+      ThreadContextHolder::ThreadSkiaOpenGLContext.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> WindowSurfaceHolder::getSurface() {
+  if (_skSurface == nullptr) {
+
+    // Setup OpenGL and Skia
+    if (!SkiaOpenGLHelper::createSkiaDirectContextIfNecessary(
+            &ThreadContextHolder::ThreadSkiaOpenGLContext)) {
+      RNSkLogger::logToConsole(
+          "Could not create Skia Surface from native window / surface. "
+          "Failed creating Skia Direct Context");
+      return 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(
+            &ThreadContextHolder::ThreadSkiaOpenGLContext, _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 =
+        ThreadContextHolder::ThreadSkiaOpenGLContext.directContext
+            ->maxSurfaceSampleCountForColorType(colorType);
+
+    if (samples > maxSamples) {
+      samples = maxSamples;
+    }
+
+    GrBackendRenderTarget renderTarget(_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(
+        ThreadContextHolder::ThreadSkiaOpenGLContext.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

@@ -0,0 +1,125 @@
+#pragma once
+
+#include <RNSkLog.h>
+
+#include <fbjni/fbjni.h>
+#include <jni.h>
+
+#include <android/native_window_jni.h>
+#include <condition_variable>
+#include <memory>
+#include <thread>
+#include <unordered_map>
+
+#include "SkiaOpenGLHelper.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "SkCanvas.h"
+#include "SkColorSpace.h"
+#include "SkSurface.h"
+#include "include/gpu/GrBackendSurface.h"
+#include "include/gpu/GrDirectContext.h"
+#include "include/gpu/ganesh/SkSurfaceGanesh.h"
+#include "include/gpu/gl/GrGLInterface.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+/**
+ * Holder of the thread local SkiaOpenGLContext member
+ */
+class ThreadContextHolder {
+public:
+  static thread_local SkiaOpenGLContext ThreadSkiaOpenGLContext;
+};
+
+/**
+ * Holder of the Windowed SkSurface with support for making current
+ * and presenting to screen
+ */
+class WindowSurfaceHolder {
+public:
+  WindowSurfaceHolder(jobject surface, int width, int height)
+      : _width(width), _height(height),
+        _window(ANativeWindow_fromSurface(facebook::jni::Environment::current(),
+                                          surface)) {}
+
+  ~WindowSurfaceHolder() { ANativeWindow_release(_window); }
+
+  int getWidth() { return _width; }
+  int getHeight() { return _height; }
+
+  /*
+   * Ensures that the holder has a valid surface and returns the surface.
+   */
+  sk_sp<SkSurface> getSurface();
+
+  /**
+   * Resizes the surface
+   * @param width
+   * @param height
+   */
+  void resize(int width, int height) {
+    _width = width;
+    _height = height;
+    _skSurface = nullptr;
+  }
+
+  /**
+   * Sets the current surface as the active surface
+   * @return true if make current succeeds
+   */
+  bool makeCurrent() {
+    return SkiaOpenGLHelper::makeCurrent(
+        &ThreadContextHolder::ThreadSkiaOpenGLContext, _glSurface);
+  }
+
+  /**
+   * Presents the current drawing operations by swapping buffers
+   * @return true if make current succeeds
+   */
+  bool present() {
+    // Flush and submit the direct context
+    ThreadContextHolder::ThreadSkiaOpenGLContext.directContext
+        ->flushAndSubmit();
+
+    // Swap buffers
+    return SkiaOpenGLHelper::swapBuffers(
+        &ThreadContextHolder::ThreadSkiaOpenGLContext, _glSurface);
+  }
+
+private:
+  ANativeWindow *_window = nullptr;
+  sk_sp<SkSurface> _skSurface = nullptr;
+  EGLSurface _glSurface = EGL_NO_SURFACE;
+  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(int width, int height);
+
+  /**
+   * Creates a windowed Skia Surface holder.
+   * @param width Initial width of surface
+   * @param height Initial height of surface
+   * @param window Window coming from Java
+   * @return A Surface holder
+   */
+  static std::unique_ptr<WindowSurfaceHolder>
+  makeWindowedSurface(jobject window, int width, int height) {
+    return std::make_unique<WindowSurfaceHolder>(window, width, height);
+  }
+};
+
+} // namespace RNSkia