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

package/android/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,94 @@
+cmake_minimum_required(VERSION 3.4.1)
+
+project(fastyuv)
+
+set(SOURCE_FILES
+    FastYuvJni.cpp
+    fast_yuv.cpp
+)
+
+add_library(fastyuv SHARED ${SOURCE_FILES})
+
+# Enable NEON SIMD optimizations for ARM architectures
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "armv7" OR CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
+    # ARM NEON optimization flags
+    target_compile_options(fastyuv PRIVATE
+        -fPIC
+        -O3
+    )
+    
+    # ARM-specific NEON enablement (clang doesn't support -march=native for cross-compilation)
+    if(CMAKE_SYSTEM_PROCESSOR MATCHES "armv7")
+        # ARMv7 with NEON (32-bit ARM)
+        target_compile_options(fastyuv PRIVATE -march=armv7-a -mfpu=neon -mfloat-abi=softfp)
+    elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
+        # ARMv8 with full SIMD support (64-bit ARM)
+        target_compile_options(fastyuv PRIVATE -march=armv8-a)
+    endif()
+endif()
+
+# Always add libyuv include dir so headers like libyuv/convert.h are found.
+target_include_directories(fastyuv PRIVATE ${CMAKE_SOURCE_DIR}/libyuv/include)
+
+# Prefer using libyuv subproject if available.
+if (EXISTS ${CMAKE_SOURCE_DIR}/libyuv/CMakeLists.txt)
+    add_subdirectory(libyuv)
+    # Link against the libyuv target produced by that CMake. The lib creates
+    # targets named 'yuv' (static) and 'yuv_shared' (shared) whose output
+    # library name is 'libyuv'. Prefer the shared target when available.
+    if (TARGET yuv_shared)
+        target_link_libraries(fastyuv PRIVATE yuv_shared)
+    elseif (TARGET yuv)
+        target_link_libraries(fastyuv PRIVATE yuv)
+    endif()
+endif()
+
+# Android log
+find_library(log-lib log)
+target_link_libraries(fastyuv PRIVATE ${log-lib})
+cmake_minimum_required(VERSION 3.18)
+project(faceantispoof)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+get_filename_component(CMAKE_SOURCE_ABS "${CMAKE_SOURCE_DIR}" ABSOLUTE)
+# .../react-native-vision-camera-spoof-detector/android/src/main/cpp -> ../../../.. = .../node_modules
+get_filename_component(PARENT_1 "${CMAKE_SOURCE_ABS}/.." ABSOLUTE)  # main
+get_filename_component(PARENT_2 "${PARENT_1}/.." ABSOLUTE)  # src
+get_filename_component(PARENT_3 "${PARENT_2}/.." ABSOLUTE)  # android
+get_filename_component(PARENT_4 "${PARENT_3}/.." ABSOLUTE)  # react-native-vision-camera-spoof-detector
+get_filename_component(NODE_MODULES_ABS "${PARENT_4}/.." ABSOLUTE)  # node_modules
+
+set(REACT_NATIVE_DIR "${NODE_MODULES_ABS}/react-native")
+set(REACT_COMMON_DIR "${REACT_NATIVE_DIR}/ReactCommon")
+
+message(STATUS "NODE_MODULES_ABS: ${NODE_MODULES_ABS}")
+message(STATUS "REACT_NATIVE_DIR: ${REACT_NATIVE_DIR}")
+message(STATUS "REACT_COMMON_DIR: ${REACT_COMMON_DIR}")
+
+# Compile JSI implementation
+file(GLOB JSI_CPP "${REACT_COMMON_DIR}/jsi/jsi/jsi.cpp")
+
+add_library(faceantispoof SHARED FaceAntiSpoofJSI.cpp ${JSI_CPP})
+
+target_include_directories(faceantispoof PRIVATE
+    "${REACT_COMMON_DIR}/jsi"
+    "${REACT_COMMON_DIR}/cxxreact"
+    "${REACT_COMMON_DIR}/callinvoker/ReactCommon"
+    "${REACT_COMMON_DIR}/runtimeexecutor/ReactCommon"
+    "${REACT_COMMON_DIR}"
+)
+
+find_library(log-lib log)
+
+target_link_libraries(
+    faceantispoof
+    "${log-lib}"
+    c++_shared
+    atomic
+    m
+)
+
+

