@javascriptcommon/react-native-track-player 1.2.23 → 4.1.5

package/ios/SwiftAudioEx/Sources/SwiftAudioEx/RemoteCommandController/RemoteCommand.swift

@@ -0,0 +1,170 @@
+//
+//  RemoteCommand.swift
+//  SwiftAudio
+//
+//  Created by Jørgen Henrichsen on 20/03/2018.
+//
+
+import Foundation
+import MediaPlayer
+
+
+public typealias RemoteCommandHandler = (MPRemoteCommandEvent) -> MPRemoteCommandHandlerStatus
+
+public protocol RemoteCommandProtocol {
+    associatedtype Command: MPRemoteCommand
+    
+    var id: String { get }
+    var commandKeyPath: KeyPath<MPRemoteCommandCenter, Command> { get }
+    var handlerKeyPath: KeyPath<RemoteCommandController, RemoteCommandHandler> { get }
+}
+
+public struct PlayBackCommand: RemoteCommandProtocol {
+    
+    public static let play = PlayBackCommand(id: "Play", commandKeyPath: \MPRemoteCommandCenter.playCommand, handlerKeyPath: \RemoteCommandController.handlePlayCommand)
+    
+    public static let pause = PlayBackCommand(id: "Pause", commandKeyPath: \MPRemoteCommandCenter.pauseCommand, handlerKeyPath: \RemoteCommandController.handlePauseCommand)
+    
+    public static let stop = PlayBackCommand(id: "Stop", commandKeyPath: \MPRemoteCommandCenter.stopCommand, handlerKeyPath: \RemoteCommandController.handleStopCommand)
+    
+    public static let togglePlayPause = PlayBackCommand(id: "TogglePlayPause", commandKeyPath: \MPRemoteCommandCenter.togglePlayPauseCommand, handlerKeyPath: \RemoteCommandController.handleTogglePlayPauseCommand)
+    
+    public static let nextTrack = PlayBackCommand(id: "NextTrackCommand", commandKeyPath: \MPRemoteCommandCenter.nextTrackCommand, handlerKeyPath: \RemoteCommandController.handleNextTrackCommand)
+    
+    public static let previousTrack = PlayBackCommand(id: "PreviousTrack", commandKeyPath: \MPRemoteCommandCenter.previousTrackCommand, handlerKeyPath: \RemoteCommandController.handlePreviousTrackCommand)
+    
+    
+    public typealias Command = MPRemoteCommand
+    
+    public let id: String
+    
+    public var commandKeyPath: KeyPath<MPRemoteCommandCenter, MPRemoteCommand>
+    
+    public var handlerKeyPath: KeyPath<RemoteCommandController, RemoteCommandHandler>
+    
+}
+
+public struct ChangePlaybackPositionCommand: RemoteCommandProtocol {
+    
+    public static let changePlaybackPosition = ChangePlaybackPositionCommand(id: "ChangePlaybackPosition", commandKeyPath: \MPRemoteCommandCenter.changePlaybackPositionCommand, handlerKeyPath: \RemoteCommandController.handleChangePlaybackPositionCommand)
+    
+    public typealias Command = MPChangePlaybackPositionCommand
+    
+    public let id: String
+    
+    public var commandKeyPath: KeyPath<MPRemoteCommandCenter, MPChangePlaybackPositionCommand>
+    
+    public var handlerKeyPath: KeyPath<RemoteCommandController, RemoteCommandHandler>
+    
+}
+
+public struct SkipIntervalCommand: RemoteCommandProtocol {
+    
+    public static let skipForward = SkipIntervalCommand(id: "SkipForward", commandKeyPath: \MPRemoteCommandCenter.skipForwardCommand, handlerKeyPath: \RemoteCommandController.handleSkipForwardCommand)
+    
+    public static let skipBackward = SkipIntervalCommand(id: "SkipBackward", commandKeyPath: \MPRemoteCommandCenter.skipBackwardCommand, handlerKeyPath: \RemoteCommandController.handleSkipBackwardCommand)
+
+    public typealias Command = MPSkipIntervalCommand
+    
+    public let id: String
+    
+    public var commandKeyPath: KeyPath<MPRemoteCommandCenter, MPSkipIntervalCommand>
+    
+    public var handlerKeyPath: KeyPath<RemoteCommandController, RemoteCommandHandler>
+    
+    func set(preferredIntervals: [NSNumber]) -> SkipIntervalCommand {
+        MPRemoteCommandCenter.shared()[keyPath: commandKeyPath].preferredIntervals = preferredIntervals
+        return self
+    }
+    
+}
+
+public struct FeedbackCommand: RemoteCommandProtocol {
+    
+    public static let like = FeedbackCommand(id: "Like", commandKeyPath: \MPRemoteCommandCenter.likeCommand, handlerKeyPath: \RemoteCommandController.handleLikeCommand)
+    
+    public static let dislike = FeedbackCommand(id: "Dislike", commandKeyPath: \MPRemoteCommandCenter.dislikeCommand, handlerKeyPath: \RemoteCommandController.handleDislikeCommand)
+    
+    public static let bookmark = FeedbackCommand(id: "Bookmark", commandKeyPath: \MPRemoteCommandCenter.bookmarkCommand, handlerKeyPath: \RemoteCommandController.handleBookmarkCommand)
+    
+    public typealias Command = MPFeedbackCommand
+    
+    public let id: String
+    
+    public var commandKeyPath: KeyPath<MPRemoteCommandCenter, MPFeedbackCommand>
+    
+    public var handlerKeyPath: KeyPath<RemoteCommandController, RemoteCommandHandler>
+    
+    func set(isActive: Bool, localizedTitle: String, localizedShortTitle: String) -> FeedbackCommand {
+        MPRemoteCommandCenter.shared()[keyPath: commandKeyPath].isActive = isActive
+        MPRemoteCommandCenter.shared()[keyPath: commandKeyPath].localizedTitle = localizedTitle
+        MPRemoteCommandCenter.shared()[keyPath: commandKeyPath].localizedShortTitle = localizedShortTitle
+        return self
+    }
+}
+
+public enum RemoteCommand: CustomStringConvertible {
+
+    case play
+    
+    case pause
+    
+    case stop
+    
+    case togglePlayPause
+    
+    case next
+    
+    case previous
+    
+    case changePlaybackPosition
+    
+    case skipForward(preferredIntervals: [NSNumber])
+    
+    case skipBackward(preferredIntervals: [NSNumber])
+    
+    case like(isActive: Bool, localizedTitle: String, localizedShortTitle: String)
+    
+    case dislike(isActive: Bool, localizedTitle: String, localizedShortTitle: String)
+    
+    case bookmark(isActive: Bool, localizedTitle: String, localizedShortTitle: String)
+
+    public var description: String {
+        switch self {
+        case .play: return "play"
+        case .pause: return "pause"
+        case .stop: return "stop"
+        case .togglePlayPause: return "togglePlayPause"
+        case .next: return "nextTrack"
+        case .previous: return "previousTrack"
+        case .changePlaybackPosition: return "changePlaybackPosition"
+        case .skipForward(_): return "skipForward"
+        case .skipBackward(_): return "skipBackward"
+        case .like(_, _, _): return "like"
+        case .dislike(_, _, _): return "dislike"
+        case .bookmark(_, _, _): return "bookmark"
+        }
+    }
+    
+    /**
+     All values in an array for convenience.
+     Don't use for associated values.
+     */
+    static func all() -> [RemoteCommand] {
+        return [
+            .play,
+            .pause,
+            .stop,
+            .togglePlayPause,
+            .next,
+            .previous,
+            .changePlaybackPosition,
+            .skipForward(preferredIntervals: []),
+            .skipBackward(preferredIntervals: []),
+            .like(isActive: false, localizedTitle: "", localizedShortTitle: ""),
+            .dislike(isActive: false, localizedTitle: "", localizedShortTitle: ""),
+            .bookmark(isActive: false, localizedTitle: "", localizedShortTitle: "")
+        ]
+    }
+    
+}

