@aguacerowx/react-native 0.0.38 → 0.0.41

package/ios/GridRenderLayer.swift

@@ -204,34 +204,86 @@ public class GridRenderLayer: NSObject {
 
     private func reconstructAndTransformInPlace(data: inout Data) {
         let count = data.count
-        if count == 0 { return }
+        guard count > 0 else { return }
 
-        // Get raw pointer to memory (Bypasses Swift Array bounds checking)
         data.withUnsafeMutableBytes { rawBuffer in
-            guard let ptr = rawBuffer.baseAddress?.assumingMemoryBound(to: UInt8.self) else { return }
-            
-            // 1. Setup first byte
-            // Cast to Int8 to handle the delta logic, then back to UInt8 for storage
-            var runningValue: Int8 = Int8(bitPattern: ptr[0])
-            
-            // Transform first byte immediately: runningValue + 128
-            // We use &+ to allow overflow wrapping (which is exactly what we want for -128->0 mapping)
-            ptr[0] = UInt8(bitPattern: runningValue) &+ 128
+            guard let baseAddress = rawBuffer.baseAddress else { return }
+            let int8Ptr = baseAddress.assumingMemoryBound(to: Int8.self)
+            let uint8Ptr = baseAddress.assumingMemoryBound(to: UInt8.self)
+
+            // --- PHASE 1: Parallel local prefix sums ---
+            // Each thread independently prefix-sums its own chunk.
+            // At the end of this phase, each chunk is correct RELATIVE to its own start,
+            // but incorrect in absolute terms (missing the sum of all prior chunks).
+
+            let threadCount = min(ProcessInfo.processInfo.activeProcessorCount, 8)
+            let chunkSize = (count + threadCount - 1) / threadCount
+
+            // Stores the final value of each chunk after its local prefix sum.
+            // This is the "carry" we need to propagate forward.
+            var chunkEndValues = [Int8](repeating: 0, count: threadCount)
+
+            DispatchQueue.concurrentPerform(iterations: threadCount) { t in
+                let start = t * chunkSize
+                let end = min(start + chunkSize, count)
+                guard start < end else { return }
+
+                // Local prefix sum within this chunk only
+                for i in (start + 1)..<end {
+                    int8Ptr[i] = int8Ptr[i] &+ int8Ptr[i - 1]
+                }
+                chunkEndValues[t] = int8Ptr[end - 1]
+            }
 
-            // 2. Optimized Loop (One pass for everything)
-            for i in 1..<count {
-                let delta = Int8(bitPattern: ptr[i])
-                
-                // Reconstruction: Add delta to previous value
-                runningValue = runningValue &+ delta
-                
-                // Transformation: Add 128 to shift into UInt8 range for Texture
-                ptr[i] = UInt8(bitPattern: runningValue) &+ 128
+            // --- PHASE 2: Sequential fixup of chunk offsets ---
+            // Compute the running offset that needs to be added to each chunk.
+            // This must be sequential since each offset depends on the previous.
+            var offsets = [Int8](repeating: 0, count: threadCount)
+            // Chunk 0 needs no offset (it's already correct from index 0)
+            for t in 1..<threadCount {
+                offsets[t] = offsets[t - 1] &+ chunkEndValues[t - 1]
+            }
+
+            // --- PHASE 3: Parallel offset application + XOR transform ---
+            // Apply the offset correction AND the +128 transform in one pass.
+            // XOR with 0x80 is equivalent to adding 128 mod 256.
+
+            DispatchQueue.concurrentPerform(iterations: threadCount) { t in
+                let start = t * chunkSize
+                let end = min(start + chunkSize, count)
+                guard start < end else { return }
+
+                let offset = offsets[t]
+
+                if offset == 0 {
+                    // Chunk 0: no offset needed, just XOR transform
+                    // Process 8 bytes at a time using UInt64
+                    let wordStart = start
+                    let wordCount = (end - start) / 8
+                    let uint64Ptr = baseAddress.assumingMemoryBound(to: UInt64.self)
+                    let wordOffset = wordStart / 8
+
+                    for i in 0..<wordCount {
+                        uint64Ptr[wordOffset + i] ^= 0x8080808080808080
+                    }
+                    // Remaining bytes
+                    for i in (wordStart + wordCount * 8)..<end {
+                        uint8Ptr[i] ^= 0x80
+                    }
+                } else {
+                    // Chunks 1+: add offset correction, then XOR transform
+                    // Note: we have to do byte-by-byte here because the offset
+                    // applies additively in Int8 space before the UInt8 XOR
+                    for i in start..<end {
+                        let corrected = int8Ptr[i] &+ offset
+                        uint8Ptr[i] = UInt8(bitPattern: corrected) ^ 0x80
+                    }
+                }
             }
         }
     }
 
-private func processRawData(fileData: Data) -> Data? {
+    private func processRawData(fileData: Data) -> Data? {
         let start = CFAbsoluteTimeGetCurrent()
 
         // 1. Decompress

package/lib/commonjs/ios/GridRenderLayer.swift

@@ -204,34 +204,86 @@ public class GridRenderLayer: NSObject {
 
     private func reconstructAndTransformInPlace(data: inout Data) {
         let count = data.count
-        if count == 0 { return }
+        guard count > 0 else { return }
 
-        // Get raw pointer to memory (Bypasses Swift Array bounds checking)
         data.withUnsafeMutableBytes { rawBuffer in
-            guard let ptr = rawBuffer.baseAddress?.assumingMemoryBound(to: UInt8.self) else { return }
-            
-            // 1. Setup first byte
-            // Cast to Int8 to handle the delta logic, then back to UInt8 for storage
-            var runningValue: Int8 = Int8(bitPattern: ptr[0])
-            
-            // Transform first byte immediately: runningValue + 128
-            // We use &+ to allow overflow wrapping (which is exactly what we want for -128->0 mapping)
-            ptr[0] = UInt8(bitPattern: runningValue) &+ 128
+            guard let baseAddress = rawBuffer.baseAddress else { return }
+            let int8Ptr = baseAddress.assumingMemoryBound(to: Int8.self)
+            let uint8Ptr = baseAddress.assumingMemoryBound(to: UInt8.self)
+
+            // --- PHASE 1: Parallel local prefix sums ---
+            // Each thread independently prefix-sums its own chunk.
+            // At the end of this phase, each chunk is correct RELATIVE to its own start,
+            // but incorrect in absolute terms (missing the sum of all prior chunks).
+
+            let threadCount = min(ProcessInfo.processInfo.activeProcessorCount, 8)
+            let chunkSize = (count + threadCount - 1) / threadCount
+
+            // Stores the final value of each chunk after its local prefix sum.
+            // This is the "carry" we need to propagate forward.
+            var chunkEndValues = [Int8](repeating: 0, count: threadCount)
+
+            DispatchQueue.concurrentPerform(iterations: threadCount) { t in
+                let start = t * chunkSize
+                let end = min(start + chunkSize, count)
+                guard start < end else { return }
+
+                // Local prefix sum within this chunk only
+                for i in (start + 1)..<end {
+                    int8Ptr[i] = int8Ptr[i] &+ int8Ptr[i - 1]
+                }
+                chunkEndValues[t] = int8Ptr[end - 1]
+            }
 
-            // 2. Optimized Loop (One pass for everything)
-            for i in 1..<count {
-                let delta = Int8(bitPattern: ptr[i])
-                
-                // Reconstruction: Add delta to previous value
-                runningValue = runningValue &+ delta
-                
-                // Transformation: Add 128 to shift into UInt8 range for Texture
-                ptr[i] = UInt8(bitPattern: runningValue) &+ 128
+            // --- PHASE 2: Sequential fixup of chunk offsets ---
+            // Compute the running offset that needs to be added to each chunk.
+            // This must be sequential since each offset depends on the previous.
+            var offsets = [Int8](repeating: 0, count: threadCount)
+            // Chunk 0 needs no offset (it's already correct from index 0)
+            for t in 1..<threadCount {
+                offsets[t] = offsets[t - 1] &+ chunkEndValues[t - 1]
+            }
+
+            // --- PHASE 3: Parallel offset application + XOR transform ---
+            // Apply the offset correction AND the +128 transform in one pass.
+            // XOR with 0x80 is equivalent to adding 128 mod 256.
+
+            DispatchQueue.concurrentPerform(iterations: threadCount) { t in
+                let start = t * chunkSize
+                let end = min(start + chunkSize, count)
+                guard start < end else { return }
+
+                let offset = offsets[t]
+
+                if offset == 0 {
+                    // Chunk 0: no offset needed, just XOR transform
+                    // Process 8 bytes at a time using UInt64
+                    let wordStart = start
+                    let wordCount = (end - start) / 8
+                    let uint64Ptr = baseAddress.assumingMemoryBound(to: UInt64.self)
+                    let wordOffset = wordStart / 8
+
+                    for i in 0..<wordCount {
+                        uint64Ptr[wordOffset + i] ^= 0x8080808080808080
+                    }
+                    // Remaining bytes
+                    for i in (wordStart + wordCount * 8)..<end {
+                        uint8Ptr[i] ^= 0x80
+                    }
+                } else {
+                    // Chunks 1+: add offset correction, then XOR transform
+                    // Note: we have to do byte-by-byte here because the offset
+                    // applies additively in Int8 space before the UInt8 XOR
+                    for i in start..<end {
+                        let corrected = int8Ptr[i] &+ offset
+                        uint8Ptr[i] = UInt8(bitPattern: corrected) ^ 0x80
+                    }
+                }
             }
         }
     }
 
-private func processRawData(fileData: Data) -> Data? {
+    private func processRawData(fileData: Data) -> Data? {
         let start = CFAbsoluteTimeGetCurrent()
 
         // 1. Decompress

package/lib/commonjs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aguacerowx/react-native",
-  "version": "0.0.38",
+  "version": "0.0.41",
   "description": "Native weather rendering for React Native",
   "license": "ISC",
   "author": "Michael Barletta",

package/lib/module/ios/GridRenderLayer.swift

@@ -204,34 +204,86 @@ public class GridRenderLayer: NSObject {
 
     private func reconstructAndTransformInPlace(data: inout Data) {
         let count = data.count
-        if count == 0 { return }
+        guard count > 0 else { return }
 
-        // Get raw pointer to memory (Bypasses Swift Array bounds checking)
         data.withUnsafeMutableBytes { rawBuffer in
-            guard let ptr = rawBuffer.baseAddress?.assumingMemoryBound(to: UInt8.self) else { return }
-            
-            // 1. Setup first byte
-            // Cast to Int8 to handle the delta logic, then back to UInt8 for storage
-            var runningValue: Int8 = Int8(bitPattern: ptr[0])
-            
-            // Transform first byte immediately: runningValue + 128
-            // We use &+ to allow overflow wrapping (which is exactly what we want for -128->0 mapping)
-            ptr[0] = UInt8(bitPattern: runningValue) &+ 128
+            guard let baseAddress = rawBuffer.baseAddress else { return }
+            let int8Ptr = baseAddress.assumingMemoryBound(to: Int8.self)
+            let uint8Ptr = baseAddress.assumingMemoryBound(to: UInt8.self)
+
+            // --- PHASE 1: Parallel local prefix sums ---
+            // Each thread independently prefix-sums its own chunk.
+            // At the end of this phase, each chunk is correct RELATIVE to its own start,
+            // but incorrect in absolute terms (missing the sum of all prior chunks).
+
+            let threadCount = min(ProcessInfo.processInfo.activeProcessorCount, 8)
+            let chunkSize = (count + threadCount - 1) / threadCount
+
+            // Stores the final value of each chunk after its local prefix sum.
+            // This is the "carry" we need to propagate forward.
+            var chunkEndValues = [Int8](repeating: 0, count: threadCount)
+
+            DispatchQueue.concurrentPerform(iterations: threadCount) { t in
+                let start = t * chunkSize
+                let end = min(start + chunkSize, count)
+                guard start < end else { return }
+
+                // Local prefix sum within this chunk only
+                for i in (start + 1)..<end {
+                    int8Ptr[i] = int8Ptr[i] &+ int8Ptr[i - 1]
+                }
+                chunkEndValues[t] = int8Ptr[end - 1]
+            }
 
-            // 2. Optimized Loop (One pass for everything)
-            for i in 1..<count {
-                let delta = Int8(bitPattern: ptr[i])
-                
-                // Reconstruction: Add delta to previous value
-                runningValue = runningValue &+ delta
-                
-                // Transformation: Add 128 to shift into UInt8 range for Texture
-                ptr[i] = UInt8(bitPattern: runningValue) &+ 128
+            // --- PHASE 2: Sequential fixup of chunk offsets ---
+            // Compute the running offset that needs to be added to each chunk.
+            // This must be sequential since each offset depends on the previous.
+            var offsets = [Int8](repeating: 0, count: threadCount)
+            // Chunk 0 needs no offset (it's already correct from index 0)
+            for t in 1..<threadCount {
+                offsets[t] = offsets[t - 1] &+ chunkEndValues[t - 1]
+            }
+
+            // --- PHASE 3: Parallel offset application + XOR transform ---
+            // Apply the offset correction AND the +128 transform in one pass.
+            // XOR with 0x80 is equivalent to adding 128 mod 256.
+
+            DispatchQueue.concurrentPerform(iterations: threadCount) { t in
+                let start = t * chunkSize
+                let end = min(start + chunkSize, count)
+                guard start < end else { return }
+
+                let offset = offsets[t]
+
+                if offset == 0 {
+                    // Chunk 0: no offset needed, just XOR transform
+                    // Process 8 bytes at a time using UInt64
+                    let wordStart = start
+                    let wordCount = (end - start) / 8
+                    let uint64Ptr = baseAddress.assumingMemoryBound(to: UInt64.self)
+                    let wordOffset = wordStart / 8
+
+                    for i in 0..<wordCount {
+                        uint64Ptr[wordOffset + i] ^= 0x8080808080808080
+                    }
+                    // Remaining bytes
+                    for i in (wordStart + wordCount * 8)..<end {
+                        uint8Ptr[i] ^= 0x80
+                    }
+                } else {
+                    // Chunks 1+: add offset correction, then XOR transform
+                    // Note: we have to do byte-by-byte here because the offset
+                    // applies additively in Int8 space before the UInt8 XOR
+                    for i in start..<end {
+                        let corrected = int8Ptr[i] &+ offset
+                        uint8Ptr[i] = UInt8(bitPattern: corrected) ^ 0x80
+                    }
+                }
             }
         }
     }
 
-private func processRawData(fileData: Data) -> Data? {
+    private func processRawData(fileData: Data) -> Data? {
         let start = CFAbsoluteTimeGetCurrent()
 
         // 1. Decompress

package/lib/module/lib/commonjs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aguacerowx/react-native",
-  "version": "0.0.38",
+  "version": "0.0.41",
   "description": "Native weather rendering for React Native",
   "license": "ISC",
   "author": "Michael Barletta",

package/lib/module/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aguacerowx/react-native",
-  "version": "0.0.38",
+  "version": "0.0.41",
   "description": "Native weather rendering for React Native",
   "license": "ISC",
   "author": "Michael Barletta",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aguacerowx/react-native",
-  "version": "0.0.38",
+  "version": "0.0.41",
   "description": "Native weather rendering for React Native",
   "license": "ISC",
   "author": "Michael Barletta",

package/lib/module/lib/commonjs/ios/AguaceroPackage.m

@@ -1,19 +0,0 @@
-#import <React/RCTBridgeModule.h>
-#import <React/RCTViewManager.h>
-
-// This file acts as a central manifest for all your native code.
-// The autolinker will find this and use it to register your modules.
-
-// --- Make sure these module names match your Swift/Objective-C class names ---
-
-// Exposing the Swift module to Objective-C
-@interface RCT_EXTERN_MODULE(WeatherFrameProcessorModule, NSObject)
-@end
-
-// Exposing the Swift module to Objective-C
-@interface RCT_EXTERN_MODULE(InspectorModule, NSObject)
-@end
-
-// Exposing the ViewManager to Objective-C
-@interface RCT_EXTERN_MODULE(GridRenderLayerManager, RCTViewManager)
-@end

package/lib/module/lib/commonjs/ios/FragmentUniforms.swift

@@ -1,16 +0,0 @@
-import Foundation
-import simd
-
-// Must match the fragment shader's uniform structure
-struct FragmentUniforms {
-    var opacity: Float
-    var dataRange: SIMD2<Float>
-    var scale: Float
-    var offset: Float
-    var missingQuantized: Float
-    var textureSize: SIMD2<Float>
-    var smoothing: Int32
-    var scaleType: Int32
-    var isPtype: Int32
-    var isMRMS: Int32
-}