lofty 0.12.0

Audio metadata library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

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::{FrameValue, ID3v2Version};
use crate::macros::try_vec;

use std::io::Read;

use byteorder::{BigEndian, ReadBytesExt};

impl<'a> Frame<'a> {
	pub(crate) fn read<R>(reader: &mut R, version: ID3v2Version) -> Result<(Option<Self>, bool)>
	where
		R: Read,
	{
		// The header will be upgraded to ID3v2.4 past this point, so they can all be treated the same
		let (id, size, mut flags) = match match version {
			ID3v2Version::V2 => parse_v2_header(reader)?,
			ID3v2Version::V3 => parse_header(reader, false)?,
			ID3v2Version::V4 => parse_header(reader, true)?,
		} {
			None => return Ok((None, true)),
			Some(frame_header) => frame_header,
		};

		let mut content = try_vec![0; size as usize];
		reader.read_exact(&mut content)?;

		if flags.unsynchronisation {
			content = crate::id3::v2::util::unsynch_content(content.as_slice())?;
		}

		#[cfg(feature = "id3v2_compression_support")]
		if flags.compression {
			let mut decompressed = Vec::new();
			flate2::Decompress::new(true)
				.decompress_vec(&content, &mut decompressed, flate2::FlushDecompress::None)
				.map_err(|_| {
					ID3v2Error::new(ID3v2ErrorKind::Other(
						"Encountered a compressed frame, failed to decompress",
					))
				})?;

			content = decompressed
		}

		#[cfg(not(feature = "id3v2_compression_support"))]
		if flags.compression {
			crate::macros::decode_err!(@BAIL ID3v2, "Encountered a compressed ID3v2 frame, support is disabled")
		}

		let mut content_reader = &*content;

		// Get the encryption method symbol
		if let Some(enc) = flags.encryption.as_mut() {
			*enc = content_reader.read_u8()?;
		}

		// Get the group identifier
		if let Some(group) = flags.grouping_identity.as_mut() {
			*group = content_reader.read_u8()?;
		}

		// Get the real data length
		if let Some(len) = flags.data_length_indicator.as_mut() {
			*len = content_reader.read_u32::<BigEndian>()?;
		}

		let value = if flags.encryption.is_some() {
			if flags.data_length_indicator.is_none() {
				return Err(ID3v2Error::new(ID3v2ErrorKind::Other(
					"Encountered an encrypted frame without a data length indicator",
				))
				.into());
			}

			Some(FrameValue::Binary(content))
		} else {
			parse_content(&mut content_reader, id.as_str(), version)?
		};

		match value {
			Some(value) => Ok((Some(Self { id, value, flags }), false)),
			None => Ok((None, false)),
		}
	}
}