react-native-queue-player 1.2.0 → 2.0.1

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

@@ -1,8 +1,10 @@
 package com.margelo.nitro.queueplayer
 
 import androidx.media3.common.C
+import androidx.media3.common.audio.AudioProcessingPipeline
 import androidx.media3.common.audio.AudioProcessor
 import androidx.media3.common.util.UnstableApi
+import com.google.common.collect.ImmutableList
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
 import org.junit.Assert.assertTrue
@@ -17,8 +19,9 @@ import java.nio.ByteOrder
  * 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.
+ * on both 16-bit and float PCM, the 16-bit full-scale clamp, the
+ * encoding gate, and the unity pass-through that keeps the processor in
+ * the [AudioProcessingPipeline] while it applies nothing.
  */
 @RunWith(RobolectricTestRunner::class)
 @Config(sdk = [34])
@@ -26,13 +29,21 @@ import java.nio.ByteOrder
 class ReplayGainAudioProcessorTest {
 
   @Test
-  fun `isActive is false at unity gain regardless of float configuration`() {
+  fun `isActive is true at unity gain on a Float32 input`() {
     val proc = ReplayGainAudioProcessor()
     proc.configure(floatFormat(48000, 2))
-    assertFalse(proc.isActive)
+    assertTrue(proc.isActive)
 
     proc.setLinearGain(1.0f)
-    assertFalse(proc.isActive)
+    assertTrue(proc.isActive)
+  }
+
+  @Test
+  fun `isActive is true at unity gain on a 16-bit input`() {
+    val proc = ReplayGainAudioProcessor()
+    proc.configure(int16Format(48000, 2))
+    proc.setLinearGain(1.0f)
+    assertTrue(proc.isActive)
   }
 
   @Test
@@ -51,6 +62,13 @@ class ReplayGainAudioProcessorTest {
     assertTrue(proc.isActive)
   }
 
+  @Test
+  fun `isActive is false before configure`() {
+    val proc = ReplayGainAudioProcessor()
+    proc.setLinearGain(0.5f)
+    assertFalse(proc.isActive)
+  }
+
   @Test
   fun `isActive is false on an unsupported encoding`() {
     val proc = ReplayGainAudioProcessor()
@@ -59,6 +77,88 @@ class ReplayGainAudioProcessorTest {
     assertFalse(proc.isActive)
   }
 
+  @Test
+  fun `queueInput at unity gain passes float samples through unchanged`() {
+    val proc = ReplayGainAudioProcessor()
+    proc.configure(floatFormat(48000, 1))
+    proc.setLinearGain(1.0f)
+
+    val input = floatBuffer(floatArrayOf(1.0f, 0.5f, -0.25f, 0.0f, -1.0f))
+    proc.queueInput(input)
+
+    val output = readFloats(proc.output, 5)
+    assertEquals(1.0f, output[0], 1e-6f)
+    assertEquals(0.5f, output[1], 1e-6f)
+    assertEquals(-0.25f, output[2], 1e-6f)
+    assertEquals(0.0f, output[3], 1e-6f)
+    assertEquals(-1.0f, output[4], 1e-6f)
+    assertEquals(0, input.remaining())
+  }
+
+  @Test
+  fun `queueInput at unity gain passes 16-bit samples through unchanged`() {
+    val proc = ReplayGainAudioProcessor()
+    proc.configure(int16Format(48000, 1))
+    proc.setLinearGain(1.0f)
+
+    val input = shortBuffer(shortArrayOf(32767, -32768, 10000, 0, -3))
+    proc.queueInput(input)
+
+    val output = readShorts(proc.output, 5)
+    assertEquals(32767, output[0].toInt())
+    assertEquals(-32768, output[1].toInt())
+    assertEquals(10000, output[2].toInt())
+    assertEquals(0, output[3].toInt())
+    assertEquals(-3, output[4].toInt())
+    assertEquals(0, input.remaining())
+  }
+
+  @Test
+  fun `a pipeline configured at unity gain stays operational`() {
+    val proc = ReplayGainAudioProcessor()
+    val pipeline = newPipeline(proc, int16Format(48000, 1))
+
+    assertTrue(
+      "the gain stage must stay in the active set so a later gain can reach the audio",
+      pipeline.isOperational
+    )
+  }
+
+  @Test
+  fun `a gain pushed after the pipeline is configured reaches the audio`() {
+    val proc = ReplayGainAudioProcessor()
+    // configure() + flush() is where Media3 fixes the active-processor set,
+    // and it runs at unity for a queue loaded while ReplayGain is off.
+    val pipeline = newPipeline(proc, int16Format(48000, 1))
+
+    // The gain arrives afterwards, as it does when the mode is selected
+    // mid-playback. Nothing reconfigures or flushes the sink.
+    proc.setLinearGain(0.5f)
+
+    val input = shortBuffer(shortArrayOf(10000, -8000, 4))
+    pipeline.queueInput(input)
+
+    assertTrue(pipeline.isOperational)
+    val output = drainShorts(pipeline, 3)
+    assertEquals(5000, output[0].toInt())
+    assertEquals(-4000, output[1].toInt())
+    assertEquals(2, output[2].toInt())
+  }
+
+  @Test
+  fun `a gain pushed then returned to unity stops reaching the audio`() {
+    val proc = ReplayGainAudioProcessor()
+    val pipeline = newPipeline(proc, int16Format(48000, 1))
+
+    proc.setLinearGain(0.5f)
+    pipeline.queueInput(shortBuffer(shortArrayOf(10000)))
+    assertEquals(5000, drainShorts(pipeline, 1)[0].toInt())
+
+    proc.setLinearGain(1.0f)
+    pipeline.queueInput(shortBuffer(shortArrayOf(10000)))
+    assertEquals(10000, drainShorts(pipeline, 1)[0].toInt())
+  }
+
   @Test
   fun `queueInput multiplies every sample by the linear gain in place`() {
     val proc = ReplayGainAudioProcessor()
@@ -156,6 +256,29 @@ class ReplayGainAudioProcessorTest {
 
   // region Helpers
 
+  /** A single-stage pipeline taken through Media3's configure-then-flush setup. */
+  private fun newPipeline(
+    proc: ReplayGainAudioProcessor,
+    format: AudioProcessor.AudioFormat,
+  ): AudioProcessingPipeline {
+    val pipeline = AudioProcessingPipeline(ImmutableList.of<AudioProcessor>(proc))
+    pipeline.configure(format)
+    pipeline.flush(AudioProcessor.StreamMetadata.DEFAULT)
+    return pipeline
+  }
+
+  /**
+   * Read [count] shorts of pipeline output and consume them the way
+   * `DefaultAudioSink` does — an undrained output buffer blocks the next
+   * [AudioProcessingPipeline.queueInput] from reaching the processors.
+   */
+  private fun drainShorts(pipeline: AudioProcessingPipeline, count: Int): ShortArray {
+    val buffer = pipeline.output
+    val values = readShorts(buffer, count)
+    buffer.position(buffer.position() + count * Short.SIZE_BYTES)
+    return values
+  }
+
   private fun floatFormat(sampleRate: Int, channelCount: Int) =
     AudioProcessor.AudioFormat(sampleRate, channelCount, C.ENCODING_PCM_FLOAT)
 

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

@@ -103,7 +103,7 @@ class ReplayGainExtractorTest {
 
   // endregion
 
-  // region parsePeak tolerance and encoder-default detection
+  // region parsePeak acceptance band
 
   @Test
   fun `parsePeak reads the standard linear format`() {
@@ -113,25 +113,40 @@ class ReplayGainExtractorTest {
   }
 
   @Test
-  fun `parsePeak rejects encoder defaults of exactly 1 and below 0_001`() {
-    assertNull(
-      "peak == exactly 1.0 means the analyser didn't run",
-      ReplayGainExtractor.parsePeak("1.000000"),
-    )
-    assertNull(
-      "peak == exactly 1.0 means the analyser didn't run",
-      ReplayGainExtractor.parsePeak("1"),
-    )
+  fun `parsePeak accepts a peak of exactly 1_0`() {
+    // 1.0 is the RG2 encoding of digital full scale — a real and
+    // common measurement for a modern master, and the value most in
+    // need of the 1/peak clip cap.
+    assertPeak("1.000000", 1.0f)
+    assertPeak("1", 1.0f)
+  }
+
+  @Test
+  fun `parsePeak accepts real measurements either side of unity`() {
+    assertPeak("0.923366", 0.923366f)
+    assertPeak("1.160082", 1.160082f)
+  }
+
+  @Test
+  fun `parsePeak accepts the 0_001 and 2_0 boundaries and rejects just outside them`() {
+    assertPeak("0.001", 0.001f)
+    assertPeak("2.0", 2.0f)
     assertNull(
-      "peak < 0.001 means encoder zero / no analysis",
-      ReplayGainExtractor.parsePeak("0.0001"),
+      "0.000999 is below the encoder-zero floor",
+      ReplayGainExtractor.parsePeak("0.000999"),
     )
     assertNull(
-      "peak == 0 means encoder zero",
-      ReplayGainExtractor.parsePeak("0"),
+      "2.000001 is an implausible true peak",
+      ReplayGainExtractor.parsePeak("2.000001"),
     )
   }
 
+  @Test
+  fun `parsePeak rejects peaks below 0_001`() {
+    assertNull(ReplayGainExtractor.parsePeak("0.0001"))
+    assertNull(ReplayGainExtractor.parsePeak("0"))
+  }
+
   @Test
   fun `parsePeak rejects values outside the 0-to-2 range`() {
     assertNull(ReplayGainExtractor.parsePeak("-0.5"))
@@ -148,6 +163,138 @@ class ReplayGainExtractorTest {
 
   // endregion
 
+  // region acceptPeak — the numeric entry point
+
+  @Test
+  fun `acceptPeak accepts full scale and the real-measurement band`() {
+    assertAcceptedPeak(1.0, 1.0f)
+    assertAcceptedPeak(0.923366, 0.923366f)
+    assertAcceptedPeak(1.160082, 1.160082f)
+    assertAcceptedPeak(0.5, 0.5f)
+  }
+
+  @Test
+  fun `acceptPeak accepts the 0_001 and 2_0 boundaries and rejects just outside them`() {
+    assertAcceptedPeak(0.001, 0.001f)
+    assertAcceptedPeak(2.0, 2.0f)
+    assertNull("0.000999 is below the encoder-zero floor", ReplayGainExtractor.acceptPeak(0.000999))
+    assertNull("2.000001 is an implausible true peak", ReplayGainExtractor.acceptPeak(2.000001))
+    assertNull(ReplayGainExtractor.acceptPeak(0.0))
+    assertNull(ReplayGainExtractor.acceptPeak(-0.5))
+    assertNull(ReplayGainExtractor.acceptPeak(3.0))
+  }
+
+  @Test
+  fun `acceptPeak rejects a value above 2_0 that narrows to 2_0 as a Float`() {
+    // 2.0000001 is inside half a Float ulp of 2.0, so a range check
+    // applied after the Double -> Float narrowing sees 2.0f and lets
+    // it through. The 2.0 case is the positive control: this test
+    // must not be satisfiable by rejecting everything.
+    assertAcceptedPeak(2.0, 2.0f)
+    assertNull(ReplayGainExtractor.acceptPeak(2.0000001))
+  }
+
+  @Test
+  fun `acceptPeak rejects non-finite input`() {
+    assertAcceptedPeak(1.0, 1.0f)
+    assertNull(ReplayGainExtractor.acceptPeak(Double.NaN))
+    assertNull(ReplayGainExtractor.acceptPeak(Double.POSITIVE_INFINITY))
+    assertNull(ReplayGainExtractor.acceptPeak(Double.NEGATIVE_INFINITY))
+  }
+
+  // endregion
+
+  // region acceptGainDb — the numeric entry point
+
+  @Test
+  fun `acceptGainDb accepts every finite value with no plausibility band`() {
+    assertAcceptedGain(-20.0, -20.0f)
+    assertAcceptedGain(-6.54, -6.54f)
+    assertAcceptedGain(0.0, 0.0f)
+    assertAcceptedGain(6.0, 6.0f)
+    assertAcceptedGain(3.21, 3.21f)
+    // Physically absurd, still accepted — gain carries no range guard;
+    // clip safety is the clamp's job, not the acceptor's.
+    assertAcceptedGain(100.0, 100.0f)
+    assertAcceptedGain(-100.0, -100.0f)
+  }
+
+  @Test
+  fun `acceptGainDb rejects non-finite input`() {
+    assertAcceptedGain(-20.0, -20.0f)
+    assertNull(ReplayGainExtractor.acceptGainDb(Double.NaN))
+    assertNull(ReplayGainExtractor.acceptGainDb(Double.POSITIVE_INFINITY))
+    assertNull(ReplayGainExtractor.acceptGainDb(Double.NEGATIVE_INFINITY))
+  }
+
+  @Test
+  fun `acceptGainDb rejects a magnitude that narrows to Float infinity`() {
+    // Finite as a Double, infinite as a Float — the returned value has
+    // to be finite, so the check belongs after the narrowing.
+    assertAcceptedGain(-20.0, -20.0f)
+    assertNull(ReplayGainExtractor.acceptGainDb(1e40))
+    assertNull(ReplayGainExtractor.acceptGainDb(-1e40))
+  }
+
+  // endregion
+
+  // region String and numeric entry points share one rule
+
+  @Test
+  fun `parsePeak and acceptPeak agree on every value in the peak acceptance table`() {
+    val table = listOf(
+      "1.000000" to 1.0,
+      "1" to 1.0,
+      "0.923366" to 0.923366,
+      "1.160082" to 1.160082,
+      "0.5" to 0.5,
+      "2.0" to 2.0,
+      "2.000001" to 2.000001,
+      "0.001" to 0.001,
+      "0.000999" to 0.000999,
+      "0" to 0.0,
+      "-0.5" to -0.5,
+      "3.0" to 3.0,
+      "nan" to Double.NaN,
+      "inf" to Double.POSITIVE_INFINITY,
+      "-inf" to Double.NEGATIVE_INFINITY,
+    )
+    for ((raw, numeric) in table) {
+      assertSamePeakVerdict(raw, numeric)
+    }
+  }
+
+  @Test
+  fun `parseGainDb and acceptGainDb agree on every value in the gain acceptance table`() {
+    val table = listOf(
+      "-20.00 dB" to -20.0,
+      "-6.54" to -6.54,
+      "+3.21 dB" to 3.21,
+      "0.00 dB" to 0.0,
+      "100.0" to 100.0,
+      "-100.0" to -100.0,
+      "nan dB" to Double.NaN,
+      "inf" to Double.POSITIVE_INFINITY,
+      "-inf" to Double.NEGATIVE_INFINITY,
+    )
+    for ((raw, numeric) in table) {
+      assertSameGainVerdict(raw, numeric)
+    }
+  }
+
+  @Test
+  fun `comma decimals reject on the string path while the numeric path accepts the value`() {
+    // The period-decimal rule is a property of RG2 text, not of the
+    // number — so it lives in the string parser and the numeric
+    // acceptor takes the same value happily.
+    assertNull(ReplayGainExtractor.parsePeak("0,5"))
+    assertAcceptedPeak(0.5, 0.5f)
+    assertNull(ReplayGainExtractor.parseGainDb("-6,54 dB"))
+    assertAcceptedGain(-6.54, -6.54f)
+  }
+
+  // endregion
+
   // region canonicalKeyForName mapping
 
   @Test
@@ -450,6 +597,54 @@ class ReplayGainExtractorTest {
     assertEquals(expected, actual!!, accuracy)
   }
 
+  private fun assertAcceptedPeak(value: Double, expected: Float, accuracy: Float = 0.0001f) {
+    val actual = ReplayGainExtractor.acceptPeak(value)
+    assertNotNull("expected acceptPeak($value) to succeed", actual)
+    assertEquals(expected, actual!!, accuracy)
+  }
+
+  private fun assertAcceptedGain(value: Double, expected: Float, accuracy: Float = 0.001f) {
+    val actual = ReplayGainExtractor.acceptGainDb(value)
+    assertNotNull("expected acceptGainDb($value) to succeed", actual)
+    assertEquals(expected, actual!!, accuracy)
+  }
+
+  private fun assertSamePeakVerdict(raw: String, numeric: Double) {
+    val fromString = ReplayGainExtractor.parsePeak(raw)
+    val fromNumeric = ReplayGainExtractor.acceptPeak(numeric)
+    assertEquals(
+      "parsePeak('$raw') and acceptPeak($numeric) must agree on acceptance",
+      fromString == null,
+      fromNumeric == null,
+    )
+    if (fromString != null && fromNumeric != null) {
+      assertEquals(
+        "parsePeak('$raw') and acceptPeak($numeric) must agree on value",
+        fromString,
+        fromNumeric,
+        0.0001f,
+      )
+    }
+  }
+
+  private fun assertSameGainVerdict(raw: String, numeric: Double) {
+    val fromString = ReplayGainExtractor.parseGainDb(raw)
+    val fromNumeric = ReplayGainExtractor.acceptGainDb(numeric)
+    assertEquals(
+      "parseGainDb('$raw') and acceptGainDb($numeric) must agree on acceptance",
+      fromString == null,
+      fromNumeric == null,
+    )
+    if (fromString != null && fromNumeric != null) {
+      assertEquals(
+        "parseGainDb('$raw') and acceptGainDb($numeric) must agree on value",
+        fromString,
+        fromNumeric,
+        0.001f,
+      )
+    }
+  }
+
   private fun txxx(description: String, value: String): TextInformationFrame =
     TextInformationFrame(
       /* id = */ "TXXX",

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

@@ -94,30 +94,170 @@ class ReplayGainGainTest {
   }
 
   @Test
-  fun `peak equal to 1 bypasses cap (encoder-default sentinel)`() {
-    // The extractor already strips peak == 1.0; defending the math in
-    // case any other code path produces such a ReplayGainData. With
-    // +6 dB raw ≈ 1.995 and peak == 1.0, 1/peak == 1.0 would clamp
-    // raw to 1.0 — but the contract is "peak == 1.0 means no useful
-    // peak data", so the cap is bypassed.
+  fun `a full-scale peak caps the boost at unity`() {
+    // 1.0 is digital full scale, so 1/peak == 1.0 and a +6 dB boost
+    // (raw ≈ 1.995) has nowhere to go: any boost on a full-scale
+    // master clips. The cap binds to exactly unity.
     val data = ReplayGainData(
       trackGainDb = 6.0f,
       trackPeak = 1.0f,
       albumGainDb = null,
       albumPeak = null,
     )
-    assertEquals(lin(6.0), computeLinearGain(data, ReplayGainMode.TRACK), 1e-6f)
+    assertEquals(1.0f, computeLinearGain(data, ReplayGainMode.TRACK), 1e-6f)
   }
 
   @Test
-  fun `peak below 0_001 bypasses cap (encoder-zero sentinel)`() {
+  fun `a full-scale peak leaves attenuation alone`() {
+    // -20 dB raw = 0.100, well under the 1.0 cap — the cap is present
+    // and simply does not bind. Attenuation can never clip.
+    val data = ReplayGainData(
+      trackGainDb = -20.0f,
+      trackPeak = 1.0f,
+      albumGainDb = null,
+      albumPeak = null,
+    )
+    assertEquals(lin(-20.0), computeLinearGain(data, ReplayGainMode.TRACK), 1e-6f)
+  }
+
+  @Test
+  fun `an unusable peak clamps the boost to unity`() {
+    // A peak below 0.001 carries no usable measurement, and a peak
+    // cannot be derived from a gain — so boost is suppressed rather
+    // than run uncapped.
+    for (peak in listOf(0.0005f, 0.0001f)) {
+      val data = ReplayGainData(
+        trackGainDb = 6.0f,
+        trackPeak = peak,
+        albumGainDb = null,
+        albumPeak = null,
+      )
+      assertEquals(
+        "peak $peak carries no usable measurement",
+        1.0f,
+        computeLinearGain(data, ReplayGainMode.TRACK),
+        1e-6f,
+      )
+    }
+  }
+
+  @Test
+  fun `no peak at all clamps the boost to unity`() {
     val data = ReplayGainData(
       trackGainDb = 6.0f,
-      trackPeak = 0.0001f,
+      trackPeak = null,
       albumGainDb = null,
       albumPeak = null,
     )
-    assertEquals(lin(6.0), computeLinearGain(data, ReplayGainMode.TRACK), 1e-6f)
+    assertEquals(1.0f, computeLinearGain(data, ReplayGainMode.TRACK), 1e-6f)
+  }
+
+  @Test
+  fun `no peak at all leaves attenuation untouched`() {
+    // The positive half of the clamp: the boost suppression must not
+    // become a blanket clamp that also flattens cuts.
+    val data = ReplayGainData(
+      trackGainDb = -20.0f,
+      trackPeak = null,
+      albumGainDb = null,
+      albumPeak = null,
+    )
+    assertEquals(lin(-20.0), computeLinearGain(data, ReplayGainMode.TRACK), 1e-6f)
+  }
+
+  @Test
+  fun `a zero gain with no peak stays at unity`() {
+    val data = ReplayGainData(
+      trackGainDb = 0.0f,
+      trackPeak = null,
+      albumGainDb = null,
+      albumPeak = null,
+    )
+    assertEquals(1.0f, computeLinearGain(data, ReplayGainMode.TRACK), 1e-6f)
+  }
+
+  @Test
+  fun `a peak with headroom lets the full boost through`() {
+    // The positive control for the clamp rows above: peak 0.5 gives
+    // 1/peak = 2.0, so +6 dB (≈ 1.9953) fits underneath and is applied
+    // in full. Without this, "expect 1.000" everywhere is satisfied by
+    // an implementation that applies nothing at all.
+    val data = ReplayGainData(
+      trackGainDb = 6.0f,
+      trackPeak = 0.5f,
+      albumGainDb = null,
+      albumPeak = null,
+    )
+    assertEquals(1.9953f, computeLinearGain(data, ReplayGainMode.TRACK), 1e-4f)
+  }
+
+  @Test
+  fun `a boost beyond the headroom is capped at 1 over peak`() {
+    // +12 dB raw ≈ 3.981; peak 0.5 → 1/peak = 2.0 — cap binds.
+    val data = ReplayGainData(
+      trackGainDb = 12.0f,
+      trackPeak = 0.5f,
+      albumGainDb = null,
+      albumPeak = null,
+    )
+    assertEquals(2.0f, computeLinearGain(data, ReplayGainMode.TRACK), 1e-6f)
+  }
+
+  @Test
+  fun `a true peak above unity caps the boost below unity`() {
+    // Peaks above 1.0 are ordinary true-peak measurements: 1/1.16 =
+    // 0.862, so a +6 dB boost ends up as an attenuation.
+    val data = ReplayGainData(
+      trackGainDb = 6.0f,
+      trackPeak = 1.16f,
+      albumGainDb = null,
+      albumPeak = null,
+    )
+    assertEquals(1.0f / 1.16f, computeLinearGain(data, ReplayGainMode.TRACK), 1e-4f)
+  }
+
+  @Test
+  fun `the clip cap applies in album mode as well as track mode`() {
+    // Wiring the cap on the track pair alone passes every row above.
+    val noPeak = ReplayGainData(
+      trackGainDb = null,
+      trackPeak = null,
+      albumGainDb = 6.0f,
+      albumPeak = null,
+    )
+    assertEquals(
+      "album mode with no album peak clamps the boost to unity",
+      1.0f,
+      computeLinearGain(noPeak, ReplayGainMode.ALBUM),
+      1e-6f,
+    )
+    val fullScale = ReplayGainData(
+      trackGainDb = null,
+      trackPeak = null,
+      albumGainDb = 6.0f,
+      albumPeak = 1.0f,
+    )
+    assertEquals(
+      "album mode with a full-scale album peak caps the boost at unity",
+      1.0f,
+      computeLinearGain(fullScale, ReplayGainMode.ALBUM),
+      1e-6f,
+    )
+  }
+
+  @Test
+  fun `each mode caps against its own peak`() {
+    // Same gain in both modes, different peaks — the applied value has
+    // to differ, which shows the cap reads the selected pair's peak
+    // rather than whichever peak the data happens to carry.
+    val data = ReplayGainData(
+      trackGainDb = 6.0f,
+      trackPeak = 0.5f,
+      albumGainDb = 6.0f,
+      albumPeak = 1.16f,
+    )
+    assertEquals(1.9953f, computeLinearGain(data, ReplayGainMode.TRACK), 1e-4f)
+    assertEquals(1.0f / 1.16f, computeLinearGain(data, ReplayGainMode.ALBUM), 1e-4f)
   }
 
   @Test