package/ios/SwiftAudioEx/Sources/SwiftAudioEx/RemoteCommandController/RemoteCommandController.swift

@@ -0,0 +1,206 @@
+//
+//  File.swift
+//  SwiftAudio
+//
+//  Created by Jørgen Henrichsen on 20/03/2018.
+//
+
+import Foundation
+import MediaPlayer
+
+public protocol RemoteCommandable {
+    func getCommands() ->  [RemoteCommand]
+}
+
+public class RemoteCommandController {
+        
+    private let center: MPRemoteCommandCenter
+    
+    weak var audioPlayer: AudioPlayer?
+    
+    var commandTargetPointers: [String: Any] = [:]
+    private var enabledCommands: [RemoteCommand] = []
+
+    /**
+     Create a new RemoteCommandController.
+     
+     - parameter remoteCommandCenter: The MPRemoteCommandCenter used. Default is `MPRemoteCommandCenter.shared()`
+     */
+    public init(remoteCommandCenter: MPRemoteCommandCenter = MPRemoteCommandCenter.shared()) {
+        center = remoteCommandCenter
+    }
+    
+    internal func enable(commands: [RemoteCommand]) {
+        let commandsToDisable = enabledCommands.filter { command in
+            !commands.contains(where: { $0.description == command.description })
+        }
+
+        enabledCommands = commands
+        commands.forEach { self.enable(command: $0) }
+        disable(commands: commandsToDisable)
+    }
+    
+    internal func disable(commands: [RemoteCommand]) {
+        commands.forEach { self.disable(command: $0) }
+    }
+    
+    private func enableCommand<Command: RemoteCommandProtocol>(_ command: Command) {
+        center[keyPath: command.commandKeyPath].isEnabled = true
+        center[keyPath: command.commandKeyPath].removeTarget(commandTargetPointers[command.id])
+        commandTargetPointers[command.id] = center[keyPath: command.commandKeyPath].addTarget(handler: self[keyPath: command.handlerKeyPath])
+    }
+    
+    private func disableCommand<Command: RemoteCommandProtocol>(_ command: Command) {
+        center[keyPath: command.commandKeyPath].isEnabled = false
+        center[keyPath: command.commandKeyPath].removeTarget(commandTargetPointers[command.id])
+        commandTargetPointers.removeValue(forKey: command.id)
+    }
+    
+    private func enable(command: RemoteCommand) {
+        switch command {
+        case .play: self.enableCommand(PlayBackCommand.play)
+        case .pause: self.enableCommand(PlayBackCommand.pause)
+        case .stop: self.enableCommand(PlayBackCommand.stop)
+        case .togglePlayPause: self.enableCommand(PlayBackCommand.togglePlayPause)
+        case .next: self.enableCommand(PlayBackCommand.nextTrack)
+        case .previous: self.enableCommand(PlayBackCommand.previousTrack)
+        case .changePlaybackPosition: self.enableCommand(ChangePlaybackPositionCommand.changePlaybackPosition)
+        case .skipForward(let preferredIntervals): self.enableCommand(SkipIntervalCommand.skipForward.set(preferredIntervals: preferredIntervals))
+        case .skipBackward(let preferredIntervals): self.enableCommand(SkipIntervalCommand.skipBackward.set(preferredIntervals: preferredIntervals))
+        case .like(let isActive, let localizedTitle, let localizedShortTitle):
+            self.enableCommand(FeedbackCommand.like.set(isActive: isActive, localizedTitle: localizedTitle, localizedShortTitle: localizedShortTitle))
+        case .dislike(let isActive, let localizedTitle, let localizedShortTitle):
+            self.enableCommand(FeedbackCommand.dislike.set(isActive: isActive, localizedTitle: localizedTitle, localizedShortTitle: localizedShortTitle))
+        case .bookmark(let isActive, let localizedTitle, let localizedShortTitle):
+            self.enableCommand(FeedbackCommand.bookmark.set(isActive: isActive, localizedTitle: localizedTitle, localizedShortTitle: localizedShortTitle))
+        }
+    }
+    
+    private func disable(command: RemoteCommand) {
+        switch command {
+        case .play: self.disableCommand(PlayBackCommand.play)
+        case .pause: self.disableCommand(PlayBackCommand.pause)
+        case .stop: self.disableCommand(PlayBackCommand.stop)
+        case .togglePlayPause: self.disableCommand(PlayBackCommand.togglePlayPause)
+        case .next: self.disableCommand(PlayBackCommand.nextTrack)
+        case .previous: self.disableCommand(PlayBackCommand.previousTrack)
+        case .changePlaybackPosition: self.disableCommand(ChangePlaybackPositionCommand.changePlaybackPosition)
+        case .skipForward(_): self.disableCommand(SkipIntervalCommand.skipForward)
+        case .skipBackward(_): self.disableCommand(SkipIntervalCommand.skipBackward)
+        case .like(_, _, _): self.disableCommand(FeedbackCommand.like)
+        case .dislike(_, _, _): self.disableCommand(FeedbackCommand.dislike)
+        case .bookmark(_, _, _): self.disableCommand(FeedbackCommand.bookmark)
+        }
+    }
+    
+    // MARK: - Handlers
+    
+    public lazy var handlePlayCommand: RemoteCommandHandler = handlePlayCommandDefault
+    public lazy var handlePauseCommand: RemoteCommandHandler = handlePauseCommandDefault
+    public lazy var handleStopCommand: RemoteCommandHandler = handleStopCommandDefault
+    public lazy var handleTogglePlayPauseCommand: RemoteCommandHandler = handleTogglePlayPauseCommandDefault
+    public lazy var handleSkipForwardCommand: RemoteCommandHandler  = handleSkipForwardCommandDefault
+    public lazy var handleSkipBackwardCommand: RemoteCommandHandler = handleSkipBackwardDefault
+    public lazy var handleChangePlaybackPositionCommand: RemoteCommandHandler  = handleChangePlaybackPositionCommandDefault
+    public lazy var handleNextTrackCommand: RemoteCommandHandler = handleNextTrackCommandDefault
+    public lazy var handlePreviousTrackCommand: RemoteCommandHandler = handlePreviousTrackCommandDefault
+    public lazy var handleLikeCommand: RemoteCommandHandler = handleLikeCommandDefault
+    public lazy var handleDislikeCommand: RemoteCommandHandler = handleDislikeCommandDefault
+    public lazy var handleBookmarkCommand: RemoteCommandHandler = handleBookmarkCommandDefault
+    
+    private func handlePlayCommandDefault(event: MPRemoteCommandEvent) -> MPRemoteCommandHandlerStatus {
+        if let audioPlayer = audioPlayer {
+            audioPlayer.play()
+            return MPRemoteCommandHandlerStatus.success
+        }
+        return MPRemoteCommandHandlerStatus.commandFailed
+    }
+    
+    private func handlePauseCommandDefault(event: MPRemoteCommandEvent) -> MPRemoteCommandHandlerStatus {
+        if let audioPlayer = audioPlayer {
+            audioPlayer.pause()
+            return MPRemoteCommandHandlerStatus.success
+        }
+        return MPRemoteCommandHandlerStatus.commandFailed
+    }
+    
+    private func handleStopCommandDefault(event: MPRemoteCommandEvent) -> MPRemoteCommandHandlerStatus {
+        if let audioPlayer = audioPlayer {
+            audioPlayer.stop()
+            return .success
+        }
+        return MPRemoteCommandHandlerStatus.commandFailed
+    }
+    
+    private func handleTogglePlayPauseCommandDefault(event: MPRemoteCommandEvent) -> MPRemoteCommandHandlerStatus {
+        if let audioPlayer = audioPlayer {
+            audioPlayer.togglePlaying()
+            return MPRemoteCommandHandlerStatus.success
+        }
+        return MPRemoteCommandHandlerStatus.commandFailed
+    }
+    
+    private func handleSkipForwardCommandDefault(event: MPRemoteCommandEvent) -> MPRemoteCommandHandlerStatus {
+        if let command = event.command as? MPSkipIntervalCommand,
+            let interval = command.preferredIntervals.first,
+            let audioPlayer = audioPlayer {
+            audioPlayer.seek(to: audioPlayer.currentTime + Double(truncating: interval))
+            return MPRemoteCommandHandlerStatus.success
+        }
+        return MPRemoteCommandHandlerStatus.commandFailed
+    }
+    
+    private func handleSkipBackwardDefault(event: MPRemoteCommandEvent) -> MPRemoteCommandHandlerStatus {
+        if let command = event.command as? MPSkipIntervalCommand,
+            let interval = command.preferredIntervals.first,
+            let audioPlayer = audioPlayer {
+            audioPlayer.seek(to: audioPlayer.currentTime - Double(truncating: interval))
+            return MPRemoteCommandHandlerStatus.success
+        }
+        return MPRemoteCommandHandlerStatus.commandFailed
+    }
+    
+    private func handleChangePlaybackPositionCommandDefault(event: MPRemoteCommandEvent) -> MPRemoteCommandHandlerStatus {
+        if let event = event as? MPChangePlaybackPositionCommandEvent,
+            let audioPlayer = audioPlayer {
+            audioPlayer.seek(to: event.positionTime)
+            return MPRemoteCommandHandlerStatus.success
+        }
+        return MPRemoteCommandHandlerStatus.commandFailed
+    }
+    
+    private func handleNextTrackCommandDefault(event: MPRemoteCommandEvent) -> MPRemoteCommandHandlerStatus {
+        if let player = audioPlayer as? QueuedAudioPlayer {
+            player.next()
+            return MPRemoteCommandHandlerStatus.success
+        }
+        return MPRemoteCommandHandlerStatus.commandFailed
+    }
+    
+    private func handlePreviousTrackCommandDefault(event: MPRemoteCommandEvent) -> MPRemoteCommandHandlerStatus {
+        if let player = audioPlayer as? QueuedAudioPlayer {
+            player.previous()
+            return MPRemoteCommandHandlerStatus.success
+        }
+        return MPRemoteCommandHandlerStatus.commandFailed
+    }
+    
+    private func handleLikeCommandDefault(event: MPRemoteCommandEvent) -> MPRemoteCommandHandlerStatus {
+        MPRemoteCommandHandlerStatus.success
+    }
+    
+    private func handleDislikeCommandDefault(event: MPRemoteCommandEvent) -> MPRemoteCommandHandlerStatus {
+        MPRemoteCommandHandlerStatus.success
+    }
+    
+    private func handleBookmarkCommandDefault(event: MPRemoteCommandEvent) -> MPRemoteCommandHandlerStatus {
+        MPRemoteCommandHandlerStatus.success
+    }
+    
+    private func getRemoteCommandHandlerStatus(forError error: Error) -> MPRemoteCommandHandlerStatus {
+        return error is AudioPlayerError.QueueError
+            ? MPRemoteCommandHandlerStatus.noSuchContent
+            : MPRemoteCommandHandlerStatus.commandFailed
+    }
+    
+}

