aud_io: Move AtomInfo and AtomIdent from lofty

Author: Serial-ATA

aud_io/src/error.rs

@@ -8,10 +8,20 @@ pub enum AudioError {
 	// File data related errors
 	/// Attempting to read/write an abnormally large amount of data
 	TooMuchData,
+	/// Expected the data to be a different size than provided
+	///
+	/// This occurs when the size of an item is written as one value, but that size is either too
+	/// big or small to be valid within the bounds of that item.
+	// TODO: Should probably have context
+	SizeMismatch,
 
 	/// Errors that arise while decoding text
 	TextDecode(&'static str),
 
+	// Format-specific
+	/// Arises when an MP4 atom contains invalid data
+	BadAtom(&'static str),
+	
 	// Conversions for external errors
 	/// Represents all cases of [`std::io::Error`].
 	Io(std::io::Error),
@@ -72,6 +82,13 @@ impl Display for AudioError {
 				f,
 				"Attempted to read/write an abnormally large amount of data"
 			),
+			AudioError::SizeMismatch => write!(
+				f,
+				"Encountered an invalid item size, either too big or too small to be valid"
+			),
+			
+			// Format-specific
+			AudioError::BadAtom(message) => write!(f, "MP4 Atom: {message}"),
 		}
 	}
 }

aud_io/src/lib.rs

@@ -5,3 +5,4 @@ pub mod math;
 pub mod io;
 pub mod config;
 pub mod alloc;
+pub mod mp4;

aud_io/src/macros.rs

@@ -1,3 +1,8 @@
+#[macro_export]
+macro_rules! try_vec {
+	($elem:expr; $size:expr) => {{ $crate::alloc::fallible_vec_from_element($elem, $size)? }};
+}
+
 // Shorthand for `return Err(AudioError::Foo)`
 //
 // Usage:

lofty/src/mp4/atom_info.rs renamed to aud_io/src/mp4/atom_info.rs

@@ -1,18 +1,16 @@
 use crate::config::ParsingMode;
-use crate::error::{ErrorKind, LoftyError, Result};
-use crate::macros::{err, try_vec};
-use crate::tag::{ItemKey, TagType};
+use crate::error::{AudioError, Result};
+use crate::text::utf8_decode;
+use crate::{err, try_vec};
 
 use std::borrow::Cow;
 use std::io::{Read, Seek, SeekFrom};
 
-use aud_io::text::utf8_decode;
-use aud_io::err as io_err;
 use byteorder::{BigEndian, ReadBytesExt};
 
-pub(super) const FOURCC_LEN: u64 = 4;
-pub(super) const IDENTIFIER_LEN: u64 = 4;
-pub(super) const ATOM_HEADER_LEN: u64 = FOURCC_LEN + IDENTIFIER_LEN;
+pub const FOURCC_LEN: u64 = 4;
+pub const IDENTIFIER_LEN: u64 = 4;
+pub const ATOM_HEADER_LEN: u64 = FOURCC_LEN + IDENTIFIER_LEN;
 
 /// Represents an `MP4` atom identifier
 #[derive(Eq, PartialEq, Debug, Clone)]
@@ -64,55 +62,12 @@ impl<'a> AtomIdent<'a> {
 	}
 }
 
-impl<'a> TryFrom<&'a ItemKey> for AtomIdent<'a> {
-	type Error = LoftyError;
-
-	fn try_from(value: &'a ItemKey) -> std::result::Result<Self, Self::Error> {
-		if let Some(mapped_key) = value.map_key(TagType::Mp4Ilst) {
-			if mapped_key.starts_with("----") {
-				let mut split = mapped_key.split(':');
-
-				split.next();
-
-				let mean = split.next();
-				let name = split.next();
-
-				if let (Some(mean), Some(name)) = (mean, name) {
-					return Ok(AtomIdent::Freeform {
-						mean: Cow::Borrowed(mean),
-						name: Cow::Borrowed(name),
-					});
-				}
-			} else {
-				let fourcc = mapped_key.chars().map(|c| c as u8).collect::<Vec<_>>();
-
-				if let Ok(fourcc) = TryInto::<[u8; 4]>::try_into(fourcc) {
-					return Ok(AtomIdent::Fourcc(fourcc));
-				}
-			}
-		}
-
-		io_err!(TextDecode(
-			"ItemKey does not map to a freeform or fourcc identifier"
-		))
-	}
-}
-
-impl TryFrom<ItemKey> for AtomIdent<'static> {
-	type Error = LoftyError;
-
-	fn try_from(value: ItemKey) -> std::result::Result<Self, Self::Error> {
-		let ret: AtomIdent<'_> = (&value).try_into()?;
-		Ok(ret.into_owned())
-	}
-}
-
 #[derive(Debug)]
