react-native-vision-camera-spoof-detector 1.1.22 → 1.1.24

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/android/src/main/java/com/faceantispoof/FaceAntiSpoofingAdvanced.kt

@@ -260,6 +260,50 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         }
     }
 
+    fun advancedAntiSpoofingRGBA(buffer: ByteBuffer, width: Int, height: Int, rowStride: Int, pixelStride: Int): AntiSpoofingResult {
+        if (!isInitialized) {
+            return AntiSpoofingResult(
+                neuralNetworkScore = 0f,
+                laplacianScore = 0,
+                textureComplexity = 0,
+                temporalConsistency = 0f,
+                colorSaturation = 0f,
+                combinedScore = 0f,
+                confidence = 0f
+            )
+        }
+
+        return try {
+            val sampled = sampleRgbaBufferToModelAndGray(buffer, width, height, rowStride, pixelStride)
+            val nnResult = neuralNetworkAntiSpoofingSampled(sampled.rgbBuffer)
+            val nnScore = nnResult.getOrNull() ?: throw IllegalStateException(nnResult.exceptionOrNull()?.message ?: "NN inference failed")
+            val laplacianScore = calculateLaplacianFromGray(sampled.grayBuffer)
+            val combinedScore = calculateCombinedScore(nnScore, laplacianScore)
+            val confidence = calculateConfidence(nnScore, laplacianScore)
+
+            AntiSpoofingResult(
+                neuralNetworkScore = nnScore,
+                laplacianScore = laplacianScore,
+                textureComplexity = 0,
+                temporalConsistency = 0f,
+                colorSaturation = 0f,
+                combinedScore = combinedScore,
+                confidence = confidence
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "Error in advancedAntiSpoofingRGBA buffer path", e)
+            AntiSpoofingResult(
+                neuralNetworkScore = 0f,
+                laplacianScore = 0,
+                textureComplexity = 0,
+                temporalConsistency = 0f,
+                colorSaturation = 0f,
+                combinedScore = 0f,
+                confidence = 0f
+            )
+        }
+    }
+
     // FROM WORKING VERSION: neuralNetworkAntiSpoofing with Bitmap
     private fun neuralNetworkAntiSpoofing(bitmap: Bitmap): Result<Float> {
         return try {
@@ -381,6 +425,45 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         return SampledFrame(modelInputBuffer, grayBuffer)
     }
 
+    private fun sampleRgbaBufferToModelAndGray(
+        buffer: ByteBuffer,
+        srcWidth: Int,
+        srcHeight: Int,
+        rowStride: Int,
+        pixelStride: Int
+    ): SampledFrame {
+        val targetWidth = INPUT_IMAGE_SIZE
+        val targetHeight = INPUT_IMAGE_SIZE
+        val scaleX = srcWidth.toFloat() / targetWidth
+        val scaleY = srcHeight.toFloat() / targetHeight
+        val duplicated = buffer.duplicate()
+        duplicated.order(ByteOrder.nativeOrder())
+
+        for (targetY in 0 until targetHeight) {
+            val srcY = (targetY * scaleY).toInt().coerceIn(0, srcHeight - 1)
+            val rowOffset = srcY * rowStride
+            for (targetX in 0 until targetWidth) {
+                val srcX = (targetX * scaleX).toInt().coerceIn(0, srcWidth - 1)
+                val pixelIndex = rowOffset + srcX * pixelStride
+
+                val r = duplicated.get(pixelIndex).toInt() and 0xFF
+                val g = duplicated.get(pixelIndex + 1).toInt() and 0xFF
+                val b = duplicated.get(pixelIndex + 2).toInt() and 0xFF
+
+                modelInputBuffer[targetY][targetX][0] = r / 255f
+                modelInputBuffer[targetY][targetX][1] = g / 255f
+                modelInputBuffer[targetY][targetX][2] = b / 255f
+                grayBuffer[targetY][targetX] = (
+                    0.299f * r +
+                    0.587f * g +
+                    0.114f * b
+                ).toInt()
+            }
+        }
+
+        return SampledFrame(modelInputBuffer, grayBuffer)
+    }
+
     // FROM WORKING VERSION: laplacian with Bitmap
     private fun laplacian(bitmap: Bitmap): Result<Int> {
         return try {

package/android/src/main/java/com/margelo/nitro/camera/spoofdetector/HybridSpoofDetectorOutput.kt

@@ -83,12 +83,21 @@ class HybridSpoofDetectorOutput(
       return
     }
     try {
-      val rgba = extractRgbaBytes(image)
-      if (!shouldProcessFrame(rgba, image.width, image.height)) {
+      val plane = image.planes.firstOrNull() ?: throw IllegalStateException("RGBA image has no planes")
+      val rgba = plane.buffer.duplicate()
+      rgba.order(java.nio.ByteOrder.nativeOrder())
+
+      if (!shouldProcessFrameFromPlane(rgba, image.width, image.height, plane.rowStride, plane.pixelStride)) {
         return
       }
 
-      val result = detector.advancedAntiSpoofingRGBA(rgba, image.width, image.height)
+      val result = detector.advancedAntiSpoofingRGBA(
+        rgba,
+        image.width,
+        image.height,
+        plane.rowStride,
+        plane.pixelStride,
+      )
       val isLive = result.neuralNetworkScore < FaceAntiSpoofingAdvanced.BASE_THRESHOLD &&
         result.laplacianScore > FaceAntiSpoofingAdvanced.LAPLACIAN_THRESHOLD
       options.onResult.invoke(
@@ -109,7 +118,13 @@ class HybridSpoofDetectorOutput(
     }
   }
 
-  private fun shouldProcessFrame(rgba: ByteArray, width: Int, height: Int): Boolean {
+  private fun shouldProcessFrameFromPlane(
+    buffer: java.nio.ByteBuffer,
+    width: Int,
+    height: Int,
+    rowStride: Int,
+    pixelStride: Int,
+  ): Boolean {
     val frameIndex = frameCounter.incrementAndGet()
     if (frameIndex % FRAME_EVALUATION_INTERVAL != 0) {
       return false
@@ -121,14 +136,14 @@ class HybridSpoofDetectorOutput(
     var sampleCount = 0
 
     for (y in 0 until height step sampleStep) {
-      val rowOffset = y * width * 4
+      val rowOffset = y * rowStride
       for (x in 0 until width step sampleStep) {
-        val index = rowOffset + x * 4
-        if (index + 2 >= rgba.size) continue
+        val index = rowOffset + x * pixelStride
+        if (index + 2 >= buffer.capacity()) continue
 
-        val r = rgba[index].toInt() and 0xFF
-        val g = rgba[index + 1].toInt() and 0xFF
-        val b = rgba[index + 2].toInt() and 0xFF
+        val r = buffer.get(index).toInt() and 0xFF
+        val g = buffer.get(index + 1).toInt() and 0xFF
+        val b = buffer.get(index + 2).toInt() and 0xFF
         val luma = (0.299 * r + 0.587 * g + 0.114 * b).toInt()
 
         brightnessSum += luma.toLong()
@@ -143,7 +158,7 @@ class HybridSpoofDetectorOutput(
 
     val avgBrightness = brightnessSum.toFloat() / sampleCount
     val variance = (brightnessSquaredSum.toFloat() / sampleCount) - (avgBrightness * avgBrightness)
-    val brightnessDelta = kotlin.math.abs(avgBrightness - lastFrameBrightness)
+    val brightnessDelta = abs(avgBrightness - lastFrameBrightness)
     lastFrameBrightness = avgBrightness
 
     val brightnessOk = avgBrightness in MIN_FRAME_BRIGHTNESS..MAX_FRAME_BRIGHTNESS

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-vision-camera-spoof-detector",
-  "version": "1.1.22",
+  "version": "1.1.24",
   "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"