package/ios/SwiftAudioEx/Sources/SwiftAudioEx/RepeatMode.swift

@@ -0,0 +1,15 @@
+//
+//  RepeatMode.swift
+//  SwiftAudio
+//
+//  Created by David Chavez on 29.05.21.
+//  Copyright © 2021 Double Symmmery. All rights reserved.
+//
+
+import Foundation
+
+public enum RepeatMode: Int {
+    case off
+    case track
+    case queue
+}

package/ios/SwiftAudioEx/Sources/SwiftAudioEx/TimeEventFrequency.swift

@@ -0,0 +1,26 @@
+//
+//  TimeEventFrequency.swift
+//  SwiftAudio
+//
+//  Created by Jørgen Henrichsen on 11/03/2018.
+//
+
+import Foundation
+import AVFoundation
+
+
+public enum TimeEventFrequency {
+    case everySecond
+    case everyHalfSecond
+    case everyQuarterSecond
+    case custom(time: CMTime)
+    
+    func getTime() -> CMTime {
+        switch self {
+        case .everySecond: return CMTime(value: 1, timescale: 1)
+        case .everyHalfSecond: return CMTime(value: 1, timescale: 2)
+        case .everyQuarterSecond: return CMTime(value: 1, timescale: 4)
+        case .custom(let time): return time
+        }
+    }
+}

