@javascriptcommon/react-native-track-player 4.1.24 → 4.1.26

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

@@ -2,10 +2,8 @@
 
 import android.content.Context
 import android.media.AudioManager
-import android.media.audiofx.BassBoost
 import android.media.audiofx.Equalizer
 import android.media.audiofx.LoudnessEnhancer
-import android.media.audiofx.Virtualizer
 import androidx.annotation.CallSuper
 import androidx.annotation.OptIn
 import androidx.media3.common.AudioAttributes
@@ -41,6 +39,7 @@ import com.lovegaoshi.kotlinaudio.player.components.FocusManager
 import com.lovegaoshi.kotlinaudio.player.components.MediaFactory
 import com.lovegaoshi.kotlinaudio.player.components.setupBuffer
 import com.lovegaoshi.kotlinaudio.processors.BalanceAudioProcessor
+import com.lovegaoshi.kotlinaudio.processors.EqualizerAudioProcessor
 import com.lovegaoshi.kotlinaudio.processors.FFTEmitter
 import kotlinx.coroutines.Deferred
 import kotlinx.coroutines.MainScope
@@ -62,8 +61,6 @@ abstract class AudioPlayer internal constructor(
     private var exoPlayer2: ExoPlayer? = null
     private var loudnessEnhancers = ArrayList<LoudnessEnhancer>()
     private var equalizers = ArrayList<Equalizer>()
-    private var bassBoosts = ArrayList<BassBoost>()
-    private var virtualizers = ArrayList<Virtualizer>()
     private var currentExoPlayer = true
 
     var exoPlayer: ExoPlayer
@@ -76,6 +73,7 @@ abstract class AudioPlayer internal constructor(
     private val focusManager = FocusManager(context, listener=focusListener, options=options)
     var fftEmitter: (DoubleArray) -> Unit = { v -> Timber.tag("APMFFT").d("FFT emitted $v") }
     private val balanceProcessor = BalanceAudioProcessor()
+    private val equalizerProcessor = EqualizerAudioProcessor()
 
     var alwaysPauseOnInterruption: Boolean
         get() = focusManager.alwaysPauseOnInterruption
@@ -215,8 +213,8 @@ abstract class AudioPlayer internal constructor(
                     }
                 }
 
-        }, arrayOf(balanceProcessor)) else APMRenderersFactory(
-            context, 0, null, arrayOf(balanceProcessor)
+        }, arrayOf(equalizerProcessor, balanceProcessor)) else APMRenderersFactory(
+            context, 0, null, arrayOf(equalizerProcessor, balanceProcessor)
         )
         renderer.setExtensionRendererMode(DefaultRenderersFactory.EXTENSION_RENDERER_MODE_PREFER)
         val mPlayer = ExoPlayer
@@ -303,161 +301,66 @@ abstract class AudioPlayer internal constructor(
             .map { i -> equalizers[0].getPresetName(i.toShort()) }
     }
 
-    // 10-band Equalizer API (cross-platform compatible)
+    // 8-band Software Equalizer API (cross-platform, biquad with coefficient smoothing)
 
-    /**
-     * Enable or disable the equalizer
-     */
     fun setEqualizerEnabled(enabled: Boolean) {
-        equalizers.forEach { equalizer ->
-            equalizer.enabled = enabled
-        }
+        equalizerProcessor.isEnabled = enabled
     }
 
-    /**
-     * Check if the equalizer is enabled
-     */
-    fun getEqualizerEnabled(): Boolean {
-        if (equalizers.isEmpty()) return false
-        return equalizers[0].enabled
-    }
+    fun getEqualizerEnabled(): Boolean = equalizerProcessor.isEnabled
 
-    /**
-     * Get the number of equalizer bands available
-     */
-    fun getEqualizerBandCount(): Int {
-        if (equalizers.isEmpty()) return 0
-        return equalizers[0].numberOfBands.toInt()
-    }
+    fun getEqualizerBandCount(): Int = EqualizerAudioProcessor.BAND_COUNT
 
