MP4: Create DataType enum, replacing constants

Author: Serial-ATA

lofty/src/mp4/ilst/atom.rs

@@ -1,5 +1,6 @@
 use crate::error::Result;
 use crate::macros::err;
+use crate::mp4::ilst::data_type::DataType;
 use crate::mp4::AtomIdent;
 use crate::picture::Picture;
 
@@ -213,7 +214,10 @@ impl<'a> Atom<'a> {
 	pub(crate) fn unknown_implicit(ident: AtomIdent<'_>, data: Vec<u8>) -> Self {
 		Self {
 			ident: ident.into_owned(),
-			data: AtomDataStorage::Single(AtomData::Unknown { code: 0, data }),
+			data: AtomDataStorage::Single(AtomData::Unknown {
+				code: DataType::Reserved,
+				data,
+			}),
 		}
 	}
 
@@ -247,8 +251,7 @@ impl Debug for Atom<'_> {
 /// NOTES:
 ///
 /// * This only covers the most common data types.
-///   See the list of [well-known data types](https://developer.apple.com/library/archive/documentation/QuickTime/QTFF/Metadata/Metadata.html#//apple_ref/doc/uid/TP40000939-CH1-SW34)
-///   for codes.
+///   See the list of [DataType] for all known types.
 /// * There are only two variants for integers, which
 ///   will come from codes `21` and `22`. All other integer
 ///   types will be stored as [`AtomData::Unknown`], refer
@@ -290,51 +293,52 @@ pub enum AtomData {
 	/// variant.
 	Unknown {
 		/// The code, or type of the item
-		code: u32,
+		code: DataType,
 		/// The binary data of the atom
 		data: Vec<u8>,
 	},
 }
 
-/// The parental advisory rating
-///
-/// See also:
-/// <https://docs.mp3tag.de/mapping/#itunesadvisory>
-/// <https://exiftool.org/TagNames/QuickTime.html>
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum AdvisoryRating {
-	/// *Inoffensive*/*None* (0)
-	Inoffensive,
-	/// *Explicit* (1 or 4)
+impl AtomData {
+	/// Get the [`DataType`] of the atom
 	///
-	/// In the past Apple used the value 4 for explicit content
-	/// that has later been replaced by 1. Both values are considered
-	/// as valid when reading but only the newer value 1 is written.
-	Explicit,
-	/// *Clean*/*Edited* (2)
-	Clean,
-}
-
-impl AdvisoryRating {
-	/// Returns the rating as it appears in the `rtng` atom
-	pub fn as_u8(&self) -> u8 {
+	/// Note that for [`AtomData::Picture`], the type is determined by the picture's MIME type.
+	/// If the MIME type is unknown (or unset), the data type will be [`DataType::Reserved`].
+	///
+	/// # Examples
+	///
+	/// ```rust
+	/// use lofty::mp4::{AtomData, DataType};
+	/// use lofty::picture::{MimeType, Picture, PictureType};
+	///
+	/// let data = AtomData::UTF8(String::from("foo"));
+	/// assert_eq!(data.data_type(), DataType::Utf8);
+	///
+	/// let data = AtomData::SignedInteger(42);
+	/// assert_eq!(data.data_type(), DataType::BeSignedInteger);
+	///
+	/// let data = AtomData::Picture(Picture::new_unchecked(
+	/// 	PictureType::CoverFront,
+	/// 	Some(MimeType::Jpeg),
+	/// 	None,
+	/// 	Vec::new(),
+	/// ));
+	/// assert_eq!(data.data_type(), DataType::Jpeg);
+	/// ```
+	pub fn data_type(&self) -> DataType {
 		match self {
-			AdvisoryRating::Inoffensive => 0,
-			AdvisoryRating::Explicit => 1,
-			AdvisoryRating::Clean => 2,
-		}
-	}
-}
-
-impl TryFrom<u8> for AdvisoryRating {
-	type Error = u8;
-
-	fn try_from(input: u8) -> std::result::Result<Self, Self::Error> {
-		match input {
-			0 => Ok(Self::Inoffensive),
-			1 | 4 => Ok(Self::Explicit),
-			2 => Ok(Self::Clean),
-			value => Err(value),
+			AtomData::UTF8(_) => DataType::Utf8,
+			AtomData::UTF16(_) => DataType::Utf16,
+			AtomData::SignedInteger(_) | AtomData::Bool(_) => DataType::BeSignedInteger,
+			AtomData::UnsignedInteger(_) => DataType::BeUnsignedInteger,
+			AtomData::Picture(p) => {
+				let Some(mime) = p.mime_type() else {
+					return DataType::Reserved;
+				};
+
+				DataType::from(mime)
+			},
+			AtomData::Unknown { code, .. } => *code,
 		}
 	}
 }

lofty/src/mp4/ilst/data_type.rs

@@ -0,0 +1,200 @@
+use crate::picture::MimeType;
+
+/// The [well known] basic data types
+///
+/// This should cover all the data types you'll encounter in an MP4 file.
+///
+/// [well known]: https://developer.apple.com/documentation/quicktime-file-format/well-known_types
+// OLD LINKS:
+// * https://developer.apple.com/library/archive/documentation/QuickTime/QTFF/Metadata/Metadata.html#//apple_ref/doc/uid/TP40000939-CH1-SW35
+#[repr(u32)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum DataType {
+	/// Reserved for use where no type needs to be indicated
+	Reserved = 0,
+	/// UTF-8 string without any count or NULL terminator
+	Utf8 = 1,
+	/// A big-endian UTF-16 string
+	Utf16 = 2,
+	/// Deprecated unless it is needed for special Japanese characters
+	SJis = 3,
+	/// The UTF-8 variant storage of a string for sorting only
+	Utf8Sort = 4,
+	/// The UTF-16 variant storage of a string for sorting only
+	Utf16Sort = 5,
+	/// **DEPRECATED** A GIF image
+	Gif = 12,
+	/// A JPEG in a JFIF wrapper
+	Jpeg = 13,
+	/// A PNG in a PNG wrapper
+	Png = 14,
+	/// A big-endian signed integer in 1,2,3 or 4 bytes
+	BeSignedInteger = 21,
+	/// A big-endian unsigned integer in 1,2,3 or 4 bytes; size of value determines integer size
+	BeUnsignedInteger = 22,
+	/// A big-endian 32-bit floating point value (IEEE754)
+	BeFloat32 = 23,
+	/// A big-endian 64-bit floating point value (IEEE754)
+	BeFloat64 = 24,
+	/// Windows bitmap format graphics
+	Bmp = 27,
+	/// A QuickTime metadata atom
+	QuicktimeMetadata = 28,
+	/// An 8-bit signed integer
+	Signed8BitInteger = 65,
+	/// A big-endian 16-bit signed integer
+	Be16BitSignedInteger = 66,
+	/// A big-endian 32-bit signed integer
+	Be32BitSignedInteger = 67,
+	/// A block of data representing a two dimensional (2D) point with 32-bit big-endian floating point x and y coordinates. It has the structure:
+	///
+	/// ```c
+	/// struct {
+	///     BEFloat32 x;
+	///     BEFloat32 y;
+	/// }
+	/// ```
+	BePointF32 = 70,
+	/// A block of data representing 2D dimensions with 32-bit big-endian floating point width and height. It has the structure:
+	///
+	/// ```c
+	/// struct {
+	///     BEFloat32 width;
+	///     BEFloat32 height;
+	/// }
+	/// ```
+	BeDimensionsF32 = 71,
+	/// A block of data representing a 2D rectangle with 32-bit big-endian floating point x and y coordinates and a 32-bit big-endian floating point width and height size. It has the structure:
+	///
+	/// ```c
+	/// struct {
+	///     BEFloat32 x;
+	///     BEFloat32 y;
+	///     BEFloat32 width;
+	///     BEFloat32 height;
+	/// }
+	/// ```
+	///
+	/// or the equivalent structure:
+	///
+	/// ```c
+	/// struct {
+	///     PointF32 origin;
+	///     DimensionsF32 size;
+	/// }
+	/// ```
+	BeRectF32 = 72,
+	/// A big-endian 64-bit signed integer
+	Be64BitSignedInteger = 74,
+	/// An 8-bit unsigned integer
+	Unsigned8BitInteger = 75,
+	/// A big-endian 16-bit unsigned integer
+	Be16BitUnsignedInteger = 76,
+	/// A big-endian 32-bit unsigned integer
+	Be32BitUnsignedInteger = 77,
+	/// A big-endian 64-bit unsigned integer
+	Be64BitUnsignedInteger = 78,
+	/// A block of data representing a 3x3 transformation matrix. It has the structure:
+	///
+	/// ```c
+	/// struct {
+	///    BEFloat64 matrix[3][3];
+	/// }
+	/// ```
+	AffineTransformF64 = 79,
+	/// Some other data type
+	Other(u32),
+}
+
+impl From<u32> for DataType {
+	fn from(value: u32) -> Self {
+		match value {
+			0 => DataType::Reserved,
+			1 => DataType::Utf8,
+			2 => DataType::Utf16,
+			3 => DataType::SJis,
+			4 => DataType::Utf8Sort,
+			5 => DataType::Utf16Sort,
+			12 => DataType::Gif,
+			13 => DataType::Jpeg,
+			14 => DataType::Png,
+			21 => DataType::BeSignedInteger,
+			22 => DataType::BeUnsignedInteger,
+			23 => DataType::BeFloat32,
+			24 => DataType::BeFloat64,
+			27 => DataType::Bmp,
+			28 => DataType::QuicktimeMetadata,
+			65 => DataType::Signed8BitInteger,
+			66 => DataType::Be16BitSignedInteger,
+			67 => DataType::Be32BitSignedInteger,
+			70 => DataType::BePointF32,
+			71 => DataType::BeDimensionsF32,
+			72 => DataType::BeRectF32,
+			74 => DataType::Be64BitSignedInteger,
+			75 => DataType::Unsigned8BitInteger,
+			76 => DataType::Be16BitUnsignedInteger,
+			77 => DataType::Be32BitUnsignedInteger,
+			78 => DataType::Be64BitUnsignedInteger,
+			79 => DataType::AffineTransformF64,
+			other => DataType::Other(other),
+		}
+	}
+}
+
+impl From<DataType> for u32 {
+	fn from(value: DataType) -> Self {
+		match value {
+			DataType::Reserved => 0,
+			DataType::Utf8 => 1,
+			DataType::Utf16 => 2,
+			DataType::SJis => 3,
+			DataType::Utf8Sort => 4,
+			DataType::Utf16Sort => 5,
+			DataType::Gif => 12,
+			DataType::Jpeg => 13,
+			DataType::Png => 14,
+			DataType::BeSignedInteger => 21,
+			DataType::BeUnsignedInteger => 22,
+			DataType::BeFloat32 => 23,
+			DataType::BeFloat64 => 24,
+			DataType::Bmp => 27,
+			DataType::QuicktimeMetadata => 28,
+			DataType::Signed8BitInteger => 65,
+			DataType::Be16BitSignedInteger => 66,
+			DataType::Be32BitSignedInteger => 67,
+			DataType::BePointF32 => 70,
+			DataType::BeDimensionsF32 => 71,
+			DataType::BeRectF32 => 72,
+			DataType::Be64BitSignedInteger => 74,
+			DataType::Unsigned8BitInteger => 75,
+			DataType::Be16BitUnsignedInteger => 76,
+			DataType::Be32BitUnsignedInteger => 77,
+			DataType::Be64BitUnsignedInteger => 78,
+			DataType::AffineTransformF64 => 79,
+			DataType::Other(other) => other,
+		}
+	}
+}
+
+impl From<MimeType> for DataType {
+	fn from(value: MimeType) -> Self {
+		DataType::from(&value)
+	}
+}
+
+impl From<&MimeType> for DataType {
+	fn from(value: &MimeType) -> Self {
+		match value {
+			MimeType::Gif => DataType::Gif,
+			MimeType::Jpeg => DataType::Jpeg,
+			MimeType::Png => DataType::Png,
+			MimeType::Bmp => DataType::Bmp,
+			_ => DataType::Reserved,
+		}
+	}
+}
+
+impl DataType {
+	/// A data type can only occupy 24 bits
+	pub const MAX: u32 = 16_777_215;
+}