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

package/cpp/third_party/tgfx/src/core/YUVHardwareBuffer.cpp

@@ -0,0 +1,98 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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 "YUVHardwareBuffer.h"
+#include "core/utils/USE.h"
+#include "gpu/resources/TextureView.h"
+#include "utils/ColorSpaceHelper.h"
+#if defined(__OHOS__)
+#include <native_buffer/native_buffer.h>
+#endif
+
+namespace tgfx {
+static std::mutex cacheLocker = {};
+static std::unordered_map<HardwareBufferRef, std::weak_ptr<YUVHardwareBuffer>> nv12BufferMap = {};
+
+std::shared_ptr<YUVHardwareBuffer> YUVHardwareBuffer::MakeFrom(HardwareBufferRef hardwareBuffer,
+                                                               YUVColorSpace colorSpace) {
+  auto info = HardwareBufferGetInfo(hardwareBuffer);
+  if (info.format != HardwareBufferFormat::YCBCR_420_SP) {
+    return nullptr;
+  }
+  std::lock_guard<std::mutex> cacheLock(cacheLocker);
+  auto result = nv12BufferMap.find(hardwareBuffer);
+  if (result != nv12BufferMap.end()) {
+    auto buffer = result->second.lock();
+    if (buffer) {
+      return buffer;
+    }
+    nv12BufferMap.erase(result);
+  }
+#if defined(__OHOS__)
+  // On the HarmonyOS platform, video-decoded HardwareBuffers may not have the correct color space
+  // set, so we need to set it manually before creating the texture.
+  switch (colorSpace) {
+    case YUVColorSpace::BT601_LIMITED:
+      OH_NativeBuffer_SetColorSpace(hardwareBuffer, OH_COLORSPACE_BT601_SMPTE_C_LIMIT);
+      break;
+    case YUVColorSpace::BT601_FULL:
+      OH_NativeBuffer_SetColorSpace(hardwareBuffer, OH_COLORSPACE_BT601_SMPTE_C_FULL);
+      break;
+    case YUVColorSpace::BT709_LIMITED:
+      OH_NativeBuffer_SetColorSpace(hardwareBuffer, OH_COLORSPACE_BT709_LIMIT);
+      break;
+    case YUVColorSpace::BT709_FULL:
+      OH_NativeBuffer_SetColorSpace(hardwareBuffer, OH_COLORSPACE_BT709_FULL);
+      break;
+    case YUVColorSpace::BT2020_LIMITED:
+      OH_NativeBuffer_SetColorSpace(hardwareBuffer, OH_COLORSPACE_BT2020_PQ_LIMIT);
+      break;
+    case YUVColorSpace::BT2020_FULL:
+      OH_NativeBuffer_SetColorSpace(hardwareBuffer, OH_COLORSPACE_BT2020_PQ_FULL);
+      break;
+    default:
+      break;
+  }
+#endif
+  auto buffer = std::shared_ptr<YUVHardwareBuffer>(
+      new YUVHardwareBuffer(info.width, info.height, hardwareBuffer, colorSpace));
+  nv12BufferMap[hardwareBuffer] = buffer;
+  return buffer;
+}
+
+YUVHardwareBuffer::YUVHardwareBuffer(int width, int height, HardwareBufferRef hardwareBuffer,
+                                     YUVColorSpace yuvColorSpace)
+    : _width(width), _height(height), hardwareBuffer(hardwareBuffer), _yuvColorSpace(yuvColorSpace),
+      _colorSpace(MakeColorSpaceFromYUVColorSpace(yuvColorSpace)) {
+  HardwareBufferRetain(hardwareBuffer);
+}
+
+YUVHardwareBuffer::~YUVHardwareBuffer() {
+  HardwareBufferRelease(hardwareBuffer);
+  std::lock_guard<std::mutex> cacheLock(cacheLocker);
+  nv12BufferMap.erase(hardwareBuffer);
+}
+
+const std::shared_ptr<ColorSpace>& YUVHardwareBuffer::colorSpace() const {
+  return _colorSpace;
+}
+
+std::shared_ptr<TextureView> YUVHardwareBuffer::onMakeTexture(Context* context, bool) const {
+  return TextureView::MakeFrom(context, hardwareBuffer, _yuvColorSpace);
+}
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/core/YUVHardwareBuffer.h

@@ -0,0 +1,63 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2025 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 "tgfx/core/ImageBuffer.h"
+
+namespace tgfx {
+/**
+ * YUVHardwareBuffer represents a pixel array in the YUV format, stored in a platform-specific
+ * hardware buffer.
+ */
+class YUVHardwareBuffer : public ImageBuffer {
+ public:
+  static std::shared_ptr<YUVHardwareBuffer> MakeFrom(HardwareBufferRef hardwareBuffer,
+                                                     YUVColorSpace colorSpace);
+
+  ~YUVHardwareBuffer() override;
+
+  int width() const override {
+    return _width;
+  }
+
+  int height() const override {
+    return _height;
+  }
+
+  bool isAlphaOnly() const final {
+    return false;
+  }
+
+  const std::shared_ptr<ColorSpace>& colorSpace() const override;
+
+ protected:
+  std::shared_ptr<TextureView> onMakeTexture(Context* context, bool mipmapped) const override;
+
+ private:
+  int _width = 0;
+  int _height = 0;
+  HardwareBufferRef hardwareBuffer = nullptr;
+  YUVColorSpace _yuvColorSpace = YUVColorSpace::BT601_LIMITED;
+  std::shared_ptr<ColorSpace> _colorSpace = nullptr;
+
+  YUVHardwareBuffer(int width, int height, HardwareBufferRef hardwareBuffer,
+                    YUVColorSpace yuvColorSpace);
+};
+
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/core/codecs/jpeg/JpegCodec.cpp

@@ -0,0 +1,445 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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 "core/codecs/jpeg/JpegCodec.h"
+#include <csetjmp>
+#include "core/utils/ColorSpaceHelper.h"
+#include "core/utils/Log.h"
+#include "core/utils/MathExtra.h"
+#include "core/utils/OrientationHelper.h"
+#include "skcms.h"
+#include "tgfx/core/Buffer.h"
+#include "tgfx/core/Data.h"
+#include "tgfx/core/Pixmap.h"
+
+extern "C" {
+#include "jerror.h"
+#include "jpeglib.h"
+}
+
+namespace tgfx {
+
+// libjpeg-turbo supports DCT scaling at N/DENOM ratios (N=1..DENOM).
+static const uint32_t JPEG_SCALE_DENOM = 8;
+
+bool JpegCodec::IsJpeg(const std::shared_ptr<Data>& data) {
+  constexpr uint8_t jpegSig[] = {0xFF, 0xD8, 0xFF};
+  return data->size() >= 3 && !memcmp(data->bytes(), jpegSig, sizeof(jpegSig));
+}
+
+const uint32_t kExifHeaderSize = 14;
+const uint32_t kExifMarker = JPEG_APP0 + 1;
+
+static bool is_orientation_marker(jpeg_marker_struct* marker, Orientation* orientation) {
+  if (kExifMarker != marker->marker || marker->data_length < kExifHeaderSize) {
+    return false;
+  }
+
+  constexpr uint8_t kExifSig[]{'E', 'x', 'i', 'f', '\0'};
+  if (memcmp(marker->data, kExifSig, sizeof(kExifSig)) != 0) {
+    return false;
+  }
+
+  // Account for 'E', 'x', 'i', 'f', '\0', '<fill byte>'.
+  constexpr size_t kOffset = 6;
+  return is_orientation_marker(marker->data + kOffset, marker->data_length - kOffset, orientation);
+}
+
+static Orientation get_exif_orientation(jpeg_decompress_struct* dinfo) {
+  Orientation orientation;
+  for (jpeg_marker_struct* marker = dinfo->marker_list; marker; marker = marker->next) {
+    if (is_orientation_marker(marker, &orientation)) {
+      return orientation;
+    }
+  }
+  return Orientation::TopLeft;
+}
+
+struct my_error_mgr {
+  struct jpeg_error_mgr pub;
+  jmp_buf setjmp_buffer;
+};
+
+std::shared_ptr<ImageCodec> JpegCodec::MakeFrom(const std::string& filePath) {
+  return MakeFromData(filePath, nullptr);
+}
+
+std::shared_ptr<ImageCodec> JpegCodec::MakeFrom(std::shared_ptr<Data> imageBytes) {
+  return MakeFromData("", std::move(imageBytes));
+}
+
+static bool ExtractICCProfile(jpeg_decompress_struct* cinfo, std::vector<uint8_t>& iccProfileData) {
+  jpeg_saved_marker_ptr marker = cinfo->marker_list;
+  while (marker) {
+    if (marker->marker == JPEG_APP0 + 2 && marker->data_length > 14 &&
+        std::memcmp(marker->data, "ICC_PROFILE", 12) == 0) {
+      iccProfileData.insert(iccProfileData.end(), marker->data + 14,
+                            marker->data + marker->data_length);
+    }
+    marker = marker->next;
+  }
+  return !iccProfileData.empty();
+}
+
+static bool ParseICCProfile(const std::vector<uint8_t>& iccProfileData,
+                            gfx::skcms_ICCProfile* profile) {
+  return skcms_Parse(iccProfileData.data(), iccProfileData.size(), profile);
+}
+
+std::shared_ptr<ImageCodec> JpegCodec::MakeFromData(const std::string& filePath,
+                                                    std::shared_ptr<Data> byteData) {
+  FILE* infile = nullptr;
+  if (byteData == nullptr && (infile = fopen(filePath.c_str(), "rb")) == nullptr) {
+    return nullptr;
+  }
+  jpeg_decompress_struct cinfo = {};
+  my_error_mgr jerr = {};
+  cinfo.err = jpeg_std_error(&jerr.pub);
+  Orientation orientation = Orientation::TopLeft;
+  std::shared_ptr<ColorSpace> cs = nullptr;
+  do {
+    if (setjmp(jerr.setjmp_buffer)) break;
+    jpeg_create_decompress(&cinfo);
+    if (infile) {
+      jpeg_stdio_src(&cinfo, infile);
+    } else {
+      jpeg_mem_src(&cinfo, byteData->bytes(), byteData->size());
+    }
+    jpeg_save_markers(&cinfo, kExifMarker, 0xFFFF);
+    jpeg_save_markers(&cinfo, JPEG_APP0 + 2, 0xFFFF);
+    if (jpeg_read_header(&cinfo, TRUE) != JPEG_HEADER_OK) break;
+    orientation = get_exif_orientation(&cinfo);
+    std::vector<uint8_t> iccProfileData;
+    if (ExtractICCProfile(&cinfo, iccProfileData)) {
+      cs = ColorSpace::MakeFromICC(iccProfileData.data(), iccProfileData.size());
+    }
+    if (!cs) {
+      cs = ColorSpace::SRGB();
+    }
+  } while (false);
+  jpeg_destroy_decompress(&cinfo);
+  if (infile) fclose(infile);
+  if (cinfo.image_width == 0 || cinfo.image_height == 0) {
+    return nullptr;
+  }
+  return std::shared_ptr<ImageCodec>(
+      new JpegCodec(static_cast<int>(cinfo.image_width), static_cast<int>(cinfo.image_height),
+                    orientation, filePath, std::move(byteData), std::move(cs)));
+}
+
+static bool ConvertCMYKWithProfile(void* dst, const gfx::skcms_ICCProfile& cmykProfile,
+                                   const ImageInfo& dstInfo) {
+  gfx::skcms_PixelFormat dstPixelFormat;
+  switch (dstInfo.colorType()) {
+    case ColorType::BGRA_8888:
+      dstPixelFormat = gfx::skcms_PixelFormat_BGRA_8888;
+      break;
+    case ColorType::RGBA_8888:
+      dstPixelFormat = gfx::skcms_PixelFormat_RGBA_8888;
+      break;
+    default:
+      return false;
+  }
+  auto dstColorSpace = dstInfo.colorSpace();
+  if (dstColorSpace == nullptr) {
+    dstColorSpace = ColorSpace::SRGB();
+  }
+  const gfx::skcms_ICCProfile dstProfile = ToSkcmsICCProfile(dstColorSpace);
+  auto width = dstInfo.width();
+  auto height = dstInfo.height();
+  auto src = dst;
+  for (int i = 0; i < height; i++) {
+    bool status = gfx::skcms_Transform(
+        src, gfx::skcms_PixelFormat_RGBA_8888, gfx::skcms_AlphaFormat_Unpremul, &cmykProfile, dst,
+        dstPixelFormat, gfx::skcms_AlphaFormat_Unpremul, &dstProfile, static_cast<size_t>(width));
+    if (!status) {
+      return false;
+    }
+    dst = reinterpret_cast<uint8_t*>(dst) + dstInfo.rowBytes();
+    src = reinterpret_cast<uint8_t*>(src) + dstInfo.rowBytes();
+  }
+  return true;
+}
+
+// Fallback formula CMYK to RGB conversion.
+// libjpeg outputs inverted CMYK (like Photoshop): 255=no ink, 0=full ink
+// Formula: R = C * K / 255 (both C and K are already inverted)
+static void ConvertCMYKToRGBWithFormula(void* pixels, const ImageInfo& dstInfo) {
+  auto width = dstInfo.width();
+  auto height = dstInfo.height();
+  auto rowBytes = dstInfo.rowBytes();
+  auto colorType = dstInfo.colorType();
+  auto data = static_cast<uint8_t*>(pixels);
+  for (int y = 0; y < height; y++) {
+    auto row = data + static_cast<size_t>(y) * rowBytes;
+    for (int x = 0; x < width; x++) {
+      auto pixel = row + x * 4;
+      uint8_t c = pixel[0];
+      uint8_t m = pixel[1];
+      uint8_t yVal = pixel[2];
+      uint8_t k = pixel[3];
+      // Inverted CMYK to RGB: R = C * K / 255
+      uint8_t r = static_cast<uint8_t>((c * k + 127) / 255);
+      uint8_t g = static_cast<uint8_t>((m * k + 127) / 255);
+      uint8_t b = static_cast<uint8_t>((yVal * k + 127) / 255);
+      if (colorType == ColorType::BGRA_8888) {
+        pixel[0] = b;
+        pixel[1] = g;
+        pixel[2] = r;
+      } else {
+        pixel[0] = r;
+        pixel[1] = g;
+        pixel[2] = b;
+      }
+      pixel[3] = 255;
+    }
+  }
+}
+
+std::pair<int, int> JpegCodec::getScaledDimensions(float scale) const {
+  // Match scale to a JPEG DCT scaling level (N/DENOM, N=1..DENOM).
+  for (uint32_t n = 1; n <= JPEG_SCALE_DENOM; n++) {
+    if (FloatNearlyEqual(scale, static_cast<float>(n) / static_cast<float>(JPEG_SCALE_DENOM))) {
+      // Replicate libjpeg-turbo's output dimension formula:
+      // output_dim = (image_dim * scale_num + scale_denom - 1) / scale_denom
+      auto denom = static_cast<long>(JPEG_SCALE_DENOM);
+      auto numLong = static_cast<long>(n);
+      auto outputWidth =
+          static_cast<int>((static_cast<long>(width()) * numLong + denom - 1) / denom);
+      auto outputHeight =
+          static_cast<int>((static_cast<long>(height()) * numLong + denom - 1) / denom);
+      return {outputWidth, outputHeight};
+    }
+  }
+  return ImageCodec::getScaledDimensions(scale);
+}
+
+bool JpegCodec::readPixels(const ImageInfo& dstInfo, void* dstPixels) const {
+  for (uint32_t n = 1; n <= JPEG_SCALE_DENOM; n++) {
+    auto [scaledWidth, scaledHeight] =
+        getScaledDimensions(static_cast<float>(n) / static_cast<float>(JPEG_SCALE_DENOM));
+    if (scaledWidth == dstInfo.width() && scaledHeight == dstInfo.height()) {
+      return readScaledPixels(dstInfo.colorType(), dstInfo.alphaType(), dstInfo.rowBytes(),
+                              dstPixels, n, dstInfo.colorSpace());
+    }
+  }
+  return ImageCodec::readPixels(dstInfo, dstPixels);
+}
+
+bool JpegCodec::onReadPixels(ColorType colorType, AlphaType alphaType, size_t dstRowBytes,
+                             std::shared_ptr<ColorSpace> colorSpace, void* dstPixels) const {
+  return readScaledPixels(colorType, alphaType, dstRowBytes, dstPixels, JPEG_SCALE_DENOM,
+                          std::move(colorSpace));
+}
+
+bool JpegCodec::readScaledPixels(ColorType colorType, AlphaType alphaType, size_t dstRowBytes,
+                                 void* dstPixels, uint32_t scaleNum,
+                                 std::shared_ptr<ColorSpace> dstColorSpace) const {
+  if (dstPixels == nullptr) {
+    return false;
+  }
+  if (colorType == ColorType::ALPHA_8) {
+    auto [_, alphaHeight] =
+        getScaledDimensions(static_cast<float>(scaleNum) / static_cast<float>(JPEG_SCALE_DENOM));
+    memset(dstPixels, 255, dstRowBytes * static_cast<size_t>(alphaHeight));
+    return true;
+  }
+  J_COLOR_SPACE out_color_space;
+  bool needsBitmapConversion = false;
+  switch (colorType) {
+    case ColorType::RGBA_8888:
+      out_color_space = JCS_EXT_RGBA;
+      break;
+    case ColorType::BGRA_8888:
+      out_color_space = JCS_EXT_BGRA;
+      break;
+    case ColorType::Gray_8:
+      out_color_space = JCS_GRAYSCALE;
+      break;
+    case ColorType::RGB_565:
+      out_color_space = JCS_RGB565;
+      break;
+    default:
+      out_color_space = JCS_EXT_RGBA;
+      needsBitmapConversion = true;
+      break;
+  }
+  FILE* infile = nullptr;
+  if (fileData == nullptr && (infile = fopen(filePath.c_str(), "rb")) == nullptr) {
+    return false;
+  }
+  jpeg_decompress_struct cinfo = {};
+  my_error_mgr jerr = {};
+  cinfo.err = jpeg_std_error(&jerr.pub);
+  bool result = false;
+  do {
+    if (setjmp(jerr.setjmp_buffer)) break;
+    jpeg_create_decompress(&cinfo);
+    if (infile) {
+      jpeg_stdio_src(&cinfo, infile);
+    } else {
+      jpeg_mem_src(&cinfo, fileData->bytes(), fileData->size());
+    }
+    jpeg_save_markers(&cinfo, JPEG_APP0 + 1, 0xFFFF);
+    jpeg_save_markers(&cinfo, JPEG_APP0 + 2, 0xFFFF);
+    if (jpeg_read_header(&cinfo, TRUE) != JPEG_HEADER_OK) {
+      break;
+    }
+    cinfo.scale_num = scaleNum;
+    cinfo.scale_denom = JPEG_SCALE_DENOM;
+    cinfo.out_color_space = out_color_space;
+    if (cinfo.jpeg_color_space == JCS_CMYK || cinfo.jpeg_color_space == JCS_YCCK) {
+      cinfo.out_color_space = JCS_CMYK;
+    }
+    if (!jpeg_start_decompress(&cinfo)) {
+      break;
+    }
+#ifdef DEBUG
+    // Verify that libjpeg's output dimensions match getScaledDimensions().
+    auto [expectedWidth, expectedHeight] =
+        getScaledDimensions(static_cast<float>(scaleNum) / static_cast<float>(JPEG_SCALE_DENOM));
+    ASSERT(static_cast<int>(cinfo.output_width) == expectedWidth);
+    ASSERT(static_cast<int>(cinfo.output_height) == expectedHeight);
+#endif
+    // Use libjpeg's authoritative output dimensions to avoid buffer overflow.
+    auto dstWidth = static_cast<int>(cinfo.output_width);
+    auto dstHeight = static_cast<int>(cinfo.output_height);
+    auto dstInfo =
+        ImageInfo::Make(dstWidth, dstHeight, colorType, alphaType, dstRowBytes, dstColorSpace);
+    auto outPixels = dstPixels;
+    auto outRowBytes = dstRowBytes;
+    Bitmap bitmap = {};
+    if (needsBitmapConversion) {
+      if (!bitmap.allocPixels(dstWidth, dstHeight, false, false, colorSpace())) {
+        break;
+      }
+    }
+    Pixmap pixmap(bitmap);
+    if (!pixmap.isEmpty()) {
+      outPixels = pixmap.writablePixels();
+      outRowBytes = pixmap.rowBytes();
+    }
+    JSAMPROW pRow[1];
+    while (cinfo.output_scanline < cinfo.output_height) {
+      pRow[0] = static_cast<JSAMPROW>(static_cast<unsigned char*>(outPixels) +
+                                      outRowBytes * static_cast<size_t>(cinfo.output_scanline));
+      jpeg_read_scanlines(&cinfo, pRow, 1);
+    }
+    if (cinfo.out_color_space == JCS_CMYK) {
+      bool converted = false;
+      std::vector<uint8_t> iccProfileData;
+      if (ExtractICCProfile(&cinfo, iccProfileData)) {
+        gfx::skcms_ICCProfile cmykProfile;
+        if (ParseICCProfile(iccProfileData, &cmykProfile)) {
+          converted = ConvertCMYKWithProfile(outPixels, cmykProfile, dstInfo);
+        }
+      }
+      if (!converted) {
+        ConvertCMYKToRGBWithFormula(outPixels, dstInfo);
+      }
+    }
+    result = jpeg_finish_decompress(&cinfo);
+    if (result) {
+      if (!pixmap.isEmpty()) {
+        pixmap.readPixels(dstInfo, dstPixels);
+      } else if (NeedConvertColorSpace(colorSpace(), dstColorSpace)) {
+        ConvertColorSpaceInPlace(dstWidth, dstHeight, colorType, alphaType, dstRowBytes,
+                                 colorSpace(), dstColorSpace, dstPixels);
+      }
+    }
+  } while (false);
+  jpeg_destroy_decompress(&cinfo);
+  if (infile) {
+    fclose(infile);
+  }
+  return result;
+}
+
+std::shared_ptr<Data> JpegCodec::getEncodedData() const {
+  if (fileData) {
+    return fileData;
+  }
+  if (!filePath.empty()) {
+    return Data::MakeFromFile(filePath);
+  }
+  return nullptr;
+}
+
+#ifdef TGFX_USE_JPEG_ENCODE
+std::shared_ptr<Data> JpegCodec::Encode(const Pixmap& pixmap, int quality) {
+  auto srcPixels = static_cast<uint8_t*>(const_cast<void*>(pixmap.pixels()));
+  int srcRowBytes = static_cast<int>(pixmap.rowBytes());
+  jpeg_compress_struct cinfo = {};
+  jpeg_error_mgr jerr = {};
+  JSAMPROW row_pointer[1];
+  cinfo.err = jpeg_std_error(&jerr);
+  jpeg_create_compress(&cinfo);
+  uint8_t* dstBuffer = nullptr;
+  unsigned long dstBufferSize = 0;  // NOLINT
+  jpeg_mem_dest(&cinfo, &dstBuffer, &dstBufferSize);
+  cinfo.image_width = static_cast<JDIMENSION>(pixmap.width());
+  cinfo.image_height = static_cast<JDIMENSION>(pixmap.height());
+  Buffer buffer = {};
+  switch (pixmap.colorType()) {
+    case ColorType::RGBA_8888:
+      cinfo.in_color_space = JCS_EXT_RGBA;
+      cinfo.input_components = 4;
+      break;
+    case ColorType::BGRA_8888:
+      cinfo.in_color_space = JCS_EXT_BGRA;
+      cinfo.input_components = 4;
+      break;
+    case ColorType::Gray_8:
+      cinfo.in_color_space = JCS_GRAYSCALE;
+      cinfo.input_components = 1;
+      break;
+    default:
+      auto info = ImageInfo::Make(pixmap.width(), pixmap.height(), ColorType::RGBA_8888,
+                                  AlphaType::Premultiplied, 0, pixmap.colorSpace());
+      buffer.alloc(info.byteSize());
+      if (buffer.isEmpty()) {
+        return nullptr;
+      }
+      srcPixels = buffer.bytes();
+      srcRowBytes = static_cast<int>(info.rowBytes());
+      Pixmap(info, srcPixels).writePixels(pixmap.info(), pixmap.pixels());
+      cinfo.in_color_space = JCS_EXT_RGBA;
+      cinfo.input_components = 4;
+      break;
+  }
+  jpeg_set_defaults(&cinfo);
+  cinfo.optimize_coding = TRUE;
+  jpeg_set_quality(&cinfo, quality, TRUE);
+  jpeg_start_compress(&cinfo, TRUE);
+  if (pixmap.colorSpace()) {
+    auto iccData = pixmap.colorSpace()->toICCProfile();
+    jpeg_write_icc_profile(&cinfo, iccData->bytes(), static_cast<uint32_t>(iccData->size()));
+  }
+  while (cinfo.next_scanline < cinfo.image_height) {
+    row_pointer[0] = &(srcPixels)[cinfo.next_scanline * static_cast<JDIMENSION>(srcRowBytes)];
+    (void)jpeg_write_scanlines(&cinfo, row_pointer, 1);
+  }
+
+  /* similar to read file, clean up after we're done compressing */
+  jpeg_finish_compress(&cinfo);
+  jpeg_destroy_compress(&cinfo);
+  return Data::MakeAdopted(dstBuffer, dstBufferSize, Data::FreeProc);
+}
+#endif
+
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/core/codecs/jpeg/JpegCodec.h

@@ -0,0 +1,61 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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 "tgfx/core/ImageCodec.h"
+
+namespace tgfx {
+class JpegCodec : public ImageCodec {
+ public:
+  static std::shared_ptr<ImageCodec> MakeFrom(const std::string& filePath);
+  static std::shared_ptr<ImageCodec> MakeFrom(std::shared_ptr<Data> imageBytes);
+  static bool IsJpeg(const std::shared_ptr<Data>& data);
+
+#ifdef TGFX_USE_JPEG_ENCODE
+  static std::shared_ptr<Data> Encode(const Pixmap& pixmap, int quality);
+#endif
+
+  std::pair<int, int> getScaledDimensions(float scale) const override;
+
+  bool readPixels(const ImageInfo& dstInfo, void* dstPixels) const override;
+
+ protected:
+  bool onReadPixels(ColorType colorType, AlphaType alphaType, size_t dstRowBytes,
+                    std::shared_ptr<ColorSpace> colorSpace, void* dstPixels) const override;
+
+  std::shared_ptr<Data> getEncodedData() const override;
+
+ private:
+  std::shared_ptr<Data> fileData;
+  const std::string filePath;
+
+  bool readScaledPixels(ColorType colorType, AlphaType alphaType, size_t dstRowBytes,
+                        void* dstPixels, uint32_t scaleNum,
+                        std::shared_ptr<ColorSpace> dstColorSpace) const;
+
+  static std::shared_ptr<ImageCodec> MakeFromData(const std::string& filePath,
+                                                  std::shared_ptr<Data> byteData);
+  explicit JpegCodec(int width, int height, Orientation orientation, std::string filePath,
+                     std::shared_ptr<Data> fileData, std::shared_ptr<ColorSpace> colorSpace)
+      : ImageCodec(width, height, orientation, std::move(colorSpace)),
+        fileData(std::move(fileData)), filePath(std::move(filePath)) {
+  }
+};
+
+}  // namespace tgfx