aud_io: Move AtomReader from lofty

Author: Serial-ATA

aud_io/src/io.rs

@@ -229,3 +229,19 @@ where
 		Ok(F80::from_be_bytes(bytes))
 	}
 }
+
+/// Stable version of [`Seek::stream_len()`]
+pub trait SeekStreamLen: Seek {
+	fn stream_len_hack(&mut self) -> Result<u64> {
+		use std::io::SeekFrom;
+
+		let current_pos = self.stream_position()?;
+		let len = self.seek(SeekFrom::End(0))?;
+
+		self.seek(SeekFrom::Start(current_pos))?;
+
+		Ok(len)
+	}
+}
+
+impl<T> SeekStreamLen for T where T: Seek {}

lofty/src/mp4/read/atom_reader.rs renamed to aud_io/src/mp4/atom_reader.rs

@@ -1,11 +1,11 @@
 use crate::config::ParsingMode;
 use crate::error::Result;
-use crate::macros::err;
-use crate::util::io::SeekStreamLen;
+use super::atom_info::AtomInfo;
+use crate::err;
+use crate::io::SeekStreamLen;
 
 use std::io::{Read, Seek, SeekFrom};
 
-use aud_io::mp4::AtomInfo;
 use byteorder::{BigEndian, ReadBytesExt};
 
 /// A reader for an MP4 file
@@ -15,7 +15,7 @@ use byteorder::{BigEndian, ReadBytesExt};
 /// * [`Self::next`] to read atoms.
 /// * `read_u*` methods to read integers without needing to specify the endianness.
 /// * Bounds checking on reads and seeks to prevent going outside the file.
