@javascriptcommon/react-native-track-player 4.1.23 → 4.1.25

package/android/src/main/java/com/lovegaoshi/kotlinaudio/processors/EqualizerAudioProcessor.kt

@@ -0,0 +1,517 @@
+package com.lovegaoshi.kotlinaudio.processors
+
+import androidx.media3.common.C
+import androidx.media3.common.audio.AudioProcessor
+import androidx.media3.common.audio.BaseAudioProcessor
+import androidx.media3.common.util.UnstableApi
+import java.nio.ByteBuffer
+import kotlin.math.*
+
+/**
+ * Software audio effects processor matching iOS EqualizerAudioTap.
+ * All processing in Float64 for maximum precision.
+ *
+ * Features:
+ *  - 8-band parametric EQ (peaking biquad filters)
+ *  - Bass boost (low shelf biquad)
+ *  - Loudness enhancer (low shelf + high shelf biquad)
+ *  - Stereo virtualizer (mid-side + cross-channel all-pass)
+ *  - Per-block coefficient smoothing (click-free parameter changes)
+ *  - DC blocking filter (removes sub-sonic drift)
+ *  - Envelope-following true-peak limiter
+ *  - Denormal flush (prevents FPU slowdown on ARM)
+ */
+@UnstableApi
+class EqualizerAudioProcessor : BaseAudioProcessor() {
+
+    companion object {
+        // ── EQ ──
+        const val BAND_COUNT = 8
+        val FREQUENCIES = floatArrayOf(60f, 150f, 400f, 1000f, 2500f, 6000f, 12000f, 16000f)
+        private const val EQ_Q = 1.4
+
+        // ── Bass Boost (low shelf) ──
+        private const val BB_FREQ = 150.0
+        private const val BB_MIN_DB = 6.0    // slider 0 = gentle warmth
+        private const val BB_MAX_DB = 24.0   // slider 1 = full boost
+        private const val BB_Q = 0.8
+
+        // ── Loudness Enhancer (low shelf + high shelf) ──
+        private const val LN_LO_FREQ = 200.0
+        private const val LN_LO_MAX_DB = 15.0
+        private const val LN_HI_FREQ = 3000.0
+        private const val LN_HI_MAX_DB = 10.0
+        private const val LN_Q = 0.7
+
+        // ── Virtualizer (cross-channel all-pass) ──
+        private val AP_FREQS_L = doubleArrayOf(250.0, 630.0, 1500.0, 3200.0, 7500.0)
+        private val AP_FREQS_R = doubleArrayOf(160.0, 420.0, 1000.0, 2200.0, 5000.0, 9500.0)
+
+        // ── Processing constants ──
+        private const val SMOOTH_ALPHA = 0.008
+        private const val DC_R = 0.9995         // ~3.5 Hz cutoff at 44.1 kHz
+        private const val LIM_THRESHOLD = 0.89  // ~ -1 dBFS
+        private const val DENORM_THRESH = 1e-15
+
+        private val UNITY = doubleArrayOf(1.0, 0.0, 0.0, 0.0, 0.0)
+
+        // ═══════════ Filter Design (Audio EQ Cookbook) ═══════════
+
+        fun peakingEQ(freq: Double, gainDB: Double, q: Double, sr: Double): DoubleArray {
+            if (abs(gainDB) < 0.01) return UNITY.copyOf()
+            val A = 10.0.pow(gainDB / 40.0)
+            val w0 = 2.0 * PI * freq / sr
+            val sw = sin(w0); val cw = cos(w0)
+            val al = sw / (2.0 * q)
+            val b0 = 1.0 + al * A; val b1 = -2.0 * cw; val b2 = 1.0 - al * A
+            val a0 = 1.0 + al / A; val a1 = -2.0 * cw; val a2 = 1.0 - al / A
+            return doubleArrayOf(b0/a0, b1/a0, b2/a0, a1/a0, a2/a0)
+        }
+
+        fun lowShelf(freq: Double, gainDB: Double, q: Double, sr: Double): DoubleArray {
+            if (abs(gainDB) < 0.01) return UNITY.copyOf()
+            val A = 10.0.pow(gainDB / 40.0)
+            val w0 = 2.0 * PI * freq / sr
+            val cw = cos(w0); val sw = sin(w0)
+            val al = sw / (2.0 * q)
+            val s2a = 2.0 * sqrt(A) * al
+            val b0 = A * ((A+1) - (A-1)*cw + s2a)
+            val b1 = 2*A * ((A-1) - (A+1)*cw)
+            val b2 = A * ((A+1) - (A-1)*cw - s2a)
+            val a0 = (A+1) + (A-1)*cw + s2a
+            val a1 = -2.0 * ((A-1) + (A+1)*cw)
+            val a2 = (A+1) + (A-1)*cw - s2a
+            return doubleArrayOf(b0/a0, b1/a0, b2/a0, a1/a0, a2/a0)
+        }
+
+        fun highShelf(freq: Double, gainDB: Double, q: Double, sr: Double): DoubleArray {
+            if (abs(gainDB) < 0.01) return UNITY.copyOf()
+            val A = 10.0.pow(gainDB / 40.0)
+            val w0 = 2.0 * PI * freq / sr
+            val cw = cos(w0); val sw = sin(w0)
+            val al = sw / (2.0 * q)
+            val s2a = 2.0 * sqrt(A) * al
+            val b0 = A * ((A+1) + (A-1)*cw + s2a)
+            val b1 = -2*A * ((A-1) + (A+1)*cw)
+            val b2 = A * ((A+1) + (A-1)*cw - s2a)
+            val a0 = (A+1) - (A-1)*cw + s2a
+            val a1 = 2.0 * ((A-1) - (A+1)*cw)
+            val a2 = (A+1) - (A-1)*cw - s2a
+            return doubleArrayOf(b0/a0, b1/a0, b2/a0, a1/a0, a2/a0)
+        }
+    }
+
+    // ═══════════════════ Public state ═══════════════════
+
+    // EQ
+    @Volatile var isEnabled = false
+    private val gains = FloatArray(BAND_COUNT)
+
+    // Bass Boost
+    @Volatile var isBassBoostEnabled = false
+    @Volatile var bassBoostLevel = 0.5f   // 0..1
+
+    // Loudness
+    @Volatile var isLoudnessEnabled = false
+    @Volatile var loudnessLevel = 0.5f    // 0..1
+
+    // Virtualizer
+    @Volatile var isVirtualizerEnabled = false
+    @Volatile var virtualizerLevel = 0.5f // 0..1
+
+    // ═══════════════════ Internal state ═══════════════════
+
+    private var sampleRate = 44100.0
+    private var channelCount = 2
+
+    // EQ coefficients: [band][5]
+    private var eqCur = Array(BAND_COUNT) { UNITY.copyOf() }
+    private var eqTgt = Array(BAND_COUNT) { UNITY.copyOf() }
+    private var eqZ = Array(BAND_COUNT) { Array(2) { doubleArrayOf(0.0, 0.0) } }
+
+    // Bass boost coefficients
+    private var bbCur = UNITY.copyOf()
+    private var bbTgt = UNITY.copyOf()
+    private var bbZ = Array(2) { doubleArrayOf(0.0, 0.0) }
+
+    // Loudness: low shelf + high shelf
+    private var lnLoCur = UNITY.copyOf()
+    private var lnLoTgt = UNITY.copyOf()
+    private var lnHiCur = UNITY.copyOf()
+    private var lnHiTgt = UNITY.copyOf()
+    private var lnLoZ = Array(2) { doubleArrayOf(0.0, 0.0) }
+    private var lnHiZ = Array(2) { doubleArrayOf(0.0, 0.0) }
+
+    // Virtualizer: first-order all-pass coefficients and states
+    private var apCoeffsL = DoubleArray(0)
+    private var apCoeffsR = DoubleArray(0)
+    private var apStateL = Array(0) { doubleArrayOf(0.0, 0.0) }
+    private var apStateR = Array(0) { doubleArrayOf(0.0, 0.0) }
+
+    // DC blocker
+    private var dcXprev = DoubleArray(2)
+    private var dcYprev = DoubleArray(2)
+
+    // Limiter
+    private var limGain = 1.0
+    private var limAttCoeff = 0.0
+    private var limRelCoeff = 0.0
+
+    // ═══════════════════ EQ API ═══════════════════
+
+    fun setGain(band: Int, gainDB: Float) {
+        if (band !in 0 until BAND_COUNT) return
+        gains[band] = gainDB.coerceIn(-12f, 12f)
+        eqTgt[band] = peakingEQ(FREQUENCIES[band].toDouble(), gains[band].toDouble(), EQ_Q, sampleRate)
+    }
+
+    fun setAllGains(gainsDB: List<Float>) {
+        for (i in 0 until minOf(gainsDB.size, BAND_COUNT)) {
+            gains[i] = gainsDB[i].coerceIn(-12f, 12f)
+            eqTgt[i] = peakingEQ(FREQUENCIES[i].toDouble(), gains[i].toDouble(), EQ_Q, sampleRate)
+        }
+    }
+
+    fun getAllGains(): FloatArray = gains.copyOf()
+
+    fun resetGains() {
+        for (i in 0 until BAND_COUNT) {
+            gains[i] = 0f
+            eqTgt[i] = UNITY.copyOf()
+        }
+    }
+
+    // ═══════════════════ Bass Boost API ═══════════════════
+
+    fun updateBassBoostLevel(level: Float) {
+        bassBoostLevel = level.coerceIn(0f, 1f)
+        val g = BB_MIN_DB + (BB_MAX_DB - BB_MIN_DB) * bassBoostLevel.toDouble()
+        bbTgt = lowShelf(BB_FREQ, g, BB_Q, sampleRate)
+    }
+
+    // ═══════════════════ Loudness API ═══════════════════
+
+    fun updateLoudnessLevel(level: Float) {
+        loudnessLevel = level.coerceIn(0f, 1f)
+        val lo = LN_LO_MAX_DB * loudnessLevel.toDouble()
+        val hi = LN_HI_MAX_DB * loudnessLevel.toDouble()
+        lnLoTgt = lowShelf(LN_LO_FREQ, lo, LN_Q, sampleRate)
+        lnHiTgt = highShelf(LN_HI_FREQ, hi, LN_Q, sampleRate)
+    }
+
+    // ═══════════════════ Virtualizer API ═══════════════════
+
+    fun updateVirtualizerLevel(level: Float) {
+        virtualizerLevel = level.coerceIn(0f, 1f)
+    }
+
+    // ═══════════════════ Pipeline ═══════════════════
+
+    override fun onConfigure(inputAudioFormat: AudioProcessor.AudioFormat): AudioProcessor.AudioFormat {
+        if (inputAudioFormat.encoding == C.ENCODING_PCM_16BIT ||
+            inputAudioFormat.encoding == C.ENCODING_PCM_FLOAT
+        ) {
+            sampleRate = inputAudioFormat.sampleRate.toDouble()
+            channelCount = inputAudioFormat.channelCount
+            val nCh = channelCount
+
+            // EQ
+            for (i in 0 until BAND_COUNT) {
+                eqTgt[i] = peakingEQ(FREQUENCIES[i].toDouble(), gains[i].toDouble(), EQ_Q, sampleRate)
+                eqCur[i] = eqTgt[i].copyOf()
+            }
+            eqZ = Array(BAND_COUNT) { Array(nCh) { doubleArrayOf(0.0, 0.0) } }
+
+            // Bass boost
+            if (isBassBoostEnabled) {
+                val g = BB_MIN_DB + (BB_MAX_DB - BB_MIN_DB) * bassBoostLevel.toDouble()
+                bbTgt = lowShelf(BB_FREQ, g, BB_Q, sampleRate)
+            }
+            bbCur = bbTgt.copyOf()
+            bbZ = Array(nCh) { doubleArrayOf(0.0, 0.0) }
+
+            // Loudness
+            if (isLoudnessEnabled) {
+                lnLoTgt = lowShelf(LN_LO_FREQ, LN_LO_MAX_DB * loudnessLevel.toDouble(), LN_Q, sampleRate)
+                lnHiTgt = highShelf(LN_HI_FREQ, LN_HI_MAX_DB * loudnessLevel.toDouble(), LN_Q, sampleRate)
+            }
+            lnLoCur = lnLoTgt.copyOf(); lnHiCur = lnHiTgt.copyOf()
+            lnLoZ = Array(nCh) { doubleArrayOf(0.0, 0.0) }
+            lnHiZ = Array(nCh) { doubleArrayOf(0.0, 0.0) }
+
+            // Virtualizer all-pass coefficients
+            apCoeffsL = DoubleArray(AP_FREQS_L.size) { i ->
+                val omega = tan(PI * AP_FREQS_L[i] / sampleRate)
+                (1.0 - omega) / (1.0 + omega)
+            }
+            apCoeffsR = DoubleArray(AP_FREQS_R.size) { i ->
+                val omega = tan(PI * AP_FREQS_R[i] / sampleRate)
+                (1.0 - omega) / (1.0 + omega)
+            }
+            apStateL = Array(AP_FREQS_L.size) { doubleArrayOf(0.0, 0.0) }
+            apStateR = Array(AP_FREQS_R.size) { doubleArrayOf(0.0, 0.0) }
+
+            // DC blocker
+            dcXprev = DoubleArray(nCh)
+            dcYprev = DoubleArray(nCh)
+
+            // Limiter
+            limGain = 1.0
+            limAttCoeff = 1.0 - exp(-1.0 / (0.0005 * sampleRate))
+            limRelCoeff = 1.0 - exp(-1.0 / (0.050 * sampleRate))
+
+            return inputAudioFormat
+        }
+        return AudioProcessor.AudioFormat.NOT_SET
+    }
+
+    override fun queueInput(inputBuffer: ByteBuffer) {
+        val nCh = channelCount
+        val size = inputBuffer.remaining()
+        val output = replaceOutputBuffer(size)
+
+        val anyActive = isEnabled || isBassBoostEnabled || isLoudnessEnabled || isVirtualizerEnabled
+
+        if (!anyActive) {
+            // Pass-through
+            when (inputAudioFormat.encoding) {
+                C.ENCODING_PCM_16BIT -> while (inputBuffer.hasRemaining()) output.putShort(inputBuffer.short)
+                C.ENCODING_PCM_FLOAT -> while (inputBuffer.hasRemaining()) output.putFloat(inputBuffer.float)
+            }
+            output.flip()
+            return
+        }
+
+        // Smooth all coefficients toward targets
+        if (isEnabled) smoothCoeffs2D(eqCur, eqTgt)
+        if (isBassBoostEnabled) smoothCoeffs(bbCur, bbTgt)
+        if (isLoudnessEnabled) {
+            smoothCoeffs(lnLoCur, lnLoTgt)
+            smoothCoeffs(lnHiCur, lnHiTgt)
+        }
+
+        when (inputAudioFormat.encoding) {
+            C.ENCODING_PCM_16BIT -> processInt16(inputBuffer, output, nCh, size)
+            C.ENCODING_PCM_FLOAT -> processFloat32(inputBuffer, output, nCh, size)
+        }
+        output.flip()
+    }
+
+    // ═══════════════ Processing: Float32 path ═══════════════
+
+    private fun processFloat32(input: ByteBuffer, output: ByteBuffer, nCh: Int, size: Int) {
+        val frameCount = size / (4 * nCh)
+
+        // Read all samples into a working buffer [channel][frame]
+        val buf = Array(nCh) { DoubleArray(frameCount) }
+        for (frame in 0 until frameCount) {
+            for (ch in 0 until nCh) {
+                buf[ch][frame] = input.float.toDouble()
+            }
+        }
+
+        // 1. EQ bands
+        if (isEnabled) {
+            for (ch in 0 until nCh) {
+                val chIdx = ch.coerceAtMost(eqZ[0].size - 1)
+                for (band in 0 until BAND_COUNT) {
+                    biquadBlock(buf[ch], frameCount, eqCur[band], eqZ[band][chIdx])
+                }
+            }
+        }
+
+        // 2. Bass boost
+        if (isBassBoostEnabled) {
+            for (ch in 0 until nCh) {
+                val chIdx = ch.coerceAtMost(bbZ.size - 1)
+                biquadBlock(buf[ch], frameCount, bbCur, bbZ[chIdx])
+            }
+        }
+
+        // 3. Loudness (low shelf + high shelf)
+        if (isLoudnessEnabled) {
+            for (ch in 0 until nCh) {
+                val chIdx = ch.coerceAtMost(lnLoZ.size - 1)
+                biquadBlock(buf[ch], frameCount, lnLoCur, lnLoZ[chIdx])
+                biquadBlock(buf[ch], frameCount, lnHiCur, lnHiZ[chIdx])
+            }
+        }
+
+        // 4. Virtualizer (stereo only)
+        if (isVirtualizerEnabled && nCh >= 2) {
+            applyVirtualizer(buf[0], buf[1], frameCount)
+        }
+
+        // 5. DC blocker
+        for (ch in 0 until nCh) {
+            val chIdx = ch.coerceAtMost(dcXprev.size - 1)
+            applyDCBlock(buf[ch], frameCount, chIdx)
+        }
+
+        // 6. True-peak limiter + write output
+        for (frame in 0 until frameCount) {
+            var peak = 0.0
+            for (ch in 0 until nCh) peak = max(peak, abs(buf[ch][frame]))
+            val tgt = if (peak > LIM_THRESHOLD) LIM_THRESHOLD / peak else 1.0
+            limGain += (tgt - limGain) * if (tgt < limGain) limAttCoeff else limRelCoeff
+            val g = limGain
+            for (ch in 0 until nCh) {
+                output.putFloat((buf[ch][frame] * g).toFloat())
+            }
+        }
+    }
+
+    // ═══════════════ Processing: Int16 path ═══════════════
+
+    private fun processInt16(input: ByteBuffer, output: ByteBuffer, nCh: Int, size: Int) {
+        val frameCount = size / (2 * nCh)
+
+        val buf = Array(nCh) { DoubleArray(frameCount) }
+        for (frame in 0 until frameCount) {
+            for (ch in 0 until nCh) {
+                buf[ch][frame] = input.short.toDouble() / 32768.0
+            }
+        }
+
+        // 1. EQ bands
+        if (isEnabled) {
+            for (ch in 0 until nCh) {
+                val chIdx = ch.coerceAtMost(eqZ[0].size - 1)
+                for (band in 0 until BAND_COUNT) {
+                    biquadBlock(buf[ch], frameCount, eqCur[band], eqZ[band][chIdx])
+                }
+            }
+        }
+
+        // 2. Bass boost
+        if (isBassBoostEnabled) {
+            for (ch in 0 until nCh) {
+                val chIdx = ch.coerceAtMost(bbZ.size - 1)
+                biquadBlock(buf[ch], frameCount, bbCur, bbZ[chIdx])
+            }
+        }
+
+        // 3. Loudness
+        if (isLoudnessEnabled) {
+            for (ch in 0 until nCh) {
+                val chIdx = ch.coerceAtMost(lnLoZ.size - 1)
+                biquadBlock(buf[ch], frameCount, lnLoCur, lnLoZ[chIdx])
+                biquadBlock(buf[ch], frameCount, lnHiCur, lnHiZ[chIdx])
+            }
+        }
+
+        // 4. Virtualizer (stereo only)
+        if (isVirtualizerEnabled && nCh >= 2) {
+            applyVirtualizer(buf[0], buf[1], frameCount)
+        }
+
+        // 5. DC blocker
+        for (ch in 0 until nCh) {
+            val chIdx = ch.coerceAtMost(dcXprev.size - 1)
+            applyDCBlock(buf[ch], frameCount, chIdx)
+        }
+
+        // 6. True-peak limiter + write output
+        for (frame in 0 until frameCount) {
+            var peak = 0.0
+            for (ch in 0 until nCh) peak = max(peak, abs(buf[ch][frame]))
+            val tgt = if (peak > LIM_THRESHOLD) LIM_THRESHOLD / peak else 1.0
+            limGain += (tgt - limGain) * if (tgt < limGain) limAttCoeff else limRelCoeff
+            val g = limGain
+            for (ch in 0 until nCh) {
+                output.putShort((buf[ch][frame] * g * 32768.0).coerceIn(-32768.0, 32767.0).toInt().toShort())
+            }
+        }
+    }
+
+    // ═══════════════ Virtualizer ═══════════════
+
+    private fun applyVirtualizer(L: DoubleArray, R: DoubleArray, count: Int) {
+        val lvl = virtualizerLevel.toDouble()
+        val width = 1.0 + lvl * 1.5    // 1.0 (normal) to 2.5 (wide)
+        val apMix = 0.5 + lvl * 0.5    // 0.5 (moderate) to 1.0 (full phase shift)
+
+        for (i in 0 until count) {
+            val l = L[i]; val r = R[i]
+
+            // Mid-side decomposition + widening
+            val mid  = (l + r) * 0.5
+            val side = (l - r) * 0.5
+            val wL = mid + side * width
+            val wR = mid - side * width
+
+            // Cascade all-pass on LEFT channel
+            var sigL = wL
+            for (s in apCoeffsL.indices) {
+                val a = apCoeffsL[s]
+                val y = a * sigL + apStateL[s][0] - a * apStateL[s][1]
+                apStateL[s][0] = sigL
+                apStateL[s][1] = y
+                sigL = y
+            }
+
+            // Cascade all-pass on RIGHT channel
+            var sigR = wR
+            for (s in apCoeffsR.indices) {
+                val a = apCoeffsR[s]
+                val y = a * sigR + apStateR[s][0] - a * apStateR[s][1]
+                apStateR[s][0] = sigR
+                apStateR[s][1] = y
+                sigR = y
+            }
+
+            // Cross-channel decorrelation
+            L[i] = wL * (1.0 - apMix) + sigL * apMix
+            R[i] = wR * (1.0 - apMix) + sigR * apMix
+        }
+    }
+
+    // ═══════════════ DC Blocker ═══════════════
+
+    private fun applyDCBlock(samples: DoubleArray, count: Int, ch: Int) {
+        var xp = dcXprev[ch]; var yp = dcYprev[ch]
+        for (i in 0 until count) {
+            val x = samples[i]
+            val y = x - xp + DC_R * yp
+            xp = x; yp = y
+            samples[i] = y
+        }
+        dcXprev[ch] = xp; dcYprev[ch] = yp
+    }
+
+    // ═══════════════ Biquad processing ═══════════════
+
+    /** Process a block of Float64 samples through a biquad filter (Direct Form II Transposed) */
+    private fun biquadBlock(samples: DoubleArray, count: Int, c: DoubleArray, z: DoubleArray) {
+        val b0 = c[0]; val b1 = c[1]; val b2 = c[2]; val a1 = c[3]; val a2 = c[4]
+        var z1 = z[0]; var z2 = z[1]
+        for (i in 0 until count) {
+            val x = samples[i]
+            val y = b0 * x + z1
+            z1 = b1 * x - a1 * y + z2
+            z2 = b2 * x - a2 * y
+            samples[i] = y
+        }
+        // Flush denormals
+        if (abs(z1) < DENORM_THRESH) z1 = 0.0
+        if (abs(z2) < DENORM_THRESH) z2 = 0.0
+        z[0] = z1; z[1] = z2
+    }
+
+    // ═══════════════ Coefficient smoothing ═══════════════
+
+    private fun smoothCoeffs(cur: DoubleArray, tgt: DoubleArray) {
+        for (k in cur.indices) {
+            cur[k] += SMOOTH_ALPHA * (tgt[k] - cur[k])
+        }
+    }
+
+    private fun smoothCoeffs2D(cur: Array<DoubleArray>, tgt: Array<DoubleArray>) {
+        for (i in cur.indices) {
+            val c = cur[i]; val t = tgt[i]
+            for (k in c.indices) {
+                c[k] += SMOOTH_ALPHA * (t[k] - c[k])
+            }
+        }
+    }
+}