-pub(crate) struct AtomInfo {
-	pub(crate) start: u64,
-	pub(crate) len: u64,
-	pub(crate) extended: bool,
-	pub(crate) ident: AtomIdent<'static>,
+pub struct AtomInfo {
+	pub start: u64,
+	pub len: u64,
+	pub extended: bool,
+	pub ident: AtomIdent<'static>,
 }
 
 // The spec permits any characters to be used in atom identifiers. This doesn't
@@ -125,7 +80,7 @@ fn is_valid_identifier_byte(b: u8) -> bool {
 }
 
 impl AtomInfo {
-	pub(crate) fn read<R>(
+	pub fn read<R>(
 		data: &mut R,
 		mut reader_size: u64,
 		parse_mode: ParsingMode,
@@ -214,7 +169,7 @@ impl AtomInfo {
 		}))
 	}
 
-	pub(crate) fn header_size(&self) -> u64 {
+	pub fn header_size(&self) -> u64 {
 		if !self.extended {
 			return ATOM_HEADER_LEN;
 		}
@@ -261,10 +216,10 @@ where
 
 	match atom {
 		Some(AtomInfo {
-			ident: AtomIdent::Fourcc(ref fourcc),
-			len,
-			..
-		}) if fourcc == name => {
+				 ident: AtomIdent::Fourcc(ref fourcc),
+				 len,
+				 ..
+			 }) if fourcc == name => {
 			if len < 12 {
 				err!(BadAtom("Found an incomplete freeform identifier chunk"));
 			}
@@ -284,9 +239,9 @@ where
 			*reader_size -= len;
 
 			utf8_decode(content).map_err(|_| {
-				LoftyError::new(ErrorKind::BadAtom(
+				AudioError::BadAtom(
 					"Found a non UTF-8 string while reading freeform identifier",
-				))
+				)
 			})
 		},
 		_ => err!(BadAtom(

aud_io/src/mp4/mod.rs

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

lofty/src/mp4/ilst/mod.rs

@@ -24,6 +24,7 @@ use std::borrow::Cow;
 use std::io::Write;
 use std::ops::Deref;
 
+use aud_io::err as io_err;
 use aud_io::io::{FileLike, Length, Truncate};
 use lofty_attr::tag;
 
@@ -885,6 +886,49 @@ impl From<Tag> for Ilst {
 	}
 }
 
+impl<'a> TryFrom<&'a ItemKey> for AtomIdent<'a> {
+	type Error = LoftyError;
+
+	fn try_from(value: &'a ItemKey) -> std::result::Result<Self, Self::Error> {
+		if let Some(mapped_key) = value.map_key(TagType::Mp4Ilst) {
+			if mapped_key.starts_with("----") {
+				let mut split = mapped_key.split(':');
+
+				split.next();
+
+				let mean = split.next();
+				let name = split.next();
+
+				if let (Some(mean), Some(name)) = (mean, name) {
+					return Ok(AtomIdent::Freeform {
+						mean: Cow::Borrowed(mean),
+						name: Cow::Borrowed(name),
+					});
+				}
+			} else {
+				let fourcc = mapped_key.chars().map(|c| c as u8).collect::<Vec<_>>();
+
+				if let Ok(fourcc) = TryInto::<[u8; 4]>::try_into(fourcc) {
+					return Ok(AtomIdent::Fourcc(fourcc));
+				}
+			}
+		}
+
+		io_err!(TextDecode(
+			"ItemKey does not map to a freeform or fourcc identifier"
+		))
+	}
+}
+
+impl TryFrom<ItemKey> for AtomIdent<'static> {
+	type Error = LoftyError;
+
+	fn try_from(value: ItemKey) -> std::result::Result<Self, Self::Error> {
+		let ret: AtomIdent<'_> = (&value).try_into()?;
+		Ok(ret.into_owned())
+	}
+}
+
 #[cfg(test)]
 mod tests {
 	use crate::config::{ParseOptions, ParsingMode, WriteOptions};

lofty/src/mp4/ilst/read.rs

@@ -5,7 +5,6 @@ use crate::config::{ParseOptions, ParsingMode};
 use crate::error::{LoftyError, Result};
 use crate::id3::v1::constants::GENRES;
 use crate::macros::{err, try_vec};
-use crate::mp4::atom_info::{ATOM_HEADER_LEN, AtomInfo};
 use crate::mp4::ilst::atom::AtomDataStorage;
 use crate::mp4::read::{AtomReader, skip_atom};
 use crate::picture::{MimeType, Picture, PictureType};
@@ -15,6 +14,7 @@ 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};
 
 pub(in crate::mp4) fn parse_ilst<R>(
 	reader: &mut AtomReader<R>,

lofty/src/mp4/ilst/write.rs

@@ -5,14 +5,14 @@ use crate::error::{FileEncodingError, LoftyError, Result};
 use crate::file::FileType;
 use crate::macros::{decode_err, try_vec};
 use crate::mp4::AtomData;
-use crate::mp4::atom_info::{ATOM_HEADER_LEN, AtomIdent, AtomInfo, FOURCC_LEN};
 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::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::err as io_err;
 use aud_io::io::{FileLike, Length, Truncate};
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};

lofty/src/mp4/mod.rs

@@ -3,7 +3,6 @@
 //! ## File notes
 //!
 //! The only supported tag format is [`Ilst`].
-mod atom_info;
 pub(crate) mod ilst;
 mod moov;
 mod properties;
@@ -22,7 +21,7 @@ pub mod constants {
 }
 
 pub use crate::mp4::properties::{AudioObjectType, Mp4Codec, Mp4Properties};
-pub use atom_info::AtomIdent;
+pub use aud_io::mp4::AtomIdent;
 pub use ilst::Ilst;
 pub use ilst::advisory_rating::AdvisoryRating;
 pub use ilst::atom::{Atom, AtomData};

lofty/src/mp4/moov.rs

@@ -1,4 +1,3 @@
-use super::atom_info::{AtomIdent, AtomInfo};
 use super::ilst::Ilst;
 use super::ilst::read::parse_ilst;
 use super::read::{AtomReader, find_child_atom, meta_is_full, skip_atom};
@@ -8,6 +7,8 @@ use crate::macros::decode_err;
 
 use std::io::{Read, Seek};
 
+use aud_io::mp4::{AtomIdent, AtomInfo};
+
 pub(crate) struct Moov {
 	// Represents the trak.mdia atom
 	pub(crate) traks: Vec<AtomInfo>,