react-native-vision-camera-spoof-detector 1.1.23 → 1.1.25

package/android/CMakeLists.txt

@@ -18,6 +18,9 @@ include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/VisionCameraSpoofDetec
 
 find_library(LOG_LIB log)
 find_package(react-native-vision-camera REQUIRED)
+find_package(ReactAndroid REQUIRED)
+find_package(fbjni REQUIRED)
+find_package(react-native-nitro-modules REQUIRED)
 
 target_link_options(${PACKAGE_NAME} PRIVATE "-Wl,-z,max-page-size=16384")
 
@@ -25,5 +28,14 @@ target_link_libraries(
         ${PACKAGE_NAME}
         ${LOG_LIB}
         android
+        fbjni::fbjni
+        ReactAndroid::jsi
+        react-native-nitro-modules::NitroModules
         react-native-vision-camera::VisionCamera
 )
+
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+    target_link_libraries(${PACKAGE_NAME} ReactAndroid::reactnative)
+else()
+    target_link_libraries(${PACKAGE_NAME} ReactAndroid::react_nativemodule_core)
+endif()

package/android/build.gradle

@@ -38,15 +38,6 @@ android {
 
         buildConfigField "String", "MODEL_FILE", "\"FaceAntiSpoofing.tflite\""
         buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
-
-        // Needed for JSI / C++ build
-        externalNativeBuild {
-            cmake {
-                cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-all"
-                arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
-                abiFilters (*reactNativeArchitectures())
-            }
-        }
     }
 
     buildTypes {
@@ -98,6 +89,16 @@ android {
         }
     }
 
+    defaultConfig {
+        externalNativeBuild {
+            cmake {
+                cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-all"
+                arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+                abiFilters(*reactNativeArchitectures())
+            }
+        }
+    }
+
     externalNativeBuild {
         cmake {
             path "CMakeLists.txt"

package/android/src/main/cpp/cpp-adapter.cpp

@@ -1,9 +1,12 @@
-#include "VisionCameraSpoofDetectorOnLoad.hpp"
-#include <fbjni/fbjni.h>
 #include <jni.h>
+#include <fbjni/fbjni.h>
+
+#include "VisionCameraSpoofDetectorOnLoad.hpp"
 
+extern "C" {
 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
   return facebook::jni::initialize(vm, []() {
     margelo::nitro::camera::spoofdetector::registerAllNatives();
   });
-}
+}
+}

package/ios/HybridSpoofDetectorOutput.swift

@@ -1,5 +1,4 @@
 import AVFoundation
-import CoreImage
 import Foundation
 import NitroModules
 import VisionCamera
@@ -8,11 +7,12 @@ final class HybridSpoofDetectorOutput: HybridCameraOutputSpec, NativeCameraOutpu
   private let queue = DispatchQueue(label: "com.faceantispoof.output", qos: .userInitiated)
   private let options: SpoofDetectorOutputOptions
   private let delegate: SpoofDetectorDelegate
-  private let ciContext = CIContext(options: nil)
   private let stateLock = NSLock()
   private let targetSize = 256
   private var isBusy = false
   private var isDisposed = false
+  private var frameCounter = 0
+  private var lastFrameBrightness: Float = 0
 
   let output = AVCaptureVideoDataOutput()
   let requiresAudioInput = false
