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

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

@@ -389,6 +389,49 @@ class MusicModule(reactContext: ReactApplicationContext) : NativeTrackPlayerSpec
         callback.resolve(null)
     }
 
+    // Audio Effects (BassBoost, Loudness, Virtualizer)
+
+    override fun setBassBoostEnabled(enabled: Boolean, callback: Promise) = launchInScope {
+        if (verifyServiceBoundOrReject(callback)) return@launchInScope
+        musicService.setBassBoostEnabled(enabled)
+        callback.resolve(null)
+    }
+
+    override fun setBassBoostLevel(level: Double, callback: Promise) = launchInScope {
+        if (verifyServiceBoundOrReject(callback)) return@launchInScope
+        musicService.setBassBoostLevel(level.toFloat())
+        callback.resolve(null)
+    }
+
+    override fun setLoudnessEnabled(enabled: Boolean, callback: Promise) = launchInScope {
+        if (verifyServiceBoundOrReject(callback)) return@launchInScope
+        musicService.setLoudnessEnabled(enabled)
+        callback.resolve(null)
+    }
+
+    override fun setLoudnessLevel(level: Double, callback: Promise) = launchInScope {
+        if (verifyServiceBoundOrReject(callback)) return@launchInScope
+        musicService.setLoudnessLevel(level.toFloat())
+        callback.resolve(null)
+    }
+
+    override fun setVirtualizerEnabled(enabled: Boolean, callback: Promise) = launchInScope {
+        if (verifyServiceBoundOrReject(callback)) return@launchInScope
+        musicService.setVirtualizerEnabled(enabled)
+        callback.resolve(null)
+    }
+
+    override fun setVirtualizerLevel(level: Double, callback: Promise) = launchInScope {
+        if (verifyServiceBoundOrReject(callback)) return@launchInScope
+        musicService.setVirtualizerLevel(level.toFloat())
+        callback.resolve(null)
+    }
+
+    override fun setBalance(balance: Double, callback: Promise) = launchInScope {
+        if (verifyServiceBoundOrReject(callback)) return@launchInScope
+        musicService.setBalance(balance.toFloat())
+        callback.resolve(null)
+    }
 
     override fun add(data: ReadableArray?, insertBeforeIndex: Double, callback: Promise) = launchInScope {
         if (verifyServiceBoundOrReject(callback)) return@launchInScope

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

@@ -201,6 +201,36 @@ class MusicService : HeadlessJsMediaService() {
         player.resetEqualizer()
     }
 
+    // Audio Effects (BassBoost, Loudness, Virtualizer)
+
+    fun setBassBoostEnabled(enabled: Boolean) {
+        player.setBassBoostEnabled(enabled)
+    }
+
+    fun setBassBoostLevel(level: Float) {
+        player.setBassBoostLevel(level)
+    }
+
+    fun setLoudnessEnabled(enabled: Boolean) {
+        player.setLoudnessEnabled(enabled)
+    }
+
+    fun setLoudnessLevel(level: Float) {
+        player.setLoudnessLevel(level)
+    }
+
+    fun setVirtualizerEnabled(enabled: Boolean) {
+        player.setVirtualizerEnabled(enabled)
+    }
+
+    fun setVirtualizerLevel(level: Float) {
+        player.setVirtualizerLevel(level)
+    }
+
+    fun setBalance(balance: Float) {
+        player.setBalance(balance)
+    }
+
     fun crossFadePrepare(previous: Boolean = false, seekTo: Double = 0.0) {
         player.crossFadePrepare(previous, seekTo)
     }

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

@@ -2,8 +2,10 @@
 
 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
@@ -38,6 +40,7 @@ import com.lovegaoshi.kotlinaudio.player.components.Cache
 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.FFTEmitter
 import kotlinx.coroutines.Deferred
 import kotlinx.coroutines.MainScope
@@ -59,6 +62,8 @@ 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
@@ -70,6 +75,7 @@ abstract class AudioPlayer internal constructor(
     private val focusListener = APMFocusListener()
     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()
 
     var alwaysPauseOnInterruption: Boolean
         get() = focusManager.alwaysPauseOnInterruption
@@ -209,7 +215,9 @@ abstract class AudioPlayer internal constructor(
                     }
                 }
 
-        }) else DefaultRenderersFactory(context)
+        }, arrayOf(balanceProcessor)) else APMRenderersFactory(
+            context, 0, null, arrayOf(balanceProcessor)
+        )
         renderer.setExtensionRendererMode(DefaultRenderersFactory.EXTENSION_RENDERER_MODE_PREFER)
         val mPlayer = ExoPlayer
             .Builder(context)
