react-native-queue-player 1.0.0

package/android/src/main/java/com/margelo/nitro/queueplayer/AirPlayEngine.kt

@@ -0,0 +1,314 @@
+package com.margelo.nitro.queueplayer
+
+import androidx.media3.common.AudioAttributes
+import androidx.media3.common.C
+import androidx.media3.common.MediaItem
+import androidx.media3.common.PlaybackException
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.exoplayer.RenderersFactory
+import androidx.media3.exoplayer.analytics.AnalyticsListener
+import androidx.media3.exoplayer.audio.AudioSink
+import androidx.media3.exoplayer.audio.TeeAudioProcessor
+import androidx.media3.exoplayer.source.MediaSource
+import com.margelo.nitro.queueplayer.cast.airplay.AirPlayRenderersFactory
+import java.util.concurrent.CopyOnWriteArrayList
+
+/**
+ * Dedicated single-ExoPlayer engine for AirPlay (1 + 2) push-PCM streaming.
+ *
+ * A standalone peer of [GaplessEngine] / [CrossfadeEngine] — intentionally NOT
+ * built on top of them. Its audio renderer's [AudioSink] is the AirPlay
+ * session's sink (passed in), wired through a bare [AirPlayRenderersFactory]:
+ * no forced float output, no ReplayGain, no visualizer. The AirPlay sinks only
+ * accept Int16 RAW PCM, and feeding them from the local engine's
+ * float/processor pipeline corrupted the stream — so AirPlay gets its own clean
+ * engine, built on connect and released on disconnect.
+ *
+ * One engine per session: the [airplaySink] is bound at ExoPlayer construction
+ * and never swapped. [TrackPlayer] swaps this engine in when an AirPlay session
+ * activates and swaps back to the user's gapless/crossfade engine on disconnect,
+ * carrying queue + index + position + play state across both directions.
+ *
+ * Threading: constructed + accessed on the service main looper; ExoPlayer
+ * dispatches callbacks on the same looper.
+ */
+@UnstableApi
+internal class AirPlayEngine(
+  context: android.content.Context,
+  airplaySink: AudioSink,
+  mediaSourceFactory: MediaSource.Factory? = null,
+  audioContentType: AudioContentType? = null,
+) : PlaybackEngine {
+
+  override var delegate: PlaybackEngineDelegate? = null
+
+  private val sessionIdListeners = CopyOnWriteArrayList<(IntArray) -> Unit>()
+  private var lastKnownSessionId: Int = C.AUDIO_SESSION_ID_UNSET
+
+  private val renderersFactory: RenderersFactory =
+    AirPlayRenderersFactory(context, airplaySink)
+
+  /**
+   * Underlying Media3 player. Module-internal escape hatch so
+   * [PlaybackService] can do service-level wiring (audio-focus listener
+   * attach, `MediaSession.setPlayer`) without going through the abstract
+   * [PlaybackEngine] surface.
+   */
+  val exoPlayer: ExoPlayer = buildAirPlayExoPlayer(
+    context, mediaSourceFactory, audioContentType, renderersFactory,
+  )
+
+  override val mediaSessionPlayer: ExoPlayer get() = exoPlayer
+
+  private var released: Boolean = false
+
+  private val playerListener = object : Player.Listener {
+    override fun onPlaybackStateChanged(playbackState: Int) {
+      delegate?.onStateMaybeChanged(this@AirPlayEngine, playWhenReadyReason = null)
+      if (playbackState == Player.STATE_ENDED) {
+        delegate?.onPlaybackEnded(this@AirPlayEngine)
+      }
+    }
+
+    override fun onPlayWhenReadyChanged(playWhenReady: Boolean, reason: Int) {
+      delegate?.onStateMaybeChanged(this@AirPlayEngine, playWhenReadyReason = reason)
+    }
+
+    override fun onIsPlayingChanged(isPlaying: Boolean) {
+      delegate?.onIsPlayingChanged(this@AirPlayEngine, isPlaying)
+      delegate?.onStateMaybeChanged(this@AirPlayEngine, playWhenReadyReason = null)
+    }
+
+    override fun onMediaItemTransition(mediaItem: MediaItem?, reason: Int) {
+      delegate?.onTrackTransition(this@AirPlayEngine, reason)
+    }
+
+    override fun onTracksChanged(tracks: androidx.media3.common.Tracks) {
+      // Surface the active item's format change. No ReplayGain parse — RG is
+      // intentionally absent on the AirPlay engine.
+      delegate?.onActiveItemFormatChanged(this@AirPlayEngine)
+    }
+
+    override fun onPositionDiscontinuity(
+      oldPosition: Player.PositionInfo,
+      newPosition: Player.PositionInfo,
+      reason: Int,
+    ) {
+      if (reason == Player.DISCONTINUITY_REASON_AUTO_TRANSITION) {
+        delegate?.onAutoTransitionDiscontinuity(this@AirPlayEngine)
+      }
+    }
+
+    override fun onPlayerError(error: PlaybackException) {
+      delegate?.onError(this@AirPlayEngine, error)
+    }
+  }
+
+  private val analyticsListener = object : AnalyticsListener {
+    override fun onAudioSessionIdChanged(
+      eventTime: AnalyticsListener.EventTime,
+      audioSessionId: Int,
+    ) {
+      lastKnownSessionId = audioSessionId
+      val ids = currentAudioSessionIds()
+      sessionIdListeners.forEach { it(ids) }
+    }
+  }
+
+  init {
+    exoPlayer.addListener(playerListener)
+    exoPlayer.addAnalyticsListener(analyticsListener)
+    // Hand the active player reference to the cast sink-router. TrackPlayer
+    // reads it back when it swaps this engine in and starts the active session's
+    // receiver-display metadata sync (MetadataAwareSession.onActivated) against
+    // this engine's ExoPlayer.
+    com.margelo.nitro.queueplayer.cast.CastSinkRouter.registerPlayer(exoPlayer)
+  }
+
+  // --- PlaybackEngine — lifecycle ---
+
+  override suspend fun prepare(
+    mediaItems: List<MediaItem>,
+    startIndex: Int,
+    startPositionMs: Long,
+  ) {
+    exoPlayer.setMediaItems(mediaItems, startIndex, startPositionMs)
+    exoPlayer.prepare()
+  }
+
+  override fun release() {
+    if (released) return
+    released = true
+    exoPlayer.removeListener(playerListener)
+    exoPlayer.removeAnalyticsListener(analyticsListener)
+    sessionIdListeners.clear()
+    // Stop the receiver-display metadata sync bound to this engine's player
+    // before the player is released. Releasing the AirPlay engine is the single
+    // deactivation trigger that covers every teardown — swap back to local,
+    // AirPlay->AirPlay rebuild, and service onDestroy — because each releases
+    // the active AirPlay engine. On disconnect / receiver death the session is
+    // already cleared (so this is a no-op) and its own close() has stopped the
+    // sync; this catches the paths that don't route through a session close.
+    (com.margelo.nitro.queueplayer.cast.CastSinkRouter.activeSession()
+      as? com.margelo.nitro.queueplayer.cast.MetadataAwareSession)?.onDeactivated()
+    // Drop the delegate before releasing the player so any callback already
+    // dispatched onto the looper cannot fan out to a TrackPlayer that has just
+    // swapped to a fresh engine. exoPlayer.release() releases the AirPlay sink
+    // (idempotent — the session's close() may have released it already).
+    delegate = null
+    exoPlayer.release()
+  }
+
+  // --- PlaybackEngine — queue mutation ---
+
+  override fun setMediaItems(
+    items: List<MediaItem>,
+    startIndex: Int,
+    startPositionMs: Long,
+  ) {
+    exoPlayer.setMediaItems(items, startIndex, startPositionMs)
+    // ExoPlayer is IDLE after construction; prepare() is required before any
+    // subsequent play() can take effect (mirrors GaplessEngine).
+    exoPlayer.prepare()
+  }
+
+  override fun addMediaItems(items: List<MediaItem>, insertBefore: Int) {
+    exoPlayer.addMediaItems(insertBefore, items)
+  }
+
+  override fun removeMediaItems(indices: IntArray) {
+    val sorted = indices.toMutableList().apply { sortDescending() }
+    for (i in sorted) exoPlayer.removeMediaItem(i)
+  }
+
+  override fun moveMediaItem(fromIndex: Int, toIndex: Int) {
+    exoPlayer.moveMediaItem(fromIndex, toIndex)
+  }
+
+  // --- PlaybackEngine — transport ---
+
+  override fun play() { exoPlayer.play() }
+  override fun pause() { exoPlayer.pause() }
+  override fun stop() { exoPlayer.stop() }
+  override fun seekTo(index: Int, positionMs: Long) { exoPlayer.seekTo(index, positionMs) }
+  override fun skipToNext() { exoPlayer.seekToNextMediaItem() }
+  override fun skipToPrevious() { exoPlayer.seekToPreviousMediaItem() }
+
+  // --- PlaybackEngine — config ---
+
+  override fun setVolume(volume: Float) {
+    // The AirPlay sink ignores ExoPlayer volume (receiver volume is controlled
+    // session-side via RTSP). Forwarded for interface completeness.
+    exoPlayer.volume = volume
+  }
+
+  override fun setPlaybackSpeed(speed: Float) { exoPlayer.setPlaybackSpeed(speed) }
+
+  override fun setRepeatMode(mode: RepeatMode) {
+    exoPlayer.repeatMode = when (mode) {
+      RepeatMode.OFF -> Player.REPEAT_MODE_OFF
+      RepeatMode.TRACK -> Player.REPEAT_MODE_ONE
+      RepeatMode.QUEUE -> Player.REPEAT_MODE_ALL
+    }
+  }
+
+  override fun setPitchCorrectionMode(mode: PitchCorrectionMode) {
+    // No-op: AirPlay streams to a remote receiver that owns rendering.
+    // Pitch-correction is a local-engine concern.
+  }
+
+  override fun setWakeMode(mode: Int) {
+    exoPlayer.setWakeMode(mode)
+  }
+
+  // --- PlaybackEngine — state ---
+
+  override val currentMediaItemIndex: Int
+    get() {
+      val count = exoPlayer.mediaItemCount
+      if (count == 0) return -1
+      return exoPlayer.currentMediaItemIndex
+    }
+
+  override val currentPositionMs: Long get() = exoPlayer.currentPosition
+
+  override val currentDurationMs: Long
+    get() {
+      val d = exoPlayer.duration
+      return if (d == C.TIME_UNSET) 0L else d
+    }
+
+  override val bufferedPositionMs: Long get() = exoPlayer.bufferedPosition
+  override val isPlaying: Boolean get() = exoPlayer.isPlaying
+  override val currentMediaItem: MediaItem? get() = exoPlayer.currentMediaItem
+
+  override val allMediaItems: List<MediaItem>
+    get() {
+      val count = exoPlayer.mediaItemCount
+      if (count == 0) return emptyList()
+      val out = ArrayList<MediaItem>(count)
+      for (i in 0 until count) out.add(exoPlayer.getMediaItemAt(i))
+      return out
+    }
+
+  // --- PlaybackEngine — effect chain ---
+
+  override fun currentAudioSessionIds(): IntArray =
+    if (lastKnownSessionId == C.AUDIO_SESSION_ID_UNSET) IntArray(0)
+    else intArrayOf(lastKnownSessionId)
+
+  override fun addAudioSessionIdListener(listener: (IntArray) -> Unit): () -> Unit {
+    sessionIdListeners.add(listener)
+    listener(currentAudioSessionIds())
+    return { sessionIdListeners.remove(listener) }
+  }
+
+  // No visualizer on the AirPlay engine — the receiver renders audio, not us.
+  override fun attachAudioBufferSink(sink: TeeAudioProcessor.AudioBufferSink) { /* no-op */ }
+  override fun detachAudioBufferSink(sink: TeeAudioProcessor.AudioBufferSink) { /* no-op */ }
+
+  // ReplayGain absent on the AirPlay engine — interface defaults
+  // (currentReplayGainData() = null, currentReplayGainActive() = false) apply.
+
+  // --- PlaybackEngine — handoff ---
+
+  override suspend fun handoff(to: PlaybackEngine, atTrackBoundary: Boolean) {
+    throw NotImplementedError("PlaybackEngine.handoff is not supported by AirPlayEngine")
+  }
+}
+
+/**
+ * Build the AirPlay engine's ExoPlayer. Mirrors the gapless engine's standard
+ * configuration (audio focus, becoming-noisy, network wake) but with the bare
+ * [AirPlayRenderersFactory] supplied by the caller.
+ */
+@UnstableApi
+private fun buildAirPlayExoPlayer(
+  context: android.content.Context,
+  mediaSourceFactory: MediaSource.Factory?,
+  audioContentType: AudioContentType?,
+  renderersFactory: RenderersFactory,
+): ExoPlayer {
+  val builder = ExoPlayer.Builder(context)
+  builder.setRenderersFactory(renderersFactory)
+  if (mediaSourceFactory != null) {
+    builder.setMediaSourceFactory(mediaSourceFactory)
+  }
+  val player = builder.build()
+  player.pauseAtEndOfMediaItems = false
+  val contentType = if (audioContentType == AudioContentType.SPEECH) {
+    C.AUDIO_CONTENT_TYPE_SPEECH
+  } else {
+    C.AUDIO_CONTENT_TYPE_MUSIC
+  }
+  val audioAttributes = AudioAttributes.Builder()
+    .setUsage(C.USAGE_MEDIA)
+    .setContentType(contentType)
+    .build()
+  player.setAudioAttributes(audioAttributes, /* handleAudioFocus = */ true)
+  player.setHandleAudioBecomingNoisy(true)
+  player.setWakeMode(C.WAKE_MODE_NETWORK)
+  return player
+}

