Fix truncation error acumulation for Sonic's resampling algorithm

Sonic would accumulate truncation errors on float to int conversions
that caused the final output sample count to drift noticeably, by
hundreds of samples on streams of a few minutes of length. The fix now
keeps track of the truncation error and compensates for it.

Other small fixes include eliminating lossy operations (e.g. int
division) and using doubles instead of floats for resampling where
helpful.

This CL also introduces `SonicParameterizedTest`, which helps test
resampling on an arbitrary number of randomly generated parameters,
with random sample data. `SonicParameterizedTest` uses `BigDecimal`s
for calculating sample count values, as to avoid precision issues with
large sample counts.

PiperOrigin-RevId: 673852768

Author: ivanbuper

RELEASENOTES.md

@@ -18,6 +18,8 @@
         ([#1659](https://github.com/google/ExoPlayer/issues/1659)).
 *   DataSource:
 *   Audio:
+    *   Fix truncation error acumulation for `Sonic`'s resampling algorithm to
+        prevent drift on number of output samples.
 *   Video:
 *   Text:
 *   Metadata:

libraries/common/src/main/java/androidx/media3/common/audio/Sonic.java

@@ -38,7 +38,7 @@
   private final int channelCount;
   private final float speed;
   private final float pitch;
-  private final float rate;
+  private final double rate;
   private final int minPeriod;
   private final int maxPeriod;
   private final int maxRequiredFrameCount;
@@ -57,6 +57,7 @@
   private int prevMinDiff;
   private int minDiff;
   private int maxDiff;
+  private double accumulatedInterpolationError;
 
   /**
    * Creates a new Sonic audio stream processor.
@@ -73,7 +74,7 @@ public Sonic(
     this.channelCount = channelCount;
     this.speed = speed;
     this.pitch = pitch;
-    rate = (float) inputSampleRateHz / outputSampleRateHz;
+    rate = (double) inputSampleRateHz / outputSampleRateHz;
     minPeriod = inputSampleRateHz / MAXIMUM_PITCH;
     maxPeriod = inputSampleRateHz / MINIMUM_PITCH;
     maxRequiredFrameCount = 2 * maxPeriod;
@@ -130,10 +131,20 @@ public void getOutput(ShortBuffer buffer) {
    */
   public void queueEndOfStream() {
     int remainingFrameCount = inputFrameCount;
+
     float s = speed / pitch;
-    float r = rate * pitch;
+    double r = rate * pitch;
+
+    // Math.round(double) returns a long, but we can safely cast from long to int because the only
+    // double (accumulatedInterpolationError) always has a value between (-0.5 ; 0.5).
     int expectedOutputFrames =
-        outputFrameCount + (int) ((remainingFrameCount / s + pitchFrameCount) / r + 0.5f);
+        outputFrameCount
+            + (int)
+                Math.round(
+                    ((remainingFrameCount / s + pitchFrameCount) / r
+                        + accumulatedInterpolationError));
+
+    accumulatedInterpolationError = 0;
 
     // Add enough silence to flush both input and pitch buffers.
     inputBuffer =
@@ -144,10 +155,12 @@ public void queueEndOfStream() {
     }
     inputFrameCount += 2 * maxRequiredFrameCount;
     processStreamInput();
+
     // Throw away any extra frames we generated due to the silence we added.
     if (outputFrameCount > expectedOutputFrames) {
       outputFrameCount = expectedOutputFrames;
     }
+
     // Empty input and pitch buffers.
     inputFrameCount = 0;
     remainingInputToCopyFrameCount = 0;
@@ -166,6 +179,7 @@ public void flush() {
     prevMinDiff = 0;
     minDiff = 0;
     maxDiff = 0;
+    accumulatedInterpolationError = 0;
   }
 
   /** Returns the size of output that can be read with {@link #getOutput(ShortBuffer)}, in bytes. */
@@ -366,20 +380,35 @@ private short interpolate(short[] in, int inPos, int oldSampleRate, int newSampl
     return (short) ((ratio * left + (width - ratio) * right) / width);
   }
 
-  private void adjustRate(float rate, int originalOutputFrameCount) {
+  private void adjustRate(double rate, int originalOutputFrameCount) {
+    // If no new samples added to output buffer, then return.
     if (outputFrameCount == originalOutputFrameCount) {
       return;
     }
-    int newSampleRate = (int) (inputSampleRateHz / rate);
-    int oldSampleRate = inputSampleRateHz;
-    // Set these values to help with the integer math.
-    while (newSampleRate > (1 << 14) || oldSampleRate > (1 << 14)) {
+
+    // Move samples to pitch buffer first to calculate the block size.
+    moveNewSamplesToPitchBuffer(originalOutputFrameCount);
+    // Leave at least one pitch sample in the buffer.
+    int blockSize = pitchFrameCount - 1;
+    double expectedFrameCount = blockSize / rate + accumulatedInterpolationError;
+    // We can safely cast from long to int because accumulatedInterpolationError is always between
+    // (-0.5 ; 0.5), blockSize should always receive a reasonable buffer size (e.g. 1024 frames),
+    // and we can assume that rate will not involve infinitesimally small values under normal
+    // operation.
+    int newSampleRate = (int) Math.round(expectedFrameCount);
+    accumulatedInterpolationError = expectedFrameCount - newSampleRate;
+    int oldSampleRate = blockSize;
+
+    // Simplify ratio for interpolation.
+    while (newSampleRate != 0
+        && oldSampleRate != 0
+        && newSampleRate % 2 == 0
+        && oldSampleRate % 2 == 0) {
       newSampleRate /= 2;
       oldSampleRate /= 2;
     }
-    moveNewSamplesToPitchBuffer(originalOutputFrameCount);
-    // Leave at least one pitch sample in the buffer.
-    for (int position = 0; position < pitchFrameCount - 1; position++) {
+
+    for (int position = 0; position < blockSize; position++) {
       while ((oldRatePosition + 1) * newSampleRate > newRatePosition * oldSampleRate) {
         outputBuffer =
             ensureSpaceForAdditionalFrames(
@@ -398,7 +427,7 @@ private void adjustRate(float rate, int originalOutputFrameCount) {
         newRatePosition = 0;
       }
     }
-    removePitchFrames(pitchFrameCount - 1);
+    removePitchFrames(blockSize);
   }
 
   private int skipPitchPeriod(short[] samples, int position, float speed, int period) {
@@ -479,14 +508,14 @@ private void processStreamInput() {
     // Resample as many pitch periods as we have buffered on the input.
     int originalOutputFrameCount = outputFrameCount;
     float s = speed / pitch;
-    float r = rate * pitch;
+    double r = rate * pitch;
     if (s > 1.00001 || s < 0.99999) {
       changeSpeed(s);
     } else {
       copyToOutput(inputBuffer, 0, inputFrameCount);
       inputFrameCount = 0;
     }
-    if (r != 1.0f) {
+    if (r != 1.0) {
       adjustRate(r, originalOutputFrameCount);
     }
   }

libraries/common/src/test/java/androidx/media3/common/audio/RandomParameterizedSonicTest.java

@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.media3.common.audio;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Range;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.nio.ByteBuffer;
+import java.nio.ShortBuffer;
+import java.util.Random;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.ParameterizedRobolectricTestRunner;
+import org.robolectric.ParameterizedRobolectricTestRunner.Parameter;
+import org.robolectric.ParameterizedRobolectricTestRunner.Parameters;
+
+/** Parameterized robolectric test for testing {@link Sonic}. */
+@RunWith(ParameterizedRobolectricTestRunner.class)
+public final class RandomParameterizedSonicTest {
+
+  private static final int BLOCK_SIZE = 4096;
+  private static final int BYTES_PER_SAMPLE = 2;
+  private static final int SAMPLE_RATE = 48000;
+  // Max 10 min streams.
+  private static final long MAX_LENGTH_SAMPLES = 10 * 60 * SAMPLE_RATE;
+  // How many instances per parameter to generate.
+  private static final int PARAM_COUNT = 5;
+  private static final int SPEED_DECIMAL_PRECISION = 2;
+  private static final ImmutableList<Range<Float>> SPEED_RANGES =
+      ImmutableList.of(
+          Range.closedOpen(0f, 1f), Range.closedOpen(1f, 2f), Range.closedOpen(2f, 20f));
+
+  private static final Random random = new Random(/* seed */ 0);
+
+  private static final ImmutableList<Object[]> sParams = initParams();
+
+  @Parameters(name = "speed={0}, streamLength={1}")
+  public static ImmutableList<Object[]> params() {
+    // params() is called multiple times, so return cached parameters to avoid regenerating
+    // different random parameter values.
+    return sParams;
+  }
+
+  private static ImmutableList<Object[]> initParams() {
+    ImmutableSet.Builder<Object[]> paramsBuilder = new ImmutableSet.Builder<>();
+    ImmutableSet.Builder<Float> speedsBuilder = new ImmutableSet.Builder<>();
+
+    for (int i = 0; i < PARAM_COUNT; i++) {
+      Range<Float> r = SPEED_RANGES.get(i % SPEED_RANGES.size());
+      speedsBuilder.add(round(generateFloatInRange(r)));
+    }
+    ImmutableSet<Float> speeds = speedsBuilder.build();
+
+    ImmutableSet<Long> lengths =
+        new ImmutableSet.Builder<Long>()
+            .addAll(
+                random
+                    .longs(/* min */ 0, MAX_LENGTH_SAMPLES)
+                    .distinct()
+                    .limit(PARAM_COUNT)
+                    .iterator())
+            .build();
+    for (long length : lengths) {
+      for (float speed : speeds) {
+        paramsBuilder.add(new Object[] {speed, length});
+      }
+    }
+    return paramsBuilder.build().asList();
+  }
+
+  @Parameter(0)
+  public float speed;
+
+  @Parameter(1)
+  public long streamLength;
+
+  @Test
+  public void resampling_returnsExpectedNumberOfSamples() {
+    byte[] buf = new byte[BLOCK_SIZE * BYTES_PER_SAMPLE];
+    ShortBuffer outBuffer = ShortBuffer.allocate(BLOCK_SIZE);
+    // Use same speed and pitch values for Sonic to resample stream.
+    Sonic sonic =
+        new Sonic(
+            /* inputSampleRateHz= */ SAMPLE_RATE,
+            /* channelCount= */ 1,
+            /* speed= */ speed,
+            /* pitch= */ speed,
+            /* outputSampleRateHz= */ SAMPLE_RATE);
+    long readSampleCount = 0;
+
+    for (long samplesLeft = streamLength; samplesLeft > 0; samplesLeft -= BLOCK_SIZE) {
+      random.nextBytes(buf);
+      if (samplesLeft >= BLOCK_SIZE) {
+        sonic.queueInput(ByteBuffer.wrap(buf).asShortBuffer());
+      } else {
+        sonic.queueInput(
+            ByteBuffer.wrap(buf, 0, (int) (samplesLeft * BYTES_PER_SAMPLE)).asShortBuffer());
+        sonic.queueEndOfStream();
+      }
+      while (sonic.getOutputSize() > 0) {
+        sonic.getOutput(outBuffer);
+        readSampleCount += outBuffer.position();
+        outBuffer.clear();
+      }
+    }
+    sonic.flush();
+
+    BigDecimal bigSpeed = new BigDecimal(String.valueOf(speed));
+    BigDecimal bigLength = new BigDecimal(String.valueOf(streamLength));
+    // The scale of expectedSize will always be equal to bigLength. Thus, the result will always
+    // yield an integer.
+    BigDecimal expectedSize = bigLength.divide(bigSpeed, RoundingMode.HALF_EVEN);
+    assertThat(readSampleCount).isWithin(1).of(expectedSize.longValueExact());
+  }
+
+  private static float round(float num) {
+    BigDecimal bigDecimal = new BigDecimal(Float.toString(num));
+    return bigDecimal.setScale(SPEED_DECIMAL_PRECISION, RoundingMode.HALF_EVEN).floatValue();
+  }
+
+  private static float generateFloatInRange(Range<Float> r) {
+    return r.lowerEndpoint() + random.nextFloat() * (r.upperEndpoint() - r.lowerEndpoint());
+  }
+}