From eb0f3df520e5e0219fe0c78c862edc3a5611ca2c Mon Sep 17 00:00:00 2001
From: Dalton Messmer <messmer.dalton@gmail.com>
Date: Tue, 22 Jul 2025 18:22:16 -0400
Subject: [PATCH 01/10] Add  concept

---
 include/AudioBufferView.h | 23 +++++++++++++++++++++--
 1 file changed, 21 insertions(+), 2 deletions(-)

diff --git a/include/AudioBufferView.h b/include/AudioBufferView.h
index 56fff10faf8..495ef0fabdf 100644
--- a/include/AudioBufferView.h
+++ b/include/AudioBufferView.h
@@ -97,15 +97,34 @@ class BufferViewData<SampleT, DynamicChannelCount>
 	f_cnt_t m_frames = 0;
 };
 
+template<typename T, typename... AllowedTs>
+inline constexpr bool OneOf = (std::is_same_v<T, AllowedTs> || ...);
+
 } // namespace detail
 
 
+//! Recognized sample types, either const or non-const
+template<typename T>
+concept SampleType = detail::OneOf<std::remove_const_t<T>,
+	float,
+	double,
+	std::int8_t,
+	std::uint8_t,
+	std::int16_t,
+	std::uint16_t,
+	std::int32_t,
+	std::uint32_t,
+	std::int64_t,
+	std::uint64_t
+>;
+
+
 /**
  * Non-owning view for multi-channel interleaved audio data
  *
  * TODO C++23: Use std::mdspan?
  */
