From f011fc280b139e3019bd129603b9bb0da3ad0c3f Mon Sep 17 00:00:00 2001
From: atok <atoktoto@fastmail.fm>
Date: Sat, 23 Dec 2023 18:42:37 +0100
Subject: [PATCH 01/22] Explicit std, alloc and core dependencies

---
 symphonia-core/Cargo.toml                    |  3 ++-
 symphonia-core/src/audio.rs                  | 12 ++++++----
 symphonia-core/src/checksum/md5.rs           |  2 +-
 symphonia-core/src/codecs.rs                 |  5 ++--
 symphonia-core/src/conv.rs                   |  4 ++--
 symphonia-core/src/dsp/fft.rs                | 10 ++++----
 symphonia-core/src/dsp/mdct/simd.rs          |  7 ++++--
 symphonia-core/src/errors.rs                 |  4 ++--
 symphonia-core/src/formats.rs                |  4 ++++
 symphonia-core/src/io/bit.rs                 | 24 +++++++++++---------
 symphonia-core/src/io/buf_reader.rs          |  2 +-
 symphonia-core/src/io/media_source_stream.rs | 13 +++++++----
 symphonia-core/src/io/mod.rs                 |  6 +++--
 symphonia-core/src/io/scoped_stream.rs       |  6 ++---
 symphonia-core/src/lib.rs                    |  4 ++++
 symphonia-core/src/meta.rs                   | 14 ++++++++----
 symphonia-core/src/probe.rs                  |  6 +++++
 symphonia-core/src/sample.rs                 |  2 +-
 symphonia-core/src/units.rs                  | 12 +++++-----
 symphonia-core/src/util.rs                   |  2 +-
 20 files changed, 89 insertions(+), 53 deletions(-)

diff --git a/symphonia-core/Cargo.toml b/symphonia-core/Cargo.toml
index 4db81690..54e5666e 100644
--- a/symphonia-core/Cargo.toml
+++ b/symphonia-core/Cargo.toml
@@ -13,7 +13,8 @@ edition = "2018"
 rust-version = "1.53"
 
 [features]
-default = []
+default = ["std"]
+std = []
 
 # SIMD support.
 opt-simd-sse = ["rustfft/sse"]
diff --git a/symphonia-core/src/audio.rs b/symphonia-core/src/audio.rs
index 36f431d2..b8f93a42 100644
--- a/symphonia-core/src/audio.rs
+++ b/symphonia-core/src/audio.rs
@@ -8,11 +8,13 @@
 //! The `audio` module provides primitives for working with multi-channel audio buffers of varying
 //! sample formats.
 
-use std::borrow::Cow;
-use std::fmt;
-use std::marker::PhantomData;
-use std::mem;
-use std::vec::Vec;
+use alloc::borrow::Cow;
+use alloc::boxed::Box;
+use alloc::vec;
+use core::fmt;
+use core::marker::PhantomData;
+use core::mem;
+use alloc::vec::Vec;
 
 use arrayvec::ArrayVec;
 use bitflags::bitflags;
diff --git a/symphonia-core/src/checksum/md5.rs b/symphonia-core/src/checksum/md5.rs
index 3f44a25b..1834eae0 100644
--- a/symphonia-core/src/checksum/md5.rs
+++ b/symphonia-core/src/checksum/md5.rs
@@ -5,7 +5,7 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use std::cmp;
+use core::cmp;
 
 use crate::io::Monitor;
 
diff --git a/symphonia-core/src/codecs.rs b/symphonia-core/src/codecs.rs
index 31feb1de..97907413 100644
--- a/symphonia-core/src/codecs.rs
+++ b/symphonia-core/src/codecs.rs
@@ -8,9 +8,10 @@
 //! The `codec` module provides the traits and support structures necessary to implement audio codec
 //! decoders.
 
+use alloc::boxed::Box;
 use std::collections::HashMap;
-use std::default::Default;
-use std::fmt;
+use core::default::Default;
+use core::fmt;
 
 use crate::audio::{AudioBufferRef, Channels, Layout};
 use crate::errors::{unsupported_error, Result};