package/ios/RNTrackPlayer/RNTrackPlayer.swift

@@ -140,8 +140,11 @@ public class RNTrackPlayer: NSObject, AudioSessionControllerDelegate {
         if let fftLength = config["useFFTProcessor"] as? Int {
             player.audioTap = WaveformAudioTap(mFFTLength: fftLength, mEmit: {data in
                 self.emit(event:EventType.FFTUpdated, body:data)})
+        } else {
+            // Always attach equalizer tap — transparent pass-through when no effects are active.
+            // This avoids audio glitches from re-attaching the tap when effects are toggled.
+            player.audioTap = equalizerTap
         }
-        // Note: Equalizer tap is NOT attached by default. Call setEqualizerEnabled(true) to enable.
 
         // configure buffer size
         if let bufferDuration = config["minBuffer"] as? TimeInterval {
@@ -822,7 +825,6 @@ public class RNTrackPlayer: NSObject, AudioSessionControllerDelegate {
         lastIndex: Int?,
         lastPosition: Double?
     ) {
-
         if let item = item {
             DispatchQueue.main.async {
                 UIApplication.shared.beginReceivingRemoteControlEvents();
@@ -946,9 +948,8 @@ public class RNTrackPlayer: NSObject, AudioSessionControllerDelegate {
     public func setEqualizerEnabled(enabled: Bool, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
         if (rejectWhenNotInitialized(reject: reject)) { return }
 
-        // Toggle the enabled flag
-        // Note: For the equalizer to work, the tap must be attached to the player first
         equalizerTap.isEnabled = enabled
+
         resolve(NSNull())
     }
 
@@ -1015,6 +1016,57 @@ public class RNTrackPlayer: NSObject, AudioSessionControllerDelegate {
         equalizerTap.resetGains()
         resolve(NSNull())
     }
+
+    // MARK: - Audio Effects
+
+    @objc(setBassBoostEnabled:resolver:rejecter:)
+    public func setBassBoostEnabled(enabled: Bool, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+        equalizerTap.isBassBoostEnabled = enabled
+        resolve(NSNull())
+    }
+
+    @objc(setLoudnessEnabled:resolver:rejecter:)
+    public func setLoudnessEnabled(enabled: Bool, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+        equalizerTap.isLoudnessEnabled = enabled
+        resolve(NSNull())
+    }
+
+    @objc(setVirtualizerEnabled:resolver:rejecter:)
+    public func setVirtualizerEnabled(enabled: Bool, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+        equalizerTap.isVirtualizerEnabled = enabled
+        resolve(NSNull())
+    }
+
+    @objc(setBassBoostLevel:resolver:rejecter:)
+    public func setBassBoostLevel(level: Float, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+        equalizerTap.updateBassBoostLevel(level)
+        resolve(NSNull())
+    }
+
+    @objc(setLoudnessLevel:resolver:rejecter:)
+    public func setLoudnessLevel(level: Float, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+        equalizerTap.updateLoudnessLevel(level)
+        resolve(NSNull())
+    }
+
+    @objc(setVirtualizerLevel:resolver:rejecter:)
+    public func setVirtualizerLevel(level: Float, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+        equalizerTap.updateVirtualizerLevel(level)
+        resolve(NSNull())
+    }
+
+    @objc(setBalance:resolver:rejecter:)
+    public func setBalance(balance: Float, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+        equalizerTap.balance = max(-1, min(1, balance))
+        resolve(NSNull())
+    }
 }
 
 extension RNTrackPlayer {

package/ios/RNTrackPlayer/TrackPlayer.mm

@@ -284,4 +284,34 @@ RCT_EXPORT_MODULE()
     [trackPlayer resetEqualizer:resolve rejecter:reject];
 }
 
+// Audio Effects
+
+- (void)setBassBoostEnabled:(BOOL)enabled resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+    [trackPlayer setBassBoostEnabled:enabled resolver:resolve rejecter:reject];
+}
+
+- (void)setLoudnessEnabled:(BOOL)enabled resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+    [trackPlayer setLoudnessEnabled:enabled resolver:resolve rejecter:reject];
+}
+
+- (void)setVirtualizerEnabled:(BOOL)enabled resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+    [trackPlayer setVirtualizerEnabled:enabled resolver:resolve rejecter:reject];
+}
+
+- (void)setBassBoostLevel:(double)level resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+    [trackPlayer setBassBoostLevel:(float)level resolver:resolve rejecter:reject];
+}
+
+- (void)setLoudnessLevel:(double)level resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+    [trackPlayer setLoudnessLevel:(float)level resolver:resolve rejecter:reject];
+}
+
+- (void)setVirtualizerLevel:(double)level resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+    [trackPlayer setVirtualizerLevel:(float)level resolver:resolve rejecter:reject];
+}
+
+- (void)setBalance:(double)balance resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+    [trackPlayer setBalance:(float)balance resolver:resolve rejecter:reject];
+}
+
 @end