package/ios/SwiftAudioEx/Sources/SwiftAudioEx/Utils/DispatchQueueType.swift

@@ -0,0 +1,18 @@
+//
+//  DispatchQueueType.swift
+//  SwiftAudio
+//
+//  Created by David Chavez on 29.05.21.
+//
+
+import Foundation
+
+public protocol DispatchQueueType {
+    func async(flags: DispatchWorkItemFlags, execute work: @escaping @convention(block) () -> Void)
+}
+
+extension DispatchQueue: DispatchQueueType {
+    public func async(flags: DispatchWorkItemFlags, execute work: @escaping @convention(block) () -> Void) {
+        async(group: nil, qos: .unspecified, flags: flags, execute: work)
+    }
+}

package/ios/SwiftAudioEx/Sources/SwiftAudioEx/WaveformAudioTap.swift

@@ -0,0 +1,159 @@
+//
+//  WaveformAudioTap.swift
+//  SwiftAudioEx
+//
+//  Created by Rachel on 8/11/25.
+//
+
+import Foundation
+import CoreAudio
+import Accelerate
+
+struct AudioAnalysis {
+    let amplitude: Float        // Overall amplitude (0-1)
+    let eqBands: [Float]        // Normalized energy in each frequency band (0-1)
+}
+
+public class WaveformAudioTap: AudioTap {
+    static var outputs = [String]()
+    
+    // Frequency ranges for EQ bands (in Hz)
+    // HACK: i dont think this works; need to review, but it compiles nonetheless
+    private let frequencyRanges = [
+        (20, 60),     // Sub bass
+        (60, 250),    // Bass
+        (250, 500),   // Low mids
+        (500, 2000),  // Mids
+        (2000, 4000), // Upper mids
+        (4000, 20000) // Highs
+    ]
+    private let fftLength: Int
+    
+    private let emit: (_ data: Any?) -> Void
+    private var fftSetup: vDSP_DFT_Setup?
+
+    let tapIndex: Int
+
+    public init(
+        mFFTLength: Int = 1024,
+        mEmit: @escaping (_ data: Any) -> Void = { print($0) }
+    ){
+        self.tapIndex = 0
+        self.fftLength = mFFTLength
+        self.emit = mEmit
+        fftSetup = vDSP_DFT_zop_CreateSetup(
+            nil,
+            UInt(mFFTLength),
+            vDSP_DFT_Direction.FORWARD
+        )
+    }
+    
+    deinit {
+        if let setup = fftSetup {
+            vDSP_DFT_DestroySetup(setup)
+        }
+    }
+    
+    public override func initialize() {
+        Self.outputs.append("audioTap \(tapIndex): initialize")
+    }
+
+    public override func finalize() {
+        Self.outputs.append("audioTap \(tapIndex): finalize")
+    }
+
+    public override func prepare(description: AudioStreamBasicDescription) {
+        Self.outputs.append("audioTap \(tapIndex): prepare")
+    }
+
+    public override func unprepare() {
+        Self.outputs.append("audioTap \(tapIndex): unprepare")
+    }
+
+    public override func process(numberOfFrames: Int, buffer: UnsafeMutableAudioBufferListPointer) {
+        Self.outputs.append("audioTap \(tapIndex): process")
+        // Get the first buffer (assuming mono/first channel of stereo)
+        let firstBuffer = buffer[0]
+        guard firstBuffer.mData != nil else {
+            self.emit([
+                "amplitude": 0,
+                "data": Array(repeating: 0, count: frequencyRanges.count)
+            ])
+            return
+        }
+        
+        // Convert buffer data to array of floats
+        let frameLength = Int(firstBuffer.mDataByteSize) / MemoryLayout<Float>.size
+        let audioData = UnsafeBufferPointer<Float>(
+            start: firstBuffer.mData?.assumingMemoryBound(to: Float.self),
+            count: frameLength
+        )
+        
+        // Calculate RMS amplitude
+        var rms: Float = 0
+        vDSP_rmsqv(audioData.baseAddress!, 1, &rms, UInt(frameLength))
+        
+        // Prepare for FFT
+        var realPart = [Float](repeating: 0, count: fftLength)
+        var imagPart = [Float](repeating: 0, count: fftLength)
+        
+        // Copy audio data to real part, zero-padding if necessary
+        let copyLength = min(frameLength, fftLength)
+        realPart.withUnsafeMutableBufferPointer { realPtr in
+            _ = audioData.prefix(copyLength).enumerated().map { realPtr[$0.0] = $0.1 }
+        }
+        
+        // Apply Hanning window
+        var window = [Float](repeating: 0, count: fftLength)
+        vDSP_hann_window(&window, UInt(fftLength), Int32(vDSP_HANN_NORM))
+        vDSP_vmul(realPart, 1, window, 1, &realPart, 1, UInt(fftLength))
+        
+        // Perform FFT
+        realPart.withUnsafeMutableBufferPointer { realPtr in
+            imagPart.withUnsafeMutableBufferPointer { imagPtr in
+                var splitComplex = DSPSplitComplex(
+                    realp: realPtr.baseAddress!,
+                    imagp: imagPtr.baseAddress!
+                )
+                
+                if let fftSetup = fftSetup {
+                    vDSP_DFT_Execute(fftSetup,
+                                     realPtr.baseAddress!,
+                                     imagPtr.baseAddress!,
+                                     splitComplex.realp,
+                                     splitComplex.imagp)
+                }
+                
+                // Calculate magnitude spectrum
+                var magnitudes = [Float](repeating: 0, count: fftLength/2)
+                vDSP_zvmags(&splitComplex, 1, &magnitudes, 1, UInt(fftLength/2))
+                
+                // Calculate frequency resolution
+                let sampleRate: Float = 44100 // Adjust based on your audio format
+                let frequencyResolution = sampleRate / Float(fftLength)
+                
+                // Calculate energy in each frequency band
+                var eqBands: [Float] = []
+                
+                for (lowFreq, highFreq) in frequencyRanges {
+                    let lowBin = Int(Float(lowFreq) / frequencyResolution)
+                    let highBin = min(Int(Float(highFreq) / frequencyResolution), magnitudes.count)
+                    
+                    let bandMagnitudes = Array(magnitudes[lowBin..<highBin])
+                    var bandEnergy: Float = 0
+                    vDSP_meanv(bandMagnitudes, 1, &bandEnergy, UInt(bandMagnitudes.count))
+                    
+                    // Convert to dB scale and normalize
+                    let dbValue = 20 * log10(bandEnergy + 1e-6)
+                    let normalizedValue = (dbValue + 60) / 60 // Normalize to 0-1 range
+                    eqBands.append(max(0, min(1, normalizedValue)))
+                }
+                
+                self.emit([
+                    "amplitude": rms,
+                    "data": eqBands
+                ])
+            }
+        }
+    }
+}