first commit

Author: kevinrenskers

.gitignore

@@ -0,0 +1,7 @@
+.DS_Store
+/.build
+/Packages
+/*.xcodeproj
+.swiftpm
+Package.resolved
+.claude

.swiftformat

@@ -0,0 +1,8 @@
+--indent 2
+--indentcase true
+--patternlet inline
+--disable unusedArguments
+--disable redundantReturn
+--disable opaqueGenericParameters
+--disable hoistTry
+--disable blankLinesBetweenChainedFunctions

Package.swift

@@ -0,0 +1,18 @@
+// swift-tools-version:5.10
+
+import PackageDescription
+
+let package = Package(
+  name: "Scry",
+  products: [
+    .library(name: "Scry", targets: ["Scry"]),
+  ],
+  targets: [
+    .target(name: "Scry"),
+    .testTarget(
+      name: "ScryTests",
+      dependencies: ["Scry"],
+      resources: [.copy("Fixtures")]
+    ),
+  ]
+)

README.md

@@ -0,0 +1,115 @@
+# Scry
+
+A pure Swift EXIF metadata parser. No dependencies, no Apple frameworks. Fully macOS and Linux compatible.
+
+Supports **JPEG**, **PNG**, **WebP**, and **TIFF**.
+
+## Usage
+
+```swift
+import Scry
+
+// From a file path
+if let metadata = try Scry.metadata(fromFileAt: "/path/to/photo.jpg") {
+  print(metadata["Make"])    // "Apple"
+  print(metadata["Model"])   // "iPhone 14 Pro"
+  print(metadata["FNumber"]) // 1.78
+}
+
+// From Data
+let data = Data(contentsOf: url)
+if let metadata = try Scry.metadata(from: data) {
+  // format is auto-detected
+}
+```
+
+Returns `nil` when the image has no EXIF data or the format is unsupported.
+
+## Installation
+
+Add to your `Package.swift`:
+
+```swift
+dependencies: [
+  .package(url: "https://github.com/loopwerk/Scry.git", from: "1.0.0"),
+]
+```
+
+## Metadata properties
+
+`Scry.metadata` returns a flat `[String: Any]` dictionary. The keys and value types are:
+
+### Image info (from TIFF IFD0)
+
+| Key | Type | Example |
+|-----|------|---------|
+| `ImageWidth` | `Int` | `4032` |
+| `ImageLength` | `Int` | `3024` |
+| `ImageDescription` | `String` | `"Sunset photo"` |
+| `Make` | `String` | `"Apple"` |
+| `Model` | `String` | `"iPhone 14 Pro"` |
+| `Orientation` | `Int` | `1` |
+| `XResolution` | `Double` | `72.0` |
+| `YResolution` | `Double` | `72.0` |
+| `ResolutionUnit` | `Int` | `2` |
+| `Software` | `String` | `"18.7.3"` |
+| `DateTime` | `String` | `"2026:01:05 17:11:42"` |
+| `Artist` | `String` | `"Kevin Renskers"` |
+| `HostComputer` | `String` | `"iPhone 14 Pro"` |
+| `Copyright` | `String` | `"2026 Kevin Renskers"` |
+
+### Exposure and camera (from EXIF sub-IFD)
+
+| Key | Type | Example |
+|-----|------|---------|
+| `ExposureTime` | `Double` | `0.04` (seconds) |
+| `FNumber` | `Double` | `1.78` |
+| `ExposureProgram` | `Int` | `2` |
+| `ISOSpeedRatings` | `Int` | `800` |
+| `ExifVersion` | `[UInt8]` | `[2, 3, 2]` |
+| `DateTimeOriginal` | `String` | `"2026:01:05 17:11:42"` |
+| `DateTimeDigitized` | `String` | `"2026:01:05 17:11:42"` |
+| `ShutterSpeedValue` | `Double` | `4.64` (APEX) |
+| `ApertureValue` | `Double` | `1.66` (APEX) |
+| `BrightnessValue` | `Double` | `-2.50` (APEX) |
+| `ExposureBiasValue` | `Double` | `0.0` (EV) |
+| `MeteringMode` | `Int` | `5` |
+| `Flash` | `Int` | `16` |
+| `FocalLength` | `Double` | `6.86` (mm) |
+| `OffsetTime` | `String` | `"+01:00"` |
+| `OffsetTimeOriginal` | `String` | `"+01:00"` |
+| `OffsetTimeDigitized` | `String` | `"+01:00"` |
+| `PixelXDimension` | `Int` | `4032` |
+| `PixelYDimension` | `Int` | `3024` |
+| `CustomRendered` | `Int` | `0` |
+| `ExposureMode` | `Int` | `0` |
+| `WhiteBalance` | `Int` | `0` |
+| `FocalLenIn35mmFilm` | `Int` | `24` |
+| `SceneCaptureType` | `Int` | `0` |
+| `BodySerialNumber` | `String` | `"DNXXXXXXXXXXXX"` |
+| `LensSpecification` | `[Double]` | `[2.22, 9.0, 1.78, 2.8]` |
+| `LensMake` | `String` | `"Apple"` |
+| `LensModel` | `String` | `"iPhone 14 Pro back triple camera 6.86mm f/1.78"` |
+| `LensSerialNumber` | `String` | `"XXXXXXXXXX"` |
+
+### GPS (from GPS sub-IFD)
+
+| Key | Type | Example |
+|-----|------|---------|
+| `GPSVersionID` | `[Int]` | `[2, 3, 0, 0]` |
+| `GPSLatitudeRef` | `String` | `"N"` |
+| `GPSLatitude` | `[Double]` | `[52.0, 31.0, 12.74]` (deg, min, sec) |
+| `GPSLongitudeRef` | `String` | `"E"` |
+| `GPSLongitude` | `[Double]` | `[13.0, 24.0, 36.33]` (deg, min, sec) |
+| `GPSAltitudeRef` | `Int` | `0` (0 = above sea level) |
+| `GPSAltitude` | `Double` | `38.39` (meters) |
+| `GPSTimeStamp` | `[Double]` | `[16.0, 11.0, 42.0]` (hrs, min, sec) |
+| `GPSSpeedRef` | `String` | `"K"` (km/h) |
+| `GPSSpeed` | `Double` | `0.0` |
+| `GPSImgDirectionRef` | `String` | `"T"` (true north) |
+| `GPSImgDirection` | `Double` | `139.56` (degrees) |
+| `GPSDestBearingRef` | `String` | `"T"` |
+| `GPSDestBearing` | `Double` | `139.56` (degrees) |
+| `GPSDateStamp` | `String` | `"2026:01:05"` |
+
+Only keys present in the image are included in the dictionary. Not every image will have every property.

Sources/Scry/ByteReader.swift

@@ -0,0 +1,82 @@
+import Foundation
+
+struct ByteReader {
+  enum ByteOrder {
+    case big, little
+  }
+
+  let data: Data
+  var offset: Int
+  var byteOrder: ByteOrder
+
+  init(data: Data, offset: Int = 0, byteOrder: ByteOrder = .big) {
+    self.data = data
+    self.offset = offset
+    self.byteOrder = byteOrder
+  }
+
+  var remaining: Int {
+    max(0, data.count - offset)
+  }
+
+  mutating func readUInt8() throws -> UInt8 {
+    guard offset < data.count else { throw EXIFError.truncatedData }
+    let value = data[data.startIndex + offset]
+    offset += 1
+    return value
+  }
+
+  mutating func readUInt16() throws -> UInt16 {
+    guard offset + 2 <= data.count else { throw EXIFError.truncatedData }
+    let start = data.startIndex + offset
+    let raw = UInt16(data[start]) << 8 | UInt16(data[start + 1])
+    offset += 2
+    switch byteOrder {
+      case .big: return raw
+      case .little: return raw.byteSwapped
+    }
+  }
+
+  mutating func readUInt32() throws -> UInt32 {
+    guard offset + 4 <= data.count else { throw EXIFError.truncatedData }
+    let start = data.startIndex + offset
+    let raw = UInt32(data[start]) << 24 | UInt32(data[start + 1]) << 16
+      | UInt32(data[start + 2]) << 8 | UInt32(data[start + 3])
+    offset += 4
+    switch byteOrder {
+      case .big: return raw
+      case .little: return raw.byteSwapped
+    }
+  }
+
+  mutating func readInt32() throws -> Int32 {
+    Int32(bitPattern: try readUInt32())
+  }
+
+  mutating func readBytes(_ count: Int) throws -> Data {
+    guard offset + count <= data.count else { throw EXIFError.truncatedData }
+    let start = data.startIndex + offset
+    let result = data[start ..< start + count]
+    offset += count
+    return Data(result)
+  }
+
+  mutating func readASCII(_ count: Int) throws -> String {
+    let bytes = try readBytes(count)
+    // Strip null terminators and trailing whitespace
+    let trimmed = bytes.prefix(while: { $0 != 0 })
+    return String(data: Data(trimmed), encoding: .utf8)
+      ?? String(data: Data(trimmed), encoding: .ascii)
+      ?? ""
+  }
+
+  mutating func skip(_ count: Int) throws {
+    guard offset + count <= data.count else { throw EXIFError.truncatedData }
+    offset += count
+  }
+
+  /// Create a reader at a specific offset within the same data, inheriting byte order.
+  func readerAt(_ offset: Int) -> ByteReader {
+    ByteReader(data: data, offset: offset, byteOrder: byteOrder)
+  }
+}

Sources/Scry/Containers/JPEGContainer.swift

@@ -0,0 +1,73 @@
+import Foundation
+
+enum JPEGContainer {
+  /// Extract EXIF TIFF data from a JPEG file.
+  static func extractEXIF(from data: Data) throws -> Data {
+    guard data.count >= 4,
+          data[data.startIndex] == 0xFF,
+          data[data.startIndex + 1] == 0xD8
+    else {
+      throw EXIFError.invalidJPEGStructure
+    }
+
+    var offset = 2
+
+    while offset + 4 <= data.count {
+      let start = data.startIndex + offset
+
+      // Each marker starts with 0xFF
+      guard data[start] == 0xFF else {
+        throw EXIFError.invalidJPEGStructure
+      }
+
+      let marker = data[start + 1]
+
+      // Skip padding bytes (0xFF 0xFF...)
+      if marker == 0xFF {
+        offset += 1
+        continue
+      }
+
+      // SOS (Start of Scan) or EOI — no more metadata segments
+      if marker == 0xDA || marker == 0xD9 {
+        break
+      }
+
+      // Markers without a length field (RST, TEM, SOI)
+      if marker == 0x00 || marker == 0x01 || (0xD0 ... 0xD7).contains(marker) {
+        offset += 2
+        continue
+      }
+
+      // Read segment length (includes the 2 length bytes but not the marker)
+      guard offset + 4 <= data.count else { break }
+      let length = Int(data[start + 2]) << 8 | Int(data[start + 3])
+      guard length >= 2 else { throw EXIFError.invalidJPEGStructure }
+
+      // APP1 marker (0xE1) — check for EXIF signature
+      if marker == 0xE1 {
+        let payloadStart = offset + 4
+        let payloadLength = length - 2
+
+        if payloadLength >= 6, payloadStart + 6 <= data.count {
+          let sigStart = data.startIndex + payloadStart
+          // "Exif\0\0"
+          if data[sigStart] == 0x45, data[sigStart + 1] == 0x78,
+             data[sigStart + 2] == 0x69, data[sigStart + 3] == 0x66,
+             data[sigStart + 4] == 0x00, data[sigStart + 5] == 0x00
+          {
+            let tiffStart = payloadStart + 6
+            let tiffLength = payloadLength - 6
+            guard tiffStart + tiffLength <= data.count else { throw EXIFError.truncatedData }
+            return Data(data[data.startIndex + tiffStart ..< data.startIndex + tiffStart + tiffLength])
+          }
+        }
+      }
+
+      // Move to next marker
+      offset += 2 + length
+    }
+
+    throw EXIFError.noEXIFData
+  }
+}

Sources/Scry/Containers/PNGContainer.swift

@@ -0,0 +1,47 @@
+import Foundation
+
+enum PNGContainer {
+  /// Extract EXIF TIFF data from a PNG file's eXIf chunk.
+  static func extractEXIF(from data: Data) throws -> Data {
+    // PNG signature: 89 50 4E 47 0D 0A 1A 0A
+    guard data.count >= 8,
+          data[data.startIndex] == 0x89,
+          data[data.startIndex + 1] == 0x50,
+          data[data.startIndex + 2] == 0x4E,
+          data[data.startIndex + 3] == 0x47
+    else {
+      throw EXIFError.invalidPNGStructure
+    }
+
+    var offset = 8 // skip signature
+
+    // Iterate through chunks: [4 bytes length][4 bytes type][data][4 bytes CRC]
+    while offset + 8 <= data.count {
+      let start = data.startIndex + offset
+
+      // Chunk data length (big-endian)
+      let length = Int(data[start]) << 24 | Int(data[start + 1]) << 16
+        | Int(data[start + 2]) << 8 | Int(data[start + 3])
+
+      // Chunk type (4 ASCII bytes)
+      let typeStart = start + 4
+      guard typeStart + 4 <= data.endIndex else { break }
+      let chunkType = String(data: data[typeStart ..< typeStart + 4], encoding: .ascii) ?? ""
+
+      let dataStart = offset + 8
+      guard dataStart + length + 4 <= data.count else { break }
+
+      if chunkType == "eXIf" {
+        return Data(data[data.startIndex + dataStart ..< data.startIndex + dataStart + length])
+      }
+
+      // IEND — end of PNG
+      if chunkType == "IEND" { break }
+
+      // Move to next chunk: length field (4) + type (4) + data + CRC (4)
+      offset += 12 + length
+    }
+
+    throw EXIFError.noEXIFData
+  }
+}

Sources/Scry/Containers/TIFFContainer.swift

@@ -0,0 +1,14 @@
+import Foundation
+
+enum TIFFContainer {
+  /// For TIFF files, the entire file is the TIFF structure — pass through.
+  static func extractEXIF(from data: Data) throws -> Data {
+    guard data.count >= 8,
+          (data[data.startIndex] == 0x49 && data[data.startIndex + 1] == 0x49)
+          || (data[data.startIndex] == 0x4D && data[data.startIndex + 1] == 0x4D)
+    else {
+      throw EXIFError.invalidTIFFHeader
+    }
+    return data
+  }
+}