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

package/android/src/main/cpp/libyuv/util/yuvconvert.cc

@@ -0,0 +1,367 @@
+/*
+ *  Copyright 2013 The LibYuv Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS. All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+// Convert an ARGB image to YUV.
+// Usage: yuvconvert src_argb.raw dst_yuv.raw
+
+#ifndef _CRT_SECURE_NO_WARNINGS
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "libyuv/convert.h"
+#include "libyuv/planar_functions.h"
+#include "libyuv/scale_argb.h"
+
+// options
+bool verbose = false;
+bool attenuate = false;
+bool unattenuate = false;
+int image_width = 0, image_height = 0;  // original width and height
+int dst_width = 0, dst_height = 0;      // new width and height
+int fileindex_org = 0;  // argv argument contains the original file name.
+int fileindex_rec = 0;  // argv argument contains the reconstructed file name.
+int num_rec = 0;        // Number of reconstructed images.
+int num_skip_org = 0;   // Number of frames to skip in original.
+int num_frames = 0;     // Number of frames to convert.
+int filter = 1;         // Bilinear filter for scaling.
+
+static __inline uint32_t Abs(int32_t v) {
+  return v >= 0 ? v : -v;
+}
+
+// Parse PYUV format. ie name.1920x800_24Hz_P420.yuv
+static bool ExtractResolutionFromFilename(const char* name,
+                                          int* width_ptr,
+                                          int* height_ptr) {
+  // Isolate the .width_height. section of the filename by searching for a
+  // dot or underscore followed by a digit.
+  for (int i = 0; name[i]; ++i) {
+    if ((name[i] == '.' || name[i] == '_') && name[i + 1] >= '0' &&
+        name[i + 1] <= '9') {
+      int n = sscanf(name + i + 1, "%dx%d", width_ptr, height_ptr);  // NOLINT
+      if (2 == n) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+static void PrintHelp(const char* program) {
+  printf("%s [-options] src_argb.raw dst_yuv.raw\n", program);
+  printf(
+      " -s <width> <height> .... specify source resolution.  "
+      "Optional if name contains\n"
+      "                          resolution (ie. "
+      "name.1920x800_24Hz_P420.yuv)\n"
+      "                          Negative value mirrors.\n");
+  printf(" -d <width> <height> .... specify destination resolution.\n");
+  printf(" -f <filter> ............ 0 = point, 1 = bilinear (default).\n");
+  printf(" -skip <src_argb> ....... Number of frame to skip of src_argb\n");
+  printf(" -frames <num> .......... Number of frames to convert\n");
+  printf(" -attenuate ............. Attenuate the ARGB image\n");
+  printf(" -unattenuate ........... Unattenuate the ARGB image\n");
+  printf(" -v ..................... verbose\n");
+  printf(" -h ..................... this help\n");
+  exit(0);
+}
+
+static void ParseOptions(int argc, const char* argv[]) {
+  if (argc <= 1) {
+    PrintHelp(argv[0]);
+  }
+  for (int c = 1; c < argc; ++c) {
+    if (!strcmp(argv[c], "-v")) {
+      verbose = true;
+    } else if (!strcmp(argv[c], "-attenuate")) {
+      attenuate = true;
+    } else if (!strcmp(argv[c], "-unattenuate")) {
+      unattenuate = true;
+    } else if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
+      PrintHelp(argv[0]);
+    } else if (!strcmp(argv[c], "-s") && c + 2 < argc) {
+      image_width = atoi(argv[++c]);   // NOLINT
+      image_height = atoi(argv[++c]);  // NOLINT
+    } else if (!strcmp(argv[c], "-d") && c + 2 < argc) {
+      dst_width = atoi(argv[++c]);   // NOLINT
+      dst_height = atoi(argv[++c]);  // NOLINT
+    } else if (!strcmp(argv[c], "-skip") && c + 1 < argc) {
+      num_skip_org = atoi(argv[++c]);  // NOLINT
+    } else if (!strcmp(argv[c], "-frames") && c + 1 < argc) {
+      num_frames = atoi(argv[++c]);  // NOLINT
+    } else if (!strcmp(argv[c], "-f") && c + 1 < argc) {
+      filter = atoi(argv[++c]);  // NOLINT
+    } else if (argv[c][0] == '-') {
+      fprintf(stderr, "Unknown option. %s\n", argv[c]);
+    } else if (fileindex_org == 0) {
+      fileindex_org = c;
+    } else if (fileindex_rec == 0) {
+      fileindex_rec = c;
+      num_rec = 1;
+    } else {
+      ++num_rec;
+    }
+  }
+  if (fileindex_org == 0 || fileindex_rec == 0) {
+    fprintf(stderr, "Missing filenames\n");
+    PrintHelp(argv[0]);
+  }
+  if (num_skip_org < 0) {
+    fprintf(stderr, "Skipped frames incorrect\n");
+    PrintHelp(argv[0]);
+  }
+  if (num_frames < 0) {
+    fprintf(stderr, "Number of frames incorrect\n");
+    PrintHelp(argv[0]);
+  }
+
+  int org_width, org_height;
+  int rec_width, rec_height;
+  bool org_res_avail = ExtractResolutionFromFilename(argv[fileindex_org],
+                                                     &org_width, &org_height);
+  bool rec_res_avail = ExtractResolutionFromFilename(argv[fileindex_rec],
+                                                     &rec_width, &rec_height);
+  if (image_width == 0 || image_height == 0) {
+    if (org_res_avail) {
+      image_width = org_width;
+      image_height = org_height;
+    } else if (rec_res_avail) {
+      image_width = rec_width;
+      image_height = rec_height;
+    } else {
+      fprintf(stderr, "Missing dimensions.\n");
+      PrintHelp(argv[0]);
+    }
+  }
+  if (dst_width == 0 || dst_height == 0) {
+    if (rec_res_avail) {
+      dst_width = rec_width;
+      dst_height = rec_height;
+    } else {
+      dst_width = Abs(image_width);
+      dst_height = Abs(image_height);
+    }
+  }
+}
+
+static const int kTileX = 32;
+static const int kTileY = 32;
+
+static int TileARGBScale(const uint8_t* src_argb,
+                         int src_stride_argb,
+                         int src_width,
+                         int src_height,
+                         uint8_t* dst_argb,
+                         int dst_stride_argb,
+                         int destination_width,
+                         int destination_height,
+                         libyuv::FilterMode filtering) {
+  for (int y = 0; y < destination_height; y += kTileY) {
+    for (int x = 0; x < destination_width; x += kTileX) {
+      int clip_width = kTileX;
+      if (x + clip_width > destination_width) {
+        clip_width = destination_width - x;
+      }
+      int clip_height = kTileY;
+      if (y + clip_height > destination_height) {
+        clip_height = destination_height - y;
+      }
+      int r = libyuv::ARGBScaleClip(src_argb, src_stride_argb, src_width,
+                                    src_height, dst_argb, dst_stride_argb,
+                                    destination_width, destination_height, x, y,
+                                    clip_width, clip_height, filtering);
+      if (r) {
+        return r;
+      }
+    }
+  }
+  return 0;
+}
+
+int main(int argc, const char* argv[]) {
+  ParseOptions(argc, argv);
+
+  // Open original file (first file argument)
+  FILE* const file_org = fopen(argv[fileindex_org], "rb");
+  if (file_org == NULL) {
+    fprintf(stderr, "Cannot open %s\n", argv[fileindex_org]);
+    exit(1);
+  }
+
+  // Open all files to convert to
+  FILE** file_rec = new FILE*[num_rec];
+  memset(file_rec, 0, num_rec * sizeof(FILE*));  // NOLINT
+  for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
+    file_rec[cur_rec] = fopen(argv[fileindex_rec + cur_rec], "wb");
+    if (file_rec[cur_rec] == NULL) {
+      fprintf(stderr, "Cannot open %s\n", argv[fileindex_rec + cur_rec]);
+      fclose(file_org);
+      for (int i = 0; i < cur_rec; ++i) {
+        fclose(file_rec[i]);
+      }
+      delete[] file_rec;
+      exit(1);
+    }
+  }
+
+  bool org_is_yuv = strstr(argv[fileindex_org], "_P420.") != NULL;
+  bool org_is_argb = strstr(argv[fileindex_org], "_ARGB.") != NULL;
+  if (!org_is_yuv && !org_is_argb) {
+    fprintf(stderr, "Original format unknown %s\n", argv[fileindex_org]);
+    exit(1);
+  }
+  int org_size = Abs(image_width) * Abs(image_height) * 4;  // ARGB
+  // Input is YUV
+  if (org_is_yuv) {
+    const int y_size = Abs(image_width) * Abs(image_height);
+    const int uv_size =
+        ((Abs(image_width) + 1) / 2) * ((Abs(image_height) + 1) / 2);
+    org_size = y_size + 2 * uv_size;  // YUV original.
+  }
+
+  const int dst_size = dst_width * dst_height * 4;  // ARGB scaled
+  const int y_size = dst_width * dst_height;
+  const int uv_size = ((dst_width + 1) / 2) * ((dst_height + 1) / 2);
+  const size_t total_size = y_size + 2 * uv_size;
+#if defined(_MSC_VER)
+  _fseeki64(file_org,
+            static_cast<__int64>(num_skip_org) * static_cast<__int64>(org_size),
+            SEEK_SET);
+#else
+  fseek(file_org, num_skip_org * total_size, SEEK_SET);
+#endif
+
+  uint8_t* const ch_org = new uint8_t[org_size];
+  uint8_t* const ch_dst = new uint8_t[dst_size];
+  uint8_t* const ch_rec = new uint8_t[total_size];
+  if (ch_org == NULL || ch_rec == NULL) {
+    fprintf(stderr, "No memory available\n");
+    fclose(file_org);
+    for (int i = 0; i < num_rec; ++i) {
+      fclose(file_rec[i]);
+    }
+    delete[] ch_org;
+    delete[] ch_dst;
+    delete[] ch_rec;
+    delete[] file_rec;
+    exit(1);
+  }
+
+  if (verbose) {
+    printf("Size: %dx%d to %dx%d\n", image_width, image_height, dst_width,
+           dst_height);
+  }
+
+  int number_of_frames;
+  for (number_of_frames = 0;; ++number_of_frames) {
+    if (num_frames && number_of_frames >= num_frames) {
+      break;
+    }
+
+    // Load original YUV or ARGB frame.
+    size_t bytes_org =
+        fread(ch_org, sizeof(uint8_t), static_cast<size_t>(org_size), file_org);
+    if (bytes_org < static_cast<size_t>(org_size)) {
+      break;
+    }
+
+    // TODO(fbarchard): Attenuate doesnt need to know dimensions.
+    // ARGB attenuate frame
+    if (org_is_argb && attenuate) {
+      libyuv::ARGBAttenuate(ch_org, 0, ch_org, 0, org_size / 4, 1);
+    }
+    // ARGB unattenuate frame
+    if (org_is_argb && unattenuate) {
+      libyuv::ARGBUnattenuate(ch_org, 0, ch_org, 0, org_size / 4, 1);
+    }
+
+    for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
+      // Scale YUV or ARGB frame.
+      if (org_is_yuv) {
+        int src_width = Abs(image_width);
+        int src_height = Abs(image_height);
+        int half_src_width = (src_width + 1) / 2;
+        int half_src_height = (src_height + 1) / 2;
+        int half_dst_width = (dst_width + 1) / 2;
+        int half_dst_height = (dst_height + 1) / 2;
+        I420Scale(
+            ch_org, src_width, ch_org + src_width * src_height, half_src_width,
+            ch_org + src_width * src_height + half_src_width * half_src_height,
+            half_src_width, image_width, image_height, ch_rec, dst_width,
+            ch_rec + dst_width * dst_height, half_dst_width,
+            ch_rec + dst_width * dst_height + half_dst_width * half_dst_height,
+            half_dst_width, dst_width, dst_height,
+            static_cast<libyuv::FilterMode>(filter));
+      } else {
+        TileARGBScale(ch_org, Abs(image_width) * 4, image_width, image_height,
+                      ch_dst, dst_width * 4, dst_width, dst_height,
+                      static_cast<libyuv::FilterMode>(filter));
+      }
+      bool rec_is_yuv = strstr(argv[fileindex_rec + cur_rec], "_P420.") != NULL;
+      bool rec_is_argb =
+          strstr(argv[fileindex_rec + cur_rec], "_ARGB.") != NULL;
+      if (!rec_is_yuv && !rec_is_argb) {
+        fprintf(stderr, "Output format unknown %s\n",
+                argv[fileindex_rec + cur_rec]);
+        continue;  // Advance to next file.
+      }
+
+      // Convert ARGB to YUV.
+      if (!org_is_yuv && rec_is_yuv) {
+        int half_width = (dst_width + 1) / 2;
+        int half_height = (dst_height + 1) / 2;
+        libyuv::ARGBToI420(
+            ch_dst, dst_width * 4, ch_rec, dst_width,
+            ch_rec + dst_width * dst_height, half_width,
+            ch_rec + dst_width * dst_height + half_width * half_height,
+            half_width, dst_width, dst_height);
+      }
+
+      // Output YUV or ARGB frame.
+      if (rec_is_yuv) {
+        size_t bytes_rec =
+            fwrite(ch_rec, sizeof(uint8_t), static_cast<size_t>(total_size),
+                   file_rec[cur_rec]);
+        if (bytes_rec < static_cast<size_t>(total_size)) {
+          break;
+        }
+      } else {
+        size_t bytes_rec =
+            fwrite(ch_dst, sizeof(uint8_t), static_cast<size_t>(dst_size),
+                   file_rec[cur_rec]);
+        if (bytes_rec < static_cast<size_t>(dst_size)) {
+          break;
+        }
+      }
+      if (verbose) {
+        printf("%5d", number_of_frames);
+      }
+      if (verbose) {
+        printf("\t%s", argv[fileindex_rec + cur_rec]);
+        printf("\n");
+      }
+    }
+  }
+
+  fclose(file_org);
+  for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
+    fclose(file_rec[cur_rec]);
+  }
+  delete[] ch_org;
+  delete[] ch_dst;
+  delete[] ch_rec;
+  delete[] file_rec;
+  return 0;
+}

package/android/src/main/cpp/libyuv/winarm.mk

@@ -0,0 +1,47 @@
+# This is a generic makefile for libyuv for Windows Arm.
+# call "c:\Program Files (x86)\Microsoft Visual Studio 11.0\VC\bin\x86_arm\vcvarsx86_arm.bat"
+# nmake /f winarm.mk
+# make -f winarm.mk
+# nmake /f winarm.mk clean
+# consider /arch:ARMv7VE
+CC=cl
+CCFLAGS=/Ox /nologo /Iinclude /DWINAPI_FAMILY=WINAPI_FAMILY_PHONE_APP
+AR=lib
+ARFLAGS=/MACHINE:ARM /NOLOGO /SUBSYSTEM:NATIVE
+RM=cmd /c del
+
+LOCAL_OBJ_FILES = \
+	source/compare.o\
+	source/compare_common.o\
+	source/convert.o\
+	source/convert_argb.o\
+	source/convert_from.o\
+	source/convert_from_argb.o\
+	source/convert_to_argb.o\
+	source/convert_to_i420.o\
+	source/cpu_id.o\
+	source/planar_functions.o\
+	source/rotate.o\
+	source/rotate_any.o\
+	source/rotate_argb.o\
+	source/rotate_common.o\
+	source/row_any.o\
+	source/row_common.o\
+	source/scale.o\
+	source/scale_any.o\
+	source/scale_argb.o\
+	source/scale_common.o\
+	source/scale_uv.o\
+	source/video_common.o
+
+.cc.o:
+	$(CC) /c $(CCFLAGS) $*.cc /Fo$@
+
+all: libyuv_arm.lib winarm.mk
+
+libyuv_arm.lib: $(LOCAL_OBJ_FILES) winarm.mk
+	$(AR) $(ARFLAGS) /OUT:$@ $(LOCAL_OBJ_FILES)
+
+clean:
+	$(RM) "source\*.o" libyuv_arm.lib
+

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

@@ -0,0 +1,49 @@
+package com.faceantispoof
+
+/**
+ * Configuration class for TensorFlow Lite accelerators
+ * Allows developers to control GPU/NNAPI delegate behavior
+ */
+object AcceleratorConfig {
+    
+    /**
+     * Enable GPU acceleration (recommended for modern devices)
+     * Accelerates model 3-10x compared to CPU
+     */
+    var enableGpu: Boolean = true
+    
+    /**
+     * Enable NNAPI acceleration (recommended for Pixel/Samsung devices)
+     * Accelerates model 3-10x compared to CPU
+     * Fallback if GPU is not available
+     */
+    var enableNnapi: Boolean = true
+    
+    /**
+     * Enable CPU fallback if GPU/NNAPI are not available
+     * Default: true
+     */
+    var enableCpuFallback: Boolean = true
+    
+    /**
+     * Number of threads for CPU inference
+     * Default: 4 threads
+     */
+    var cpuThreadCount: Int = 4
+    
+    /**
+     * Print debug logs for accelerator selection
+     */
+    var debugLogging: Boolean = true
+    
+    override fun toString(): String {
+        return """
+            AcceleratorConfig:
+            - GPU Enabled: $enableGpu
+            - NNAPI Enabled: $enableNnapi
+            - CPU Fallback: $enableCpuFallback
+            - CPU Threads: $cpuThreadCount
+            - Debug Logging: $debugLogging
+        """.trimIndent()
+    }
+}

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