package/android/src/main/cpp/FaceAntiSpoofJSI.cpp

@@ -0,0 +1,68 @@
+#include <jni.h>
+#include <jsi/jsi.h>
+#include <string>
+#include <android/log.h>
+
+using namespace facebook;
+
+// Logging macro
+#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "FaceAntiSpoofJSI", __VA_ARGS__))
+
+// Dummy frame processing function
+jsi::Value faceAntiSpoof(jsi::Runtime &runtime, const jsi::Value &frame) {
+    LOGI("FaceAntiSpoofJSI: frame received");
+
+    jsi::Object result(runtime);
+    result.setProperty(runtime, "isLive", true);
+    result.setProperty(runtime, "label", "Live");
+    result.setProperty(runtime, "confidence", 0.99);
+
+    return result;
+}
+
+// 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

@@ -0,0 +1,111 @@
+#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"

package/android/src/main/cpp/fast_yuv.cpp

@@ -0,0 +1,332 @@
+#include "fast_yuv.h"
+#include <stdlib.h>
+#include <string.h>
+#include <vector>
+#include <unordered_map>
+#include <mutex>
+
+// Include specific libyuv headers with SIMD optimizations.
+// libyuv internally uses NEON for ARM and other SIMD extensions.
+#include "libyuv/convert.h"
+#include "libyuv/convert_argb.h"
+#include "libyuv/convert_from.h"
+#include "libyuv/scale.h"
+#include "libyuv/rotate.h"
+
+namespace fastyuv {
+
+// Simple memory pool for reducing allocation overhead in video processing
+class BufferPool {
+private:
+    std::unordered_map<size_t, std::vector<uint8_t*>> pool;
+    std::mutex pool_mutex;
+    static constexpr int MAX_BUFFERS_PER_SIZE = 4;  // Keep up to 4 buffers per size
+
+public:
+    uint8_t* allocate(size_t size) {
+        std::lock_guard<std::mutex> guard(pool_mutex);
+        auto& buffers = pool[size];
+        if (!buffers.empty()) {
+            uint8_t* buf = buffers.back();
+            buffers.pop_back();
+            return buf;
+        }
+        return (uint8_t*)malloc(size);
+    }
+
+    void deallocate(uint8_t* ptr, size_t size) {
+        if (!ptr) return;
+        std::lock_guard<std::mutex> guard(pool_mutex);
+        auto& buffers = pool[size];
+        if (buffers.size() < MAX_BUFFERS_PER_SIZE) {
+            buffers.push_back(ptr);
+        } else {
+            free(ptr);
+        }
+    }
+
+    static BufferPool& getInstance() {
+        static BufferPool instance;
+        return instance;
+    }
+};
+
+// RAII helper for automatic buffer management
+class BufferGuard {
+private:
+    uint8_t* ptr;
+    size_t size;
+
+public:
+    BufferGuard(size_t size) : size(size) {
+        ptr = BufferPool::getInstance().allocate(size);
+    }
+    ~BufferGuard() {
+        BufferPool::getInstance().deallocate(ptr, size);
+    }
+    uint8_t* get() { return ptr; }
+    operator uint8_t*() { return ptr; }
+};
+
+bool NV21ToRGB24(const uint8_t* nv21, int width, int height, uint8_t* dst_rgb) {
+    if (!nv21 || !dst_rgb || width <= 0 || height <= 0) return false;
+
+    // libyuv doesn't always provide a single-step NV21->RGB24, so convert via I420.
+    int y_size = width * height;
+    int i420_u_size = (width/2) * (height/2);
+
+    BufferGuard i420_y_guard(y_size);
+    BufferGuard i420_u_guard(i420_u_size);
+    BufferGuard i420_v_guard(i420_u_size);
+    
+    uint8_t* i420_y = i420_y_guard.get();
+    uint8_t* i420_u = i420_u_guard.get();
+    uint8_t* i420_v = i420_v_guard.get();
+
+    if (!i420_y || !i420_u || !i420_v) {
+        return false;
+    }
+
+    // NV21: Y plane, then interleaved VU (V first)
+    const uint8_t* src_y = nv21;
+    const uint8_t* src_vu = nv21 + y_size;
+
+    int res = libyuv::NV21ToI420(src_y, width,
+                                 src_vu, width,
+                                 i420_y, width,
+                                 i420_u, width/2,
+                                 i420_v, width/2,
+                                 width, height);
+
+    if (res != 0) {
+        return false;
+    }
+
+    // Convert I420 -> ARGB (libyuv provides I420ToARGB with NEON), then strip alpha to RGB24
+    int pixel_count = width * height;
+    
+    BufferGuard tmp_argb_guard(pixel_count * 4);
+    uint8_t* tmp_argb = tmp_argb_guard.get();
+    if (!tmp_argb) { return false; }
+
+    res = libyuv::I420ToARGB(i420_y, width,
+                             i420_u, width/2,
+                             i420_v, width/2,
+                             tmp_argb, width * 4,
+                             width, height);
+    if (res == 0) {
+        // Strip alpha - vectorized by compiler with -O3
+        for (int i = 0; i < pixel_count; ++i) {
+            dst_rgb[i*3 + 0] = tmp_argb[i*4 + 1];
+            dst_rgb[i*3 + 1] = tmp_argb[i*4 + 2];
+            dst_rgb[i*3 + 2] = tmp_argb[i*4 + 3];
+        }
+    }
+
+    return res == 0;
+}
+
+bool NV21ToARGB(const uint8_t* nv21, int width, int height, uint8_t* dst_argb) {
+    if (!nv21 || !dst_argb || width <= 0 || height <= 0) return false;
+
+    int y_size = width * height;
+    int uv_size = (width/2) * (height/2);
+    
+    // Use buffer pool for I420 intermediate buffers
+    BufferGuard i420_y_guard(y_size);
+    BufferGuard i420_u_guard(uv_size);
+    BufferGuard i420_v_guard(uv_size);
+    
+    uint8_t* i420_y = i420_y_guard.get();
+    uint8_t* i420_u = i420_u_guard.get();
+    uint8_t* i420_v = i420_v_guard.get();
+    
+    if (!i420_y || !i420_u || !i420_v) { return false; }
+
+    const uint8_t* src_y = nv21;
+    const uint8_t* src_vu = nv21 + y_size;
+
+    // libyuv handles NEON/SIMD optimizations internally on ARM
+    int res = libyuv::NV21ToI420(src_y, width,
+                                 src_vu, width,
+                                 i420_y, width,
+                                 i420_u, width/2,
+                                 i420_v, width/2,
+                                 width, height);
+
+    if (res != 0) { return false; }
+
+    // Fast NEON-optimized I420 to ARGB conversion
+    res = libyuv::I420ToARGB(i420_y, width,
+                             i420_u, width/2,
+                             i420_v, width/2,
+                             dst_argb, width * 4,
+                             width, height);
+
+    return res == 0;
+}
+
+bool NV21ToBGR24(const uint8_t* nv21, int width, int height, uint8_t* dst_bgr) {
+    // Convert to RGB24 then swap channels with SIMD-friendly loop
+    if (!nv21 || !dst_bgr) return false;
+    int pixel_count = width * height;
+    
+    BufferGuard tmp_guard(pixel_count * 3);
+    uint8_t* tmp = tmp_guard.get();
+    if (!tmp) return false;
+    
+    bool ok = NV21ToRGB24(nv21, width, height, tmp);
+    if (!ok) { return false; }
+    
+    // Swap R<->B with vectorizable loop
+    for (int i = 0; i < pixel_count; ++i) {
+        dst_bgr[i*3 + 0] = tmp[i*3 + 2];
+        dst_bgr[i*3 + 1] = tmp[i*3 + 1];
+        dst_bgr[i*3 + 2] = tmp[i*3 + 0];
+    }
+    return true;
+}
+
+bool NV21ToARGBResize(const uint8_t* nv21, int src_w, int src_h, uint8_t* dst_argb, int dst_w, int dst_h) {
+    if (!nv21 || !dst_argb || src_w <= 0 || src_h <= 0 || dst_w <= 0 || dst_h <= 0) return false;
+
+    int src_y_size = src_w * src_h;
+    int src_uv_size = (src_w/2) * (src_h/2);
+    
+    BufferGuard i420_y_guard(src_y_size);
+    BufferGuard i420_u_guard(src_uv_size);
+    BufferGuard i420_v_guard(src_uv_size);
+    
+    uint8_t* i420_y = i420_y_guard.get();
+    uint8_t* i420_u = i420_u_guard.get();
+    uint8_t* i420_v = i420_v_guard.get();
+    
+    if (!i420_y || !i420_u || !i420_v) { return false; }
+
+    const uint8_t* src_y = nv21;
+    const uint8_t* src_vu = nv21 + src_y_size;
+
+    int res = libyuv::NV21ToI420(src_y, src_w,
+                                 src_vu, src_w,
+                                 i420_y, src_w,
+                                 i420_u, src_w/2,
+                                 i420_v, src_w/2,
+                                 src_w, src_h);
+    if (res != 0) { return false; }
+
+    // Allocate scaled I420
+    int dst_y_size = dst_w * dst_h;
+    int dst_uv_size = (dst_w/2)*(dst_h/2);
+    
+    BufferGuard dst_y_guard(dst_y_size);
+    BufferGuard dst_u_guard(dst_uv_size);
+    BufferGuard dst_v_guard(dst_uv_size);
+    
+    uint8_t* dst_y = dst_y_guard.get();
+    uint8_t* dst_u = dst_u_guard.get();
+    uint8_t* dst_v = dst_v_guard.get();
+    
+    if (!dst_y || !dst_u || !dst_v) { return false; }
+
+    // libyuv scale uses NEON/SIMD internally
+    res = libyuv::I420Scale(i420_y, src_w,
+                           i420_u, src_w/2,
+                           i420_v, src_w/2,
+                           src_w, src_h,
+                           dst_y, dst_w,
+                           dst_u, dst_w/2,
+                           dst_v, dst_w/2,
+                           dst_w, dst_h,
+                           libyuv::kFilterBox);
+
+    if (res != 0) { return false; }
+
+    // Convert scaled I420 to ARGB with NEON acceleration
+    res = libyuv::I420ToARGB(dst_y, dst_w,
+                             dst_u, dst_w/2,
+                             dst_v, dst_w/2,
+                             dst_argb, dst_w * 4,
+                             dst_w, dst_h);
+
+    return res == 0;
+}
+
+bool NV21ToARGBRotate(const uint8_t* nv21, int src_w, int src_h, uint8_t* dst_argb, int rotation) {
+    if (!nv21 || !dst_argb) return false;
+    // rotation must be 0/90/180/270
+    int rot = rotation % 360;
+    if (rot < 0) rot += 360;
+    if (rot % 90 != 0) return false;
+
+    int y_size = src_w * src_h;
+    int uv_size = (src_w/2)*(src_h/2);
+    
+    BufferGuard i420_y_guard(y_size);
+    BufferGuard i420_u_guard(uv_size);
+    BufferGuard i420_v_guard(uv_size);
+    
+    uint8_t* i420_y = i420_y_guard.get();
+    uint8_t* i420_u = i420_u_guard.get();
+    uint8_t* i420_v = i420_v_guard.get();
+    
+    if (!i420_y || !i420_u || !i420_v) { return false; }
+
+    const uint8_t* src_y = nv21;
+    const uint8_t* src_vu = nv21 + y_size;
+
+    int res = libyuv::NV21ToI420(src_y, src_w,
+                                 src_vu, src_w,
+                                 i420_y, src_w,
+                                 i420_u, src_w/2,
+                                 i420_v, src_w/2,
+                                 src_w, src_h);
+    if (res != 0) { return false; }
+
+    // Rotate I420
+    int dst_w = (rot == 90 || rot == 270) ? src_h : src_w;
+    int dst_h = (rot == 90 || rot == 270) ? src_w : src_h;
+
+    int dst_y_size = dst_w * dst_h;
+    int dst_uv_size = (dst_w/2)*(dst_h/2);
+    
+    BufferGuard ry_guard(dst_y_size);
+    BufferGuard ru_guard(dst_uv_size);
+    BufferGuard rv_guard(dst_uv_size);
+    
+    uint8_t* ry = ry_guard.get();
+    uint8_t* ru = ru_guard.get();
+    uint8_t* rv = rv_guard.get();
+    
+    if (!ry || !ru || !rv) { return false; }
+
+    libyuv::RotationMode mode = libyuv::kRotate0;
+    switch (rot) {
+        case 0: mode = libyuv::kRotate0; break;
+        case 90: mode = libyuv::kRotate90; break;
+        case 180: mode = libyuv::kRotate180; break;
+        case 270: mode = libyuv::kRotate270; break;
+    }
+
+    // I420Rotate uses NEON on ARM
+    res = libyuv::I420Rotate(i420_y, src_w,
+                             i420_u, src_w/2,
+                             i420_v, src_w/2,
+                             ry, dst_w,
+                             ru, dst_w/2,
+                             rv, dst_w/2,
+                             src_w, src_h,
+                             mode);
+
+    if (res != 0) { return false; }
+
+    // Convert rotated I420 to ARGB with NEON acceleration
+    res = libyuv::I420ToARGB(ry, dst_w,
+                             ru, dst_w/2,
+                             rv, dst_w/2,
+                             dst_argb, dst_w * 4,
+                             dst_w, dst_h);
+
+    return res == 0;
+}
+
+} // namespace fastyuv