package/android/src/main/java/com/margelo/nitro/queueplayer/ArtworkContentProvider.kt

@@ -0,0 +1,124 @@
+package com.margelo.nitro.queueplayer
+
+import android.content.ContentProvider
+import android.content.ContentValues
+import android.content.Context
+import android.database.Cursor
+import android.net.Uri
+import android.os.ParcelFileDescriptor
+import java.io.File
+import java.security.MessageDigest
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ * Exported `ContentProvider` that serves locally-cached artwork files
+ * to cross-process media controllers (Android Auto's gearhead, Wear,
+ * Assistant). Solves the missing-cover symptom on the AA Now Playing
+ * surface — gearhead resolves `artworkUri` via its own `ContentResolver`
+ * in a different process and cannot read another app's private
+ * `file://` storage; Media3 does not currently call
+ * `grantUriPermission` for connected controllers
+ * (androidx/media#2331). An exported provider serving the same files
+ * via `content://` lets gearhead open them with no URI-permission
+ * dance.
+ *
+ * Security: registers only file paths we have explicitly handed out
+ * via [mapFileUri]. The URI carries an opaque token (SHA-256 prefix
+ * of the file path); a malicious caller cannot probe arbitrary paths
+ * without already knowing the token. Process-lifecycle: the registry
+ * is in-memory, so a process death + restart drops the map; the
+ * media controller re-queries our session afterwards which re-runs
+ * [mapFileUri] and re-populates the registry transparently.
+ *
+ * Authority is `${applicationId}.rnqp.artwork` — per-consumer-app
+ * unique so multiple RNQP-using apps on the same device don't clash.
+ */
+class ArtworkContentProvider : ContentProvider() {
+
+  override fun onCreate(): Boolean {
+    appContextRef = context?.applicationContext
+    return appContextRef != null
+  }
+
+  override fun query(
+    uri: Uri,
+    projection: Array<out String>?,
+    selection: String?,
+    selectionArgs: Array<out String>?,
+    sortOrder: String?
+  ): Cursor? = null
+
+  override fun getType(uri: Uri): String = "image/*"
+
+  override fun insert(uri: Uri, values: ContentValues?): Uri? = null
+
+  override fun delete(uri: Uri, selection: String?, selectionArgs: Array<out String>?): Int = 0
+
+  override fun update(
+    uri: Uri,
+    values: ContentValues?,
+    selection: String?,
+    selectionArgs: Array<out String>?
+  ): Int = 0
+
+  override fun openFile(uri: Uri, mode: String): ParcelFileDescriptor? {
+    val token = uri.pathSegments.firstOrNull() ?: return null
+    val file = registry[token] ?: return null
+    return try {
+      ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY)
+    } catch (_: Throwable) {
+      null
+    }
+  }
+
+  companion object {
+    private const val AUTHORITY_SUFFIX = ".rnqp.artwork"
+    private val registry = ConcurrentHashMap<String, File>()
+
+    @Volatile
+    private var appContextRef: Context? = null
+
+    /** Authority owned by THIS consumer app, e.g.
+     *  `com.consumer.app.rnqp.artwork`. Returns null only before the
+     *  provider's onCreate runs (which happens at app start). */
+    fun authority(): String? = appContextRef?.let { it.packageName + AUTHORITY_SUFFIX }
+
+    /**
+     * Convert a `file://` URI for a locally-cached artwork file into
+     * a `content://` URI served by this provider. Returns the input
+     * unchanged when it is not `file://`, or when the file is
+     * unreadable. The returned URI is parcel-safe to hand off to
+     * cross-process controllers (Android Auto, Wear, Assistant).
+     */
+    fun mapFileUri(fileUri: Uri): Uri {
+      if (fileUri.scheme != "file") return fileUri
+      val path = fileUri.path ?: return fileUri
+      val file = File(path)
+      if (!file.exists() || !file.canRead()) return fileUri
+      val auth = authority() ?: return fileUri
+      val token = tokenFor(path)
+      registry[token] = file
+      return Uri.Builder()
+        .scheme("content")
+        .authority(auth)
+        .appendPath(token)
+        .build()
+    }
+
+    /** SHA-256 prefix of [path], 32 hex chars. Stable per path so
+     *  re-registering the same file is idempotent — the registry map
+     *  ends up with a single entry per cached file regardless of how
+     *  many MediaItems reference it. */
+    private fun tokenFor(path: String): String {
+      val digest = MessageDigest.getInstance("SHA-256")
+      val bytes = digest.digest(path.toByteArray(Charsets.UTF_8))
+      val hex = StringBuilder(bytes.size * 2)
+      for (b in bytes) {
+        val v = b.toInt() and 0xFF
+        hex.append("0123456789abcdef"[v ushr 4])
+        hex.append("0123456789abcdef"[v and 0x0F])
+      }
+      return hex.substring(0, 32)
+    }
+  }
+}

