1 files changed, 43 insertions, 17 deletions

diff --git a/dom/media/driftcontrol/gtest/TestAudioDriftCorrection.cpp b/dom/media/driftcontrol/gtest/TestAudioDriftCorrection.cpp
index c13f443d37..9d3f0f091a 100644
--- a/dom/media/driftcontrol/gtest/TestAudioDriftCorrection.cpp
+++ b/dom/media/driftcontrol/gtest/TestAudioDriftCorrection.cpp
@@ -260,10 +260,10 @@ TEST(TestAudioDriftCorrection, LargerTransmitterBlockSizeThanDesiredBuffering)
 
   // Input is stable so no corrections should occur.
   EXPECT_EQ(ad.NumCorrectionChanges(), 0U);
-  // The drift correction buffer size had to be larger than the desired (the
-  // buffer size is twice the initial buffering level), to accomodate the large
-  // input block size.
-  EXPECT_EQ(ad.BufferSize(), 9600U);
+  // The desired buffering and pre-buffering level was
+  // transmitterBlockSize * 11 / 10 to accomodate the large input block size.
+  // The buffer size was twice the pre-buffering level.
+  EXPECT_EQ(ad.BufferSize(), transmitterBlockSize * 11 / 10 * 2);
 }
 
 TEST(TestAudioDriftCorrection, LargerReceiverBlockSizeThanDesiredBuffering)
@@ -275,9 +275,9 @@ TEST(TestAudioDriftCorrection, LargerReceiverBlockSizeThanDesiredBuffering)
       MakePrincipalHandle(nsContentUtils::GetSystemPrincipal());
   AudioDriftCorrection ad(sampleRate, sampleRate, testPrincipal);
 
