react-native-yolo 0.0.7 → 0.0.8

package/Yolo.podspec

@@ -27,5 +27,8 @@ Pod::Spec.new do |s|
 
   s.dependency 'React-jsi'
   s.dependency 'React-callinvoker'
+  s.dependency 'VisionCamera'
+  s.dependency 'TensorFlowLiteSwift'
+  
   install_modules_dependencies(s)
 end

package/android/src/main/java/com/yolo/HybridYoloModel.kt

@@ -11,6 +11,7 @@ import org.tensorflow.lite.DataType
 import org.tensorflow.lite.Interpreter
 import yolo.com.loader.YoloModelLoader
 import kotlin.math.roundToInt
+import com.margelo.nitro.camera.CameraOrientation
 
 class HybridYoloModel(
     modelPath: String
@@ -158,8 +159,15 @@ class HybridYoloModel(
 
         for (dy in 0 until dstHeight) {
             for (dx in 0 until dstWidth) {
-                val srcX = dy * srcWidth / dstHeight
-                val srcY = srcHeight - 1 - (dx * srcHeight / dstWidth)
+                val (srcX, srcY) = mapModelPixelToFramePixel(
+                    dx = dx,
+                    dy = dy,
+                    dstWidth = dstWidth,
+                    dstHeight = dstHeight,
+                    srcWidth = srcWidth,
+                    srcHeight = srcHeight,
+                    orientation = frame.orientation
+                )
 
                 val yIndex = srcY * yRowStride + srcX
 
@@ -209,4 +217,43 @@ class HybridYoloModel(
 
         input.rewind()
     }
+
+    private fun mapModelPixelToFramePixel(
+        dx: Int,
+        dy: Int,
+        dstWidth: Int,
+        dstHeight: Int,
+        srcWidth: Int,
+        srcHeight: Int,
+        orientation: CameraOrientation
+    ): Pair<Int, Int> {
+        val nx = dx.toFloat() / dstWidth
+        val ny = dy.toFloat() / dstHeight
+
+        return when (orientation) {
+            CameraOrientation.UP -> {
+                val srcX = (nx * srcWidth).toInt()
+                val srcY = (ny * srcHeight).toInt()
+                srcX.coerceIn(0, srcWidth - 1) to srcY.coerceIn(0, srcHeight - 1)
+            }
+
+            CameraOrientation.DOWN -> {
+                val srcX = ((1f - nx) * srcWidth).toInt()
+                val srcY = ((1f - ny) * srcHeight).toInt()
+                srcX.coerceIn(0, srcWidth - 1) to srcY.coerceIn(0, srcHeight - 1)
+            }
+
+            CameraOrientation.LEFT -> {
+                val srcX = (ny * srcWidth).toInt()
+                val srcY = ((1f - nx) * srcHeight).toInt()
+                srcX.coerceIn(0, srcWidth - 1) to srcY.coerceIn(0, srcHeight - 1)
+            }
+
+            CameraOrientation.RIGHT -> {
+                val srcX = ((1f - ny) * srcWidth).toInt()
+                val srcY = (nx * srcHeight).toInt()
+                srcX.coerceIn(0, srcWidth - 1) to srcY.coerceIn(0, srcHeight - 1)
+            }
+        }
+    }
 }

package/ios/HybridYolo.swift

@@ -1,14 +1,56 @@
-//
-//  HybridYolo.swift
-//  Pods
-//
-//  Created by Khaoula-Ghalimi on 22/06/2026.
-//
-
 import Foundation
+import NitroModules
+import VisionCamera
 
-class HybridYolo: HybridYoloSpec {
-    func sum(num1: Double, num2: Double) throws -> Double {
-        return num1 + num2
+public class HybridYolo: HybridYoloSpec {
+    private static let tag = "YOLO_TAG"
+    
+    // Initialisateur obligatoire pour les modules Nitro
+    public required init() {
+        super.init()
+    }
+    
+    /**
+     * Charge l'objet modèle YOLO spécifié par son chemin.
+     * Implémente la méthode obligatoire du protocole Nitro TypeScript.
+     */
+    public override func loadModel(modelPath: String) throws -> any HybridYoloModelSpec {
+        NSLog("[%@]: Trying to load model object: %@", HybridYolo.tag, modelPath)
+        
+        // Initialise et retourne votre sous-classe de modèle Nitro (assurez-vous qu'elle s'appelle bien HybridYoloModel)
+        return try HybridYoloModel(modelPath: modelPath)
+    }
+    
+    /**
+     * Valide un Frame de la caméra, le convertit en JPEG permanent (NV12 -> JPEG -> Fix Rotation),
+     * puis l'encode instantanément en chaîne de caractères Base64 standard.
+     */
+    public override func frameToBase64(frame: any HybridFrameSpec) throws -> String {
+        NSLog("[%@]: Trying to convert frame to base64", HybridYolo.tag)
+        
+        do {
+            // 1. Validation du buffer vidéo via notre validateur adapté à iOS (NV12 à 2 plans minimum)
+            guard FrameValidator.isValidYuv(frame: frame) else {
+                return ""
+            }
+            NSLog("[%@]: frameToBase64: frame is valid YUV", HybridYolo.tag)
+            
+            // 2. Traitement complet de l'image (Conversion NV12 -> Encodage GPU JPEG -> Rendu de sécurité)
+            let jpegBytes = FrameJpegConverter.toJpegBytes(frame: frame, quality: 80)
+            
+            guard !jpegBytes.isEmpty else {
+                NSLog("[%@]: ❌ frameToBase64 failed: converted JPEG bytes array is empty", HybridYolo.tag)
+                return ""
+            }
+            NSLog("[%@]: frameToBase64: jpegBytes size: %d bytes", HybridYolo.tag, jpegBytes.count)
+            
+            // 3. Encapsulation dans un conteneur Data pour un encodage Base64 matériel (sans sauts de ligne, équivalent de NO_WRAP)
+            let data = Data(jpegBytes)
+            return data.base64EncodedString(options: [])
+            
+        } catch {
+            NSLog("[%@]: ❌ frameToBase64 failed: %@", HybridYolo.tag, error.localizedDescription)
+            return ""
+        }
     }
 }

package/ios/HybridYoloModel.swift

@@ -0,0 +1,250 @@
+import Foundation
+import NitroModules
+import TensorFlowLite
+import VisionCamera
+import CoreVideo
+
+public class HybridYoloModel: HybridYoloModelSpec {
+    private static let tag = "YOLO_MODEL_TAG"
+    
+    private let modelLoader = YoloModelLoader()
+    
+    private var interpreter: Interpreter? = nil
+    private var inputBuffer: Data? = nil
+    private var inputWidth = 0
+    private var inputHeight = 0
+    private var inputDataType: Tensor.DataType? = nil
+    
+    private let threadLock = NSLock()
+    
+    public required init(modelPath: String) throws {
+        super.init()
+        try load(modelPath: modelPath)
+    }
+    
+    private func load(modelPath: String) throws {
+        do {
+            let modelData = try modelLoader.load(modelPath: modelPath)
+            
+            // Initialisation de l'interpréteur TensorFlowLiteSwift
+            interpreter = try Interpreter(modelData: modelData)
+            guard let localInterpreter = interpreter else { return }
+            
+            try localInterpreter.allocateTensors()
+            
+            let inputTensor = try localInterpreter.inputTensor(at: 0)
+            let outputTensor = try localInterpreter.outputTensor(at: 0)
+            
+            let shape = inputTensor.shape.dimensions
+            
+            inputHeight = shape[1]
+            inputWidth = shape[2]
+            inputDataType = inputTensor.dataType
+            inputBuffer = try modelLoader.makeInputBuffer(interpreter: localInterpreter)
+            
+            NSLog("[%@]: ✅ YOLO model instance loaded", HybridYoloModel.tag)
+            NSLog("[%@]: 📥 Input shape: %@", HybridYoloModel.tag, shape.description)
+            NSLog("[%@]: 📤 Output shape: %@", HybridYoloModel.tag, outputTensor.shape.dimensions.description)
+        } catch {
+            NSLog("[%@]: ❌ Failed to load model instance: %@", HybridYoloModel.tag, error.localizedDescription)
+            throw error
+        }
+    }
+    
+    public override func detect(frame: any HybridFrameSpec) throws -> [Detection] {
+        guard let localInterpreter = interpreter else {
+            NSLog("[%@]: ❌ This model instance is not loaded.", HybridYoloModel.tag)
+            return []
+        }
+        
+        guard FrameValidator.isValidYuv(frame: frame) else {
+            NSLog("[%@]: ❌ Invalid frame provided for detection.", HybridYoloModel.tag)
+            return []
+        }
+        
+        guard var input = inputBuffer else { return [] }
+        
+        threadLock.lock()
+        defer { threadLock.unlock() }
+        
+        // Remplissage du buffer d'entrée en analysant les données NV12
+        try fillInputFromYuvFrame(
+            frame: frame,
+            input: &input,
+            dstWidth: inputWidth,
+            dstHeight: inputHeight,
+            dataType: inputDataType ?? .float32
+        )
+        
+        // Injection du tampon de données brut dans le tenseur d'entrée
+        try localInterpreter.copy(input, toInputAt: 0)
+        try localInterpreter.invoke()
+        
+        // Récupération des résultats du tenseur de sortie
+        let outputTensor = try localInterpreter.outputTensor(at: 0)
+        
+        // Extraction et conversion de la structure des tenseurs [1, 300, 6] en Float
+        let nativeOutputs = outputTensor.data.withUnsafeBytes { (ptr: UnsafeRawBufferPointer) -> [Float] in
+            let floatPtr = ptr.assumingMemoryBound(to: Float.self)
+            return Array(floatPtr)
+        }
+        
+        return parseNmsOutput(outputArray: nativeOutputs, confidenceThreshold: 0.5)
+    }
+    
+    public override func close() throws {
+        interpreter = nil
+        inputBuffer = nil
+        NSLog("[%@]: 🧹 YOLO model disposed", HybridYoloModel.tag)
+    }
+    
+    private func parseNmsOutput(outputArray: [Float], confidenceThreshold: Float = 0.5) -> [Detection] {
+        var detections: [Detection] = []
+        
+        let totalRows = 300
+        let columnsPerRow = 6
+        
+        // Parcours du tableau aplati [300 * 6]
+        for i in 0..<totalRows {
+            let offset = i * columnsPerRow
+            guard offset + 5 < outputArray.count else { break }
+            
+            let score = outputArray[offset + 4]
+            if score < confidenceThreshold { continue }
+            
+            let box = BoundingBox(
+                x1: Double(outputArray[offset + 0]),
+                y1: Double(outputArray[offset + 1]),
+                x2: Double(outputArray[offset + 2]),
+                y2: Double(outputArray[offset + 3])
+            )
+            
+            detections.append(
+                Detection(
+                    boundingBox: box,
+                    score: Double(score),
+                    classId: Double(outputArray[offset + 5])
+                )
+            )
+        }
+        
+        return detections
+    }
+    
+    private func fillInputFromYuvFrame(
+        frame: any HybridFrameSpec,
+        input: inout Data,
+        dstWidth: Int,
+        dstHeight: Int,
+        dataType: Tensor.DataType
+    ) throws {
+        let srcWidth = Int(frame.width)
+        let srcHeight = Int(frame.height)
+        
+        // Extraction du CVPixelBuffer matériel pour un accès direct ultra-rapide
+        let nativeBuffer = try frame.getNativeBuffer()
+        guard let rawPointer = nativeBuffer.pointer else { return }
+        let pixelBuffer = Unmanaged<CVPixelBuffer>.fromOpaque(rawPointer).takeUnretainedValue()
+        
+        CVPixelBufferLockBaseAddress(pixelBuffer, .readOnly)
+        defer { CVPixelBufferUnlockBaseAddress(pixelBuffer, .readOnly) }
+        
+        guard let yBaseAddress = CVPixelBufferGetBaseAddressOfPlane(pixelBuffer, 0),
+              let uvBaseAddress = CVPixelBufferGetBaseAddressOfPlane(pixelBuffer, 1) else { return }
+        
+        let yRowStride = CVPixelBufferGetBytesPerRowOfPlane(pixelBuffer, 0)
+        let uvRowStride = CVPixelBufferGetBytesPerRowOfPlane(pixelBuffer, 1)
+        
+        let yPtr = yBaseAddress.assumingMemoryBound(to: UInt8.self)
+        let uvPtr = uvBaseAddress.assumingMemoryBound(to: UInt8.self)
+        
+        // Allocation du flux d'écriture en octets
+        var bytes: [UInt8] = []
+        bytes.reserveCapacity(input.count)
+        
+        for dy in 0..<dstHeight {
+            for dx in 0..<dstWidth {
+                let (srcX, srcY) = mapModelPixelToFramePixel(
+                    dx: dx, dy: dy,
+                    dstWidth: dstWidth, dstHeight: dstHeight,
+                    srcWidth: srcWidth, srcHeight: srcHeight,
+                    orientation: frame.orientation
+                )
+                
+                let yIndex = srcY * yRowStride + srcX
+                
+                // NV12 : Les composants U et V sont regroupés au même endroit (U, V, U, V)
+                // L'indice de ligne utilise uvRowStride. Chaque pixel partagé saute de 2 en 2 horizontalement.
+                let uvY = srcY / 2
+                let uvX = srcX / 2
+                let uvIndex = uvY * uvRowStride + uvX * 2
+                
+                let y = Int(yPtr[yIndex])
+                let u = Int(uvPtr[uvIndex])     // Dans NV12, U se trouve au premier octet
+                let v = Int(uvPtr[uvIndex + 1]) // V se trouve juste à côté
+                
+                // Formule standard de conversion YUV en RGB
+                let rFloat = Float(y) + 1.402 * Float(v - 128)
+                let gFloat = Float(y) - 0.344136 * Float(u - 128) - 0.714136 * Float(v - 128)
+                let bFloat = Float(y) + 1.772 * Float(u - 128)
+                
+                let r = Int(rFloat.rounded()).clamped(to: 0...255)
+                let g = Int(gFloat.rounded()).clamped(to: 0...255)
+                let b = Int(bFloat.rounded()).clamped(to: 0...255)
+                
+                if dataType == .float32 {
+                    let rNorm = Float(r) / 255.0
+                    let gNorm = Float(g) / 255.0
+                    let bNorm = Float(b) / 255.0
+                    
+                    withUnsafeBytes(of: rNorm) { bytes.append(contentsOf: $0) }
+                    withUnsafeBytes(of: gNorm) { bytes.append(contentsOf: $0) }
+                    withUnsafeBytes(of: bNorm) { bytes.append(contentsOf: $0) }
+                } else {
+                    bytes.append(UInt8(r))
+                    bytes.append(UInt8(g))
+                    bytes.append(UInt8(b))
+                }
+            }
+        }
+        
+        // Copie globale du flux binaire structuré dans l'espace mémoire d'entrée
+        input.withUnsafeMutableBytes { dstPtr in
+            bytes.withUnsafeBytes { srcPtr in
+                dstPtr.copyBytes(from: srcPtr)
+            }
+        }
+    }
+    
+    private func mapModelPixelToFramePixel(
+        dx: Int, dy: Int,
+        dstWidth: Int, dstHeight: Int,
+        srcWidth: Int, srcHeight: Int,
+        orientation: CameraOrientation
+    ) -> (x: Int, y: Int) {
+        let nx = Float(dx) / Float(dstWidth)
+        let ny = Float(dy) / Float(dstHeight)
+        
+        switch orientation {
+        case .up:
+            let sx = Int(nx * Float(srcWidth))
+            let sy = Int(ny * Float(srcHeight))
+            return (sx.clamped(to: 0...(srcWidth - 1)), sy.clamped(to: 0...(srcHeight - 1)))
+        case .down:
+            let sx = Int((1.0 - nx) * Float(srcWidth))
+            let sy = Int((1.0 - ny) * Float(srcHeight))
+            return (sx.clamped(to: 0...(srcWidth - 1)), sy.clamped(to: 0...(srcHeight - 1)))
+        case .left:
+            let sx = Int(ny * Float(srcWidth))
+            let sy = Int((1.0 - nx) * Float(srcHeight))
+            return (sx.clamped(to: 0...(srcWidth - 1)), sy.clamped(to: 0...(srcHeight - 1)))
+        case .right:
+            let sx = Int((1.0 - ny) * Float(srcWidth))
+            let sy = Int(nx * Float(srcHeight))
+            return (sx.clamped(to: 0...(srcWidth - 1)), sy.clamped(to: 0...(srcHeight - 1)))
+        @unknown default:
+            return (0, 0)
+        }
+    }
+}
+

package/ios/Loader/YoloModelLoader.swift

@@ -0,0 +1,139 @@
+import Foundation
+import NitroModules
+import TensorFlowLite // Activé via votre s.dependency 'TensorFlowLiteSwift'
+
+public class YoloModelLoader {
+    private static let tag = "YOLO_TAG_LOADER"
+    
+    public init() {}
+    
+    /**
+     * Charge un modèle YOLO à partir du chemin spécifié (URL, URI de fichier, chemin absolu, ou ressource brute).
+     * Retourne un objet `Data` contenant les octets du modèle configurés via mmap (équivalent du MappedByteBuffer).
+     */
+    public func load(modelPath: String) throws -> Data {
+        if modelPath.hasPrefix("http://") || modelPath.hasPrefix("https://") {
+            NSLog("[%@]: Loading model from URL", YoloModelLoader.tag)
+            let cachedFileURL = try downloadToCache(urlString: modelPath)
+            return try mapFile(fileURL: cachedFileURL)
+            
+        } else if modelPath.hasPrefix("file://") {
+            NSLog("[%@]: Loading model from file URI", YoloModelLoader.tag)
+            guard let url = URL(string: modelPath) else {
+                throw NSError(domain: "YoloModelLoader", code: 400, userInfo: [NSLocalizedDescriptionKey: "Invalid file URI"])
+            }
+            return try mapFile(fileURL: url)
+            
+        } else if modelPath.hasPrefix("/") {
+            NSLog("[%@]: Loading model from absolute path", YoloModelLoader.tag)
+            let url = URL(fileURLWithPath: modelPath)
+            return try mapFile(fileURL: url)
+            
+        } else if modelPath.hasPrefix("assets_") {
+            NSLog("[%@]: Loading model from RN raw resource", YoloModelLoader.tag)
+            let cachedFileURL = try copyRawResourceToCache(resourceName: modelPath)
+            return try mapFile(fileURL: cachedFileURL)
+            
+        } else {
+            NSLog("[%@]: Loading model from Main App Bundle Assets", YoloModelLoader.tag)
+            let cleanName = modelPath.replacingOccurrences(of: ".tflite", with: "")
+            guard let bundleURL = ContextProvider.mainBundle.url(forResource: cleanName, withExtension: "tflite") else {
+                throw NSError(domain: "YoloModelLoader", code: 404, userInfo: [NSLocalizedDescriptionKey: "Model not found in main bundle: \(modelPath)"])
+            }
+            return try mapFile(fileURL: bundleURL)
+        }
+    }
+    
+    private func copyRawResourceToCache(resourceName: String) throws -> URL {
+        guard let bundleURL = ContextProvider.mainBundle.url(forResource: resourceName, withExtension: "tflite") else {
+            throw NSError(domain: "YoloModelLoader", code: 404, userInfo: [NSLocalizedDescriptionKey: "Raw resource not found: \(resourceName)"])
+        }
+        
+        let destinationURL = ContextProvider.cacheDirectory.appendingPathComponent("\(resourceName).tflite")
+        
+        if FileManager.default.fileExists(atPath: destinationURL.path) {
+            try? FileManager.default.removeItem(at: destinationURL)
+        }
+        
+        try FileManager.default.copyItem(at: bundleURL, to: destinationURL)
+        
+        let attributes = try FileManager.default.attributesOfItem(atPath: destinationURL.path)
+        let fileSize = attributes[.size] as? Int64 ?? 0
+        
+        NSLog("[%@]: Copied raw resource to: %@", YoloModelLoader.tag, destinationURL.path)
+        NSLog("[%@]: Copied raw resource size: %lld bytes", YoloModelLoader.tag, fileSize)
+        
+        return destinationURL
+    }
+    
+    private func mapFile(fileURL: URL) throws -> Data {
+        let path = fileURL.path
+        if !FileManager.default.fileExists(atPath: path) {
+            throw NSError(domain: "YoloModelLoader", code: 404, userInfo: [NSLocalizedDescriptionKey: "Model file does not exist: \(path)"])
+        }
+        
+        let attributes = try FileManager.default.attributesOfItem(atPath: path)
+        let fileSize = attributes[.size] as? Int64 ?? 0
+        
+        if fileSize <= 0 {
+            throw NSError(domain: "YoloModelLoader", code: 400, userInfo: [NSLocalizedDescriptionKey: "Model file is empty: \(path)"])
+        }
+        
+        // .alwaysMapped utilise mmap au niveau du noyau iOS pour des performances instantanées (Zero CPU copy)
+        return try Data(contentsOf: fileURL, options: .alwaysMapped)
+    }
+    
+    private func downloadToCache(urlString: String) throws -> URL {
+        guard let url = URL(string: urlString) else {
+            throw NSError(domain: "YoloModelLoader", code: 400, userInfo: [NSLocalizedDescriptionKey: "Malformed URL"])
+        }
+        
+        let destinationURL = ContextProvider.cacheDirectory.appendingPathComponent("yolo_model.tflite")
+        let modelData = try Data(contentsOf: url)
+        try modelData.write(to: destinationURL, options: .atomic)
+        
+        NSLog("[%@]: Downloaded model to: %@", YoloModelLoader.tag, destinationURL.path)
+        NSLog("[%@]: Downloaded model size: %d bytes", YoloModelLoader.tag, modelData.count)
+        
+        return destinationURL
+    }
+    
+    /**
+     * Alloue un tampon d'entrée brut ('Data') calibré sur les dimensions du tenseur d'entrée du modèle.
+     * Remplace parfaitement Direct ByteBuffer de Java.
+     */
+    public func makeInputBuffer(interpreter: Interpreter) throws -> Data {
+        // Récupérer le premier tenseur d'entrée du modèle TFLite
+        let inputTensor = try interpreter.inputTensor(at: 0)
+        let shape = inputTensor.shape.dimensions // Généralement: [1, 640, 640, 3]
+        let dataType = inputTensor.dataType
+        
+        let batch = shape[0]
+        let height = shape[1]
+        let width = shape[2]
+        let channels = shape[3]
+        
+        // Vérifications strictes (équivalents de require() en Kotlin)
+        guard batch == 1 else {
+            fatalError("YOLO Input Violation: Batch size must be 1")
+        }
+        guard channels == 3 else {
+            fatalError("YOLO Input Violation: Channels count must be 3 (RGB)")
+        }
+        
+        let bytesPerValue: Int
+        switch dataType {
+        case .float32:
+            bytesPerValue = 4
+        case .uInt8:
+            bytesPerValue = 1
+        default:
+            fatalError("Unsupported input type: \(dataType)")
+        }
+        
+        let totalBytes = batch * width * height * channels * bytesPerValue
+        
+        // Crée une structure Data Swift vide avec l'empreinte mémoire exacte
+        return Data(repeating: 0, count: totalBytes)
+    }
+}

package/ios/Utils/BitmapOrientationFixer.swift

@@ -0,0 +1,64 @@
+import Foundation
+import UIKit
+import NitroModules
+import VisionCamera
+
+public enum BitmapOrientationFixer {
+    public static func fix(
+        jpegBytes: [UInt8],
+        frame: any HybridFrameSpec,
+        quality: Int
+    ) -> [UInt8] {
+
+        let data = Data(jpegBytes)
+        guard let image = UIImage(data: data),
+              let cgImage = image.cgImage
+        else {
+            return jpegBytes
+        }
+
+        let uiOrientation: UIImage.Orientation
+
+        switch frame.orientation {
+        case .up:
+            uiOrientation = frame.isMirrored ? .upMirrored : .up
+        case .down:
+            uiOrientation = frame.isMirrored ? .downMirrored : .down
+        case .left:
+            uiOrientation = frame.isMirrored ? .leftMirrored : .left
+        case .right:
+            uiOrientation = frame.isMirrored ? .rightMirrored : .right
+        @unknown default:
+            uiOrientation = .up
+        }
+
+        // 1. Wrap the image with the correct EXIF layout metadata
+        let orientedImage = UIImage(
+            cgImage: cgImage,
+            scale: 1.0, // Force 1.0 to preserve raw camera matrix resolution
+            orientation: uiOrientation
+        )
+
+        // 2. Configure a 1:1 hardware pixel canvas context format
+        let rendererFormat = UIGraphicsImageRendererFormat.default()
+        rendererFormat.scale = 1.0
+        rendererFormat.opaque = true // JPEG does not support transparency, making it opaque saves memory performance
+
+        // 3. Draw and physically bake the metadata rotation permanently into new pixel bytes
+        let bakedImage = UIGraphicsImageRenderer(
+            size: orientedImage.size,
+            format: rendererFormat
+        ).image { _ in
+            orientedImage.draw(in: CGRect(origin: .zero, size: orientedImage.size))
+        }
+
+        let compressionQuality = CGFloat(max(0, min(quality, 100))) / 100.0
+
+        // 4. Compress the baked image. The metadata flag is now gone, and the pixels themselves are rotated.
+        guard let outputData = bakedImage.jpegData(compressionQuality: compressionQuality) else {
+            return jpegBytes
+        }
+
+        return [UInt8](outputData)
+    }
+}

package/ios/Utils/ContextProvider.swift

@@ -0,0 +1,45 @@
+import Foundation
+import UIKit
+import NitroModules
+
+/**
+ * Provides a way to access application-wide singletons and paths from anywhere in the app.
+ * This acts as the iOS equivalent to the Android ContextProvider.
+ */
+public enum ContextProvider {
+    
+    /// Returns the main application instance (equivalent to Application instance)
+    public static var sharedApplication: UIApplication {
+        // Must be accessed on the main thread
+        if Thread.isMainThread {
+            return UIApplication.shared
+        } else {
+            var app: UIApplication!
+            DispatchQueue.main.sync {
+                app = UIApplication.shared
+            }
+            return app
+        }
+    }
+    
+    /// Returns the main bundle containing application assets (equivalent to context.resources)
+    public static var mainBundle: Bundle {
+        return Bundle.main
+    }
+    
+    /// Returns the application cache directory URL (equivalent to context.cacheDir)
+    public static var cacheDirectory: URL {
+        guard let url = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first else {
+            fatalError("iOS Cache Directory is null or inaccessible")
+        }
+        return url
+    }
+    
+    /// Returns the application document directory URL (equivalent to context.filesDir)
+    public static var documentsDirectory: URL {
+        guard let url = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first else {
+            fatalError("iOS Documents Directory is null or inaccessible")
+        }
+        return url
+    }
+}

package/ios/Utils/FrameJpegConverter.swift

@@ -0,0 +1,41 @@
+import Foundation
+import NitroModules
+import VisionCamera
+
+public enum FrameJpegConverter {
+    private static let tag = "YOLO_TAG_FrameJpegConverter"
+    
+    public static func toJpegBytes(frame: any HybridFrameSpec, quality: Int = 80) -> [UInt8] {
+        // 1. Extraction et arrondi propre des dimensions du frame
+        let width = Int(frame.width.rounded())
+        let height = Int(frame.height.rounded())
+        
+        // 2. Conversion ultra-rapide via memcpy vers le format matériel NV12
+        let nv12 = Yuv420ToNv12Converter.convert(frame: frame, width: width, height: height)
+        
+        if nv12.isEmpty {
+            NSLog("[%@]: ❌ Failed to convert frame to NV12 array", tag)
+            return []
+        }
+        
+        // 3. Encodage matériel en JPEG via le GPU (CoreImage / CIContext)
+        let jpegBytes = Nv12JpegEncoder.encode(
+            nv12: nv12,
+            width: width,
+            height: height,
+            quality: quality
+        )
+        
+        if jpegBytes.isEmpty {
+            NSLog("[%@]: ❌ Failed to encode NV12 data to JPEG bytes", tag)
+            return []
+        }
+        
+        // 4. Redessin de sécurité via UIGraphicsImageRenderer pour fixer définitivement les pixels
+        return BitmapOrientationFixer.fix(
+            jpegBytes: jpegBytes,
+            frame: frame,
+            quality: quality
+        )
+    }
+}

package/ios/Utils/FrameValidator.swift

@@ -0,0 +1,40 @@
+import Foundation
+import NitroModules
+import VisionCamera
+
+public enum FrameValidator {
+    private static let tag = "YOLO_TAG_FrameValidator"
+    
+    public static func isValidYuv(frame: any HybridFrameSpec) -> Bool {
+        // 1. Vérification de la validité globale du Frame
+        if !frame.isValid {
+            NSLog("[%@]: ❌ Frame is not valid", tag)
+            return false
+        }
+        
+        do {
+            let planes = try frame.getPlanes()
+            
+            // 2. Sur iOS, le format matériel natif NV12 contient exactement 2 plans.
+            // On s'assure d'avoir au moins ces 2 plans requis.
+            if planes.count < 2 {
+                NSLog("[%@]: ❌ Expected at least 2 YUV planes (NV12), got %d", tag, planes.count)
+                return false
+            }
+            
+            // 3. Parcours et validation de chaque plan individuel
+            for (index, plane) in planes.enumerated() {
+                if !plane.isValid {
+                    NSLog("[%@]: ❌ Plane %d is not valid", tag, index)
+                    return false
+                }
+            }
+            
+            return true
+            
+        } catch {
+            NSLog("[%@]: ❌ Failed to retrieve planes from frame: %@", tag, error.localizedDescription)
+            return false
+        }
+    }
+}

package/ios/Utils/Nv12JpegEncoder.swift

@@ -0,0 +1,58 @@
+import Foundation
+import CoreImage
+import UIKit
+
+public enum Nv12JpegEncoder {
+    // Réutiliser le CIContext permet d'éviter des fuites de mémoire massives à chaque frame
+    private static let ciContext = CIContext(options: [CIContextOption.useSoftwareRenderer: false])
+    
+    public static func encode(
+        nv12: [UInt8],
+        width: Int,
+        height: Int,
+        quality: Int
+    ) -> [UInt8] {
+        
+        // 1. Convertir la qualité (0-100 sur Android) en CGFloat (0.0-1.0 sur iOS)
+        let compressionQuality = CGFloat(max(0, min(quality, 100))) / 100.0
+        
+        let ySize = width * height
+        let uvSize = ySize / 2
+        
+        // Sécurité : s'assurer que la taille du tableau correspond bien aux dimensions fournies
+        guard nv12.count >= (ySize + uvSize) else { return [] }
+        
+        // 2. Transformer le tableau d'octets [UInt8] en objet Data Swift
+        let rawData = Data(bytes: nv12, count: ySize + uvSize)
+        
+        // 3. Spécifier le format de couleur NV12 pour CoreImage (kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange)
+        let imageOptions: [CIImageOption: Any] = [
+            .colorSpace: CGColorSpaceCreateDeviceRGB()
+        ]
+        
+        // On indique à CoreImage la structure exacte du NV12 (Plan 0: Y, Plan 1: UV entrelacé)
+        guard let ciImage = CIImage(
+            imageWithFormat: Int32(kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange),
+            size: CGSize(width: width, height: height),
+            data: rawData,
+            rowBytes: width,
+            options: imageOptions
+        ) else {
+            return []
+        }
+        
+        // 4. Rendu de l'image GPU vers une structure d'image CoreGraphics
+        guard let cgImage = ciContext.createCGImage(ciImage, from: ciImage.extent) else {
+            return []
+        }
+        
+        // 5. Conversion en UIImage puis compression matérielle en JPEG
+        let uiImage = UIImage(cgImage: cgImage)
+        guard let jpegData = uiImage.jpegData(compressionQuality: compressionQuality) else {
+            return []
+        }
+        
+        // 6. Retourner le tableau d'octets natif [UInt8] requis par votre modèle
+        return [UInt8](jpegData)
+    }
+}

package/ios/Utils/Yuv420ToNv12Converter.swift

@@ -0,0 +1,71 @@
+import Foundation
+import AVFoundation
+import NitroModules
+import VisionCamera
+import CoreVideo
+
+public enum Yuv420ToNv12Converter {
+    public static func convert(frame: any HybridFrameSpec, width: Int, height: Int) -> [UInt8] {
+        do {
+            let nativeBuffer = try frame.getNativeBuffer()
+            guard let rawPointer = nativeBuffer.pointer else { return [] }
+
+            let pixelBuffer = Unmanaged<CVPixelBuffer>
+                .fromOpaque(rawPointer)
+                .takeUnretainedValue()
+
+            CVPixelBufferLockBaseAddress(pixelBuffer, .readOnly)
+            defer {
+                CVPixelBufferUnlockBaseAddress(pixelBuffer, .readOnly)
+            }
+
+            guard
+                let yBaseAddress = CVPixelBufferGetBaseAddressOfPlane(pixelBuffer, 0),
+                let uvBaseAddress = CVPixelBufferGetBaseAddressOfPlane(pixelBuffer, 1)
+            else {
+                return []
+            }
+
+            let yRowStride = CVPixelBufferGetBytesPerRowOfPlane(pixelBuffer, 0)
+            let uvRowStride = CVPixelBufferGetBytesPerRowOfPlane(pixelBuffer, 1)
+
+            let ySize = width * height
+            let uvSize = ySize / 2
+
+            var nv12 = [UInt8](repeating: 0, count: ySize + uvSize)
+
+            nv12.withUnsafeMutableBytes { dstBuffer in
+                guard let dstBase = dstBuffer.baseAddress else { return }
+
+                let ySrc = yBaseAddress.assumingMemoryBound(to: UInt8.self)
+                let uvSrc = uvBaseAddress.assumingMemoryBound(to: UInt8.self)
+                let dst = dstBase.assumingMemoryBound(to: UInt8.self)
+
+                // 1. Copy Y Plane row-by-row to safely discard padding/stride
+                for row in 0..<height {
+                    memcpy(
+                        dst.advanced(by: row * width),
+                        ySrc.advanced(by: row * yRowStride),
+                        width
+                    )
+                }
+
+                // 2. Copy UV Plane row-by-row safely
+                let uvDstStart = ySize
+                let chromaHeight = height / 2
+
+                for row in 0..<chromaHeight {
+                    memcpy(
+                        dst.advanced(by: uvDstStart + (row * width)), // Fixed layout math
+                        uvSrc.advanced(by: row * uvRowStride),
+                        width
+                    )
+                }
+            }
+
+            return nv12
+        } catch {
+            return []
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-yolo",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "react-native-yolo is a react native package built with Nitro",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/module/index.js",