A Canvas Sized to the Device

    /// The largest edge any canvas may have (Metal's texture limit on every
    /// supported iPad).
    public static let maximumEdge = 16384

    /// The most pixels a canvas may hold on a device with `memory` bytes of
    /// RAM. Every layer keeps a GPU mirror and the history keeps tiles, so
    /// the canvas grows with the device: 16 MP up to 4 GB, 36 MP up to
    /// 8 GB, 64 MP above.
    public static func maximumPixels(memory: UInt64) -> Int {
        let gigabyte: UInt64 = 1 << 30
        if memory <= 4 * gigabyte { return 16_000_000 }
        if memory <= 8 * gigabyte { return 36_000_000 }
        return 64_000_000
    }

    /// The most layers a canvas this size holds: every layer keeps a GPU
    /// mirror, and the history needs room beside them.
    public var maximumLayers: Int {
        let budget = 1_400 * 1024 * 1024
        return max(4, min(200, budget / max(1, pixelCount * 4)))
    }

    /// This size scaled down, keeping its proportions, until it fits both the
    /// edge limit and `maximumPixels`.
    public func limited(toPixels maximumPixels: Int) -> CanvasSize {
        var scale = 1.0
        let longest = Double(max(width, height))
        if longest > Double(Self.maximumEdge) {
            scale = Double(Self.maximumEdge) / longest
        }
        let pixels = Double(width) * Double(height) * scale * scale
        if pixels > Double(maximumPixels) {
            scale *= (Double(maximumPixels) / pixels).squareRoot()
        }
        guard scale < 1 else { return self }
        return CanvasSize(width: max(1, Int((Double(width) * scale).rounded(.down))),
                          height: max(1, Int((Double(height) * scale).rounded(.down))))
    }

// A minimal sketch of Ariandel's canvas cap: the same rules as CanvasSize's
// maximumPixels, limited(toPixels:) and maximumLayers, run for three RAM sizes.
// Build and run: swiftc -swift-version 6 canvas.swift -o canvas && ./canvas
import Foundation

let maximumEdge = 16384                       // Metal's 2D texture limit on supported iPads

func maximumPixels(memory: UInt64) -> Int {
    let gigabyte: UInt64 = 1 << 30
    if memory <= 4 * gigabyte { return 16_000_000 }
    if memory <= 8 * gigabyte { return 36_000_000 }
    return 64_000_000
}

func limited(_ width: Int, _ height: Int, toPixels cap: Int) -> (Int, Int) {
    var scale = 1.0
    let longest = Double(max(width, height))
    if longest > Double(maximumEdge) { scale = Double(maximumEdge) / longest }
    let pixels = Double(width) * Double(height) * scale * scale
    if pixels > Double(cap) { scale *= (Double(cap) / pixels).squareRoot() }
    guard scale < 1 else { return (width, height) }
    return (max(1, Int((Double(width) * scale).rounded(.down))), max(1, Int((Double(height) * scale).rounded(.down))))
}

func maximumLayers(_ width: Int, _ height: Int) -> Int {
    let budget = 1_400 * 1024 * 1024          // bytes of 8-bit RGBA mirror the layers may take
    return max(4, min(200, budget / max(1, width * height * 4)))
}

let requests = [(16384, 16384), (4961, 7016), (2480, 3508), (20000, 500)]   // A4 at 600 and at 300 dpi
for gb: UInt64 in [4, 8, 16] {
    let cap = maximumPixels(memory: gb << 30)
    print("\(gb) GB device: cap \(cap / 1_000_000) MP")
    for (w, h) in requests {
        let (fw, fh) = limited(w, h, toPixels: cap)
        print("  \(w)x\(h) -> \(fw)x\(fh)  (\(fw * fh / 1000) k px, up to \(maximumLayers(fw, fh)) layers)")
    }
}
print("this Mac:", ProcessInfo.processInfo.physicalMemory >> 30, "GB ->",
      maximumPixels(memory: ProcessInfo.processInfo.physicalMemory) / 1_000_000, "MP")

// AriandelEngine/CanvasRenderer.swift: mipmaps only when the canvas is shown smaller than its pixels
    public func encodeDisplay(artwork: Artwork, options: DisplayOptions, pass: MTLRenderPassDescriptor,
                              commandBuffer: MTLCommandBuffer) {
        guard let composite else { return }
        let screenScale = options.transform.scale * options.contentScale
        if screenScale < 1, mipmapsStale, composite.mipmapLevelCount > 1,
           let blit = commandBuffer.makeBlitCommandEncoder() {
            blit.generateMipmaps(for: composite)
            blit.endEncoding()
            mipmapsStale = false
        }
        guard let encoder = commandBuffer.makeRenderCommandEncoder(descriptor: pass) else { return }
        // ...

// AriandelEngine/KeyedArchive.swift: reading Procreate's archives without running their classes
/// Reading a keyed archive (NSKeyedArchiver's plist) without its classes, as
/// Procreate's brushes and documents are kept: objects are walked by their
/// references, never decoded, so no code from the file runs. Strings,
/// numbers and dates come out as themselves; anything else stays a plist
/// dictionary to look into.
struct KeyedArchive {
    let objects: [Any]
    let root: [String: Any]

    init?(_ data: Data) {
        guard let plist = try? PropertyListSerialization.propertyList(from: data, format: nil) as? [String: Any],
              let objects = plist["$objects"] as? [Any],
              let top = plist["$top"] as? [String: Any],
              let index = top["root"].flatMap(Self.uid), index < objects.count,
              let root = objects[index] as? [String: Any] else { return nil }
        self.objects = objects
        self.root = root
    }
    // ...

// AriandelMobile, Support/Timelapse.swift: HEVC only past 1080p
        /// Past 1080p, H.264's largest frames no longer hold every canvas (a 4K
        /// square is beyond it), and HEVC carries the detail at half the bits.
        var codec: AVVideoCodecType { max(width, height) > Timelapse.longEdge ? .hevc : .h264 }

        /// Bits a second for the codec at this size: 6 Mb/s at 1080p for H.264.
        var bitRate: Int {
            let pixels = Double(width * height)
            return max(2_000_000, Int(pixels * (codec == .hevc ? 2 : 3)))
        }