+  AudioSegment inSegment;
   for (uint32_t i = 0; i < (sampleRate / 1000) * 500;
        i += transmitterBlockSize) {
-    AudioSegment inSegment;
     AudioChunk chunk =
         CreateAudioChunk<float>(transmitterBlockSize, 1, AUDIO_FORMAT_FLOAT32);
     inSegment.AppendAndConsumeChunk(std::move(chunk));
@@ -285,6 +285,7 @@ TEST(TestAudioDriftCorrection, LargerReceiverBlockSizeThanDesiredBuffering)
     if (i % receiverBlockSize == 0) {
       AudioSegment outSegment = ad.RequestFrames(inSegment, receiverBlockSize);
       EXPECT_EQ(outSegment.GetDuration(), receiverBlockSize);
+      inSegment.Clear();
     }
 
     if (i >= receiverBlockSize) {
@@ -294,11 +295,12 @@ TEST(TestAudioDriftCorrection, LargerReceiverBlockSizeThanDesiredBuffering)
 
   // Input is stable so no corrections should occur.
   EXPECT_EQ(ad.NumCorrectionChanges(), 0U);
+  EXPECT_EQ(ad.NumUnderruns(), 0U);
   // The drift correction buffer size had to be larger than the desired (the
   // buffer size is twice the initial buffering level), to accomodate the large
   // input block size that gets buffered in the resampler only when processing
   // output.
-  EXPECT_EQ(ad.BufferSize(), 19200U);
+  EXPECT_EQ(ad.BufferSize(), 9600U);
 }
 
 TEST(TestAudioDriftCorrection, DynamicInputBufferSizeChanges)
@@ -329,9 +331,9 @@ TEST(TestAudioDriftCorrection, DynamicInputBufferSizeChanges)
       if (((receivedFramesStart - transmittedFramesStart + i) /
            aTransmitterBlockSize) > numBlocksTransmitted) {
         tone.Generate(inSegment, aTransmitterBlockSize);
-        MOZ_ASSERT(!inSegment.IsNull());
+        MOZ_RELEASE_ASSERT(!inSegment.IsNull());
         inToneVerifier.AppendData(inSegment);
-        MOZ_ASSERT(!inSegment.IsNull());
+        MOZ_RELEASE_ASSERT(!inSegment.IsNull());
         ++numBlocksTransmitted;
         totalFramesTransmitted += aTransmitterBlockSize;
       }
@@ -459,29 +461,50 @@ TEST(TestAudioDriftCorrection, DriftStepResponseUnderrunHighLatencyInput)
   constexpr uint32_t iterations = 200;
   const PrincipalHandle testPrincipal =
       MakePrincipalHandle(nsContentUtils::GetSystemPrincipal());
-  uint32_t inputRate = nominalRate * 1005 / 1000;  // 0.5% drift
-  uint32_t inputInterval = inputRate;
+  uint32_t inputRate1 = nominalRate * 1005 / 1000;  // 0.5% drift
+  uint32_t inputInterval1 = inputRate1;
   AudioGenerator<AudioDataValue> tone(1, nominalRate, 440);
   AudioDriftCorrection ad(nominalRate, nominalRate, testPrincipal);
   for (uint32_t i = 0; i < interval * iterations; i += interval / 100) {
     AudioSegment inSegment;
     if (i > 0 && i % interval == 0) {
-      tone.Generate(inSegment, inputInterval);
+      tone.Generate(inSegment, inputInterval1);
     }
     ad.RequestFrames(inSegment, interval / 100);
   }
 
-  inputRate = nominalRate * 995 / 1000;  // -0.5% drift
-  inputInterval = inputRate;
+  uint32_t inputRate2 = nominalRate * 995 / 1000;  // -0.5% drift
+  uint32_t inputInterval2 = inputRate2;
   for (uint32_t i = 0; i < interval * iterations; i += interval / 100) {
     AudioSegment inSegment;
+    // The first segment is skipped to cause an underrun.
     if (i > 0 && i % interval == 0) {
-      tone.Generate(inSegment, inputInterval);
+      tone.Generate(inSegment, inputInterval2);
     }
     ad.RequestFrames(inSegment, interval / 100);
+    if (i >= interval / 10 && i < interval) {
+      // While the DynamicResampler has not set its pre-buffer after the
+      // underrun, InFramesBuffered() reports the pre-buffer size.
+      // The initial desired buffer and pre-buffer size was
+      // inputInterval1 * 11 / 10 to accomodate the large input block size.
+      // This was doubled when the underrun occurred.
+      EXPECT_EQ(ad.CurrentBuffering(), inputInterval1 * 11 / 10 * 2)
+          << "for i=" << i;
+    } else if (i == interval) {
+      // After the pre-buffer was set and used to generate the first output
+      // block, the actual number of frames buffered almost matches the
+      // pre-buffer size, with some rounding from output to input frame count
+      // conversion.
+      EXPECT_EQ(ad.CurrentBuffering(), inputInterval1 * 11 / 10 * 2 - 1)
+          << "after first input after underrun";
+    }
   }
 
-  EXPECT_EQ(ad.BufferSize(), 220800U);
+  // The initial desired buffering and pre-buffering level was
+  // inputInterval1 * 11 / 10 to accomodate the large input block size.
+  // The buffer size was initially twice the pre-buffering level, and then
+  // doubled when the underrun occurred.
+  EXPECT_EQ(ad.BufferSize(), inputInterval1 * 11 / 10 * 2 * 2);
   EXPECT_EQ(ad.NumUnderruns(), 1u);
 }
 
@@ -511,7 +534,7 @@ TEST(TestAudioDriftCorrection, DriftStepResponseOverrun)
     ad.RequestFrames(inSegment, interval / 100);
   }
 
-  // Change input callbacks to 2000ms (+0.5% drift) = 48200 frames, which will
+  // Change input callbacks to 1000ms (+0.5% drift) = 48200 frames, which will
   // overrun the ring buffer.
   for (uint32_t i = 0; i < interval * iterations; i += interval / 100) {
     AudioSegment inSegment;
@@ -524,6 +547,9 @@ TEST(TestAudioDriftCorrection, DriftStepResponseOverrun)
     ad.RequestFrames(inSegment, interval / 100);
   }
 
-  EXPECT_EQ(ad.BufferSize(), 105600U);
+  // The desired buffering and pre-buffering levels were increased to
+  // inputInterval * 11 / 10 to accomodate the large input block size.
+  // The buffer size was increased to twice the pre-buffering level.
+  EXPECT_EQ(ad.BufferSize(), inputInterval * 11 / 10 * 2);
   EXPECT_EQ(ad.NumUnderruns(), 1u);
 }