@@ -407,36 +415,102 @@ abstract class AudioPlayer internal constructor(
         }
     }
 
+    // Bass Boost API
+
+    fun setBassBoostEnabled(enabled: Boolean) {
+        bassBoosts.forEach { it.enabled = 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
+        }
+    }
+
+    // Loudness Enhancer API (enable/disable + level)
+
+    fun setLoudnessEnabled(enabled: Boolean) {
+        loudnessEnhancers.forEach { it.enabled = 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
+        }
+    }
+
+    // Virtualizer API
+
+    fun setVirtualizerEnabled(enabled: Boolean) {
+        virtualizers.forEach { it.enabled = 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
+        }
+    }
+
+    // Balance API
+
+    fun setBalance(balance: Float) {
+        balanceProcessor.setBalance(balance)
+    }
+
+    fun getBalance(): Float = balanceProcessor.getBalance()
+
     /**
      * Get preset names for iOS compatibility (custom presets mapped to Android system presets)
      */
     fun getEqualizerPresetNames(): List<String> {
-        // Return iOS-compatible preset names
+        // Must match iOS EqualizerAudioTap.Preset order
         return listOf(
-            "Flat", "Rock", "Pop", "Jazz", "Classical",
-            "Hip Hop", "Electronic", "Acoustic", "Bass Boost",
-            "Treble Boost", "Vocal", "Loudness"
+            "eqAcoustic", "eqBassBooster", "eqBassReducer", "eqClassical",
+            "eqDance", "eqDeep", "eqElectronic", "eqFlat",
+            "eqHipHop", "eqJazz", "eqLatin", "eqLoudness",
+            "eqLounge", "eqPiano", "eqPop", "eqRnb",
+            "eqRock", "eqSmallSpeakers", "eqSpokenWord",
+            "eqTrebleBooster", "eqTrebleReducer", "eqVocalBooster"
         )
     }
 
     /**
-     * Apply a preset by index (iOS-compatible)
-     * Maps iOS preset index to gain values
+     * Apply a preset by index (matches iOS preset order)
+     * 8 bands: 60, 150, 400, 1K, 2.5K, 6K, 12K, 16K
      */
     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
+            listOf( 3f,  2f,  1f,  0f,  1f,  2f,  2f,  2f),  // Acoustic
+            listOf( 6f,  5f,  3f,  1f,  0f,  0f,  0f,  0f),  // Bass Booster
+            listOf(-6f, -5f, -3f, -1f,  0f,  0f,  0f,  0f),  // Bass Reducer
+            listOf( 4f,  2f,  0f, -1f,  0f,  2f,  3f,  3f),  // Classical
+            listOf( 5f,  4f,  1f,  0f,  2f,  4f,  3f,  2f),  // Dance
+            listOf( 5f,  4f,  2f,  1f,  0f, -1f, -2f, -3f),  // Deep
+            listOf( 4f,  3f,  0f, -1f,  0f,  3f,  4f,  4f),  // Electronic
+            listOf( 0f,  0f,  0f,  0f,  0f,  0f,  0f,  0f),  // Flat
+            listOf( 5f,  4f,  2f,  0f, -1f,  1f,  2f,  3f),  // Hip-Hop
+            listOf( 3f,  2f,  1f,  0f, -1f,  1f,  2f,  2f),  // Jazz
+            listOf( 4f,  3f,  0f, -1f,  0f,  2f,  4f,  3f),  // Latin
+            listOf( 5f,  3f,  0f, -2f,  0f,  2f,  4f,  4f),  // Loudness
+            listOf(-1f,  1f,  2f,  1f,  0f, -1f,  1f,  1f),  // Lounge
+            listOf( 1f,  0f,  1f,  2f,  3f,  2f,  2f,  1f),  // Piano
+            listOf(-1f,  1f,  3f,  3f,  2f,  1f,  1f,  1f),  // Pop
+            listOf( 5f,  4f,  2f,  0f, -1f,  1f,  2f,  2f),  // R&B
+            listOf( 4f,  3f,  0f, -1f,  1f,  3f,  4f,  3f),  // Rock
+            listOf( 5f,  4f,  3f,  1f,  0f, -1f,  2f,  3f),  // Small Speakers
+            listOf(-2f,  0f,  1f,  3f,  4f,  3f,  1f, -1f),  // Spoken Word
+            listOf( 0f,  0f,  0f,  0f,  1f,  3f,  5f,  6f),  // Treble Booster
+            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])
@@ -512,6 +586,8 @@ 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
     }
