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

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.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": {