react-native-skia 3.0.1 → 3.0.2

package/android/cpp/jni/include/JniSkiaPictureView.h

@@ -1,172 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include <fbjni/fbjni.h>
-#include <jni.h>
-#include <jsi/jsi.h>
-
-#include "JniSkiaBaseView.h"
-#include "JniSkiaManager.h"
-#include "RNSkAndroidView.h"
-#include "RNSkPictureView.h"
-
-#include <android/native_window.h>
-#include <android/native_window_jni.h>
-#include <fbjni/detail/Hybrid.h>
-
-#if defined(SK_GRAPHITE)
-#include "RNDawnContext.h"
-#else
-#include "OpenGLContext.h"
-#endif
-#include "include/core/SkBitmap.h"
-#include "include/core/SkCanvas.h"
-#include "include/core/SkImage.h"
-#include "include/core/SkPaint.h"
-#include "include/core/SkPicture.h"
-#include "include/core/SkPictureRecorder.h"
-#include "include/core/SkSurface.h"
-
-namespace RNSkia {
-namespace jsi = facebook::jsi;
-namespace jni = facebook::jni;
-
-class JniSkiaPictureView : public jni::HybridClass<JniSkiaPictureView>,
-                           public JniSkiaBaseView {
-public:
-  static auto constexpr kJavaDescriptor =
-      "Lcom/reactnative/skia/SkiaPictureView;";
-
-  static jni::local_ref<jhybriddata>
-  initHybrid(jni::alias_ref<jhybridobject> jThis,
-             jni::alias_ref<JniSkiaManager::javaobject> skiaManager) {
-    return makeCxxInstance(jThis, skiaManager);
-  }
-
-  static void registerNatives() {
-    registerHybrid(
-        {makeNativeMethod("initHybrid", JniSkiaPictureView::initHybrid),
-         makeNativeMethod("surfaceAvailable",
-                          JniSkiaPictureView::surfaceAvailable),
-         makeNativeMethod("surfaceDestroyed",
-                          JniSkiaPictureView::surfaceDestroyed),
-         makeNativeMethod("surfaceSizeChanged",
-                          JniSkiaPictureView::surfaceSizeChanged),
-         makeNativeMethod("setDebugMode", JniSkiaPictureView::setDebugMode),
-         makeNativeMethod("registerView", JniSkiaPictureView::registerView),
-         makeNativeMethod("unregisterView", JniSkiaPictureView::unregisterView),
-         makeNativeMethod("getBitmap", JniSkiaPictureView::getBitmap)});
-  }
-
-protected:
-  void surfaceAvailable(jobject surface, int width, int height, bool isSurface,
-                        bool highBitDepth) override {
-    JniSkiaBaseView::surfaceAvailable(surface, width, height, isSurface,
-                                      highBitDepth);
-  }
-
-  void surfaceSizeChanged(jobject surface, int width, int height,
-                          bool isSurface, bool highBitDepth) override {
-    JniSkiaBaseView::surfaceSizeChanged(surface, width, height, isSurface,
-                                        highBitDepth);
-  }
-
-  void surfaceDestroyed() override { JniSkiaBaseView::surfaceDestroyed(); }
-
-  void setDebugMode(bool show) override { JniSkiaBaseView::setDebugMode(show); }
-
-  void registerView(int nativeId) override {
-    JniSkiaBaseView::registerView(nativeId);
-  }
-
-  void unregisterView() override { JniSkiaBaseView::unregisterView(); }
-
-  jni::local_ref<jni::JArrayInt> getBitmap(int width, int height) override {
-    // Get the RNSkPictureView from the android view
-    auto pictureView =
-        std::static_pointer_cast<RNSkAndroidView<RNSkia::RNSkPictureView>>(
-            _skiaAndroidView);
-    if (!pictureView) {
-      return JniSkiaBaseView::getBitmap(width, height);
-    }
-
-    // Get the renderer and cast it to RNSkPictureRenderer
-    auto renderer = std::static_pointer_cast<RNSkia::RNSkPictureRenderer>(
-        pictureView->getRenderer());
-    if (!renderer) {
-      return jni::JArrayInt::newArray(0);
-    }
-
-    const size_t pixelCount =
-        static_cast<size_t>(width) * static_cast<size_t>(height);
-    if (pixelCount == 0) {
-      return jni::JArrayInt::newArray(0);
-    }
-
-    sk_sp<SkSurface> surface;
-#if defined(SK_GRAPHITE)
-    surface = DawnContext::getInstance().MakeOffscreen(width, height);
-#else
-    surface = OpenGLContext::getInstance().MakeOffscreen(width, height);
-#endif
-
-    if (!surface) {
-      return jni::JArrayInt::newArray(0);
-    }
-
-    SkCanvas *canvas = surface->getCanvas();
-    if (canvas == nullptr) {
-      return jni::JArrayInt::newArray(0);
-    }
-
-    // Draws whatever the view currently shows: a picture or a recorder.
-    renderer->drawInto(canvas, pictureView->getPixelDensity());
-
-    sk_sp<SkImage> snapshot = surface->makeImageSnapshot();
-    if (!snapshot) {
-      return jni::JArrayInt::newArray(0);
-    }
-
-    sk_sp<SkImage> image = snapshot->makeNonTextureImage();
-    if (!image) {
-      return jni::JArrayInt::newArray(0);
-    }
-
-    if (!image) {
-      return jni::JArrayInt::newArray(0);
-    }
-
-    std::vector<int32_t> pixels(pixelCount);
-    SkImageInfo readInfo = SkImageInfo::Make(
-        width, height, kBGRA_8888_SkColorType, kPremul_SkAlphaType);
-    size_t rowBytes = static_cast<size_t>(width) * sizeof(int32_t);
-    if (!image->readPixels(nullptr, readInfo, pixels.data(), rowBytes, 0, 0)) {
-      return jni::JArrayInt::newArray(0);
-    }
-
-    auto intArray = jni::JArrayInt::newArray(pixelCount);
-    intArray->setRegion(0, pixelCount,
-                        reinterpret_cast<const jint *>(pixels.data()));
-
-    return intArray;
-  }
-
-private:
-  friend HybridBase;
-
-  explicit JniSkiaPictureView(
-      jni::alias_ref<jhybridobject> jThis,
-      jni::alias_ref<JniSkiaManager::javaobject> skiaManager)
-      : JniSkiaBaseView(
-            skiaManager,
-            std::make_shared<RNSkAndroidView<RNSkia::RNSkPictureView>>(
-                skiaManager->cthis()->getPlatformContext())) {}
-
-  jni::global_ref<javaobject> javaPart_;
-};
-
-} // namespace RNSkia

