@javascriptcommon/react-native-track-player 4.1.9 → 4.1.12

package/android/build.gradle

@@ -111,4 +111,7 @@ dependencies {
 
     implementation 'androidx.test:rules:1.7.0'
     implementation 'jp.wasabeef.transformers:coil:1.0.6'
+
+    // FORK PATCH: Used by AutoConnectionDetector
+    implementation "androidx.car.app:app:1.7.0"
 }

package/android/src/main/java/com/doublesymmetry/trackplayer/module/MusicModule.kt

@@ -325,6 +325,63 @@ class MusicModule(reactContext: ReactApplicationContext) : NativeTrackPlayerSpec
         callback.resolve(Arguments.fromList(musicService.getEqualizerPresets()))
     }
 
+    // Cross-platform Equalizer Band API
+
+    override fun setEqualizerEnabled(enabled: Boolean, callback: Promise) = launchInScope {
+        if (verifyServiceBoundOrReject(callback)) return@launchInScope
+        musicService.setEqualizerEnabled(enabled)
+        callback.resolve(null)
+    }
+
+    override fun getEqualizerEnabled(callback: Promise) = launchInScope {
+        if (verifyServiceBoundOrReject(callback)) return@launchInScope
+        callback.resolve(musicService.getEqualizerEnabled())
+    }
+
+    override fun setEqualizerBand(band: Double, gain: Double, callback: Promise) = launchInScope {
+        if (verifyServiceBoundOrReject(callback)) return@launchInScope
+        musicService.setEqualizerBand(band.toInt(), gain.toFloat())
+        callback.resolve(null)
+    }
+
+    override fun setEqualizerBands(gains: ReadableArray?, callback: Promise) = launchInScope {
+        if (verifyServiceBoundOrReject(callback)) return@launchInScope
+        val gainsList = mutableListOf<Float>()
+        gains?.let {
+            for (i in 0 until it.size()) {
+                gainsList.add(it.getDouble(i).toFloat())
+            }
+        }
+        musicService.setEqualizerBands(gainsList)
+        callback.resolve(null)
+    }
+
+    override fun getEqualizerBands(callback: Promise) = launchInScope {
+        if (verifyServiceBoundOrReject(callback)) return@launchInScope
+        callback.resolve(Arguments.fromList(musicService.getEqualizerBands()))
+    }
+
+    override fun getEqualizerFrequencies(callback: Promise) = launchInScope {
+        if (verifyServiceBoundOrReject(callback)) return@launchInScope
+        callback.resolve(Arguments.fromList(musicService.getEqualizerFrequencies()))
+    }
+
+    override fun applyEqualizerPreset(presetIndex: Double, callback: Promise) = launchInScope {
+        if (verifyServiceBoundOrReject(callback)) return@launchInScope
+        musicService.applyEqualizerPreset(presetIndex.toInt())
+        callback.resolve(null)
+    }
+
+    override fun getEqualizerPresetNames(callback: Promise) = launchInScope {
+        if (verifyServiceBoundOrReject(callback)) return@launchInScope
+        callback.resolve(Arguments.fromList(musicService.getEqualizerPresetNames()))
+    }
+
+    override fun resetEqualizer(callback: Promise) = launchInScope {
+        if (verifyServiceBoundOrReject(callback)) return@launchInScope
+        musicService.resetEqualizer()
+        callback.resolve(null)
+    }
 
     override fun setLoudnessEnhance(gain: Double, callback: Promise) = launchInScope {
         musicService.setLoudnessEnhance(gain.toInt())

package/android/src/main/java/com/doublesymmetry/trackplayer/service/MusicService.kt

@@ -156,6 +156,48 @@ class MusicService : HeadlessJsMediaService() {
         player.setLoudnessEnhance(gain)
     }
 
+    // Cross-platform Equalizer Band API
+
+    fun setEqualizerEnabled(enabled: Boolean) {
+        player.setEqualizerEnabled(enabled)
+    }
+
+    fun getEqualizerEnabled(): Boolean {
+        return player.getEqualizerEnabled()
+    }
+
+    fun setEqualizerBand(band: Int, gain: Float) {
+        player.setEqualizerBand(band, gain)
+    }
+
+    fun setEqualizerBands(gains: List<Float>) {
+        player.setEqualizerBands(gains)
+    }
+
+    fun getEqualizerBands(): List<Float> {
+        return player.getEqualizerBands()
+    }
+
+    fun getEqualizerFrequencies(): List<Int> {
+        return player.getEqualizerFrequencies()
+    }
+
+    fun getEqualizerBandLevelRange(): List<Float> {
+        return player.getEqualizerBandLevelRange()
+    }
+
+    fun applyEqualizerPreset(presetIndex: Int) {
+        player.applyEqualizerPreset(presetIndex)
+    }
+
+    fun getEqualizerPresetNames(): List<String> {
+        return player.getEqualizerPresetNames()
+    }
+
+    fun resetEqualizer() {
+        player.resetEqualizer()
+    }
+
     fun crossFadePrepare(previous: Boolean = false, seekTo: Double = 0.0) {
         player.crossFadePrepare(previous, seekTo)
     }

package/android/src/main/java/com/lovegaoshi/kotlinaudio/player/AudioPlayer.kt

@@ -295,6 +295,154 @@ abstract class AudioPlayer internal constructor(
             .map { i -> equalizers[0].getPresetName(i.toShort()) }
     }
 
+    // 10-band Equalizer API (cross-platform compatible)
+
+    /**
+     * Enable or disable the equalizer
+     */
+    fun setEqualizerEnabled(enabled: Boolean) {
+        equalizers.forEach { equalizer ->
+            equalizer.enabled = enabled
+        }
+    }
+
+    /**
+     * Check if the equalizer is enabled
+     */
+    fun getEqualizerEnabled(): Boolean {
+        if (equalizers.isEmpty()) return false
+        return equalizers[0].enabled
+    }
+
+    /**
+     * Get the number of equalizer bands available
+     */
+    fun getEqualizerBandCount(): Int {
+        if (equalizers.isEmpty()) return 0
+        return equalizers[0].numberOfBands.toInt()
+    }
+
+    /**
+     * Set the gain for a specific equalizer band
+     * @param band Band index (0 to bandCount-1)
+     * @param gainDB Gain in millibels (mB). 1 dB = 100 mB
+     */
+    fun setEqualizerBand(band: Int, gainDB: Float) {
+        equalizers.forEach { equalizer ->
+            if (band >= 0 && band < equalizer.numberOfBands) {
+                // Convert dB to millibels (mB)
+                val millibels = (gainDB * 100).toInt().toShort()
+                val range = equalizer.bandLevelRange
+                val clampedLevel = millibels.coerceIn(range[0], range[1])
+                equalizer.setBandLevel(band.toShort(), clampedLevel)
+                equalizer.enabled = true
+            }
+        }
+    }
+
+    /**
+     * Set gains for all equalizer bands at once
+     * @param gainsDB Array of gain values in dB
+     */
+    fun setEqualizerBands(gainsDB: List<Float>) {
+        equalizers.forEach { equalizer ->
+            val bandCount = equalizer.numberOfBands.toInt()
+            val range = equalizer.bandLevelRange
+            for (i in 0 until minOf(gainsDB.size, bandCount)) {
+                val millibels = (gainsDB[i] * 100).toInt().toShort()
+                val clampedLevel = millibels.coerceIn(range[0], range[1])
+                equalizer.setBandLevel(i.toShort(), clampedLevel)
+            }
+            equalizer.enabled = true
+        }
+    }
+
+    /**
+     * Get all current equalizer band gains
+     * @return Array of gain values in dB
+     */
+    fun getEqualizerBands(): List<Float> {
+        if (equalizers.isEmpty()) return emptyList()
+        val equalizer = equalizers[0]
+        val bandCount = equalizer.numberOfBands.toInt()
+        return (0 until bandCount).map { band ->
+            // Convert millibels to dB
+            equalizer.getBandLevel(band.toShort()).toFloat() / 100f
+        }
+    }
+
+    /**
+     * Get the center frequencies for each equalizer band
+     * @return Array of frequency values in Hz
+     */
+    fun getEqualizerFrequencies(): List<Int> {
+        if (equalizers.isEmpty()) return emptyList()
+        val equalizer = equalizers[0]
+        val bandCount = equalizer.numberOfBands.toInt()
+        return (0 until bandCount).map { band ->
+            // getCenterFreq returns milliHz, convert to Hz
+            (equalizer.getCenterFreq(band.toShort()) / 1000)
+        }
+    }
+
+    /**
+     * Get the band level range in dB [min, max]
+     */
+    fun getEqualizerBandLevelRange(): List<Float> {
+        if (equalizers.isEmpty()) return listOf(-12f, 12f)
+        val range = equalizers[0].bandLevelRange
+        // Convert millibels to dB
+        return listOf(range[0].toFloat() / 100f, range[1].toFloat() / 100f)
+    }
+
+    /**
+     * Reset all equalizer bands to 0 (flat response)
+     */
+    fun resetEqualizer() {
+        equalizers.forEach { equalizer ->
+            val bandCount = equalizer.numberOfBands.toInt()
+            for (i in 0 until bandCount) {
+                equalizer.setBandLevel(i.toShort(), 0)
+            }
+        }
+    }
+
+    /**
+     * Get preset names for iOS compatibility (custom presets mapped to Android system presets)
+     */
+    fun getEqualizerPresetNames(): List<String> {
+        // Return iOS-compatible preset names
+        return listOf(
+            "Flat", "Rock", "Pop", "Jazz", "Classical",
+            "Hip Hop", "Electronic", "Acoustic", "Bass Boost",
+            "Treble Boost", "Vocal", "Loudness"
+        )
+    }
+
+    /**
+     * Apply a preset by index (iOS-compatible)
+     * Maps iOS preset index to gain values
+     */
+    fun applyEqualizerPreset(presetIndex: Int) {
+        val presets = listOf(
+            listOf(0f, 0f, 0f, 0f, 0f, 0f, 0f, 0f, 0f, 0f),           // Flat
+            listOf(5f, 4f, 3f, 1f, -1f, 0f, 2f, 3f, 4f, 4f),          // Rock
+            listOf(-1f, 1f, 3f, 4f, 3f, 1f, 0f, 1f, 2f, 2f),          // Pop
+            listOf(3f, 2f, 1f, 2f, -1f, -1f, 0f, 1f, 2f, 3f),         // Jazz
+            listOf(4f, 3f, 2f, 1f, -1f, -1f, 0f, 2f, 3f, 4f),         // Classical
+            listOf(5f, 5f, 3f, 1f, -1f, 0f, 1f, 0f, 2f, 3f),          // Hip Hop
+            listOf(4f, 4f, 2f, 0f, -2f, -1f, 0f, 2f, 4f, 4f),         // Electronic
+            listOf(3f, 2f, 1f, 1f, 0f, 0f, 1f, 2f, 2f, 2f),           // Acoustic
+            listOf(6f, 5f, 4f, 2f, 0f, 0f, 0f, 0f, 0f, 0f),           // Bass Boost
+            listOf(0f, 0f, 0f, 0f, 0f, 1f, 2f, 4f, 5f, 6f),           // Treble Boost
+            listOf(-2f, -1f, 0f, 2f, 4f, 4f, 3f, 1f, 0f, -1f),        // Vocal
+            listOf(5f, 4f, 2f, 0f, -2f, -2f, 0f, 2f, 4f, 5f)          // Loudness
+        )
+        if (presetIndex >= 0 && presetIndex < presets.size) {
+            setEqualizerBands(presets[presetIndex])
+        }
+    }
+
     fun togglePlaying() {
         if (exoPlayer.isPlaying) {
             pause()

package/ios/RNTrackPlayer/RNTrackPlayer.swift

@@ -35,6 +35,7 @@ public class RNTrackPlayer: NSObject, AudioSessionControllerDelegate {
     private var hasInitialized = false
     private let player = QueuedAudioPlayer()
     private let audioSessionController = AudioSessionController.shared
+    private var equalizerTap: EqualizerAudioTap?
     private var shouldEmitProgressEvent: Bool = false
     private var shouldResumePlaybackAfterInterruptionEnds: Bool = false
     private var forwardJumpInterval: NSNumber? = nil;
@@ -895,6 +896,107 @@ public class RNTrackPlayer: NSObject, AudioSessionControllerDelegate {
             ]
         )
     }
+
+    // MARK: - iOS Equalizer Methods
+
+    @objc(setEqualizerEnabled:resolver:rejecter:)
+    public func setEqualizerEnabled(enabled: Bool, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        if enabled {
+            if equalizerTap == nil {
+                equalizerTap = EqualizerAudioTap()
+            }
+            equalizerTap?.isEnabled = true
+            player.audioTap = equalizerTap
+        } else {
+            equalizerTap?.isEnabled = false
+            player.audioTap = nil
+        }
+
+        resolve(NSNull())
+    }
+
+    @objc(getEqualizerEnabled:rejecter:)
+    public func getEqualizerEnabled(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        let enabled = equalizerTap?.isEnabled ?? false
+        resolve(enabled)
+    }
+
+    @objc(setEqualizerBand:gain:resolver:rejecter:)
+    public func setEqualizerBand(band: Int, gain: Float, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        if equalizerTap == nil {
+            equalizerTap = EqualizerAudioTap()
+            player.audioTap = equalizerTap
+        }
+
+        equalizerTap?.setGain(band: band, gainDB: gain)
+        resolve(NSNull())
+    }
+
+    @objc(setEqualizerBands:resolver:rejecter:)
+    public func setEqualizerBands(gains: [NSNumber], resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        if equalizerTap == nil {
+            equalizerTap = EqualizerAudioTap()
+            player.audioTap = equalizerTap
+        }
+
+        let floatGains = gains.map { $0.floatValue }
+        equalizerTap?.setAllGains(floatGains)
+        resolve(NSNull())
+    }
+
+    @objc(getEqualizerBands:rejecter:)
+    public func getEqualizerBands(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        let gains = equalizerTap?.getAllGains() ?? Array(repeating: Float(0), count: 10)
+        resolve(gains)
+    }
+
+    @objc(getEqualizerFrequencies:rejecter:)
+    public func getEqualizerFrequencies(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        resolve(EqualizerAudioTap.frequencies)
+    }
+
+    @objc(applyEqualizerPreset:resolver:rejecter:)
+    public func applyEqualizerPreset(presetIndex: Int, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        let presets = EqualizerAudioTap.Preset.allCases
+        guard presetIndex >= 0 && presetIndex < presets.count else {
+            reject("invalid_preset", "Preset index out of bounds", nil)
+            return
+        }
+
+        if equalizerTap == nil {
+            equalizerTap = EqualizerAudioTap()
+            player.audioTap = equalizerTap
+        }
+
+        let preset = presets[presetIndex]
+        equalizerTap?.applyPreset(preset)
+        resolve(NSNull())
+    }
+
+    @objc(getEqualizerPresetNames:rejecter:)
+    public func getEqualizerPresetNames(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        resolve(EqualizerAudioTap.presetNames)
+    }
+
+    @objc(resetEqualizer:rejecter:)
+    public func resetEqualizer(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+
+        equalizerTap?.resetGains()
+        resolve(NSNull())
+    }
 }
 
 extension RNTrackPlayer {

package/ios/SwiftAudioEx/Sources/SwiftAudioEx/AVPlayerWrapper/AVPlayerWrapper.swift

@@ -40,6 +40,7 @@ class AVPlayerWrapper: AVPlayerWrapperProtocol {
         label: "AVPlayerWrapper.stateQueue",
         attributes: .concurrent
     )
+    private var cachedDuration: TimeInterval = 0.0
 
     public init() {
         playerTimeObserver = AVPlayerTimeObserver(periodicObserverTimeInterval: timeEventFrequency.getTime())
@@ -115,17 +116,8 @@ class AVPlayerWrapper: AVPlayerWrapperProtocol {
     }
     
     var duration: TimeInterval {
-        if let seconds = currentItem?.asset.duration.seconds, !seconds.isNaN {
-            return seconds
-        }
-        else if let seconds = currentItem?.duration.seconds, !seconds.isNaN {
-            return seconds
-        }
-        else if let seconds = currentItem?.seekableTimeRanges.last?.timeRangeValue.duration.seconds,
-                !seconds.isNaN {
-            return seconds
-        }
-        return 0.0
+        // Return cached duration to avoid synchronous access to AVAsset properties
+        return cachedDuration
     }
     
     var bufferedPosition: TimeInterval {
@@ -242,7 +234,7 @@ class AVPlayerWrapper: AVPlayerWrapperProtocol {
             state = .loading
             
             // Load metadata keys asynchronously and separate from playable, to allow that to execute as quickly as it can
-            let metdataKeys = ["commonMetadata", "availableChapterLocales", "availableMetadataFormats"]
+            let metdataKeys = ["commonMetadata", "availableChapterLocales", "availableMetadataFormats", "duration"]
             pendingAsset.loadValuesAsynchronously(forKeys: metdataKeys, completionHandler: { [weak self] in
                 guard let self = self else { return }
                 if (pendingAsset != self.asset) { return; }
@@ -381,6 +373,7 @@ class AVPlayerWrapper: AVPlayerWrapperProtocol {
         
         asset.cancelLoading()
         self.asset = nil
+        cachedDuration = 0.0
         
         avPlayer.replaceCurrentItem(with: nil)
     }
@@ -518,6 +511,7 @@ extension AVPlayerWrapper: AVPlayerItemObserverDelegate {
     }
         
     func item(didUpdateDuration duration: Double) {
+        cachedDuration = duration
         delegate?.AVWrapper(didUpdateDuration: duration)
     }
     

package/ios/SwiftAudioEx/Sources/SwiftAudioEx/EqualizerAudioTap.swift

@@ -0,0 +1,346 @@
+//
+//  EqualizerAudioTap.swift
+//  SwiftAudioEx
+//
+//  iOS Equalizer implementation using biquad peaking filters
+//
+
+import Foundation
+import AVFoundation
+import Accelerate
+
+/// 10-band parametric equalizer using cascaded biquad filters
+/// Processes audio in real-time via MTAudioProcessingTap
+public class EqualizerAudioTap: AudioTap {
+
+    // MARK: - Constants
+
+    /// Standard 10-band equalizer frequencies (Hz)
+    public static let frequencies: [Float] = [
+        32,     // Sub-bass
+        64,     // Bass
+        125,    // Low-bass
+        250,    // Low-mid
+        500,    // Mid
+        1000,   // Mid
+        2000,   // Upper-mid
+        4000,   // Presence
+        8000,   // Brilliance
+        16000   // Air
+    ]
+
+    /// Number of equalizer bands
+    public static let bandCount = 10
+
+    /// Default Q factor for peaking filters (standard for graphic EQ)
+    private static let defaultQ: Float = 1.41
+
+    // MARK: - Properties
+
+    /// Whether the equalizer is enabled
+    public var isEnabled: Bool = true
+
+    /// Gain values for each band in dB (-12 to +12)
+    private var _gains: [Float] = Array(repeating: 0, count: bandCount)
+
+    /// Thread-safe access to gains
+    private let gainsLock = NSLock()
+
+    /// Current sample rate (set during prepare)
+    private var sampleRate: Float = 44100
+
+    /// Biquad filter coefficients for each band [b0, b1, b2, a1, a2]
+    private var coefficients: [[Float]] = []
+
+    /// Filter state (delay elements) for each band, per channel
+    /// Structure: [band][channel][z1, z2]
+    private var filterStates: [[[Float]]] = []
+
+    /// Number of audio channels
+    private var channelCount: Int = 2
+
+    /// Flag to indicate coefficients need recalculation
+    private var needsUpdate: Bool = true
+
+    // MARK: - Public API
+
+    public override init() {
+        super.init()
+        // Initialize with flat response (all gains at 0)
+        resetGains()
+    }
+
+    /// Set gain for a specific band
+    /// - Parameters:
+    ///   - band: Band index (0-9)
+    ///   - gainDB: Gain in decibels (-12 to +12)
+    public func setGain(band: Int, gainDB: Float) {
+        guard band >= 0 && band < Self.bandCount else { return }
+
+        let clampedGain = max(-12, min(12, gainDB))
+
+        gainsLock.lock()
+        _gains[band] = clampedGain
+        needsUpdate = true
+        gainsLock.unlock()
+    }
+
+    /// Set gains for all bands at once
+    /// - Parameter gains: Array of 10 gain values in dB
+    public func setAllGains(_ gains: [Float]) {
+        guard gains.count == Self.bandCount else { return }
+
+        gainsLock.lock()
+        for i in 0..<Self.bandCount {
+            _gains[i] = max(-12, min(12, gains[i]))
+        }
+        needsUpdate = true
+        gainsLock.unlock()
+    }
+
+    /// Get current gain for a specific band
+    public func getGain(band: Int) -> Float {
+        guard band >= 0 && band < Self.bandCount else { return 0 }
+
+        gainsLock.lock()
+        let gain = _gains[band]
+        gainsLock.unlock()
+        return gain
+    }
+
+    /// Get all current gains
+    public func getAllGains() -> [Float] {
+        gainsLock.lock()
+        let gains = _gains
+        gainsLock.unlock()
+        return gains
+    }
+
+    /// Reset all gains to 0 (flat response)
+    public func resetGains() {
+        gainsLock.lock()
+        _gains = Array(repeating: 0, count: Self.bandCount)
+        needsUpdate = true
+        gainsLock.unlock()
+    }
+
+    // MARK: - AudioTap Overrides
+
+    public override func initialize() {
+        // Called when tap is attached
+    }
+
+    public override func finalize() {
+        // Called when tap is detached
+        filterStates = []
+        coefficients = []
+    }
+
+    public override func prepare(description: AudioStreamBasicDescription) {
+        sampleRate = Float(description.mSampleRate)
+        channelCount = Int(description.mChannelsPerFrame)
+
+        // Initialize filter states for each band and channel
+        filterStates = Array(
+            repeating: Array(
+                repeating: [0, 0],  // z1, z2 delay elements
+                count: channelCount
+            ),
+            count: Self.bandCount
+        )
+
+        // Calculate initial coefficients
+        updateCoefficients()
+    }
+
+    public override func unprepare() {
+        // Reset filter states
+        for band in 0..<filterStates.count {
+            for channel in 0..<filterStates[band].count {
+                filterStates[band][channel] = [0, 0]
+            }
+        }
+    }
+
+    public override func process(numberOfFrames: Int, buffer: UnsafeMutableAudioBufferListPointer) {
+        // Skip processing if disabled or no frames
+        guard isEnabled && numberOfFrames > 0 else { return }
+
+        // Check if coefficients need update
+        gainsLock.lock()
+        if needsUpdate {
+            updateCoefficientsLocked()
+            needsUpdate = false
+        }
+        let currentCoefficients = coefficients
+        gainsLock.unlock()
+
+        // Process each channel
+        for channelIndex in 0..<min(buffer.count, channelCount) {
+            guard let channelData = buffer[channelIndex].mData else { continue }
+
+            let samples = channelData.assumingMemoryBound(to: Float.self)
+
+            // Apply each band's filter in cascade
+            for bandIndex in 0..<Self.bandCount {
+                guard bandIndex < currentCoefficients.count else { continue }
+
+                let coeff = currentCoefficients[bandIndex]
+                guard coeff.count >= 5 else { continue }
+
+                let b0 = coeff[0]
+                let b1 = coeff[1]
+                let b2 = coeff[2]
+                let a1 = coeff[3]
+                let a2 = coeff[4]
+
+                // Get filter state for this band and channel
+                var z1 = filterStates[bandIndex][channelIndex][0]
+                var z2 = filterStates[bandIndex][channelIndex][1]
+
+                // Process samples using Direct Form II Transposed
+                for i in 0..<numberOfFrames {
+                    let input = samples[i]
+                    let output = b0 * input + z1
+                    z1 = b1 * input - a1 * output + z2
+                    z2 = b2 * input - a2 * output
+                    samples[i] = output
+                }
+
+                // Save filter state
+                filterStates[bandIndex][channelIndex][0] = z1
+                filterStates[bandIndex][channelIndex][1] = z2
+            }
+        }
+    }
+
+    // MARK: - Private Methods
+
+    private func updateCoefficients() {
+        gainsLock.lock()
+        updateCoefficientsLocked()
+        gainsLock.unlock()
+    }
+
+    /// Calculate biquad coefficients for all bands (must be called with lock held)
+    private func updateCoefficientsLocked() {
+        coefficients = []
+
+        for i in 0..<Self.bandCount {
+            let freq = Self.frequencies[i]
+            let gainDB = _gains[i]
+
+            let coeff = calculatePeakingEQCoefficients(
+                frequency: freq,
+                gainDB: gainDB,
+                q: Self.defaultQ,
+                sampleRate: sampleRate
+            )
+            coefficients.append(coeff)
+        }
+    }
+
+    /// Calculate biquad coefficients for a peaking EQ filter
+    /// Based on Audio EQ Cookbook by Robert Bristow-Johnson
+    /// - Parameters:
+    ///   - frequency: Center frequency in Hz
+    ///   - gainDB: Gain in decibels
+    ///   - q: Q factor (bandwidth)
+    ///   - sampleRate: Sample rate in Hz
+    /// - Returns: Coefficients [b0, b1, b2, a1, a2] (normalized by a0)
+    private func calculatePeakingEQCoefficients(
+        frequency: Float,
+        gainDB: Float,
+        q: Float,
+        sampleRate: Float
+    ) -> [Float] {
+        // If gain is essentially 0, return unity (pass-through)
+        if abs(gainDB) < 0.01 {
+            return [1, 0, 0, 0, 0]  // b0=1, rest=0 means y[n] = x[n]
+        }
+
+        let A = pow(10, gainDB / 40)  // sqrt(10^(dB/20))
+        let w0 = 2 * Float.pi * frequency / sampleRate
+        let cosW0 = cos(w0)
+        let sinW0 = sin(w0)
+        let alpha = sinW0 / (2 * q)
+
+        // Peaking EQ coefficients
+        let b0 = 1 + alpha * A
+        let b1 = -2 * cosW0
+        let b2 = 1 - alpha * A
+        let a0 = 1 + alpha / A
+        let a1 = -2 * cosW0
+        let a2 = 1 - alpha / A
+
+        // Normalize by a0
+        return [
+            b0 / a0,
+            b1 / a0,
+            b2 / a0,
+            a1 / a0,
+            a2 / a0
+        ]
+    }
+}
+
+// MARK: - Preset Support
+
+extension EqualizerAudioTap {
+
+    /// Predefined equalizer presets
+    public enum Preset: String, CaseIterable {
+        case flat = "Flat"
+        case rock = "Rock"
+        case pop = "Pop"
+        case jazz = "Jazz"
+        case classical = "Classical"
+        case hiphop = "Hip Hop"
+        case electronic = "Electronic"
+        case acoustic = "Acoustic"
+        case bass = "Bass Boost"
+        case treble = "Treble Boost"
+        case vocal = "Vocal"
+        case loudness = "Loudness"
+
+        /// Gain values for each preset (10 bands)
+        public var gains: [Float] {
+            switch self {
+            case .flat:
+                return [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+            case .rock:
+                return [5, 4, 3, 1, -1, 0, 2, 3, 4, 4]
+            case .pop:
+                return [-1, 1, 3, 4, 3, 1, 0, 1, 2, 2]
+            case .jazz:
+                return [3, 2, 1, 2, -1, -1, 0, 1, 2, 3]
+            case .classical:
+                return [4, 3, 2, 1, -1, -1, 0, 2, 3, 4]
+            case .hiphop:
+                return [5, 5, 3, 1, -1, 0, 1, 0, 2, 3]
+            case .electronic:
+                return [4, 4, 2, 0, -2, -1, 0, 2, 4, 4]
+            case .acoustic:
+                return [3, 2, 1, 1, 0, 0, 1, 2, 2, 2]
+            case .bass:
+                return [6, 5, 4, 2, 0, 0, 0, 0, 0, 0]
+            case .treble:
+                return [0, 0, 0, 0, 0, 1, 2, 4, 5, 6]
+            case .vocal:
+                return [-2, -1, 0, 2, 4, 4, 3, 1, 0, -1]
+            case .loudness:
+                return [5, 4, 2, 0, -2, -2, 0, 2, 4, 5]
+            }
+        }
+    }
+
+    /// Apply a preset
+    public func applyPreset(_ preset: Preset) {
+        setAllGains(preset.gains)
+    }
+
+    /// Get all available preset names
+    public static var presetNames: [String] {
+        return Preset.allCases.map { $0.rawValue }
+    }
+}

package/lib/specs/NativeTrackPlayer.d.ts

@@ -46,6 +46,15 @@ export interface Spec extends TurboModule {
     setEqualizerPreset(preset: number): Promise<void>;
     getCurrentEqualizerPreset(): Promise<number>;
     getEqualizerPresets(): Promise<string[]>;
+    setEqualizerEnabled(enabled: boolean): Promise<void>;
+    getEqualizerEnabled(): Promise<boolean>;
+    setEqualizerBand(band: number, gain: number): Promise<void>;
+    setEqualizerBands(gains: number[]): Promise<void>;
+    getEqualizerBands(): Promise<number[]>;
+    getEqualizerFrequencies(): Promise<number[]>;
+    applyEqualizerPreset(presetIndex: number): Promise<void>;
+    getEqualizerPresetNames(): Promise<string[]>;
+    resetEqualizer(): Promise<void>;
     addListener(eventName: string): void;
     removeListeners(count: number): void;
     getConstants: () => {

package/lib/src/trackPlayer.d.ts

@@ -369,3 +369,51 @@ export declare function getCurrentEqualizerPreset(): Promise<number>;
  * android only. get the current eq preset names.
  */
 export declare function getEqualizerPresets(): Promise<string[]>;
+/**
+ * Enable or disable the parametric equalizer.
+ * - iOS: 10-band biquad peaking filters
+ * - Android: System equalizer (band count varies by device, typically 5)
+ */
+export declare function setEqualizerEnabled(enabled: boolean): Promise<void>;
+/**
+ * Check if the equalizer is enabled.
+ */
+export declare function getEqualizerEnabled(): Promise<boolean>;
+/**
+ * Set the gain for a specific equalizer band.
+ * @param band Band index (0 to bandCount-1)
+ * @param gain Gain in dB (range varies by platform, typically -12 to +12)
+ */
+export declare function setEqualizerBand(band: number, gain: number): Promise<void>;
+/**
+ * Set all equalizer band gains at once.
+ * @param gains Array of gain values in dB
+ * Note: iOS has 10 bands, Android typically has 5 (device dependent)
+ */
+export declare function setEqualizerBands(gains: number[]): Promise<void>;
+/**
+ * Get all current equalizer band gains.
+ * @returns Array of gain values in dB
+ */
+export declare function getEqualizerBands(): Promise<number[]>;
+/**
+ * Get the center frequencies for each equalizer band.
+ * @returns Array of frequency values in Hz
+ * - iOS: [32, 64, 125, 250, 500, 1000, 2000, 4000, 8000, 16000]
+ * - Android: varies by device (typically 5 bands)
+ */
+export declare function getEqualizerFrequencies(): Promise<number[]>;
+/**
+ * Apply a preset to the equalizer.
+ * @param presetIndex Index of the preset (use getEqualizerPresetNames to get available presets)
+ */
+export declare function applyEqualizerPreset(presetIndex: number): Promise<void>;
+/**
+ * Get available equalizer preset names.
+ * @returns Array of preset names ["Flat", "Rock", "Pop", "Jazz", ...]
+ */
+export declare function getEqualizerPresetNames(): Promise<string[]>;
+/**
+ * Reset all equalizer bands to 0 (flat response).
+ */
+export declare function resetEqualizer(): Promise<void>;

package/lib/src/trackPlayer.js

@@ -625,3 +625,70 @@ export async function getEqualizerPresets() {
         return [];
     return TrackPlayer.getEqualizerPresets();
 }
+// MARK: - Cross-Platform Equalizer API (Band Control)
+/**
+ * Enable or disable the parametric equalizer.
+ * - iOS: 10-band biquad peaking filters
+ * - Android: System equalizer (band count varies by device, typically 5)
+ */
+export async function setEqualizerEnabled(enabled) {
+    return TrackPlayer.setEqualizerEnabled(enabled);
+}
+/**
+ * Check if the equalizer is enabled.
+ */
+export async function getEqualizerEnabled() {
+    return TrackPlayer.getEqualizerEnabled();
+}
+/**
+ * Set the gain for a specific equalizer band.
+ * @param band Band index (0 to bandCount-1)
+ * @param gain Gain in dB (range varies by platform, typically -12 to +12)
+ */
+export async function setEqualizerBand(band, gain) {
+    return TrackPlayer.setEqualizerBand(band, gain);
+}
+/**
+ * Set all equalizer band gains at once.
+ * @param gains Array of gain values in dB
+ * Note: iOS has 10 bands, Android typically has 5 (device dependent)
+ */
+export async function setEqualizerBands(gains) {
+    return TrackPlayer.setEqualizerBands(gains);
+}
+/**
+ * Get all current equalizer band gains.
+ * @returns Array of gain values in dB
+ */
+export async function getEqualizerBands() {
+    return TrackPlayer.getEqualizerBands();
+}
+/**
+ * Get the center frequencies for each equalizer band.
+ * @returns Array of frequency values in Hz
+ * - iOS: [32, 64, 125, 250, 500, 1000, 2000, 4000, 8000, 16000]
+ * - Android: varies by device (typically 5 bands)
+ */
+export async function getEqualizerFrequencies() {
+    return TrackPlayer.getEqualizerFrequencies();
+}
+/**
+ * Apply a preset to the equalizer.
+ * @param presetIndex Index of the preset (use getEqualizerPresetNames to get available presets)
+ */
+export async function applyEqualizerPreset(presetIndex) {
+    return TrackPlayer.applyEqualizerPreset(presetIndex);
+}
+/**
+ * Get available equalizer preset names.
+ * @returns Array of preset names ["Flat", "Rock", "Pop", "Jazz", ...]
+ */
+export async function getEqualizerPresetNames() {
+    return TrackPlayer.getEqualizerPresetNames();
+}
+/**
+ * Reset all equalizer bands to 0 (flat response).
+ */
+export async function resetEqualizer() {
+    return TrackPlayer.resetEqualizer();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@javascriptcommon/react-native-track-player",
-  "version": "4.1.9",
+  "version": "4.1.12",
   "description": "A fully fledged audio module created for music apps",
   "main": "lib/src/index.js",
   "types": "lib/src/index.d.ts",

package/specs/NativeTrackPlayer.ts

@@ -68,6 +68,17 @@ export interface Spec extends TurboModule {
   getCurrentEqualizerPreset(): Promise<number>;
   getEqualizerPresets(): Promise<string[]>;
 
+  // iOS Equalizer methods (10-band parametric EQ)
+  setEqualizerEnabled(enabled: boolean): Promise<void>;
+  getEqualizerEnabled(): Promise<boolean>;
+  setEqualizerBand(band: number, gain: number): Promise<void>;
+  setEqualizerBands(gains: number[]): Promise<void>;
+  getEqualizerBands(): Promise<number[]>;
+  getEqualizerFrequencies(): Promise<number[]>;
+  applyEqualizerPreset(presetIndex: number): Promise<void>;
+  getEqualizerPresetNames(): Promise<string[]>;
+  resetEqualizer(): Promise<void>;
+
   // event listeners
   addListener(eventName: string): void;
   removeListeners(count: number): void;

package/src/trackPlayer.ts

@@ -804,3 +804,83 @@ export async function getEqualizerPresets(): Promise<string[]> {
   if (!isAndroid) return [];
   return TrackPlayer.getEqualizerPresets();
 }
+
+// MARK: - Cross-Platform Equalizer API (Band Control)
+
+/**
+ * Enable or disable the parametric equalizer.
+ * - iOS: 10-band biquad peaking filters
+ * - Android: System equalizer (band count varies by device, typically 5)
+ */
+export async function setEqualizerEnabled(enabled: boolean): Promise<void> {
+  return TrackPlayer.setEqualizerEnabled(enabled);
+}
+
+/**
+ * Check if the equalizer is enabled.
+ */
+export async function getEqualizerEnabled(): Promise<boolean> {
+  return TrackPlayer.getEqualizerEnabled();
+}
+
+/**
+ * Set the gain for a specific equalizer band.
+ * @param band Band index (0 to bandCount-1)
+ * @param gain Gain in dB (range varies by platform, typically -12 to +12)
+ */
+export async function setEqualizerBand(
+  band: number,
+  gain: number,
+): Promise<void> {
+  return TrackPlayer.setEqualizerBand(band, gain);
+}
+
+/**
+ * Set all equalizer band gains at once.
+ * @param gains Array of gain values in dB
+ * Note: iOS has 10 bands, Android typically has 5 (device dependent)
+ */
+export async function setEqualizerBands(gains: number[]): Promise<void> {
+  return TrackPlayer.setEqualizerBands(gains);
+}
+
+/**
+ * Get all current equalizer band gains.
+ * @returns Array of gain values in dB
+ */
+export async function getEqualizerBands(): Promise<number[]> {
+  return TrackPlayer.getEqualizerBands();
+}
+
+/**
+ * Get the center frequencies for each equalizer band.
+ * @returns Array of frequency values in Hz
+ * - iOS: [32, 64, 125, 250, 500, 1000, 2000, 4000, 8000, 16000]
+ * - Android: varies by device (typically 5 bands)
+ */
+export async function getEqualizerFrequencies(): Promise<number[]> {
+  return TrackPlayer.getEqualizerFrequencies();
+}
+
+/**
+ * Apply a preset to the equalizer.
+ * @param presetIndex Index of the preset (use getEqualizerPresetNames to get available presets)
+ */
+export async function applyEqualizerPreset(presetIndex: number): Promise<void> {
+  return TrackPlayer.applyEqualizerPreset(presetIndex);
+}
+
+/**
+ * Get available equalizer preset names.
+ * @returns Array of preset names ["Flat", "Rock", "Pop", "Jazz", ...]
+ */
+export async function getEqualizerPresetNames(): Promise<string[]> {
+  return TrackPlayer.getEqualizerPresetNames();
+}
+
+/**
+ * Reset all equalizer bands to 0 (flat response).
+ */
+export async function resetEqualizer(): Promise<void> {
+  return TrackPlayer.resetEqualizer();
+}