@@ -0,0 +1,145 @@
+package com.faceantispoof
+
+import com.mrousavy.camera.frameprocessors.Frame
+import com.mrousavy.camera.frameprocessors.FrameProcessorPlugin
+import android.util.Log
+import java.util.concurrent.Executors
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicReference
+
+/**
+ * Frame processor that performs face anti-spoofing detection directly on YUV frames
+ * without creating intermediate Bitmaps. Uses ByteBuffer and FloatArray for efficient processing.
+ * 
+ * IMPORTANT: All heavy processing is offloaded to a dedicated background thread (not the VisionCamera callback thread)
+ * to prevent frame drop issues and ensure smooth camera preview.
+ */
+class FaceAntiSpoofFrameProcessor : FrameProcessorPlugin() {
+
+    private var faceAntiSpoofing: FaceAntiSpoofingAdvanced? = null
+    private var isInitialized = false
+    
+    // Single-threaded executor for offloading processing tasks
+    private val processingExecutor = Executors.newSingleThreadExecutor { runnable ->
+        Thread(runnable, "FaceAntiSpoofProcessor").apply { isDaemon = true }
+    }
+    
+    // Store the latest result to avoid race conditions
+    private val latestResult: AtomicReference<Map<String, Any?>> = AtomicReference(
+        mapOf(
+            "error" to "Not initialized",
+            "isLive" to false,
+            "label" to "Not Initialized"
+        )
+    )
+    
+    // Track if processing is in flight to prevent queue overflow
+    private val isProcessing = AtomicReference(false)
+
+    fun initialize(assets: android.content.res.AssetManager) {
+        try {
+            faceAntiSpoofing = FaceAntiSpoofingAdvanced(assets)
+            isInitialized = true
+            Log.i("FaceAntiSpoof", "Initialized successfully")
+        } catch (e: Exception) {
+            Log.e("FaceAntiSpoof", "Initialization failed: ${e.message}", e)
+            isInitialized = false
+        }
+    }
+
+    override fun callback(frame: Frame, params: Map<String, Any?>?): Any? {
+        // Return immediately without blocking the VisionCamera thread
+        // The callback should return quickly to avoid frame drops
+        
+        if (!isInitialized) {
+            return latestResult.get()
+        }
+
+        // Only process if the previous frame has finished processing
+        // This prevents accumulating a queue of frames to process
+        if (!isProcessing.compareAndSet(false, true)) {
+            // Processing already in flight, return the latest result
+            return latestResult.get()
+        }
+
+        // Submit the heavy processing to the background thread executor
+        processingExecutor.submit {
+            try {
+                val faceAntispoof = faceAntiSpoofing ?: throw Exception("FaceAntiSpoofing not initialized")
+
+                // Extract YUV data directly from frame without creating Bitmap
+                val image = frame.getImage()
+                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 nv21 = ByteArray(ySize + uSize + vSize)
+
+                yBuffer.get(nv21, 0, ySize)
+                vBuffer.get(nv21, ySize, vSize)
+                uBuffer.get(nv21, ySize + vSize, uSize)
+
+                val width = frame.getWidth()
+                val height = frame.getHeight()
+
+                // Process NV21 data directly (no Bitmap conversion)
+                val result = faceAntispoof.advancedAntiSpoofing(nv21, width, height)
+
+                val resultMap = mapOf(
+                    "isLive" to result.isLive,
+                    "label" to result.label,
+                    "neuralNetworkScore" to result.neuralNetworkScore.toDouble(),
+                    "laplacianScore" to result.laplacianScore,
+                    "combinedScore" to result.combinedScore.toDouble()
+                )
+                
+                // Update the latest result for the next callback
+                latestResult.set(resultMap)
+            } catch (e: Exception) {
+                Log.e("FaceAntiSpoof", "Processing error: ${e.message}", e)
+                val errorMap = mapOf(
+                    "error" to e.message,
+                    "isLive" to false,
+                    "label" to "Error: ${e.message}"
+                )
+                latestResult.set(errorMap)
+            } finally {
+                // Mark processing as complete for the next frame
+                isProcessing.set(false)
+            }
+        }
+        
+        // Return the latest result immediately without waiting
+        return latestResult.get()
+    }
+    
+    /**
+     * Cleanup resources when the frame processor is no longer needed
+     * This should be called when the camera is closed or the app is destroyed
+     */
+    fun cleanup() {
+        try {
+            // Shutdown the executor and wait for any running tasks to complete
+            processingExecutor.shutdown()
+            if (!processingExecutor.awaitTermination(5, java.util.concurrent.TimeUnit.SECONDS)) {
+                Log.w("FaceAntiSpoof", "Executor did not terminate in time, forcing shutdown")
+                processingExecutor.shutdownNow()
+            }
+            
+            // Clean up the face anti-spoofing model
+            faceAntiSpoofing?.close()
+            faceAntiSpoofing = null
+            isInitialized = false
+            
+            Log.i("FaceAntiSpoof", "Cleanup completed successfully")
+        } catch (e: Exception) {
+            Log.e("FaceAntiSpoof", "Error during cleanup: ${e.message}", e)
+        }
+    }
+}