@shopify/react-native-skia 1.5.3 → 1.5.5

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