qualia_core_db/q42/emf_container/extension/
codec.rs1use super::super::header::EmfError;
3use super::model::*;
4use crate::container_10d::crc32c::crc32c;
5use crate::q42::chunk_integrity::{blake3_trailer, BLAKE3_TRAILER_BYTES};
6use std::collections::BTreeSet;
7
8pub const EXTENSION_FOOTER_BYTES: usize = 64;
9pub const EXTENSION_FOOTER_MAGIC: [u8; 8] = *b"Q42EMFX3";
10
11pub(super) fn align64(value: usize) -> Result<usize, EmfError> {
12 value
13 .checked_add(63)
14 .map(|v| v & !63)
15 .ok_or(EmfError::ArithmeticOverflow)
16}
17pub(super) fn add(a: usize, b: usize) -> Result<usize, EmfError> {
18 a.checked_add(b).ok_or(EmfError::ArithmeticOverflow)
19}
20pub(super) fn count(value: u64) -> Result<usize, EmfError> {
21 usize::try_from(value).map_err(|_| EmfError::ArithmeticOverflow)
22}
23pub(super) fn u64_at(bytes: &[u8], at: usize) -> u64 {
24 u64::from_le_bytes(bytes[at..at + 8].try_into().unwrap_or([0; 8]))
25}
26pub(super) fn u32_at(bytes: &[u8], at: usize) -> u32 {
27 u32::from_le_bytes(bytes[at..at + 4].try_into().unwrap_or([0; 4]))
28}
29
30#[derive(Clone, Debug)]
32pub struct EmfExtensionView<'a> {
33 pub(super) metadata: EmfExtensionMetadata,
34 pub(super) pcm: &'a [u8],
35 pub(crate) field_end: usize,
36}
37impl<'a> EmfExtensionView<'a> {
38 pub fn metadata(&self) -> &EmfExtensionMetadata {
39 &self.metadata
40 }
41 pub fn audio_payload(&self, track: usize) -> Option<&'a [u8]> {
42 let descriptor = self.metadata.audio_tracks.get(track)?;
43 let start = usize::try_from(descriptor.pcm_offset).ok()?;
44 let length = usize::try_from(descriptor.pcm_bytes).ok()?;
45 self.pcm.get(start..start.checked_add(length)?)
46 }
47 pub fn audio_sample(&self, track: usize, frame: u64, channel: u16) -> Option<f32> {
48 let descriptor = self.metadata.audio_tracks.get(track)?;
49 if frame >= descriptor.frames || channel >= descriptor.spec.channels {
50 return None;
51 }
52 let sample = frame
53 .checked_mul(u64::from(descriptor.spec.channels))?
54 .checked_add(u64::from(channel))?;
55 let offset = usize::try_from(sample).ok()?.checked_mul(4)?;
56 let bytes = self
57 .audio_payload(track)?
58 .get(offset..offset.checked_add(4)?)?;
59 Some(f32::from_le_bytes(bytes.try_into().ok()?))
60 }
61}
62
63pub(crate) struct PreparedExtension {
64 pub metadata: EmfExtensionMetadata,
65 json: Vec<u8>,
66 json_aligned: usize,
67 pcm_bytes: usize,
68 limits: EmfExtensionLimits,
69}
70impl PreparedExtension {
71 pub fn required_file_bytes(&self, field_end: usize) -> Result<usize, EmfError> {
72 let bytes = add(
73 add(add(field_end, self.json_aligned)?, self.pcm_bytes)?,
74 BLAKE3_TRAILER_BYTES + EXTENSION_FOOTER_BYTES,
75 )?;
76 if bytes > self.limits.max_file_bytes {
77 return Err(EmfError::ExtensionLimits);
78 }
79 Ok(bytes)
80 }
81 pub fn write_into(
82 &self,
83 tracks: &[EmfAudioTrack<'_>],
84 out: &mut [u8],
85 field_end: usize,
86 ) -> Result<usize, EmfError> {
87 let required = self.required_file_bytes(field_end)?;
88 if field_end % 64 != 0
89 || out.len() < required
90 || tracks.len() != self.metadata.audio_tracks.len()
91 {
92 return Err(EmfError::ExtensionMetadata);
93 }
94 let payload_end = required - BLAKE3_TRAILER_BYTES - EXTENSION_FOOTER_BYTES;
95 out[field_end..required].fill(0);
96 out[field_end..field_end + self.json.len()].copy_from_slice(&self.json);
97 let pcm_start = field_end + self.json_aligned;
98 for (index, track) in tracks.iter().enumerate() {
99 let descriptor = &self.metadata.audio_tracks[index];
100 if track.samples.len().checked_mul(4) != Some(count(descriptor.pcm_bytes)?) {
101 return Err(EmfError::AudioTrack { track_index: index });
102 }
103 let start = add(pcm_start, count(descriptor.pcm_offset)?)?;
104 for (sample, bytes) in track
105 .samples
106 .iter()
107 .zip(out[start..start + count(descriptor.pcm_bytes)?].chunks_exact_mut(4))
108 {
109 bytes.copy_from_slice(&sample.to_le_bytes());
110 }
111 }
112 let trailer = blake3_trailer(&out[field_end..payload_end]);
113 out[payload_end..payload_end + BLAKE3_TRAILER_BYTES].copy_from_slice(&trailer);
114 let mut footer = [0u8; 64];
115 footer[..8].copy_from_slice(&EXTENSION_FOOTER_MAGIC);
116 footer[8..16].copy_from_slice(&(field_end as u64).to_le_bytes());
117 footer[16..24].copy_from_slice(&(self.json.len() as u64).to_le_bytes());
118 footer[24..32].copy_from_slice(&(self.pcm_bytes as u64).to_le_bytes());
119 footer[32..40].copy_from_slice(&((payload_end - field_end) as u64).to_le_bytes());
120 footer[40..44].copy_from_slice(&(tracks.len() as u32).to_le_bytes());
121 footer[44..48].copy_from_slice(&u32::from(EMF_EXTENSION_SCHEMA_VERSION).to_le_bytes());
122 let crc = crc32c(&footer[..60]);
123 footer[60..].copy_from_slice(&crc.to_le_bytes());
124 out[required - 64..required].copy_from_slice(&footer);
125 Ok(required)
126 }
127}
128
129pub(super) fn checked_audio_timing(
130 spec: &EmfAudioTrackSpec,
131 frames: u64,
132 time: &EmfTimebase,
133) -> Result<(), EmfError> {
134 let rate = i128::from(spec.sample_rate_num);
136 let den = i128::from(time.ticks_per_second_den);
137 let start = i128::from(spec.start_tick)
138 .checked_mul(rate)
139 .and_then(|v| v.checked_mul(den))
140 .ok_or(EmfError::ArithmeticOverflow)?;
141 let duration = i128::from(frames)
142 .checked_mul(i128::from(spec.sample_rate_den))
143 .and_then(|v| v.checked_mul(i128::from(time.ticks_per_second_num)))
144 .ok_or(EmfError::ArithmeticOverflow)?;
145 start
146 .checked_add(duration)
147 .ok_or(EmfError::ArithmeticOverflow)?;
148 rate.checked_mul(i128::from(time.ticks_per_second_num))
149 .ok_or(EmfError::ArithmeticOverflow)?;
150 Ok(())
151}
152
153pub(crate) fn prepare_extension(
154 field: &EmfFieldInterpretation,
155 tracks: &[EmfAudioTrack<'_>],
156 limits: EmfExtensionLimits,
157) -> Result<PreparedExtension, EmfError> {
158 field.validate()?;
159 if tracks.len() > limits.max_tracks || tracks.len() > 16 {
160 return Err(EmfError::ExtensionLimits);
161 }
162 let mut descriptors = Vec::with_capacity(tracks.len());
163 let mut ids = BTreeSet::new();
164 let mut pcm_bytes = 0usize;
165 for (index, track) in tracks.iter().enumerate() {
166 track.spec.validate(index)?;
167 if !ids.insert(track.spec.id.as_str())
168 || track.samples.is_empty()
169 || track.samples.len() % track.spec.channels as usize != 0
170 {
171 return Err(EmfError::AudioTrack { track_index: index });
172 }
173 let length = track
174 .samples
175 .len()
176 .checked_mul(4)
177 .ok_or(EmfError::ArithmeticOverflow)?;
178 let start = pcm_bytes;
179 pcm_bytes = align64(add(start, length)?)?;
180 if pcm_bytes > limits.max_audio_bytes {
181 return Err(EmfError::ExtensionLimits);
182 }
183 let frames = (track.samples.len() / track.spec.channels as usize) as u64;
184 checked_audio_timing(&track.spec, frames, &field.timebase)?;
185 let mut hash = blake3::Hasher::new();
186 for sample in track.samples {
187 if !sample.is_finite()
188 || (matches!(track.spec.units, EmfSignalUnits::NormalizedAmplitude)
189 && sample.abs() > 1.0)
190 {
191 return Err(EmfError::AudioTrack { track_index: index });
192 }
193 hash.update(&sample.to_le_bytes());
194 }
195 descriptors.push(EmfAudioTrackDescriptor {
196 codec: EmfAudioCodec::PcmF32Le,
197 spec: track.spec.clone(),
198 frames,
199 pcm_offset: start as u64,
200 pcm_bytes: length as u64,
201 blake3: *hash.finalize().as_bytes(),
202 });
203 }
204 let metadata = EmfExtensionMetadata {
205 schema_version: EMF_EXTENSION_SCHEMA_VERSION,
206 field: field.clone(),
207 audio_tracks: descriptors,
208 };
209 let json = serde_json::to_vec(&metadata).map_err(|_| EmfError::ExtensionMetadata)?;
211 if json.len() > limits.max_metadata_bytes {
212 return Err(EmfError::ExtensionLimits);
213 }
214 Ok(PreparedExtension {
215 metadata,
216 json_aligned: align64(json.len())?,
217 json,
218 pcm_bytes,
219 limits,
220 })
221}
222
223pub(crate) fn parse_extension(
224 bytes: &[u8],
225 limits: EmfExtensionLimits,
226) -> Result<EmfExtensionView<'_>, EmfError> {
227 if bytes.len() > limits.max_file_bytes {
228 return Err(EmfError::ExtensionLimits);
229 }
230 if bytes.len() < 64 + BLAKE3_TRAILER_BYTES + EXTENSION_FOOTER_BYTES {
231 return Err(EmfError::ExtensionMetadata);
232 }
233 let footer = &bytes[bytes.len() - EXTENSION_FOOTER_BYTES..];
234 let field_end = count(u64_at(footer, 8))?;
235 let tail = bytes.get(field_end..).ok_or(EmfError::ExtensionMetadata)?;
236 super::range::parse_extension_tail(tail, field_end, bytes.len(), limits)
237}
238
239pub(crate) fn validate_field_directory(
241 header: &super::super::header::EmfContainerHeader,
242 directory: usize,
243 chunks: usize,
244 bytes: &[u8],
245 extension: &EmfExtensionView<'_>,
246) -> Result<(), EmfError> {
247 if count(header.directory_offset)? != directory || header.chunk_count as usize != chunks {
248 return Err(EmfError::DirectoryBounds);
249 }
250 let length = chunks
251 .checked_mul(super::super::chunk_directory::CHUNK_DIRECTORY_ENTRY_BYTES)
252 .ok_or(EmfError::ArithmeticOverflow)?;
253 let rows = bytes
254 .get(directory..add(directory, length)?)
255 .ok_or(EmfError::DirectoryBounds)?;
256 super::range::validate_directory_bytes(header, rows, extension)
257}