react-native-queue-player 1.0.0 → 1.0.2

package/android/build.gradle

@@ -71,6 +71,11 @@ android {
     targetSdkVersion getExtOrDefault("targetSdkVersion")
     testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
 
+    // Shipped in the AAR and applied to the consumer's R8 run so a consuming
+    // app's release build needs no manual rules for this library's transitive
+    // dependencies (e.g. Ktor's java.lang.management reference on Android).
+    consumerProguardFiles "consumer-rules.pro"
+
     externalNativeBuild {
       cmake {
         cppFlags "-frtti -fexceptions -Wall -fstack-protector-all"

package/android/consumer-rules.pro

@@ -0,0 +1,14 @@
+# React Native Queue Player — consumer R8 / ProGuard rules.
+#
+# Packaged into the published AAR via `consumerProguardFiles` and applied
+# automatically to a consuming app's R8 run, so consumers need no manual rules
+# for this library's transitive dependencies.
+
+# The embedded Ktor CIO HTTP server (the Android AirPlay 2 receiver) ships
+# io.ktor.util.debug.IntellijIdeaDebugDetector, which references
+# java.lang.management.ManagementFactory and RuntimeMXBean to detect an attached
+# IntelliJ debugger. Those JMX classes are JVM-only and absent on Android, so a
+# consumer's R8 release build (full mode treats missing classes as errors) fails
+# on the missing references. The detector is debug tooling that never executes
+# at runtime on Android; ignore the missing classes rather than fail the build.
+-dontwarn java.lang.management.**

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

@@ -23,12 +23,14 @@ import androidx.media3.exoplayer.audio.DefaultAudioSink
  * 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.
+ * Float output is deliberately NOT enabled. With Media3 float output, a hi-res
+ * (24-bit+) source produces a float sink, and [DefaultAudioSink.configure] then
+ * DROPS the entire custom [AudioProcessorChain] — its float branch omits the
+ * chain because the built-in Sonic outputs 16-bit — silently disabling playback
+ * speed, pitch-correction, ReplayGain, and the visualizer on hi-res content.
+ * Keeping the sink at 16-bit (Media3 downconverts hi-res) keeps the chain in the
+ * pipeline for every source; [ReplayGainAudioProcessor] and
+ * [SignalsmithStretchAudioProcessor] both process 16-bit PCM directly.
  */
 @UnstableApi
 internal class AudioPipelineRenderersFactory(
@@ -36,10 +38,6 @@ internal class AudioPipelineRenderersFactory(
   private val audioProcessorChain: AudioProcessorChain,
 ) : DefaultRenderersFactory(context) {
 
-  init {
-    setEnableAudioFloatOutput(true)
-  }
-
   override fun buildAudioSink(
     context: Context,
     enableFloatOutput: Boolean,

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

@@ -5,23 +5,22 @@ 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.roundToInt
 
 /**
  * Standalone Media3 [AudioProcessor] that applies a per-track linear
- * gain to a Float32 PCM stream. No knowledge of the engine, the EQ
- * stage, or the visualizer pipeline — purely "given a Float32 buffer,
- * multiply by [linearGain]". The owning engine pushes a new gain via
- * [setLinearGain] from its `Player.Listener.onMetadata` callback;
- * `onMediaItemTransition` resets to unity until the next metadata
- * arrival.
+ * gain to a PCM stream. No knowledge of the engine, the EQ stage, or the
+ * visualizer pipeline — purely "given a PCM buffer, multiply by
+ * [linearGain]". The owning engine pushes a new gain via [setLinearGain]
+ * from its `Player.Listener` callbacks; `onMediaItemTransition` resets to
+ * unity until the next track's tags arrive.
  *
- * Float32-only by design. [AudioPipelineRenderersFactory] opts the
- * factory into `setEnableAudioFloatOutput(true)` at construction so
- * Media3 propagates `enableFloatOutput = true` into `buildAudioSink`,
- * and the resulting `DefaultAudioSink` produces `ENCODING_PCM_FLOAT`.
- * Sources decoded to Int16 PCM transit through this processor
- * untouched via [isActive] returning `false`, matching the documented
- * non-Float32 no-op limitation in NOTES.md §25.
+ * Handles both 16-bit and float PCM. The sink runs at 16-bit (see
+ * [AudioPipelineRenderersFactory] — float output would drop the whole
+ * chain on hi-res sources), so a 16-bit block is scaled in float precision
+ * and narrowed back with a round + full-scale clamp; a float block is
+ * scaled in place. The gain is already clip-capped against the track peak
+ * (`ReplayGainGain`), so the clamp only guards sentinel/missing-peak tags.
  */
 @UnstableApi
 internal class ReplayGainAudioProcessor : BaseAudioProcessor() {
@@ -37,11 +36,11 @@ internal class ReplayGainAudioProcessor : BaseAudioProcessor() {
   private var linearGain: Float = 1.0f
 
   /**
-   * `true` when [onConfigure] saw `ENCODING_PCM_FLOAT`. Volatile for
-   * the same render-thread / main-thread split as [linearGain].
+   * Input PCM encoding captured at [onConfigure]. Volatile for the same
+   * render-thread / main-thread split as [linearGain].
    */
   @Volatile
-  private var inputIsFloat: Boolean = false
+  private var encoding: Int = C.ENCODING_INVALID
 
   /**
    * Push a new linear gain. `1.0f` disables the processor's per-sample
@@ -52,7 +51,7 @@ internal class ReplayGainAudioProcessor : BaseAudioProcessor() {
   }
 
   override fun onConfigure(input: AudioProcessor.AudioFormat): AudioProcessor.AudioFormat {
-    inputIsFloat = (input.encoding == C.ENCODING_PCM_FLOAT)
+    encoding = input.encoding
     // Pass-through: this stage doesn't change rate, channel count, or
     // encoding. Returning [AudioProcessor.AudioFormat.NOT_SET] would
     // tell Media3 the processor consumes the stream and drops the
@@ -61,23 +60,36 @@ internal class ReplayGainAudioProcessor : BaseAudioProcessor() {
   }
 
   override fun isActive(): Boolean =
-    super.isActive() && linearGain != 1.0f && inputIsFloat
+    super.isActive() && linearGain != 1.0f &&
+      (encoding == C.ENCODING_PCM_FLOAT || encoding == C.ENCODING_PCM_16BIT)
 
   override fun queueInput(input: ByteBuffer) {
     val gain = linearGain
     val byteCount = input.remaining()
     if (byteCount == 0) return
     val out = replaceOutputBuffer(byteCount)
-    val inF = input.asFloatBuffer()
-    val outF = out.asFloatBuffer()
-    while (inF.hasRemaining()) {
-      outF.put(inF.get() * gain)
+    if (encoding == C.ENCODING_PCM_FLOAT) {
+      val inF = input.asFloatBuffer()
+      val outF = out.asFloatBuffer()
+      while (inF.hasRemaining()) {
+        outF.put(inF.get() * gain)
+      }
+    } else {
+      // 16-bit: scale in float precision, narrow back with round + clamp.
+      // The gain is peak-capped upstream, so the clamp only guards
+      // sentinel/missing-peak tags against wraparound.
+      val inS = input.asShortBuffer()
+      val outS = out.asShortBuffer()
+      while (inS.hasRemaining()) {
+        val scaled = inS.get() * gain
+        outS.put(scaled.roundToInt().coerceIn(-32768, 32767).toShort())
+      }
     }
     input.position(input.limit())
     // Advance the byte-level position so [getOutput] hands back a
-    // buffer with the produced bytes between position and limit. The
-    // float-view writes mutate the underlying bytes but don't move
-    // the parent ByteBuffer's position.
+    // buffer with the produced bytes between position and limit — the
+    // typed-view writes mutate the underlying bytes but don't move the
+    // parent ByteBuffer's position.
     out.position(byteCount)
     out.flip()
   }

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

@@ -56,11 +56,12 @@ internal class SignalsmithStretchAudioProcessor : BaseAudioProcessor() {
   private var floatIn: ByteBuffer? = null
   private var floatOut: ByteBuffer? = null
 
-  // Input (media) vs output (playout) byte tallies since the last flush, for
-  // the chain's getMediaDuration position mapping. Accumulated only while
-  // stretching (the pass-through span never delegates to this processor).
-  private var inputBytes: Long = 0L
-  private var outputBytes: Long = 0L
+  // True once a stretched block has been produced, so the engine's tail
+  // latency awaits a drain. [onQueueEndOfStream] drains it exactly once and
+  // clears this — the native `outputLatency()` reports the fixed algorithmic
+  // latency (not the live buffer fill), so re-draining re-emits the same tail
+  // frames (an audible stutter) and never ends the stream.
+  private var pendingDrain = false
 
   // Fractional frame remainder so per-block outFrames average to inFrames/speed.
   private var frameCarry: Double = 0.0
@@ -73,13 +74,16 @@ internal class SignalsmithStretchAudioProcessor : BaseAudioProcessor() {
   fun isStretching(): Boolean = isActive && speed != 1f
 
   /**
-   * Map a playout duration back to media duration, mirroring Sonic's model:
-   * `playout * inputBytes / outputBytes`. Returns the playout unchanged until
-   * the first stretched block has been produced.
+   * Map a playout duration back to media duration. For a pure time-stretch,
+   * `s` seconds of media play per playout second at speed `s`, so media =
+   * playout * speed — computed from the live speed rather than a cumulative
+   * input/output byte ratio, which mis-maps while the engine's latency is
+   * drained (the drained tail inflates output-vs-input) and freezes the
+   * position clock on a speed change.
    */
   fun getMediaDuration(playoutDuration: Long): Long =
-    if (outputBytes == 0L) playoutDuration
-    else Util.scaleLargeTimestamp(playoutDuration, inputBytes, outputBytes)
+    if (speed == 1f) playoutDuration
+    else Util.scaleLargeTimestamp(playoutDuration, (speed * 1_000_000f).toLong(), 1_000_000L)
 
   override fun onConfigure(inputAudioFormat: AudioProcessor.AudioFormat): AudioProcessor.AudioFormat {
     encoding = inputAudioFormat.encoding
@@ -87,8 +91,11 @@ internal class SignalsmithStretchAudioProcessor : BaseAudioProcessor() {
     sampleRateHz = inputAudioFormat.sampleRate
     bytesPerFrame = channelCount * if (encoding == C.ENCODING_PCM_FLOAT) 4 else 2
     // A reconfigure invalidates any engine built for the previous format;
-    // the next stretching queueInput lazily rebuilds it.
+    // the next stretching queueInput lazily rebuilds it. Clear the drain flag
+    // so the invariant holds locally, independent of the flush that Media3
+    // issues after a (re)configure.
     releaseNative()
+    pendingDrain = false
     // Pass-through format — the stretch changes duration, not rate/channels/
     // encoding. Returning NOT_SET would drop the sink.
     return inputAudioFormat
@@ -148,13 +155,17 @@ internal class SignalsmithStretchAudioProcessor : BaseAudioProcessor() {
     }
 
     input.position(input.limit())
-    inputBytes += inFrames.toLong() * bytesPerFrame
-    outputBytes += outFrames.toLong() * bytesPerFrame
+    pendingDrain = true
   }
 
   override fun onQueueEndOfStream() {
     val stretch = nativeStretch ?: return
-    if (speed == 1f) return // not stretching — nothing buffered to drain
+    // Drain the engine's tail latency exactly once per stretched span. Media3
+    // can call this repeatedly around a reconfigure; `outputLatency()` reports
+    // the fixed algorithmic latency, so re-draining re-emits the same tail
+    // frames (stutter) and the stream never ends, stalling a speed change.
+    if (!pendingDrain || speed == 1f) return
+    pendingDrain = false
     val latency = stretch.outputLatency()
     if (latency <= 0) return
     if (encoding == C.ENCODING_PCM_FLOAT) {
@@ -176,14 +187,12 @@ internal class SignalsmithStretchAudioProcessor : BaseAudioProcessor() {
       out.position(latency * bytesPerFrame)
       out.flip()
     }
-    outputBytes += latency.toLong() * bytesPerFrame
   }
 
   override fun onFlush(streamMetadata: AudioProcessor.StreamMetadata) {
     nativeStretch?.reset()
     frameCarry = 0.0
-    inputBytes = 0L
-    outputBytes = 0L
+    pendingDrain = false
   }
 
   override fun onReset() {
@@ -191,8 +200,7 @@ internal class SignalsmithStretchAudioProcessor : BaseAudioProcessor() {
     floatIn = null
     floatOut = null
     frameCarry = 0.0
-    inputBytes = 0L
-    outputBytes = 0L
+    pendingDrain = false
   }
 
   private fun ensureNative(): SignalsmithStretchNative {

package/android/src/test/java/com/margelo/nitro/queueplayer/AudioPipelineRenderersFactoryTest.kt

@@ -3,8 +3,8 @@ package com.margelo.nitro.queueplayer
 import androidx.media3.common.util.UnstableApi
 import androidx.media3.exoplayer.DefaultRenderersFactory
 import androidx.test.core.app.ApplicationProvider
+import org.junit.Assert.assertFalse
 import org.junit.Assert.assertNotNull
-import org.junit.Assert.assertTrue
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.robolectric.RobolectricTestRunner
@@ -13,8 +13,8 @@ import java.lang.reflect.Field
 
 /**
  * Unit coverage for [AudioPipelineRenderersFactory] construction — it wraps a
- * caller-supplied [androidx.media3.common.audio.AudioProcessorChain] and opts
- * the produced sink into float output. The engines drive end-to-end exercise of
+ * caller-supplied [androidx.media3.common.audio.AudioProcessorChain] and leaves
+ * the produced sink at 16-bit (float output off). The engines drive end-to-end exercise of
  * `buildAudioSink` via `ExoPlayer.Builder.build()` in
  * [GaplessEngineLifecycleTest] / [CrossfadeEngineLifecycleTest]; `buildAudioSink`
  * itself is `protected` on [DefaultRenderersFactory] and cannot be called
@@ -36,21 +36,22 @@ class AudioPipelineRenderersFactoryTest {
   }
 
   @Test
-  fun `factory enables audio float output so the float processors see Float32 PCM`() {
-    // [DefaultRenderersFactory.enableAudioFloatOutput] defaults to false;
-    // without an explicit opt-in Media3 propagates `enableFloatOutput = false`
-    // into [buildAudioSink], which makes the sink emit Int16 PCM and silently
-    // disables the float-gated processors (ReplayGain + the music stretcher,
-    // whose isActive gate on ENCODING_PCM_FLOAT). The factory's init block flips
-    // the flag to true; pin that by reading the private field via reflection —
-    // no public accessor exists, but the field name is stable across Media3 1.x.
+  fun `factory leaves audio float output off so the chain survives on hi-res sources`() {
+    // Float output would make a hi-res (24-bit+) source produce a float sink,
+    // and DefaultAudioSink.configure()'s float branch DROPS the custom
+    // AudioProcessorChain — silently disabling playback speed, pitch-correction,
+    // ReplayGain, and the visualizer on hi-res content. Keeping the sink at
+    // 16-bit (Media3 downconverts hi-res) keeps the chain in the pipeline for
+    // every source. Pin that the factory leaves float output off (the
+    // DefaultRenderersFactory default) via reflection — no public accessor
+    // exists, but the field name is stable across Media3 1.x.
     val factory =
       AudioPipelineRenderersFactory(context, PitchAwareAudioProcessorChain(emptyArray()))
     val field: Field =
       DefaultRenderersFactory::class.java.getDeclaredField("enableFloatOutput")
     field.isAccessible = true
-    assertTrue(
-      "AudioPipelineRenderersFactory must enable float output",
+    assertFalse(
+      "AudioPipelineRenderersFactory must NOT enable float output (it drops the chain on hi-res)",
       field.getBoolean(factory),
     )
   }

package/android/src/test/java/com/margelo/nitro/queueplayer/ReplayGainAudioProcessorTest.kt

@@ -14,10 +14,11 @@ import java.nio.ByteBuffer
 import java.nio.ByteOrder
 
 /**
- * Unit coverage for [ReplayGainAudioProcessor] — the per-sample
- * Float32 gain stage Media3 wires into the AudioSink chain. Exercises
- * the [AudioProcessor] contract: configure, isActive gating, in-place
- * multiply, encoding gate.
+ * Unit coverage for [ReplayGainAudioProcessor] — the per-sample gain
+ * stage Media3 wires into the AudioSink chain. Exercises the
+ * [AudioProcessor] contract: configure, isActive gating, in-place multiply
+ * on both 16-bit and float PCM, the 16-bit full-scale clamp, and the
+ * encoding gate.
  */
 @RunWith(RobolectricTestRunner::class)
 @Config(sdk = [34])
@@ -43,10 +44,18 @@ class ReplayGainAudioProcessorTest {
   }
 
   @Test
-  fun `isActive is false on a non-Float32 input regardless of gain`() {
+  fun `isActive is true with non-unity gain on a 16-bit input`() {
     val proc = ReplayGainAudioProcessor()
     proc.configure(int16Format(48000, 2))
     proc.setLinearGain(0.5f)
+    assertTrue(proc.isActive)
+  }
+
+  @Test
+  fun `isActive is false on an unsupported encoding`() {
+    val proc = ReplayGainAudioProcessor()
+    proc.configure(AudioProcessor.AudioFormat(48000, 2, C.ENCODING_PCM_24BIT))
+    proc.setLinearGain(0.5f)
     assertFalse(proc.isActive)
   }
 
@@ -82,6 +91,39 @@ class ReplayGainAudioProcessorTest {
     assertEquals(0.6f, output[2], 1e-6f)
   }
 
+  @Test
+  fun `queueInput scales 16-bit samples by the linear gain`() {
+    val proc = ReplayGainAudioProcessor()
+    proc.configure(int16Format(48000, 1))
+    proc.setLinearGain(0.5f)
+
+    val input = shortBuffer(shortArrayOf(10000, -8000, 4, 0, -10000))
+    proc.queueInput(input)
+
+    val output = readShorts(proc.output, 5)
+    assertEquals(5000, output[0].toInt())
+    assertEquals(-4000, output[1].toInt())
+    assertEquals(2, output[2].toInt())
+    assertEquals(0, output[3].toInt())
+    assertEquals(-5000, output[4].toInt())
+  }
+
+  @Test
+  fun `queueInput clamps a 16-bit boost that exceeds full scale`() {
+    val proc = ReplayGainAudioProcessor()
+    proc.configure(int16Format(44100, 1))
+    proc.setLinearGain(2.0f)
+
+    // 20000*2 = 40000 > 32767 and -20000*2 = -40000 < -32768 both clamp.
+    val input = shortBuffer(shortArrayOf(20000, -20000, 1000))
+    proc.queueInput(input)
+
+    val output = readShorts(proc.output, 3)
+    assertEquals(32767, output[0].toInt())
+    assertEquals(-32768, output[1].toInt())
+    assertEquals(2000, output[2].toInt())
+  }
+
   @Test
   fun `queueInput consumes the input buffer`() {
     val proc = ReplayGainAudioProcessor()
@@ -137,5 +179,22 @@ class ReplayGainAudioProcessorTest {
     return out
   }
 
+  private fun shortBuffer(values: ShortArray): ByteBuffer {
+    val buffer = ByteBuffer
+      .allocateDirect(values.size * Short.SIZE_BYTES)
+      .order(ByteOrder.nativeOrder())
+    val asShort = buffer.asShortBuffer()
+    for (v in values) asShort.put(v)
+    buffer.position(0).limit(values.size * Short.SIZE_BYTES)
+    return buffer
+  }
+
+  private fun readShorts(buffer: ByteBuffer, count: Int): ShortArray {
+    val out = ShortArray(count)
+    val asShort = buffer.asShortBuffer()
+    for (i in 0 until count) out[i] = asShort.get()
+    return out
+  }
+
   // endregion
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-queue-player",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Nitro Modules audio playback library for React Native — gapless, EQ, crossfade, automotive, voice, casting",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/index.d.ts",
@@ -39,7 +39,11 @@
     "nitrogen": "nitrogen && bash scripts/strip-nitrogen-unused-let.sh",
     "typecheck": "tsc",
     "test": "jest",
-    "test:coverage": "jest --coverage"
+    "test:coverage": "jest --coverage",
+    "release:patch": "node scripts/release.mjs patch",
+    "release:minor": "node scripts/release.mjs minor",
+    "release:major": "node scripts/release.mjs major",
+    "publish:npm": "npm publish --access public"
   },
   "keywords": [
     "react-native",