-pub(crate) struct AtomReader<R>
+pub struct AtomReader<R>
 where
 	R: Read + Seek,
 {
@@ -31,7 +31,7 @@ where
 	R: Read + Seek,
 {
 	/// Create a new `AtomReader`
-	pub(crate) fn new(mut reader: R, parse_mode: ParsingMode) -> Result<Self> {
+	pub fn new(mut reader: R, parse_mode: ParsingMode) -> Result<Self> {
 		let len = reader.stream_len_hack()?;
 		Ok(Self {
 			reader,
@@ -47,46 +47,46 @@ where
 	/// This is useful when reading an atom such as `moov`, where we only want to read it and its
 	/// children. We can read the atom, set the bounds to the atom's length, and then read the children
 	/// without worrying about reading past the atom's end.
-	pub(crate) fn reset_bounds(&mut self, start_position: u64, len: u64) {
+	pub fn reset_bounds(&mut self, start_position: u64, len: u64) {
 		self.start = start_position;
 		self.remaining_size = len;
 		self.len = len;
 	}
 
-	pub(crate) fn read_u8(&mut self) -> std::io::Result<u8> {
+	pub fn read_u8(&mut self) -> std::io::Result<u8> {
 		self.remaining_size = self.remaining_size.saturating_sub(1);
 		self.reader.read_u8()
 	}
 
-	pub(crate) fn read_u16(&mut self) -> std::io::Result<u16> {
+	pub fn read_u16(&mut self) -> std::io::Result<u16> {
 		self.remaining_size = self.remaining_size.saturating_sub(2);
 		self.reader.read_u16::<BigEndian>()
 	}
 
-	pub(crate) fn read_u24(&mut self) -> std::io::Result<u32> {
+	pub fn read_u24(&mut self) -> std::io::Result<u32> {
 		self.remaining_size = self.remaining_size.saturating_sub(3);
 		self.reader.read_u24::<BigEndian>()
 	}
 
-	pub(crate) fn read_u32(&mut self) -> std::io::Result<u32> {
+	pub fn read_u32(&mut self) -> std::io::Result<u32> {
 		self.remaining_size = self.remaining_size.saturating_sub(4);
 		self.reader.read_u32::<BigEndian>()
 	}
 
-	pub(crate) fn read_u64(&mut self) -> std::io::Result<u64> {
+	pub fn read_u64(&mut self) -> std::io::Result<u64> {
 		self.remaining_size = self.remaining_size.saturating_sub(8);
 		self.reader.read_u64::<BigEndian>()
 	}
 
-	pub(crate) fn read_uint(&mut self, size: usize) -> std::io::Result<u64> {
+	pub fn read_uint(&mut self, size: usize) -> std::io::Result<u64> {
 		self.remaining_size = self.remaining_size.saturating_sub(size as u64);
 		self.reader.read_uint::<BigEndian>(size)
 	}
 
 	/// Read the next atom in the file
 	///
 	/// This will leave the reader at the beginning of the atom content.
-	pub(crate) fn next(&mut self) -> Result<Option<AtomInfo>> {
+	pub fn next(&mut self) -> Result<Option<AtomInfo>> {
 		if self.remaining_size == 0 {
 			return Ok(None);
 		}
@@ -98,7 +98,7 @@ where
 		AtomInfo::read(self, self.remaining_size, self.parse_mode).map_err(Into::into)
 	}
 
-	pub(crate) fn into_inner(self) -> R {
+	pub fn into_inner(self) -> R {
 		self.reader
 	}
 }

aud_io/src/mp4/mod.rs

@@ -1,2 +1,5 @@
 mod atom_info;
 pub use atom_info::*;
+
+mod atom_reader;
+pub use atom_reader::*;

lofty/src/mp4/ilst/mod.rs

@@ -934,7 +934,6 @@ mod tests {
 	use crate::config::{ParseOptions, ParsingMode, WriteOptions};
 	use crate::mp4::ilst::TITLE;
 	use crate::mp4::ilst::atom::AtomDataStorage;
-	use crate::mp4::read::AtomReader;
 	use crate::mp4::{AdvisoryRating, Atom, AtomData, AtomIdent, DataType, Ilst, Mp4File};
 	use crate::picture::{MimeType, Picture, PictureType};
 	use crate::prelude::*;
@@ -944,6 +943,8 @@ mod tests {
 
 	use std::io::{Cursor, Read as _, Seek as _, Write as _};
 
+	use aud_io::mp4::AtomReader;
+
 	fn read_ilst(path: &str, parse_options: ParseOptions) -> Ilst {
 		let tag = std::fs::read(path).unwrap();
 		read_ilst_raw(&tag, parse_options)

lofty/src/mp4/ilst/read.rs

@@ -6,15 +6,15 @@ use crate::error::{LoftyError, Result};
 use crate::id3::v1::constants::GENRES;
 use crate::macros::{err, try_vec};
 use crate::mp4::ilst::atom::AtomDataStorage;
-use crate::mp4::read::{AtomReader, skip_atom};
+use crate::mp4::read::skip_atom;
 use crate::picture::{MimeType, Picture, PictureType};
 use crate::tag::TagExt;
 
 use std::borrow::Cow;
 use std::io::{Cursor, Read, Seek, SeekFrom};
 
 use aud_io::text::{utf8_decode, utf16_decode_bytes};
-use aud_io::mp4::{ATOM_HEADER_LEN, AtomInfo};
+use aud_io::mp4::{ATOM_HEADER_LEN, AtomInfo, AtomReader};
 
 pub(in crate::mp4) fn parse_ilst<R>(
 	reader: &mut AtomReader<R>,

lofty/src/mp4/ilst/write.rs

@@ -6,13 +6,13 @@ use crate::file::FileType;
 use crate::macros::{decode_err, try_vec};
 use crate::mp4::AtomData;
 use crate::mp4::ilst::r#ref::AtomRef;
-use crate::mp4::read::{AtomReader, atom_tree, find_child_atom, meta_is_full, verify_mp4};
+use crate::mp4::read::{atom_tree, find_child_atom, meta_is_full, verify_mp4};
 use crate::mp4::write::{AtomWriter, AtomWriterCompanion, ContextualAtom};
 use crate::picture::{MimeType, Picture};
 
 use std::io::{Cursor, Seek, SeekFrom, Write};
 
-use aud_io::mp4::{ATOM_HEADER_LEN, AtomIdent, AtomInfo, FOURCC_LEN};
+use aud_io::mp4::{AtomReader, ATOM_HEADER_LEN, AtomIdent, AtomInfo, FOURCC_LEN};
 use aud_io::err as io_err;
 use aud_io::io::{FileLike, Length, Truncate};
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};

lofty/src/mp4/moov.rs

@@ -1,13 +1,13 @@
 use super::ilst::Ilst;
 use super::ilst::read::parse_ilst;
-use super::read::{AtomReader, find_child_atom, meta_is_full, skip_atom};
+use super::read::{find_child_atom, meta_is_full, skip_atom};
 use crate::config::ParseOptions;
 use crate::error::Result;
 use crate::macros::decode_err;
 
 use std::io::{Read, Seek};
 
-use aud_io::mp4::{AtomIdent, AtomInfo};
+use aud_io::mp4::{AtomReader, AtomIdent, AtomInfo};
 
 pub(crate) struct Moov {
 	// Represents the trak.mdia atom

lofty/src/mp4/properties.rs

@@ -1,4 +1,4 @@
-use super::read::{AtomReader, find_child_atom, skip_atom};
+use super::read::{find_child_atom, skip_atom};
 use crate::config::ParsingMode;
 use crate::error::{LoftyError, Result};
 use crate::macros::{decode_err, err, try_vec};
@@ -7,7 +7,7 @@ use crate::properties::FileProperties;
 use std::io::{Cursor, Read, Seek, SeekFrom};
 use std::time::Duration;
 
-use aud_io::mp4::{AtomIdent, AtomInfo};
+use aud_io::mp4::{AtomReader, AtomIdent, AtomInfo};
 use aud_io::alloc::VecFallibleCapacity;
 use aud_io::math::RoundedDivision;
 use byteorder::{BigEndian, ReadBytesExt};

lofty/src/mp4/read/mod.rs renamed to lofty/src/mp4/read.rs

@@ -1,5 +1,3 @@
-mod atom_reader;
-
 use super::Mp4File;
 use super::moov::Moov;
 use super::properties::Mp4Properties;
@@ -10,13 +8,11 @@ use crate::util::io::SeekStreamLen;
 
 use std::io::{Read, Seek, SeekFrom};
 
-use aud_io::mp4::{AtomIdent, AtomInfo};
+use aud_io::mp4::{AtomIdent, AtomInfo, AtomReader};
 use aud_io::err as io_err;
 use aud_io::text::utf8_decode_str;
 use byteorder::{BigEndian, ReadBytesExt};
 
-pub(super) use atom_reader::AtomReader;
-
 pub(in crate::mp4) fn verify_mp4<R>(reader: &mut AtomReader<R>) -> Result<String>
 where
 	R: Read + Seek,