@@ -620,6 +696,22 @@ abstract class AudioPlayer internal constructor(
             } catch (e: RuntimeException) {
                 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!")
+            }
         }
     }
 

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

@@ -1,6 +1,7 @@
 package com.lovegaoshi.kotlinaudio.player.components
 
 import android.content.Context
+import androidx.media3.common.audio.AudioProcessor
 import androidx.media3.common.util.UnstableApi
 import androidx.media3.exoplayer.DefaultRenderersFactory
 import androidx.media3.exoplayer.audio.AudioSink
@@ -13,7 +14,8 @@ import com.lovegaoshi.kotlinaudio.processors.TeeListener
 class APMRenderersFactory(
     context: Context,
     sampleRate: Int = 4096,
-    emitter: FFTEmitter?
+    emitter: FFTEmitter?,
+    private val extraProcessors: Array<AudioProcessor> = emptyArray()
 ) : DefaultRenderersFactory(context) {
     val teeProcessor = TeeAudioProcessor(TeeListener(sampleRate, emitter))
 
@@ -26,8 +28,8 @@ class APMRenderersFactory(
         return DefaultAudioSink.Builder(context)
             .setEnableFloatOutput(enableFloatOutput)
             .setEnableAudioTrackPlaybackParams(enableAudioTrackPlaybackParams)
-            .setAudioProcessors(arrayOf(teeProcessor))
+            .setAudioProcessors(arrayOf(*extraProcessors, teeProcessor))
             .build()
     }
 
-}
+}

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

@@ -0,0 +1,62 @@
+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
+
+@UnstableApi
+class BalanceAudioProcessor : BaseAudioProcessor() {
+    @Volatile
+    private var balance: Float = 0f
+
+    fun setBalance(value: Float) {
+        balance = value.coerceIn(-1f, 1f)
+    }
+
+    fun getBalance(): Float = balance
+
+    override fun onConfigure(inputAudioFormat: AudioProcessor.AudioFormat): AudioProcessor.AudioFormat {
+        if (inputAudioFormat.channelCount == 2 &&
+            (inputAudioFormat.encoding == C.ENCODING_PCM_16BIT || inputAudioFormat.encoding == C.ENCODING_PCM_FLOAT)
+        ) {
+            return inputAudioFormat
+        }
+        return AudioProcessor.AudioFormat.NOT_SET
+    }
+
+    override fun queueInput(inputBuffer: ByteBuffer) {
+        val bal = balance
+        if (bal == 0f) {
+            replaceOutputBuffer(inputBuffer.remaining()).put(inputBuffer).flip()
+            return
+        }
+
+        val leftGain = if (bal <= 0f) 1f else 1f - bal
+        val rightGain = if (bal >= 0f) 1f else 1f + bal
+
+        val size = inputBuffer.remaining()
+        val output = replaceOutputBuffer(size)
+
+        when (inputAudioFormat.encoding) {
+            C.ENCODING_PCM_16BIT -> {
+                while (inputBuffer.hasRemaining()) {
+                    val left = inputBuffer.short
+                    val right = inputBuffer.short
+                    output.putShort((left * leftGain).toInt().coerceIn(Short.MIN_VALUE.toInt(), Short.MAX_VALUE.toInt()).toShort())
+                    output.putShort((right * rightGain).toInt().coerceIn(Short.MIN_VALUE.toInt(), Short.MAX_VALUE.toInt()).toShort())
+                }
+            }
+            C.ENCODING_PCM_FLOAT -> {
+                while (inputBuffer.hasRemaining()) {
+                    val left = inputBuffer.float
+                    val right = inputBuffer.float
+                    output.putFloat(left * leftGain)
+                    output.putFloat(right * rightGain)
+                }
+            }
+        }
+        output.flip()
+    }
+}

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

