react-native-vision-camera-spoof-detector 1.0.0

package/android/src/main/java/com/faceantispoof/YuvToFloatArrayConverter.kt

@@ -0,0 +1,198 @@
+package com.faceantispoof
+
+import java.nio.ByteBuffer
+
+/**
+ * Converts YUV NV21 data directly to normalized RGB float arrays without creating Bitmaps.
+ * Supports downsampling/resizing in-place using nearest-neighbor interpolation.
+ */
+class YuvToFloatArrayConverter {
+
+    /**
+     * Convert NV21 YUV data directly to a normalized RGB float array.
+     * Output array is [height][width][3] where RGB channels are normalized to [0, 1].
+     * @param nv21 NV21 encoded YUV data
+     * @param width Original frame width
+     * @param height Original frame height
+     * @param targetWidth Target output width (can be different for resizing)
+     * @param targetHeight Target output height (can be different for resizing)
+     * @param outputRgbFloat Pre-allocated float array to store output, or null to allocate new
+     * @return Float array of shape [targetHeight * targetWidth * 3] with RGB values normalized to [0, 1]
+     */
+    fun nv21ToRgbFloatArray(
+        nv21: ByteArray,
+        width: Int,
+        height: Int,
+        targetWidth: Int = width,
+        targetHeight: Int = height,
+        outputRgbFloat: FloatArray? = null
+    ): FloatArray {
+        val outputSize = targetWidth * targetHeight * 3
+        val output = outputRgbFloat?.takeIf { it.size >= outputSize } ?: FloatArray(outputSize)
+
+        val ySize = width * height
+        val uvPixelStride = 2
+
+        var outIdx = 0
+
+        for (targetY in 0 until targetHeight) {
+            // Map target Y to original frame Y (nearest-neighbor)
+            val srcY = (targetY * height) / targetHeight
+            val srcRowOffset = srcY * width
+
+            for (targetX in 0 until targetWidth) {
+                // Map target X to original frame X (nearest-neighbor)
+                val srcX = (targetX * width) / targetWidth
+
+                // Get Y component
+                val yVal = nv21[srcRowOffset + srcX].toInt() and 0xFF
+
+                // Get U and V components (NV21 layout: UV interleaved in second half)
+                val uvIndex = ySize + (srcY / 2) * width + (srcX / 2) * uvPixelStride
+                val vVal = nv21[uvIndex].toInt() and 0xFF
+                val uVal = nv21[uvIndex + 1].toInt() and 0xFF
+
+                // YUV to RGB conversion
+                val yf = yVal.toFloat()
+                val uf = uVal - 128f
+                val vf = vVal - 128f
+
+                val r = (yf + 1.402f * vf).coerceIn(0f, 255f)
+                val g = (yf - 0.34414f * uf - 0.71414f * vf).coerceIn(0f, 255f)
+                val b = (yf + 1.772f * uf).coerceIn(0f, 255f)
+
+                // Normalize to [0, 1]
+                output[outIdx++] = r / 255f
+                output[outIdx++] = g / 255f
+                output[outIdx++] = b / 255f
+            }
+        }
+
+        return output
+    }
+
+    /**
+     * Convert NV21 directly to a flat RGB float buffer (single channel interleaving).
+     * @param nv21 NV21 encoded YUV data
+     * @param width Original frame width
+     * @param height Original frame height
+     * @param targetWidth Target output width
+     * @param targetHeight Target output height
+     * @return ByteBuffer containing RGB floats in native byte order
+     */
+    fun nv21ToRgbByteBuffer(
+        nv21: ByteArray,
+        width: Int,
+        height: Int,
+        targetWidth: Int = width,
+        targetHeight: Int = height
+    ): ByteBuffer {
+        val outputSize = targetWidth * targetHeight * 3 * 4 // 3 floats per pixel, 4 bytes per float
+        val output = ByteBuffer.allocateDirect(outputSize).apply {
+            order(java.nio.ByteOrder.nativeOrder())
+        }
+
+        val ySize = width * height
+        val uvPixelStride = 2
+
+        for (targetY in 0 until targetHeight) {
+            val srcY = (targetY * height) / targetHeight
+            val srcRowOffset = srcY * width
+
+            for (targetX in 0 until targetWidth) {
+                val srcX = (targetX * width) / targetWidth
+
+                val yVal = nv21[srcRowOffset + srcX].toInt() and 0xFF
+
+                val uvIndex = ySize + (srcY / 2) * width + (srcX / 2) * uvPixelStride
+                val vVal = nv21[uvIndex].toInt() and 0xFF
+                val uVal = nv21[uvIndex + 1].toInt() and 0xFF
+
+                val yf = yVal.toFloat()
+                val uf = uVal - 128f
+                val vf = vVal - 128f
+
+                val r = (yf + 1.402f * vf).coerceIn(0f, 255f) / 255f
+                val g = (yf - 0.34414f * uf - 0.71414f * vf).coerceIn(0f, 255f) / 255f
+                val b = (yf + 1.772f * uf).coerceIn(0f, 255f) / 255f
+
+                output.putFloat(r)
+                output.putFloat(g)
+                output.putFloat(b)
+            }
+        }
+
+        output.rewind()
+        return output
+    }
+
+    /**
+     * Convert NV21 to grayscale intensity values stored as floats [0, 1].
+     * Useful for Laplacian edge detection.
+     * @param nv21 NV21 encoded YUV data
+     * @param width Original frame width
+     * @param height Original frame height
+     * @param targetWidth Target output width
+     * @param targetHeight Target output height
+     * @return Float array of size [targetHeight * targetWidth] with normalized grayscale values
+     */
+    fun nv21ToGrayscaleFloatArray(
+        nv21: ByteArray,
+        width: Int,
+        height: Int,
+        targetWidth: Int = width,
+        targetHeight: Int = height,
+        outputGrayscale: FloatArray? = null
+    ): FloatArray {
+        val outputSize = targetWidth * targetHeight
+        val output = outputGrayscale?.takeIf { it.size >= outputSize } ?: FloatArray(outputSize)
+
+        val ySize = width * height
+
+        var outIdx = 0
+        for (targetY in 0 until targetHeight) {
+            val srcY = (targetY * height) / targetHeight
+            val srcRowOffset = srcY * width
+
+            for (targetX in 0 until targetWidth) {
+                val srcX = (targetX * width) / targetWidth
+                val yVal = nv21[srcRowOffset + srcX].toInt() and 0xFF
+                output[outIdx++] = yVal / 255f
+            }
+        }
+
+        return output
+    }
+
+    /**
+     * Convert NV21 to integer grayscale values [0, 255].
+     * More efficient for operations that don't need float precision.
+     */
+    fun nv21ToGrayscaleIntArray(
+        nv21: ByteArray,
+        width: Int,
+        height: Int,
+        targetWidth: Int = width,
+        targetHeight: Int = height,
+        outputGrayscale: IntArray? = null
+    ): IntArray {
+        val outputSize = targetWidth * targetHeight
+        val output = outputGrayscale?.takeIf { it.size >= outputSize } ?: IntArray(outputSize)
+
+        val ySize = width * height
+
+        var outIdx = 0
+        for (targetY in 0 until targetHeight) {
+            val srcY = (targetY * height) / targetHeight
+            val srcRowOffset = srcY * width
+
+            for (targetX in 0 until targetWidth) {
+                val srcX = (targetX * width) / targetWidth
+                val yVal = nv21[srcRowOffset + srcX].toInt() and 0xFF
+                output[outIdx++] = yVal
+            }
+        }
+
+        return output
+    }
+}

