ID3v2: Move all header related items to v2::header module

Author: Serial-ATA

src/aac/read.rs

@@ -1,8 +1,8 @@
 use super::header::{ADTSHeader, HEADER_MASK};
 use super::AacFile;
 use crate::error::Result;
+use crate::id3::v2::header::Id3v2Header;
 use crate::id3::v2::read::parse_id3v2;
-use crate::id3::v2::read_id3v2_header;
 use crate::id3::{find_id3v1, ID3FindResults};
 use crate::macros::{decode_err, parse_mode_choice};
 use crate::mpeg::header::{cmp_header, search_for_frame_sync, HeaderCmpResult};
@@ -43,7 +43,7 @@ where
 				// Seek back to read the tag in full
 				reader.seek(SeekFrom::Current(-4))?;
 
-				let header = read_id3v2_header(reader)?;
+				let header = Id3v2Header::parse(reader)?;
 				let skip_footer = header.flags.footer;
 
 				stream_len -= u64::from(header.size);

src/id3/mod.rs

@@ -8,7 +8,7 @@ pub mod v2;
 
 use crate::error::{ErrorKind, LoftyError, Result};
 use crate::macros::try_vec;
-use v2::{read_id3v2_header, Id3v2Header};
+use v2::header::Id3v2Header;
 
 use std::io::{Read, Seek, SeekFrom};
 use std::ops::Neg;
@@ -92,7 +92,7 @@ where
 	let mut header = None;
 	let mut id3v2 = None;
 