package/android/src/main/java/com/margelo/nitro/queueplayer/AudioFocusErrorMapping.kt

@@ -0,0 +1,89 @@
+package com.margelo.nitro.queueplayer
+
+import androidx.media3.common.Player
+
+/**
+ * Maps Media3 [Player.Listener] audio-focus reason ints to the lib-
+ * standardized `nativeDomain` string + a stable human-readable
+ * message used by `PlaybackService` when firing the corresponding
+ * non-fatal `PlaybackError` through `TrackPlayer`'s error channel.
+ *
+ * Media3 already drives the actual pause / duck / resume response
+ * via `setAudioAttributes(handleAudioFocus = true)`. The mapping
+ * exists purely so consumers can render UX (interruption banner,
+ * resume prompt) without re-deriving the focus state from the
+ * playback-state stream.
+ *
+ * **`AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK` is intentionally NOT
+ * surfaced.** Media3 ducks internally on can-duck losses and does
+ * not expose that state via any public [Player.Listener] reason —
+ * neither `PLAY_WHEN_READY_CHANGE_REASON_*` nor
+ * `PLAYBACK_SUPPRESSION_REASON_*`. The only way to observe it is
+ * to register a parallel `AudioFocusRequest`, which contends with
+ * Media3's request against the same `USAGE_MEDIA` attributes and
+ * can displace the focus Media3 holds. That's worse than the lost
+ * observability, so the can-duck variant is dropped from the
+ * surface.
+ *
+ * Three `nativeDomain` strings, all sharing the `AUDIO_FOCUS_`
+ * prefix so JS consumers can branch on
+ * `nativeDomain.startsWith("AUDIO_FOCUS_")` and treat any focus
+ * event as a single category when they don't care about the sub-
+ * state. Unknown reason ints map to `null` so the caller drops
+ * them — keeps unknown future codes from leaking through as
+ * malformed events.
+ */
+internal object AudioFocusErrorMapping {
+
+  /** Output pair surfaced by the mapping functions. */
+  data class Mapping(val nativeDomain: String, val message: String)
+
+  /** Shared prefix for the focus `nativeDomain` strings. */
+  const val NATIVE_DOMAIN_PREFIX = "AUDIO_FOCUS_"
+
+  /**
+   * Translate a [Player.Listener.onPlayWhenReadyChanged] reason
+   * into the lib-standardized event pair. Only
+   * [Player.PLAY_WHEN_READY_CHANGE_REASON_AUDIO_FOCUS_LOSS]
+   * produces a mapping — every other reason is a non-focus
+   * transition (USER, REMOTE, END_OF_MEDIA_ITEM, SUPPRESSED) and
+   * returns `null` so the caller drops the event.
+   */
+  fun mapPlayWhenReadyReason(reason: Int): Mapping? =
+    if (reason == Player.PLAY_WHEN_READY_CHANGE_REASON_AUDIO_FOCUS_LOSS) {
+      Mapping(
+        nativeDomain = NATIVE_DOMAIN_PREFIX + "LOSS_PERMANENT",
+        message = "Audio focus lost permanently; Media3 has paused playback.",
+      )
+    } else {
+      null
+    }
+
+  /**
+   * Translate a [Player.Listener.onPlaybackSuppressionReasonChanged]
+   * transition into the lib-standardized event pair. Two transitions
+   * map:
+   *   - any → [Player.PLAYBACK_SUPPRESSION_REASON_TRANSIENT_AUDIO_FOCUS_LOSS]
+   *     ⇒ `LOSS_TRANSIENT`
+   *   - [Player.PLAYBACK_SUPPRESSION_REASON_TRANSIENT_AUDIO_FOCUS_LOSS]
+   *     → [Player.PLAYBACK_SUPPRESSION_REASON_NONE] ⇒ `GAIN`
+   *
+   * Other transitions (e.g. NONE → UNSUITABLE_AUDIO_OUTPUT, or
+   * NONE → NONE redundant fires) return `null`.
+   */
+  fun mapSuppressionReason(reason: Int, previous: Int): Mapping? = when {
+    reason == Player.PLAYBACK_SUPPRESSION_REASON_TRANSIENT_AUDIO_FOCUS_LOSS &&
+      previous != Player.PLAYBACK_SUPPRESSION_REASON_TRANSIENT_AUDIO_FOCUS_LOSS ->
+      Mapping(
+        nativeDomain = NATIVE_DOMAIN_PREFIX + "LOSS_TRANSIENT",
+        message = "Audio focus lost transiently; Media3 has paused playback.",
+      )
+    reason == Player.PLAYBACK_SUPPRESSION_REASON_NONE &&
+      previous == Player.PLAYBACK_SUPPRESSION_REASON_TRANSIENT_AUDIO_FOCUS_LOSS ->
+      Mapping(
+        nativeDomain = NATIVE_DOMAIN_PREFIX + "GAIN",
+        message = "Audio focus regained.",
+      )
+    else -> null
+  }
+}

