Skip to main content

qualia_core_db/q42/emf_container/extension/
codec.rs

1//! Exact-byte extension integrity, checked extents and borrowed PCM access.
2use 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/// Metadata is bounded owned cold state; sample payloads remain borrowed original bytes.
31#[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    // Check the common rational endpoint without converting a timestamp to float.
135    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    // All variable strings/track counts were bounded before this cold serialization.
210    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
239/// Complete-reader wrapper around the same canonical range directory checks.
240pub(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}