-	if let Ok(id3v2_header) = read_id3v2_header(data) {
+	if let Ok(id3v2_header) = Id3v2Header::parse(data) {
 		if read {
 			let mut tag = try_vec![0; id3v2_header.size as usize];
 			data.read_exact(&mut tag)?;

src/id3/v2/flags.rs

@@ -1,11 +1,11 @@
 use crate::error::{Id3v2Error, Id3v2ErrorKind, Result};
 use crate::id3::v2::frame::FrameValue;
+use crate::id3::v2::header::Id3v2Version;
 use crate::id3::v2::items::{
 	AttachedPictureFrame, CommentFrame, EventTimingCodesFrame, ExtendedTextFrame, ExtendedUrlFrame,
 	KeyValueFrame, OwnershipFrame, Popularimeter, PrivateFrame, RelativeVolumeAdjustmentFrame,
 	TextInformationFrame, UniqueFileIdentifierFrame, UnsynchronizedTextFrame, UrlLinkFrame,
 };
-use crate::id3::v2::Id3v2Version;
 use crate::macros::err;
 use crate::probe::ParsingMode;
 use crate::util::text::TextEncoding;

src/id3/v2/frame/content.rs

@@ -3,13 +3,13 @@ mod header;
 pub(super) mod id;
 pub(super) mod read;
 
+use super::header::Id3v2Version;
 use super::items::{
 	AttachedPictureFrame, CommentFrame, EventTimingCodesFrame, ExtendedTextFrame, ExtendedUrlFrame,
 	KeyValueFrame, OwnershipFrame, Popularimeter, PrivateFrame, RelativeVolumeAdjustmentFrame,
 	TextInformationFrame, UniqueFileIdentifierFrame, UnsynchronizedTextFrame, UrlLinkFrame,
 };
 use super::util::upgrade::{upgrade_v2, upgrade_v3};
-use super::Id3v2Version;
 use crate::error::{ErrorKind, Id3v2Error, Id3v2ErrorKind, LoftyError, Result};
 use crate::tag::item::{ItemKey, ItemValue, TagItem};
 use crate::tag::TagType;

src/id3/v2/frame/mod.rs

@@ -2,8 +2,9 @@ use super::header::{parse_header, parse_v2_header};
 use super::Frame;
 use crate::error::{Id3v2Error, Id3v2ErrorKind, Result};
 use crate::id3::v2::frame::content::parse_content;
+use crate::id3::v2::header::Id3v2Version;
 use crate::id3::v2::util::synchsafe::{SynchsafeInteger, UnsynchronizedStream};
-use crate::id3::v2::{FrameFlags, FrameId, FrameValue, Id3v2Version};
+use crate::id3::v2::{FrameFlags, FrameId, FrameValue};
 use crate::macros::try_vec;
 use crate::probe::ParsingMode;
 

src/id3/v2/frame/read.rs

@@ -0,0 +1,141 @@
+use crate::error::{Id3v2Error, Id3v2ErrorKind, Result};
+use crate::id3::v2::restrictions::TagRestrictions;
+use crate::id3::v2::util::synchsafe::SynchsafeInteger;
+use crate::macros::err;
+
+use std::io::Read;
+
+use byteorder::{BigEndian, ByteOrder, ReadBytesExt};
+
+/// The ID3v2 version
+#[derive(PartialEq, Eq, Debug, Clone, Copy)]
+pub enum Id3v2Version {
+	/// ID3v2.2
+	V2,
+	/// ID3v2.3
+	V3,
+	/// ID3v2.4
+	V4,
+}
+
+/// Flags that apply to the entire tag
+#[derive(Default, Copy, Clone, Debug, PartialEq, Eq)]
+#[allow(clippy::struct_excessive_bools)]
+pub struct Id3v2TagFlags {
+	/// Whether or not all frames are unsynchronised. See [`FrameFlags::unsynchronisation`](crate::id3::v2::FrameFlags::unsynchronisation)
+	pub unsynchronisation: bool,
+	/// Indicates if the tag is in an experimental stage
+	pub experimental: bool,
+	/// Indicates that the tag includes a footer
+	///
+	/// A footer will be created if the tag is written
+	pub footer: bool,
+	/// Whether or not to include a CRC-32 in the extended header
+	///
+	/// This is calculated if the tag is written
+	pub crc: bool,
+	/// Restrictions on the tag, written in the extended header
+	///
+	/// In addition to being setting this flag, all restrictions must be provided. See [`TagRestrictions`]
+	pub restrictions: Option<TagRestrictions>,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub(crate) struct Id3v2Header {
+	pub version: Id3v2Version,
+	pub flags: Id3v2TagFlags,
+	pub size: u32,
+	pub extended_size: u32,
+}
+
+impl Id3v2Header {
+	pub(crate) fn parse<R>(bytes: &mut R) -> Result<Self>
+	where
+		R: Read,
+	{
+		let mut header = [0; 10];
+		bytes.read_exact(&mut header)?;
+
+		if &header[..3] != b"ID3" {
+			err!(FakeTag);
+		}
+
+		// Version is stored as [major, minor], but here we don't care about minor revisions unless there's an error.
+		let version = match header[3] {
+			2 => Id3v2Version::V2,
+			3 => Id3v2Version::V3,
+			4 => Id3v2Version::V4,
+			major => {
+				return Err(
+					Id3v2Error::new(Id3v2ErrorKind::BadId3v2Version(major, header[4])).into(),
+				)
+			},
+		};
+
+		let flags = header[5];
+
+		// Compression was a flag only used in ID3v2.2 (bit 2).
+		// At the time the ID3v2.2 specification was written, a compression scheme wasn't decided.
+		// The spec recommends just ignoring the tag in this case.
+		if version == Id3v2Version::V2 && flags & 0x40 == 0x40 {
+			return Err(Id3v2Error::new(Id3v2ErrorKind::V2Compression).into());
+		}
+
+		let mut flags_parsed = Id3v2TagFlags {
+			unsynchronisation: flags & 0x80 == 0x80,
+			experimental: (version == Id3v2Version::V4 || version == Id3v2Version::V3)
+				&& flags & 0x20 == 0x20,
+			footer: (version == Id3v2Version::V4 || version == Id3v2Version::V3)
+				&& flags & 0x10 == 0x10,
+			crc: false,         // Retrieved later if applicable
+			restrictions: None, // Retrieved later if applicable
+		};
+
+		let size = BigEndian::read_u32(&header[6..]).unsynch();
+		let mut extended_size = 0;
+
+		let extended_header =
+			(version == Id3v2Version::V4 || version == Id3v2Version::V3) && flags & 0x40 == 0x40;
+
+		if extended_header {
+			extended_size = bytes.read_u32::<BigEndian>()?.unsynch();
+
+			if extended_size < 6 {
+				return Err(Id3v2Error::new(Id3v2ErrorKind::BadExtendedHeaderSize).into());
+			}
+
+			// Useless byte since there's only 1 byte for flags
+			let _num_flag_bytes = bytes.read_u8()?;
+
+			let extended_flags = bytes.read_u8()?;
+
+			// The only flags we care about here are the CRC and restrictions
+
+			if extended_flags & 0x20 == 0x20 {
+				flags_parsed.crc = true;
+
+				// We don't care about the existing CRC (5) or its length byte (1)
+				let mut crc = [0; 6];
+				bytes.read_exact(&mut crc)?;
+			}
+
+			if extended_flags & 0x10 == 0x10 {
+				// We don't care about the length byte, it is always 1
+				let _data_length = bytes.read_u8()?;
+
+				flags_parsed.restrictions = Some(TagRestrictions::from_byte(bytes.read_u8()?));
+			}
+		}
+
+		if extended_size > 0 && extended_size >= size {
+			return Err(Id3v2Error::new(Id3v2ErrorKind::BadExtendedHeaderSize).into());
+		}
+
+		Ok(Id3v2Header {
+			version,
+			flags: flags_parsed,
+			size,
+			extended_size,
+		})
+	}
+}

src/id3/v2/header.rs

@@ -1,5 +1,5 @@
 use crate::error::{Id3v2Error, Id3v2ErrorKind, Result};
-use crate::id3::v2::Id3v2Version;
+use crate::id3::v2::header::Id3v2Version;
 use crate::macros::err;
 use crate::picture::{MimeType, Picture, PictureType};
 use crate::util::text::{encode_text, TextEncoding};

src/id3/v2/items/attached_picture_frame.rs

@@ -1,6 +1,6 @@
 use crate::error::{Id3v2Error, Id3v2ErrorKind, LoftyError, Result};
 use crate::id3::v2::frame::content::verify_encoding;
-use crate::id3::v2::Id3v2Version;
+use crate::id3::v2::header::Id3v2Version;
 use crate::util::text::{decode_text, encode_text, read_to_terminator, utf16_decode, TextEncoding};
 
 use std::hash::{Hash, Hasher};

src/id3/v2/items/extended_text_frame.rs

@@ -1,6 +1,6 @@
 use crate::error::Result;
 use crate::id3::v2::frame::content::verify_encoding;
-use crate::id3::v2::Id3v2Version;
+use crate::id3::v2::header::Id3v2Version;
 use crate::util::text::{decode_text, encode_text, TextEncoding};
 
 use std::hash::{Hash, Hasher};