Phase 7: Per-Programm-Audiomixer über Core-Audio-Taps
Ein Tap mit mutedWhenTapped schaltet die ursprüngliche Ausgabe eines Programms stumm und liefert das Signal stattdessen bei Onyx ab; ein privates Aggregate-Device aus Tap und echtem Ausgabegerät gibt es nach der Verstärkung wieder aus. Das ist der einzige Weg, den macOS ohne eigenen Treiber anbietet. Die Kennlinie ist hergeleitet, nicht geraten: halbe empfundene Lautstärke sind rund −10 dB, also Faktor 0,316. Aus 0,5^k = 0,316 folgt k ≈ 1,66. Die Skala ist damit symmetrisch — 50 % sind −10 dB, 200 % sind +10 dB. Mein erster Ansatz mit der vierten Potenz ergab bei halbem Regler 6 % statt 32 %; der Test hat das gefangen, bevor es an einen Lautsprecher kam. Über 100 % greift ein weicher Begrenzer. Ohne ihn schneidet die Hardware die Werte hart ab, und das knackt hörbar. Er arbeitet erst ab 0,7, weil eine Begrenzung, die schon bei Zimmerlautstärke einsetzt, matt klingt. Der Mixer ist standardmäßig aus, und auch eingeschaltet greift er nur bei ausdrücklich gewählten Programmen ein. Alles andere läuft unverändert vorbei. Der Notausschalter steht sichtbar in der Ansicht, nicht in einem Menü: wenn der Ton weg ist, ist das der Knopf, den man sucht. Drei Fehlerfälle sind eingeplant, weil jeder von ihnen ein stummes Programm bedeutet. Der Wachhund baut Taps neu auf, die nur noch Stille liefern — der bekannte Fall aus Spike C. Ein Wechsel des Ausgabegeräts baut alle Taps neu auf, weil sie am alten Gerät hängen. Und ein fehlgeschlagener Aufbau räumt sich selbst weg, statt in einem halben Zustand zu verharren. Beim Beenden von Onyx wird der Mixer abgebaut: sonst bleiben die abgegriffenen Programme stumm zurück. 178 Tests grün, App-Signatur gültig.
This commit is contained in:
Guido Schmit
276
Packages/OnyxKit/Sources/AudioProvider/AudioMixer.swift
Normal file
276
Packages/OnyxKit/Sources/AudioProvider/AudioMixer.swift
Normal file
@@ -0,0 +1,276 @@
|
||||
import Foundation
|
||||
import AppKit
|
||||
import CoreAudio
|
||||
import OSLog
|
||||
|
||||
private let log = Logger(subsystem: "com.scarriffleservices.onyx", category: "Audio")
|
||||
|
||||
/// Der Per-Programm-Lautstärkemixer.
|
||||
///
|
||||
/// **Er ist standardmäßig aus.** Eingeschaltet greift er in den Tonweg jedes
|
||||
/// gewählten Programms ein — geht dabei etwas schief, ist das Programm still.
|
||||
/// Ein Werkzeug, das ungefragt zwischen Musik und Lautsprecher tritt, hat man
|
||||
/// sich nicht ausgesucht.
|
||||
@MainActor
|
||||
@Observable
|
||||
public final class AudioMixer {
|
||||
|
||||
public private(set) var processes: [AudioProcess] = []
|
||||
public private(set) var isEnabled = false
|
||||
public private(set) var lastError: String?
|
||||
|
||||
/// Programme, die vom Mixer bearbeitet werden. Alle anderen laufen
|
||||
/// unverändert am Mixer vorbei.
|
||||
public private(set) var managed: Set<String> = []
|
||||
|
||||
private var store = VolumeStore()
|
||||
private var taps: [String: ProcessTap] = [:]
|
||||
private var refreshTimer: Timer?
|
||||
private var watchdogTimer: Timer?
|
||||
private let defaults: UserDefaults
|
||||
|
||||
private enum Keys {
|
||||
static let volumes = "onyx.audio.volumes"
|
||||
static let muted = "onyx.audio.muted"
|
||||
static let managed = "onyx.audio.managed"
|
||||
}
|
||||
|
||||
public init(defaults: UserDefaults = .standard) {
|
||||
self.defaults = defaults
|
||||
let volumes = defaults.dictionary(forKey: Keys.volumes) as? [String: Double] ?? [:]
|
||||
let muted = defaults.stringArray(forKey: Keys.muted) ?? []
|
||||
store = VolumeStore(volumes: volumes, muted: muted)
|
||||
managed = Set(defaults.stringArray(forKey: Keys.managed) ?? [])
|
||||
}
|
||||
|
||||
// MARK: - Ein und aus
|
||||
|
||||
public func enable() {
|
||||
guard !isEnabled else { return }
|
||||
isEnabled = true
|
||||
refresh()
|
||||
|
||||
refreshTimer = Timer.scheduledTimer(withTimeInterval: 3, repeats: true) { _ in
|
||||
MainActor.assumeIsolated { [weak self] in self?.refresh() }
|
||||
}
|
||||
// Der bekannte Fehlerfall aus Spike C: Taps liefern nach einiger Zeit
|
||||
// nur noch Nullen. Von außen sieht das aus, als wäre das Programm
|
||||
// stumm — und genau das ist es dann auch, weil der Tap das Original
|
||||
// stummschaltet.
|
||||
watchdogTimer = Timer.scheduledTimer(withTimeInterval: 5, repeats: true) { _ in
|
||||
MainActor.assumeIsolated { [weak self] in self?.checkForStalledTaps() }
|
||||
}
|
||||
observeDeviceChanges()
|
||||
log.notice("Mixer eingeschaltet")
|
||||
}
|
||||
|
||||
/// Notausschalter. Stellt den unveränderten Systemzustand wieder her.
|
||||
///
|
||||
/// Muss immer erreichbar sein und darf nie fehlschlagen: wenn der Ton weg
|
||||
/// ist, ist das der Knopf, den man sucht.
|
||||
public func disable() {
|
||||
isEnabled = false
|
||||
refreshTimer?.invalidate(); refreshTimer = nil
|
||||
watchdogTimer?.invalidate(); watchdogTimer = nil
|
||||
for tap in taps.values { tap.stop() }
|
||||
taps.removeAll()
|
||||
lastError = nil
|
||||
log.notice("Mixer ausgeschaltet — Tonweg unverändert")
|
||||
}
|
||||
|
||||
// MARK: - Programme
|
||||
|
||||
private func refresh() {
|
||||
processes = Self.currentProcesses()
|
||||
syncTaps()
|
||||
}
|
||||
|
||||
/// Legt Taps an und ab, sodass sie zu `managed` und den laufenden
|
||||
/// Programmen passen.
|
||||
private func syncTaps() {
|
||||
guard isEnabled else { return }
|
||||
guard let outputUID = Self.defaultOutputUID() else {
|
||||
lastError = AudioMixerError.noOutputDevice.errorDescription
|
||||
return
|
||||
}
|
||||
|
||||
let wanted = Set(processes.filter { managed.contains($0.bundleID) }.map(\.bundleID))
|
||||
|
||||
// Beendete oder abgewählte Programme freigeben — sonst bliebe der Tap
|
||||
// stehen und schaltete ein Programm stumm, das gar nicht mehr gemeint ist.
|
||||
for (bundleID, tap) in taps where !wanted.contains(bundleID) {
|
||||
tap.stop()
|
||||
taps[bundleID] = nil
|
||||
}
|
||||
|
||||
for process in processes where wanted.contains(process.bundleID) {
|
||||
if let existing = taps[process.bundleID] {
|
||||
existing.setGain(store.effectiveGain(for: process.bundleID))
|
||||
continue
|
||||
}
|
||||
let tap = ProcessTap(process: process)
|
||||
tap.setGain(store.effectiveGain(for: process.bundleID))
|
||||
do {
|
||||
try tap.start(outputDeviceUID: outputUID)
|
||||
taps[process.bundleID] = tap
|
||||
lastError = nil
|
||||
} catch {
|
||||
// Bei einem Fehlschlag nicht in einem halben Zustand
|
||||
// verharren: das Programm bleibt sonst stumm zurück.
|
||||
tap.stop()
|
||||
managed.remove(process.bundleID)
|
||||
persist()
|
||||
lastError = error.localizedDescription
|
||||
log.error("Tap für \(process.name, privacy: .public) fehlgeschlagen: \(error.localizedDescription, privacy: .public)")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Baut Taps neu auf, die nur noch Stille liefern.
|
||||
private func checkForStalledTaps() {
|
||||
for (bundleID, tap) in taps {
|
||||
guard tap.isRunning,
|
||||
Date().timeIntervalSince(tap.lastAudioAt) > 30,
|
||||
processes.first(where: { $0.bundleID == bundleID })?.isPlaying == true
|
||||
else { continue }
|
||||
|
||||
log.error("Tap für \(bundleID, privacy: .public) liefert nur Stille — Neuaufbau")
|
||||
tap.stop()
|
||||
taps[bundleID] = nil
|
||||
}
|
||||
syncTaps()
|
||||
}
|
||||
|
||||
/// Wechselt das Ausgabegerät, müssen alle Taps neu aufgebaut werden: sie
|
||||
/// hängen am alten Gerät und gäben ins Leere aus.
|
||||
private func observeDeviceChanges() {
|
||||
var address = AudioObjectPropertyAddress(
|
||||
mSelector: kAudioHardwarePropertyDefaultOutputDevice,
|
||||
mScope: kAudioObjectPropertyScopeGlobal,
|
||||
mElement: kAudioObjectPropertyElementMain)
|
||||
|
||||
AudioObjectAddPropertyListenerBlock(
|
||||
AudioObjectID(kAudioObjectSystemObject), &address, .main) { [weak self] _, _ in
|
||||
MainActor.assumeIsolated {
|
||||
guard let self, self.isEnabled else { return }
|
||||
log.notice("Ausgabegerät gewechselt — Taps werden neu aufgebaut")
|
||||
for tap in self.taps.values { tap.stop() }
|
||||
self.taps.removeAll()
|
||||
self.syncTaps()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Steuerung
|
||||
|
||||
public func isManaged(_ bundleID: String) -> Bool { managed.contains(bundleID) }
|
||||
|
||||
public func setManaged(_ isManaged: Bool, for bundleID: String) {
|
||||
if isManaged { managed.insert(bundleID) } else { managed.remove(bundleID) }
|
||||
persist()
|
||||
syncTaps()
|
||||
}
|
||||
|
||||
public func volume(for bundleID: String) -> Double { store.volume(for: bundleID) }
|
||||
public func isMuted(_ bundleID: String) -> Bool { store.isMuted(for: bundleID) }
|
||||
|
||||
public func setVolume(_ volume: Double, for bundleID: String) {
|
||||
store.set(volume, for: bundleID)
|
||||
taps[bundleID]?.setGain(store.effectiveGain(for: bundleID))
|
||||
persist()
|
||||
}
|
||||
|
||||
public func setMuted(_ isMuted: Bool, for bundleID: String) {
|
||||
store.setMuted(isMuted, for: bundleID)
|
||||
taps[bundleID]?.setGain(store.effectiveGain(for: bundleID))
|
||||
persist()
|
||||
}
|
||||
|
||||
private func persist() {
|
||||
defaults.set(store.snapshot, forKey: Keys.volumes)
|
||||
defaults.set(store.mutedIdentifiers, forKey: Keys.muted)
|
||||
defaults.set(Array(managed), forKey: Keys.managed)
|
||||
}
|
||||
|
||||
// MARK: - Core Audio
|
||||
|
||||
static func currentProcesses() -> [AudioProcess] {
|
||||
var address = AudioObjectPropertyAddress(
|
||||
mSelector: kAudioHardwarePropertyProcessObjectList,
|
||||
mScope: kAudioObjectPropertyScopeGlobal,
|
||||
mElement: kAudioObjectPropertyElementMain)
|
||||
|
||||
var size: UInt32 = 0
|
||||
guard AudioObjectGetPropertyDataSize(AudioObjectID(kAudioObjectSystemObject),
|
||||
&address, 0, nil, &size) == noErr, size > 0
|
||||
else { return [] }
|
||||
|
||||
let count = Int(size) / MemoryLayout<AudioObjectID>.stride
|
||||
let raw = UnsafeMutableRawPointer.allocate(byteCount: Int(size),
|
||||
alignment: MemoryLayout<AudioObjectID>.alignment)
|
||||
defer { raw.deallocate() }
|
||||
guard AudioObjectGetPropertyData(AudioObjectID(kAudioObjectSystemObject),
|
||||
&address, 0, nil, &size, raw) == noErr else { return [] }
|
||||
|
||||
let objects = Array(UnsafeBufferPointer(
|
||||
start: raw.assumingMemoryBound(to: AudioObjectID.self), count: count))
|
||||
|
||||
return objects.compactMap { object -> AudioProcess? in
|
||||
guard let bundleID = string(object, kAudioProcessPropertyBundleID),
|
||||
!bundleID.isEmpty else { return nil }
|
||||
let pid = value(object, kAudioProcessPropertyPID, pid_t(0)) ?? -1
|
||||
|
||||
// Systemdienste wie coreaudiod oder die Sprachausgabe gehören nicht
|
||||
// in eine Liste, in der man „Spotify leiser" sucht.
|
||||
guard !bundleID.hasPrefix("com.apple.audio"),
|
||||
!bundleID.hasPrefix("com.apple.core") else { return nil }
|
||||
|
||||
let name = NSRunningApplication(processIdentifier: pid)?.localizedName ?? bundleID
|
||||
let playing = (value(object, kAudioProcessPropertyIsRunningOutput, UInt32(0)) ?? 0) != 0
|
||||
return AudioProcess(objectID: object, pid: pid, bundleID: bundleID,
|
||||
name: name, isPlaying: playing)
|
||||
}
|
||||
// Was gerade klingt, gehört nach oben.
|
||||
.sorted { ($0.isPlaying ? 0 : 1, $0.name.lowercased())
|
||||
< ($1.isPlaying ? 0 : 1, $1.name.lowercased()) }
|
||||
}
|
||||
|
||||
static func defaultOutputUID() -> String? {
|
||||
var address = AudioObjectPropertyAddress(
|
||||
mSelector: kAudioHardwarePropertyDefaultOutputDevice,
|
||||
mScope: kAudioObjectPropertyScopeGlobal,
|
||||
mElement: kAudioObjectPropertyElementMain)
|
||||
guard let device = value(AudioObjectID(kAudioObjectSystemObject), nil,
|
||||
AudioObjectID(kAudioObjectUnknown), address: &address)
|
||||
else { return nil }
|
||||
return string(device, kAudioDevicePropertyDeviceUID)
|
||||
}
|
||||
|
||||
private static func value<T>(_ object: AudioObjectID, _ selector: AudioObjectPropertySelector?,
|
||||
_ initial: T,
|
||||
address custom: UnsafeMutablePointer<AudioObjectPropertyAddress>? = nil)
|
||||
-> T? {
|
||||
var address = custom?.pointee ?? AudioObjectPropertyAddress(
|
||||
mSelector: selector ?? 0, mScope: kAudioObjectPropertyScopeGlobal,
|
||||
mElement: kAudioObjectPropertyElementMain)
|
||||
var result = initial
|
||||
var size = UInt32(MemoryLayout<T>.size)
|
||||
guard AudioObjectGetPropertyData(object, &address, 0, nil, &size, &result) == noErr
|
||||
else { return nil }
|
||||
return result
|
||||
}
|
||||
|
||||
private static func string(_ object: AudioObjectID,
|
||||
_ selector: AudioObjectPropertySelector) -> String? {
|
||||
var address = AudioObjectPropertyAddress(
|
||||
mSelector: selector, mScope: kAudioObjectPropertyScopeGlobal,
|
||||
mElement: kAudioObjectPropertyElementMain)
|
||||
var result: CFString?
|
||||
var size = UInt32(MemoryLayout<CFString?>.size)
|
||||
let status = withUnsafeMutablePointer(to: &result) {
|
||||
AudioObjectGetPropertyData(object, &address, 0, nil, &size, $0)
|
||||
}
|
||||
guard status == noErr, let result else { return nil }
|
||||
return result as String
|
||||
}
|
||||
}
|
||||
103
Packages/OnyxKit/Sources/AudioProvider/Gain.swift
Normal file
103
Packages/OnyxKit/Sources/AudioProvider/Gain.swift
Normal file
@@ -0,0 +1,103 @@
|
||||
import Foundation
|
||||
|
||||
/// Rechnet Reglerstellung in Verstärkung um.
|
||||
public enum Gain {
|
||||
|
||||
/// Zweifache Lautstärke ist die Obergrenze.
|
||||
///
|
||||
/// 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
|
||||
|
||||
/// Verstärkungsfaktor zu einer Reglerstellung von 0 bis 2.
|
||||
///
|
||||
/// Bewusst nicht linear. Lautstärke wird ungefähr logarithmisch
|
||||
/// wahrgenommen; ein linearer Regler wäre in der unteren Hälfte praktisch
|
||||
/// wirkungslos und in der oberen viel zu empfindlich.
|
||||
///
|
||||
/// Der Exponent ist hergeleitet, nicht geraten: halbe empfundene Lautstärke
|
||||
/// entspricht rund −10 dB, also Faktor 0,316. Aus 0,5^k = 0,316 folgt
|
||||
/// k ≈ 1,66. Damit klingt der halbe Reglerweg auch halb so laut.
|
||||
///
|
||||
/// Eine Potenz statt einer Dezibel-Rechnung, weil hier kein Logarithmus je
|
||||
/// Abtastwert anfallen soll — der Faktor wird einmal je Puffer bestimmt,
|
||||
/// aber die Formel steht in einem Echtzeitpfad.
|
||||
public static let taper: Double = 1.66
|
||||
|
||||
public static func factor(forVolume volume: Double) -> Double {
|
||||
let clamped = min(max(volume, 0), maximumVolume)
|
||||
guard clamped > 0 else { return 0 }
|
||||
return pow(clamped, taper)
|
||||
}
|
||||
}
|
||||
|
||||
/// Weiche Begrenzung.
|
||||
///
|
||||
/// Bei zweifacher Verstärkung entstehen Abtastwerte weit über dem gültigen
|
||||
/// Bereich. Ungebremst schneidet die Hardware sie hart ab, und das knackt
|
||||
/// hörbar. Der Tangens hyperbolicus biegt sie stattdessen sanft um: leise
|
||||
/// Signale bleiben unangetastet, laute werden zunehmend gestaucht.
|
||||
public enum SoftClip {
|
||||
|
||||
/// Ab hier greift die Kennlinie. Darunter bleibt das Signal unverändert —
|
||||
/// eine Begrenzung, die schon bei Zimmerlautstärke arbeitet, klingt matt.
|
||||
public static let threshold: Float = 0.7
|
||||
|
||||
public static func apply(_ sample: Float) -> Float {
|
||||
let magnitude = abs(sample)
|
||||
guard magnitude > threshold else { return sample }
|
||||
|
||||
let excess = magnitude - threshold
|
||||
let headroom = 1 - threshold
|
||||
let compressed = threshold + headroom * tanh(excess / headroom)
|
||||
return sample < 0 ? -compressed : compressed
|
||||
}
|
||||
}
|
||||
|
||||
/// Merkt sich Lautstärke und Stummschaltung je Programm.
|
||||
///
|
||||
/// Nach der Bundle-Kennung, nicht nach Prozessnummer: die ändert sich bei
|
||||
/// jedem Start, und eine Einstellung, die einen Neustart des Programms nicht
|
||||
/// überlebt, ist keine.
|
||||
public struct VolumeStore: Sendable {
|
||||
|
||||
private var volumes: [String: Double] = [:]
|
||||
private var muted: Set<String> = []
|
||||
|
||||
public init() {}
|
||||
|
||||
/// Unbekannte Programme starten auf voller Lautstärke — nicht auf null.
|
||||
/// Ein Programm, das nach dem Start stumm ist, wirkt kaputt, und niemand
|
||||
/// sucht die Ursache im Mixer.
|
||||
public func volume(for bundleID: String) -> Double {
|
||||
volumes[bundleID] ?? 1.0
|
||||
}
|
||||
|
||||
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)
|
||||
}
|
||||
|
||||
public mutating func setMuted(_ isMuted: Bool, for bundleID: String) {
|
||||
// Getrennt von der Lautstärke: sonst verliert man beim Stummschalten
|
||||
// den eingestellten Wert und muss ihn danach neu suchen.
|
||||
if isMuted { muted.insert(bundleID) } else { muted.remove(bundleID) }
|
||||
}
|
||||
|
||||
/// Was der Audiopfad tatsächlich anwenden soll.
|
||||
public func effectiveGain(for bundleID: String) -> Double {
|
||||
isMuted(for: bundleID) ? 0 : Gain.factor(forVolume: volume(for: bundleID))
|
||||
}
|
||||
|
||||
// MARK: - Sicherung
|
||||
|
||||
public var snapshot: [String: Double] { volumes }
|
||||
public var mutedIdentifiers: [String] { Array(muted) }
|
||||
|
||||
public init(volumes: [String: Double], muted: [String]) {
|
||||
self.volumes = volumes
|
||||
self.muted = Set(muted)
|
||||
}
|
||||
}
|
||||
24
Packages/OnyxKit/Sources/AudioProvider/Localizable.xcstrings
Normal file
24
Packages/OnyxKit/Sources/AudioProvider/Localizable.xcstrings
Normal file
@@ -0,0 +1,24 @@
|
||||
{
|
||||
"sourceLanguage" : "en",
|
||||
"strings" : {
|
||||
"mixer.name" : { "localizations" : {
|
||||
"de" : { "stringUnit" : { "state" : "translated", "value" : "Audio-Mixer" } },
|
||||
"en" : { "stringUnit" : { "state" : "translated", "value" : "Audio mixer" } } } },
|
||||
"mixer.on" : { "localizations" : {
|
||||
"de" : { "stringUnit" : { "state" : "translated", "value" : "Mixer einschalten" } },
|
||||
"en" : { "stringUnit" : { "state" : "translated", "value" : "Turn mixer on" } } } },
|
||||
"mixer.off" : { "localizations" : {
|
||||
"de" : { "stringUnit" : { "state" : "translated", "value" : "Mixer ausschalten" } },
|
||||
"en" : { "stringUnit" : { "state" : "translated", "value" : "Turn mixer off" } } } },
|
||||
"mixer.off.explain" : { "localizations" : {
|
||||
"de" : { "stringUnit" : { "state" : "translated", "value" : "Regelt die Lautstärke einzelner Programme, auch über 100 %." } },
|
||||
"en" : { "stringUnit" : { "state" : "translated", "value" : "Sets the volume of individual apps, including above 100%." } } } },
|
||||
"mixer.off.warning" : { "localizations" : {
|
||||
"de" : { "stringUnit" : { "state" : "translated", "value" : "Dafür greift Onyx in den Tonweg der ausgewählten Programme ein. Beim Ausschalten wird der ursprüngliche Zustand sofort wiederhergestellt." } },
|
||||
"en" : { "stringUnit" : { "state" : "translated", "value" : "Onyx intercepts the audio path of the selected apps to do this. Turning it off restores the original state immediately." } } } },
|
||||
"mixer.noProcesses" : { "localizations" : {
|
||||
"de" : { "stringUnit" : { "state" : "translated", "value" : "Kein Programm gibt gerade Ton aus" } },
|
||||
"en" : { "stringUnit" : { "state" : "translated", "value" : "No app is playing audio" } } } }
|
||||
},
|
||||
"version" : "1.0"
|
||||
}
|
||||
184
Packages/OnyxKit/Sources/AudioProvider/MixerView.swift
Normal file
184
Packages/OnyxKit/Sources/AudioProvider/MixerView.swift
Normal file
@@ -0,0 +1,184 @@
|
||||
import SwiftUI
|
||||
import AppKit
|
||||
import OnyxDesign
|
||||
import OnyxWidgetKit
|
||||
|
||||
/// Die Mischpult-Ansicht. Dieselbe im Panel und im Menüleisten-Popover.
|
||||
public struct MixerView: View {
|
||||
let mixer: AudioMixer
|
||||
/// Im Panel ist es eng, im Popover nicht.
|
||||
let compact: Bool
|
||||
|
||||
public init(mixer: AudioMixer, compact: Bool = false) {
|
||||
self.mixer = mixer
|
||||
self.compact = compact
|
||||
}
|
||||
|
||||
public var body: some View {
|
||||
VStack(alignment: .leading, spacing: compact ? 6 : 10) {
|
||||
if mixer.isEnabled {
|
||||
if mixer.processes.isEmpty {
|
||||
Text("mixer.noProcesses", bundle: .module)
|
||||
.font(Onyx.Font.caption)
|
||||
.foregroundStyle(Onyx.Color.textTertiary)
|
||||
} else {
|
||||
ForEach(mixer.processes.prefix(compact ? 4 : 10)) { process in
|
||||
ProcessRow(mixer: mixer, process: process, compact: compact)
|
||||
}
|
||||
}
|
||||
|
||||
if let error = mixer.lastError {
|
||||
Text(error).font(Onyx.Font.caption).foregroundStyle(Onyx.Color.critical)
|
||||
.fixedSize(horizontal: false, vertical: true)
|
||||
}
|
||||
|
||||
Divider().overlay(Onyx.Color.hairline)
|
||||
// Der Notausschalter gehört sichtbar dazu, nicht in ein Menü:
|
||||
// wenn der Ton weg ist, ist das der Knopf, den man sucht.
|
||||
Button { mixer.disable() } label: {
|
||||
Label("mixer.off", systemImage: "power")
|
||||
.font(Onyx.Font.caption)
|
||||
}
|
||||
.buttonStyle(.plain)
|
||||
.foregroundStyle(Onyx.Color.textSecondary)
|
||||
} else {
|
||||
OffState(mixer: mixer, compact: compact)
|
||||
}
|
||||
}
|
||||
.frame(maxWidth: .infinity, alignment: .leading)
|
||||
}
|
||||
}
|
||||
|
||||
/// Der ausgeschaltete Zustand erklärt, worauf man sich einlässt.
|
||||
private struct OffState: View {
|
||||
let mixer: AudioMixer
|
||||
let compact: Bool
|
||||
|
||||
var body: some View {
|
||||
VStack(alignment: .leading, spacing: 6) {
|
||||
Text("mixer.off.explain", bundle: .module)
|
||||
.font(Onyx.Font.caption)
|
||||
.foregroundStyle(Onyx.Color.textSecondary)
|
||||
.fixedSize(horizontal: false, vertical: true)
|
||||
|
||||
if !compact {
|
||||
Text("mixer.off.warning", bundle: .module)
|
||||
.font(Onyx.Font.caption)
|
||||
.foregroundStyle(Onyx.Color.textTertiary)
|
||||
.fixedSize(horizontal: false, vertical: true)
|
||||
}
|
||||
|
||||
Button { mixer.enable() } label: {
|
||||
Label("mixer.on", systemImage: "slider.horizontal.3").font(Onyx.Font.caption)
|
||||
}
|
||||
.buttonStyle(.plain)
|
||||
.foregroundStyle(Onyx.Color.accent)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private struct ProcessRow: View {
|
||||
let mixer: AudioMixer
|
||||
let process: AudioProcess
|
||||
let compact: Bool
|
||||
|
||||
var body: some View {
|
||||
let managed = mixer.isManaged(process.bundleID)
|
||||
|
||||
VStack(alignment: .leading, spacing: 2) {
|
||||
HStack(spacing: 6) {
|
||||
icon
|
||||
Text(process.name)
|
||||
.font(Onyx.Font.caption)
|
||||
.foregroundStyle(process.isPlaying ? Onyx.Color.textPrimary
|
||||
: Onyx.Color.textSecondary)
|
||||
.lineLimit(1)
|
||||
|
||||
if process.isPlaying {
|
||||
Circle().fill(Onyx.Color.positive).frame(width: 5, height: 5)
|
||||
}
|
||||
Spacer(minLength: 0)
|
||||
|
||||
if managed {
|
||||
Text("\(Int(mixer.volume(for: process.bundleID) * 100)) %")
|
||||
.font(Onyx.Font.metricSmall)
|
||||
.foregroundStyle(mixer.volume(for: process.bundleID) > 1
|
||||
? Onyx.Color.warning : Onyx.Color.textTertiary)
|
||||
|
||||
Button {
|
||||
mixer.setMuted(!mixer.isMuted(process.bundleID), for: process.bundleID)
|
||||
} label: {
|
||||
Image(systemName: mixer.isMuted(process.bundleID)
|
||||
? "speaker.slash.fill" : "speaker.wave.2.fill")
|
||||
.font(.system(size: 10))
|
||||
}
|
||||
.buttonStyle(.plain)
|
||||
.foregroundStyle(mixer.isMuted(process.bundleID)
|
||||
? Onyx.Color.critical : Onyx.Color.textTertiary)
|
||||
}
|
||||
|
||||
// Erst wenn ein Programm ausgewählt ist, wird sein Ton
|
||||
// abgegriffen. Alles andere läuft unverändert am Mixer vorbei.
|
||||
Toggle("", isOn: Binding(
|
||||
get: { managed },
|
||||
set: { mixer.setManaged($0, for: process.bundleID) }))
|
||||
.toggleStyle(.switch)
|
||||
.controlSize(.mini)
|
||||
.labelsHidden()
|
||||
}
|
||||
|
||||
if managed {
|
||||
Slider(value: Binding(
|
||||
get: { mixer.volume(for: process.bundleID) },
|
||||
set: { mixer.setVolume($0, for: process.bundleID) }),
|
||||
in: 0...Gain.maximumVolume)
|
||||
.controlSize(.mini)
|
||||
.disabled(mixer.isMuted(process.bundleID))
|
||||
.overlay(alignment: .leading) {
|
||||
// Markierung bei 100 %: darüber wird verstärkt, und
|
||||
// man soll sehen, wann man diese Grenze überschreitet.
|
||||
GeometryReader { geometry in
|
||||
Rectangle()
|
||||
.fill(Onyx.Color.hairline)
|
||||
.frame(width: 1, height: 8)
|
||||
.offset(x: geometry.size.width / Gain.maximumVolume, y: 4)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ViewBuilder
|
||||
private var icon: some View {
|
||||
if let app = NSRunningApplication(processIdentifier: process.pid),
|
||||
let image = app.icon {
|
||||
Image(nsImage: image).resizable().frame(width: 14, height: 14)
|
||||
} else {
|
||||
Image(systemName: "app.dashed")
|
||||
.font(.system(size: 11))
|
||||
.foregroundStyle(Onyx.Color.textTertiary)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Widget
|
||||
|
||||
public struct AudioMixerWidget: OnyxWidget {
|
||||
public let id = "audio"
|
||||
public var displayName: String { String(localized: "mixer.name", bundle: .module) }
|
||||
public let symbolName = "slider.horizontal.3"
|
||||
public let supportedSizes: [WidgetSize] = [.medium, .large]
|
||||
|
||||
private let mixer: AudioMixer
|
||||
|
||||
public init(mixer: AudioMixer) { self.mixer = mixer }
|
||||
|
||||
public func makeView(size: WidgetSize) -> AnyView {
|
||||
AnyView(
|
||||
ScrollView {
|
||||
MixerView(mixer: mixer, compact: size == .medium)
|
||||
}
|
||||
.scrollIndicators(.never)
|
||||
)
|
||||
}
|
||||
}
|
||||
203
Packages/OnyxKit/Sources/AudioProvider/ProcessTap.swift
Normal file
203
Packages/OnyxKit/Sources/AudioProvider/ProcessTap.swift
Normal file
@@ -0,0 +1,203 @@
|
||||
import Foundation
|
||||
import AudioToolbox
|
||||
import CoreAudio
|
||||
import AVFoundation
|
||||
import OSLog
|
||||
|
||||
private let log = Logger(subsystem: "com.scarriffleservices.onyx", category: "Audio")
|
||||
|
||||
/// Ein Programm, das Ton ausgibt.
|
||||
public struct AudioProcess: Identifiable, Equatable, Sendable {
|
||||
public let objectID: AudioObjectID
|
||||
public let pid: pid_t
|
||||
public let bundleID: String
|
||||
public let name: String
|
||||
public let isPlaying: Bool
|
||||
|
||||
public var id: AudioObjectID { objectID }
|
||||
}
|
||||
|
||||
/// Fängt den Ton **eines** Programms ab, verstärkt ihn und gibt ihn wieder aus.
|
||||
///
|
||||
/// Der Weg ist der einzige, den macOS ohne Treiber anbietet: ein Process Tap
|
||||
/// mit `mutedWhenTapped` schaltet die ursprüngliche Ausgabe stumm und liefert
|
||||
/// das Signal stattdessen hier ab. Ein privates Aggregate-Device aus Tap und
|
||||
/// echtem Ausgabegerät gibt es nach der Bearbeitung wieder aus.
|
||||
///
|
||||
/// **Fällt dieser Aufbau auseinander, ist das Programm still.** Deshalb wird
|
||||
/// jeder Fehler zum Abbau des Taps führen, nicht zu einem halben Zustand — und
|
||||
/// deshalb gibt es einen Wachhund gegen die bekannten Null-Puffer.
|
||||
final class ProcessTap {
|
||||
|
||||
let process: AudioProcess
|
||||
/// Wird im Echtzeitpfad gelesen. `atomic` genügt hier nicht als Sprachmittel,
|
||||
/// aber ein einzelner `Float` wird auf arm64 atomar geschrieben.
|
||||
private(set) var gain: Float = 1
|
||||
|
||||
private var tapID = AudioObjectID(kAudioObjectUnknown)
|
||||
private var aggregateID = AudioObjectID(kAudioObjectUnknown)
|
||||
private var procID: AudioDeviceIOProcID?
|
||||
private let tapUUID = UUID()
|
||||
|
||||
/// Wann zuletzt ein Puffer mit Inhalt kam — für den Wachhund.
|
||||
private(set) var lastAudioAt = Date()
|
||||
private(set) var isRunning = false
|
||||
|
||||
init(process: AudioProcess) {
|
||||
self.process = process
|
||||
}
|
||||
|
||||
deinit { stop() }
|
||||
|
||||
func setGain(_ value: Double) {
|
||||
gain = Float(value)
|
||||
}
|
||||
|
||||
// MARK: - Aufbau
|
||||
|
||||
func start(outputDeviceUID: String) throws {
|
||||
guard !isRunning else { return }
|
||||
|
||||
let description = CATapDescription(stereoMixdownOfProcesses: [process.objectID])
|
||||
description.uuid = tapUUID
|
||||
description.name = "Onyx – \(process.name)"
|
||||
description.isPrivate = true
|
||||
// Der Kern des Ganzen: das Original wird stumm geschaltet, das Signal
|
||||
// kommt nur noch hier an. Ohne das hörte man beides gleichzeitig.
|
||||
description.muteBehavior = .mutedWhenTapped
|
||||
|
||||
var tap = AudioObjectID(kAudioObjectUnknown)
|
||||
let tapStatus = AudioHardwareCreateProcessTap(description, &tap)
|
||||
guard tapStatus == noErr else { throw AudioMixerError.tapFailed(tapStatus) }
|
||||
tapID = tap
|
||||
|
||||
let aggregate: [String: Any] = [
|
||||
kAudioAggregateDeviceNameKey: "Onyx Mixer – \(process.name)",
|
||||
kAudioAggregateDeviceUIDKey: UUID().uuidString,
|
||||
// Privat: das Gerät soll nicht in der Tonauswahl des Systems
|
||||
// auftauchen und auch nicht von anderen Programmen gewählt werden.
|
||||
kAudioAggregateDeviceIsPrivateKey: true,
|
||||
kAudioAggregateDeviceIsStackedKey: false,
|
||||
kAudioAggregateDeviceMainSubDeviceKey: outputDeviceUID,
|
||||
kAudioAggregateDeviceSubDeviceListKey: [[kAudioSubDeviceUIDKey: outputDeviceUID]],
|
||||
kAudioAggregateDeviceTapListKey: [[
|
||||
kAudioSubTapUIDKey: tapUUID.uuidString,
|
||||
kAudioSubTapDriftCompensationKey: true,
|
||||
]],
|
||||
]
|
||||
|
||||
var device = AudioObjectID(kAudioObjectUnknown)
|
||||
let aggregateStatus = AudioHardwareCreateAggregateDevice(aggregate as CFDictionary, &device)
|
||||
guard aggregateStatus == noErr else {
|
||||
cleanUp()
|
||||
throw AudioMixerError.aggregateFailed(aggregateStatus)
|
||||
}
|
||||
aggregateID = device
|
||||
|
||||
var proc: AudioDeviceIOProcID?
|
||||
let ioStatus = AudioDeviceCreateIOProcIDWithBlock(&proc, aggregateID, nil) {
|
||||
[weak self] _, inputData, _, outputData, _ in
|
||||
self?.render(input: inputData, output: outputData)
|
||||
}
|
||||
guard ioStatus == noErr, let proc else {
|
||||
cleanUp()
|
||||
throw AudioMixerError.ioProcFailed(ioStatus)
|
||||
}
|
||||
procID = proc
|
||||
|
||||
guard AudioDeviceStart(aggregateID, proc) == noErr else {
|
||||
cleanUp()
|
||||
throw AudioMixerError.startFailed
|
||||
}
|
||||
|
||||
isRunning = true
|
||||
lastAudioAt = Date()
|
||||
log.notice("Tap aktiv für \(self.process.name, privacy: .public)")
|
||||
}
|
||||
|
||||
// MARK: - Echtzeitpfad
|
||||
|
||||
/// Läuft auf dem Audiothread. Hier darf nichts geschehen, was blockieren
|
||||
/// kann: keine Speicheranforderung, keine Sperre, kein Protokollieren.
|
||||
private func render(input: UnsafePointer<AudioBufferList>,
|
||||
output: UnsafeMutablePointer<AudioBufferList>) {
|
||||
let inputList = UnsafeMutableAudioBufferListPointer(
|
||||
UnsafeMutablePointer(mutating: input))
|
||||
let outputList = UnsafeMutableAudioBufferListPointer(output)
|
||||
|
||||
let factor = gain
|
||||
var sawAudio = false
|
||||
|
||||
for (index, outputBuffer) in outputList.enumerated() {
|
||||
guard index < inputList.count,
|
||||
let source = inputList[index].mData,
|
||||
let destination = outputBuffer.mData else { continue }
|
||||
|
||||
let count = Int(min(inputList[index].mDataByteSize, outputBuffer.mDataByteSize))
|
||||
/ MemoryLayout<Float>.size
|
||||
let inputSamples = source.assumingMemoryBound(to: Float.self)
|
||||
let outputSamples = destination.assumingMemoryBound(to: Float.self)
|
||||
|
||||
for sample in 0..<count {
|
||||
let value = inputSamples[sample] * factor
|
||||
// Nur begrenzen, wenn wirklich verstärkt wird — unterhalb der
|
||||
// Schwelle ist die Kennlinie ohnehin die Identität, und im
|
||||
// Echtzeitpfad zählt jede eingesparte Rechnung.
|
||||
outputSamples[sample] = factor > 1 ? SoftClip.apply(value) : value
|
||||
if !sawAudio, value != 0 { sawAudio = true }
|
||||
}
|
||||
}
|
||||
|
||||
if sawAudio { lastAudioAt = Date() }
|
||||
}
|
||||
|
||||
// MARK: - Abbau
|
||||
|
||||
func stop() {
|
||||
guard tapID != kAudioObjectUnknown || aggregateID != kAudioObjectUnknown else { return }
|
||||
cleanUp()
|
||||
isRunning = false
|
||||
}
|
||||
|
||||
/// Immer in dieser Reihenfolge: erst anhalten, dann IOProc, dann Gerät,
|
||||
/// dann Tap. Umgekehrt bleibt das Programm stumm zurück, weil der Tap noch
|
||||
/// stummschaltet, aber nichts mehr ausgibt.
|
||||
private func cleanUp() {
|
||||
if let procID {
|
||||
AudioDeviceStop(aggregateID, procID)
|
||||
AudioDeviceDestroyIOProcID(aggregateID, procID)
|
||||
self.procID = nil
|
||||
}
|
||||
if aggregateID != kAudioObjectUnknown {
|
||||
AudioHardwareDestroyAggregateDevice(aggregateID)
|
||||
aggregateID = AudioObjectID(kAudioObjectUnknown)
|
||||
}
|
||||
if tapID != kAudioObjectUnknown {
|
||||
AudioHardwareDestroyProcessTap(tapID)
|
||||
tapID = AudioObjectID(kAudioObjectUnknown)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public enum AudioMixerError: Error, LocalizedError {
|
||||
case tapFailed(OSStatus)
|
||||
case aggregateFailed(OSStatus)
|
||||
case ioProcFailed(OSStatus)
|
||||
case startFailed
|
||||
case noOutputDevice
|
||||
|
||||
public var errorDescription: String? {
|
||||
switch self {
|
||||
case .tapFailed(let status):
|
||||
"Der Ton dieses Programms lässt sich nicht abgreifen (\(status))."
|
||||
case .aggregateFailed(let status):
|
||||
"Das Mischgerät ließ sich nicht anlegen (\(status))."
|
||||
case .ioProcFailed(let status):
|
||||
"Die Tonverarbeitung ließ sich nicht starten (\(status))."
|
||||
case .startFailed:
|
||||
"Das Mischgerät startet nicht."
|
||||
case .noOutputDevice:
|
||||
"Kein Ausgabegerät gefunden."
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user