Replace cpp::span shim with std::span

15 files changed, 68 insertions, 69 deletions

diff --git a/src/codecs/CMakeLists.txt b/src/codecs/CMakeLists.txt
index b6481bd1..a1221adf 100644
--- a/src/codecs/CMakeLists.txt
+++ b/src/codecs/CMakeLists.txt
@@ -6,7 +6,7 @@ idf_component_register(
   SRCS "dr_flac.cpp" "codec.cpp" "mad.cpp" "opus.cpp" "vorbis.cpp"
        "source_buffer.cpp" "sample.cpp" "wav.cpp"
   INCLUDE_DIRS "include"
-  REQUIRES "result" "span" "libmad" "drflac" "tremor" "opusfile" "memory" "util"
+  REQUIRES "result" "libmad" "drflac" "tremor" "opusfile" "memory" "util"
        "komihash")
 
 target_compile_options("${COMPONENT_LIB}" PRIVATE ${EXTRA_WARNINGS})
diff --git a/src/codecs/dr_flac.cpp b/src/codecs/dr_flac.cpp
index 2f9acf8c..9341e938 100644
--- a/src/codecs/dr_flac.cpp
+++ b/src/codecs/dr_flac.cpp
@@ -100,7 +100,7 @@ auto DrFlacDecoder::OpenStream(std::shared_ptr<IStream> input, uint32_t offset)
   return format;
 }
 
