feat: CPU utilization optimization in image diff calculations

LaunchDarklySessionReplay.podspec

@@ -27,9 +27,15 @@ Pod::Spec.new do |s|
     ss.source_files = "Sources/Common/**/*.{swift,h,m}"
   end
 
+  s.subspec "SessionReplayC" do |ss|
+    ss.source_files = "Sources/SessionReplayC/**/*.{c,h}"
+    ss.public_header_files = "Sources/SessionReplayC/include/**/*.h"
+  end
+
   s.subspec "LaunchDarklySessionReplay" do |ss|
     ss.source_files = "Sources/LaunchDarklySessionReplay/**/*.{swift,h,m}"
     ss.dependency "LaunchDarklySessionReplay/Common"
+    ss.dependency "LaunchDarklySessionReplay/SessionReplayC"
     ss.dependency "LaunchDarklyObservability/LaunchDarklyObservability"
   end
 end

Package.swift

@@ -27,6 +27,10 @@ let package = Package(
             name: "ObjCBridge",
             publicHeadersPath: "."
         ),
+        .target(
+            name: "SessionReplayC",
+            publicHeadersPath: "include"
+        ),
         .target(name: "Common",
                 dependencies: [.product(name: "LaunchDarkly", package: "ios-client-sdk", condition: .when(platforms: [.iOS, .tvOS]))]),
         .target(
@@ -53,6 +57,7 @@ let package = Package(
             dependencies: [
                 "Common",
                 "LaunchDarklyObservability",
+                "SessionReplayC",
             ],
         ),
         .target(
@@ -97,7 +102,8 @@ let package = Package(
             name: "SessionReplayTests",
             dependencies: [
                 "LaunchDarklySessionReplay",
-                "LaunchDarklyObservability"
+                "LaunchDarklyObservability",
+                "SessionReplayC",
             ]
         ),
     ]

Sources/LaunchDarklySessionReplay/BenchMark/BenchmarkExecutor.swift

@@ -20,6 +20,33 @@ public final class BenchmarkExecutor {
 
     public init() {}
 
+    public typealias SignatureResult = (
+        elapsedTime: TimeInterval,
+        totalBytes: Int,
+        frameCount: Int
+    )
+
+    public func signatureBenchmark(framesDirectory: URL) throws -> SignatureResult {
+        let reader = try RawFrameReader(directory: framesDirectory)
+        let frames = Array(reader)
+        let manager = TileSignatureManager()
+        var totalBytes = 0
+
+        for frame in frames {
+            if let cgImage = frame.image.cgImage {
+                totalBytes += cgImage.bytesPerRow * cgImage.height
+            }
+        }
+
+        let start = CFAbsoluteTimeGetCurrent()
+        for frame in frames {
+            let _ = manager.compute(image: frame.image)
+        }
+        let elapsed = CFAbsoluteTimeGetCurrent() - start
+
+        return (elapsedTime: elapsed, totalBytes: totalBytes, frameCount: frames.count)
+    }
+
     public func compression(framesDirectory: URL, runs: Int = 1) async throws -> [CompressionResult] {
         let reader = try RawFrameReader(directory: framesDirectory)
         let frames = Array(reader)
@@ -56,9 +83,9 @@ public final class BenchmarkExecutor {
 
         for frame in frames {
             let captureStart = CFAbsoluteTimeGetCurrent()
-            guard let exportFrame = exportDiffManager.exportFrame(from: frame, onTiledFrameComputed: {
-                captureTime += CFAbsoluteTimeGetCurrent() - captureStart
-            }) else {
+            let exportFrame = exportDiffManager.exportFrame(from: frame)
+            captureTime += CFAbsoluteTimeGetCurrent() - captureStart
+            guard let exportFrame else {
                 continue
             }
 

Sources/LaunchDarklySessionReplay/BenchMark/RawFrameIO.swift

@@ -119,9 +119,10 @@ final class RawFrameReader: Sequence {
                 image = cached
             } else {
                 let imageURL = directory.appendingPathComponent(String(format: "%06d.png", imageIndex))
-                guard let loaded = UIImage(contentsOfFile: imageURL.path) else { return nil }
-                imageCache[imageIndex] = loaded
-                image = loaded
+                guard let loaded = UIImage(contentsOfFile: imageURL.path),
+                      let decoded = Self.forceDecoded(loaded) else { return nil }
+                imageCache[imageIndex] = decoded
+                image = decoded
             }
 
             let areasJSON = columns[4].replacingOccurrences(of: "\"\"", with: "\"")
@@ -143,6 +144,25 @@ final class RawFrameReader: Sequence {
             return RawFrame(image: image, timestamp: timestamp, orientation: orientation, areas: areas)
         }
 
+        private static func forceDecoded(_ source: UIImage) -> UIImage? {
+            guard let cgImage = source.cgImage else { return nil }
+            let width = cgImage.width
+            let height = cgImage.height
+            let colorSpace = cgImage.colorSpace ?? CGColorSpaceCreateDeviceRGB()
+            guard let ctx = CGContext(
+                data: nil,
+                width: width,
+                height: height,
+                bitsPerComponent: 8,
+                bytesPerRow: width * 4,
+                space: colorSpace,
+                bitmapInfo: CGImageAlphaInfo.premultipliedFirst.rawValue | CGBitmapInfo.byteOrder32Little.rawValue
+            ) else { return nil }
+            ctx.draw(cgImage, in: CGRect(x: 0, y: 0, width: width, height: height))
+            guard let decoded = ctx.makeImage() else { return nil }
+            return UIImage(cgImage: decoded, scale: source.scale, orientation: source.imageOrientation)
+        }
+
         private static func parseCSV(line: String) -> [String] {
             var result = [String]()
             var current = ""

Sources/LaunchDarklySessionReplay/ScreenCapture/ImageSignature.swift

@@ -0,0 +1,105 @@
+import CoreGraphics
+
+struct ImageSignature: Hashable {
+    let rows: Int
+    let columns: Int
+    let tileWidth: Int
+    let tileHeight: Int
+    let tileSignatures: [TileSignature]
+    private let _hashValue: Int
+
+    init(rows: Int, columns: Int, tileWidth: Int, tileHeight: Int, tileSignatures: [TileSignature]) {
+        self.init(
+            rows: rows, columns: columns,
+            tileWidth: tileWidth, tileHeight: tileHeight,
+            tileSignatures: tileSignatures,
+            tileAccHash: Self._accumulateHash(tileSignatures)
+        )
+    }
+
+    init(rows: Int, columns: Int, tileWidth: Int, tileHeight: Int, tileSignatures: [TileSignature], tileAccHash: Int) {
+        self.rows = rows
+        self.columns = columns
+        self.tileWidth = tileWidth
+        self.tileHeight = tileHeight
+        self.tileSignatures = tileSignatures
+
+        var hasher = Hasher()
+        hasher.combine(rows)
+        hasher.combine(columns)
+        hasher.combine(tileWidth)
+        hasher.combine(tileHeight)
+        hasher.combine(tileAccHash)
+        self._hashValue = hasher.finalize()
+    }
+
+    @inline(__always)
+    static func _accumulateTile(_ acc: Int, _ sig: TileSignature) -> Int {
+        (acc &* 31) &+ Int(truncatingIfNeeded: sig.hashLo ^ sig.hashHi)
+    }
+
+    private static func _accumulateHash(_ tiles: [TileSignature]) -> Int {
+        var acc = 0
+        for sig in tiles { acc = _accumulateTile(acc, sig) }
+        return acc
+    }
+
+    func hash(into hasher: inout Hasher) {
+        hasher.combine(_hashValue)
+    }
+
+    static func == (lhs: ImageSignature, rhs: ImageSignature) -> Bool {
+        lhs._hashValue == rhs._hashValue &&
+        lhs.rows == rhs.rows &&
+        lhs.columns == rhs.columns &&
+        lhs.tileWidth == rhs.tileWidth &&
+        lhs.tileHeight == rhs.tileHeight &&
+        lhs.tileSignatures == rhs.tileSignatures
+    }
+}
+
+struct TileSignature: Hashable {
+    let hashLo: Int64
+    let hashHi: Int64
+}
+
+extension ImageSignature {
+    func diffRectangle(other: ImageSignature?) -> CGRect? {
+        guard let other else {
+            return CGRect(x: 0,
+                          y: 0,
+                          width: columns * tileWidth,
+                          height: rows * tileHeight)
+        }
+
+        guard rows == other.rows, columns == other.columns, tileWidth == other.tileWidth, tileHeight == other.tileHeight else {
+            return CGRect(x: 0,
+                          y: 0,
+                          width: columns * tileWidth,
+                          height: rows * tileHeight)
+        }
+
+        var minRow = Int.max
+        var maxRow = Int.min
+        var minColumn = Int.max
+        var maxColumn = Int.min
+
+        for (i, tile) in tileSignatures.enumerated() where tile != other.tileSignatures[i] {
+            let row = i / columns
+            let col = i % columns
+            minRow = min(minRow, row)
+            maxRow = max(maxRow, row)
+            minColumn = min(minColumn, col)
+            maxColumn = max(maxColumn, col)
+        }
+
+        guard minRow != Int.max else {
+            return nil
+        }
+
+        return CGRect(x: minColumn * tileWidth,
+                      y: minRow * tileHeight,
+                      width: (maxColumn - minColumn + 1) * tileWidth,
+                      height: (maxRow - minRow + 1) * tileHeight)
+    }
+}