feat: unlock 1080p60 on capable devices via StreamCapability (#28)

Replace the hard-coded 720px / 30fps encode ceilings with a device-
derived StreamCapability (1080p60 on 6GB+ / 6-core hardware, 1080p30 on
4GB, 720p30 on 3GB). encodeSize now takes a maxShortEdge and a new
encodeFrameRate(maxFrameRate:) clamps fps, both fed by the capability so
a high-end pick never asks a device for more than it can sustain. The
thermal governor and adaptive controller continue to pull the live rate
down from this static ceiling at runtime. Settings pickers gain 60fps and
10/12 Mbps options, filtered to the device ceiling. Closes #17.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: joeblau

Stream/ScreenCaptureController.swift

@@ -360,6 +360,10 @@ private final class ScreenCaptureOutput: NSObject, SCStreamOutput, SCStreamDeleg
 
     private let publisher: any Publisher
     private let settings: StreamSettings
+    /// Device resolution/fps ceiling. Caps both the encode size (short edge) and
+    /// the capture pacing so a 1080p60 pick never asks a device for more than it
+    /// can sustain. The thermal governor tightens this further at runtime.
+    private let capability = StreamCapability.current
     private let onStopped: @Sendable (Error) -> Void
     private let micLevelMeter: ScreenCaptureMicrophoneMeter
     private let micLevelChannel = MicrophoneLevelChannel()
@@ -384,14 +388,15 @@ private final class ScreenCaptureOutput: NSObject, SCStreamOutput, SCStreamDeleg
         self.settings = settings
         self.onStopped = onStopped
         micLevelMeter = ScreenCaptureMicrophoneMeter(gain: settings.micVolume)
-        targetFrameInterval = CMTime(value: 1, timescale: CMTimeScale(max(1, settings.frameRate)))
+        targetFrameInterval = CMTime(value: 1,
+                                     timescale: CMTimeScale(settings.encodeFrameRate(maxFrameRate: capability.maxFrameRate)))
         (videoSamples, videoContinuation) = AsyncStream.makeStream(
             of: CMSampleBuffer.self,
             bufferingPolicy: .bufferingNewest(1)
         )
         super.init()
         if settings.pipEnabled { facecam.start(with: settings) }
-        videoConsumer = Task { [videoSamples, publisher, settings] in
+        videoConsumer = Task { [videoSamples, publisher, settings, capability] in
             var targetSize: CGSize?
             for await sampleBuffer in videoSamples {
                 guard sampleBuffer.isValid,
@@ -400,7 +405,8 @@ private final class ScreenCaptureOutput: NSObject, SCStreamOutput, SCStreamDeleg
                 if targetSize == nil {
                     let width = CVPixelBufferGetWidth(image)
                     let height = CVPixelBufferGetHeight(image)
-                    let target = settings.encodeSize(forOrientedWidth: width, height: height)
+                    let target = settings.encodeSize(forOrientedWidth: width, height: height,
+                                                     maxShortEdge: capability.maxShortEdge)
                     await publisher.setOutputSize(target, nativeShortEdge: min(width, height))
                     targetSize = target
                 }
@@ -484,7 +490,9 @@ private final class ScreenCaptureOutput: NSObject, SCStreamOutput, SCStreamDeleg
     func applyThermalProfile(frameRateCap: Int, allowPiP: Bool) {
         sampleQueue.async { [weak self] in
             guard let self else { return }
-            let fps = max(1, min(self.settings.frameRate, frameRateCap))
+            // Cap to the device ceiling first, then the thermal frame-rate cap.
+            let deviceRate = self.settings.encodeFrameRate(maxFrameRate: self.capability.maxFrameRate)
+            let fps = max(1, min(deviceRate, frameRateCap))
             self.targetFrameInterval = CMTime(value: 1, timescale: CMTimeScale(fps))
         }
         guard settings.pipEnabled else { return }

Stream/SettingsView.swift

@@ -99,10 +99,15 @@ struct SettingsView: View {
     // MARK: - Bitrate / fps presets
 
     private static let videoBitrates: [Int] = [
-        1_000_000, 2_000_000, 3_000_000, 4_500_000, 6_000_000, 8_000_000
+        1_000_000, 2_000_000, 3_000_000, 4_500_000, 6_000_000, 8_000_000, 10_000_000, 12_000_000
     ]
     private static let audioBitrates: [Int] = [64_000, 96_000, 128_000, 192_000, 256_000]
-    private static let frameRates: [Int] = [24, 30]
+    private static let frameRates: [Int] = [24, 30, 60]
+
+    /// This device's resolution/fps ceiling. Gates the Quality and Frame Rate
+    /// menus below so they never offer more than the hardware can actually stream
+    /// (1080p60 on capable devices, 720p30 on older ones).
+    private var capability: StreamCapability { .current }
 
     private func bitrateLabel(_ bps: Int) -> String {
         String(format: "%.1f Mbps", Double(bps) / 1_000_000)
@@ -451,10 +456,13 @@ struct SettingsView: View {
     private var videoSection: some View {
         Section {
             Picker("Quality", selection: Binding(
-                get: { settings.videoQuality },
+                // Show the EFFECTIVE value: a stored pick above this device's
+                // ceiling displays (and streams) as the capped value rather than
+                // leaving the picker with no matching selection.
+                get: { min(settings.videoQuality, capability.maxShortEdge) },
                 set: { settings.videoQuality = $0; onChange() }
             )) {
-                ForEach(Self.qualities, id: \.self) { q in
+                ForEach(Self.qualities.filter { $0 <= capability.maxShortEdge }, id: \.self) { q in
                     Text(qualityLabel(q)).tag(q)
                 }
             }
@@ -469,17 +477,17 @@ struct SettingsView: View {
             }
 
             Picker("Frame Rate", selection: Binding(
-                get: { settings.frameRate },
+                get: { min(settings.frameRate, capability.maxFrameRate) },
                 set: { settings.frameRate = $0; onChange() }
             )) {
-                ForEach(Self.frameRates, id: \.self) { fps in
+                ForEach(Self.frameRates.filter { $0 <= capability.maxFrameRate }, id: \.self) { fps in
                     Text("\(fps) fps").tag(fps)
                 }
             }
         } header: {
             Text("Video")
         } footer: {
-            Text("Bitrate is a maximum and automatically drops when the uplink is congested. Frame rate is capped at 30 fps for stable capture and encoding.")
+            Text("Bitrate is a maximum and drops automatically when the uplink is congested. Resolution and frame rate are limited to what this device can sustain, and are reduced automatically when it runs warm or low on power.")
         }
     }
 

StreamBroadcast/RTMPPublisher.swift

@@ -30,12 +30,20 @@ actor RTMPPublisher: Publisher {
                                             requestTimeout: 5_000,
                                             qualityOfService: .userInteractive)
     private lazy var stream = RTMPStream(connection: connection)
+    /// Device resolution/fps ceiling (1080p60 on capable hardware, else 720p30),
+    /// computed once. The thermal governor + ABR cap the live rate below it.
+    private let capability = StreamCapability.current
     private lazy var networkController = BroadcastAdaptiveBitRateController(
         maximumBitRate: settings.videoBitrate,
-        frameRate: settings.frameRate
+        frameRate: settings.encodeFrameRate(maxFrameRate: capability.maxFrameRate)
     )
     private var isRunning = false
     private var settings: StreamSettings = .default
+
+    /// The frame rate this device can encode: the user's chosen rate clamped to
+    /// the device capability ceiling. Replaces the old hard `min(frameRate, 30)`
+    /// scattered across the encode/repeat paths.
+    private var encodeFrameRate: Int { settings.encodeFrameRate(maxFrameRate: capability.maxFrameRate) }
     /// The encode dimensions are locked once, from the first screen frame, so the
     /// stream matches the device orientation/aspect. Until set, video is dropped.
     private var outputSizeConfigured = false
@@ -89,7 +97,7 @@ actor RTMPPublisher: Publisher {
 
     private func startFrameRepeat() {
         frameRepeatTask?.cancel()
-        let fps = UInt64(max(1, min(settings.frameRate, 30)))
+        let fps = UInt64(encodeFrameRate)
         let interval = 1_000_000_000 / fps
         frameRepeatTask = Task { [weak self] in
             while !Task.isCancelled {
@@ -728,7 +736,7 @@ actor RTMPPublisher: Publisher {
     /// Idempotent — only the first call takes effect.
     func setOutputSize(_ size: CGSize, nativeShortEdge _: Int) async {
         guard !outputSizeConfigured else { return }
-        let frameRate = min(max(settings.frameRate, 1), 30)
+        let frameRate = encodeFrameRate
         var v = await stream.videoSettings
         v.videoSize = size
         v.scalingMode = .letterbox
@@ -772,7 +780,7 @@ actor RTMPPublisher: Publisher {
         // never dropped) so latency stays bounded instead of the queue growing.
         guard videoAdmission.admit() else { return }
         let duration = CMTime(value: 1,
-                              timescale: CMTimeScale(min(max(settings.frameRate, 1), 30)))
+                              timescale: CMTimeScale(encodeFrameRate))
         let normalized = timeline.normalize(sb, kind: .video, fallbackDuration: duration)
         await mixer.append(enforceMonotonicVideo(normalized, minStep: duration))
     }
@@ -1006,7 +1014,11 @@ actor BroadcastAdaptiveBitRateController: StreamBitRateStrategy {
         minimumVideoBitRate = max(300_000, maximumBitRate / 10)
         targetBitRate = maximumBitRate
         pathCeiling = maximumBitRate
-        let clampedFrameRate = min(max(frameRate, 1), 30)
+        // Clamp only to a sane hardware maximum, NOT 30. The caller already passes
+        // a capability-resolved rate (≤60 on capable devices); keeping the real
+        // value here is what makes the `configuredFrameRate > 30` congestion tier
+        // in `frameInterval` reachable — it was dead code while this pinned to ≤30.
+        let clampedFrameRate = min(max(frameRate, 1), 120)
         configuredFrameRate = clampedFrameRate
         preferredFrameInterval = max(0, (1.0 / Double(clampedFrameRate)) - 0.001)
     }

StreamBroadcast/SessionPublisher.swift

@@ -43,11 +43,18 @@ actor SessionPublisher: Publisher {
     private let transport: StreamCore.StreamProtocol
     private let mixer = MediaMixer(captureSessionMode: .manual,
                                    multiTrackAudioMixingEnabled: true)
+    /// Device resolution/fps ceiling (1080p60 on capable hardware, else 720p30),
+    /// computed once. The thermal governor + ABR cap the live rate below it.
+    private let capability = StreamCapability.current
     private lazy var networkController = BroadcastAdaptiveBitRateController(
         maximumBitRate: settings.videoBitrate,
-        frameRate: settings.frameRate)
+        frameRate: settings.encodeFrameRate(maxFrameRate: capability.maxFrameRate))
     private var settings: StreamSettings = .default
 
+    /// The frame rate this device can encode: the user's chosen rate clamped to
+    /// the device capability ceiling. Replaces the old hard `min(frameRate, 30)`.
+    private var encodeFrameRate: Int { settings.encodeFrameRate(maxFrameRate: capability.maxFrameRate) }
+
     private var session: (any StreamSession)?
     private var stream: (any StreamConvertible)?
     private var isRunning = false
@@ -92,7 +99,7 @@ actor SessionPublisher: Publisher {
 
     private func startFrameRepeat() {
         frameRepeatTask?.cancel()
-        let fps = UInt64(max(1, min(settings.frameRate, 30)))
+        let fps = UInt64(encodeFrameRate)
         let interval = 1_000_000_000 / fps
         frameRepeatTask = Task { [weak self] in
             while !Task.isCancelled {
@@ -242,7 +249,7 @@ actor SessionPublisher: Publisher {
     }
 
     private func makeVideoSettings(_ current: VideoCodecSettings, size: CGSize? = nil) async -> VideoCodecSettings {
-        let frameRate = min(max(settings.frameRate, 1), 30)
+        let frameRate = encodeFrameRate
         var v = current
         if let size { v.videoSize = size }
         v.scalingMode = .letterbox
@@ -264,7 +271,7 @@ actor SessionPublisher: Publisher {
         lastVideoAppendAt = DispatchTime.now().uptimeNanoseconds
         lastVideoBuffer = sb
         guard videoAdmission.admit() else { return }
-        let duration = CMTime(value: 1, timescale: CMTimeScale(min(max(settings.frameRate, 1), 30)))
+        let duration = CMTime(value: 1, timescale: CMTimeScale(encodeFrameRate))
         let normalized = timeline.normalize(sb, kind: .video, fallbackDuration: duration)
         await mixer.append(enforceMonotonicVideo(normalized, minStep: duration))
     }

StreamCore/StreamCapability.swift

@@ -0,0 +1,76 @@
+import Foundation
+
+/// The resolution and frame-rate ceiling a *device* can sustain for the whole
+/// in-app pipeline (ScreenCaptureKit capture → optional facecam compositing →
+/// H.264 encode → RTMP/SRT/WHIP publish, all in one process).
+///
+/// This replaces the old hard `maxStreamShortEdge = 720` / `min(fps, 30)`
+/// constants that made the headline 1080p60 target unreachable. The ceiling is
+/// derived from real device signals (core count + physical memory) so a capable
+/// phone unlocks 1080p60 while an older one stays at a safe 720p30. The
+/// *thermal* half of "capability" is layered on top at runtime by
+/// `ThermalPowerGovernor` + the adaptive controller, which pull the live rate
+/// back below this static ceiling whenever the device runs warm or low on power.
+///
+/// The derivation is a pure function of injected values (`device(processorCount:
+/// physicalMemory:)`) so it is deterministic and unit-testable on CI, which runs
+/// the StreamCore suite on whatever simulator the runner ships. Only `current`
+/// reads the live `ProcessInfo`, and that is used exclusively by the app.
+public struct StreamCapability: Equatable, Sendable {
+    /// Largest encoded SHORT edge (px) this device may stream. The long edge
+    /// follows the screen's real aspect ratio. 1080 on capable devices, else 720.
+    public let maxShortEdge: Int
+    /// Highest encoded frame rate (fps) this device may stream. 60 on capable
+    /// devices, else 30. The thermal governor caps this further at runtime.
+    public let maxFrameRate: Int
+
+    public init(maxShortEdge: Int, maxFrameRate: Int) {
+        self.maxShortEdge = maxShortEdge
+        self.maxFrameRate = maxFrameRate
+    }
+
+    // MARK: - Device signal thresholds
+
+    /// ≈6 GB+ of RAM (reported physical memory sits a little under the nominal
+    /// spec, so 5.0 GB is a safe divider between 4 GB and 6 GB devices). Devices
+    /// at or above this — iPhone 14 Pro / 15 / 16 / 17-class and recent iPad
+    /// Pro/Air — have the memory headroom to run capture + compositing + a real
+    /// 1080p60 encoder without tripping jetsam.
+    static let highMemoryFloor: UInt64 = 5_000_000_000
+    /// ≈4 GB of RAM (3.3 GB divider sits between the ~2.9 GB a 3 GB device
+    /// reports and the ~3.7 GB a 4 GB device reports). Enough for 1080p30, but
+    /// not the doubled encoder + capture load of 60 fps.
+    static let midMemoryFloor: UInt64 = 3_300_000_000
+    /// 1080p60's encoder throughput needs the full performance-core complement;
+    /// every 6 GB+ iPhone and iPad reports at least this many logical cores.
+    static let highCoreFloor = 6
+
+    // MARK: - Derivation
+
+    /// Derives the ceiling from device signals. Resolution and frame rate are
+    /// gated independently so a mid-tier device still gets 1080p (at 30 fps)
+    /// rather than being dropped all the way to 720p:
+    ///
+    /// - 6 GB+ & ≥6 cores → **1080p60** (the headline target)
+    /// - 4 GB            → **1080p30**
+    /// - ≤3 GB           → **720p30**
+    ///
+    /// Deliberately conservative: the thermal governor can only pull the rate
+    /// *down* from here, so the ceiling must be a rate the device can actually
+    /// hold when cool, not an aspirational peak.
+    public static func device(
+        processorCount: Int = ProcessInfo.processInfo.processorCount,
+        physicalMemory: UInt64 = ProcessInfo.processInfo.physicalMemory
+    ) -> StreamCapability {
+        let maxShortEdge = physicalMemory >= midMemoryFloor ? 1080 : 720
+        let maxFrameRate = (physicalMemory >= highMemoryFloor && processorCount >= highCoreFloor)
+            ? 60 : 30
+        return StreamCapability(maxShortEdge: maxShortEdge, maxFrameRate: maxFrameRate)
+    }
+
+    /// This device's ceiling, computed once from the live `ProcessInfo`. Used by
+    /// the app (encoder, capture pacing, and the Settings pickers). Tests use
+    /// `device(processorCount:physicalMemory:)` with injected values instead so
+    /// they never depend on the CI runner's hardware.
+    public static let current = device()
+}

StreamCore/StreamSettings.swift

@@ -210,18 +210,15 @@ public struct StreamSettings: Codable, Equatable, Sendable {
         }
     }
 
-    /// Conservative ceiling on the encoded stream's short edge. Screen capture,
-    /// facecam composition, encoding, chat, and publishing now share the app
-    /// process, so 720p remains the stable default across supported devices.
-    public static let maxStreamShortEdge = 720
-
     /// Derives the encode dimensions from the live (already upright-oriented)
     /// screen size, preserving the real aspect ratio. The short edge is clamped to
-    /// `videoQuality` (never upscaled above the source) AND to `maxStreamShortEdge`,
-    /// and both edges are rounded to even numbers as required by H.264/HEVC. Locking
-    /// this at broadcast start keeps the RTMP resolution stable for the whole session.
-    public func encodeSize(forOrientedWidth width: Int, height: Int) -> CGSize {
-        let targetShortEdge = min(videoQuality, Self.maxStreamShortEdge)
+    /// `videoQuality` (never upscaled above the source) AND to `maxShortEdge` — the
+    /// device-capability ceiling from `StreamCapability` (1080 on capable hardware,
+    /// 720 otherwise) that replaced the old hard-coded 720 cap. Both edges are
+    /// rounded to even numbers as required by H.264/HEVC. Locking this at broadcast
+    /// start keeps the stream resolution stable for the whole session.
+    public func encodeSize(forOrientedWidth width: Int, height: Int, maxShortEdge: Int) -> CGSize {
+        let targetShortEdge = max(2, min(videoQuality, maxShortEdge))
         guard width > 0, height > 0 else {
             // Fallback to a portrait 9:16 canvas at the (capped) chosen quality.
             return CGSize(width: even(targetShortEdge), height: even(targetShortEdge * 16 / 9))
@@ -233,6 +230,15 @@ public struct StreamSettings: Codable, Equatable, Sendable {
         return CGSize(width: max(2, w), height: max(2, h))
     }
 
+    /// The encode frame rate for a device capability: the user's chosen rate
+    /// clamped to `[1, maxFrameRate]`. `maxFrameRate` is `StreamCapability`'s
+    /// device ceiling (60 on capable hardware, else 30); this replaced the hard
+    /// `min(frameRate, 30)` scattered across the encode/repeat paths. The thermal
+    /// governor and adaptive controller cap the live rate further at runtime.
+    public func encodeFrameRate(maxFrameRate: Int) -> Int {
+        min(max(frameRate, 1), max(1, maxFrameRate))
+    }
+
     /// Derives the local backup's encode dimensions. `streamSize` is the locked
     /// RTMP encode size (already aspect-correct for the screen); `sourceShortEdge`
     /// is the short edge of the actual frames the mixer emits (native screen size