package/android/src/main/java/com/faceantispoof/YuvToRgbConverter.kt

@@ -0,0 +1,73 @@
+package com.faceantispoof
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.media.Image
+import android.renderscript.Allocation
+import android.renderscript.Element
+import android.renderscript.RenderScript
+import android.renderscript.ScriptIntrinsicYuvToRGB
+import android.util.Log
+
+/**
+ * DEPRECATED: Use YuvToFloatArrayConverter instead for Bitmap-free processing.
+ * 
+ * Lightweight YUV -> RGB converter using RenderScript intrinsics.
+ * Based on CameraX sample implementation; faster than compressing to JPEG.
+ * This class creates Bitmaps which should be avoided in performance-critical code.
+ */
+@Deprecated("Use YuvToFloatArrayConverter for direct ByteBuffer/FloatArray processing without Bitmaps", ReplaceWith("YuvToFloatArrayConverter"))
+class YuvToRgbConverter(context: Context) {
+    private val rs: RenderScript = RenderScript.create(context.applicationContext)
+    private val scriptYuvToRgb: ScriptIntrinsicYuvToRGB = ScriptIntrinsicYuvToRGB.create(rs, Element.U8_4(rs))
+    private var yuvBuffer: ByteArray = ByteArray(0)
+    private var yuvAlloc: Allocation? = null
+    private var rgbaAlloc: Allocation? = null
+
+    init {
+        Log.w("YuvToRgbConverter", "YuvToRgbConverter is deprecated. Use YuvToFloatArrayConverter instead.")
+    }
+
+    fun yuvToRgb(image: Image, output: Bitmap) {
+        val planes = image.planes
+        val yBuffer = planes[0].buffer
+        val uBuffer = planes[1].buffer
+        val vBuffer = planes[2].buffer
+
+        val ySize = yBuffer.remaining()
+        val uSize = uBuffer.remaining()
+        val vSize = vBuffer.remaining()
+        val total = ySize + uSize + vSize
+
+        if (yuvBuffer.size != total) {
+            yuvBuffer = ByteArray(total)
+        }
+
+        yBuffer.get(yuvBuffer, 0, ySize)
+        vBuffer.get(yuvBuffer, ySize, vSize)
+        uBuffer.get(yuvBuffer, ySize + vSize, uSize)
+
+        if (yuvAlloc == null || yuvAlloc!!.bytesSize < yuvBuffer.size) {
+            try { yuvAlloc?.destroy() } catch (ignored: Throwable) {}
+            yuvAlloc = Allocation.createSized(rs, Element.U8(rs), yuvBuffer.size)
+        }
+
+        yuvAlloc!!.copyFrom(yuvBuffer)
+        scriptYuvToRgb.setInput(yuvAlloc)
+
+        // Create or reuse rgba allocation tied to the output bitmap
+        if (rgbaAlloc == null || rgbaAlloc!!.type.x != output.width || rgbaAlloc!!.type.y != output.height) {
+            try { rgbaAlloc?.destroy() } catch (ignored: Throwable) {}
+            rgbaAlloc = Allocation.createFromBitmap(rs, output)
+        }
+
+        scriptYuvToRgb.forEach(rgbaAlloc)
+        rgbaAlloc!!.copyTo(output)
+    }
+
+    fun destroy() {
+        try { yuvAlloc?.destroy() } catch (ignored: Throwable) {}
+        try { rgbaAlloc?.destroy() } catch (ignored: Throwable) {}
+        try { rs.destroy() } catch (ignored: Throwable) {}
+    }
+}