-    /**
-     * 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
-            }
-        }
+        equalizerProcessor.setGain(band, gainDB)
     }
 
-    /**
-     * 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
-        }
+        equalizerProcessor.setAllGains(gainsDB)
     }
 
-    /**
-     * 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
-        }
+        return equalizerProcessor.getAllGains().toList()
     }
 
-    /**
-     * 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)
-        }
+        return EqualizerAudioProcessor.FREQUENCIES.map { it.toInt() }
     }
 
-    /**
-     * 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)
-    }
+    fun getEqualizerBandLevelRange(): List<Float> = listOf(-12f, 12f)
 
-    /**
-     * 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)
-            }
-        }
+        equalizerProcessor.resetGains()
     }
 
-    // Bass Boost API
+    // Bass Boost API (software DSP — matches iOS low shelf filter)
 
     fun setBassBoostEnabled(enabled: Boolean) {
-        bassBoosts.forEach { it.enabled = enabled }
+        equalizerProcessor.isBassBoostEnabled = enabled
     }
 
     fun setBassBoostLevel(level: Float) {
-        // level 0.0-1.0 → strength 250-1000 (always boosts, never zero)
-        val strength = (250 + level * 750).toInt().coerceIn(250, 1000).toShort()
-        bassBoosts.forEach {
-            it.setStrength(strength)
-            it.enabled = true
-        }
+        equalizerProcessor.updateBassBoostLevel(level)
     }
 
-    // Loudness Enhancer API (enable/disable + level)
+    // Loudness Enhancer API (software DSP — matches iOS low+high shelf)
 
     fun setLoudnessEnabled(enabled: Boolean) {
-        loudnessEnhancers.forEach { it.enabled = enabled }
+        equalizerProcessor.isLoudnessEnabled = enabled
     }
 
     fun setLoudnessLevel(level: Float) {
-        // level 0.0-1.0 → target gain 100-1500 mB (1-15 dB, always enhances)
-        val gainMb = (100 + level * 1400).toInt().coerceIn(100, 1500)
-        loudnessEnhancers.forEach {
-            it.setTargetGain(gainMb)
-            it.enabled = true
-        }
+        equalizerProcessor.updateLoudnessLevel(level)
     }
 
-    // Virtualizer API
+    // Virtualizer API (software DSP — matches iOS all-pass stereo widener)
 
     fun setVirtualizerEnabled(enabled: Boolean) {
-        virtualizers.forEach { it.enabled = enabled }
+        equalizerProcessor.isVirtualizerEnabled = enabled
     }
 
     fun setVirtualizerLevel(level: Float) {
-        // level 0.0-1.0 → strength 200-1000 (always adds spatial width)
-        val strength = (200 + level * 800).toInt().coerceIn(200, 1000).toShort()
-        virtualizers.forEach {
-            it.setStrength(strength)
-            it.enabled = true
-        }
+        equalizerProcessor.updateVirtualizerLevel(level)
     }
 
     // Balance API
@@ -484,8 +387,8 @@ abstract class AudioPlayer internal constructor(
     }
 
     /**
-     * Apply a preset by index (matches iOS preset order)
-     * 8 bands: 60, 150, 400, 1K, 2.5K, 6K, 12K, 16K
+     * Apply a preset by index (matches iOS preset order).
+     * 8 bands: 60, 150, 400, 1K, 2.5K, 6K, 12K, 16K — same as software EQ.
      */
     fun applyEqualizerPreset(presetIndex: Int) {
         val presets = listOf(
@@ -512,9 +415,8 @@ abstract class AudioPlayer internal constructor(
             listOf( 0f,  0f,  0f,  0f, -1f, -3f, -5f, -6f),  // Treble Reducer
             listOf(-2f, -1f,  1f,  3f,  4f,  3f,  1f,  0f)   // Vocal Booster
         )
-        if (presetIndex >= 0 && presetIndex < presets.size) {
-            setEqualizerBands(presets[presetIndex])
-        }
+        if (presetIndex < 0 || presetIndex >= presets.size) return
+        setEqualizerBands(presets[presetIndex])
     }
 
     fun togglePlaying() {
@@ -586,8 +488,6 @@ abstract class AudioPlayer internal constructor(
         }
         equalizers.forEach { e -> e.release() }
         loudnessEnhancers.forEach { e -> e.release() }
-        bassBoosts.forEach { e -> e.release() }
-        virtualizers.forEach { e -> e.release() }
         cache?.release()
         cache = null
     }
@@ -681,7 +581,13 @@ abstract class AudioPlayer internal constructor(
     inner class AudioFxInitListener: AnalyticsListener {
         @OptIn(UnstableApi::class)
         override fun onAudioSessionIdChanged(eventTime: AnalyticsListener.EventTime, audioSessionId: Int) {
-            // Try to add LoudnessEnhancer
+            // Release old native effects before creating new ones
+            loudnessEnhancers.forEach { try { it.release() } catch (_: Exception) {} }
+            loudnessEnhancers.clear()
+            equalizers.forEach { try { it.release() } catch (_: Exception) {} }
+            equalizers.clear()
+
+            // Native LoudnessEnhancer (only for setLoudnessEnhance legacy API)
             try {
                 val enhancer = LoudnessEnhancer(audioSessionId)
                 loudnessEnhancers.add(enhancer)
@@ -689,7 +595,7 @@ abstract class AudioPlayer internal constructor(
                 Timber.tag("APMAudioFx").e("[AudioFx] failed to load loudnessEnhancer. it's fine if in dev!")
             }
 
-            // Try to add Equalizer
+            // Native Equalizer (only for setEqualizerPreset legacy API)
             try {
                 val equalizer = Equalizer(0, audioSessionId)
                 equalizers.add(equalizer)
@@ -697,21 +603,8 @@ abstract class AudioPlayer internal constructor(
                 Timber.tag("APMAudioFx").e("[AudioFx] failed to load equalizer. it's fine if in dev!")
             }
 
-            // Try to add BassBoost
-            try {
-                val bassBoost = BassBoost(0, audioSessionId)
-                bassBoosts.add(bassBoost)
-            } catch (e: RuntimeException) {
-                Timber.tag("APMAudioFx").e("[AudioFx] failed to load bassBoost. it's fine if in dev!")
-            }
-
-            // Try to add Virtualizer
-            try {
-                val virtualizer = Virtualizer(0, audioSessionId)
-                virtualizers.add(virtualizer)
-            } catch (e: RuntimeException) {
-                Timber.tag("APMAudioFx").e("[AudioFx] failed to load virtualizer. it's fine if in dev!")
-            }
+            // Bass boost, loudness, virtualizer, EQ bands — all handled by
+            // software EqualizerAudioProcessor (no native effects needed)
         }
     }
 

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

@@ -17,18 +17,20 @@ class APMRenderersFactory(
     emitter: FFTEmitter?,
     private val extraProcessors: Array<AudioProcessor> = emptyArray()
 ) : DefaultRenderersFactory(context) {
-    val teeProcessor = TeeAudioProcessor(TeeListener(sampleRate, emitter))
-
+    val teeProcessor = if (sampleRate > 0 && emitter != null)
+        TeeAudioProcessor(TeeListener(sampleRate, emitter)) else null
 
     override fun buildAudioSink(
         context: Context,
         enableFloatOutput: Boolean,
         enableAudioTrackPlaybackParams: Boolean
     ): AudioSink? {
+        val processors = if (teeProcessor != null)
+            arrayOf(*extraProcessors, teeProcessor) else arrayOf(*extraProcessors)
         return DefaultAudioSink.Builder(context)
             .setEnableFloatOutput(enableFloatOutput)
             .setEnableAudioTrackPlaybackParams(enableAudioTrackPlaybackParams)
-            .setAudioProcessors(arrayOf(*extraProcessors, teeProcessor))
+            .setAudioProcessors(processors)
             .build()
     }
 

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

@@ -29,7 +29,11 @@ class BalanceAudioProcessor : BaseAudioProcessor() {
     override fun queueInput(inputBuffer: ByteBuffer) {
         val bal = balance
         if (bal == 0f) {
-            replaceOutputBuffer(inputBuffer.remaining()).put(inputBuffer).flip()
+            val output = replaceOutputBuffer(inputBuffer.remaining())
+            if (output !== inputBuffer) {
+                output.put(inputBuffer)
+            }
+            output.flip()
             return
         }
 

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/package.json

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