package/android/src/main/cpp/fast_yuv.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <stdint.h>
+
+// Lightweight helpers using libyuv. Implemented in fast_yuv.cpp.
+namespace fastyuv {
+
+// Convert NV21 (YUV420sp) to 3-channel RGB (RGB24). Returns true on success.
+bool NV21ToRGB24(const uint8_t* nv21, int width, int height, uint8_t* dst_rgb);
+
+// Convert NV21 to ARGB (4 bytes per pixel, order A,R,G,B)
+bool NV21ToARGB(const uint8_t* nv21, int width, int height, uint8_t* dst_argb);
+
+// Convert NV21 to BGR24
+bool NV21ToBGR24(const uint8_t* nv21, int width, int height, uint8_t* dst_bgr);
+
+// Resize NV21 -> ARGB with scaling to dst_w x dst_h
+bool NV21ToARGBResize(const uint8_t* nv21, int src_w, int src_h, uint8_t* dst_argb, int dst_w, int dst_h);
+
+// Rotate NV21 to ARGB with rotation 0/90/180/270
+bool NV21ToARGBRotate(const uint8_t* nv21, int src_w, int src_h, uint8_t* dst_argb, int rotation);
+
+} // namespace fastyuv

package/android/src/main/cpp/libyuv/.clang-format

