@succinctlabs/react-native-zcam1 0.4.0-alpha.4 → 0.4.0-alpha.6

package/ios/Zcam1CameraViewManager.m

@@ -50,6 +50,8 @@ RCT_EXPORT_MODULE(Zcam1CameraView);
 // @property (nonatomic, copy) NSDictionary *customFilmStyles;   // additional custom film styles by name
 // @property (nonatomic) BOOL depthEnabled;            // enable depth data at session level (default: NO)
 // @property (nonatomic, copy) RCTDirectEventBlock onOrientationChange;  // orientation change callback
+// @property (nonatomic) BOOL hardwareShutterEnabled;                    // enable hardware button capture (default: YES)
+// @property (nonatomic, copy) RCTDirectEventBlock onHardwareShutter;    // hardware shutter callback
 RCT_EXPORT_VIEW_PROPERTY(isActive, BOOL);
 RCT_EXPORT_VIEW_PROPERTY(position, NSString);
 RCT_EXPORT_VIEW_PROPERTY(captureFormat, NSString);
@@ -58,6 +60,8 @@ RCT_EXPORT_VIEW_PROPERTY(torch, BOOL);
 RCT_EXPORT_VIEW_PROPERTY(exposure, float);
 RCT_EXPORT_VIEW_PROPERTY(depthEnabled, BOOL);
 RCT_EXPORT_VIEW_PROPERTY(onOrientationChange, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(hardwareShutterEnabled, BOOL);
+RCT_EXPORT_VIEW_PROPERTY(onHardwareShutter, RCTDirectEventBlock);
 
 // Use custom property setter to ensure the Swift setter is called properly.
 RCT_CUSTOM_VIEW_PROPERTY(filmStyle, NSString, Zcam1CameraView)

package/ios/Zcam1DepthData.swift

@@ -2,12 +2,16 @@
 //  Zcam1DepthData.swift
 //  react-native-zcam1-sdk
 //
-//  Depth data extraction and processing using AVDepthData.
+//  Depth data extraction, processing, and heat map generation using AVDepthData.
+//
+//  All sensor types (LiDAR, TrueDepth, dual camera) are converted to Float32 depth
+//  at a single boundary via AVDepthData.converting(toDepthDataType:). Downstream
+//  code never branches on pixel format.
 //
 
 import AVFoundation
+import CommonCrypto
 import Foundation
-import ImageIO
 import UIKit
 
 // MARK: - Depth Data Processor
@@ -15,6 +19,8 @@ import UIKit
 /// Handles extraction, conversion, and serialization of depth data from AVDepthData.
 public class Zcam1DepthDataProcessor {
 
+    // MARK: - Public API
+
     /// Extract depth data from an AVCapturePhoto if available.
     /// Returns a dictionary containing depth information or nil if not available.
     public static func extractDepthData(from photo: AVCapturePhoto) -> [String: Any]? {
@@ -26,24 +32,28 @@ public class Zcam1DepthDataProcessor {
     }
 
     /// Process AVDepthData and return a dictionary with depth information.
+    ///
+    /// Converts any sensor format to Float32 depth at the boundary, then computes
+    /// statistics using a single code path.
     public static func processDepthData(_ depthData: AVDepthData) -> [String: Any] {
-        let depthDataMap = depthData.depthDataMap
+        // Record the original pixel format for metadata before conversion.
+        let originalPixelFormat = CVPixelBufferGetPixelFormatType(depthData.depthDataMap)
+        let pixelFormatString = pixelFormatTypeToString(originalPixelFormat)
+
+        // Unify all sensor formats to Float32 depth.
+        let unified = convertToFloat32Depth(depthData)
+        let depthDataMap = unified.depthDataMap
 
-        // Get depth data dimensions
         let width = CVPixelBufferGetWidth(depthDataMap)
         let height = CVPixelBufferGetHeight(depthDataMap)
 
-        // Get pixel format type
-        let pixelFormatType = CVPixelBufferGetPixelFormatType(depthDataMap)
-        let pixelFormatString = pixelFormatTypeToString(pixelFormatType)
-
-        // Extract depth statistics
+        // Extract depth statistics from the unified Float32 buffer.
         let statistics = extractDepthStatistics(from: depthDataMap)
 
-        // Get accuracy if available (iOS 14.1+)
+        // Get accuracy if available (iOS 14.1+).
         var accuracyString = "relative"
         if #available(iOS 14.1, *) {
-            switch depthData.depthDataAccuracy {
+            switch unified.depthDataAccuracy {
             case .relative:
                 accuracyString = "relative"
             case .absolute:
@@ -53,34 +63,158 @@ public class Zcam1DepthDataProcessor {
             }
         }
 
-        var result: [String: Any] = [
+        return [
             "width": width,
             "height": height,
             "pixelFormat": pixelFormatString,
             "statistics": statistics,
             "accuracy": accuracyString,
         ]
+    }
+
+    /// Generate a Turbo-colorized depth heat map JPEG and a SHA-256 hash of the raw depth buffer.
+    ///
+    /// Returns `(jpegData, rawHash)` where:
+    ///  - `jpegData`: JPEG-encoded heat map at the depth sensor's native resolution
+    ///  - `rawHash`: hex-encoded SHA-256 of the raw Float32 depth buffer
+    ///
+    /// The `photoOrientation` parameter should be the UIImage.Orientation of the captured photo
+    /// so the heatmap matches the photo's display orientation (depth sensor data is always in
+    /// native landscape orientation).
+    ///
+    /// Returns nil if the depth data contains no valid pixels.
+    public static func generateHeatMap(
+        from depthData: AVDepthData,
+        photoOrientation: UIImage.Orientation = .up
+    ) -> (jpegData: Data, rawHash: String)? {
+        // Unify to Float32 depth.
+        let unified = convertToFloat32Depth(depthData)
+        let depthDataMap = unified.depthDataMap
+
+        let width = CVPixelBufferGetWidth(depthDataMap)
+        let height = CVPixelBufferGetHeight(depthDataMap)
+
+        CVPixelBufferLockBaseAddress(depthDataMap, .readOnly)
+        defer { CVPixelBufferUnlockBaseAddress(depthDataMap, .readOnly) }
+
+        guard let baseAddress = CVPixelBufferGetBaseAddress(depthDataMap) else {
+            return nil
+        }
+
+        let bytesPerRow = CVPixelBufferGetBytesPerRow(depthDataMap)
+        let floatBuffer = baseAddress.assumingMemoryBound(to: Float32.self)
+        let rowStride = bytesPerRow / MemoryLayout<Float32>.stride
+
+        // Compute SHA-256 of the raw Float32 pixel data (excluding row padding).
+        let pixelBytesPerRow = width * MemoryLayout<Float32>.stride
+        let rawHash: String
+        if pixelBytesPerRow == bytesPerRow {
+            // No padding — hash the entire buffer directly.
+            rawHash = sha256Hex(data: baseAddress, count: height * bytesPerRow)
+        } else {
+            // Strip per-row padding by copying only pixel data into a contiguous buffer.
+            var contiguous = Data(capacity: height * pixelBytesPerRow)
+            for y in 0..<height {
+                let rowStart = baseAddress.advanced(by: y * bytesPerRow)
+                contiguous.append(Data(bytes: rowStart, count: pixelBytesPerRow))
+            }
+            rawHash = contiguous.withUnsafeBytes { sha256Hex(data: $0.baseAddress!, count: contiguous.count) }
+        }
+
+        // Extract all values and find min/max.
+        var minVal: Float = .infinity
+        var maxVal: Float = -.infinity
+        var hasValidPixel = false
+
+        for y in 0..<height {
+            let rowBase = y * rowStride
+            for x in 0..<width {
+                let v = floatBuffer[rowBase + x]
+                if v.isFinite {
+                    hasValidPixel = true
+                    minVal = min(minVal, v)
+                    maxVal = max(maxVal, v)
+                }
+            }
+        }
+
+        guard hasValidPixel else { return nil }
+
+        let range = maxVal - minVal
+
+        // Build RGBA pixel data using the Turbo colormap.
+        var rgbaData = [UInt8](repeating: 0, count: width * height * 4)
+        for y in 0..<height {
+            let rowBase = y * rowStride
+            for x in 0..<width {
+                let v = floatBuffer[rowBase + x]
+                let pixelIndex = (y * width + x) * 4
+
+                let normalized: Float
+                if v.isFinite, range > 0 {
+                    normalized = max(0, min(1, (v - minVal) / range))
+                } else if v.isFinite {
+                    normalized = 0.5 // All pixels same depth
+                } else {
+                    normalized = 0 // NaN/Inf → black (closest color)
+                }
+
+                let lutIndex = min(255, Int(normalized * 255))
+                let (r, g, b) = Self.turboLUT[lutIndex]
+                rgbaData[pixelIndex]     = r
+                rgbaData[pixelIndex + 1] = g
+                rgbaData[pixelIndex + 2] = b
+                rgbaData[pixelIndex + 3] = 255
+            }
+        }
+
+        // Create CGImage from RGBA data.
+        let colorSpace = CGColorSpaceCreateDeviceRGB()
+        guard let context = CGContext(
+            data: &rgbaData,
+            width: width,
+            height: height,
+            bitsPerComponent: 8,
+            bytesPerRow: width * 4,
+            space: colorSpace,
+            bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
+        ), let cgImage = context.makeImage() else {
+            return nil
+        }
+
+        // Encode as JPEG, applying the photo's orientation so the heatmap matches.
+        let orientedImage = UIImage(cgImage: cgImage, scale: 1.0, orientation: photoOrientation)
+        guard let jpegData = orientedImage.jpegData(compressionQuality: 0.85) else {
+            return nil
+        }
+
+        return (jpegData, rawHash)
+    }
+
+    // MARK: - Private Helpers
 
-        return result
+    /// Convert any depth data format to Float32 depth at the boundary.
+    /// After this call, the depthDataMap is guaranteed to be Float32.
+    private static func convertToFloat32Depth(_ depthData: AVDepthData) -> AVDepthData {
+        let currentType = CVPixelBufferGetPixelFormatType(depthData.depthDataMap)
+        if currentType == kCVPixelFormatType_DepthFloat32 {
+            return depthData
+        }
+        return depthData.converting(toDepthDataType: kCVPixelFormatType_DepthFloat32)
     }
 
-    /// Extract statistics (min, max, mean, stddev) from depth data.
+    /// Extract statistics (min, max, mean, stddev) from a Float32 depth buffer.
     ///
-    /// Computing stats over every pixel can be expensive and can delay photo capture completion,
-    /// especially when depth delivery is enabled. To keep capture responsive, this uses:
-    /// - adaptive sampling (caps work to ~65k pixels)
-    /// - a single-pass (Welford) accumulator (avoids large allocations)
+    /// Uses adaptive sampling (caps at ~65k pixels) and a single-pass Welford accumulator.
     private static func extractDepthStatistics(from depthDataMap: CVPixelBuffer) -> [String: Any] {
         let width = CVPixelBufferGetWidth(depthDataMap)
         let height = CVPixelBufferGetHeight(depthDataMap)
-        let pixelFormatType = CVPixelBufferGetPixelFormatType(depthDataMap)
 
         // Cap work by sampling at most ~65k pixels.
         let totalPixels = max(1, width * height)
         let maxSamples = 65_536
         let stride: Int = {
             if totalPixels <= maxSamples { return 1 }
-            // Choose a stride so that (w/stride)*(h/stride) ~= maxSamples.
             let scale = sqrt(Double(totalPixels) / Double(maxSamples))
             return max(1, Int(scale.rounded(.up)))
         }()
@@ -93,61 +227,38 @@ public class Zcam1DepthDataProcessor {
         }
 
         let bytesPerRow = CVPixelBufferGetBytesPerRow(depthDataMap)
+        let floatBuffer = baseAddress.assumingMemoryBound(to: Float32.self)
+        let rowStride = bytesPerRow / MemoryLayout<Float32>.stride
 
+        // Single-pass Welford accumulator.
         var count: Int = 0
         var mean: Double = 0
         var m2: Double = 0
         var minValue: Float = .infinity
         var maxValue: Float = -.infinity
 
-        func accumulate(_ v: Float) {
-            guard v.isFinite else { return }
-            count += 1
-            minValue = min(minValue, v)
-            maxValue = max(maxValue, v)
-
-            let x = Double(v)
-            let delta = x - mean
-            mean += delta / Double(count)
-            let delta2 = x - mean
-            m2 += delta * delta2
-        }
-
-        // Extract depth values based on pixel format (sampled).
-        switch pixelFormatType {
-        case kCVPixelFormatType_DepthFloat32, kCVPixelFormatType_DisparityFloat32:
-            let floatBuffer = baseAddress.assumingMemoryBound(to: Float32.self)
-            let rowStride = bytesPerRow / MemoryLayout<Float32>.stride
-            var y = 0
-            while y < height {
-                let rowBase = y * rowStride
-                var x = 0
-                while x < width {
-                    accumulate(floatBuffer[rowBase + x])
-                    x += stride
-                }
-                y += stride
-            }
-
-        case kCVPixelFormatType_DepthFloat16, kCVPixelFormatType_DisparityFloat16:
-            let float16Buffer = baseAddress.assumingMemoryBound(to: Float16.self)
-            let rowStride = bytesPerRow / MemoryLayout<Float16>.stride
-            var y = 0
-            while y < height {
-                let rowBase = y * rowStride
-                var x = 0
-                while x < width {
-                    accumulate(Float(float16Buffer[rowBase + x]))
-                    x += stride
+        var y = 0
+        while y < height {
+            let rowBase = y * rowStride
+            var x = 0
+            while x < width {
+                let v = floatBuffer[rowBase + x]
+                if v.isFinite {
+                    count += 1
+                    minValue = min(minValue, v)
+                    maxValue = max(maxValue, v)
+
+                    let d = Double(v)
+                    let delta = d - mean
+                    mean += delta / Double(count)
+                    let delta2 = d - mean
+                    m2 += delta * delta2
                 }
-                y += stride
+                x += stride
             }
-
-        default:
-            break
+            y += stride
         }
 
-        // Calculate statistics
         guard count > 0 else {
             return [
                 "min": "",
@@ -174,40 +285,6 @@ public class Zcam1DepthDataProcessor {
         ]
     }
 
-    /// Extract camera calibration data.
-    private static func extractCalibrationData(_ calibration: AVCameraCalibrationData) -> [String:
-        Any]
-    {
-        var result: [String: Any] = [:]
-
-        // Intrinsic matrix (3x3) - camera intrinsic parameters
-        // Intrinsic matrix (3x3)
-        let intrinsicMatrix = calibration.intrinsicMatrix
-        result["intrinsicMatrix"] = [
-            [intrinsicMatrix[0, 0], intrinsicMatrix[0, 1], intrinsicMatrix[0, 2]],
-            [intrinsicMatrix[1, 0], intrinsicMatrix[1, 1], intrinsicMatrix[1, 2]],
-            [intrinsicMatrix[2, 0], intrinsicMatrix[2, 1], intrinsicMatrix[2, 2]],
-        ]
-
-        // Extrinsic matrix (4x3)
-        let extrinsicMatrix = calibration.extrinsicMatrix
-        result["extrinsicMatrix"] = [
-            [extrinsicMatrix[0, 0], extrinsicMatrix[0, 1], extrinsicMatrix[0, 2]],
-            [extrinsicMatrix[1, 0], extrinsicMatrix[1, 1], extrinsicMatrix[1, 2]],
-            [extrinsicMatrix[2, 0], extrinsicMatrix[2, 1], extrinsicMatrix[2, 2]],
-            [extrinsicMatrix[3, 0], extrinsicMatrix[3, 1], extrinsicMatrix[3, 2]],
-        ]
-
-        // Lens distortion center
-        let lensDistortionCenter = calibration.lensDistortionCenter
-        result["lensDistortionCenter"] = [
-            "x": lensDistortionCenter.x,
-            "y": lensDistortionCenter.y,
-        ]
-
-        return result
-    }
-
     /// Convert pixel format type to a human-readable string.
     private static func pixelFormatTypeToString(_ pixelFormatType: OSType) -> String {
         switch pixelFormatType {
@@ -224,194 +301,50 @@ public class Zcam1DepthDataProcessor {
         }
     }
 
-    /// Encode depth data as a grayscale image for visualization.
-    ///
-    /// The output is encoded to match Google's GDepth `RangeInverse` convention:
-    /// values are higher (brighter) for nearer pixels and lower (darker) for farther pixels.
-    public static func encodeDepthDataAsImage(
-        depthData: AVDepthData
-    ) -> UIImage? {
-        let depthDataMap = depthData.depthDataMap
-        let width = CVPixelBufferGetWidth(depthDataMap)
-        let height = CVPixelBufferGetHeight(depthDataMap)
-
-        CVPixelBufferLockBaseAddress(depthDataMap, .readOnly)
-        defer { CVPixelBufferUnlockBaseAddress(depthDataMap, .readOnly) }
-
-        guard let baseAddress = CVPixelBufferGetBaseAddress(depthDataMap) else {
-            return nil
-        }
-
-        let pixelFormatType = CVPixelBufferGetPixelFormatType(depthDataMap)
-        let bytesPerRow = CVPixelBufferGetBytesPerRow(depthDataMap)
-
-        // Extract depth values and find their range
-        var depthValues: [Float] = []
-        depthValues.reserveCapacity(width * height)
-        var minDepth: Float = .infinity
-        var maxDepth: Float = -.infinity
-
-        switch pixelFormatType {
-        case kCVPixelFormatType_DepthFloat32, kCVPixelFormatType_DisparityFloat32:
-            let floatBuffer = baseAddress.assumingMemoryBound(to: Float32.self)
-            for y in 0..<height {
-                for x in 0..<width {
-                    let offset = y * (bytesPerRow / MemoryLayout<Float32>.stride) + x
-                    let value = floatBuffer[offset]
-                    if !value.isNaN && !value.isInfinite {
-                        depthValues.append(value)
-                        // Ignore non-positive values when establishing near/far planes,
-                        // since RangeInverse uses 1/depth.
-                        if value > 0 {
-                            minDepth = min(minDepth, value)
-                            maxDepth = max(maxDepth, value)
-                        }
-                    }
-                }
-            }
-
-        case kCVPixelFormatType_DepthFloat16, kCVPixelFormatType_DisparityFloat16:
-            let float16Buffer = baseAddress.assumingMemoryBound(to: Float16.self)
-            for y in 0..<height {
-                for x in 0..<width {
-                    let offset = y * (bytesPerRow / MemoryLayout<Float16>.stride) + x
-                    let value = Float(float16Buffer[offset])
-                    if !value.isNaN && !value.isInfinite {
-                        depthValues.append(value)
-                        // Ignore non-positive values when establishing near/far planes,
-                        // since RangeInverse uses 1/depth.
-                        if value > 0 {
-                            minDepth = min(minDepth, value)
-                            maxDepth = max(maxDepth, value)
-                        }
-                    }
-                }
-            }
-
-        default:
-            return nil
-        }
-
-        // Create grayscale image from normalized depth data
-        guard !depthValues.isEmpty else { return nil }
-
-        // If we never saw any positive finite values, near/far planes are not usable.
-        if !minDepth.isFinite || !maxDepth.isFinite || minDepth <= 0 || maxDepth <= 0 {
-            minDepth = 0
-            maxDepth = 0
-        }
-
-        let depthRange = maxDepth - minDepth
-        var pixelData = [UInt8]()
-        pixelData.reserveCapacity(width * height)
-
-        switch pixelFormatType {
-        case kCVPixelFormatType_DepthFloat32, kCVPixelFormatType_DisparityFloat32:
-            let floatBuffer = baseAddress.assumingMemoryBound(to: Float32.self)
-            for y in 0..<height {
-                for x in 0..<width {
-                    let offset = y * (bytesPerRow / MemoryLayout<Float32>.stride) + x
-                    let value = floatBuffer[offset]
-                    if value.isNaN || value.isInfinite || value <= 0 {
-                        pixelData.append(0)
-                        continue
-                    }
-
-                    // RangeInverse: normalize in inverse-depth space (1/z), so nearer pixels are brighter.
-                    let normalized: Float
-                    if depthRange > 0, minDepth > 0, maxDepth > 0 {
-                        let inv = 1.0 / value
-                        let invNear = 1.0 / minDepth
-                        let invFar = 1.0 / maxDepth
-                        let invRange = invNear - invFar
-
-                        if inv.isFinite, invNear.isFinite, invFar.isFinite, invRange != 0 {
-                            normalized = (inv - invFar) / invRange
-                        } else {
-                            normalized = 0
-                        }
-                    } else {
-                        normalized = 0
-                    }
-
-                    if !normalized.isFinite {
-                        pixelData.append(0)
-                    } else {
-                        let clamped = max(0, min(1, normalized))
-                        pixelData.append(UInt8(max(0, min(255, clamped * 255))))
-                    }
-                }
-            }
-
-        case kCVPixelFormatType_DepthFloat16, kCVPixelFormatType_DisparityFloat16:
-            let float16Buffer = baseAddress.assumingMemoryBound(to: Float16.self)
-            for y in 0..<height {
-                for x in 0..<width {
-                    let offset = y * (bytesPerRow / MemoryLayout<Float16>.stride) + x
-                    let value = Float(float16Buffer[offset])
-                    if value.isNaN || value.isInfinite || value <= 0 {
-                        pixelData.append(0)
-                        continue
-                    }
-
-                    // RangeInverse: normalize in inverse-depth space (1/z), so nearer pixels are brighter.
-                    let normalized: Float
-                    if depthRange > 0, minDepth > 0, maxDepth > 0 {
-                        let inv = 1.0 / value
-                        let invNear = 1.0 / minDepth
-                        let invFar = 1.0 / maxDepth
-                        let invRange = invNear - invFar
-
-                        if inv.isFinite, invNear.isFinite, invFar.isFinite, invRange != 0 {
-                            normalized = (inv - invFar) / invRange
-                        } else {
-                            normalized = 0
-                        }
-                    } else {
-                        normalized = 0
-                    }
-
-                    if !normalized.isFinite {
-                        pixelData.append(0)
-                    } else {
-                        let clamped = max(0, min(1, normalized))
-                        pixelData.append(UInt8(max(0, min(255, clamped * 255))))
-                    }
-                }
-            }
-
-        default:
-            return nil
-        }
-
-        // Create CGImage from pixel data
-        guard
-            let provider = CGDataProvider(
-                data: NSData(bytes: pixelData, length: pixelData.count))
-        else {
-            return nil
-        }
-
-        let colorSpace = CGColorSpaceCreateDeviceGray()
-        guard
-            let cgImage = CGImage(
-                width: width,
-                height: height,
-                bitsPerComponent: 8,
-                bitsPerPixel: 8,
-                bytesPerRow: width,
-                space: colorSpace,
-                bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.none.rawValue),
-                provider: provider,
-                decode: nil,
-                shouldInterpolate: false,
-                intent: .defaultIntent
-            )
-        else {
-            return nil
-        }
-
-        return UIImage(cgImage: cgImage)
+    /// Compute SHA-256 hex string from a raw memory buffer.
+    private static func sha256Hex(data: UnsafeRawPointer, count: Int) -> String {
+        var hash = [UInt8](repeating: 0, count: Int(CC_SHA256_DIGEST_LENGTH))
+        CC_SHA256(data, CC_LONG(count), &hash)
+        return hash.map { String(format: "%02x", $0) }.joined()
     }
 
+    // MARK: - Turbo Colormap LUT
+
+    /// Google Turbo colormap — 256 RGB entries optimized for depth visualization.
+    /// Source: https://gist.github.com/mikhailov-work/ee72ba4191942acecc03fe6da94fc73f (public domain)
+    // swiftlint:disable:next large_tuple
+    private static let turboLUT: [(UInt8, UInt8, UInt8)] = [
+        (48,18,59),(50,21,67),(51,24,74),(52,27,81),(53,30,88),(54,33,95),(55,36,102),(56,39,109),
+        (57,42,115),(58,45,121),(59,47,128),(60,50,134),(61,53,139),(62,56,145),(63,59,151),(63,62,156),
+        (64,64,162),(65,67,167),(65,70,172),(66,73,177),(66,75,181),(67,78,186),(68,81,191),(68,84,195),
+        (68,86,199),(69,89,203),(69,92,207),(69,94,211),(70,97,214),(70,100,218),(70,102,221),(70,105,224),
+        (70,107,227),(71,110,230),(71,113,233),(71,115,235),(71,118,238),(71,120,240),(71,123,242),(70,125,244),
+        (70,128,246),(70,130,248),(70,133,250),(70,135,251),(69,138,252),(69,140,253),(68,143,254),(67,145,254),
+        (66,148,255),(65,150,255),(64,153,255),(62,155,254),(61,158,254),(59,160,253),(58,163,252),(56,165,251),
+        (55,168,250),(53,171,248),(51,173,247),(49,175,245),(47,178,244),(46,180,242),(44,183,240),(42,185,238),
+        (40,188,235),(39,190,233),(37,192,231),(35,195,228),(34,197,226),(32,199,223),(31,201,221),(30,203,218),
+        (28,205,216),(27,208,213),(26,210,210),(26,212,208),(25,213,205),(24,215,202),(24,217,200),(24,219,197),
+        (24,221,194),(24,222,192),(24,224,189),(25,226,187),(25,227,185),(26,228,182),(28,230,180),(29,231,178),
+        (31,233,175),(32,234,172),(34,235,170),(37,236,167),(39,238,164),(42,239,161),(44,240,158),(47,241,155),
+        (50,242,152),(53,243,148),(56,244,145),(60,245,142),(63,246,138),(67,247,135),(70,248,132),(74,248,128),
+        (78,249,125),(82,250,122),(85,250,118),(89,251,115),(93,252,111),(97,252,108),(101,253,105),(105,253,102),
+        (109,254,98),(113,254,95),(117,254,92),(121,254,89),(125,255,86),(128,255,83),(132,255,81),(136,255,78),
+        (139,255,75),(143,255,73),(146,255,71),(150,254,68),(153,254,66),(156,254,64),(159,253,63),(161,253,61),
+        (164,252,60),(167,252,58),(169,251,57),(172,251,56),(175,250,55),(177,249,54),(180,248,54),(183,247,53),
+        (185,246,53),(188,245,52),(190,244,52),(193,243,52),(195,241,52),(198,240,52),(200,239,52),(203,237,52),
+        (205,236,52),(208,234,52),(210,233,53),(212,231,53),(215,229,53),(217,228,54),(219,226,54),(221,224,55),
+        (223,223,55),(225,221,55),(227,219,56),(229,217,56),(231,215,57),(233,213,57),(235,211,57),(236,209,58),
+        (238,207,58),(239,205,58),(241,203,58),(242,201,58),(244,199,58),(245,197,58),(246,195,58),(247,193,58),
+        (248,190,57),(249,188,57),(250,186,57),(251,184,56),(251,182,55),(252,179,54),(252,177,54),(253,174,53),
+        (253,172,52),(254,169,51),(254,167,50),(254,164,49),(254,161,48),(254,158,47),(254,155,45),(254,153,44),
+        (254,150,43),(254,147,42),(254,144,41),(253,141,39),(253,138,38),(252,135,37),(252,132,35),(251,129,34),
+        (251,126,33),(250,123,31),(249,120,30),(249,117,29),(248,114,28),(247,111,26),(246,108,25),(245,105,24),
+        (244,102,23),(243,99,21),(242,96,20),(241,93,19),(240,91,18),(239,88,17),(237,85,16),(236,83,15),
+        (235,80,14),(234,78,13),(232,75,12),(231,73,12),(229,71,11),(228,69,10),(226,67,10),(225,65,9),
+        (223,63,8),(221,61,8),(220,59,7),(218,57,7),(216,55,6),(214,53,6),(212,51,5),(210,49,5),
+        (208,47,5),(206,45,4),(204,43,4),(202,42,4),(200,40,3),(197,38,3),(195,37,3),(193,35,2),
+        (190,33,2),(188,32,2),(185,30,2),(183,29,2),(180,27,1),(178,26,1),(175,24,1),(172,23,1),
+        (169,22,1),(167,20,1),(164,19,1),(161,18,1),(158,16,1),(155,15,1),(152,14,1),(149,13,1),
+        (146,11,1),(142,10,1),(139,9,2),(136,8,2),(133,7,2),(129,6,2),(126,5,2),(122,4,3),
+    ]
 }

package/lib/module/NativeZcam1Capture.js.map

@@ -1 +1 @@
-{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeZcam1Capture.ts"],"mappings":";;AAAA,SAA2BA,mBAAmB,QAAQ,cAAc;;AA8JpE;AACA;AACA;AACA;AACA;;AA4KA,eAAeA,mBAAmB,CAACC,YAAY,CAAO,cAAc,CAAC","ignoreList":[]}
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeZcam1Capture.ts"],"mappings":";;AAAA,SAA2BA,mBAAmB,QAAQ,cAAc;;AA0KpE;AACA;AACA;AACA;AACA;;AA4KA,eAAeA,mBAAmB,CAACC,YAAY,CAAO,cAAc,CAAC","ignoreList":[]}