@livedesk/client 0.1.119 → 0.1.121

package/THIRD_PARTY_NOTICES.md

@@ -24,4 +24,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
-

package/fast/osx-arm64/MindExec.RemoteAgent.Fast/MacSystemAudioCapture.swift

@@ -0,0 +1,213 @@
+import AudioToolbox
+import AVFAudio
+import CoreGraphics
+import CoreMedia
+import Foundation
+import ScreenCaptureKit
+
+@available(macOS 13.0, *)
+final class LiveDeskSystemAudioCapture: NSObject, SCStreamOutput, SCStreamDelegate {
+    private let sampleRate: Int
+    private let channelCount: Int
+    private let queue = DispatchQueue(label: "dev.livedesk.screencapturekit.audio", qos: .userInteractive)
+    private let writeLock = NSLock()
+    private var stream: SCStream?
+    private var audioFrameCount = 0
+    private var loggedFormat = false
+
+    init(sampleRate: Int, channelCount: Int) {
+        self.sampleRate = max(8_000, min(192_000, sampleRate))
+        self.channelCount = max(1, min(2, channelCount))
+        super.init()
+    }
+
+    func start() async throws {
+        let content = try await SCShareableContent.excludingDesktopWindows(false, onScreenWindowsOnly: true)
+        guard !content.displays.isEmpty else {
+            throw LiveDeskSystemAudioError.noDisplays
+        }
+
+        let mainDisplayID = CGMainDisplayID()
+        let display = content.displays.sorted { left, right in
+            let leftIsMain = left.displayID == mainDisplayID
+            let rightIsMain = right.displayID == mainDisplayID
+            if leftIsMain != rightIsMain {
+                return leftIsMain
+            }
+            return left.displayID < right.displayID
+        }[0]
+
+        let configuration = SCStreamConfiguration()
+        configuration.width = 2
+        configuration.height = 2
+        configuration.minimumFrameInterval = CMTime(value: 1, timescale: 1)
+        configuration.queueDepth = 8
+        configuration.capturesAudio = true
+        configuration.sampleRate = sampleRate
+        configuration.channelCount = channelCount
+        configuration.excludesCurrentProcessAudio = true
+
+        let stream = SCStream(filter: SCContentFilter(display: display, excludingWindows: []), configuration: configuration, delegate: self)
+        try stream.addStreamOutput(self, type: .audio, sampleHandlerQueue: queue)
+        self.stream = stream
+        try await stream.startCapture()
+        fputs("LiveDeskSCKAudio started displayID=\(display.displayID) sampleRate=\(sampleRate) channels=\(channelCount)\n", stderr)
+
+        while !Task.isCancelled {
+            try await Task.sleep(nanoseconds: 1_000_000_000)
+        }
+    }
+
+    func stream(_ stream: SCStream, didOutputSampleBuffer sampleBuffer: CMSampleBuffer, of type: SCStreamOutputType) {
+        guard type == .audio, sampleBuffer.isValid, CMSampleBufferDataIsReady(sampleBuffer) else {
+            return
+        }
+        writePcm(sampleBuffer)
+    }
+
+    func stream(_ stream: SCStream, didStopWithError error: Error) {
+        fputs("LiveDeskSCKAudio stream stopped: \(error)\n", stderr)
+        exit(3)
+    }
+
+    private func writePcm(_ sampleBuffer: CMSampleBuffer) {
+        guard let description = sampleBuffer.formatDescription?.audioStreamBasicDescription else {
+            return
+        }
+
+        let channels = Int(description.mChannelsPerFrame)
+        let frames = Int(CMSampleBufferGetNumSamples(sampleBuffer))
+        let isFloat32 = description.mFormatID == kAudioFormatLinearPCM
+            && description.mBitsPerChannel == 32
+            && (description.mFormatFlags & kAudioFormatFlagIsFloat) != 0
+        let isInterleaved = (description.mFormatFlags & kAudioFormatFlagIsNonInterleaved) == 0
+        guard isFloat32, frames > 0, channels > 0, channels <= 8 else {
+            if !loggedFormat {
+                loggedFormat = true
+                fputs("LiveDeskSCKAudio unsupported PCM format id=\(description.mFormatID) flags=\(description.mFormatFlags) bits=\(description.mBitsPerChannel) channels=\(channels)\n", stderr)
+            }
+            return
+        }
+
+        do {
+            try sampleBuffer.withAudioBufferList { audioBufferList, _ in
+                let bytesPerSample = MemoryLayout<Float>.size
+                let bytesPerChannel = frames * bytesPerSample
+                let outputBytes = bytesPerChannel * channels
+                guard audioBufferList.count > 0, outputBytes > 0 else {
+                    return
+                }
+
+                let output: Data
+                if isInterleaved {
+                    let sourceBuffer = audioBufferList[0]
+                    guard let source = sourceBuffer.mData, Int(sourceBuffer.mDataByteSize) >= outputBytes else {
+                        return
+                    }
+                    output = Data(bytes: source, count: outputBytes)
+                } else {
+                    guard audioBufferList.count >= channels else {
+                        return
+                    }
+                    var interleaved = Data(count: outputBytes)
+                    var copied = true
+                    interleaved.withUnsafeMutableBytes { rawBuffer in
+                        guard let destination = rawBuffer.baseAddress?.assumingMemoryBound(to: Float.self) else {
+                            copied = false
+                            return
+                        }
+                        for channelIndex in 0..<channels {
+                            let sourceBuffer = audioBufferList[channelIndex]
+                            guard let source = sourceBuffer.mData,
+                                  Int(sourceBuffer.mDataByteSize) >= bytesPerChannel else {
+                                copied = false
+                                return
+                            }
+                            let sourceSamples = source.assumingMemoryBound(to: Float.self)
+                            for frameIndex in 0..<frames {
+                                destination[frameIndex * channels + channelIndex] = sourceSamples[frameIndex]
+                            }
+                        }
+                    }
+                    guard copied else {
+                        return
+                    }
+                    output = interleaved
+                }
+
+                if !loggedFormat {
+                    loggedFormat = true
+                    fputs("LiveDeskSCKAudio format sampleRate=\(Int(description.mSampleRate.rounded())) channels=\(channels) frames=\(frames) interleaved=\(isInterleaved ? 1 : 0)\n", stderr)
+                }
+                writePacket(output, sampleRate: Int(description.mSampleRate.rounded()), channels: channels)
+                audioFrameCount += 1
+                if audioFrameCount == 1 || audioFrameCount % 250 == 0 {
+                    fputs("LiveDeskSCKAudio frames=\(audioFrameCount) bytes=\(output.count)\n", stderr)
+                }
+            }
+        } catch {
+            fputs("LiveDeskSCKAudio audio buffer error: \(error)\n", stderr)
+        }
+    }
+
+    private func writePacket(_ pcm: Data, sampleRate: Int, channels: Int) {
+        guard sampleRate > 0, channels > 0, pcm.count <= Int(UInt32.max) else {
+            return
+        }
+        var packet = Data()
+        packet.reserveCapacity(16 + pcm.count)
+        packet.append(contentsOf: [0x4c, 0x44, 0x41, 0x55])
+        appendLittleEndian(UInt16(1), to: &packet)
+        appendLittleEndian(UInt16(min(channels, Int(UInt16.max))), to: &packet)
+        appendLittleEndian(UInt32(min(sampleRate, Int(UInt32.max))), to: &packet)
+        appendLittleEndian(UInt32(pcm.count), to: &packet)
+        packet.append(pcm)
+
+        writeLock.lock()
+        FileHandle.standardOutput.write(packet)
+        writeLock.unlock()
+    }
+
+    private func appendLittleEndian<T: FixedWidthInteger>(_ value: T, to data: inout Data) {
+        var littleEndian = value.littleEndian
+        withUnsafeBytes(of: &littleEndian) { bytes in
+            data.append(contentsOf: bytes)
+        }
+    }
+}
+
+enum LiveDeskSystemAudioError: Error {
+    case noDisplays
+}
+
+func intArg(_ name: String, default defaultValue: Int) -> Int {
+    let args = CommandLine.arguments
+    guard let index = args.firstIndex(of: name), index + 1 < args.count else {
+        return defaultValue
+    }
+    return Int(args[index + 1]) ?? defaultValue
+}
+
+@main
+struct LiveDeskSystemAudioMain {
+    static func main() async {
+        guard #available(macOS 13.0, *) else {
+            fputs("LiveDeskSCKAudio requires macOS 13 or later.\n", stderr)
+            exit(2)
+        }
+        guard CGPreflightScreenCaptureAccess() else {
+            fputs("LiveDeskSCKAudio Screen & System Audio Recording permission is not granted.\n", stderr)
+            exit(10)
+        }
+
+        let sampleRate = intArg("--sample-rate", default: 48_000)
+        let channels = intArg("--channels", default: 2)
+        do {
+            let capture = LiveDeskSystemAudioCapture(sampleRate: sampleRate, channelCount: channels)
+            try await capture.start()
+        } catch {
+            fputs("LiveDeskSCKAudio failed: \(error)\n", stderr)
+            exit(1)
+        }
+    }
+}