package/android/cpp/rnskia-android/GrAHardwareBufferUtils.cpp

@@ -1,245 +0,0 @@
-/*
- * Copyright 2023 Google LLC
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "GrAHardwareBufferUtils.h"
-#if __ANDROID_API__ >= 26
-
-#define GL_GLEXT_PROTOTYPES
-#define EGL_EGLEXT_PROTOTYPES
-
-#include "include/gpu/ganesh/GrBackendSurface.h"
-#include "include/gpu/ganesh/GrDirectContext.h"
-#include "include/gpu/ganesh/gl/GrGLBackendSurface.h"
-#include "include/gpu/ganesh/gl/GrGLTypes.h"
-#include "src/gpu/ganesh/gl/GrGLDefines.h"
-// #include "src/gpu/ganesh/GrDirectContextPriv.h"
-// #include "src/gpu/ganesh/gl/GrGLUtil.h"
-
-#include <EGL/egl.h>
-#include <EGL/eglext.h>
-#include <GLES/gl.h>
-#include <GLES/glext.h>
-#include <android/hardware_buffer.h>
-
-#define PROT_CONTENT_EXT_STR "EGL_EXT_protected_content"
-#define EGL_PROTECTED_CONTENT_EXT 0x32C0
-
-namespace RNSkia {
-
-typedef EGLClientBuffer (*EGLGetNativeClientBufferANDROIDProc)(
-    const struct AHardwareBuffer *);
-typedef EGLImageKHR (*EGLCreateImageKHRProc)(EGLDisplay, EGLContext, EGLenum,
-                                             EGLClientBuffer, const EGLint *);
-typedef void (*EGLImageTargetTexture2DOESProc)(EGLenum, void *);
-
-GrBackendFormat GetGLBackendFormat(GrDirectContext *dContext,
-                                   uint32_t bufferFormat,
-                                   bool requireKnownFormat) {
-  GrBackendApi backend = dContext->backend();
-  if (backend != GrBackendApi::kOpenGL) {
-    return {};
-  }
-  switch (bufferFormat) {
-  // TODO: find out if we can detect, which graphic buffers support
-  // GR_GL_TEXTURE_2D
-  case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
-  case AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM:
-    return GrBackendFormats::MakeGL(GR_GL_RGBA8, GR_GL_TEXTURE_EXTERNAL);
-  case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
-    return GrBackendFormats::MakeGL(GR_GL_RGBA16F, GR_GL_TEXTURE_EXTERNAL);
-  case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
-    return GrBackendFormats::MakeGL(GR_GL_RGB565, GR_GL_TEXTURE_EXTERNAL);
-  case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
-    return GrBackendFormats::MakeGL(GR_GL_RGB10_A2, GR_GL_TEXTURE_EXTERNAL);
-  case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
-    return GrBackendFormats::MakeGL(GR_GL_RGB8, GR_GL_TEXTURE_EXTERNAL);
-#if __ANDROID_API__ >= 33
-  case AHARDWAREBUFFER_FORMAT_R8_UNORM:
-    return GrBackendFormats::MakeGL(GR_GL_R8, GR_GL_TEXTURE_EXTERNAL);
-#endif
-  default:
-    if (requireKnownFormat) {
-      return {};
-    } else {
-      return GrBackendFormats::MakeGL(GR_GL_RGBA8, GR_GL_TEXTURE_EXTERNAL);
-    }
-  }
-  SkUNREACHABLE;
-}
-
-class GLTextureHelper {
-public:
-  GLTextureHelper(GrGLuint texID, EGLImageKHR image, EGLDisplay display,
-                  GrGLuint texTarget)
-      : fTexID(texID), fImage(image), fDisplay(display), fTexTarget(texTarget) {
-  }
-  ~GLTextureHelper() {
-    glDeleteTextures(1, &fTexID);
-    // eglDestroyImageKHR will remove a ref from the AHardwareBuffer
-    eglDestroyImageKHR(fDisplay, fImage);
-  }
-  void rebind(GrDirectContext *);
-
-private:
-  GrGLuint fTexID;
-  EGLImageKHR fImage;
-  EGLDisplay fDisplay;
-  GrGLuint fTexTarget;
-};
-
-void GLTextureHelper::rebind(GrDirectContext *dContext) {
-  glBindTexture(fTexTarget, fTexID);
-  GLenum status = GL_NO_ERROR;
-  if ((status = glGetError()) != GL_NO_ERROR) {
-    SkDebugf("glBindTexture(%#x, %d) failed (%#x)",
-             static_cast<int>(fTexTarget), static_cast<int>(fTexID),
-             static_cast<int>(status));
-    return;
-  }
-  glEGLImageTargetTexture2DOES(fTexTarget, fImage);
-  if ((status = glGetError()) != GL_NO_ERROR) {
-    SkDebugf("glEGLImageTargetTexture2DOES failed (%#x)",
-             static_cast<int>(status));
-    return;
-  }
-  dContext->resetContext(kTextureBinding_GrGLBackendState);
-}
-
-void delete_gl_texture(void *context) {
-  auto cleanupHelper = static_cast<GLTextureHelper *>(context);
-  delete cleanupHelper;
-}
-
-void update_gl_texture(void *context, GrDirectContext *dContext) {
-  auto cleanupHelper = static_cast<GLTextureHelper *>(context);
-  cleanupHelper->rebind(dContext);
-}
-
-static GrBackendTexture make_gl_backend_texture(
-    GrDirectContext *dContext, AHardwareBuffer *hardwareBuffer, int width,
-    int height, DeleteImageProc *deleteProc, UpdateImageProc *updateProc,
-    TexImageCtx *imageCtx, bool isProtectedContent,
-    const GrBackendFormat &backendFormat, bool isRenderable) {
-  while (GL_NO_ERROR != glGetError()) {
-  } // clear GL errors
-
-  auto eglGetNativeClientBufferANDROID =
-      (EGLGetNativeClientBufferANDROIDProc)eglGetProcAddress(
-          "eglGetNativeClientBufferANDROID");
-  if (!eglGetNativeClientBufferANDROID) {
-    RNSkLogger::logToConsole(
-        "Failed to get the eglGetNativeClientBufferAndroid proc");
-    return {};
-  }
-
-  EGLClientBuffer clientBuffer =
-      eglGetNativeClientBufferANDROID(hardwareBuffer);
-  EGLint attribs[] = {EGL_IMAGE_PRESERVED_KHR, EGL_TRUE,
-                      isProtectedContent ? EGL_PROTECTED_CONTENT_EXT : EGL_NONE,
-                      isProtectedContent ? EGL_TRUE : EGL_NONE, EGL_NONE};
-  EGLDisplay display = eglGetCurrentDisplay();
-  // eglCreateImageKHR will add a ref to the AHardwareBuffer
-  EGLImageKHR image =
-      eglCreateImageKHR(display, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,
-                        clientBuffer, attribs);
-  if (EGL_NO_IMAGE_KHR == image) {
-    SkDebugf("Could not create EGL image, err = (%#x)",
-             static_cast<int>(eglGetError()));
-    return {};
-  }
-
-  GrGLuint texID;
-  glGenTextures(1, &texID);
-  if (!texID) {
-    eglDestroyImageKHR(display, image);
-    return {};
-  }
-
-  GrGLuint target = isRenderable ? GR_GL_TEXTURE_2D : GR_GL_TEXTURE_EXTERNAL;
-
-  glBindTexture(target, texID);
-  GLenum status = GL_NO_ERROR;
-  if ((status = glGetError()) != GL_NO_ERROR) {
-    SkDebugf("glBindTexture failed (%#x)", static_cast<int>(status));
-    glDeleteTextures(1, &texID);
-    eglDestroyImageKHR(display, image);
-    return {};
-  }
-  glEGLImageTargetTexture2DOES(target, image);
-  if ((status = glGetError()) != GL_NO_ERROR) {
-    SkDebugf("glEGLImageTargetTexture2DOES failed (%#x)",
-             static_cast<int>(status));
-    glDeleteTextures(1, &texID);
-    eglDestroyImageKHR(display, image);
-    return {};
-  }
-  dContext->resetContext(kTextureBinding_GrGLBackendState);
-
-  GrGLTextureInfo textureInfo;
-  textureInfo.fID = texID;
-  SkASSERT(backendFormat.isValid());
-  textureInfo.fTarget = target;
-  textureInfo.fFormat = GrBackendFormats::AsGLFormatEnum(backendFormat);
-  textureInfo.fProtected = skgpu::Protected(isProtectedContent);
-
-  *deleteProc = delete_gl_texture;
-  *updateProc = update_gl_texture;
-  *imageCtx = new GLTextureHelper(texID, image, display, target);
-
-  return GrBackendTextures::MakeGL(width, height, skgpu::Mipmapped::kNo,
-                                   textureInfo);
-}
-
-static bool can_import_protected_content_eglimpl() {
-  EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
-  const char *exts = eglQueryString(dpy, EGL_EXTENSIONS);
-  size_t cropExtLen = strlen(PROT_CONTENT_EXT_STR);
-  size_t extsLen = strlen(exts);
-  bool equal = !strcmp(PROT_CONTENT_EXT_STR, exts);
-  bool atStart = !strncmp(PROT_CONTENT_EXT_STR " ", exts, cropExtLen + 1);
-  bool atEnd =
-      (cropExtLen + 1) < extsLen &&
-      !strcmp(" " PROT_CONTENT_EXT_STR, exts + extsLen - (cropExtLen + 1));
-  bool inMiddle = strstr(exts, " " PROT_CONTENT_EXT_STR " ");
-  return equal || atStart || atEnd || inMiddle;
-}
-
-static bool can_import_protected_content(GrDirectContext *dContext) {
-  SkASSERT(GrBackendApi::kOpenGL == dContext->backend());
-  // Only compute whether the extension is present once the first time this
-  // function is called.
-  static bool hasIt = can_import_protected_content_eglimpl();
-  return hasIt;
-}
-
-GrBackendTexture
-MakeGLBackendTexture(GrDirectContext *dContext, AHardwareBuffer *hardwareBuffer,
-                     int width, int height, DeleteImageProc *deleteProc,
-                     UpdateImageProc *updateProc, TexImageCtx *imageCtx,
-                     bool isProtectedContent,
-                     const GrBackendFormat &backendFormat, bool isRenderable) {
-  SkASSERT(dContext);
-  if (dContext->abandoned()) {
-    return {};
-  }
-
-  if (GrBackendApi::kOpenGL != dContext->backend()) {
-    return {};
-  }
-
-  if (isProtectedContent && !can_import_protected_content(dContext)) {
-    return {};
-  }
-
-  return make_gl_backend_texture(
-      dContext, hardwareBuffer, width, height, deleteProc, updateProc, imageCtx,
-      isProtectedContent, backendFormat, isRenderable);
-}
-
-} // namespace RNSkia
-
-#endif

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

@@ -1,33 +0,0 @@
-#pragma once
-
-#include "include/core/SkTypes.h"
-
-#include "RNSkLog.h"
-
-#if __ANDROID_API__ >= 26
-
-#include "include/gpu/ganesh/GrBackendSurface.h"
-#include "include/gpu/ganesh/GrTypes.h"
-
-class GrDirectContext;
-
-extern "C" {
-typedef struct AHardwareBuffer AHardwareBuffer;
-}
-
-namespace RNSkia {
-
-typedef void *TexImageCtx;
-typedef void (*DeleteImageProc)(TexImageCtx);
-typedef void (*UpdateImageProc)(TexImageCtx, GrDirectContext *);
-
-GrBackendTexture
-MakeGLBackendTexture(GrDirectContext *dContext, AHardwareBuffer *hardwareBuffer,
-                     int width, int height, DeleteImageProc *deleteProc,
-                     UpdateImageProc *updateProc, TexImageCtx *imageCtx,
-                     bool isProtectedContent,
-                     const GrBackendFormat &backendFormat, bool isRenderable);
-
-} // namespace RNSkia
-
-#endif

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

@@ -1,248 +0,0 @@
-#pragma once
-
-#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 OpenGLSharedContext {
-public:
-  OpenGLSharedContext(const OpenGLSharedContext &) = delete;
-  OpenGLSharedContext &operator=(const OpenGLSharedContext &) = delete;
-
-  static OpenGLSharedContext &getInstance() {
-    static OpenGLSharedContext instance;
-    return instance;
-  }
-
-  gl::Display *getDisplay() { return _glDisplay.get(); }
-  gl::Context *getContext() { return _glContext.get(); }
-  gl::Surface *getSurface() { return _glSurface.get(); }
-  EGLConfig getConfig() { return _glConfig; }
-
-private:
-  std::unique_ptr<gl::Display> _glDisplay;
-  std::unique_ptr<gl::Context> _glContext;
-  std::unique_ptr<gl::Surface> _glSurface;
-  EGLConfig _glConfig;
-
-  OpenGLSharedContext() {
-    _glDisplay = std::make_unique<gl::Display>();
-    _glConfig = _glDisplay->chooseConfig();
-    _glContext = _glDisplay->makeContext(_glConfig, nullptr);
-    _glSurface = _glDisplay->makePixelBufferSurface(_glConfig, 1, 1);
-    if (_glContext == nullptr || _glSurface == nullptr) {
-      RNSkLogger::logToConsole(
-          "Couldn't create the shared OpenGL context or surface");
-      return;
-    }
-    _glContext->makeCurrent(_glSurface.get());
-  }
-};
-
-class OpenGLContext {
-public:
-  friend class OpenGLWindowContext;
-
-  OpenGLContext(const OpenGLContext &) = delete;
-  OpenGLContext &operator=(const OpenGLContext &) = delete;
-
-  static OpenGLContext &getInstance() {
-    static thread_local OpenGLContext instance;
-    return instance;
-  }
-
-  sk_sp<SkSurface> MakeOffscreen(int width, int height,
-                                 bool useP3ColorSpace = false) {
-    if (_directContext == nullptr) {
-      return nullptr;
-    }
-
-    auto colorType = kRGBA_8888_SkColorType;
-
-    SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
-
-    auto result = _glContext->makeCurrent(_glSurface.get());
-    if (!result) {
-      return nullptr;
-    }
-
-    // Create texture
-    auto GL_RGBA8 = 0x8058;
-    auto format = GrBackendFormats::MakeGL(GL_RGBA8, GL_TEXTURE_2D);
-    auto texture = _directContext->createBackendTexture(
-        width, height, format, SkColors::kTransparent, skgpu::Mipmapped::kNo,
-        GrRenderable::kYes);
-
-    if (!texture.isValid()) {
-      RNSkLogger::logToConsole("couldn't create offscreen texture %dx%d", width,
-                               height);
-      return nullptr;
-    }
-
-    struct ReleaseContext {
-      GrDirectContext *directContext;
-      GrBackendTexture texture;
-    };
-
-    auto releaseCtx = new ReleaseContext{.directContext = _directContext.get(),
-                                         .texture = texture};
-
-    sk_sp<SkColorSpace> colorSpace =
-        useP3ColorSpace ? SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB,
-                                                SkNamedGamut::kDisplayP3)
-                        : nullptr;
-
-    // Create a SkSurface from the GrBackendTexture
-    return SkSurfaces::WrapBackendTexture(
-        _directContext.get(), texture, kTopLeft_GrSurfaceOrigin, 0, colorType,
-        colorSpace, &props,
-        [](void *addr) {
-          auto releaseCtx = reinterpret_cast<ReleaseContext *>(addr);
-          releaseCtx->directContext->deleteBackendTexture(releaseCtx->texture);
-          delete releaseCtx;
-        },
-        releaseCtx);
-  }
-
-  sk_sp<SkImage> MakeImageFromBuffer(void *buffer,
-                                     bool requireKnownFormat = false) {
-#if __ANDROID_API__ >= 26
-    if (_directContext == nullptr) {
-      return nullptr;
-    }
-    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;
-    auto colorType = kRGBA_8888_SkColorType;
-    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);
-      colorType = kRGBA_8888_SkColorType;
-      break;
-    case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
-      format = GrBackendFormats::MakeGL(GR_GL_RGBA16F, GR_GL_TEXTURE_EXTERNAL);
-      colorType = kRGBA_F16_SkColorType;
-      break;
-    case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
-      format = GrBackendFormats::MakeGL(GR_GL_RGB565, GR_GL_TEXTURE_EXTERNAL);
-      colorType = kRGB_565_SkColorType;
-      break;
-    case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
-      format = GrBackendFormats::MakeGL(GR_GL_RGB10_A2, GR_GL_TEXTURE_EXTERNAL);
-      colorType = kRGBA_1010102_SkColorType;
-      break;
-    case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
-      format = GrBackendFormats::MakeGL(GR_GL_RGB8, GR_GL_TEXTURE_EXTERNAL);
-      colorType = kRGB_888x_SkColorType;
-      break;
-#if __ANDROID_API__ >= 33
-    case AHARDWAREBUFFER_FORMAT_R8_UNORM:
-      format = GrBackendFormats::MakeGL(GR_GL_R8, GR_GL_TEXTURE_EXTERNAL);
-      colorType = kAlpha_8_SkColorType;
-      break;
-#endif
-    default:
-      if (requireKnownFormat) {
-        format = GrBackendFormat();
-      } else {
-        format = GrBackendFormats::MakeGL(GR_GL_RGBA8, GR_GL_TEXTURE_EXTERNAL);
-      }
-    }
-    auto width = static_cast<int>(description.width);
-    auto height = static_cast<int>(description.height);
-    auto backendTex = MakeGLBackendTexture(
-        _directContext.get(), const_cast<AHardwareBuffer *>(hardwareBuffer),
-        width, 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, colorType,
-        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
-  }
-
-  // TODO: remove width, height
-  std::unique_ptr<WindowContext> MakeWindow(ANativeWindow *window,
-                                            bool highBitDepth = false) {
-    if (_directContext == nullptr) {
-      RNSkLogger::logToConsole(
-          "The OpenGL context is invalid, the surface will not be rendered");
-      return nullptr;
-    }
-    auto display = OpenGLSharedContext::getInstance().getDisplay();
-    if (highBitDepth) {
-      // A 10-bit window surface would require the shared EGL context to be
-      // created without a config (EGL_KHR_no_config_context) for every app,
-      // which is too risky for existing 8-bit clients on brittle drivers.
-      RNSkLogger::logToConsole(
-          "highBitDepth is not supported on the OpenGL backend, falling back "
-          "to the 8-bit format (the Graphite backend supports it)");
-    }
-    return std::make_unique<OpenGLWindowContext>(
-        _directContext.get(), display, _glContext.get(), window,
-        OpenGLSharedContext::getInstance().getConfig());
-  }
-
-  GrDirectContext *getDirectContext() { return _directContext.get(); }
-  void makeCurrent() {
-    if (_glContext != nullptr) {
-      _glContext->makeCurrent(_glSurface.get());
-    }
-  }
-
-private:
-  std::unique_ptr<gl::Context> _glContext;
-  std::unique_ptr<gl::Surface> _glSurface;
-  sk_sp<GrDirectContext> _directContext;
-
-  OpenGLContext() {
-    auto display = OpenGLSharedContext::getInstance().getDisplay();
-    auto sharedContext = OpenGLSharedContext::getInstance().getContext();
-    auto glConfig = OpenGLSharedContext::getInstance().getConfig();
-    _glContext = display->makeContext(glConfig, sharedContext);
-    _glSurface = display->makePixelBufferSurface(glConfig, 1, 1);
-    if (_glContext == nullptr || _glSurface == nullptr ||
-        !_glContext->makeCurrent(_glSurface.get())) {
-      RNSkLogger::logToConsole(
-          "Couldn't create the OpenGL context, Skia rendering is disabled");
-      return;
-    }
-    auto backendInterface = GrGLMakeNativeInterface();
-    _directContext = GrDirectContexts::MakeGL(backendInterface);
-
-    if (_directContext == nullptr) {
-      RNSkLogger::logToConsole("GrDirectContexts::MakeGL failed");
-    }
-  }
-};
-
-} // namespace RNSkia