@@ -0,0 +1,6 @@
+# Defines the Chromium style for automatic reformatting.
+# http://clang.llvm.org/docs/ClangFormatStyleOptions.html
+BasedOnStyle: Chromium
+---
+Language: Java
+BasedOnStyle: Google

package/android/src/main/cpp/libyuv/.gn

@@ -0,0 +1,40 @@
+# Copyright 2015 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.
+
+import("//build/dotfile_settings.gni")
+
+# The location of the build configuration file.
+buildconfig = "//build/config/BUILDCONFIG.gn"
+
+# The python interpreter to use by default. On Windows, this will look
+# for python3.exe and python3.bat.
+script_executable = "python3"
+
+# The secondary source root is a parallel directory tree where
+# GN build files are placed when they can not be placed directly
+# in the source tree, e.g. for third party source trees.
+secondary_source = "//build/secondary/"
+
+# These are the targets to check headers for by default. The files in targets
+# matching these patterns (see "gn help label_pattern" for format) will have
+# their includes checked for proper dependencies when you run either
+# "gn check" or "gn gen --check".
+check_targets = [ "//libyuv/*" ]
+
+# These are the list of GN files that run exec_script. This allowlist exists
+# to force additional review for new uses of exec_script, which is strongly
+# discouraged except for gypi_to_gn calls.
+exec_script_allowlist = build_dotfile_settings.exec_script_allowlist +
+                        [ "//build_overrides/build.gni" ]
+
+default_args = {
+  mac_sdk_min = "10.12"
+  ios_deployment_target = "12.0"
+  # Use Siso instead of Ninja.
+  use_siso = true
+}