@@ -27,7 +27,10 @@ final class HybridSpoofDetectorOutput: HybridCameraOutputSpec, NativeCameraOutpu
   }
 
   var targetResolution: ResolutionRule {
-    return .closestTo(margelo.nitro.camera.Size(width: 720.0, height: 1280.0))
+    let resolution = options.targetResolution.map {
+      margelo.nitro.camera.Size(width: $0.width, height: $0.height)
+    } ?? margelo.nitro.camera.Size(width: 720.0, height: 1280.0)
+    return .closestTo(resolution)
   }
 
   init(options: SpoofDetectorOutputOptions) {
@@ -35,6 +38,9 @@ final class HybridSpoofDetectorOutput: HybridCameraOutputSpec, NativeCameraOutpu
     self.delegate = SpoofDetectorDelegate()
     super.init()
 
+    output.videoSettings = [
+      kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_32BGRA,
+    ]
     delegate.onSampleBuffer = { [weak self] sampleBuffer in
       self?.process(sampleBuffer)
     }
@@ -63,7 +69,7 @@ final class HybridSpoofDetectorOutput: HybridCameraOutputSpec, NativeCameraOutpu
     isBusy = true
     stateLock.unlock()
 
-    guard let input = makeRGBInput(from: sampleBuffer) else {
+    guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else {
       stateLock.lock()
       isBusy = false
       stateLock.unlock()
@@ -71,69 +77,115 @@ final class HybridSpoofDetectorOutput: HybridCameraOutputSpec, NativeCameraOutpu
       return
     }
 
-    queue.async { [weak self] in
-      guard let self else { return }
-      defer {
-        self.stateLock.lock()
-        self.isBusy = false
-        self.stateLock.unlock()
-      }
+    CVPixelBufferLockBaseAddress(pixelBuffer, .readOnly)
+    defer {
+      CVPixelBufferUnlockBaseAddress(pixelBuffer, .readOnly)
+    }
 
-      do {
-        let result = try FaceAntiSpoofManager.process(input: input)
-        self.options.onResult(
-          AntiSpoofingResult(
-            isLive: result.isLive,
-            label: result.isLive ? "Live Face" : "Spoof Face",
-            neuralNetworkScore: result.neuralNetworkScore,
-            laplacianScore: result.laplacianScore,
-            combinedScore: result.combinedScore,
-            confidence: result.confidence
-          )
-        )
-      } catch {
-        self.options.onError?(error)
-      }
+    guard shouldProcessFrame(pixelBuffer),
+          let input = makeRGBInput(from: pixelBuffer) else {
+      stateLock.lock()
+      isBusy = false
+      stateLock.unlock()
+      return
     }
-  }
 
-  private func makeRGBInput(from sampleBuffer: CMSampleBuffer) -> [Float]? {
-    guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else { return nil }
+    defer {
+      stateLock.lock()
+      isBusy = false
+      stateLock.unlock()
+    }
 
-    let image = CIImage(cvPixelBuffer: pixelBuffer)
-    let oriented = image.oriented(forExifOrientation: outputOrientation.exifOrientation)
-    guard let cgImage = ciContext.createCGImage(oriented, from: oriented.extent) else {
-      return nil
+    do {
+      let result = try FaceAntiSpoofManager.process(input: input)
+      options.onResult(
+        AntiSpoofingResult(
+          isLive: result.isLive,
+          label: result.isLive ? "Live Face" : "Spoof Face",
+          neuralNetworkScore: result.neuralNetworkScore,
+          laplacianScore: result.laplacianScore,
+          combinedScore: result.combinedScore,
+          confidence: result.confidence
+        )
+      )
+    } catch {
+      options.onError?(error)
     }
+  }
 
-    let width = targetSize
-    let height = targetSize
-    let colorSpace = CGColorSpaceCreateDeviceRGB()
-    var bytes = [UInt8](repeating: 0, count: width * height * 4)
-    let rendered = bytes.withUnsafeMutableBytes { rawBuffer -> Bool in
-      guard let baseAddress = rawBuffer.baseAddress,
-            let context = CGContext(
-              data: baseAddress,
-              width: width,
-              height: height,
-              bitsPerComponent: 8,
-              bytesPerRow: width * 4,
-              space: colorSpace,
-              bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
-            ) else { return false }
-      context.interpolationQuality = .high
-      context.draw(cgImage, in: CGRect(x: 0, y: 0, width: width, height: height))
-      return true
+  private func shouldProcessFrame(_ pixelBuffer: CVPixelBuffer) -> Bool {
+    frameCounter += 1
+    guard frameCounter % 3 == 0 else { return false }
+
+    let width = CVPixelBufferGetWidth(pixelBuffer)
+    let height = CVPixelBufferGetHeight(pixelBuffer)
+    let bytesPerRow = CVPixelBufferGetBytesPerRow(pixelBuffer)
+    guard let baseAddress = CVPixelBufferGetBaseAddress(pixelBuffer) else { return false }
+    let bytes = baseAddress.assumingMemoryBound(to: UInt8.self)
+    let sampleStep = max(1, min(width, height) / 32)
+    var brightnessSum: Float = 0
+    var brightnessSquaredSum: Float = 0
+    var sampleCount: Float = 0
+
+    for y in stride(from: 0, to: height, by: sampleStep) {
+      for x in stride(from: 0, to: width, by: sampleStep) {
+        let offset = y * bytesPerRow + x * 4
+        let blue = Float(bytes[offset])
+        let green = Float(bytes[offset + 1])
+        let red = Float(bytes[offset + 2])
+        let luma = 0.299 * red + 0.587 * green + 0.114 * blue
+        brightnessSum += luma
+        brightnessSquaredSum += luma * luma
+        sampleCount += 1
+      }
     }
-    guard rendered else { return nil }
-
-    var result = [Float](repeating: 0, count: width * height * 3)
-    for index in 0..<(width * height) {
-      let source = index * 4
-      let destination = index * 3
-      result[destination] = Float(bytes[source]) / 255.0
-      result[destination + 1] = Float(bytes[source + 1]) / 255.0
-      result[destination + 2] = Float(bytes[source + 2]) / 255.0
+
+    guard sampleCount > 0 else { return false }
+    let average = brightnessSum / sampleCount
+    let variance = (brightnessSquaredSum / sampleCount) - (average * average)
+    let brightnessDelta = abs(average - lastFrameBrightness)
+    let isFirstSample = lastFrameBrightness == 0
+    lastFrameBrightness = average
+
+    return average >= 24 && average <= 220 && variance >= 1500 &&
+      (isFirstSample || brightnessDelta >= 8)
+  }
+
+  private func makeRGBInput(from pixelBuffer: CVPixelBuffer) -> [Float]? {
+    guard CVPixelBufferGetPixelFormatType(pixelBuffer) == kCVPixelFormatType_32BGRA,
+          let baseAddress = CVPixelBufferGetBaseAddress(pixelBuffer) else { return nil }
+
+    let sourceWidth = CVPixelBufferGetWidth(pixelBuffer)
+    let sourceHeight = CVPixelBufferGetHeight(pixelBuffer)
+    let bytesPerRow = CVPixelBufferGetBytesPerRow(pixelBuffer)
+    let bytes = baseAddress.assumingMemoryBound(to: UInt8.self)
+    var result = [Float](repeating: 0, count: targetSize * targetSize * 3)
+    let isQuarterTurn = outputOrientation == .right || outputOrientation == .left
+    let orientedWidth = isQuarterTurn ? sourceHeight : sourceWidth
+    let orientedHeight = isQuarterTurn ? sourceWidth : sourceHeight
+
+    for targetY in 0..<targetSize {
+      let orientedY = min(orientedHeight - 1, targetY * orientedHeight / targetSize)
+      for targetX in 0..<targetSize {
+        let orientedX = min(orientedWidth - 1, targetX * orientedWidth / targetSize)
+        let sourcePoint: (x: Int, y: Int)
+        switch outputOrientation {
+        case .right:
+          sourcePoint = (orientedY, sourceHeight - 1 - orientedX)
+        case .down:
+          sourcePoint = (sourceWidth - 1 - orientedX, sourceHeight - 1 - orientedY)
+        case .left:
+          sourcePoint = (sourceWidth - 1 - orientedY, orientedX)
+        default:
+          sourcePoint = (orientedX, orientedY)
+        }
+
+        let source = sourcePoint.y * bytesPerRow + sourcePoint.x * 4
+        let destination = (targetY * targetSize + targetX) * 3
+        result[destination] = Float(bytes[source + 2]) / 255
+        result[destination + 1] = Float(bytes[source + 1]) / 255
+        result[destination + 2] = Float(bytes[source]) / 255
+      }
     }
     return result
   }
@@ -150,15 +202,3 @@ private final class SpoofDetectorDelegate: NSObject, AVCaptureVideoDataOutputSam
     onSampleBuffer?(sampleBuffer)
   }
 }
-
-private extension CameraOrientation {
-  var exifOrientation: Int32 {
-    switch self {
-    case .up: return 1
-    case .right: return 6
-    case .down: return 3
-    case .left: return 8
-    @unknown default: return 1
-    }
-  }
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-vision-camera-spoof-detector",
-  "version": "1.1.23",
+  "version": "1.1.25",
   "description": "High-performance face anti-spoofing and liveness detection module for React Native Vision Camera. Uses TensorFlow Lite with GPU acceleration and optimized YUV processing.",
   "homepage": "https://github.com/dpraful/react-native-vision-camera-spoof-detector",
   "repository": {

package/android/src/main/cpp/CMakeLists.txt

@@ -1,33 +0,0 @@
-cmake_minimum_required(VERSION 3.18)
-project(VisionCameraSpoofDetector)
-
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_SUPPRESS_REGENERATION ON)
-set(CMAKE_POSITION_INDEPENDENT_CODE ON)
-set(CMAKE_ANDROID_STL_TYPE c++_shared)
-
-set(PACKAGE_NAME VisionCameraSpoofDetector)
-set(CMAKE_VERBOSE_MAKEFILE ON)
-
-add_library(${PACKAGE_NAME} SHARED
-    cpp-adapter.cpp
-)
-
-# Nitrogen-generated hybrid bindings
-include(${CMAKE_SOURCE_DIR}/../../../../nitrogen/generated/android/VisionCameraSpoofDetector+autolinking.cmake)
-
-find_library(LOG_LIB log)
-find_package(react-native-vision-camera REQUIRED)
-
-# Android 15+ 16KB page support
-target_link_options(${PACKAGE_NAME} PRIVATE "-Wl,-z,max-page-size=16384")
-
-target_link_libraries(
-    ${PACKAGE_NAME}
-    ${LOG_LIB}
-    android
-    react-native-vision-camera::VisionCamera
-)
-
-

package/android/src/main/cpp/FaceAntiSpoofJSI.cpp

@@ -1,142 +0,0 @@
-#include <jni.h>
-#include <jsi/jsi.h>
-#include <string>
-#include <vector>
-#include <algorithm>
-#include <android/log.h>
-
-using namespace facebook;
-
-// Logging macro
-#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "FaceAntiSpoofJSI", __VA_ARGS__))
-
-static JavaVM *javaVm = nullptr;
-
-jsi::Value faceAntiSpoof(jsi::Runtime &runtime, const jsi::Value &frame) {
-    if (!frame.isObject()) {
-        throw jsi::JSError(runtime, "FaceAntiSpoof expected a Frame object");
-    }
-
-    auto frameObject = frame.asObject(runtime);
-    auto planesValue = frameObject.getProperty(runtime, "getPlanes").asObject(runtime)
-        .asFunction(runtime).call(runtime, frameObject);
-    auto planes = planesValue.asObject(runtime);
-    auto length = static_cast<size_t>(planes.getProperty(runtime, "length").asNumber());
-    if (length < 3) {
-        throw jsi::JSError(runtime, "FaceAntiSpoof expected Y, U and V planes");
-    }
-
-    std::vector<std::vector<uint8_t>> planeData(3);
-    jint rowStrides[3] = {};
-    jint pixelStrides[3] = {};
-    for (size_t index = 0; index < 3; index++) {
-        auto plane = planes.getProperty(runtime, jsi::Value(static_cast<double>(index))).asObject(runtime);
-        auto buffer = plane.getProperty(runtime, "getPixelBuffer").asObject(runtime)
-            .asFunction(runtime).call(runtime, plane).asObject(runtime);
-        auto arrayBuffer = std::move(buffer).getArrayBuffer(runtime);
-        auto *data = static_cast<const uint8_t *>(arrayBuffer.data(runtime));
-        planeData[index].assign(data, data + arrayBuffer.size(runtime));
-        rowStrides[index] = static_cast<jint>(plane.getProperty(runtime, "bytesPerRow").asNumber());
-        auto planeWidth = plane.getProperty(runtime, "width").asNumber();
-        pixelStrides[index] = std::max(1, static_cast<jint>(rowStrides[index] / planeWidth));
-    }
-
-    JNIEnv *env = nullptr;
-    bool attached = false;
-    if (javaVm == nullptr) {
-        throw jsi::JSError(runtime, "FaceAntiSpoof Android runtime is unavailable");
-    }
-    if (javaVm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION_1_6) == JNI_EDETACHED) {
-        if (javaVm->AttachCurrentThread(&env, nullptr) != JNI_OK) {
-            throw jsi::JSError(runtime, "FaceAntiSpoof could not attach to Android runtime");
-        }
-        attached = true;
-    }
-    auto moduleClass = env->FindClass("com/faceantispoof/FaceAntiSpoofModule");
-    auto process = env->GetStaticMethodID(moduleClass, "processFrameFromJSI", "([[BII[I[I)[D");
-    auto javaPlanes = env->NewObjectArray(3, env->FindClass("[B"), nullptr);
-    auto javaRowStrides = env->NewIntArray(3);
-    auto javaPixelStrides = env->NewIntArray(3);
-    env->SetIntArrayRegion(javaRowStrides, 0, 3, rowStrides);
-    env->SetIntArrayRegion(javaPixelStrides, 0, 3, pixelStrides);
-    for (int index = 0; index < 3; index++) {
-        auto bytes = env->NewByteArray(static_cast<jsize>(planeData[index].size()));
-        env->SetByteArrayRegion(bytes, 0, static_cast<jsize>(planeData[index].size()),
-            reinterpret_cast<const jbyte *>(planeData[index].data()));
-        env->SetObjectArrayElement(javaPlanes, index, bytes);
-        env->DeleteLocalRef(bytes);
-    }
-    auto values = static_cast<jdoubleArray>(env->CallStaticObjectMethod(
-        moduleClass, process, javaPlanes, static_cast<jint>(frameObject.getProperty(runtime, "width").asNumber()),
-        static_cast<jint>(frameObject.getProperty(runtime, "height").asNumber()),
-        javaRowStrides, javaPixelStrides));
-    jdouble output[5] = {};
-    if (values != nullptr) env->GetDoubleArrayRegion(values, 0, 5, output);
-    env->DeleteLocalRef(values);
-    env->DeleteLocalRef(javaPixelStrides);
-    env->DeleteLocalRef(javaRowStrides);
-    env->DeleteLocalRef(javaPlanes);
-    env->DeleteLocalRef(moduleClass);
-    if (attached) javaVm->DetachCurrentThread();
-
-    jsi::Object result(runtime);
-    result.setProperty(runtime, "isLive", output[0] != 0.0);
-    result.setProperty(runtime, "label", output[0] != 0.0 ? "Live Face" : "Spoof Face");
-    result.setProperty(runtime, "neuralNetworkScore", output[1]);
-    result.setProperty(runtime, "laplacianScore", output[2]);
-    result.setProperty(runtime, "combinedScore", output[3]);
-    result.setProperty(runtime, "confidence", output[4]);
-    return result;
-}
-
-extern "C" JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *) {
-    javaVm = vm;
-    return JNI_VERSION_1_6;
-}
-
-// JSI registration function
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_faceantispoof_FaceAntiSpoofModule_registerJSIFunction(JNIEnv *env, jobject thiz, jlong jsContextPtr) {
-    LOGI("registerJSIFunction called with jsContextPtr = %ld", (long)jsContextPtr);
-    
-    if (jsContextPtr == 0) {
-        LOGI("FaceAntiSpoofJSI: JS runtime pointer is 0 (null)!");
-        return;
-    }
-    
-    auto *runtime = reinterpret_cast<jsi::Runtime *>(jsContextPtr);
-    if (!runtime) {
-        LOGI("FaceAntiSpoofJSI: Runtime reinterpret_cast resulted in null pointer!");
-        return;
-    }
-
-    try {
-        LOGI("FaceAntiSpoofJSI: Creating JSI function...");
-        
-        jsi::Function func = jsi::Function::createFromHostFunction(
-            *runtime,
-            jsi::PropNameID::forAscii(*runtime, "__faceAntiSpoof"),
-            1,
-            [](jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) -> jsi::Value {
-                LOGI("FaceAntiSpoofJSI: __faceAntiSpoof function called");
-                if (count < 1) {
-                    jsi::Object error(rt);
-                    error.setProperty(rt, "isLive", false);
-                    error.setProperty(rt, "label", "No frame provided");
-                    error.setProperty(rt, "confidence", 0.0);
-                    return error;
-                }
-                return faceAntiSpoof(rt, args[0]);
-            }
-        );
-
-        LOGI("FaceAntiSpoofJSI: Setting __faceAntiSpoof on global object...");
-        runtime->global().setProperty(*runtime, "__faceAntiSpoof", std::move(func));
-        LOGI("FaceAntiSpoofJSI: __faceAntiSpoof registered successfully!");
-    } catch (const std::exception &e) {
-        LOGI("FaceAntiSpoofJSI: Exception during JSI registration: %s", e.what());
-    } catch (...) {
-        LOGI("FaceAntiSpoofJSI: Unknown exception during JSI registration!");
-    }
-}

package/android/src/main/cpp/FastYuvJni.cpp

@@ -1,111 +0,0 @@
-#include <jni.h>
-#include <android/log.h>
-#include <string.h>
-#include "fast_yuv.h"
-
-#define LOG_TAG "FastYuvJNI"
-#define ALOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, __VA_ARGS__)
-
-extern "C" {
-
-JNIEXPORT jboolean JNICALL Java_com_visioncamera_fastyuv_FastYuv_nativeNV21ToARGB(JNIEnv* env, jclass clazz,
-                                                                                jbyteArray nv21Array,
-                                                                                jint width, jint height,
-                                                                                jbyteArray outArgbArray) {
-    if (!nv21Array || !outArgbArray) return JNI_FALSE;
-    jsize in_len = env->GetArrayLength(nv21Array);
-    jsize out_len = env->GetArrayLength(outArgbArray);
-    int expected_in = width * height + (width * height) / 2;
-    int expected_out = width * height * 4;
-    if (in_len < expected_in || out_len < expected_out) return JNI_FALSE;
-
-    jbyte* in_bytes = env->GetByteArrayElements(nv21Array, nullptr);
-    jbyte* out_bytes = env->GetByteArrayElements(outArgbArray, nullptr);
-    bool ok = fastyuv::NV21ToARGB((const uint8_t*)in_bytes, width, height, (uint8_t*)out_bytes);
-    env->ReleaseByteArrayElements(nv21Array, in_bytes, JNI_ABORT);
-    env->ReleaseByteArrayElements(outArgbArray, out_bytes, 0);
-    return ok ? JNI_TRUE : JNI_FALSE;
-}
-
-JNIEXPORT jboolean JNICALL Java_com_visioncamera_fastyuv_FastYuv_nativeNV21ToRGB(JNIEnv* env, jclass clazz,
-                                                                               jbyteArray nv21Array,
-                                                                               jint width, jint height,
-                                                                               jbyteArray outRgbArray) {
-    if (!nv21Array || !outRgbArray) return JNI_FALSE;
-    jsize in_len = env->GetArrayLength(nv21Array);
-    jsize out_len = env->GetArrayLength(outRgbArray);
-    int expected_in = width * height + (width * height) / 2;
-    int expected_out = width * height * 3;
-    if (in_len < expected_in || out_len < expected_out) return JNI_FALSE;
-
-    jbyte* in_bytes = env->GetByteArrayElements(nv21Array, nullptr);
-    jbyte* out_bytes = env->GetByteArrayElements(outRgbArray, nullptr);
-    bool ok = fastyuv::NV21ToRGB24((const uint8_t*)in_bytes, width, height, (uint8_t*)out_bytes);
-    env->ReleaseByteArrayElements(nv21Array, in_bytes, JNI_ABORT);
-    env->ReleaseByteArrayElements(outRgbArray, out_bytes, 0);
-    return ok ? JNI_TRUE : JNI_FALSE;
-}
-
-JNIEXPORT jboolean JNICALL Java_com_visioncamera_fastyuv_FastYuv_nativeNV21ToBGR(JNIEnv* env, jclass clazz,
-                                                                               jbyteArray nv21Array,
-                                                                               jint width, jint height,
-                                                                               jbyteArray outBgrArray) {
-    if (!nv21Array || !outBgrArray) return JNI_FALSE;
-    jsize in_len = env->GetArrayLength(nv21Array);
-    jsize out_len = env->GetArrayLength(outBgrArray);
-    int expected_in = width * height + (width * height) / 2;
-    int expected_out = width * height * 3;
-    if (in_len < expected_in || out_len < expected_out) return JNI_FALSE;
-
-    jbyte* in_bytes = env->GetByteArrayElements(nv21Array, nullptr);
-    jbyte* out_bytes = env->GetByteArrayElements(outBgrArray, nullptr);
-    bool ok = fastyuv::NV21ToBGR24((const uint8_t*)in_bytes, width, height, (uint8_t*)out_bytes);
-    env->ReleaseByteArrayElements(nv21Array, in_bytes, JNI_ABORT);
-    env->ReleaseByteArrayElements(outBgrArray, out_bytes, 0);
-    return ok ? JNI_TRUE : JNI_FALSE;
-}
-
-JNIEXPORT jboolean JNICALL Java_com_visioncamera_fastyuv_FastYuv_nativeNV21ToARGBResize(JNIEnv* env, jclass clazz,
-                                                                                       jbyteArray nv21Array,
-                                                                                       jint src_w, jint src_h,
-                                                                                       jbyteArray outArgbArray,
-                                                                                       jint dst_w, jint dst_h) {
-    if (!nv21Array || !outArgbArray) return JNI_FALSE;
-    jsize in_len = env->GetArrayLength(nv21Array);
-    jsize out_len = env->GetArrayLength(outArgbArray);
-    int expected_in = src_w * src_h + (src_w * src_h) / 2;
-    int expected_out = dst_w * dst_h * 4;
-    if (in_len < expected_in || out_len < expected_out) return JNI_FALSE;
-
-    jbyte* in_bytes = env->GetByteArrayElements(nv21Array, nullptr);
-    jbyte* out_bytes = env->GetByteArrayElements(outArgbArray, nullptr);
-    bool ok = fastyuv::NV21ToARGBResize((const uint8_t*)in_bytes, src_w, src_h, (uint8_t*)out_bytes, dst_w, dst_h);
-    env->ReleaseByteArrayElements(nv21Array, in_bytes, JNI_ABORT);
-    env->ReleaseByteArrayElements(outArgbArray, out_bytes, 0);
-    return ok ? JNI_TRUE : JNI_FALSE;
-}
-
-JNIEXPORT jboolean JNICALL Java_com_visioncamera_fastyuv_FastYuv_nativeNV21ToARGBRotate(JNIEnv* env, jclass clazz,
-                                                                                       jbyteArray nv21Array,
-                                                                                       jint src_w, jint src_h,
-                                                                                       jbyteArray outArgbArray,
-                                                                                       jint rotation) {
-    if (!nv21Array || !outArgbArray) return JNI_FALSE;
-    jsize in_len = env->GetArrayLength(nv21Array);
-    jsize out_len = env->GetArrayLength(outArgbArray);
-    int expected_in = src_w * src_h + (src_w * src_h) / 2;
-    // rotation may swap dims; allocate expected_out conservatively using max dims
-    int dst_w = (rotation % 180 == 0) ? src_w : src_h;
-    int dst_h = (rotation % 180 == 0) ? src_h : src_w;
-    int expected_out = dst_w * dst_h * 4;
-    if (in_len < expected_in || out_len < expected_out) return JNI_FALSE;
-
-    jbyte* in_bytes = env->GetByteArrayElements(nv21Array, nullptr);
-    jbyte* out_bytes = env->GetByteArrayElements(outArgbArray, nullptr);
-    bool ok = fastyuv::NV21ToARGBRotate((const uint8_t*)in_bytes, src_w, src_h, (uint8_t*)out_bytes, rotation);
-    env->ReleaseByteArrayElements(nv21Array, in_bytes, JNI_ABORT);
-    env->ReleaseByteArrayElements(outArgbArray, out_bytes, 0);
-    return ok ? JNI_TRUE : JNI_FALSE;
-}
-
-} // extern "C"