package/android/src/main/res/values/strings.xml

@@ -0,0 +1,3 @@
+<resources>
+    <string name="app_name">Vision Camera Face Anti-Spoof</string>
+</resources>

package/index.d.ts

@@ -0,0 +1,84 @@
+/**
+ * React Native Vision Camera Face Anti-Spoofing Detector
+ * TypeScript type definitions
+ */
+
+import type { Frame } from 'react-native-vision-camera';
+
+/**
+ * Result from face anti-spoofing detection
+ */
+export interface FaceAntiSpoofingResult {
+  /** Whether the face is live (not a spoof/fake) */
+  isLive: boolean;
+  
+  /** Human-readable label: "Live Face" or "Spoof Face" */
+  label: string;
+  
+  /** Neural network confidence score (0.0-1.0), lower is more likely to be live */
+  neuralNetworkScore: number;
+  
+  /** Laplacian-based image quality score, higher is better */
+  laplacianScore: number;
+  
+  /** Combined score (weighted average, 0.0-1.0) */
+  combinedScore: number;
+  
+  /** Error message if detection failed */
+  error?: string;
+}
+
+/**
+ * Accelerator type for TensorFlow Lite inference
+ */
+export type AcceleratorType = 'CPU' | 'GPU' | 'NNAPI';
+
+/**
+ * Frame processor function for real-time face anti-spoofing detection
+ */
+export function faceAntiSpoofFrameProcessor(
+  frame: Frame
+): FaceAntiSpoofingResult | null;
+
+/**
+ * Check if face anti-spoofing module is available
+ */
+export function isFaceAntiSpoofAvailable(): boolean;
+
+/**
+ * Initialize the face anti-spoofing module
+ * Must be called before using the frame processor
+ */
+export function initializeFaceAntiSpoof(): Promise<boolean>;
+
+/**
+ * Native module interface
+ */
+export interface FaceAntiSpoofModule {
+  initialize(): Promise<boolean>;
+  
+  checkModelStatus(): Promise<{
+    pluginAvailable: boolean;
+    modelLoaded: boolean;
+    accelerator?: AcceleratorType;
+  }>;
+  
+  isAvailable(): Promise<boolean>;
+  
+  testMethod(): Promise<string>;
+  
+  getModuleInfo(): Promise<{
+    name: string;
+    methods: string[];
+    version: string;
+    accelerator?: AcceleratorType;
+  }>;
+  
+  install(): Promise<boolean>;
+}
+
+/**
+ * Default export - the native module
+ */
+declare const FaceAntiSpoof: FaceAntiSpoofModule;
+export default FaceAntiSpoof;