diff --git a/symphonia-core/src/conv.rs b/symphonia-core/src/conv.rs
index c41fec3a..408de30b 100644
--- a/symphonia-core/src/conv.rs
+++ b/symphonia-core/src/conv.rs
@@ -28,7 +28,7 @@ pub mod dither {
     use super::FromSample;
     use crate::sample::Sample;
     use crate::sample::{i24, u24};
-    use std::marker::PhantomData;
+    use core::marker::PhantomData;
 
     mod prng {
         #[inline]
@@ -679,7 +679,7 @@ impl<S> ConvertibleSample for S where
 mod tests {
     use super::FromSample;
     use crate::sample::{i24, u24, Sample};
-    use std::{i16, i32, i8, u16, u32, u8};
+    use core::{i16, i32, i8, u16, u32, u8};
 
     #[test]
     fn verify_u8_from_sample() {
diff --git a/symphonia-core/src/dsp/fft.rs b/symphonia-core/src/dsp/fft.rs
index 350ce468..29e375cd 100644
--- a/symphonia-core/src/dsp/fft.rs
+++ b/symphonia-core/src/dsp/fft.rs
@@ -10,8 +10,9 @@
 //! The complex (I)FFT in this module supports a size up-to 65536. The FFT is implemented using the
 //! radix-2 Cooley-Tukey algorithm.
 
-use std::convert::TryInto;
-use std::f32;
+use alloc::boxed::Box;
+use core::convert::TryInto;
+use core::f32;
 
 use lazy_static::lazy_static;
 
@@ -25,7 +26,7 @@ macro_rules! fft_twiddle_table {
 
                 let mut table = [Default::default(); N >> 1];
 
-                let theta = std::f64::consts::PI / (N >> 1) as f64;
+                let theta = core::f64::consts::PI / (N >> 1) as f64;
 
                 for (k, t) in table.iter_mut().enumerate() {
                     let angle = theta * k as f64;
@@ -408,8 +409,9 @@ fn fft2(x: &mut [Complex; 2]) {
 
 #[cfg(test)]
 mod tests {
+    use alloc::vec::Vec;
     use super::*;
-    use std::f64;
+    use core::f64;
 
     /// Compute a naive DFT.
     fn dft_naive(x: &[Complex], y: &mut [Complex]) {
diff --git a/symphonia-core/src/dsp/mdct/simd.rs b/symphonia-core/src/dsp/mdct/simd.rs
index 502095d6..621b5de5 100644
--- a/symphonia-core/src/dsp/mdct/simd.rs
+++ b/symphonia-core/src/dsp/mdct/simd.rs
@@ -7,7 +7,10 @@
 
 //! The Modified Discrete Cosine Transform (MDCT) implemented with SIMD optimizations.
 
-use std::sync::Arc;
+use alloc::boxed::Box;
+use alloc::vec::Vec;
+use alloc::sync::Arc;
+use alloc::vec;
 
 use rustfft::num_complex::Complex;
 
@@ -42,7 +45,7 @@ impl Imdct {
         let mut twiddle = Vec::with_capacity(n2);
 
         let alpha = 1.0 / 8.0 + if scale.is_sign_positive() { 0.0 } else { n2 as f64 };
-        let pi_n = std::f64::consts::PI / n as f64;
+        let pi_n = core::f64::consts::PI / n as f64;
         let sqrt_scale = scale.abs().sqrt();
 
         for k in 0..n2 {
diff --git a/symphonia-core/src/errors.rs b/symphonia-core/src/errors.rs
index 7959b3b9..ae2565cf 100644
--- a/symphonia-core/src/errors.rs
+++ b/symphonia-core/src/errors.rs
@@ -8,9 +8,9 @@
 //! The `errors` module defines the common error type.
 
 use std::error;
-use std::fmt;
+use core::fmt;
 use std::io;
-use std::result;
+use core::result;
 
 /// `SeekErrorKind` is a list of generic reasons why a seek may fail.
 #[derive(Debug)]
diff --git a/symphonia-core/src/formats.rs b/symphonia-core/src/formats.rs
index 58158f31..e91203ee 100644
--- a/symphonia-core/src/formats.rs
+++ b/symphonia-core/src/formats.rs
@@ -8,6 +8,9 @@
 //! The `format` module provides the traits and support structures necessary to implement media
 //! demuxers.
 
+use alloc::boxed::Box;
+use alloc::string::String;
+use alloc::vec::Vec;
 use crate::codecs::CodecParameters;
 use crate::errors::Result;
 use crate::io::{BufReader, MediaSourceStream};
@@ -327,6 +330,7 @@ impl Packet {
 pub mod util {
     //! Helper utilities for implementing `FormatReader`s.
 
+    use alloc::vec::Vec;
     use super::Packet;
 
     /// A `SeekPoint` is a mapping between a sample or frame number to byte offset within a media
diff --git a/symphonia-core/src/io/bit.rs b/symphonia-core/src/io/bit.rs
index 82cbe32e..5be17d0a 100644
--- a/symphonia-core/src/io/bit.rs
+++ b/symphonia-core/src/io/bit.rs
@@ -5,7 +5,7 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use std::cmp::min;
+use core::cmp::min;
 use std::io;
 
 use crate::io::ReadBytes;
@@ -18,9 +18,10 @@ fn end_of_bitstream_error<T>() -> io::Result<T> {
 pub mod vlc {
     //! The `vlc` module provides support for decoding variable-length codes (VLC).
 
-    use std::cmp::max;
-    use std::collections::{BTreeMap, VecDeque};
+    use core::cmp::max;
+    use alloc::collections::{BTreeMap, VecDeque};
     use std::io;
+    use alloc::vec::Vec;
 
     fn codebook_error<T>(desc: &'static str) -> io::Result<T> {
         Err(io::Error::new(io::ErrorKind::Other, desc))
@@ -957,7 +958,7 @@ impl<'a> BitReaderLtr<'a> {
 impl<'a> private::FetchBitsLtr for BitReaderLtr<'a> {
     #[inline]
     fn fetch_bits_partial(&mut self) -> io::Result<()> {
-        let mut buf = [0u8; std::mem::size_of::<u64>()];
+        let mut buf = [0u8; core::mem::size_of::<u64>()];
 
         let read_len = min(self.buf.len(), (u64::BITS - self.n_bits_left) as usize >> 3);
 
@@ -972,9 +973,9 @@ impl<'a> private::FetchBitsLtr for BitReaderLtr<'a> {
     }
 
     fn fetch_bits(&mut self) -> io::Result<()> {
-        let mut buf = [0u8; std::mem::size_of::<u64>()];
+        let mut buf = [0u8; core::mem::size_of::<u64>()];
 
-        let read_len = min(self.buf.len(), std::mem::size_of::<u64>());
+        let read_len = min(self.buf.len(), core::mem::size_of::<u64>());
 
         if read_len == 0 {
             return end_of_bitstream_error();
@@ -1406,7 +1407,7 @@ impl<'a> BitReaderRtl<'a> {
 impl<'a> private::FetchBitsRtl for BitReaderRtl<'a> {
     #[inline]
     fn fetch_bits_partial(&mut self) -> io::Result<()> {
-        let mut buf = [0u8; std::mem::size_of::<u64>()];
+        let mut buf = [0u8; core::mem::size_of::<u64>()];
 
         let read_len = min(self.buf.len(), (u64::BITS - self.n_bits_left) as usize >> 3);
 
@@ -1421,9 +1422,9 @@ impl<'a> private::FetchBitsRtl for BitReaderRtl<'a> {
     }
 
     fn fetch_bits(&mut self) -> io::Result<()> {
-        let mut buf = [0u8; std::mem::size_of::<u64>()];
+        let mut buf = [0u8; core::mem::size_of::<u64>()];
 
-        let read_len = min(self.buf.len(), std::mem::size_of::<u64>());
+        let read_len = min(self.buf.len(), core::mem::size_of::<u64>());
 
         if read_len == 0 {
             return end_of_bitstream_error();
@@ -1466,6 +1467,7 @@ impl<'a> FiniteBitStream for BitReaderRtl<'a> {
 
 #[cfg(test)]
 mod tests {
+    use alloc::vec::Vec;
     use super::vlc::{BitOrder, Codebook, CodebookBuilder, Entry8x8};
     use super::{BitReaderLtr, ReadBitsLtr};
     use super::{BitReaderRtl, ReadBitsRtl};
@@ -1830,7 +1832,7 @@ mod tests {
         let decoded: Vec<u8> =
             (0..text.len()).into_iter().map(|_| bs.read_codebook(&codebook).unwrap().0).collect();
 
-        assert_eq!(text, std::str::from_utf8(&decoded).unwrap());
+        assert_eq!(text, core::str::from_utf8(&decoded).unwrap());
     }
 
     // BitStreamRtl
@@ -2126,6 +2128,6 @@ mod tests {
         let decoded: Vec<u8> =
             (0..text.len()).into_iter().map(|_| bs.read_codebook(&codebook).unwrap().0).collect();
 
-        assert_eq!(text, std::str::from_utf8(&decoded).unwrap());
+        assert_eq!(text, core::str::from_utf8(&decoded).unwrap());
     }
 }
diff --git a/symphonia-core/src/io/buf_reader.rs b/symphonia-core/src/io/buf_reader.rs
index fbbf860b..3cb84e21 100644
--- a/symphonia-core/src/io/buf_reader.rs
+++ b/symphonia-core/src/io/buf_reader.rs
@@ -5,7 +5,7 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use std::cmp;
+use core::cmp;
 use std::io;
 
 use super::{FiniteStream, ReadBytes};
diff --git a/symphonia-core/src/io/media_source_stream.rs b/symphonia-core/src/io/media_source_stream.rs
index a5bbb234..c3f8877b 100644
--- a/symphonia-core/src/io/media_source_stream.rs
+++ b/symphonia-core/src/io/media_source_stream.rs
@@ -5,10 +5,12 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use std::cmp;
+use alloc::boxed::Box;
+use alloc::vec;
+use core::cmp;
 use std::io;
 use std::io::{IoSliceMut, Read, Seek};
-use std::ops::Sub;
+use core::ops::Sub;
 
 use super::SeekBuffered;
 use super::{MediaSource, ReadBytes};
@@ -436,12 +438,12 @@ impl SeekBuffered for MediaSourceStream {
 
         // Forward seek.
         let delta = if pos > old_pos {
-            assert!(pos - old_pos < std::isize::MAX as u64);
+            assert!(pos - old_pos < core::isize::MAX as u64);
             (pos - old_pos) as isize
         }
         else if pos < old_pos {
             // Backward seek.
-            assert!(old_pos - pos < std::isize::MAX as u64);
+            assert!(old_pos - pos < core::isize::MAX as u64);
             -((old_pos - pos) as isize)
         }
         else {
@@ -467,6 +469,9 @@ impl SeekBuffered for MediaSourceStream {
 
 #[cfg(test)]
 mod tests {
+    use alloc::boxed::Box;
+    use alloc::vec;
+    use alloc::vec::Vec;
     use super::{MediaSourceStream, ReadBytes, SeekBuffered};
     use std::io::{Cursor, Read};
 
diff --git a/symphonia-core/src/io/mod.rs b/symphonia-core/src/io/mod.rs
index e301cfcf..75da23be 100644
--- a/symphonia-core/src/io/mod.rs
+++ b/symphonia-core/src/io/mod.rs
@@ -19,8 +19,10 @@
 //! either the [`ReadBitsLtr`] or [`ReadBitsRtl`] traits depending on the order in which they
 //! consume bits.
 
+use alloc::boxed::Box;
+use alloc::vec;
 use std::io;
-use std::mem;
+use core::mem;
 
 mod bit;
 mod buf_reader;
@@ -475,7 +477,7 @@ pub trait SeekBuffered {
     /// This function is identical to [`SeekBuffered::seek_buffered_rel`] when a negative delta is
     /// provided.
     fn seek_buffered_rev(&mut self, delta: usize) {
-        assert!(delta < std::isize::MAX as usize);
+        assert!(delta < core::isize::MAX as usize);
         self.seek_buffered_rel(-(delta as isize));
     }
 }
diff --git a/symphonia-core/src/io/scoped_stream.rs b/symphonia-core/src/io/scoped_stream.rs
index 12106062..3d2a09cc 100644
--- a/symphonia-core/src/io/scoped_stream.rs
+++ b/symphonia-core/src/io/scoped_stream.rs
@@ -5,7 +5,7 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use std::cmp;
+use core::cmp;
 use std::io;
 
 use super::{FiniteStream, ReadBytes, SeekBuffered};
@@ -184,8 +184,8 @@ impl<B: ReadBytes + SeekBuffered> SeekBuffered for ScopedStream<B> {
     fn seek_buffered_rel(&mut self, delta: isize) -> u64 {
         // Clamp the delta value such that the absolute position after the buffered seek will be
         // within the bounds of the ScopedStream.
-        let max_back = self.read.min(std::isize::MAX as u64) as isize;
-        let max_forward = (self.len - self.read).min(std::isize::MAX as u64) as isize;
+        let max_back = self.read.min(core::isize::MAX as u64) as isize;
+        let max_forward = (self.len - self.read).min(core::isize::MAX as u64) as isize;
         self.inner.seek_buffered_rel(delta.clamp(-max_back, max_forward))
     }
 }
diff --git a/symphonia-core/src/lib.rs b/symphonia-core/src/lib.rs
index 81b0f76f..2adc5301 100644
--- a/symphonia-core/src/lib.rs
+++ b/symphonia-core/src/lib.rs
@@ -1,3 +1,4 @@
+#![no_std]
 // Symphonia
 // Copyright (c) 2019-2022 The Project Symphonia Developers.
 //
@@ -12,6 +13,9 @@
 #![allow(clippy::identity_op)]
 #![allow(clippy::manual_range_contains)]
 
+extern crate alloc;
+extern crate std;
+
 pub mod audio;
 pub mod checksum;
 pub mod codecs;
diff --git a/symphonia-core/src/meta.rs b/symphonia-core/src/meta.rs
index c1e30fd8..f3fac2bc 100644
--- a/symphonia-core/src/meta.rs
+++ b/symphonia-core/src/meta.rs
@@ -7,11 +7,15 @@
 
 //! The `meta` module defines basic metadata elements, and management structures.
 
-use std::borrow::Cow;
-use std::collections::VecDeque;
-use std::convert::From;
-use std::fmt;
-use std::num::NonZeroU32;
+use alloc::boxed::Box;
+use alloc::string::String;
+use alloc::vec::Vec;
+use alloc::borrow::Cow;
+use alloc::collections::VecDeque;
+use core::convert::From;
+use core::fmt;
+use core::num::NonZeroU32;
+use alloc::string::ToString;
 
 use crate::errors::Result;
 use crate::io::MediaSourceStream;
diff --git a/symphonia-core/src/probe.rs b/symphonia-core/src/probe.rs
index 823d19de..8156e425 100644
--- a/symphonia-core/src/probe.rs
+++ b/symphonia-core/src/probe.rs
@@ -8,6 +8,10 @@
 //! The `probe` module provides methods and traits to support auto-detection of media formats from
 //! arbitrary media streams.
 
+use alloc::boxed::Box;
+use alloc::string::String;
+use alloc::vec::Vec;
+use alloc::borrow::ToOwned;
 use crate::errors::{unsupported_error, Result};
 use crate::formats::{FormatOptions, FormatReader};
 use crate::io::{MediaSourceStream, ReadBytes, SeekBuffered};
@@ -16,6 +20,8 @@ use crate::meta::{Metadata, MetadataLog, MetadataOptions, MetadataReader};
 use log::{debug, error, info};
 
 mod bloom {
+    use alloc::boxed::Box;
+    use alloc::vec;
 
     fn fnv1a32(value: &[u8; 2]) -> u32 {
         const INIT: u32 = 0x811c_9dc5;
diff --git a/symphonia-core/src/sample.rs b/symphonia-core/src/sample.rs
index eafb87af..bd195373 100644
--- a/symphonia-core/src/sample.rs
+++ b/symphonia-core/src/sample.rs
@@ -7,7 +7,7 @@
 
 //! The `sample` module defines the core audio sample trait and any non-primitive sample data types.
 
-use std::fmt;
+use core::fmt;
 
 use crate::util::clamp::{clamp_f32, clamp_f64, clamp_i24, clamp_u24};
 
diff --git a/symphonia-core/src/units.rs b/symphonia-core/src/units.rs
index 12fc4a7e..5a47dd2b 100644
--- a/symphonia-core/src/units.rs
+++ b/symphonia-core/src/units.rs
@@ -7,7 +7,7 @@
 
 //! The `units` module provides definitions for common units.
 
-use std::fmt;
+use core::fmt;
 
 /// A `TimeStamp` represents an instantenous instant in time since the start of a stream. One
 /// `TimeStamp` "tick" is equivalent to the stream's `TimeBase` in seconds.
@@ -118,15 +118,15 @@ impl From<f64> for Time {
     }
 }
 
-impl From<std::time::Duration> for Time {
-    fn from(duration: std::time::Duration) -> Self {
+impl From<core::time::Duration> for Time {
+    fn from(duration: core::time::Duration) -> Self {
         Time::new(duration.as_secs(), f64::from(duration.subsec_nanos()) / 1_000_000_000.0)
     }
 }
 
-impl From<Time> for std::time::Duration {
+impl From<Time> for core::time::Duration {
     fn from(time: Time) -> Self {
-        std::time::Duration::new(time.seconds, (1_000_000_000.0 * time.frac) as u32)
+        core::time::Duration::new(time.seconds, (1_000_000_000.0 * time.frac) as u32)
     }
 }
 
@@ -243,7 +243,7 @@ impl fmt::Display for TimeBase {
 #[cfg(test)]
 mod tests {
     use super::{Time, TimeBase};
-    use std::time::Duration;
+    use core::time::Duration;
 
     #[test]
     fn verify_timebase() {
diff --git a/symphonia-core/src/util.rs b/symphonia-core/src/util.rs
index 30e8af78..c9cb406a 100644
--- a/symphonia-core/src/util.rs
+++ b/symphonia-core/src/util.rs
@@ -331,7 +331,7 @@ pub mod clamp {
     #[cfg(test)]
     mod tests {
         use super::*;
-        use std::{i16, i32, i64, i8, u16, u32, u64, u8};
+        use core::{i16, i32, i64, i8, u16, u32, u64, u8};
 
         #[test]
         fn verify_clamp() {

From 7405c30f16fb43397da45186bd31f7a646fa2cf7 Mon Sep 17 00:00:00 2001
From: atok <atoktoto@fastmail.fm>
Date: Sat, 23 Dec 2023 23:01:39 +0100
Subject: [PATCH 02/22] symphonia-core no_std (still requires alloc)

---
 rust-toolchain.toml                          |   2 +
 symphonia-bundle-flac/src/demuxer.rs         |   2 -
 symphonia-bundle-mp3/src/demuxer.rs          |   1 -
 symphonia-bundle-mp3/src/layer3/mod.rs       |   4 +-
 symphonia-check/src/main.rs                  |   4 +-
 symphonia-codec-aac/src/aac/codebooks.rs     |   7 +-
 symphonia-codec-aac/src/adts.rs              |   3 +-
 symphonia-codec-vorbis/src/floor.rs          |   6 +-
 symphonia-codec-vorbis/src/residue.rs        |   4 +-
 symphonia-core/src/codecs.rs                 |   8 +-
 symphonia-core/src/errors.rs                 | 213 ++++++++++++++++++-
 symphonia-core/src/io/bit.rs                 |  95 +++++----
 symphonia-core/src/io/buf_reader.rs          |  29 +--
 symphonia-core/src/io/media_source_stream.rs |  94 +++++---
 symphonia-core/src/io/mod.rs                 | 202 +++++++++++++-----
 symphonia-core/src/io/monitor_stream.rs      |  18 +-
 symphonia-core/src/io/scoped_stream.rs       |  25 +--
 symphonia-core/src/lib.rs                    |   4 +
 symphonia-format-isomp4/src/demuxer.rs       |   3 +-
 symphonia-format-mkv/src/demuxer.rs          |   3 +-
 symphonia-format-mkv/src/ebml.rs             |   4 +-
 symphonia-format-ogg/src/demuxer.rs          |   5 +-
 symphonia-format-ogg/src/page.rs             |   6 +-
 symphonia-format-ogg/src/physical.rs         |   3 +-
 symphonia-format-riff/src/aiff/mod.rs        |   2 -
 symphonia-format-riff/src/wave/mod.rs        |   2 -
 symphonia-format-wav/src/lib.rs              |   2 -
 symphonia-metadata/src/id3v2/frames.rs       |   2 +-
 symphonia-metadata/src/id3v2/unsync.rs       |  16 +-
 symphonia-play/src/main.rs                   |   7 +-
 symphonia/examples/getting-started.rs        |   2 +-
 31 files changed, 541 insertions(+), 237 deletions(-)
 create mode 100644 rust-toolchain.toml

diff --git a/rust-toolchain.toml b/rust-toolchain.toml
new file mode 100644
index 00000000..271800cb
--- /dev/null
+++ b/rust-toolchain.toml
@@ -0,0 +1,2 @@
+[toolchain]
+channel = "nightly"
\ No newline at end of file
diff --git a/symphonia-bundle-flac/src/demuxer.rs b/symphonia-bundle-flac/src/demuxer.rs
index 2ae595f9..1ae73ad8 100644
--- a/symphonia-bundle-flac/src/demuxer.rs
+++ b/symphonia-bundle-flac/src/demuxer.rs
@@ -5,8 +5,6 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use std::io::{Seek, SeekFrom};
-
 use symphonia_core::support_format;
 
 use symphonia_core::codecs::{CodecParameters, VerificationCheck, CODEC_TYPE_FLAC};
diff --git a/symphonia-bundle-mp3/src/demuxer.rs b/symphonia-bundle-mp3/src/demuxer.rs
index ee389ec2..e50023a4 100644
--- a/symphonia-bundle-mp3/src/demuxer.rs
+++ b/symphonia-bundle-mp3/src/demuxer.rs
@@ -18,7 +18,6 @@ use symphonia_core::probe::{Descriptor, Instantiate, QueryDescriptor};
 use crate::common::{FrameHeader, MpegLayer};
 use crate::header::{self, MAX_MPEG_FRAME_SIZE, MPEG_HEADER_LEN};
 
-use std::io::{Seek, SeekFrom};
 
 use log::{debug, info, warn};
 
diff --git a/symphonia-bundle-mp3/src/layer3/mod.rs b/symphonia-bundle-mp3/src/layer3/mod.rs
index d1257486..1108a9a3 100644
--- a/symphonia-bundle-mp3/src/layer3/mod.rs
+++ b/symphonia-bundle-mp3/src/layer3/mod.rs
@@ -8,7 +8,7 @@
 use std::fmt;
 
 use symphonia_core::audio::{AudioBuffer, Signal};
-use symphonia_core::errors::{decode_error, Error, Result};
+use symphonia_core::errors::{decode_error, Error, IoErrorKind, Result};
 use symphonia_core::io::{BitReaderLtr, BufReader, ReadBitsLtr, ReadBytes};
 
 mod bitstream;
@@ -356,7 +356,7 @@ impl Layer3 {
                 // IO error to a decode error.
                 frame_data.granules[gr].channels[ch].rzero = match huffman_result {
                     Ok(rzero) => rzero,
-                    Err(Error::IoError(e)) if e.kind() == std::io::ErrorKind::Other => {
+                    Err(Error::IoError(IoErrorKind::Other, _)) => {
                         return decode_error("mpa: huffman decode overrun");
                     }
                     Err(err) => return Err(err),
diff --git a/symphonia-check/src/main.rs b/symphonia-check/src/main.rs
index 1682074f..68a84182 100644
--- a/symphonia-check/src/main.rs
+++ b/symphonia-check/src/main.rs
@@ -18,7 +18,7 @@ use std::process::{Command, Stdio};
 
 use symphonia::core::audio::{AudioBufferRef, SampleBuffer};
 use symphonia::core::codecs::{Decoder, DecoderOptions};
-use symphonia::core::errors::{Error, Result};
+use symphonia::core::errors::{Error, IoErrorKind, Result};
 use symphonia::core::formats::{FormatOptions, FormatReader};
 use symphonia::core::io::{MediaSourceStream, ReadOnlySource};
 use symphonia::core::meta::MetadataOptions;
@@ -396,7 +396,7 @@ fn main() {
     println!();
 
     match run_test(path, &opts, &mut res) {
-        Err(Error::IoError(err)) if err.kind() == std::io::ErrorKind::UnexpectedEof => (),
+        Err(Error::IoError(IoErrorKind::UnexpectedEof, _)) => (),
         Err(err) => {
             eprintln!("Test interrupted by error: {}", err);
             std::process::exit(2);
diff --git a/symphonia-codec-aac/src/aac/codebooks.rs b/symphonia-codec-aac/src/aac/codebooks.rs
index 88370aa1..b5d7b9e5 100644
--- a/symphonia-codec-aac/src/aac/codebooks.rs
+++ b/symphonia-codec-aac/src/aac/codebooks.rs
@@ -6,6 +6,7 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 use symphonia_core::io::{vlc::*, ReadBitsLtr};
+use symphonia_core::errors::Result;
 
 use lazy_static::lazy_static;
 
@@ -500,7 +501,7 @@ pub struct QuadsCodebook {
 
 impl QuadsCodebook {
     #[inline(always)]
-    pub fn read_quant<B: ReadBitsLtr>(&self, bs: &mut B) -> std::io::Result<(u8, u8, u8, u8)> {
+    pub fn read_quant<B: ReadBitsLtr>(&self, bs: &mut B) -> Result<(u8, u8, u8, u8)> {
         bs.read_codebook(&self.codebook).map(|(cw, _)| AAC_QUADS[cw as usize])
     }
 }
@@ -522,7 +523,7 @@ pub struct PairsCodebook {
 
 impl PairsCodebook {
     #[inline(always)]
-    pub fn read_dequant<B: ReadBitsLtr>(&self, bs: &mut B) -> std::io::Result<(f32, f32)> {
+    pub fn read_dequant<B: ReadBitsLtr>(&self, bs: &mut B) -> Result<(f32, f32)> {
         bs.read_codebook(&self.codebook).map(|(cw, _)| self.values[cw as usize])
     }
 }
@@ -543,7 +544,7 @@ pub struct EscapeCodebook {
 
 impl EscapeCodebook {
     #[inline(always)]
-    pub fn read_quant<B: ReadBitsLtr>(&self, bs: &mut B) -> std::io::Result<(u16, u16)> {
+    pub fn read_quant<B: ReadBitsLtr>(&self, bs: &mut B) -> Result<(u16, u16)> {
         bs.read_codebook(&self.codebook).map(|(cw, _)| self.values[cw as usize])
     }
 }
diff --git a/symphonia-codec-aac/src/adts.rs b/symphonia-codec-aac/src/adts.rs
index 596c41dc..7ff60dca 100644
--- a/symphonia-codec-aac/src/adts.rs
+++ b/symphonia-codec-aac/src/adts.rs
@@ -16,11 +16,10 @@ use symphonia_core::io::*;
 use symphonia_core::meta::{Metadata, MetadataLog};
 use symphonia_core::probe::{Descriptor, Instantiate, QueryDescriptor};
 
-use std::io::{Seek, SeekFrom};
-
 use super::common::{map_channels, M4AType, AAC_SAMPLE_RATES, M4A_TYPES};
 
 use log::debug;
+use symphonia_core::io::Seek;
 
 const SAMPLES_PER_AAC_PACKET: u64 = 1024;
 
diff --git a/symphonia-codec-vorbis/src/floor.rs b/symphonia-codec-vorbis/src/floor.rs
index 1e478a1f..3dbfa65e 100644
--- a/symphonia-codec-vorbis/src/floor.rs
+++ b/symphonia-codec-vorbis/src/floor.rs
@@ -8,7 +8,7 @@
 use std::cmp::min;
 use std::collections::HashSet;
 
-use symphonia_core::errors::{decode_error, Error, Result};
+use symphonia_core::errors::{decode_error, Error, IoErrorKind, Result};
 use symphonia_core::io::{BitReaderRtl, ReadBitsRtl};
 
 use super::codebook::VorbisCodebook;
@@ -92,7 +92,7 @@ macro_rules! io_try_or_ret {
             // An end-of-bitstream error is classified under ErrorKind::Other. This condition
             // should not be treated as an error, rather, it should return from the function
             // immediately without error.
-            Err(ref e) if e.kind() == std::io::ErrorKind::Other => return Ok(()),
+            Err(Error::IoError(IoErrorKind::Other, _)) => return Ok(()),
             Err(e) => return Err(e.into()),
         }
     };
@@ -105,7 +105,7 @@ macro_rules! try_or_ret {
             // An end-of-bitstream error is classified under ErrorKind::Other. This condition
             // should not be treated as an error, rather, it should return from the function
             // immediately without error.
-            Err(Error::IoError(ref e)) if e.kind() == std::io::ErrorKind::Other => return Ok(()),
+            Err(Error::IoError(IoErrorKind::Other, _)) => return Ok(()),
             Err(e) => return Err(e),
         }
     };
diff --git a/symphonia-codec-vorbis/src/residue.rs b/symphonia-codec-vorbis/src/residue.rs
index 0f66c69d..c7b7fc2c 100644
--- a/symphonia-codec-vorbis/src/residue.rs
+++ b/symphonia-codec-vorbis/src/residue.rs
@@ -9,7 +9,7 @@ use std::cmp::min;
 use std::convert::TryInto;
 use std::io;
 
-use symphonia_core::errors::{decode_error, Error, Result};
+use symphonia_core::errors::{decode_error, Error, IoErrorKind, Result};
 use symphonia_core::io::{BitReaderRtl, ReadBitsRtl};
 
 use super::codebook::VorbisCodebook;
@@ -155,7 +155,7 @@ impl Residue {
             Ok(_) => (),
             // An end-of-bitstream error is classified under ErrorKind::Other. This condition
             // should not be treated as an error.
-            Err(Error::IoError(ref e)) if e.kind() == io::ErrorKind::Other => (),
+            Err(Error::IoError(IoErrorKind::Other, _)) => (),
             Err(e) => return Err(e),
         };
 
diff --git a/symphonia-core/src/codecs.rs b/symphonia-core/src/codecs.rs
index 97907413..3fe4757e 100644
--- a/symphonia-core/src/codecs.rs
+++ b/symphonia-core/src/codecs.rs
@@ -9,7 +9,7 @@
 //! decoders.
 
 use alloc::boxed::Box;
-use std::collections::HashMap;
+use alloc::collections::BTreeMap;
 use core::default::Default;
 use core::fmt;
 
@@ -20,7 +20,7 @@ use crate::sample::SampleFormat;
 use crate::units::TimeBase;
 
 /// A `CodecType` is a unique identifier used to identify a specific codec.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Ord, PartialOrd)]
 pub struct CodecType(u32);
 
 /// Declares a new `CodecType` given a character code. A character code is an ASCII string
@@ -523,13 +523,13 @@ pub struct CodecDescriptor {
 /// A `CodecRegistry` allows the registration of codecs, and provides a method to instantiate a
 /// `Decoder` given a `CodecParameters` object.
 pub struct CodecRegistry {
-    codecs: HashMap<CodecType, CodecDescriptor>,
+    codecs: BTreeMap<CodecType, CodecDescriptor>,
 }
 
 impl CodecRegistry {
     /// Instantiate a new `CodecRegistry`.
     pub fn new() -> Self {
-        CodecRegistry { codecs: HashMap::new() }
+        CodecRegistry { codecs: BTreeMap::new() }
     }
 
     /// Gets the `CodecDescriptor` for a registered codec.
diff --git a/symphonia-core/src/errors.rs b/symphonia-core/src/errors.rs
index ae2565cf..d8d5a686 100644
--- a/symphonia-core/src/errors.rs
+++ b/symphonia-core/src/errors.rs
@@ -7,10 +7,10 @@
 
 //! The `errors` module defines the common error type.
 
-use std::error;
+use core::{error, result};
 use core::fmt;
-use std::io;
-use core::result;
+use core::fmt::{Display, Formatter, write};
+
 
 /// `SeekErrorKind` is a list of generic reasons why a seek may fail.
 #[derive(Debug)]
@@ -36,11 +36,199 @@ impl SeekErrorKind {
     }
 }
 
+#[derive(Debug)]
+pub enum IoErrorKind {
+    /// An entity was not found, often a file.
+    NotFound,
+    /// The operation lacked the necessary privileges to complete.
+    PermissionDenied,
+    /// The connection was refused by the remote server.
+    ConnectionRefused,
+    /// The connection was reset by the remote server.
+    ConnectionReset,
+    /// The remote host is not reachable.
+    HostUnreachable,
+    /// The network containing the remote host is not reachable.
+    NetworkUnreachable,
+    /// The connection was aborted (terminated) by the remote server.
+    ConnectionAborted,
+    /// The network operation failed because it was not connected yet.
+    NotConnected,
+    /// A socket address could not be bound because the address is already in
+    /// use elsewhere.
+    AddrInUse,
+    /// A nonexistent interface was requested or the requested address was not
+    /// local.
+    AddrNotAvailable,
+    /// The system's networking is down.
+    NetworkDown,
+    /// The operation failed because a pipe was closed.
+    BrokenPipe,
+    /// An entity already exists, often a file.
+    AlreadyExists,
+    /// The operation needs to block to complete, but the blocking operation was
+    /// requested to not occur.
+    WouldBlock,
+    /// A filesystem object is, unexpectedly, not a directory.
+    ///
+    /// For example, a filesystem path was specified where one of the intermediate directory
+    /// components was, in fact, a plain file.
+    NotADirectory,
+    /// The filesystem object is, unexpectedly, a directory.
+    ///
+    /// A directory was specified when a non-directory was expected.
+    IsADirectory,
+    /// A non-empty directory was specified where an empty directory was expected.
+    DirectoryNotEmpty,
+    /// The filesystem or storage medium is read-only, but a write operation was attempted.
+    ReadOnlyFilesystem,
+    /// Loop in the filesystem or IO subsystem; often, too many levels of symbolic links.
+    ///
+    /// There was a loop (or excessively long chain) resolving a filesystem object
+    /// or file IO object.
+    ///
+    /// On Unix this is usually the result of a symbolic link loop; or, of exceeding the
+    /// system-specific limit on the depth of symlink traversal.
+    FilesystemLoop,
+    /// Stale network file handle.
+    ///
+    /// With some network filesystems, notably NFS, an open file (or directory) can be invalidated
+    /// by problems with the network or server.
+    StaleNetworkFileHandle,
+    /// A parameter was incorrect.
+    InvalidInput,
+    /// Data not valid for the operation were encountered.
+    ///
+    /// Unlike [`InvalidInput`], this typically means that the operation
+    /// parameters were valid, however the error was caused by malformed
+    /// input data.
+    ///
+    /// For example, a function that reads a file into a string will error with
+    /// `InvalidData` if the file's contents are not valid UTF-8.
+    ///
+    /// [`InvalidInput`]: std::io::ErrorKind::InvalidInput
+    InvalidData,
+    /// The I/O operation's timeout expired, causing it to be canceled.
+    TimedOut,
+    /// An error returned when an operation could not be completed because a
+    /// call to [`write`] returned [`Ok(0)`].
+    ///
+    /// This typically means that an operation could only succeed if it wrote a
+    /// particular number of bytes but only a smaller number of bytes could be
+    /// written.
+    ///
+    /// [`write`]: crate::io::Write::write
+    /// [`Ok(0)`]: Ok
+    WriteZero,
+    /// The underlying storage (typically, a filesystem) is full.
+    ///
+    /// This does not include out of quota errors.
+    StorageFull,
+    /// Seek on unseekable file.
+    ///
+    /// Seeking was attempted on an open file handle which is not suitable for seeking - for
+    /// example, on Unix, a named pipe opened with `File::open`.
+    NotSeekable,
+    /// Filesystem quota was exceeded.
+    FilesystemQuotaExceeded,
+    /// File larger than allowed or supported.
+    ///
+    /// This might arise from a hard limit of the underlying filesystem or file access API, or from
+    /// an administratively imposed resource limitation.  Simple disk full, and out of quota, have
+    /// their own errors.
+    FileTooLarge,
+    /// Resource is busy.
+    ResourceBusy,
+    /// Executable file is busy.
+    ///
+    /// An attempt was made to write to a file which is also in use as a running program.  (Not all
+    /// operating systems detect this situation.)
+    ExecutableFileBusy,
+    /// Deadlock (avoided).
+    ///
+    /// A file locking operation would result in deadlock.  This situation is typically detected, if
+    /// at all, on a best-effort basis.
+    Deadlock,
+    /// Cross-device or cross-filesystem (hard) link or rename.
+    CrossesDevices,
+    /// Too many (hard) links to the same filesystem object.
+    ///
+    /// The filesystem does not support making so many hardlinks to the same file.
+    TooManyLinks,
+    /// A filename was invalid.
+    ///
+    /// This error can also cause if it exceeded the filename length limit.
+    InvalidFilename,
+    /// Program argument list too long.
+    ///
+    /// When trying to run an external program, a system or process limit on the size of the
+    /// arguments would have been exceeded.
+    ArgumentListTooLong,
+    /// This operation was interrupted.
+    ///
+    /// Interrupted operations can typically be retried.
+    Interrupted,
+
+    /// This operation is unsupported on this platform.
+    ///
+    /// This means that the operation can never succeed.
+    Unsupported,
+
+    // ErrorKinds which are primarily categorisations for OS error
+    // codes should be added above.
+    //
+    /// An error returned when an operation could not be completed because an
+    /// "end of file" was reached prematurely.
+    ///
+    /// This typically means that an operation could only succeed if it read a
+    /// particular number of bytes but only a smaller number of bytes could be
+    /// read.
+    UnexpectedEof,
+
+    /// An operation could not be completed, because it failed
+    /// to allocate enough memory.
+    OutOfMemory,
+
+    // "Unusual" error kinds which do not correspond simply to (sets
+    // of) OS error codes, should be added just above this comment.
+    // `Other` and `Uncategorized` should remain at the end:
+    //
+    /// A custom error that does not fall under any other I/O error kind.
+    ///
+    /// This can be used to construct your own [`std::io::Error`]s that do not match any
+    /// [`std::io::ErrorKind`].
+    ///
+    /// This [`std::io::ErrorKind`] is not used by the standard library.
+    ///
+    /// Errors from the standard library that do not fall under any of the I/O
+    /// error kinds cannot be `match`ed on, and will only match a wildcard (`_`) pattern.
+    /// New [`std::io::ErrorKind`]s might be added in the future for some of those.
+    Other,
+
+    /// Any I/O error from the standard library that's not part of this list.
+    ///
+    /// Errors that are `Uncategorized` now may move to a different or a new
+    /// [`std::io::ErrorKind`] variant in the future. It is not recommended to match
+    /// an error against `Uncategorized`; use a wildcard match (`_`) instead.
+    #[doc(hidden)]
+    Uncategorized,
+}
+
+impl Display for IoErrorKind {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+impl core::error::Error for IoErrorKind {
+
+}
+
 /// `Error` provides an enumeration of all possible errors reported by Symphonia.
 #[derive(Debug)]
 pub enum Error {
     /// An IO error occured while reading, writing, or seeking the stream.
-    IoError(std::io::Error),
+    IoError(IoErrorKind, &'static str),
     /// The stream contained malformed data and could not be decoded or demuxed.
     DecodeError(&'static str),
     /// The stream could not be seeked.
@@ -57,7 +245,9 @@ pub enum Error {
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            Error::IoError(ref err) => err.fmt(f),
+            Error::IoError(ref err, msg) => {
+                write!(f, "io error {:?}: {}", err, msg)
+            },
             Error::DecodeError(msg) => {
                 write!(f, "malformed stream: {}", msg)
             }
@@ -77,10 +267,10 @@ impl fmt::Display for Error {
     }
 }
 
-impl std::error::Error for Error {
+impl core::error::Error for Error {
     fn cause(&self) -> Option<&dyn error::Error> {
         match *self {
-            Error::IoError(ref err) => Some(err),
+            Error::IoError(ref err, _msg) => Some(err),
             Error::DecodeError(_) => None,
             Error::SeekError(_) => None,
             Error::Unsupported(_) => None,
@@ -90,9 +280,10 @@ impl std::error::Error for Error {
     }
 }
 
-impl From<io::Error> for Error {
-    fn from(err: io::Error) -> Error {
-        Error::IoError(err)
+#[cfg(feature = "std")]
+impl From<std::io::Error> for Error {
+    fn from(err: std::io::Error) -> Error {
+        Error::from(err)
     }
 }
 
@@ -125,5 +316,5 @@ pub fn reset_error<T>() -> Result<T> {
 
 /// Convenience function to create an end-of-stream error.
 pub fn end_of_stream_error<T>() -> Result<T> {
-    Err(Error::IoError(io::Error::new(io::ErrorKind::UnexpectedEof, "end of stream")))
+    Err(Error::IoError(IoErrorKind::UnexpectedEof, "end of stream"))
 }
diff --git a/symphonia-core/src/io/bit.rs b/symphonia-core/src/io/bit.rs
index 5be17d0a..827c3d98 100644
--- a/symphonia-core/src/io/bit.rs
+++ b/symphonia-core/src/io/bit.rs
@@ -6,13 +6,13 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 use core::cmp::min;
-use std::io;
 
 use crate::io::ReadBytes;
 use crate::util::bits::*;
+use crate::errors::{Error, IoErrorKind, Result};
 
-fn end_of_bitstream_error<T>() -> io::Result<T> {
-    Err(io::Error::new(io::ErrorKind::Other, "unexpected end of bitstream"))
+fn end_of_bitstream_error<T>() -> Result<T> {
+    Err(Error::IoError(IoErrorKind::Other, "unexpected end of bitstream"))
 }
 
 pub mod vlc {
@@ -20,11 +20,12 @@ pub mod vlc {
 
     use core::cmp::max;
     use alloc::collections::{BTreeMap, VecDeque};
-    use std::io;
     use alloc::vec::Vec;
+    use crate::errors::{IoErrorKind, Result};
+    use crate::errors::Error;
 
-    fn codebook_error<T>(desc: &'static str) -> io::Result<T> {
-        Err(io::Error::new(io::ErrorKind::Other, desc))
+    fn codebook_error<T>(desc: &'static str) -> Result<T> {
+        Err(Error::IoError(IoErrorKind::Other, desc))
     }
 
     /// `BitOrder` describes the relationship between the order of bits in the provided codewords
@@ -298,7 +299,7 @@ pub mod vlc {
             bit_order: BitOrder,
             is_sparse: bool,
             blocks: &[CodebookBlock<E>],
-        ) -> io::Result<Vec<E>> {
+        ) -> Result<Vec<E>> {
             // The codebook table.
             let mut table = Vec::new();
 
@@ -435,7 +436,7 @@ pub mod vlc {
             code_words: &[u32],
             code_lens: &[u8],
             values: &[E::ValueType],
-        ) -> io::Result<Codebook<E>> {
+        ) -> Result<Codebook<E>> {
             assert!(code_words.len() == code_lens.len());
             assert!(code_words.len() == values.len());
 
@@ -523,14 +524,14 @@ pub mod vlc {
 }
 
 mod private {
-    use std::io;
+    use crate::errors::Result;
 
     pub trait FetchBitsLtr {
         /// Discard any remaining bits in the source and fetch new bits.
-        fn fetch_bits(&mut self) -> io::Result<()>;
+        fn fetch_bits(&mut self) -> Result<()>;
 
         /// Fetch new bits, and append them after the remaining bits.
-        fn fetch_bits_partial(&mut self) -> io::Result<()>;
+        fn fetch_bits_partial(&mut self) -> Result<()>;
 
         /// Get all the bits in the source.
         fn get_bits(&self) -> u64;
@@ -544,10 +545,10 @@ mod private {
 
     pub trait FetchBitsRtl {
         /// Discard any remaining bits in the source and fetch new bits.
-        fn fetch_bits(&mut self) -> io::Result<()>;
+        fn fetch_bits(&mut self) -> Result<()>;
 
         /// Fetch new bits, and append them after the remaining bits.
-        fn fetch_bits_partial(&mut self) -> io::Result<()>;
+        fn fetch_bits_partial(&mut self) -> Result<()>;
 
         /// Get all the bits in the source.
         fn get_bits(&self) -> u64;
@@ -577,7 +578,7 @@ pub trait ReadBitsLtr: private::FetchBitsLtr {
 
     /// Ignores the specified number of bits from the stream or returns an error.
     #[inline(always)]
-    fn ignore_bits(&mut self, mut num_bits: u32) -> io::Result<()> {
+    fn ignore_bits(&mut self, mut num_bits: u32) -> Result<()> {
         if num_bits <= self.num_bits_left() {
             self.consume_bits(num_bits);
         }
@@ -600,13 +601,13 @@ pub trait ReadBitsLtr: private::FetchBitsLtr {
 
     /// Ignores one bit from the stream or returns an error.
     #[inline(always)]
-    fn ignore_bit(&mut self) -> io::Result<()> {
+    fn ignore_bit(&mut self) -> Result<()> {
         self.ignore_bits(1)
     }
 
     /// Read a single bit as a boolean value or returns an error.
     #[inline(always)]
-    fn read_bool(&mut self) -> io::Result<bool> {
+    fn read_bool(&mut self) -> Result<bool> {
         if self.num_bits_left() < 1 {
             self.fetch_bits()?;
         }
@@ -619,7 +620,7 @@ pub trait ReadBitsLtr: private::FetchBitsLtr {
 
     /// Reads and returns a single bit or returns an error.
     #[inline(always)]
-    fn read_bit(&mut self) -> io::Result<u32> {
+    fn read_bit(&mut self) -> Result<u32> {
         if self.num_bits_left() < 1 {
             self.fetch_bits()?;
         }
@@ -633,7 +634,7 @@ pub trait ReadBitsLtr: private::FetchBitsLtr {
 
     /// Reads and returns up to 32-bits or returns an error.
     #[inline(always)]
-    fn read_bits_leq32(&mut self, mut bit_width: u32) -> io::Result<u32> {
+    fn read_bits_leq32(&mut self, mut bit_width: u32) -> Result<u32> {
         debug_assert!(bit_width <= u32::BITS);
 
         // Shift in two 32-bit operations instead of a single 64-bit operation to avoid panicing
@@ -659,14 +660,14 @@ pub trait ReadBitsLtr: private::FetchBitsLtr {
     /// Reads up to 32-bits and interprets them as a signed two's complement integer or returns an
     /// error.
     #[inline(always)]
-    fn read_bits_leq32_signed(&mut self, bit_width: u32) -> io::Result<i32> {
+    fn read_bits_leq32_signed(&mut self, bit_width: u32) -> Result<i32> {
         let value = self.read_bits_leq32(bit_width)?;
         Ok(sign_extend_leq32_to_i32(value, bit_width))
     }
 
     /// Reads and returns up to 64-bits or returns an error.
     #[inline(always)]
-    fn read_bits_leq64(&mut self, mut bit_width: u32) -> io::Result<u64> {
+    fn read_bits_leq64(&mut self, mut bit_width: u32) -> Result<u64> {
         debug_assert!(bit_width <= u64::BITS);
 
         // Hard-code the bit_width == 0 case as it's not possible to handle both the bit_width == 0
@@ -700,14 +701,14 @@ pub trait ReadBitsLtr: private::FetchBitsLtr {
     /// Reads up to 64-bits and interprets them as a signed two's complement integer or returns an
     /// error.
     #[inline(always)]
-    fn read_bits_leq64_signed(&mut self, bit_width: u32) -> io::Result<i64> {
+    fn read_bits_leq64_signed(&mut self, bit_width: u32) -> Result<i64> {
         let value = self.read_bits_leq64(bit_width)?;
         Ok(sign_extend_leq64_to_i64(value, bit_width))
     }
 
     /// Reads and returns a unary zeros encoded integer or an error.
     #[inline(always)]
-    fn read_unary_zeros(&mut self) -> io::Result<u32> {
+    fn read_unary_zeros(&mut self) -> Result<u32> {
         let mut num = 0;
 
         loop {
@@ -740,7 +741,7 @@ pub trait ReadBitsLtr: private::FetchBitsLtr {
 
     /// Reads and returns a unary zeros encoded integer that is capped to a maximum value.
     #[inline(always)]
-    fn read_unary_zeros_capped(&mut self, mut limit: u32) -> io::Result<u32> {
+    fn read_unary_zeros_capped(&mut self, mut limit: u32) -> Result<u32> {
         let mut num = 0;
 
         loop {
@@ -777,7 +778,7 @@ pub trait ReadBitsLtr: private::FetchBitsLtr {
 
     /// Reads and returns a unary ones encoded integer or an error.
     #[inline(always)]
-    fn read_unary_ones(&mut self) -> io::Result<u32> {
+    fn read_unary_ones(&mut self) -> Result<u32> {
         // Note: This algorithm is identical to read_unary_zeros except flipped for 1s.
         let mut num = 0;
 
@@ -803,7 +804,7 @@ pub trait ReadBitsLtr: private::FetchBitsLtr {
 
     /// Reads and returns a unary ones encoded integer that is capped to a maximum value.
     #[inline(always)]
-    fn read_unary_ones_capped(&mut self, mut limit: u32) -> io::Result<u32> {
+    fn read_unary_ones_capped(&mut self, mut limit: u32) -> Result<u32> {
         // Note: This algorithm is identical to read_unary_zeros_capped except flipped for 1s.
         let mut num = 0;
 
@@ -839,7 +840,7 @@ pub trait ReadBitsLtr: private::FetchBitsLtr {
     fn read_codebook<E: vlc::CodebookEntry>(
         &mut self,
         codebook: &vlc::Codebook<E>,
-    ) -> io::Result<(E::ValueType, u32)> {
+    ) -> Result<(E::ValueType, u32)> {
         // Attempt refill the bit buffer with enough bits for the longest codeword in the codebook.
         // However, this does not mean the bit buffer will have enough bits to decode a codeword.
         if self.num_bits_left() < codebook.max_code_len {
@@ -908,14 +909,14 @@ impl<'a, B: ReadBytes> BitStreamLtr<'a, B> {
 
 impl<'a, B: ReadBytes> private::FetchBitsLtr for BitStreamLtr<'a, B> {
     #[inline(always)]
-    fn fetch_bits(&mut self) -> io::Result<()> {
+    fn fetch_bits(&mut self) -> Result<()> {
         self.bits = u64::from(self.reader.read_u8()?) << 56;
         self.n_bits_left = u8::BITS;
         Ok(())
     }
 
     #[inline(always)]
-    fn fetch_bits_partial(&mut self) -> io::Result<()> {
+    fn fetch_bits_partial(&mut self) -> Result<()> {
         todo!()
     }
 
@@ -957,7 +958,7 @@ impl<'a> BitReaderLtr<'a> {
 
 impl<'a> private::FetchBitsLtr for BitReaderLtr<'a> {
     #[inline]
-    fn fetch_bits_partial(&mut self) -> io::Result<()> {
+    fn fetch_bits_partial(&mut self) -> Result<()> {
         let mut buf = [0u8; core::mem::size_of::<u64>()];
 
         let read_len = min(self.buf.len(), (u64::BITS - self.n_bits_left) as usize >> 3);
@@ -972,7 +973,7 @@ impl<'a> private::FetchBitsLtr for BitReaderLtr<'a> {
         Ok(())
     }
 
-    fn fetch_bits(&mut self) -> io::Result<()> {
+    fn fetch_bits(&mut self) -> Result<()> {
         let mut buf = [0u8; core::mem::size_of::<u64>()];
 
         let read_len = min(self.buf.len(), core::mem::size_of::<u64>());
@@ -1027,7 +1028,7 @@ pub trait ReadBitsRtl: private::FetchBitsRtl {
 
     /// Ignores the specified number of bits from the stream or returns an error.
     #[inline(always)]
-    fn ignore_bits(&mut self, mut num_bits: u32) -> io::Result<()> {
+    fn ignore_bits(&mut self, mut num_bits: u32) -> Result<()> {
         if num_bits <= self.num_bits_left() {
             self.consume_bits(num_bits);
         }
@@ -1050,13 +1051,13 @@ pub trait ReadBitsRtl: private::FetchBitsRtl {
 
     /// Ignores one bit from the stream or returns an error.
     #[inline(always)]
-    fn ignore_bit(&mut self) -> io::Result<()> {
+    fn ignore_bit(&mut self) -> Result<()> {
         self.ignore_bits(1)
     }
 
     /// Read a single bit as a boolean value or returns an error.
     #[inline(always)]
-    fn read_bool(&mut self) -> io::Result<bool> {
+    fn read_bool(&mut self) -> Result<bool> {
         if self.num_bits_left() < 1 {
             self.fetch_bits()?;
         }
@@ -1069,7 +1070,7 @@ pub trait ReadBitsRtl: private::FetchBitsRtl {
 
     /// Reads and returns a single bit or returns an error.
     #[inline(always)]
-    fn read_bit(&mut self) -> io::Result<u32> {
+    fn read_bit(&mut self) -> Result<u32> {
         if self.num_bits_left() < 1 {
             self.fetch_bits()?;
         }
@@ -1083,7 +1084,7 @@ pub trait ReadBitsRtl: private::FetchBitsRtl {
 
     /// Reads and returns up to 32-bits or returns an error.
     #[inline(always)]
-    fn read_bits_leq32(&mut self, bit_width: u32) -> io::Result<u32> {
+    fn read_bits_leq32(&mut self, bit_width: u32) -> Result<u32> {
         debug_assert!(bit_width <= u32::BITS);
 
         let mut bits = self.get_bits();
@@ -1108,14 +1109,14 @@ pub trait ReadBitsRtl: private::FetchBitsRtl {
     /// Reads up to 32-bits and interprets them as a signed two's complement integer or returns an
     /// error.
     #[inline(always)]
-    fn read_bits_leq32_signed(&mut self, bit_width: u32) -> io::Result<i32> {
+    fn read_bits_leq32_signed(&mut self, bit_width: u32) -> Result<i32> {
         let value = self.read_bits_leq32(bit_width)?;
         Ok(sign_extend_leq32_to_i32(value, bit_width))
     }
 
     /// Reads and returns up to 64-bits or returns an error.
     #[inline(always)]
-    fn read_bits_leq64(&mut self, bit_width: u32) -> io::Result<u64> {
+    fn read_bits_leq64(&mut self, bit_width: u32) -> Result<u64> {
         debug_assert!(bit_width <= u64::BITS);
 
         // Hard-code the bit_width == 0 case as it's not possible to handle both the bit_width == 0
@@ -1153,14 +1154,14 @@ pub trait ReadBitsRtl: private::FetchBitsRtl {
     /// Reads up to 64-bits and interprets them as a signed two's complement integer or returns an
     /// error.
     #[inline(always)]
-    fn read_bits_leq64_signed(&mut self, bit_width: u32) -> io::Result<i64> {
+    fn read_bits_leq64_signed(&mut self, bit_width: u32) -> Result<i64> {
         let value = self.read_bits_leq64(bit_width)?;
         Ok(sign_extend_leq64_to_i64(value, bit_width))
     }
 
     /// Reads and returns a unary zeros encoded integer or an error.
     #[inline(always)]
-    fn read_unary_zeros(&mut self) -> io::Result<u32> {
+    fn read_unary_zeros(&mut self) -> Result<u32> {
         let mut num = 0;
 
         loop {
@@ -1193,7 +1194,7 @@ pub trait ReadBitsRtl: private::FetchBitsRtl {
 
     /// Reads and returns a unary zeros encoded integer that is capped to a maximum value.
     #[inline(always)]
-    fn read_unary_zeros_capped(&mut self, mut limit: u32) -> io::Result<u32> {
+    fn read_unary_zeros_capped(&mut self, mut limit: u32) -> Result<u32> {
         let mut num = 0;
 
         loop {
@@ -1230,7 +1231,7 @@ pub trait ReadBitsRtl: private::FetchBitsRtl {
 
     /// Reads and returns a unary ones encoded integer or an error.
     #[inline(always)]
-    fn read_unary_ones(&mut self) -> io::Result<u32> {
+    fn read_unary_ones(&mut self) -> Result<u32> {
         // Note: This algorithm is identical to read_unary_zeros except flipped for 1s.
         let mut num = 0;
 
@@ -1256,7 +1257,7 @@ pub trait ReadBitsRtl: private::FetchBitsRtl {
 
     /// Reads and returns a unary ones encoded integer or an error.
     #[inline(always)]
-    fn read_unary_ones_capped(&mut self, mut limit: u32) -> io::Result<u32> {
+    fn read_unary_ones_capped(&mut self, mut limit: u32) -> Result<u32> {
         // Note: This algorithm is identical to read_unary_zeros_capped except flipped for 1s.
         let mut num = 0;
 
@@ -1290,7 +1291,7 @@ pub trait ReadBitsRtl: private::FetchBitsRtl {
     fn read_codebook<E: vlc::CodebookEntry>(
         &mut self,
         codebook: &vlc::Codebook<E>,
-    ) -> io::Result<(E::ValueType, u32)> {
+    ) -> Result<(E::ValueType, u32)> {
         if self.num_bits_left() < codebook.max_code_len {
             self.fetch_bits_partial()?;
         }
@@ -1357,14 +1358,14 @@ impl<'a, B: ReadBytes> BitStreamRtl<'a, B> {
 
 impl<'a, B: ReadBytes> private::FetchBitsRtl for BitStreamRtl<'a, B> {
     #[inline(always)]
-    fn fetch_bits(&mut self) -> io::Result<()> {
+    fn fetch_bits(&mut self) -> Result<()> {
         self.bits = u64::from(self.reader.read_u8()?);
         self.n_bits_left = u8::BITS;
         Ok(())
     }
 
     #[inline(always)]
-    fn fetch_bits_partial(&mut self) -> io::Result<()> {
+    fn fetch_bits_partial(&mut self) -> Result<()> {
         todo!()
     }
 
@@ -1406,7 +1407,7 @@ impl<'a> BitReaderRtl<'a> {
 
 impl<'a> private::FetchBitsRtl for BitReaderRtl<'a> {
     #[inline]
-    fn fetch_bits_partial(&mut self) -> io::Result<()> {
+    fn fetch_bits_partial(&mut self) -> Result<()> {
         let mut buf = [0u8; core::mem::size_of::<u64>()];
 
         let read_len = min(self.buf.len(), (u64::BITS - self.n_bits_left) as usize >> 3);
@@ -1421,7 +1422,7 @@ impl<'a> private::FetchBitsRtl for BitReaderRtl<'a> {
         Ok(())
     }
 
-    fn fetch_bits(&mut self) -> io::Result<()> {
+    fn fetch_bits(&mut self) -> Result<()> {
         let mut buf = [0u8; core::mem::size_of::<u64>()];
 
         let read_len = min(self.buf.len(), core::mem::size_of::<u64>());
diff --git a/symphonia-core/src/io/buf_reader.rs b/symphonia-core/src/io/buf_reader.rs
index 3cb84e21..2c9e8f27 100644
--- a/symphonia-core/src/io/buf_reader.rs
+++ b/symphonia-core/src/io/buf_reader.rs
@@ -6,13 +6,14 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 use core::cmp;
-use std::io;
 
 use super::{FiniteStream, ReadBytes};
+use crate::errors::{IoErrorKind, Result};
+use crate::errors::Error;
 
 #[inline(always)]
-fn underrun_error<T>() -> io::Result<T> {
-    Err(io::Error::new(io::ErrorKind::UnexpectedEof, "buffer underrun"))
+fn underrun_error<T>() -> Result<T> {
+    Err(Error::IoError(IoErrorKind::UnexpectedEof, "buffer underrun"))
 }
 
 /// A `BufReader` reads bytes from a byte buffer.
@@ -33,7 +34,7 @@ impl<'a> BufReader<'a> {
     /// if the underlying buffer is exhausted before matching the pattern, remainder of the buffer
     /// is returned.
     #[inline(always)]
-    pub fn scan_bytes_ref(&mut self, pattern: &[u8], scan_len: usize) -> io::Result<&'a [u8]> {
+    pub fn scan_bytes_ref(&mut self, pattern: &[u8], scan_len: usize) -> Result<&'a [u8]> {
         self.scan_bytes_aligned_ref(pattern, 1, scan_len)
     }
 
@@ -44,7 +45,7 @@ impl<'a> BufReader<'a> {
         pattern: &[u8],
         align: usize,
         scan_len: usize,
-    ) -> io::Result<&'a [u8]> {
+    ) -> Result<&'a [u8]> {
         // The pattern must be atleast one byte.
         debug_assert!(!pattern.is_empty());
 
@@ -76,7 +77,7 @@ impl<'a> BufReader<'a> {
     }
 
     /// Returns a reference to the next `len` bytes in the buffer and advances the stream.
-    pub fn read_buf_bytes_ref(&mut self, len: usize) -> io::Result<&'a [u8]> {
+    pub fn read_buf_bytes_ref(&mut self, len: usize) -> Result<&'a [u8]> {
         if self.pos + len > self.buf.len() {
             return underrun_error();
         }
@@ -94,7 +95,7 @@ impl<'a> BufReader<'a> {
 
 impl<'a> ReadBytes for BufReader<'a> {
     #[inline(always)]
-    fn read_byte(&mut self) -> io::Result<u8> {
+    fn read_byte(&mut self) -> Result<u8> {
         if self.buf.len() - self.pos < 1 {
             return underrun_error();
         }
@@ -104,7 +105,7 @@ impl<'a> ReadBytes for BufReader<'a> {
     }
 
     #[inline(always)]
-    fn read_double_bytes(&mut self) -> io::Result<[u8; 2]> {
+    fn read_double_bytes(&mut self) -> Result<[u8; 2]> {
         if self.buf.len() - self.pos < 2 {
             return underrun_error();
         }
@@ -117,7 +118,7 @@ impl<'a> ReadBytes for BufReader<'a> {
     }
 
     #[inline(always)]
-    fn read_triple_bytes(&mut self) -> io::Result<[u8; 3]> {
+    fn read_triple_bytes(&mut self) -> Result<[u8; 3]> {
         if self.buf.len() - self.pos < 3 {
             return underrun_error();
         }
@@ -130,7 +131,7 @@ impl<'a> ReadBytes for BufReader<'a> {
     }
 
     #[inline(always)]
-    fn read_quad_bytes(&mut self) -> io::Result<[u8; 4]> {
+    fn read_quad_bytes(&mut self) -> Result<[u8; 4]> {
         if self.buf.len() - self.pos < 4 {
             return underrun_error();
         }
@@ -142,7 +143,7 @@ impl<'a> ReadBytes for BufReader<'a> {
         Ok(bytes)
     }
 
-    fn read_buf(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+    fn read_buf(&mut self, buf: &mut [u8]) -> Result<usize> {
         let len = cmp::min(self.buf.len() - self.pos, buf.len());
         buf[..len].copy_from_slice(&self.buf[self.pos..self.pos + len]);
         self.pos += len;
@@ -150,7 +151,7 @@ impl<'a> ReadBytes for BufReader<'a> {
         Ok(len)
     }
 
-    fn read_buf_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
+    fn read_buf_exact(&mut self, buf: &mut [u8]) -> Result<()> {
         let len = buf.len();
 
         if self.buf.len() - self.pos < len {
@@ -168,14 +169,14 @@ impl<'a> ReadBytes for BufReader<'a> {
         pattern: &[u8],
         align: usize,
         buf: &'b mut [u8],
-    ) -> io::Result<&'b mut [u8]> {
+    ) -> Result<&'b mut [u8]> {
         let scanned = self.scan_bytes_aligned_ref(pattern, align, buf.len())?;
         buf[..scanned.len()].copy_from_slice(scanned);
 
         Ok(&mut buf[..scanned.len()])
     }
 
-    fn ignore_bytes(&mut self, count: u64) -> io::Result<()> {
+    fn ignore_bytes(&mut self, count: u64) -> Result<()> {
         if self.buf.len() - self.pos < count as usize {
             return underrun_error();
         }
diff --git a/symphonia-core/src/io/media_source_stream.rs b/symphonia-core/src/io/media_source_stream.rs
index c3f8877b..56af3d3b 100644
--- a/symphonia-core/src/io/media_source_stream.rs
+++ b/symphonia-core/src/io/media_source_stream.rs
@@ -8,16 +8,17 @@
 use alloc::boxed::Box;
 use alloc::vec;
 use core::cmp;
-use std::io;
-use std::io::{IoSliceMut, Read, Seek};
+// use std::io::{IoSliceMut, Read, Seek};
 use core::ops::Sub;
 
-use super::SeekBuffered;
+use super::{IoSliceMut, Read, Seek, SeekBuffered, SeekFrom};
 use super::{MediaSource, ReadBytes};
+use crate::errors::{IoErrorKind, Result};
+use crate::errors::Error;
 
 #[inline(always)]
-fn end_of_stream_error<T>() -> io::Result<T> {
-    Err(io::Error::new(io::ErrorKind::UnexpectedEof, "end of stream"))
+fn end_of_stream_error<T>() -> Result<T> {
+    Err(Error::IoError(IoErrorKind::UnexpectedEof, ""))
 }
 
 /// `MediaSourceStreamOptions` specifies the buffering behaviour of a `MediaSourceStream`.
@@ -100,7 +101,7 @@ impl MediaSourceStream {
     }
 
     /// If the buffer has been exhausted, fetch a new block of data to replenish the buffer.
-    fn fetch(&mut self) -> io::Result<()> {
+    fn fetch(&mut self) -> Result<()> {
         // Only fetch when the ring buffer is empty.
         if self.is_buffer_exhausted() {
             // Split the vector at the write position to get slices of the two contiguous regions of
@@ -139,7 +140,7 @@ impl MediaSourceStream {
 
     /// If the buffer has been exhausted, fetch a new block of data to replenish the buffer. If
     /// no more data could be fetched, return an end-of-stream error.
-    fn fetch_or_eof(&mut self) -> io::Result<()> {
+    fn fetch_or_eof(&mut self) -> Result<()> {
         self.fetch()?;
 
         if self.is_buffer_exhausted() {
@@ -188,8 +189,8 @@ impl MediaSource for MediaSourceStream {
     }
 }
 
-impl io::Read for MediaSourceStream {
-    fn read(&mut self, mut buf: &mut [u8]) -> io::Result<usize> {
+impl Read for MediaSourceStream {
+    fn read(&mut self, mut buf: &mut [u8]) -> Result<usize> {
         let read_len = buf.len();
 
         while !buf.is_empty() {
@@ -204,7 +205,7 @@ impl io::Read for MediaSourceStream {
                     buf = &mut buf[count..];
                     self.consume(count);
                 }
-                Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {}
+                Err(Error::IoError(IoErrorKind::Interrupted, _))  => {}
                 Err(e) => return Err(e),
             }
         }
@@ -215,17 +216,17 @@ impl io::Read for MediaSourceStream {
     }
 }
 
-impl io::Seek for MediaSourceStream {
-    fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {
+impl Seek for MediaSourceStream {
+    fn seek(&mut self, pos: SeekFrom) -> Result<u64> {
         // The current position of the underlying reader is ahead of the current position of the
         // MediaSourceStream by how ever many bytes have not been read from the read-ahead buffer
         // yet. When seeking from the current position adjust the position delta to offset that
         // difference.
         let pos = match pos {
-            io::SeekFrom::Current(0) => return Ok(self.pos()),
-            io::SeekFrom::Current(delta_pos) => {
+            SeekFrom::Current(0) => return Ok(self.pos()),
+            SeekFrom::Current(delta_pos) => {
                 let delta = delta_pos - self.unread_buffer_len() as i64;
-                self.inner.seek(io::SeekFrom::Current(delta))
+                self.inner.seek(SeekFrom::Current(delta))
             }
             _ => self.inner.seek(pos),
         }?;
@@ -238,7 +239,7 @@ impl io::Seek for MediaSourceStream {
 
 impl ReadBytes for MediaSourceStream {
     #[inline(always)]
-    fn read_byte(&mut self) -> io::Result<u8> {
+    fn read_byte(&mut self) -> Result<u8> {
         // This function, read_byte, is inlined for performance. To reduce code bloat, place the
         // read-ahead buffer replenishment in a seperate function. Call overhead will be negligible
         // compared to the actual underlying read.
@@ -252,7 +253,7 @@ impl ReadBytes for MediaSourceStream {
         Ok(value)
     }
 
-    fn read_double_bytes(&mut self) -> io::Result<[u8; 2]> {
+    fn read_double_bytes(&mut self) -> Result<[u8; 2]> {
         let mut bytes = [0; 2];
 
         let buf = self.continguous_buf();
@@ -270,7 +271,7 @@ impl ReadBytes for MediaSourceStream {
         Ok(bytes)
     }
 
-    fn read_triple_bytes(&mut self) -> io::Result<[u8; 3]> {
+    fn read_triple_bytes(&mut self) -> Result<[u8; 3]> {
         let mut bytes = [0; 3];
 
         let buf = self.continguous_buf();
@@ -287,7 +288,7 @@ impl ReadBytes for MediaSourceStream {
         Ok(bytes)
     }
 
-    fn read_quad_bytes(&mut self) -> io::Result<[u8; 4]> {
+    fn read_quad_bytes(&mut self) -> Result<[u8; 4]> {
         let mut bytes = [0; 4];
 
         let buf = self.continguous_buf();
@@ -304,7 +305,7 @@ impl ReadBytes for MediaSourceStream {
         Ok(bytes)
     }
 
-    fn read_buf(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+    fn read_buf(&mut self, buf: &mut [u8]) -> Result<usize> {
         // Implemented via io::Read trait.
         let read = self.read(buf)?;
 
@@ -319,14 +320,14 @@ impl ReadBytes for MediaSourceStream {
         }
     }
 
-    fn read_buf_exact(&mut self, mut buf: &mut [u8]) -> io::Result<()> {
+    fn read_buf_exact(&mut self, mut buf: &mut [u8]) -> Result<()> {
         while !buf.is_empty() {
             match self.read(buf) {
                 Ok(0) => break,
                 Ok(count) => {
                     buf = &mut buf[count..];
                 }
-                Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {}
+                Err(Error::IoError(IoErrorKind::Interrupted, _)) =>  {}
                 Err(e) => return Err(e),
             }
         }
@@ -344,12 +345,12 @@ impl ReadBytes for MediaSourceStream {
         _: &[u8],
         _: usize,
         _: &'a mut [u8],
-    ) -> io::Result<&'a mut [u8]> {
+    ) -> Result<&'a mut [u8]> {
         // Intentionally left unimplemented.
         unimplemented!();
     }
 
-    fn ignore_bytes(&mut self, mut count: u64) -> io::Result<()> {
+    fn ignore_bytes(&mut self, mut count: u64) -> Result<()> {
         // If the stream is seekable and the number of bytes to ignore is large, perform a seek
         // first. Note that ignored bytes are rewindable. Therefore, ensure the ring-buffer is
         // full after the seek just like if bytes were ignored by consuming them instead.
@@ -358,7 +359,7 @@ impl ReadBytes for MediaSourceStream {
         // Only apply the optimization if seeking 2x or more than the ring-buffer size.
         while count >= 2 * ring_len && self.is_seekable() {
             let delta = count.clamp(0, i64::MAX as u64).sub(ring_len);
-            self.seek(io::SeekFrom::Current(delta as i64))?;
+            self.seek(SeekFrom::Current(delta as i64))?;
             count -= delta;
         }
 
@@ -467,6 +468,28 @@ impl SeekBuffered for MediaSourceStream {
     }
 }
 
+#[cfg(not(feature = "std"))]
+impl Read for &[u8] {
+    #[inline]
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
+        let amt = cmp::min(buf.len(), self.len());
+        let (a, b) = self.split_at(amt);
+
+        // First check if the amount of bytes we want to read is small:
+        // `copy_from_slice` will generally expand to a call to `memcpy`, and
+        // for a single byte the overhead is significant.
+        if amt == 1 {
+            buf[0] = a[0];
+        } else {
+            buf[..amt].copy_from_slice(a);
+        }
+
+        *self = b;
+        Ok(amt)
+    }
+}
+
+#[cfg(feature = "std")]
 #[cfg(test)]
 mod tests {
     use alloc::boxed::Box;
@@ -536,16 +559,17 @@ mod tests {
         }
     }
 
-    #[test]
-    fn verify_mss_read_to_end() {
-        let data = generate_random_bytes(5 * 96 * 1024);
-
-        let ms = Cursor::new(data.clone());
-        let mut mss = MediaSourceStream::new(Box::new(ms), Default::default());
-        let mut output: Vec<u8> = Vec::new();
-        assert_eq!(mss.read_to_end(&mut output).unwrap(), data.len());
-        assert_eq!(output.into_boxed_slice(), data);
-    }
+    // TODO
+    // #[test]
+    // fn verify_mss_read_to_end() {
+    //     let data = generate_random_bytes(5 * 96 * 1024);
+    //
+    //     let ms = Cursor::new(data.clone());
+    //     let mut mss = MediaSourceStream::new(Box::new(ms), Default::default());
+    //     let mut output: Vec<u8> = Vec::new();
+    //     assert_eq!(mss.read_to_end(&mut output).unwrap(), data.len());
+    //     assert_eq!(output.into_boxed_slice(), data);
+    // }
 
     #[test]
     fn verify_mss_seek_buffered() {
diff --git a/symphonia-core/src/io/mod.rs b/symphonia-core/src/io/mod.rs
index 75da23be..ca5b50b3 100644
--- a/symphonia-core/src/io/mod.rs
+++ b/symphonia-core/src/io/mod.rs
@@ -21,8 +21,8 @@
 
 use alloc::boxed::Box;
 use alloc::vec;
-use std::io;
 use core::mem;
+use std::io;
 
 mod bit;
 mod buf_reader;
@@ -35,13 +35,109 @@ pub use buf_reader::BufReader;
 pub use media_source_stream::{MediaSourceStream, MediaSourceStreamOptions};
 pub use monitor_stream::{Monitor, MonitorStream};
 pub use scoped_stream::ScopedStream;
+use std::ops::{Deref, DerefMut};
+use crate::errors::{Error, IoErrorKind, Result};
+
+pub trait Seek {
+    fn seek(&mut self, _: SeekFrom) -> Result<u64>;
+}
+
+pub enum SeekFrom {
+    /// Sets the offset to the provided number of bytes.
+    Start(u64),
+
+    /// Sets the offset to the size of this object plus the specified number of
+    /// bytes.
+    ///
+    /// It is possible to seek beyond the end of an object, but it's an error to
+    /// seek before byte 0.
+    End(i64),
+
+    /// Sets the offset to the current position plus the specified number of
+    /// bytes.
+    ///
+    /// It is possible to seek beyond the end of an object, but it's an error to
+    /// seek before byte 0.
+    Current(i64),
+}
+
+struct IoSliceMut<'a> {
+    buf: &'a mut [u8],
+}
+
+impl <'a> IoSliceMut<'a> {
+    fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {
+        IoSliceMut {
+            buf
+        }
+    }
+}
+
+impl<'a> Deref for IoSliceMut<'a> {
+    type Target = [u8];
+
+    #[inline]
+    fn deref(&self) -> &[u8] {
+        self.buf
+    }
+}
+
+impl<'a> DerefMut for IoSliceMut<'a> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut [u8] {
+        self.buf
+    }
+}
+
+impl <'a> Iterator for IoSliceMut<'a> {
+    type Item = u8;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        todo!()
+    }
+}
+
+
+pub trait Read {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize>;
+
+    fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize> {
+        default_read_vectored(|b| self.read(b), bufs)
+    }
+}
+
+fn default_read_vectored<F>(read: F, bufs: &mut [IoSliceMut<'_>]) -> Result<usize>
+    where
+        F: FnOnce(&mut [u8]) -> Result<usize>,
+{
+    let buf = bufs.iter_mut().find(|b| !b.is_empty()).map_or(&mut [][..], |b| &mut **b);
+    read(buf)
+}
+
+impl <T: std::io::Read> Read for T {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
+        self.read(buf).map_err(|e| { Error::from(e) })
+    }
+}
+
+impl <T: std::io::Seek> Seek for T  {
+    fn seek(&mut self, from: SeekFrom) -> Result<u64> {
+        let from = match from {
+            SeekFrom::Start(x) => io::SeekFrom::Start(x),
+            SeekFrom::End(x) => io::SeekFrom::End(x),
+            SeekFrom::Current(x) => io::SeekFrom::Current(x),
+        };
+        self.seek(from).map_err(|e| { Error::from(e) })
+    }
+}
 
 /// `MediaSource` is a composite trait of [`std::io::Read`] and [`std::io::Seek`]. A source *must*
 /// implement this trait to be used by [`MediaSourceStream`].
 ///
 /// Despite requiring the [`std::io::Seek`] trait, seeking is an optional capability that can be
 /// queried at runtime.
-pub trait MediaSource: io::Read + io::Seek + Send + Sync {
+// pub trait MediaSource: io::Read + io::Seek + Send + Sync {
+pub trait MediaSource: Read + Seek + Send + Sync {
     /// Returns if the source is seekable. This may be an expensive operation.
     fn is_seekable(&self) -> bool;
 
@@ -49,6 +145,7 @@ pub trait MediaSource: io::Read + io::Seek + Send + Sync {
     fn byte_len(&self) -> Option<u64>;
 }
 
+#[cfg(feature = "std")]
 impl MediaSource for std::fs::File {
     /// Returns if the `std::io::File` backing the `MediaSource` is seekable.
     ///
@@ -76,7 +173,8 @@ impl MediaSource for std::fs::File {
     }
 }
 
-impl<T: std::convert::AsRef<[u8]> + Send + Sync> MediaSource for io::Cursor<T> {
+#[cfg(feature = "std")]
+impl<T: std::convert::AsRef<[u8]> + Send + Sync> MediaSource for std::io::Cursor<T> {
     /// Always returns true since a `io::Cursor<u8>` is always seekable.
     fn is_seekable(&self) -> bool {
         true
@@ -93,11 +191,11 @@ impl<T: std::convert::AsRef<[u8]> + Send + Sync> MediaSource for io::Cursor<T> {
 
 /// `ReadOnlySource` wraps any source implementing [`std::io::Read`] in an unseekable
 /// [`MediaSource`].
-pub struct ReadOnlySource<R: io::Read> {
+pub struct ReadOnlySource<R: Read> {
     inner: R,
 }
 
-impl<R: io::Read + Send> ReadOnlySource<R> {
+impl<R: Read + Send> ReadOnlySource<R> {
     /// Instantiates a new `ReadOnlySource<R>` by taking ownership and wrapping the provided
     /// `Read`er.
     pub fn new(inner: R) -> Self {
@@ -120,7 +218,7 @@ impl<R: io::Read + Send> ReadOnlySource<R> {
     }
 }
 
-impl<R: io::Read + Send + Sync> MediaSource for ReadOnlySource<R> {
+impl<R: Read + Send + Sync> MediaSource for ReadOnlySource<R> {
     fn is_seekable(&self) -> bool {
         false
     }
@@ -130,15 +228,15 @@ impl<R: io::Read + Send + Sync> MediaSource for ReadOnlySource<R> {
     }
 }
 
-impl<R: io::Read> io::Read for ReadOnlySource<R> {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+impl<R: Read> Read for ReadOnlySource<R> {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
         self.inner.read(buf)
     }
 }
 
-impl<R: io::Read> io::Seek for ReadOnlySource<R> {
-    fn seek(&mut self, _: io::SeekFrom) -> io::Result<u64> {
-        Err(io::Error::new(io::ErrorKind::Other, "source does not support seeking"))
+impl<R: Read> Seek for ReadOnlySource<R> {
+    fn seek(&mut self, _: SeekFrom) -> Result<u64> {
+        Err(Error::IoError(IoErrorKind::Other, "source does not support seeking"))
     }
 }
 
@@ -146,67 +244,67 @@ impl<R: io::Read> io::Seek for ReadOnlySource<R> {
 /// unsigned integers or floating-point values of standard widths.
 pub trait ReadBytes {
     /// Reads a single byte from the stream and returns it or an error.
-    fn read_byte(&mut self) -> io::Result<u8>;
+    fn read_byte(&mut self) -> Result<u8>;
 
     /// Reads two bytes from the stream and returns them in read-order or an error.
-    fn read_double_bytes(&mut self) -> io::Result<[u8; 2]>;
+    fn read_double_bytes(&mut self) -> Result<[u8; 2]>;
 
     /// Reads three bytes from the stream and returns them in read-order or an error.
-    fn read_triple_bytes(&mut self) -> io::Result<[u8; 3]>;
+    fn read_triple_bytes(&mut self) -> Result<[u8; 3]>;
 
     /// Reads four bytes from the stream and returns them in read-order or an error.
-    fn read_quad_bytes(&mut self) -> io::Result<[u8; 4]>;
+    fn read_quad_bytes(&mut self) -> Result<[u8; 4]>;
 
     /// Reads up-to the number of bytes required to fill buf or returns an error.
-    fn read_buf(&mut self, buf: &mut [u8]) -> io::Result<usize>;
+    fn read_buf(&mut self, buf: &mut [u8]) -> Result<usize>;
 
     /// Reads exactly the number of bytes required to fill be provided buffer or returns an error.
-    fn read_buf_exact(&mut self, buf: &mut [u8]) -> io::Result<()>;
+    fn read_buf_exact(&mut self, buf: &mut [u8]) -> Result<()>;
 
     /// Reads a single unsigned byte from the stream and returns it or an error.
     #[inline(always)]
-    fn read_u8(&mut self) -> io::Result<u8> {
+    fn read_u8(&mut self) -> Result<u8> {
         self.read_byte()
     }
 
     /// Reads a single signed byte from the stream and returns it or an error.
     #[inline(always)]
-    fn read_i8(&mut self) -> io::Result<i8> {
+    fn read_i8(&mut self) -> Result<i8> {
         Ok(self.read_byte()? as i8)
     }
 
     /// Reads two bytes from the stream and interprets them as an unsigned 16-bit little-endian
     /// integer or returns an error.
     #[inline(always)]
-    fn read_u16(&mut self) -> io::Result<u16> {
+    fn read_u16(&mut self) -> Result<u16> {
         Ok(u16::from_le_bytes(self.read_double_bytes()?))
     }
 
     /// Reads two bytes from the stream and interprets them as an signed 16-bit little-endian
     /// integer or returns an error.
     #[inline(always)]
-    fn read_i16(&mut self) -> io::Result<i16> {
+    fn read_i16(&mut self) -> Result<i16> {
         Ok(i16::from_le_bytes(self.read_double_bytes()?))
     }
 
     /// Reads two bytes from the stream and interprets them as an unsigned 16-bit big-endian
     /// integer or returns an error.
     #[inline(always)]
-    fn read_be_u16(&mut self) -> io::Result<u16> {
+    fn read_be_u16(&mut self) -> Result<u16> {
         Ok(u16::from_be_bytes(self.read_double_bytes()?))
     }
 
     /// Reads two bytes from the stream and interprets them as an signed 16-bit big-endian
     /// integer or returns an error.
     #[inline(always)]
-    fn read_be_i16(&mut self) -> io::Result<i16> {
+    fn read_be_i16(&mut self) -> Result<i16> {
         Ok(i16::from_be_bytes(self.read_double_bytes()?))
     }
 
     /// Reads three bytes from the stream and interprets them as an unsigned 24-bit little-endian
     /// integer or returns an error.
     #[inline(always)]
-    fn read_u24(&mut self) -> io::Result<u32> {
+    fn read_u24(&mut self) -> Result<u32> {
         let mut buf = [0u8; mem::size_of::<u32>()];
         buf[0..3].clone_from_slice(&self.read_triple_bytes()?);
         Ok(u32::from_le_bytes(buf))
@@ -215,14 +313,14 @@ pub trait ReadBytes {
     /// Reads three bytes from the stream and interprets them as an signed 24-bit little-endian
     /// integer or returns an error.
     #[inline(always)]
-    fn read_i24(&mut self) -> io::Result<i32> {
+    fn read_i24(&mut self) -> Result<i32> {
         Ok(((self.read_u24()? << 8) as i32) >> 8)
     }
 
     /// Reads three bytes from the stream and interprets them as an unsigned 24-bit big-endian
     /// integer or returns an error.
     #[inline(always)]
-    fn read_be_u24(&mut self) -> io::Result<u32> {
+    fn read_be_u24(&mut self) -> Result<u32> {
         let mut buf = [0u8; mem::size_of::<u32>()];
         buf[0..3].clone_from_slice(&self.read_triple_bytes()?);
         Ok(u32::from_be_bytes(buf) >> 8)
@@ -231,42 +329,42 @@ pub trait ReadBytes {
     /// Reads three bytes from the stream and interprets them as an signed 24-bit big-endian
     /// integer or returns an error.
     #[inline(always)]
-    fn read_be_i24(&mut self) -> io::Result<i32> {
+    fn read_be_i24(&mut self) -> Result<i32> {
         Ok(((self.read_be_u24()? << 8) as i32) >> 8)
     }
 
     /// Reads four bytes from the stream and interprets them as an unsigned 32-bit little-endian
     /// integer or returns an error.
     #[inline(always)]
-    fn read_u32(&mut self) -> io::Result<u32> {
+    fn read_u32(&mut self) -> Result<u32> {
         Ok(u32::from_le_bytes(self.read_quad_bytes()?))
     }
 
     /// Reads four bytes from the stream and interprets them as an signed 32-bit little-endian
     /// integer or returns an error.
     #[inline(always)]
-    fn read_i32(&mut self) -> io::Result<i32> {
+    fn read_i32(&mut self) -> Result<i32> {
         Ok(i32::from_le_bytes(self.read_quad_bytes()?))
     }
 
     /// Reads four bytes from the stream and interprets them as an unsigned 32-bit big-endian
     /// integer or returns an error.
     #[inline(always)]
-    fn read_be_u32(&mut self) -> io::Result<u32> {
+    fn read_be_u32(&mut self) -> Result<u32> {
         Ok(u32::from_be_bytes(self.read_quad_bytes()?))
     }
 
     /// Reads four bytes from the stream and interprets them as a signed 32-bit big-endian
     /// integer or returns an error.
     #[inline(always)]
-    fn read_be_i32(&mut self) -> io::Result<i32> {
+    fn read_be_i32(&mut self) -> Result<i32> {
         Ok(i32::from_be_bytes(self.read_quad_bytes()?))
     }
 
     /// Reads eight bytes from the stream and interprets them as an unsigned 64-bit little-endian
     /// integer or returns an error.
     #[inline(always)]
-    fn read_u64(&mut self) -> io::Result<u64> {
+    fn read_u64(&mut self) -> Result<u64> {
         let mut buf = [0u8; mem::size_of::<u64>()];
         self.read_buf_exact(&mut buf)?;
         Ok(u64::from_le_bytes(buf))
@@ -275,7 +373,7 @@ pub trait ReadBytes {
     /// Reads eight bytes from the stream and interprets them as an signed 64-bit little-endian
     /// integer or returns an error.
     #[inline(always)]
-    fn read_i64(&mut self) -> io::Result<i64> {
+    fn read_i64(&mut self) -> Result<i64> {
         let mut buf = [0u8; mem::size_of::<i64>()];
         self.read_buf_exact(&mut buf)?;
         Ok(i64::from_le_bytes(buf))
@@ -284,7 +382,7 @@ pub trait ReadBytes {
     /// Reads eight bytes from the stream and interprets them as an unsigned 64-bit big-endian
     /// integer or returns an error.
     #[inline(always)]
-    fn read_be_u64(&mut self) -> io::Result<u64> {
+    fn read_be_u64(&mut self) -> Result<u64> {
         let mut buf = [0u8; mem::size_of::<u64>()];
         self.read_buf_exact(&mut buf)?;
         Ok(u64::from_be_bytes(buf))
@@ -293,7 +391,7 @@ pub trait ReadBytes {
     /// Reads eight bytes from the stream and interprets them as an signed 64-bit big-endian
     /// integer or returns an error.
     #[inline(always)]
-    fn read_be_i64(&mut self) -> io::Result<i64> {
+    fn read_be_i64(&mut self) -> Result<i64> {
         let mut buf = [0u8; mem::size_of::<i64>()];
         self.read_buf_exact(&mut buf)?;
         Ok(i64::from_be_bytes(buf))
@@ -302,21 +400,21 @@ pub trait ReadBytes {
     /// Reads four bytes from the stream and interprets them as a 32-bit little-endian IEEE-754
     /// floating-point value.
     #[inline(always)]
-    fn read_f32(&mut self) -> io::Result<f32> {
+    fn read_f32(&mut self) -> Result<f32> {
         Ok(f32::from_le_bytes(self.read_quad_bytes()?))
     }
 
     /// Reads four bytes from the stream and interprets them as a 32-bit big-endian IEEE-754
     /// floating-point value.
     #[inline(always)]
-    fn read_be_f32(&mut self) -> io::Result<f32> {
+    fn read_be_f32(&mut self) -> Result<f32> {
         Ok(f32::from_be_bytes(self.read_quad_bytes()?))
     }
 
     /// Reads four bytes from the stream and interprets them as a 64-bit little-endian IEEE-754
     /// floating-point value.
     #[inline(always)]
-    fn read_f64(&mut self) -> io::Result<f64> {
+    fn read_f64(&mut self) -> Result<f64> {
         let mut buf = [0u8; mem::size_of::<u64>()];
         self.read_buf_exact(&mut buf)?;
         Ok(f64::from_le_bytes(buf))
@@ -325,7 +423,7 @@ pub trait ReadBytes {
     /// Reads four bytes from the stream and interprets them as a 64-bit big-endian IEEE-754
     /// floating-point value.
     #[inline(always)]
-    fn read_be_f64(&mut self) -> io::Result<f64> {
+    fn read_be_f64(&mut self) -> Result<f64> {
         let mut buf = [0u8; mem::size_of::<u64>()];
         self.read_buf_exact(&mut buf)?;
         Ok(f64::from_be_bytes(buf))
@@ -333,7 +431,7 @@ pub trait ReadBytes {
 
     /// Reads up-to the number of bytes requested, and returns a boxed slice of the data or an
     /// error.
-    fn read_boxed_slice(&mut self, len: usize) -> io::Result<Box<[u8]>> {
+    fn read_boxed_slice(&mut self, len: usize) -> Result<Box<[u8]>> {
         let mut buf = vec![0u8; len];
         let actual_len = self.read_buf(&mut buf)?;
         buf.truncate(actual_len);
@@ -342,7 +440,7 @@ pub trait ReadBytes {
 
     /// Reads exactly the number of bytes requested, and returns a boxed slice of the data or an
     /// error.
-    fn read_boxed_slice_exact(&mut self, len: usize) -> io::Result<Box<[u8]>> {
+    fn read_boxed_slice_exact(&mut self, len: usize) -> Result<Box<[u8]>> {
         let mut buf = vec![0u8; len];
         self.read_buf_exact(&mut buf)?;
         Ok(buf.into_boxed_slice())
@@ -351,7 +449,7 @@ pub trait ReadBytes {
     /// Reads bytes from the stream into a supplied buffer until a byte pattern is matched. Returns
     /// a mutable slice to the valid region of the provided buffer.
     #[inline(always)]
-    fn scan_bytes<'a>(&mut self, pattern: &[u8], buf: &'a mut [u8]) -> io::Result<&'a mut [u8]> {
+    fn scan_bytes<'a>(&mut self, pattern: &[u8], buf: &'a mut [u8]) -> Result<&'a mut [u8]> {
         self.scan_bytes_aligned(pattern, 1, buf)
     }
 
@@ -362,10 +460,10 @@ pub trait ReadBytes {
         pattern: &[u8],
         align: usize,
         buf: &'a mut [u8],
-    ) -> io::Result<&'a mut [u8]>;
+    ) -> Result<&'a mut [u8]>;
 
     /// Ignores the specified number of bytes from the stream or returns an error.
-    fn ignore_bytes(&mut self, count: u64) -> io::Result<()>;
+    fn ignore_bytes(&mut self, count: u64) -> Result<()>;
 
     /// Gets the position of the stream.
     fn pos(&self) -> u64;
@@ -373,32 +471,32 @@ pub trait ReadBytes {
 
 impl<'b, R: ReadBytes> ReadBytes for &'b mut R {
     #[inline(always)]
-    fn read_byte(&mut self) -> io::Result<u8> {
+    fn read_byte(&mut self) -> Result<u8> {
         (*self).read_byte()
     }
 
     #[inline(always)]
-    fn read_double_bytes(&mut self) -> io::Result<[u8; 2]> {
+    fn read_double_bytes(&mut self) -> Result<[u8; 2]> {
         (*self).read_double_bytes()
     }
 
     #[inline(always)]
-    fn read_triple_bytes(&mut self) -> io::Result<[u8; 3]> {
+    fn read_triple_bytes(&mut self) -> Result<[u8; 3]> {
         (*self).read_triple_bytes()
     }
 
     #[inline(always)]
-    fn read_quad_bytes(&mut self) -> io::Result<[u8; 4]> {
+    fn read_quad_bytes(&mut self) -> Result<[u8; 4]> {
         (*self).read_quad_bytes()
     }
 
     #[inline(always)]
-    fn read_buf(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+    fn read_buf(&mut self, buf: &mut [u8]) -> Result<usize> {
         (*self).read_buf(buf)
     }
 
     #[inline(always)]
-    fn read_buf_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
+    fn read_buf_exact(&mut self, buf: &mut [u8]) -> Result<()> {
         (*self).read_buf_exact(buf)
     }
 
@@ -408,12 +506,12 @@ impl<'b, R: ReadBytes> ReadBytes for &'b mut R {
         pattern: &[u8],
         align: usize,
         buf: &'a mut [u8],
-    ) -> io::Result<&'a mut [u8]> {
+    ) -> Result<&'a mut [u8]> {
         (*self).scan_bytes_aligned(pattern, align, buf)
     }
 
     #[inline(always)]
-    fn ignore_bytes(&mut self, count: u64) -> io::Result<()> {
+    fn ignore_bytes(&mut self, count: u64) -> Result<()> {
         (*self).ignore_bytes(count)
     }
 
diff --git a/symphonia-core/src/io/monitor_stream.rs b/symphonia-core/src/io/monitor_stream.rs
index 72677be9..bea9335a 100644
--- a/symphonia-core/src/io/monitor_stream.rs
+++ b/symphonia-core/src/io/monitor_stream.rs
@@ -5,9 +5,9 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use std::io;
 
 use super::ReadBytes;
+use crate::errors::Result;
 
 /// A `Monitor` provides a common interface to examine the operations observed be
 /// a [`MonitorStream`].
@@ -73,40 +73,40 @@ impl<B: ReadBytes, M: Monitor> MonitorStream<B, M> {
 
 impl<B: ReadBytes, M: Monitor> ReadBytes for MonitorStream<B, M> {
     #[inline(always)]
-    fn read_byte(&mut self) -> io::Result<u8> {
+    fn read_byte(&mut self) -> Result<u8> {
         let byte = self.inner.read_byte()?;
         self.monitor.process_byte(byte);
         Ok(byte)
     }
 
     #[inline(always)]
-    fn read_double_bytes(&mut self) -> io::Result<[u8; 2]> {
+    fn read_double_bytes(&mut self) -> Result<[u8; 2]> {
         let bytes = self.inner.read_double_bytes()?;
         self.monitor.process_double_bytes(bytes);
         Ok(bytes)
     }
 
     #[inline(always)]
-    fn read_triple_bytes(&mut self) -> io::Result<[u8; 3]> {
+    fn read_triple_bytes(&mut self) -> Result<[u8; 3]> {
         let bytes = self.inner.read_triple_bytes()?;
         self.monitor.process_triple_bytes(bytes);
         Ok(bytes)
     }
 
     #[inline(always)]
-    fn read_quad_bytes(&mut self) -> io::Result<[u8; 4]> {
+    fn read_quad_bytes(&mut self) -> Result<[u8; 4]> {
         let bytes = self.inner.read_quad_bytes()?;
         self.monitor.process_quad_bytes(bytes);
         Ok(bytes)
     }
 
-    fn read_buf(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+    fn read_buf(&mut self, buf: &mut [u8]) -> Result<usize> {
         let len = self.inner.read_buf(buf)?;
         self.monitor.process_buf_bytes(&buf[0..len]);
         Ok(len)
     }
 
-    fn read_buf_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
+    fn read_buf_exact(&mut self, buf: &mut [u8]) -> Result<()> {
         self.inner.read_buf_exact(buf)?;
         self.monitor.process_buf_bytes(buf);
         Ok(())
@@ -117,13 +117,13 @@ impl<B: ReadBytes, M: Monitor> ReadBytes for MonitorStream<B, M> {
         pattern: &[u8],
         align: usize,
         buf: &'a mut [u8],
-    ) -> io::Result<&'a mut [u8]> {
+    ) -> Result<&'a mut [u8]> {
         let result = self.inner.scan_bytes_aligned(pattern, align, buf)?;
         self.monitor.process_buf_bytes(result);
         Ok(result)
     }
 
-    fn ignore_bytes(&mut self, count: u64) -> io::Result<()> {
+    fn ignore_bytes(&mut self, count: u64) -> Result<()> {
         self.inner.ignore_bytes(count)
     }
 
diff --git a/symphonia-core/src/io/scoped_stream.rs b/symphonia-core/src/io/scoped_stream.rs
index 3d2a09cc..812cfc97 100644
--- a/symphonia-core/src/io/scoped_stream.rs
+++ b/symphonia-core/src/io/scoped_stream.rs
@@ -6,13 +6,14 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 use core::cmp;
-use std::io;
+use crate::errors::{IoErrorKind, Result};
+use crate::errors::Error;
 
 use super::{FiniteStream, ReadBytes, SeekBuffered};
 
 #[inline(always)]
-fn out_of_bounds_error<T>() -> io::Result<T> {
-    Err(io::Error::new(io::ErrorKind::UnexpectedEof, "out of bounds"))
+fn out_of_bounds_error<T>() -> Result<T> {
+    Err(Error::IoError(IoErrorKind::UnexpectedEof, "out of bounds"))
 }
 
 /// A `ScopedStream` restricts the number of bytes that may be read to an upper limit.
@@ -41,7 +42,7 @@ impl<B: ReadBytes> ScopedStream<B> {
     }
 
     /// Ignores the remainder of the `ScopedStream`.
-    pub fn ignore(&mut self) -> io::Result<()> {
+    pub fn ignore(&mut self) -> Result<()> {
         self.inner.ignore_bytes(self.len - self.read)
     }
 
@@ -70,7 +71,7 @@ impl<B: ReadBytes> FiniteStream for ScopedStream<B> {
 
 impl<B: ReadBytes> ReadBytes for ScopedStream<B> {
     #[inline(always)]
-    fn read_byte(&mut self) -> io::Result<u8> {
+    fn read_byte(&mut self) -> Result<u8> {
         if self.len - self.read < 1 {
             return out_of_bounds_error();
         }
@@ -80,7 +81,7 @@ impl<B: ReadBytes> ReadBytes for ScopedStream<B> {
     }
 
     #[inline(always)]
-    fn read_double_bytes(&mut self) -> io::Result<[u8; 2]> {
+    fn read_double_bytes(&mut self) -> Result<[u8; 2]> {
         if self.len - self.read < 2 {
             return out_of_bounds_error();
         }
@@ -90,7 +91,7 @@ impl<B: ReadBytes> ReadBytes for ScopedStream<B> {
     }
 
     #[inline(always)]
-    fn read_triple_bytes(&mut self) -> io::Result<[u8; 3]> {
+    fn read_triple_bytes(&mut self) -> Result<[u8; 3]> {
         if self.len - self.read < 3 {
             return out_of_bounds_error();
         }
@@ -100,7 +101,7 @@ impl<B: ReadBytes> ReadBytes for ScopedStream<B> {
     }
 
     #[inline(always)]
-    fn read_quad_bytes(&mut self) -> io::Result<[u8; 4]> {
+    fn read_quad_bytes(&mut self) -> Result<[u8; 4]> {
         if self.len - self.read < 4 {
             return out_of_bounds_error();
         }
@@ -109,7 +110,7 @@ impl<B: ReadBytes> ReadBytes for ScopedStream<B> {
         self.inner.read_quad_bytes()
     }
 
-    fn read_buf(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+    fn read_buf(&mut self, buf: &mut [u8]) -> Result<usize> {
         // Limit read_buf() to the remainder of the scoped bytes if buf has a greater length.
         let scoped_len = cmp::min(self.len - self.read, buf.len() as u64) as usize;
         let result = self.inner.read_buf(&mut buf[0..scoped_len])?;
@@ -117,7 +118,7 @@ impl<B: ReadBytes> ReadBytes for ScopedStream<B> {
         Ok(result)
     }
 
-    fn read_buf_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
+    fn read_buf_exact(&mut self, buf: &mut [u8]) -> Result<()> {
         if self.len - self.read < buf.len() as u64 {
             return out_of_bounds_error();
         }
@@ -132,7 +133,7 @@ impl<B: ReadBytes> ReadBytes for ScopedStream<B> {
         pattern: &[u8],
         align: usize,
         buf: &'a mut [u8],
-    ) -> io::Result<&'a mut [u8]> {
+    ) -> Result<&'a mut [u8]> {
         if self.len - self.read < buf.len() as u64 {
             return out_of_bounds_error();
         }
@@ -143,7 +144,7 @@ impl<B: ReadBytes> ReadBytes for ScopedStream<B> {
     }
 
     #[inline(always)]
-    fn ignore_bytes(&mut self, count: u64) -> io::Result<()> {
+    fn ignore_bytes(&mut self, count: u64) -> Result<()> {
         if self.len - self.read < count {
             return out_of_bounds_error();
         }
diff --git a/symphonia-core/src/lib.rs b/symphonia-core/src/lib.rs
index 2adc5301..cdd62445 100644
--- a/symphonia-core/src/lib.rs
+++ b/symphonia-core/src/lib.rs
@@ -13,7 +13,11 @@
 #![allow(clippy::identity_op)]
 #![allow(clippy::manual_range_contains)]
 
+#![feature(error_in_core)]
+
 extern crate alloc;
+
+#[cfg(feature = "std")]
 extern crate std;
 
 pub mod audio;
diff --git a/symphonia-format-isomp4/src/demuxer.rs b/symphonia-format-isomp4/src/demuxer.rs
index 2bab1df1..c09e1cd2 100644
--- a/symphonia-format-isomp4/src/demuxer.rs
+++ b/symphonia-format-isomp4/src/demuxer.rs
@@ -10,12 +10,11 @@ use symphonia_core::{errors::end_of_stream_error, support_format};
 use symphonia_core::codecs::CodecParameters;
 use symphonia_core::errors::{decode_error, seek_error, unsupported_error, Result, SeekErrorKind};
 use symphonia_core::formats::prelude::*;
-use symphonia_core::io::{MediaSource, MediaSourceStream, ReadBytes, SeekBuffered};
+use symphonia_core::io::*;
 use symphonia_core::meta::{Metadata, MetadataLog};
 use symphonia_core::probe::{Descriptor, Instantiate, QueryDescriptor};
 use symphonia_core::units::Time;
 
-use std::io::{Seek, SeekFrom};
 use std::sync::Arc;
 
 use crate::atoms::{AtomIterator, AtomType};
diff --git a/symphonia-format-mkv/src/demuxer.rs b/symphonia-format-mkv/src/demuxer.rs
index ccbc7484..7fdca565 100644
--- a/symphonia-format-mkv/src/demuxer.rs
+++ b/symphonia-format-mkv/src/demuxer.rs
@@ -7,7 +7,6 @@
 
 use std::collections::{HashMap, VecDeque};
 use std::convert::TryFrom;
-use std::io::{Seek, SeekFrom};
 
 use symphonia_core::audio::Layout;
 use symphonia_core::codecs::{CodecParameters, CODEC_TYPE_FLAC, CODEC_TYPE_VORBIS};
@@ -17,7 +16,7 @@ use symphonia_core::errors::{
 use symphonia_core::formats::{
     Cue, FormatOptions, FormatReader, Packet, SeekMode, SeekTo, SeekedTo, Track,
 };
-use symphonia_core::io::{BufReader, MediaSource, MediaSourceStream, ReadBytes};
+use symphonia_core::io::{BufReader, MediaSource, MediaSourceStream, ReadBytes, Seek, SeekFrom};
 use symphonia_core::meta::{Metadata, MetadataLog};
 use symphonia_core::probe::Instantiate;
 use symphonia_core::probe::{Descriptor, QueryDescriptor};
diff --git a/symphonia-format-mkv/src/ebml.rs b/symphonia-format-mkv/src/ebml.rs
index 9c5c3a1b..ae2bf50d 100644
--- a/symphonia-format-mkv/src/ebml.rs
+++ b/symphonia-format-mkv/src/ebml.rs
@@ -5,10 +5,8 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use std::io::SeekFrom;
-
 use symphonia_core::errors::{decode_error, seek_error, Error, Result, SeekErrorKind};
-use symphonia_core::io::{MediaSource, ReadBytes};
+use symphonia_core::io::{MediaSource, ReadBytes, SeekFrom};
 use symphonia_core::util::bits::sign_extend_leq64_to_i64;
 
 use crate::element_ids::{ElementType, Type, ELEMENTS};
diff --git a/symphonia-format-ogg/src/demuxer.rs b/symphonia-format-ogg/src/demuxer.rs
index e964403b..4003d3db 100644
--- a/symphonia-format-ogg/src/demuxer.rs
+++ b/symphonia-format-ogg/src/demuxer.rs
@@ -6,12 +6,11 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 use std::collections::BTreeMap;
-use std::io::{Seek, SeekFrom};
 
 use symphonia_core::errors::{reset_error, seek_error, unsupported_error};
 use symphonia_core::errors::{Error, Result, SeekErrorKind};
 use symphonia_core::formats::prelude::*;
-use symphonia_core::io::{MediaSource, MediaSourceStream, ReadBytes, SeekBuffered};
+use symphonia_core::io::*;
 use symphonia_core::meta::{Metadata, MetadataLog};
 use symphonia_core::probe::{Descriptor, Instantiate, QueryDescriptor};
 use symphonia_core::support_format;
@@ -49,7 +48,7 @@ impl OggReader {
         loop {
             match self.pages.try_next_page(&mut self.reader) {
                 Ok(_) => break,
-                Err(Error::IoError(e)) => return Err(Error::from(e)),
+                Err(Error::IoError(e, desc)) => return Err(Error::IoError(e, desc)),
                 Err(e) => {
                     warn!("{}", e);
                 }
diff --git a/symphonia-format-ogg/src/page.rs b/symphonia-format-ogg/src/page.rs
index 271fa648..e54871ca 100644
--- a/symphonia-format-ogg/src/page.rs
+++ b/symphonia-format-ogg/src/page.rs
@@ -6,7 +6,7 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 use symphonia_core::checksum::Crc32;
-use symphonia_core::errors::{decode_error, Error, Result};
+use symphonia_core::errors::{decode_error, Error, IoErrorKind, Result};
 use symphonia_core::io::{BufReader, Monitor, MonitorStream, ReadBytes, SeekBuffered};
 
 use log::{debug, warn};
@@ -269,7 +269,7 @@ impl PageReader {
         loop {
             match self.try_next_page(reader) {
                 Ok(_) => break,
-                Err(Error::IoError(e)) => return Err(Error::from(e)),
+                Err(Error::IoError(e, desc)) => return Err(Error::IoError(e, desc)),
                 _ => (),
             }
         }
@@ -290,7 +290,7 @@ impl PageReader {
                         break;
                     }
                 }
-                Err(Error::IoError(e)) => return Err(Error::from(e)),
+                Err(Error::IoError(e, desc)) => return Err(Error::IoError(e, desc)),
                 _ => (),
             }
         }
diff --git a/symphonia-format-ogg/src/physical.rs b/symphonia-format-ogg/src/physical.rs
index dc921740..58c80b96 100644
--- a/symphonia-format-ogg/src/physical.rs
+++ b/symphonia-format-ogg/src/physical.rs
@@ -5,10 +5,9 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 use std::collections::{BTreeMap, BTreeSet};
-use std::io::{Seek, SeekFrom};
 
 use symphonia_core::errors::Result;
-use symphonia_core::io::{MediaSourceStream, ReadBytes, ScopedStream, SeekBuffered};
+use symphonia_core::io::{MediaSourceStream, ReadBytes, ScopedStream, SeekBuffered, SeekFrom, Seek};
 
 use super::logical::{InspectState, LogicalStream};
 use super::page::*;
diff --git a/symphonia-format-riff/src/aiff/mod.rs b/symphonia-format-riff/src/aiff/mod.rs
index 7d8804c9..c7b9c2a7 100644
--- a/symphonia-format-riff/src/aiff/mod.rs
+++ b/symphonia-format-riff/src/aiff/mod.rs
@@ -5,8 +5,6 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use std::io::{Seek, SeekFrom};
-
 use symphonia_core::codecs::CodecParameters;
 use symphonia_core::errors::{seek_error, unsupported_error};
 use symphonia_core::errors::{Result, SeekErrorKind};
diff --git a/symphonia-format-riff/src/wave/mod.rs b/symphonia-format-riff/src/wave/mod.rs
index d0e65b9d..23b59e84 100644
--- a/symphonia-format-riff/src/wave/mod.rs
+++ b/symphonia-format-riff/src/wave/mod.rs
@@ -5,8 +5,6 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use std::io::{Seek, SeekFrom};
-
 use symphonia_core::codecs::CodecParameters;
 use symphonia_core::errors::{seek_error, unsupported_error};
 use symphonia_core::errors::{Result, SeekErrorKind};
diff --git a/symphonia-format-wav/src/lib.rs b/symphonia-format-wav/src/lib.rs
index 281f9567..c4499c40 100644
--- a/symphonia-format-wav/src/lib.rs
+++ b/symphonia-format-wav/src/lib.rs
@@ -14,8 +14,6 @@
 #![allow(clippy::identity_op)]
 #![allow(clippy::manual_range_contains)]
 
-use std::io::{Seek, SeekFrom};
-
 use symphonia_core::codecs::CodecParameters;
 use symphonia_core::errors::{decode_error, end_of_stream_error, seek_error, unsupported_error};
 use symphonia_core::errors::{Result, SeekErrorKind};
diff --git a/symphonia-metadata/src/id3v2/frames.rs b/symphonia-metadata/src/id3v2/frames.rs
index 0ffbfc2c..fc9424a0 100644
--- a/symphonia-metadata/src/id3v2/frames.rs
+++ b/symphonia-metadata/src/id3v2/frames.rs
@@ -952,7 +952,7 @@ fn scan_text<'a>(
     reader: &'a mut BufReader<'_>,
     encoding: Encoding,
     scan_len: usize,
-) -> io::Result<Cow<'a, str>> {
+) -> Result<Cow<'a, str>> {
     let buf = match encoding {
         Encoding::Iso8859_1 | Encoding::Utf8 => reader.scan_bytes_aligned_ref(&[0x00], 1, scan_len),
         Encoding::Utf16Bom | Encoding::Utf16Be => {
diff --git a/symphonia-metadata/src/id3v2/unsync.rs b/symphonia-metadata/src/id3v2/unsync.rs
index 826dc12c..01b2b407 100644
--- a/symphonia-metadata/src/id3v2/unsync.rs
+++ b/symphonia-metadata/src/id3v2/unsync.rs
@@ -86,7 +86,7 @@ impl<B: ReadBytes + FiniteStream> FiniteStream for UnsyncStream<B> {
 }
 
 impl<B: ReadBytes + FiniteStream> ReadBytes for UnsyncStream<B> {
-    fn read_byte(&mut self) -> io::Result<u8> {
+    fn read_byte(&mut self) -> Result<u8> {
         let last = self.byte;
 
         self.byte = self.inner.read_byte()?;
@@ -100,24 +100,24 @@ impl<B: ReadBytes + FiniteStream> ReadBytes for UnsyncStream<B> {
         Ok(self.byte)
     }
 
-    fn read_double_bytes(&mut self) -> io::Result<[u8; 2]> {
+    fn read_double_bytes(&mut self) -> Result<[u8; 2]> {
         Ok([self.read_byte()?, self.read_byte()?])
     }
 
-    fn read_triple_bytes(&mut self) -> io::Result<[u8; 3]> {
+    fn read_triple_bytes(&mut self) -> Result<[u8; 3]> {
         Ok([self.read_byte()?, self.read_byte()?, self.read_byte()?])
     }
 
-    fn read_quad_bytes(&mut self) -> io::Result<[u8; 4]> {
+    fn read_quad_bytes(&mut self) -> Result<[u8; 4]> {
         Ok([self.read_byte()?, self.read_byte()?, self.read_byte()?, self.read_byte()?])
     }
 
-    fn read_buf(&mut self, _: &mut [u8]) -> io::Result<usize> {
+    fn read_buf(&mut self, _: &mut [u8]) -> Result<usize> {
         // Not required.
         unimplemented!();
     }
 
-    fn read_buf_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
+    fn read_buf_exact(&mut self, buf: &mut [u8]) -> Result<()> {
         let len = buf.len();
 
         if len > 0 {
@@ -166,12 +166,12 @@ impl<B: ReadBytes + FiniteStream> ReadBytes for UnsyncStream<B> {
         _: &[u8],
         _: usize,
         _: &'a mut [u8],
-    ) -> io::Result<&'a mut [u8]> {
+    ) -> Result<&'a mut [u8]> {
         // Not required.
         unimplemented!();
     }
 
-    fn ignore_bytes(&mut self, count: u64) -> io::Result<()> {
+    fn ignore_bytes(&mut self, count: u64) -> Result<()> {
         for _ in 0..count {
             self.inner.read_byte()?;
         }
diff --git a/symphonia-play/src/main.rs b/symphonia-play/src/main.rs
index 323e7f1b..9655b3b3 100644
--- a/symphonia-play/src/main.rs
+++ b/symphonia-play/src/main.rs
@@ -18,7 +18,7 @@ use std::path::Path;
 
 use lazy_static::lazy_static;
 use symphonia::core::codecs::{DecoderOptions, FinalizeResult, CODEC_TYPE_NULL};
-use symphonia::core::errors::{Error, Result};
+use symphonia::core::errors::{Error, IoErrorKind, Result};
 use symphonia::core::formats::{Cue, FormatOptions, FormatReader, SeekMode, SeekTo, Track};
 use symphonia::core::io::{MediaSource, MediaSourceStream, ReadOnlySource};
 use symphonia::core::meta::{ColorMode, MetadataOptions, MetadataRevision, Tag, Value, Visual};
@@ -402,10 +402,7 @@ fn first_supported_track(tracks: &[Track]) -> Option<&Track> {
 
 fn ignore_end_of_stream_error(result: Result<()>) -> Result<()> {
     match result {
-        Err(Error::IoError(err))
-            if err.kind() == std::io::ErrorKind::UnexpectedEof
-                && err.to_string() == "end of stream" =>
-        {
+        Err(Error::IoError(IoErrorKind::UnexpectedEof, "end of stream")) => {
             // Do not treat "end of stream" as a fatal error. It's the currently only way a
             // format reader can indicate the media is complete.
             Ok(())
diff --git a/symphonia/examples/getting-started.rs b/symphonia/examples/getting-started.rs
index 64ad2470..064ac404 100644
--- a/symphonia/examples/getting-started.rs
+++ b/symphonia/examples/getting-started.rs
@@ -86,7 +86,7 @@ fn main() {
             Ok(_decoded) => {
                 // Consume the decoded audio samples (see below).
             }
-            Err(Error::IoError(_)) => {
+            Err(Error::IoError(_, _)) => {
                 // The packet failed to decode due to an IO error, skip the packet.
                 continue;
             }

From a83d9a0d76d00dd755ac90a980ee1ea382d6a420 Mon Sep 17 00:00:00 2001
From: atok <atoktoto@fastmail.fm>
Date: Sun, 24 Dec 2023 10:45:57 +0100
Subject: [PATCH 03/22] Add back the missing test

---
 symphonia-core/src/io/media_source_stream.rs | 25 +++++++------
 symphonia-core/src/io/mod.rs                 | 38 +++++++++++++++-----
 2 files changed, 41 insertions(+), 22 deletions(-)

diff --git a/symphonia-core/src/io/media_source_stream.rs b/symphonia-core/src/io/media_source_stream.rs
index 56af3d3b..83da55b2 100644
--- a/symphonia-core/src/io/media_source_stream.rs
+++ b/symphonia-core/src/io/media_source_stream.rs
@@ -8,7 +8,6 @@
 use alloc::boxed::Box;
 use alloc::vec;
 use core::cmp;
-// use std::io::{IoSliceMut, Read, Seek};
 use core::ops::Sub;
 
 use super::{IoSliceMut, Read, Seek, SeekBuffered, SeekFrom};
@@ -496,7 +495,8 @@ mod tests {
     use alloc::vec;
     use alloc::vec::Vec;
     use super::{MediaSourceStream, ReadBytes, SeekBuffered};
-    use std::io::{Cursor, Read};
+    use std::io::{Cursor};
+    use crate::io::Read;
 
     /// Generate a random vector of bytes of the specified length using a PRNG.
     fn generate_random_bytes(len: usize) -> Box<[u8]> {
@@ -559,17 +559,16 @@ mod tests {
         }
     }
 
-    // TODO
-    // #[test]
-    // fn verify_mss_read_to_end() {
-    //     let data = generate_random_bytes(5 * 96 * 1024);
-    //
-    //     let ms = Cursor::new(data.clone());
-    //     let mut mss = MediaSourceStream::new(Box::new(ms), Default::default());
-    //     let mut output: Vec<u8> = Vec::new();
-    //     assert_eq!(mss.read_to_end(&mut output).unwrap(), data.len());
-    //     assert_eq!(output.into_boxed_slice(), data);
-    // }
+    #[test]
+    fn verify_mss_read_to_end() {
+        let data = generate_random_bytes(5 * 96 * 1024);
+
+        let ms = Cursor::new(data.clone());
+        let mut mss = MediaSourceStream::new(Box::new(ms), Default::default());
+        let mut output: Vec<u8> = Vec::new();
+        assert_eq!(mss.read_to_end(&mut output).unwrap(), data.len());
+        assert_eq!(output.into_boxed_slice(), data);
+    }
 
     #[test]
     fn verify_mss_seek_buffered() {
diff --git a/symphonia-core/src/io/mod.rs b/symphonia-core/src/io/mod.rs
index ca5b50b3..de89c883 100644
--- a/symphonia-core/src/io/mod.rs
+++ b/symphonia-core/src/io/mod.rs
@@ -36,6 +36,7 @@ pub use media_source_stream::{MediaSourceStream, MediaSourceStreamOptions};
 pub use monitor_stream::{Monitor, MonitorStream};
 pub use scoped_stream::ScopedStream;
 use std::ops::{Deref, DerefMut};
+use alloc::vec::Vec;
 use crate::errors::{Error, IoErrorKind, Result};
 
 pub trait Seek {
@@ -89,21 +90,40 @@ impl<'a> DerefMut for IoSliceMut<'a> {
     }
 }
 
-impl <'a> Iterator for IoSliceMut<'a> {
-    type Item = u8;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        todo!()
-    }
-}
-
-
 pub trait Read {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize>;
 
     fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize> {
         default_read_vectored(|b| self.read(b), bufs)
     }
+
+    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize> {
+        default_slow_read_to_end(self, buf)
+    }
+}
+
+/// Warning: The default implementation in io::Read is much faster
+fn default_slow_read_to_end<R: Read + ?Sized>(
+    r: &mut R,
+    buf: &mut Vec<u8>
+) -> Result<usize> {
+
+    let mut cnt: usize = 0;
+    let mut read_buf: [u8; 1024] = [0; 1024];
+
+    while let r = r.read(&mut read_buf) {
+        let n = match r {
+            Ok(0) => break,
+            Ok(n) => n,
+            Err(Error::IoError(IoErrorKind::Interrupted, _)) => 0, // Ignored
+            Err(err) => return Err(err),
+        };
+
+        buf.extend_from_slice(&read_buf[0..n]);
+        cnt += n;
+    }
+
+    Ok(cnt)
 }
 
 fn default_read_vectored<F>(read: F, bufs: &mut [IoSliceMut<'_>]) -> Result<usize>

From 868f33faef82c79c9eb30698ce65c3b5aa06a763 Mon Sep 17 00:00:00 2001
From: atok <atoktoto@fastmail.fm>
Date: Sun, 24 Dec 2023 10:48:35 +0100
Subject: [PATCH 04/22] Cleanup

---
 symphonia-codec-vorbis/src/residue.rs  | 1 -
 symphonia-core/src/errors.rs           | 2 +-
 symphonia-format-ogg/src/page.rs       | 2 +-
 symphonia-metadata/src/id3v2/frames.rs | 1 -
 symphonia-metadata/src/id3v2/unsync.rs | 2 --
 5 files changed, 2 insertions(+), 6 deletions(-)

diff --git a/symphonia-codec-vorbis/src/residue.rs b/symphonia-codec-vorbis/src/residue.rs
index c7b7fc2c..3e2f3076 100644
--- a/symphonia-codec-vorbis/src/residue.rs
+++ b/symphonia-codec-vorbis/src/residue.rs
@@ -7,7 +7,6 @@
 
 use std::cmp::min;
 use std::convert::TryInto;
-use std::io;
 
 use symphonia_core::errors::{decode_error, Error, IoErrorKind, Result};
 use symphonia_core::io::{BitReaderRtl, ReadBitsRtl};
diff --git a/symphonia-core/src/errors.rs b/symphonia-core/src/errors.rs
index d8d5a686..53e7997e 100644
--- a/symphonia-core/src/errors.rs
+++ b/symphonia-core/src/errors.rs
@@ -9,7 +9,7 @@
 
 use core::{error, result};
 use core::fmt;
-use core::fmt::{Display, Formatter, write};
+use core::fmt::{Display, Formatter};
 
 
 /// `SeekErrorKind` is a list of generic reasons why a seek may fail.
diff --git a/symphonia-format-ogg/src/page.rs b/symphonia-format-ogg/src/page.rs
index e54871ca..ff811f3f 100644
--- a/symphonia-format-ogg/src/page.rs
+++ b/symphonia-format-ogg/src/page.rs
@@ -6,7 +6,7 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 use symphonia_core::checksum::Crc32;
-use symphonia_core::errors::{decode_error, Error, IoErrorKind, Result};
+use symphonia_core::errors::{decode_error, Error, Result};
 use symphonia_core::io::{BufReader, Monitor, MonitorStream, ReadBytes, SeekBuffered};
 
 use log::{debug, warn};
diff --git a/symphonia-metadata/src/id3v2/frames.rs b/symphonia-metadata/src/id3v2/frames.rs
index fc9424a0..490ea3ab 100644
--- a/symphonia-metadata/src/id3v2/frames.rs
+++ b/symphonia-metadata/src/id3v2/frames.rs
@@ -6,7 +6,6 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 use std::borrow::Cow;
 use std::collections::HashMap;
-use std::io;
 use std::str;
 
 use symphonia_core::errors::{decode_error, unsupported_error, Result};
diff --git a/symphonia-metadata/src/id3v2/unsync.rs b/symphonia-metadata/src/id3v2/unsync.rs
index 01b2b407..0bbca529 100644
--- a/symphonia-metadata/src/id3v2/unsync.rs
+++ b/symphonia-metadata/src/id3v2/unsync.rs
@@ -5,8 +5,6 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use std::io;
-
 use symphonia_core::errors::Result;
 use symphonia_core::io::{FiniteStream, ReadBytes};
 

From 9b7d0c5ac43d091d3b16227aa9a3e96bd48baf87 Mon Sep 17 00:00:00 2001
From: atok <atoktoto@fastmail.fm>
Date: Sun, 24 Dec 2023 11:01:00 +0100
Subject: [PATCH 05/22] Cleanup

---
 symphonia-core/src/errors.rs        | 1 +
 symphonia-core/src/io/buf_reader.rs | 3 +--
 symphonia-core/src/io/mod.rs        | 9 +++++++--
 3 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/symphonia-core/src/errors.rs b/symphonia-core/src/errors.rs
index 53e7997e..e8cc76f9 100644
--- a/symphonia-core/src/errors.rs
+++ b/symphonia-core/src/errors.rs
@@ -36,6 +36,7 @@ impl SeekErrorKind {
     }
 }
 
+//TODO figure out mapping from io::Error
 #[derive(Debug)]
 pub enum IoErrorKind {
     /// An entity was not found, often a file.
diff --git a/symphonia-core/src/io/buf_reader.rs b/symphonia-core/src/io/buf_reader.rs
index 2c9e8f27..8731ac36 100644
--- a/symphonia-core/src/io/buf_reader.rs
+++ b/symphonia-core/src/io/buf_reader.rs
@@ -8,8 +8,7 @@
 use core::cmp;
 
 use super::{FiniteStream, ReadBytes};
-use crate::errors::{IoErrorKind, Result};
-use crate::errors::Error;
+use crate::errors::{IoErrorKind, Result, Error};
 
 #[inline(always)]
 fn underrun_error<T>() -> Result<T> {
diff --git a/symphonia-core/src/io/mod.rs b/symphonia-core/src/io/mod.rs
index de89c883..bd02b76a 100644
--- a/symphonia-core/src/io/mod.rs
+++ b/symphonia-core/src/io/mod.rs
@@ -21,7 +21,11 @@
 
 use alloc::boxed::Box;
 use alloc::vec;
+use alloc::vec::Vec;
 use core::mem;
+use core::ops::{Deref, DerefMut};
+
+#[cfg(feature = "std")]
 use std::io;
 
 mod bit;
@@ -35,8 +39,7 @@ pub use buf_reader::BufReader;
 pub use media_source_stream::{MediaSourceStream, MediaSourceStreamOptions};
 pub use monitor_stream::{Monitor, MonitorStream};
 pub use scoped_stream::ScopedStream;
-use std::ops::{Deref, DerefMut};
-use alloc::vec::Vec;
+
 use crate::errors::{Error, IoErrorKind, Result};
 
 pub trait Seek {
@@ -134,12 +137,14 @@ fn default_read_vectored<F>(read: F, bufs: &mut [IoSliceMut<'_>]) -> Result<usiz
     read(buf)
 }
 
+#[cfg(feature = "std")]
 impl <T: std::io::Read> Read for T {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
         self.read(buf).map_err(|e| { Error::from(e) })
     }
 }
 
+#[cfg(feature = "std")]
 impl <T: std::io::Seek> Seek for T  {
     fn seek(&mut self, from: SeekFrom) -> Result<u64> {
         let from = match from {

From 29825f81f1abf5bebd9d6b321ebbe5a1226436c2 Mon Sep 17 00:00:00 2001
From: atok <atoktoto@fastmail.fm>
Date: Sun, 24 Dec 2023 11:52:27 +0100
Subject: [PATCH 06/22] no_std support in symphonia-metadata

---
 symphonia-core/src/probe.rs            |  2 +-
 symphonia-metadata/Cargo.toml          |  6 +++++-
 symphonia-metadata/src/id3v1.rs        |  1 +
 symphonia-metadata/src/id3v2/frames.rs | 24 ++++++++++++++----------
 symphonia-metadata/src/itunes.rs       |  6 +++---
 symphonia-metadata/src/lib.rs          |  4 ++++
 symphonia-metadata/src/riff.rs         |  7 ++++---
 symphonia-metadata/src/vorbis.rs       |  9 ++++++---
 8 files changed, 38 insertions(+), 21 deletions(-)

diff --git a/symphonia-core/src/probe.rs b/symphonia-core/src/probe.rs
index 8156e425..09dc7079 100644
--- a/symphonia-core/src/probe.rs
+++ b/symphonia-core/src/probe.rs
@@ -370,7 +370,7 @@ macro_rules! support_metadata {
             mime_types: $mimes,
             markers: $markers,
             score: Self::score,
-            inst: Instantiate::Metadata(|opt| Box::new(Self::new(&opt))),
+            inst: Instantiate::Metadata(|opt| alloc::boxed::Box::new(Self::new(&opt))),
         }
     };
 }
diff --git a/symphonia-metadata/Cargo.toml b/symphonia-metadata/Cargo.toml
index 6be5cda5..fbdaadb9 100644
--- a/symphonia-metadata/Cargo.toml
+++ b/symphonia-metadata/Cargo.toml
@@ -16,4 +16,8 @@ rust-version = "1.53"
 encoding_rs = "0.8.17"
 lazy_static = "1.4.0"
 log = "0.4"
-symphonia-core = { version = "0.5.2", path = "../symphonia-core" }
\ No newline at end of file
+symphonia-core = { version = "0.5.2", path = "../symphonia-core", default-features = false }
+
+[features]
+std = ["symphonia-core/std"]
+default = ["std"]
\ No newline at end of file
diff --git a/symphonia-metadata/src/id3v1.rs b/symphonia-metadata/src/id3v1.rs
index 581a28e9..4b4e0f5b 100644
--- a/symphonia-metadata/src/id3v1.rs
+++ b/symphonia-metadata/src/id3v1.rs
@@ -7,6 +7,7 @@
 
 //! An ID3v1 metadata reader.
 
+use alloc::string::String;
 use symphonia_core::errors::{unsupported_error, Result};
 use symphonia_core::io::ReadBytes;
 use symphonia_core::meta::{MetadataBuilder, StandardTagKey, Tag, Value};
diff --git a/symphonia-metadata/src/id3v2/frames.rs b/symphonia-metadata/src/id3v2/frames.rs
index 490ea3ab..a54261d2 100644
--- a/symphonia-metadata/src/id3v2/frames.rs
+++ b/symphonia-metadata/src/id3v2/frames.rs
@@ -4,9 +4,13 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-use std::borrow::Cow;
-use std::collections::HashMap;
-use std::str;
+use alloc::borrow::Cow;
+use alloc::{format, vec};
+use alloc::boxed::Box;
+use alloc::collections::BTreeMap;
+use alloc::string::{String, ToString};
+use alloc::vec::Vec;
+use core::str;
 
 use symphonia_core::errors::{decode_error, unsupported_error, Result};
 use symphonia_core::io::{BufReader, FiniteStream, ReadBytes};
@@ -173,8 +177,8 @@ fn unsupported_frame(id: &[u8]) -> Result<FrameResult> {
 type FrameParser = fn(&mut BufReader<'_>, Option<StandardTagKey>, &str) -> Result<FrameResult>;
 
 lazy_static! {
-    static ref LEGACY_FRAME_MAP: HashMap<&'static [u8; 3], &'static [u8; 4]> = {
-        let mut m = HashMap::new();
+    static ref LEGACY_FRAME_MAP: BTreeMap<&'static [u8; 3], &'static [u8; 4]> = {
+        let mut m = BTreeMap::new();
         m.insert(b"BUF", b"RBUF");
         m.insert(b"CNT", b"PCNT");
         m.insert(b"COM", b"COMM");
@@ -249,8 +253,8 @@ lazy_static! {
 
 lazy_static! {
     static ref FRAME_PARSERS:
-        HashMap<&'static [u8; 4], (FrameParser, Option<StandardTagKey>)> = {
-            let mut m = HashMap::new();
+        BTreeMap<&'static [u8; 4], (FrameParser, Option<StandardTagKey>)> = {
+            let mut m = BTreeMap::new();
             // m.insert(b"AENC", read_null_frame);
             m.insert(b"APIC", (read_apic_frame as FrameParser, None));
             // m.insert(b"ASPI", read_null_frame);
@@ -363,8 +367,8 @@ lazy_static! {
 }
 
 lazy_static! {
-    static ref TXXX_FRAME_STD_KEYS: HashMap<&'static str, StandardTagKey> = {
-        let mut m = HashMap::new();
+    static ref TXXX_FRAME_STD_KEYS: BTreeMap<&'static str, StandardTagKey> = {
+        let mut m = BTreeMap::new();
         m.insert("ACOUSTID FINGERPRINT", StandardTagKey::AcoustidFingerprint);
         m.insert("ACOUSTID ID", StandardTagKey::AcoustidId);
         m.insert("BARCODE", StandardTagKey::IdentBarcode);
@@ -406,7 +410,7 @@ fn validate_lang_code(code: [u8; 3]) -> bool {
 ///
 /// Assumes the bytes are valid ASCII characters. Panics otherwise.
 fn as_ascii_str(id: &[u8]) -> &str {
-    std::str::from_utf8(id).unwrap()
+    core::str::from_utf8(id).unwrap()
 }
 
 /// Finds a frame parser for "modern" ID3v2.3 or ID3v2.4 tags.
diff --git a/symphonia-metadata/src/itunes.rs b/symphonia-metadata/src/itunes.rs
index 0eb487c1..793c2fc1 100644
--- a/symphonia-metadata/src/itunes.rs
+++ b/symphonia-metadata/src/itunes.rs
@@ -7,15 +7,15 @@
 
 //! iTunes metadata support.
 
+use alloc::collections::BTreeMap;
 use symphonia_core::meta::StandardTagKey;
 
-use std::collections::HashMap;
 
 use lazy_static::lazy_static;
 
 lazy_static! {
-    static ref ITUNES_TAG_MAP: HashMap<&'static str, StandardTagKey> = {
-        let mut m = HashMap::new();
+    static ref ITUNES_TAG_MAP: BTreeMap<&'static str, StandardTagKey> = {
+        let mut m = BTreeMap::new();
         m.insert("com.apple.iTunes:ARTISTS", StandardTagKey::Artist);
         m.insert("com.apple.iTunes:ASIN", StandardTagKey::IdentAsin);
         m.insert("com.apple.iTunes:BARCODE", StandardTagKey::IdentBarcode);
diff --git a/symphonia-metadata/src/lib.rs b/symphonia-metadata/src/lib.rs
index 2e4a7533..d41f45eb 100644
--- a/symphonia-metadata/src/lib.rs
+++ b/symphonia-metadata/src/lib.rs
@@ -5,6 +5,8 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
+#![no_std]
+
 #![warn(rust_2018_idioms)]
 #![forbid(unsafe_code)]
 // The following lints are allowed in all Symphonia crates. Please see clippy.toml for their
@@ -14,6 +16,8 @@
 #![allow(clippy::identity_op)]
 #![allow(clippy::manual_range_contains)]
 
+extern crate alloc;
+
 pub mod id3v1;
 pub mod id3v2;
 pub mod itunes;
diff --git a/symphonia-metadata/src/riff.rs b/symphonia-metadata/src/riff.rs
index 08a22543..02fe0cd7 100644
--- a/symphonia-metadata/src/riff.rs
+++ b/symphonia-metadata/src/riff.rs
@@ -7,13 +7,14 @@
 
 //! A RIFF INFO metadata reader.
 
+use alloc::collections::BTreeMap;
+use alloc::string::String;
 use lazy_static::lazy_static;
-use std::collections::HashMap;
 use symphonia_core::meta::{StandardTagKey, Tag, Value};
 
 lazy_static! {
-    static ref RIFF_INFO_MAP: HashMap<&'static str, StandardTagKey> = {
-        let mut m = HashMap::new();
+    static ref RIFF_INFO_MAP: BTreeMap<&'static str, StandardTagKey> = {
+        let mut m = BTreeMap::new();
         m.insert("ages", StandardTagKey::Rating);
         m.insert("cmnt", StandardTagKey::Comment);
         // Is this the same as a cmnt?
diff --git a/symphonia-metadata/src/vorbis.rs b/symphonia-metadata/src/vorbis.rs
index 92f62758..dc107b59 100644
--- a/symphonia-metadata/src/vorbis.rs
+++ b/symphonia-metadata/src/vorbis.rs
@@ -7,15 +7,18 @@
 
 //! A Vorbic COMMENT metadata reader for FLAC or OGG formats.
 
+use alloc::collections::BTreeMap;
+use alloc::string::String;
+use alloc::vec;
+use alloc::vec::Vec;
 use lazy_static::lazy_static;
-use std::collections::HashMap;
 use symphonia_core::errors::Result;
 use symphonia_core::io::ReadBytes;
 use symphonia_core::meta::{MetadataBuilder, StandardTagKey, Tag, Value};
 
 lazy_static! {
-    static ref VORBIS_COMMENT_MAP: HashMap<&'static str, StandardTagKey> = {
-        let mut m = HashMap::new();
+    static ref VORBIS_COMMENT_MAP: BTreeMap<&'static str, StandardTagKey> = {
+        let mut m = BTreeMap::new();
         m.insert("album artist"                , StandardTagKey::AlbumArtist);
         m.insert("album"                       , StandardTagKey::Album);
         m.insert("albumartist"                 , StandardTagKey::AlbumArtist);

From e47bc3155308060cb06b20b4a6f896ea2973e365 Mon Sep 17 00:00:00 2001
From: atok <atoktoto@fastmail.fm>
Date: Sun, 24 Dec 2023 12:01:09 +0100
Subject: [PATCH 07/22] no_std support in symphonia-utils-xiph

---
 symphonia-utils-xiph/Cargo.toml           | 8 ++++++--
 symphonia-utils-xiph/src/flac/metadata.rs | 7 +++++--
 symphonia-utils-xiph/src/lib.rs           | 4 ++++
 3 files changed, 15 insertions(+), 4 deletions(-)

diff --git a/symphonia-utils-xiph/Cargo.toml b/symphonia-utils-xiph/Cargo.toml
index 6f65bb66..eee902f6 100644
--- a/symphonia-utils-xiph/Cargo.toml
+++ b/symphonia-utils-xiph/Cargo.toml
@@ -13,5 +13,9 @@ edition = "2018"
 rust-version = "1.53"
 
 [dependencies]
-symphonia-core = { version = "0.5.2", path = "../symphonia-core" }
-symphonia-metadata = { version = "0.5.2", path = "../symphonia-metadata" }
\ No newline at end of file
+symphonia-core = { version = "0.5.2", path = "../symphonia-core", default-features = false }
+symphonia-metadata = { version = "0.5.2", path = "../symphonia-metadata", default-features = false }
+
+[features]
+std = ["symphonia-core/std", "symphonia-metadata/std"]
+default = ["std"]
\ No newline at end of file
diff --git a/symphonia-utils-xiph/src/flac/metadata.rs b/symphonia-utils-xiph/src/flac/metadata.rs
index 9408038b..80f85145 100644
--- a/symphonia-utils-xiph/src/flac/metadata.rs
+++ b/symphonia-utils-xiph/src/flac/metadata.rs
@@ -5,8 +5,11 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use std::ascii;
-use std::num::NonZeroU32;
+use alloc::string::String;
+use alloc::vec;
+use alloc::vec::Vec;
+use core::ascii;
+use core::num::NonZeroU32;
 
 use symphonia_core::audio::Channels;
 use symphonia_core::errors::{decode_error, Result};
diff --git a/symphonia-utils-xiph/src/lib.rs b/symphonia-utils-xiph/src/lib.rs
index 4062085e..fd0b54bc 100644
--- a/symphonia-utils-xiph/src/lib.rs
+++ b/symphonia-utils-xiph/src/lib.rs
@@ -12,5 +12,9 @@
 #![allow(clippy::identity_op)]
 #![allow(clippy::manual_range_contains)]
 
+#![no_std]
+
+extern crate alloc;
+
 pub mod flac;
 pub mod vorbis;

From f18bf1e114b10c1892964a8e31efe53deb65bbe1 Mon Sep 17 00:00:00 2001
From: atok <atoktoto@fastmail.fm>
Date: Sun, 24 Dec 2023 12:05:09 +0100
Subject: [PATCH 08/22] Only use replacement IoSliceMut when no_std

---
 symphonia-core/src/io/mod.rs | 69 ++++++++++++++++++++----------------
 1 file changed, 39 insertions(+), 30 deletions(-)

diff --git a/symphonia-core/src/io/mod.rs b/symphonia-core/src/io/mod.rs
index bd02b76a..607d1593 100644
--- a/symphonia-core/src/io/mod.rs
+++ b/symphonia-core/src/io/mod.rs
@@ -24,10 +24,17 @@ use alloc::vec;
 use alloc::vec::Vec;
 use core::mem;
 use core::ops::{Deref, DerefMut};
+use crate::errors::{Error, IoErrorKind, Result};
 
 #[cfg(feature = "std")]
 use std::io;
 
+#[cfg(feature = "std")]
+use std::io::IoSliceMut;
+
+#[cfg(not(feature = "std"))]
+use no_std_compat::IoSliceMut;
+
 mod bit;
 mod buf_reader;
 mod media_source_stream;
@@ -40,8 +47,6 @@ pub use media_source_stream::{MediaSourceStream, MediaSourceStreamOptions};
 pub use monitor_stream::{Monitor, MonitorStream};
 pub use scoped_stream::ScopedStream;
 
-use crate::errors::{Error, IoErrorKind, Result};
-
 pub trait Seek {
     fn seek(&mut self, _: SeekFrom) -> Result<u64>;
 }
@@ -65,34 +70,6 @@ pub enum SeekFrom {
     Current(i64),
 }
 
-struct IoSliceMut<'a> {
-    buf: &'a mut [u8],
-}
-
-impl <'a> IoSliceMut<'a> {
-    fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {
-        IoSliceMut {
-            buf
-        }
-    }
-}
-
-impl<'a> Deref for IoSliceMut<'a> {
-    type Target = [u8];
-
-    #[inline]
-    fn deref(&self) -> &[u8] {
-        self.buf
-    }
-}
-
-impl<'a> DerefMut for IoSliceMut<'a> {
-    #[inline]
-    fn deref_mut(&mut self) -> &mut [u8] {
-        self.buf
-    }
-}
-
 pub trait Read {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize>;
 
@@ -630,3 +607,35 @@ pub trait FiniteStream {
     /// Returns the number of bytes available for reading.
     fn bytes_available(&self) -> u64;
 }
+
+mod no_std_compat {
+    use std::ops::{Deref, DerefMut};
+
+    pub struct IoSliceMut<'a> {
+        buf: &'a mut [u8],
+    }
+
+    impl <'a> IoSliceMut<'a> {
+        fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {
+            IoSliceMut {
+                buf
+            }
+        }
+    }
+
+    impl<'a> Deref for IoSliceMut<'a> {
+        type Target = [u8];
+
+        #[inline]
+        fn deref(&self) -> &[u8] {
+            self.buf
+        }
+    }
+
+    impl<'a> DerefMut for IoSliceMut<'a> {
+        #[inline]
+        fn deref_mut(&mut self) -> &mut [u8] {
+            self.buf
+        }
+    }
+}
\ No newline at end of file

From a0312a53433f850404a4395710befceef7b249fa Mon Sep 17 00:00:00 2001
From: atok <atoktoto@fastmail.fm>
Date: Sun, 24 Dec 2023 12:23:48 +0100
Subject: [PATCH 09/22] Fix io:Error mapping

---
 symphonia-core/src/errors.rs | 34 ++++++++++++++++++++++++----------
 symphonia-core/src/io/mod.rs |  9 +++++----
 2 files changed, 29 insertions(+), 14 deletions(-)

diff --git a/symphonia-core/src/errors.rs b/symphonia-core/src/errors.rs
index e8cc76f9..65b9421c 100644
--- a/symphonia-core/src/errors.rs
+++ b/symphonia-core/src/errors.rs
@@ -36,7 +36,6 @@ impl SeekErrorKind {
     }
 }
 
-//TODO figure out mapping from io::Error
 #[derive(Debug)]
 pub enum IoErrorKind {
     /// An entity was not found, often a file.
@@ -205,14 +204,6 @@ pub enum IoErrorKind {
     /// error kinds cannot be `match`ed on, and will only match a wildcard (`_`) pattern.
     /// New [`std::io::ErrorKind`]s might be added in the future for some of those.
     Other,
-
-    /// Any I/O error from the standard library that's not part of this list.
-    ///
-    /// Errors that are `Uncategorized` now may move to a different or a new
-    /// [`std::io::ErrorKind`] variant in the future. It is not recommended to match
-    /// an error against `Uncategorized`; use a wildcard match (`_`) instead.
-    #[doc(hidden)]
-    Uncategorized,
 }
 
 impl Display for IoErrorKind {
@@ -284,7 +275,30 @@ impl core::error::Error for Error {
 #[cfg(feature = "std")]
 impl From<std::io::Error> for Error {
     fn from(err: std::io::Error) -> Error {
-        Error::from(err)
+        let error_kind = match err.kind() {
+            std::io::ErrorKind::NotFound => IoErrorKind::NotFound,
+            std::io::ErrorKind::PermissionDenied => IoErrorKind::PermissionDenied,
+            std::io::ErrorKind::ConnectionRefused => IoErrorKind::ConnectionRefused,
+            std::io::ErrorKind::ConnectionReset => IoErrorKind::ConnectionReset,
+            std::io::ErrorKind::ConnectionAborted => IoErrorKind::ConnectionAborted,
+            std::io::ErrorKind::NotConnected => IoErrorKind::NotConnected,
+            std::io::ErrorKind::AddrInUse => IoErrorKind::AddrInUse,
+            std::io::ErrorKind::AddrNotAvailable => IoErrorKind::AddrNotAvailable,
+            std::io::ErrorKind::BrokenPipe => IoErrorKind::BrokenPipe,
+            std::io::ErrorKind::AlreadyExists => IoErrorKind::AlreadyExists,
+            std::io::ErrorKind::WouldBlock => IoErrorKind::WouldBlock,
+            std::io::ErrorKind::InvalidInput => IoErrorKind::InvalidInput,
+            std::io::ErrorKind::InvalidData => IoErrorKind::InvalidData,
+            std::io::ErrorKind::TimedOut => IoErrorKind::TimedOut,
+            std::io::ErrorKind::WriteZero => IoErrorKind::WriteZero,
+            std::io::ErrorKind::Interrupted => IoErrorKind::Interrupted,
+            std::io::ErrorKind::Unsupported => IoErrorKind::Unsupported,
+            std::io::ErrorKind::UnexpectedEof => IoErrorKind::UnexpectedEof,
+            std::io::ErrorKind::OutOfMemory => IoErrorKind::OutOfMemory,
+            std::io::ErrorKind::Other => IoErrorKind::Other,
+            _ => IoErrorKind::Other,
+        };
+        Error::IoError(error_kind, "")
     }
 }
 
diff --git a/symphonia-core/src/io/mod.rs b/symphonia-core/src/io/mod.rs
index 607d1593..1ce2f839 100644
--- a/symphonia-core/src/io/mod.rs
+++ b/symphonia-core/src/io/mod.rs
@@ -23,7 +23,6 @@ use alloc::boxed::Box;
 use alloc::vec;
 use alloc::vec::Vec;
 use core::mem;
-use core::ops::{Deref, DerefMut};
 use crate::errors::{Error, IoErrorKind, Result};
 
 #[cfg(feature = "std")]
@@ -91,7 +90,8 @@ fn default_slow_read_to_end<R: Read + ?Sized>(
     let mut cnt: usize = 0;
     let mut read_buf: [u8; 1024] = [0; 1024];
 
-    while let r = r.read(&mut read_buf) {
+    loop {
+        let r =  r.read(&mut read_buf);
         let n = match r {
             Ok(0) => break,
             Ok(n) => n,
@@ -608,15 +608,16 @@ pub trait FiniteStream {
     fn bytes_available(&self) -> u64;
 }
 
+#[cfg(not(feature = "std"))]
 mod no_std_compat {
-    use std::ops::{Deref, DerefMut};
+    use core::ops::{Deref, DerefMut};
 
     pub struct IoSliceMut<'a> {
         buf: &'a mut [u8],
     }
 
     impl <'a> IoSliceMut<'a> {
-        fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {
+        pub fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {
             IoSliceMut {
                 buf
             }

From 4fa2de730130217d1b38a012c187229ec54dc54f Mon Sep 17 00:00:00 2001
From: atok <atoktoto@fastmail.fm>
Date: Sun, 24 Dec 2023 12:32:29 +0100
Subject: [PATCH 10/22] std feature in main crate

---
 symphonia/Cargo.toml | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/symphonia/Cargo.toml b/symphonia/Cargo.toml
index 223f6a33..1e8bcacf 100644
--- a/symphonia/Cargo.toml
+++ b/symphonia/Cargo.toml
@@ -15,7 +15,8 @@ rust-version = "1.53"
 [features]
 # Only royalty-free open standard codecs and formats are enabled by default.
 # TODO: Remove all defaults for v0.6.0. Features should be additive.
-default = ["adpcm", "flac", "mkv", "ogg", "pcm", "vorbis", "wav"]
+default = ["adpcm", "flac", "mkv", "ogg", "pcm", "vorbis", "wav", "std"]
+std = ["symphonia-metadata/std", "symphonia-core/std"]
 
 # Enable specific codecs and formats.
 # TODO: Use "dep:" after MSRV is raised to >= 1.60.
@@ -83,10 +84,12 @@ lazy_static = "1.4.0"
 [dependencies.symphonia-core]
 version = "0.5.2"
 path = "../symphonia-core"
+default-features = false
 
 [dependencies.symphonia-metadata]
 version = "0.5.2"
 path = "../symphonia-metadata"
+default-features = false
 
 [dependencies.symphonia-bundle-flac]
 version = "0.5.2"

From 92f0b0cd9955b84fdf2e6ff691a9e2ae501c9d4b Mon Sep 17 00:00:00 2001
From: atok <atoktoto@fastmail.fm>
Date: Sun, 24 Dec 2023 12:39:53 +0100
Subject: [PATCH 11/22] no_std for symphonia-bundle-flac

---
 symphonia-bundle-flac/Cargo.toml      | 6 +++++-
 symphonia-bundle-flac/src/decoder.rs  | 9 +++++----
 symphonia-bundle-flac/src/demuxer.rs  | 2 ++
 symphonia-bundle-flac/src/lib.rs      | 4 ++++
 symphonia-bundle-flac/src/parser.rs   | 3 +++
 symphonia-bundle-flac/src/validate.rs | 4 ++--
 symphonia-core/src/codecs.rs          | 2 +-
 symphonia/Cargo.toml                  | 2 +-
 8 files changed, 23 insertions(+), 9 deletions(-)

diff --git a/symphonia-bundle-flac/Cargo.toml b/symphonia-bundle-flac/Cargo.toml
index 21ab2593..0eaf576d 100644
--- a/symphonia-bundle-flac/Cargo.toml
+++ b/symphonia-bundle-flac/Cargo.toml
@@ -16,4 +16,8 @@ rust-version = "1.53"
 log = "0.4"
 symphonia-core = { version = "0.5.2", path = "../symphonia-core" }
 symphonia-metadata = { version = "0.5.2", path = "../symphonia-metadata" }
-symphonia-utils-xiph = { version = "0.5.2", path = "../symphonia-utils-xiph" }
\ No newline at end of file
+symphonia-utils-xiph = { version = "0.5.2", path = "../symphonia-utils-xiph" }
+
+[features]
+std = []
+default = ["std"]
\ No newline at end of file
diff --git a/symphonia-bundle-flac/src/decoder.rs b/symphonia-bundle-flac/src/decoder.rs
index ce02fdda..658a628f 100644
--- a/symphonia-bundle-flac/src/decoder.rs
+++ b/symphonia-bundle-flac/src/decoder.rs
@@ -5,9 +5,10 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use std::cmp;
-use std::convert::TryInto;
-use std::num::Wrapping;
+use alloc::string::String;
+use core::cmp;
+use core::convert::TryInto;
+use core::num::Wrapping;
 
 use symphonia_core::audio::{AsAudioBufferRef, AudioBuffer, AudioBufferRef};
 use symphonia_core::audio::{Signal, SignalSpec};
@@ -263,7 +264,7 @@ impl Decoder for FlacDecoder {
                 // Only generate the expected and decoded MD5 checksum strings if logging is
                 // enabled at the debug level.
                 if log_enabled!(log::Level::Debug) {
-                    use std::fmt::Write;
+                    use core::fmt::Write;
 
                     let mut expected_s = String::with_capacity(32);
                     let mut decoded_s = String::with_capacity(32);
diff --git a/symphonia-bundle-flac/src/demuxer.rs b/symphonia-bundle-flac/src/demuxer.rs
index 1ae73ad8..bcd125d4 100644
--- a/symphonia-bundle-flac/src/demuxer.rs
+++ b/symphonia-bundle-flac/src/demuxer.rs
@@ -5,6 +5,8 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
+use alloc::boxed::Box;
+use alloc::vec::Vec;
 use symphonia_core::support_format;
 
 use symphonia_core::codecs::{CodecParameters, VerificationCheck, CODEC_TYPE_FLAC};
diff --git a/symphonia-bundle-flac/src/lib.rs b/symphonia-bundle-flac/src/lib.rs
index c1ffec2c..712b550f 100644
--- a/symphonia-bundle-flac/src/lib.rs
+++ b/symphonia-bundle-flac/src/lib.rs
@@ -14,6 +14,10 @@
 #![allow(clippy::identity_op)]
 #![allow(clippy::manual_range_contains)]
 
+#![no_std]
+
+extern crate alloc;
+
 mod decoder;
 mod demuxer;
 mod frame;
diff --git a/symphonia-bundle-flac/src/parser.rs b/symphonia-bundle-flac/src/parser.rs
index cd389ccc..df2c5bb6 100644
--- a/symphonia-bundle-flac/src/parser.rs
+++ b/symphonia-bundle-flac/src/parser.rs
@@ -5,6 +5,9 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
+use alloc::boxed::Box;
+use alloc::vec;
+use alloc::vec::Vec;
 use symphonia_core::checksum::Crc16Ansi;
 use symphonia_core::errors::Result;
 use symphonia_core::formats::Packet;
diff --git a/symphonia-bundle-flac/src/validate.rs b/symphonia-bundle-flac/src/validate.rs
index e42a8d31..0339f5f0 100644
--- a/symphonia-bundle-flac/src/validate.rs
+++ b/symphonia-bundle-flac/src/validate.rs
@@ -5,8 +5,8 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use std::mem;
-use std::vec::Vec;
+use core::mem;
+use alloc::vec::Vec;
 
 use symphonia_core::audio::{AudioBuffer, Signal};
 use symphonia_core::checksum::Md5;
diff --git a/symphonia-core/src/codecs.rs b/symphonia-core/src/codecs.rs
index 3fe4757e..281c95a9 100644
--- a/symphonia-core/src/codecs.rs
+++ b/symphonia-core/src/codecs.rs
@@ -583,7 +583,7 @@ macro_rules! support_codec {
             codec: $type,
             short_name: $short_name,
             long_name: $long_name,
-            inst_func: |params, opt| Ok(Box::new(Self::try_new(&params, &opt)?)),
+            inst_func: |params, opt| Ok(alloc::boxed::Box::new(Self::try_new(&params, &opt)?)),
         }
     };
 }
diff --git a/symphonia/Cargo.toml b/symphonia/Cargo.toml
index 1e8bcacf..4256b8f6 100644
--- a/symphonia/Cargo.toml
+++ b/symphonia/Cargo.toml
@@ -16,7 +16,7 @@ rust-version = "1.53"
 # Only royalty-free open standard codecs and formats are enabled by default.
 # TODO: Remove all defaults for v0.6.0. Features should be additive.
 default = ["adpcm", "flac", "mkv", "ogg", "pcm", "vorbis", "wav", "std"]
-std = ["symphonia-metadata/std", "symphonia-core/std"]
+std = ["symphonia-metadata/std", "symphonia-core/std", "symphonia-bundle-flac/std"]
 
 # Enable specific codecs and formats.
 # TODO: Use "dep:" after MSRV is raised to >= 1.60.

From 645896162c6aadead2dbb1d4bb82ff39fc604945 Mon Sep 17 00:00:00 2001
From: atok <atoktoto@fastmail.fm>
Date: Tue, 26 Dec 2023 20:53:01 +0100
Subject: [PATCH 12/22] made fft dependency optional, added libm (temporarily)

---
 symphonia-bundle-flac/Cargo.toml | 8 ++++----
 symphonia-core/Cargo.toml        | 8 +++++---
 symphonia-core/src/dsp/mod.rs    | 2 ++
 symphonia-core/src/lib.rs        | 3 +++
 symphonia-core/src/units.rs      | 6 +++---
 symphonia/Cargo.toml             | 1 +
 symphonia/src/lib.rs             | 1 +
 7 files changed, 19 insertions(+), 10 deletions(-)

diff --git a/symphonia-bundle-flac/Cargo.toml b/symphonia-bundle-flac/Cargo.toml
index 0eaf576d..13e7ccb9 100644
--- a/symphonia-bundle-flac/Cargo.toml
+++ b/symphonia-bundle-flac/Cargo.toml
@@ -14,10 +14,10 @@ rust-version = "1.53"
 
 [dependencies]
 log = "0.4"
-symphonia-core = { version = "0.5.2", path = "../symphonia-core" }
-symphonia-metadata = { version = "0.5.2", path = "../symphonia-metadata" }
-symphonia-utils-xiph = { version = "0.5.2", path = "../symphonia-utils-xiph" }
+symphonia-core = { version = "0.5.2", path = "../symphonia-core", default-features = false }
+symphonia-metadata = { version = "0.5.2", path = "../symphonia-metadata", default-features = false }
+symphonia-utils-xiph = { version = "0.5.2", path = "../symphonia-utils-xiph", default-features = false }
 
 [features]
-std = []
+std = ["symphonia-core/std", "symphonia-metadata/std", "symphonia-utils-xiph/std"]
 default = ["std"]
\ No newline at end of file
diff --git a/symphonia-core/Cargo.toml b/symphonia-core/Cargo.toml
index 54e5666e..c5cbc3fc 100644
--- a/symphonia-core/Cargo.toml
+++ b/symphonia-core/Cargo.toml
@@ -13,8 +13,9 @@ edition = "2018"
 rust-version = "1.53"
 
 [features]
-default = ["std"]
-std = []
+std = ["arrayvec/std"]
+fft = ["rustfft"]
+default = ["std", "fft"]
 
 # SIMD support.
 opt-simd-sse = ["rustfft/sse"]
@@ -29,11 +30,12 @@ opt-simd = [
 ]
 
 [dependencies]
-arrayvec = "0.7.1"
+arrayvec = { version = "0.7.1", default-features = false }
 bitflags = "1.2.1"
 bytemuck = "1.7"
 lazy_static = "1.4.0"
 log = "0.4"
+libm = { version = "0.2.8" }
 
 [dependencies.rustfft]
 version = "6.1.0"
diff --git a/symphonia-core/src/dsp/mod.rs b/symphonia-core/src/dsp/mod.rs
index 8de8f0cc..82f3c9ea 100644
--- a/symphonia-core/src/dsp/mod.rs
+++ b/symphonia-core/src/dsp/mod.rs
@@ -8,5 +8,7 @@
 //! The `dsp` module provides efficient implementations of common signal processing algorithms.
 
 pub mod complex;
+#[cfg(feature="fft")]
 pub mod fft;
+#[cfg(feature="fft")]
 pub mod mdct;
diff --git a/symphonia-core/src/lib.rs b/symphonia-core/src/lib.rs
index cdd62445..7e5745ed 100644
--- a/symphonia-core/src/lib.rs
+++ b/symphonia-core/src/lib.rs
@@ -17,6 +17,9 @@
 
 extern crate alloc;
 
+#[cfg(not(feature="std"))]
+extern crate core as std;
+
 #[cfg(feature = "std")]
 extern crate std;
 
diff --git a/symphonia-core/src/units.rs b/symphonia-core/src/units.rs
index 5a47dd2b..cc230f6e 100644
--- a/symphonia-core/src/units.rs
+++ b/symphonia-core/src/units.rs
@@ -99,7 +99,7 @@ impl From<u64> for Time {
 impl From<f32> for Time {
     fn from(seconds: f32) -> Self {
         if seconds >= 0.0 {
-            Time::new(seconds.trunc() as u64, f64::from(seconds.fract()))
+            Time::new(libm::truncf(seconds) as u64, f64::from(seconds - libm::truncf(seconds)))
         }
         else {
             Time::new(0, 0.0)
@@ -110,7 +110,7 @@ impl From<f32> for Time {
 impl From<f64> for Time {
     fn from(seconds: f64) -> Self {
         if seconds >= 0.0 {
-            Time::new(seconds.trunc() as u64, seconds.fract())
+            Time::new(libm::trunc(seconds) as u64, seconds - libm::trunc(seconds))
         }
         else {
             Time::new(0, 0.0)
@@ -170,7 +170,7 @@ impl TimeBase {
         if dividend < (1 << 52) {
             let seconds = (dividend as f64) / f64::from(self.denom);
 
-            Time::new(seconds.trunc() as u64, seconds.fract())
+            Time::new(libm::trunc(seconds) as u64, seconds - libm::trunc(seconds))
         }
         else {
             // If the dividend requires more than 52 bits, calculate the integer portion using
diff --git a/symphonia/Cargo.toml b/symphonia/Cargo.toml
index 4256b8f6..fc2daa94 100644
--- a/symphonia/Cargo.toml
+++ b/symphonia/Cargo.toml
@@ -94,6 +94,7 @@ default-features = false
 [dependencies.symphonia-bundle-flac]
 version = "0.5.2"
 path = "../symphonia-bundle-flac"
+default-features = false
 optional = true
 
 [dependencies.symphonia-bundle-mp3]
diff --git a/symphonia/src/lib.rs b/symphonia/src/lib.rs
index b33cbc34..e03e2f72 100644
--- a/symphonia/src/lib.rs
+++ b/symphonia/src/lib.rs
@@ -7,6 +7,7 @@
 
 #![warn(rust_2018_idioms)]
 #![forbid(unsafe_code)]
+#![no_std]
 
 //! # Project Symphonia
 //!

From b85de5235127ddfcdbdc9ea884ac140e35819ef8 Mon Sep 17 00:00:00 2001
From: atok <atoktoto@fastmail.fm>
Date: Thu, 28 Dec 2023 12:04:44 +0100
Subject: [PATCH 13/22] Make format-wav no_std

---
 symphonia-format-wav/src/chunks.rs |  2 ++
 symphonia-format-wav/src/lib.rs    | 11 +++++++++++
 2 files changed, 13 insertions(+)

diff --git a/symphonia-format-wav/src/chunks.rs b/symphonia-format-wav/src/chunks.rs
index dff84589..3c5b695d 100644
--- a/symphonia-format-wav/src/chunks.rs
+++ b/symphonia-format-wav/src/chunks.rs
@@ -5,6 +5,8 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
+use alloc::vec;
+use alloc::string::String;
 use std::fmt;
 use std::marker::PhantomData;
 
diff --git a/symphonia-format-wav/src/lib.rs b/symphonia-format-wav/src/lib.rs
index c4499c40..52b11cd0 100644
--- a/symphonia-format-wav/src/lib.rs
+++ b/symphonia-format-wav/src/lib.rs
@@ -5,6 +5,7 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
+#![no_std]
 #![warn(rust_2018_idioms)]
 #![forbid(unsafe_code)]
 // The following lints are allowed in all Symphonia crates. Please see clippy.toml for their
@@ -14,6 +15,16 @@
 #![allow(clippy::identity_op)]
 #![allow(clippy::manual_range_contains)]
 
+#[cfg(not(feature="std"))]
+extern crate core as std;
+
+extern crate alloc;
+
+use alloc::vec;
+use alloc::vec::Vec;
+use alloc::boxed::Box;
+use alloc::string::String;
+
 use symphonia_core::codecs::CodecParameters;
 use symphonia_core::errors::{decode_error, end_of_stream_error, seek_error, unsupported_error};
 use symphonia_core::errors::{Result, SeekErrorKind};

From a9cb41139fa4560784809039f59ca3972f62b5cd Mon Sep 17 00:00:00 2001
From: atok <atoktoto@fastmail.fm>
Date: Fri, 29 Dec 2023 10:10:40 +0100
Subject: [PATCH 14/22] Make codec-pcm no_std

---
 symphonia-codec-pcm/Cargo.toml  | 2 +-
 symphonia-codec-pcm/src/lib.rs  | 6 ++++++
 symphonia-format-wav/Cargo.toml | 4 ++--
 3 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/symphonia-codec-pcm/Cargo.toml b/symphonia-codec-pcm/Cargo.toml
index c9c8a67c..dbf1e553 100644
--- a/symphonia-codec-pcm/Cargo.toml
+++ b/symphonia-codec-pcm/Cargo.toml
@@ -14,4 +14,4 @@ rust-version = "1.53"
 
 [dependencies]
 log = "0.4"
-symphonia-core = { version = "0.5.2", path = "../symphonia-core" }
\ No newline at end of file
+symphonia-core = { version = "0.5.2", path = "../symphonia-core", default-features = false }
\ No newline at end of file
diff --git a/symphonia-codec-pcm/src/lib.rs b/symphonia-codec-pcm/src/lib.rs
index 22f9a857..355ab907 100644
--- a/symphonia-codec-pcm/src/lib.rs
+++ b/symphonia-codec-pcm/src/lib.rs
@@ -7,6 +7,7 @@
 
 #![warn(rust_2018_idioms)]
 #![forbid(unsafe_code)]
+#![no_std]
 // The following lints are allowed in all Symphonia crates. Please see clippy.toml for their
 // justification.
 #![allow(clippy::comparison_chain)]
@@ -14,6 +15,11 @@
 #![allow(clippy::identity_op)]
 #![allow(clippy::manual_range_contains)]
 
+#[cfg(not(std))]
+extern crate core as std;
+
+extern crate alloc;
+
 use symphonia_core::support_codec;
 
 use symphonia_core::audio::{AsAudioBufferRef, AudioBuffer, AudioBufferRef, Signal, SignalSpec};
diff --git a/symphonia-format-wav/Cargo.toml b/symphonia-format-wav/Cargo.toml
index 6ecea71a..55991a4b 100644
--- a/symphonia-format-wav/Cargo.toml
+++ b/symphonia-format-wav/Cargo.toml
@@ -14,5 +14,5 @@ rust-version = "1.53"
 
 [dependencies]
 log = "0.4"
-symphonia-core = { version = "0.5.2", path = "../symphonia-core" }
-symphonia-metadata = { version = "0.5.2", path = "../symphonia-metadata" }
\ No newline at end of file
+symphonia-core = { version = "0.5.2", path = "../symphonia-core", default-features = false }
+symphonia-metadata = { version = "0.5.2", path = "../symphonia-metadata", default-features = false }
\ No newline at end of file

From c71a473ec438beaa33c499c6442100bcb15210dd Mon Sep 17 00:00:00 2001
From: atok <atoktoto@fastmail.fm>
Date: Fri, 29 Dec 2023 16:19:30 +0100
Subject: [PATCH 15/22] Made id3v2 optional in order to make encoding_rs
 dependency optional to make the binary smaller

---
 symphonia-metadata/Cargo.toml             |  5 ++--
 symphonia-metadata/src/lib.rs             |  2 ++
 symphonia-utils-xiph/src/flac/metadata.rs | 34 +++++++++++++++++++++--
 symphonia/Cargo.toml                      |  2 ++
 symphonia/src/lib.rs                      |  4 +--
 5 files changed, 40 insertions(+), 7 deletions(-)

diff --git a/symphonia-metadata/Cargo.toml b/symphonia-metadata/Cargo.toml
index fbdaadb9..c6cb3389 100644
--- a/symphonia-metadata/Cargo.toml
+++ b/symphonia-metadata/Cargo.toml
@@ -13,11 +13,12 @@ edition = "2018"
 rust-version = "1.53"
 
 [dependencies]
-encoding_rs = "0.8.17"
+encoding_rs = { version = "0.8.17", optional = true }
 lazy_static = "1.4.0"
 log = "0.4"
 symphonia-core = { version = "0.5.2", path = "../symphonia-core", default-features = false }
 
 [features]
 std = ["symphonia-core/std"]
-default = ["std"]
\ No newline at end of file
+default = ["std", "id3v2"]
+id3v2 = ["encoding_rs"]
\ No newline at end of file
diff --git a/symphonia-metadata/src/lib.rs b/symphonia-metadata/src/lib.rs
index d41f45eb..364931a7 100644
--- a/symphonia-metadata/src/lib.rs
+++ b/symphonia-metadata/src/lib.rs
@@ -19,7 +19,9 @@
 extern crate alloc;
 
 pub mod id3v1;
+#[cfg(feature = "id3v2")]
 pub mod id3v2;
+
 pub mod itunes;
 pub mod riff;
 pub mod vorbis;
diff --git a/symphonia-utils-xiph/src/flac/metadata.rs b/symphonia-utils-xiph/src/flac/metadata.rs
index 80f85145..2c11d713 100644
--- a/symphonia-utils-xiph/src/flac/metadata.rs
+++ b/symphonia-utils-xiph/src/flac/metadata.rs
@@ -16,10 +16,10 @@ use symphonia_core::errors::{decode_error, Result};
 use symphonia_core::formats::util::SeekIndex;
 use symphonia_core::formats::{Cue, CuePoint};
 use symphonia_core::io::*;
-use symphonia_core::meta::{ColorMode, MetadataBuilder, Size, StandardTagKey, Tag, Value};
+use symphonia_core::meta::{ColorMode, MetadataBuilder, Size, StandardTagKey, StandardVisualKey, Tag, Value};
 use symphonia_core::meta::{VendorData, Visual};
 
-use symphonia_metadata::{id3v2, vorbis};
+use symphonia_metadata::vorbis;
 
 #[derive(PartialEq, Eq)]
 pub enum MetadataBlockType {
@@ -483,7 +483,7 @@ pub fn read_picture_block<B: ReadBytes>(
         dimensions,
         bits_per_pixel,
         color_mode,
-        usage: id3v2::util::apic_picture_type_to_visual_key(type_enc),
+        usage: apic_picture_type_to_visual_key(type_enc),
         tags,
         data,
     });
@@ -491,6 +491,34 @@ pub fn read_picture_block<B: ReadBytes>(
     Ok(())
 }
 
+
+/// Try to get a `StandardVisualKey` from the APIC picture type identifier.
+pub fn apic_picture_type_to_visual_key(apic: u32) -> Option<StandardVisualKey> {
+    match apic {
+        0x01 => Some(StandardVisualKey::FileIcon),
+        0x02 => Some(StandardVisualKey::OtherIcon),
+        0x03 => Some(StandardVisualKey::FrontCover),
+        0x04 => Some(StandardVisualKey::BackCover),
+        0x05 => Some(StandardVisualKey::Leaflet),
+        0x06 => Some(StandardVisualKey::Media),
+        0x07 => Some(StandardVisualKey::LeadArtistPerformerSoloist),
+        0x08 => Some(StandardVisualKey::ArtistPerformer),
+        0x09 => Some(StandardVisualKey::Conductor),
+        0x0a => Some(StandardVisualKey::BandOrchestra),
+        0x0b => Some(StandardVisualKey::Composer),
+        0x0c => Some(StandardVisualKey::Lyricist),
+        0x0d => Some(StandardVisualKey::RecordingLocation),
+        0x0e => Some(StandardVisualKey::RecordingSession),
+        0x0f => Some(StandardVisualKey::Performance),
+        0x10 => Some(StandardVisualKey::ScreenCapture),
+        0x12 => Some(StandardVisualKey::Illustration),
+        0x13 => Some(StandardVisualKey::BandArtistLogo),
+        0x14 => Some(StandardVisualKey::PublisherStudioLogo),
+        _ => None,
+    }
+}
+
+
 pub struct MetadataBlockHeader {
     pub is_last: bool,
     pub block_type: MetadataBlockType,
diff --git a/symphonia/Cargo.toml b/symphonia/Cargo.toml
index fc2daa94..3818f1bd 100644
--- a/symphonia/Cargo.toml
+++ b/symphonia/Cargo.toml
@@ -35,6 +35,8 @@ aiff = ["symphonia-format-riff"]
 vorbis = ["symphonia-codec-vorbis"]
 wav = ["symphonia-format-wav"]
 
+id3v2 = ["symphonia-metadata/id3v2"]
+
 # MPEG audio codecs.
 mpa = ["mp1", "mp2", "mp3"]
 
diff --git a/symphonia/src/lib.rs b/symphonia/src/lib.rs
index e03e2f72..2229f0d9 100644
--- a/symphonia/src/lib.rs
+++ b/symphonia/src/lib.rs
@@ -261,7 +261,6 @@ pub mod default {
     ///
     /// Use this function to easily populate a custom probe with all enabled formats.
     pub fn register_enabled_formats(probe: &mut Probe) {
-        use symphonia_metadata::id3v2::Id3v2Reader;
 
         // Formats
         #[cfg(feature = "aac")]
@@ -289,7 +288,8 @@ pub mod default {
         probe.register_all::<formats::MkvReader>();
 
         // Metadata
-        probe.register_all::<Id3v2Reader>();
+        #[cfg(feature = "id3v2")]
+        probe.register_all::<symphonia_metadata::id3v2::Id3v2Reader>();
     }
 }
 

From 952d5a678632cfc1cf670a0030effaaf19bb6351 Mon Sep 17 00:00:00 2001
From: atok <atoktoto@fastmail.fm>
Date: Sun, 7 Jan 2024 11:31:07 +0100
Subject: [PATCH 16/22] Remove Send + Sync trait bounds from FormatReader

---
 symphonia-core/src/formats.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/symphonia-core/src/formats.rs b/symphonia-core/src/formats.rs
index e91203ee..0309dd59 100644
--- a/symphonia-core/src/formats.rs
+++ b/symphonia-core/src/formats.rs
@@ -168,7 +168,7 @@ impl Track {
 /// `FormatReader` provides an Iterator-like interface over packets for easy consumption and
 /// filtering. Seeking will invalidate the state of any `Decoder` processing packets from the
 /// `FormatReader` and should be reset after a successful seek operation.
-pub trait FormatReader: Send + Sync {
+pub trait FormatReader {
     /// Attempt to instantiate a `FormatReader` using the provided `FormatOptions` and
     /// `MediaSourceStream`. The reader will probe the container to verify format support, determine
     /// the number of tracks, and read any initial metadata.

From 7122e9391ca3e422c4789b1af39b651c8c0817e0 Mon Sep 17 00:00:00 2001
From: atok <atoktoto@fastmail.fm>
Date: Sun, 7 Jan 2024 11:31:37 +0100
Subject: [PATCH 17/22] Remove Send + Sync trait bounds from MediaSource

---
 symphonia-core/src/io/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/symphonia-core/src/io/mod.rs b/symphonia-core/src/io/mod.rs
index 1ce2f839..4e33c2fb 100644
--- a/symphonia-core/src/io/mod.rs
+++ b/symphonia-core/src/io/mod.rs
@@ -139,7 +139,7 @@ impl <T: std::io::Seek> Seek for T  {
 /// Despite requiring the [`std::io::Seek`] trait, seeking is an optional capability that can be
 /// queried at runtime.
 // pub trait MediaSource: io::Read + io::Seek + Send + Sync {
-pub trait MediaSource: Read + Seek + Send + Sync {
+pub trait MediaSource: Read + Seek  {
     /// Returns if the source is seekable. This may be an expensive operation.
     fn is_seekable(&self) -> bool;
 

From 7e05c8bb67fb10b596a5281d4ee4233925f2aae8 Mon Sep 17 00:00:00 2001
From: atok <atoktoto@fastmail.fm>
Date: Mon, 8 Jan 2024 17:25:41 +0100
Subject: [PATCH 18/22] Rework error wrapping

---
 symphonia-bundle-mp3/src/layer3/mod.rs       |   5 +-
 symphonia-bundle-mp3/src/lib.rs              |   2 +
 symphonia-check/src/main.rs                  |   5 +-
 symphonia-codec-aac/src/lib.rs               |   2 +
 symphonia-codec-adpcm/src/lib.rs             |   2 +
 symphonia-codec-alac/src/lib.rs              |   2 +
 symphonia-codec-vorbis/src/floor.rs          |   7 +-
 symphonia-codec-vorbis/src/lib.rs            |   2 +
 symphonia-codec-vorbis/src/residue.rs        |   5 +-
 symphonia-core/src/errors.rs                 | 285 ++++---------------
 symphonia-core/src/io/bit.rs                 |  11 +-
 symphonia-core/src/io/buf_reader.rs          |   5 +-
 symphonia-core/src/io/media_source_stream.rs |   9 +-
 symphonia-core/src/io/mod.rs                 |  10 +-
 symphonia-core/src/io/scoped_stream.rs       |   5 +-
 symphonia-core/src/lib.rs                    |   4 +-
 symphonia-format-isomp4/src/stream.rs        |   3 +-
 symphonia-format-mkv/src/demuxer.rs          |   3 +-
 symphonia-format-mkv/src/ebml.rs             |  14 +-
 symphonia-format-mkv/src/segment.rs          |   3 +-
 symphonia-format-ogg/src/demuxer.rs          |   4 +-
 symphonia-format-ogg/src/page.rs             |   6 +-
 symphonia-format-riff/src/common.rs          |   3 +-
 symphonia-format-wav/src/chunks.rs           |   3 +-
 symphonia-play/src/main.rs                   |   5 +-
 25 files changed, 119 insertions(+), 286 deletions(-)

diff --git a/symphonia-bundle-mp3/src/layer3/mod.rs b/symphonia-bundle-mp3/src/layer3/mod.rs
index 1108a9a3..9b19cc43 100644
--- a/symphonia-bundle-mp3/src/layer3/mod.rs
+++ b/symphonia-bundle-mp3/src/layer3/mod.rs
@@ -8,7 +8,8 @@
 use std::fmt;
 
 use symphonia_core::audio::{AudioBuffer, Signal};
-use symphonia_core::errors::{decode_error, Error, IoErrorKind, Result};
+use symphonia_core::errors::{decode_error, Result};
+use symphonia_core::errors::SymphoniaError as Error;
 use symphonia_core::io::{BitReaderLtr, BufReader, ReadBitsLtr, ReadBytes};
 
 mod bitstream;
@@ -356,7 +357,7 @@ impl Layer3 {
                 // IO error to a decode error.
                 frame_data.granules[gr].channels[ch].rzero = match huffman_result {
                     Ok(rzero) => rzero,
-                    Err(Error::IoError(IoErrorKind::Other, _)) => {
+                    Err(Error::IoError(_)) => {
                         return decode_error("mpa: huffman decode overrun");
                     }
                     Err(err) => return Err(err),
diff --git a/symphonia-bundle-mp3/src/lib.rs b/symphonia-bundle-mp3/src/lib.rs
index def350db..08ac92e0 100644
--- a/symphonia-bundle-mp3/src/lib.rs
+++ b/symphonia-bundle-mp3/src/lib.rs
@@ -14,6 +14,8 @@
 #![allow(clippy::identity_op)]
 #![allow(clippy::manual_range_contains)]
 
+extern crate alloc;
+
 // Shared modules.
 mod common;
 mod header;
diff --git a/symphonia-check/src/main.rs b/symphonia-check/src/main.rs
index 68a84182..74153d6d 100644
--- a/symphonia-check/src/main.rs
+++ b/symphonia-check/src/main.rs
@@ -18,7 +18,8 @@ use std::process::{Command, Stdio};
 
 use symphonia::core::audio::{AudioBufferRef, SampleBuffer};
 use symphonia::core::codecs::{Decoder, DecoderOptions};
-use symphonia::core::errors::{Error, IoErrorKind, Result};
+use symphonia::core::errors::Result;
+use symphonia::core::errors::SymphoniaError as Error;
 use symphonia::core::formats::{FormatOptions, FormatReader};
 use symphonia::core::io::{MediaSourceStream, ReadOnlySource};
 use symphonia::core::meta::MetadataOptions;
@@ -396,7 +397,7 @@ fn main() {
     println!();
 
     match run_test(path, &opts, &mut res) {
-        Err(Error::IoError(IoErrorKind::UnexpectedEof, _)) => (),
+        Err(Error::EndOfFile) => (),
         Err(err) => {
             eprintln!("Test interrupted by error: {}", err);
             std::process::exit(2);
diff --git a/symphonia-codec-aac/src/lib.rs b/symphonia-codec-aac/src/lib.rs
index 34c8c9f8..08ca8fad 100644
--- a/symphonia-codec-aac/src/lib.rs
+++ b/symphonia-codec-aac/src/lib.rs
@@ -16,6 +16,8 @@
 // TODO: Remove this when refactoring AAC.
 #![allow(clippy::needless_range_loop)]
 
+extern crate alloc;
+
 mod aac;
 mod adts;
 mod common;
diff --git a/symphonia-codec-adpcm/src/lib.rs b/symphonia-codec-adpcm/src/lib.rs
index 4d69fe3e..079d8512 100644
--- a/symphonia-codec-adpcm/src/lib.rs
+++ b/symphonia-codec-adpcm/src/lib.rs
@@ -24,6 +24,8 @@ use symphonia_core::errors::{unsupported_error, Result};
 use symphonia_core::formats::Packet;
 use symphonia_core::io::ReadBytes;
 
+extern crate alloc;
+
 mod codec_ima;
 mod codec_ms;
 mod common;
diff --git a/symphonia-codec-alac/src/lib.rs b/symphonia-codec-alac/src/lib.rs
index 1ada71ab..e43c2c72 100644
--- a/symphonia-codec-alac/src/lib.rs
+++ b/symphonia-codec-alac/src/lib.rs
@@ -29,6 +29,8 @@ use symphonia_core::formats::Packet;
 use symphonia_core::io::{BitReaderLtr, BufReader, FiniteStream, ReadBitsLtr, ReadBytes};
 use symphonia_core::support_codec;
 
+extern crate alloc;
+
 /// Supported ALAC version.
 const ALAC_VERSION: u8 = 0;
 
diff --git a/symphonia-codec-vorbis/src/floor.rs b/symphonia-codec-vorbis/src/floor.rs
index 3dbfa65e..b3c14c25 100644
--- a/symphonia-codec-vorbis/src/floor.rs
+++ b/symphonia-codec-vorbis/src/floor.rs
@@ -8,7 +8,8 @@
 use std::cmp::min;
 use std::collections::HashSet;
 
-use symphonia_core::errors::{decode_error, Error, IoErrorKind, Result};
+use symphonia_core::errors::SymphoniaError as Error;
+use symphonia_core::errors::{decode_error, Result};
 use symphonia_core::io::{BitReaderRtl, ReadBitsRtl};
 
 use super::codebook::VorbisCodebook;
@@ -92,7 +93,7 @@ macro_rules! io_try_or_ret {
             // An end-of-bitstream error is classified under ErrorKind::Other. This condition
             // should not be treated as an error, rather, it should return from the function
             // immediately without error.
-            Err(Error::IoError(IoErrorKind::Other, _)) => return Ok(()),
+            Err(Error::EndOfFile) => return Ok(()),
             Err(e) => return Err(e.into()),
         }
     };
@@ -105,7 +106,7 @@ macro_rules! try_or_ret {
             // An end-of-bitstream error is classified under ErrorKind::Other. This condition
             // should not be treated as an error, rather, it should return from the function
             // immediately without error.
-            Err(Error::IoError(IoErrorKind::Other, _)) => return Ok(()),
+            Err(Error::EndOfFile) => return Ok(()),
             Err(e) => return Err(e),
         }
     };
diff --git a/symphonia-codec-vorbis/src/lib.rs b/symphonia-codec-vorbis/src/lib.rs
index 59b53455..7726fada 100644
--- a/symphonia-codec-vorbis/src/lib.rs
+++ b/symphonia-codec-vorbis/src/lib.rs
@@ -16,6 +16,8 @@
 // Disable to better express the specification.
 #![allow(clippy::collapsible_else_if)]
 
+extern crate alloc;
+
 use symphonia_core::audio::{AsAudioBufferRef, AudioBuffer, AudioBufferRef};
 use symphonia_core::audio::{Signal, SignalSpec};
 use symphonia_core::codecs::{CodecDescriptor, CodecParameters, CODEC_TYPE_VORBIS};
diff --git a/symphonia-codec-vorbis/src/residue.rs b/symphonia-codec-vorbis/src/residue.rs
index 3e2f3076..5531571b 100644
--- a/symphonia-codec-vorbis/src/residue.rs
+++ b/symphonia-codec-vorbis/src/residue.rs
@@ -8,7 +8,8 @@
 use std::cmp::min;
 use std::convert::TryInto;
 
-use symphonia_core::errors::{decode_error, Error, IoErrorKind, Result};
+use symphonia_core::errors::SymphoniaError as Error;
+use symphonia_core::errors::{decode_error, Result};
 use symphonia_core::io::{BitReaderRtl, ReadBitsRtl};
 
 use super::codebook::VorbisCodebook;
@@ -154,7 +155,7 @@ impl Residue {
             Ok(_) => (),
             // An end-of-bitstream error is classified under ErrorKind::Other. This condition
             // should not be treated as an error.
-            Err(Error::IoError(IoErrorKind::Other, _)) => (),
+            Err(Error::EndOfFile) => (),
             Err(e) => return Err(e),
         };
 
diff --git a/symphonia-core/src/errors.rs b/symphonia-core/src/errors.rs
index 65b9421c..2cf07712 100644
--- a/symphonia-core/src/errors.rs
+++ b/symphonia-core/src/errors.rs
@@ -7,9 +7,13 @@
 
 //! The `errors` module defines the common error type.
 
-use core::{error, result};
+use core::{result};
 use core::fmt;
-use core::fmt::{Display, Formatter};
+use core::fmt::{Display};
+use std::error::Error;
+use alloc::boxed::Box;
+use std::io::ErrorKind;
+use std::ops::Deref;
 
 
 /// `SeekErrorKind` is a list of generic reasons why a seek may fail.
@@ -36,191 +40,13 @@ impl SeekErrorKind {
     }
 }
 
-#[derive(Debug)]
-pub enum IoErrorKind {
-    /// An entity was not found, often a file.
-    NotFound,
-    /// The operation lacked the necessary privileges to complete.
-    PermissionDenied,
-    /// The connection was refused by the remote server.
-    ConnectionRefused,
-    /// The connection was reset by the remote server.
-    ConnectionReset,
-    /// The remote host is not reachable.
-    HostUnreachable,
-    /// The network containing the remote host is not reachable.
-    NetworkUnreachable,
-    /// The connection was aborted (terminated) by the remote server.
-    ConnectionAborted,
-    /// The network operation failed because it was not connected yet.
-    NotConnected,
-    /// A socket address could not be bound because the address is already in
-    /// use elsewhere.
-    AddrInUse,
-    /// A nonexistent interface was requested or the requested address was not
-    /// local.
-    AddrNotAvailable,
-    /// The system's networking is down.
-    NetworkDown,
-    /// The operation failed because a pipe was closed.
-    BrokenPipe,
-    /// An entity already exists, often a file.
-    AlreadyExists,
-    /// The operation needs to block to complete, but the blocking operation was
-    /// requested to not occur.
-    WouldBlock,
-    /// A filesystem object is, unexpectedly, not a directory.
-    ///
-    /// For example, a filesystem path was specified where one of the intermediate directory
-    /// components was, in fact, a plain file.
-    NotADirectory,
-    /// The filesystem object is, unexpectedly, a directory.
-    ///
-    /// A directory was specified when a non-directory was expected.
-    IsADirectory,
-    /// A non-empty directory was specified where an empty directory was expected.
-    DirectoryNotEmpty,
-    /// The filesystem or storage medium is read-only, but a write operation was attempted.
-    ReadOnlyFilesystem,
-    /// Loop in the filesystem or IO subsystem; often, too many levels of symbolic links.
-    ///
-    /// There was a loop (or excessively long chain) resolving a filesystem object
-    /// or file IO object.
-    ///
-    /// On Unix this is usually the result of a symbolic link loop; or, of exceeding the
-    /// system-specific limit on the depth of symlink traversal.
-    FilesystemLoop,
-    /// Stale network file handle.
-    ///
-    /// With some network filesystems, notably NFS, an open file (or directory) can be invalidated
-    /// by problems with the network or server.
-    StaleNetworkFileHandle,
-    /// A parameter was incorrect.
-    InvalidInput,
-    /// Data not valid for the operation were encountered.
-    ///
-    /// Unlike [`InvalidInput`], this typically means that the operation
-    /// parameters were valid, however the error was caused by malformed
-    /// input data.
-    ///
-    /// For example, a function that reads a file into a string will error with
-    /// `InvalidData` if the file's contents are not valid UTF-8.
-    ///
-    /// [`InvalidInput`]: std::io::ErrorKind::InvalidInput
-    InvalidData,
-    /// The I/O operation's timeout expired, causing it to be canceled.
-    TimedOut,
-    /// An error returned when an operation could not be completed because a
-    /// call to [`write`] returned [`Ok(0)`].
-    ///
-    /// This typically means that an operation could only succeed if it wrote a
-    /// particular number of bytes but only a smaller number of bytes could be
-    /// written.
-    ///
-    /// [`write`]: crate::io::Write::write
-    /// [`Ok(0)`]: Ok
-    WriteZero,
-    /// The underlying storage (typically, a filesystem) is full.
-    ///
-    /// This does not include out of quota errors.
-    StorageFull,
-    /// Seek on unseekable file.
-    ///
-    /// Seeking was attempted on an open file handle which is not suitable for seeking - for
-    /// example, on Unix, a named pipe opened with `File::open`.
-    NotSeekable,
-    /// Filesystem quota was exceeded.
-    FilesystemQuotaExceeded,
-    /// File larger than allowed or supported.
-    ///
-    /// This might arise from a hard limit of the underlying filesystem or file access API, or from
-    /// an administratively imposed resource limitation.  Simple disk full, and out of quota, have
-    /// their own errors.
-    FileTooLarge,
-    /// Resource is busy.
-    ResourceBusy,
-    /// Executable file is busy.
-    ///
-    /// An attempt was made to write to a file which is also in use as a running program.  (Not all
-    /// operating systems detect this situation.)
-    ExecutableFileBusy,
-    /// Deadlock (avoided).
-    ///
-    /// A file locking operation would result in deadlock.  This situation is typically detected, if
-    /// at all, on a best-effort basis.
-    Deadlock,
-    /// Cross-device or cross-filesystem (hard) link or rename.
-    CrossesDevices,
-    /// Too many (hard) links to the same filesystem object.
-    ///
-    /// The filesystem does not support making so many hardlinks to the same file.
-    TooManyLinks,
-    /// A filename was invalid.
-    ///
-    /// This error can also cause if it exceeded the filename length limit.
-    InvalidFilename,
-    /// Program argument list too long.
-    ///
-    /// When trying to run an external program, a system or process limit on the size of the
-    /// arguments would have been exceeded.
-    ArgumentListTooLong,
-    /// This operation was interrupted.
-    ///
-    /// Interrupted operations can typically be retried.
-    Interrupted,
-
-    /// This operation is unsupported on this platform.
-    ///
-    /// This means that the operation can never succeed.
-    Unsupported,
-
-    // ErrorKinds which are primarily categorisations for OS error
-    // codes should be added above.
-    //
-    /// An error returned when an operation could not be completed because an
-    /// "end of file" was reached prematurely.
-    ///
-    /// This typically means that an operation could only succeed if it read a
-    /// particular number of bytes but only a smaller number of bytes could be
-    /// read.
-    UnexpectedEof,
-
-    /// An operation could not be completed, because it failed
-    /// to allocate enough memory.
-    OutOfMemory,
-
-    // "Unusual" error kinds which do not correspond simply to (sets
-    // of) OS error codes, should be added just above this comment.
-    // `Other` and `Uncategorized` should remain at the end:
-    //
-    /// A custom error that does not fall under any other I/O error kind.
-    ///
-    /// This can be used to construct your own [`std::io::Error`]s that do not match any
-    /// [`std::io::ErrorKind`].
-    ///
-    /// This [`std::io::ErrorKind`] is not used by the standard library.
-    ///
-    /// Errors from the standard library that do not fall under any of the I/O
-    /// error kinds cannot be `match`ed on, and will only match a wildcard (`_`) pattern.
-    /// New [`std::io::ErrorKind`]s might be added in the future for some of those.
-    Other,
-}
-
-impl Display for IoErrorKind {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "{:?}", self)
-    }
-}
-
-impl core::error::Error for IoErrorKind {
-
-}
-
 /// `Error` provides an enumeration of all possible errors reported by Symphonia.
 #[derive(Debug)]
-pub enum Error {
-    /// An IO error occured while reading, writing, or seeking the stream.
-    IoError(IoErrorKind, &'static str),
+pub enum SymphoniaError {
+    /// An IO error occurred while reading, writing, or seeking the stream.
+    IoError(Box<dyn Error>),
+    /// An IO error occurred while reading, writing, or seeking the stream that is retryable.
+    IoInterruptedError(Box<dyn Error>),
     /// The stream contained malformed data and could not be decoded or demuxed.
     DecodeError(&'static str),
     /// The stream could not be seeked.
@@ -232,104 +58,93 @@ pub enum Error {
     LimitError(&'static str),
     /// The demuxer or decoder needs to be reset before continuing.
     ResetRequired,
+    EndOfFile,
+    Other(&'static str),
 }
 
-impl fmt::Display for Error {
+impl fmt::Display for SymphoniaError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            Error::IoError(ref err, msg) => {
-                write!(f, "io error {:?}: {}", err, msg)
-            },
-            Error::DecodeError(msg) => {
+            SymphoniaError::IoError(ref err) => {
+                write!(f, "io error {:?}", err)
+            }
+            SymphoniaError::IoInterruptedError(ref err) => {
+                write!(f, "io error {:?}", err)
+            }
+            SymphoniaError::DecodeError(msg) => {
                 write!(f, "malformed stream: {}", msg)
             }
-            Error::SeekError(ref kind) => {
+            SymphoniaError::SeekError(ref kind) => {
                 write!(f, "seek error: {}", kind.as_str())
             }
-            Error::Unsupported(feature) => {
+            SymphoniaError::Unsupported(feature) => {
                 write!(f, "unsupported feature: {}", feature)
             }
-            Error::LimitError(constraint) => {
+            SymphoniaError::LimitError(constraint) => {
                 write!(f, "limit reached: {}", constraint)
             }
-            Error::ResetRequired => {
+            SymphoniaError::ResetRequired => {
                 write!(f, "decoder needs to be reset")
             }
+            SymphoniaError::EndOfFile => {
+                write!(f, "unexpected end of file")
+            }
+            SymphoniaError::Other(msg) => {
+                write!(f, "other error: {}", msg)
+            }
         }
     }
 }
 
-impl core::error::Error for Error {
-    fn cause(&self) -> Option<&dyn error::Error> {
+impl core::error::Error for SymphoniaError {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
         match *self {
-            Error::IoError(ref err, _msg) => Some(err),
-            Error::DecodeError(_) => None,
-            Error::SeekError(_) => None,
-            Error::Unsupported(_) => None,
-            Error::LimitError(_) => None,
-            Error::ResetRequired => None,
+            SymphoniaError::IoError(ref err) => Some(err.deref()),
+            SymphoniaError::IoInterruptedError(ref err) => Some(err.deref()),
+            _ => None,
         }
     }
 }
 
 #[cfg(feature = "std")]
-impl From<std::io::Error> for Error {
-    fn from(err: std::io::Error) -> Error {
-        let error_kind = match err.kind() {
-            std::io::ErrorKind::NotFound => IoErrorKind::NotFound,
-            std::io::ErrorKind::PermissionDenied => IoErrorKind::PermissionDenied,
-            std::io::ErrorKind::ConnectionRefused => IoErrorKind::ConnectionRefused,
-            std::io::ErrorKind::ConnectionReset => IoErrorKind::ConnectionReset,
-            std::io::ErrorKind::ConnectionAborted => IoErrorKind::ConnectionAborted,
-            std::io::ErrorKind::NotConnected => IoErrorKind::NotConnected,
-            std::io::ErrorKind::AddrInUse => IoErrorKind::AddrInUse,
-            std::io::ErrorKind::AddrNotAvailable => IoErrorKind::AddrNotAvailable,
-            std::io::ErrorKind::BrokenPipe => IoErrorKind::BrokenPipe,
-            std::io::ErrorKind::AlreadyExists => IoErrorKind::AlreadyExists,
-            std::io::ErrorKind::WouldBlock => IoErrorKind::WouldBlock,
-            std::io::ErrorKind::InvalidInput => IoErrorKind::InvalidInput,
-            std::io::ErrorKind::InvalidData => IoErrorKind::InvalidData,
-            std::io::ErrorKind::TimedOut => IoErrorKind::TimedOut,
-            std::io::ErrorKind::WriteZero => IoErrorKind::WriteZero,
-            std::io::ErrorKind::Interrupted => IoErrorKind::Interrupted,
-            std::io::ErrorKind::Unsupported => IoErrorKind::Unsupported,
-            std::io::ErrorKind::UnexpectedEof => IoErrorKind::UnexpectedEof,
-            std::io::ErrorKind::OutOfMemory => IoErrorKind::OutOfMemory,
-            std::io::ErrorKind::Other => IoErrorKind::Other,
-            _ => IoErrorKind::Other,
-        };
-        Error::IoError(error_kind, "")
+impl From<std::io::Error> for SymphoniaError {
+    fn from(err: std::io::Error) -> SymphoniaError {
+        match err.kind() {
+            ErrorKind::Interrupted => SymphoniaError::IoInterruptedError(Box::new(err)),
+            ErrorKind::UnexpectedEof => SymphoniaError::EndOfFile,
+            _ => SymphoniaError::IoError(Box::new(err))
+        }
     }
 }
 
-pub type Result<T> = result::Result<T, Error>;
+pub type Result<T> = result::Result<T, SymphoniaError>;
 
 /// Convenience function to create a decode error.
 pub fn decode_error<T>(desc: &'static str) -> Result<T> {
-    Err(Error::DecodeError(desc))
+    Err(SymphoniaError::DecodeError(desc))
 }
 
 /// Convenience function to create a seek error.
 pub fn seek_error<T>(kind: SeekErrorKind) -> Result<T> {
-    Err(Error::SeekError(kind))
+    Err(SymphoniaError::SeekError(kind))
 }
 
 /// Convenience function to create an unsupport feature error.
 pub fn unsupported_error<T>(feature: &'static str) -> Result<T> {
-    Err(Error::Unsupported(feature))
+    Err(SymphoniaError::Unsupported(feature))
 }
 
 /// Convenience function to create a limit error.
 pub fn limit_error<T>(constraint: &'static str) -> Result<T> {
-    Err(Error::LimitError(constraint))
+    Err(SymphoniaError::LimitError(constraint))
 }
 
 /// Convenience function to create a reset required error.
 pub fn reset_error<T>() -> Result<T> {
-    Err(Error::ResetRequired)
+    Err(SymphoniaError::ResetRequired)
 }
 
 /// Convenience function to create an end-of-stream error.
 pub fn end_of_stream_error<T>() -> Result<T> {
-    Err(Error::IoError(IoErrorKind::UnexpectedEof, "end of stream"))
+    Err(SymphoniaError::EndOfFile)
 }
diff --git a/symphonia-core/src/io/bit.rs b/symphonia-core/src/io/bit.rs
index 827c3d98..31ddee05 100644
--- a/symphonia-core/src/io/bit.rs
+++ b/symphonia-core/src/io/bit.rs
@@ -9,10 +9,11 @@ use core::cmp::min;
 
 use crate::io::ReadBytes;
 use crate::util::bits::*;
-use crate::errors::{Error, IoErrorKind, Result};
+use crate::errors::{Result};
+use crate::errors::SymphoniaError as Error;
 
 fn end_of_bitstream_error<T>() -> Result<T> {
-    Err(Error::IoError(IoErrorKind::Other, "unexpected end of bitstream"))
+    Err(Error::Other("unexpected end of bitstream"))
 }
 
 pub mod vlc {
@@ -21,11 +22,11 @@ pub mod vlc {
     use core::cmp::max;
     use alloc::collections::{BTreeMap, VecDeque};
     use alloc::vec::Vec;
-    use crate::errors::{IoErrorKind, Result};
-    use crate::errors::Error;
+    use crate::errors::{Result};
+    use crate::errors::SymphoniaError as Error;
 
     fn codebook_error<T>(desc: &'static str) -> Result<T> {
-        Err(Error::IoError(IoErrorKind::Other, desc))
+        Err(Error::Other(desc))
     }
 
     /// `BitOrder` describes the relationship between the order of bits in the provided codewords
diff --git a/symphonia-core/src/io/buf_reader.rs b/symphonia-core/src/io/buf_reader.rs
index 8731ac36..072912c6 100644
--- a/symphonia-core/src/io/buf_reader.rs
+++ b/symphonia-core/src/io/buf_reader.rs
@@ -8,11 +8,12 @@
 use core::cmp;
 
 use super::{FiniteStream, ReadBytes};
-use crate::errors::{IoErrorKind, Result, Error};
+use crate::errors::{Result};
+use crate::errors::SymphoniaError as Error;
 
 #[inline(always)]
 fn underrun_error<T>() -> Result<T> {
-    Err(Error::IoError(IoErrorKind::UnexpectedEof, "buffer underrun"))
+    Err(Error::Other("buffer underrun"))
 }
 
 /// A `BufReader` reads bytes from a byte buffer.
diff --git a/symphonia-core/src/io/media_source_stream.rs b/symphonia-core/src/io/media_source_stream.rs
index 83da55b2..0f88c41b 100644
--- a/symphonia-core/src/io/media_source_stream.rs
+++ b/symphonia-core/src/io/media_source_stream.rs
@@ -12,12 +12,11 @@ use core::ops::Sub;
 
 use super::{IoSliceMut, Read, Seek, SeekBuffered, SeekFrom};
 use super::{MediaSource, ReadBytes};
-use crate::errors::{IoErrorKind, Result};
-use crate::errors::Error;
+use crate::errors::{Result, SymphoniaError};
 
 #[inline(always)]
 fn end_of_stream_error<T>() -> Result<T> {
-    Err(Error::IoError(IoErrorKind::UnexpectedEof, ""))
+    Err(SymphoniaError::EndOfFile)
 }
 
 /// `MediaSourceStreamOptions` specifies the buffering behaviour of a `MediaSourceStream`.
@@ -204,7 +203,7 @@ impl Read for MediaSourceStream {
                     buf = &mut buf[count..];
                     self.consume(count);
                 }
-                Err(Error::IoError(IoErrorKind::Interrupted, _))  => {}
+                Err(SymphoniaError::IoInterruptedError(_))  => {}
                 Err(e) => return Err(e),
             }
         }
@@ -326,7 +325,7 @@ impl ReadBytes for MediaSourceStream {
                 Ok(count) => {
                     buf = &mut buf[count..];
                 }
-                Err(Error::IoError(IoErrorKind::Interrupted, _)) =>  {}
+                Err(SymphoniaError::IoInterruptedError(_))  => {}
                 Err(e) => return Err(e),
             }
         }
diff --git a/symphonia-core/src/io/mod.rs b/symphonia-core/src/io/mod.rs
index 4e33c2fb..e2f3ad51 100644
--- a/symphonia-core/src/io/mod.rs
+++ b/symphonia-core/src/io/mod.rs
@@ -23,7 +23,7 @@ use alloc::boxed::Box;
 use alloc::vec;
 use alloc::vec::Vec;
 use core::mem;
-use crate::errors::{Error, IoErrorKind, Result};
+use crate::errors::{SymphoniaError, Result};
 
 #[cfg(feature = "std")]
 use std::io;
@@ -95,7 +95,7 @@ fn default_slow_read_to_end<R: Read + ?Sized>(
         let n = match r {
             Ok(0) => break,
             Ok(n) => n,
-            Err(Error::IoError(IoErrorKind::Interrupted, _)) => 0, // Ignored
+            Err(SymphoniaError::IoInterruptedError(_))  => 0, // Ignored
             Err(err) => return Err(err),
         };
 
@@ -117,7 +117,7 @@ fn default_read_vectored<F>(read: F, bufs: &mut [IoSliceMut<'_>]) -> Result<usiz
 #[cfg(feature = "std")]
 impl <T: std::io::Read> Read for T {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
-        self.read(buf).map_err(|e| { Error::from(e) })
+        self.read(buf).map_err(|e| { SymphoniaError::from(e) })
     }
 }
 
@@ -129,7 +129,7 @@ impl <T: std::io::Seek> Seek for T  {
             SeekFrom::End(x) => io::SeekFrom::End(x),
             SeekFrom::Current(x) => io::SeekFrom::Current(x),
         };
-        self.seek(from).map_err(|e| { Error::from(e) })
+        self.seek(from).map_err(|e| { SymphoniaError::from(e) })
     }
 }
 
@@ -238,7 +238,7 @@ impl<R: Read> Read for ReadOnlySource<R> {
 
 impl<R: Read> Seek for ReadOnlySource<R> {
     fn seek(&mut self, _: SeekFrom) -> Result<u64> {
-        Err(Error::IoError(IoErrorKind::Other, "source does not support seeking"))
+        Err(SymphoniaError::Other("source does not support seeking"))
     }
 }
 
diff --git a/symphonia-core/src/io/scoped_stream.rs b/symphonia-core/src/io/scoped_stream.rs
index 812cfc97..3819300e 100644
--- a/symphonia-core/src/io/scoped_stream.rs
+++ b/symphonia-core/src/io/scoped_stream.rs
@@ -6,14 +6,13 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 use core::cmp;
-use crate::errors::{IoErrorKind, Result};
-use crate::errors::Error;
+use crate::errors::{Result, SymphoniaError};
 
 use super::{FiniteStream, ReadBytes, SeekBuffered};
 
 #[inline(always)]
 fn out_of_bounds_error<T>() -> Result<T> {
-    Err(Error::IoError(IoErrorKind::UnexpectedEof, "out of bounds"))
+    Err(SymphoniaError::EndOfFile)
 }
 
 /// A `ScopedStream` restricts the number of bytes that may be read to an upper limit.
diff --git a/symphonia-core/src/lib.rs b/symphonia-core/src/lib.rs
index 7e5745ed..98d387b4 100644
--- a/symphonia-core/src/lib.rs
+++ b/symphonia-core/src/lib.rs
@@ -16,9 +16,7 @@
 #![feature(error_in_core)]
 
 extern crate alloc;
-
-#[cfg(not(feature="std"))]
-extern crate core as std;
+extern crate core;
 
 #[cfg(feature = "std")]
 extern crate std;
diff --git a/symphonia-format-isomp4/src/stream.rs b/symphonia-format-isomp4/src/stream.rs
index ec93c475..1ac8c415 100644
--- a/symphonia-format-isomp4/src/stream.rs
+++ b/symphonia-format-isomp4/src/stream.rs
@@ -4,7 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-use symphonia_core::errors::{decode_error, Error, Result};
+use symphonia_core::errors::{decode_error, Result};
+use symphonia_core::errors::SymphoniaError as Error;
 
 use crate::atoms::{stsz::SampleSize, Co64Atom, MoofAtom, MoovAtom, MvexAtom, StcoAtom, TrafAtom};
 
diff --git a/symphonia-format-mkv/src/demuxer.rs b/symphonia-format-mkv/src/demuxer.rs
index 7fdca565..54555a8f 100644
--- a/symphonia-format-mkv/src/demuxer.rs
+++ b/symphonia-format-mkv/src/demuxer.rs
@@ -11,8 +11,9 @@ use std::convert::TryFrom;
 use symphonia_core::audio::Layout;
 use symphonia_core::codecs::{CodecParameters, CODEC_TYPE_FLAC, CODEC_TYPE_VORBIS};
 use symphonia_core::errors::{
-    decode_error, end_of_stream_error, seek_error, unsupported_error, Error, Result, SeekErrorKind,
+    decode_error, end_of_stream_error, seek_error, unsupported_error, Result, SeekErrorKind,
 };
+use symphonia_core::errors::SymphoniaError as Error;
 use symphonia_core::formats::{
     Cue, FormatOptions, FormatReader, Packet, SeekMode, SeekTo, SeekedTo, Track,
 };
diff --git a/symphonia-format-mkv/src/ebml.rs b/symphonia-format-mkv/src/ebml.rs
index ae2bf50d..7437c2ed 100644
--- a/symphonia-format-mkv/src/ebml.rs
+++ b/symphonia-format-mkv/src/ebml.rs
@@ -5,7 +5,7 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use symphonia_core::errors::{decode_error, seek_error, Error, Result, SeekErrorKind};
+use symphonia_core::errors::{decode_error, seek_error, SymphoniaError, Result, SeekErrorKind};
 use symphonia_core::io::{MediaSource, ReadBytes, SeekFrom};
 use symphonia_core::util::bits::sign_extend_leq64_to_i64;
 
@@ -376,7 +376,7 @@ impl<R: ReadBytes> ElementIterator<R> {
         let hdr = self.current.expect("not in an element");
         let value = self
             .try_read_data(hdr)?
-            .ok_or(Error::DecodeError("mkv: element has no primitive data"))?;
+            .ok_or(SymphoniaError::DecodeError("mkv: element has no primitive data"))?;
         Ok(value)
     }
 
@@ -384,7 +384,7 @@ impl<R: ReadBytes> ElementIterator<R> {
     pub(crate) fn read_u64(&mut self) -> Result<u64> {
         match self.read_data()? {
             ElementData::UnsignedInt(s) => Ok(s),
-            _ => Err(Error::DecodeError("mkv: expected an unsigned int")),
+            _ => Err(SymphoniaError::DecodeError("mkv: expected an unsigned int")),
         }
     }
 
@@ -392,7 +392,7 @@ impl<R: ReadBytes> ElementIterator<R> {
     pub(crate) fn read_f64(&mut self) -> Result<f64> {
         match self.read_data()? {
             ElementData::Float(s) => Ok(s),
-            _ => Err(Error::DecodeError("mkv: expected a float")),
+            _ => Err(SymphoniaError::DecodeError("mkv: expected a float")),
         }
     }
 
@@ -400,7 +400,7 @@ impl<R: ReadBytes> ElementIterator<R> {
     pub(crate) fn read_string(&mut self) -> Result<String> {
         match self.read_data()? {
             ElementData::String(s) => Ok(s),
-            _ => Err(Error::DecodeError("mkv: expected a string")),
+            _ => Err(SymphoniaError::DecodeError("mkv: expected a string")),
         }
     }
 
@@ -408,7 +408,7 @@ impl<R: ReadBytes> ElementIterator<R> {
     pub(crate) fn read_boxed_slice(&mut self) -> Result<Box<[u8]>> {
         match self.read_data()? {
             ElementData::Binary(b) => Ok(b),
-            _ => Err(Error::DecodeError("mkv: expected binary data")),
+            _ => Err(SymphoniaError::DecodeError("mkv: expected binary data")),
         }
     }
 
@@ -469,7 +469,7 @@ impl<R: ReadBytes> ElementIterator<R> {
                             8 => self.reader.read_be_f64()?,
                             _ => {
                                 self.ignore_data()?;
-                                return Err(Error::DecodeError("mkv: invalid float length"));
+                                return Err(SymphoniaError::DecodeError("mkv: invalid float length"));
                             }
                         };
                         ElementData::Float(value)
diff --git a/symphonia-format-mkv/src/segment.rs b/symphonia-format-mkv/src/segment.rs
index bda51ad9..cdbc4ad0 100644
--- a/symphonia-format-mkv/src/segment.rs
+++ b/symphonia-format-mkv/src/segment.rs
@@ -5,7 +5,8 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use symphonia_core::errors::{Error, Result};
+use symphonia_core::errors::SymphoniaError as Error;
+use symphonia_core::errors::{Result};
 use symphonia_core::io::{BufReader, ReadBytes};
 use symphonia_core::meta::{MetadataBuilder, MetadataRevision, Tag, Value};
 
diff --git a/symphonia-format-ogg/src/demuxer.rs b/symphonia-format-ogg/src/demuxer.rs
index 4003d3db..8eda9523 100644
--- a/symphonia-format-ogg/src/demuxer.rs
+++ b/symphonia-format-ogg/src/demuxer.rs
@@ -8,7 +8,7 @@
 use std::collections::BTreeMap;
 
 use symphonia_core::errors::{reset_error, seek_error, unsupported_error};
-use symphonia_core::errors::{Error, Result, SeekErrorKind};
+use symphonia_core::errors::{SymphoniaError, Result, SeekErrorKind};
 use symphonia_core::formats::prelude::*;
 use symphonia_core::io::*;
 use symphonia_core::meta::{Metadata, MetadataLog};
@@ -48,7 +48,7 @@ impl OggReader {
         loop {
             match self.pages.try_next_page(&mut self.reader) {
                 Ok(_) => break,
-                Err(Error::IoError(e, desc)) => return Err(Error::IoError(e, desc)),
+                Err(SymphoniaError::IoError(e)) => return Err(SymphoniaError::IoError(e)),
                 Err(e) => {
                     warn!("{}", e);
                 }
diff --git a/symphonia-format-ogg/src/page.rs b/symphonia-format-ogg/src/page.rs
index ff811f3f..e824694c 100644
--- a/symphonia-format-ogg/src/page.rs
+++ b/symphonia-format-ogg/src/page.rs
@@ -6,7 +6,7 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 use symphonia_core::checksum::Crc32;
-use symphonia_core::errors::{decode_error, Error, Result};
+use symphonia_core::errors::{decode_error, SymphoniaError, Result};
 use symphonia_core::io::{BufReader, Monitor, MonitorStream, ReadBytes, SeekBuffered};
 
 use log::{debug, warn};
@@ -269,7 +269,7 @@ impl PageReader {
         loop {
             match self.try_next_page(reader) {
                 Ok(_) => break,
-                Err(Error::IoError(e, desc)) => return Err(Error::IoError(e, desc)),
+                Err(SymphoniaError::IoError(e)) => return Err(SymphoniaError::IoError(e)),
                 _ => (),
             }
         }
@@ -290,7 +290,7 @@ impl PageReader {
                         break;
                     }
                 }
-                Err(Error::IoError(e, desc)) => return Err(Error::IoError(e, desc)),
+                Err(SymphoniaError::IoError(e)) => return Err(SymphoniaError::IoError(e)),
                 _ => (),
             }
         }
diff --git a/symphonia-format-riff/src/common.rs b/symphonia-format-riff/src/common.rs
index 2ac56aac..440522eb 100644
--- a/symphonia-format-riff/src/common.rs
+++ b/symphonia-format-riff/src/common.rs
@@ -12,7 +12,8 @@ use std::marker::PhantomData;
 use symphonia_core::audio::Channels;
 use symphonia_core::codecs::CodecParameters;
 use symphonia_core::codecs::CodecType;
-use symphonia_core::errors::{decode_error, end_of_stream_error, Error, Result};
+use symphonia_core::errors::{decode_error, end_of_stream_error, Result};
+use symphonia_core::errors::SymphoniaError as Error;
 use symphonia_core::formats::prelude::*;
 use symphonia_core::io::{MediaSourceStream, ReadBytes};
 
diff --git a/symphonia-format-wav/src/chunks.rs b/symphonia-format-wav/src/chunks.rs
index 3c5b695d..2d2b8129 100644
--- a/symphonia-format-wav/src/chunks.rs
+++ b/symphonia-format-wav/src/chunks.rs
@@ -17,7 +17,8 @@ use symphonia_core::codecs::{
     CODEC_TYPE_PCM_F64LE, CODEC_TYPE_PCM_MULAW, CODEC_TYPE_PCM_S16LE, CODEC_TYPE_PCM_S24LE,
     CODEC_TYPE_PCM_S32LE, CODEC_TYPE_PCM_U8,
 };
-use symphonia_core::errors::{decode_error, unsupported_error, Error, Result};
+use symphonia_core::errors::{decode_error, unsupported_error, Result};
+use symphonia_core::errors::SymphoniaError as Error;
 use symphonia_core::io::ReadBytes;
 use symphonia_core::meta::Tag;
 use symphonia_metadata::riff;
diff --git a/symphonia-play/src/main.rs b/symphonia-play/src/main.rs
index 9655b3b3..40d7677b 100644
--- a/symphonia-play/src/main.rs
+++ b/symphonia-play/src/main.rs
@@ -18,7 +18,8 @@ use std::path::Path;
 
 use lazy_static::lazy_static;
 use symphonia::core::codecs::{DecoderOptions, FinalizeResult, CODEC_TYPE_NULL};
-use symphonia::core::errors::{Error, IoErrorKind, Result};
+use symphonia::core::errors::Result;
+use symphonia::core::errors::SymphoniaError as Error;
 use symphonia::core::formats::{Cue, FormatOptions, FormatReader, SeekMode, SeekTo, Track};
 use symphonia::core::io::{MediaSource, MediaSourceStream, ReadOnlySource};
 use symphonia::core::meta::{ColorMode, MetadataOptions, MetadataRevision, Tag, Value, Visual};
@@ -402,7 +403,7 @@ fn first_supported_track(tracks: &[Track]) -> Option<&Track> {
 
 fn ignore_end_of_stream_error(result: Result<()>) -> Result<()> {
     match result {
-        Err(Error::IoError(IoErrorKind::UnexpectedEof, "end of stream")) => {
+        Err(Error::EndOfFile) => {
             // Do not treat "end of stream" as a fatal error. It's the currently only way a
             // format reader can indicate the media is complete.
             Ok(())

From de3cef16b885a99f21a0e5eebc11ab1710f3579c Mon Sep 17 00:00:00 2001
From: atok <atoktoto@fastmail.fm>
Date: Mon, 8 Jan 2024 20:52:34 +0100
Subject: [PATCH 19/22] no_std compatibility for rebased changes

---
 symphonia-core/src/dsp/mdct/no_simd.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/symphonia-core/src/dsp/mdct/no_simd.rs b/symphonia-core/src/dsp/mdct/no_simd.rs
index f2853ce8..d18b2755 100644
--- a/symphonia-core/src/dsp/mdct/no_simd.rs
+++ b/symphonia-core/src/dsp/mdct/no_simd.rs
@@ -9,6 +9,9 @@
 
 use crate::dsp::complex::Complex;
 use crate::dsp::fft::*;
+use alloc::boxed::Box;
+use alloc::vec;
+use alloc::vec::Vec;
 
 /// The Inverse Modified Discrete Transform (IMDCT).
 pub struct Imdct {

From f496c90f3d83f2a5e4d9ef5ce1d49d39a3f64a0a Mon Sep 17 00:00:00 2001
From: atok <atoktoto@fastmail.fm>
Date: Mon, 8 Jan 2024 20:53:39 +0100
Subject: [PATCH 20/22] Removed the requirement for building with nightly when
 not no_std

---
 rust-toolchain.toml          |  2 --
 symphonia-core/src/errors.rs | 22 +++++++++++++---------
 symphonia-core/src/lib.rs    |  2 +-
 3 files changed, 14 insertions(+), 12 deletions(-)
 delete mode 100644 rust-toolchain.toml

diff --git a/rust-toolchain.toml b/rust-toolchain.toml
deleted file mode 100644
index 271800cb..00000000
--- a/rust-toolchain.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-[toolchain]
-channel = "nightly"
\ No newline at end of file
diff --git a/symphonia-core/src/errors.rs b/symphonia-core/src/errors.rs
index 2cf07712..8e7f9988 100644
--- a/symphonia-core/src/errors.rs
+++ b/symphonia-core/src/errors.rs
@@ -10,10 +10,14 @@
 use core::{result};
 use core::fmt;
 use core::fmt::{Display};
-use std::error::Error;
 use alloc::boxed::Box;
-use std::io::ErrorKind;
-use std::ops::Deref;
+
+#[cfg(not(feature = "std"))]
+use core::error::Error as StdError;
+
+#[cfg(feature = "std")]
+use std::error::Error as StdError;
+use core::ops::Deref;
 
 
 /// `SeekErrorKind` is a list of generic reasons why a seek may fail.
@@ -44,9 +48,9 @@ impl SeekErrorKind {
 #[derive(Debug)]
 pub enum SymphoniaError {
     /// An IO error occurred while reading, writing, or seeking the stream.
-    IoError(Box<dyn Error>),
+    IoError(Box<dyn StdError>),
     /// An IO error occurred while reading, writing, or seeking the stream that is retryable.
-    IoInterruptedError(Box<dyn Error>),
+    IoInterruptedError(Box<dyn StdError>),
     /// The stream contained malformed data and could not be decoded or demuxed.
     DecodeError(&'static str),
     /// The stream could not be seeked.
@@ -96,8 +100,8 @@ impl fmt::Display for SymphoniaError {
     }
 }
 
-impl core::error::Error for SymphoniaError {
-    fn source(&self) -> Option<&(dyn Error + 'static)> {
+impl StdError for SymphoniaError {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
         match *self {
             SymphoniaError::IoError(ref err) => Some(err.deref()),
             SymphoniaError::IoInterruptedError(ref err) => Some(err.deref()),
@@ -110,8 +114,8 @@ impl core::error::Error for SymphoniaError {
 impl From<std::io::Error> for SymphoniaError {
     fn from(err: std::io::Error) -> SymphoniaError {
         match err.kind() {
-            ErrorKind::Interrupted => SymphoniaError::IoInterruptedError(Box::new(err)),
-            ErrorKind::UnexpectedEof => SymphoniaError::EndOfFile,
+            std::io::ErrorKind::Interrupted => SymphoniaError::IoInterruptedError(Box::new(err)),
+            std::io::ErrorKind::UnexpectedEof => SymphoniaError::EndOfFile,
             _ => SymphoniaError::IoError(Box::new(err))
         }
     }
diff --git a/symphonia-core/src/lib.rs b/symphonia-core/src/lib.rs
index 98d387b4..93075c39 100644
--- a/symphonia-core/src/lib.rs
+++ b/symphonia-core/src/lib.rs
@@ -13,7 +13,7 @@
 #![allow(clippy::identity_op)]
 #![allow(clippy::manual_range_contains)]
 
-#![feature(error_in_core)]
+#![cfg_attr(not(feature = "std"), feature(error_in_core))]
 
 extern crate alloc;
 extern crate core;

From e543ca1ef3e0ccbbf2ce89a700a03b040d6c05da Mon Sep 17 00:00:00 2001
From: atok <atoktoto@fastmail.fm>
Date: Mon, 8 Jan 2024 22:29:07 +0100
Subject: [PATCH 21/22] fmt

---
 symphonia-bundle-flac/src/lib.rs             |  1 -
 symphonia-bundle-flac/src/validate.rs        |  2 +-
 symphonia-bundle-mp3/src/demuxer.rs          |  1 -
 symphonia-bundle-mp3/src/layer3/mod.rs       |  2 +-
 symphonia-codec-aac/src/aac/codebooks.rs     |  2 +-
 symphonia-core/src/audio.rs                  |  2 +-
 symphonia-core/src/dsp/fft.rs                |  2 +-
 symphonia-core/src/dsp/mdct/simd.rs          |  2 +-
 symphonia-core/src/dsp/mod.rs                |  4 +--
 symphonia-core/src/errors.rs                 | 11 +++----
 symphonia-core/src/formats.rs                |  8 ++---
 symphonia-core/src/io/bit.rs                 | 12 +++----
 symphonia-core/src/io/buf_reader.rs          |  2 +-
 symphonia-core/src/io/media_source_stream.rs | 13 ++++----
 symphonia-core/src/io/mod.rs                 | 34 ++++++++------------
 symphonia-core/src/io/monitor_stream.rs      |  1 -
 symphonia-core/src/io/scoped_stream.rs       |  2 +-
 symphonia-core/src/lib.rs                    |  1 -
 symphonia-core/src/meta.rs                   |  6 ++--
 symphonia-core/src/probe.rs                  |  8 ++---
 symphonia-format-isomp4/src/stream.rs        |  2 +-
 symphonia-format-mkv/src/demuxer.rs          |  2 +-
 symphonia-format-mkv/src/ebml.rs             |  6 ++--
 symphonia-format-mkv/src/segment.rs          |  2 +-
 symphonia-format-ogg/src/demuxer.rs          |  2 +-
 symphonia-format-ogg/src/page.rs             |  2 +-
 symphonia-format-ogg/src/physical.rs         |  4 ++-
 symphonia-format-riff/src/common.rs          |  2 +-
 symphonia-format-wav/src/chunks.rs           |  4 +--
 symphonia-format-wav/src/lib.rs              |  6 ++--
 symphonia-metadata/src/id3v2/frames.rs       |  2 +-
 symphonia-metadata/src/itunes.rs             |  1 -
 symphonia-metadata/src/lib.rs                |  1 -
 symphonia-utils-xiph/src/flac/metadata.rs    |  6 ++--
 symphonia-utils-xiph/src/lib.rs              |  1 -
 symphonia/src/lib.rs                         |  1 -
 36 files changed, 75 insertions(+), 85 deletions(-)

diff --git a/symphonia-bundle-flac/src/lib.rs b/symphonia-bundle-flac/src/lib.rs
index 712b550f..d343fbe9 100644
--- a/symphonia-bundle-flac/src/lib.rs
+++ b/symphonia-bundle-flac/src/lib.rs
@@ -13,7 +13,6 @@
 #![allow(clippy::excessive_precision)]
 #![allow(clippy::identity_op)]
 #![allow(clippy::manual_range_contains)]
-
 #![no_std]
 
 extern crate alloc;
diff --git a/symphonia-bundle-flac/src/validate.rs b/symphonia-bundle-flac/src/validate.rs
index 0339f5f0..d58d87c8 100644
--- a/symphonia-bundle-flac/src/validate.rs
+++ b/symphonia-bundle-flac/src/validate.rs
@@ -5,8 +5,8 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use core::mem;
 use alloc::vec::Vec;
+use core::mem;
 
 use symphonia_core::audio::{AudioBuffer, Signal};
 use symphonia_core::checksum::Md5;
diff --git a/symphonia-bundle-mp3/src/demuxer.rs b/symphonia-bundle-mp3/src/demuxer.rs
index e50023a4..f706c0fb 100644
--- a/symphonia-bundle-mp3/src/demuxer.rs
+++ b/symphonia-bundle-mp3/src/demuxer.rs
@@ -18,7 +18,6 @@ use symphonia_core::probe::{Descriptor, Instantiate, QueryDescriptor};
 use crate::common::{FrameHeader, MpegLayer};
 use crate::header::{self, MAX_MPEG_FRAME_SIZE, MPEG_HEADER_LEN};
 
-
 use log::{debug, info, warn};
 
 /// MPEG1 and MPEG2 audio elementary stream reader.
diff --git a/symphonia-bundle-mp3/src/layer3/mod.rs b/symphonia-bundle-mp3/src/layer3/mod.rs
index 9b19cc43..6da0fbe9 100644
--- a/symphonia-bundle-mp3/src/layer3/mod.rs
+++ b/symphonia-bundle-mp3/src/layer3/mod.rs
@@ -8,8 +8,8 @@
 use std::fmt;
 
 use symphonia_core::audio::{AudioBuffer, Signal};
-use symphonia_core::errors::{decode_error, Result};
 use symphonia_core::errors::SymphoniaError as Error;
+use symphonia_core::errors::{decode_error, Result};
 use symphonia_core::io::{BitReaderLtr, BufReader, ReadBitsLtr, ReadBytes};
 
 mod bitstream;
diff --git a/symphonia-codec-aac/src/aac/codebooks.rs b/symphonia-codec-aac/src/aac/codebooks.rs
index b5d7b9e5..f33eeb5a 100644
--- a/symphonia-codec-aac/src/aac/codebooks.rs
+++ b/symphonia-codec-aac/src/aac/codebooks.rs
@@ -5,8 +5,8 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use symphonia_core::io::{vlc::*, ReadBitsLtr};
 use symphonia_core::errors::Result;
+use symphonia_core::io::{vlc::*, ReadBitsLtr};
 
 use lazy_static::lazy_static;
 
diff --git a/symphonia-core/src/audio.rs b/symphonia-core/src/audio.rs
index b8f93a42..047cb360 100644
--- a/symphonia-core/src/audio.rs
+++ b/symphonia-core/src/audio.rs
@@ -11,10 +11,10 @@
 use alloc::borrow::Cow;
 use alloc::boxed::Box;
 use alloc::vec;
+use alloc::vec::Vec;
 use core::fmt;
 use core::marker::PhantomData;
 use core::mem;
-use alloc::vec::Vec;
 
 use arrayvec::ArrayVec;
 use bitflags::bitflags;
diff --git a/symphonia-core/src/dsp/fft.rs b/symphonia-core/src/dsp/fft.rs
index 29e375cd..a8cbfe86 100644
--- a/symphonia-core/src/dsp/fft.rs
+++ b/symphonia-core/src/dsp/fft.rs
@@ -409,8 +409,8 @@ fn fft2(x: &mut [Complex; 2]) {
 
 #[cfg(test)]
 mod tests {
-    use alloc::vec::Vec;
     use super::*;
+    use alloc::vec::Vec;
     use core::f64;
 
     /// Compute a naive DFT.
diff --git a/symphonia-core/src/dsp/mdct/simd.rs b/symphonia-core/src/dsp/mdct/simd.rs
index 621b5de5..9ec4b07c 100644
--- a/symphonia-core/src/dsp/mdct/simd.rs
+++ b/symphonia-core/src/dsp/mdct/simd.rs
@@ -8,9 +8,9 @@
 //! The Modified Discrete Cosine Transform (MDCT) implemented with SIMD optimizations.
 
 use alloc::boxed::Box;
-use alloc::vec::Vec;
 use alloc::sync::Arc;
 use alloc::vec;
+use alloc::vec::Vec;
 
 use rustfft::num_complex::Complex;
 
diff --git a/symphonia-core/src/dsp/mod.rs b/symphonia-core/src/dsp/mod.rs
index 82f3c9ea..243198fb 100644
--- a/symphonia-core/src/dsp/mod.rs
+++ b/symphonia-core/src/dsp/mod.rs
@@ -8,7 +8,7 @@
 //! The `dsp` module provides efficient implementations of common signal processing algorithms.
 
 pub mod complex;
-#[cfg(feature="fft")]
+#[cfg(feature = "fft")]
 pub mod fft;
-#[cfg(feature="fft")]
+#[cfg(feature = "fft")]
 pub mod mdct;
diff --git a/symphonia-core/src/errors.rs b/symphonia-core/src/errors.rs
index 8e7f9988..021d857c 100644
--- a/symphonia-core/src/errors.rs
+++ b/symphonia-core/src/errors.rs
@@ -7,18 +7,17 @@
 
 //! The `errors` module defines the common error type.
 
-use core::{result};
-use core::fmt;
-use core::fmt::{Display};
 use alloc::boxed::Box;
+use core::fmt;
+use core::fmt::Display;
+use core::result;
 
 #[cfg(not(feature = "std"))]
 use core::error::Error as StdError;
 
+use core::ops::Deref;
 #[cfg(feature = "std")]
 use std::error::Error as StdError;
-use core::ops::Deref;
-
 
 /// `SeekErrorKind` is a list of generic reasons why a seek may fail.
 #[derive(Debug)]
@@ -116,7 +115,7 @@ impl From<std::io::Error> for SymphoniaError {
         match err.kind() {
             std::io::ErrorKind::Interrupted => SymphoniaError::IoInterruptedError(Box::new(err)),
             std::io::ErrorKind::UnexpectedEof => SymphoniaError::EndOfFile,
-            _ => SymphoniaError::IoError(Box::new(err))
+            _ => SymphoniaError::IoError(Box::new(err)),
         }
     }
 }
diff --git a/symphonia-core/src/formats.rs b/symphonia-core/src/formats.rs
index 0309dd59..ed6a99b5 100644
--- a/symphonia-core/src/formats.rs
+++ b/symphonia-core/src/formats.rs
@@ -8,14 +8,14 @@
 //! The `format` module provides the traits and support structures necessary to implement media
 //! demuxers.
 
-use alloc::boxed::Box;
-use alloc::string::String;
-use alloc::vec::Vec;
 use crate::codecs::CodecParameters;
 use crate::errors::Result;
 use crate::io::{BufReader, MediaSourceStream};
 use crate::meta::{Metadata, Tag};
 use crate::units::{Time, TimeStamp};
+use alloc::boxed::Box;
+use alloc::string::String;
+use alloc::vec::Vec;
 
 pub mod prelude {
     //! The `formats` module prelude.
@@ -330,8 +330,8 @@ impl Packet {
 pub mod util {
     //! Helper utilities for implementing `FormatReader`s.
 
-    use alloc::vec::Vec;
     use super::Packet;
+    use alloc::vec::Vec;
 
     /// A `SeekPoint` is a mapping between a sample or frame number to byte offset within a media
     /// stream.
diff --git a/symphonia-core/src/io/bit.rs b/symphonia-core/src/io/bit.rs
index 31ddee05..8d274878 100644
--- a/symphonia-core/src/io/bit.rs
+++ b/symphonia-core/src/io/bit.rs
@@ -7,10 +7,10 @@
 
 use core::cmp::min;
 
+use crate::errors::Result;
+use crate::errors::SymphoniaError as Error;
 use crate::io::ReadBytes;
 use crate::util::bits::*;
-use crate::errors::{Result};
-use crate::errors::SymphoniaError as Error;
 
 fn end_of_bitstream_error<T>() -> Result<T> {
     Err(Error::Other("unexpected end of bitstream"))
@@ -19,11 +19,11 @@ fn end_of_bitstream_error<T>() -> Result<T> {
 pub mod vlc {
     //! The `vlc` module provides support for decoding variable-length codes (VLC).
 
-    use core::cmp::max;
+    use crate::errors::Result;
+    use crate::errors::SymphoniaError as Error;
     use alloc::collections::{BTreeMap, VecDeque};
     use alloc::vec::Vec;
-    use crate::errors::{Result};
-    use crate::errors::SymphoniaError as Error;
+    use core::cmp::max;
 
     fn codebook_error<T>(desc: &'static str) -> Result<T> {
         Err(Error::Other(desc))
@@ -1469,10 +1469,10 @@ impl<'a> FiniteBitStream for BitReaderRtl<'a> {
 
 #[cfg(test)]
 mod tests {
-    use alloc::vec::Vec;
     use super::vlc::{BitOrder, Codebook, CodebookBuilder, Entry8x8};
     use super::{BitReaderLtr, ReadBitsLtr};
     use super::{BitReaderRtl, ReadBitsRtl};
+    use alloc::vec::Vec;
 
     #[test]
     #[allow(clippy::bool_assert_comparison)]
diff --git a/symphonia-core/src/io/buf_reader.rs b/symphonia-core/src/io/buf_reader.rs
index 072912c6..233be022 100644
--- a/symphonia-core/src/io/buf_reader.rs
+++ b/symphonia-core/src/io/buf_reader.rs
@@ -8,7 +8,7 @@
 use core::cmp;
 
 use super::{FiniteStream, ReadBytes};
-use crate::errors::{Result};
+use crate::errors::Result;
 use crate::errors::SymphoniaError as Error;
 
 #[inline(always)]
diff --git a/symphonia-core/src/io/media_source_stream.rs b/symphonia-core/src/io/media_source_stream.rs
index 0f88c41b..f380b85d 100644
--- a/symphonia-core/src/io/media_source_stream.rs
+++ b/symphonia-core/src/io/media_source_stream.rs
@@ -203,7 +203,7 @@ impl Read for MediaSourceStream {
                     buf = &mut buf[count..];
                     self.consume(count);
                 }
-                Err(SymphoniaError::IoInterruptedError(_))  => {}
+                Err(SymphoniaError::IoInterruptedError(_)) => {}
                 Err(e) => return Err(e),
             }
         }
@@ -325,7 +325,7 @@ impl ReadBytes for MediaSourceStream {
                 Ok(count) => {
                     buf = &mut buf[count..];
                 }
-                Err(SymphoniaError::IoInterruptedError(_))  => {}
+                Err(SymphoniaError::IoInterruptedError(_)) => {}
                 Err(e) => return Err(e),
             }
         }
@@ -478,7 +478,8 @@ impl Read for &[u8] {
         // for a single byte the overhead is significant.
         if amt == 1 {
             buf[0] = a[0];
-        } else {
+        }
+        else {
             buf[..amt].copy_from_slice(a);
         }
 
@@ -490,12 +491,12 @@ impl Read for &[u8] {
 #[cfg(feature = "std")]
 #[cfg(test)]
 mod tests {
+    use super::{MediaSourceStream, ReadBytes, SeekBuffered};
+    use crate::io::Read;
     use alloc::boxed::Box;
     use alloc::vec;
     use alloc::vec::Vec;
-    use super::{MediaSourceStream, ReadBytes, SeekBuffered};
-    use std::io::{Cursor};
-    use crate::io::Read;
+    use std::io::Cursor;
 
     /// Generate a random vector of bytes of the specified length using a PRNG.
     fn generate_random_bytes(len: usize) -> Box<[u8]> {
diff --git a/symphonia-core/src/io/mod.rs b/symphonia-core/src/io/mod.rs
index e2f3ad51..a109ee6f 100644
--- a/symphonia-core/src/io/mod.rs
+++ b/symphonia-core/src/io/mod.rs
@@ -19,11 +19,11 @@
 //! either the [`ReadBitsLtr`] or [`ReadBitsRtl`] traits depending on the order in which they
 //! consume bits.
 
+use crate::errors::{Result, SymphoniaError};
 use alloc::boxed::Box;
 use alloc::vec;
 use alloc::vec::Vec;
 use core::mem;
-use crate::errors::{SymphoniaError, Result};
 
 #[cfg(feature = "std")]
 use std::io;
@@ -82,20 +82,16 @@ pub trait Read {
 }
 
 /// Warning: The default implementation in io::Read is much faster
-fn default_slow_read_to_end<R: Read + ?Sized>(
-    r: &mut R,
-    buf: &mut Vec<u8>
-) -> Result<usize> {
-
+fn default_slow_read_to_end<R: Read + ?Sized>(r: &mut R, buf: &mut Vec<u8>) -> Result<usize> {
     let mut cnt: usize = 0;
     let mut read_buf: [u8; 1024] = [0; 1024];
 
     loop {
-        let r =  r.read(&mut read_buf);
+        let r = r.read(&mut read_buf);
         let n = match r {
             Ok(0) => break,
             Ok(n) => n,
-            Err(SymphoniaError::IoInterruptedError(_))  => 0, // Ignored
+            Err(SymphoniaError::IoInterruptedError(_)) => 0, // Ignored
             Err(err) => return Err(err),
         };
 
@@ -107,29 +103,29 @@ fn default_slow_read_to_end<R: Read + ?Sized>(
 }
 
 fn default_read_vectored<F>(read: F, bufs: &mut [IoSliceMut<'_>]) -> Result<usize>
-    where
-        F: FnOnce(&mut [u8]) -> Result<usize>,
+where
+    F: FnOnce(&mut [u8]) -> Result<usize>,
 {
     let buf = bufs.iter_mut().find(|b| !b.is_empty()).map_or(&mut [][..], |b| &mut **b);
     read(buf)
 }
 
 #[cfg(feature = "std")]
-impl <T: std::io::Read> Read for T {
+impl<T: std::io::Read> Read for T {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
-        self.read(buf).map_err(|e| { SymphoniaError::from(e) })
+        self.read(buf).map_err(|e| SymphoniaError::from(e))
     }
 }
 
 #[cfg(feature = "std")]
-impl <T: std::io::Seek> Seek for T  {
+impl<T: std::io::Seek> Seek for T {
     fn seek(&mut self, from: SeekFrom) -> Result<u64> {
         let from = match from {
             SeekFrom::Start(x) => io::SeekFrom::Start(x),
             SeekFrom::End(x) => io::SeekFrom::End(x),
             SeekFrom::Current(x) => io::SeekFrom::Current(x),
         };
-        self.seek(from).map_err(|e| { SymphoniaError::from(e) })
+        self.seek(from).map_err(|e| SymphoniaError::from(e))
     }
 }
 
@@ -139,7 +135,7 @@ impl <T: std::io::Seek> Seek for T  {
 /// Despite requiring the [`std::io::Seek`] trait, seeking is an optional capability that can be
 /// queried at runtime.
 // pub trait MediaSource: io::Read + io::Seek + Send + Sync {
-pub trait MediaSource: Read + Seek  {
+pub trait MediaSource: Read + Seek {
     /// Returns if the source is seekable. This may be an expensive operation.
     fn is_seekable(&self) -> bool;
 
@@ -616,11 +612,9 @@ mod no_std_compat {
         buf: &'a mut [u8],
     }
 
-    impl <'a> IoSliceMut<'a> {
+    impl<'a> IoSliceMut<'a> {
         pub fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {
-            IoSliceMut {
-                buf
-            }
+            IoSliceMut { buf }
         }
     }
 
@@ -639,4 +633,4 @@ mod no_std_compat {
             self.buf
         }
     }
-}
\ No newline at end of file
+}
diff --git a/symphonia-core/src/io/monitor_stream.rs b/symphonia-core/src/io/monitor_stream.rs
index bea9335a..3053c096 100644
--- a/symphonia-core/src/io/monitor_stream.rs
+++ b/symphonia-core/src/io/monitor_stream.rs
@@ -5,7 +5,6 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-
 use super::ReadBytes;
 use crate::errors::Result;
 
diff --git a/symphonia-core/src/io/scoped_stream.rs b/symphonia-core/src/io/scoped_stream.rs
index 3819300e..6cf90eff 100644
--- a/symphonia-core/src/io/scoped_stream.rs
+++ b/symphonia-core/src/io/scoped_stream.rs
@@ -5,8 +5,8 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use core::cmp;
 use crate::errors::{Result, SymphoniaError};
+use core::cmp;
 
 use super::{FiniteStream, ReadBytes, SeekBuffered};
 
diff --git a/symphonia-core/src/lib.rs b/symphonia-core/src/lib.rs
index 93075c39..8d79fc2b 100644
--- a/symphonia-core/src/lib.rs
+++ b/symphonia-core/src/lib.rs
@@ -12,7 +12,6 @@
 #![allow(clippy::excessive_precision)]
 #![allow(clippy::identity_op)]
 #![allow(clippy::manual_range_contains)]
-
 #![cfg_attr(not(feature = "std"), feature(error_in_core))]
 
 extern crate alloc;
diff --git a/symphonia-core/src/meta.rs b/symphonia-core/src/meta.rs
index f3fac2bc..4664b99e 100644
--- a/symphonia-core/src/meta.rs
+++ b/symphonia-core/src/meta.rs
@@ -7,15 +7,15 @@
 
 //! The `meta` module defines basic metadata elements, and management structures.
 
+use alloc::borrow::Cow;
 use alloc::boxed::Box;
+use alloc::collections::VecDeque;
 use alloc::string::String;
+use alloc::string::ToString;
 use alloc::vec::Vec;
-use alloc::borrow::Cow;
-use alloc::collections::VecDeque;
 use core::convert::From;
 use core::fmt;
 use core::num::NonZeroU32;
-use alloc::string::ToString;
 
 use crate::errors::Result;
 use crate::io::MediaSourceStream;
diff --git a/symphonia-core/src/probe.rs b/symphonia-core/src/probe.rs
index 09dc7079..9aba21c0 100644
--- a/symphonia-core/src/probe.rs
+++ b/symphonia-core/src/probe.rs
@@ -8,14 +8,14 @@
 //! The `probe` module provides methods and traits to support auto-detection of media formats from
 //! arbitrary media streams.
 
-use alloc::boxed::Box;
-use alloc::string::String;
-use alloc::vec::Vec;
-use alloc::borrow::ToOwned;
 use crate::errors::{unsupported_error, Result};
 use crate::formats::{FormatOptions, FormatReader};
 use crate::io::{MediaSourceStream, ReadBytes, SeekBuffered};
 use crate::meta::{Metadata, MetadataLog, MetadataOptions, MetadataReader};
+use alloc::borrow::ToOwned;
+use alloc::boxed::Box;
+use alloc::string::String;
+use alloc::vec::Vec;
 
 use log::{debug, error, info};
 
diff --git a/symphonia-format-isomp4/src/stream.rs b/symphonia-format-isomp4/src/stream.rs
index 1ac8c415..820c0d69 100644
--- a/symphonia-format-isomp4/src/stream.rs
+++ b/symphonia-format-isomp4/src/stream.rs
@@ -4,8 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-use symphonia_core::errors::{decode_error, Result};
 use symphonia_core::errors::SymphoniaError as Error;
+use symphonia_core::errors::{decode_error, Result};
 
 use crate::atoms::{stsz::SampleSize, Co64Atom, MoofAtom, MoovAtom, MvexAtom, StcoAtom, TrafAtom};
 
diff --git a/symphonia-format-mkv/src/demuxer.rs b/symphonia-format-mkv/src/demuxer.rs
index 54555a8f..428f480c 100644
--- a/symphonia-format-mkv/src/demuxer.rs
+++ b/symphonia-format-mkv/src/demuxer.rs
@@ -10,10 +10,10 @@ use std::convert::TryFrom;
 
 use symphonia_core::audio::Layout;
 use symphonia_core::codecs::{CodecParameters, CODEC_TYPE_FLAC, CODEC_TYPE_VORBIS};
+use symphonia_core::errors::SymphoniaError as Error;
 use symphonia_core::errors::{
     decode_error, end_of_stream_error, seek_error, unsupported_error, Result, SeekErrorKind,
 };
-use symphonia_core::errors::SymphoniaError as Error;
 use symphonia_core::formats::{
     Cue, FormatOptions, FormatReader, Packet, SeekMode, SeekTo, SeekedTo, Track,
 };
diff --git a/symphonia-format-mkv/src/ebml.rs b/symphonia-format-mkv/src/ebml.rs
index 7437c2ed..96841eb1 100644
--- a/symphonia-format-mkv/src/ebml.rs
+++ b/symphonia-format-mkv/src/ebml.rs
@@ -5,7 +5,7 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use symphonia_core::errors::{decode_error, seek_error, SymphoniaError, Result, SeekErrorKind};
+use symphonia_core::errors::{decode_error, seek_error, Result, SeekErrorKind, SymphoniaError};
 use symphonia_core::io::{MediaSource, ReadBytes, SeekFrom};
 use symphonia_core::util::bits::sign_extend_leq64_to_i64;
 
@@ -469,7 +469,9 @@ impl<R: ReadBytes> ElementIterator<R> {
                             8 => self.reader.read_be_f64()?,
                             _ => {
                                 self.ignore_data()?;
-                                return Err(SymphoniaError::DecodeError("mkv: invalid float length"));
+                                return Err(SymphoniaError::DecodeError(
+                                    "mkv: invalid float length",
+                                ));
                             }
                         };
                         ElementData::Float(value)
diff --git a/symphonia-format-mkv/src/segment.rs b/symphonia-format-mkv/src/segment.rs
index cdbc4ad0..1dd2c3e0 100644
--- a/symphonia-format-mkv/src/segment.rs
+++ b/symphonia-format-mkv/src/segment.rs
@@ -5,8 +5,8 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
+use symphonia_core::errors::Result;
 use symphonia_core::errors::SymphoniaError as Error;
-use symphonia_core::errors::{Result};
 use symphonia_core::io::{BufReader, ReadBytes};
 use symphonia_core::meta::{MetadataBuilder, MetadataRevision, Tag, Value};
 
diff --git a/symphonia-format-ogg/src/demuxer.rs b/symphonia-format-ogg/src/demuxer.rs
index 8eda9523..7e793a07 100644
--- a/symphonia-format-ogg/src/demuxer.rs
+++ b/symphonia-format-ogg/src/demuxer.rs
@@ -8,7 +8,7 @@
 use std::collections::BTreeMap;
 
 use symphonia_core::errors::{reset_error, seek_error, unsupported_error};
-use symphonia_core::errors::{SymphoniaError, Result, SeekErrorKind};
+use symphonia_core::errors::{Result, SeekErrorKind, SymphoniaError};
 use symphonia_core::formats::prelude::*;
 use symphonia_core::io::*;
 use symphonia_core::meta::{Metadata, MetadataLog};
diff --git a/symphonia-format-ogg/src/page.rs b/symphonia-format-ogg/src/page.rs
index e824694c..a5621e16 100644
--- a/symphonia-format-ogg/src/page.rs
+++ b/symphonia-format-ogg/src/page.rs
@@ -6,7 +6,7 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 use symphonia_core::checksum::Crc32;
-use symphonia_core::errors::{decode_error, SymphoniaError, Result};
+use symphonia_core::errors::{decode_error, Result, SymphoniaError};
 use symphonia_core::io::{BufReader, Monitor, MonitorStream, ReadBytes, SeekBuffered};
 
 use log::{debug, warn};
diff --git a/symphonia-format-ogg/src/physical.rs b/symphonia-format-ogg/src/physical.rs
index 58c80b96..19d94a13 100644
--- a/symphonia-format-ogg/src/physical.rs
+++ b/symphonia-format-ogg/src/physical.rs
@@ -7,7 +7,9 @@
 use std::collections::{BTreeMap, BTreeSet};
 
 use symphonia_core::errors::Result;
-use symphonia_core::io::{MediaSourceStream, ReadBytes, ScopedStream, SeekBuffered, SeekFrom, Seek};
+use symphonia_core::io::{
+    MediaSourceStream, ReadBytes, ScopedStream, Seek, SeekBuffered, SeekFrom,
+};
 
 use super::logical::{InspectState, LogicalStream};
 use super::page::*;
diff --git a/symphonia-format-riff/src/common.rs b/symphonia-format-riff/src/common.rs
index 440522eb..b8d0d67f 100644
--- a/symphonia-format-riff/src/common.rs
+++ b/symphonia-format-riff/src/common.rs
@@ -12,8 +12,8 @@ use std::marker::PhantomData;
 use symphonia_core::audio::Channels;
 use symphonia_core::codecs::CodecParameters;
 use symphonia_core::codecs::CodecType;
-use symphonia_core::errors::{decode_error, end_of_stream_error, Result};
 use symphonia_core::errors::SymphoniaError as Error;
+use symphonia_core::errors::{decode_error, end_of_stream_error, Result};
 use symphonia_core::formats::prelude::*;
 use symphonia_core::io::{MediaSourceStream, ReadBytes};
 
diff --git a/symphonia-format-wav/src/chunks.rs b/symphonia-format-wav/src/chunks.rs
index 2d2b8129..b556b969 100644
--- a/symphonia-format-wav/src/chunks.rs
+++ b/symphonia-format-wav/src/chunks.rs
@@ -5,8 +5,8 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use alloc::vec;
 use alloc::string::String;
+use alloc::vec;
 use std::fmt;
 use std::marker::PhantomData;
 
@@ -17,8 +17,8 @@ use symphonia_core::codecs::{
     CODEC_TYPE_PCM_F64LE, CODEC_TYPE_PCM_MULAW, CODEC_TYPE_PCM_S16LE, CODEC_TYPE_PCM_S24LE,
     CODEC_TYPE_PCM_S32LE, CODEC_TYPE_PCM_U8,
 };
-use symphonia_core::errors::{decode_error, unsupported_error, Result};
 use symphonia_core::errors::SymphoniaError as Error;
+use symphonia_core::errors::{decode_error, unsupported_error, Result};
 use symphonia_core::io::ReadBytes;
 use symphonia_core::meta::Tag;
 use symphonia_metadata::riff;
diff --git a/symphonia-format-wav/src/lib.rs b/symphonia-format-wav/src/lib.rs
index 52b11cd0..059fa7f0 100644
--- a/symphonia-format-wav/src/lib.rs
+++ b/symphonia-format-wav/src/lib.rs
@@ -15,15 +15,15 @@
 #![allow(clippy::identity_op)]
 #![allow(clippy::manual_range_contains)]
 
-#[cfg(not(feature="std"))]
+#[cfg(not(feature = "std"))]
 extern crate core as std;
 
 extern crate alloc;
 
-use alloc::vec;
-use alloc::vec::Vec;
 use alloc::boxed::Box;
 use alloc::string::String;
+use alloc::vec;
+use alloc::vec::Vec;
 
 use symphonia_core::codecs::CodecParameters;
 use symphonia_core::errors::{decode_error, end_of_stream_error, seek_error, unsupported_error};
diff --git a/symphonia-metadata/src/id3v2/frames.rs b/symphonia-metadata/src/id3v2/frames.rs
index a54261d2..f8bc6b8d 100644
--- a/symphonia-metadata/src/id3v2/frames.rs
+++ b/symphonia-metadata/src/id3v2/frames.rs
@@ -5,11 +5,11 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 use alloc::borrow::Cow;
-use alloc::{format, vec};
 use alloc::boxed::Box;
 use alloc::collections::BTreeMap;
 use alloc::string::{String, ToString};
 use alloc::vec::Vec;
+use alloc::{format, vec};
 use core::str;
 
 use symphonia_core::errors::{decode_error, unsupported_error, Result};
diff --git a/symphonia-metadata/src/itunes.rs b/symphonia-metadata/src/itunes.rs
index 793c2fc1..5f716514 100644
--- a/symphonia-metadata/src/itunes.rs
+++ b/symphonia-metadata/src/itunes.rs
@@ -10,7 +10,6 @@
 use alloc::collections::BTreeMap;
 use symphonia_core::meta::StandardTagKey;
 
-
 use lazy_static::lazy_static;
 
 lazy_static! {
diff --git a/symphonia-metadata/src/lib.rs b/symphonia-metadata/src/lib.rs
index 364931a7..134cf546 100644
--- a/symphonia-metadata/src/lib.rs
+++ b/symphonia-metadata/src/lib.rs
@@ -6,7 +6,6 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 #![no_std]
-
 #![warn(rust_2018_idioms)]
 #![forbid(unsafe_code)]
 // The following lints are allowed in all Symphonia crates. Please see clippy.toml for their
diff --git a/symphonia-utils-xiph/src/flac/metadata.rs b/symphonia-utils-xiph/src/flac/metadata.rs
index 2c11d713..00e23b0a 100644
--- a/symphonia-utils-xiph/src/flac/metadata.rs
+++ b/symphonia-utils-xiph/src/flac/metadata.rs
@@ -16,7 +16,9 @@ use symphonia_core::errors::{decode_error, Result};
 use symphonia_core::formats::util::SeekIndex;
 use symphonia_core::formats::{Cue, CuePoint};
 use symphonia_core::io::*;
-use symphonia_core::meta::{ColorMode, MetadataBuilder, Size, StandardTagKey, StandardVisualKey, Tag, Value};
+use symphonia_core::meta::{
+    ColorMode, MetadataBuilder, Size, StandardTagKey, StandardVisualKey, Tag, Value,
+};
 use symphonia_core::meta::{VendorData, Visual};
 
 use symphonia_metadata::vorbis;
@@ -491,7 +493,6 @@ pub fn read_picture_block<B: ReadBytes>(
     Ok(())
 }
 
-
 /// Try to get a `StandardVisualKey` from the APIC picture type identifier.
 pub fn apic_picture_type_to_visual_key(apic: u32) -> Option<StandardVisualKey> {
     match apic {
@@ -518,7 +519,6 @@ pub fn apic_picture_type_to_visual_key(apic: u32) -> Option<StandardVisualKey> {
     }
 }
 
-
 pub struct MetadataBlockHeader {
     pub is_last: bool,
     pub block_type: MetadataBlockType,
diff --git a/symphonia-utils-xiph/src/lib.rs b/symphonia-utils-xiph/src/lib.rs
index fd0b54bc..01606989 100644
--- a/symphonia-utils-xiph/src/lib.rs
+++ b/symphonia-utils-xiph/src/lib.rs
@@ -11,7 +11,6 @@
 #![allow(clippy::excessive_precision)]
 #![allow(clippy::identity_op)]
 #![allow(clippy::manual_range_contains)]
-
 #![no_std]
 
 extern crate alloc;
diff --git a/symphonia/src/lib.rs b/symphonia/src/lib.rs
index 2229f0d9..45f3b744 100644
--- a/symphonia/src/lib.rs
+++ b/symphonia/src/lib.rs
@@ -261,7 +261,6 @@ pub mod default {
     ///
     /// Use this function to easily populate a custom probe with all enabled formats.
     pub fn register_enabled_formats(probe: &mut Probe) {
-
         // Formats
         #[cfg(feature = "aac")]
         probe.register_all::<formats::AdtsReader>();

From 803525d936f0dd5e4fd455e94f2a9936b6b76af9 Mon Sep 17 00:00:00 2001
From: atok <atoktoto@fastmail.fm>
Date: Sat, 13 Jan 2024 08:39:44 +0100
Subject: [PATCH 22/22] Contributors, Remove unnecessary imports, remove
 unnecessary changes, Fix tests

---
 CONTRIBUTORS                              |  1 +
 symphonia-codec-aac/tests/tests.rs        |  2 +-
 symphonia-codec-pcm/src/lib.rs            |  3 ---
 symphonia-core/src/errors.rs              |  2 +-
 symphonia-core/src/io/mod.rs              | 13 ---------
 symphonia-metadata/Cargo.toml             |  5 ++--
 symphonia-metadata/src/lib.rs             |  2 --
 symphonia-utils-xiph/src/flac/metadata.rs | 32 +++--------------------
 symphonia/Cargo.toml                      |  2 --
 symphonia/examples/basic-interleaved.rs   |  2 +-
 symphonia/examples/getting-started.rs     |  4 +--
 symphonia/src/lib.rs                      |  5 ++--
 12 files changed, 14 insertions(+), 59 deletions(-)

diff --git a/CONTRIBUTORS b/CONTRIBUTORS
index 8521175a..8efbc794 100644
--- a/CONTRIBUTORS
+++ b/CONTRIBUTORS
@@ -17,6 +17,7 @@ Thom Chiovoloni <chiovolonit@gmail.com>
 # Please keep this section sorted in ascending order.
 
 aschey [https://github.com/aschey]
+atoktoto [https://github.com/atoktoto]
 BlackHoleFox [https://github.com/blackholefox]
 darksv [https://github.com/darksv]
 dedobbin [https://github.com/dedobbin]
diff --git a/symphonia-codec-aac/tests/tests.rs b/symphonia-codec-aac/tests/tests.rs
index 6f2e3c89..7ba3d3ea 100644
--- a/symphonia-codec-aac/tests/tests.rs
+++ b/symphonia-codec-aac/tests/tests.rs
@@ -31,5 +31,5 @@ fn invalid_channels_aac() {
 
     let err = test_decode(file).unwrap_err();
 
-    assert!(matches!(err, errors::Error::Unsupported(_)));
+    assert!(matches!(err, errors::SymphoniaError::Unsupported(_)));
 }
diff --git a/symphonia-codec-pcm/src/lib.rs b/symphonia-codec-pcm/src/lib.rs
index 355ab907..5e25bf5b 100644
--- a/symphonia-codec-pcm/src/lib.rs
+++ b/symphonia-codec-pcm/src/lib.rs
@@ -15,9 +15,6 @@
 #![allow(clippy::identity_op)]
 #![allow(clippy::manual_range_contains)]
 
-#[cfg(not(std))]
-extern crate core as std;
-
 extern crate alloc;
 
 use symphonia_core::support_codec;
diff --git a/symphonia-core/src/errors.rs b/symphonia-core/src/errors.rs
index 021d857c..42be564a 100644
--- a/symphonia-core/src/errors.rs
+++ b/symphonia-core/src/errors.rs
@@ -65,7 +65,7 @@ pub enum SymphoniaError {
     Other(&'static str),
 }
 
-impl fmt::Display for SymphoniaError {
+impl Display for SymphoniaError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             SymphoniaError::IoError(ref err) => {
diff --git a/symphonia-core/src/io/mod.rs b/symphonia-core/src/io/mod.rs
index a109ee6f..1e088c93 100644
--- a/symphonia-core/src/io/mod.rs
+++ b/symphonia-core/src/io/mod.rs
@@ -51,21 +51,8 @@ pub trait Seek {
 }
 
 pub enum SeekFrom {
-    /// Sets the offset to the provided number of bytes.
     Start(u64),
-
-    /// Sets the offset to the size of this object plus the specified number of
-    /// bytes.
-    ///
-    /// It is possible to seek beyond the end of an object, but it's an error to
-    /// seek before byte 0.
     End(i64),
-
-    /// Sets the offset to the current position plus the specified number of
-    /// bytes.
-    ///
-    /// It is possible to seek beyond the end of an object, but it's an error to
-    /// seek before byte 0.
     Current(i64),
 }
 
diff --git a/symphonia-metadata/Cargo.toml b/symphonia-metadata/Cargo.toml
index c6cb3389..fbdaadb9 100644
--- a/symphonia-metadata/Cargo.toml
+++ b/symphonia-metadata/Cargo.toml
@@ -13,12 +13,11 @@ edition = "2018"
 rust-version = "1.53"
 
 [dependencies]
-encoding_rs = { version = "0.8.17", optional = true }
+encoding_rs = "0.8.17"
 lazy_static = "1.4.0"
 log = "0.4"
 symphonia-core = { version = "0.5.2", path = "../symphonia-core", default-features = false }
 
 [features]
 std = ["symphonia-core/std"]
-default = ["std", "id3v2"]
-id3v2 = ["encoding_rs"]
\ No newline at end of file
+default = ["std"]
\ No newline at end of file
diff --git a/symphonia-metadata/src/lib.rs b/symphonia-metadata/src/lib.rs
index 134cf546..16cc582f 100644
--- a/symphonia-metadata/src/lib.rs
+++ b/symphonia-metadata/src/lib.rs
@@ -18,9 +18,7 @@
 extern crate alloc;
 
 pub mod id3v1;
-#[cfg(feature = "id3v2")]
 pub mod id3v2;
-
 pub mod itunes;
 pub mod riff;
 pub mod vorbis;
diff --git a/symphonia-utils-xiph/src/flac/metadata.rs b/symphonia-utils-xiph/src/flac/metadata.rs
index 00e23b0a..bdf7f3a0 100644
--- a/symphonia-utils-xiph/src/flac/metadata.rs
+++ b/symphonia-utils-xiph/src/flac/metadata.rs
@@ -17,11 +17,11 @@ use symphonia_core::formats::util::SeekIndex;
 use symphonia_core::formats::{Cue, CuePoint};
 use symphonia_core::io::*;
 use symphonia_core::meta::{
-    ColorMode, MetadataBuilder, Size, StandardTagKey, StandardVisualKey, Tag, Value,
+    ColorMode, MetadataBuilder, Size, StandardTagKey, Tag, Value,
 };
 use symphonia_core::meta::{VendorData, Visual};
 
-use symphonia_metadata::vorbis;
+use symphonia_metadata::{id3v2, vorbis};
 
 #[derive(PartialEq, Eq)]
 pub enum MetadataBlockType {
@@ -485,7 +485,7 @@ pub fn read_picture_block<B: ReadBytes>(
         dimensions,
         bits_per_pixel,
         color_mode,
-        usage: apic_picture_type_to_visual_key(type_enc),
+        usage: id3v2::util::apic_picture_type_to_visual_key(type_enc),
         tags,
         data,
     });
@@ -493,32 +493,6 @@ pub fn read_picture_block<B: ReadBytes>(
     Ok(())
 }
 
-/// Try to get a `StandardVisualKey` from the APIC picture type identifier.
-pub fn apic_picture_type_to_visual_key(apic: u32) -> Option<StandardVisualKey> {
-    match apic {
-        0x01 => Some(StandardVisualKey::FileIcon),
-        0x02 => Some(StandardVisualKey::OtherIcon),
-        0x03 => Some(StandardVisualKey::FrontCover),
-        0x04 => Some(StandardVisualKey::BackCover),
-        0x05 => Some(StandardVisualKey::Leaflet),
-        0x06 => Some(StandardVisualKey::Media),
-        0x07 => Some(StandardVisualKey::LeadArtistPerformerSoloist),
-        0x08 => Some(StandardVisualKey::ArtistPerformer),
-        0x09 => Some(StandardVisualKey::Conductor),
-        0x0a => Some(StandardVisualKey::BandOrchestra),
-        0x0b => Some(StandardVisualKey::Composer),
-        0x0c => Some(StandardVisualKey::Lyricist),
-        0x0d => Some(StandardVisualKey::RecordingLocation),
-        0x0e => Some(StandardVisualKey::RecordingSession),
-        0x0f => Some(StandardVisualKey::Performance),
-        0x10 => Some(StandardVisualKey::ScreenCapture),
-        0x12 => Some(StandardVisualKey::Illustration),
-        0x13 => Some(StandardVisualKey::BandArtistLogo),
-        0x14 => Some(StandardVisualKey::PublisherStudioLogo),
-        _ => None,
-    }
-}
-
 pub struct MetadataBlockHeader {
     pub is_last: bool,
     pub block_type: MetadataBlockType,
diff --git a/symphonia/Cargo.toml b/symphonia/Cargo.toml
index 3818f1bd..fc2daa94 100644
--- a/symphonia/Cargo.toml
+++ b/symphonia/Cargo.toml
@@ -35,8 +35,6 @@ aiff = ["symphonia-format-riff"]
 vorbis = ["symphonia-codec-vorbis"]
 wav = ["symphonia-format-wav"]
 
-id3v2 = ["symphonia-metadata/id3v2"]
-
 # MPEG audio codecs.
 mpa = ["mp1", "mp2", "mp3"]
 
diff --git a/symphonia/examples/basic-interleaved.rs b/symphonia/examples/basic-interleaved.rs
index b248abc0..7cc0cea2 100644
--- a/symphonia/examples/basic-interleaved.rs
+++ b/symphonia/examples/basic-interleaved.rs
@@ -4,7 +4,7 @@ use std::path::Path;
 
 use symphonia::core::audio::SampleBuffer;
 use symphonia::core::codecs::DecoderOptions;
-use symphonia::core::errors::Error;
+use symphonia::core::errors::SymphoniaError as Error;
 use symphonia::core::formats::FormatOptions;
 use symphonia::core::io::MediaSourceStream;
 use symphonia::core::meta::MetadataOptions;
diff --git a/symphonia/examples/getting-started.rs b/symphonia/examples/getting-started.rs
index 064ac404..580c5d19 100644
--- a/symphonia/examples/getting-started.rs
+++ b/symphonia/examples/getting-started.rs
@@ -1,5 +1,5 @@
 use symphonia::core::codecs::{DecoderOptions, CODEC_TYPE_NULL};
-use symphonia::core::errors::Error;
+use symphonia::core::errors::SymphoniaError as Error;
 use symphonia::core::formats::FormatOptions;
 use symphonia::core::io::MediaSourceStream;
 use symphonia::core::meta::MetadataOptions;
@@ -86,7 +86,7 @@ fn main() {
             Ok(_decoded) => {
                 // Consume the decoded audio samples (see below).
             }
-            Err(Error::IoError(_, _)) => {
+            Err(Error::IoError(_)) => {
                 // The packet failed to decode due to an IO error, skip the packet.
                 continue;
             }
diff --git a/symphonia/src/lib.rs b/symphonia/src/lib.rs
index 45f3b744..e03e2f72 100644
--- a/symphonia/src/lib.rs
+++ b/symphonia/src/lib.rs
@@ -261,6 +261,8 @@ pub mod default {
     ///
     /// Use this function to easily populate a custom probe with all enabled formats.
     pub fn register_enabled_formats(probe: &mut Probe) {
+        use symphonia_metadata::id3v2::Id3v2Reader;
+
         // Formats
         #[cfg(feature = "aac")]
         probe.register_all::<formats::AdtsReader>();
@@ -287,8 +289,7 @@ pub mod default {
         probe.register_all::<formats::MkvReader>();
 
         // Metadata
-        #[cfg(feature = "id3v2")]
-        probe.register_all::<symphonia_metadata::id3v2::Id3v2Reader>();
+        probe.register_all::<Id3v2Reader>();
     }
 }