EBML: Handle EbmlTag -> Tag conversion

Author: Serial-ATA

lofty/src/ape/tag/mod.rs

@@ -915,6 +915,7 @@ mod tests {
 	fn skip_reading_cover_art() {
 		let p = Picture::new_unchecked(
 			PictureType::CoverFront,
+			None,
 			Some(MimeType::Jpeg),
 			None,
 			std::iter::repeat(0).take(50).collect::<Vec<u8>>(),

lofty/src/ebml/element_reader.rs

@@ -109,7 +109,6 @@ ebml_master_elements! {
 		children: [
 			// SeekHead: { 0x114D_9B74, Master },
 			Info: { 0x1549_A966, Master },
-			Cluster: { 0x1F43_B675, Master },
 			Tracks: { 0x1654_AE6B, Master },
 			Tags: { 0x1254_C367, Master },
 			Attachments: { 0x1941_A469, Master },

lofty/src/ebml/read.rs

@@ -1,7 +1,6 @@
 mod segment;
 mod segment_attachments;
 mod segment_chapters;
-mod segment_cluster;
 mod segment_info;
 mod segment_tags;
 mod segment_tracks;

lofty/src/ebml/read/segment.rs

@@ -1,4 +1,4 @@
-use super::{segment_attachments, segment_cluster, segment_info, segment_tags, segment_tracks};
+use super::{segment_attachments, segment_info, segment_tags, segment_tracks};
 use crate::config::ParseOptions;
 use crate::ebml::element_reader::{ElementHeader, ElementIdent, ElementReader, ElementReaderYield};
 use crate::ebml::properties::EbmlProperties;
@@ -30,13 +30,6 @@ where
 							properties,
 						)?;
 					},
-					ElementIdent::Cluster if parse_options.read_properties => {
-						segment_cluster::read_from(
-							&mut children_reader.children(),
-							parse_options,
-							properties,
-						)?;
-					},
 					ElementIdent::Tracks if parse_options.read_properties => {
 						segment_tracks::read_from(
 							&mut children_reader.children(),

lofty/src/ebml/read/segment_attachments.rs

@@ -7,6 +7,7 @@ use crate::error::Result;
 use crate::macros::decode_err;
 use crate::picture::MimeType;
 
+use std::borrow::Cow;
 use std::io::{Read, Seek};
 
 pub(super) fn read_from<R>(
@@ -31,7 +32,7 @@ where
 	Ok(())
 }
 
-fn read_attachment<R>(element_reader: &mut ElementReader<R>) -> Result<AttachedFile>
+fn read_attachment<R>(element_reader: &mut ElementReader<R>) -> Result<AttachedFile<'static>>
 where
 	R: Read + Seek,
 {
@@ -105,12 +106,12 @@ where
 	};
 
 	Ok(AttachedFile {
-		description,
-		file_name,
+		description: description.map(Cow::Owned),
+		file_name: Cow::Owned(file_name),
 		mime_type,
-		file_data,
+		file_data: Cow::Owned(file_data),
 		uid,
-		referral,
+		referral: referral.map(Cow::Owned),
 		used_start_time,
 		used_end_time,
 	})

lofty/src/ebml/read/segment_cluster.rs

@@ -2,8 +2,8 @@ use crate::config::ParseOptions;
 use crate::ebml::element_reader::{ElementChildIterator, ElementIdent, ElementReaderYield};
 use crate::ebml::{EbmlTag, Language, SimpleTag, Tag, TagValue, Target, TargetType};
 use crate::error::Result;
-
 use crate::macros::decode_err;
+
 use std::io::{Read, Seek};
 
 pub(super) fn read_from<R>(
@@ -57,7 +57,7 @@ where
 				target = Some(read_targets(&mut children_reader.children())?);
 			},
 			ElementIdent::SimpleTag => {
-				simple_tags.push(read_simple_tag(&mut children_reader.children())?);
+				simple_tags.push(read_simple_tag(&mut children_reader.children())?)
 			},
 			_ => {
 				unimplemented!("Unhandled child element in \\Segment\\Tags\\Tag: {master:?}");
@@ -70,7 +70,7 @@ where
 	};
 
 	Ok(Tag {
-		target,
+		target: Some(target),
 		simple_tags,
 	})
 }

lofty/src/ebml/read/segment_tags.rs

@@ -1,31 +1,34 @@
 use crate::error::Result;
 use crate::macros::encode_err;
-use crate::picture::MimeType;
+use crate::picture::{MimeType, Picture};
 
+use std::borrow::Cow;
 use std::fmt::Debug;
 
 /// Some attached file
 ///
 /// This element contains any attached files, similar to the [GEOB]
 /// frame in ID3v2. The difference is, this is *also* used for images.
 ///
+/// **Unsupported in WebM**
+///
 /// [GEOB]: crate::id3::v2::GeneralEncapsulatedObject
 #[derive(Clone, Eq, PartialEq)]
-pub struct AttachedFile {
+pub struct AttachedFile<'a> {
 	/// A human-friendly name for the attached file.
-	pub description: Option<String>,
+	pub description: Option<Cow<'a, str>>,
 	/// The actual file name of the attached file.
-	pub file_name: String,
+	pub file_name: Cow<'a, str>,
 	/// Media type of the file following the [RFC6838] format.
 	///
 	/// [RFC6838]: https://tools.ietf.org/html/rfc6838
 	pub mime_type: MimeType,
 	/// The data of the file.
-	pub file_data: Vec<u8>,
+	pub file_data: Cow<'a, [u8]>,
 	/// Unique ID representing the file, as random as possible.
 	pub uid: u64,
 	/// A binary value that a track/codec can refer to when the attachment is needed.
-	pub referral: Option<Vec<u8>>,
+	pub referral: Option<Cow<'a, [u8]>>,
 	/// The timestamp at which this optimized font attachment comes into context.
 	///
 	/// This is expressed in Segment Ticks which is based on `TimestampScale`. This element is
@@ -38,7 +41,7 @@ pub struct AttachedFile {
 	pub used_end_time: Option<u64>,
 }
 
-impl Debug for AttachedFile {
+impl Debug for AttachedFile<'_> {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		f.debug_struct("AttachedFile")
 			.field("description", &self.description)
@@ -53,12 +56,85 @@ impl Debug for AttachedFile {
 	}
 }
 
-impl AttachedFile {
+impl From<Picture> for AttachedFile<'_> {
+	fn from(picture: Picture) -> Self {
+		Self {
+			description: picture.description,
+			file_name: picture.file_name.unwrap_or_default(),
+			mime_type: picture
+				.mime_type
+				.unwrap_or(MimeType::Unknown(String::from("image/"))),
+			file_data: picture.data,
+			uid: 0,
+			referral: None,
+			used_start_time: None,
+			used_end_time: None,
+		}
+	}
+}
+
+impl AttachedFile<'_> {
+	/// Whether this file is an image
+	///
+	/// This will check if the [`MimeType`] starts with `image/`.
+	///
+	/// # Examples
+	///
+	/// ```rust
+	/// use lofty::ebml::AttachedFile;
+	/// use lofty::picture::MimeType;
+	///
+	/// let file = AttachedFile {
+	/// 	description: None,
+	/// 	file_name: "something.png".into(),
+	/// 		// PNG MIME type
+	/// 	mime_type: MimeType::Png,
+	/// 	file_data: vec![1, 2, 3].into(),
+	/// 	uid: 0,
+	/// 	referral: None,
+	/// 	used_start_time: None,
+	/// 	used_end_time: None
+	/// };
+	///
+	/// assert!(file.is_image());
+	pub fn is_image(&self) -> bool {
+		match &self.mime_type {
+			MimeType::Unknown(mime) if mime.starts_with("image/") => true,
+			MimeType::Unknown(_) => false,
+			// `MimeType` is only ever used for `Picture`s outside of Matroska
+			_ => true,
+		}
+	}
+
 	pub(crate) fn validate(&self) -> Result<()> {
 		if self.uid == 0 {
 			encode_err!(@BAIL Ebml, "The UID of an attachment cannot be 0");
 		}
 
 		Ok(())
 	}
+
+	pub(crate) fn into_owned(self) -> AttachedFile<'static> {
+		let AttachedFile {
+			description,
+			file_name,
+			mime_type,
+			file_data,
+			uid,
+			referral,
+			used_start_time,
+			used_end_time,
+		} = self;
+
+		AttachedFile {
+			description: description.map(|d| Cow::Owned(d.into_owned())),
+			file_name: Cow::Owned(file_name.into_owned()),
+			mime_type,
+			file_data: Cow::Owned(file_data.into_owned()),
+			uid,
+			referral: referral.map(|r| Cow::Owned(r.into_owned())),
+			used_start_time,
+			used_end_time,
+		}
+	}
 }

lofty/src/ebml/tag/attached_file.rs

@@ -0,0 +1,132 @@
+//! Conversions to and from generic types
+//!
+//! NOTE: We can **ONLY** convert `SimpleTags` that come from a target with **NO** uids
+
+use super::{EbmlTag, Language, SimpleTag, TargetType, TOMBSTONE_SIMPLE_TAG};
+use crate::tag::items::Lang;
+use crate::tag::{ItemKey, Tag, TagItem, TagType};
+
+use std::collections::HashMap;
+use std::sync::LazyLock;
+
+macro_rules! matroska_mapping_tables {
+	(
+        $($target:ident => [
+            $($matroska_key:literal <=> $item_key:ident),* $(,)?
+        ]);+ $(;)?
+    ) => {
+		const _: () = {
+			match TargetType::Album {
+				$(
+					TargetType::$target => {}
+				),+
+			}
+		};
+
+		pub(crate) const SUPPORTED_ITEMKEYS: &[ItemKey] = &[
+			$(
+				$(
+					ItemKey::$item_key
+				),*
+			)+
+		];
+
+		static MAPPINGS: LazyLock<HashMap<(TargetType, &'static str), ItemKey>> = LazyLock::new(|| {
+			let mut m = HashMap::new();
+			$(
+				$(
+					m.insert((TargetType::$target, $matroska_key), ItemKey::$item_key);
+				)*
+			)+
+			m
+		});
+
+		static REVERSE_MAPPINGS: LazyLock<HashMap<ItemKey, (TargetType, &'static str)>> = LazyLock::new(|| {
+			let mut m = HashMap::new();
+			$(
+				$(
+					m.insert(ItemKey::$item_key, (TargetType::$target, $matroska_key));
+				)*
+			)+
+			m
+		});
+	};
+}
+
+// TODO: Actually define all the mappings
+matroska_mapping_tables!(
+	Shot => [];
+	Scene => [];
+	Track => [
+		"TITLE" <=> TrackTitle,
+		"ARTIST" <=> TrackArtist,
+	];
+	Part => [];
+	Album => [];
+	Edition => [];
+	Collection => [];
+);
+
+const TAG_RETAINED: bool = true;
+const TAG_CONSUMED: bool = false;
+
+pub(super) fn split_tag(mut ebml_tag: EbmlTag) -> (EbmlTag, Tag) {
+	let mut tag = Tag::new(TagType::Ebml);
+
+	// TODO: Pictures, can they be handled in a generic way?
+	//       What about the uid and referral?
+
+	ebml_tag.tags.retain_mut(|t| {
+		let target_type = match &t.target {
+			Some(t) if !t.has_uids() => t.target_type,
+			// We cannot use any tags bound to uids
+			Some(_) => return TAG_RETAINED,
+			None => TargetType::default(),
+		};
+
+		t.simple_tags
+			.retain_mut(|simple_tag| split_simple_tags(target_type, simple_tag, &mut tag));
+		if t.simple_tags.is_empty() {
+			return TAG_CONSUMED;
+		}
+
+		return TAG_RETAINED;
+	});
+
+	(ebml_tag, tag)
+}
+
+fn split_simple_tags(
+	target_type: TargetType,
+	simple_tag: &mut SimpleTag<'_>,
+	tag: &mut Tag,
+) -> bool {
+	let lang: Lang;
+	match &simple_tag.language {
+		Some(Language::Iso639_2(l)) if l.len() == 3 => {
+			lang = l.as_bytes().try_into().unwrap(); // Infallible
+		},
+		None => lang = *b"und",
+		// `Lang` doesn't support anything outside of a 3 character ISO-639-2 code.
+		_ => return TAG_RETAINED,
+	}
+
+	let Some(item_key) = MAPPINGS.get(&(target_type, &*simple_tag.name)).cloned() else {
+		return TAG_RETAINED;
+	};
+
+	if simple_tag.value.is_none() {
+		// Ignore empty items, `TagItem` is not made to handle them.
+		return TAG_RETAINED;
+	}
+
+	let simple_tag = std::mem::replace(simple_tag, TOMBSTONE_SIMPLE_TAG);
+	tag.push(TagItem {
+		lang,
+		description: String::new(),
+		item_key,
+		item_value: simple_tag.value.unwrap().into(), // Infallible
+	});
+
+	return TAG_CONSUMED;
+}