package/index.js

@@ -0,0 +1,47 @@
+import { NativeModules } from 'react-native';
+import { VisionCameraProxy } from 'react-native-vision-camera';
+
+const { FaceAntiSpoof } = NativeModules;
+
+const _faceAntiSpoofPlugin = VisionCameraProxy.initFrameProcessorPlugin('faceAntiSpoof', {});
+
+// Worklet called by VisionCamera
+export const faceAntiSpoofFrameProcessor = function (frame) {
+  'worklet';
+  try {
+    if (_faceAntiSpoofPlugin && typeof _faceAntiSpoofPlugin.call === 'function') {
+      return _faceAntiSpoofPlugin.call(frame);
+    }
+    return null;
+  } catch (err) {
+    console.error('[FaceAntiSpoof] Error in frame processor call:', err);
+    return null;
+  }
+};
+
+export default FaceAntiSpoof;
+
+// Utility functions
+export const isFaceAntiSpoofAvailable = () => {
+  return !!FaceAntiSpoof;
+};
+
+export const initializeFaceAntiSpoof = async () => {
+  try {
+    const result = await FaceAntiSpoof.initialize();
+    const status = await FaceAntiSpoof.checkModelStatus();
+
+    try {
+      if (typeof FaceAntiSpoof.install === 'function') {
+        await FaceAntiSpoof.install();
+      }
+    } catch (e) {
+      console.error('[FaceAntiSpoof] install() failed:', e);
+    }
+
+    return result && status.pluginAvailable;
+  } catch (error) {
+    console.error('[FaceAntiSpoof] Initialization failed:', error);
+    throw error;
+  }
+};

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "react-native-vision-camera-spoof-detector",
+  "version": "1.0.0",
+  "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/jescon-tech/react-native-vision-camera-spoof-detector",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jescon-tech/react-native-vision-camera-spoof-detector.git"
+  },
+  "bugs": {
+    "url": "https://github.com/jescon-tech/react-native-vision-camera-spoof-detector/issues"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "PRAFULDAS M M",
+    "company": "JESCON TECHNOLOGIES PVT LTD",
+    "email": "jescontechnologies@gmail.com"
+  },
+  "main": "index.js",
+  "browser": "index.js",
+  "react-native": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "android/",
+    "ios/",
+    "index.js",
+    "index.d.ts",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "test": "jest",
+    "lint": "eslint .",
+    "type-check": "tsc --noEmit"
+  },
+  "keywords": [
+    "react-native",
+    "vision-camera",
+    "face-detection",
+    "anti-spoofing",
+    "liveness-detection",
+    "face-liveness",
+    "spoofing-detection",
+    "tensorflow-lite",
+    "gpu-acceleration",
+    "yuv-processing"
+  ],
+  "peerDependencies": {
+    "react-native": ">=0.60.0",
+    "react-native-vision-camera": "^4.6.4 || ^5.0.0",
+    "react-native-reanimated": "^3.0.0",
+    "react-native-worklets-core": "^1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react-native-vision-camera-face-detector": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "react-native": "^0.72.0",
+    "@babel/plugin-proposal-nullish-coalescing-operator": "^7.18.6",
+    "@babel/plugin-proposal-optional-chaining": "^7.21.0"
+  },
+  "dependencies": {
+    "react-native-geolocation-service": "^5.3.1"
+  },
+  "engines": {
+    "node": ">=16.0.0",
+    "npm": ">=8.0.0"
+  },
+  "packageManager": "npm@8.0.0",
+  "documentation": "https://github.com/jescon-tech/react-native-vision-camera-spoof-detector/wiki"
+}