package/ios/SwiftAudioEx/Sources/SwiftAudioEx/AudioTap.swift

@@ -41,55 +41,58 @@ open class AudioTap {
 extension AVPlayerWrapper {
     internal func attachTap(_ tap: AudioTap?, to item: AVPlayerItem) {
         guard let tap else { return }
-        guard let track = item.asset.tracks(withMediaType: .audio).first else {
+
+        // Try sync first (works for local/progressive files)
+        if let track = item.asset.tracks(withMediaType: .audio).first {
+            applyTap(tap, to: item, track: track)
             return
         }
-        
+
+        // Async fallback for HLS streams where tracks aren't immediately available
+        Task {
+            guard let tracks = try? await item.asset.loadTracks(withMediaType: .audio),
+                  let track = tracks.first else { return }
+            await MainActor.run {
+                self.applyTap(tap, to: item, track: track)
+            }
+        }
+    }
+
+    private func applyTap(_ tap: AudioTap, to item: AVPlayerItem, track: AVAssetTrack) {
         let audioMix = AVMutableAudioMix()
         let params = AVMutableAudioMixInputParameters(track: track)
-        
-        // we need to retain this pointer so it doesn't disappear out from under us.
-        // we'll then let it go after we finalize.  If the tap changed upstream, we
-        // aren't going to pick up the new one until after this player item goes away.
+
         let client = UnsafeMutableRawPointer(Unmanaged.passRetained(tap).toOpaque())
-        
+
         var callbacks = MTAudioProcessingTapCallbacks(version: kMTAudioProcessingTapCallbacksVersion_0, clientInfo: client)
         { tapRef, clientInfo, tapStorageOut in
-            // initial tap setup
             guard let clientInfo else { return }
             tapStorageOut.pointee = clientInfo
             let audioTap = Unmanaged<AudioTap>.fromOpaque(clientInfo).takeUnretainedValue()
             audioTap.initialize()
         } finalize: { tapRef in
-            // clean up
             let audioTap = Unmanaged<AudioTap>.fromOpaque(MTAudioProcessingTapGetStorage(tapRef)).takeUnretainedValue()
             audioTap.finalize()
-            // we're done, we can let go of the pointer we retained.
             Unmanaged.passUnretained(audioTap).release()
         } prepare: { tapRef, maxFrames, processingFormat in
-            // allocate memory for sound processing
             let audioTap = Unmanaged<AudioTap>.fromOpaque(MTAudioProcessingTapGetStorage(tapRef)).takeUnretainedValue()
             audioTap.prepare(description: processingFormat.pointee)
         } unprepare: { tapRef in
-            // deallocate memory for sound processing
             let audioTap = Unmanaged<AudioTap>.fromOpaque(MTAudioProcessingTapGetStorage(tapRef)).takeUnretainedValue()
             audioTap.unprepare()
         } process: { tapRef, numberFrames, flags, bufferListInOut, numberFramesOut, flagsOut in
             guard noErr == MTAudioProcessingTapGetSourceAudio(tapRef, numberFrames, bufferListInOut, flagsOut, nil, numberFramesOut) else {
                 return
             }
-            
-            // process sound data
             let audioTap = Unmanaged<AudioTap>.fromOpaque(MTAudioProcessingTapGetStorage(tapRef)).takeUnretainedValue()
             audioTap.process(numberOfFrames: numberFrames, buffer: UnsafeMutableAudioBufferListPointer(bufferListInOut))
         }
-        
+
         var tapRef: MTAudioProcessingTap?
         let error = MTAudioProcessingTapCreate(kCFAllocatorDefault, &callbacks, kMTAudioProcessingTapCreationFlag_PreEffects, &tapRef)
-        assert(error == noErr)
-        
+        if error != noErr { return }
+
         params.audioTapProcessor = tapRef
-        
         audioMix.inputParameters = [params]
         item.audioMix = audioMix
     }