-template<typename SampleT, proc_ch_t channelCount = DynamicChannelCount>
+template<SampleType SampleT, proc_ch_t channelCount = DynamicChannelCount>
 class InterleavedBufferView : public detail::BufferViewData<SampleT, channelCount>
 {
 	using Base = detail::BufferViewData<SampleT, channelCount>;
@@ -186,7 +205,7 @@ static_assert(sizeof(InterleavedBufferView<float, 2>) == sizeof(void*) + sizeof(
  *
  * TODO C++23: Use std::mdspan?
  */
-template<typename SampleT, proc_ch_t channelCount = DynamicChannelCount>
+template<SampleType SampleT, proc_ch_t channelCount = DynamicChannelCount>
 class PlanarBufferView : public detail::BufferViewData<SampleT* const, channelCount>
 {
 	using Base = detail::BufferViewData<SampleT* const, channelCount>;

From 27229c686d19a846e50605af5a9cc33252f3c6a8 Mon Sep 17 00:00:00 2001
From: Dalton Messmer <messmer.dalton@gmail.com>
Date: Tue, 22 Jul 2025 18:36:27 -0400
Subject: [PATCH 02/10] Make  static when possible

---
 include/AudioBufferView.h | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/include/AudioBufferView.h b/include/AudioBufferView.h
index 495ef0fabdf..f79d18ad8ab 100644
--- a/include/AudioBufferView.h
+++ b/include/AudioBufferView.h
@@ -63,7 +63,7 @@ class BufferViewData
 	}
 
 	constexpr auto data() const noexcept -> SampleT* { return m_data; }
-	constexpr auto channels() const noexcept -> proc_ch_t { return channelCount; }
+	static constexpr auto channels() noexcept -> proc_ch_t { return channelCount; }
 	constexpr auto frames() const noexcept -> f_cnt_t { return m_frames; }
 
 protected:
@@ -156,7 +156,7 @@ class InterleavedBufferView : public detail::BufferViewData<SampleT, channelCoun
 
 	constexpr auto empty() const noexcept -> bool
 	{
-		return !this->m_data || this->channels() == 0 || this->m_frames == 0;
+		return !this->m_data || Base::channels() == 0 || this->m_frames == 0;
 	}
 
 	//! @return the frame at the given index
@@ -164,11 +164,11 @@ class InterleavedBufferView : public detail::BufferViewData<SampleT, channelCoun
 	{
 		if constexpr (channelCount == DynamicChannelCount)
 		{
-			return std::span<SampleT>{framePtr(index), this->channels()};
+			return std::span<SampleT>{framePtr(index), Base::channels()};
 		}
 		else
 		{
-			return std::span<SampleT, channelCount>{framePtr(index), this->channels()};
+			return std::span<SampleT, channelCount>{framePtr(index), Base::channels()};
 		}
 	}
 
@@ -179,7 +179,7 @@ class InterleavedBufferView : public detail::BufferViewData<SampleT, channelCoun
 	constexpr auto framePtr(f_cnt_t index) const noexcept -> SampleT*
 	{
 		assert(index < this->m_frames);
-		return this->m_data + index * this->channels();
+		return this->m_data + index * Base::channels();
 	}
 
 	/**
@@ -237,7 +237,7 @@ class PlanarBufferView : public detail::BufferViewData<SampleT* const, channelCo
 
 	constexpr auto empty() const noexcept -> bool
 	{
-		return !this->m_data || this->channels() == 0 || this->m_frames == 0;
+		return !this->m_data || Base::channels() == 0 || this->m_frames == 0;
 	}
 
 	//! @return the buffer of the given channel
@@ -259,7 +259,7 @@ class PlanarBufferView : public detail::BufferViewData<SampleT* const, channelCo
 	 */
 	constexpr auto bufferPtr(proc_ch_t channel) const noexcept -> SampleT*
 	{
-		assert(channel < this->channels());
+		assert(channel < Base::channels());
 		assert(this->m_data != nullptr);
 		return this->m_data[channel];
 	}

From cb9115159c65edee9b1786f8d80790c3795f6e23 Mon Sep 17 00:00:00 2001
From: Dalton Messmer <messmer.dalton@gmail.com>
Date: Tue, 22 Jul 2025 18:44:30 -0400
Subject: [PATCH 03/10] Add  and  to

---
 include/AudioBufferView.h | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/include/AudioBufferView.h b/include/AudioBufferView.h
index f79d18ad8ab..498399b14f0 100644
--- a/include/AudioBufferView.h
+++ b/include/AudioBufferView.h
@@ -49,7 +49,7 @@ class BufferViewData
 	constexpr BufferViewData() = default;
 	constexpr BufferViewData(const BufferViewData&) = default;
 
-	constexpr BufferViewData(SampleT* data, proc_ch_t channels, f_cnt_t frames) noexcept
+	constexpr BufferViewData(SampleT* data, [[maybe_unused]] proc_ch_t channels, f_cnt_t frames) noexcept
 		: m_data{data}
 		, m_frames{frames}
 	{
@@ -159,6 +159,16 @@ class InterleavedBufferView : public detail::BufferViewData<SampleT, channelCoun
 		return !this->m_data || Base::channels() == 0 || this->m_frames == 0;
 	}
 
+	constexpr auto dataSizeBytes() const noexcept -> std::size_t
+	{
+		return Base::channels() * this->m_frames * sizeof(SampleT);
+	}
+
+	constexpr auto dataView() noexcept -> std::span<SampleT>
+	{
+		return std::span<SampleT>{this->m_data, this->m_frames * Base::channels()};
+	}
+
 	//! @return the frame at the given index
 	constexpr auto frame(f_cnt_t index) const noexcept
 	{

From d305e4d52968a4e42d0979f9607e3265027f656c Mon Sep 17 00:00:00 2001
From: Dalton Messmer <messmer.dalton@gmail.com>
Date: Tue, 22 Jul 2025 19:09:08 -0400
Subject: [PATCH 04/10] Support conversions between  and

---
 include/AudioBufferView.h | 41 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/include/AudioBufferView.h b/include/AudioBufferView.h
index 498399b14f0..332d2789fce 100644
--- a/include/AudioBufferView.h
+++ b/include/AudioBufferView.h
@@ -31,6 +31,7 @@
 #include <type_traits>
 
 #include "LmmsTypes.h"
+#include "SampleFrame.h"
 
 namespace lmms
 {
@@ -154,6 +155,20 @@ class InterleavedBufferView : public detail::BufferViewData<SampleT, channelCoun
 	{
 	}
 
+	//! Construct from std::span<SampleFrame>
+	InterleavedBufferView(std::span<SampleFrame> buffer) noexcept
+		requires (std::is_same_v<std::remove_const_t<SampleT>, float> && channelCount == 2)
+		: Base{reinterpret_cast<float*>(buffer.data()), buffer.size()}
+	{
+	}
+
+	//! Construct from std::span<const SampleFrame>
+	InterleavedBufferView(std::span<const SampleFrame> buffer) noexcept
+		requires (std::is_same_v<SampleT, const float> && channelCount == 2)
+		: Base{reinterpret_cast<const float*>(buffer.data()), buffer.size()}
+	{
+	}
+
 	constexpr auto empty() const noexcept -> bool
 	{
 		return !this->m_data || Base::channels() == 0 || this->m_frames == 0;
@@ -200,6 +215,32 @@ class InterleavedBufferView : public detail::BufferViewData<SampleT, channelCoun
 	{
 		return framePtr(index);
 	}
+
+	auto sampleFrameAt(f_cnt_t index) noexcept -> SampleFrame&
+		requires (std::is_same_v<SampleT, float> && channelCount == 2)
+	{
+		assert(index < this->m_frames);
+		return reinterpret_cast<SampleFrame*>(this->m_data)[index];
+	}
+
+	auto sampleFrameAt(f_cnt_t index) const noexcept -> const SampleFrame&
+		requires (std::is_same_v<SampleT, const float> && channelCount == 2)
+	{
+		assert(index < this->m_frames);
+		return reinterpret_cast<const SampleFrame*>(this->m_data)[index];
+	}
+
+	auto toSampleFrames() noexcept -> std::span<SampleFrame>
+		requires (std::is_same_v<SampleT, float> && channelCount == 2)
+	{
+		return {reinterpret_cast<SampleFrame*>(this->m_data), this->m_frames};
+	}
+
+	auto toSampleFrames() const noexcept -> std::span<const SampleFrame>
+		requires (std::is_same_v<SampleT, const float> && channelCount == 2)
+	{
+		return {reinterpret_cast<const SampleFrame*>(this->m_data), this->m_frames};
+	}
 };
 
 // Check that the std::span-like space optimization works

From 57c20d4e30d94ab1caf54e3aad5ebb3650fa6895 Mon Sep 17 00:00:00 2001
From: Dalton Messmer <messmer.dalton@gmail.com>
Date: Tue, 22 Jul 2025 19:25:00 -0400
Subject: [PATCH 05/10] Support iteration over frames of

---
 include/AudioBufferView.h | 203 +++++++++++++++++++++++++++++++++++++-
 1 file changed, 201 insertions(+), 2 deletions(-)

diff --git a/include/AudioBufferView.h b/include/AudioBufferView.h
index 332d2789fce..9530f1d2423 100644
--- a/include/AudioBufferView.h
+++ b/include/AudioBufferView.h
@@ -42,7 +42,7 @@ inline constexpr auto DynamicChannelCount = static_cast<proc_ch_t>(-1);
 
 namespace detail {
 
-// For static channel count
+// For buffer views with static channel count
 template<typename SampleT, proc_ch_t channelCount>
 class BufferViewData
 {
@@ -72,7 +72,7 @@ class BufferViewData
 	f_cnt_t m_frames = 0;
 };
 
-// For dynamic channel count
+// For buffer views with dynamic channel count
 template<typename SampleT>
 class BufferViewData<SampleT, DynamicChannelCount>
 {
@@ -98,6 +98,174 @@ class BufferViewData<SampleT, DynamicChannelCount>
 	f_cnt_t m_frames = 0;
 };
 
+// For interleaved frame iterators with static channel count
+template<typename SampleT, proc_ch_t channelCount>
+class InterleavedFrameIteratorData
+{
+public:
+	constexpr InterleavedFrameIteratorData() = default;
+	constexpr explicit InterleavedFrameIteratorData(SampleT* data) noexcept
+		: m_data{data}
+	{
+	}
+
+	static constexpr auto channels() noexcept -> proc_ch_t { return channelCount; }
+
+protected:
+	SampleT* m_data = nullptr;
+};
+
+// For interleaved frame iterators with dynamic channel count
+template<typename SampleT>
+class InterleavedFrameIteratorData<SampleT, DynamicChannelCount>
+{
+public:
+	constexpr InterleavedFrameIteratorData() = default;
+	constexpr InterleavedFrameIteratorData(SampleT* data, proc_ch_t channels) noexcept
+		: m_data{data}
+		, m_channels{channels}
+	{
+	}
+
+	constexpr auto channels() const noexcept -> proc_ch_t { return m_channels; }
+
+protected:
+	SampleT* m_data = nullptr;
+	proc_ch_t m_channels = 0;
+};
+
+// Allows for iterating over the frames of `InterleavedBufferView`
+template<typename SampleT, proc_ch_t channelCount = DynamicChannelCount>
+class InterleavedFrameIterator : public InterleavedFrameIteratorData<SampleT, channelCount>
+{
+	using Base = InterleavedFrameIteratorData<SampleT, channelCount>;
+
+public:
+	using iterator_concept = std::random_access_iterator_tag;
+	using value_type = SampleT*;
+	using difference_type = std::ptrdiff_t;
+
+	constexpr InterleavedFrameIterator() = default;
+	constexpr InterleavedFrameIterator(const InterleavedFrameIterator&) = default;
+
+	template<typename T = SampleT> requires (channelCount != DynamicChannelCount)
+	constexpr explicit InterleavedFrameIterator(T* data) noexcept
+		: Base{data}
+	{
+	}
+
+	template<typename T = SampleT> requires (channelCount == DynamicChannelCount)
+	constexpr InterleavedFrameIterator(T* data, proc_ch_t channels) noexcept
+		: Base{data, channels}
+	{
+	}
+
+	constexpr auto operator*() const noexcept -> value_type { return this->m_data; }
+
+	constexpr auto operator[](difference_type frames) const noexcept -> value_type
+	{
+		return this->m_data[frames * Base::channels()];
+	}
+
+	constexpr auto operator++() noexcept -> InterleavedFrameIterator&
+	{
+		this->m_data += Base::channels();
+		return *this;
+	}
+
+	constexpr auto operator++(int) noexcept -> InterleavedFrameIterator
+	{
+		auto temp = *this;
+		++(*this);
+		return temp;
+	}
+
+	constexpr auto operator--() noexcept -> InterleavedFrameIterator&
+	{
+		this->m_data -= Base::channels();
+		return *this;
+	}
+
+	constexpr auto operator--(int) noexcept -> InterleavedFrameIterator
+	{
+		auto temp = *this;
+		--(*this);
+		return temp;
+	}
+
+	constexpr auto operator+=(difference_type channels) noexcept -> InterleavedFrameIterator&
+	{
+		this->m_data += channels * Base::channels();
+		return *this;
+	}
+
+	constexpr auto operator-=(difference_type channels) noexcept -> InterleavedFrameIterator&
+	{
+		this->m_data -= channels * Base::channels();
+		return *this;
+	}
+
+	friend constexpr auto operator+(InterleavedFrameIterator iter, difference_type frames) noexcept
+		-> InterleavedFrameIterator
+	{
+		if constexpr (channelCount == DynamicChannelCount)
+		{
+			return {iter.m_data + frames * Base::channels(), Base::channels()};
+		}
+		else
+		{
+			return InterleavedFrameIterator{iter.m_data + frames * Base::channels()};
+		}
+	}
+
+	friend constexpr auto operator+(difference_type frames, InterleavedFrameIterator iter) noexcept
+		-> InterleavedFrameIterator
+	{
+		return iter + frames;
+	}
+
+	constexpr auto operator-(difference_type frames) const noexcept -> InterleavedFrameIterator
+	{
+		if constexpr (channelCount == DynamicChannelCount)
+		{
+			return {this->m_data - frames * Base::channels(), Base::channels()};
+		}
+		else
+		{
+			return InterleavedFrameIterator{this->m_data - frames * Base::channels()};
+		}
+	}
+
+	constexpr auto operator-(InterleavedFrameIterator other) const noexcept -> difference_type
+	{
+		return this->m_data - other.m_data;
+	}
+
+	constexpr auto operator<=>(InterleavedFrameIterator other) const noexcept
+	{
+		return this->m_data <=> other.m_data;
+	}
+
+	constexpr auto operator==(InterleavedFrameIterator other) const noexcept -> bool
+	{
+		return this->m_data == other.m_data;
+	}
+
+	constexpr auto operator<=>(SampleT* sentinel) const noexcept
+	{
+		return this->m_data <=> sentinel;
+	}
+
+	constexpr auto operator==(SampleT* sentinel) const noexcept -> bool
+	{
+		return this->m_data == sentinel;
+	}
+
+	constexpr auto base() const noexcept -> SampleT* { return this->m_data; }
+};
+
+static_assert(std::random_access_iterator<InterleavedFrameIterator<float, 2>>);
+
 template<typename T, typename... AllowedTs>
 inline constexpr bool OneOf = (std::is_same_v<T, AllowedTs> || ...);
 
@@ -130,6 +298,9 @@ class InterleavedBufferView : public detail::BufferViewData<SampleT, channelCoun
 {
 	using Base = detail::BufferViewData<SampleT, channelCount>;
 
+	using FrameIter = detail::InterleavedFrameIterator<SampleT, channelCount>;
+	using ConstFrameIter = detail::InterleavedFrameIterator<const SampleT, channelCount>;
+
 public:
 	using Base::Base;
 
@@ -216,6 +387,34 @@ class InterleavedBufferView : public detail::BufferViewData<SampleT, channelCoun
 		return framePtr(index);
 	}
 
+	//! @returns a const view over the frames. Iterates in chunks containing `channels()` elements.
+	constexpr auto framesView() const noexcept -> std::ranges::subrange<ConstFrameIter, const SampleT*>
+	{
+		const SampleT* end = this->m_data + Base::channels() * this->m_frames;
+		if constexpr (channelCount == DynamicChannelCount)
+		{
+			return std::ranges::subrange{ConstFrameIter{this->m_data, Base::channels()}, end};
+		}
+		else
+		{
+			return std::ranges::subrange{ConstFrameIter{this->m_data}, end};
+		}
+	}
+
+	//! @returns a view over the frames. Iterates in chunks containing `channels()` elements.
+	constexpr auto framesView() noexcept -> std::ranges::subrange<FrameIter, SampleT*>
+	{
+		SampleT* end = this->m_data + Base::channels() * this->m_frames;
+		if constexpr (channelCount == DynamicChannelCount)
+		{
+			return std::ranges::subrange{FrameIter{this->m_data, Base::channels()}, end};
+		}
+		else
+		{
+			return std::ranges::subrange{FrameIter{this->m_data}, end};
+		}
+	}
+
 	auto sampleFrameAt(f_cnt_t index) noexcept -> SampleFrame&
 		requires (std::is_same_v<SampleT, float> && channelCount == 2)
 	{

From 7a1235d072ec5f553fc84b14245187e597247372 Mon Sep 17 00:00:00 2001
From: Dalton Messmer <messmer.dalton@gmail.com>
Date: Tue, 22 Jul 2025 19:31:22 -0400
Subject: [PATCH 06/10] Add `subspan` method

---------

Co-authored-by: Sotonye Atemie <sakertooth@gmail.com>
---
 include/AudioBufferView.h | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/include/AudioBufferView.h b/include/AudioBufferView.h
index 9530f1d2423..19a0c43598f 100644
--- a/include/AudioBufferView.h
+++ b/include/AudioBufferView.h
@@ -387,6 +387,21 @@ class InterleavedBufferView : public detail::BufferViewData<SampleT, channelCoun
 		return framePtr(index);
 	}
 
+	//! @returns a subview at the given frame offset `offset` with a frame count of `frames`
+	constexpr auto subspan(f_cnt_t offset, f_cnt_t frames) const -> InterleavedBufferView<SampleT, channelCount>
+	{
+		assert(offset <= this->m_frames);
+		assert(offset + frames <= this->m_frames);
+		if constexpr (channelCount == DynamicChannelCount)
+		{
+			return {this->m_data + offset * Base::channels(), Base::channels(), frames};
+		}
+		else
+		{
+			return {this->m_data + offset * Base::channels(), frames};
+		}
+	}
+
 	//! @returns a const view over the frames. Iterates in chunks containing `channels()` elements.
 	constexpr auto framesView() const noexcept -> std::ranges::subrange<ConstFrameIter, const SampleT*>
 	{

From 4b05ca2bf9b9fc7b6a79eb7f755a7df27b27ddd4 Mon Sep 17 00:00:00 2001
From: Dalton Messmer <messmer.dalton@gmail.com>
Date: Mon, 4 Aug 2025 13:26:22 -0400
Subject: [PATCH 07/10] Rename SampleT template parameter to T

---
 include/AudioBufferView.h | 140 +++++++++++++++++++-------------------
 1 file changed, 70 insertions(+), 70 deletions(-)

diff --git a/include/AudioBufferView.h b/include/AudioBufferView.h
index 19a0c43598f..61a4df4bce1 100644
--- a/include/AudioBufferView.h
+++ b/include/AudioBufferView.h
@@ -43,44 +43,44 @@ inline constexpr auto DynamicChannelCount = static_cast<proc_ch_t>(-1);
 namespace detail {
 
 // For buffer views with static channel count
-template<typename SampleT, proc_ch_t channelCount>
+template<typename T, proc_ch_t channelCount>
 class BufferViewData
 {
 public:
 	constexpr BufferViewData() = default;
 	constexpr BufferViewData(const BufferViewData&) = default;
 
-	constexpr BufferViewData(SampleT* data, [[maybe_unused]] proc_ch_t channels, f_cnt_t frames) noexcept
+	constexpr BufferViewData(T* data, [[maybe_unused]] proc_ch_t channels, f_cnt_t frames) noexcept
 		: m_data{data}
 		, m_frames{frames}
 	{
 		assert(channels == channelCount);
 	}
 
-	constexpr BufferViewData(SampleT* data, f_cnt_t frames) noexcept
+	constexpr BufferViewData(T* data, f_cnt_t frames) noexcept
 		: m_data{data}
 		, m_frames{frames}
 	{
 	}
 
-	constexpr auto data() const noexcept -> SampleT* { return m_data; }
+	constexpr auto data() const noexcept -> T* { return m_data; }
 	static constexpr auto channels() noexcept -> proc_ch_t { return channelCount; }
 	constexpr auto frames() const noexcept -> f_cnt_t { return m_frames; }
 
 protected:
-	SampleT* m_data = nullptr;
+	T* m_data = nullptr;
 	f_cnt_t m_frames = 0;
 };
 
 // For buffer views with dynamic channel count
-template<typename SampleT>
-class BufferViewData<SampleT, DynamicChannelCount>
+template<typename T>
+class BufferViewData<T, DynamicChannelCount>
 {
 public:
 	constexpr BufferViewData() = default;
 	constexpr BufferViewData(const BufferViewData&) = default;
 
-	constexpr BufferViewData(SampleT* data, proc_ch_t channels, f_cnt_t frames) noexcept
+	constexpr BufferViewData(T* data, proc_ch_t channels, f_cnt_t frames) noexcept
 		: m_data{data}
 		, m_channels{channels}
 		, m_frames{frames}
@@ -88,23 +88,23 @@ class BufferViewData<SampleT, DynamicChannelCount>
 		assert(channels != DynamicChannelCount);
 	}
 
-	constexpr auto data() const noexcept -> SampleT* { return m_data; }
+	constexpr auto data() const noexcept -> T* { return m_data; }
 	constexpr auto channels() const noexcept -> proc_ch_t { return m_channels; }
 	constexpr auto frames() const noexcept -> f_cnt_t { return m_frames; }
 
 protected:
-	SampleT* m_data = nullptr;
+	T* m_data = nullptr;
 	proc_ch_t m_channels = 0;
 	f_cnt_t m_frames = 0;
 };
 
 // For interleaved frame iterators with static channel count
-template<typename SampleT, proc_ch_t channelCount>
+template<typename T, proc_ch_t channelCount>
 class InterleavedFrameIteratorData
 {
 public:
 	constexpr InterleavedFrameIteratorData() = default;
-	constexpr explicit InterleavedFrameIteratorData(SampleT* data) noexcept
+	constexpr explicit InterleavedFrameIteratorData(T* data) noexcept
 		: m_data{data}
 	{
 	}
@@ -112,16 +112,16 @@ class InterleavedFrameIteratorData
 	static constexpr auto channels() noexcept -> proc_ch_t { return channelCount; }
 
 protected:
-	SampleT* m_data = nullptr;
+	T* m_data = nullptr;
 };
 
 // For interleaved frame iterators with dynamic channel count
-template<typename SampleT>
-class InterleavedFrameIteratorData<SampleT, DynamicChannelCount>
+template<typename T>
+class InterleavedFrameIteratorData<T, DynamicChannelCount>
 {
 public:
 	constexpr InterleavedFrameIteratorData() = default;
-	constexpr InterleavedFrameIteratorData(SampleT* data, proc_ch_t channels) noexcept
+	constexpr InterleavedFrameIteratorData(T* data, proc_ch_t channels) noexcept
 		: m_data{data}
 		, m_channels{channels}
 	{
@@ -130,32 +130,32 @@ class InterleavedFrameIteratorData<SampleT, DynamicChannelCount>
 	constexpr auto channels() const noexcept -> proc_ch_t { return m_channels; }
 
 protected:
-	SampleT* m_data = nullptr;
+	T* m_data = nullptr;
 	proc_ch_t m_channels = 0;
 };
 
 // Allows for iterating over the frames of `InterleavedBufferView`
-template<typename SampleT, proc_ch_t channelCount = DynamicChannelCount>
-class InterleavedFrameIterator : public InterleavedFrameIteratorData<SampleT, channelCount>
+template<typename T, proc_ch_t channelCount = DynamicChannelCount>
+class InterleavedFrameIterator : public InterleavedFrameIteratorData<T, channelCount>
 {
-	using Base = InterleavedFrameIteratorData<SampleT, channelCount>;
+	using Base = InterleavedFrameIteratorData<T, channelCount>;
 
 public:
 	using iterator_concept = std::random_access_iterator_tag;
-	using value_type = SampleT*;
+	using value_type = T*;
 	using difference_type = std::ptrdiff_t;
 
 	constexpr InterleavedFrameIterator() = default;
 	constexpr InterleavedFrameIterator(const InterleavedFrameIterator&) = default;
 
-	template<typename T = SampleT> requires (channelCount != DynamicChannelCount)
-	constexpr explicit InterleavedFrameIterator(T* data) noexcept
+	template<typename U = T> requires (channelCount != DynamicChannelCount)
+	constexpr explicit InterleavedFrameIterator(U* data) noexcept
 		: Base{data}
 	{
 	}
 
-	template<typename T = SampleT> requires (channelCount == DynamicChannelCount)
-	constexpr InterleavedFrameIterator(T* data, proc_ch_t channels) noexcept
+	template<typename U = T> requires (channelCount == DynamicChannelCount)
+	constexpr InterleavedFrameIterator(U* data, proc_ch_t channels) noexcept
 		: Base{data, channels}
 	{
 	}
@@ -251,17 +251,17 @@ class InterleavedFrameIterator : public InterleavedFrameIteratorData<SampleT, ch
 		return this->m_data == other.m_data;
 	}
 
-	constexpr auto operator<=>(SampleT* sentinel) const noexcept
+	constexpr auto operator<=>(T* sentinel) const noexcept
 	{
 		return this->m_data <=> sentinel;
 	}
 
-	constexpr auto operator==(SampleT* sentinel) const noexcept -> bool
+	constexpr auto operator==(T* sentinel) const noexcept -> bool
 	{
 		return this->m_data == sentinel;
 	}
 
-	constexpr auto base() const noexcept -> SampleT* { return this->m_data; }
+	constexpr auto base() const noexcept -> T* { return this->m_data; }
 };
 
 static_assert(std::random_access_iterator<InterleavedFrameIterator<float, 2>>);
@@ -293,27 +293,27 @@ concept SampleType = detail::OneOf<std::remove_const_t<T>,
  *
  * TODO C++23: Use std::mdspan?
  */
-template<SampleType SampleT, proc_ch_t channelCount = DynamicChannelCount>
-class InterleavedBufferView : public detail::BufferViewData<SampleT, channelCount>
+template<SampleType T, proc_ch_t channelCount = DynamicChannelCount>
+class InterleavedBufferView : public detail::BufferViewData<T, channelCount>
 {
-	using Base = detail::BufferViewData<SampleT, channelCount>;
+	using Base = detail::BufferViewData<T, channelCount>;
 
-	using FrameIter = detail::InterleavedFrameIterator<SampleT, channelCount>;
-	using ConstFrameIter = detail::InterleavedFrameIterator<const SampleT, channelCount>;
+	using FrameIter = detail::InterleavedFrameIterator<T, channelCount>;
+	using ConstFrameIter = detail::InterleavedFrameIterator<const T, channelCount>;
 
 public:
 	using Base::Base;
 
 	//! Contruct const from mutable (static channel count)
-	template<typename T = SampleT> requires (std::is_const_v<T> && channelCount != DynamicChannelCount)
-	constexpr InterleavedBufferView(InterleavedBufferView<std::remove_const_t<T>, channelCount> other) noexcept
+	template<typename U = T> requires (std::is_const_v<U> && channelCount != DynamicChannelCount)
+	constexpr InterleavedBufferView(InterleavedBufferView<std::remove_const_t<U>, channelCount> other) noexcept
 		: Base{other.data(), other.frames()}
 	{
 	}
 
 	//! Contruct const from mutable (dynamic channel count)
-	template<typename T = SampleT> requires (std::is_const_v<T> && channelCount == DynamicChannelCount)
-	constexpr InterleavedBufferView(InterleavedBufferView<std::remove_const_t<T>, channelCount> other) noexcept
+	template<typename U = T> requires (std::is_const_v<U> && channelCount == DynamicChannelCount)
+	constexpr InterleavedBufferView(InterleavedBufferView<std::remove_const_t<U>, channelCount> other) noexcept
 		: Base{other.data(), other.channels(), other.frames()}
 	{
 	}
@@ -321,21 +321,21 @@ class InterleavedBufferView : public detail::BufferViewData<SampleT, channelCoun
 	//! Construct dynamic channel count from static
 	template<proc_ch_t otherChannels>
 		requires (channelCount == DynamicChannelCount && otherChannels != DynamicChannelCount)
-	constexpr InterleavedBufferView(InterleavedBufferView<SampleT, otherChannels> other) noexcept
+	constexpr InterleavedBufferView(InterleavedBufferView<T, otherChannels> other) noexcept
 		: Base{other.data(), otherChannels, other.frames()}
 	{
 	}
 
 	//! Construct from std::span<SampleFrame>
 	InterleavedBufferView(std::span<SampleFrame> buffer) noexcept
-		requires (std::is_same_v<std::remove_const_t<SampleT>, float> && channelCount == 2)
+		requires (std::is_same_v<std::remove_const_t<T>, float> && channelCount == 2)
 		: Base{reinterpret_cast<float*>(buffer.data()), buffer.size()}
 	{
 	}
 
 	//! Construct from std::span<const SampleFrame>
 	InterleavedBufferView(std::span<const SampleFrame> buffer) noexcept
-		requires (std::is_same_v<SampleT, const float> && channelCount == 2)
+		requires (std::is_same_v<T, const float> && channelCount == 2)
 		: Base{reinterpret_cast<const float*>(buffer.data()), buffer.size()}
 	{
 	}
@@ -347,12 +347,12 @@ class InterleavedBufferView : public detail::BufferViewData<SampleT, channelCoun
 
 	constexpr auto dataSizeBytes() const noexcept -> std::size_t
 	{
-		return Base::channels() * this->m_frames * sizeof(SampleT);
+		return Base::channels() * this->m_frames * sizeof(T);
 	}
 
-	constexpr auto dataView() noexcept -> std::span<SampleT>
+	constexpr auto dataView() noexcept -> std::span<T>
 	{
-		return std::span<SampleT>{this->m_data, this->m_frames * Base::channels()};
+		return std::span<T>{this->m_data, this->m_frames * Base::channels()};
 	}
 
 	//! @return the frame at the given index
@@ -360,11 +360,11 @@ class InterleavedBufferView : public detail::BufferViewData<SampleT, channelCoun
 	{
 		if constexpr (channelCount == DynamicChannelCount)
 		{
-			return std::span<SampleT>{framePtr(index), Base::channels()};
+			return std::span<T>{framePtr(index), Base::channels()};
 		}
 		else
 		{
-			return std::span<SampleT, channelCount>{framePtr(index), Base::channels()};
+			return std::span<T, channelCount>{framePtr(index), Base::channels()};
 		}
 	}
 
@@ -372,7 +372,7 @@ class InterleavedBufferView : public detail::BufferViewData<SampleT, channelCoun
 	 * @return pointer to the frame at the given index.
 	 * The size of the frame is `channels()`.
 	 */
-	constexpr auto framePtr(f_cnt_t index) const noexcept -> SampleT*
+	constexpr auto framePtr(f_cnt_t index) const noexcept -> T*
 	{
 		assert(index < this->m_frames);
 		return this->m_data + index * Base::channels();
@@ -382,13 +382,13 @@ class InterleavedBufferView : public detail::BufferViewData<SampleT, channelCoun
 	 * @return pointer to the frame at the given index.
 	 * The size of the frame is `channels()`.
 	 */
-	constexpr auto operator[](f_cnt_t index) const noexcept -> SampleT*
+	constexpr auto operator[](f_cnt_t index) const noexcept -> T*
 	{
 		return framePtr(index);
 	}
 
 	//! @returns a subview at the given frame offset `offset` with a frame count of `frames`
-	constexpr auto subspan(f_cnt_t offset, f_cnt_t frames) const -> InterleavedBufferView<SampleT, channelCount>
+	constexpr auto subspan(f_cnt_t offset, f_cnt_t frames) const -> InterleavedBufferView<T, channelCount>
 	{
 		assert(offset <= this->m_frames);
 		assert(offset + frames <= this->m_frames);
@@ -403,9 +403,9 @@ class InterleavedBufferView : public detail::BufferViewData<SampleT, channelCoun
 	}
 
 	//! @returns a const view over the frames. Iterates in chunks containing `channels()` elements.
-	constexpr auto framesView() const noexcept -> std::ranges::subrange<ConstFrameIter, const SampleT*>
+	constexpr auto framesView() const noexcept -> std::ranges::subrange<ConstFrameIter, const T*>
 	{
-		const SampleT* end = this->m_data + Base::channels() * this->m_frames;
+		const T* end = this->m_data + Base::channels() * this->m_frames;
 		if constexpr (channelCount == DynamicChannelCount)
 		{
 			return std::ranges::subrange{ConstFrameIter{this->m_data, Base::channels()}, end};
@@ -417,9 +417,9 @@ class InterleavedBufferView : public detail::BufferViewData<SampleT, channelCoun
 	}
 
 	//! @returns a view over the frames. Iterates in chunks containing `channels()` elements.
-	constexpr auto framesView() noexcept -> std::ranges::subrange<FrameIter, SampleT*>
+	constexpr auto framesView() noexcept -> std::ranges::subrange<FrameIter, T*>
 	{
-		SampleT* end = this->m_data + Base::channels() * this->m_frames;
+		T* end = this->m_data + Base::channels() * this->m_frames;
 		if constexpr (channelCount == DynamicChannelCount)
 		{
 			return std::ranges::subrange{FrameIter{this->m_data, Base::channels()}, end};
@@ -431,27 +431,27 @@ class InterleavedBufferView : public detail::BufferViewData<SampleT, channelCoun
 	}
 
 	auto sampleFrameAt(f_cnt_t index) noexcept -> SampleFrame&
-		requires (std::is_same_v<SampleT, float> && channelCount == 2)
+		requires (std::is_same_v<T, float> && channelCount == 2)
 	{
 		assert(index < this->m_frames);
 		return reinterpret_cast<SampleFrame*>(this->m_data)[index];
 	}
 
 	auto sampleFrameAt(f_cnt_t index) const noexcept -> const SampleFrame&
-		requires (std::is_same_v<SampleT, const float> && channelCount == 2)
+		requires (std::is_same_v<T, const float> && channelCount == 2)
 	{
 		assert(index < this->m_frames);
 		return reinterpret_cast<const SampleFrame*>(this->m_data)[index];
 	}
 
 	auto toSampleFrames() noexcept -> std::span<SampleFrame>
-		requires (std::is_same_v<SampleT, float> && channelCount == 2)
+		requires (std::is_same_v<T, float> && channelCount == 2)
 	{
 		return {reinterpret_cast<SampleFrame*>(this->m_data), this->m_frames};
 	}
 
 	auto toSampleFrames() const noexcept -> std::span<const SampleFrame>
-		requires (std::is_same_v<SampleT, const float> && channelCount == 2)
+		requires (std::is_same_v<T, const float> && channelCount == 2)
 	{
 		return {reinterpret_cast<const SampleFrame*>(this->m_data), this->m_frames};
 	}
@@ -465,29 +465,29 @@ static_assert(sizeof(InterleavedBufferView<float, 2>) == sizeof(void*) + sizeof(
 /**
  * Non-owning view for multi-channel non-interleaved audio data
  *
- * The data type is `SampleT* const*` which is a 2D array accessed as data[channel][frame index]
+ * The data type is `T* const*` which is a 2D array accessed as data[channel][frame index]
  * where each channel's buffer contains `frames()` frames.
  *
  * TODO C++23: Use std::mdspan?
  */
-template<SampleType SampleT, proc_ch_t channelCount = DynamicChannelCount>
-class PlanarBufferView : public detail::BufferViewData<SampleT* const, channelCount>
+template<SampleType T, proc_ch_t channelCount = DynamicChannelCount>
+class PlanarBufferView : public detail::BufferViewData<T* const, channelCount>
 {
-	using Base = detail::BufferViewData<SampleT* const, channelCount>;
+	using Base = detail::BufferViewData<T* const, channelCount>;
 
 public:
 	using Base::Base;
 
 	//! Contruct const from mutable (static channel count)
-	template<typename T = SampleT> requires (std::is_const_v<T> && channelCount != DynamicChannelCount)
-	constexpr PlanarBufferView(PlanarBufferView<std::remove_const_t<T>, channelCount> other) noexcept
+	template<typename U = T> requires (std::is_const_v<U> && channelCount != DynamicChannelCount)
+	constexpr PlanarBufferView(PlanarBufferView<std::remove_const_t<U>, channelCount> other) noexcept
 		: Base{other.data(), other.frames()}
 	{
 	}
 
 	//! Contruct const from mutable (dynamic channel count)
-	template<typename T = SampleT> requires (std::is_const_v<T> && channelCount == DynamicChannelCount)
-	constexpr PlanarBufferView(PlanarBufferView<std::remove_const_t<T>, channelCount> other) noexcept
+	template<typename U = T> requires (std::is_const_v<U> && channelCount == DynamicChannelCount)
+	constexpr PlanarBufferView(PlanarBufferView<std::remove_const_t<U>, channelCount> other) noexcept
 		: Base{other.data(), other.channels(), other.frames()}
 	{
 	}
@@ -495,7 +495,7 @@ class PlanarBufferView : public detail::BufferViewData<SampleT* const, channelCo
 	//! Construct dynamic channel count from static
 	template<proc_ch_t otherChannels>
 		requires (channelCount == DynamicChannelCount && otherChannels != DynamicChannelCount)
-	constexpr PlanarBufferView(PlanarBufferView<SampleT, otherChannels> other) noexcept
+	constexpr PlanarBufferView(PlanarBufferView<T, otherChannels> other) noexcept
 		: Base{other.data(), otherChannels, other.frames()}
 	{
 	}
@@ -506,14 +506,14 @@ class PlanarBufferView : public detail::BufferViewData<SampleT* const, channelCo
 	}
 
 	//! @return the buffer of the given channel
-	constexpr auto buffer(proc_ch_t channel) const noexcept -> std::span<SampleT>
+	constexpr auto buffer(proc_ch_t channel) const noexcept -> std::span<T>
 	{
 		return {bufferPtr(channel), this->m_frames};
 	}
 
 	//! @return the buffer of the given channel
 	template<proc_ch_t channel> requires (channelCount != DynamicChannelCount)
-	constexpr auto buffer() const noexcept -> std::span<SampleT>
+	constexpr auto buffer() const noexcept -> std::span<T>
 	{
 		return {bufferPtr<channel>(), this->m_frames};
 	}
@@ -522,7 +522,7 @@ class PlanarBufferView : public detail::BufferViewData<SampleT* const, channelCo
 	 * @return pointer to the buffer of the given channel.
 	 * The size of the buffer is `frames()`.
 	 */
-	constexpr auto bufferPtr(proc_ch_t channel) const noexcept -> SampleT*
+	constexpr auto bufferPtr(proc_ch_t channel) const noexcept -> T*
 	{
 		assert(channel < Base::channels());
 		assert(this->m_data != nullptr);
@@ -534,7 +534,7 @@ class PlanarBufferView : public detail::BufferViewData<SampleT* const, channelCo
 	 * The size of the buffer is `frames()`.
 	 */
 	template<proc_ch_t channel> requires (channelCount != DynamicChannelCount)
-	constexpr auto bufferPtr() const noexcept -> SampleT*
+	constexpr auto bufferPtr() const noexcept -> T*
 	{
 		static_assert(channel < channelCount);
 		assert(this->m_data != nullptr);
@@ -545,7 +545,7 @@ class PlanarBufferView : public detail::BufferViewData<SampleT* const, channelCo
 	 * @return pointer to the buffer of a given channel.
 	 * The size of the buffer is `frames()`.
 	 */
-	constexpr auto operator[](proc_ch_t channel) const noexcept -> SampleT*
+	constexpr auto operator[](proc_ch_t channel) const noexcept -> T*
 	{
 		return bufferPtr(channel);
 	}

From 5b1137e29e7d40466bbc39c4949a1bde0dac1f92 Mon Sep 17 00:00:00 2001
From: Dalton Messmer <messmer.dalton@gmail.com>
Date: Mon, 4 Aug 2025 13:30:29 -0400
Subject: [PATCH 08/10] Simplify InterleavedFrameIterator constructors

---
 include/AudioBufferView.h | 19 +++++--------------
 1 file changed, 5 insertions(+), 14 deletions(-)

diff --git a/include/AudioBufferView.h b/include/AudioBufferView.h
index 61a4df4bce1..427aa32e76c 100644
--- a/include/AudioBufferView.h
+++ b/include/AudioBufferView.h
@@ -104,6 +104,8 @@ class InterleavedFrameIteratorData
 {
 public:
 	constexpr InterleavedFrameIteratorData() = default;
+	constexpr InterleavedFrameIteratorData(const InterleavedFrameIteratorData&) = default;
+
 	constexpr explicit InterleavedFrameIteratorData(T* data) noexcept
 		: m_data{data}
 	{
@@ -121,6 +123,8 @@ class InterleavedFrameIteratorData<T, DynamicChannelCount>
 {
 public:
 	constexpr InterleavedFrameIteratorData() = default;
+	constexpr InterleavedFrameIteratorData(const InterleavedFrameIteratorData&) = default;
+
 	constexpr InterleavedFrameIteratorData(T* data, proc_ch_t channels) noexcept
 		: m_data{data}
 		, m_channels{channels}
@@ -145,20 +149,7 @@ class InterleavedFrameIterator : public InterleavedFrameIteratorData<T, channelC
 	using value_type = T*;
 	using difference_type = std::ptrdiff_t;
 
-	constexpr InterleavedFrameIterator() = default;
-	constexpr InterleavedFrameIterator(const InterleavedFrameIterator&) = default;
-
-	template<typename U = T> requires (channelCount != DynamicChannelCount)
-	constexpr explicit InterleavedFrameIterator(U* data) noexcept
-		: Base{data}
-	{
-	}
-
-	template<typename U = T> requires (channelCount == DynamicChannelCount)
-	constexpr InterleavedFrameIterator(U* data, proc_ch_t channels) noexcept
-		: Base{data, channels}
-	{
-	}
+	using Base::Base;
 
 	constexpr auto operator*() const noexcept -> value_type { return this->m_data; }
 

From f60bc1422983ce3085247e0c2301023ae4beafe5 Mon Sep 17 00:00:00 2001
From: Dalton Messmer <messmer.dalton@gmail.com>
Date: Tue, 5 Aug 2025 04:08:48 -0400
Subject: [PATCH 09/10] Add AudioBufferView

---
 include/AudioBufferView.h | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/include/AudioBufferView.h b/include/AudioBufferView.h
index 427aa32e76c..14b33e66c59 100644
--- a/include/AudioBufferView.h
+++ b/include/AudioBufferView.h
@@ -27,6 +27,7 @@
 #define LMMS_AUDIO_BUFFER_VIEW_H
 
 #include <cassert>
+#include <concepts>
 #include <span>
 #include <type_traits>
 
@@ -446,6 +447,9 @@ class InterleavedBufferView : public detail::BufferViewData<T, channelCount>
 	{
 		return {reinterpret_cast<const SampleFrame*>(this->m_data), this->m_frames};
 	}
+
+	//! Use to distinguish between `InterleavedBufferView` and `PlanarBufferView` when using `AnyBufferView`
+	static constexpr bool Interleaved = true;
 };
 
 // Check that the std::span-like space optimization works
@@ -540,12 +544,21 @@ class PlanarBufferView : public detail::BufferViewData<T* const, channelCount>
 	{
 		return bufferPtr(channel);
 	}
+
+	//! Use to distinguish between `InterleavedBufferView` and `PlanarBufferView` when using `AnyBufferView`
+	static constexpr bool Interleaved = false;
 };
 
 // Check that the std::span-like space optimization works
 static_assert(sizeof(PlanarBufferView<float>) > sizeof(PlanarBufferView<float, 2>));
 static_assert(sizeof(PlanarBufferView<float, 2>) == sizeof(void**) + sizeof(f_cnt_t));
 
+
+//! Concept for any buffer view - interleaved or planar
+template<class T, typename U, proc_ch_t channels = DynamicChannelCount>
+concept AnyBufferView = SampleType<U> && (std::convertible_to<T, InterleavedBufferView<U, channels>>
+	|| std::convertible_to<T, PlanarBufferView<U, channels>>);
+
 } // namespace lmms
 
 #endif // LMMS_AUDIO_BUFFER_VIEW_H

From ee03af82a50d194e91c2d6f2c117a5af1d109c5e Mon Sep 17 00:00:00 2001
From: Dalton Messmer <messmer.dalton@gmail.com>
Date: Wed, 6 Aug 2025 03:37:50 -0400
Subject: [PATCH 10/10] Rename AnyBufferView to AudioBufferView

---
 include/AudioBufferView.h | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/include/AudioBufferView.h b/include/AudioBufferView.h
index 14b33e66c59..f0c0b0864f6 100644
--- a/include/AudioBufferView.h
+++ b/include/AudioBufferView.h
@@ -28,6 +28,7 @@
 
 #include <cassert>
 #include <concepts>
+#include <ranges>
 #include <span>
 #include <type_traits>
 
@@ -448,7 +449,7 @@ class InterleavedBufferView : public detail::BufferViewData<T, channelCount>
 		return {reinterpret_cast<const SampleFrame*>(this->m_data), this->m_frames};
 	}
 
-	//! Use to distinguish between `InterleavedBufferView` and `PlanarBufferView` when using `AnyBufferView`
+	//! Use to distinguish between `InterleavedBufferView` and `PlanarBufferView` when using `AudioBufferView`
 	static constexpr bool Interleaved = true;
 };
 
@@ -545,7 +546,7 @@ class PlanarBufferView : public detail::BufferViewData<T* const, channelCount>
 		return bufferPtr(channel);
 	}
 
-	//! Use to distinguish between `InterleavedBufferView` and `PlanarBufferView` when using `AnyBufferView`
+	//! Use to distinguish between `InterleavedBufferView` and `PlanarBufferView` when using `AudioBufferView`
 	static constexpr bool Interleaved = false;
 };
 
@@ -554,9 +555,9 @@ static_assert(sizeof(PlanarBufferView<float>) > sizeof(PlanarBufferView<float, 2
 static_assert(sizeof(PlanarBufferView<float, 2>) == sizeof(void**) + sizeof(f_cnt_t));
 
 
-//! Concept for any buffer view - interleaved or planar
+//! Concept for any audio buffer view, interleaved or planar
 template<class T, typename U, proc_ch_t channels = DynamicChannelCount>
-concept AnyBufferView = SampleType<U> && (std::convertible_to<T, InterleavedBufferView<U, channels>>
+concept AudioBufferView = SampleType<U> && (std::convertible_to<T, InterleavedBufferView<U, channels>>
 	|| std::convertible_to<T, PlanarBufferView<U, channels>>);
 
 } // namespace lmms