lofty 0.11.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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use super::atom_info::{AtomIdent, AtomInfo};
use super::ilst::read::parse_ilst;
use super::ilst::Ilst;
use super::read::{meta_is_full, nested_atom, skip_unneeded, AtomReader};
use crate::error::Result;
use crate::macros::decode_err;

use std::io::{Read, Seek};

pub(crate) struct Moov {
	// Represents the trak.mdia atom
	pub(crate) traks: Vec<AtomInfo>,
	// Represents a parsed moov.udta.meta.ilst
	pub(crate) meta: Option<Ilst>,
}

impl Moov {
	pub(super) fn find<R>(reader: &mut AtomReader<R>) -> Result<AtomInfo>
	where
		R: Read + Seek,
	{
		let mut moov = None;

		while let Ok(atom) = reader.next() {
			if atom.ident == AtomIdent::Fourcc(*b"moov") {
				moov = Some(atom);
				break;
			}

			skip_unneeded(reader, atom.extended, atom.len)?;
		}

		moov.ok_or_else(|| decode_err!(MP4, "No \"moov\" atom found"))
	}

	pub(super) fn parse<R>(reader: &mut AtomReader<R>, read_properties: bool) -> Result<Self>
	where
		R: Read + Seek,
	{
		let mut traks = Vec::new();
		let mut meta = None;

		while let Ok(atom) = reader.next() {
			if let AtomIdent::Fourcc(fourcc) = atom.ident {
				match &fourcc {
					b"trak" if read_properties => {
						// All we need from here is trak.mdia
						if let Some(mdia) = nested_atom(reader, atom.len, b"mdia")? {
							traks.push(mdia);
						}
					},
					b"udta" => {
						meta = meta_from_udta(reader, atom.len - 8)?;
					},
					_ => skip_unneeded(reader, atom.extended, atom.len)?,
				}

				continue;
			}

			skip_unneeded(reader, atom.extended, atom.len)?
		}

		Ok(Self { traks, meta })
	}
}

fn meta_from_udta<R>(reader: &mut AtomReader<R>, len: u64) -> Result<Option<Ilst>>
where
	R: Read + Seek,
{
	let mut read = 8;
	let mut meta = (false, 0_u64);

	while read < len {
		let atom = reader.next()?;

		if atom.ident == AtomIdent::Fourcc(*b"meta") {
			meta = (true, atom.len);
			break;
		}

		read += atom.len;
		skip_unneeded(reader, atom.extended, atom.len)?;
	}

	if !meta.0 {
		return Ok(None);
	}

	// It's possible for the `meta` atom to be non-full,
	// so we have to check for that case
	let full_meta_atom = meta_is_full(reader)?;

	if full_meta_atom {
		read = 12;
	} else {
		read = 8;
	}

	let mut islt = (false, 0_u64);

	while read < meta.1 {
		let atom = reader.next()?;

		if atom.ident == AtomIdent::Fourcc(*b"ilst") {
			islt = (true, atom.len);
			break;
		}

		read += atom.len;
		skip_unneeded(reader, atom.extended, atom.len)?;
	}

	if islt.0 {
		return parse_ilst(reader, islt.1 - 8).map(Some);
	}

	Ok(None)
}