react-native-yolo 0.0.11 → 0.0.13

package/ios/HybridYoloModel.swift

@@ -121,9 +121,9 @@ public class HybridYoloModel: HybridYoloModelSpec {
             
             detections.append(
                 Detection(
-                    boundingBox: box,
+                    classId: Double(outputArray[offset + 5]),
                     score: Double(score),
-                    classId: Double(outputArray[offset + 5])
+                    boundingBox: box
                 )
             )
         }
@@ -143,8 +143,13 @@ public class HybridYoloModel: HybridYoloModelSpec {
         
         // 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()
+        guard let rawPointer = UnsafeRawPointer(bitPattern: UInt(nativeBuffer.pointer)) else {
+            return
+        }
+
+        let pixelBuffer = Unmanaged<CVPixelBuffer>
+            .fromOpaque(rawPointer)
+            .takeUnretainedValue()
         
         CVPixelBufferLockBaseAddress(pixelBuffer, .readOnly)
         defer { CVPixelBufferUnlockBaseAddress(pixelBuffer, .readOnly) }
@@ -184,13 +189,17 @@ public class HybridYoloModel: HybridYoloModelSpec {
                 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 yf = Float(y)
+                let uf = Float(u - 128)
+                let vf = Float(v - 128)
+
+                let rFloat = yf + (1.402 * vf)
+                let gFloat = yf - (0.344136 * uf) - (0.714136 * vf)
+                let bFloat = yf + (1.772 * uf)
                 
-                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)
+                let r = clampInt(Int(rFloat.rounded()), 0, 255)
+                let g = clampInt(Int(gFloat.rounded()), 0, 255)
+                let b = clampInt(Int(bFloat.rounded()), 0, 255)
                 
                 if dataType == .float32 {
                     let rNorm = Float(r) / 255.0
@@ -229,22 +238,26 @@ public class HybridYoloModel: HybridYoloModelSpec {
         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)))
+            return (clampInt(sx, 0, srcWidth - 1), clampInt(sy, 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)))
+            return (clampInt(sx, 0, srcWidth - 1), clampInt(sy, 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)))
+            return (clampInt(sx, 0, srcWidth - 1), clampInt(sy, 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)))
+            return (clampInt(sx, 0, srcWidth - 1), clampInt(sy, 0, srcHeight - 1))
         @unknown default:
             return (0, 0)
         }
     }
+
+    private func clampInt(_ value: Int, _ minValue: Int, _ maxValue: Int) -> Int {
+        return min(max(value, minValue), maxValue)
+    }
 }
 

package/ios/Utils/FrameJpegConverter.swift

@@ -1,41 +1,42 @@
 import Foundation
 import NitroModules
 import VisionCamera
+import CoreVideo
 
 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)
+        do {
+            let nativeBuffer = try frame.getNativeBuffer()
+
+            guard let rawPointer = UnsafeRawPointer(bitPattern: UInt(nativeBuffer.pointer)) else {
+                NSLog("[%@]: ❌ Failed to get native buffer pointer", tag)
+                return []
+            }
+
+            let pixelBuffer = Unmanaged<CVPixelBuffer>
+                .fromOpaque(rawPointer)
+                .takeUnretainedValue()
+
+            let jpegBytes = Nv12JpegEncoder.encode(
+                pixelBuffer: pixelBuffer,
+                quality: quality
+            )
+
+            if jpegBytes.isEmpty {
+                NSLog("[%@]: ❌ Failed to encode pixelBuffer to JPEG bytes", tag)
+                return []
+            }
+
+            return BitmapOrientationFixer.fix(
+                jpegBytes: jpegBytes,
+                frame: frame,
+                quality: quality
+            )
+        } catch {
+            NSLog("[%@]: ❌ Failed to convert frame to JPEG: %@", tag, "\(error)")
             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/Nv12JpegEncoder.swift

@@ -1,58 +1,32 @@
 import Foundation
 import CoreImage
-import UIKit
+import CoreVideo
+import ImageIO
 
 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])
-    
+    private static let ciContext = CIContext(options: [
+        CIContextOption.useSoftwareRenderer: false
+    ])
+
     public static func encode(
-        nv12: [UInt8],
-        width: Int,
-        height: Int,
+        pixelBuffer: CVPixelBuffer,
         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
+
+        let ciImage = CIImage(cvPixelBuffer: pixelBuffer)
+        let colorSpace = CGColorSpaceCreateDeviceRGB()
+
+        guard let jpegData = ciContext.jpegRepresentation(
+            of: ciImage,
+            colorSpace: colorSpace,
+            options: [
+                kCGImageDestinationLossyCompressionQuality as CIImageRepresentationOption: compressionQuality
+            ]
         ) 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/package.json

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