package/fast/osx-x64/MindExec.RemoteAgent.Fast/MacSystemAudioCapture.swift

@@ -0,0 +1,213 @@
+import AudioToolbox
+import AVFAudio
+import CoreGraphics
+import CoreMedia
+import Foundation
+import ScreenCaptureKit
+
+@available(macOS 13.0, *)
+final class LiveDeskSystemAudioCapture: NSObject, SCStreamOutput, SCStreamDelegate {
+    private let sampleRate: Int
+    private let channelCount: Int
+    private let queue = DispatchQueue(label: "dev.livedesk.screencapturekit.audio", qos: .userInteractive)
+    private let writeLock = NSLock()
+    private var stream: SCStream?
+    private var audioFrameCount = 0
+    private var loggedFormat = false
+
+    init(sampleRate: Int, channelCount: Int) {
+        self.sampleRate = max(8_000, min(192_000, sampleRate))
+        self.channelCount = max(1, min(2, channelCount))
+        super.init()
+    }
+
+    func start() async throws {
+        let content = try await SCShareableContent.excludingDesktopWindows(false, onScreenWindowsOnly: true)
+        guard !content.displays.isEmpty else {
+            throw LiveDeskSystemAudioError.noDisplays
+        }
+
+        let mainDisplayID = CGMainDisplayID()
+        let display = content.displays.sorted { left, right in
+            let leftIsMain = left.displayID == mainDisplayID
+            let rightIsMain = right.displayID == mainDisplayID
+            if leftIsMain != rightIsMain {
+                return leftIsMain
+            }
+            return left.displayID < right.displayID
+        }[0]
+
+        let configuration = SCStreamConfiguration()
+        configuration.width = 2
+        configuration.height = 2
+        configuration.minimumFrameInterval = CMTime(value: 1, timescale: 1)
+        configuration.queueDepth = 8
+        configuration.capturesAudio = true
+        configuration.sampleRate = sampleRate
+        configuration.channelCount = channelCount
+        configuration.excludesCurrentProcessAudio = true
+
+        let stream = SCStream(filter: SCContentFilter(display: display, excludingWindows: []), configuration: configuration, delegate: self)
+        try stream.addStreamOutput(self, type: .audio, sampleHandlerQueue: queue)
+        self.stream = stream
+        try await stream.startCapture()
+        fputs("LiveDeskSCKAudio started displayID=\(display.displayID) sampleRate=\(sampleRate) channels=\(channelCount)\n", stderr)
+
+        while !Task.isCancelled {
+            try await Task.sleep(nanoseconds: 1_000_000_000)
+        }
+    }
+
+    func stream(_ stream: SCStream, didOutputSampleBuffer sampleBuffer: CMSampleBuffer, of type: SCStreamOutputType) {
+        guard type == .audio, sampleBuffer.isValid, CMSampleBufferDataIsReady(sampleBuffer) else {
+            return
+        }
+        writePcm(sampleBuffer)
+    }
+
+    func stream(_ stream: SCStream, didStopWithError error: Error) {
+        fputs("LiveDeskSCKAudio stream stopped: \(error)\n", stderr)
+        exit(3)
+    }
+
+    private func writePcm(_ sampleBuffer: CMSampleBuffer) {
+        guard let description = sampleBuffer.formatDescription?.audioStreamBasicDescription else {
+            return
+        }
+
+        let channels = Int(description.mChannelsPerFrame)
+        let frames = Int(CMSampleBufferGetNumSamples(sampleBuffer))
+        let isFloat32 = description.mFormatID == kAudioFormatLinearPCM
+            && description.mBitsPerChannel == 32
+            && (description.mFormatFlags & kAudioFormatFlagIsFloat) != 0
+        let isInterleaved = (description.mFormatFlags & kAudioFormatFlagIsNonInterleaved) == 0
+        guard isFloat32, frames > 0, channels > 0, channels <= 8 else {
+            if !loggedFormat {
+                loggedFormat = true
+                fputs("LiveDeskSCKAudio unsupported PCM format id=\(description.mFormatID) flags=\(description.mFormatFlags) bits=\(description.mBitsPerChannel) channels=\(channels)\n", stderr)
+            }
+            return
+        }
+
+        do {
+            try sampleBuffer.withAudioBufferList { audioBufferList, _ in
+                let bytesPerSample = MemoryLayout<Float>.size
+                let bytesPerChannel = frames * bytesPerSample
+                let outputBytes = bytesPerChannel * channels
+                guard audioBufferList.count > 0, outputBytes > 0 else {
+                    return
+                }
+
+                let output: Data
+                if isInterleaved {
+                    let sourceBuffer = audioBufferList[0]
+                    guard let source = sourceBuffer.mData, Int(sourceBuffer.mDataByteSize) >= outputBytes else {
+                        return
+                    }
+                    output = Data(bytes: source, count: outputBytes)
+                } else {
+                    guard audioBufferList.count >= channels else {
+                        return
+                    }
+                    var interleaved = Data(count: outputBytes)
+                    var copied = true
+                    interleaved.withUnsafeMutableBytes { rawBuffer in
+                        guard let destination = rawBuffer.baseAddress?.assumingMemoryBound(to: Float.self) else {
+                            copied = false
+                            return
+                        }
+                        for channelIndex in 0..<channels {
+                            let sourceBuffer = audioBufferList[channelIndex]
+                            guard let source = sourceBuffer.mData,
+                                  Int(sourceBuffer.mDataByteSize) >= bytesPerChannel else {
+                                copied = false
+                                return
+                            }
+                            let sourceSamples = source.assumingMemoryBound(to: Float.self)
+                            for frameIndex in 0..<frames {
+                                destination[frameIndex * channels + channelIndex] = sourceSamples[frameIndex]
+                            }
+                        }
+                    }
+                    guard copied else {
+                        return
+                    }
+                    output = interleaved
+                }
+
+                if !loggedFormat {
+                    loggedFormat = true
+                    fputs("LiveDeskSCKAudio format sampleRate=\(Int(description.mSampleRate.rounded())) channels=\(channels) frames=\(frames) interleaved=\(isInterleaved ? 1 : 0)\n", stderr)
+                }
+                writePacket(output, sampleRate: Int(description.mSampleRate.rounded()), channels: channels)
+                audioFrameCount += 1
+                if audioFrameCount == 1 || audioFrameCount % 250 == 0 {
+                    fputs("LiveDeskSCKAudio frames=\(audioFrameCount) bytes=\(output.count)\n", stderr)
+                }
+            }
+        } catch {
+            fputs("LiveDeskSCKAudio audio buffer error: \(error)\n", stderr)
+        }
+    }
+
+    private func writePacket(_ pcm: Data, sampleRate: Int, channels: Int) {
+        guard sampleRate > 0, channels > 0, pcm.count <= Int(UInt32.max) else {
+            return
+        }
+        var packet = Data()
+        packet.reserveCapacity(16 + pcm.count)
+        packet.append(contentsOf: [0x4c, 0x44, 0x41, 0x55])
+        appendLittleEndian(UInt16(1), to: &packet)
+        appendLittleEndian(UInt16(min(channels, Int(UInt16.max))), to: &packet)
+        appendLittleEndian(UInt32(min(sampleRate, Int(UInt32.max))), to: &packet)
+        appendLittleEndian(UInt32(pcm.count), to: &packet)
+        packet.append(pcm)
+
+        writeLock.lock()
+        FileHandle.standardOutput.write(packet)
+        writeLock.unlock()
+    }
+
+    private func appendLittleEndian<T: FixedWidthInteger>(_ value: T, to data: inout Data) {
+        var littleEndian = value.littleEndian
+        withUnsafeBytes(of: &littleEndian) { bytes in
+            data.append(contentsOf: bytes)
+        }
+    }
+}
+
+enum LiveDeskSystemAudioError: Error {
+    case noDisplays
+}
+
+func intArg(_ name: String, default defaultValue: Int) -> Int {
+    let args = CommandLine.arguments
+    guard let index = args.firstIndex(of: name), index + 1 < args.count else {
+        return defaultValue
+    }
+    return Int(args[index + 1]) ?? defaultValue
+}
+
+@main
+struct LiveDeskSystemAudioMain {
+    static func main() async {
+        guard #available(macOS 13.0, *) else {
+            fputs("LiveDeskSCKAudio requires macOS 13 or later.\n", stderr)
+            exit(2)
+        }
+        guard CGPreflightScreenCaptureAccess() else {
+            fputs("LiveDeskSCKAudio Screen & System Audio Recording permission is not granted.\n", stderr)
+            exit(10)
+        }
+
+        let sampleRate = intArg("--sample-rate", default: 48_000)
+        let channels = intArg("--channels", default: 2)
+        do {
+            let capture = LiveDeskSystemAudioCapture(sampleRate: sampleRate, channelCount: channels)
+            try await capture.start()
+        } catch {
+            fputs("LiveDeskSCKAudio failed: \(error)\n", stderr)
+            exit(1)
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livedesk/client",
-  "version": "0.1.119",
+  "version": "0.1.121",
   "description": "LiveDesk local remote client",
   "type": "module",
   "bin": {