Overdrive je Programm: bis 400 %, aber nur auf Ansage

Der Regler ging bisher immer bis 200 %, ohne dass man das wollen musste. Jetzt
endet er bei 100 % — der Stellung, in der ein Programm klingt, wie es gemeint
war —, und ein Blitz in der Zeile gibt den Bereich darüber frei. Je Programm:
ein Browser braucht ihn für eine leise Konferenz, die Musik daneben nicht.

Oberhalb von 100 % gilt die Kennlinie nicht mehr. Dort steht die Zahl für den
Faktor selbst: 400 % sind das Vierfache der Amplitude. Mit der Kennlinie wären
daraus 4^1,66 ≈ 10,4 geworden — eine Beschriftung, die etwas anderes verspricht,
als der Regler tut. Bei genau 100 % stimmen beide Hälften überein, die Kurve hat
also keinen Sprung, nur einen Knick. Unterhalb bleibt alles wie es war.

Beim Abschalten wird die Lautstärke zurückgeholt. Sonst bliebe ein Programm
dreifach verstärkt, während sein Regler am rechten Anschlag steht und 100 %
anzeigt. Dasselbe beim Laden alter Einstellungen: ein gespeichertes 180 % aus
der Zeit ohne Freigabe fällt auf 100 %.

Die 100 %-Markierung im Regler erscheint nur noch mit Overdrive — ohne ihn läge
sie am rechten Anschlag und sagte dort nichts mehr.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Packages/OnyxKit/Sources/AudioProvider/Gain.swift

@@ -3,12 +3,22 @@ import Foundation
 /// Rechnet Reglerstellung in Verstärkung um.
 public enum Gain {
 
-    /// Zweifache Lautstärke ist die Obergrenze.
+    /// Ohne Overdrive ist bei 100 % Schluss.
     ///
-    /// Mehr wäre technisch möglich und praktisch sinnlos: bei doppelter
-    /// Verstärkung arbeitet der Begrenzer bereits deutlich, darüber bleibt vom
-    /// Signal nur noch Kompression übrig.
-    public static let maximumVolume: Double = 2.0
+    /// Das ist die Stellung, in der das Programm klingt, wie es gemeint war.
+    /// Alles darüber ist ein Eingriff und soll auch einer sein.
+    public static let maximumVolume: Double = 1.0
+
+    /// Mit Overdrive: das Vierfache.
+    ///
+    /// Für leise Videokonferenzen und schlecht ausgesteuerte Videos. Darüber
+    /// hinaus bringt es nichts mehr — der Begrenzer drückt dann alles zusammen,
+    /// und was lauter wird, ist vor allem das Grundrauschen der Quelle.
+    public static let overdriveMaximum: Double = 4.0
+
+    public static func maximum(overdrive: Bool) -> Double {
+        overdrive ? overdriveMaximum : maximumVolume
+    }
 
     /// Verstärkungsfaktor zu einer Reglerstellung von 0 bis 2.
     ///
@@ -25,10 +35,17 @@ public enum Gain {
     /// aber die Formel steht in einem Echtzeitpfad.
     public static let taper: Double = 1.66
 
+    /// Oberhalb von 100 % gilt die Kennlinie **nicht**.
+    ///
+    /// Dort steht die Zahl für den Faktor selbst: 400 % sind das Vierfache der
+    /// Amplitude. Mit der Kennlinie wären daraus 4^1,66 ≈ 10,4 geworden — eine
+    /// Beschriftung, die etwas anderes verspricht, als der Regler tut. Bei
+    /// genau 100 % stimmen beide Hälften überein, die Kurve hat also keinen
+    /// Sprung, nur einen Knick.
     public static func factor(forVolume volume: Double) -> Double {
-        let clamped = min(max(volume, 0), maximumVolume)
+        let clamped = min(max(volume, 0), overdriveMaximum)
         guard clamped > 0 else { return 0 }
-        return pow(clamped, taper)
+        return clamped <= 1 ? pow(clamped, taper) : clamped
     }
 }
 
@@ -64,6 +81,7 @@ public struct VolumeStore: Sendable {
 
     private var volumes: [String: Double] = [:]
     private var muted: Set<String> = []
+    private var overdrive: Set<String> = []
 
     public init() {}
 
@@ -77,7 +95,26 @@ public struct VolumeStore: Sendable {
     public func isMuted(for bundleID: String) -> Bool { muted.contains(bundleID) }
 
     public mutating func set(_ volume: Double, for bundleID: String) {
-        volumes[bundleID] = min(max(volume, 0), Gain.maximumVolume)
+        volumes[bundleID] = min(max(volume, 0), Gain.maximum(overdrive: isOverdriven(bundleID)))
+    }
+
+    public func isOverdriven(_ bundleID: String) -> Bool { overdrive.contains(bundleID) }
+
+    /// Schaltet den erweiterten Bereich frei.
+    ///
+    /// Beim Abschalten wird die Lautstärke zurückgeholt: ein Wert von 340 %
+    /// bliebe sonst wirksam, obwohl der Regler ihn gar nicht mehr darstellen
+    /// kann — der Knopf säße am rechten Anschlag und das Programm wäre trotzdem
+    /// dreifach verstärkt.
+    public mutating func setOverdrive(_ isOn: Bool, for bundleID: String) {
+        if isOn {
+            overdrive.insert(bundleID)
+        } else {
+            overdrive.remove(bundleID)
+            if let volume = volumes[bundleID], volume > Gain.maximumVolume {
+                volumes[bundleID] = Gain.maximumVolume
+            }
+        }
     }
 
     public mutating func setMuted(_ isMuted: Bool, for bundleID: String) {
@@ -95,9 +132,17 @@ public struct VolumeStore: Sendable {
 
     public var snapshot: [String: Double] { volumes }
     public var mutedIdentifiers: [String] { Array(muted) }
+    public var overdrivenIdentifiers: [String] { Array(overdrive) }
 
-    public init(volumes: [String: Double], muted: [String]) {
-        self.volumes = volumes
+    public init(volumes: [String: Double], muted: [String], overdrive: [String] = []) {
+        // Der Overdrive zuerst: sonst schneidet das Einsetzen der Lautstärken
+        // alles über 100 % ab, was gerade wiederhergestellt werden soll.
+        self.overdrive = Set(overdrive)
+        let allowed = Set(overdrive)
+        self.volumes = volumes.reduce(into: [:]) { result, entry in
+            let maximum = Gain.maximum(overdrive: allowed.contains(entry.key))
+            result[entry.key] = min(max(entry.value, 0), maximum)
+        }
         self.muted = Set(muted)
     }
 }