src/media/audio/audio_core/mixer/position_manager_unittest.cc - fuchsia - Git at Google

 // Copyright 2019 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.

 #include "src/media/audio/audio_core/mixer/position_manager.h"

 #include <iterator>

 #include <fbl/algorithm.h>
 #include <gtest/gtest.h>

 namespace media::audio::mixer {
 namespace {

 constexpr int64_t kFracFrame = kOneFrame.raw_value();
 constexpr int64_t kFracHalfFrame = kFracFrame / 2;

 // Produce the frame pointer (in source format) for the first frame in the source buffer.
 TEST(PositionManagerTest, FirstSourceFrame) {
   auto source_chans = 2u;
   mixer::PositionManager pos_mgr(source_chans, 2u, 1, 1);

   int64_t source_frames = 5;

   // Setting this to any non-nullptr value
   void* source_void_ptr = static_cast<void*>(&source_frames);

   auto source_offset = Fixed(3);

   pos_mgr.SetSourceValues(source_void_ptr, source_frames, &source_offset);

   uint8_t* expected_source_frame_u8 = static_cast<uint8_t*>(source_void_ptr);
   int16_t* expected_source_frame_16 = static_cast<int16_t*>(source_void_ptr);
   int32_t* expected_source_frame_32 = static_cast<int32_t*>(source_void_ptr);
   float* expected_source_frame_float = static_cast<float*>(source_void_ptr);

   EXPECT_EQ(pos_mgr.FirstSourceFrame<uint8_t>(), expected_source_frame_u8);
   EXPECT_EQ(pos_mgr.FirstSourceFrame<int16_t>(), expected_source_frame_16);
   EXPECT_EQ(pos_mgr.FirstSourceFrame<int32_t>(), expected_source_frame_32);
   EXPECT_EQ(pos_mgr.FirstSourceFrame<float>(), expected_source_frame_float);
 }

 // Produce the frame pointer (in source format) for the last frame in the source buffer.
 TEST(PositionManagerTest, LastSourceFrame) {
   constexpr auto source_chans = 3u;
   mixer::PositionManager pos_mgr(source_chans, 2u, 1, 1);

   constexpr int64_t source_frames = 5;

   float source[source_chans * source_frames];
   const auto source_void = static_cast<void*>(source);

   auto source_offset = Fixed(1);

   pos_mgr.SetSourceValues(source_void, source_frames, &source_offset);

   auto sample_num_of_last_frame = source_chans * (source_frames - 1);
   uint8_t* expected_source_frame_u8 = static_cast<uint8_t*>(source_void) + sample_num_of_last_frame;
   int16_t* expected_source_frame_16 = static_cast<int16_t*>(source_void) + sample_num_of_last_frame;
   int32_t* expected_source_frame_32 = static_cast<int32_t*>(source_void) + sample_num_of_last_frame;
   float* expected_source_frame_float = static_cast<float*>(source_void) + sample_num_of_last_frame;

   EXPECT_EQ(pos_mgr.LastSourceFrame<uint8_t>(), expected_source_frame_u8);
   EXPECT_EQ(pos_mgr.LastSourceFrame<int16_t>(), expected_source_frame_16);
   EXPECT_EQ(pos_mgr.LastSourceFrame<int32_t>(), expected_source_frame_32);
   EXPECT_EQ(pos_mgr.LastSourceFrame<float>(), expected_source_frame_float);
 }

 // Produce the frame pointer (in source format) corresponding with the current source offset
 // This should take into account both source format container size and num source channels.
 TEST(PositionManagerTest, CurrentSourceFrame) {
   constexpr auto source_chans = 2u;
   constexpr auto dest_chans = 1u;
   mixer::PositionManager pos_mgr(source_chans, dest_chans, 1, kFracFrame);

   constexpr int64_t source_frames = 2;

   int16_t source[source_frames * source_chans];
   auto source_void = static_cast<void*>(source);

   auto source_start = 1;
   auto source_offset = Fixed(source_start);

   pos_mgr.SetSourceValues(source_void, source_frames, &source_offset);

   auto expected_source_frame = source + (source_start * source_chans);
   EXPECT_EQ(pos_mgr.CurrentSourceFrame<int16_t>(), expected_source_frame);
   EXPECT_FALSE(pos_mgr.SourceIsConsumed());

   auto expected_source_frame_u8 =
       reinterpret_cast<uint8_t*>(source_void) + (source_start * source_chans);
   EXPECT_EQ(pos_mgr.CurrentSourceFrame<uint8_t>(), expected_source_frame_u8);

   auto expected_source_frame_32 =
       reinterpret_cast<int32_t*>(source_void) + (source_start * source_chans);
   EXPECT_EQ(pos_mgr.CurrentSourceFrame<int32_t>(), expected_source_frame_32);

   auto expected_source_frame_float =
       reinterpret_cast<float*>(source_void) + (source_start * source_chans);
   EXPECT_EQ(pos_mgr.CurrentSourceFrame<float>(), expected_source_frame_float);

   source_start = 0;
   source_offset = Fixed(source_start);
   pos_mgr.SetSourceValues(source_void, source_frames, &source_offset);

   expected_source_frame = source + (source_start * source_chans);
   EXPECT_EQ(pos_mgr.CurrentSourceFrame<int16_t>(), expected_source_frame);
   EXPECT_FALSE(pos_mgr.SourceIsConsumed());
 }

 // Produce the frame pointer (float*) corresponding with the current destination offset
 // This should take into account the number of destination channels.
 TEST(PositionManagerTest, CurrentDestFrame) {
   constexpr auto source_chans = 1u;
   constexpr auto dest_chans = 4u;
   mixer::PositionManager pos_mgr(source_chans, dest_chans, 1, kFracFrame);

   constexpr auto dest_frames = 2;
   float dest[dest_frames * dest_chans];
   int64_t dest_offset = 1;

   auto expected_dest_frame = dest + (dest_offset * dest_chans);
   pos_mgr.SetDestValues(dest, dest_frames, &dest_offset);

   EXPECT_EQ(pos_mgr.CurrentDestFrame(), expected_dest_frame);

   dest_offset = 0;
   expected_dest_frame = dest + (dest_offset * dest_chans);
   pos_mgr.SetDestValues(dest, dest_frames, &dest_offset);

   EXPECT_EQ(pos_mgr.CurrentDestFrame(), expected_dest_frame);
 }

 // Write back the latest values of source offset, dest offset, and source modulo.
 // This should overwrite existing values at those locations, and include effects of advances.
 TEST(PositionManagerTest, UpdateOffsets) {
   mixer::PositionManager pos_mgr(1, 1, 1, kFracFrame);

   float input;
   void* source_void_ptr = static_cast<void*>(&input);
   constexpr int64_t source_frames = 1;
   auto source_offset = Fixed(0);
   pos_mgr.SetSourceValues(source_void_ptr, source_frames, &source_offset);

   float data;
   float* dest = &data;
   auto dest_frames = 1;
   int64_t dest_offset = 0;
   pos_mgr.SetDestValues(dest, dest_frames, &dest_offset);

   auto step_size = kFracFrame;
   auto rate_modulo = 0ul;
   auto denominator = 1ul;
   auto source_position_modulo = 0ul;
   pos_mgr.SetRateValues(step_size, rate_modulo, denominator, &source_position_modulo);

   source_offset = Fixed::FromRaw(27);
   dest_offset = 42;
   source_position_modulo = 72;
   pos_mgr.UpdateOffsets();

   EXPECT_EQ(source_offset, Fixed(0));
   EXPECT_EQ(dest_offset, 0);
   EXPECT_EQ(source_position_modulo, 72ul);

   // Now that rate_modulo and denominator are non-zero, source_position_modulo should be updated
   rate_modulo = 1ul;
   denominator = 2ul;
   source_position_modulo = 0;
   pos_mgr.SetRateValues(step_size, rate_modulo, denominator, &source_position_modulo);

   source_offset = Fixed::FromRaw(27);
   dest_offset = 42;
   source_position_modulo = 72;
   pos_mgr.UpdateOffsets();

   EXPECT_EQ(source_offset, Fixed(0));
   EXPECT_EQ(dest_offset, 0);
   EXPECT_EQ(source_position_modulo, 0ul);
 }

 TEST(PositionManagerTest, FrameCanBeMixed) {
   constexpr auto source_chans = 1u;
   constexpr auto dest_chans = 1u;
   auto half = Fixed(ffl::FromRatio(1, 2)).raw_value();
   mixer::PositionManager pos_mgr(source_chans, dest_chans, half + 1, half + 1);

   int16_t source[2 * source_chans];
   const auto source_void = static_cast<void*>(source);
   Fixed source_offset = ffl::FromRatio(3, 2) - Fixed::FromRaw(1);
   pos_mgr.SetSourceValues(source_void, std::size(source), &source_offset);

   float dest[2u * dest_chans];
   int64_t dest_offset = 1;
   pos_mgr.SetDestValues(dest, 2, &dest_offset);
   EXPECT_TRUE(pos_mgr.FrameCanBeMixed());
   EXPECT_FALSE(pos_mgr.SourceIsConsumed());

   source_offset += Fixed::FromRaw(1);
   pos_mgr.SetSourceValues(source_void, std::size(source), &source_offset);
   EXPECT_FALSE(pos_mgr.FrameCanBeMixed());
   EXPECT_TRUE(pos_mgr.SourceIsConsumed());
 }

 TEST(PositionManagerTest, AdvanceFrame_Basic) {
   mixer::PositionManager pos_mgr(1, 1, 1, kFracFrame);

   uint8_t source[3];
   auto source_offset = Fixed(1);
   pos_mgr.SetSourceValues(static_cast<void*>(source), std::size(source), &source_offset);

   float dest[3];
   int64_t dest_offset = 1;
   pos_mgr.SetDestValues(dest, 3, &dest_offset);

   auto source_position_modulo = 0ul;
   pos_mgr.SetRateValues(kFracFrame, 0, 1, &source_position_modulo);

   Fixed expected_source_offset = source_offset + Fixed(1);
   auto received_source_offset = Fixed::FromRaw(pos_mgr.AdvanceFrame());
   EXPECT_EQ(received_source_offset, expected_source_offset);
   EXPECT_TRUE(pos_mgr.FrameCanBeMixed());
   EXPECT_FALSE(pos_mgr.SourceIsConsumed());
 }

 // When source_offset reaches source_frames, we can no longer mix a frame, and source is consumed.
 TEST(PositionManagerTest, AdvanceFrame_SourceReachesEnd) {
   mixer::PositionManager pos_mgr(1, 1, 1, kFracFrame);

   int32_t source[2];
   auto source_offset = Fixed(1);
   pos_mgr.SetSourceValues(static_cast<void*>(source), std::size(source), &source_offset);

   float dest[3u];
   int64_t dest_offset = 2;
   pos_mgr.SetDestValues(dest, 3, &dest_offset);

   auto source_position_modulo = 0ul;
   pos_mgr.SetRateValues(kFracFrame, 0, 1, &source_position_modulo);

   Fixed expected_source_offset = source_offset + Fixed(1);
   auto received_source_offset = Fixed::FromRaw(pos_mgr.AdvanceFrame());
   EXPECT_EQ(received_source_offset, expected_source_offset);
   EXPECT_FALSE(pos_mgr.FrameCanBeMixed());
   EXPECT_TRUE(pos_mgr.SourceIsConsumed());
 }

 // source_modulo starts just one shy of incrementing source_offset, and rate_modulo increments it
 // This is the boundary case, exactly where source_modulo affects source_offset
 TEST(PositionManagerTest, AdvanceFrame_SourceModuloReachesEnd) {
   mixer::PositionManager pos_mgr(1, 1, 1, kFracFrame);

   int16_t source[3];
   Fixed source_offset = Fixed(2) - Fixed::FromRaw(1);
   pos_mgr.SetSourceValues(static_cast<void*>(source), std::size(source), &source_offset);

   float dest[3];
   int64_t dest_offset = 1;
   pos_mgr.SetDestValues(dest, 3, &dest_offset);

   constexpr auto step_size = kFracFrame;
   auto rate_modulo = 1ul;
   auto denominator = 243ul;
   auto source_position_modulo = 242ul;
   pos_mgr.SetRateValues(step_size, rate_modulo, denominator, &source_position_modulo);

   Fixed expected_source_offset = Fixed(2) - Fixed::FromRaw(1);
   EXPECT_TRUE(pos_mgr.FrameCanBeMixed());
   EXPECT_FALSE(pos_mgr.SourceIsConsumed());
   EXPECT_EQ(pos_mgr.CurrentSourceFrame<int16_t>(), &source[1]);
   EXPECT_EQ(pos_mgr.source_offset(), expected_source_offset);

   expected_source_offset = Fixed(3);
   auto received_source_offset = Fixed::FromRaw(pos_mgr.AdvanceFrame());
   EXPECT_EQ(received_source_offset, expected_source_offset);
   EXPECT_EQ(pos_mgr.source_offset(), received_source_offset);

   EXPECT_FALSE(pos_mgr.FrameCanBeMixed());
   EXPECT_TRUE(pos_mgr.SourceIsConsumed());
   EXPECT_EQ(received_source_offset, Fixed(3));
 }

 // source_modulo starts two shy of incrementing source_offset, and rate_modulo increments it by one.
 // This is the boundary case, one less than where source_modulo affects source_offset
 TEST(PositionManagerTest, AdvanceFrame_SourceModuloAlmostReachesEnd) {
   mixer::PositionManager pos_mgr(1, 1, 1, kFracFrame);

   float source[3];
   Fixed source_offset = Fixed(2) - Fixed::FromRaw(1);
   pos_mgr.SetSourceValues(static_cast<void*>(source), std::size(source), &source_offset);

   float dest[3];
   int64_t dest_offset = 1;
   pos_mgr.SetDestValues(dest, 3, &dest_offset);

   constexpr auto step_size = kFracFrame;
   auto rate_modulo = 1ul;
   auto denominator = 243ul;
   auto source_position_modulo = 241ul;
   pos_mgr.SetRateValues(step_size, rate_modulo, denominator, &source_position_modulo);

   Fixed expected_source_offset = Fixed(2) - Fixed::FromRaw(1);
   EXPECT_TRUE(pos_mgr.FrameCanBeMixed());
   EXPECT_EQ(pos_mgr.CurrentSourceFrame<float>(), &source[1]);
   EXPECT_EQ(pos_mgr.source_offset(), expected_source_offset);

   expected_source_offset = source_offset + Fixed(1);
   auto received_source_offset = Fixed::FromRaw(pos_mgr.AdvanceFrame());
   EXPECT_EQ(received_source_offset, expected_source_offset);
   EXPECT_EQ(pos_mgr.source_offset(), received_source_offset);

   EXPECT_TRUE(pos_mgr.FrameCanBeMixed());
   EXPECT_FALSE(pos_mgr.SourceIsConsumed());
   EXPECT_EQ(pos_mgr.CurrentSourceFrame<float>(), &source[2]);
   EXPECT_EQ(received_source_offset, Fixed(3) - Fixed::FromRaw(1));
 }

 // When dest_offset reaches dest_frames, we can no longer mix a frame, but source is not consumed.
 TEST(PositionManagerTest, AdvanceFrame_DestReachesEnd) {
   mixer::PositionManager pos_mgr(1, 1, 1, kFracFrame);

   int16_t source[3];
   auto source_offset = Fixed(1);
   const Fixed expected_source_offset = source_offset + Fixed(1);

   pos_mgr.SetSourceValues(static_cast<void*>(source), std::size(source), &source_offset);

   float dest[2];
   const int64_t dest_frames = std::size(dest);
   int64_t dest_offset = 1;
   pos_mgr.SetDestValues(dest, dest_frames, &dest_offset);

   constexpr auto step_size = kFracFrame;
   auto source_position_modulo = 0ul;
   pos_mgr.SetRateValues(step_size, 0, 1, &source_position_modulo);

   auto received_source_offset = Fixed::FromRaw(pos_mgr.AdvanceFrame());

   EXPECT_EQ(received_source_offset, expected_source_offset);
   EXPECT_EQ(pos_mgr.source_offset(), received_source_offset);

   EXPECT_FALSE(pos_mgr.FrameCanBeMixed());
   EXPECT_FALSE(pos_mgr.SourceIsConsumed());
 }

 // Unity step_size (no rate_modulo) is the default if SetRateValues is never called.
 TEST(PositionManagerTest, AdvanceFrame_NoRateValues) {
   mixer::PositionManager pos_mgr(1, 1, 1, kFracFrame);

   int16_t source[3];
   Fixed source_offset = Fixed(2) - Fixed::FromRaw(1);
   pos_mgr.SetSourceValues(static_cast<void*>(source), std::size(source), &source_offset);

   float dest[3];
   int64_t dest_offset = 1;
   pos_mgr.SetDestValues(dest, 3, &dest_offset);

   Fixed expected_source_offset = Fixed(2) - Fixed::FromRaw(1);
   EXPECT_TRUE(pos_mgr.FrameCanBeMixed());
   EXPECT_FALSE(pos_mgr.SourceIsConsumed());
   EXPECT_EQ(pos_mgr.CurrentSourceFrame<int16_t>(), &source[1]);
   EXPECT_EQ(pos_mgr.source_offset(), expected_source_offset);

   expected_source_offset = Fixed(3) - Fixed::FromRaw(1);
   auto received_source_offset = Fixed::FromRaw(pos_mgr.AdvanceFrame());
   pos_mgr.UpdateOffsets();

   EXPECT_EQ(received_source_offset, expected_source_offset);
   EXPECT_EQ(pos_mgr.source_offset(), received_source_offset);

   EXPECT_TRUE(pos_mgr.FrameCanBeMixed());
   EXPECT_FALSE(pos_mgr.SourceIsConsumed());
 }

 // AdvanceToEnd is limited by dest.
 TEST(PositionManagerTest, AdvanceToEnd_Dest) {
   mixer::PositionManager pos_mgr(1, 1, 1, kFracFrame);

   int16_t source[12];
   Fixed source_offset = Fixed(1) - Fixed::FromRaw(1);
   pos_mgr.SetSourceValues(static_cast<void*>(source), std::size(source), &source_offset);

   float dest[5];
   int64_t dest_offset = 0;
   pos_mgr.SetDestValues(dest, std::size(dest), &dest_offset);

   constexpr auto step_size = kFracFrame * 2 - 1;
   auto source_position_modulo = 1ul;
   auto denominator = 2ul;
   pos_mgr.SetRateValues(step_size, 0, denominator, &source_position_modulo);

   auto num_source_frames_skipped = pos_mgr.AdvanceToEnd();
   EXPECT_EQ(num_source_frames_skipped, 10);

   pos_mgr.UpdateOffsets();

   EXPECT_EQ(source_offset, Fixed(11) - Fixed::FromRaw(6));
   EXPECT_EQ(dest_offset, 5);
   EXPECT_EQ(source_position_modulo, 1ul);
   EXPECT_FALSE(pos_mgr.FrameCanBeMixed());
   EXPECT_FALSE(pos_mgr.SourceIsConsumed());
 }

 // AdvanceToEnd is limited by source, with no rate_modulo factor
 TEST(PositionManagerTest, AdvanceToEnd_SourceBasic) {
   mixer::PositionManager pos_mgr(1, 1, kFracHalfFrame + 1, kFracHalfFrame + 1);

   int16_t source[6];
   auto source_offset = Fixed(1);
   pos_mgr.SetSourceValues(static_cast<void*>(source), std::size(source), &source_offset);

   float dest[13];
   int64_t dest_offset = 0;
   pos_mgr.SetDestValues(dest, std::size(dest), &dest_offset);

   auto source_position_modulo = 0ul;
   pos_mgr.SetRateValues(kFracHalfFrame, 0, 1, &source_position_modulo);

   auto num_source_frames_skipped = pos_mgr.AdvanceToEnd();
   EXPECT_EQ(num_source_frames_skipped, 5);

   Fixed expect_source_offset = Fixed(ffl::FromRatio(11, 2));
   pos_mgr.UpdateOffsets();

   EXPECT_EQ(source_offset, expect_source_offset)
       << std::hex << source_offset.raw_value() << " != " << expect_source_offset.raw_value();
   EXPECT_EQ(dest_offset, 9);
   EXPECT_EQ(source_position_modulo, 0u);
   EXPECT_FALSE(pos_mgr.FrameCanBeMixed());
   EXPECT_TRUE(pos_mgr.SourceIsConsumed());
 }

 // AdvanceToEnd is limited by source; rate_modulo contributes EXACTLY what consumes source.
 TEST(PositionManagerTest, AdvanceToEnd_SourceExactModulo) {
   mixer::PositionManager pos_mgr(1, 1, 1, kFracHalfFrame + 1);

   int16_t source[11];
   Fixed source_offset = Fixed(1) - Fixed::FromRaw(1);
   pos_mgr.SetSourceValues(static_cast<void*>(source), std::size(source), &source_offset);

   float dest[6];
   int64_t dest_offset = 0;
   pos_mgr.SetDestValues(dest, std::size(dest), &dest_offset);

   constexpr auto step_size = 2 * kFracFrame;
   auto rate_modulo = 1ul;
   auto denominator = 25ul;
   auto source_position_modulo = 20ul;
   pos_mgr.SetRateValues(step_size, rate_modulo, denominator, &source_position_modulo);

   auto num_source_frames_skipped = pos_mgr.AdvanceToEnd();
   EXPECT_EQ(num_source_frames_skipped, 11);

   pos_mgr.UpdateOffsets();

   EXPECT_EQ(source_offset, Fixed(11));
   EXPECT_EQ(dest_offset, 5);
   EXPECT_EQ(source_position_modulo, 0ul);
   EXPECT_FALSE(pos_mgr.FrameCanBeMixed());
   EXPECT_TRUE(pos_mgr.SourceIsConsumed());
 }

 // AdvanceToEnd is limited by source; source_position modulo flows beyond source but by < 1 frame.
 TEST(PositionManagerTest, AdvanceToEnd_SourceExtraModulo) {
   mixer::PositionManager pos_mgr(1, 1, 1, kFracHalfFrame + 1);

   int16_t source[11];
   Fixed source_offset = Fixed(1) - Fixed::FromRaw(1);
   pos_mgr.SetSourceValues(static_cast<void*>(source), std::size(source), &source_offset);

   float dest[6];
   int64_t dest_offset = 0;
   pos_mgr.SetDestValues(dest, std::size(dest), &dest_offset);

   constexpr auto step_size = kFracFrame * 2;
   auto rate_modulo = 1ul;
   auto denominator = 25ul;
   auto source_position_modulo = 24ul;
   pos_mgr.SetRateValues(step_size, rate_modulo, denominator, &source_position_modulo);

   auto num_source_frames_skipped = pos_mgr.AdvanceToEnd();
   EXPECT_EQ(num_source_frames_skipped, 11);

   pos_mgr.UpdateOffsets();

   EXPECT_EQ(source_offset, Fixed(11));
   EXPECT_EQ(dest_offset, 5);
   EXPECT_EQ(source_position_modulo, 4ul);
   EXPECT_FALSE(pos_mgr.FrameCanBeMixed());
   EXPECT_TRUE(pos_mgr.SourceIsConsumed());
 }

 // AdvanceToEnd is limited by source; step_size and filter lengths are high-magnitude.
 TEST(PositionManagerTest, AdvanceToEndExtremeRatesAndWidths) {
   mixer::PositionManager pos_mgr(1, 1, (336 << Fixed::Format::FractionalBits) + 1,
                                  (336 << Fixed::Format::FractionalBits) + 1);

   float dest[10];
   int64_t dest_offset = 0;
   pos_mgr.SetDestValues(dest, std::size(dest), &dest_offset);

   auto step_size = (24 << Fixed::Format::FractionalBits);
   auto rate_modulo = 0ul;
   auto denominator = 1ul;
   auto source_position_modulo = 0ul;
   pos_mgr.SetRateValues(step_size, rate_modulo, denominator, &source_position_modulo);

   int16_t source[360];
   auto source_offset = Fixed::FromRaw(-1);
   pos_mgr.SetSourceValues(static_cast<void*>(source), 336, &source_offset);

   auto num_source_frames_skipped = pos_mgr.AdvanceToEnd();
   EXPECT_EQ(num_source_frames_skipped, 24);

   pos_mgr.UpdateOffsets();
   EXPECT_EQ(source_offset.raw_value(), (24 << Fixed::Format::FractionalBits) - 1);
   EXPECT_EQ(dest_offset, 1);
   EXPECT_FALSE(pos_mgr.FrameCanBeMixed());
   EXPECT_TRUE(pos_mgr.SourceIsConsumed());

   // Now try starting from just one subframe further. This should not advance.
   source_offset = Fixed(0);
   pos_mgr.SetSourceValues(static_cast<void*>(source), 336, &source_offset);

   num_source_frames_skipped = pos_mgr.AdvanceToEnd();
   EXPECT_EQ(num_source_frames_skipped, 0);

   pos_mgr.UpdateOffsets();
   EXPECT_EQ(source_offset, Fixed(0));
   EXPECT_EQ(dest_offset, 1);
   EXPECT_FALSE(pos_mgr.FrameCanBeMixed());
   EXPECT_TRUE(pos_mgr.SourceIsConsumed());

   // Back up position but subtract a frame of source supply: we should not advance.
   source_offset = Fixed::FromRaw(-1);
   pos_mgr.SetSourceValues(static_cast<void*>(source), 335, &source_offset);

   num_source_frames_skipped = pos_mgr.AdvanceToEnd();
   EXPECT_EQ(num_source_frames_skipped, 0);

   pos_mgr.UpdateOffsets();
   EXPECT_EQ(source_offset, Fixed::FromRaw(-1));
   EXPECT_EQ(dest_offset, 1);
   EXPECT_FALSE(pos_mgr.FrameCanBeMixed());
   EXPECT_TRUE(pos_mgr.SourceIsConsumed());
 }

 }  // namespace
 }  // namespace media::audio::mixer
	// Copyright 2019 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.

	#include "src/media/audio/audio_core/mixer/position_manager.h"

	#include <iterator>

	#include <fbl/algorithm.h>
	#include <gtest/gtest.h>

	namespace media::audio::mixer {
	namespace {

	constexpr int64_t kFracFrame = kOneFrame.raw_value();
	constexpr int64_t kFracHalfFrame = kFracFrame / 2;

	// Produce the frame pointer (in source format) for the first frame in the source buffer.
	TEST(PositionManagerTest, FirstSourceFrame) {
	auto source_chans = 2u;
	mixer::PositionManager pos_mgr(source_chans, 2u, 1, 1);

	int64_t source_frames = 5;

	// Setting this to any non-nullptr value
	void* source_void_ptr = static_cast<void*>(&source_frames);

	auto source_offset = Fixed(3);

	pos_mgr.SetSourceValues(source_void_ptr, source_frames, &source_offset);

	uint8_t* expected_source_frame_u8 = static_cast<uint8_t*>(source_void_ptr);
	int16_t* expected_source_frame_16 = static_cast<int16_t*>(source_void_ptr);
	int32_t* expected_source_frame_32 = static_cast<int32_t*>(source_void_ptr);
	float* expected_source_frame_float = static_cast<float*>(source_void_ptr);

	EXPECT_EQ(pos_mgr.FirstSourceFrame<uint8_t>(), expected_source_frame_u8);
	EXPECT_EQ(pos_mgr.FirstSourceFrame<int16_t>(), expected_source_frame_16);
	EXPECT_EQ(pos_mgr.FirstSourceFrame<int32_t>(), expected_source_frame_32);
	EXPECT_EQ(pos_mgr.FirstSourceFrame<float>(), expected_source_frame_float);
	}

	// Produce the frame pointer (in source format) for the last frame in the source buffer.
	TEST(PositionManagerTest, LastSourceFrame) {
	constexpr auto source_chans = 3u;
	mixer::PositionManager pos_mgr(source_chans, 2u, 1, 1);

	constexpr int64_t source_frames = 5;

	float source[source_chans * source_frames];
	const auto source_void = static_cast<void*>(source);

	auto source_offset = Fixed(1);

	pos_mgr.SetSourceValues(source_void, source_frames, &source_offset);

	auto sample_num_of_last_frame = source_chans * (source_frames - 1);
	uint8_t* expected_source_frame_u8 = static_cast<uint8_t*>(source_void) + sample_num_of_last_frame;
	int16_t* expected_source_frame_16 = static_cast<int16_t*>(source_void) + sample_num_of_last_frame;
	int32_t* expected_source_frame_32 = static_cast<int32_t*>(source_void) + sample_num_of_last_frame;
	float* expected_source_frame_float = static_cast<float*>(source_void) + sample_num_of_last_frame;

	EXPECT_EQ(pos_mgr.LastSourceFrame<uint8_t>(), expected_source_frame_u8);
	EXPECT_EQ(pos_mgr.LastSourceFrame<int16_t>(), expected_source_frame_16);
	EXPECT_EQ(pos_mgr.LastSourceFrame<int32_t>(), expected_source_frame_32);
	EXPECT_EQ(pos_mgr.LastSourceFrame<float>(), expected_source_frame_float);
	}

	// Produce the frame pointer (in source format) corresponding with the current source offset
	// This should take into account both source format container size and num source channels.
	TEST(PositionManagerTest, CurrentSourceFrame) {
	constexpr auto source_chans = 2u;
	constexpr auto dest_chans = 1u;
	mixer::PositionManager pos_mgr(source_chans, dest_chans, 1, kFracFrame);

	constexpr int64_t source_frames = 2;

	int16_t source[source_frames * source_chans];
	auto source_void = static_cast<void*>(source);

	auto source_start = 1;
	auto source_offset = Fixed(source_start);

	pos_mgr.SetSourceValues(source_void, source_frames, &source_offset);

	auto expected_source_frame = source + (source_start * source_chans);
	EXPECT_EQ(pos_mgr.CurrentSourceFrame<int16_t>(), expected_source_frame);
	EXPECT_FALSE(pos_mgr.SourceIsConsumed());

	auto expected_source_frame_u8 =
	reinterpret_cast<uint8_t>(source_void) + (source_start source_chans);
	EXPECT_EQ(pos_mgr.CurrentSourceFrame<uint8_t>(), expected_source_frame_u8);

	auto expected_source_frame_32 =
	reinterpret_cast<int32_t>(source_void) + (source_start source_chans);
	EXPECT_EQ(pos_mgr.CurrentSourceFrame<int32_t>(), expected_source_frame_32);

	auto expected_source_frame_float =
	reinterpret_cast<float>(source_void) + (source_start source_chans);
	EXPECT_EQ(pos_mgr.CurrentSourceFrame<float>(), expected_source_frame_float);

	source_start = 0;
	source_offset = Fixed(source_start);
	pos_mgr.SetSourceValues(source_void, source_frames, &source_offset);

	expected_source_frame = source + (source_start * source_chans);
	EXPECT_EQ(pos_mgr.CurrentSourceFrame<int16_t>(), expected_source_frame);
	EXPECT_FALSE(pos_mgr.SourceIsConsumed());
	}

	// Produce the frame pointer (float*) corresponding with the current destination offset
	// This should take into account the number of destination channels.
	TEST(PositionManagerTest, CurrentDestFrame) {
	constexpr auto source_chans = 1u;
	constexpr auto dest_chans = 4u;
	mixer::PositionManager pos_mgr(source_chans, dest_chans, 1, kFracFrame);

	constexpr auto dest_frames = 2;
	float dest[dest_frames * dest_chans];
	int64_t dest_offset = 1;

	auto expected_dest_frame = dest + (dest_offset * dest_chans);
	pos_mgr.SetDestValues(dest, dest_frames, &dest_offset);

	EXPECT_EQ(pos_mgr.CurrentDestFrame(), expected_dest_frame);

	dest_offset = 0;
	expected_dest_frame = dest + (dest_offset * dest_chans);
	pos_mgr.SetDestValues(dest, dest_frames, &dest_offset);

	EXPECT_EQ(pos_mgr.CurrentDestFrame(), expected_dest_frame);
	}

	// Write back the latest values of source offset, dest offset, and source modulo.
	// This should overwrite existing values at those locations, and include effects of advances.
	TEST(PositionManagerTest, UpdateOffsets) {
	mixer::PositionManager pos_mgr(1, 1, 1, kFracFrame);

	float input;
	void* source_void_ptr = static_cast<void*>(&input);
	constexpr int64_t source_frames = 1;
	auto source_offset = Fixed(0);
	pos_mgr.SetSourceValues(source_void_ptr, source_frames, &source_offset);

	float data;
	float* dest = &data;
	auto dest_frames = 1;
	int64_t dest_offset = 0;
	pos_mgr.SetDestValues(dest, dest_frames, &dest_offset);

	auto step_size = kFracFrame;
	auto rate_modulo = 0ul;
	auto denominator = 1ul;
	auto source_position_modulo = 0ul;
	pos_mgr.SetRateValues(step_size, rate_modulo, denominator, &source_position_modulo);

	source_offset = Fixed::FromRaw(27);
	dest_offset = 42;
	source_position_modulo = 72;
	pos_mgr.UpdateOffsets();

	EXPECT_EQ(source_offset, Fixed(0));
	EXPECT_EQ(dest_offset, 0);
	EXPECT_EQ(source_position_modulo, 72ul);

	// Now that rate_modulo and denominator are non-zero, source_position_modulo should be updated
	rate_modulo = 1ul;
	denominator = 2ul;
	source_position_modulo = 0;
	pos_mgr.SetRateValues(step_size, rate_modulo, denominator, &source_position_modulo);

	source_offset = Fixed::FromRaw(27);
	dest_offset = 42;
	source_position_modulo = 72;
	pos_mgr.UpdateOffsets();

	EXPECT_EQ(source_offset, Fixed(0));
	EXPECT_EQ(dest_offset, 0);
	EXPECT_EQ(source_position_modulo, 0ul);
	}

	TEST(PositionManagerTest, FrameCanBeMixed) {
	constexpr auto source_chans = 1u;
	constexpr auto dest_chans = 1u;
	auto half = Fixed(ffl::FromRatio(1, 2)).raw_value();
	mixer::PositionManager pos_mgr(source_chans, dest_chans, half + 1, half + 1);

	int16_t source[2 * source_chans];
	const auto source_void = static_cast<void*>(source);
	Fixed source_offset = ffl::FromRatio(3, 2) - Fixed::FromRaw(1);
	pos_mgr.SetSourceValues(source_void, std::size(source), &source_offset);

	float dest[2u * dest_chans];
	int64_t dest_offset = 1;
	pos_mgr.SetDestValues(dest, 2, &dest_offset);
	EXPECT_TRUE(pos_mgr.FrameCanBeMixed());
	EXPECT_FALSE(pos_mgr.SourceIsConsumed());

	source_offset += Fixed::FromRaw(1);
	pos_mgr.SetSourceValues(source_void, std::size(source), &source_offset);
	EXPECT_FALSE(pos_mgr.FrameCanBeMixed());
	EXPECT_TRUE(pos_mgr.SourceIsConsumed());
	}

	TEST(PositionManagerTest, AdvanceFrame_Basic) {
	mixer::PositionManager pos_mgr(1, 1, 1, kFracFrame);

	uint8_t source[3];
	auto source_offset = Fixed(1);
	pos_mgr.SetSourceValues(static_cast<void*>(source), std::size(source), &source_offset);

	float dest[3];
	int64_t dest_offset = 1;
	pos_mgr.SetDestValues(dest, 3, &dest_offset);

	auto source_position_modulo = 0ul;
	pos_mgr.SetRateValues(kFracFrame, 0, 1, &source_position_modulo);

	Fixed expected_source_offset = source_offset + Fixed(1);
	auto received_source_offset = Fixed::FromRaw(pos_mgr.AdvanceFrame());
	EXPECT_EQ(received_source_offset, expected_source_offset);
	EXPECT_TRUE(pos_mgr.FrameCanBeMixed());
	EXPECT_FALSE(pos_mgr.SourceIsConsumed());
	}

	// When source_offset reaches source_frames, we can no longer mix a frame, and source is consumed.
	TEST(PositionManagerTest, AdvanceFrame_SourceReachesEnd) {
	mixer::PositionManager pos_mgr(1, 1, 1, kFracFrame);

	int32_t source[2];
	auto source_offset = Fixed(1);
	pos_mgr.SetSourceValues(static_cast<void*>(source), std::size(source), &source_offset);

	float dest[3u];
	int64_t dest_offset = 2;
	pos_mgr.SetDestValues(dest, 3, &dest_offset);

	auto source_position_modulo = 0ul;
	pos_mgr.SetRateValues(kFracFrame, 0, 1, &source_position_modulo);

	Fixed expected_source_offset = source_offset + Fixed(1);
	auto received_source_offset = Fixed::FromRaw(pos_mgr.AdvanceFrame());
	EXPECT_EQ(received_source_offset, expected_source_offset);
	EXPECT_FALSE(pos_mgr.FrameCanBeMixed());
	EXPECT_TRUE(pos_mgr.SourceIsConsumed());
	}

	// source_modulo starts just one shy of incrementing source_offset, and rate_modulo increments it
	// This is the boundary case, exactly where source_modulo affects source_offset
	TEST(PositionManagerTest, AdvanceFrame_SourceModuloReachesEnd) {
	mixer::PositionManager pos_mgr(1, 1, 1, kFracFrame);

	int16_t source[3];
	Fixed source_offset = Fixed(2) - Fixed::FromRaw(1);
	pos_mgr.SetSourceValues(static_cast<void*>(source), std::size(source), &source_offset);

	float dest[3];
	int64_t dest_offset = 1;
	pos_mgr.SetDestValues(dest, 3, &dest_offset);

	constexpr auto step_size = kFracFrame;
	auto rate_modulo = 1ul;
	auto denominator = 243ul;
	auto source_position_modulo = 242ul;
	pos_mgr.SetRateValues(step_size, rate_modulo, denominator, &source_position_modulo);

	Fixed expected_source_offset = Fixed(2) - Fixed::FromRaw(1);
	EXPECT_TRUE(pos_mgr.FrameCanBeMixed());
	EXPECT_FALSE(pos_mgr.SourceIsConsumed());
	EXPECT_EQ(pos_mgr.CurrentSourceFrame<int16_t>(), &source[1]);
	EXPECT_EQ(pos_mgr.source_offset(), expected_source_offset);

	expected_source_offset = Fixed(3);
	auto received_source_offset = Fixed::FromRaw(pos_mgr.AdvanceFrame());
	EXPECT_EQ(received_source_offset, expected_source_offset);
	EXPECT_EQ(pos_mgr.source_offset(), received_source_offset);

	EXPECT_FALSE(pos_mgr.FrameCanBeMixed());
	EXPECT_TRUE(pos_mgr.SourceIsConsumed());
	EXPECT_EQ(received_source_offset, Fixed(3));
	}

	// source_modulo starts two shy of incrementing source_offset, and rate_modulo increments it by one.
	// This is the boundary case, one less than where source_modulo affects source_offset
	TEST(PositionManagerTest, AdvanceFrame_SourceModuloAlmostReachesEnd) {
	mixer::PositionManager pos_mgr(1, 1, 1, kFracFrame);

	float source[3];
	Fixed source_offset = Fixed(2) - Fixed::FromRaw(1);
	pos_mgr.SetSourceValues(static_cast<void*>(source), std::size(source), &source_offset);

	float dest[3];
	int64_t dest_offset = 1;
	pos_mgr.SetDestValues(dest, 3, &dest_offset);

	constexpr auto step_size = kFracFrame;
	auto rate_modulo = 1ul;
	auto denominator = 243ul;
	auto source_position_modulo = 241ul;
	pos_mgr.SetRateValues(step_size, rate_modulo, denominator, &source_position_modulo);

	Fixed expected_source_offset = Fixed(2) - Fixed::FromRaw(1);
	EXPECT_TRUE(pos_mgr.FrameCanBeMixed());
	EXPECT_EQ(pos_mgr.CurrentSourceFrame<float>(), &source[1]);
	EXPECT_EQ(pos_mgr.source_offset(), expected_source_offset);

	expected_source_offset = source_offset + Fixed(1);
	auto received_source_offset = Fixed::FromRaw(pos_mgr.AdvanceFrame());
	EXPECT_EQ(received_source_offset, expected_source_offset);
	EXPECT_EQ(pos_mgr.source_offset(), received_source_offset);

	EXPECT_TRUE(pos_mgr.FrameCanBeMixed());
	EXPECT_FALSE(pos_mgr.SourceIsConsumed());
	EXPECT_EQ(pos_mgr.CurrentSourceFrame<float>(), &source[2]);
	EXPECT_EQ(received_source_offset, Fixed(3) - Fixed::FromRaw(1));
	}

	// When dest_offset reaches dest_frames, we can no longer mix a frame, but source is not consumed.
	TEST(PositionManagerTest, AdvanceFrame_DestReachesEnd) {
	mixer::PositionManager pos_mgr(1, 1, 1, kFracFrame);

	int16_t source[3];
	auto source_offset = Fixed(1);
	const Fixed expected_source_offset = source_offset + Fixed(1);

	pos_mgr.SetSourceValues(static_cast<void*>(source), std::size(source), &source_offset);

	float dest[2];
	const int64_t dest_frames = std::size(dest);
	int64_t dest_offset = 1;
	pos_mgr.SetDestValues(dest, dest_frames, &dest_offset);

	constexpr auto step_size = kFracFrame;
	auto source_position_modulo = 0ul;
	pos_mgr.SetRateValues(step_size, 0, 1, &source_position_modulo);

	auto received_source_offset = Fixed::FromRaw(pos_mgr.AdvanceFrame());

	EXPECT_EQ(received_source_offset, expected_source_offset);
	EXPECT_EQ(pos_mgr.source_offset(), received_source_offset);

	EXPECT_FALSE(pos_mgr.FrameCanBeMixed());
	EXPECT_FALSE(pos_mgr.SourceIsConsumed());
	}

	// Unity step_size (no rate_modulo) is the default if SetRateValues is never called.
	TEST(PositionManagerTest, AdvanceFrame_NoRateValues) {
	mixer::PositionManager pos_mgr(1, 1, 1, kFracFrame);

	int16_t source[3];
	Fixed source_offset = Fixed(2) - Fixed::FromRaw(1);
	pos_mgr.SetSourceValues(static_cast<void*>(source), std::size(source), &source_offset);

	float dest[3];
	int64_t dest_offset = 1;
	pos_mgr.SetDestValues(dest, 3, &dest_offset);

	Fixed expected_source_offset = Fixed(2) - Fixed::FromRaw(1);
	EXPECT_TRUE(pos_mgr.FrameCanBeMixed());
	EXPECT_FALSE(pos_mgr.SourceIsConsumed());
	EXPECT_EQ(pos_mgr.CurrentSourceFrame<int16_t>(), &source[1]);
	EXPECT_EQ(pos_mgr.source_offset(), expected_source_offset);

	expected_source_offset = Fixed(3) - Fixed::FromRaw(1);
	auto received_source_offset = Fixed::FromRaw(pos_mgr.AdvanceFrame());
	pos_mgr.UpdateOffsets();

	EXPECT_EQ(received_source_offset, expected_source_offset);
	EXPECT_EQ(pos_mgr.source_offset(), received_source_offset);

	EXPECT_TRUE(pos_mgr.FrameCanBeMixed());
	EXPECT_FALSE(pos_mgr.SourceIsConsumed());
	}

	// AdvanceToEnd is limited by dest.
	TEST(PositionManagerTest, AdvanceToEnd_Dest) {
	mixer::PositionManager pos_mgr(1, 1, 1, kFracFrame);

	int16_t source[12];
	Fixed source_offset = Fixed(1) - Fixed::FromRaw(1);
	pos_mgr.SetSourceValues(static_cast<void*>(source), std::size(source), &source_offset);

	float dest[5];
	int64_t dest_offset = 0;
	pos_mgr.SetDestValues(dest, std::size(dest), &dest_offset);

	constexpr auto step_size = kFracFrame * 2 - 1;
	auto source_position_modulo = 1ul;
	auto denominator = 2ul;
	pos_mgr.SetRateValues(step_size, 0, denominator, &source_position_modulo);

	auto num_source_frames_skipped = pos_mgr.AdvanceToEnd();
	EXPECT_EQ(num_source_frames_skipped, 10);

	pos_mgr.UpdateOffsets();

	EXPECT_EQ(source_offset, Fixed(11) - Fixed::FromRaw(6));
	EXPECT_EQ(dest_offset, 5);
	EXPECT_EQ(source_position_modulo, 1ul);
	EXPECT_FALSE(pos_mgr.FrameCanBeMixed());
	EXPECT_FALSE(pos_mgr.SourceIsConsumed());
	}

	// AdvanceToEnd is limited by source, with no rate_modulo factor
	TEST(PositionManagerTest, AdvanceToEnd_SourceBasic) {
	mixer::PositionManager pos_mgr(1, 1, kFracHalfFrame + 1, kFracHalfFrame + 1);

	int16_t source[6];
	auto source_offset = Fixed(1);
	pos_mgr.SetSourceValues(static_cast<void*>(source), std::size(source), &source_offset);

	float dest[13];
	int64_t dest_offset = 0;
	pos_mgr.SetDestValues(dest, std::size(dest), &dest_offset);

	auto source_position_modulo = 0ul;
	pos_mgr.SetRateValues(kFracHalfFrame, 0, 1, &source_position_modulo);

	auto num_source_frames_skipped = pos_mgr.AdvanceToEnd();
	EXPECT_EQ(num_source_frames_skipped, 5);

	Fixed expect_source_offset = Fixed(ffl::FromRatio(11, 2));
	pos_mgr.UpdateOffsets();

	EXPECT_EQ(source_offset, expect_source_offset)
	<< std::hex << source_offset.raw_value() << " != " << expect_source_offset.raw_value();
	EXPECT_EQ(dest_offset, 9);
	EXPECT_EQ(source_position_modulo, 0u);
	EXPECT_FALSE(pos_mgr.FrameCanBeMixed());
	EXPECT_TRUE(pos_mgr.SourceIsConsumed());
	}

	// AdvanceToEnd is limited by source; rate_modulo contributes EXACTLY what consumes source.
	TEST(PositionManagerTest, AdvanceToEnd_SourceExactModulo) {
	mixer::PositionManager pos_mgr(1, 1, 1, kFracHalfFrame + 1);

	int16_t source[11];
	Fixed source_offset = Fixed(1) - Fixed::FromRaw(1);
	pos_mgr.SetSourceValues(static_cast<void*>(source), std::size(source), &source_offset);

	float dest[6];
	int64_t dest_offset = 0;
	pos_mgr.SetDestValues(dest, std::size(dest), &dest_offset);

	constexpr auto step_size = 2 * kFracFrame;
	auto rate_modulo = 1ul;
	auto denominator = 25ul;
	auto source_position_modulo = 20ul;
	pos_mgr.SetRateValues(step_size, rate_modulo, denominator, &source_position_modulo);

	auto num_source_frames_skipped = pos_mgr.AdvanceToEnd();
	EXPECT_EQ(num_source_frames_skipped, 11);

	pos_mgr.UpdateOffsets();

	EXPECT_EQ(source_offset, Fixed(11));
	EXPECT_EQ(dest_offset, 5);
	EXPECT_EQ(source_position_modulo, 0ul);
	EXPECT_FALSE(pos_mgr.FrameCanBeMixed());
	EXPECT_TRUE(pos_mgr.SourceIsConsumed());
	}

	// AdvanceToEnd is limited by source; source_position modulo flows beyond source but by < 1 frame.
	TEST(PositionManagerTest, AdvanceToEnd_SourceExtraModulo) {
	mixer::PositionManager pos_mgr(1, 1, 1, kFracHalfFrame + 1);

	int16_t source[11];
	Fixed source_offset = Fixed(1) - Fixed::FromRaw(1);
	pos_mgr.SetSourceValues(static_cast<void*>(source), std::size(source), &source_offset);

	float dest[6];
	int64_t dest_offset = 0;
	pos_mgr.SetDestValues(dest, std::size(dest), &dest_offset);

	constexpr auto step_size = kFracFrame * 2;
	auto rate_modulo = 1ul;
	auto denominator = 25ul;
	auto source_position_modulo = 24ul;
	pos_mgr.SetRateValues(step_size, rate_modulo, denominator, &source_position_modulo);

	auto num_source_frames_skipped = pos_mgr.AdvanceToEnd();
	EXPECT_EQ(num_source_frames_skipped, 11);

	pos_mgr.UpdateOffsets();

	EXPECT_EQ(source_offset, Fixed(11));
	EXPECT_EQ(dest_offset, 5);
	EXPECT_EQ(source_position_modulo, 4ul);
	EXPECT_FALSE(pos_mgr.FrameCanBeMixed());
	EXPECT_TRUE(pos_mgr.SourceIsConsumed());
	}

	// AdvanceToEnd is limited by source; step_size and filter lengths are high-magnitude.
	TEST(PositionManagerTest, AdvanceToEndExtremeRatesAndWidths) {
	mixer::PositionManager pos_mgr(1, 1, (336 << Fixed::Format::FractionalBits) + 1,
	(336 << Fixed::Format::FractionalBits) + 1);

	float dest[10];
	int64_t dest_offset = 0;
	pos_mgr.SetDestValues(dest, std::size(dest), &dest_offset);

	auto step_size = (24 << Fixed::Format::FractionalBits);
	auto rate_modulo = 0ul;
	auto denominator = 1ul;
	auto source_position_modulo = 0ul;
	pos_mgr.SetRateValues(step_size, rate_modulo, denominator, &source_position_modulo);

	int16_t source[360];
	auto source_offset = Fixed::FromRaw(-1);
	pos_mgr.SetSourceValues(static_cast<void*>(source), 336, &source_offset);

	auto num_source_frames_skipped = pos_mgr.AdvanceToEnd();
	EXPECT_EQ(num_source_frames_skipped, 24);

	pos_mgr.UpdateOffsets();
	EXPECT_EQ(source_offset.raw_value(), (24 << Fixed::Format::FractionalBits) - 1);
	EXPECT_EQ(dest_offset, 1);
	EXPECT_FALSE(pos_mgr.FrameCanBeMixed());
	EXPECT_TRUE(pos_mgr.SourceIsConsumed());

	// Now try starting from just one subframe further. This should not advance.
	source_offset = Fixed(0);
	pos_mgr.SetSourceValues(static_cast<void*>(source), 336, &source_offset);

	num_source_frames_skipped = pos_mgr.AdvanceToEnd();
	EXPECT_EQ(num_source_frames_skipped, 0);

	pos_mgr.UpdateOffsets();
	EXPECT_EQ(source_offset, Fixed(0));
	EXPECT_EQ(dest_offset, 1);
	EXPECT_FALSE(pos_mgr.FrameCanBeMixed());
	EXPECT_TRUE(pos_mgr.SourceIsConsumed());

	// Back up position but subtract a frame of source supply: we should not advance.
	source_offset = Fixed::FromRaw(-1);
	pos_mgr.SetSourceValues(static_cast<void*>(source), 335, &source_offset);

	num_source_frames_skipped = pos_mgr.AdvanceToEnd();
	EXPECT_EQ(num_source_frames_skipped, 0);

	pos_mgr.UpdateOffsets();
	EXPECT_EQ(source_offset, Fixed::FromRaw(-1));
	EXPECT_EQ(dest_offset, 1);
	EXPECT_FALSE(pos_mgr.FrameCanBeMixed());
	EXPECT_TRUE(pos_mgr.SourceIsConsumed());
	}

	} // namespace
	} // namespace media::audio::mixer