react-native-tgfx 0.0.0 → 0.0.2-alpha.0

package/cpp/third_party/tgfx/src/platform/android/SurfaceTexture.cpp

@@ -0,0 +1,309 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2023 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  unless required by applicable law or agreed to in writing, software distributed under the
+//  license is distributed on an "as is" basis, without warranties or conditions of any kind,
+//  either express or implied. see the license for the specific language governing permissions
+//  and limitations under the license.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "platform/android/SurfaceTexture.h"
+#include <chrono>
+#include "HandlerThread.h"
+#include "JNIUtil.h"
+#include "core/utils/ColorSpaceHelper.h"
+#include "core/utils/Log.h"
+#include "gpu/opengl/GLFunctions.h"
+#include "gpu/opengl/GLGPU.h"
+#include "gpu/opengl/GLTexture.h"
+#include "gpu/resources/DefaultTextureView.h"
+
+namespace tgfx {
+static Global<jclass> SurfaceTextureClass;
+static jmethodID SurfaceTexture_Constructor_singleBufferMode;
+static jmethodID SurfaceTexture_Constructor_texName;
+static jmethodID SurfaceTexture_setOnFrameAvailableListenerHandler;
+static jmethodID SurfaceTexture_setOnFrameAvailableListener;
+static jfieldID SurfaceTexture_mEventHandler;
+static jmethodID SurfaceTexture_updateTexImage;
+static jmethodID SurfaceTexture_attachToGLContext;
+static jmethodID SurfaceTexture_detachFromGLContext;
+static jmethodID SurfaceTexture_getTransformMatrix;
+static jmethodID SurfaceTexture_release;
+static jmethodID SurfaceTexture_getDataSpace;
+static Global<jclass> SurfaceClass;
+static jmethodID Surface_Constructor;
+static Global<jclass> HandlerClass;
+static jmethodID Handler_Constructor;
+static Global<jclass> EventHandlerClass;
+static jmethodID EventHandler_Constructor;
+static Global<jclass> DataSpaceClass;
+static jmethodID DataSpaceClass_getStandard;
+static jmethodID DataSpaceClass_getTransfer;
+
+void SurfaceTexture::JNIInit(JNIEnv* env) {
+  SurfaceTextureClass = env->FindClass("android/graphics/SurfaceTexture");
+  SurfaceTexture_Constructor_singleBufferMode =
+      env->GetMethodID(SurfaceTextureClass.get(), "<init>", "(Z)V");
+  if (env->ExceptionCheck()) {
+    env->ExceptionClear();
+    SurfaceTexture_Constructor_texName =
+        env->GetMethodID(SurfaceTextureClass.get(), "<init>", "(I)V");
+  }
+  SurfaceTexture_setOnFrameAvailableListenerHandler = env->GetMethodID(
+      SurfaceTextureClass.get(), "setOnFrameAvailableListener",
+      "(Landroid/graphics/SurfaceTexture$OnFrameAvailableListener;Landroid/os/Handler;)V");
+  if (env->ExceptionCheck()) {
+    env->ExceptionClear();
+    SurfaceTexture_setOnFrameAvailableListener =
+        env->GetMethodID(SurfaceTextureClass.get(), "setOnFrameAvailableListener",
+                         "(Landroid/graphics/SurfaceTexture$OnFrameAvailableListener;)V");
+    SurfaceTexture_mEventHandler =
+        env->GetFieldID(SurfaceTextureClass.get(), "mEventHandler",
+                        "Landroid/graphics/SurfaceTexture$EventHandler;");
+    EventHandlerClass = env->FindClass("android/graphics/SurfaceTexture$EventHandler");
+    EventHandler_Constructor =
+        env->GetMethodID(EventHandlerClass.get(), "<init>",
+                         "(Landroid/graphics/SurfaceTexture;Landroid/os/Looper;)V");
+  } else {
+    HandlerClass = env->FindClass("android/os/Handler");
+    Handler_Constructor = env->GetMethodID(HandlerClass.get(), "<init>", "(Landroid/os/Looper;)V");
+  }
+  SurfaceTexture_updateTexImage =
+      env->GetMethodID(SurfaceTextureClass.get(), "updateTexImage", "()V");
+  SurfaceTexture_attachToGLContext =
+      env->GetMethodID(SurfaceTextureClass.get(), "attachToGLContext", "(I)V");
+  SurfaceTexture_detachFromGLContext =
+      env->GetMethodID(SurfaceTextureClass.get(), "detachFromGLContext", "()V");
+  SurfaceTexture_getTransformMatrix =
+      env->GetMethodID(SurfaceTextureClass.get(), "getTransformMatrix", "([F)V");
+  SurfaceTexture_release = env->GetMethodID(SurfaceTextureClass.get(), "release", "()V");
+  SurfaceTexture_getDataSpace = env->GetMethodID(SurfaceTextureClass.get(), "getDataSpace", "()I");
+  if (SurfaceTexture_getDataSpace == nullptr) {
+    env->ExceptionClear();
+  }
+  SurfaceClass = env->FindClass("android/view/Surface");
+  Surface_Constructor =
+      env->GetMethodID(SurfaceClass.get(), "<init>", "(Landroid/graphics/SurfaceTexture;)V");
+  DataSpaceClass = env->FindClass("android/hardware/DataSpace");
+  if (DataSpaceClass.get() != nullptr) {
+    DataSpaceClass_getStandard =
+        env->GetStaticMethodID(DataSpaceClass.get(), "getStandard", "(I)I");
+    DataSpaceClass_getTransfer =
+        env->GetStaticMethodID(DataSpaceClass.get(), "getTransfer", "(I)I");
+  } else {
+    env->ExceptionClear();
+  }
+}
+
+static std::mutex threadLocker = {};
+static std::shared_ptr<HandlerThread> handlerThread;
+
+static jobject GetGlobalLooper() {
+  std::lock_guard<std::mutex> autoLock(threadLocker);
+  if (handlerThread == nullptr) {
+    handlerThread = HandlerThread::Make();
+  }
+  if (handlerThread == nullptr) {
+    return nullptr;
+  }
+  return handlerThread->getLooper();
+}
+
+static void SetOnFrameAvailableListener(JNIEnv* env, jobject surfaceTexture, jobject listener,
+                                        jobject looper) {
+  if (SurfaceTexture_setOnFrameAvailableListenerHandler != nullptr) {
+    auto handler = env->NewObject(HandlerClass.get(), Handler_Constructor, looper);
+    env->CallVoidMethod(surfaceTexture, SurfaceTexture_setOnFrameAvailableListenerHandler, listener,
+                        handler);
+  } else {
+    env->CallVoidMethod(surfaceTexture, SurfaceTexture_setOnFrameAvailableListener, listener);
+    auto handler =
+        env->NewObject(EventHandlerClass.get(), EventHandler_Constructor, surfaceTexture, looper);
+    env->SetObjectField(surfaceTexture, SurfaceTexture_mEventHandler, handler);
+  }
+}
+
+std::shared_ptr<SurfaceTexture> SurfaceTexture::Make(int width, int height, jobject listener) {
+  if (width <= 0 || height <= 0 || listener == nullptr) {
+    return nullptr;
+  }
+  JNIEnvironment environment;
+  auto env = environment.current();
+  if (env == nullptr) {
+    return nullptr;
+  }
+  jobject stObject;
+  if (SurfaceTexture_Constructor_singleBufferMode != nullptr) {
+    stObject = env->NewObject(SurfaceTextureClass.get(),
+                              SurfaceTexture_Constructor_singleBufferMode, JNI_FALSE);
+  } else {
+    stObject = env->NewObject(SurfaceTextureClass.get(), SurfaceTexture_Constructor_texName, 0);
+    if (stObject != nullptr) {
+      env->CallVoidMethod(stObject, SurfaceTexture_detachFromGLContext);
+    }
+  }
+  if (env->ExceptionCheck()) {
+    env->ExceptionClear();
+    LOGE("SurfaceImageReader::MakeFrom(): failed to create a new SurfaceTexture!");
+    return nullptr;
+  }
+  auto looper = GetGlobalLooper();
+  if (looper == nullptr) {
+    return nullptr;
+  }
+  SetOnFrameAvailableListener(env, stObject, listener, looper);
+  if (env->ExceptionCheck()) {
+    env->ExceptionClear();
+    LOGE("SurfaceImageReader::MakeFrom(): failed to set the OnFrameAvailableListener!");
+    return nullptr;
+  }
+  return std::shared_ptr<SurfaceTexture>(new SurfaceTexture(width, height, env, stObject));
+}
+
+SurfaceTexture::SurfaceTexture(int width, int height, JNIEnv*, jobject st)
+    : ImageStream(width, height) {
+  surfaceTexture = st;
+}
+
+SurfaceTexture::~SurfaceTexture() {
+  JNIEnvironment environment;
+  auto env = environment.current();
+  if (env == nullptr) {
+    return;
+  }
+  env->CallVoidMethod(surfaceTexture.get(), SurfaceTexture_release);
+}
+
+jobject SurfaceTexture::createInputSurface() const {
+  // Use JNIEnvironment::Current() to fetch the thread-local JNIEnv without pushing a new local
+  // frame. Wrapping this in a stack JNIEnvironment would trigger PopLocalFrame(nullptr) on scope
+  // exit and release the local ref returned by NewObject before the caller can use it. The
+  // returned local ref instead lives in the caller's current local frame.
+  auto env = JNIEnvironment::Current();
+  if (env == nullptr) {
+    return nullptr;
+  }
+  return env->NewObject(SurfaceClass.get(), Surface_Constructor, surfaceTexture.get());
+}
+
+void SurfaceTexture::notifyFrameAvailable() {
+  // Note: If there is a pending frame available already, SurfaceTexture will not dispatch any new
+  // frame-available event until you have called the SurfaceTexture.updateTexImage().
+  std::lock_guard<std::mutex> autoLock(locker);
+  frameAvailable = true;
+  condition.notify_all();
+}
+
+static ISize ComputeTextureSize(float matrix[16], int width, int height) {
+  Size size = {static_cast<float>(width), static_cast<float>(height)};
+  auto scaleX = fabsf(matrix[0]);
+  if (scaleX > 0) {
+    size.width = size.width / (scaleX + matrix[12] * 2);
+  }
+  float scaleY = fabsf(matrix[5]);
+  if (scaleY > 0) {
+    size.height = size.height / (scaleY + (matrix[13] - scaleY) * 2);
+  }
+  return size.toRound();
+}
+
+std::shared_ptr<TextureView> SurfaceTexture::onMakeTexture(Context* context, bool) {
+  auto textureID = makeExternalOESTexture(context);
+  if (textureID == 0) {
+    return nullptr;
+  }
+  auto textureSize = updateTexImage();
+  if (textureSize.isEmpty()) {
+    auto gl = static_cast<GLGPU*>(context->gpu())->functions();
+    gl->deleteTextures(1, &textureID);
+    return nullptr;
+  }
+  TextureDescriptor descriptor = {textureSize.width,
+                                  textureSize.height,
+                                  PixelFormat::RGBA_8888,
+                                  false,
+                                  1,
+                                  TextureUsage::TEXTURE_BINDING};
+  auto gpu = static_cast<GLGPU*>(context->gpu());
+  auto texture = gpu->makeResource<GLTexture>(
+      descriptor, static_cast<unsigned>(GL_TEXTURE_EXTERNAL_OES), textureID);
+  return Resource::AddToCache(context, new DefaultTextureView(std::move(texture)));
+}
+
+bool SurfaceTexture::onUpdateTexture(std::shared_ptr<TextureView>) {
+  auto size = updateTexImage();
+  return !size.isEmpty();
+}
+
+unsigned SurfaceTexture::makeExternalOESTexture(Context* context) {
+  std::lock_guard<std::mutex> autoLock(locker);
+  JNIEnvironment environment;
+  auto env = environment.current();
+  if (env == nullptr) {
+    return 0;
+  }
+  auto gl = static_cast<GLGPU*>(context->gpu())->functions();
+  unsigned textureID = 0;
+  gl->genTextures(1, &textureID);
+  if (textureID == 0) {
+    return 0;
+  }
+  env->CallVoidMethod(surfaceTexture.get(), SurfaceTexture_attachToGLContext, textureID);
+  if (env->ExceptionCheck()) {
+    env->ExceptionClear();
+    gl->deleteTextures(1, &textureID);
+    LOGE("NativeImageReader::makeTexture(): failed to attached to a SurfaceTexture!");
+    return 0;
+  }
+  return textureID;
+}
+
+ISize SurfaceTexture::updateTexImage() {
+  std::unique_lock<std::mutex> autoLock(locker);
+  if (!frameAvailable) {
+    static const auto TIMEOUT = std::chrono::seconds(1);
+    auto status = condition.wait_for(autoLock, TIMEOUT);
+    if (status == std::cv_status::timeout) {
+      LOGE("NativeImageReader::onUpdateTexture(): timeout when waiting for the frame available!");
+      return {};
+    }
+  }
+  JNIEnvironment environment;
+  auto env = environment.current();
+  if (env == nullptr) {
+    return {};
+  }
+  frameAvailable = false;
+  env->CallVoidMethod(surfaceTexture.get(), SurfaceTexture_updateTexImage);
+  if (env->ExceptionCheck()) {
+    env->ExceptionClear();
+    LOGE("NativeImageReader::onUpdateTexture(): failed to updateTexImage!");
+    return {};
+  }
+  if (SurfaceTexture_getDataSpace) {
+    jint dataSpace = env->CallIntMethod(surfaceTexture.get(), SurfaceTexture_getDataSpace);
+    jint standard =
+        env->CallStaticIntMethod(DataSpaceClass.get(), DataSpaceClass_getStandard, dataSpace);
+    jint transfer =
+        env->CallStaticIntMethod(DataSpaceClass.get(), DataSpaceClass_getTransfer, dataSpace);
+    _colorSpace = AndroidDataSpaceToColorSpace(standard, transfer);
+  }
+  auto floatArray = env->NewFloatArray(16);
+  env->CallVoidMethod(surfaceTexture.get(), SurfaceTexture_getTransformMatrix, floatArray);
+  auto matrix = env->GetFloatArrayElements(floatArray, nullptr);
+  auto textureSize = ComputeTextureSize(matrix, width(), height());
+  env->ReleaseFloatArrayElements(floatArray, matrix, 0);
+  return textureSize;
+}
+
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/platform/android/SurfaceTexture.h

@@ -0,0 +1,84 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2023 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  unless required by applicable law or agreed to in writing, software distributed under the
+//  license is distributed on an "as is" basis, without warranties or conditions of any kind,
+//  either express or implied. see the license for the specific language governing permissions
+//  and limitations under the license.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "platform/ImageStream.h"
+#include "tgfx/platform/android/Global.h"
+
+namespace tgfx {
+class Texture;
+
+/**
+ * The SurfaceTexture class allows direct access to image data rendered into the Java Surface object
+ * on the android platform. It is typically used with the ImageReader class.
+ */
+class SurfaceTexture : public ImageStream {
+ public:
+  /**
+   * Creates a new SurfaceTexture with the specified image size and listener. Returns nullptr
+   * if the image size is zero or the listener is null.
+   * @param width The width of generated ImageBuffers.
+   * @param height The height of generated ImageBuffers.
+   * @param listener A java object that implements the SurfaceTexture.OnFrameAvailableListener
+   * interface. The implementation should make a native call to the notifyFrameAvailable() of the
+   * returned SurfaceImageReader.
+   */
+  static std::shared_ptr<SurfaceTexture> Make(int width, int height, jobject listener);
+
+  ~SurfaceTexture() override;
+
+  /**
+   * Creates a new Java Surface object connected to this SurfaceTexture. Each call returns a fresh
+   * Surface. The caller owns the returned object and must call Surface.release() when done.
+   */
+  jobject createInputSurface() const;
+
+  /**
+   * Notifies the previously returned ImageBuffer is available for generating textures. The method
+   * should only be called by the listener passed in when creating the reader.
+   */
+  void notifyFrameAvailable();
+
+  const std::shared_ptr<ColorSpace>& colorSpace() const override {
+    return _colorSpace;
+  }
+
+ protected:
+  std::shared_ptr<TextureView> onMakeTexture(Context* context, bool mipmapped) override;
+
+  bool onUpdateTexture(std::shared_ptr<TextureView> textureView) override;
+
+ private:
+  std::mutex locker = {};
+  std::condition_variable condition = {};
+  Global<jobject> surfaceTexture;
+  bool frameAvailable = false;
+  std::shared_ptr<ColorSpace> _colorSpace = nullptr;
+
+  static void JNIInit(JNIEnv* env);
+
+  SurfaceTexture(int width, int height, JNIEnv* env, jobject surfaceTexture);
+
+  unsigned makeExternalOESTexture(Context* context);
+
+  ISize updateTexImage();
+
+  friend class JNIInit;
+};
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/platform/android/SurfaceTextureReader.cpp

@@ -0,0 +1,71 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2023 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  unless required by applicable law or agreed to in writing, software distributed under the
+//  license is distributed on an "as is" basis, without warranties or conditions of any kind,
+//  either express or implied. see the license for the specific language governing permissions
+//  and limitations under the license.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "tgfx/platform/android/SurfaceTextureReader.h"
+#ifdef TGFX_USE_VULKAN
+
+namespace tgfx {
+std::shared_ptr<SurfaceTextureReader> SurfaceTextureReader::Make(int, int, jobject) {
+  return nullptr;
+}
+
+SurfaceTextureReader::SurfaceTextureReader(std::shared_ptr<ImageStream> stream)
+    : ImageReader(std::move(stream)) {
+}
+
+jobject SurfaceTextureReader::createInputSurface() const {
+  return nullptr;
+}
+
+void SurfaceTextureReader::notifyFrameAvailable() {
+}
+}  // namespace tgfx
+
+#else
+#include <chrono>
+#include "platform/android/SurfaceTexture.h"
+
+namespace tgfx {
+std::shared_ptr<SurfaceTextureReader> SurfaceTextureReader::Make(int width, int height,
+                                                                 jobject listener) {
+  if (listener == nullptr || width < 1 || height < 1) {
+    return nullptr;
+  }
+  auto imageStream = SurfaceTexture::Make(width, height, listener);
+  if (imageStream == nullptr) {
+    return nullptr;
+  }
+  auto imageReader =
+      std::shared_ptr<SurfaceTextureReader>(new SurfaceTextureReader(std::move(imageStream)));
+  imageReader->weakThis = imageReader;
+  return imageReader;
+}
+
+SurfaceTextureReader::SurfaceTextureReader(std::shared_ptr<ImageStream> stream)
+    : ImageReader(std::move(stream)) {
+}
+
+jobject SurfaceTextureReader::createInputSurface() const {
+  return std::static_pointer_cast<SurfaceTexture>(stream)->createInputSurface();
+}
+
+void SurfaceTextureReader::notifyFrameAvailable() {
+  std::static_pointer_cast<SurfaceTexture>(stream)->notifyFrameAvailable();
+}
+}  // namespace tgfx
+#endif

package/cpp/third_party/tgfx/src/platform/apple/BitmapContextUtil.h

@@ -0,0 +1,26 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2023 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  unless required by applicable law or agreed to in writing, software distributed under the
+//  license is distributed on an "as is" basis, without warranties or conditions of any kind,
+//  either express or implied. see the license for the specific language governing permissions
+//  and limitations under the license.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include <CoreGraphics/CGBitmapContext.h>
+#include "tgfx/core/ImageInfo.h"
+
+namespace tgfx {
+CGContextRef CreateBitmapContext(const ImageInfo& info, void* pixels);
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/platform/apple/BitmapContextUtil.mm

@@ -0,0 +1,63 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2023 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  unless required by applicable law or agreed to in writing, software distributed under the
+//  license is distributed on an "as is" basis, without warranties or conditions of any kind,
+//  either express or implied. see the license for the specific language governing permissions
+//  and limitations under the license.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "BitmapContextUtil.h"
+#include "CGColorSpaceUtil.h"
+
+namespace tgfx {
+static uint32_t GetBitmapInfo(AlphaType alphaType, ColorType colorType) {
+  CGBitmapInfo bitmapInfo = 0;
+  auto premultiplied = alphaType == AlphaType::Premultiplied;
+  CGImageAlphaInfo alphaInfo = kCGImageAlphaNone;
+  switch (colorType) {
+    case ColorType::BGRA_8888:
+      bitmapInfo = kCGBitmapByteOrder32Little;
+      alphaInfo = premultiplied ? kCGImageAlphaPremultipliedFirst : kCGImageAlphaFirst;
+      break;
+    case ColorType::RGBA_8888:
+      bitmapInfo = kCGBitmapByteOrder32Big;
+      alphaInfo = premultiplied ? kCGImageAlphaPremultipliedLast : kCGImageAlphaLast;
+      break;
+    case ColorType::ALPHA_8:
+      alphaInfo = kCGImageAlphaOnly;
+      break;
+    default:
+      break;
+  }
+  return static_cast<uint32_t>(bitmapInfo) | static_cast<uint32_t>(alphaInfo);
+}
+
+CGContextRef CreateBitmapContext(const ImageInfo& info, void* pixels) {
+  if (pixels == nullptr) {
+    return nullptr;
+  }
+  auto bitmapInfo = GetBitmapInfo(info.alphaType(), info.colorType());
+  if (bitmapInfo == 0) {
+    return nullptr;
+  }
+  CGColorSpaceRef colorspace =
+      info.colorType() == ColorType::ALPHA_8 ? nullptr : CreateCGColorSpace(info.colorSpace());
+  auto cgContext = CGBitmapContextCreate(pixels, static_cast<size_t>(info.width()),
+                                         static_cast<size_t>(info.height()), 8, info.rowBytes(),
+                                         colorspace, bitmapInfo);
+  if (colorspace) {
+    CFRelease(colorspace);
+  }
+  return cgContext;
+}
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/platform/apple/CGColorSpaceUtil.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2026 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  unless required by applicable law or agreed to in writing, software distributed under the
+//  license is distributed on an "as is" basis, without warranties or conditions of any kind,
+//  either express or implied. see the license for the specific language governing permissions
+//  and limitations under the license.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include <CoreGraphics/CGColorSpace.h>
+#include "tgfx/core/ColorSpace.h"
+
+namespace tgfx {
+// Converts a tgfx ColorSpace to a CGColorSpaceRef via ICC profile data. Returns
+// kCGColorSpaceSRGB when the input is null or conversion fails. The caller must
+// release the returned CGColorSpaceRef with CFRelease().
+CGColorSpaceRef CreateCGColorSpace(const std::shared_ptr<ColorSpace>& colorSpace);
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/platform/apple/CGColorSpaceUtil.mm

@@ -0,0 +1,46 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2026 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  unless required by applicable law or agreed to in writing, software distributed under the
+//  license is distributed on an "as is" basis, without warranties or conditions of any kind,
+//  either express or implied. see the license for the specific language governing permissions
+//  and limitations under the license.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "CGColorSpaceUtil.h"
+
+namespace tgfx {
+CGColorSpaceRef CreateCGColorSpace(const std::shared_ptr<ColorSpace>& colorSpace) {
+  if (colorSpace != nullptr) {
+    if (auto iccData = colorSpace->toICCProfile()) {
+      if (CFDataRef cfData =
+              CFDataCreate(kCFAllocatorDefault, reinterpret_cast<const UInt8*>(iccData->data()),
+                           static_cast<CFIndex>(iccData->size()))) {
+        CGColorSpaceRef cgColorSpace = nullptr;
+        if (@available(iOS 10.0, macOS 10.12, *)) {
+          cgColorSpace = CGColorSpaceCreateWithICCData(cfData);
+        } else {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+          cgColorSpace = CGColorSpaceCreateWithICCProfile(cfData);
+#pragma clang diagnostic pop
+        }
+        CFRelease(cfData);
+        if (cgColorSpace != nullptr) {
+          return cgColorSpace;
+        }
+      }
+    }
+  }
+  return CGColorSpaceCreateWithName(kCGColorSpaceSRGB);
+}
+}  // namespace tgfx