-auto DrFlacDecoder::DecodeTo(cpp::span<sample::Sample> output)
+auto DrFlacDecoder::DecodeTo(std::span<sample::Sample> output)
     -> cpp::result<OutputInfo, Error> {
   size_t frames_to_read = output.size() / flac_->channels / 2;
 
diff --git a/src/codecs/include/codec.hpp b/src/codecs/include/codec.hpp
index e48e3c58..4d588a98 100644
--- a/src/codecs/include/codec.hpp
+++ b/src/codecs/include/codec.hpp
@@ -6,19 +6,16 @@
 
 #pragma once
 
-#include <stdint.h>
-#include <sys/_stdint.h>
-
 #include <cstddef>
 #include <cstdint>
 #include <memory>
 #include <optional>
+#include <span>
 #include <string>
 #include <utility>
 
 #include "result.hpp"
 #include "sample.hpp"
-#include "span.hpp"
 #include "types.hpp"
 
 #include "memory_resource.hpp"
@@ -35,7 +32,7 @@ class IStream {
 
   auto type() -> StreamType { return t_; }
 
-  virtual auto Read(cpp::span<std::byte> dest) -> ssize_t = 0;
+  virtual auto Read(std::span<std::byte> dest) -> ssize_t = 0;
 
   virtual auto CanSeek() -> bool = 0;
 
@@ -54,7 +51,7 @@ class IStream {
   /*
    * Called by codecs to indicate that they've finished parsing any header data
    * within this stream, and are about to begin decoding.
-   * 
+   *
    * Currently used as a hint to the readahead stream to begin prefetching file
    * data.
    */
@@ -117,7 +114,7 @@ class ICodec {
    * Decodes metadata or headers from the given input stream, and returns the
    * format for the samples that will be decoded from it.
    */
-  virtual auto OpenStream(std::shared_ptr<IStream> input,uint32_t offset)
+  virtual auto OpenStream(std::shared_ptr<IStream> input, uint32_t offset)
       -> cpp::result<OutputFormat, Error> = 0;
 
   struct OutputInfo {
@@ -128,7 +125,7 @@ class ICodec {
   /*
    * Writes PCM samples to the given output buffer.
    */
-  virtual auto DecodeTo(cpp::span<sample::Sample> destination)
+  virtual auto DecodeTo(std::span<sample::Sample> destination)
       -> cpp::result<OutputInfo, Error> = 0;
 };
 
diff --git a/src/codecs/include/dr_flac.hpp b/src/codecs/include/dr_flac.hpp
index 547876f4..ac46e92f 100644
--- a/src/codecs/include/dr_flac.hpp
+++ b/src/codecs/include/dr_flac.hpp
@@ -10,13 +10,13 @@
 #include <cstdint>
 #include <memory>
 #include <optional>
+#include <span>
 #include <string>
 #include <utility>
 
 #include "dr_flac.h"
 #include "sample.hpp"
 #include "source_buffer.hpp"
-#include "span.hpp"
 
 #include "codec.hpp"
 
@@ -27,10 +27,10 @@ class DrFlacDecoder : public ICodec {
   DrFlacDecoder();
   ~DrFlacDecoder();
 
-  auto OpenStream(std::shared_ptr<IStream> input,uint32_t offset)
+  auto OpenStream(std::shared_ptr<IStream> input, uint32_t offset)
       -> cpp::result<OutputFormat, Error> override;
 
-  auto DecodeTo(cpp::span<sample::Sample> destination)
+  auto DecodeTo(std::span<sample::Sample> destination)
       -> cpp::result<OutputInfo, Error> override;
 
   DrFlacDecoder(const DrFlacDecoder&) = delete;
@@ -38,7 +38,7 @@ class DrFlacDecoder : public ICodec {
 
  private:
   std::shared_ptr<IStream> input_;
-  drflac *flac_;
+  drflac* flac_;
 };
 
 }  // namespace codecs
diff --git a/src/codecs/include/mad.hpp b/src/codecs/include/mad.hpp
index ead0b2a2..d1d0aac5 100644
--- a/src/codecs/include/mad.hpp
+++ b/src/codecs/include/mad.hpp
@@ -11,11 +11,11 @@
 #include <optional>
 #include <string>
 #include <utility>
+#include <span>
 
 #include "mad.h"
 #include "sample.hpp"
 #include "source_buffer.hpp"
-#include "span.hpp"
 
 #include "codec.hpp"
 
@@ -29,7 +29,7 @@ class MadMp3Decoder : public ICodec {
   auto OpenStream(std::shared_ptr<IStream> input,uint32_t offset)
       -> cpp::result<OutputFormat, Error> override;
 
-  auto DecodeTo(cpp::span<sample::Sample> destination)
+  auto DecodeTo(std::span<sample::Sample> destination)
       -> cpp::result<OutputInfo, Error> override;
 
   MadMp3Decoder(const MadMp3Decoder&) = delete;
diff --git a/src/codecs/include/opus.hpp b/src/codecs/include/opus.hpp
index de2f7131..200b2d44 100644
--- a/src/codecs/include/opus.hpp
+++ b/src/codecs/include/opus.hpp
@@ -10,12 +10,12 @@
 #include <cstdint>
 #include <memory>
 #include <optional>
+#include <span>
 #include <string>
 #include <utility>
 
 #include "opusfile.h"
 #include "sample.hpp"
-#include "span.hpp"
 
 #include "codec.hpp"
 
@@ -26,10 +26,10 @@ class XiphOpusDecoder : public ICodec {
   XiphOpusDecoder();
   ~XiphOpusDecoder();
 
-  auto OpenStream(std::shared_ptr<IStream> input,uint32_t offset)
+  auto OpenStream(std::shared_ptr<IStream> input, uint32_t offset)
       -> cpp::result<OutputFormat, Error> override;
 
-  auto DecodeTo(cpp::span<sample::Sample> destination)
+  auto DecodeTo(std::span<sample::Sample> destination)
       -> cpp::result<OutputInfo, Error> override;
 
   XiphOpusDecoder(const XiphOpusDecoder&) = delete;
diff --git a/src/codecs/include/source_buffer.hpp b/src/codecs/include/source_buffer.hpp
index 7834834d..6444dd2c 100644
--- a/src/codecs/include/source_buffer.hpp
+++ b/src/codecs/include/source_buffer.hpp
@@ -9,8 +9,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <functional>
-
-#include "span.hpp"
+#include <span>
 
 #include "codec.hpp"
 
@@ -22,15 +21,15 @@ class SourceBuffer {
   ~SourceBuffer();
 
   auto Refill(IStream* src) -> bool;
-  auto AddBytes(std::function<size_t(cpp::span<std::byte>)> writer) -> void;
-  auto ConsumeBytes(std::function<size_t(cpp::span<std::byte>)> reader) -> void;
+  auto AddBytes(std::function<size_t(std::span<std::byte>)> writer) -> void;
+  auto ConsumeBytes(std::function<size_t(std::span<std::byte>)> reader) -> void;
   auto Empty() -> void;
 
   SourceBuffer(const SourceBuffer&) = delete;
   SourceBuffer& operator=(const SourceBuffer&) = delete;
 
  private:
-  const cpp::span<std::byte> buffer_;
+  const std::span<std::byte> buffer_;
   size_t bytes_in_buffer_;
   size_t offset_of_bytes_;
 };
diff --git a/src/codecs/include/vorbis.hpp b/src/codecs/include/vorbis.hpp
index 3cf0f9ce..e6f393dc 100644
--- a/src/codecs/include/vorbis.hpp
+++ b/src/codecs/include/vorbis.hpp
@@ -10,12 +10,12 @@
 #include <cstdint>
 #include <memory>
 #include <optional>
+#include <span>
 #include <string>
 #include <utility>
 
 #include "ivorbisfile.h"
 #include "sample.hpp"
-#include "span.hpp"
 
 #include "codec.hpp"
 
@@ -26,10 +26,10 @@ class TremorVorbisDecoder : public ICodec {
   TremorVorbisDecoder();
   ~TremorVorbisDecoder();
 
-  auto OpenStream(std::shared_ptr<IStream> input,uint32_t offset)
+  auto OpenStream(std::shared_ptr<IStream> input, uint32_t offset)
       -> cpp::result<OutputFormat, Error> override;
 
-  auto DecodeTo(cpp::span<sample::Sample> destination)
+  auto DecodeTo(std::span<sample::Sample> destination)
       -> cpp::result<OutputInfo, Error> override;
 
   TremorVorbisDecoder(const TremorVorbisDecoder&) = delete;
diff --git a/src/codecs/include/wav.hpp b/src/codecs/include/wav.hpp
index 40138968..c09a3bb3 100644
--- a/src/codecs/include/wav.hpp
+++ b/src/codecs/include/wav.hpp
@@ -34,7 +34,7 @@ class WavDecoder : public ICodec {
   auto OpenStream(std::shared_ptr<IStream> input,uint32_t offset)
       -> cpp::result<OutputFormat, Error> override;
 
-  auto DecodeTo(cpp::span<sample::Sample> destination)
+  auto DecodeTo(std::span<sample::Sample> destination)
       -> cpp::result<OutputInfo, Error> override;
 
   WavDecoder(const WavDecoder&) = delete;
diff --git a/src/codecs/mad.cpp b/src/codecs/mad.cpp
index e44e9922..01b2f721 100644
--- a/src/codecs/mad.cpp
+++ b/src/codecs/mad.cpp
@@ -74,7 +74,7 @@ auto MadMp3Decoder::OpenStream(std::shared_ptr<IStream> input, uint32_t offset)
   while (!eof && !got_header) {
     eof = buffer_.Refill(input_.get());
 
-    buffer_.ConsumeBytes([&](cpp::span<std::byte> buf) -> size_t {
+    buffer_.ConsumeBytes([&](std::span<std::byte> buf) -> size_t {
       mad_stream_buffer(stream_.get(),
                         reinterpret_cast<const unsigned char*>(buf.data()),
                         buf.size_bytes());
@@ -130,7 +130,7 @@ auto MadMp3Decoder::OpenStream(std::shared_ptr<IStream> input, uint32_t offset)
     }
     need_refill = false;
 
-    buffer_.ConsumeBytes([&](cpp::span<std::byte> buf) -> size_t {
+    buffer_.ConsumeBytes([&](std::span<std::byte> buf) -> size_t {
       mad_stream_buffer(stream_.get(),
                         reinterpret_cast<const unsigned char*>(buf.data()),
                         buf.size());
@@ -156,13 +156,13 @@ auto MadMp3Decoder::OpenStream(std::shared_ptr<IStream> input, uint32_t offset)
   return output;
 }
 
-auto MadMp3Decoder::DecodeTo(cpp::span<sample::Sample> output)
+auto MadMp3Decoder::DecodeTo(std::span<sample::Sample> output)
     -> cpp::result<OutputInfo, Error> {
   if (current_sample_ < 0 && !is_eos_) {
     if (!is_eof_) {
       is_eof_ = buffer_.Refill(input_.get());
       if (is_eof_) {
-        buffer_.AddBytes([&](cpp::span<std::byte> buf) -> size_t {
+        buffer_.AddBytes([&](std::span<std::byte> buf) -> size_t {
           if (buf.size() < MAD_BUFFER_GUARD) {
             is_eof_ = false;
             return 0;
@@ -174,7 +174,7 @@ auto MadMp3Decoder::DecodeTo(cpp::span<sample::Sample> output)
       }
     }
 
-    buffer_.ConsumeBytes([&](cpp::span<std::byte> buf) -> size_t {
+    buffer_.ConsumeBytes([&](std::span<std::byte> buf) -> size_t {
       mad_stream_buffer(stream_.get(),
                         reinterpret_cast<const unsigned char*>(buf.data()),
                         buf.size());
diff --git a/src/codecs/opus.cpp b/src/codecs/opus.cpp
index a5220c4b..b5e7c3fc 100644
--- a/src/codecs/opus.cpp
+++ b/src/codecs/opus.cpp
@@ -140,7 +140,7 @@ auto XiphOpusDecoder::OpenStream(std::shared_ptr<IStream> input,
   };
 }
 
-auto XiphOpusDecoder::DecodeTo(cpp::span<sample::Sample> output)
+auto XiphOpusDecoder::DecodeTo(std::span<sample::Sample> output)
     -> cpp::result<OutputInfo, Error> {
   int samples_written = op_read_stereo(opus_, output.data(), output.size());
 
diff --git a/src/codecs/source_buffer.cpp b/src/codecs/source_buffer.cpp
index 0a986bc3..538d7f47 100644
--- a/src/codecs/source_buffer.cpp
+++ b/src/codecs/source_buffer.cpp
@@ -39,7 +39,7 @@ auto SourceBuffer::Refill(IStream* src) -> bool {
     return false;
   }
   bool eof = false;
-  AddBytes([&](cpp::span<std::byte> buf) -> size_t {
+  AddBytes([&](std::span<std::byte> buf) -> size_t {
     ssize_t bytes_read = src->Read(buf);
     // Treat read errors as EOF.
     eof = bytes_read <= 0;
@@ -48,7 +48,7 @@ auto SourceBuffer::Refill(IStream* src) -> bool {
   return eof;
 }
 
-auto SourceBuffer::AddBytes(std::function<size_t(cpp::span<std::byte>)> writer)
+auto SourceBuffer::AddBytes(std::function<size_t(std::span<std::byte>)> writer)
     -> void {
   if (offset_of_bytes_ > 0) {
     std::memmove(buffer_.data(), buffer_.data() + offset_of_bytes_,
@@ -61,7 +61,7 @@ auto SourceBuffer::AddBytes(std::function<size_t(cpp::span<std::byte>)> writer)
 }
 
 auto SourceBuffer::ConsumeBytes(
-    std::function<size_t(cpp::span<std::byte>)> reader) -> void {
+    std::function<size_t(std::span<std::byte>)> reader) -> void {
   size_t bytes_consumed = std::invoke(
       reader, buffer_.subspan(offset_of_bytes_, bytes_in_buffer_));
   assert(bytes_consumed <= bytes_in_buffer_);
diff --git a/src/codecs/test/test_mad.cpp b/src/codecs/test/test_mad.cpp
index e8c714e7..15c96eae 100644
--- a/src/codecs/test/test_mad.cpp
+++ b/src/codecs/test/test_mad.cpp
@@ -8,14 +8,14 @@
 
 #include <algorithm>
 #include <cstdint>
+#include <span>
 
 #include "catch2/catch.hpp"
-#include "span.hpp"
 
 #include "test.mp3.hpp"
 
-void load_mp3(cpp::span<std::byte> dest) {
-  cpp::span<std::byte> src(reinterpret_cast<std::byte*>(test_mp3),
+void load_mp3(std::span<std::byte> dest) {
+  std::span<std::byte> src(reinterpret_cast<std::byte*>(test_mp3),
                            test_mp3_len);
   std::copy(src.begin(), src.begin() + dest.size(), dest.begin());
 }
diff --git a/src/codecs/vorbis.cpp b/src/codecs/vorbis.cpp
index 9131451b..0b2af691 100644
--- a/src/codecs/vorbis.cpp
+++ b/src/codecs/vorbis.cpp
@@ -129,7 +129,7 @@ auto TremorVorbisDecoder::OpenStream(std::shared_ptr<IStream> input,
   };
 }
 
-auto TremorVorbisDecoder::DecodeTo(cpp::span<sample::Sample> output)
+auto TremorVorbisDecoder::DecodeTo(std::span<sample::Sample> output)
     -> cpp::result<OutputInfo, Error> {
   int unused = 0;
   long bytes_written =
diff --git a/src/codecs/wav.cpp b/src/codecs/wav.cpp
index 714ec237..f5b9d789 100644
--- a/src/codecs/wav.cpp
+++ b/src/codecs/wav.cpp
@@ -20,24 +20,24 @@ namespace codecs {
 
 [[maybe_unused]] static const char kTag[] = "wav";
 
-static inline auto bytes_to_u16(cpp::span<std::byte const, 2> bytes)
+static inline auto bytes_to_u16(std::span<std::byte const, 2> bytes)
     -> uint16_t {
   return (uint16_t)bytes[0] | (uint16_t)bytes[1] << 8;
 }
 
-static inline auto bytes_to_u32(cpp::span<std::byte const, 4> bytes)
+static inline auto bytes_to_u32(std::span<std::byte const, 4> bytes)
     -> uint32_t {
   return (uint32_t)bytes[0] | (uint32_t)bytes[1] << 8 |
          (uint32_t)bytes[2] << 16 | (uint32_t)bytes[3] << 24;
 }
 
-static inline auto bytes_to_str(cpp::span<std::byte const> bytes)
+static inline auto bytes_to_str(std::span<std::byte const> bytes)
     -> std::string {
   return std::string(reinterpret_cast<const char*>(bytes.data()),
-                    bytes.size_bytes());
+                     bytes.size_bytes());
 }
 
-static int16_t convert_f32_to_16_bit(cpp::span<const std::byte> bytes) {
+static int16_t convert_f32_to_16_bit(std::span<const std::byte> bytes) {
   uint64_t val = 0;
   val = (uint8_t)bytes[3];
   val = (val << 8) | (uint8_t)bytes[2];
@@ -57,7 +57,7 @@ static int16_t convert_f32_to_16_bit(cpp::span<const std::byte> bytes) {
   return sample::FromDouble(*fval);
 }
 
-static int16_t convert_f64_to_16_bit(cpp::span<const std::byte> bytes) {
+static int16_t convert_f64_to_16_bit(std::span<const std::byte> bytes) {
   uint64_t val = 0;
   val = (uint8_t)bytes[7];
   val = (val << 8) | (uint8_t)bytes[6];
@@ -71,7 +71,7 @@ static int16_t convert_f64_to_16_bit(cpp::span<const std::byte> bytes) {
   return sample::FromDouble(*fval);
 }
 
-static int16_t convert_to_16_bit(cpp::span<const std::byte> bytes) {
+static int16_t convert_to_16_bit(std::span<const std::byte> bytes) {
   int depth = bytes.size();
   int32_t val = 0;
   // If 8-bit Assume Unsigned
@@ -82,10 +82,13 @@ static int16_t convert_to_16_bit(cpp::span<const std::byte> bytes) {
   switch (depth) {
     case 4:
       val = (uint8_t)bytes[3];
+      [[fallthrough]];
     case 3:
       val = (val << 8) | (uint8_t)bytes[2];
+      [[fallthrough]];
     case 2:
       val = (val << 8) | (uint8_t)bytes[1];
+      [[fallthrough]];
     case 1:
       val = (val << 8) | (uint8_t)bytes[0];
   }
@@ -98,7 +101,7 @@ WavDecoder::WavDecoder() : input_(), buffer_() {}
 
 WavDecoder::~WavDecoder() {}
 
-auto WavDecoder::OpenStream(std::shared_ptr<IStream> input,uint32_t offset)
+auto WavDecoder::OpenStream(std::shared_ptr<IStream> input, uint32_t offset)
     -> cpp::result<OutputFormat, Error> {
   input_ = input;
 
@@ -123,7 +126,7 @@ auto WavDecoder::OpenStream(std::shared_ptr<IStream> input,uint32_t offset)
   // - end of this part, next header we care about is 'data'
   // - and then the next 4 bytes = 32 bit int = size of data
 
-  auto buffer_span = cpp::span{buf};
+  auto buffer_span = std::span{buf};
 
   std::string riff = bytes_to_str(buffer_span.subspan(0, 4));
   if (riff != "RIFF") {
@@ -131,7 +134,7 @@ auto WavDecoder::OpenStream(std::shared_ptr<IStream> input,uint32_t offset)
     return cpp::fail(Error::kMalformedData);
   }
 
-  uint32_t file_size = bytes_to_u32(buffer_span.subspan(4, 4)) + 8;
+  // uint32_t file_size = bytes_to_u32(buffer_span.subspan(4, 4)) + 8;
 
   std::string fmt_header = bytes_to_str(buffer_span.subspan(12, 4));
   ESP_LOGI(kTag, "fmt header found? %s",
@@ -142,9 +145,9 @@ auto WavDecoder::OpenStream(std::shared_ptr<IStream> input,uint32_t offset)
   }
 
   // Size of the fmt header, should be 16, 18 or 40
-  uint32_t fmt_header_size = bytes_to_u32(buffer_span.subspan(16, 4));
+  // uint32_t fmt_header_size = bytes_to_u32(buffer_span.subspan(16, 4));
 
-  wave_format_ = bytes_to_u16(buffer_span.subspan(20, 2));
+  wave_format_ = bytes_to_u16(buffer_span.subspan<20, 2>());
   if (wave_format_ == kWaveFormatPCM) {
     ESP_LOGD(kTag, "wave format: PCM");
   } else if (wave_format_ == kWaveFormatExtensible) {
@@ -156,17 +159,17 @@ auto WavDecoder::OpenStream(std::shared_ptr<IStream> input,uint32_t offset)
     return cpp::fail(Error::kUnsupportedFormat);
   }
 
-  num_channels_ = bytes_to_u16(buffer_span.subspan(22, 2));
+  num_channels_ = bytes_to_u16(buffer_span.subspan<22, 2>());
 
-  uint32_t samples_per_second = bytes_to_u32(buffer_span.subspan(24, 4));
+  uint32_t samples_per_second = bytes_to_u32(buffer_span.subspan<24, 4>());
 
-  uint32_t avg_bytes_per_second = bytes_to_u32(buffer_span.subspan(28, 4));
+  // uint32_t avg_bytes_per_second = bytes_to_u32(buffer_span.subspan(28, 4));
 
-  uint16_t block_align = bytes_to_u16(buffer_span.subspan(32, 2));
+  uint16_t block_align = bytes_to_u16(buffer_span.subspan<32, 2>());
 
   bytes_per_sample_ = block_align / num_channels_;
 
-  uint16_t bits_per_sample = bytes_to_u16(buffer_span.subspan(34, 2));
+  // uint16_t bits_per_sample = bytes_to_u16(buffer_span.subspan(34, 2));
 
   // find the start of the data chunk
   std::array<std::byte, 4> data_tag = {std::byte{0x64}, std::byte{0x61},
@@ -180,7 +183,7 @@ auto WavDecoder::OpenStream(std::shared_ptr<IStream> input,uint32_t offset)
   int data_chunk_index = std::distance(buffer_span.begin(), data_loc.begin());
 
   uint32_t data_chunk_size =
-      bytes_to_u32(buffer_span.subspan(data_chunk_index + 4, 4));
+      bytes_to_u32(buffer_span.subspan(data_chunk_index + 4, 4).first<4>());
 
   // calculate number of samples
   int number_of_samples = data_chunk_size / bytes_per_sample_;
@@ -188,20 +191,20 @@ auto WavDecoder::OpenStream(std::shared_ptr<IStream> input,uint32_t offset)
   // extension to the fmt chunk size (0 or 22)
   uint16_t extension_size = 0;
   if (wave_format_ == kWaveFormatExtensible) {
-    extension_size = bytes_to_u16(buffer_span.subspan(36, 2));
+    extension_size = bytes_to_u16(buffer_span.subspan<36, 2>());
   }
 
   // Parse extension if applicable
   if (extension_size == 22) {
     // Valid bits per sample
-    uint16_t valid_bits_per_sample = bytes_to_u16(buffer_span.subspan(38, 2));
+    // uint16_t valid_bits_per_sample = bytes_to_u16(buffer_span.subspan(38,
+    // 2));
 
-    uint32_t speaker_mask = bytes_to_u32(buffer_span.subspan(40, 4));
+    // uint32_t speaker_mask = bytes_to_u32(buffer_span.subspan(40, 4));
 
     // Parse subformat
-    subformat_ = bytes_to_u16(buffer_span.subspan(44, 2));
-    if (!(subformat_ == kWaveFormatPCM ||
-          subformat_ == kWaveFormatIEEEFloat)) {
+    subformat_ = bytes_to_u16(buffer_span.subspan<44, 2>());
+    if (!(subformat_ == kWaveFormatPCM || subformat_ == kWaveFormatIEEEFloat)) {
       ESP_LOGW(kTag, "WAVE extensible subformat_ not supported");
       return cpp::fail(Error::kUnsupportedFormat);
     }
@@ -210,7 +213,8 @@ auto WavDecoder::OpenStream(std::shared_ptr<IStream> input,uint32_t offset)
   int64_t data_offset = offset * samples_per_second * bytes_per_sample_;
 
   // Seek track to start of data
-  input->SeekTo(data_chunk_index + 8 + data_offset, IStream::SeekFrom::kStartOfStream);
+  input->SeekTo(data_chunk_index + 8 + data_offset,
+                IStream::SeekFrom::kStartOfStream);
 
   output_format_ = {.num_channels = (uint8_t)num_channels_,
                     .sample_rate_hz = samples_per_second,
@@ -219,12 +223,12 @@ auto WavDecoder::OpenStream(std::shared_ptr<IStream> input,uint32_t offset)
   return output_format_;
 }
 
-auto WavDecoder::DecodeTo(cpp::span<sample::Sample> output)
+auto WavDecoder::DecodeTo(std::span<sample::Sample> output)
     -> cpp::result<OutputInfo, Error> {
   bool is_eof = buffer_.Refill(input_.get());
   size_t samples_written = 0;
 
-  buffer_.ConsumeBytes([&](cpp::span<std::byte> buf) -> size_t {
+  buffer_.ConsumeBytes([&](std::span<std::byte> buf) -> size_t {
     size_t bytes_read = buf.size_bytes();
     size_t frames_read =
         bytes_read / bytes_per_sample_ / output_format_.num_channels;
@@ -254,7 +258,6 @@ auto WavDecoder::DecodeTo(cpp::span<sample::Sample> output)
     return samples_written * bytes_per_sample_;
   });
 
-
   return OutputInfo{.samples_written = samples_written,
                     .is_stream_finished = samples_written == 0 && is_eof};
 }