EBML: Start parsing \Ebml\Segments\Tracks

Author: Serial-ATA

lofty/src/ebml/element_reader.rs

@@ -169,11 +169,11 @@ ebml_master_elements! {
 struct ElementReaderContext {
 	/// Previous master element
 	previous_master: Option<MasterElement>,
-	previous_master_length: u64,
+	previous_master_length: VInt,
 	/// Current master element
 	current_master: Option<MasterElement>,
 	/// Remaining length of the master element
-	master_length: u64,
+	master_length: VInt,
 	/// Maximum size in octets of all element IDs
 	max_id_length: u8,
 	/// Maximum size in octets of all element data sizes
@@ -189,9 +189,9 @@ impl Default for ElementReaderContext {
 	fn default() -> Self {
 		Self {
 			previous_master: None,
-			previous_master_length: 0,
+			previous_master_length: VInt::ZERO,
 			current_master: None,
-			master_length: 0,
+			master_length: VInt::ZERO,
 			// https://www.rfc-editor.org/rfc/rfc8794.html#name-ebmlmaxidlength-element
 			max_id_length: 4,
 			// https://www.rfc-editor.org/rfc/rfc8794.html#name-ebmlmaxsizelength-element
@@ -202,12 +202,32 @@ impl Default for ElementReaderContext {
 }
 
 pub(crate) enum ElementReaderYield {
-	Master((ElementIdent, u64)),
-	Child((ChildElementDescriptor, u64)),
+	Master((ElementIdent, VInt)),
+	Child((ChildElementDescriptor, VInt)),
 	Unknown(ElementHeader),
 	Eof,
 }
 
+impl ElementReaderYield {
+	pub fn ident(&self) -> Option<u64> {
+		match self {
+			ElementReaderYield::Master((ident, _)) => Some(*ident as u64),
+			ElementReaderYield::Child((child, _)) => Some(child.ident as u64),
+			ElementReaderYield::Unknown(header) => Some(header.id.value()),
+			_ => None,
+		}
+	}
+
+	pub fn size(&self) -> Option<u64> {
+		match self {
+			ElementReaderYield::Master((_, size)) => Some(size.value()),
+			ElementReaderYield::Child((_, size)) => Some(size.value()),
+			ElementReaderYield::Unknown(header) => Some(header.size.value()),
+			_ => None,
+		}
+	}
+}
+
 pub struct ElementReader<R> {
 	reader: R,
 	ctx: ElementReaderContext,
@@ -250,7 +270,7 @@ where
 
 	fn goto_next_master(&mut self) -> Result<ElementReaderYield> {
 		if self.ctx.master_length != 0 {
-			self.skip(self.ctx.master_length)?;
+			self.skip(self.ctx.master_length.value())?;
 		}
 
 		let header = ElementHeader::read(
@@ -265,7 +285,7 @@ where
 
 		self.store_previous_master();
 		self.ctx.current_master = Some(*master);
-		self.ctx.master_length = header.size.value();
+		self.ctx.master_length = header.size;
 		Ok(ElementReaderYield::Master((
 			master.id,
 			self.ctx.master_length,
@@ -312,16 +332,13 @@ where
 					.get(&header.id)
 					.expect("Nested master elements should be defined at this level."),
 			);
-			self.ctx.master_length = header.size.value();
+			self.ctx.master_length = header.size;
 
 			// We encountered a nested master element
-			return Ok(ElementReaderYield::Master((
-				child.ident,
-				header.size.value(),
-			)));
+			return Ok(ElementReaderYield::Master((child.ident, header.size)));
 		}
 
-		Ok(ElementReaderYield::Child((*child, header.size.value())))
+		Ok(ElementReaderYield::Child((*child, header.size)))
 	}
 
 	fn lock(&mut self) {

lofty/src/ebml/read.rs

@@ -92,36 +92,38 @@ where
 		}
 
 		if ident == ElementIdent::EBMLMaxIDLength {
-			properties.header.max_id_length = child_reader.read_unsigned_int(size)? as u8;
+			properties.header.max_id_length = child_reader.read_unsigned_int(size.value())? as u8;
 			child_reader.set_max_id_length(properties.header.max_id_length);
 			continue;
 		}
 
 		if ident == ElementIdent::EBMLMaxSizeLength {
-			properties.header.max_size_length = child_reader.read_unsigned_int(size)? as u8;
+			properties.header.max_size_length = child_reader.read_unsigned_int(size.value())? as u8;
 			child_reader.set_max_size_length(properties.header.max_size_length);
 			continue;
 		}
 
 		// Anything else in the header is unnecessary, and only read for the properties
 		// struct
 		if !parse_options.read_properties {
-			child_reader.skip(size)?;
+			child_reader.skip(size.value())?;
 			continue;
 		}
 
 		match ident {
 			ElementIdent::EBMLVersion => {
-				properties.header.version = child_reader.read_unsigned_int(size)?
+				properties.header.version = child_reader.read_unsigned_int(size.value())?
 			},
 			ElementIdent::EBMLReadVersion => {
-				properties.header.read_version = child_reader.read_unsigned_int(size)?
+				properties.header.read_version = child_reader.read_unsigned_int(size.value())?
+			},
+			ElementIdent::DocType => {
+				properties.header.doc_type = child_reader.read_string(size.value())?
 			},
-			ElementIdent::DocType => properties.header.doc_type = child_reader.read_string(size)?,
 			ElementIdent::DocTypeVersion => {
-				properties.header.doc_type_version = child_reader.read_unsigned_int(size)?
+				properties.header.doc_type_version = child_reader.read_unsigned_int(size.value())?
 			},
-			_ => child_reader.skip(size)?,
+			_ => child_reader.skip(size.value())?,
 		}
 	}
 

lofty/src/ebml/read/segment.rs

@@ -34,17 +34,11 @@ where
 				ElementIdent::Tracks if parse_options.read_properties => {
 					segment_tracks::read_from(children_reader.inner(), parse_options, properties)?
 				},
-				ElementIdent::Tags | ElementIdent::Attachments | ElementIdent::Chapters => {
+				ElementIdent::Tags | ElementIdent::Chapters if parse_options.read_tags => {
 					let mut tag = tags.unwrap_or_default();
 
 					if id == ElementIdent::Tags {
 						segment_tags::read_from(children_reader.inner(), parse_options, &mut tag)?
-					} else if id == ElementIdent::Attachments {
-						segment_attachments::read_from(
-							children_reader.inner(),
-							parse_options,
-							&mut tag,
-						)?
 					} else {
 						segment_chapters::read_from(
 							children_reader.inner(),
@@ -55,12 +49,23 @@ where
 
 					tags = Some(tag);
 				},
+				ElementIdent::Attachments if parse_options.read_cover_art => {
+					let mut tag = tags.unwrap_or_default();
+
+					segment_attachments::read_from(
+						children_reader.inner(),
+						parse_options,
+						&mut tag,
+					)?;
+
+					tags = Some(tag);
+				},
 				_ => {
 					// We do not end up using information from all of the segment
 					// elements, so we can just skip any useless ones.
 
 					log::debug!("Skipping EBML master element: {:?}", id);
-					children_reader.skip(size)?;
+					children_reader.skip(size.value())?;
 					children_reader.goto_previous_master()?;
 					continue;
 				},

lofty/src/ebml/read/segment_info.rs

@@ -23,15 +23,15 @@ where
 				// elements, so we can just skip them.
 
 				log::debug!("Skipping EBML master element: {:?}", id);
-				children_reader.skip(size)?;
+				children_reader.skip(size.value())?;
 				children_reader.goto_previous_master()?;
 				continue;
 			},
 			ElementReaderYield::Child((child, size)) => {
 				match child.ident {
 					ElementIdent::TimecodeScale => {
 						properties.segment_info.timestamp_scale =
-							children_reader.read_unsigned_int(size)?;
+							children_reader.read_unsigned_int(size.value())?;
 
 						if properties.segment_info.timestamp_scale == 0 {
 							log::warn!("Segment.Info.TimecodeScale is 0, which is invalid");
@@ -41,17 +41,19 @@ where
 						}
 					},
 					ElementIdent::MuxingApp => {
-						properties.segment_info.muxing_app = children_reader.read_utf8(size)?
+						properties.segment_info.muxing_app =
+							children_reader.read_utf8(size.value())?
 					},
 					ElementIdent::WritingApp => {
-						properties.segment_info.writing_app = children_reader.read_utf8(size)?
+						properties.segment_info.writing_app =
+							children_reader.read_utf8(size.value())?
 					},
 					_ => {
 						// We do not end up using information from all of the segment
 						// elements, so we can just skip any useless ones.
 
 						log::debug!("Skipping EBML child element: {:?}", child.ident);
-						children_reader.skip(size)?;
+						children_reader.skip(size.value())?;
 						continue;
 					},
 				}

lofty/src/ebml/read/segment_tracks.rs

@@ -1,18 +1,57 @@
 use crate::config::ParseOptions;
-use crate::ebml::element_reader::{ElementIdent, ElementReader, ElementReaderYield};
+use crate::ebml::element_reader::{
+	ChildElementDescriptor, ElementHeader, ElementIdent, ElementReader, ElementReaderYield,
+};
 use crate::ebml::properties::EbmlProperties;
 use crate::error::Result;
 use crate::macros::decode_err;
 
 use std::io::{Read, Seek};
 
 pub(super) fn read_from<R>(
+	element_reader: &mut ElementReader<R>,
+	parse_options: ParseOptions,
+	properties: &mut EbmlProperties,
+) -> Result<()>
+where
+	R: Read + Seek,
+{
+	let mut children_reader = element_reader.children();
+
+	while let Some(child) = children_reader.next()? {
+		match child {
+			ElementReaderYield::Master((ElementIdent::TrackEntry, size)) => {
+				read_track_entry(children_reader.inner(), parse_options, properties)?;
+			},
+			ElementReaderYield::Eof => {
+				break;
+			},
+			_ => {
+				let id = child
+					.ident()
+					.expect("Child element must have an identifier");
+				let size = child.size().expect("Child element must have a size");
+
+				log::warn!(
+					"Unexpected child element in \\EBML\\Segment\\Tracks: {:?}, skipping",
+					id
+				);
+				children_reader.skip(size)?;
+				continue;
+			},
+		}
+	}
+
+	Ok(())
+}
+
+fn read_track_entry<R>(
 	_element_reader: &mut ElementReader<R>,
 	_parse_options: ParseOptions,
 	_properties: &mut EbmlProperties,
 ) -> Result<()>
 where
 	R: Read + Seek,
 {
-	unimplemented!("\\Ebml\\Segment\\Tracks")
+	Ok(())
 }

lofty/src/ebml/vint.rs

@@ -2,6 +2,7 @@ use crate::error::Result;
 use crate::macros::err;
 
 use std::io::Read;
+use std::ops::{Add, Sub};
 
 use byteorder::{ReadBytesExt, WriteBytesExt};
 
@@ -20,7 +21,12 @@ impl VInt {
 	const MAX_OCTET_LENGTH: u64 = 8;
 	const USABLE_BITS: u64 = Self::MAX_OCTET_LENGTH * Self::USABLE_BITS_PER_BYTE;
 
-	const MAX_VALUE: u64 = u64::MAX >> (u64::BITS as u64 - Self::USABLE_BITS);
+	/// The maximum value that can be represented by a `VInt`
+	pub const MAX: u64 = u64::MAX >> (u64::BITS as u64 - Self::USABLE_BITS);
+	/// The minimum value that can be represented by a `VInt`
+	pub const MIN: u64 = 0;
+	/// A `VInt` with a value of 0
+	pub const ZERO: Self = Self(0);
 
 	/// Create a signed `VInt` from a `u64`
 	///
@@ -43,7 +49,7 @@ impl VInt {
 	/// # Ok(()) }
 	/// ```
 	pub fn from_u64(uint: u64) -> Result<Self> {
-		if uint > Self::MAX_VALUE {
+		if uint > Self::MAX {
 			err!(BadVintSize);
 		}
 
@@ -249,6 +255,35 @@ impl VInt {
 
 		Ok(ret)
 	}
+
+	pub(crate) fn saturating_sub(&self, other: u64) -> Self {
+		Self(self.0.saturating_sub(other))
+	}
+}
+
+impl Sub for VInt {
+	type Output = Self;
+
+	fn sub(self, other: Self) -> Self::Output {
+		Self(self.0 - other.0)
+	}
+}
+
+impl Add for VInt {
+	type Output = Self;
+
+	fn add(self, other: Self) -> Self::Output {
+		let val = self.0 + other.0;
+		assert!(val <= Self::MAX, "VInt overflow");
+
+		Self(val)
+	}
+}
+
+impl PartialEq<u64> for VInt {
+	fn eq(&self, other: &u64) -> bool {
+		self.0 == *other
+	}
 }
 
 #[cfg(test)]