package/android/src/main/java/com/margelo/nitro/queueplayer/AudioPipelineRenderersFactory.kt

@@ -0,0 +1,60 @@
+package com.margelo.nitro.queueplayer
+
+import android.content.Context
+import androidx.media3.common.audio.AudioProcessorChain
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.DefaultRenderersFactory
+import androidx.media3.exoplayer.audio.AudioSink
+import androidx.media3.exoplayer.audio.DefaultAudioSink
+
+/**
+ * Generic [DefaultRenderersFactory] that wires a caller-supplied
+ * [AudioProcessorChain] into the produced [AudioSink].
+ *
+ * Uses [DefaultAudioSink.Builder.setAudioProcessorChain], which — unlike
+ * `setAudioProcessors` — does NOT auto-append Sonic + silence-skipping. The
+ * chain therefore owns the ENTIRE pipeline composition (ReplayGain, the
+ * visualizer Tee, and the mode-gated pitch-correction stretchers); the factory
+ * owns no subsystem state. The engine builds the chain and passes it in.
+ *
+ * Per-AudioSink chain instances are mandatory: the chain holds stateful
+ * processors (the visualizer [androidx.media3.exoplayer.audio.TeeAudioProcessor]
+ * and the music time-stretcher), and sharing one across two AudioSinks would
+ * interleave their `flush` + buffer state. The CrossfadeEngine builds two
+ * factories (one per leg); each receives its own chain.
+ *
+ * Float-output is opted in at construction via [setEnableAudioFloatOutput]:
+ * Media3's [DefaultRenderersFactory] defaults that flag to `false`, which would
+ * propagate as `enableFloatOutput = false` into [buildAudioSink] and produce an
+ * Int16 PCM sink. [ReplayGainAudioProcessor.isActive] and
+ * [SignalsmithStretchAudioProcessor.isActive] gate on `ENCODING_PCM_FLOAT`, so
+ * without the explicit opt-in they would silently run as pass-throughs.
+ */
+@UnstableApi
+internal class AudioPipelineRenderersFactory(
+  context: Context,
+  private val audioProcessorChain: AudioProcessorChain,
+) : DefaultRenderersFactory(context) {
+
+  init {
+    setEnableAudioFloatOutput(true)
+  }
+
+  override fun buildAudioSink(
+    context: Context,
+    enableFloatOutput: Boolean,
+    enableAudioTrackPlaybackParams: Boolean,
+  ): AudioSink {
+    // `enableAudioTrackPlaybackParams` is the legacy name from
+    // DefaultRenderersFactory.buildAudioSink; the DefaultAudioSink
+    // Builder method that accepts it is now
+    // `setEnableAudioOutputPlaybackParameters` — same boolean, broader
+    // scope (controls output-level rather than AudioTrack-only
+    // playback params).
+    return DefaultAudioSink.Builder(context)
+      .setAudioProcessorChain(audioProcessorChain)
+      .setEnableFloatOutput(enableFloatOutput)
+      .setEnableAudioOutputPlaybackParameters(enableAudioTrackPlaybackParams)
+      .build()
+  }
+}