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

package/VisionCameraSpoofDetector.podspec

@@ -34,6 +34,7 @@ Pod::Spec.new do |s|
   s.resources = ['lib/assets/*']
 
   s.dependency 'TensorFlowLiteSwift'
+  s.dependency 'TensorFlowLiteC/Metal'
   s.dependency 'VisionCamera'
   s.dependency 'React-jsi'
   s.dependency 'React-callinvoker'

package/ios/FaceAntiSpoofManager.swift

@@ -3,6 +3,27 @@ import Foundation
 #if canImport(TensorFlowLite)
 import TensorFlowLite
 #endif
+#if canImport(TensorFlowLiteCMetal)
+import TensorFlowLiteCMetal
+#endif
+
+#if canImport(TensorFlowLite) && canImport(TensorFlowLiteCMetal)
+private final class IOSMetalDelegate: Delegate {
+    let cDelegate: Delegate.CDelegate
+
+    init() {
+        var options = TFLGpuDelegateOptions()
+        options.allow_precision_loss = false
+        options.wait_type = TFLGpuDelegateWaitTypePassive
+        options.enable_quantization = true
+        cDelegate = TFLGpuDelegateCreate(&options)
+    }
+
+    deinit {
+        TFLGpuDelegateDelete(cDelegate)
+    }
+}
+#endif
 
 @objcMembers
 public class FaceAntiSpoofManager: NSObject {
@@ -16,7 +37,16 @@ public class FaceAntiSpoofManager: NSObject {
 
     #if canImport(TensorFlowLite)
     public static var sharedInterpreter: Interpreter?
+    public static private(set) var currentAccelerator = "CPU"
+    public static var enableGpu = true
+    public static var disableGpuDelegate = false
+    public static var enableCpuFallback = true
+    public static var forceCpuOnly = false
+    public static var cpuThreadCount = 4
     private static let interpreterLock = NSLock()
+    #if canImport(TensorFlowLiteCMetal)
+    private static var metalDelegate: IOSMetalDelegate?
+    #endif
     #endif
 
     @objc public class func initializeModel() -> Bool {
@@ -46,15 +76,48 @@ public class FaceAntiSpoofManager: NSObject {
         }
 
         do {
+            let threadCount = max(1, cpuThreadCount)
             var options = Interpreter.Options()
-            options.threadCount = 2
-            sharedInterpreter = try Interpreter(modelPath: path, options: options)
+            options.threadCount = threadCount
+
+            #if canImport(TensorFlowLiteCMetal)
+            if enableGpu && !disableGpuDelegate && !forceCpuOnly {
+                do {
+                    let delegate = IOSMetalDelegate()
+                    sharedInterpreter = try Interpreter(
+                        modelPath: path,
+                        options: options,
+                        delegates: [delegate]
+                    )
+                    metalDelegate = delegate
+                    currentAccelerator = "GPU"
+                    NSLog("[FaceAntiSpoof] Manager: Metal delegate enabled | Threads: \(threadCount)")
+                } catch {
+                    metalDelegate = nil
+                    NSLog("[FaceAntiSpoof] Manager: Metal delegate unavailable: \(error)")
+                    guard enableCpuFallback else { throw error }
+                }
+            }
+            #endif
+
+            if sharedInterpreter == nil {
+                guard enableCpuFallback || forceCpuOnly else {
+                    throw NSError(domain: "FaceAntiSpoof", code: 4, userInfo: [
+                        NSLocalizedDescriptionKey: "No enabled TensorFlow Lite accelerator is available"
+                    ])
+                }
+                sharedInterpreter = try Interpreter(modelPath: path, options: options)
+                currentAccelerator = "CPU"
+                NSLog("[FaceAntiSpoof] Manager: CPU fallback enabled | Threads: \(threadCount)")
+            }
             try sharedInterpreter?.allocateTensors()
             NSLog("[FaceAntiSpoof] Manager: Loaded model at \(path)")
             return true
         } catch {
             NSLog("[FaceAntiSpoof] Manager: Failed to create interpreter: \(error)")
             sharedInterpreter = nil
+            metalDelegate = nil
+            currentAccelerator = "CPU"
             return false
         }
         #else
@@ -71,6 +134,14 @@ public class FaceAntiSpoofManager: NSObject {
         #endif
     }
 
+    @objc public class func accelerator() -> String {
+        #if canImport(TensorFlowLite)
+        return currentAccelerator
+        #else
+        return "UNAVAILABLE"
+        #endif
+    }
+
     public class func process(input: [Float]) throws -> DetectionResult {
         #if canImport(TensorFlowLite)
         if sharedInterpreter == nil && !initializeModel() {
@@ -158,7 +229,11 @@ public class FaceAntiSpoofManager: NSObject {
 
     @objc public class func cleanupModel() {
         #if canImport(TensorFlowLite)
+        interpreterLock.lock()
         sharedInterpreter = nil
+        metalDelegate = nil
+        currentAccelerator = "CPU"
+        interpreterLock.unlock()
         #endif
         NSLog("[FaceAntiSpoof] Manager: cleaned up model")
     }

package/ios/FaceAntiSpoofModule.m

@@ -110,10 +110,26 @@ RCT_REMAP_METHOD(getModuleInfo,
 								 getModuleInfoWithResolver:(RCTPromiseResolveBlock)resolve
 								 rejecter:(RCTPromiseRejectBlock)reject)
 {
-	NSDictionary *info = @{@"name": @"FaceAntiSpoof", @"methods": @[@"initialize", @"checkModelStatus", @"isAvailable", @"testMethod", @"getModuleInfo", @"install", @"cleanup"]};
+	NSDictionary *info = @{ @"name": @"FaceAntiSpoof", @"methods": @[@"initialize", @"checkModelStatus", @"isAvailable", @"testMethod", @"getModuleInfo", @"install", @"cleanup", @"getAccelerator"], @"accelerators": @[@"GPU", @"CPU"] };
 	resolve(info);
 }
 
+RCT_REMAP_METHOD(getAccelerator,
+								 getAcceleratorWithResolver:(RCTPromiseResolveBlock)resolve
+								 rejecter:(RCTPromiseRejectBlock)reject)
+{
+	Class managerClass = NSClassFromString(@"FaceAntiSpoofManager");
+	if (managerClass != Nil) {
+		SEL sel = NSSelectorFromString(@"accelerator");
+		if ([managerClass respondsToSelector:sel]) {
+			id (*msgSendObject)(id, SEL) = (id (*)(id, SEL))objc_msgSend;
+			resolve(msgSendObject((id)managerClass, sel));
+			return;
+		}
+	}
+	resolve(@"UNAVAILABLE");
+}
+
 RCT_REMAP_METHOD(install,
 								 installWithResolver:(RCTPromiseResolveBlock)resolve
 								 rejecter:(RCTPromiseRejectBlock)reject)

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.24",
+  "version": "1.1.26",
   "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": {